@skein-code/cli 0.3.9 → 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.9",
+  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: [
-      "First-run context preparation now shows the real inspect, build, persist, and verify stages",
-      "Fresh sessions add a compact Skein identity and grouped workspace rail without filling the terminal",
-      "Short and narrow terminals collapse the index handoff while preserving validation and recovery states"
+      "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,
@@ -3279,7 +3279,7 @@ function formatContextHits(hits, roots) {
 }
 
 // src/agent/runner.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 
 // src/context/manager.ts
 var RECENT_TURN_RESERVE = 3;
@@ -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"]),
@@ -4974,6 +4990,19 @@ var lastRunSchema = z5.object({
   checks: z5.array(verificationEvidenceSchema),
   detail: z5.string(),
   mutationTracking: z5.enum(["complete", "unknown"]).optional(),
+  acceptance: z5.object({
+    state: z5.enum(["draft", "active", "satisfied", "blocked"]),
+    total: z5.number().int().nonnegative(),
+    satisfied: z5.number().int().nonnegative(),
+    pending: z5.number().int().nonnegative(),
+    blocked: z5.number().int().nonnegative(),
+    missingVerification: z5.array(z5.string()),
+    unresolved: z5.array(z5.object({
+      id: z5.string(),
+      description: z5.string(),
+      status: z5.enum(["pending", "satisfied", "blocked"])
+    }).strict())
+  }).strict().optional(),
   reason: z5.string(),
   finishedAt: z5.string()
 }).strict();
@@ -4986,6 +5015,27 @@ var workingMemorySchema = z5.object({
   relevantFiles: z5.array(z5.string()),
   lastUpdatedAt: z5.string()
 }).strict();
+var taskContractCriterionSchema = z5.object({
+  id: z5.string().min(1).max(128),
+  description: z5.string().min(1).max(2e3),
+  required: z5.boolean(),
+  status: z5.enum(["pending", "satisfied", "blocked"]),
+  evidenceRefs: z5.array(z5.string().min(1).max(256)).max(64),
+  note: z5.string().max(2e3).optional()
+}).strict();
+var taskContractSchema = z5.object({
+  version: z5.literal(1),
+  state: z5.enum(["draft", "active", "satisfied", "blocked"]),
+  objective: z5.string().min(1).max(2e4),
+  scope: z5.array(z5.string().min(1).max(2e3)).max(64),
+  constraints: z5.array(z5.string().min(1).max(2e3)).max(64),
+  nonGoals: z5.array(z5.string().min(1).max(2e3)).max(64),
+  acceptanceCriteria: z5.array(taskContractCriterionSchema).min(1).max(64),
+  verificationRequirements: z5.array(z5.string().min(1).max(2e3)).max(64),
+  createdAt: z5.string(),
+  updatedAt: z5.string(),
+  auditBoundaryId: z5.string().min(1).max(128).optional()
+}).strict();
 var sessionSchema = z5.object({
   id: sessionIdSchema,
   title: z5.string(),
@@ -5003,6 +5053,8 @@ 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({
     inputTokens: z5.number().nonnegative(),
@@ -5263,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: {
@@ -5525,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;
@@ -5577,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",
@@ -5796,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 {
       }
     }
@@ -5817,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 {
           }
         }
@@ -5898,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 {
     }
   }
@@ -6014,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 }
     );
   }
@@ -6067,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/**",
@@ -6126,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);
@@ -6147,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: {
@@ -6177,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");
@@ -6221,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();
@@ -6268,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/**",
@@ -6315,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.");
@@ -6339,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;
@@ -6349,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;
@@ -6421,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: {
@@ -6448,7 +6944,7 @@ var shellTool = {
     }, ["command"])
   },
   permissionCategories(arguments_) {
-    const input2 = inputSchema7.parse(arguments_);
+    const input2 = inputSchema8.parse(arguments_);
     validateEnvironment(input2.env);
     return [
       "shell",
@@ -6458,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) : [];
@@ -6503,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,
@@ -6513,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 } : {}
@@ -6576,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;
       }
@@ -6604,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 };
@@ -6620,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;
@@ -6652,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);
       }
@@ -6673,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: {
@@ -6715,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":
@@ -6751,126 +7251,97 @@ var taskTool = {
   }
 };
 
-// src/tools/working-memory.ts
-import { z as z13 } from "zod";
-var inputSchema9 = z13.discriminatedUnion("action", [
-  z13.object({ action: z13.literal("show") }).strict(),
-  z13.object({ action: z13.literal("set_goal"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("set_focus"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("add_constraint"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("add_decision"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("add_question"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("resolve_question"), value: z13.string().min(1).max(1e3) }).strict(),
-  z13.object({ action: z13.literal("add_file"), path: z13.string().min(1).max(4e3) }).strict(),
-  z13.object({ action: z13.literal("clear"), field: z13.enum(["constraints", "decisions", "openQuestions", "relevantFiles"]) }).strict()
-]);
-var workingMemoryTool = {
-  definition: {
-    name: "working_memory",
-    description: "Read or update short-term thread state: goal, focus, constraints, decisions, open questions, and relevant files. This state is temporary and is not durable memory.",
-    category: "read",
-    inputSchema: jsonSchema({
-      action: { type: "string", enum: [
-        "show",
-        "set_goal",
-        "set_focus",
-        "add_constraint",
-        "add_decision",
-        "add_question",
-        "resolve_question",
-        "add_file",
-        "clear"
-      ] },
-      value: { type: "string", description: "Text for a goal, focus, constraint, decision, or question." },
-      path: { type: "string", description: "Workspace-relative relevant file path." },
-      field: { type: "string", enum: ["constraints", "decisions", "openQuestions", "relevantFiles"] }
-    }, ["action"])
-  },
-  async execute(arguments_, context) {
-    const input2 = inputSchema9.parse(arguments_);
-    const memory = context.session.workingMemory ?? emptyWorkingMemory2();
-    switch (input2.action) {
-      case "show":
-        break;
-      case "set_goal":
-        memory.goal = clean(input2.value);
-        break;
-      case "set_focus":
-        memory.focus = clean(input2.value);
-        break;
-      case "add_constraint":
-        pushBounded2(memory.constraints, input2.value, 12);
-        break;
-      case "add_decision":
-        pushBounded2(memory.decisions, input2.value, 12);
-        break;
-      case "add_question":
-        pushBounded2(memory.openQuestions, input2.value, 12);
-        break;
-      case "resolve_question":
-        removeMatching(memory.openQuestions, input2.value);
-        break;
-      case "add_file": {
-        const safe = await context.workspace.resolvePath(input2.path, { expect: "any" });
-        pushBounded2(memory.relevantFiles, safe, 24);
-        break;
-      }
-      case "clear":
-        memory[input2.field] = [];
-        break;
-    }
-    memory.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    context.session.workingMemory = memory;
-    return { content: render(memory), metadata: { workingMemory: { ...memory } } };
-  }
-};
-function emptyWorkingMemory2() {
+// src/tools/task-contract.ts
+import { randomUUID as randomUUID11 } from "node:crypto";
+import { z as z15 } from "zod";
+
+// src/agent/task-contract.ts
+import { randomUUID as randomUUID10 } from "node:crypto";
+var EXECUTABLE_INTENTS = /* @__PURE__ */ new Set(["debug", "refactor", "test", "implement"]);
+function shouldUseTaskContract(request, intent, existing) {
+  if (existing && existing.state !== "satisfied") return true;
+  if (!EXECUTABLE_INTENTS.has(intent)) return false;
+  const value = request.trim();
+  if (value.length < 180) return false;
+  const requirements = value.split(/(?:\n+|[；;。]\s*|\b(?:and|then|also|plus)\b|以及|并且|同时|还要|另外)/iu).filter((item) => item.trim().length >= 12);
+  const complexitySignals = [
+    /\b(?:refactor|migrate|redesign|architecture|end[- ]to[- ]end|across|multiple)\b/iu,
+    /重构|迁移|架构|完整|全链路|多个|跨模块|兼容|同时/iu,
+    /(?:^|\n)\s*(?:[-*]|\d+[.)、])\s+/mu
+  ].filter((pattern) => pattern.test(value)).length;
+  return requirements.length >= 3 || complexitySignals >= 2 || value.length >= 500;
+}
+function createDraftTaskContract(request, auditBoundaryId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const objective = compact(request, 2e3);
   return {
-    goal: "",
-    focus: "",
-    constraints: [],
-    decisions: [],
-    openQuestions: [],
-    relevantFiles: [],
-    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    version: 1,
+    state: "draft",
+    objective,
+    scope: ["Configured workspace roots and the files required by the objective."],
+    constraints: [
+      "Preserve unrelated user changes.",
+      "Use successful tool evidence for acceptance claims."
+    ],
+    nonGoals: [],
+    acceptanceCriteria: [
+      criterion("requested-outcome", `Implement the requested outcome: ${compact(request, 500)}`),
+      criterion("verification", "Run the smallest relevant deterministic verification after the final mutation.")
+    ],
+    verificationRequirements: [
+      "Record at least one successful test, typecheck, lint, build, check, or diff check after the final mutation."
+    ],
+    createdAt: now,
+    updatedAt: now,
+    ...auditBoundaryId ? { auditBoundaryId } : {}
   };
 }
