chainlesschain 0.162.31 → 0.162.32

package/src/lib/goal-store.js

@@ -0,0 +1,308 @@
+/**
+ * goal-store — cross-session persistent goals / OKRs for `cc goal`.
+ *
+ * Unlike a session (short-lived context) or a checkpoint (file state), a goal
+ * is a long-lived objective the agent should advance toward across many
+ * sessions. This is the standalone store + ops; wiring the goal into the agent
+ * loop (so each turn is measured against it) lives in goal-context.js.
+ *
+ * On-disk layout (under <home>/goals, overridable via opts.root for tests):
+ *   <root>/<id>.json        one goal per file
+ *
+ * Distinct from:
+ *   - cc session   (short-term conversation context)
+ *   - cc memory    (durable facts, not objectives)
+ *   - cc planmode  (a single run's plan, not a cross-session objective)
+ *   - cc workflow  (execution orchestration, not intent)
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { getHomeDir } from "./paths.js";
+
+/** Valid goal lifecycle states. `active` goals are the ones injected. */
+export const GOAL_STATUS = Object.freeze({
+  ACTIVE: "active",
+  PAUSED: "paused",
+  DONE: "done",
+  ABANDONED: "abandoned",
+});
+
+const STATUS_VALUES = new Set(Object.values(GOAL_STATUS));
+
+function defaultRoot() {
+  return path.join(getHomeDir(), "goals");
+}
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function newId(prefix) {
+  // Date.now/random are fine here (plain CLI lib, not a resumable workflow).
+  const rand = Math.random().toString(36).slice(2, 8);
+  return `${prefix}-${Date.now()}-${rand}`;
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function goalFile(root, id) {
+  return path.join(root, `${id}.json`);
+}
+
+/** Clamp a value to a 0–100 integer percentage, or null when not a number. */
+function clampPct(v) {
+  if (v == null || v === "") return null;
+  const n = Math.round(Number(v));
+  if (!Number.isFinite(n)) return null;
+  return Math.max(0, Math.min(100, n));
+}
+
+/**
+ * Derive a 0–100 progress from completed key results. Returns null when there
+ * are no key results (caller may keep a manually-set progress instead).
+ */
+function derivedProgress(keyResults) {
+  if (!Array.isArray(keyResults) || keyResults.length === 0) return null;
+  const done = keyResults.filter((k) => k.done).length;
+  return Math.round((done / keyResults.length) * 100);
+}
+
+/**
+ * Create a goal.
+ * @param {object} input { objective, title, keyResults?: string[]|object[] }
+ * @param {object} [opts] { root }
+ * @returns {object} the persisted goal
+ */
+export function createGoal(input = {}, opts = {}) {
+  const root = opts.root || defaultRoot();
+  const objective = String(input.objective || "").trim();
+  if (!objective) {
+    throw new Error("createGoal requires an objective");
+  }
+  const id = input.id || newId("goal");
+  const keyResults = (input.keyResults || []).map((kr) => normalizeKr(kr));
+  const goal = {
+    id,
+    title: String(input.title || objective).trim(),
+    objective,
+    keyResults,
+    status: GOAL_STATUS.ACTIVE,
+    progress: derivedProgress(keyResults) ?? 0,
+    linkedSessions: [],
+    notes: [],
+    drift: { lastProgressAt: null, flags: [] },
+    createdAt: nowIso(),
+    updatedAt: nowIso(),
+  };
+  ensureDir(root);
+  fs.writeFileSync(goalFile(root, id), JSON.stringify(goal, null, 2), "utf-8");
+  return goal;
+}
+
+function normalizeKr(kr) {
+  if (typeof kr === "string") {
+    return {
+      id: newId("kr"),
+      text: kr.trim(),
+      target: null,
+      current: 0,
+      done: false,
+    };
+  }
+  return {
+    id: kr.id || newId("kr"),
+    text: String(kr.text || "").trim(),
+    target: kr.target == null ? null : Number(kr.target),
+    current: Number(kr.current) || 0,
+    done: !!kr.done,
+  };
+}
+
+/** Load a goal by id, or null. */
+export function getGoal(id, opts = {}) {
+  const root = opts.root || defaultRoot();
+  const file = goalFile(root, id);
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function saveGoal(goal, opts = {}) {
+  const root = opts.root || defaultRoot();
+  ensureDir(root);
+  goal.updatedAt = nowIso();
+  fs.writeFileSync(
+    goalFile(root, goal.id),
+    JSON.stringify(goal, null, 2),
+    "utf-8",
+  );
+  return goal;
+}
+
+/** List goals, newest first. Optionally filter by status. */
+export function listGoals(opts = {}) {
+  const root = opts.root || defaultRoot();
+  if (!fs.existsSync(root)) return [];
+  const out = [];
+  for (const name of fs.readdirSync(root)) {
+    if (!name.endsWith(".json")) continue;
+    const g = getGoal(name.slice(0, -5), { root });
+    if (!g) continue;
+    if (opts.status && g.status !== opts.status) continue;
+    out.push(g);
+  }
+  return out.sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1));
+}
+
+/** Mutate a goal via `fn(goal)`; throws if not found. */
+function mutate(id, fn, opts = {}) {
+  const goal = getGoal(id, opts);
+  if (!goal) throw new Error(`no such goal: ${id}`);
+  fn(goal);
+  return saveGoal(goal, opts);
+}
+
+/** Add a key result to a goal. */
+export function addKeyResult(id, text, krOpts = {}, opts = {}) {
+  return mutate(
+    id,
+    (g) => {
+      g.keyResults.push(normalizeKr({ text, target: krOpts.target }));
+      const dp = derivedProgress(g.keyResults);
+      if (dp != null) g.progress = dp;
+    },
+    opts,
+  );
+}
+
+/** Update a key result (current value and/or done flag). */
+export function setKeyResult(id, krId, patch = {}, opts = {}) {
+  return mutate(
+    id,
+    (g) => {
+      const kr = g.keyResults.find((k) => k.id === krId);
+      if (!kr) throw new Error(`no such key result: ${krId}`);
+      if (patch.current != null) kr.current = Number(patch.current);
+      if (patch.done != null) kr.done = !!patch.done;
+      if (
+        kr.target != null &&
+        patch.current != null &&
+        Number(patch.current) >= kr.target
+      ) {
+        kr.done = true;
+      }
+      const dp = derivedProgress(g.keyResults);
+      if (dp != null) g.progress = dp;
+      g.drift.lastProgressAt = nowIso();
+    },
+    opts,
+  );
+}
+
+/**
+ * Record progress: set an explicit percentage and/or append a note.
+ * @param {object} input { pct?, note?, by? }
+ */
+export function recordProgress(id, input = {}, opts = {}) {
+  return mutate(
+    id,
+    (g) => {
+      const pct = clampPct(input.pct);
+      if (pct != null) g.progress = pct;
+      if (input.note) {
+        g.notes.push({
+          at: nowIso(),
+          text: String(input.note),
+          by: input.by === "agent" ? "agent" : "user",
+        });
+      }
+      g.drift.lastProgressAt = nowIso();
+    },
+    opts,
+  );
+}
+
+/** Attach a session id to a goal (idempotent). */
+export function linkSession(id, sessionId, opts = {}) {
+  if (!sessionId) throw new Error("linkSession requires a sessionId");
+  return mutate(
+    id,
+    (g) => {
+      if (!g.linkedSessions.includes(sessionId)) {
+        g.linkedSessions.push(sessionId);
+      }
+    },
+    opts,
+  );
+}
+
+/** Detach a session id from a goal. */
+export function unlinkSession(id, sessionId, opts = {}) {
+  return mutate(
+    id,
+    (g) => {
+      g.linkedSessions = g.linkedSessions.filter((s) => s !== sessionId);
+    },
+    opts,
+  );
+}
+
+/** Set a goal's status (active/paused/done/abandoned). */
+export function setStatus(id, status, opts = {}) {
+  if (!STATUS_VALUES.has(status)) {
+    throw new Error(
+      `invalid status "${status}" — expected one of: ${[...STATUS_VALUES].join(", ")}`,
+    );
+  }
+  return mutate(
+    id,
+    (g) => {
+      g.status = status;
+      if (status === GOAL_STATUS.DONE && g.progress < 100) g.progress = 100;
+    },
+    opts,
+  );
+}
+
+/** Delete a goal. Returns true if it existed. */
+export function deleteGoal(id, opts = {}) {
+  const root = opts.root || defaultRoot();
+  const file = goalFile(root, id);
+  if (!fs.existsSync(file)) return false;
+  fs.rmSync(file);
+  return true;
+}
+
+/**
+ * Resolve the goal that should be bound to the current run, in priority order:
+ *   1. explicit id (--goal <id>)
+ *   2. an active goal linked to the current session
+ *   3. when exactly one active goal exists, that one
+ *   4. null
+ *
+ * Only `active` goals are ever auto-resolved (steps 2–3); an explicit id is
+ * honored regardless of status so a user can re-inspect a paused goal.
+ *
+ * @param {object} [sel] { explicitId, sessionId }
+ * @param {object} [opts] { root }
+ */
+export function resolveActiveGoal(sel = {}, opts = {}) {
+  if (sel.explicitId) {
+    return getGoal(sel.explicitId, opts);
+  }
+  const active = listGoals({ ...opts, status: GOAL_STATUS.ACTIVE });
+  if (active.length === 0) return null;
+  if (sel.sessionId) {
+    const linked = active.find((g) => g.linkedSessions.includes(sel.sessionId));
+    if (linked) return linked;
+  }
+  if (active.length === 1) return active[0];
+  // Ambiguous (multiple active, none linked) — caller must pick explicitly.
+  return null;
+}

