agent.libx.js 0.92.7 → 0.92.8

package/cli/cli.ts

@@ -983,9 +983,24 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
   let duplexPersist: () => void = () => {}; // bound once the session exists (re-voice fires async)
   let duplexAccount: (data: any) => void = () => {}; // worker cost → session meta (bound below)
   // Workers are non-interactive: a permission 'ask' can't pop a menu mid-conversation (it would fight
-  // the line editor for raw stdin). Auto-deny with a narratable reason — the worker adapts or reports
-  // back and the voice narrates it. Allow/deny rules (config, --allowedTools, --yes) apply as-is.
+  // the line editor for raw stdin). VOICE mode relays the ask through the conversation (park →
+  // '[task asks]' re-voice → spoken yes/no via AnswerTask; timeout → deny). Text duplex (and the
+  // relay's timeout path) auto-denies with a narratable reason — the worker adapts or reports back.
+  let permSeq = 0;
   const duplexAsk = async (call: ToolUse): Promise<{ decision: 'allow' | 'deny' }> => {
+    if (args.voice && dx) {
+      const hint = summarizeCall(call.name, call.args).slice(0, 80);
+      // NB: perm asks are keyed perm-N (PermissionPolicy.ask carries no task identity), so a
+      // cancelled task can't clean its parked perm question — bounded by askTimeoutMs → deny.
+      const id = `perm-${++permSeq}`;
+      err('\r\x1b[0J' + yellow(`  ? worker asks to run ${call.name}`) + dim(` ${hint} — say yes/no (or it auto-denies)\n`));
+      editorRef?.redrawNow();
+      const a = await dx.parkQuestion(id, `Permission: may the background worker run ${call.name}${hint ? ` (${hint})` : ''}? Yes or no.`);
+      const allow = /^\s*(y(es|ep|eah)?|sure|ok(ay)?|allow|go|approved?|do it)\b/i.test(a);
+      err('\r\x1b[0J' + dim(`  ${allow ? '✓ allowed' : '⊘ denied'} ${call.name} (${a.trim() || 'no answer'})\n`));
+      editorRef?.redrawNow();
+      return { decision: allow ? 'allow' : 'deny' };
+    }
     err('\r\x1b[0J' + yellow(`  ⊘ worker asked to run ${call.name} — auto-denied (no interactive approval in duplex; use --yes or --allowedTools)\n`));
     editorRef?.redrawNow(); // background event at a live prompt — repaint below the notice
     return { decision: 'deny' };
@@ -1073,7 +1088,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
       workerModel: agent.options.model,
       workerOptions,
       host,
-      ...(args.voice ? { voiceStyle: 'conversational' as const, progressUpdates: true } : {}), // voice: narrate throttled worker progress (dead air is worse than a short aside)
+      ...(args.voice ? { voiceStyle: 'conversational' as const, progressUpdates: true, askRelay: true } : {}), // voice: progress asides + worker questions relayed through the conversation
       // Per-TASK checkpoint frames (the natural undo unit in duplex = one delegation): opened BEFORE
       // the worker spawns (post-spawn would race its first edits). `checkpoints` is bound below.
       onTaskStart: async (_id, label) => { await checkpoints.begin(label); },

package/dist/cli.js

@@ -3445,11 +3445,17 @@ var DuplexAgentOptions = class {
   progressUpdates = false;
   /** Min ms between progress re-voices per task. */
   progressIntervalMs = 25e3;
+  /** Relay worker questions (AskUserQuestion + permission asks via parkQuestion) through the VOICE:
+   *  the question re-voices as '[task <id> asks] …', the user answers conversationally, and the
+   *  voice model resolves it with the AnswerTask tool. Off → host.ask passthrough (text menus). */
+  askRelay = false;
+  /** Parked questions auto-resolve empty after this long (callers map '' to deny/best-judgment). */
+  askTimeoutMs = 12e4;
   /** Host overrides for QuickLook lookups (keyed by `what`). The engine's defaults go through the
    *  (possibly jailed) fs — e.g. `.git/**` is deny-listed, so the CLI supplies 'branch' itself. */
   quickLook;
 };
-var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou work in a pair: you talk, and a background worker with FULL access to the user\'s environment (files, shell, web) does the hands-on work. You can find out or do ANYTHING by calling `Delegate` with a clear, self-contained brief \u2014 so NEVER tell the user you can\'t see, access, or do something. Delegate and find out. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), delegate IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nAfter calling Delegate, tell the user you are on it in one short sentence, then end your turn. Do not wait for the result.\nResults arrive later as events like "[task t1 completed] \u2026" or "[task t1 failed] \u2026". When one arrives, summarize it for the ear in one or two short sentences. "[task t1 progress] \u2026" events are interim status, NOT results \u2014 give at most a half-sentence aside ("still on it \u2014 running tests now") and end your turn. Never present progress as a finished result.\nNever read raw file paths, diffs, or code aloud verbatim.\nDo not fire a second Delegate for work already in flight \u2014 check `TaskStatus` first. Use `CancelTask` when the user asks to stop something.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not delegate, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file \u2014 use `QuickLook` (instant, no task). Anything requiring searching, reasoning, running commands, or editing still goes through `Delegate`.\nNEVER claim to have stored, saved, or remembered something durably \u2014 you cannot. Anything the user wants persisted (their name, preferences, notes) must be Delegated so a worker writes it to memory.\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled or surprising, briefly confirm what they meant ("did you mean\u2026?") instead of answering the literal words.';
+var VOICE_SYSTEM_PROMPT = 'You are a spoken voice assistant \u2014 the user HEARS everything you say. Use short sentences. One idea per sentence. No markdown, no bullet lists, no code blocks, no headings, no emoji.\nKeep turns SHORT \u2014 one to three sentences, then stop. Never lecture, enumerate cases, or add caveats unprompted. Conversation is a fast exchange: give the one thing asked, and let the user pull more if they want it.\nYou work in a pair: you talk, and a background worker with FULL access to the user\'s environment (files, shell, web) does the hands-on work. You can find out or do ANYTHING by calling `Delegate` with a clear, self-contained brief \u2014 so NEVER tell the user you can\'t see, access, or do something. Delegate and find out. When the user mentions their project, folder, files, or environment ("this project", "the current folder", "my code"), delegate IMMEDIATELY \u2014 do not ask for paths or details the worker can discover itself. Never pretend to have done the work or invent results \u2014 the worker\'s report is your only source.\nAfter calling Delegate, tell the user you are on it in one short sentence, then end your turn. Do not wait for the result.\nResults arrive later as events like "[task t1 completed] \u2026" or "[task t1 failed] \u2026". When one arrives, summarize it for the ear in one or two short sentences. "[task t1 progress] \u2026" events are interim status, NOT results \u2014 give at most a half-sentence aside ("still on it \u2014 running tests now") and end your turn. Never present progress as a finished result.\nNever read raw file paths, diffs, or code aloud verbatim.\n"[task t1 asks] \u2026" events are QUESTIONS from a background task \u2014 relay to the user in your own words, short, then end your turn. When the user answers, call `AnswerTask` with that id and their answer. NEVER answer on the user\'s behalf for permissions or risky operations; if their reply is ambiguous, confirm first.\nDo not fire a second Delegate for work already in flight \u2014 check `TaskStatus` first. Use `CancelTask` when the user asks to stop something.\nPRIORITY: when the user says goodbye or wants to end/finish/wrap up the session ("ok bye", "that\'s all", "let\'s finish", "let\'s end", "goodnight", "exit", "wrap up"), call `ExitSession` IMMEDIATELY \u2014 do not delegate, do not check status, just exit.\nFor TRIVIAL instant lookups only \u2014 current time, git branch, listing a folder, peeking at a small file \u2014 use `QuickLook` (instant, no task). Anything requiring searching, reasoning, running commands, or editing still goes through `Delegate`.\nNEVER claim to have stored, saved, or remembered something durably \u2014 you cannot. Anything the user wants persisted (their name, preferences, notes) must be Delegated so a worker writes it to memory.\nUser messages may arrive via speech-to-text and can carry transcription artifacts \u2014 odd words, cut-offs, homophones ("for you" vs "folder"). Read for INTENT, not surface text. If a message seems garbled or surprising, briefly confirm what they meant ("did you mean\u2026?") instead of answering the literal words.';
 var VOICE_STYLE_CONVERSATIONAL = `Speak like a person in a live conversation, not an assistant reading a script. React first, then deliver: a quick impulsive beat ("oh nice", "hmm, hold on", "ah, got it") before the substance. Use contractions always. Vary sentence length \u2014 some very short. Light fillers and backchannels are fine ("mm-hm", "right", "let's see") but at most one per reply \u2014 never stack them. When you delegate, say it like a human would ("hang on, let me actually dig into that \u2014 gimme a minute") instead of announcing a task. When a result comes back, react to it like you just found out ("okay so \u2014 turns out\u2026"). Match the user's energy: a quick question gets a quick answer \u2014 a few words is a perfectly good turn. Prefer a short answer plus an offer ("want the details?") over covering everything. Never narrate your own mechanics (no "I will now delegate", no task ids out loud).`;
 var DuplexAgent = class {
   options;
@@ -3459,6 +3465,8 @@ var DuplexAgent = class {
   seq = 0;
   pendingEvents = [];
   flushQueued = false;
+  /** Parked worker questions awaiting a (voice-relayed) user answer, keyed by ask id. */
+  pendingAsks = /* @__PURE__ */ new Map();
   constructor(options) {
     this.options = { ...new DuplexAgentOptions(), ...options };
     const o = this.options;
@@ -3481,7 +3489,7 @@ Today's date: ${(/* @__PURE__ */ new Date()).toDateString()}.`,
       // no defaultTools() — the voice can only Delegate, never touch files itself. Set AFTER the
       // voiceOptions spread (addTools() would be clobbered by the first prepare()); extra voice
       // tools come in via voiceOptions.tools and are merged here.
-      tools: [...o.voiceOptions?.tools ?? [], this.delegateTool(), this.taskStatusTool(), this.cancelTaskTool(), this.quickLookTool()]
+      tools: [...o.voiceOptions?.tools ?? [], this.delegateTool(), this.taskStatusTool(), this.cancelTaskTool(), this.quickLookTool(), this.answerTaskTool()]
     });
   }
   /** One user turn: the voice agent streams the reply (and may Delegate). Serialized with re-voice turns. */
@@ -3552,7 +3560,12 @@ ${recent}` : brief;
         report.output(chunk);
       }
     } : base;
-    const workerHost = o.host?.ask ? { ask: (q2) => o.host.ask(q2) } : void 0;
+    const relayAsk = async (q2) => {
+      const opts = q2.options?.length ? ` Options: ${q2.options.map((x) => x.label).join(", ")}.` : "";
+      const a = await this.parkQuestion(id, `${q2.question}${opts}`);
+      return a || "(no answer from the user \u2014 use your best judgment and note the assumption)";
+    };
+    const workerHost = o.askRelay ? { ask: relayAsk } : o.host?.ask ? { ask: (q2) => o.host.ask(q2) } : void 0;
     const worker = new Agent({
       ai: o.ai,
       fs: o.fs,
@@ -3608,7 +3621,35 @@ ${recent}` : brief;
       }
     };
   }
