agent.libx.js 0.93.27 → 0.93.29

package/dist/index.d.ts

@@ -375,61 +375,65 @@ declare const webFetchTool: AgentTool;
 declare const webSearchTool: AgentTool;
 
 /**
- * Artifact blackboard — keep large tool/subagent outputs OUT of the main context, but queryable.
+ * Scratch — keep large tool/subagent outputs OUT of the main context, but queryable AS FILES.
  *
  * Pattern: many-tool / many-subagent engines bloat context with raw outputs (search results, big
  * file reads, subagent reports) that are mostly noise once a gist is taken. Here, a tool wrapped with
- * `withArtifactCapture` stashes any oversized result in an `ArtifactStore` and returns a compact stub
- * (id + preview) to context. When the caller later needs a buried detail, `Ask({question, over})`
- * peeks into the full artifact in a side-step — a (cheap) model extracts just the answer, so the raw
- * blob never re-enters the caller's context. The caller (often a stronger model) synthesizes from the
- * tight answer Ask returns. Two-tier division of labour: cheap RETRIEVE/EXTRACT, strong SYNTHESIZE.
+ * `Scratch.capture` writes any oversized result to an ephemeral scratch filesystem (a real VFS) and
+ * returns a compact stub (path + preview) to context. To recover a buried detail later you do NOT
+ * re-bloat context — you peek with the FILE tools already on hand:
+ *   • Grep/Glob/Read over the scratch dir — returns matching lines, not the blob (a free, light peek).
+ *   • Ask({question, over?}) — a CHEAP child agent over the scratch FS that greps/reads and returns
+ *     just the answer; its reasoning tokens never touch the caller's context.
+ * Two-tier division of labour: cheap RETRIEVE/EXTRACT, strong caller SYNTHESIZE.
  *
- * Spike, not load-bearing yet — segregated module (IoC via options), zero Agent-core changes.
+ * The scratch FS is injected (IoC): pass a MemFilesystem for ephemeral, or a disk-backed one under the
+ * session dir to persist across resume (CC's lesson: the filesystem is the durable store). Segregated
+ * module — zero Agent-core changes.
  */
 