-function pushBounded2(values, value, limit) {
-  const normalized = clean(value);
-  const existing = values.indexOf(normalized);
-  if (existing >= 0) values.splice(existing, 1);
-  values.push(normalized);
-  if (values.length > limit) values.splice(0, values.length - limit);
+function successfulContractEvidence(session) {
+  const refs = /* @__PURE__ */ new Set();
+  const contract = session.taskContract;
+  if (!contract) return refs;
+  for (const event of eventsSinceContract(session.audit ?? [], contract)) {
+    if (event.type !== "tool" || event.outcome !== "success") continue;
+    if (event.tool === "task_contract" || event.tool === "task" || event.tool === "working_memory") continue;
+    refs.add(event.id);
+    refs.add(event.toolCallId);
+  }
+  return refs;
 }
-function removeMatching(values, value) {
-  const query = value.toLocaleLowerCase().trim();
-  for (let index = values.length - 1; index >= 0; index -= 1) {
-    const candidate = values[index];
-    if (candidate.toLocaleLowerCase() === query || candidate.toLocaleLowerCase().includes(query)) {
-      values.splice(index, 1);
-    }
+function eventsSinceContract(audit, contract) {
+  if (contract.auditBoundaryId) {
+    const boundary = audit.findIndex((event) => event.id === contract.auditBoundaryId);
+    if (boundary >= 0) return audit.slice(boundary + 1);
   }
+  return audit.filter((event) => event.createdAt >= contract.createdAt);
 }
-function clean(value) {
-  return value.trim().replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/g, "[redacted-secret]").replace(/\b((?:api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret))\s*[:=]\s*[^\s,;]+/gi, "$1=[redacted]").replace(/\s+/g, " ").slice(0, 1e3);
+function refreshTaskContractState(contract) {
+  const required = contract.acceptanceCriteria.filter((item) => item.required);
+  contract.state = required.some((item) => item.status === "blocked") ? "blocked" : required.length > 0 && required.every((item) => item.status === "satisfied") ? "satisfied" : "active";
+  contract.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
 }
-function render(memory) {
-  return [
-    `Goal: ${memory.goal || "(none)"}`,
-    `Focus: ${memory.focus || "(none)"}`,
-    `Constraints: ${memory.constraints.length ? memory.constraints.join(" \xB7 ") : "(none)"}`,
-    `Decisions: ${memory.decisions.length ? memory.decisions.join(" \xB7 ") : "(none)"}`,
-    `Open questions: ${memory.openQuestions.length ? memory.openQuestions.join(" \xB7 ") : "(none)"}`,
-    `Relevant files: ${memory.relevantFiles.length ? memory.relevantFiles.join(" \xB7 ") : "(none)"}`
-  ].join("\n");
+function criterion(id, description) {
+  return {
+    id: `${id}-${randomUUID10().slice(0, 8)}`,
+    description,
+    required: true,
+    status: "pending",
+    evidenceRefs: []
+  };
+}
+function compact(value, limit) {
+  return value.trim().replace(/\s+/gu, " ").slice(0, limit);
 }
 
+// src/agent/completion-gate.ts
+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) {
@@ -7048,10 +7519,513 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
+// src/agent/completion-gate.ts
+function captureVerification(call, result, changeSequence, configuredCommands) {
+  if (call.name !== "shell" && call.name !== "git") return void 0;
+  const command2 = commandForCall(call);
+  if (!command2) return void 0;
+  const normalized = normalizeCommand2(command2);
+  const configured = new Set(configuredCommands.map(normalizeCommand2));
+  const kind = configured.has(normalized) ? "configured" : classifyVerificationCommand(normalized);
+  if (!kind) return void 0;
+  return {
+    toolCallId: call.id,
+    tool: call.name,
+    command: redactCommand(command2),
+    kind,
+    ok: result.ok,
+    changeSequence,
+    commandKey: createHash10("sha256").update(normalized).digest("hex")
+  };
+}
+function buildRunCompletion(changedFiles, evidence, currentChangeSequence, mutationTracking = "complete", taskContract, audit = []) {
+  const files = [...new Set(changedFiles)];
+  const acceptance = taskContract ? buildAcceptance(taskContract, audit, evidence, currentChangeSequence) : void 0;
+  if (mutationTracking === "unknown") {
+    return {
+      status: "unverified",
+      changedFiles: files,
+      checks: [],
+      detail: files.length ? `Workspace changes were observed, but a dynamic shell command prevented complete mutation tracking for ${fileCount(files.length)}.` : "A dynamic shell command may have changed workspace files, but reliable mutation tracking was unavailable.",
+      mutationTracking,
+      ...acceptance ? { acceptance: acceptanceForCompletion(acceptance, "unverified") } : {}
+    };
+  }
+  if (!files.length) {
+    if (acceptance && acceptanceUnresolved(acceptance)) {
+      return {
+        status: "unverified",
+        changedFiles: [],
+        checks: [],
+        detail: acceptanceDetail(acceptance),
+        acceptance: acceptanceForCompletion(acceptance, "unverified")
+      };
+    }
+    return {
+      status: "no_changes",
+      changedFiles: [],
+      checks: [],
+      detail: "No workspace files changed in this run.",
+      ...acceptance ? { acceptance: acceptanceForCompletion(acceptance, "no_changes") } : {}
+    };
+  }
+  const latestByCommand = /* @__PURE__ */ new Map();
+  for (const item of evidence) {
+    if (item.changeSequence === currentChangeSequence) {
+      latestByCommand.set(item.commandKey, item);
+    }
+  }
+  const checks = [...latestByCommand.values()].map(publicEvidence);
+  if (!checks.length) {
+    return {
+      status: "unverified",
+      changedFiles: files,
+      checks,
+      detail: `No successful verification was recorded after the last change to ${fileCount(files.length)}.`,
+      ...acceptance ? { acceptance: acceptanceForCompletion(acceptance, "unverified") } : {}
+    };
+  }
+  const failures = checks.filter((check) => !check.ok);
+  if (failures.length) {
+    return {
+      status: "verification_failed",
+      changedFiles: files,
+      checks,
+      detail: `${failures.length} of ${checks.length} current verification ${checks.length === 1 ? "check" : "checks"} failed.`,
+      ...acceptance ? { acceptance: acceptanceForCompletion(acceptance, "verification_failed") } : {}
+    };
+  }
+  if (acceptance && acceptanceUnresolved(acceptance)) {
+    return {
+      status: "unverified",
+      changedFiles: files,
+      checks,
+      detail: acceptanceDetail(acceptance),
+      acceptance: acceptanceForCompletion(acceptance, "unverified")
+    };
+  }
+  return {
+    status: "verified",
+    changedFiles: files,
+    checks,
+    detail: `${checks.length} current verification ${checks.length === 1 ? "check" : "checks"} passed for ${fileCount(files.length)}.`,
+    ...acceptance ? { acceptance: acceptanceForCompletion(acceptance, "verified") } : {}
+  };
+}
+function completionRecoveryDirective(completion) {
+  if (completion.acceptance && acceptanceUnresolved(completion.acceptance)) {
+    const unresolved = completion.acceptance.unresolved.map((item) => `- [${item.status}] ${item.id}: ${item.description}`).join("\n");
+    const failed = completion.checks.filter((check) => !check.ok).map((check) => `- ${check.command} (tool call ${check.toolCallId})`).join("\n");
+    return `<runtime-completion-gate status="acceptance_unresolved" authorization="none">
+The run cannot be marked complete while required Task Contract criteria remain unresolved:
+${unresolved || "- Acceptance criteria are satisfied."}${completion.acceptance.missingVerification.length ? `
+Missing required verification:
+${completion.acceptance.missingVerification.map((item) => `- ${item}`).join("\n")}` : ""}${failed ? `
+Current failed checks:
+${failed}` : ""}
+Complete or explicitly block only these criteria. Mark a criterion satisfied through task_contract only with successful tool audit evidence or a successful tool-call id. Run the smallest missing verification after the final mutation. Do not repeat the final summary or claim acceptance from prose alone.
+</runtime-completion-gate>`;
+  }
+  if (completion.status === "verification_failed") {
+    const failed = completion.checks.filter((check) => !check.ok).map((check) => `- ${check.command} (tool call ${check.toolCallId})`).join("\n");
+    return `<runtime-completion-gate status="verification_failed" authorization="none">
+The run cannot be marked complete because current verification failed:
+${failed}
+Inspect the recorded tool output, correct the underlying problem, and rerun the smallest relevant check. Do not repeat the final summary or claim success without a new successful tool result. If the failure cannot be resolved safely, state the exact blocker and leave the result unverified.
+</runtime-completion-gate>`;
+  }
+  const changeSummary = completion.mutationTracking === "unknown" ? "A dynamic shell command could not be mapped to a complete set of workspace changes." : `The run changed ${fileCount(completion.changedFiles.length)}, but no successful verification command was recorded after the last change.`;
+  return `<runtime-completion-gate status="unverified" authorization="none">
+${changeSummary}
+Run the smallest relevant test, typecheck, lint, build, or git diff --check now. Do not repeat the final summary or claim a check passed without a successful tool result. If verification cannot be run safely, state the exact reason and leave the result unverified.
+</runtime-completion-gate>`;
+}
+function buildAcceptance(contract, audit, evidence, currentChangeSequence) {
+  const contractEvents = eventsSinceContract(audit, contract);
+  const successfulEvents = contractEvents.filter(
+    (event) => event.type === "tool" && event.outcome === "success" && event.tool !== "task_contract" && event.tool !== "task" && event.tool !== "working_memory"
+  );
+  const latestMutationIndex = contractEvents.reduce((latest, event, index) => {
+    const changedFiles = event.metadata?.changedFiles;
+    return Array.isArray(changedFiles) && changedFiles.length > 0 ? index : latest;
+  }, -1);
+  const successfulRefs = /* @__PURE__ */ new Map();
+  for (const event of successfulEvents) {
+    const index = contractEvents.indexOf(event);
+    successfulRefs.set(event.id, { event, index });
+    successfulRefs.set(event.toolCallId, { event, index });
+  }
+  const required = contract.acceptanceCriteria.filter((item) => item.required);
+  const normalized = required.map((item) => {
+    const evidenceValid = item.evidenceRefs.some((ref) => {
+      const event = successfulRefs.get(ref);
+      return event !== void 0 && event.index >= latestMutationIndex;
+    });
+    const status = item.status === "satisfied" && !evidenceValid ? "pending" : item.status;
+    return { id: item.id, description: item.description, status };
+  });
+  const satisfied = normalized.filter((item) => item.status === "satisfied").length;
+  const pending = normalized.filter((item) => item.status === "pending").length;
+  const blocked = normalized.filter((item) => item.status === "blocked").length;
+  const currentChecks = evidence.filter((item) => item.changeSequence === currentChangeSequence && item.ok);
+  const requirements = contract.verificationRequirements.length ? contract.verificationRequirements : ["Record at least one successful test, typecheck, lint, build, check, or diff check after the final mutation."];
+  const missingVerification = requirements.filter(
+    (requirement) => !verificationRequirementMet(requirement, currentChecks)
+  );
+  return {
+    state: contract.state === "draft" ? "draft" : blocked > 0 ? "blocked" : pending > 0 || missingVerification.length > 0 ? "active" : "satisfied",
+    total: normalized.length,
+    satisfied,
+    pending,
+    blocked,
+    missingVerification,
+    unresolved: normalized.filter((item) => item.status !== "satisfied")
+  };
+}
+function acceptanceDetail(acceptance) {
+  const parts = [
+    acceptance.pending ? `${acceptance.pending} pending` : "",
+    acceptance.blocked ? `${acceptance.blocked} blocked` : "",
+    acceptance.missingVerification.length ? `${acceptance.missingVerification.length} verification requirements missing` : ""
+  ].filter(Boolean).join(" and ");
+  const unresolved = acceptance.pending + acceptance.blocked;
+  return `Task Contract acceptance is unresolved: ${parts} required ${unresolved === 1 ? "criterion" : "criteria"}.`;
+}
+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 = createHash10("sha256").update(normalized).digest("hex");
+  return checks.some((item) => item.commandKey === commandKey);
+}
+function acceptanceUnresolved(acceptance) {
+  return acceptance.pending > 0 || acceptance.blocked > 0 || acceptance.missingVerification.length > 0;
+}
+function acceptanceForCompletion(acceptance, status) {
+  if (acceptance.state === "draft" || acceptance.state === "blocked" || status === "verified" || status === "no_changes") return acceptance;
+  return acceptance.state === "active" ? acceptance : { ...acceptance, state: "active" };
+}
+function classifyVerificationCommand(command2) {
+  const normalized = normalizeCommand2(command2).toLocaleLowerCase();
+  const segments = normalized.split(/\s*(?:&&|\|\||;)\s*/u).filter(Boolean);
+  if (segments.length > 1) {
+    const kinds = segments.map(classifySingleVerificationCommand);
+    if (kinds.every((kind) => kind !== void 0)) {
+      return kinds.every((kind) => kind === kinds[0]) ? kinds[0] : "check";
+    }
+    return void 0;
+  }
+  return classifySingleVerificationCommand(normalized);
+}
+function classifySingleVerificationCommand(command2) {
+  const value = command2.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+)+/u, "");
+  if (/^git\s+diff\b.*(?:^|\s)--check(?:\s|$)/u.test(value)) return "diff";
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test(?::[^\s]+)?|test|vitest|jest)(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:vitest|jest)(?:\s|$)/u.test(value) || /^(?:python(?:\d+(?:\.\d+)*)?\s+-m\s+)?pytest(?:\s|$)/u.test(value) || /^(?:cargo|go|dotnet|mvn|mvnw|gradle|gradlew)\s+(?:test|verify)(?:\s|$)/u.test(value) || /^(?:make|just|task)\s+(?:test|verify)(?:\s|$)/u.test(value) || /^node\s+--test(?:\s|$)/u.test(value)) return "test";
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:typecheck|type-check|check:types)(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:tsc|pyright|mypy)(?:\s|$)/u.test(value) || /^(?:tsc|pyright|mypy)(?:\s|$)/u.test(value) || /^cargo\s+check(?:\s|$)/u.test(value)) return "typecheck";
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?lint(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:eslint|biome|ruff)(?:\s|$)/u.test(value) || /^(?:eslint|biome\s+check|ruff\s+check|cargo\s+clippy)(?:\s|$)/u.test(value)) return "lint";
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:build|compile)(?:\s|$)/u.test(value) || /^(?:cargo|go|dotnet|mvn|mvnw|gradle|gradlew)\s+build(?:\s|$)/u.test(value) || /^(?:make|just|task)\s+(?:build|compile)(?:\s|$)/u.test(value)) return "build";
+  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?check(?:\s|$)/u.test(value) || /^(?:make|just|task|gradle|gradlew)\s+check(?:\s|$)/u.test(value)) return "check";
+  return void 0;
+}
+function publicEvidence(item) {
+  return {
+    toolCallId: item.toolCallId,
+    tool: item.tool,
+    command: item.command,
+    kind: item.kind,
+    ok: item.ok
+  };
+}
+function normalizeCommand2(command2) {
+  return command2.trim().replace(/[\t ]+/gu, " ");
+}
+function redactCommand(command2) {
+  return command2.replace(/[\u0000-\u001f\u007f-\u009f]/gu, " ").replace(/\b((?:api[_-]?key|access[_-]?token|authorization|password|secret|token))\s*=\s*([^\s]+)/giu, "$1=[redacted]").replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/gu, "[redacted-secret]").trim().slice(0, 2e3);
+}
+function fileCount(count) {
+  return `${count} workspace ${count === 1 ? "file" : "files"}`;
+}
+
+// src/tools/task-contract.ts
+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 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(),
+  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 = {
+  definition: {
+    name: "task_contract",
+    description: "Define and update the durable acceptance contract for a complex executable request. Satisfied criteria require successful tool audit evidence IDs or tool-call IDs.",
+    category: "read",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["show", "replace", "activate", "update_criterion"] },
+        objective: { type: "string" },
+        scope: { type: "array", items: { type: "string" } },
+        constraints: { type: "array", items: { type: "string" } },
+        non_goals: { type: "array", items: { type: "string" } },
+        acceptance_criteria: { type: "array", items: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            description: { type: "string" },
+            required: { type: "boolean" }
+          },
+          required: ["description"],
+          additionalProperties: false
+        } },
+        verification_requirements: {
+          type: "array",
+          minItems: 1,
+          items: { type: "string" },
+          description: "Required verification commands or the standard any-successful-check requirement."
+        },
+        id: { type: "string" },
+        status: { type: "string", enum: ["pending", "satisfied", "blocked"] },
+        evidence_refs: { type: "array", items: { type: "string" } },
+        note: { type: "string" }
+      },
+      required: ["action"],
+      additionalProperties: false
+    }
+  },
+  async execute(arguments_, context) {
+    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") {
+      if (contract.state !== "draft") {
+        throw new Error("Only a draft Task Contract can be replaced.");
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const criteria = input2.acceptance_criteria.map((item) => ({
+        id: item.id ?? `criterion-${randomUUID11().slice(0, 8)}`,
+        description: item.description,
+        required: item.required ?? true,
+        status: "pending",
+        evidenceRefs: []
+      }));
+      if (new Set(criteria.map((item) => item.id)).size !== criteria.length) {
+        throw new Error("Task Contract criterion ids must be unique.");
+      }
+      if (!criteria.some((item) => item.required)) {
+        throw new Error("Task Contract requires at least one required acceptance criterion.");
+      }
+      for (const existing of contract.acceptanceCriteria.filter((item) => item.required)) {
+        const retained = criteria.find((item) => item.id === existing.id);
+        if (!retained || !retained.required || retained.description !== existing.description) {
+          throw new Error(`Required criterion cannot be removed or weakened: ${existing.id}`);
+        }
+      }
+      for (const existing of contract.verificationRequirements) {
+        if (!input2.verification_requirements.includes(existing)) {
+          throw new Error(`Verification requirement cannot be removed: ${existing}`);
+        }
+      }
+      for (const requirement of input2.verification_requirements) {
+        validateVerificationRequirement(requirement);
+      }
+      Object.assign(contract, {
+        version: 1,
+        state: "active",
+        objective: input2.objective,
+        scope: input2.scope,
+        constraints: input2.constraints,
+        nonGoals: input2.non_goals,
+        acceptanceCriteria: criteria,
+        verificationRequirements: input2.verification_requirements,
+        createdAt: contract.createdAt,
+        updatedAt: now,
+        ...contract.auditBoundaryId ? { auditBoundaryId: contract.auditBoundaryId } : {}
+      });
+    } else if (input2.action === "activate") {
+      refreshTaskContractState(contract);
+    } else if (input2.action === "update_criterion") {
+      if (contract.state === "draft") {
+        throw new Error("Activate the draft Task Contract before updating acceptance criteria.");
+      }
+      const criterion2 = contract.acceptanceCriteria.find((item) => item.id === input2.id);
+      if (!criterion2) throw new Error(`Unknown Task Contract criterion id: ${input2.id}`);
+      const refs = [...new Set(input2.evidence_refs ?? [])];
+      if (input2.status === "satisfied") {
+        if (!refs.length) throw new Error("Satisfied criteria require at least one evidence_refs entry.");
+        const valid = successfulContractEvidence(context.session);
+        const invalid = refs.filter((ref) => !valid.has(ref));
+        if (invalid.length) {
+          throw new Error(`Unknown or unsuccessful evidence refs: ${invalid.join(", ")}`);
+        }
+      }
+      criterion2.status = input2.status;
+      criterion2.evidenceRefs = input2.status === "satisfied" ? refs : [];
+      if (input2.note === void 0) delete criterion2.note;
+      else criterion2.note = input2.note;
+      refreshTaskContractState(contract);
+    }
+    return {
+      content: formatContract(contract),
+      metadata: { taskContract: structuredClone(contract) }
+    };
+  }
+};
+function formatContract(contract) {
+  const satisfied = contract.acceptanceCriteria.filter((item) => item.status === "satisfied").length;
+  const criteria = contract.acceptanceCriteria.map(
+    (item) => `- [${item.status}] ${item.id}: ${item.description}`
+  ).join("\n");
+  return `Task Contract: ${contract.state} (${satisfied}/${contract.acceptanceCriteria.length} satisfied)
+Objective: ${contract.objective}
+${criteria}`;
+}
+function validateVerificationRequirement(requirement) {
+  if (/^Record at least one successful (.+) after the final mutation\.?$/iu.test(requirement)) return;
+  if (/\b(?:api[_-]?key|authorization|password|secret|token)\s*=/iu.test(requirement)) {
+    throw new Error("Verification requirements cannot contain credentials.");
+  }
+  if (!classifyVerificationCommand(requirement)) {
+    throw new Error(`Verification requirement is not a recognized deterministic check: ${requirement}`);
+  }
+}
+
+// src/tools/working-memory.ts
+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: {
+    name: "working_memory",
+    description: "Read or update short-term thread state: goal, focus, constraints, decisions, open questions, and relevant files. This state is temporary and is not durable memory.",
+    category: "read",
+    inputSchema: jsonSchema({
+      action: { type: "string", enum: [
+        "show",
+        "set_goal",
+        "set_focus",
+        "add_constraint",
+        "add_decision",
+        "add_question",
+        "resolve_question",
+        "add_file",
+        "clear"
+      ] },
+      value: { type: "string", description: "Text for a goal, focus, constraint, decision, or question." },
+      path: { type: "string", description: "Workspace-relative relevant file path." },
+      field: { type: "string", enum: ["constraints", "decisions", "openQuestions", "relevantFiles"] }
+    }, ["action"])
+  },
+  async execute(arguments_, context) {
+    const input2 = inputSchema11.parse(arguments_);
+    const memory = context.session.workingMemory ?? emptyWorkingMemory2();
+    switch (input2.action) {
+      case "show":
+        break;
+      case "set_goal":
+        memory.goal = clean(input2.value);
+        break;
+      case "set_focus":
+        memory.focus = clean(input2.value);
+        break;
+      case "add_constraint":
+        pushBounded2(memory.constraints, input2.value, 12);
+        break;
+      case "add_decision":
+        pushBounded2(memory.decisions, input2.value, 12);
+        break;
+      case "add_question":
+        pushBounded2(memory.openQuestions, input2.value, 12);
+        break;
+      case "resolve_question":
+        removeMatching(memory.openQuestions, input2.value);
+        break;
+      case "add_file": {
+        const safe = await context.workspace.resolvePath(input2.path, { expect: "any" });
+        pushBounded2(memory.relevantFiles, safe, 24);
+        break;
+      }
+      case "clear":
+        memory[input2.field] = [];
+        break;
+    }
+    memory.lastUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    context.session.workingMemory = memory;
+    return { content: render(memory), metadata: { workingMemory: { ...memory } } };
+  }
+};
+function emptyWorkingMemory2() {
+  return {
+    goal: "",
+    focus: "",
+    constraints: [],
+    decisions: [],
+    openQuestions: [],
+    relevantFiles: [],
+    lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function pushBounded2(values, value, limit) {
+  const normalized = clean(value);
+  const existing = values.indexOf(normalized);
+  if (existing >= 0) values.splice(existing, 1);
+  values.push(normalized);
+  if (values.length > limit) values.splice(0, values.length - limit);
+}
+function removeMatching(values, value) {
+  const query = value.toLocaleLowerCase().trim();
+  for (let index = values.length - 1; index >= 0; index -= 1) {
+    const candidate = values[index];
+    if (candidate.toLocaleLowerCase() === query || candidate.toLocaleLowerCase().includes(query)) {
+      values.splice(index, 1);
+    }
+  }
+}
+function clean(value) {
+  return value.trim().replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/g, "[redacted-secret]").replace(/\b((?:api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret))\s*[:=]\s*[^\s,;]+/gi, "$1=[redacted]").replace(/\s+/g, " ").slice(0, 1e3);
+}
+function render(memory) {
+  return [
+    `Goal: ${memory.goal || "(none)"}`,
+    `Focus: ${memory.focus || "(none)"}`,
+    `Constraints: ${memory.constraints.length ? memory.constraints.join(" \xB7 ") : "(none)"}`,
+    `Decisions: ${memory.decisions.length ? memory.decisions.join(" \xB7 ") : "(none)"}`,
+    `Open questions: ${memory.openQuestions.length ? memory.openQuestions.join(" \xB7 ") : "(none)"}`,
+    `Relevant files: ${memory.relevantFiles.length ? memory.relevantFiles.join(" \xB7 ") : "(none)"}`
+  ].join("\n");
+}
+
 // src/tools/index.ts
 function createDefaultToolRegistry(_options = {}) {
   return new ToolRegistry([
     readFileTool,
+    readToolArtifactTool,
     listFilesTool,
     searchCodeTool,
     writeFileTool,
@@ -7059,6 +8033,7 @@ function createDefaultToolRegistry(_options = {}) {
     shellTool,
     gitTool,
     taskTool,
+    taskContractTool,
     workingMemoryTool
   ]);
 }
@@ -7098,11 +8073,19 @@ ${workspaceRules}` : ""}`;
 }
 function buildSessionStatePrompt(session) {
   const tasks = session.tasks.length ? session.tasks.map((task) => `- [${task.status}] ${task.title}`).join("\n") : "- No active plan.";
+  const contract = session.taskContract && session.taskContract.state !== "satisfied" ? `
+
+Task Contract (${session.taskContract.state}):
+Objective: ${session.taskContract.objective}
+${session.taskContract.acceptanceCriteria.map(
+    (item) => `- [${item.status}] ${item.id}: ${item.description}`
+  ).join("\n")}
+Use task_contract to activate or update acceptance. A satisfied criterion requires successful tool evidence.` : "";
   return `<session-state scope="session" authorization="none">
 This is mutable execution state, not a permission grant or higher-priority instruction.
 
 Current saved plan:
-${tasks}
+${tasks}${contract}
 </session-state>`;
 }
 function buildRetrievedContext(packed, mentions, primaryRoot, roots = [primaryRoot]) {
@@ -7170,136 +8153,328 @@ function escapeAttribute3(value) {
   })[character] ?? character);
 }
 