+  /** Park a question under `askId` (a task id, or any unique key for permission asks): re-voices
+   *  '[task <id> asks] …' and resolves with the user's answer via AnswerTask — or '' on timeout/
+   *  task settle (callers map '' to deny / best-judgment). Workers never block forever. */
+  parkQuestion(askId, question) {
+    return new Promise((resolve4) => {
+      let settled = false;
+      const finish = (answer) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        this.pendingAsks.delete(askId);
+        resolve4(answer);
+      };
+      const timer = setTimeout(() => {
+        this.notify("task_ask_timeout", `task ${askId}: question timed out \u2014 proceeding without an answer`);
+        finish("");
+      }, this.options.askTimeoutMs);
+      this.pendingAsks.set(askId, { question, resolve: finish });
+      this.notify("task_ask", `task ${askId} asks: ${question}`, { id: askId, question });
+      this.queueRevoice(`[task ${askId} asks] ${question}
+(Relay this to the user in your own words. When they answer, call AnswerTask with id "${askId}" and their answer.)`);
+    });
+  }
+  /** Resolve any question a settling/cancelled task left parked (its answer can no longer matter). */
+  dropAsk(id) {
+    this.pendingAsks.get(id)?.resolve("");
+  }
   onWorkerSettled(id, res) {
+    this.dropAsk(id);
     const rec = this.tasks.get(id);
     if (res.finishReason === "aborted" || rec.status === "cancelled") {
       rec.status = "cancelled";
@@ -3628,6 +3669,7 @@ ${recent}` : brief;
     this.failTask(this.tasks.get(id), err2 instanceof Error ? err2.message : String(err2));
   }
   failTask(rec, msg) {
+    this.dropAsk(rec.id);
     rec.status = "error";
     log6.warn(`task ${rec.id} failed: ${msg}`);
     this.notify("task_error", `task ${rec.id} (${rec.label}) failed: ${msg}`);
@@ -3720,6 +3762,23 @@ ${recent}` : brief;
       }
     };
   }