package/src/repl/agent-repl.js

@@ -92,8 +92,18 @@ async function executeTool(name, args) {
  */
 async function agentLoop(messages, options) {
   const usageEvents = [];
-  for await (const event of coreAgentLoop(messages, options)) {
-    if (event.type === "tool-executing") {
+  // The REPL runs its own auto-compaction (after each turn, with metrics +
+  // persisted compact events), so opt out of the agent loop's in-loop
+  // compaction to avoid compacting the same history twice.
+  for await (const event of coreAgentLoop(messages, {
+    autoCompact: false,
+    ...options,
+  })) {
+    if (event.type === "checkpoint") {
+      process.stdout.write(
+        chalk.gray(`  ⎌ checkpoint ${event.id} (before ${event.tool})\n`),
+      );
+    } else if (event.type === "tool-executing") {
       process.stdout.write(
         chalk.gray(
           `  [${event.tool}] ${formatToolArgs(event.tool, event.args)}\n`,
@@ -158,6 +168,9 @@ export async function startAgentRepl(options = {}) {
   const additionalDirectories = Array.isArray(options.additionalDirectories)
     ? options.additionalDirectories
     : [];
+  // Snapshot the work tree before each mutating tool (git engine) so the user
+  // can `cc checkpoint restore` to just before any tool call.
+  const autoCheckpoint = options.autoCheckpoint === true;
 
   // --fallback-model: retry a turn's LLM call once on a backup model when the
   // primary errors out (overload / network). Built once; passed into every
@@ -718,8 +731,10 @@ export async function startAgentRepl(options = {}) {
 
     if (trimmed === "/compact") {
       if (_compressor && messages.length > 3) {
-        const { messages: compacted, stats } =
-          await _compressor.compress(messages);
+        const { messages: compacted, stats } = await _compressor.compress(
+          messages,
+          { preserveToolPairs: true },
+        );
         messages.length = 0;
         messages.push(...compacted);
         recordCompressionMetric(stats, {
@@ -1521,6 +1536,23 @@ export async function startAgentRepl(options = {}) {
     try {
       process.stdout.write("\n");
       const iterationBudget = new IterationBudget({ owner: sessionId });
+      // Bind a cross-session goal (cc goal) into this run, if one resolves.
+      // Composes WITH defaultPrepareCall — never replaces it. Best-effort.
+      let prepareCall = defaultPrepareCall;
+      try {
+        const { resolveActiveGoal } = await import("../lib/goal-store.js");
+        const boundGoal = resolveActiveGoal({ sessionId });
+        if (boundGoal) {
+          const { goalPrepareCall, composePrepareCall } =
+            await import("../lib/goal-context.js");
+          prepareCall = composePrepareCall([
+            defaultPrepareCall,
+            goalPrepareCall(boundGoal),
+          ]);
+        }
+      } catch (_e) {
+        /* goal binding is best-effort — fall back to defaultPrepareCall */
+      }
       const { content: response, usageEvents } = await agentLoop(messages, {
         provider,
         model: activeModel,
@@ -1531,7 +1563,9 @@ export async function startAgentRepl(options = {}) {
         sessionId,
         cwd: process.cwd(),
         additionalDirectories,
-        prepareCall: defaultPrepareCall,
+        autoCheckpoint,
+        checkpointSession: sessionId,
+        prepareCall,
         approvalGate: _approvalGate,
         mcpClient: _bundleMcpClient || undefined,
         chatFn: _fallbackChatFn,
@@ -1613,8 +1647,10 @@ export async function startAgentRepl(options = {}) {
         _compressor.shouldAutoCompact(messages)
       ) {
         try {
-          const { messages: compacted, stats } =
-            await _compressor.compress(messages);
+          const { messages: compacted, stats } = await _compressor.compress(
+            messages,
+            { preserveToolPairs: true },
+          );
           messages.length = 0;
           messages.push(...compacted);
           recordCompressionMetric(stats, {

package/src/runtime/agent-core.js

@@ -1663,7 +1663,21 @@ export async function chatWithTools(rawMessages, options) {
   throwIfAborted(signal);
 
   if (provider === "ollama") {
-    const response = await fetch(`${baseUrl}/api/chat`, {
+    const apiUrl = `${baseUrl}/api/chat`;
+    // Real-time token deltas (Claude-Code `--include-partial-messages`): when
+    // the caller supplies an onToken hook, stream the response and forward each
+    // content chunk as it arrives. Tool calls + usage are accumulated and the
+    // same {message, usage} shape is returned, so the agent loop is unchanged.
+    // Without onToken we keep the cheaper single-shot non-streaming request.
+    if (typeof options.onToken === "function") {
+      return await _chatOllamaStreaming(
+        apiUrl,
+        { model, messages, tools },
+        options.onToken,
+        signal,
+      );
+    }
+    const response = await fetch(apiUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       signal,
@@ -1817,6 +1831,109 @@ export async function chatWithTools(rawMessages, options) {
   return out;
 }
 
+// ─── Ollama streaming (token deltas for --include-partial-messages) ─────────
+//
+// Ollama `/api/chat` with `stream:true` returns NDJSON: one JSON object per
+// line, each carrying an incremental `message.content` chunk, optional
+// `message.tool_calls` (emitted whole, not byte-streamed), and a final line
+// with `done:true` + `prompt_eval_count`/`eval_count` token totals. We reduce
+// the stream line-by-line so onToken fires live, then finalize into the same
+// {message, usage} shape the non-streaming branch returns.
+
+function _ollamaInitState() {
+  return {
+    role: "assistant",
+    content: "",
+    toolCalls: null,
+    promptEval: 0,
+    evalCount: 0,
+  };
+}
+
+function _ollamaReduceLine(state, line, onToken) {
+  const s = (line || "").trim();
+  if (!s) return state;
+  let obj;
+  try {
+    obj = JSON.parse(s);
+  } catch {
+    return state; // tolerate partial/garbage lines mid-stream
+  }
+  const msg = obj.message;
+  if (msg) {
+    if (msg.role) state.role = msg.role;
+    if (typeof msg.content === "string" && msg.content) {
+      state.content += msg.content;
+      if (typeof onToken === "function") {
+        try {
+          onToken(msg.content);
+        } catch {
+          // A failing UI hook must never break the agent run.
+        }
+      }
+    }
+    if (Array.isArray(msg.tool_calls) && msg.tool_calls.length) {
+      state.toolCalls = (state.toolCalls || []).concat(msg.tool_calls);
+    }
+  }
+  if (obj.prompt_eval_count) state.promptEval = obj.prompt_eval_count;
+  if (obj.eval_count) state.evalCount = obj.eval_count;
+  return state;
+}
+
+function _ollamaFinalize(state) {
+  const message = { role: state.role, content: state.content };
+  if (state.toolCalls && state.toolCalls.length) {
+    message.tool_calls = state.toolCalls;
+  }
+  const data = { message };
+  if (state.promptEval || state.evalCount) {
+    data.usage = {
+      input_tokens: state.promptEval,
+      output_tokens: state.evalCount,
+    };
+  }
+  return data;
+}
+
+/**
+ * Pure reducer over an iterable of Ollama NDJSON lines. Exported for tests so
+ * the parse/accumulate logic can be exercised without a live HTTP stream.
+ */
+export function _accumulateOllamaStream(lines, onToken) {
+  const state = _ollamaInitState();
+  for (const line of lines) _ollamaReduceLine(state, line, onToken);
+  return _ollamaFinalize(state);
+}
+
+async function _chatOllamaStreaming(apiUrl, body, onToken, signal) {
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    signal,
+    body: JSON.stringify({ ...body, stream: true }),
+  });
+  if (!response.ok) {
+    throw new Error(`Ollama error: ${response.status}`);
+  }
+  const state = _ollamaInitState();
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buf += decoder.decode(value, { stream: true });
+    let idx;
+    while ((idx = buf.indexOf("\n")) >= 0) {
+      _ollamaReduceLine(state, buf.slice(0, idx), onToken);
+      buf = buf.slice(idx + 1);
+    }
+  }
+  if (buf.trim()) _ollamaReduceLine(state, buf, onToken);
+  return _ollamaFinalize(state);
+}
+
 function _normalizeAnthropicResponse(data) {
   const content = data.content || [];
   const textBlocks = content.filter((b) => b.type === "text");
@@ -1843,11 +1960,58 @@ function _normalizeAnthropicResponse(data) {
 
 // ─── Agent loop (async generator) ─────────────────────────────────────────
 
+// Tools that never mutate the workspace — auto-checkpoint skips these.
+const _CHECKPOINT_READ_ONLY = new Set([
+  "read_file",
+  "search_files",
+  "list_dir",
+  "list_skills",
+  "search_sessions",
+]);
+
+let _checkpointStoreP = null;
+function _loadCheckpointStore() {
+  if (!_checkpointStoreP) {
+    _checkpointStoreP = import("../lib/checkpoint-store.js");
+  }
+  return _checkpointStoreP;
+}
+
+/**
+ * Best-effort auto-checkpoint of the working tree BEFORE a mutating tool runs,
+ * so a later `cc checkpoint restore` can roll back to just before that tool.
+ * Enabled via toolContext.autoCheckpoint; uses the git engine only (no-op
+ * outside a git work tree). Never throws — checkpointing must not block a tool.
+ *
+ * @returns {Promise<string|null>} the checkpoint id, or null when skipped
+ */
+async function _autoCheckpointBeforeTool(toolContext, toolName, toolArgs) {
+  if (!toolContext?.autoCheckpoint) return null;
+  if (_CHECKPOINT_READ_ONLY.has(toolName)) return null;
+  const cwd = toolContext.cwd || process.cwd();
+  try {
+    const store = await _loadCheckpointStore();
+    if (!store.isCheckpointAvailable(cwd)) return null;
+    const res = store.createCheckpoint(cwd, {
+      session: toolContext.checkpointSession || "agent",
+      label: `before ${toolName}: ${formatToolArgs(toolName, toolArgs)}`.slice(
+        0,
+        120,
+      ),
+      skipIfUnchanged: true,
+    });
+    return res?.id || null;
+  } catch {
+    return null; // checkpoint failure must never block the tool
+  }
+}
+
 /**
  * Async generator that drives the agentic tool-use loop.
  *
  * Yields events:
  *   { type: "slot-filling", slot, question }  — when asking user for missing info
+ *   { type: "checkpoint", id, tool }          — auto-checkpoint before a mutating tool
  *   { type: "tool-executing", tool, args }
  *   { type: "tool-result", tool, result, error }
  *   { type: "response-complete", content }
@@ -1855,6 +2019,38 @@ function _normalizeAnthropicResponse(data) {
  * @param {Array} messages - mutable messages array (will be appended to)
  * @param {object} options - provider, model, baseUrl, apiKey, contextEngine, hookDb, skillLoader, cwd, slotFiller, interaction
  */
+/**
+ * Lazily build (and cache on `options`) the PromptCompressor used for in-loop
+ * auto-compaction. Returns null when the feature is off or the module can't be
+ * loaded — callers treat that as "don't compact". Cached (including null) so we
+ * import once per run, not once per iteration.
+ */
+async function _getAutoCompactor(options) {
+  if (Object.prototype.hasOwnProperty.call(options, "_autoCompactor")) {
+    return options._autoCompactor;
+  }
+  let compressor = null;
+  try {
+    const { feature } = await import("../lib/feature-flags.js");
+    if (feature("PROMPT_COMPRESSOR")) {
+      const { PromptCompressor } =
+        await import("../harness/prompt-compressor.js");
+      compressor = new PromptCompressor({
+        model: options.model,
+        provider: options.provider,
+      });
+    }
+  } catch {
+    compressor = null;
+  }
+  try {
+    options._autoCompactor = compressor;
+  } catch {
+    // options may be frozen — fine, we just re-import next iteration
+  }
+  return compressor;
+}
+
 export async function* agentLoop(messages, options) {
   // Shared iteration budget — replaces hardcoded MAX_ITERATIONS.
   // When options.iterationBudget is provided (e.g. from parent agent),
@@ -1879,6 +2075,9 @@ export async function* agentLoop(messages, options) {
     approvalGate: options.approvalGate || null,
     shellConfirm: options.shellConfirm || null,
     additionalDirectories: options.additionalDirectories || null,
+    autoCheckpoint: options.autoCheckpoint || false,
+    checkpointSession:
+      options.checkpointSession || options.sessionId || "agent",
   };
 
   throwIfAborted(signal);
@@ -1979,6 +2178,42 @@ export async function* agentLoop(messages, options) {
       };
     }
 
+    // Headless auto-compaction (Claude-Code `--print` parity). Keeps long
+    // `-p` / `--resume` runs under the model's context window instead of
+    // growing until the provider rejects the request. Opt-out with
+    // `autoCompact: false` (the interactive REPL does this — it compacts on its
+    // own schedule). Default-on, gated by the PROMPT_COMPRESSOR flag + a size
+    // threshold inside the compressor, so it only fires for genuinely large
+    // contexts. Safe to compact here: the previous iteration always finishes
+    // its full tool_call→tool_result cycle before we loop, so `messages` has no
+    // dangling call; `preserveToolPairs` then guarantees compaction never
+    // orphans a tool result. Best-effort — a failure never aborts the run.
+    if (options.autoCompact !== false && messages.length > 4) {
+      try {
+        const compactor = await _getAutoCompactor(options);
+        if (compactor && compactor.shouldAutoCompact(messages)) {
+          const { messages: compacted, stats } = await compactor.compress(
+            messages,
+            { preserveToolPairs: true },
+          );
+          if (stats.saved > 0 && compacted.length < messages.length) {
+            messages.splice(0, messages.length, ...compacted);
+            if (typeof options.onCompaction === "function") {
+              try {
+                options.onCompaction(stats, compacted);
+              } catch {
+                // persistence is best-effort
+              }
+            }
+            yield { type: "compaction", stats, runId };
+          }
+        }
+      } catch (_e) {
+        if (isAbortError(_e) || signal?.aborted) throw _e;
+        // Compaction is best-effort — proceed with the uncompacted messages.
+      }
+    }
+
     // Turn-scoped context injection (open-agents prepareCall parity).
     // prepareCall runs fresh each iteration and returns an ephemeral
     // system-message supplement that is NOT persisted to messages history.
@@ -2050,6 +2285,15 @@ export async function* agentLoop(messages, options) {
         toolArgs = {};
       }
 
+      // Auto-checkpoint the work tree before a mutating tool (opt-in), so the
+      // user can `cc checkpoint restore` back to just before this call.
+      const cpId = await _autoCheckpointBeforeTool(
+        toolContext,
+        toolName,
+        toolArgs,
+      );
+      if (cpId) yield { type: "checkpoint", id: cpId, tool: toolName };
+
       yield { type: "tool-executing", tool: toolName, args: toolArgs };
 
       let toolResult;