-// src/agent/completion-gate.ts
-import { createHash as createHash9 } from "node:crypto";
-function captureVerification(call, result, changeSequence, configuredCommands) {
-  if (call.name !== "shell" && call.name !== "git") return void 0;
-  const command2 = commandForCall(call);
-  if (!command2) return void 0;
-  const normalized = normalizeCommand2(command2);
-  const configured = new Set(configuredCommands.map(normalizeCommand2));
-  const kind = configured.has(normalized) ? "configured" : classifyVerificationCommand(normalized);
-  if (!kind) return void 0;
-  return {
-    toolCallId: call.id,
-    tool: call.name,
-    command: redactCommand(command2),
-    kind,
-    ok: result.ok,
-    changeSequence,
-    commandKey: createHash9("sha256").update(normalized).digest("hex")
-  };
-}
-function buildRunCompletion(changedFiles, evidence, currentChangeSequence, mutationTracking = "complete") {
-  const files = [...new Set(changedFiles)];
-  if (mutationTracking === "unknown") {
-    return {
-      status: "unverified",
-      changedFiles: files,
-      checks: [],
-      detail: files.length ? `Workspace changes were observed, but a dynamic shell command prevented complete mutation tracking for ${fileCount(files.length)}.` : "A dynamic shell command may have changed workspace files, but reliable mutation tracking was unavailable.",
-      mutationTracking
-    };
+// src/agent/tool-recovery.ts
+import { createHash as createHash11 } from "node:crypto";
+var RETRY_BUDGET = {
+  schema_input: 3,
+  unknown_tool: 2,
+  permission_denied: 0,
+  command_exit: 3,
+  timeout: 2,
+  cancelled: 0,
+  hook: 1,
+  execution: 3,
+  contract_required: 2
+};
+var REPAIR_HINT = {
+  schema_input: "Correct the arguments to match the tool schema.",
+  unknown_tool: "Choose a tool exposed for this turn.",
+  permission_denied: "Do not retry unless the user or configuration changes permission.",
+  command_exit: "Inspect the exit output, change the command or fix the cause, then retry once.",
+  timeout: "Narrow the operation or increase its allowed timeout.",
+  cancelled: "Stop work and preserve the current state.",
+  hook: "Fix the hook failure before relying on the tool result.",
+  execution: "Use the error detail to change the inputs or approach.",
+  contract_required: "Activate the Task Contract before any workspace mutation."
+};
+var ToolRecoveryController = class {
+  signatures = /* @__PURE__ */ new Map();
+  classFailures = /* @__PURE__ */ new Map();
+  toolClasses = /* @__PURE__ */ new Map();
+  preflight(call) {
+    const callKey = callSignature(call);
+    const signatureState = this.signatures.get(callKey);
+    if (signatureState && (signatureState.failures >= 2 || !isRetryable(signatureState.failureClass))) {
+      return this.receipt(
+        call,
+        signatureState.failureClass,
+        signatureState.failures + 1,
+        true
+      );
+    }
+    const lastClass = this.toolClasses.get(call.name);
+    if (lastClass && (this.classFailures.get(lastClass) ?? 0) >= RETRY_BUDGET[lastClass] && RETRY_BUDGET[lastClass] > 0) {
+      return this.receipt(call, lastClass, (signatureState?.failures ?? 0) + 1, true);
+    }
+    return void 0;
   }
-  if (!files.length) {
-    return {
-      status: "no_changes",
-      changedFiles: [],
-      checks: [],
-      detail: "No workspace files changed in this run."
-    };
+  recordFailure(call, failureClass) {
+    const callKey = callSignature(call);
+    const current = this.signatures.get(callKey);
+    const failures = current?.failureClass === failureClass ? current.failures + 1 : 1;
+    this.signatures.set(callKey, { failureClass, failures });
+    this.toolClasses.set(call.name, failureClass);
+    this.classFailures.set(failureClass, (this.classFailures.get(failureClass) ?? 0) + 1);
+    return this.receipt(
+      call,
+      failureClass,
+      failures,
+      failures >= 2 || !isRetryable(failureClass)
+    );
   }
-  const latestByCommand = /* @__PURE__ */ new Map();
-  for (const item of evidence) {
-    if (item.changeSequence === currentChangeSequence) {
-      latestByCommand.set(item.commandKey, item);
-    }
+  recordSuccess(call) {
+    this.signatures.delete(callSignature(call));
+    this.toolClasses.delete(call.name);
   }
-  const checks = [...latestByCommand.values()].map(publicEvidence);
-  if (!checks.length) {
+  receipt(call, failureClass, attempt, circuitOpen) {
+    const budget = RETRY_BUDGET[failureClass];
+    const consumed = this.classFailures.get(failureClass) ?? 0;
     return {
-      status: "unverified",
-      changedFiles: files,
-      checks,
-      detail: `No successful verification was recorded after the last change to ${fileCount(files.length)}.`
+      class: failureClass,
+      retryable: isRetryable(failureClass) && consumed < budget && !circuitOpen,
+      repairHint: REPAIR_HINT[failureClass],
+      attempt,
+      remaining: Math.max(0, budget - consumed),
+      circuitOpen,
+      signature: failureSignature(call, failureClass)
     };
   }
-  const failures = checks.filter((check) => !check.ok);
-  if (failures.length) {
-    return {
-      status: "verification_failed",
-      changedFiles: files,
-      checks,
-      detail: `${failures.length} of ${checks.length} current verification ${checks.length === 1 ? "check" : "checks"} failed.`
-    };
+};
+function classifyToolFailure(result, fallback = "execution") {
+  if (result.metadata?.failureClass && isFailureClass(result.metadata.failureClass)) {
+    return result.metadata.failureClass;
+  }
+  if (result.metadata?.aborted === true) return "cancelled";
+  if (result.metadata?.timedOut === true) return "timeout";
+  if (result.metadata?.hookError) return "hook";
+  if (typeof result.metadata?.exitCode === "number" && result.metadata.exitCode !== 0) {
+    return "command_exit";
+  }
+  return fallback;
+}
+function formatFailureReceipt(receipt) {
+  return `Failure: ${receipt.class}; attempt ${receipt.attempt}; ${receipt.remaining} retries remain; circuit ${receipt.circuitOpen ? "open" : "closed"}. Repair: ${receipt.repairHint}`;
+}
+function isRetryable(failureClass) {
+  return RETRY_BUDGET[failureClass] > 0;
+}
+function callSignature(call) {
+  return createHash11("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}`).digest("hex");
+}
+function failureSignature(call, failureClass) {
+  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]";
+  if (Array.isArray(value)) return value.map((item) => redact(item));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([name, item]) => [name, redact(item, name)]));
+  }
+  return value;
+}
+function stableJson(value) {
+  return JSON.stringify(value) ?? String(value);
+}
+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 {
-    status: "verified",
-    changedFiles: files,
-    checks,
-    detail: `${checks.length} current verification ${checks.length === 1 ? "check" : "checks"} passed for ${fileCount(files.length)}.`
+    content: formatReceipt(options, metadata, preview),
+    metadata
   };
 }
-function completionRecoveryDirective(completion) {
-  if (completion.status === "verification_failed") {
-    const failed = completion.checks.filter((check) => !check.ok).map((check) => `- ${check.command} (tool call ${check.toolCallId})`).join("\n");
-    return `<runtime-completion-gate status="verification_failed" authorization="none">
-The run cannot be marked complete because current verification failed:
-${failed}
-Inspect the recorded tool output, correct the underlying problem, and rerun the smallest relevant check. Do not repeat the final summary or claim success without a new successful tool result. If the failure cannot be resolved safely, state the exact blocker and leave the result unverified.
-</runtime-completion-gate>`;
+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);
   }
-  const changeSummary = completion.mutationTracking === "unknown" ? "A dynamic shell command could not be mapped to a complete set of workspace changes." : `The run changed ${fileCount(completion.changedFiles.length)}, but no successful verification command was recorded after the last change.`;
-  return `<runtime-completion-gate status="unverified" authorization="none">
-${changeSummary}
-Run the smallest relevant test, typecheck, lint, build, or git diff --check now. Do not repeat the final summary or claim a check passed without a successful tool result. If verification cannot be run safely, state the exact reason and leave the result unverified.
-</runtime-completion-gate>`;
+  return Math.max(1, Math.ceil(tokens2));
 }
-function classifyVerificationCommand(command2) {
-  const normalized = normalizeCommand2(command2).toLocaleLowerCase();
-  const segments = normalized.split(/\s*(?:&&|\|\||;)\s*/u).filter(Boolean);
-  if (segments.length > 1) {
-    const kinds = segments.map(classifySingleVerificationCommand);
-    if (kinds.every((kind) => kind !== void 0)) {
-      return kinds.every((kind) => kind === kinds[0]) ? kinds[0] : "check";
-    }
-    return void 0;
+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 classifySingleVerificationCommand(normalized);
+  return value.slice(0, end);
 }
-function classifySingleVerificationCommand(command2) {
-  const value = command2.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|[^\s]+)\s+)+/u, "");
-  if (/^git\s+diff\b.*(?:^|\s)--check(?:\s|$)/u.test(value)) return "diff";
-  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:test(?::[^\s]+)?|test|vitest|jest)(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:vitest|jest)(?:\s|$)/u.test(value) || /^(?:python(?:\d+(?:\.\d+)*)?\s+-m\s+)?pytest(?:\s|$)/u.test(value) || /^(?:cargo|go|dotnet|mvn|mvnw|gradle|gradlew)\s+(?:test|verify)(?:\s|$)/u.test(value) || /^(?:make|just|task)\s+(?:test|verify)(?:\s|$)/u.test(value) || /^node\s+--test(?:\s|$)/u.test(value)) return "test";
-  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:typecheck|type-check|check:types)(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:tsc|pyright|mypy)(?:\s|$)/u.test(value) || /^(?:tsc|pyright|mypy)(?:\s|$)/u.test(value) || /^cargo\s+check(?:\s|$)/u.test(value)) return "typecheck";
-  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?lint(?:\s|$)/u.test(value) || /^(?:npx|pnpx|bunx)\s+(?:eslint|biome|ruff)(?:\s|$)/u.test(value) || /^(?:eslint|biome\s+check|ruff\s+check|cargo\s+clippy)(?:\s|$)/u.test(value)) return "lint";
-  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:build|compile)(?:\s|$)/u.test(value) || /^(?:cargo|go|dotnet|mvn|mvnw|gradle|gradlew)\s+build(?:\s|$)/u.test(value) || /^(?:make|just|task)\s+(?:build|compile)(?:\s|$)/u.test(value)) return "build";
-  if (/^(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?check(?:\s|$)/u.test(value) || /^(?:make|just|task|gradle|gradlew)\s+check(?:\s|$)/u.test(value)) return "check";
-  return void 0;
+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 publicEvidence(item) {
-  return {
-    toolCallId: item.toolCallId,
-    tool: item.tool,
-    command: item.command,
-    kind: item.kind,
-    ok: item.ok
-  };
+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 normalizeCommand2(command2) {
-  return command2.trim().replace(/[\t ]+/gu, " ");
+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 redactCommand(command2) {
-  return command2.replace(/[\u0000-\u001f\u007f-\u009f]/gu, " ").replace(/\b((?:api[_-]?key|access[_-]?token|authorization|password|secret|token))\s*=\s*([^\s]+)/giu, "$1=[redacted]").replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/gu, "[redacted-secret]").trim().slice(0, 2e3);
+function clamp2(value, minimum, maximum) {
+  return Math.max(minimum, Math.min(maximum, value));
 }
-function fileCount(count) {
-  return `${count} workspace ${count === 1 ? "file" : "files"}`;
+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",
@@ -7308,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"
@@ -7326,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({
@@ -7364,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;
@@ -7378,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) {
@@ -7428,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({
@@ -7476,6 +8651,7 @@ var AgentRunner = class {
   contextEngine;
   tools;
   sessionStore;
+  toolArtifactStore;
   checkpointStore;
   workspace;
   hooks;
@@ -7497,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);
@@ -7538,6 +8715,8 @@ var AgentRunner = class {
     const changeSequenceAtStart = this.changeSequence;
     const runChangedFiles = /* @__PURE__ */ new Set();
     const verificationEvidence = [];
+    const toolRecovery = new ToolRecoveryController();
+    let activeRunContract = this.session.taskContract;
     let mutationTracking = "complete";
     let completionRecoveryAttempted = false;
     const recordExecution = (call, result) => {
@@ -7556,12 +8735,21 @@ var AgentRunner = class {
       );
       if (evidence) verificationEvidence.push(evidence);
     };
-    const completionReport = () => buildRunCompletion(
-      runChangedFiles,
-      verificationEvidence,
-      this.changeSequence,
-      mutationTracking
-    );
+    const completionReport = () => {
+      const completion = buildRunCompletion(
+        runChangedFiles,
+        verificationEvidence,
+        this.changeSequence,
+        mutationTracking,
+        activeRunContract,
+        this.session.audit ?? []
+      );
+      if (completion.acceptance && activeRunContract && activeRunContract.state !== "draft") {
+        activeRunContract.state = completion.acceptance.state;
+        activeRunContract.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return completion;
+    };
     const finishRun = async (reason, completion = completionReport()) => {
       this.session.lastRun = {
         ...completion,
@@ -7569,11 +8757,16 @@ var AgentRunner = class {
         finishedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       await this.persist();
+      const finalContract = activeRunContract && structuredClone(activeRunContract);
+      if (finalContract && finalContract.state !== "satisfied") {
+        await emit({ type: "contract", contract: finalContract });
+      }
       await emit({ type: "done", reason, completion });
       return this.session;
     };
     try {
       throwIfAborted(options.signal);
+      await this.reconcileToolArtifacts();
       if (this.session.messages.length === 0 && this.session.title === "New session") {
         this.session.title = titleFromInput(request);
       }
@@ -7613,10 +8806,22 @@ var AgentRunner = class {
       const turnDirective = buildTurnDirective(request, {
         agents: Boolean(this.config.agents?.enabled)
       });
+      const contractEnabled = shouldUseTaskContract(
+        request,
+        turnDirective.intent,
+        this.session.taskContract
+      );
+      if (contractEnabled && (!this.session.taskContract || this.session.taskContract.state === "satisfied")) {
+        this.session.taskContract = createDraftTaskContract(request, this.session.audit?.at(-1)?.id);
+        await this.persist();
+        await emit({ type: "contract", contract: structuredClone(this.session.taskContract) });
+      }
+      activeRunContract = contractEnabled ? this.session.taskContract : void 0;
       const promptSections = [
         `intent:${turnDirective.intent}`,
         ...workspaceRules ? ["rules"] : [],
         ...this.session.workingMemory ? ["working-memory"] : [],
+        ...contractEnabled ? ["task-contract"] : [],
         ...this.session.contextSummary ? ["session-summary"] : [],
         ...!trivialTurn ? [`context:${packed.engine}`] : [],
         ...packed.text ? [`code:${packed.engine}`] : [],
@@ -7668,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(
-          options.askMode ? this.tools.definitions().filter((tool) => tool.category === "read") : this.tools.definitions()
+        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");
         }
@@ -7678,8 +8887,7 @@ var AgentRunner = class {
           this.config.model.maxTokens ?? 8192,
           availableTokens - estimatedInputTokens
         ));
-        const visibleTools = options.askMode ? this.tools.definitions().filter((tool) => tool.category === "read") : this.tools.definitions();
-        const assistantId = randomUUID10();
+        const assistantId = randomUUID12();
         const response = await this.completeModel(
           messages,
           visibleTools,
@@ -7722,9 +8930,17 @@ var AgentRunner = class {
           return finishRun("token_budget");
         }
         if (response.toolCalls.length) {
+          const visibleToolNames = new Set(visibleTools.map((tool) => tool.name));
           for (const call of response.toolCalls) {
             throwIfAborted(options.signal);
-            const result = await this.executeTool(call, options, emit);
+            const result = await this.executeTool(
+              call,
+              options,
+              emit,
+              toolRecovery,
+              visibleToolNames
+            );
+            if (call.name === "task_contract") activeRunContract = this.session.taskContract;
             recordExecution(call, result);
             this.session.messages.push(message("tool", result.content, {
               toolCallId: result.toolCallId,
@@ -7753,8 +8969,11 @@ Review these results, correct any failures if needed, then provide the final ans
           continue;
         }
         const completion = completionReport();
-        if (this.config.agent.autoVerify && (completion.status === "unverified" || completion.status === "verification_failed") && !completionRecoveryAttempted && turn < maxTurns) {
+        if ((this.config.agent.autoVerify || Boolean(completion.acceptance)) && (completion.status === "unverified" || completion.status === "verification_failed") && !completionRecoveryAttempted && turn < maxTurns) {
           completionRecoveryAttempted = true;
+          if (activeRunContract) {
+            await emit({ type: "contract", contract: structuredClone(activeRunContract) });
+          }
           this.session.messages.push(message("user", completionRecoveryDirective(completion)));
           await this.persist();
           await this.runAfterTurnHook(turn, [], options.signal);
@@ -7822,10 +9041,29 @@ ${input2}`
     if (final) return final;
     return { content, toolCalls: [] };
   }
-  async executeTool(call, options, emit) {
+  async executeTool(call, options, emit, recovery = new ToolRecoveryController(), visibleToolNames) {
+    const preflight = recovery.preflight(call);
+    if (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 = await this.protectToolResult(
+        failedResult(call, `Tool is not exposed for this turn: ${call.name}`, receipt)
+      );
+      this.recordToolResult(result);
+      await emit({ type: "tool_result", result });
+      return result;
+    }
     const tool = this.tools.get(call.name);
     if (!tool) {
-      const result = failedResult(call, `Unknown tool: ${call.name}`);
+      const receipt = recovery.recordFailure(call, "unknown_tool");
+      const result = await this.protectToolResult(failedResult(call, `Unknown tool: ${call.name}`, receipt));
       this.recordToolResult(result);
       await emit({ type: "tool_result", result });
       return result;
@@ -7836,7 +9074,18 @@ ${input2}`
         tool.permissionCategories?.(call.arguments) ?? [tool.definition.category]
       );
     } catch (error) {
-      const result = failedResult(call, formatToolError(error));
+      const failureClass = classifyThrownToolFailure(error, options.signal);
+      const receipt = recovery.recordFailure(call, failureClass);
+      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 = 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 });
       return result;
@@ -7844,7 +9093,10 @@ ${input2}`
     for (const category of categories) {
       const allowed = await this.authorize(call, category, options, emit);
       if (!allowed) {
-        const result = failedResult(call, `Permission denied for ${category} operation.`);
+        const receipt = recovery.recordFailure(call, "permission_denied");
+        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;
@@ -7858,6 +9110,7 @@ ${input2}`
       workspace: this.workspace,
       session: this.session,
       contextEngine: this.contextEngine,
+      toolArtifactStore: this.toolArtifactStore,
       emit,
       ...options.signal ? { signal: options.signal } : {}
     };
@@ -7891,30 +9144,48 @@ ${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 } : {}
       };
+      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);
+        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 })) });
       }
+      if (call.name === "task_contract" && this.session.taskContract) {
+        await emit({ type: "contract", contract: structuredClone(this.session.taskContract) });
+      }
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
       return result;
     } catch (error) {
-      const result = failedResult(call, formatToolError(error));
+      const normalized = toError(error);
+      const failureClass = classifyThrownToolFailure(normalized, options.signal);
+      const receipt = recovery.recordFailure(call, failureClass);
+      const result = await this.protectToolResult(failedResult(call, formatToolError(error), receipt));
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
       return result;
@@ -7983,7 +9254,7 @@ Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : executio
   }
   appendAudit(event) {
     const audit = this.session.audit ?? (this.session.audit = []);
-    audit.push({ id: randomUUID10(), createdAt: (/* @__PURE__ */ new Date()).toISOString(), ...event });
+    audit.push({ id: randomUUID12(), createdAt: (/* @__PURE__ */ new Date()).toISOString(), ...event });
     if (audit.length > 5e3) audit.splice(0, audit.length - 5e3);
   }
   async acceptChangedFiles(paths) {
@@ -8004,7 +9275,7 @@ Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : executio
     const results = [];
     for (const command2 of this.config.agent.verifyCommands) {
       const call = {
-        id: `verify-${randomUUID10()}`,
+        id: `verify-${randomUUID12()}`,
         name: "shell",
         arguments: { command: command2, cwd: this.workspace.primaryRoot }
       };
@@ -8068,10 +9339,67 @@ Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : executio
   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 {
-    id: randomUUID10(),
+    id: randomUUID12(),
     role,
     content,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -8142,24 +9470,33 @@ function estimateResponseTokens(response) {
 function uniqueCategories(categories) {
   return [...new Set(categories)];
 }
-function failedResult(call, content) {
+function failedResult(call, content, failure) {
   return {
     toolCallId: call.id,
     name: call.name,
     ok: false,
-    content: truncateToolOutput(content)
+    content: failure ? `${formatFailureReceipt(failure)}
+${content}` : content,
+    ...failure ? { metadata: { failure } } : {}
   };
 }
-function truncateToolOutput(content) {
-  const max = 8e4;
-  return content.length <= max ? content : `${content.slice(0, max)}
-\u2026 tool output truncated`;
+function visibleToolDefinitions(tools, askMode, contractEnabled, artifactReadAvailable) {
+  return tools.definitions().filter(
+    (tool) => (!askMode || tool.category === "read") && (contractEnabled || tool.name !== "task_contract") && (artifactReadAvailable || tool.name !== "read_tool_artifact")
+  );
 }
 function formatToolError(error) {
   const normalized = toError(error);
   if (normalized.name === "ZodError") return `Invalid tool arguments: ${normalized.message}`;
   return normalized.message;
 }
+function classifyThrownToolFailure(error, signal) {
+  const normalized = toError(error);
+  if (isAbortError(normalized) || signal?.aborted) return "cancelled";
+  if (normalized.name === "HookError") return "hook";
+  if (normalized.name === "ZodError" || normalized.name === "ToolInputError") return "schema_input";
+  return "execution";
+}
 function titleFromInput(input2) {
   return input2.trim().replace(/\s+/g, " ").slice(0, 80) || "New session";
 }
@@ -8180,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 = [
   {
@@ -8274,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);
       }
     }
@@ -8297,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();
@@ -8335,9 +9672,9 @@ function integer(value, fallback, min, max) {
 }
 
 // src/agent/delegation.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
-import { join as join17 } from "node:path";
-import { z as z15 } from "zod";
+import { randomUUID as randomUUID14 } from "node:crypto";
+import { join as join18 } from "node:path";
+import { z as z18 } from "zod";
 
 // src/agent/external-runtime.ts
 async function runExternalAgent(request) {
@@ -8464,101 +9801,101 @@ function numeric(...values) {
 }
 
 // src/agent/team-store.ts
-import { createHash as createHash10, randomUUID as randomUUID11 } 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 z14 } from "zod";
-var runIdSchema = z14.string().uuid();
-var hashSchema = z14.string().regex(/^[a-f0-9]{64}$/u);
-var artifactSchema = z14.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: z14.number().int().nonnegative().max(5e5)
+  bytes: z17.number().int().nonnegative().max(5e5)
 }).strict();
-var phaseSchema = z14.enum(["work", "review", "revision", "write"]);
-var agentRecordSchema = z14.object({
-  id: z14.string().uuid(),
-  profile: z14.string(),
-  provider: z14.string(),
-  model: z14.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: z14.boolean(),
-  createdAt: z14.string(),
-  startedAt: z14.string().optional(),
-  endedAt: z14.string().optional(),
-  durationMs: z14.number().int().nonnegative().optional(),
-  toolCalls: z14.number().int().nonnegative().optional(),
-  usage: z14.object({
-    inputTokens: z14.number().int().nonnegative(),
-    outputTokens: z14.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 = z14.object({
-  id: z14.string().uuid(),
-  from: z14.string(),
-  to: z14.string(),
-  createdAt: z14.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 = z14.object({
-  status: z14.enum(["ready", "conflict", "integrated"]),
-  checkedAt: z14.string(),
-  detail: z14.string().max(2e4),
-  checkpoint: z14.object({
-    sessionId: z14.string(),
-    checkpointId: z14.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: z14.string().optional()
+  integratedAt: z17.string().optional()
 }).strict();
-var writerLaneSchema = z14.object({
-  profile: z14.string(),
-  reviewer: z14.string(),
-  baseCommit: z14.string().regex(/^[a-f0-9]{40,64}$/u),
-  outcome: z14.enum(["accepted", "rejected", "failed", "cancelled"]),
-  patch: artifactSchema,
-  files: z14.array(z14.string().min(1).max(4e3)).max(2e3),
-  worktreeCleaned: z14.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: z14.string(),
-  objective: z14.string().max(3e4),
-  reviewer: z14.string(),
-  createdAt: z14.string(),
-  updatedAt: z14.string(),
-  status: z14.enum(["running", "accepted", "rejected", "failed"]),
-  maxReviewRounds: z14.number().int().min(0).max(3),
-  reviewRounds: z14.number().int().min(0).max(3),
-  agents: z14.array(agentRecordSchema).max(256),
-  messages: z14.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 = z14.object({
-  version: z14.literal(1),
+var manifestV1Schema = z17.object({
+  version: z17.literal(1),
   ...manifestFields
 }).strict();
-var manifestV2Schema = z14.object({
-  version: z14.literal(2),
+var manifestV2Schema = z17.object({
+  version: z17.literal(2),
   ...manifestFields,
   writer: writerLaneSchema.optional()
 }).strict();
-var manifestSchema2 = z14.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();
     const manifest = manifestSchema2.parse({
       version: 2,
-      id: randomUUID11(),
+      id: randomUUID13(),
       workspace: this.workspace,
       objective: input2.objective,
       reviewer: input2.reviewer,
@@ -8636,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) {
@@ -8653,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;
@@ -8682,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;
@@ -8707,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 = createHash10("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 (createHash10("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) {
@@ -8751,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 = createHash10("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}`);
   }
 };
@@ -8815,10 +10152,10 @@ function resolveAgentModelRoute(team, parent, profile) {
 }
 
 // src/agent/writer-lane.ts
-import { createHash as createHash11 } 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 });
@@ -8831,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 = "";
@@ -8913,7 +10250,7 @@ var WriterLane = class {
     return {
       baseCommit,
       patch,
-      patchSha256: createHash11("sha256").update(patch).digest("hex"),
+      patchSha256: createHash13("sha256").update(patch).digest("hex"),
       files,
       worktreeCleaned,
       value
@@ -8932,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 {
@@ -9040,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.");
@@ -9055,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.");
     }
@@ -9064,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) {
@@ -9076,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",
@@ -9085,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",
@@ -9134,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;
@@ -9143,14 +10480,14 @@ async function pathExists2(path) {
 }
 
 // src/agent/delegation.ts
-var writerRunInputSchema = z15.object({
-  task: z15.string().min(1).max(2e4),
-  profile: z15.string().max(64).optional(),
-  reviewer: z15.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 = z15.object({
-  run_id: z15.string().uuid(),
-  patch_sha256: z15.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) {
@@ -9211,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 = z15.object({
-          tasks: z15.array(z15.object({
-            profile: z15.string().max(64).optional(),
-            task: z15.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) => ({
@@ -9260,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 = z15.object({
-          objective: z15.string().min(1).max(3e4),
-          tasks: z15.array(z15.object({
-            profile: z15.string().max(64).optional(),
-            task: z15.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: z15.string().max(64).optional()
+          reviewer: z18.string().max(64).optional()
         }).parse(arguments_);
         const tasks = input2.tasks.map((task) => ({
           profile: task.profile ?? manager.team.defaultProfile,
@@ -9329,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) {
@@ -9364,7 +10701,7 @@ var DelegationManager = class {
         maxReviewRounds: 0
       });
       await emit?.({ type: "team_start", id: board.id, objective: task });
-      const writerId = randomUUID12();
+      const writerId = randomUUID14();
       await emit?.({ type: "agent_queued", id: writerId, profile: profile.name, task, phase: "write" });
       const draft = await this.writerLane.createDraft(
         Math.min(this.team.maxWriterPatchBytes ?? 6e4, 12e4),
@@ -9516,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;
@@ -9734,7 +11071,7 @@ You are the only writer inside a disposable worktree. Make only the bounded requ
     const reviewer = reviewerOverride ?? this.team.reviewerProfile ?? "reviewer";
     const rounds = Math.max(0, this.team.maxReviewRounds ?? 1);
     const board = await this.teamStore?.create({ objective, reviewer, maxReviewRounds: rounds });
-    const runId = board?.id ?? randomUUID12();
+    const runId = board?.id ?? randomUUID14();
     await emit?.({ type: "team_start", id: runId, objective });
     try {
       let results = await this.runBatch(board?.id, tasks, "work", emit, signal);
@@ -9792,7 +11129,7 @@ ${review.summary}`,
     }
   }
   async runBatch(runId, tasks, phase, emit, signal) {
-    const scheduled = tasks.map((task) => ({ id: randomUUID12(), task }));
+    const scheduled = tasks.map((task) => ({ id: randomUUID14(), task }));
     for (const item of scheduled) {
       await emit?.({ type: "agent_queued", id: item.id, profile: item.task.profile, task: item.task.task, phase });
     }
@@ -9901,12 +11238,12 @@ Start the response with exactly VERDICT: ACCEPT when the evidence is sufficient,
     });
   }
   async peerMessage(runId, from, to, content, emit) {
-    const id = randomUUID12();
+    const id = randomUUID14();
     if (runId) await this.teamStore?.recordMessage(runId, { id, from, to, content });
     await emit?.({ type: "agent_message", id, from, to, content });
   }
   async runOne(task, phase, emit, signal, retryOf, scheduledId) {
-    const id = scheduledId ?? randomUUID12();
+    const id = scheduledId ?? randomUUID14();
     const profile = this.options.profiles.get(task.profile);
     const configuredRoute = this.team.routes?.[task.profile];
     const budgetMode = configuredRoute?.budgetMode ?? this.team.budgetMode ?? "observe";
@@ -10818,11 +12155,11 @@ ${this.glyphs.meta} ${session.changedFiles.length} changed files ${this.glyphs.s
 `);
   }
   printText(event) {
-    const { quiet, compact } = this.options;
+    const { quiet, compact: compact2 } = this.options;
     if (quiet) return;
     switch (event.type) {
       case "thinking":
-        if (!compact) process.stderr.write(this.paint.dim(`${this.glyphs.meta} reasoning ${this.glyphs.separator} turn ${event.turn}
+        if (!compact2) process.stderr.write(this.paint.dim(`${this.glyphs.meta} reasoning ${this.glyphs.separator} turn ${event.turn}
 `));
         break;
       case "context":
@@ -10832,7 +12169,7 @@ ${this.glyphs.meta} ${session.changedFiles.length} changed files ${this.glyphs.s
         ));
         break;
       case "prompt":
-        if (!compact) {
+        if (!compact2) {
           process.stderr.write(this.paint.dim(
             `${this.glyphs.meta} prompt ${this.glyphs.separator} ${event.intent} ${this.glyphs.separator} ${event.sections.join(" + ")} ${this.glyphs.separator} ~${event.estimatedTokens} tokens
 `
@@ -10867,12 +12204,21 @@ ${this.glyphs.meta} ${session.changedFiles.length} changed files ${this.glyphs.s
         }
         break;
       case "tasks":
-        if (!compact) {
+        if (!compact2) {
           const completed = event.tasks.filter((task) => task.status === "completed").length;
           process.stderr.write(this.paint.dim(`${this.glyphs.meta} plan ${this.glyphs.separator} ${completed}/${event.tasks.length} complete
 `));
         }
         break;
+      case "contract": {
+        const required = event.contract.acceptanceCriteria.filter((item) => item.required);
+        const satisfied = required.filter((item) => item.status === "satisfied").length;
+        process.stderr.write(this.paint.dim(
+          `${this.glyphs.meta} contract ${this.glyphs.separator} ${event.contract.state} ${this.glyphs.separator} ${satisfied}/${required.length} accepted
+`
+        ));
+        break;
+      }
       case "writer_lane":
         process.stderr.write(
           `${event.status === "ready" || event.status === "integrated" ? this.paint.green(this.glyphs.success) : this.paint.red(this.glyphs.error)} writer ${event.id.slice(0, 8)} ${this.glyphs.separator} ${event.status} ${this.glyphs.separator} ${event.detail}
@@ -10954,6 +12300,7 @@ function sessionSummary(session) {
     createdAt: session.createdAt,
     updatedAt: session.updatedAt,
     tasks: session.tasks,
+    ...session.taskContract ? { taskContract: session.taskContract } : {},
     changedFiles: session.changedFiles,
     ...session.lastRun ? { lastRun: session.lastRun } : {},
     usage: session.usage
@@ -10981,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];
@@ -11003,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 {
@@ -11157,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";
@@ -11254,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 {
@@ -11377,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 };
@@ -11389,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));
@@ -11408,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 = {
@@ -11644,7 +12991,7 @@ function ToolGlyph({ state, glyphs }) {
   if (state === "cancelled") return /* @__PURE__ */ jsx(Text, { color: theme.warning, children: glyphs.warning });
   return /* @__PURE__ */ jsx(Text, { color: theme.error, children: glyphs.error });
 }
-function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = false, expandedToolId, compact = false }) {
+function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = false, expandedToolId, compact: compact2 = false }) {
   const theme = useTheme();
   const glyphs = resolveGlyphs(glyphMode);
   if (!items.length) {
@@ -11652,13 +12999,13 @@ function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = fals
   }
   return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: items.map((item, index) => {
     if (item.kind === "user") {
-      return /* @__PURE__ */ jsxs(Box, { marginBottom: compact || item.clipped ? 0 : 1, children: [
+      return /* @__PURE__ */ jsxs(Box, { marginBottom: compact2 || item.clipped ? 0 : 1, children: [
         /* @__PURE__ */ jsx(Box, { width: 2, children: /* @__PURE__ */ jsx(Text, { bold: true, color: theme.accent, children: glyphs.prompt }) }),
         /* @__PURE__ */ jsx(Text, { bold: true, color: theme.textStrong, wrap: "wrap", children: sanitizeTerminalText(item.text) })
       ] }, item.id);
     }
     if (item.kind === "assistant") {
-      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: compact || item.clipped ? 0 : 1, children: [
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: compact2 || item.clipped ? 0 : 1, children: [
         /* @__PURE__ */ jsxs(Text, { bold: true, color: theme.accent, children: [
           glyphs.brand,
           " ",
@@ -11674,7 +13021,7 @@ function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = fals
     }
     if (item.kind === "context") {
       const spans = item.spans ?? [];
-      const spanLimit = compact ? 2 : 3;
+      const spanLimit = compact2 ? 2 : 3;
       const innerWidth = Math.max(1, safeWidth(width) - 2);
       return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
         /* @__PURE__ */ jsx(
@@ -11725,7 +13072,7 @@ function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = fals
       const duration = item.durationMs !== void 0 ? formatDuration(item.durationMs) : "";
       const detailText = [detail, duration].filter(Boolean).join("  ");
       const expanded = Boolean(item.output) && (showToolOutput || expandedToolId === item.id);
-      const verbose = expanded && item.output ? limitTerminalText(item.output, compact ? 24 : 80) : void 0;
+      const verbose = expanded && item.output ? limitTerminalText(item.output, compact2 ? 24 : 80) : void 0;
       const disclosure = item.output ? expanded ? glyphs.expanded : glyphs.collapsed : "";
       const disclosureWidth = disclosure ? displayWidth(disclosure) + 1 : 0;
       const nameLimit = Math.max(1, Math.min(rowWidth - 2 - disclosureWidth, rowWidth < 64 ? rowWidth - 2 - disclosureWidth : 28));
@@ -11859,7 +13206,7 @@ function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = fals
     }
     if (item.kind === "list") return /* @__PURE__ */ jsx(ListPanel, { title: item.title, entries: item.entries, width, glyphMode }, item.id);
     if (item.kind === "context-inspector") {
-      return /* @__PURE__ */ jsx(ContextInspector, { status: item.status, working: item.working, summary: item.summary, width, compact, glyphMode }, item.id);
+      return /* @__PURE__ */ jsx(ContextInspector, { status: item.status, working: item.working, summary: item.summary, width, compact: compact2, glyphMode }, item.id);
     }
     if (item.kind === "theme") return /* @__PURE__ */ jsx(ThemePreview, { name: item.name, width, glyphs }, item.id);
     if (item.kind === "banner") {
@@ -12069,7 +13416,7 @@ function TaskRail({ tasks, width = 80, glyphMode = "auto", maxItems }) {
     ] }) : null
   ] });
 }
-function PermissionCard({ call, category, width = 80, glyphMode = "auto", workspace, compact = false }) {
+function PermissionCard({ call, category, width = 80, glyphMode = "auto", workspace, compact: compact2 = false }) {
   const theme = useTheme();
   const glyphs = resolveGlyphs(glyphMode);
   const summary = permissionSummary(call);
@@ -12106,7 +13453,7 @@ function PermissionCard({ call, category, width = 80, glyphMode = "auto", worksp
     rowWidth >= 64 ? /* @__PURE__ */ jsx(Box, { paddingLeft: 2, children: /* @__PURE__ */ jsx(InlineRow, { parts: shortcuts, width: innerWidth, separator: `  ${glyphs.separator}  `, separatorColor: theme.border }) }) : rowWidth >= 28 ? /* @__PURE__ */ jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [
       /* @__PURE__ */ jsx(InlineRow, { parts: shortcuts.slice(0, 2), width: innerWidth, separator: "  ", separatorColor: theme.border }),
       /* @__PURE__ */ jsx(InlineRow, { parts: shortcuts.slice(2), width: innerWidth, separator: "  ", separatorColor: theme.border })
-    ] }) : compact ? /* @__PURE__ */ jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [
+    ] }) : compact2 ? /* @__PURE__ */ jsxs(Box, { paddingLeft: 2, flexDirection: "column", children: [
       /* @__PURE__ */ jsx(InlineRow, { parts: compactNarrowShortcuts.slice(0, 2), width: innerWidth, separator: " ", separatorColor: theme.border }),
       /* @__PURE__ */ jsx(InlineRow, { parts: compactNarrowShortcuts.slice(2), width: innerWidth, separator: " ", separatorColor: theme.border })
     ] }) : /* @__PURE__ */ jsx(Box, { paddingLeft: 2, flexDirection: "column", children: shortcuts.map((part) => part.color ? /* @__PURE__ */ jsx(Text, { color: part.color, children: truncateDisplay(part.text, innerWidth) }, part.text) : /* @__PURE__ */ jsx(Text, { children: truncateDisplay(part.text, innerWidth) }, part.text)) })
@@ -12367,7 +13714,7 @@ function MeterBar({ segments, total, width, glyphs }) {
     remainder ? /* @__PURE__ */ jsx(Text, { color: theme.border, children: glyphs.meterEmpty.repeat(remainder) }) : null
   ] });
 }
-function ContextInspector({ status, working, summary, width, memory, connections, sources: sources2, compact = false, minimal = false, glyphMode = "auto" }) {
+function ContextInspector({ status, working, summary, width, memory, connections, sources: sources2, compact: compact2 = false, minimal = false, glyphMode = "auto" }) {
   const theme = useTheme();
   const glyphs = resolveGlyphs(glyphMode);
   if (minimal) {
@@ -12387,10 +13734,10 @@ function ContextInspector({ status, working, summary, width, memory, connections
     { label: "summary", detail: summary ? `~${formatTokens(status.summaryTokens)} tokens ${glyphs.separator} ${status.compactedMessages} compacted` : "not created" },
     { label: "long-term", detail: memory ?? `retrieved by relevance ${glyphs.separator} untrusted context` }
   ];
-  if (!compact && working?.constraints.length) entries.push({ label: `constraints ${working.constraints.length}`, detail: working.constraints.slice(0, 2).join(` ${glyphs.separator} `) });
-  if (!compact && working?.decisions.length) entries.push({ label: `decisions ${working.decisions.length}`, detail: working.decisions.slice(0, 2).join(` ${glyphs.separator} `) });
-  if (!compact && working?.openQuestions.length) entries.push({ label: `open ${working.openQuestions.length}`, detail: working.openQuestions.slice(0, 2).join(` ${glyphs.separator} `), tone: "warning" });
-  if (!compact && working?.relevantFiles.length) entries.push({ label: "relevant files", detail: working.relevantFiles.map((file) => compactDisplayPath(sanitizeInlineTerminalText(file), 28)).join(` ${glyphs.separator} `) });
+  if (!compact2 && working?.constraints.length) entries.push({ label: `constraints ${working.constraints.length}`, detail: working.constraints.slice(0, 2).join(` ${glyphs.separator} `) });
+  if (!compact2 && working?.decisions.length) entries.push({ label: `decisions ${working.decisions.length}`, detail: working.decisions.slice(0, 2).join(` ${glyphs.separator} `) });
+  if (!compact2 && working?.openQuestions.length) entries.push({ label: `open ${working.openQuestions.length}`, detail: working.openQuestions.slice(0, 2).join(` ${glyphs.separator} `), tone: "warning" });
+  if (!compact2 && working?.relevantFiles.length) entries.push({ label: "relevant files", detail: working.relevantFiles.map((file) => compactDisplayPath(sanitizeInlineTerminalText(file), 28)).join(` ${glyphs.separator} `) });
   if (sources2?.length) {
     const pinned = sources2.filter((source) => source.state === "pinned");
     const muted = sources2.filter((source) => source.state === "muted");
@@ -12511,8 +13858,8 @@ function Banner({ model, engine, workspace, version, width, glyphs }) {
 function UpdateNotice({ current, latest, command: command2, highlights, width, glyphs }) {
   const theme = useTheme();
   const availableWidth = safeWidth(width);
-  const compact = availableWidth < 48;
-  const parts = compact ? [
+  const compact2 = availableWidth < 48;
+  const parts = compact2 ? [
     { text: `${glyphs.up} `, color: theme.accent, bold: true },
     { text: `v${current}`, color: theme.dim, bold: false },
     { text: ` ${glyphs.arrow} `, color: theme.muted, bold: false },
@@ -12533,7 +13880,7 @@ function UpdateNotice({ current, latest, command: command2, highlights, width, g
   const bullets = bulletWidth > 0 ? (highlights ?? []).map((line) => truncateDisplay(sanitizeInlineTerminalText(line), bulletWidth)) : [];
   return /* @__PURE__ */ jsxs(Box, { marginBottom: 1, flexDirection: "column", children: [
     /* @__PURE__ */ jsx(Box, { children: truncated ? /* @__PURE__ */ jsx(Text, { color: theme.muted, children: rendered }) : parts.map((part, index) => /* @__PURE__ */ jsx(Text, { color: part.color, bold: part.bold, children: part.text }, index)) }),
-    compact ? /* @__PURE__ */ jsx(Text, { color: theme.dim, children: truncateDisplay(`  run ${command2}`, availableWidth) }) : null,
+    compact2 ? /* @__PURE__ */ jsx(Text, { color: theme.dim, children: truncateDisplay(`  run ${command2}`, availableWidth) }) : null,
     bullets.map((line, index) => /* @__PURE__ */ jsx(Text, { color: theme.dim, children: `${bulletPrefix}${line}` }, index))
   ] });
 }
@@ -12635,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";
@@ -12652,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;
@@ -12716,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}`;
@@ -12733,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;
@@ -13441,9 +14788,9 @@ function tailText(value, width, maxRows) {
   return `${marker}
 ${selected.join("\n")}`;
 }
-function estimateTimelineItemRows(item, { width, compact = false, showToolOutput = false, expandedToolId }) {
+function estimateTimelineItemRows(item, { width, compact: compact2 = false, showToolOutput = false, expandedToolId }) {
   const rowWidth = Math.max(1, Math.floor(width));
-  const gap = compact ? 0 : 1;
+  const gap = compact2 ? 0 : 1;
   if (item.kind === "user") return wrappedRows(item.text, Math.max(1, rowWidth - 2)) + (item.clipped ? 0 : gap);
   if (item.kind === "assistant") {
     return 1 + richTextRows(item.text, Math.max(1, rowWidth - 2)) + (item.clipped ? 0 : gap);
@@ -13455,7 +14802,7 @@ function estimateTimelineItemRows(item, { width, compact = false, showToolOutput
     const detail = item.errorDetail || item.detail;
     const detailRows = narrow && detail ? 1 : 0;
     const metaRows = item.meta ? 1 : 0;
-    const outputRows = (showToolOutput || item.id === expandedToolId) && item.output ? Math.min(compact ? 25 : 81, richTextRows(item.output, Math.max(1, rowWidth - 2))) : 0;
+    const outputRows = (showToolOutput || item.id === expandedToolId) && item.output ? Math.min(compact2 ? 25 : 81, richTextRows(item.output, Math.max(1, rowWidth - 2))) : 0;
     return 1 + detailRows + metaRows + outputRows;
   }
   if (item.kind === "list") {
@@ -13469,7 +14816,7 @@ function estimateTimelineItemRows(item, { width, compact = false, showToolOutput
   if (item.kind === "theme") return 3;
   if (item.kind === "context") {
     const metaRows = rowWidth < 64 ? 2 : 1;
-    const spanLimit = compact ? 2 : 3;
+    const spanLimit = compact2 ? 2 : 3;
     const spanCount = Math.min(item.spans?.length ?? 0, spanLimit);
     const moreRow = (item.spans?.length ?? 0) > spanLimit ? 1 : 0;
     const degradationRows = item.degradation ? metaRows : 0;
@@ -13567,6 +14914,21 @@ function finalizeAssistant(items, id, content) {
 function endStreamingAssistants(items) {
   return items.map((item) => item.kind === "assistant" && item.streaming ? { ...item, streaming: false } : item);
 }
+function updateContractProgress(items, contract, separator = " | ") {
+  const id = "task-contract-progress";
+  if (contract.state === "satisfied") return items.filter((item) => item.id !== id);
+  const required = contract.acceptanceCriteria.filter((item) => item.required);
+  const satisfied = required.filter((item) => item.status === "satisfied").length;
+  const next = {
+    id,
+    kind: "notice",
+    tone: contract.state === "blocked" ? "error" : "info",
+    text: `Contract ${contract.state}${separator}${satisfied}/${required.length} accepted`
+  };
+  const index = items.findIndex((item) => item.id === id);
+  if (index < 0) return [...items, next].slice(-500);
+  return items.map((item, itemIndex) => itemIndex === index ? next : item);
+}
 function updateAgent(items, event) {
   const found = items.some((item) => item.kind === "agent" && item.id === event.id);
   if (!found) {
@@ -13659,7 +15021,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
   const colorEnabled = config.ui.color && !process.env.NO_COLOR;
   const [theme, setTheme] = useState2(() => resolveThemeWithColor(config.ui.theme, colorEnabled));
   const [themeCatalogRevision, setThemeCatalogRevision] = useState2(0);
-  const [compact, setCompact] = useState2(config.ui.compact);
+  const [compact2, setCompact] = useState2(config.ui.compact);
   const [interactionMode, setInteractionMode] = useState2(planMode ? "plan" : askMode ? "ask" : "build");
   const [input2, setInput] = useState2("");
   const [busy, setBusy] = useState2(false);
@@ -13799,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) {
@@ -13859,6 +15221,11 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
       case "tasks":
         setTasks(event.tasks.map((task) => ({ ...task })));
         break;
+      case "contract": {
+        setTimeline((items) => updateContractProgress(items, event.contract, separator));
+        refreshSession();
+        break;
+      }
       case "skill":
         append({ id: nextId(), kind: "skill", name: event.name, description: event.description });
         break;
@@ -14351,7 +15718,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
     }
     if (command2 === "density") {
       const normalized = argument.toLocaleLowerCase();
-      const next = normalized === "compact" ? true : normalized === "comfortable" || normalized === "normal" ? false : normalized === "" || normalized === "toggle" ? !compact : void 0;
+      const next = normalized === "compact" ? true : normalized === "comfortable" || normalized === "normal" ? false : normalized === "" || normalized === "toggle" ? !compact2 : void 0;
       if (next === void 0) throw new Error("Usage: /density [compact|comfortable]");
       setCompact(next);
       await saveUiPreference({ compact: next });
@@ -14444,7 +15811,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
       })));
       return true;
     }
-  }, [append, appendList, compact, config, ellipsis, exit, extensions, interactionMode, refreshSession, requestPermission, runner, separator, showToolOutput, tasks, theme, workflows]);
+  }, [append, appendList, compact2, config, ellipsis, exit, extensions, interactionMode, refreshSession, requestPermission, runner, separator, showToolOutput, tasks, theme, workflows]);
   const submit = useCallback(async (raw, mode = "normal") => {
     const trimmed = raw.trim();
     if (!trimmed) return;
@@ -14618,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({
@@ -14808,7 +16175,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
   const tokenTotal = session.usage.inputTokens + session.usage.outputTokens;
   const contextStatus = runner.getContextStatus();
   const frame = spinnerFrames()[frameIndex % spinnerFrames().length];
-  const compactUi = compact || terminalHeight < 28;
+  const compactUi = compact2 || terminalHeight < 28;
   const constrainedHeight = terminalHeight < 18;
   const compactComposer = terminalHeight < 18;
   const minimalInspector = terminalHeight < 22;
@@ -15014,6 +16381,16 @@ function initialTimeline(session, banner, setupProblem) {
   if (!items.length) {
     items.push({ id: nextId(), kind: "banner", model: banner.model, engine: banner.engine, workspace: banner.workspace, version: banner.version });
   }
+  if (session.taskContract && session.taskContract.state !== "satisfied") {
+    const required = session.taskContract.acceptanceCriteria.filter((item) => item.required);
+    const satisfied = required.filter((item) => item.status === "satisfied").length;
+    items.push({
+      id: "task-contract-progress",
+      kind: "notice",
+      tone: session.taskContract.state === "blocked" ? "error" : "info",
+      text: `Contract ${session.taskContract.state} | ${satisfied}/${required.length} accepted`
+    });
+  }
   if (setupProblem && items.length <= 1) items.push({ id: nextId(), kind: "notice", tone: "error", text: setupProblem });
   return items;
 }
@@ -15105,17 +16482,17 @@ function composerAttachments(value) {
   const paths = [...value.matchAll(/(?:^|\s)@([^\s]+)/g)].map((match) => match[1]).filter((path) => Boolean(path));
   return [...new Set(paths)].slice(-3);
 }
-function permissionRows(width, hasCwd, compact) {
+function permissionRows(width, hasCwd, compact2) {
   const content = 3 + (hasCwd ? 1 : 0);
   if (width >= 64) return content + 2;
   if (width >= 28) return content + 3;
-  if (compact) return content + 3;
+  if (compact2) return content + 3;
   return content + 5;
 }
-function contextInspectorRows(session, compact, width, minimal) {
+function contextInspectorRows(session, compact2, width, minimal) {
   if (minimal) return 2;
   const working = session.workingMemory;
-  const entries = 5 + (compact ? 0 : (working?.constraints.length ? 1 : 0) + (working?.decisions.length ? 1 : 0) + (working?.openQuestions.length ? 1 : 0) + (working?.relevantFiles.length ? 1 : 0));
+  const entries = 5 + (compact2 ? 0 : (working?.constraints.length ? 1 : 0) + (working?.decisions.length ? 1 : 0) + (working?.openQuestions.length ? 1 : 0) + (working?.relevantFiles.length ? 1 : 0));
   return 2 + entries * (width < 52 ? 2 : 1);
 }
 function contextInspectorStatus(status) {
@@ -15167,14 +16544,14 @@ function WorkspacePreparationView({
   const theme = useTheme();
   const safeWidth2 = Math.max(1, Math.floor(width));
   const innerWidth = Math.max(1, safeWidth2 - (safeWidth2 >= 24 ? 4 : 0));
-  const compact = safeWidth2 < 48;
+  const compact2 = safeWidth2 < 48;
   const constrained = height < 14;
   const ascii = process.env.SKEIN_GLYPHS === "ascii" || process.env.MOSAIC_GLYPHS === "ascii";
   const spinner = (ascii ? [".", "o", "O", "o"] : ["\u25DC", "\u25E0", "\u25DD", "\u25DE", "\u25E1", "\u25DF"])[frame % (ascii ? 4 : 6)];
   const separator = ascii ? "|" : "\xB7";
   const brand = ascii ? "*" : PRODUCT_MARK;
   const phase = readiness ? "ready" : error ? "error" : progress.phase;
-  const phaseLabel = preparationLabel(phase, progress, readiness, compact);
+  const phaseLabel = preparationLabel(phase, progress, readiness, compact2);
   const detail = preparationDetail(phase, progress, readiness, error);
   const modelLine = `model ${sanitizeTerminalText(model)}`;
   const workspaceLine = `workspace ${compactDisplayPath(sanitizeTerminalText(workspace), Math.max(1, innerWidth - 10))}`;
@@ -15186,14 +16563,14 @@ function WorkspacePreparationView({
         "  ",
         PRODUCT_NAME.toUpperCase()
       ] }),
-      !compact && !constrained ? /* @__PURE__ */ jsxs4(Text4, { color: theme.dim, children: [
+      !compact2 && !constrained ? /* @__PURE__ */ jsxs4(Text4, { color: theme.dim, children: [
         "  ",
         separator,
         "  LOCAL CONTEXT"
       ] }) : null
     ] }),
     !constrained ? /* @__PURE__ */ jsx4(Text4, { color: theme.muted, children: truncateDisplay("Ground the workspace before the first request.", innerWidth) }) : null,
-    !constrained && !compact ? /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: truncateDisplay(`${modelLine}  ${separator}  ${workspaceLine}`, innerWidth) }) : !constrained ? /* @__PURE__ */ jsxs4(Fragment3, { children: [
+    !constrained && !compact2 ? /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: truncateDisplay(`${modelLine}  ${separator}  ${workspaceLine}`, innerWidth) }) : !constrained ? /* @__PURE__ */ jsxs4(Fragment3, { children: [
       /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: truncateDisplay(modelLine, innerWidth) }),
       /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: truncateDisplay(workspaceLine, innerWidth) })
     ] }) : /* @__PURE__ */ jsx4(Text4, { color: theme.dim, children: truncateDisplay(workspaceLine, innerWidth) }),
@@ -15207,10 +16584,10 @@ function WorkspacePreparationView({
         step2.glyph,
         " "
       ] }),
-      /* @__PURE__ */ jsx4(Text4, { bold: step2.state === "active", color: step2.state === "pending" ? theme.dim : theme.textStrong, children: truncateDisplay(step2.label, compact ? 8 : 10) }),
+      /* @__PURE__ */ jsx4(Text4, { bold: step2.state === "active", color: step2.state === "pending" ? theme.dim : theme.textStrong, children: truncateDisplay(step2.label, compact2 ? 8 : 10) }),
       /* @__PURE__ */ jsxs4(Text4, { color: step2.state === "active" ? theme.muted : theme.dim, children: [
         "  ",
-        truncateDisplay(step2.detail, Math.max(1, innerWidth - displayWidth(step2.glyph) - (compact ? 12 : 14)))
+        truncateDisplay(step2.detail, Math.max(1, innerWidth - displayWidth(step2.glyph) - (compact2 ? 12 : 14)))
       ] })
     ] }, step2.id)) }),
     /* @__PURE__ */ jsxs4(Box3, { marginTop: 1, children: [
@@ -15351,9 +16728,9 @@ async function runWorkspacePreparation(engine, config, options = {}) {
   await instance.waitUntilExit();
   return result ?? { status: "cancelled" };
 }
-function preparationLabel(phase, progress, readiness, compact = false) {
+function preparationLabel(phase, progress, readiness, compact2 = false) {
   if (phase === "ready") {
-    if (compact) return "Index verified";
+    if (compact2) return "Index verified";
     return readiness?.rebuilt ? "Workspace index created and verified" : "Workspace index verified";
   }
   if (phase === "error") return "Workspace preparation failed";
@@ -15757,7 +17134,7 @@ function OnboardingFlow({ initialConfig, saveConfig, onFinish }) {
   }, [finish, saveConfig, state]);
   return /* @__PURE__ */ jsx5(OnboardingScreen, { state, dispatch, width, compact: compactHeight });
 }
-function OnboardingScreen({ state, dispatch, width, compact = false }) {
+function OnboardingScreen({ state, dispatch, width, compact: compact2 = false }) {
   const theme = useTheme();
   const ascii = process.env.SKEIN_GLYPHS === "ascii" || process.env.MOSAIC_GLYPHS === "ascii";
   const marker = ascii ? ">" : "\u203A";
@@ -15774,14 +17151,14 @@ function OnboardingScreen({ state, dispatch, width, compact = false }) {
     ] }),
     /* @__PURE__ */ jsx5(Text6, { color: theme.border, children: truncateDisplay(stageDivider(ascii, headerWidth), headerWidth) }),
     /* @__PURE__ */ jsx5(Text6, { color: theme.dim, children: truncateDisplay(stage.name, headerWidth) }),
-    !compact ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
+    !compact2 ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
     /* @__PURE__ */ jsx5(Text6, { color: theme.textStrong, bold: true, children: truncateDisplay(titleForStep(state.step), headerWidth) }),
-    !compact ? /* @__PURE__ */ jsx5(Text6, { color: theme.muted, wrap: "wrap", children: descriptionForStep(state) }) : null,
+    !compact2 ? /* @__PURE__ */ jsx5(Text6, { color: theme.muted, wrap: "wrap", children: descriptionForStep(state) }) : null,
     summary ? /* @__PURE__ */ jsx5(Text6, { color: theme.dim, children: truncateDisplay(summary, headerWidth) }) : null,
-    !compact ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
-    state.step === "method" ? /* @__PURE__ */ jsx5(OptionList, { options: methods, selected: state.selected, marker, width: headerWidth, compact }) : null,
-    state.step === "official-provider" ? /* @__PURE__ */ jsx5(OptionList, { options: officialProviders, selected: state.selected, marker, width: headerWidth, compact }) : null,
-    state.step === "relay-protocol" ? /* @__PURE__ */ jsx5(OptionList, { options: relayProtocols, selected: state.selected, marker, width: headerWidth, compact }) : null,
+    !compact2 ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
+    state.step === "method" ? /* @__PURE__ */ jsx5(OptionList, { options: methods, selected: state.selected, marker, width: headerWidth, compact: compact2 }) : null,
+    state.step === "official-provider" ? /* @__PURE__ */ jsx5(OptionList, { options: officialProviders, selected: state.selected, marker, width: headerWidth, compact: compact2 }) : null,
+    state.step === "relay-protocol" ? /* @__PURE__ */ jsx5(OptionList, { options: relayProtocols, selected: state.selected, marker, width: headerWidth, compact: compact2 }) : null,
     inputField ? /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
       /* @__PURE__ */ jsxs5(Box4, { children: [
         /* @__PURE__ */ jsx5(Text6, { color: theme.textStrong, bold: true, children: inputField.label }),
@@ -15809,18 +17186,18 @@ function OnboardingScreen({ state, dispatch, width, compact = false }) {
       "! ",
       truncateDisplay(state.error, Math.max(1, headerWidth - 2))
     ] }) : null,
-    !compact ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
+    !compact2 ? /* @__PURE__ */ jsx5(Box4, { height: 1 }) : null,
     /* @__PURE__ */ jsx5(Text6, { color: theme.dim, children: footerForStep(state, headerWidth) })
   ] });
 }
-function OptionList({ options, selected, marker, width, compact }) {
+function OptionList({ options, selected, marker, width, compact: compact2 }) {
   const theme = useTheme();
   return /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", children: options.map((option, index) => {
     const active = index === selected;
     const prefix = active ? `${marker} ` : "  ";
     const available = Math.max(1, width - displayWidth(prefix) - (active ? 2 : 0));
     const label = `${prefix}${truncateDisplay(option.label, available)}`;
-    return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", marginBottom: compact || index === options.length - 1 ? 0 : 1, children: [
+    return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", marginBottom: compact2 || index === options.length - 1 ? 0 : 1, children: [
       /* @__PURE__ */ jsx5(
         Text6,
         {
@@ -15830,7 +17207,7 @@ function OptionList({ options, selected, marker, width, compact }) {
           children: active ? padDisplay(label, width) : label
         }
       ),
-      !compact && width >= 36 || active ? /* @__PURE__ */ jsx5(Box4, { marginLeft: 2, width: Math.max(1, width - 2), children: /* @__PURE__ */ jsx5(Text6, { color: active ? theme.muted : theme.dim, wrap: "wrap", children: option.detail }) }) : null
+      !compact2 && width >= 36 || active ? /* @__PURE__ */ jsx5(Box4, { marginLeft: 2, width: Math.max(1, width - 2), children: /* @__PURE__ */ jsx5(Text6, { color: active ? theme.muted : theme.dim, wrap: "wrap", children: option.detail }) }) : null
     ] }, option.label);
   }) });
 }
@@ -15944,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 createHash12 } 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 inputSchema10 = copyInputSchema(remoteTool.inputSchema);
+  const inputSchema12 = copyInputSchema(remoteTool.inputSchema);
   return {
     definition: {
       name: options.exposedName,
@@ -15969,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: inputSchema10
+      inputSchema: inputSchema12
     },
     permissionCategories: () => ["network"],
     async execute(arguments_, context) {
@@ -15989,6 +17366,8 @@ function createMcpToolAdapter(options) {
         metadata: {
           mcpServer: options.serverName,
           mcpTool: remoteTool.name,
+          sourceBytes: normalized.sourceBytes,
+          sourceTruncated: normalized.sourceTruncated,
           ...normalized.isError ? { mcpError: true } : {}
         }
       };
@@ -16018,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) {
@@ -16042,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 = [];
@@ -16058,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);
@@ -16106,15 +17500,10 @@ function fitToolName(name, identity) {
   return `${name.slice(0, 64 - suffix.length).replace(/_+$/g, "")}${suffix}`;
 }
 function shortHash(value) {
-  return createHash12("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);
@@ -16126,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-]+$/;
@@ -16204,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}`);
   });
@@ -16544,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;
@@ -16703,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`);
@@ -16729,9 +18130,9 @@ async function closeTransportQuietly(transport) {
 }
 
 // src/memory/tools.ts
-import { z as z16 } from "zod";
-var scopeSchema = z16.enum(["user", "workspace", "session", "agent"]);
-var kindSchema = z16.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 [
     {
@@ -16746,10 +18147,10 @@ function createMemoryTools(store) {
         }, ["query"])
       },
       async execute(arguments_, context) {
-        const input2 = z16.object({
-          query: z16.string().max(4e3),
+        const input2 = z19.object({
+          query: z19.string().max(4e3),
           scope: scopeSchema.optional(),
-          limit: z16.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 });
@@ -16781,17 +18182,17 @@ ${record.content}`
         }, ["content", "rationale"])
       },
       async execute(arguments_, context) {
-        const input2 = z16.object({
-          content: z16.string().min(1).max(12e3),
-          rationale: z16.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: z16.array(z16.string()).max(24).optional(),
-          importance: z16.number().min(0).max(1).optional(),
-          confidence: z16.number().min(0).max(1).optional(),
-          agent: z16.string().max(64).optional(),
-          revision: z16.string().max(240).optional(),
-          conflictKey: z16.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({
@@ -16829,9 +18230,9 @@ ${record.content}`
         }, ["id"])
       },
       async execute(arguments_) {
-        const input2 = z16.object({
-          id: z16.string().uuid(),
-          permanent: z16.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 {
@@ -16858,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) {
@@ -16880,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 = {
@@ -16929,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 [];
@@ -16965,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;
@@ -16984,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;
   }
@@ -17035,7 +18436,7 @@ function escapeAttribute6(value) {
 }
 
 // src/workflows/catalog.ts
-import { z as z17 } from "zod";
+import { z as z20 } from "zod";
 var builtInWorkflows = [
   {
     name: "implement",
@@ -17126,7 +18527,7 @@ function createWorkflowTool(catalog) {
       }, ["name", "task"])
     },
     async execute(arguments_) {
-      const input2 = z17.object({ name: z17.string(), task: z17.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 {
@@ -17171,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;
@@ -17376,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 });
     });
   });
 }
@@ -17633,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}
 `);
@@ -17644,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");
@@ -18021,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)) {
@@ -18246,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 {
@@ -18409,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();