agent.libx.js 0.92.9 → 0.93.2

package/cli/cli.ts

@@ -238,7 +238,7 @@ Project instructions: ./AGENTS.md or ./CLAUDE.md are auto-loaded (scaffold with
 Auto-loaded from ./.agent/: commands/, skills/, memory/, agents/.
 
 REPL shortcuts: !<cmd> runs a shell command inline · #<note> saves a memory · @path inlines a file
-REPL slash commands: /help /version /tools /permissions /status /cost /context /cwd /model /reasoning /config /rename /compact /rewind /undo /clear /sessions /resume /commands /skills /mcp /init /export /paste /exit
+REPL slash commands: /help /version /tools /permissions /status /cost /context /cwd /model /reasoning /config /rename /compact /rewind /undo /clear /sessions /resume /commands /skills /mcp /init /export /paste /goal /exit
 REPL completion: type / (commands+skills) or @ (files) for a LIVE menu — ↑/↓ select, ⏎/Tab accept, Esc dismiss.
 REPL multi-line: Option/Alt+Enter inserts a newline, or end a line with \\ to continue. Esc cancels a running turn / clears the input line; double-Esc jumps back to edit a previous message.
 REPL shortcuts: Shift+Tab cycles permission posture (ask → accept-edits → plan) · Alt+T toggles reasoning · Alt+P switches model · Ctrl+O toggles verbose tool output · → or Tab accepts the dim history ghost-suggestion · Alt+S/Ctrl+S stash/unstash.
@@ -504,6 +504,31 @@ function turnCost(model: string, usage?: { promptTokens?: number; completionToke
   return costOf(getModelInfo(model)?.pricing, usage?.promptTokens ?? 0, usage?.completionTokens ?? 0);
 }
 
+/** Evaluate whether a goal condition has been met, based on recent transcript. */
+async function evaluateGoal(ai: ChatLike, condition: string, transcript: Message[], log: (s: string) => void): Promise<{ met: boolean; reason: string }> {
+  const recent = transcript
+    .filter((m) => m.role === 'assistant')
+    .slice(-8)
+    .map((m) => {
+      const text = typeof m.content === 'string' ? m.content : (m.content as ContentPart[]).filter((p: any) => p.type === 'text').map((p: any) => p.text).join(' ');
+      return text.slice(0, 600);
+    })
+    .join('\n---\n');
+  try {
+    const r = await ai.chat({
+      model: 'anthropic/claude-haiku-4-5',
+      stream: false,
+      messages: [
+        { role: 'system', content: 'You judge whether a goal condition has been met based on conversation transcript. Respond ONLY with JSON: {"met": boolean, "reason": "one sentence"}. Be strict — only met:true if there is clear evidence in the transcript.' },
+        { role: 'user', content: `Goal condition: ${condition}\n\nRecent assistant messages:\n${recent}` },
+      ],
+    }) as { content: string };
+    const match = r.content.match(/\{[\s\S]*\}/);
+    if (match) return JSON.parse(match[0]);
+  } catch (e: any) { log(dim(`  (goal evaluator error: ${e?.message ?? e})\n`)); }
+  return { met: false, reason: 'evaluation unclear' };
+}
+
 /** Normalize a thrown/returned error into the persisted forensic shape. */
 function errInfo(e: any): { message: string; statusCode?: number; code?: string } {
   return { message: String(e?.message ?? e), statusCode: e?.statusCode, code: e?.code };
@@ -547,6 +572,11 @@ export async function runShellLine(fs: IFilesystem, cmd: string): Promise<string
   return out || '(no output)';
 }
 
+/** Resolve a memoryDir (string or string[]) to the primary (write) dir. */
+function primaryMemDir(dir: string | string[] | undefined, fallback: string): string {
+  return (Array.isArray(dir) ? dir[0] : dir) || fallback;
+}
+
 /** Append a `#note` to the memory index (creating the dir/file if needed). Returns the file path. */
 export async function appendMemoryNote(fs: IFilesystem, dir: string, text: string): Promise<string> {
   await mkdirp(fs, dir);
@@ -1092,6 +1122,8 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     dx = new DuplexAgent({
       ai,
       fs: agent.options.fs,
+      memoryDir: agent.options.memoryDir,
+      memoryUserDir: agent.options.memoryUserDir,
       ...((args.voiceModel ?? cfg.voiceModel) ? { voiceModel: resolveModelOrNewest((args.voiceModel ?? cfg.voiceModel)!) } : {}),
       workerModel: agent.options.model,
       workerOptions,
@@ -1109,14 +1141,14 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
             return head.startsWith('ref: refs/heads/') ? `branch: ${head.slice('ref: refs/heads/'.length)}` : `detached HEAD at ${head.slice(0, 12)}`;
           } catch { return 'not a git repository'; }
         },
-        // Memory READS are QuickLook material (instant, capped); memory WRITES stay delegated —
-        // a worker creates/updates the files under .agent/memory/.
         memory: async () => {
-          const dir = agent.options.memoryDir || adot('memory');
-          try {
-            const idx = await fs.readFile(`${dir}/MEMORY.md`);
-            return idx.slice(0, 2000) || '(memory index is empty)';
-          } catch { return 'no memory yet — to save something, Delegate it (a worker writes .agent/memory/)'; }
+          const _adot = (s: string) => `${(agent.options.fs!.getCwd() === '/' ? '' : agent.options.fs!.getCwd())}/.agent/${s}`;
+          const dirs = Array.isArray(agent.options.memoryDir) ? agent.options.memoryDir : [agent.options.memoryDir || _adot('memory')];
+          const parts: string[] = [];
+          for (const d of dirs) {
+            try { const idx = await fs.readFile(`${d}/MEMORY.md`); if (idx.trim()) parts.push(idx.trim()); } catch { /* dir doesn't exist yet */ }
+          }
+          return parts.length ? parts.join('\n').slice(0, 2000) : '(no memory yet)';
         },
       },
       // The voice runs on the REAL fs (it has no fs tools — harmless) so @mentions, !cmd and #note
@@ -1238,7 +1270,14 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     const s = Math.max(0, (Date.now() - t) / 1000);
     return s < 60 ? 'just now' : s < 3600 ? `${Math.floor(s / 60)}m ago` : s < 86400 ? `${Math.floor(s / 3600)}h ago` : `${Math.floor(s / 86400)}d ago`;
   };
-  const resumeInto = (data: SessionData) => { face.transcript = data.messages; session = data; checkpoints.use?.(data.meta.id); err(dim(`  resumed ${data.meta.id} (${data.meta.turns} turns)${data.meta.title ? ' — ' + data.meta.title : ''}\n`)); printHistory(data.messages); };
+  const resumeInto = (data: SessionData) => {
+    face.transcript = data.messages; session = data; checkpoints.use?.(data.meta.id);
+    const m = data.meta as any;
+    goalCondition = m.goalCondition; goalTurns = m.goalTurns ?? 0; goalTokens = m.goalTokens ?? 0; goalLastReason = m.goalLastReason;
+    err(dim(`  resumed ${data.meta.id} (${data.meta.turns} turns)${data.meta.title ? ' — ' + data.meta.title : ''}\n`));
+    if (goalCondition) err(dim(`  ◎ goal active: ${goalCondition} (${goalTurns} turns)\n`));
+    printHistory(data.messages);
+  };
   // Double-Esc rewind (CC parity): pick an earlier user message, then choose what to restore —
   // conversation, code, or both. Returns the message text to pre-fill the prompt (when the conversation
   // is rewound) for editing + resend, or undefined (cancelled, or code-only).
@@ -1365,6 +1404,41 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     return picked && !picked.startsWith('__') ? picked : null;
   };
 
