@skein-code/cli 0.3.10 → 0.3.11

package/dist/cli.js

@@ -4,7 +4,7 @@
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename12, resolve as resolve22 } from "node:path";
+import { basename as basename12, resolve as resolve23 } from "node:path";
 import { Command, Option } from "commander";
 import chalk4 from "chalk";
 
@@ -220,7 +220,7 @@ function isSqliteBusy(error) {
 // package.json
 var package_default = {
   name: "@skein-code/cli",
-  version: "0.3.10",
+  version: "0.3.11",
   description: "A context-first, model-agnostic coding agent with an auditable terminal workspace.",
   type: "module",
   license: "MIT",
@@ -236,9 +236,9 @@ var package_default = {
   },
   skein: {
     releaseNotes: [
-      "Complex executable requests now use a durable Task Contract with evidence-bound acceptance criteria",
-      "Completion stays unverified while required acceptance or final verification remains unresolved",
-      "Structured tool failure receipts add concise repair hints, retry budgets, cancellation handling, and identical-call circuit breaking"
+      "Large tool results now use a language-aware dynamic token budget with status-preserving head and tail receipts",
+      "Complete captured output can be read back through redacted, expiring, session-scoped local artifacts",
+      "Shell and MCP source truncation is explicit, and session deletion removes retained output"
     ]
   },
   bin: {
@@ -990,16 +990,16 @@ async function hashRegularFile(path) {
   try {
     const info = await handle.stat();
     if (!info.isFile()) throw new Error(`Namespace entry is not a regular file: ${path}`);
-    const hash = createHash2("sha256");
+    const hash2 = createHash2("sha256");
     const buffer = Buffer.allocUnsafe(64 * 1024);
     let position = 0;
     while (true) {
       const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
       if (!bytesRead) break;
-      hash.update(buffer.subarray(0, bytesRead));
+      hash2.update(buffer.subarray(0, bytesRead));
       position += bytesRead;
     }
-    return { sha256: hash.digest("hex"), size: position };
+    return { sha256: hash2.digest("hex"), size: position };
   } finally {
     await handle.close();
   }
@@ -1200,18 +1200,18 @@ var MemoryStore = class {
       input2.lastVerifiedAt ?? (explicit ? now : void 0),
       "Memory verification time"
     );
-    const hash = createHash3("sha256").update(`${input2.scope}\0${scopeKey2}\0${content.toLocaleLowerCase()}`).digest("hex");
+    const hash2 = createHash3("sha256").update(`${input2.scope}\0${scopeKey2}\0${content.toLocaleLowerCase()}`).digest("hex");
     database.exec("BEGIN IMMEDIATE");
     try {
       const existing = database.prepare(
         "SELECT * FROM memories WHERE content_hash = ?"
-      ).get(hash);
+      ).get(hash2);
       const conflicting = conflictKey ? database.prepare(`
           SELECT * FROM memories
           WHERE scope = ? AND scope_key = ? AND conflict_key = ?
             AND status = 'active' AND content_hash <> ?
           ORDER BY updated_at DESC
-        `).all(input2.scope, scopeKey2, conflictKey, hash) : [];
+        `).all(input2.scope, scopeKey2, conflictKey, hash2) : [];
       const supersedesId = normalizeOptional(input2.supersedesId, 80) ?? conflicting[0]?.id;
       let id;
       if (existing) {
@@ -1256,7 +1256,7 @@ var MemoryStore = class {
           importance,
           confidence,
           source,
-          hash,
+          hash2,
           now,
           now,
           now,
@@ -1359,10 +1359,10 @@ var MemoryStore = class {
     const conflictKey = normalizeOptional(input2.conflictKey, 240);
     const candidateDefaultExpiry = !input2.expiresAt ? new Date(Date.now() + MEMORY_CANDIDATE_TTL_MS).toISOString() : void 0;
     const expiresAt = normalizeTimestamp(input2.expiresAt ?? candidateDefaultExpiry, "Memory expiration");
-    const hash = createHash3("sha256").update(`${input2.scope}\0${scopeKey2}\0${content.toLocaleLowerCase()}`).digest("hex");
+    const hash2 = createHash3("sha256").update(`${input2.scope}\0${scopeKey2}\0${content.toLocaleLowerCase()}`).digest("hex");
     const existing = database.prepare(
       "SELECT * FROM memory_candidates WHERE content_hash = ?"
-    ).get(hash);
+    ).get(hash2);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (existing) {
       if (existing.status === "approved" && existing.approved_memory_id) {
@@ -1409,7 +1409,7 @@ var MemoryStore = class {
       confidence,
       source,
       rationale,
-      hash,
+      hash2,
       now,
       now,
       revision ?? null,
@@ -4755,7 +4755,7 @@ function executableNames(command2) {
   return [command2, ...extensions.map((extension) => `${command2}${extension}`)];
 }
 function runProcess(command2, args, options) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     const started = Date.now();
     const environment = options.inheritEnv === false ? {} : { ...process.env };
     for (const name of options.unsetEnv ?? []) delete environment[name];
@@ -4776,6 +4776,8 @@ function runProcess(command2, args, options) {
     let stderr = "";
     let stdoutBytes = 0;
     let stderrBytes = 0;
+    let stdoutObservedBytes = 0;
+    let stderrObservedBytes = 0;
     let timedOut = false;
     let callbackError;
     const stdoutDecoder = new StringDecoder("utf8");
@@ -4798,12 +4800,14 @@ function runProcess(command2, args, options) {
       }
     };
     child.stdout.on("data", (chunk) => {
+      stdoutObservedBytes += chunk.length;
       const appended = append(stdoutDecoder, chunk, stdoutBytes);
       stdout += appended.text;
       stdoutBytes = appended.usedBytes;
       notify(options.onStdout, stdoutCallbackDecoder, chunk);
     });
     child.stderr.on("data", (chunk) => {
+      stderrObservedBytes += chunk.length;
       const appended = append(stderrDecoder, chunk, stderrBytes);
       stderr += appended.text;
       stderrBytes = appended.usedBytes;
@@ -4834,13 +4838,17 @@ function runProcess(command2, args, options) {
         reject(callbackError);
         return;
       }
-      resolve23({
+      resolve24({
         command: [command2, ...args].join(" "),
         exitCode: code ?? (timedOut ? 124 : 1),
         stdout,
         stderr,
         timedOut,
-        durationMs: Date.now() - started
+        durationMs: Date.now() - started,
+        stdoutBytes: stdoutObservedBytes,
+        stderrBytes: stderrObservedBytes,
+        stdoutTruncated: stdoutObservedBytes > stdoutBytes,
+        stderrTruncated: stderrObservedBytes > stderrBytes
       });
     });
     if (options.stdin) child.stdin.end(options.stdin);
@@ -4961,6 +4969,14 @@ var contextSourceSchema = z5.object({
   tokens: z5.number().int().nonnegative(),
   addedAt: z5.string()
 }).strict();
+var toolArtifactSchema = z5.object({
+  toolCallId: z5.string().min(1).max(512).refine((value) => !/[\u0000-\u001f\u007f-\u009f]/u.test(value)),
+  sha256: z5.string().regex(/^[a-f0-9]{64}$/u),
+  bytes: z5.number().int().nonnegative().max(5 * 1024 * 1024),
+  createdAt: z5.string().datetime(),
+  expiresAt: z5.string().datetime(),
+  redacted: z5.boolean()
+}).strict();
 var verificationEvidenceSchema = z5.object({
   toolCallId: z5.string(),
   tool: z5.enum(["shell", "git"]),
@@ -5037,6 +5053,7 @@ var sessionSchema = z5.object({
   compactedThroughMessageId: z5.string().optional(),
   workingMemory: workingMemorySchema.optional(),
   contextSources: z5.array(contextSourceSchema).max(64).optional(),
+  toolArtifacts: z5.array(toolArtifactSchema).max(200).optional(),
   taskContract: taskContractSchema.optional(),
   lastRun: lastRunSchema.optional(),
   usage: z5.object({
@@ -5298,13 +5315,390 @@ async function exists2(path) {
   }
 }
 
+// src/session/tool-artifacts.ts
+import { createHash as createHash7 } from "node:crypto";
+import { lstat as lstat12, readFile as readFile7, readdir as readdir4, rm as rm2 } from "node:fs/promises";
+import { join as join11, resolve as resolve13 } from "node:path";
+import { z as z6 } from "zod";
+var MAX_ARTIFACT_BYTES = 5 * 1024 * 1024;
+var MAX_TOTAL_BYTES = 20 * 1024 * 1024;
+var RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var sessionIdSchema2 = z6.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/);
+var toolCallIdSchema = z6.string().min(1).max(512).refine((value) => !/[\u0000-\u001f\u007f-\u009f]/u.test(value), {
+  message: "Tool call id cannot contain control characters."
+});
+var artifactSchema = z6.object({
+  version: z6.literal(1),
+  sessionId: sessionIdSchema2,
+  toolCallId: toolCallIdSchema,
+  sha256: z6.string().regex(/^[a-f0-9]{64}$/u),
+  bytes: z6.number().int().nonnegative().max(MAX_ARTIFACT_BYTES),
+  createdAt: z6.string().datetime(),
+  expiresAt: z6.string().datetime(),
+  redacted: z6.boolean(),
+  content: z6.string()
+}).strict();
+var ToolArtifactStore = class {
+  workspace;
+  directory;
+  managedDirectory;
+  now;
+  maxArtifactBytes;
+  maxTotalBytes;
+  retentionMs;
+  writes = Promise.resolve();
+  constructor(workspace, options = {}) {
+    this.workspace = resolve13(workspace);
+    this.managedDirectory = options.directory === void 0;
+    this.directory = options.directory ? resolve13(options.directory) : join11(resolveProjectNamespaceSync(this.workspace).active, "tool-artifacts");
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.maxArtifactBytes = options.maxArtifactBytes ?? MAX_ARTIFACT_BYTES;
+    this.maxTotalBytes = options.maxTotalBytes ?? MAX_TOTAL_BYTES;
+    this.retentionMs = options.retentionMs ?? RETENTION_MS;
+    if (!Number.isSafeInteger(this.maxArtifactBytes) || this.maxArtifactBytes < 1 || this.maxArtifactBytes > MAX_ARTIFACT_BYTES) {
+      throw new Error(`maxArtifactBytes must be between 1 and ${MAX_ARTIFACT_BYTES}.`);
+    }
+    if (!Number.isSafeInteger(this.maxTotalBytes) || this.maxTotalBytes < this.maxArtifactBytes) {
+      throw new Error("maxTotalBytes must be at least maxArtifactBytes.");
+    }
+    if (!Number.isSafeInteger(this.retentionMs) || this.retentionMs < 1) {
+      throw new Error("retentionMs must be a positive integer.");
+    }
+  }
+  async archive(sessionId, toolCallId, content, options) {
+    sessionIdSchema2.parse(sessionId);
+    toolCallIdSchema.parse(toolCallId);
+    const bytes = Buffer.byteLength(content);
+    if (bytes > this.maxArtifactBytes) return { stored: false, reason: "too_large" };
+    return this.enqueue(() => this.withManagedLease(async () => {
+      await this.ensureDirectory();
+      const now = this.now();
+      const artifacts = await this.loadArtifacts();
+      await this.removeExpired(artifacts, now);
+      const active = artifacts.filter((artifact2) => artifact2.expiresAt > now.toISOString());
+      const sha256 = hash(content);
+      const existing = active.find((artifact2) => artifact2.sessionId === sessionId && artifact2.toolCallId === toolCallId);
+      if (existing) {
+        if (existing.sha256 === sha256 && existing.bytes === bytes && existing.redacted === options.redacted) {
+          return { stored: true, artifact: reference(existing) };
+        }
+        return { stored: false, reason: "conflict" };
+      }
+      const artifact = {
+        version: 1,
+        sessionId,
+        toolCallId,
+        sha256,
+        bytes,
+        createdAt: now.toISOString(),
+        expiresAt: new Date(now.getTime() + this.retentionMs).toISOString(),
+        redacted: options.redacted,
+        content
+      };
+      const storageBytes = storedBytes(artifact);
+      let retainedBytes = active.reduce((total, retained) => total + storedBytes(retained), 0);
+      const evictable = active.slice().sort(
+        (left, right) => left.createdAt.localeCompare(right.createdAt)
+      );
+      while (retainedBytes + storageBytes > this.maxTotalBytes && evictable.length) {
+        const oldest = evictable.shift();
+        await this.removeArtifact(oldest);
+        retainedBytes -= storedBytes(oldest);
+      }
+      if (retainedBytes + storageBytes > this.maxTotalBytes) return { stored: false, reason: "total_limit" };
+      const path = this.pathFor(sessionId, toolCallId);
+      await ensureWorkspaceStorageDirectory(this.workspace, resolve13(path, ".."), {
+        requireActiveNamespace: this.managedDirectory
+      });
+      await atomicWrite(path, `${JSON.stringify(artifact)}
+`, 384);
+      return { stored: true, artifact: reference(artifact) };
+    }));
+  }
+  async read(sessionId, toolCallId, options = {}) {
+    sessionIdSchema2.parse(sessionId);
+    toolCallIdSchema.parse(toolCallId);
+    const startLine = options.startLine ?? 1;
+    const startByte = options.startByte;
+    const maxLines = options.maxLines ?? 200;
+    const maxBytes = options.maxBytes ?? 3e3;
+    if (startByte !== void 0 && options.startLine !== void 0) {
+      throw new Error("Use either startLine or startByte, not both.");
+    }
+    if (!Number.isInteger(startLine) || startLine < 1) throw new Error("startLine must be a positive integer.");
+    if (startByte !== void 0 && (!Number.isInteger(startByte) || startByte < 0)) {
+      throw new Error("startByte must be a non-negative integer.");
+    }
+    if (!Number.isInteger(maxLines) || maxLines < 1 || maxLines > 1e3) {
+      throw new Error("maxLines must be between 1 and 1000.");
+    }
+    if (!Number.isInteger(maxBytes) || maxBytes < 256 || maxBytes > 32e3) {
+      throw new Error("maxBytes must be between 256 and 32000.");
+    }
+    await this.writes;
+    return this.withManagedLease(async () => {
+      const artifact = await this.readArtifact(sessionId, toolCallId);
+      const now = this.now();
+      if (artifact.expiresAt <= now.toISOString()) {
+        await this.removeArtifact(artifact);
+        throw new Error("The retained tool output has expired. Re-run the tool if it is still needed.");
+      }
+      const page = startByte === void 0 ? readLinePage(artifact.content, startLine, maxLines, maxBytes) : readBytePage(artifact.content, startByte, maxBytes);
+      return {
+        ...reference(artifact),
+        ...page
+      };
+    });
+  }
+  /** Remove expired output and return the still-valid receipts for one session. */
+  async prune(sessionId) {
+    sessionIdSchema2.parse(sessionId);
+    return this.enqueue(() => this.withManagedLease(async () => {
+      const artifacts = await this.loadArtifacts();
+      const now = this.now();
+      await this.removeExpired(artifacts, now);
+      return artifacts.filter((artifact) => artifact.sessionId === sessionId && artifact.expiresAt > now.toISOString()).sort((left, right) => left.createdAt.localeCompare(right.createdAt)).map(reference);
+    }));
+  }
+  /** Delete every retained result owned by a removed session. */
+  async removeSession(sessionId) {
+    sessionIdSchema2.parse(sessionId);
+    await this.enqueue(() => this.withManagedLease(async () => {
+      if (!await this.directoryAvailable()) return;
+      const directory = this.sessionDirectoryFor(sessionId);
+      try {
+        const info = await lstat12(directory);
+        if (info.isSymbolicLink() || !info.isDirectory()) {
+          throw new Error(`Tool artifact session storage is not a regular directory: ${directory}`);
+        }
+        await assertNoSymlinkPath(this.workspace, directory);
+      } catch (error) {
+        if (error.code === "ENOENT") return;
+        throw error;
+      }
+      await rm2(directory, { recursive: true, force: true });
+    }));
+  }
+  async readArtifact(sessionId, toolCallId) {
+    const path = this.pathFor(sessionId, toolCallId);
+    await this.assertRegularFile(path);
+    let artifact;
+    try {
+      artifact = artifactSchema.parse(JSON.parse(await readFile7(path, "utf8")));
+    } catch {
+      throw new Error("Retained tool output is unreadable or corrupt.");
+    }
+    if (artifact.sessionId !== sessionId || artifact.toolCallId !== toolCallId) {
+      throw new Error("Retained tool output does not belong to this session.");
+    }
+    if (artifact.bytes !== Buffer.byteLength(artifact.content) || artifact.sha256 !== hash(artifact.content)) {
+      throw new Error("Retained tool output failed its integrity check.");
+    }
+    return artifact;
+  }
+  async loadArtifacts() {
+    if (!await this.directoryAvailable()) return [];
+    const artifacts = [];
+    for (const entry of await readdir4(this.directory, { withFileTypes: true })) {
+      const sessionDirectory = join11(this.directory, entry.name);
+      if (entry.isSymbolicLink()) throw new Error(`Tool artifact storage contains a symbolic link: ${sessionDirectory}`);
+      if (!entry.isDirectory() || !/^[a-f0-9]{64}$/u.test(entry.name)) continue;
+      await assertNoSymlinkPath(this.workspace, sessionDirectory);
+      for (const file of await readdir4(sessionDirectory, { withFileTypes: true })) {
+        const path = join11(sessionDirectory, file.name);
+        if (file.isSymbolicLink()) throw new Error(`Tool artifact storage contains a symbolic link: ${path}`);
+        if (!file.isFile() || !/^[a-f0-9]{64}\.json$/u.test(file.name)) continue;
+        await this.assertRegularFile(path);
+        try {
+          const artifact = artifactSchema.parse(JSON.parse(await readFile7(path, "utf8")));
+          if (artifact.bytes !== Buffer.byteLength(artifact.content) || artifact.sha256 !== hash(artifact.content)) {
+            throw new Error("integrity");
+          }
+          if (sessionDirectory !== this.sessionDirectoryFor(artifact.sessionId) || path !== this.pathFor(artifact.sessionId, artifact.toolCallId)) {
+            throw new Error("identity");
+          }
+          artifacts.push(artifact);
+        } catch {
+          throw new Error(`Tool artifact is unreadable or corrupt: ${path}`);
+        }
+      }
+    }
+    return artifacts;
+  }
+  async removeExpired(artifacts, now) {
+    for (const artifact of artifacts) {
+      if (artifact.expiresAt <= now.toISOString()) await this.removeArtifact(artifact);
+    }
+  }
+  async removeArtifact(artifact) {
+    await rm2(this.pathFor(artifact.sessionId, artifact.toolCallId), { force: true });
+  }
+  pathFor(sessionId, toolCallId) {
+    return join11(this.sessionDirectoryFor(sessionId), `${hash(`call\0${toolCallId}`)}.json`);
+  }
+  sessionDirectoryFor(sessionId) {
+    return join11(this.directory, hash(`session\0${sessionId}`));
+  }
+  async ensureDirectory() {
+    await ensureWorkspaceStorageDirectory(this.workspace, this.directory, {
+      requireActiveNamespace: this.managedDirectory
+    });
+  }
+  async directoryAvailable() {
+    if (this.managedDirectory) await assertNoSymlinkPath(this.workspace, this.directory);
+    try {
+      const info = await lstat12(this.directory);
+      if (info.isSymbolicLink() || !info.isDirectory()) {
+        throw new Error(`Tool artifact storage is not a regular directory: ${this.directory}`);
+      }
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") return false;
+      throw error;
+    }
+  }
+  async assertRegularFile(path) {
+    await assertNoSymlinkPath(this.workspace, resolve13(path, ".."));
+    try {
+      const info = await lstat12(path);
+      if (info.isSymbolicLink() || !info.isFile()) {
+        throw new Error(`Tool artifact cannot be a symbolic link or non-regular file: ${path}`);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error("No retained tool output matches this tool call in the current session.");
+      }
+      throw error;
+    }
+  }
+  async withManagedLease(operation) {
+    if (!this.managedDirectory) return operation();
+    return withNamespaceLease(projectNamespacePaths(this.workspace).canonical, "shared", async () => {
+      assertActiveProjectNamespacePath(this.workspace, this.directory);
+      return operation();
+    });
+  }
+  async enqueue(operation) {
+    const next = this.writes.then(operation);
+    this.writes = next.then(() => void 0, () => void 0);
+    return next;
+  }
+};
+function reference(artifact) {
+  return {
+    toolCallId: artifact.toolCallId,
+    sha256: artifact.sha256,
+    bytes: artifact.bytes,
+    createdAt: artifact.createdAt,
+    expiresAt: artifact.expiresAt,
+    redacted: artifact.redacted
+  };
+}
+function hash(value) {
+  return createHash7("sha256").update(value).digest("hex");
+}
+function storedBytes(artifact) {
+  return Buffer.byteLength(JSON.stringify(artifact)) + 1;
+}
+function readLinePage(content, startLine, maxLines, maxBytes) {
+  const ranges = lineRanges(content);
+  const startIndex = startLine - 1;
+  if (startIndex >= ranges.length) {
+    const totalBytes = Buffer.byteLength(content);
+    return {
+      content: "",
+      startLine,
+      endLine: startLine - 1,
+      totalLines: ranges.length,
+      startByte: totalBytes,
+      endByte: totalBytes,
+      hasMore: false
+    };
+  }
+  const endIndex = Math.min(ranges.length - 1, startIndex + maxLines - 1);
+  const startCharacter = ranges[startIndex]?.start ?? content.length;
+  const endCharacter = ranges[endIndex]?.end ?? content.length;
+  const startByte = Buffer.byteLength(content.slice(0, startCharacter));
+  const selected = Buffer.from(content.slice(startCharacter, endCharacter));
+  if (selected.length > maxBytes) {
+    const page = sliceUtf8Buffer(selected, 0, maxBytes);
+    const pageContent = page.content;
+    return {
+      content: pageContent,
+      startLine,
+      endLine: startLine + countNewlines(pageContent),
+      totalLines: ranges.length,
+      startByte,
+      endByte: startByte + page.bytes,
+      hasMore: true,
+      nextStartByte: startByte + page.bytes
+    };
+  }
+  const endLine = endIndex + 1;
+  const hasMore = endLine < ranges.length;
+  return {
+    content: selected.toString("utf8"),
+    startLine,
+    endLine,
+    totalLines: ranges.length,
+    startByte,
+    endByte: startByte + selected.length,
+    hasMore,
+    ...hasMore ? { nextStartLine: endLine + 1 } : {}
+  };
+}
+function readBytePage(content, requestedStart, maxBytes) {
+  const buffer = Buffer.from(content);
+  const startByte = Math.min(requestedStart, buffer.length);
+  if (startByte < buffer.length && isUtf8Continuation(buffer[startByte] ?? 0)) {
+    throw new Error("startByte must be an exact UTF-8 boundary shown by a previous page.");
+  }
+  const page = sliceUtf8Buffer(buffer, startByte, maxBytes);
+  const prefix = buffer.subarray(0, startByte).toString("utf8");
+  const startLine = countNewlines(prefix) + 1;
+  const endByte = startByte + page.bytes;
+  const hasMore = endByte < buffer.length;
+  return {
+    content: page.content,
+    startLine,
+    endLine: startLine + countNewlines(page.content),
+    totalLines: countNewlines(content) + 1,
+    startByte,
+    endByte,
+    hasMore,
+    ...hasMore ? { nextStartByte: endByte } : {}
+  };
+}
+function sliceUtf8Buffer(buffer, start, maxBytes) {
+  let end = Math.min(buffer.length, start + maxBytes);
+  while (end > start && isUtf8Continuation(buffer[end] ?? 0)) end -= 1;
+  return { content: buffer.subarray(start, end).toString("utf8"), bytes: end - start };
+}
+function lineRanges(content) {
+  const ranges = [];
+  const expression = /\r?\n/gu;
+  let start = 0;
+  for (const match of content.matchAll(expression)) {
+    ranges.push({ start, end: match.index });
+    start = match.index + match[0].length;
+  }
+  ranges.push({ start, end: content.length });
+  return ranges;
+}
+function countNewlines(value) {
+  return value.match(/\n/gu)?.length ?? 0;
+}
+function isUtf8Continuation(byte) {
+  return byte >= 128 && byte < 192;
+}
+
 // src/tools/apply-patch.ts
-import { lstat as lstat12, readFile as readFile7, unlink as unlink4 } from "node:fs/promises";
+import { lstat as lstat13, readFile as readFile8, unlink as unlink4 } from "node:fs/promises";
 import { applyPatch as applyUnifiedPatch, parsePatch } from "diff";
-import { z as z6 } from "zod";
-var inputSchema2 = z6.object({
-  patch: z6.string().min(1).max(1e7),
-  dry_run: z6.boolean().optional()
+import { z as z7 } from "zod";
+var inputSchema2 = z7.object({
+  patch: z7.string().min(1).max(1e7),
+  dry_run: z7.boolean().optional()
 }).strict();
 var applyPatchTool = {
   definition: {
@@ -5560,10 +5954,10 @@ function findSequence(haystack, needle, hint, minimum) {
 }
 async function readSnapshot2(path) {
   try {
-    const info = await lstat12(path);
+    const info = await lstat13(path);
     if (info.isSymbolicLink()) throw new Error(`Refusing to patch a symbolic link: ${path}`);
     if (!info.isFile()) throw new Error(`Patch target is not a regular file: ${path}`);
-    return { before: await readFile7(path), mode: info.mode };
+    return { before: await readFile8(path), mode: info.mode };
   } catch (error) {
     if (error.code === "ENOENT") return { before: null };
     throw error;
@@ -5612,13 +6006,13 @@ function buffersEqual(left, right) {
 }
 
 // src/tools/git.ts
-import { join as join11 } from "node:path";
-import { z as z7 } from "zod";
-var inputSchema3 = z7.object({
-  args: z7.array(z7.string().max(1e4)).min(1).max(200),
-  cwd: z7.string().min(1).optional(),
-  timeout_ms: z7.number().int().min(100).max(6e5).optional(),
-  stdin: z7.string().max(5e6).optional()
+import { join as join12 } from "node:path";
+import { z as z8 } from "zod";
+var inputSchema3 = z8.object({
+  args: z8.array(z8.string().max(1e4)).min(1).max(200),
+  cwd: z8.string().min(1).optional(),
+  timeout_ms: z8.number().int().min(100).max(6e5).optional(),
+  stdin: z8.string().max(5e6).optional()
 }).strict();
 var networkCommands = /* @__PURE__ */ new Set([
   "clone",
@@ -5831,7 +6225,7 @@ var gitTool = {
     for (const candidate of explicit) {
       if (!candidate || candidate.startsWith("-")) continue;
       try {
-        paths.add(await context.workspace.resolvePath(join11(cwd, candidate), { allowMissing: true }));
+        paths.add(await context.workspace.resolvePath(join12(cwd, candidate), { allowMissing: true }));
       } catch {
       }
     }
@@ -5852,7 +6246,7 @@ var gitTool = {
         const candidates = candidate.includes(" -> ") ? candidate.split(" -> ") : [candidate];
         for (const value of candidates) {
           try {
-            paths.add(await context.workspace.resolvePath(join11(cwd, value), { allowMissing: true }));
+            paths.add(await context.workspace.resolvePath(join12(cwd, value), { allowMissing: true }));
           } catch {
           }
         }
@@ -5933,7 +6327,7 @@ async function collectGitChanges(before, after, runtime, cwd, context) {
   const paths = [];
   for (const candidate of [...candidates].slice(0, 2e3)) {
     try {
-      paths.push(await context.workspace.resolvePath(join11(cwd, candidate), { allowMissing: true }));
+      paths.push(await context.workspace.resolvePath(join12(cwd, candidate), { allowMissing: true }));
     } catch {
     }
   }
@@ -6049,7 +6443,7 @@ async function validateGitWorkspaceArguments(args, command2, cwd, context) {
     if (/^(?:[a-z]+:\/\/|[a-z]+@[^:]+:)/i.test(candidate)) continue;
     if (command2 === "clone" && index === 0 && !candidate) continue;
     await context.workspace.resolvePath(
-      candidate.startsWith("/") ? candidate : join11(cwd, candidate),
+      candidate.startsWith("/") ? candidate : join12(cwd, candidate),
       { allowMissing: true }
     );
   }
@@ -6102,17 +6496,17 @@ function positionalArguments(args, command2) {
 }
 
 // src/tools/list.ts
-import { lstat as lstat13 } from "node:fs/promises";
-import { relative as relative6, resolve as resolve13 } from "node:path";
+import { lstat as lstat14 } from "node:fs/promises";
+import { relative as relative6, resolve as resolve14 } from "node:path";
 import fg3 from "fast-glob";
-import { z as z8 } from "zod";
-var inputSchema4 = z8.object({
-  path: z8.string().min(1).optional(),
-  pattern: z8.string().min(1).optional(),
-  depth: z8.number().int().min(1).max(20).optional(),
-  include_hidden: z8.boolean().optional(),
-  include_directories: z8.boolean().optional(),
-  limit: z8.number().int().min(1).max(5e3).optional()
+import { z as z9 } from "zod";
+var inputSchema4 = z9.object({
+  path: z9.string().min(1).optional(),
+  pattern: z9.string().min(1).optional(),
+  depth: z9.number().int().min(1).max(20).optional(),
+  include_hidden: z9.boolean().optional(),
+  include_directories: z9.boolean().optional(),
+  limit: z9.number().int().min(1).max(5e3).optional()
 }).strict();
 var ignored = [
   "**/.git/**",
@@ -6161,11 +6555,11 @@ var listFilesTool = {
     for (const path of selected) {
       let safePath;
       try {
-        safePath = await context.workspace.resolvePath(resolve13(directory, path), { expect: "any" });
+        safePath = await context.workspace.resolvePath(resolve14(directory, path), { expect: "any" });
       } catch {
         continue;
       }
-      const info = await lstat13(safePath);
+      const info = await lstat14(safePath);
       rendered.push(`${info.isDirectory() ? "d" : "f"} ${relative6(directory, safePath)}${info.isDirectory() ? "/" : ""}`);
     }
     const base = workspaceAliasPath(directory, context.workspace.roots);
@@ -6182,14 +6576,14 @@ var listFilesTool = {
 };
 
 // src/tools/read.ts
-import { readFile as readFile8, stat as stat7 } from "node:fs/promises";
-import { z as z9 } from "zod";
-var inputSchema5 = z9.object({
-  path: z9.string().min(1),
-  start_line: z9.number().int().positive().optional(),
-  end_line: z9.number().int().positive().optional(),
-  line_numbers: z9.boolean().optional(),
-  max_bytes: z9.number().int().positive().max(1e6).optional()
+import { readFile as readFile9, stat as stat7 } from "node:fs/promises";
+import { z as z10 } from "zod";
+var inputSchema5 = z10.object({
+  path: z10.string().min(1),
+  start_line: z10.number().int().positive().optional(),
+  end_line: z10.number().int().positive().optional(),
+  line_numbers: z10.boolean().optional(),
+  max_bytes: z10.number().int().positive().max(1e6).optional()
 }).strict();
 var readFileTool = {
   definition: {
@@ -6212,7 +6606,7 @@ var readFileTool = {
     if (info.size > 1e7) {
       throw new Error(`File is too large to read safely (${info.size} bytes).`);
     }
-    const buffer = await readFile8(path);
+    const buffer = await readFile9(path);
     if (looksBinary(buffer)) throw new Error("Binary files cannot be read with read_file.");
     const raw = buffer.toString("utf8");
     const lines = raw.split("\n");
@@ -6256,6 +6650,73 @@ function truncateUtf8(input2, maxBytes) {
   return buffer.subarray(0, end).toString("utf8");
 }
 
+// src/tools/read-artifact.ts
+import { z as z11 } from "zod";
+var inputSchema6 = z11.object({
+  sha256: z11.string().regex(/^[a-f0-9]{64}$/u),
+  start_line: z11.number().int().positive().optional(),
+  start_byte: z11.number().int().nonnegative().optional(),
+  max_lines: z11.number().int().min(1).max(1e3).optional(),
+  max_bytes: z11.number().int().min(256).max(768).optional()
+}).strict().refine((input2) => input2.start_line === void 0 || input2.start_byte === void 0, {
+  message: "Use either start_line or start_byte, not both."
+});
+var readToolArtifactTool = {
+  definition: {
+    name: "read_tool_artifact",
+    description: "Read a bounded page of oversized tool output retained for this session. Use only the SHA-256 shown in a tool-output receipt.",
+    category: "read",
+    inputSchema: jsonSchema({
+      sha256: { type: "string", description: "The exact 64-character SHA-256 from a retained-output receipt." },
+      start_line: { type: "integer", minimum: 1, default: 1 },
+      start_byte: { type: "integer", minimum: 0, description: "Exact UTF-8 continuation byte shown by a previous page." },
+      max_lines: { type: "integer", minimum: 1, maximum: 1e3, default: 200 },
+      max_bytes: { type: "integer", minimum: 256, maximum: 768, default: 768 }
+    }, ["sha256"])
+  },
+  async execute(arguments_, context) {
+    const input2 = inputSchema6.parse(arguments_);
+    const artifact = context.session.toolArtifacts?.find(
+      (candidate) => candidate.sha256 === input2.sha256 && Date.parse(candidate.expiresAt) > Date.now()
+    );
+    if (!artifact) {
+      throw new Error("No retained tool output matches this tool call in the current session.");
+    }
+    const store = context.toolArtifactStore ?? new ToolArtifactStore(context.workspace.primaryRoot);
+    const page = await store.read(context.session.id, artifact.toolCallId, {
+      ...input2.start_line !== void 0 ? { startLine: input2.start_line } : {},
+      ...input2.start_byte !== void 0 ? { startByte: input2.start_byte } : {},
+      ...input2.max_lines !== void 0 ? { maxLines: input2.max_lines } : {},
+      maxBytes: input2.max_bytes ?? 768
+    });
+    if (page.sha256 !== artifact.sha256 || page.bytes !== artifact.bytes) {
+      throw new Error("Retained tool output no longer matches the session receipt.");
+    }
+    const heading = `Retained output page: lines ${page.startLine}-${page.endLine} of ${page.totalLines}; bytes ${page.startByte}-${page.endByte} of ${page.bytes}`;
+    const continuation = page.nextStartByte !== void 0 ? `continue with start_byte=${page.nextStartByte}` : page.nextStartLine !== void 0 ? `continue with start_line=${page.nextStartLine}` : "";
+    return {
+      content: `${heading}
+${page.content}${page.hasMore ? `
+\u2026 more retained output; ${continuation}` : ""}`,
+      metadata: {
+        artifact: {
+          toolCallId: page.toolCallId,
+          sha256: page.sha256,
+          bytes: page.bytes,
+          expiresAt: page.expiresAt,
+          redacted: page.redacted
+        },
+        startLine: page.startLine,
+        endLine: page.endLine,
+        totalLines: page.totalLines,
+        startByte: page.startByte,
+        endByte: page.endByte,
+        truncated: page.hasMore
+      }
+    };
+  }
+};
+
 // src/tools/registry.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
@@ -6303,19 +6764,19 @@ function assertToolName(name) {
 }
 
 // src/tools/search.ts
-import { readFile as readFile9, stat as stat8 } from "node:fs/promises";
-import { resolve as resolve14 } from "node:path";
+import { readFile as readFile10, stat as stat8 } from "node:fs/promises";
+import { resolve as resolve15 } from "node:path";
 import fg4 from "fast-glob";
-import { z as z10 } from "zod";
-var inputSchema6 = z10.object({
-  query: z10.string().min(1).max(1e4),
-  path: z10.string().min(1).optional(),
-  pattern: z10.string().min(1).optional(),
-  mode: z10.enum(["text", "ranked"]).optional(),
-  literal: z10.boolean().optional(),
-  case_sensitive: z10.boolean().optional(),
-  context_lines: z10.number().int().min(0).max(20).optional(),
-  max_results: z10.number().int().min(1).max(500).optional()
+import { z as z12 } from "zod";
+var inputSchema7 = z12.object({
+  query: z12.string().min(1).max(1e4),
+  path: z12.string().min(1).optional(),
+  pattern: z12.string().min(1).optional(),
+  mode: z12.enum(["text", "ranked"]).optional(),
+  literal: z12.boolean().optional(),
+  case_sensitive: z12.boolean().optional(),
+  context_lines: z12.number().int().min(0).max(20).optional(),
+  max_results: z12.number().int().min(1).max(500).optional()
 }).strict();
 var ignore = [
   "**/.git/**",
@@ -6350,7 +6811,7 @@ var searchCodeTool = {
     }, ["query"])
   },
   async execute(arguments_, context) {
-    const input2 = inputSchema6.parse(arguments_);
+    const input2 = inputSchema7.parse(arguments_);
     const directory = await context.workspace.resolveDirectory(input2.path ?? ".");
     if ((input2.mode ?? "text") === "ranked") {
       if (!context.contextEngine) throw new Error("Local ranked retrieval is unavailable.");
@@ -6374,7 +6835,7 @@ var searchCodeTool = {
       if (results.length >= maxResults) break;
       let path;
       try {
-        path = await context.workspace.resolvePath(resolve14(directory, file), { expect: "file" });
+        path = await context.workspace.resolvePath(resolve15(directory, file), { expect: "file" });
       } catch {
         skipped += 1;
         continue;
@@ -6384,7 +6845,7 @@ var searchCodeTool = {
         skipped += 1;
         continue;
       }
-      const buffer = await readFile9(path);
+      const buffer = await readFile10(path);
       if (buffer.subarray(0, 8192).includes(0)) {
         skipped += 1;
         continue;
@@ -6456,17 +6917,17 @@ ${hit.content}`
 }
 
 // src/tools/shell.ts
-import { createHash as createHash7 } from "node:crypto";
-import { lstat as lstat14, readFile as readFile10, readdir as readdir4 } from "node:fs/promises";
-import { join as join12 } from "node:path";
-import { z as z11 } from "zod";
-var inputSchema7 = z11.object({
-  command: z11.string().min(1).max(1e5),
-  cwd: z11.string().min(1).optional(),
-  timeout_ms: z11.number().int().min(100).max(6e5).optional(),
-  max_output_bytes: z11.number().int().min(1e3).max(5e6).optional(),
-  env: z11.record(z11.string(), z11.string()).optional(),
-  stdin: z11.string().max(5e6).optional()
+import { createHash as createHash8 } from "node:crypto";
+import { lstat as lstat15, readFile as readFile11, readdir as readdir5 } from "node:fs/promises";
+import { join as join13 } from "node:path";
+import { z as z13 } from "zod";
+var inputSchema8 = z13.object({
+  command: z13.string().min(1).max(1e5),
+  cwd: z13.string().min(1).optional(),
+  timeout_ms: z13.number().int().min(100).max(6e5).optional(),
+  max_output_bytes: z13.number().int().min(1e3).max(5e6).optional(),
+  env: z13.record(z13.string(), z13.string()).optional(),
+  stdin: z13.string().max(5e6).optional()
 }).strict();
 var shellTool = {
   definition: {
@@ -6483,7 +6944,7 @@ var shellTool = {
     }, ["command"])
   },
   permissionCategories(arguments_) {
-    const input2 = inputSchema7.parse(arguments_);
+    const input2 = inputSchema8.parse(arguments_);
     validateEnvironment(input2.env);
     return [
       "shell",
@@ -6493,12 +6954,12 @@ var shellTool = {
     ];
   },
   async affectedPaths(arguments_, context) {
-    const input2 = inputSchema7.parse(arguments_);
+    const input2 = inputSchema8.parse(arguments_);
     if (!appearsToModifyWorkspace(input2.command)) return [];
     return collectAffectedPaths(input2.command, input2.cwd ?? ".", context);
   },
   async execute(arguments_, context) {
-    const input2 = inputSchema7.parse(arguments_);
+    const input2 = inputSchema8.parse(arguments_);
     validateEnvironment(input2.env);
     const cwd = await context.workspace.resolveDirectory(input2.cwd ?? ".");
     const candidates = appearsToModifyWorkspace(input2.command) ? await collectAffectedPaths(input2.command, input2.cwd ?? ".", context) : [];
@@ -6538,7 +6999,8 @@ Execution interrupted: ${error instanceof Error ? error.message : String(error)}
       result.stdout ? `stdout:
 ${result.stdout}` : "",
       result.stderr ? `stderr:
-${result.stderr}` : ""
+${result.stderr}` : "",
+      result.stdoutTruncated || result.stderrTruncated ? `Source output exceeded the command capture limit (${result.stdoutBytes} stdout bytes, ${result.stderrBytes} stderr bytes observed). Rerun with max_output_bytes up to 5000000 or narrow the command; omitted source bytes are not recoverable from this result.` : ""
     ].filter(Boolean);
     return {
       ok: result.exitCode === 0 && !result.timedOut,
@@ -6548,6 +7010,9 @@ ${result.stderr}` : ""
         exitCode: result.exitCode,
         timedOut: result.timedOut,
         durationMs: result.durationMs,
+        stdoutBytes: result.stdoutBytes,
+        stderrBytes: result.stderrBytes,
+        sourceTruncated: result.stdoutTruncated || result.stderrTruncated,
         changeTracking: candidates.length ? "targeted" : beforeWorkspace && afterWorkspace && beforeWorkspace.complete && afterWorkspace.complete ? "workspace-snapshot" : beforeWorkspace ? "unresolved" : "read-only"
       },
       ...changedFiles.length ? { changedFiles } : {}
@@ -6611,7 +7076,7 @@ async function collectAffectedPaths(command2, cwdInput, context) {
         allowMissing: true
       });
       try {
-        if ((await lstat14(path)).isDirectory()) continue;
+        if ((await lstat15(path)).isDirectory()) continue;
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
@@ -6639,7 +7104,7 @@ async function changedPaths(paths, before) {
 }
 async function snapshotPath(path) {
   try {
-    const info = await lstat14(path);
+    const info = await lstat15(path);
     return { exists: true, size: info.size, mtimeMs: info.mtimeMs };
   } catch (error) {
     if (error.code === "ENOENT") return { exists: false };
@@ -6655,18 +7120,18 @@ async function captureWorkspaceSnapshot(roots) {
     if (!discovered.complete) complete = false;
     for (const path of discovered.files) {
       try {
-        const info = await lstat14(path);
+        const info = await lstat15(path);
         if (!info.isFile() || info.isSymbolicLink()) continue;
         if (files.size >= MAX_SNAPSHOT_FILES || info.size > MAX_SNAPSHOT_FILE_BYTES || totalBytes + info.size > MAX_SNAPSHOT_TOTAL_BYTES) {
           complete = false;
           continue;
         }
-        const content = await readFile10(path);
+        const content = await readFile11(path);
         totalBytes += content.length;
         files.set(path, {
           size: info.size,
           mtimeMs: info.mtimeMs,
-          hash: createHash7("sha256").update(content).digest("hex")
+          hash: createHash8("sha256").update(content).digest("hex")
         });
       } catch (error) {
         if (error.code !== "ENOENT") complete = false;
@@ -6687,14 +7152,14 @@ async function discoverSnapshotFiles(root) {
     const directory = pending.pop();
     if (!directory) break;
     try {
-      const entries = await readdir4(directory, { withFileTypes: true, encoding: "utf8" });
+      const entries = await readdir5(directory, { withFileTypes: true, encoding: "utf8" });
       for (const entry of entries) {
         if (ignored2.has(entry.name) || /^\.skein\.(?:migrating|rollback)-/u.test(entry.name)) continue;
         if (entry.isSymbolicLink()) {
           complete = false;
           continue;
         }
-        const path = join12(directory, entry.name);
+        const path = join13(directory, entry.name);
         if (entry.isDirectory()) pending.push(path);
         else if (entry.isFile()) files.push(path);
       }
@@ -6708,18 +7173,18 @@ async function discoverSnapshotFiles(root) {
 
 // src/tools/task.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-import { z as z12 } from "zod";
-var taskSchema2 = z12.object({
-  id: z12.string().min(1).optional(),
-  title: z12.string().min(1).max(500),
-  status: z12.enum(["pending", "in_progress", "completed"])
+import { z as z14 } from "zod";
+var taskSchema2 = z14.object({
+  id: z14.string().min(1).optional(),
+  title: z14.string().min(1).max(500),
+  status: z14.enum(["pending", "in_progress", "completed"])
 }).strict();
-var inputSchema8 = z12.discriminatedUnion("action", [
-  z12.object({ action: z12.literal("list") }).strict(),
-  z12.object({ action: z12.literal("add"), title: z12.string().min(1).max(500), status: z12.enum(["pending", "in_progress", "completed"]).optional() }).strict(),
-  z12.object({ action: z12.literal("update"), id: z12.string().min(1), title: z12.string().min(1).max(500).optional(), status: z12.enum(["pending", "in_progress", "completed"]).optional() }).strict(),
-  z12.object({ action: z12.literal("remove"), id: z12.string().min(1) }).strict(),
-  z12.object({ action: z12.literal("replace"), tasks: z12.array(taskSchema2).max(100) }).strict()
+var inputSchema9 = z14.discriminatedUnion("action", [
+  z14.object({ action: z14.literal("list") }).strict(),
+  z14.object({ action: z14.literal("add"), title: z14.string().min(1).max(500), status: z14.enum(["pending", "in_progress", "completed"]).optional() }).strict(),
+  z14.object({ action: z14.literal("update"), id: z14.string().min(1), title: z14.string().min(1).max(500).optional(), status: z14.enum(["pending", "in_progress", "completed"]).optional() }).strict(),
+  z14.object({ action: z14.literal("remove"), id: z14.string().min(1) }).strict(),
+  z14.object({ action: z14.literal("replace"), tasks: z14.array(taskSchema2).max(100) }).strict()
 ]);
 var taskTool = {
   definition: {
@@ -6750,7 +7215,7 @@ var taskTool = {
     }
   },
   async execute(arguments_, context) {
-    const input2 = inputSchema8.parse(arguments_);
+    const input2 = inputSchema9.parse(arguments_);
     const tasks = context.session.tasks;
     switch (input2.action) {
       case "list":
@@ -6788,7 +7253,7 @@ var taskTool = {
 
 // src/tools/task-contract.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // src/agent/task-contract.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
@@ -6869,14 +7334,14 @@ function compact(value, limit) {
 }
 
 // src/agent/completion-gate.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 
 // src/tools/permissions.ts
-import { createHash as createHash8, createHmac, randomBytes } from "node:crypto";
+import { createHash as createHash9, createHmac, randomBytes } from "node:crypto";
 var permissionScopeSecret = randomBytes(32);
 function permissionKey(call, category) {
   const categoryScope = category === "network" ? `\0network-request:${scopeFingerprint(normalizeRequestState(call.arguments))}` : "";
-  const digest = createHash8("sha256").update(`${category}\0${call.name}\0${permissionTarget(call)}${categoryScope}`).digest("hex").slice(0, 24);
+  const digest = createHash9("sha256").update(`${category}\0${call.name}\0${permissionTarget(call)}${categoryScope}`).digest("hex").slice(0, 24);
   return `${category}:${call.name}:${digest}`;
 }
 function permissionTarget(call) {
@@ -7070,7 +7535,7 @@ function captureVerification(call, result, changeSequence, configuredCommands) {
     kind,
     ok: result.ok,
     changeSequence,
-    commandKey: createHash9("sha256").update(normalized).digest("hex")
+    commandKey: createHash10("sha256").update(normalized).digest("hex")
   };
 }
 function buildRunCompletion(changedFiles, evidence, currentChangeSequence, mutationTracking = "complete", taskContract, audit = []) {
@@ -7230,7 +7695,7 @@ function verificationRequirementMet(requirement, checks) {
   const normalized = normalizeCommand2(requirement);
   const broad = normalized.match(/^Record at least one successful (.+) after the final mutation\.?$/iu);
   if (broad) return checks.length > 0;
-  const commandKey = createHash9("sha256").update(normalized).digest("hex");
+  const commandKey = createHash10("sha256").update(normalized).digest("hex");
   return checks.some((item) => item.commandKey === commandKey);
 }
 function acceptanceUnresolved(acceptance) {
@@ -7282,29 +7747,29 @@ function fileCount(count) {
 }
 
 // src/tools/task-contract.ts
-var criterionSchema = z13.object({
-  id: z13.string().min(1).max(128).optional(),
-  description: z13.string().min(1).max(2e3),
-  required: z13.boolean().optional()
+var criterionSchema = z15.object({
+  id: z15.string().min(1).max(128).optional(),
+  description: z15.string().min(1).max(2e3),
+  required: z15.boolean().optional()
 }).strict();
-var inputSchema9 = z13.discriminatedUnion("action", [
-  z13.object({ action: z13.literal("show") }).strict(),
-  z13.object({
-    action: z13.literal("replace"),
-    objective: z13.string().min(1).max(2e4),
-    scope: z13.array(z13.string().min(1).max(2e3)).max(64),
-    constraints: z13.array(z13.string().min(1).max(2e3)).max(64),
-    non_goals: z13.array(z13.string().min(1).max(2e3)).max(64),
-    acceptance_criteria: z13.array(criterionSchema).min(1).max(64),
-    verification_requirements: z13.array(z13.string().min(1).max(2e3)).min(1).max(64)
+var inputSchema10 = z15.discriminatedUnion("action", [
+  z15.object({ action: z15.literal("show") }).strict(),
+  z15.object({
+    action: z15.literal("replace"),
+    objective: z15.string().min(1).max(2e4),
+    scope: z15.array(z15.string().min(1).max(2e3)).max(64),
+    constraints: z15.array(z15.string().min(1).max(2e3)).max(64),
+    non_goals: z15.array(z15.string().min(1).max(2e3)).max(64),
+    acceptance_criteria: z15.array(criterionSchema).min(1).max(64),
+    verification_requirements: z15.array(z15.string().min(1).max(2e3)).min(1).max(64)
   }).strict(),
-  z13.object({ action: z13.literal("activate") }).strict(),
-  z13.object({
-    action: z13.literal("update_criterion"),
-    id: z13.string().min(1).max(128),
-    status: z13.enum(["pending", "satisfied", "blocked"]),
-    evidence_refs: z13.array(z13.string().min(1).max(256)).max(64).optional(),
-    note: z13.string().max(2e3).optional()
+  z15.object({ action: z15.literal("activate") }).strict(),
+  z15.object({
+    action: z15.literal("update_criterion"),
+    id: z15.string().min(1).max(128),
+    status: z15.enum(["pending", "satisfied", "blocked"]),
+    evidence_refs: z15.array(z15.string().min(1).max(256)).max(64).optional(),
+    note: z15.string().max(2e3).optional()
   }).strict()
 ]);
 var taskContractTool = {
@@ -7346,7 +7811,7 @@ var taskContractTool = {
     }
   },
   async execute(arguments_, context) {
-    const input2 = inputSchema9.parse(arguments_);
+    const input2 = inputSchema10.parse(arguments_);
     let contract = context.session.taskContract;
     if (!contract) throw new Error("No Task Contract is active for this session.");
     if (input2.action === "replace") {
@@ -7443,17 +7908,17 @@ function validateVerificationRequirement(requirement) {
 }
 
 // src/tools/working-memory.ts
-import { z as z14 } from "zod";
-var inputSchema10 = z14.discriminatedUnion("action", [
-  z14.object({ action: z14.literal("show") }).strict(),
-  z14.object({ action: z14.literal("set_goal"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("set_focus"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("add_constraint"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("add_decision"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("add_question"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("resolve_question"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("add_file"), path: z14.string().min(1).max(4e3) }).strict(),
-  z14.object({ action: z14.literal("clear"), field: z14.enum(["constraints", "decisions", "openQuestions", "relevantFiles"]) }).strict()
+import { z as z16 } from "zod";
+var inputSchema11 = z16.discriminatedUnion("action", [
+  z16.object({ action: z16.literal("show") }).strict(),
+  z16.object({ action: z16.literal("set_goal"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("set_focus"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("add_constraint"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("add_decision"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("add_question"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("resolve_question"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("add_file"), path: z16.string().min(1).max(4e3) }).strict(),
+  z16.object({ action: z16.literal("clear"), field: z16.enum(["constraints", "decisions", "openQuestions", "relevantFiles"]) }).strict()
 ]);
 var workingMemoryTool = {
   definition: {
@@ -7478,7 +7943,7 @@ var workingMemoryTool = {
     }, ["action"])
   },
   async execute(arguments_, context) {
-    const input2 = inputSchema10.parse(arguments_);
+    const input2 = inputSchema11.parse(arguments_);
     const memory = context.session.workingMemory ?? emptyWorkingMemory2();
     switch (input2.action) {
       case "show":
@@ -7560,6 +8025,7 @@ function render(memory) {
 function createDefaultToolRegistry(_options = {}) {
   return new ToolRegistry([
     readFileTool,
+    readToolArtifactTool,
     listFilesTool,
     searchCodeTool,
     writeFileTool,
@@ -7688,7 +8154,7 @@ function escapeAttribute3(value) {
 }
 
 // src/agent/tool-recovery.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 var RETRY_BUDGET = {
   schema_input: 3,
   unknown_tool: 2,
@@ -7783,10 +8249,10 @@ function isRetryable(failureClass) {
   return RETRY_BUDGET[failureClass] > 0;
 }
 function callSignature(call) {
-  return createHash10("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}`).digest("hex");
+  return createHash11("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}`).digest("hex");
 }
 function failureSignature(call, failureClass) {
-  return createHash10("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}\0${failureClass}`).digest("hex");
+  return createHash11("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}\0${failureClass}`).digest("hex");
 }
 function redact(value, key = "") {
   if (/api[_-]?key|authorization|cookie|password|secret|token/i.test(key)) return "[redacted]";
@@ -7803,10 +8269,212 @@ function isFailureClass(value) {
   return typeof value === "string" && Object.hasOwn(RETRY_BUDGET, value);
 }
 
+// src/agent/tool-output.ts
+import stripAnsi from "strip-ansi";
+var MIN_TOOL_OUTPUT_TOKENS = 1024;
+var MAX_TOOL_OUTPUT_TOKENS = 8192;
+async function protectToolOutput(options) {
+  const safe = sanitizeToolOutput(options.content);
+  const sanitized = redactToolOutput(safe.text);
+  const estimatedTokens = estimateToolOutputTokens(sanitized.text);
+  const budgetTokens = clamp2(options.budgetTokens, MIN_TOOL_OUTPUT_TOKENS, MAX_TOOL_OUTPUT_TOKENS);
+  const base = {
+    originalChars: options.content.length,
+    originalBytes: Buffer.byteLength(options.content),
+    estimatedTokens,
+    budgetTokens,
+    truncated: estimatedTokens > budgetTokens,
+    redacted: sanitized.redacted,
+    sanitized: safe.sanitized
+  };
+  if (estimatedTokens <= budgetTokens) return { content: sanitized.text, metadata: base };
+  let archived;
+  try {
+    archived = await options.artifacts.archive(
+      options.sessionId,
+      options.toolCallId,
+      sanitized.text,
+      { redacted: sanitized.redacted }
+    );
+  } catch {
+    archived = { stored: false, reason: "storage_error" };
+  }
+  const artifact = archived.stored ? archived.artifact : void 0;
+  const artifactUnavailable = archived.stored ? void 0 : archived.reason;
+  const metadata = {
+    ...base,
+    ...artifact ? {
+      artifact: {
+        toolCallId: artifact.toolCallId,
+        sha256: artifact.sha256,
+        bytes: artifact.bytes,
+        createdAt: artifact.createdAt,
+        expiresAt: artifact.expiresAt
+      }
+    } : artifactUnavailable ? { artifactUnavailable } : {}
+  };
+  const receipt = formatReceipt(options, metadata, "");
+  const previewBudget = Math.max(0, budgetTokens - estimateToolOutputTokens(receipt));
+  const preview = boundedPreview(sanitized.text, previewBudget);
+  return {
+    content: formatReceipt(options, metadata, preview),
+    metadata
+  };
+}
+function dynamicToolOutputBudget(contextWindowTokens, activeContextTokens, remainingSessionTokens) {
+  const contextHeadroom = Math.max(0, contextWindowTokens - activeContextTokens);
+  const sessionHeadroom = Math.max(0, remainingSessionTokens);
+  const budget = Math.min(
+    Math.floor(contextHeadroom * 0.35),
+    Math.floor(sessionHeadroom * 0.12)
+  );
+  return clamp2(budget, MIN_TOOL_OUTPUT_TOKENS, MAX_TOOL_OUTPUT_TOKENS);
+}
+function estimateToolOutputTokens(value) {
+  let tokens2 = 0;
+  for (const character of value) {
+    tokens2 += tokenCost(character);
+  }
+  return Math.max(1, Math.ceil(tokens2));
+}
+function formatReceipt(options, metadata, preview) {
+  const lines = [
+    "[Oversized tool output bounded for the model transcript]",
+    `tool: ${boundedInlineByTokens(options.tool, 64)}`,
+    `tool-call-id: ${boundedInlineByTokens(options.toolCallId, 96)}`,
+    `status: ${options.ok ? "success" : "failure"}`,
+    `original-output: ${metadata.originalChars} chars, ${metadata.originalBytes} bytes, ~${metadata.estimatedTokens} tokens`,
+    `model-budget: ${metadata.budgetTokens} tokens (head + tail preview)`,
+    ...metadata.redacted ? ["sensitive-values: redacted before display and retention"] : [],
+    ...preservedSignals(options.metadata),
+    ...metadata.artifact ? [
+      `artifact: session-scoped; sha256 ${metadata.artifact.sha256}; ${metadata.artifact.bytes} bytes`,
+      `read-back: read_tool_artifact({"sha256":"${metadata.artifact.sha256}","start_line":1,"max_lines":200}) before ${metadata.artifact.expiresAt}`
+    ] : [`artifact: unavailable (${metadata.artifactUnavailable ?? "unknown"}); rerun the tool with a narrower result if more detail is needed`],
+    "preview:",
+    preview
+  ];
+  return lines.join("\n");
+}
+function preservedSignals(metadata) {
+  const lines = [];
+  if (typeof metadata.exitCode === "number") lines.push(`exit-code: ${metadata.exitCode}`);
+  if (metadata.timedOut === true) lines.push("timed-out: true");
+  if (metadata.sourceTruncated === true) {
+    lines.push("source-truncated: true; the producing tool reached its capture limit before this firewall");
+  }
+  const changedFiles = metadata.changedFiles;
+  if (Array.isArray(changedFiles)) {
+    const allPaths = changedFiles.filter((path) => typeof path === "string");
+    const paths = allPaths.slice(0, 3).map((path) => boundedInlineByTokens(path, 24));
+    if (paths.length) {
+      lines.push(`changed-files: ${paths.join(", ")}${allPaths.length > paths.length ? ` (+${allPaths.length - paths.length} more in metadata)` : ""}`);
+    }
+  }
+  const failure = metadata.failure;
+  if (isFailureReceipt(failure)) {
+    lines.push(`failure-class: ${failure.class}; attempt ${failure.attempt}; ${failure.remaining} retries remain`);
+  }
+  return lines;
+}
+function isFailureReceipt(value) {
+  return typeof value === "object" && value !== null && typeof value.class === "string" && typeof value.attempt === "number" && typeof value.remaining === "number";
+}
+function redactToolOutput(value) {
+  let redacted = false;
+  const replace = (expression, replacement) => {
+    expression.lastIndex = 0;
+    if (!expression.test(value)) return;
+    redacted = true;
+    expression.lastIndex = 0;
+    value = value.replace(expression, replacement);
+  };
+  replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/gu, "[redacted-secret]");
+  replace(/\b(authorization\s*:\s*(?:bearer\s+|basic\s+)?)\S+/giu, "$1[redacted]");
+  replace(/\b((?:api[_-]?key|access[_-]?token|authorization|cookie|password|client[_-]?secret)\s*[:=]\s*)(?:"[A-Za-z0-9+/_=-]{8,}"|'[A-Za-z0-9+/_=-]{8,}'|[A-Za-z0-9+/_=-]{8,})/giu, "$1[redacted]");
+  replace(/(--(?:api[_-]?key|access[_-]?token|password|client[_-]?secret)(?:=|\s+))[A-Za-z0-9+/_=-]{8,}/giu, "$1[redacted]");
+  return { text: value, redacted };
+}
+function sanitizeToolOutput(value) {
+  const text = stripAnsi(value).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu, "");
+  return { text, sanitized: text !== value };
+}
+function sliceStartByTokens(value, budget) {
+  let used = 0;
+  let end = 0;
+  for (const character of value) {
+    const cost = tokenCost(character);
+    if (used + cost > budget) break;
+    used += cost;
+    end += character.length;
+  }
+  return value.slice(0, end);
+}
+function sliceEndByTokens(value, budget) {
+  let used = 0;
+  let start = value.length;
+  while (start > 0) {
+    let next = start - 1;
+    const code = value.charCodeAt(next);
+    if (code >= 56320 && code <= 57343 && next > 0) {
+      const previous = value.charCodeAt(next - 1);
+      if (previous >= 55296 && previous <= 56319) next -= 1;
+    }
+    const character = value.slice(next, start);
+    const cost = tokenCost(character);
+    if (used + cost > budget) break;
+    used += cost;
+    start = next;
+  }
+  return value.slice(start);
+}
+function boundedPreview(value, budget) {
+  if (budget <= 0) return "";
+  if (estimateToolOutputTokens(value) <= budget) return value;
+  let low = 0;
+  let high = budget;
+  let best = "";
+  while (low <= high) {
+    const contentBudget = Math.floor((low + high) / 2);
+    const headBudget = Math.ceil(contentBudget * 0.6);
+    const tailBudget = Math.max(0, contentBudget - headBudget);
+    const head = sliceStartByTokens(value, headBudget);
+    const tail = sliceEndByTokens(value, tailBudget);
+    const preview = `${head}
+\u2026 ${Math.max(0, value.length - head.length - tail.length)} chars omitted \u2026
+${tail}`;
+    if (estimateToolOutputTokens(preview) <= budget) {
+      best = preview;
+      low = contentBudget + 1;
+    } else {
+      high = contentBudget - 1;
+    }
+  }
+  return best || sliceStartByTokens(value, budget);
+}
+function tokenCost(character) {
+  const code = character.codePointAt(0) ?? 0;
+  if (isCjkCharacter(character) || code > 127) return 2;
+  return /[A-Z0-9\p{P}\p{S}]/u.test(character) ? 0.5 : 0.25;
+}
+function isCjkCharacter(character) {
+  const code = character.codePointAt(0) ?? 0;
+  return code >= 11904 && code <= 40959 || code >= 44032 && code <= 55215 || code >= 63744 && code <= 64255 || code >= 131072 && code <= 195103;
+}
+function clamp2(value, minimum, maximum) {
+  return Math.max(minimum, Math.min(maximum, value));
+}
+function boundedInlineByTokens(value, maxTokens) {
+  const normalized = value.replace(/[\r\n\t]+/gu, " ").trim();
+  if (estimateToolOutputTokens(normalized) <= maxTokens) return normalized;
+  const suffix = "\u2026";
+  return `${sliceStartByTokens(normalized, Math.max(0, maxTokens - tokenCost(suffix)))}${suffix}`;
+}
+
 // src/agent/rules.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { join as join13 } from "node:path";
-import { lstat as lstat15, readFile as readFile11 } from "node:fs/promises";
+import { join as join14 } from "node:path";
+import { lstat as lstat16, readFile as readFile12 } from "node:fs/promises";
 var workspaceRulePaths = [
   "AGENTS.md",
   "CLAUDE.md",
@@ -7815,14 +8483,14 @@ var workspaceRulePaths = [
 ];
 async function discoverWorkspaceRules(workspace, maxChars = 12e4) {
   const workspaceAccess = new WorkspaceAccess([workspace]);
-  const activeProjectRules = join13(resolveProjectNamespaceSync(workspace).active, "rules.md");
+  const activeProjectRules = join14(resolveProjectNamespaceSync(workspace).active, "rules.md");
   const projectCandidates = [
-    ...workspaceRulePaths.slice(0, 3).map((path) => join13(workspace, path)),
+    ...workspaceRulePaths.slice(0, 3).map((path) => join14(workspace, path)),
     activeProjectRules,
-    ...workspaceRulePaths.slice(3).map((path) => join13(workspace, path))
+    ...workspaceRulePaths.slice(3).map((path) => join14(workspace, path))
   ];
   const candidates = [
-    { path: join13(resolveHomeNamespace(), "rules.md"), scope: "user" },
+    { path: join14(resolveHomeNamespace(), "rules.md"), scope: "user" },
     ...projectCandidates.map((path) => ({
       path,
       scope: "workspace"
@@ -7833,13 +8501,13 @@ async function discoverWorkspaceRules(workspace, maxChars = 12e4) {
   for (const candidate of candidates) {
     if (remaining <= 0 || !existsSync2(candidate.path)) continue;
     try {
-      const info = await lstat15(candidate.path);
+      const info = await lstat16(candidate.path);
       if (!info.isFile() || info.size > 1e6) continue;
       if (candidate.scope === "workspace") {
         const safePath = await workspaceAccess.resolvePath(candidate.path, { expect: "file" });
         if (safePath !== candidate.path) continue;
       }
-      const raw = await readFile11(candidate.path, "utf8");
+      const raw = await readFile12(candidate.path, "utf8");
       if (raw.includes("\0")) continue;
       const content = raw.slice(0, remaining);
       rules.push({
@@ -7871,7 +8539,7 @@ function escapeAttribute4(value) {
 }
 
 // src/context/context-sources.ts
-import { readFile as readFile12, stat as stat9 } from "node:fs/promises";
+import { readFile as readFile13, stat as stat9 } from "node:fs/promises";
 var MAX_SOURCE_CHARS = 6e4;
 var MAX_PINNED_CHARS = 16e4;
 var MAX_CONTEXT_SOURCES = 32;
@@ -7885,7 +8553,7 @@ async function pinContextSource(session, workspace, requested) {
   const resolved = await workspace.resolvePath(requested, { expect: "file" });
   const info = await stat9(resolved);
   const alias = workspace.display(resolved);
-  const tokens2 = estimateTokens3((await readFile12(resolved, "utf8")).slice(0, MAX_SOURCE_CHARS));
+  const tokens2 = estimateTokens3((await readFile13(resolved, "utf8")).slice(0, MAX_SOURCE_CHARS));
   const list2 = sources(session);
   const existing = list2.find((source2) => source2.path === alias);
   if (existing) {
@@ -7935,7 +8603,7 @@ async function resolvePinnedContent(session, workspace) {
     if (remaining <= 0) break;
     try {
       const safe = await workspace.resolvePath(source.path, { expect: "file" });
-      const raw = await readFile12(safe, "utf8");
+      const raw = await readFile13(safe, "utf8");
       const capped = raw.slice(0, Math.min(MAX_SOURCE_CHARS, remaining));
       source.tokens = estimateTokens3(capped);
       resolved.push({
@@ -7983,6 +8651,7 @@ var AgentRunner = class {
   contextEngine;
   tools;
   sessionStore;
+  toolArtifactStore;
   checkpointStore;
   workspace;
   hooks;
@@ -8004,6 +8673,7 @@ var AgentRunner = class {
       contextEngine: this.contextEngine
     });
     this.sessionStore = options.sessionStore ?? new SessionStore(this.workspace.primaryRoot);
+    this.toolArtifactStore = options.toolArtifactStore ?? new ToolArtifactStore(this.workspace.primaryRoot);
     this.checkpointStore = options.checkpointStore ?? new CheckpointStore(this.workspace);
     this.hooks = new HookRunner(options.config.hooks, this.workspace);
     this.contextManager = options.contextManager ?? new ContextManager(options.config);
@@ -8096,6 +8766,7 @@ var AgentRunner = class {
     };
     try {
       throwIfAborted(options.signal);
+      await this.reconcileToolArtifacts();
       if (this.session.messages.length === 0 && this.session.title === "New session") {
         this.session.title = titleFromInput(request);
       }
@@ -8202,9 +8873,13 @@ var AgentRunner = class {
           contextBudget
         );
         const availableTokens = this.config.agent.maxSessionTokens - (this.session.usage.inputTokens + this.session.usage.outputTokens);
-        const estimatedInputTokens = estimateMessages2(messages) + estimateToolDefinitions(
-          visibleToolDefinitions(this.tools, options.askMode === true, contractEnabled)
+        const visibleTools = visibleToolDefinitions(
+          this.tools,
+          options.askMode === true,
+          contractEnabled,
+          this.hasReadableToolArtifact()
         );
+        const estimatedInputTokens = estimateMessages2(messages) + estimateToolDefinitions(visibleTools);
         if (availableTokens <= 0 || estimatedInputTokens >= availableTokens) {
           return finishRun("token_budget");
         }
@@ -8212,7 +8887,6 @@ var AgentRunner = class {
           this.config.model.maxTokens ?? 8192,
           availableTokens - estimatedInputTokens
         ));
-        const visibleTools = visibleToolDefinitions(this.tools, options.askMode === true, contractEnabled);
         const assistantId = randomUUID12();
         const response = await this.completeModel(
           messages,
@@ -8370,17 +9044,17 @@ ${input2}`
   async executeTool(call, options, emit, recovery = new ToolRecoveryController(), visibleToolNames) {
     const preflight = recovery.preflight(call);
     if (preflight) {
-      const result = failedResult(call, "Tool call rejected by the recovery circuit.", preflight);
+      const result = await this.protectToolResult(
+        failedResult(call, "Tool call rejected by the recovery circuit.", preflight)
+      );
       this.recordToolResult(result);
       await emit({ type: "tool_result", result });
       return result;
     }
     if (visibleToolNames && !visibleToolNames.has(call.name)) {
       const receipt = recovery.recordFailure(call, "unknown_tool");
-      const result = failedResult(
-        call,
-        `Tool is not exposed for this turn: ${call.name}`,
-        receipt
+      const result = await this.protectToolResult(
+        failedResult(call, `Tool is not exposed for this turn: ${call.name}`, receipt)
       );
       this.recordToolResult(result);
       await emit({ type: "tool_result", result });
@@ -8389,7 +9063,7 @@ ${input2}`
     const tool = this.tools.get(call.name);
     if (!tool) {
       const receipt = recovery.recordFailure(call, "unknown_tool");
-      const result = failedResult(call, `Unknown tool: ${call.name}`, receipt);
+      const result = await this.protectToolResult(failedResult(call, `Unknown tool: ${call.name}`, receipt));
       this.recordToolResult(result);
       await emit({ type: "tool_result", result });
       return result;
@@ -8402,17 +9076,15 @@ ${input2}`
     } catch (error) {
       const failureClass = classifyThrownToolFailure(error, options.signal);
       const receipt = recovery.recordFailure(call, failureClass);
-      const result = failedResult(call, formatToolError(error), receipt);
+      const result = await this.protectToolResult(failedResult(call, formatToolError(error), receipt));
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
       return result;
     }
     if (categories.some((category) => category !== "read") && this.session.taskContract?.state === "draft") {
       const receipt = recovery.recordFailure(call, "contract_required");
-      const result = failedResult(
-        call,
-        "Potentially mutating work is paused until the draft Task Contract is activated.",
-        receipt
+      const result = await this.protectToolResult(
+        failedResult(call, "Potentially mutating work is paused until the draft Task Contract is activated.", receipt)
       );
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
@@ -8422,7 +9094,9 @@ ${input2}`
       const allowed = await this.authorize(call, category, options, emit);
       if (!allowed) {
         const receipt = recovery.recordFailure(call, "permission_denied");
-        const result = failedResult(call, `Permission denied for ${category} operation.`, receipt);
+        const result = await this.protectToolResult(
+          failedResult(call, `Permission denied for ${category} operation.`, receipt)
+        );
         this.recordToolResult(result, category);
         await emit({ type: "tool_result", result });
         return result;
@@ -8436,6 +9110,7 @@ ${input2}`
       workspace: this.workspace,
       session: this.session,
       contextEngine: this.contextEngine,
+      toolArtifactStore: this.toolArtifactStore,
       emit,
       ...options.signal ? { signal: options.signal } : {}
     };
@@ -8469,30 +9144,33 @@ ${input2}`
       } catch (error) {
         afterHookError = toError(error);
       }
-      const result = {
-        toolCallId: call.id,
-        name: call.name,
-        ok: execution.ok !== false && !afterHookError,
-        content: truncateToolOutput(afterHookError ? `${execution.content}
+      let completeContent = afterHookError ? `${execution.content}
 
-Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : execution.content),
-        metadata: {
-          ...execution.metadata ?? {},
-          ...changedFiles.length ? { changedFiles } : {},
-          ...checkpointId ? { checkpointId } : {},
-          ...beforeHooks.length || afterHooks.length ? { hooks: { before: beforeHooks.length, after: afterHooks.length } } : {},
-          ...afterHookError ? { toolSucceeded: true, hookError: afterHookError.message } : {}
-        }
+Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : execution.content;
+      const metadata = {
+        ...execution.metadata ?? {},
+        ...changedFiles.length ? { changedFiles } : {},
+        ...checkpointId ? { checkpointId } : {},
+        ...beforeHooks.length || afterHooks.length ? { hooks: { before: beforeHooks.length, after: afterHooks.length } } : {},
+        ...afterHookError ? { toolSucceeded: true, hookError: afterHookError.message } : {}
       };
-      if (!result.ok) {
-        const failureClass = options.signal?.aborted ? "cancelled" : classifyToolFailure(result);
+      const ok = execution.ok !== false && !afterHookError;
+      if (!ok) {
+        const failureClass = options.signal?.aborted ? "cancelled" : classifyToolFailure({ toolCallId: call.id, name: call.name, ok, content: completeContent, metadata });
         const receipt = recovery.recordFailure(call, failureClass);
-        result.content = truncateToolOutput(`${formatFailureReceipt(receipt)}
-${result.content}`);
-        result.metadata = { ...result.metadata, failure: receipt };
+        completeContent = `${formatFailureReceipt(receipt)}
+${completeContent}`;
+        metadata.failure = receipt;
       } else {
         recovery.recordSuccess(call);
       }
+      const result = await this.protectToolResult({
+        toolCallId: call.id,
+        name: call.name,
+        ok,
+        content: completeContent,
+        metadata
+      });
       this.contextManager.recordTool(this.session, call, result);
       if (JSON.stringify(this.session.tasks) !== tasksBefore || call.name === "task") {
         await emit({ type: "tasks", tasks: this.session.tasks.map((task) => ({ ...task })) });
@@ -8507,7 +9185,7 @@ ${result.content}`);
       const normalized = toError(error);
       const failureClass = classifyThrownToolFailure(normalized, options.signal);
       const receipt = recovery.recordFailure(call, failureClass);
-      const result = failedResult(call, formatToolError(error), receipt);
+      const result = await this.protectToolResult(failedResult(call, formatToolError(error), receipt));
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
       return result;
@@ -8661,6 +9339,63 @@ ${result.content}`);
   persist() {
     return this.persistSession ? this.sessionStore.save(this.session) : Promise.resolve();
   }
+  toolOutputBudget() {
+    const contextWindowTokens = Math.max(24e3, Math.min(1e5, this.config.context.maxTokens * 3));
+    const activeContextTokens = this.contextManager.status(this.session, contextWindowTokens).activeTokens;
+    const remainingSessionTokens = this.config.agent.maxSessionTokens - (this.session.usage.inputTokens + this.session.usage.outputTokens);
+    return dynamicToolOutputBudget(contextWindowTokens, activeContextTokens, remainingSessionTokens);
+  }
+  async protectToolResult(result) {
+    const metadata = { ...result.metadata ?? {} };
+    const output2 = await protectToolOutput({
+      content: result.content,
+      sessionId: this.session.id,
+      toolCallId: result.toolCallId,
+      tool: result.name,
+      ok: result.ok,
+      budgetTokens: this.toolOutputBudget(),
+      metadata,
+      artifacts: this.toolArtifactStore
+    });
+    if (output2.metadata.artifact) this.registerToolArtifact({
+      ...output2.metadata.artifact,
+      redacted: output2.metadata.redacted
+    });
+    return {
+      ...result,
+      content: output2.content,
+      ...output2.metadata.truncated || output2.metadata.redacted || output2.metadata.sanitized || output2.metadata.artifact || output2.metadata.artifactUnavailable ? { metadata: { ...metadata, toolOutput: output2.metadata } } : Object.keys(metadata).length ? { metadata } : {}
+    };
+  }
+  hasReadableToolArtifact() {
+    const now = Date.now();
+    return (this.session.toolArtifacts ?? []).some(
+      (artifact) => Date.parse(artifact.expiresAt) > now
+    );
+  }
+  registerToolArtifact(artifact) {
+    const now = Date.now();
+    const artifacts = (this.session.toolArtifacts ?? []).filter((candidate) => Date.parse(candidate.expiresAt) > now && candidate.toolCallId !== artifact.toolCallId);
+    artifacts.push(artifact);
+    artifacts.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    if (artifacts.length > 200) artifacts.splice(0, artifacts.length - 200);
+    this.session.toolArtifacts = artifacts;
+  }
+  async reconcileToolArtifacts() {
+    let stored;
+    try {
+      stored = await this.toolArtifactStore.prune(this.session.id);
+    } catch {
+      this.session.toolArtifacts = [];
+      return;
+    }
+    const valid = new Map(stored.map((artifact) => [artifact.toolCallId, artifact]));
+    const reconciled = (this.session.toolArtifacts ?? []).filter((receipt) => {
+      const artifact = valid.get(receipt.toolCallId);
+      return artifact !== void 0 && artifact.sha256 === receipt.sha256 && artifact.bytes === receipt.bytes && artifact.createdAt === receipt.createdAt && artifact.expiresAt === receipt.expiresAt && artifact.redacted === receipt.redacted;
+    });
+    this.session.toolArtifacts = reconciled;
+  }
 };
 function message(role, content, extra = {}) {
   return {
@@ -8740,21 +9475,16 @@ function failedResult(call, content, failure) {
     toolCallId: call.id,
     name: call.name,
     ok: false,
-    content: truncateToolOutput(failure ? `${formatFailureReceipt(failure)}
-${content}` : content),
+    content: failure ? `${formatFailureReceipt(failure)}
+${content}` : content,
     ...failure ? { metadata: { failure } } : {}
   };
 }
-function visibleToolDefinitions(tools, askMode, contractEnabled) {
+function visibleToolDefinitions(tools, askMode, contractEnabled, artifactReadAvailable) {
   return tools.definitions().filter(
-    (tool) => (!askMode || tool.category === "read") && (contractEnabled || tool.name !== "task_contract")
+    (tool) => (!askMode || tool.category === "read") && (contractEnabled || tool.name !== "task_contract") && (artifactReadAvailable || tool.name !== "read_tool_artifact")
   );
 }
-function truncateToolOutput(content) {
-  const max = 8e4;
-  return content.length <= max ? content : `${content.slice(0, max)}
-\u2026 tool output truncated`;
-}
 function formatToolError(error) {
   const normalized = toError(error);
   if (normalized.name === "ZodError") return `Invalid tool arguments: ${normalized.message}`;
@@ -8787,9 +9517,9 @@ async function safeEmit(emit, event) {
 }
 
 // src/agent/profiles.ts
-import { lstat as lstat16, readFile as readFile13, readdir as readdir5 } from "node:fs/promises";
+import { lstat as lstat17, readFile as readFile14, readdir as readdir6 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename8, join as join14 } from "node:path";
+import { basename as basename8, join as join15 } from "node:path";
 import { parse as parseYaml2 } from "yaml";
 var builtInProfiles = [
   {
@@ -8881,14 +9611,14 @@ var AgentProfileCatalog = class {
   profiles = new Map(builtInProfiles.map((profile) => [profile.name, profile]));
   async discover() {
     const locations = [
-      { path: join14(resolveHomeNamespace(), "agents"), source: "user" },
-      { path: join14(homedir3(), ".claude", "agents"), source: "user" },
-      { path: join14(resolveProjectNamespaceSync(this.workspace).active, "agents"), source: "workspace" },
-      { path: join14(this.workspace, ".claude", "agents"), source: "workspace" }
+      { path: join15(resolveHomeNamespace(), "agents"), source: "user" },
+      { path: join15(homedir3(), ".claude", "agents"), source: "user" },
+      { path: join15(resolveProjectNamespaceSync(this.workspace).active, "agents"), source: "workspace" },
+      { path: join15(this.workspace, ".claude", "agents"), source: "workspace" }
     ];
     for (const location of locations) {
       for (const file of await markdownFiles(location.path)) {
-        const profile = await readProfile(join14(location.path, file), location.source);
+        const profile = await readProfile(join15(location.path, file), location.source);
         if (profile) this.profiles.set(profile.name, profile);
       }
     }
@@ -8904,18 +9634,18 @@ var AgentProfileCatalog = class {
 };
 async function markdownFiles(directory) {
   try {
-    const info = await lstat16(directory);
+    const info = await lstat17(directory);
     if (!info.isDirectory() || info.isSymbolicLink()) return [];
-    return (await readdir5(directory, { withFileTypes: true })).filter((entry) => entry.isFile() && !entry.isSymbolicLink() && entry.name.endsWith(".md")).map((entry) => entry.name).slice(0, 200);
+    return (await readdir6(directory, { withFileTypes: true })).filter((entry) => entry.isFile() && !entry.isSymbolicLink() && entry.name.endsWith(".md")).map((entry) => entry.name).slice(0, 200);
   } catch {
     return [];
   }
 }
 async function readProfile(path, source) {
   try {
-    const info = await lstat16(path);
+    const info = await lstat17(path);
     if (!info.isFile() || info.isSymbolicLink() || info.size > 1e5) return void 0;
-    const raw = await readFile13(path, "utf8");
+    const raw = await readFile14(path, "utf8");
     const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
     const frontmatter = match ? parseYaml2(match[1] ?? "") : {};
     const prompt = (match ? raw.slice(match[0].length) : raw).trim();
@@ -8943,8 +9673,8 @@ function integer(value, fallback, min, max) {
 
 // src/agent/delegation.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
-import { join as join17 } from "node:path";
-import { z as z16 } from "zod";
+import { join as join18 } from "node:path";
+import { z as z18 } from "zod";
 
 // src/agent/external-runtime.ts
 async function runExternalAgent(request) {
@@ -9071,95 +9801,95 @@ function numeric(...values) {
 }
 
 // src/agent/team-store.ts
-import { createHash as createHash11, randomUUID as randomUUID13 } from "node:crypto";
-import { lstat as lstat17, readFile as readFile14, readdir as readdir6, rm as rm2 } from "node:fs/promises";
-import { join as join15, resolve as resolve15 } from "node:path";
-import { z as z15 } from "zod";
-var runIdSchema = z15.string().uuid();
-var hashSchema = z15.string().regex(/^[a-f0-9]{64}$/u);
-var artifactSchema = z15.object({
+import { createHash as createHash12, randomUUID as randomUUID13 } from "node:crypto";
+import { lstat as lstat18, readFile as readFile15, readdir as readdir7, rm as rm3 } from "node:fs/promises";
+import { join as join16, resolve as resolve16 } from "node:path";
+import { z as z17 } from "zod";
+var runIdSchema = z17.string().uuid();
+var hashSchema = z17.string().regex(/^[a-f0-9]{64}$/u);
+var artifactSchema2 = z17.object({
   sha256: hashSchema,
-  bytes: z15.number().int().nonnegative().max(5e5)
+  bytes: z17.number().int().nonnegative().max(5e5)
 }).strict();
-var phaseSchema = z15.enum(["work", "review", "revision", "write"]);
-var agentRecordSchema = z15.object({
-  id: z15.string().uuid(),
-  profile: z15.string(),
-  provider: z15.string(),
-  model: z15.string(),
+var phaseSchema = z17.enum(["work", "review", "revision", "write"]);
+var agentRecordSchema = z17.object({
+  id: z17.string().uuid(),
+  profile: z17.string(),
+  provider: z17.string(),
+  model: z17.string(),
   phase: phaseSchema,
-  ok: z15.boolean(),
-  createdAt: z15.string(),
-  startedAt: z15.string().optional(),
-  endedAt: z15.string().optional(),
-  durationMs: z15.number().int().nonnegative().optional(),
-  toolCalls: z15.number().int().nonnegative().optional(),
-  usage: z15.object({
-    inputTokens: z15.number().int().nonnegative(),
-    outputTokens: z15.number().int().nonnegative()
+  ok: z17.boolean(),
+  createdAt: z17.string(),
+  startedAt: z17.string().optional(),
+  endedAt: z17.string().optional(),
+  durationMs: z17.number().int().nonnegative().optional(),
+  toolCalls: z17.number().int().nonnegative().optional(),
+  usage: z17.object({
+    inputTokens: z17.number().int().nonnegative(),
+    outputTokens: z17.number().int().nonnegative()
   }).strict().optional(),
-  report: artifactSchema
+  report: artifactSchema2
 }).strict();
-var messageRecordSchema = z15.object({
-  id: z15.string().uuid(),
-  from: z15.string(),
-  to: z15.string(),
-  createdAt: z15.string(),
-  content: artifactSchema
+var messageRecordSchema = z17.object({
+  id: z17.string().uuid(),
+  from: z17.string(),
+  to: z17.string(),
+  createdAt: z17.string(),
+  content: artifactSchema2
 }).strict();
-var writerIntegrationSchema = z15.object({
-  status: z15.enum(["ready", "conflict", "integrated"]),
-  checkedAt: z15.string(),
-  detail: z15.string().max(2e4),
-  checkpoint: z15.object({
-    sessionId: z15.string(),
-    checkpointId: z15.string()
+var writerIntegrationSchema = z17.object({
+  status: z17.enum(["ready", "conflict", "integrated"]),
+  checkedAt: z17.string(),
+  detail: z17.string().max(2e4),
+  checkpoint: z17.object({
+    sessionId: z17.string(),
+    checkpointId: z17.string()
   }).strict().optional(),
-  integratedAt: z15.string().optional()
+  integratedAt: z17.string().optional()
 }).strict();
-var writerLaneSchema = z15.object({
-  profile: z15.string(),
-  reviewer: z15.string(),
-  baseCommit: z15.string().regex(/^[a-f0-9]{40,64}$/u),
-  outcome: z15.enum(["accepted", "rejected", "failed", "cancelled"]),
-  patch: artifactSchema,
-  files: z15.array(z15.string().min(1).max(4e3)).max(2e3),
-  worktreeCleaned: z15.boolean(),
-  review: artifactSchema.optional(),
+var writerLaneSchema = z17.object({
+  profile: z17.string(),
+  reviewer: z17.string(),
+  baseCommit: z17.string().regex(/^[a-f0-9]{40,64}$/u),
+  outcome: z17.enum(["accepted", "rejected", "failed", "cancelled"]),
+  patch: artifactSchema2,
+  files: z17.array(z17.string().min(1).max(4e3)).max(2e3),
+  worktreeCleaned: z17.boolean(),
+  review: artifactSchema2.optional(),
   integration: writerIntegrationSchema.optional()
 }).strict();
 var manifestFields = {
   id: runIdSchema,
-  workspace: z15.string(),
-  objective: z15.string().max(3e4),
-  reviewer: z15.string(),
-  createdAt: z15.string(),
-  updatedAt: z15.string(),
-  status: z15.enum(["running", "accepted", "rejected", "failed"]),
-  maxReviewRounds: z15.number().int().min(0).max(3),
-  reviewRounds: z15.number().int().min(0).max(3),
-  agents: z15.array(agentRecordSchema).max(256),
-  messages: z15.array(messageRecordSchema).max(512)
+  workspace: z17.string(),
+  objective: z17.string().max(3e4),
+  reviewer: z17.string(),
+  createdAt: z17.string(),
+  updatedAt: z17.string(),
+  status: z17.enum(["running", "accepted", "rejected", "failed"]),
+  maxReviewRounds: z17.number().int().min(0).max(3),
+  reviewRounds: z17.number().int().min(0).max(3),
+  agents: z17.array(agentRecordSchema).max(256),
+  messages: z17.array(messageRecordSchema).max(512)
 };
-var manifestV1Schema = z15.object({
-  version: z15.literal(1),
+var manifestV1Schema = z17.object({
+  version: z17.literal(1),
   ...manifestFields
 }).strict();
-var manifestV2Schema = z15.object({
-  version: z15.literal(2),
+var manifestV2Schema = z17.object({
+  version: z17.literal(2),
   ...manifestFields,
   writer: writerLaneSchema.optional()
 }).strict();
-var manifestSchema2 = z15.discriminatedUnion("version", [manifestV1Schema, manifestV2Schema]);
+var manifestSchema2 = z17.discriminatedUnion("version", [manifestV1Schema, manifestV2Schema]);
 var TeamRunStore = class {
   workspace;
   directory;
   managedDirectory;
   writes = Promise.resolve();
   constructor(workspace, directory) {
-    this.workspace = resolve15(workspace);
+    this.workspace = resolve16(workspace);
     this.managedDirectory = directory === void 0;
-    this.directory = directory ? resolve15(directory) : join15(resolveProjectNamespaceSync(this.workspace).active, "team-runs");
+    this.directory = directory ? resolve16(directory) : join16(resolveProjectNamespaceSync(this.workspace).active, "team-runs");
   }
   async create(input2) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -9243,10 +9973,10 @@ var TeamRunStore = class {
     runIdSchema.parse(runId);
     await this.writes;
     await this.assertRunDirectory(runId);
-    const path = join15(this.runDirectory(runId), "manifest.json");
+    const path = join16(this.runDirectory(runId), "manifest.json");
     await this.assertRegularFile(path);
-    const manifest = manifestSchema2.parse(JSON.parse(await readFile14(path, "utf8")));
-    if (manifest.id !== runId || resolve15(manifest.workspace) !== this.workspace) {
+    const manifest = manifestSchema2.parse(JSON.parse(await readFile15(path, "utf8")));
+    if (manifest.id !== runId || resolve16(manifest.workspace) !== this.workspace) {
       throw new Error("Team run manifest identity does not match its location.");
     }
     if (verify) {
@@ -9260,13 +9990,13 @@ var TeamRunStore = class {
   }
   async readArtifact(runId, artifact) {
     await this.verifyArtifact(runId, artifact);
-    return readFile14(this.artifactPath(runId, artifact.sha256), "utf8");
+    return readFile15(this.artifactPath(runId, artifact.sha256), "utf8");
   }
   async list() {
     await this.writes;
     try {
       await assertNoSymlinkPath(this.workspace, this.directory);
-      const entries = await readdir6(this.directory, { withFileTypes: true });
+      const entries = await readdir7(this.directory, { withFileTypes: true });
       const summaries = [];
       for (const entry of entries) {
         if (!entry.isDirectory() || entry.isSymbolicLink() || !runIdSchema.safeParse(entry.name).success) continue;
@@ -9289,9 +10019,9 @@ var TeamRunStore = class {
       const directory = this.runDirectory(runId);
       await assertNoSymlinkPath(this.workspace, directory);
       try {
-        const info = await lstat17(directory);
+        const info = await lstat18(directory);
         if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Team run storage is not a regular directory.");
-        await rm2(directory, { recursive: true });
+        await rm3(directory, { recursive: true });
         return true;
       } catch (error) {
         if (error.code === "ENOENT") return false;
@@ -9314,31 +10044,31 @@ var TeamRunStore = class {
   }
   async loadUnlocked(runId) {
     await this.assertRunDirectory(runId);
-    const path = join15(this.runDirectory(runId), "manifest.json");
+    const path = join16(this.runDirectory(runId), "manifest.json");
     await this.assertRegularFile(path);
-    return manifestSchema2.parse(JSON.parse(await readFile14(path, "utf8")));
+    return manifestSchema2.parse(JSON.parse(await readFile15(path, "utf8")));
   }
   async writeManifest(manifest) {
     const directory = this.runDirectory(manifest.id);
     await ensureWorkspaceStorageDirectory(this.workspace, directory, {
       requireActiveNamespace: this.managedDirectory
     });
-    await atomicWrite(join15(directory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    await atomicWrite(join16(directory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, 384);
   }
   async writeArtifact(runId, content, truncate = true) {
     const data = boundedArtifactText(content, 5e5, truncate);
     const bytes = Buffer.byteLength(data);
-    const sha256 = createHash11("sha256").update(data).digest("hex");
-    const directory = join15(this.runDirectory(runId), "blobs");
+    const sha256 = createHash12("sha256").update(data).digest("hex");
+    const directory = join16(this.runDirectory(runId), "blobs");
     await ensureWorkspaceStorageDirectory(this.workspace, directory, {
       requireActiveNamespace: this.managedDirectory
     });
-    const path = join15(directory, `${sha256}.txt`);
+    const path = join16(directory, `${sha256}.txt`);
     try {
       await this.assertRegularFile(path);
-      const existing = await readFile14(path);
-      if (createHash11("sha256").update(existing).digest("hex") !== sha256) {
+      const existing = await readFile15(path);
+      if (createHash12("sha256").update(existing).digest("hex") !== sha256) {
         throw new Error(`Team artifact hash collision or corruption: ${sha256}`);
       }
     } catch (error) {
@@ -9358,27 +10088,27 @@ var TeamRunStore = class {
     hashSchema.parse(artifact.sha256);
     const path = this.artifactPath(runId, artifact.sha256);
     await this.assertRegularFile(path);
-    const data = await readFile14(path);
-    const hash = createHash11("sha256").update(data).digest("hex");
-    if (hash !== artifact.sha256 || data.byteLength !== artifact.bytes) {
+    const data = await readFile15(path);
+    const hash2 = createHash12("sha256").update(data).digest("hex");
+    if (hash2 !== artifact.sha256 || data.byteLength !== artifact.bytes) {
       throw new Error(`Team artifact integrity check failed: ${artifact.sha256}`);
     }
   }
   artifactPath(runId, sha256) {
-    return join15(this.runDirectory(runId), "blobs", `${sha256}.txt`);
+    return join16(this.runDirectory(runId), "blobs", `${sha256}.txt`);
   }
   runDirectory(runId) {
-    return join15(this.directory, runId);
+    return join16(this.directory, runId);
   }
   async assertRunDirectory(runId) {
     const directory = this.runDirectory(runId);
     await assertNoSymlinkPath(this.workspace, directory);
-    const info = await lstat17(directory);
+    const info = await lstat18(directory);
     if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Team run storage is not a regular directory.");
   }
   async assertRegularFile(path) {
-    await assertNoSymlinkPath(this.workspace, resolve15(path, ".."));
-    const info = await lstat17(path);
+    await assertNoSymlinkPath(this.workspace, resolve16(path, ".."));
+    const info = await lstat18(path);
     if (!info.isFile() || info.isSymbolicLink()) throw new Error(`Team run file is not a regular file: ${path}`);
   }
 };
@@ -9422,10 +10152,10 @@ function resolveAgentModelRoute(team, parent, profile) {
 }
 
 // src/agent/writer-lane.ts
-import { createHash as createHash12 } from "node:crypto";
-import { lstat as lstat18, mkdtemp, realpath as realpath7, rm as rm3 } from "node:fs/promises";
+import { createHash as createHash13 } from "node:crypto";
+import { lstat as lstat19, mkdtemp, realpath as realpath7, rm as rm4 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { isAbsolute as isAbsolute5, join as join16, resolve as resolve16 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join17, resolve as resolve17 } from "node:path";
 var WriterLaneApplyError = class extends Error {
   constructor(message2, attempted, cause) {
     super(message2, cause === void 0 ? void 0 : { cause });
@@ -9438,18 +10168,18 @@ var WriterLane = class {
   workspace;
   constructor(workspace, workspaceRoots) {
     this.workspace = new WorkspaceAccess([
-      resolve16(workspace),
-      ...workspaceRoots.map((root) => resolve16(root))
+      resolve17(workspace),
+      ...workspaceRoots.map((root) => resolve17(root))
     ]);
   }
   async createDraft(maxPatchBytes, operation, signal) {
     const repository = await this.repository();
     const baseCommit = await this.head(repository);
     const lease = await acquireNamespaceLease(
-      join16(repository.commonDirectory, "skein-writer-lane"),
+      join17(repository.commonDirectory, "skein-writer-lane"),
       "exclusive"
     );
-    const worktree = await mkdtemp(join16(tmpdir2(), "skein-writer-"));
+    const worktree = await mkdtemp(join17(tmpdir2(), "skein-writer-"));
     let added = false;
     let value;
     let patch = "";
@@ -9520,7 +10250,7 @@ var WriterLane = class {
     return {
       baseCommit,
       patch,
-      patchSha256: createHash12("sha256").update(patch).digest("hex"),
+      patchSha256: createHash13("sha256").update(patch).digest("hex"),
       files,
       worktreeCleaned,
       value
@@ -9539,7 +10269,7 @@ var WriterLane = class {
     try {
       const repository = await this.repository();
       const lease = await acquireNamespaceLease(
-        join16(repository.commonDirectory, "skein-writer-lane"),
+        join17(repository.commonDirectory, "skein-writer-lane"),
         "exclusive"
       );
       try {
@@ -9647,7 +10377,7 @@ var WriterLane = class {
       if (isAbsolute5(file) || file === ".git" || file.startsWith(".git/") || file.includes("\0")) {
         throw new Error(`Writer patch contains an unsafe path: ${file}`);
       }
-      await this.workspace.resolvePath(join16(repository.root, file), { allowMissing: true });
+      await this.workspace.resolvePath(join17(repository.root, file), { allowMissing: true });
     }
     if (expectedFiles && !sameSet(files, expectedFiles)) {
       throw new Error("Writer patch paths do not match the persisted file manifest.");
@@ -9662,7 +10392,7 @@ var WriterLane = class {
     if (topLevel.exitCode !== 0 || !topLevel.stdout.trim()) {
       throw new Error("The primary workspace must be a Git repository root for writer lanes.");
     }
-    const discoveredRoot = resolve16(topLevel.stdout.trim());
+    const discoveredRoot = resolve17(topLevel.stdout.trim());
     if (await realpath7(discoveredRoot) !== await realpath7(root)) {
       throw new Error("The primary workspace must be the Git repository root for writer lanes.");
     }
@@ -9671,7 +10401,7 @@ var WriterLane = class {
     if (common.exitCode !== 0 || !common.stdout.trim()) {
       throw new Error(`Unable to resolve the Git common directory: ${processDetail(common)}`);
     }
-    const commonDirectory = await realpath7(isAbsolute5(common.stdout.trim()) ? common.stdout.trim() : resolve16(repositoryRoot, common.stdout.trim()));
+    const commonDirectory = await realpath7(isAbsolute5(common.stdout.trim()) ? common.stdout.trim() : resolve17(repositoryRoot, common.stdout.trim()));
     return { root: repositoryRoot, commonDirectory, runtime };
   }
   async head(repository) {
@@ -9683,7 +10413,7 @@ var WriterLane = class {
     return value;
   }
   async cleanupWorktree(repository, worktree, added) {
-    const physicalWorktree = await realpath7(worktree).catch(() => resolve16(worktree));
+    const physicalWorktree = await realpath7(worktree).catch(() => resolve17(worktree));
     if (added) {
       await runIsolatedGit(repository.runtime, [
         "worktree",
@@ -9692,7 +10422,7 @@ var WriterLane = class {
         worktree
       ], repository.root, { timeoutMs: 6e4 }).catch(() => void 0);
     }
-    await rm3(worktree, { recursive: true, force: true }).catch(() => void 0);
+    await rm4(worktree, { recursive: true, force: true }).catch(() => void 0);
     await runIsolatedGit(repository.runtime, [
       "worktree",
       "prune",
@@ -9741,7 +10471,7 @@ function processDetail(result) {
 }
 async function pathExists2(path) {
   try {
-    await lstat18(path);
+    await lstat19(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -9750,14 +10480,14 @@ async function pathExists2(path) {
 }
 
 // src/agent/delegation.ts
-var writerRunInputSchema = z16.object({
-  task: z16.string().min(1).max(2e4),
-  profile: z16.string().max(64).optional(),
-  reviewer: z16.string().max(64).optional()
+var writerRunInputSchema = z18.object({
+  task: z18.string().min(1).max(2e4),
+  profile: z18.string().max(64).optional(),
+  reviewer: z18.string().max(64).optional()
 }).strict();
-var writerIntegrateInputSchema = z16.object({
-  run_id: z16.string().uuid(),
-  patch_sha256: z16.string().regex(/^[a-f0-9]{64}$/u)
+var writerIntegrateInputSchema = z18.object({
+  run_id: z18.string().uuid(),
+  patch_sha256: z18.string().regex(/^[a-f0-9]{64}$/u)
 }).strict();
 var DelegationManager = class {
   constructor(options) {
@@ -9818,10 +10548,10 @@ var DelegationManager = class {
       },
       async execute(arguments_, context) {
         if (!manager.team.enabled) return { ok: false, content: "Multi-agent delegation is disabled." };
-        const input2 = z16.object({
-          tasks: z16.array(z16.object({
-            profile: z16.string().max(64).optional(),
-            task: z16.string().min(1).max(2e4)
+        const input2 = z18.object({
+          tasks: z18.array(z18.object({
+            profile: z18.string().max(64).optional(),
+            task: z18.string().min(1).max(2e4)
           })).min(1).max(manager.team.maxDelegations)
         }).parse(arguments_);
         const tasks = input2.tasks.map((task) => ({
@@ -9867,13 +10597,13 @@ var DelegationManager = class {
       },
       async execute(arguments_, context) {
         if (!manager.team.enabled) return { ok: false, content: "Multi-agent teams are disabled." };
-        const input2 = z16.object({
-          objective: z16.string().min(1).max(3e4),
-          tasks: z16.array(z16.object({
-            profile: z16.string().max(64).optional(),
-            task: z16.string().min(1).max(2e4)
+        const input2 = z18.object({
+          objective: z18.string().min(1).max(3e4),
+          tasks: z18.array(z18.object({
+            profile: z18.string().max(64).optional(),
+            task: z18.string().min(1).max(2e4)
           })).min(1).max(manager.team.maxDelegations),
-          reviewer: z16.string().max(64).optional()
+          reviewer: z18.string().max(64).optional()
         }).parse(arguments_);
         const tasks = input2.tasks.map((task) => ({
           profile: task.profile ?? manager.team.defaultProfile,
@@ -9936,7 +10666,7 @@ var DelegationManager = class {
         const plan = await manager.loadWriterPlan(input2.run_id, input2.patch_sha256);
         const files = await manager.writerLane.inspectPatch(plan.patch, plan.writer.files);
         return Promise.all(files.map(
-          (file) => context.workspace.resolvePath(join17(context.workspace.primaryRoot, file), { allowMissing: true })
+          (file) => context.workspace.resolvePath(join18(context.workspace.primaryRoot, file), { allowMissing: true })
         ));
       },
       async execute(arguments_, context) {
@@ -10123,7 +10853,7 @@ ${review.summary}`,
     const plan = await this.loadWriterPlan(runId, patchSha256);
     const files = await this.writerLane.inspectPatch(plan.patch, plan.writer.files);
     const paths = await Promise.all(files.map(
-      (file) => context.workspace.resolvePath(join17(context.workspace.primaryRoot, file), { allowMissing: true })
+      (file) => context.workspace.resolvePath(join18(context.workspace.primaryRoot, file), { allowMissing: true })
     ));
     const checkpointStore = new CheckpointStore(context.workspace);
     let checkpointId = context.checkpointId;
@@ -11598,7 +12328,7 @@ function formatResultDetail(result, paint = chalk2, glyphs = resolveCliGlyphs())
 }
 
 // src/cli/namespace-leases.ts
-import { resolve as resolve17 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 function cliNamespaceLeaseScopes(actionCommand) {
   const names = commandNames(actionCommand);
   const topLevel = names[1];
@@ -11620,7 +12350,7 @@ async function acquireCliNamespaceLeases(actionCommand) {
   const scopes = cliNamespaceLeaseScopes(actionCommand);
   const localOptions = actionCommand.opts();
   const globalOptions = actionCommand.optsWithGlobals();
-  const workspace = resolve17(localOptions.workspace ?? globalOptions.workspace ?? process.cwd());
+  const workspace = resolve18(localOptions.workspace ?? globalOptions.workspace ?? process.cwd());
   const targets = scopes.map((scope) => scope === "project" ? projectNamespacePaths(workspace).canonical : homeNamespacePaths().canonical);
   const leases = [];
   try {
@@ -11774,11 +12504,11 @@ function command(name, description, usage, aliases) {
 
 // src/ui/text.ts
 import stringWidth from "string-width";
-import stripAnsi from "strip-ansi";
+import stripAnsi2 from "strip-ansi";
 var controlCharacters = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu;
 var escapeSequences = /[[\]][0-9;?=>!]*[ -/]*[@-~]|[[\]][?=>][0-9;?=>!]*[a-zA-Z~]/gu;
 function sanitizeTerminalText(value) {
-  return stripAnsi(value).replace(escapeSequences, "").replace(/\r\n?/g, "\n").replace(controlCharacters, "");
+  return stripAnsi2(value).replace(escapeSequences, "").replace(/\r\n?/g, "\n").replace(controlCharacters, "");
 }
 function terminalEllipsis() {
   return process.env.SKEIN_GLYPHS === "ascii" || process.env.MOSAIC_GLYPHS === "ascii" ? "..." : "\u2026";
@@ -11871,8 +12601,8 @@ function graphemes(value) {
 }
 
 // src/ui/theme.ts
-import { lstat as lstat19, readdir as readdir7, readFile as readFile15 } from "node:fs/promises";
-import { basename as basename9, join as join18, resolve as resolve18 } from "node:path";
+import { lstat as lstat20, readdir as readdir8, readFile as readFile16 } from "node:fs/promises";
+import { basename as basename9, join as join19, resolve as resolve19 } from "node:path";
 import React, { createContext, useContext } from "react";
 function defineTheme(seed) {
   return {
@@ -11994,10 +12724,10 @@ async function reloadUserThemes(directory = userThemeDirectory()) {
   userThemeNames.clear();
   const loaded = [];
   const errors = [];
-  const resolvedDirectory = resolve18(directory);
+  const resolvedDirectory = resolve19(directory);
   let entries;
   try {
-    entries = await readdir7(resolvedDirectory, { encoding: "utf8" });
+    entries = await readdir8(resolvedDirectory, { encoding: "utf8" });
   } catch (error) {
     if (error.code === "ENOENT") {
       return { directory: resolvedDirectory, loaded, errors };
@@ -12006,13 +12736,13 @@ async function reloadUserThemes(directory = userThemeDirectory()) {
   }
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const path = join18(resolvedDirectory, entry);
+    const path = join19(resolvedDirectory, entry);
     try {
-      const info = await lstat19(path);
+      const info = await lstat20(path);
       if (!info.isFile() || info.isSymbolicLink() || info.size > 64e3) {
         throw new Error("must be a regular JSON file smaller than 64 KB");
       }
-      const parsed = JSON.parse(await readFile15(path, "utf8"));
+      const parsed = JSON.parse(await readFile16(path, "utf8"));
       const name = themeName(parsed, basename9(entry, ".json"));
       if (builtInThemeNames.has(name)) throw new Error(`cannot replace built-in theme \`${name}\``);
       themes[name] = defineTheme(themeSeed(parsed, name));
@@ -12025,7 +12755,7 @@ async function reloadUserThemes(directory = userThemeDirectory()) {
   return { directory: resolvedDirectory, loaded, errors };
 }
 function userThemeDirectory(environment = process.env) {
-  return environment.SKEIN_THEME_DIR ?? environment.MOSAIC_THEME_DIR ?? join18(resolveHomeNamespace(environment), "themes");
+  return environment.SKEIN_THEME_DIR ?? environment.MOSAIC_THEME_DIR ?? join19(resolveHomeNamespace(environment), "themes");
 }
 var defaultTheme = themes.graphite;
 var palette = {
@@ -13252,9 +13982,9 @@ function safeWidth(width) {
 }
 
 // src/utils/update-check.ts
-import { mkdir as mkdir9, readFile as readFile16, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join19 } from "node:path";
-import stripAnsi2 from "strip-ansi";
+import { mkdir as mkdir9, readFile as readFile17, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join20 } from "node:path";
+import stripAnsi3 from "strip-ansi";
 var PACKAGE_NAME = "@skein-code/cli";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 var CACHE_FILE = "update-check.json";
@@ -13269,7 +13999,7 @@ function sanitizeHighlights(value) {
   const cleaned = [];
   for (const entry of value) {
     if (typeof entry !== "string") continue;
-    const flattened = stripAnsi2(entry).replace(BIDI_CONTROLS, "").replace(/[\u0000-\u001f\u007f-\u009f]/gu, " ").replace(/\s+/gu, " ").trim();
+    const flattened = stripAnsi3(entry).replace(BIDI_CONTROLS, "").replace(/[\u0000-\u001f\u007f-\u009f]/gu, " ").replace(/\s+/gu, " ").trim();
     if (!flattened || flattened.length > MAX_HIGHLIGHT_LENGTH) continue;
     cleaned.push(flattened);
     if (cleaned.length >= MAX_HIGHLIGHTS) break;
@@ -13333,7 +14063,7 @@ function compareVersions(a, b) {
   return 0;
 }
 function updateCachePath(env = process.env) {
-  return join19(resolveHomeNamespace(env), CACHE_FILE);
+  return join20(resolveHomeNamespace(env), CACHE_FILE);
 }
 function upgradeCommand() {
   return `npm i -g ${PACKAGE_NAME}`;
@@ -13350,7 +14080,7 @@ function noticeIfNewer(latest, current, highlights) {
 }
 async function readUpdateCache(env = process.env) {
   try {
-    const raw = await readFile16(updateCachePath(env), "utf8");
+    const raw = await readFile17(updateCachePath(env), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt === "number" && Number.isFinite(parsed.checkedAt) && parsed.checkedAt >= 0 && (parsed.latest === null || typeof parsed.latest === "string" && parseVersion(parsed.latest))) {
       const latest = typeof parsed.latest === "string" ? parsed.latest : null;
@@ -14431,7 +15161,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
     return () => clearInterval(timer);
   }, [busy]);
   const requestPermission = useCallback((call, category) => {
-    return new Promise((resolve23) => setPermission({ call, category, resolve: resolve23 }));
+    return new Promise((resolve24) => setPermission({ call, category, resolve: resolve24 }));
   }, []);
   const onEvent = useCallback((event) => {
     switch (event.type) {
@@ -15255,8 +15985,8 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
   }, [append]);
   function settlePermission(grant, stop = false) {
     if (!permission) return;
-    const { call, category, resolve: resolve23 } = permission;
-    resolve23(grant);
+    const { call, category, resolve: resolve24 } = permission;
+    resolve24(grant);
     setPermission(void 0);
     if (grant === "session") {
       append({
@@ -16591,24 +17321,24 @@ async function runFirstRunOnboarding(initialConfig, options = {}) {
 }
 
 // src/runtime/extensions.ts
-import { resolve as resolve21 } from "node:path";
+import { resolve as resolve22 } from "node:path";
 
 // src/mcp/manager.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import stripAnsi4 from "strip-ansi";
+import stripAnsi5 from "strip-ansi";
 
 // src/mcp/tool.ts
-import { createHash as createHash13 } from "node:crypto";
-import stripAnsi3 from "strip-ansi";
+import { createHash as createHash14 } from "node:crypto";
+import stripAnsi4 from "strip-ansi";
 var MAX_ARGUMENT_BYTES = 256e3;
 var MAX_DESCRIPTION_LENGTH = 4e3;
-var MAX_RESULT_LENGTH = 8e4;
+var MAX_RESULT_BYTES = 5 * 1024 * 1024;
 var MAX_SCHEMA_BYTES = 1e5;
 function createMcpToolAdapter(options) {
   const { remoteTool } = options;
-  const inputSchema11 = copyInputSchema(remoteTool.inputSchema);
+  const inputSchema12 = copyInputSchema(remoteTool.inputSchema);
   return {
     definition: {
       name: options.exposedName,
@@ -16616,7 +17346,7 @@ function createMcpToolAdapter(options) {
       // MCP servers are an external trust boundary. Read-only annotations are
       // hints from that server and must not lower the local permission level.
       category: "network",
-      inputSchema: inputSchema11
+      inputSchema: inputSchema12
     },
     permissionCategories: () => ["network"],
     async execute(arguments_, context) {
@@ -16636,6 +17366,8 @@ function createMcpToolAdapter(options) {
         metadata: {
           mcpServer: options.serverName,
           mcpTool: remoteTool.name,
+          sourceBytes: normalized.sourceBytes,
+          sourceTruncated: normalized.sourceTruncated,
           ...normalized.isError ? { mcpError: true } : {}
         }
       };
@@ -16665,8 +17397,8 @@ function isUsableRemoteTool(tool) {
   }
 }
 function describeTool(serverName, tool) {
-  const label = stripAnsi3(tool.title?.trim() || tool.name).replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 200);
-  const description = tool.description ? stripAnsi3(tool.description).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ").trim().slice(0, MAX_DESCRIPTION_LENGTH) : void 0;
+  const label = stripAnsi4(tool.title?.trim() || tool.name).replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 200);
+  const description = tool.description ? stripAnsi4(tool.description).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ").trim().slice(0, MAX_DESCRIPTION_LENGTH) : void 0;
   return description ? `[MCP ${serverName}/${label}] ${description}` : `Call the ${label} tool provided by the ${serverName} MCP server.`;
 }
 function copyInputSchema(schema) {
@@ -16689,7 +17421,7 @@ function assertArguments(arguments_) {
 }
 function normalizeCallResult(result) {
   if (!isRecord2(result)) {
-    return { content: truncateResult(safeJson(result)), isError: false };
+    return boundResult(safeJson(result), false);
   }
   const isError = result.isError === true;
   const sections = [];
@@ -16705,7 +17437,22 @@ ${safeJson(result.structuredContent)}`);
 ${safeJson(result.toolResult)}`);
   }
   const content = sections.filter(Boolean).join("\n\n") || (isError ? "The MCP tool reported an error." : "The MCP tool completed without output.");
-  return { content: truncateResult(content), isError };
+  return boundResult(content, isError);
+}
+function boundResult(content, isError) {
+  const sourceBytes = Buffer.byteLength(content);
+  if (sourceBytes <= MAX_RESULT_BYTES) {
+    return { content, isError, sourceBytes, sourceTruncated: false };
+  }
+  const marker = `
+... ${sourceBytes - MAX_RESULT_BYTES} or more source bytes omitted by the MCP safety limit ...
+`;
+  const markerBytes = Buffer.byteLength(marker);
+  const available = MAX_RESULT_BYTES - markerBytes;
+  const headBytes = Math.floor(available * 0.6);
+  const tailBytes = available - headBytes;
+  const bounded = `${sliceUtf8Start(content, headBytes)}${marker}${sliceUtf8End(content, tailBytes)}`;
+  return { content: bounded, isError, sourceBytes, sourceTruncated: true };
 }
 function formatContentBlock(block) {
   if (!isRecord2(block) || typeof block.type !== "string") return safeJson(block);
@@ -16753,15 +17500,10 @@ function fitToolName(name, identity) {
   return `${name.slice(0, 64 - suffix.length).replace(/_+$/g, "")}${suffix}`;
 }
 function shortHash(value) {
-  return createHash13("sha256").update(value).digest("hex").slice(0, 8);
-}
-function truncateResult(content) {
-  if (content.length <= MAX_RESULT_LENGTH) return content;
-  return `${content.slice(0, MAX_RESULT_LENGTH)}
-... MCP result truncated`;
+  return createHash14("sha256").update(value).digest("hex").slice(0, 8);
 }
 function sanitizeOutputText(value) {
-  return stripAnsi3(value).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+  return stripAnsi4(value).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
 }
 function sanitizeInlineText(value) {
   return sanitizeOutputText(value).replace(/[\r\n\t]+/g, " ").trim().slice(0, 2e3);
@@ -16773,13 +17515,25 @@ function safeJson(value) {
     return String(value);
   }
 }
+function sliceUtf8Start(value, maxBytes) {
+  const buffer = Buffer.from(value);
+  let end = Math.min(buffer.length, maxBytes);
+  while (end > 0 && (buffer[end] ?? 0) >= 128 && (buffer[end] ?? 0) < 192) end -= 1;
+  return buffer.subarray(0, end).toString("utf8");
+}
+function sliceUtf8End(value, maxBytes) {
+  const buffer = Buffer.from(value);
+  let start = Math.max(0, buffer.length - maxBytes);
+  while (start < buffer.length && (buffer[start] ?? 0) >= 128 && (buffer[start] ?? 0) < 192) start += 1;
+  return buffer.subarray(start).toString("utf8");
+}
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/mcp/validation.ts
 import { stat as stat10, realpath as realpath8 } from "node:fs/promises";
-import { isAbsolute as isAbsolute6, resolve as resolve19 } from "node:path";
+import { isAbsolute as isAbsolute6, resolve as resolve20 } from "node:path";
 var SERVER_NAME = /^[a-z][a-z0-9_-]{0,63}$/;
 var ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var HEADER_NAME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
@@ -16851,9 +17605,9 @@ async function validateCwd(configured, options) {
   if (configured !== void 0 && (configured.length > 4e3 || CONTROL_CHARACTERS.test(configured))) {
     throw new Error("MCP working directory is invalid or too long");
   }
-  const defaultCwd = resolve19(options.cwd ?? process.cwd());
-  const candidate = configured ? isAbsolute6(configured) ? resolve19(configured) : resolve19(defaultCwd, configured) : defaultCwd;
-  const roots = options.workspaceRoots?.length ? options.workspaceRoots.map((root) => resolve19(root)) : [defaultCwd];
+  const defaultCwd = resolve20(options.cwd ?? process.cwd());
+  const candidate = configured ? isAbsolute6(configured) ? resolve20(configured) : resolve20(defaultCwd, configured) : defaultCwd;
+  const roots = options.workspaceRoots?.length ? options.workspaceRoots.map((root) => resolve20(root)) : [defaultCwd];
   const resolvedCandidate = await realpath8(candidate).catch(() => {
     throw new Error(`MCP working directory does not exist: ${candidate}`);
   });
@@ -17191,7 +17945,7 @@ var McpManager = class {
       stderr: "pipe"
     });
     transport.stderr?.on("data", (chunk) => {
-      const text = stripAnsi4(chunk.toString()).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").trim();
+      const text = stripAnsi5(chunk.toString()).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").trim();
       if (text) this.options.logger?.(`MCP ${name} stderr`, { text: text.slice(0, 2e3) });
     });
     return transport;
@@ -17350,7 +18104,7 @@ function errorMessage2(error) {
   return sanitizeStatusText(message2) || "Unknown MCP error";
 }
 function sanitizeStatusText(value) {
-  return stripAnsi4(value).replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, 1e3);
+  return stripAnsi5(value).replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, 1e3);
 }
 function timeoutError(timeoutMs) {
   const error = new Error(`MCP request timed out after ${timeoutMs} ms`);
@@ -17376,9 +18130,9 @@ async function closeTransportQuietly(transport) {
 }
 
 // src/memory/tools.ts
-import { z as z17 } from "zod";
-var scopeSchema = z17.enum(["user", "workspace", "session", "agent"]);
-var kindSchema = z17.enum(["semantic", "episodic", "procedural"]);
+import { z as z19 } from "zod";
+var scopeSchema = z19.enum(["user", "workspace", "session", "agent"]);
+var kindSchema = z19.enum(["semantic", "episodic", "procedural"]);
 function createMemoryTools(store) {
   return [
     {
@@ -17393,10 +18147,10 @@ function createMemoryTools(store) {
         }, ["query"])
       },
       async execute(arguments_, context) {
-        const input2 = z17.object({
-          query: z17.string().max(4e3),
+        const input2 = z19.object({
+          query: z19.string().max(4e3),
           scope: scopeSchema.optional(),
-          limit: z17.number().int().min(1).max(20).optional()
+          limit: z19.number().int().min(1).max(20).optional()
         }).parse(arguments_);
         const scopes = input2.scope ? [{ scope: input2.scope, scopeKey: scopeKey(input2.scope, context) }] : availableScopes(context);
         const records = store.search(input2.query, { scopes, limit: input2.limit ?? 8 });
@@ -17428,17 +18182,17 @@ ${record.content}`
         }, ["content", "rationale"])
       },
       async execute(arguments_, context) {
-        const input2 = z17.object({
-          content: z17.string().min(1).max(12e3),
-          rationale: z17.string().min(1).max(1e3),
+        const input2 = z19.object({
+          content: z19.string().min(1).max(12e3),
+          rationale: z19.string().min(1).max(1e3),
           scope: scopeSchema.optional(),
           kind: kindSchema.optional(),
-          tags: z17.array(z17.string()).max(24).optional(),
-          importance: z17.number().min(0).max(1).optional(),
-          confidence: z17.number().min(0).max(1).optional(),
-          agent: z17.string().max(64).optional(),
-          revision: z17.string().max(240).optional(),
-          conflictKey: z17.string().max(240).optional()
+          tags: z19.array(z19.string()).max(24).optional(),
+          importance: z19.number().min(0).max(1).optional(),
+          confidence: z19.number().min(0).max(1).optional(),
+          agent: z19.string().max(64).optional(),
+          revision: z19.string().max(240).optional(),
+          conflictKey: z19.string().max(240).optional()
         }).strict().parse(arguments_);
         const scope = input2.scope ?? "workspace";
         const candidate = store.propose({
@@ -17476,9 +18230,9 @@ ${record.content}`
         }, ["id"])
       },
       async execute(arguments_) {
-        const input2 = z17.object({
-          id: z17.string().uuid(),
-          permanent: z17.boolean().optional()
+        const input2 = z19.object({
+          id: z19.string().uuid(),
+          permanent: z19.boolean().optional()
         }).parse(arguments_);
         const changed = input2.permanent ? store.remove(input2.id) : store.archive(input2.id);
         return {
@@ -17505,9 +18259,9 @@ function scopeKey(scope, context) {
 }
 
 // src/skills/catalog.ts
-import { lstat as lstat20, readFile as readFile17, readdir as readdir8, realpath as realpath9 } from "node:fs/promises";
+import { lstat as lstat21, readFile as readFile18, readdir as readdir9, realpath as realpath9 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { basename as basename11, join as join20, resolve as resolve20 } from "node:path";
+import { basename as basename11, join as join21, resolve as resolve21 } from "node:path";
 import { parse as parseYaml3 } from "yaml";
 var SkillCatalog = class {
   constructor(workspace, config) {
@@ -17527,7 +18281,7 @@ var SkillCatalog = class {
     for (const location of locations) {
       const entries = await safeDirectories(location.path);
       for (const entry of entries) {
-        const skillPath = join20(location.path, entry, "SKILL.md");
+        const skillPath = join21(location.path, entry, "SKILL.md");
         const metadata = await readMetadata(skillPath);
         if (!metadata) continue;
         const descriptor = {
@@ -17576,31 +18330,31 @@ ${skill.content}
 }
 function discoveryLocations(workspace, configured) {
   const home = homedir4();
-  const workspaceRoot = resolve20(workspace);
+  const workspaceRoot = resolve21(workspace);
   return [
-    { path: join20(home, ".agents", "skills"), scope: "user", trusted: true },
-    { path: join20(home, ".claude", "skills"), scope: "user", trusted: true },
-    { path: join20(home, ".augment", "skills"), scope: "user", trusted: true },
-    { path: join20(resolveHomeNamespace(), "skills"), scope: "user", trusted: true },
+    { path: join21(home, ".agents", "skills"), scope: "user", trusted: true },
+    { path: join21(home, ".claude", "skills"), scope: "user", trusted: true },
+    { path: join21(home, ".augment", "skills"), scope: "user", trusted: true },
+    { path: join21(resolveHomeNamespace(), "skills"), scope: "user", trusted: true },
     ...configured.map((path) => {
-      const resolved = resolve20(workspaceRoot, path);
+      const resolved = resolve21(workspaceRoot, path);
       return {
         path: resolved,
         scope: "configured",
         trusted: !isInside(workspaceRoot, resolved)
       };
     }),
-    { path: join20(workspace, ".agents", "skills"), scope: "workspace", trusted: false },
-    { path: join20(workspace, ".claude", "skills"), scope: "workspace", trusted: false },
-    { path: join20(workspace, ".augment", "skills"), scope: "workspace", trusted: false },
-    { path: join20(resolveProjectNamespaceSync(workspaceRoot).active, "skills"), scope: "workspace", trusted: false }
+    { path: join21(workspace, ".agents", "skills"), scope: "workspace", trusted: false },
+    { path: join21(workspace, ".claude", "skills"), scope: "workspace", trusted: false },
+    { path: join21(workspace, ".augment", "skills"), scope: "workspace", trusted: false },
+    { path: join21(resolveProjectNamespaceSync(workspaceRoot).active, "skills"), scope: "workspace", trusted: false }
   ];
 }
 async function safeDirectories(path) {
   try {
-    const info = await lstat20(path);
+    const info = await lstat21(path);
     if (!info.isDirectory() || info.isSymbolicLink()) return [];
-    const entries = await readdir8(path, { withFileTypes: true });
+    const entries = await readdir9(path, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory() && !entry.isSymbolicLink()).map((entry) => entry.name).slice(0, 500);
   } catch {
     return [];
@@ -17612,7 +18366,7 @@ async function readMetadata(path) {
   const { frontmatter } = splitFrontmatter(raw);
   if (!frontmatter) return void 0;
   const parsed = parseYaml3(frontmatter);
-  const name = typeof parsed?.name === "string" ? parsed.name.trim() : basename11(resolve20(path, ".."));
+  const name = typeof parsed?.name === "string" ? parsed.name.trim() : basename11(resolve21(path, ".."));
   const description = typeof parsed?.description === "string" ? parsed.description.trim() : "";
   if (!/^[a-z][a-z0-9_-]{0,63}$/.test(name) || !description || description.length > 1e3) {
     return void 0;
@@ -17631,13 +18385,13 @@ async function readSkill(path, maxChars) {
 }
 async function safeRead(path, maxBytes) {
   try {
-    const info = await lstat20(path);
+    const info = await lstat21(path);
     if (!info.isFile() || info.isSymbolicLink() || info.size > maxBytes) return void 0;
-    const parent = resolve20(path, "..");
+    const parent = resolve21(path, "..");
     const resolvedParent = await realpath9(parent);
     const resolvedPath = await realpath9(path);
     if (!resolvedPath.startsWith(`${resolvedParent}/`)) return void 0;
-    return await readFile17(path, "utf8");
+    return await readFile18(path, "utf8");
   } catch {
     return void 0;
   }
@@ -17682,7 +18436,7 @@ function escapeAttribute6(value) {
 }
 
 // src/workflows/catalog.ts
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 var builtInWorkflows = [
   {
     name: "implement",
@@ -17773,7 +18527,7 @@ function createWorkflowTool(catalog) {
       }, ["name", "task"])
     },
     async execute(arguments_) {
-      const input2 = z18.object({ name: z18.string(), task: z18.string().min(1).max(2e4) }).parse(arguments_);
+      const input2 = z20.object({ name: z20.string(), task: z20.string().min(1).max(2e4) }).parse(arguments_);
       const workflow = catalog.get(input2.name);
       if (!workflow) return { ok: false, content: `Unknown workflow: ${input2.name}` };
       return {
@@ -17818,7 +18572,7 @@ var ExtensionRuntime = class _ExtensionRuntime {
   delegation;
   initialized = false;
   static async create(config, registry, options = {}) {
-    const runtime = new _ExtensionRuntime(config, resolve21(config.workspaceRoots[0] ?? process.cwd()), options);
+    const runtime = new _ExtensionRuntime(config, resolve22(config.workspaceRoots[0] ?? process.cwd()), options);
     try {
       await runtime.initialize(registry, options.signal);
       return runtime;
@@ -18023,15 +18777,15 @@ function upgradeCommandOverride(env = process.env) {
   return trimmed ? trimmed : void 0;
 }
 function runUpgrade(plan) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     const child = spawn2(plan.command, plan.args, {
       stdio: "inherit",
       shell: plan.shell ?? false
     });
-    child.on("error", () => resolve23({ ok: false, exitCode: 127, display: plan.display }));
+    child.on("error", () => resolve24({ ok: false, exitCode: 127, display: plan.display }));
     child.on("close", (code) => {
       const exitCode = code ?? 1;
-      resolve23({ ok: exitCode === 0, exitCode, display: plan.display });
+      resolve24({ ok: exitCode === 0, exitCode, display: plan.display });
     });
   });
 }
@@ -18280,9 +19034,11 @@ sessionCommand.command("show <id>").description("Show a saved session transcript
   else process.stdout.write(sessionMarkdown(session));
 });
 sessionCommand.command("delete <id>").description("Delete a saved session").option("-w, --workspace <path>", "workspace root").option("--yes", "skip confirmation").action(async (id, options) => {
-  const store = new SessionStore(workspaceOption(options.workspace));
+  const workspace = workspaceOption(options.workspace);
+  const store = new SessionStore(workspace);
   const session = await requireSessionSelector(store, id);
   if (!options.yes && !await confirm(`Delete session ${session.id.slice(0, 8)}?`)) return;
+  await new ToolArtifactStore(workspace).removeSession(session.id);
   await store.remove(session.id);
   process.stdout.write(`Deleted ${session.id}
 `);
@@ -18291,7 +19047,7 @@ sessionCommand.command("export <id>").description("Export a session as Markdown"
   const store = new SessionStore(workspaceOption(options.workspace));
   const session = await requireSessionSelector(store, id);
   const markdown = sessionMarkdown(session);
-  if (options.output) await writeFile3(resolve22(options.output), markdown, "utf8");
+  if (options.output) await writeFile3(resolve23(options.output), markdown, "utf8");
   else process.stdout.write(markdown);
 });
 var checkpointCommand = program.command("checkpoint").description("Inspect and restore pre-mutation snapshots");
@@ -18668,7 +19424,7 @@ async function runChat(prompts, options) {
   const stdinPrompt = !process.stdin.isTTY ? await readStdin() : "";
   const firstPrompt = [...prompts, stdinPrompt].filter(Boolean).join("\n\n").trim();
   if (shouldPrint && !firstPrompt) throw new Error("Provide a prompt argument or pipe input on stdin.");
-  const workspace = resolve22(options.workspace);
+  const workspace = resolve23(options.workspace);
   let config = await runtimeConfig(workspace, options);
   let completedOnboarding = false;
   if (!shouldPrint && needsFirstRunOnboarding(config)) {
@@ -18893,14 +19649,14 @@ async function runAgentSetup(options) {
 `);
 }
 async function runtimeConfig(workspaceInput, options) {
-  const workspace = resolve22(workspaceInput);
+  const workspace = resolve23(workspaceInput);
   const loaded = await loadConfig(workspace, options.config, {
     trustProjectConfig: options.trustProjectConfig === true
   });
   const roots = [
     workspace,
     ...loaded.workspaceRoots,
-    ...(options.addWorkspace ?? []).map((root) => resolve22(workspace, root))
+    ...(options.addWorkspace ?? []).map((root) => resolve23(workspace, root))
   ];
   const provider = options.provider ? validateProvider(options.provider) : loaded.model.provider;
   return {
@@ -19056,7 +19812,7 @@ function collect(value, previous) {
 }
 function workspaceOption(value) {
   const rootOptions = program.opts();
-  return resolve22(value ?? rootOptions.workspace ?? process.cwd());
+  return resolve23(value ?? rootOptions.workspace ?? process.cwd());
 }
 function runtimeOptions(options) {
   const root = program.opts();