+  answerTaskTool() {
+    return {
+      name: "AnswerTask",
+      description: `Relay the user's answer to a pending question from a background task (the "[task <id> asks]" events). Pass the id from the event and the user's answer.`,
+      parameters: {
+        type: "object",
+        required: ["id", "answer"],
+        properties: { id: { type: "string" }, answer: { type: "string", description: "the user's answer, verbatim or faithfully summarized" } }
+      },
+      run: async ({ id, answer }) => {
+        const ask = this.pendingAsks.get(String(id));
+        if (!ask) return `No pending question for '${id}' \u2014 it may have been answered already or timed out.`;
+        ask.resolve(String(answer ?? ""));
+        return `Answer relayed \u2014 task ${id} resumes.`;
+      }
+    };
+  }
   cancelTaskTool() {
     return {
       name: "CancelTask",
@@ -4074,9 +4133,10 @@ var VoiceEngine = class {
     if (rms < o.overlapRms) return;
     const t = now();
     if (!this.pausedAt) {
-      this.pausedAt = t;
-      this.overlapLoud = 1;
+      this.overlapLoud = t - this.overlapLastLoudAt <= 60 ? this.overlapLoud + 1 : 1;
       this.overlapLastLoudAt = t;
+      if (this.overlapLoud < 3) return;
+      this.pausedAt = t;
       this.player.pause();
       this.armResume();
       return;
@@ -7902,7 +7962,21 @@ async function repl(args, ai, cfg, cwd) {
   };
   let duplexAccount = () => {
   };
+  let permSeq = 0;
   const duplexAsk = async (call) => {
+    if (args.voice && dx) {
+      const hint = summarizeCall(call.name, call.args).slice(0, 80);
+      const id = `perm-${++permSeq}`;
+      err("\r\x1B[0J" + yellow(`  ? worker asks to run ${call.name}`) + dim(` ${hint} \u2014 say yes/no (or it auto-denies)
+`));
+      editorRef?.redrawNow();
+      const a = await dx.parkQuestion(id, `Permission: may the background worker run ${call.name}${hint ? ` (${hint})` : ""}? Yes or no.`);
+      const allow = /^\s*(y(es|ep|eah)?|sure|ok(ay)?|allow|go|approved?|do it)\b/i.test(a);
+      err("\r\x1B[0J" + dim(`  ${allow ? "\u2713 allowed" : "\u2298 denied"} ${call.name} (${a.trim() || "no answer"})
+`));
+      editorRef?.redrawNow();
+      return { decision: allow ? "allow" : "deny" };
+    }
     err("\r\x1B[0J" + yellow(`  \u2298 worker asked to run ${call.name} \u2014 auto-denied (no interactive approval in duplex; use --yes or --allowedTools)
 `));
     editorRef?.redrawNow();
@@ -7976,8 +8050,8 @@ async function repl(args, ai, cfg, cwd) {
       workerModel: agent.options.model,
       workerOptions,
       host,
-      ...args.voice ? { voiceStyle: "conversational", progressUpdates: true } : {},
-      // voice: narrate throttled worker progress (dead air is worse than a short aside)
+      ...args.voice ? { voiceStyle: "conversational", progressUpdates: true, askRelay: true } : {},
+      // voice: progress asides + worker questions relayed through the conversation
       // Per-TASK checkpoint frames (the natural undo unit in duplex = one delegation): opened BEFORE
       // the worker spawns (post-spawn would race its first edits). `checkpoints` is bound below.
       onTaskStart: async (_id, label) => {