+  let goalCondition: string | undefined = (session.meta as any).goalCondition;
+  let goalTurns: number = (session.meta as any).goalTurns ?? 0;
+  let goalTokens: number = (session.meta as any).goalTokens ?? 0;
+  let goalLastReason: string | undefined = (session.meta as any).goalLastReason;
+  const GOAL_MAX_TURNS = 50;
+  const persistGoal = () => {
+    const m = session.meta as any;
+    m.goalCondition = goalCondition; m.goalTurns = goalTurns; m.goalTokens = goalTokens; m.goalLastReason = goalLastReason;
+  };
+
+  // ---- /goal: autonomous loop with a halting condition ----
+  const goalLoop = async () => {
+    while (goalCondition && !aborting && !exitRequested && goalTurns < GOAL_MAX_TURNS) {
+      const result = await evaluateGoal(ai, goalCondition, face.transcript, err);
+      goalLastReason = result.reason;
+      if (result.met) {
+        err(green(`  ✓ goal met: ${result.reason}\n`));
+        goalCondition = undefined; goalLastReason = undefined;
+        persistGoal();
+        return;
+      }
+      err(dim(`  ◎ not yet (${result.reason}) — turn ${goalTurns + 1}\n`));
+      aborting = false;
+      const tokensBefore = session.meta.tokens ?? 0;
+      await turn(`Continue working toward the goal: ${goalCondition}`);
+      goalTokens += (session.meta.tokens ?? 0) - tokensBefore;
+      goalTurns++;
+      persistGoal();
+      if (exitRequested) return;
+    }
+    if (goalTurns >= GOAL_MAX_TURNS) {
+      err(yellow(`  ⚠ goal reached ${GOAL_MAX_TURNS} turns — pausing. /goal to check status, /goal clear to cancel\n`));
+    }
+  };
+
   // ---- slash builtins: name → handler. Returns true to exit the REPL. ----
   const builtins: Record<string, { desc: string; run: (a: string[]) => boolean | void | Promise<boolean | void> }> = {
     help: { desc: 'show this help', run: () => { err(HELP + '\n'); } },
@@ -1704,6 +1778,35 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
         } catch (e: any) { err(red(`  export failed: ${e?.message ?? e}\n`)); }
       },
     },
