chainlesschain 0.166.106 → 0.166.108

package/src/lib/plugin-runtime/manifest.js

@@ -27,6 +27,7 @@
 import fs from "fs";
 import path from "path";
 import semver from "semver";
+import { normalizeGoalExtension } from "./goal-extension-contract.js";
 import {
   normalizeCapabilities,
   normalizeOptionsSchema,
@@ -89,6 +90,8 @@ export function parsePluginManifest(root) {
     // actual audit) from a legacy one that declared nothing (unrestricted).
     capabilities: normalizeCapabilities(null),
     capabilitiesDeclared: false,
+    goalExtensionDeclared: false,
+    goalExtension: null,
     optionsSchema: {},
     errors,
     warnings,
@@ -219,6 +222,15 @@ export function parsePluginManifest(root) {
   result.capabilities = normalizeCapabilities(manifest.permissions);
   result.capabilitiesDeclared = Boolean(hasPermissions);
   result.optionsSchema = normalizeOptionsSchema(manifest.optionsSchema);
+  result.goalExtensionDeclared = Object.hasOwn(manifest, "goalExtension");
+  try {
+    result.goalExtension = normalizeGoalExtension(
+      manifest.goalExtension,
+      manifest.permissions,
+    );
+  } catch (err) {
+    errors.push(err.message);
+  }
   // Declared-vs-actual audit runs ONLY when a permissions block is present — a
   // legacy plugin that declares nothing is unrestricted by design, so it never
   // gets these warnings (keeps existing manifests warning-free).

package/src/lib/plugin-runtime/policy.js

@@ -45,6 +45,7 @@ export function loadManagedPluginPolicy(opts = {}) {
   const key = String(
     opts.managedSettingsFile || env.CC_MANAGED_SETTINGS || "<default>",
   );
+  if (opts.fresh === true) _cache.delete(key);
   if (_cache.has(key)) {
     const cached = _cache.get(key);
     // A cached failure sentinel must re-throw on EVERY call — otherwise the

package/src/lib/project-goal-connection.js

@@ -0,0 +1,225 @@
+/** Explicit short-lived desktop connection. No DB path or client-supplied actor. */
+import fs from "node:fs";
+import path from "node:path";
+import http from "node:http";
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { inspectPrivatePath } from "@chainlesschain/session-core/private-storage";
+import { goalExtensionRef } from "@chainlesschain/session-core/goal-extension-proposal-contract";
+import { validateGoalEvidenceProjection } from "@chainlesschain/session-core/goal-evidence-contract";
+import { validateGoalDraftDescriptor } from "@chainlesschain/session-core/goal-draft-connection-contract";
+import { createProjectGoalDraftClient } from "./project-goal-draft-connection.js";
+function fail() {
+  throw new Error("CLI_GOAL_CONNECTION_UNAVAILABLE");
+}
+const sameFile = (a, b) =>
+  a.dev === b.dev &&
+  a.ino === b.ino &&
+  a.size === b.size &&
+  a.mtimeMs === b.mtimeMs &&
+  a.ctimeMs === b.ctimeMs;
+export function createProjectGoalConnection(file) {
+  let fd;
+  try {
+    if (
+      typeof file !== "string" ||
+      !file ||
+      file.length > 4096 ||
+      /[\u0000-\u001f]/u.test(file)
+    )
+      fail();
+    const target = path.resolve(file);
+    const before = fs.lstatSync(target);
+    if (
+      !before.isFile() ||
+      before.isSymbolicLink() ||
+      before.nlink !== 1 ||
+      before.size > 4096 ||
+      !inspectPrivatePath(target).ok
+    )
+      fail();
+    fd = fs.openSync(
+      target,
+      fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0),
+    );
+    const opened = fs.fstatSync(fd);
+    if (!sameFile(before, opened)) fail();
+    const raw = Buffer.alloc(4097);
+    const count = fs.readSync(fd, raw, 0, raw.length, 0);
+    if (count > 4096 || !sameFile(opened, fs.fstatSync(fd))) fail();
+    const descriptor = JSON.parse(raw.subarray(0, count).toString("utf8"));
+    if (descriptor.schema === "chainlesschain.project-goal-connection/v3") {
+      const verified = validateGoalDraftDescriptor(descriptor);
+      return createProjectGoalDraftClient(verified, () => {
+        if (
+          Date.now() >= verified.expiresAt ||
+          !sameFile(opened, fs.lstatSync(target))
+        )
+          fail();
+      });
+    }
+    const evidence =
+      descriptor.schema === "chainlesschain.project-goal-connection/v2";
+    const endpointPath = evidence ? "/goal-evidence" : "/goal-summary";
+    if (
+      Object.keys(descriptor).sort().join() !==
+        (evidence
+          ? "capability,endpoint,expiresAt,goalRef,key,schema"
+          : "endpoint,expiresAt,goalRef,key,schema") ||
+      (evidence
+        ? descriptor.capability !== "goal.evidence"
+        : descriptor.schema !== "chainlesschain.project-goal-connection/v1") ||
+      typeof descriptor.endpoint !== "string" ||
+      !/^http:\/\/127\.0\.0\.1:[1-9][0-9]{0,4}\/goal-(?:summary|evidence)$/.test(
+        descriptor.endpoint,
+      ) ||
+      new URL(descriptor.endpoint).pathname !== endpointPath ||
+      Number(new URL(descriptor.endpoint).port) > 65535 ||
+      typeof descriptor.key !== "string" ||
+      !/^[a-f0-9]{64}$/.test(descriptor.key) ||
+      !Number.isSafeInteger(descriptor.expiresAt) ||
+      descriptor.expiresAt <= Date.now() ||
+      descriptor.expiresAt > Date.now() + 15 * 60 * 1000 + 5000
+    )
+      fail();
+    const ref = goalExtensionRef(descriptor.goalRef);
+    function validate() {
+      if (
+        Date.now() >= descriptor.expiresAt ||
+        !sameFile(opened, fs.lstatSync(target))
+      )
+        fail();
+    }
+    const mac = (value) =>
+      createHmac("sha256", Buffer.from(descriptor.key, "hex"))
+        .update(value)
+        .digest("hex");
+    async function read(id = ref.id) {
+      validate();
+      if (id !== ref.id) fail();
+      const nonce = randomBytes(32).toString("hex");
+      try {
+        const result = await new Promise((resolve, reject) => {
+          const request = http.get(
+            descriptor.endpoint,
+            {
+              agent: false,
+              maxHeaderSize: 4096,
+              headers: {
+                "X-CC-Nonce": nonce,
+                "X-CC-Signature": mac(
+                  `request\nGET\n${endpointPath}\n${nonce}`,
+                ),
+              },
+            },
+            (response) => {
+              const chunks = [];
+              let bytes = 0;
+              response.on("error", reject);
+              response.on("data", (chunk) => {
+                bytes += chunk.length;
+                if (bytes > 16 * 1024) response.destroy(new Error("limit"));
+                else chunks.push(chunk);
+              });
+              response.on("end", () => {
+                const body = Buffer.concat(chunks).toString("utf8"),
+                  signature = response.headers["x-cc-signature"];
+                if (
+                  response.statusCode !== 200 ||
+                  typeof signature !== "string" ||
+                  !/^[a-f0-9]{64}$/.test(signature) ||
+                  !timingSafeEqual(
+                    Buffer.from(signature),
+                    Buffer.from(mac(`response\n${nonce}\n${body}`)),
+                  )
+                ) {
+                  reject(new Error("signature"));
+                  return;
+                }
+                try {
+                  resolve(JSON.parse(body));
+                } catch {
+                  reject(new Error("json"));
+                }
+              });
+            },
+          );
+          request.setTimeout(5000, () => request.destroy(new Error("timeout")));
+          const deadline = setTimeout(
+            () => request.destroy(new Error("timeout")),
+            5000,
+          );
+          request.once("close", () => clearTimeout(deadline));
+          request.on("error", reject);
+        });
+        validate();
+        if (
+          Object.keys(result).sort().join() !==
+            (evidence
+              ? "goalRef,objective,receipts,risk,schema,status"
+              : "goalRef,objective,schema,status") ||
+          result.schema !==
+            (evidence
+              ? "chainlesschain.project-goal-evidence/v1"
+              : "chainlesschain.project-goal-summary/v1") ||
+          JSON.stringify(goalExtensionRef(result.goalRef)) !==
+            JSON.stringify(ref) ||
+          typeof result.objective !== "string" ||
+          result.objective.length > 4096 ||
+          result.status !== "active"
+        )
+          fail();
+        if (evidence)
+          validateGoalEvidenceProjection({
+            risk: result.risk,
+            receipts: result.receipts,
+          });
+        return { ...result, goalRef: ref };
+      } catch {
+        fail();
+      }
+    }
+    validate();
+    return Object.freeze({ goalRef: ref, evidence, read });
+  } catch {
+    fail();
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}
+
+export async function readProjectGoalCatalog(options = {}) {
+  if (
+    options.after !== undefined ||
+    !Number.isSafeInteger(options.limit ?? 20) ||
+    (options.limit ?? 20) < 1 ||
+    (options.limit ?? 20) > 20
+  )
+    fail();
+  const source = createProjectGoalConnection(options.connection);
+  const goal = await source.read();
+  return {
+    schema: "chainlesschain.goal-catalog.v1",
+    source: "desktop-project",
+    snapshot: true,
+    storeId: source.goalRef.storeId,
+    observedAt: new Date().toISOString(),
+    entries: [
+      {
+        id: source.goalRef.id,
+        title: goal.objective
+          .replace(
+            /[\u0000-\u001f\u007f-\u009f\u200e\u200f\u202a-\u202e\u2066-\u2069]/gu,
+            " ",
+          )
+          .slice(0, 160),
+        status: goal.status,
+        revision: source.goalRef.revision,
+        controlGeneration: source.goalRef.controlGeneration,
+      },
+    ],
+    scannedCount: 1,
+    skippedCount: 0,
+    invalidNameCount: 0,
+    nextCursor: null,
+  };
+}

package/src/lib/project-goal-draft-connection.js

@@ -0,0 +1,217 @@
+import http from "node:http";
+import {
+  createHash,
+  createHmac,
+  randomBytes,
+  timingSafeEqual,
+} from "node:crypto";
+import { digestBusinessObjectContent as digest } from "@chainlesschain/session-core/business-object-contract";
+import {
+  validateGoalDraftSources,
+  validateGoalDraftReceipt,
+  validateGoalDraftProposal,
+} from "@chainlesschain/session-core/goal-draft-connection-contract";
+function unavailable() {
+  return new Error("CLI_GOAL_CONNECTION_UNAVAILABLE");
+}
+function exact(raw, keys) {
+  if (
+    !raw ||
+    typeof raw !== "object" ||
+    Array.isArray(raw) ||
+    Object.keys(raw).length !== keys.length ||
+    keys.some((key) => !Object.hasOwn(raw, key))
+  )
+    throw unavailable();
+}
+/** Constructed only after the shared private-file reader verifies the descriptor. */
+export function createProjectGoalDraftClient(descriptor, validate) {
+  const ref = Object.freeze({ ...descriptor.goalRef }),
+    grant = Object.freeze({
+      id: descriptor.grantRef.id,
+      epoch: descriptor.grantRef.epoch,
+      plugin: Object.freeze({ ...descriptor.plugin }),
+      declarationDigest: descriptor.declarationDigest,
+    });
+  const mac = (text) =>
+    createHmac("sha256", Buffer.from(descriptor.key, "hex"))
+      .update(text)
+      .digest("hex");
+  async function exchange(method, payload, writing = false) {
+    validate();
+    const bytes =
+      payload === undefined
+        ? Buffer.alloc(0)
+        : Buffer.from(JSON.stringify(payload));
+    if (bytes.length > 16384) throw unavailable();
+    const nonce = randomBytes(32).toString("hex"),
+      bodyHash = createHash("sha256").update(bytes).digest("hex");
+    let sent = false;
+    try {
+      const result = await new Promise((resolve, reject) => {
+        const request = http.request(
+          descriptor.endpoint,
+          {
+            method,
+            agent: false,
+            maxHeaderSize: 4096,
+            headers: {
+              "X-CC-Nonce": nonce,
+              "X-CC-Signature": mac(
+                `request-v3\n${method}\n/goal-drafts\n${nonce}\n${bodyHash}`,
+              ),
+              ...(method === "POST"
+                ? {
+                    "Content-Type": "application/json",
+                    "Content-Length": bytes.length,
+                  }
+                : {}),
+            },
+          },
+          (response) => {
+            const chunks = [];
+            let size = 0;
+            response.on("error", reject);
+            response.on("data", (chunk) => {
+              size += chunk.length;
+              if (size > 16384) response.destroy(unavailable());
+              else chunks.push(chunk);
+            });
+            response.on("end", () => {
+              try {
+                const text = new TextDecoder("utf-8", { fatal: true }).decode(
+                    Buffer.concat(chunks),
+                  ),
+                  signature = response.headers["x-cc-signature"];
+                if (
+                  typeof signature !== "string" ||
+                  !/^[a-f0-9]{64}$/u.test(signature) ||
+                  !timingSafeEqual(
+                    Buffer.from(signature),
+                    Buffer.from(
+                      mac(
+                        `response-v3\n${nonce}\n${response.statusCode}\n${text}`,
+                      ),
+                    ),
+                  )
+                )
+                  throw unavailable();
+                if (response.statusCode !== 200) throw unavailable();
+                resolve(JSON.parse(text));
+              } catch (error) {
+                reject(error);
+              }
+            });
+          },
+        );
+        const timer = setTimeout(() => request.destroy(unavailable()), 5000);
+        request.once("close", () => clearTimeout(timer));
+        request.on("error", reject);
+        request.setTimeout(5000, () => request.destroy(unavailable()));
+        sent = writing;
+        request.end(bytes);
+      });
+      validate();
+      if (digest(result.goalRef) !== digest(ref)) throw unavailable();
+      return result;
+    } catch {
+      const error = unavailable();
+      if (sent) {
+        error.code = "CLI_GOAL_DRAFT_OUTCOME_UNKNOWN";
+        error.outcomeUnknown = true;
+      }
+      throw error;
+    }
+  }
+  async function read(id = ref.id) {
+    if (id !== ref.id) throw unavailable();
+    const result = await exchange("GET");
+    exact(result, [
+      "schema",
+      "goalRef",
+      "objective",
+      "status",
+      "grant",
+      "sources",
+    ]);
+    if (
+      result.schema !== "chainlesschain.project-goal-drafts/v1" ||
+      typeof result.objective !== "string" ||
+      result.objective.length > 4096 ||
+      result.status !== "active" ||
+      digest(result.grant) !== digest(grant)
+    )
+      throw unavailable();
+    validateGoalDraftSources(result.sources);
+    return { ...result, goalRef: ref };
+  }
+  async function sources(afterId) {
+    const result = await exchange("POST", {
+      operation: "sources",
+      ...(afterId !== undefined ? { afterId } : {}),
+    });
+    exact(result, ["schema", "goalRef", "sources"]);
+    if (result.schema !== "chainlesschain.goal-draft-sources/v1")
+      throw unavailable();
+    return validateGoalDraftSources(result.sources);
+  }
+  async function receipt({ requestId, inputDigest }) {
+    const result = await exchange("POST", {
+      operation: "receipt",
+      requestId,
+      inputDigest,
+    });
+    exact(result, ["schema", "goalRef", "receipt"]);
+    if (result.schema !== "chainlesschain.goal-draft-receipt/v1")
+      throw unavailable();
+    const value = validateGoalDraftReceipt(result.receipt);
+    if (value.requestId !== requestId || value.inputDigest !== inputDigest)
+      throw unavailable();
+    return value;
+  }
+  async function enqueue(raw) {
+    const proposal = validateGoalDraftProposal(raw),
+      inputDigest = digest(proposal);
+    let received = false;
+    try {
+      const result = await exchange(
+        "POST",
+        { operation: "enqueue", proposal },
+        true,
+      );
+      received = true;
+      exact(result, ["schema", "goalRef", "receipt"]);
+      if (result.schema !== "chainlesschain.goal-draft-submit/v1")
+        throw unavailable();
+      const value = validateGoalDraftReceipt(result.receipt);
+      if (
+        value.state !== "saved" ||
+        value.requestId !== proposal.requestId ||
+        value.inputDigest !== inputDigest
+      )
+        throw unavailable();
+      return value;
+    } catch (error) {
+      // Once HTTP may have dispatched, an invalid/absent response is not proof
+      // that no native draft was saved. Preserve this exact request identity.
+      if (received || error.outcomeUnknown) {
+        error.code = "CLI_GOAL_DRAFT_OUTCOME_UNKNOWN";
+        error.outcomeUnknown = true;
+      }
+      throw error;
+    }
+  }
+  validate();
+  return Object.freeze({
+    goalRef: ref,
+    evidence: false,
+    drafts: true,
+    plugin: grant.plugin,
+    declarationDigest: grant.declarationDigest,
+    grantRef: Object.freeze({ ...descriptor.grantRef }),
+    read,
+    sources,
+    enqueue,
+    receipt,
+  });
+}

package/src/lib/read-file-loop-guard.js

@@ -32,6 +32,79 @@ export class ReadFileLoopGuard {
     this.batch = null;
     this.largeOutputs = new Set();
     this.editRecoveryReads = new Map();
+    this.visiblePages = null;
+    this.visibleRequest = 0;
+  }
+
+  /** Observe only the request actually selected for the provider, not history. */
+  observeVisibleMessages(messages) {
+    this.visibleRequest++;
+    this.visiblePages = [];
+    const retain = (value) => {
+      if (
+        typeof value?.path !== "string" ||
+        typeof value.fileVersion !== "string"
+      )
+        return;
+      if (typeof value.content === "string" && !value.contentOmitted) {
+        this.visiblePages.push(value);
+      }
+      for (const excerpt of Array.isArray(value.excerpts)
+        ? value.excerpts
+        : []) {
+        if (typeof excerpt?.content === "string")
+          this.visiblePages.push({
+            ...excerpt,
+            path: value.path,
+            fileVersion: value.fileVersion,
+          });
+      }
+    };
+    const retainContext = (context) => {
+      if (
+        typeof context !== "string" ||
+        !context.startsWith("[File excerpts retained across compaction")
+      )
+        return;
+      try {
+        const entries = JSON.parse(context.slice(context.indexOf("\n") + 1));
+        if (Array.isArray(entries)) entries.forEach(retain);
+      } catch {
+        /* A truncated hint provides no confirmed source evidence. */
+      }
+    };
+    for (const message of messages || []) {
+      if (message.role === "assistant") retainContext(message.content);
+      if (message.role !== "tool") continue;
+      let value;
+      try {
+        value =
+          typeof message.content === "string"
+            ? JSON.parse(message.content.split("\n\n[Budget ")[0])
+            : message.content;
+      } catch {
+        continue;
+      }
+      retain(value);
+      for (const context of Array.isArray(value?.retainedReadContext)
+        ? value.retainedReadContext
+        : []) {
+        retainContext(context);
+      }
+    }
+  }
+
+  isPageVisible(page) {
+    return (
+      this.visiblePages?.some(
+        (visible) =>
+          keyFor(visible.path, {}) === keyFor(page.path, {}) &&
+          visible.fileVersion === page.fileVersion &&
+          typeof page.content === "string" &&
+          page.content.length > 0 &&
+          visible.content.includes(page.content),
+      ) === true
+    );
   }
 
   recordEditRecovery(result) {
@@ -94,6 +167,7 @@ export class ReadFileLoopGuard {
         rereads: new Set(),
         summary: null,
         excerpts: [],
+        contextRestoreOffered: false,
       };
     }
     let page = readPage(args);
@@ -108,11 +182,11 @@ export class ReadFileLoopGuard {
         readProgress: { newContent: false },
       };
     }
-    const span = page.readSpan;
+    let span = page.readSpan;
     const covered = entry.spans.some(
       ([start, end]) => start <= span.start && end >= span.end,
     );
-    const targeted =
+    let targeted =
       Number(args.offset) > 0 &&
       Number(args.limit) > 0 &&
       Number(args.limit) <= 200 &&
@@ -122,20 +196,52 @@ export class ReadFileLoopGuard {
     );
     let newContent = !covered;
     const hadOutline = !!entry.summary?.outline;
+    // A planner can evict a read without compacting the transcript. Give one
+    // bounded landing page for that version, then require explicit ranges.
+    // Dropping the same evidence repeatedly must not reopen full-file scans.
+    if (
+      covered &&
+      entry.summary?.reachedEnd === true &&
+      !targeted &&
+      this.visiblePages !== null &&
+      entry.lastReadRequest < this.visibleRequest &&
+      !this.isPageVisible(page) &&
+      !entry.contextRestoreOffered &&
+      entry.rereads.size < 3
+    ) {
+      const offset =
+        Number.isSafeInteger(Number(args.offset)) && Number(args.offset) > 0
+          ? Number(args.offset)
+          : 1;
+      const bounded = readPage({ ...args, offset, limit: 80 });
+      if (!bounded.error && bounded.readSpan && !this.isPageVisible(bounded)) {
+        page = bounded;
+        span = page.readSpan;
+        targeted = true;
+        entry.contextRestoreOffered = true;
+      }
+    }
     if (covered || (coveredPrefix && !targeted)) {
       // Permit a bounded, explicit reread for editing or lost context. Broad
       // rescans and subsequent repeats recover automatically, including when
       // the model varies offset/limit inside an already covered region.
-      const fingerprint = createHash("sha256")
-        .update(JSON.stringify(span))
-        .digest("hex");
+      const restoring =
+        this.visiblePages !== null &&
+        entry.lastReadRequest < this.visibleRequest &&
+        !this.isPageVisible(page);
+      const fingerprint =
+        (restoring ? "restore:" : "review:") +
+        createHash("sha256").update(JSON.stringify(span)).digest("hex");
       if (
         targeted &&
         !entry.rereads.has(fingerprint) &&
         entry.rereads.size < 3
       ) {
         entry.rereads.add(fingerprint);
-        page.readRecovery = { action: "targeted-review" };
+        page.readRecovery = {
+          action: restoring ? "context-restore" : "targeted-review",
+        };
+        if (restoring) page.readRecovery.fileVersion = fileVersion;
       } else {
         const unread = entry.spans[0]?.[0] === 0 ? entry.spans[0][1] : 0;
         if (unread < span.total) {
@@ -162,12 +268,20 @@ export class ReadFileLoopGuard {
             ...(entry.summary?.outline
               ? { outline: entry.summary.outline }
               : {}),
-            hint: "The entire unchanged file has already been read during this run. Do not restart the scan. Use the retained outline/findings to perform the user's task; use search_files and a small explicit offset/limit only for missing details. Reading the file is not task completion.",
+            recoveryRead: {
+              path: filePath,
+              offset: 1,
+              limit: 80,
+              ...(args.hashed === true ? { hashed: true } : {}),
+              ...(args.raw === true ? { raw: true } : {}),
+            },
+            hint: "The unchanged file was read earlier, but historical coverage does not mean its source is visible now. Use any source excerpts actually present in this request. For missing details, use search_files or read_file with a specific offset and limit (at most 80 lines); recoveryRead is a bounded starting range, not permission to restart a full scan. Reading the file is not task completion.",
           };
         }
       }
     }
     entry.spans = mergeSpan(entry.spans, page.readSpan);
+    entry.lastReadRequest = this.visibleRequest;
     // Coverage alone cannot restore source code after compaction. Keep bounded
     // observed pages for every file type, not only large Markdown outlines.
     // Label truncation explicitly; a retained prefix is not the whole range.
@@ -232,6 +346,8 @@ export class ReadFileLoopGuard {
     if (tool === "read_file") {
       if (result?.readRecovery?.action === "edit-anchor-refresh")
         this.batch.advanced = true;
+      if (result?.readRecovery?.action === "context-restore")
+        this.batch.advanced = true;
       if (result?.readProgress?.newContent === true) this.batch.advanced = true;
       if (result?.readProgress?.newContent === false) this.batch.duplicates++;
     } else if (
@@ -308,7 +424,7 @@ export class ReadFileLoopGuard {
 
   get recoveryHint() {
     return this.repeatedBatches >= 1
-      ? "Repeated file reads or identical large command outputs detected. Do not switch to run_code/run_shell to dump the same file again. Filter/count locally and print only relevant rows, totals and source line numbers, or use a focused search. The runtime continues unfinished read_file scans automatically and returns use-findings after EOF. Use the retained outline to perform the user's task. Do not restart a whole-file scan after context compaction; answer once the requested evidence is sufficient."
+      ? "Repeated file reads or identical large command outputs detected. Do not switch to run_code/run_shell to dump the same file again. Filter/count locally and print only relevant rows, totals and source line numbers, or use a focused search. The runtime continues unfinished read_file scans automatically and returns use-findings after EOF. Use source evidence actually visible in this request; recover missing details with a specific offset and limit of at most 80 lines. Do not restart a whole-file scan after context compaction; answer once the requested evidence is sufficient."
       : null;
   }
 

package/src/lib/session-host-snapshot.js

@@ -27,6 +27,7 @@ import {
   sanitizePersistedMessages,
 } from "./session-message-provenance.js";
 import { createSessionTranscriptStructureProjection } from "./session-transcript-structure.js";
+import { projectToolRoundMessages } from "./session-tool-round.js";
 import { normalizeSessionBudgetRootConfig } from "./session-budget-production-root.js";
 import {
   createDeferredQuestionEventReducer,
@@ -86,6 +87,8 @@ function replayMessagesFromVerifiedEvents(events) {
       isReplayableMessage(event.data)
     ) {
       suffix.push(event.data);
+    } else if (event?.type === "tool_round") {
+      suffix.push(...projectToolRoundMessages(event).toReversed());
     } else if (event?.type === "ws_turn") {
       const turn = projectWsTurnMessages(event);
       if (turn) suffix.push(turn.assistant, turn.user);