-interface Artifact {
-    id: string;
-    tool: string;
-    brief: string;
-    content: string;
-    bytes: number;
-}
-/** In-memory store of captured tool outputs. Ids are a monotonic `a1, a2, …` (test-friendly, no RNG). */
-declare class ArtifactStore {
-    private items;
-    private seq;
-    put(tool: string, content: string, brief?: string): Artifact;
-    get(id: string): Artifact | undefined;
-    list(): Artifact[];
-    get size(): number;
-    /** Cheap keyword retrieval over brief+content — rank by how many query terms each artifact contains. */
-    search(query: string, k?: number): Artifact[];
-}
-interface CaptureOptions {
+/** Default scratch dir (a path in the injected scratch FS). */
+declare const SCRATCH_DIR = "/scratch";
+interface ScratchOptions {
     /** Min result length (chars) to capture; smaller results pass through untouched. Default 1500. */
     threshold?: number;
+    /** Dir within the scratch FS to write captures. Default SCRATCH_DIR. */
+    dir?: string;
     /** Chars of the captured output to preview in the stub. Default 320. */
     previewChars?: number;
 }
 /**
- * Wrap a tool so any oversized STRING result is stored as an artifact and replaced with a compact
- * stub. Non-string results (images/structured) and small results pass through unchanged.
+ * Owns an (injected) scratch filesystem + a capture counter. `capture(tool)` wraps a tool so its
+ * oversized string results spill to a scratch file and are replaced in context with a stub.
  */
-declare function withArtifactCapture(tool: AgentTool, store: ArtifactStore, opts?: CaptureOptions): AgentTool;
+declare class Scratch {
+    fs: IFilesystem;
+    options: Required<ScratchOptions>;
+    private seq;
+    private dirReady?;
+    constructor(fs: IFilesystem, options?: ScratchOptions);
+    /** Number of captures so far. */
+    get count(): number;
+    /** Wrap a tool: oversized STRING results spill to a scratch file; everything else passes through. */
+    capture(tool: AgentTool): AgentTool;
+    /** Wrap many tools at once. */
+    captureAll(tools: AgentTool[]): AgentTool[];
+}
 interface AskOptions {
-    store: ArtifactStore;
+    /** The scratch filesystem to peek into (dedicated VFS holding only scratch files). */
+    fs: IFilesystem;
     ai: ChatLike;
-    /** Model for the extraction step — intentionally a CHEAP model; the caller synthesizes. */
+    /** Model for the peek — intentionally a CHEAP model; the caller synthesizes. */
     model: string;
-    /** Max chars of each artifact fed to the extractor (default 12000). */
-    maxChars?: number;
+    /** Step budget for the peek child (default 6). */
+    maxSteps?: number;
+    /** Scratch dir to search when `over` is omitted. Default SCRATCH_DIR. */
+    dir?: string;
 }
 /**
- * `Ask` — peek into stored artifacts to answer a question, WITHOUT loading the raw data into the
- * caller's context. Pass `over` (artifact id(s)) for a targeted peek, or omit to auto-retrieve by
- * relevance. Returns only the extracted answer. Built for the two-tier split: a cheap model does the
- * retrieve+extract here; the (stronger) caller synthesizes the final answer from what comes back.
+ * `Ask` — peek into the scratch FS to answer a question WITHOUT loading raw data into the caller's
+ * context. Spawns a cheap child agent (Read/Grep/Glob over scratch) that greps/reads and returns just
+ * the answer. Pass `over` (a path) for a targeted peek, or omit to grep-discover.
  */
 declare function makeAskTool(o: AskOptions): AgentTool;
 
@@ -1134,4 +1138,4 @@ declare class CartesiaTTS {
     close(): void;
 }
 
-export { Agent, type AgentDef, AgentOptions, AgentTool, type Artifact, ArtifactStore, type AskOptions, type Attempt, type AudioSink, type AudioSource, type AuthProvider, BodDbFilesystem, type CaptureOptions, CartesiaTTS, CartesiaTTSOptions, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type LoadMemoryOpts, MEMORY_PROMPT, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, type ReflectOptions, RunResult, STT_SAMPLE_RATE, ScriptedHostBridge, type SkillInfo, SonioxSTT, SonioxSTTOptions, type SttLike, TTS_SAMPLE_RATE, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, type TtsLike, UserQuestion, VOICE_MEMORY_PROMPT, VOICE_SYSTEM_PROMPT, VoiceEngine, VoiceEngineOptions, type VoiceState, type WebFetchOptions, type WebSearchOptions, type WorkerTier, applyEditsTool, askUserQuestionTool, checkpointTool, checkpointTools, compileSynthesizedTool, decodeDdgUrl, diskAgentOptions, expandCommand, expandTemplate, forComponent, fullAgentOptions, globTool, grepTool, htmlToText, idfWeights, lessonCapture, loadAgents, loadCommands, loadInstructions, loadMemory, loadSkills, makeAskTool, makeTaskBatchTool, makeTaskTool, makeWebFetchTool, makeWebSearchTool, mkdirp, multiEditTool, parseDdgHtml, raceAttempts, reflectOnRun, relevanceScore, repoIndex, repoMapTool, resolveAuth, rollbackTool, sandboxAgentOptions, slugify, tokenize, toolCall, topByRelevance, validateToolCode, webFetchTool, webSearchTool, withArtifactCapture, writeFact, writeTool };
+export { Agent, type AgentDef, AgentOptions, AgentTool, type AskOptions, type Attempt, type AudioSink, type AudioSource, type AuthProvider, BodDbFilesystem, CartesiaTTS, CartesiaTTSOptions, ChatLike, ChatOptions, ChatResponse, type CommandInfo, ConsoleHostBridge, DEFAULT_DENY, DuplexAgent, DuplexAgentOptions, type DuplexTaskStatus, FakeAIClient, Hooks, HostBridge, JailOptions, JailedFilesystem, type LessonOptions, LessonOptionsDefaults, type LoadMemoryOpts, MEMORY_PROMPT, MessageContent, type Mount, MountFilesystem, NodeDiskFilesystem, OverlayFilesystem, type ReflectOptions, RunResult, SCRATCH_DIR, STT_SAMPLE_RATE, Scratch, type ScratchOptions, ScriptedHostBridge, type SkillInfo, SonioxSTT, SonioxSTTOptions, type SttLike, TTS_SAMPLE_RATE, type TaskRecord, type TaskToolOptions, ToolCall, type ToolSpec, type TtsLike, UserQuestion, VOICE_MEMORY_PROMPT, VOICE_SYSTEM_PROMPT, VoiceEngine, VoiceEngineOptions, type VoiceState, type WebFetchOptions, type WebSearchOptions, type WorkerTier, applyEditsTool, askUserQuestionTool, checkpointTool, checkpointTools, compileSynthesizedTool, decodeDdgUrl, diskAgentOptions, expandCommand, expandTemplate, forComponent, fullAgentOptions, globTool, grepTool, htmlToText, idfWeights, lessonCapture, loadAgents, loadCommands, loadInstructions, loadMemory, loadSkills, makeAskTool, makeTaskBatchTool, makeTaskTool, makeWebFetchTool, makeWebSearchTool, mkdirp, multiEditTool, parseDdgHtml, raceAttempts, reflectOnRun, relevanceScore, repoIndex, repoMapTool, resolveAuth, rollbackTool, sandboxAgentOptions, slugify, tokenize, toolCall, topByRelevance, validateToolCode, webFetchTool, webSearchTool, writeFact, writeTool };

package/dist/index.js

@@ -1998,9 +1998,9 @@ async function loadCommands(fs, dir, opts = {}) {
       properties: { name: { type: "string" }, args: { type: "string", description: "arguments to fill the template" } }
     },
     async run({ name, args }, ctx) {
-      const slug = String(name ?? "").replace(/^\//, "");
-      const c = commands.find((x) => x.name === slug);
-      if (!c) return `Error: no command named '${slug}'. Available: ${commands.map((x) => x.name).join(", ")}`;
+      const slug2 = String(name ?? "").replace(/^\//, "");
+      const c = commands.find((x) => x.name === slug2);
+      if (!c) return `Error: no command named '${slug2}'. Available: ${commands.map((x) => x.name).join(", ")}`;
       return expandCommand(ctx.fs, c, String(args ?? ""));
     }
   };
@@ -2035,9 +2035,9 @@ async function loadMemory(fs, dir, opts = {}) {
     const lines = md.split("\n");
     if (!header) header = lines.filter((l) => !/^\s*-\s*\[.+\]\(.+\.md\)/.test(l)).join("\n").trim();
     for (const l of lines.filter((l2) => /^\s*-\s*\[.+\]\(.+\.md\)/.test(l2))) {
-      const slug = l.match(/\]\(([^)]+)\.md\)/)?.[1];
-      if (slug && !seenSlugs.has(slug)) {
-        seenSlugs.add(slug);
+      const slug2 = l.match(/\]\(([^)]+)\.md\)/)?.[1];
+      if (slug2 && !seenSlugs.has(slug2)) {
+        seenSlugs.add(slug2);
         allPointers.push(l);
       }
     }