+    goal: {
+      desc: 'autonomous loop — /goal <condition> | /goal (status) | /goal clear',
+      run: async (a) => {
+        if (!a.length) {
+          if (!goalCondition) { err(dim('  no active goal\n')); return; }
+          const tokStr = goalTokens > 1000 ? `${(goalTokens / 1000).toFixed(1)}k` : String(goalTokens);
+          err(`  ${bold('◎ goal:')} ${goalCondition}\n` + dim(`  ${goalTurns} turn${goalTurns === 1 ? '' : 's'} · ${tokStr} tokens${goalLastReason ? ` · last: ${goalLastReason}` : ''}\n`));
+          return;
+        }
+        if (a[0] === 'clear') {
+          if (!goalCondition) { err(dim('  no active goal\n')); return; }
+          goalCondition = undefined; goalTurns = 0; goalTokens = 0; goalLastReason = undefined;
+          persistGoal();
+          err(green('  ✓ goal cleared\n'));
+          return;
+        }
+        goalCondition = a.join(' ');
+        goalTurns = 0; goalTokens = 0; goalLastReason = undefined;
+        persistGoal();
+        err(green(`  ◎ goal set: ${goalCondition}\n`) + dim('  working… (Esc to pause)\n'));
+        const tokensBefore = session.meta.tokens ?? 0;
+        await turn(goalCondition);
+        goalTokens += (session.meta.tokens ?? 0) - tokensBefore;
+        goalTurns++;
+        persistGoal();
+        if (!exitRequested) await goalLoop();
+        if (exitRequested) return true;
+      },
+    },
     exit: { desc: 'quit', run: () => true },
     quit: { desc: 'quit', run: () => true },
   };
