lazyclaw 5.1.0 → 5.2.0

package/providers/tool_use/anthropic.mjs

@@ -51,6 +51,13 @@ export async function callOnce({
   baseUrl,
   fetchImpl,
   signal,
+  // Group B / C9 — prompt caching. Opt-in; the existing phase 12b/24
+  // test surface asserts the no-cache byte shape so this defaults off.
+  // Production call sites (agent_turn, mention_router) pass `cache:true`
+  // so every real Messages API call from the tool-use path gets a
+  // cache_control:ephemeral block on the static system prefix AND on
+  // the last tool object (so the tool schema cache also benefits).
+  cache = false,
 } = {}) {
   if (!Array.isArray(messages) || messages.length === 0) {
     throw new AnthropicToolUseError('messages[] is required and non-empty', 'NO_MESSAGES');
@@ -65,16 +72,45 @@ export async function callOnce({
     max_tokens: maxTokens,
     messages,
   };
-  if (system && String(system).trim()) body.system = String(system);
-  if (tools && tools.length) body.tools = tools;
+  if (system && String(system).trim()) {
+    if (cache) {
+      // Lift the system string into a one-block array carrying
+      // cache_control. The Anthropic API accepts either a plain string
+      // OR an array of text blocks here; we use the array form so we
+      // can attach the breakpoint marker.
+      body.system = [{ type: 'text', text: String(system), cache_control: { type: 'ephemeral' } }];
+    } else {
+      body.system = String(system);
+    }
+  }
+  if (tools && tools.length) {
+    if (cache) {
+      // Clone the array (don't mutate the caller's reference) and
+      // attach cache_control to the LAST tool — that marks the entire
+      // tool block as cacheable, per Anthropic's spec.
+      const cloned = tools.map((t, i) => (i === tools.length - 1
+        ? { ...t, cache_control: { type: 'ephemeral' } }
+        : t));
+      body.tools = cloned;
+    } else {
+      body.tools = tools;
+    }
+  }
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'x-api-key': apiKey,
+    'anthropic-version': ANTHROPIC_VERSION,
+  };
+  if (cache) {
+    // The prompt-caching beta header. Required only on early adoption;
+    // safe to include on newer API versions where it's a no-op.
+    headers['anthropic-beta'] = 'prompt-caching-2024-07-31';
+  }
 
   const res = await fetchFn(url, {
     method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'x-api-key': apiKey,
-      'anthropic-version': ANTHROPIC_VERSION,
-    },
+    headers,
     body: JSON.stringify(body),
     signal,
   });

package/skills.mjs

@@ -15,6 +15,22 @@ import os from 'node:os';
 const SKILLS_DIRNAME = 'skills';
 const SKILL_EXT = '.md';
 
+// Group B / M8 — memoize listSkills() + skillsIndex() per configDir.
+// composePromptStack is called on every chat/agent turn; listing the
+// skills directory + statting + reading every file used to cost ~2-5 ms
+// at ~30 skills, and was the largest non-network item in the per-turn
+// flame graph. Cache key is the skills/ directory's mtimeMs — any
+// install/remove via this module bumps it (writeFile updates the
+// containing dir's mtime). Manual edits with `vim` also bust the cache
+// because writing a file in a directory updates that dir's mtime.
+// _invalidateSkillsCache() is exported as the safety hatch for callers
+// that want to be explicit.
+const _indexCache = new Map();  // cfgDir → { mtimeMs, skills, index }
+
+export function _invalidateSkillsCache(configDir = defaultConfigDir()) {
+  _indexCache.delete(configDir);
+}
+
 export function defaultConfigDir() {
   return process.env.LAZYCLAW_CONFIG_DIR || path.join(os.homedir(), '.lazyclaw');
 }
@@ -33,7 +49,14 @@ export function skillPath(name, configDir = defaultConfigDir()) {
 export function listSkills(configDir = defaultConfigDir()) {
   const dir = skillsDir(configDir);
   if (!fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir)
+  // M8 — cache hit when the skills/ directory's mtime is unchanged.
+  let dirMtime = 0;
+  try { dirMtime = fs.statSync(dir).mtimeMs; } catch { /* unreadable → bypass cache */ }
+  const cached = _indexCache.get(configDir);
+  if (cached && cached.mtimeMs === dirMtime && dirMtime > 0) {
+    return cached.skills;
+  }
+  const skills = fs.readdirSync(dir)
     .filter(name => name.endsWith(SKILL_EXT))
     .map(name => {
       const full = path.join(dir, name);
@@ -57,6 +80,10 @@ export function listSkills(configDir = defaultConfigDir()) {
       };
     })
     .sort((a, b) => a.name.localeCompare(b.name));
+  if (dirMtime > 0) {
+    _indexCache.set(configDir, { mtimeMs: dirMtime, skills, index: null });
+  }
+  return skills;
 }
 
 // Parse a leading YAML frontmatter block (--- … ---). Only the flat
@@ -108,9 +135,19 @@ function firstHeading(body) {
 // paying for their full bodies (progressive disclosure — the model
 // pulls a full skill on demand via the skill_view tool).
 export function skillsIndex(configDir = defaultConfigDir()) {
+  // Memoize the rendered index alongside the cached skills array — both
+  // are pure functions of the skills/ mtime.
+  const cached = _indexCache.get(configDir);
+  if (cached && cached.index !== null) return cached.index;
   const skills = listSkills(configDir);
-  if (!skills.length) return '';
-  return skills.map((s) => `- ${s.name}: ${s.summary}`.trimEnd()).join('\n');
+  if (!skills.length) {
+    if (cached) cached.index = '';
+    return '';
+  }
+  const index = skills.map((s) => `- ${s.name}: ${s.summary}`.trimEnd()).join('\n');
+  const refreshed = _indexCache.get(configDir);
+  if (refreshed) refreshed.index = index;
+  return index;
 }
 
 export function loadSkill(name, configDir = defaultConfigDir()) {
@@ -123,12 +160,14 @@ export function installSkill(name, content, configDir = defaultConfigDir()) {
   const p = skillPath(name, configDir);
   fs.mkdirSync(path.dirname(p), { recursive: true });
   fs.writeFileSync(p, content);
+  _invalidateSkillsCache(configDir);
   return p;
 }
 
 export function removeSkill(name, configDir = defaultConfigDir()) {
   const p = skillPath(name, configDir);
   if (fs.existsSync(p)) fs.unlinkSync(p);
+  _invalidateSkillsCache(configDir);
 }
 
 export function skillExists(name, configDir = defaultConfigDir()) {

package/tasks.mjs

@@ -157,7 +157,30 @@ export function appendTurn(id, turn, configDir = defaultConfigDir()) {
   const t = getTask(id, configDir);
   if (!t) throw new TaskError(`no task "${id}"`, 'TASK_NO_TASK');
   const turns = Array.isArray(t.turns) ? [...t.turns, turn] : [turn];
-  return patchTask(id, { turns }, configDir);
+  const next = patchTask(id, { turns }, configDir);
+  // v5 Group A (M4): mirror the appended turn to the FTS5 sessions
+  // index using session_id = `task:<id>` so the recall tool can surface
+  // task transcripts the same way it surfaces chat sessions. Namespaced
+  // with the `task:` prefix to avoid colliding with chat session ids.
+  // Best-effort: any FTS failure stays inside the dynamic-import block
+  // so a missing index_db (e.g. in a stripped test env) never breaks
+  // task writes.
+  try {
+    void (async () => {
+      try {
+        const { indexSessionTurn } = await import('./mas/index_db.mjs');
+        const turnIdx = turns.length - 1;
+        indexSessionTurn({
+          session_id: `task:${id}`,
+          turn_idx: turnIdx,
+          role: turn.agent === 'user' ? 'user' : 'assistant',
+          ts: Date.parse(turn.ts) || Date.now(),
+          content: turn.text || '',
+        }, configDir);
+      } catch { /* swallow */ }
+    })();
+  } catch { /* swallow */ }
+  return next;
 }
 
 export function removeTask(id, configDir = defaultConfigDir()) {

package/tui/repl.mjs

@@ -56,6 +56,12 @@ export function consumeNextTurnFirstMessage(state) {
 }
 
 // ─── React mount ─────────────────────────────────────────────────────────
+// v5.1 TODO (C7 follow-up): replace direct stdout writes in cli.mjs's
+// _chatRunTurnFactory with a scrollback ref'd via this component. The
+// shape would be an `onOutput` prop that pushes chunks into a `useState`
+// array rendered through Ink's <Static items={scrollback}/>. v5.0.10
+// ships with raw stdout writes interleaved with Ink (acceptable visual
+// jank in exchange for unblocking the chat loop).
 export function ReplApp({ splashProps, runTurn }) {
   const [state, setState] = useState(makeReplState);
   const { exit } = useApp();

package/tui/run_turn.mjs

@@ -0,0 +1,138 @@
+// tui/run_turn.mjs — shared chat-turn streaming closure (v5 Group C, C7).
+//
+// Single source of truth for the streaming + persist + post-task
+// learning loop. The same factory backs:
+//   - the ink REPL path (ReplApp.runTurn)
+//   - the legacy readline path (cli.mjs's `for await (const line of rl)` body)
+//
+// One factory ⇒ one set of bugs. Both call sites get the same buffered
+// writer (CJK-safe 30 ms coalescing), the same persistTurn dual-write
+// (sessions + memory/recent), and the same fire-and-forget learning
+// hook (queueMicrotask).
+//
+// `ctx` carries the chat-session state. Getter functions close over
+// *current* bindings so a mid-session /provider switch takes effect on
+// the very next turn without re-creating the closure.
+//
+// `writeFn` is the sink for streamed chunks — the legacy path passes
+// `(s) => process.stdout.write(s)`; the ink path also writes to stdout
+// for v5.0.10 (interleaves with Ink output; visual jank accepted in
+// exchange for unblocking the chat loop). v5.1 TODO: route the ink
+// writeFn through a scrollback ref in ReplApp.
+//
+// Errors are swallowed (matches v4 legacy behavior) — we write
+// "error: ..." into writeFn but do not re-throw, so the caller's
+// turn-completion logic (ReplApp onTurnComplete, legacy `rl.prompt`)
+// runs unconditionally.
+
+/**
+ * @typedef {Object} RunTurnCtx
+ * @property {Object} cfg                                  Active config.
+ * @property {string} cfgDir                               Resolved configDir.
+ * @property {Object|null} sandboxSpec                     Parsed --sandbox spec (or null).
+ * @property {string} syntheticChatSessionId              Session-id fallback when --session not set.
+ * @property {() => Array<{role:string,content:string}>} getMessages
+ * @property {() => { sendMessage: Function, name?: string }} getProv
+ * @property {() => string} getActiveProvName
+ * @property {() => string|null} getActiveModel
+ * @property {() => string|null} getSessionId
+ * @property {(role: string, content: string) => void} persistTurn
+ * @property {(u: any) => void} accumulateUsage
+ * @property {(provider: string) => string} resolveAuthKey  Caller supplies; mirrors cli.mjs::_resolveAuthKey.
+ * @property {(n: number) => void} [onCharsSent]            Optional observer (legacy path increments charsSent).
+ */
+
+/**
+ * Build a runTurn(text, signal) closure that drives one provider turn
+ * end-to-end.
+ *
+ * @param {{ ctx: RunTurnCtx, writeFn: (chunk: string) => void }} args
+ * @returns {(text: string, signal?: AbortSignal) => Promise<void>}
+ */
+export function makeRunTurn({ ctx, writeFn }) {
+  return async function runTurn(text, signal) {
+    if (signal?.aborted) return;
+    const messages = ctx.getMessages();
+    messages.push({ role: 'user', content: text });
+    try { ctx.onCharsSent && ctx.onCharsSent(text.length); }
+    catch { /* observer is best-effort */ }
+    ctx.persistTurn('user', text);
+
+    let acc = '';
+    let _writeBuf = '';
+    let _writeTimer = null;
+    const _flush = () => {
+      if (_writeBuf) {
+        try { writeFn(_writeBuf); }
+        catch { /* sink failure must not kill the turn */ }
+        _writeBuf = '';
+      }
+      _writeTimer = null;
+    };
+    const _writeChunk = (s) => {
+      _writeBuf += s;
+      if (!_writeTimer) _writeTimer = setTimeout(_flush, 30);
+    };
+
+    try {
+      const sysMsg = messages.find((m) => m.role === 'system');
+      const prov = ctx.getProv();
+      const activeProvName = ctx.getActiveProvName();
+      const activeModel = ctx.getActiveModel();
+      // C8 — prompt-cache the static system prefix. The Anthropic
+      // provider prefers `systemStatic` when present; non-Anthropic
+      // providers ignore the field and fall back to the legacy
+      // single-block path with `cache:true`.
+      for await (const chunk of prov.sendMessage(messages, {
+        apiKey: ctx.resolveAuthKey(activeProvName),
+        model: activeModel,
+        sandbox: ctx.sandboxSpec,
+        signal,
+        onUsage: ctx.accumulateUsage,
+        cache: true,
+        ...(sysMsg ? { systemStatic: sysMsg.content } : {}),
+      })) {
+        _writeChunk(chunk);
+        acc += chunk;
+      }
+      if (_writeTimer) clearTimeout(_writeTimer);
+      _flush();
+      try { writeFn('\n'); }
+      catch { /* sink failure must not kill the turn */ }
+      messages.push({ role: 'assistant', content: acc });
+      ctx.persistTurn('assistant', acc);
+      // v5 Group A (C1): close the post-task learning loop on every
+      // successful chat turn. Fire-and-forget via queueMicrotask so the
+      // next prompt is never blocked on trajectory write / synth.
+      try {
+        queueMicrotask(() => {
+          import('../mas/learning.mjs').then((mod) => mod.runLearning('post-task', {
+            agent: { name: 'chat', provider: activeProvName, model: activeModel, role: '' },
+            task: {
+              id: ctx.getSessionId() || ctx.syntheticChatSessionId,
+              title: '(chat turn)',
+              turns: messages.slice(-2).map((m) => ({
+                agent: m.role === 'user' ? 'user' : 'chat',
+                text: m.content,
+                ts: new Date().toISOString(),
+              })),
+            },
+            configDir: ctx.cfgDir,
+            cfg: ctx.cfg,
+            transcript: acc.slice(0, 8000),
+          })).catch(() => { /* learning loop is best-effort */ });
+        });
+      } catch { /* never let learning hook break the chat */ }
+    } catch (err) {
+      if (_writeTimer) clearTimeout(_writeTimer);
+      _flush();
+      // ABORT errors are user-initiated; drop the partial reply (don't
+      // push an incomplete assistant message — next turn would treat
+      // it as a complete reply and confuse the model).
+      if (err?.code !== 'ABORT' && !signal?.aborted) {
+        try { writeFn(`error: ${err?.message || String(err)}\n`); }
+        catch { /* sink failure must not mask err */ }
+      }
+    }
+  };
+}

package/web/dashboard.html

@@ -1780,7 +1780,7 @@
               <div class="name" style="margin-left:8px;">${escHtml(String(label))}</div>
               <div class="dim row-actions">bm25 ${Number(h.bm25 || 0).toFixed(2)}</div>
             </div>
-            <div class="dim" style="margin-top:6px;font-size:12px;">${h.snippet || ''}</div>
+            <div class="dim" style="margin-top:6px;font-size:12px;">${escHtml(h.snippet || '').replace(/&lt;mark&gt;/g,'<mark>').replace(/&lt;\/mark&gt;/g,'</mark>')}</div>
           </div>`;
         }).join('');
       } catch (e) {