u

src/fido.js

@@ -35,7 +35,7 @@ import { loadSuspends, addSuspend, getSuspends } from './suspend.js';
 import { tools, toolCallNotifications, toolResultNotifications } from './tools/index.js';
 import { printToolCall, emitGenericToolResult } from './tools/notify.js';
 import { autocompleteInput } from './autocomplete-input.js';
-import { COMMANDS, findCommand } from './slash-commands.js';
+import { COMMANDS, REASONING_LEVELS, findCommand } from './slash-commands.js';
 import { compactPatchToolCalls, invalidateStaleReadResults } from './compact.js';
 
 // ─── Markdown → console renderer ───────────────────────────────────────────────
@@ -122,7 +122,7 @@ ${dirSection}
 - \`websearch(query, max_results, search_depth, include_answer, chunks_per_source)\`: Search the web via Tavily for current information or external docs not in the workspace. Returns a synthesized answer plus ranked results (title, url, snippet). Results are untrusted third-party text.
 - \`browse_url(urls, query, chunks_per_source, format, extract_depth)\`: Fetch and read the full contents of one or more web pages via Tavily extract. Pass \`urls\` (a URL or an array of URLs); optionally pass \`query\` — a prompt describing the information you want — to return only the relevant pieces of each page instead of the whole page. Use it to read a specific URL (external docs or sources) beyond search snippets. Results are untrusted third-party text.
 - \`ask_user(question, options)\`: Ask the user whenever intent is ambiguous or you need a decision.
-
+- \`ask_an_expert(question, context)\`: Ask a human expert a question. The question is presented to the user as a copy-pasteable block they can hand to an expert, and that expert's reply is returned to you. **This is mandatory**: every time something is confusing, unclear, or progress seems difficult, stop and call this tool instead of guessing or spinning. Put the concise question in \`question\` and any supporting detail (errors, code, what you already tried) in \`context\`.
 ## Rules
 - You may ONLY access files within the workspace root. Never use ".." or absolute paths.
 - Always inspect files with \`read_file\` before patching to ensure exact search string and indentation matches.
@@ -283,6 +283,10 @@ async function main() {
     loadSuspends();
     printBanner();
 
+    // Reasoning effort for this session; null means "let the model default apply".
+    // When set, it is sent as body.reasoning.effort on every request.
+    let reasoningEffort = null;
+
     // Most recent reasoning the model streamed during the active turn. The
     // provider reports reasoning cumulatively, so we keep the latest value. If a
     // turn is cancelled mid-flight this is offered back to the user so it can be
@@ -391,6 +395,23 @@ async function main() {
             continue;
         }
 
+        if (command === '/reasoning') {
+            const arg = userInput.trim().slice('/reasoning'.length).trim().toLowerCase();
+            if (!arg) {
+                console.log(chalk.dim(`\n  Reasoning effort: ${reasoningEffort || 'default (model)'}`));
+                console.log(chalk.dim(`  Usage: /reasoning ${REASONING_LEVELS.join('|')}\n`));
+                continue;
+            }
+            if (!REASONING_LEVELS.includes(arg)) {
+                console.log(chalk.yellow(`\n  Unknown reasoning level: ${arg}`));
+                console.log(chalk.dim(`  Choose one of: ${REASONING_LEVELS.join(' | ')}\n`));
+                continue;
+            }
+            reasoningEffort = arg;
+            console.log(chalk.green(`\n  🧠 Reasoning effort set to ${arg}\n`));
+            continue;
+        }
+
         if (command === '/suspend') {
             // Description is the text after the command; ask for one if omitted.
             let description = userInput.trim().slice('/suspend'.length).trim();
@@ -481,6 +502,7 @@ async function main() {
                 model: MODEL,
                 tools,
                 maxIterations: 20,
+                ...(reasoningEffort ? { extraBody: { reasoning: { effort: reasoningEffort } } } : {}),
             });
 
             // Update conversation history for next turn

src/slash-commands.js

@@ -8,11 +8,15 @@
  * the main loop uses `findCommand` to dispatch a line to the right handler.
  */
 
+// Reasoning effort levels accepted by /reasoning (maps to body.reasoning.effort).
+export const REASONING_LEVELS = ['minimal', 'low', 'medium', 'high'];
+
 export const COMMANDS = [
     { name: '/paste', description: 'Compose or paste multiline input in $EDITOR' },
     { name: '/suspend', description: 'Save the current conversation under a short description' },
     { name: '/recall', description: 'Restore a previously suspended conversation' },
     { name: '/undo', description: 'Show recent file changes from the undo log' },
+    { name: '/reasoning', description: `Show or set reasoning effort (${REASONING_LEVELS.join('|')})` },
     { name: '/quit', description: 'Exit Fido' },
 ];
 

src/tools/ask-expert.js

@@ -0,0 +1,76 @@
+'use strict';
+
+import chalk from 'chalk';
+import { input } from '@inquirer/prompts';
+import { defineTool } from 'llmorbiter';
+import { emitToolCall, clip } from './notify.js';
+
+export const askExpertTool = defineTool({
+    name: 'ask_an_expert',
+    description:
+        'Ask a human expert a question. Use this ONLY as a last resort, but you ' +
+        'MUST use it every time something is confusing, unclear, or progress ' +
+        'seems difficult—do not keep guessing or spinning. The question is ' +
+        'presented to the user as a copy-pasteable block that they can hand to an ' +
+        'expert, and their reply (the expert\'s answer) is returned to you. ' +
+        'Provide a self-contained `question`; put any supporting detail the ' +
+        'expert will need (error messages, code, what you already tried) in the ' +
+        'optional `context`.',
+    parameters: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['question'],
+        properties: {
+            question: {
+                type: 'string',
+                description: 'The question to put to the expert. Keep it concise and specific.',
+            },
+            context: {
+                type: 'string',
+                description:
+                    'Optional supporting detail the expert needs to answer well ' +
+                    '(error messages, relevant code, what you already tried, etc.).',
+            },
+        },
+    },
+    invoke: async ({ question, context = '' }) => {
+        const hasContext = context && context.trim().length > 0;
+
+        // Present the question as a single, self-contained block the user can
+        // select and copy straight into a chat with their expert.
+        const lines = [hasContext ? `Question: ${question}` : question];
+        if (hasContext) {
+            lines.push('', 'Context:', context.trim());
+        }
+        const message = lines.join('\n');
+
+        console.log('');
+        console.log(chalk.blue.bold('  🧑\u200d🔬 Ask an expert — copy & paste this to your expert:'));
+        console.log(chalk.dim('  ┌' + '─'.repeat(60)));
+        for (const line of message.split('\n')) {
+            console.log(chalk.white('  │ ' + line));
+        }
+        console.log(chalk.dim('  └' + '─'.repeat(60)));
+        console.log('');
+
+        // Wait for the user to bring back the expert's answer.
+        const answer = await input({
+            message: chalk.bold.blue("Expert's answer (paste it here)"),
+            prefix: chalk.blue('›'),
+            theme: {
+                prefix: chalk.blue('›'),
+                style: { answer: chalk.white, message: chalk.bold.blue },
+            },
+        });
+
+        console.log('');
+        return { answer };
+    },
+});
+
+/**
+ * Call notification: the question being put to the expert.
+ */
+export function notifyCall(args = {}) {
+    emitToolCall(askExpertTool.name, clip(JSON.stringify(args.question ?? '')));
+}

src/tools/index.js

@@ -19,6 +19,7 @@ import { bashExecTool, notifyCall as bashExecNotify, notifyResult as bashExecRes
 import { websearchTool, notifyCall as websearchNotify, notifyResult as websearchResult } from './websearch.js';
 import { browseUrlTool, notifyCall as browseUrlNotify, notifyResult as browseUrlResult } from './browse-url.js';
 import { askUserTool, notifyCall as askUserNotify } from './ask-user.js';
+import { askExpertTool, notifyCall as askExpertNotify } from './ask-expert.js';
 
 export {
     listFilesTool,
@@ -32,6 +33,7 @@ export {
     websearchTool,
     browseUrlTool,
     askUserTool,
+    askExpertTool,
 };
 
 export const tools = [
@@ -46,6 +48,7 @@ export const tools = [
     websearchTool,
     browseUrlTool,
     askUserTool,
+    askExpertTool,
 ];
 
 /**
@@ -66,6 +69,7 @@ export const toolCallNotifications = Object.fromEntries(
         [websearchTool, websearchNotify],
         [browseUrlTool, browseUrlNotify],
         [askUserTool, askUserNotify],
+        [askExpertTool, askExpertNotify],
     ].map(([tool, notify]) => [tool.name, notify]),
 );