@@ -1770,7 +1873,6 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
 
   let prefill: string | undefined; // set by double-Esc jump-back → pre-fills the next prompt
   let tick = 0; // footer spinner frame counter (advances on each ticked re-render)
-
   /** One dispatch seam for a submitted line — typed (REPL loop) and spoken (voiceIO.onUtterance)
    *  share it, so voice gets !cmd/#note//commands/mentions/persistence identically. Returns 'quit'
    *  when a builtin asked to exit. */
@@ -1787,7 +1889,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     // `#note` — jot a memory, like CC. Writes to the memory index (created if absent).
     if (line.startsWith('#')) {
       const note = line.slice(1).trim();
-      if (note) { const where = await appendMemoryNote(agent.options.fs!, agent.options.memoryDir || adot('memory'), note); err(green(`  ✎ remembered → ${where}\n`)); }
+      if (note) { const where = await appendMemoryNote(agent.options.fs!, primaryMemDir(agent.options.memoryDir, adot('memory')), note); err(green(`  ✎ remembered → ${where}\n`)); }
       return;
     }
 
@@ -1813,6 +1915,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     const task = pendingImages.length ? `${line} ${pendingImages.map((p) => '@' + p).join(' ')}` : line;
     pendingImages.length = 0;
     await turn(task);
+    if (goalCondition && !aborting && !exitRequested) { goalTurns++; persistGoal(); await goalLoop(); }
     if (exitRequested) return 'quit';
   };
 
@@ -1901,6 +2004,7 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
       if (posture !== 'default') parts.push(postureLabel());
       const r = work.reasoning; if (r && r !== 'off') parts.push(`reasoning:${r}`);
       if (verboseOutput) parts.push('verbose');
+      if (goalCondition) parts.push(`◎ goal (${goalTurns} turns)`);
       if (inputStash.length) parts.push(`${inputStash.length} stashed (⌃S to pop)`);
       // Running background tasks: one STACKED line each, pinned to the prompt block, with an animated
       // spinner frame (statusTickMs re-renders this footer every second) — a slow worker is visibly
@@ -1913,8 +2017,16 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
       }
       return [...taskLines, parts.join(' · ')].filter(Boolean).join('\n');
     };