@@ -2053,20 +2053,20 @@ function slugify(s, fallback = "note") {
   const base = String(s ?? "").trim().toLowerCase().replace(/\.md$/i, "").replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 48);
   return base || fallback;
 }
-async function writeFact(fs, dir, slug, body, opts) {
+async function writeFact(fs, dir, slug2, body, opts) {
   await mkdirp(fs, dir);
   const content = opts?.type ? `---
 type: ${opts.type}
 ---
 
 ${body}` : body;
-  await fs.writeFile(`${dir}/${slug}.md`, content.endsWith("\n") ? content : content + "\n");
+  await fs.writeFile(`${dir}/${slug2}.md`, content.endsWith("\n") ? content : content + "\n");
   const indexPath = `${dir}/MEMORY.md`;
   const idx = await fs.exists(indexPath) ? await fs.readFile(indexPath) : "# Memory Index\n";
   const summary = opts?.description || body.split("\n")[0].slice(0, 80);
-  const line = `- [${slug}](${slug}.md) \u2014 ${summary}`;
+  const line = `- [${slug2}](${slug2}.md) \u2014 ${summary}`;
   const lines = idx.split("\n");
-  const at = lines.findIndex((l) => l.includes(`(${slug}.md)`));
+  const at = lines.findIndex((l) => l.includes(`(${slug2}.md)`));
   if (at >= 0) {
     if (lines[at] !== line) {
       lines[at] = line;
@@ -2117,8 +2117,8 @@ async function listSlugs(fs, dir, prefix = "") {
   }
   return out;
 }
-async function loadFact(fs, dir, slug) {
-  const path = `${dir}/${slug}.md`;
+async function loadFact(fs, dir, slug2) {
+  const path = `${dir}/${slug2}.md`;
   try {
     const raw = await fs.readFile(path);
     const { body } = splitFrontmatter(raw);
@@ -2127,9 +2127,9 @@ async function loadFact(fs, dir, slug) {
     return null;
   }
 }
-async function loadFactMulti(fs, dirs, slug) {
+async function loadFactMulti(fs, dirs, slug2) {
   for (const d of dirs) {
-    const r = await loadFact(fs, d, slug);
+    const r = await loadFact(fs, d, slug2);
     if (r != null) return r;
   }
   return null;
@@ -2155,9 +2155,9 @@ function recallTool(fs, dirs) {
         pattern: { type: "string", description: 'glob pattern to match against slugs (e.g. "auth*", "*database*")' }
       }
     },
-    async run({ slug, slugs, pattern }, ctx) {
+    async run({ slug: slug2, slugs, pattern }, ctx) {
       let targets = [];
-      if (slug) targets = [cleanSlug(slug)];
+      if (slug2) targets = [cleanSlug(slug2)];
       else if (Array.isArray(slugs)) targets = slugs.map(cleanSlug).filter(Boolean);
       else if (pattern) {
         const escaped = String(pattern).replace(/[.+^${}()|[\]\\]/g, "\\$&");
@@ -2208,19 +2208,19 @@ function memorySearchTool(fs, dirs) {
         matcher = (l) => l.toLowerCase().includes(lower);
       }
       const loaded = [];
-      for (const slug of slugs) {
-        const body = await loadFactMulti(fs, dirs, slug);
-        if (body) loaded.push({ slug, body });
+      for (const slug2 of slugs) {
+        const body = await loadFactMulti(fs, dirs, slug2);
+        if (body) loaded.push({ slug: slug2, body });
       }
       const idf = idfWeights(loaded.map((l) => l.body));
       const qTokens = tokenize(q);
       const hits = [];
-      for (const { slug, body } of loaded) {
+      for (const { slug: slug2, body } of loaded) {
         const lines = body.split("\n");
         const matchLine = lines.find(matcher);
         if (!matchLine && !relevanceScore(body, qTokens, idf)) continue;
         const snippet = matchLine?.trim().slice(0, 120) || lines.find((l) => l.trim())?.trim().slice(0, 120) || "";
-        hits.push({ slug, snippet, score: relevanceScore(body, qTokens, idf) });
+        hits.push({ slug: slug2, snippet, score: relevanceScore(body, qTokens, idf) });
       }
       if (!hits.length) return "(no matches)";
       hits.sort((a, b) => b.score - a.score);
@@ -2244,11 +2244,11 @@ function rememberTool(fs, dir, memOpts = {}) {
         description: { type: "string", description: "one-line summary for the memory index (\u226480 chars)" }
       }
     },
-    async run({ fact, slug, type, description }, ctx) {
+    async run({ fact, slug: slug2, type, description }, ctx) {
       const body = String(fact ?? "").trim();
       if (!body) return `Error: nothing to remember (empty fact).`;
       if (++writes > maxWrites) return `Rate limit: too many memories this session (${maxWrites}). Only persist genuinely durable facts.`;
-      const name = slugify(slug || body.split("\n")[0]);
+      const name = slugify(slug2 || body.split("\n")[0]);
       const isGlobal = (type === "user" || type === "feedback") && memOpts.userDir;
       const targetDir = isGlobal ? memOpts.userDir : dir;
       await writeFact(fs, targetDir, name, body, { type, description });
@@ -3568,100 +3568,100 @@ init_tools_structured();
 init_todo();
 init_tools_web();
 
-// src/artifacts.ts
+// src/scratch.ts
+init_tools();
+init_tools_structured();
 init_logging();
-var log5 = forComponent("artifacts");
-var ArtifactStore = class {
-  items = /* @__PURE__ */ new Map();
-  seq = 0;
-  put(tool, content, brief) {
-    const id = "a" + ++this.seq;
-    const art = { id, tool, brief: brief || content.replace(/\s+/g, " ").trim().slice(0, 80), content, bytes: content.length };
-    this.items.set(id, art);
-    return art;
-  }
-  get(id) {
-    return this.items.get(id);
-  }
-  list() {
-    return [...this.items.values()];
-  }
-  get size() {
-    return this.items.size;
-  }
-  /** Cheap keyword retrieval over brief+content — rank by how many query terms each artifact contains. */
-  search(query, k = 3) {
-    const terms = [...new Set(query.toLowerCase().split(/\W+/).filter((t) => t.length > 2))];
-    if (!terms.length) return this.list().slice(-k);
-    return this.list().map((a) => {
-      const hay = (a.brief + " " + a.content).toLowerCase();
-      return { a, score: terms.reduce((s, t) => s + (hay.includes(t) ? 1 : 0), 0) };
-    }).filter((x) => x.score > 0).sort((x, y) => y.score - x.score).slice(0, k).map((x) => x.a);
-  }
-};
+var log5 = forComponent("scratch");
+var SCRATCH_DIR = "/scratch";
 function shortArgs(args) {
   try {
-    const s = JSON.stringify(args);
-    return s.length > 60 ? s.slice(0, 57) + "\u2026" : s;
+    const s = JSON.stringify(args ?? {});
+    return s.length > 50 ? s.slice(0, 47) + "\u2026" : s;
   } catch {
     return "";
   }
 }
-function withArtifactCapture(tool, store, opts = {}) {
-  const threshold = opts.threshold ?? 1500;
-  const previewChars = opts.previewChars ?? 320;
-  return {
-    ...tool,
-    run: async (args, ctx) => {
-      const raw = await tool.run(args, ctx);
-      if (typeof raw !== "string" || raw.length <= threshold) return raw;
-      const art = store.put(tool.name, raw, `${tool.name}(${shortArgs(args)})`);
-      const preview = raw.slice(0, previewChars).replace(/\s+/g, " ").trim();
-      return `[artifact ${art.id} \xB7 ${tool.name} \xB7 ${art.bytes} bytes \u2014 full output stored out of context to keep it clean]
+var slug = (s) => s.replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").toLowerCase().slice(0, 32) || "out";
+var Scratch = class {
+  constructor(fs, options = {}) {
+    this.fs = fs;
+    this.options = { threshold: 1500, dir: SCRATCH_DIR, previewChars: 320, ...options };
+  }
+  fs;
+  options;
+  seq = 0;
+  dirReady;
+  /** Number of captures so far. */
+  get count() {
+    return this.seq;
+  }
+  /** Wrap a tool: oversized STRING results spill to a scratch file; everything else passes through. */
+  capture(tool) {
+    const { threshold, dir, previewChars } = this.options;
+    return {
+      ...tool,
+      run: async (args, ctx) => {
+        const raw = await tool.run(args, ctx);
+        if (typeof raw !== "string" || raw.length <= threshold) return raw;
+        const id = "a" + ++this.seq;
+        const path = `${dir}/${id}-${slug(tool.name)}.txt`;
+        const header = `# ${tool.name}(${shortArgs(args)}) \u2014 ${raw.length} bytes
+`;
+        try {
+          await (this.dirReady ??= mkdirp(this.fs, dir));
+          await this.fs.writeFile(path, header + raw);
+        } catch (e) {
+          log5.debug("scratch write failed; returning raw", e);
+          return raw;
+        }
+        const preview = raw.slice(0, previewChars).replace(/\s+/g, " ").trim();
+        return `[scratch ${path} \xB7 ${tool.name} \xB7 ${raw.length} bytes \u2014 full output saved out of context to keep it clean]
 preview: ${preview}\u2026
-To pull a specific detail from it, call Ask({ question: "\u2026", over: "${art.id}" }) \u2014 do NOT guess at what the preview cuts off.`;
-    }
-  };
-}
-var ASK_SYSTEM = "You are a retrieval-extraction step. Given one or more ARTIFACTS (raw outputs from earlier tools) and a QUESTION, find and return exactly the information that answers the question \u2014 quote values/facts verbatim from the artifacts. Do NOT add analysis, opinions, or anything not grounded in the artifacts. If the answer is not present, say so plainly. Be concise.";
+To pull a specific detail, Grep/Read ${path}, or call Ask({ question: "\u2026", over: "${path}" }). Do NOT guess at what the preview cuts off.`;
+      }
+    };
+  }
+  /** Wrap many tools at once. */
+  captureAll(tools) {
+    return tools.map((t) => this.capture(t));
+  }
+};
+var ASK_PROMPT = "You are a retrieval-extraction step with Read, Grep and Glob over a scratch filesystem holding raw outputs from earlier tools. Find the information that answers the question and return it concisely, quoting values/facts verbatim. Do NOT add analysis or anything not grounded in the files. If the answer is not present, say so plainly.";
 function makeAskTool(o) {
-  const maxChars = o.maxChars ?? 12e3;
+  const dir = o.dir ?? SCRATCH_DIR;
   return {
     name: "Ask",
-    description: 'Answer a question by peeking into stored artifacts \u2014 large earlier outputs (web search, big file reads, subagent reports) kept out of your context. Pass `over` with an artifact id like "a3" (or several, comma-separated) for a targeted lookup, or omit it to auto-find relevant artifacts. Returns only the extracted answer; the full data never enters your context.',
+    description: "Answer a question by peeking into the scratch files \u2014 large earlier outputs (web search, big reads, subagent reports) kept out of your context. Pass `over` with a scratch path for a targeted lookup, or omit it to search the scratch dir. Returns only the extracted answer; the full data never enters your context.",
     parameters: {
       type: "object",
       required: ["question"],
       properties: {
-        question: { type: "string", description: "what you need from the artifact(s)" },
-        over: { type: "string", description: 'artifact id(s) to read, e.g. "a3" or "a1,a4"; omit to auto-retrieve' }
+        question: { type: "string", description: "what you need from the scratch files" },
+        over: { type: "string", description: 'scratch path to read, e.g. "/scratch/a3-websearch.txt"; omit to search' }
       }
     },
     async run({ question, over }) {
       const q = String(question ?? "").trim();
       if (!q) return "Error: empty question";
-      const arts = over ? String(over).split(/[,\s]+/).filter(Boolean).map((id) => o.store.get(id)).filter((a) => !!a) : o.store.search(q);
-      if (!arts.length) return over ? `Error: no artifact matching '${over}' (have: ${o.store.list().map((a) => a.id).join(", ") || "none"})` : "(no relevant artifacts found)";
-      const corpus = arts.map((a) => `### artifact ${a.id} (${a.tool})
-${a.content.slice(0, maxChars)}`).join("\n\n");
+      const child = new Agent({
+        ai: o.ai,
+        model: o.model,
+        fs: o.fs,
+        tools: toolsByName(["Read", "Grep", "Glob"]),
+        maxSteps: o.maxSteps ?? 6,
+        systemPrompt: ASK_PROMPT
+      });
+      const hint = over ? `Start by reading: ${over}.` : `Grep/Glob ${dir} to find the relevant file(s) first.`;
       try {
-        const res = await o.ai.chat({
-          model: o.model,
-          messages: [
-            { role: "system", content: ASK_SYSTEM },
-            { role: "user", content: `ARTIFACTS:
-${corpus}
-
-QUESTION: ${q}` }
-          ]
-        });
-        const answer = (res?.content ?? "").trim();
-        return answer ? `${answer}
+        const res = await child.run(`${hint}
 
-(from ${arts.map((a) => a.id).join(", ")})` : "(no answer found in artifacts)";
+Question: ${q}`);
+        const answer = (res.text ?? "").trim();
+        return answer || "(no answer found in scratch)";
       } catch (e) {
-        log5.debug("Ask extraction failed", e);
-        return `Error querying artifacts: ${e?.message ?? e}`;
+        log5.debug("Ask peek failed", e);
+        return `Error querying scratch: ${e?.message ?? e}`;
       }
     }
   };
@@ -3724,15 +3724,15 @@ If the run was fine or the issue was purely task-specific (not generalizable), r
   const m = text.match(/LESSON:\s*(.+)/i);
   const lesson = m?.[1]?.trim().slice(0, 200) ?? "";
   if (!lesson || /^none\b/i.test(lesson)) return null;
-  const slug = ("lesson-" + slugify(lesson)).slice(0, 56);
+  const slug2 = ("lesson-" + slugify(lesson)).slice(0, 56);
   try {
-    await writeFact(o.fs, o.dir, slug, lesson);
+    await writeFact(o.fs, o.dir, slug2, lesson);
   } catch (e) {
     log7.warn(`could not persist lesson: ${e?.message ?? e}`);
     return null;
   }
-  log7.debug(`reflection persisted ${slug}`);
-  return slug;
+  log7.debug(`reflection persisted ${slug2}`);
+  return slug2;
 }
 function digestRun(messages, maxChars) {
   const lines = [];
@@ -5233,7 +5233,6 @@ import { MemFilesystem as MemFilesystem3, IndexedDbFilesystem, CommandExecutor a
 export {
   Agent,
   AgentOptions,
-  ArtifactStore,
   BodDbFilesystem,
   CartesiaTTS,
   CartesiaTTSOptions,
@@ -5257,8 +5256,10 @@ export {
   PermissionPolicy,
   RecordingHooks,
   RecordingLifecycle,
+  SCRATCH_DIR,
   STT_SAMPLE_RATE,
   SandboxJobRegistry,
+  Scratch,
   ScriptedHostBridge,
   SonioxSTT,
   SonioxSTTOptions,
@@ -5335,7 +5336,6 @@ export {
   validateToolCode,
   webFetchTool,
   webSearchTool,
-  withArtifactCapture,
   writeFact,
   writeTool
 };