+    // LIVE prompt: while a worker question is pending, the prompt itself becomes the question
+    // (CC-parity for permission asks) — duplexAsk's redrawNow() flips it the moment an ask parks.
+    const livePrompt = () => {
+      const ask = dx?.pendingAsks.size ? dx.pendingAsks.values().next().value : undefined;
+      if (!ask) return promptStr;
+      const q = ask.question.replace(/\s+/g, ' ').slice(0, 64);
+      return bold(yellow(`? ${q}${ask.question.length > 64 ? '…' : ''} ‹yes/no› `));
+    };
     const result = await readMultiline((cont) => editor.readLine({
-      prompt: cont ? contPrompt : promptStr, suggest, history, classifyPaste, onEmptyPaste: grabClipboardAttachment,
+      prompt: cont ? contPrompt : livePrompt, suggest, history, classifyPaste, onEmptyPaste: grabClipboardAttachment,
       initial: cont ? undefined : initial, status: computeFooter, vimMode: cfg.editorMode === 'vim',
       statusTickMs: dx ? 1000 : undefined, // duplex: animate the running-task footer while idle at the prompt
       onCyclePosture: cyclePosture,
@@ -1928,6 +2040,14 @@ async function repl(args: Args, ai: ChatLike, cfg: Partial<AgentConfig>, cwd: st
     if (result === REWIND) { prefill = await rewindToMessage(); continue; } // double-Esc → jump-back picker
     const line = result.trim();
     if (!line) continue;
+    // Typed answer to a pending worker question: resolve it DIRECTLY (deterministic, no LLM hop) —
+    // same UX as approving in a normal session. Anything else falls through to the conversation.
+    if (dx?.pendingAsks.size && /^(y(es|ep|eah)?|n(o|ope)?|sure|ok(ay)?|allow|deny|go( ahead)?)[.!]?$/i.test(line)) {
+      const [id, ask] = dx.pendingAsks.entries().next().value!;
+      ask.resolve(line);
+      err(dim(`  ↳ answered ${id}: ${line}\n`));
+      continue;
+    }
     let quit = await dispatchLine(line) === 'quit';
     // Drain stashed input (typed while the turn was running)
     while (!quit && inputStash.length) {
@@ -2025,7 +2145,8 @@ async function main() {
     const { ok, res } = await runTurn(agent, store, session, args.task, undefined, cwd);
     // opt-in: on a bad outcome, reflect once and persist a novel lesson for next session
     if (cfg.reflectOnFailure && !ok && res && agent.options.memoryDir) {
-      const slug = await reflectOnRun({ ai, model: agent.options.model, fs: agent.options.fs!, dir: agent.options.memoryDir, result: res });
+      const _fsBase = agent.options.fs!.getCwd() === '/' ? '' : agent.options.fs!.getCwd();
+      const slug = await reflectOnRun({ ai, model: agent.options.model, fs: agent.options.fs!, dir: primaryMemDir(agent.options.memoryDir, `${_fsBase}/.agent/memory`), result: res });
       if (slug) err(dim(`  ✎ learned a lesson → ${slug}\n`));
     }
     await closeMcp(mounted); // kill MCP child processes after the run (and any reflection)

package/dist/{Agent-QwBA0wu6.d.ts → Agent-B_xvSHlG.d.ts}

@@ -229,8 +229,11 @@ declare class AgentOptions {
     skillsDir?: string | string[];
     /** VFS dir(s) of slash-command templates (`<dir>/<name>.md`). If set: inject a catalog + add the `SlashCommand` tool. Multiple dirs are merged (first wins). */
     commandsDir?: string | string[];
-    /** VFS dir of memory (`<dir>/MEMORY.md`). If set: inject the index at run start (persistence = backend). */
-    memoryDir?: string;
+    /** VFS dir(s) of memory (`<dir>/MEMORY.md`). If set: inject the index at run start (persistence = backend).
+     *  Multiple dirs are merged (reads search all; writes go to first). */
+    memoryDir?: string | string[];
+    /** User-scope memory dir for global facts (type=user/feedback). Remember routes by type when set. */
+    memoryUserDir?: string;
     /** Filenames to discover as project instructions (e.g. `AGENT.md`, `AGENTS.md`, `CLAUDE.md`).
      *  Walks the VFS tree and merges all found files (general → specific, like Claude Code).
      *  `true` (default) = auto-discover standard names. `string[]` = custom names. `false` = skip. */
@@ -272,6 +275,8 @@ declare class AgentOptions {
     };
     /** Provider-specific options forwarded to ai.chat() (e.g. cursor mcpServers, cwd). */
     providerOptions?: Record<string, unknown>;
+    /** Tool selection mode: 'auto' = model decides (needed for Groq); undefined = provider default. */
+    toolChoice?: 'auto' | 'required' | 'none';
     /** Extended-thinking / reasoning effort, normalized across providers (anthropic, openai).
      *  `'off'`/undefined = none; `'low'|'medium'|'high'` or a raw token budget. Mapped to the
      *  provider-specific request shape via {@link reasoningToChatFragment}; explicit `providerOptions` wins. */

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { h as RunResult, R as ReasoningEffort } from './Agent-QwBA0wu6.js';
+import { h as RunResult, R as ReasoningEffort } from './Agent-B_xvSHlG.js';
 import { IFilesystem } from '@livx.cc/wcli/core';
 import { M as Message, c as ContentPart } from './tools-GPWp7oXq.js';