@skein-code/cli 0.3.10 → 0.3.12

package/dist/cli.js

@@ -4,7 +4,7 @@
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 import { writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename12, resolve as resolve22 } from "node:path";
+import { basename as basename12, resolve as resolve23 } from "node:path";
 import { Command, Option } from "commander";
 import chalk4 from "chalk";
 
@@ -220,7 +220,7 @@ function isSqliteBusy(error) {
 // package.json
 var package_default = {
   name: "@skein-code/cli",
-  version: "0.3.10",
+  version: "0.3.12",
   description: "A context-first, model-agnostic coding agent with an auditable terminal workspace.",
   type: "module",
   license: "MIT",
@@ -236,9 +236,9 @@ var package_default = {
   },
   skein: {
     releaseNotes: [
-      "Complex executable requests now use a durable Task Contract with evidence-bound acceptance criteria",
-      "Completion stays unverified while required acceptance or final verification remains unresolved",
-      "Structured tool failure receipts add concise repair hints, retry budgets, cancellation handling, and identical-call circuit breaking"
+      "Each model request records privacy-safe token partitions and actual-versus-estimated provenance",
+      "Local retrieval now selects focused, standard, broad, or maximum evidence budgets",
+      "Terminal and JSON diagnostics expose budget decisions without storing prompt or source content"
     ]
   },
   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,
@@ -2484,6 +2484,112 @@ function shouldUseProviderEnvironmentKey(provider, baseUrl) {
   return baseUrl.replace(/\/+$/u, "") === official[provider];
 }
 
+// src/context/budget.ts
+var tierTokens = {
+  focused: 2e3,
+  standard: 4e3,
+  broad: 8e3,
+  maximum: 12e3
+};
+function selectContextBudget(query, config, options = {}) {
+  if (options.trivial) return noContextBudget("trivial turn; retrieval skipped");
+  const configuredCeiling = positiveFloor(options.maxTokens ?? config.context.maxTokens);
+  const configuredTopK = positiveFloor(options.topK ?? config.context.topK);
+  if (configuredCeiling === 0 || configuredTopK === 0) {
+    return noContextBudget("retrieval disabled by the configured context ceiling");
+  }
+  const normalized = query.trim().toLocaleLowerCase();
+  const explicitPaths = countExplicitPaths(query);
+  const breadthSignals = countMatches(normalized, [
+    /\b(?:cross[- ]module|cross[- ]package|across modules|across packages|entire repository|whole repository|whole codebase|all modules|all packages|end[- ]to[- ]end)\b/gu,
+    /跨模块|跨包|全仓库|全代码库|整个(?:项目|仓库|代码库)|所有(?:模块|包)|端到端/gu
+  ]);
+  const exhaustiveSignals = countMatches(normalized, [
+    /\b(?:exhaustive|comprehensive|repository[- ]wide|codebase[- ]wide|all call sites|all usages|architecture migration|security audit)\b/gu,
+    /全面|完整审计|全量|全局迁移|所有调用|所有引用|架构迁移|安全审计/gu
+  ]);
+  const coordinationSignals = countMatches(normalized, [
+    /\b(?:and|then|also|plus|including|migrate|redesign|architecture|integration|workflow)\b/gu,
+    /并且|然后|同时|以及|包括|迁移|重设计|架构|集成|工作流/gu
+  ]);
+  let tier;
+  let reason;
+  if (breadthSignals > 0 && exhaustiveSignals > 0 && (coordinationSignals >= 2 || normalized.length >= 180)) {
+    tier = "maximum";
+    reason = "explicit repository-wide work with exhaustive, multi-part scope";
+  } else if (breadthSignals > 0 || exhaustiveSignals >= 2) {
+    tier = "broad";
+    reason = "cross-module or repository-wide evidence requested";
+  } else if (explicitPaths > 0 && coordinationSignals < 2) {
+    tier = "focused";
+    reason = "one or more explicit paths bound the evidence surface";
+  } else if ((options.intent === "explain" || options.intent === "review" || options.intent === "test") && normalized.length <= 160 && coordinationSignals < 2) {
+    tier = "focused";
+    reason = `short ${options.intent} request with a narrow evidence surface`;
+  } else {
+    tier = "standard";
+    reason = "ordinary implementation, debugging, or refactoring request";
+  }
+  const requestedTokens = tierTokens[tier];
+  const budgetTokens = Math.min(configuredCeiling, requestedTokens);
+  const baseBudgetTokens = Math.min(budgetTokens, tierTokens.focused);
+  const incrementalBudgetTokens = Math.max(0, budgetTokens - baseBudgetTokens);
+  const topKByTier = {
+    focused: 4,
+    standard: 8,
+    broad: 12,
+    maximum: 16
+  };
+  const topK = Math.min(configuredTopK, topKByTier[tier]);
+  const capped = budgetTokens < requestedTokens ? `; capped by configuration at ${budgetTokens} tokens` : "";
+  return {
+    tier,
+    budgetTokens,
+    baseBudgetTokens,
+    incrementalBudgetTokens,
+    topK,
+    reason: `${reason}${capped}`
+  };
+}
+function emptyPackedContext(decision, engine = "local") {
+  return {
+    text: "",
+    hits: [],
+    estimatedTokens: 0,
+    engine,
+    truncated: false,
+    budgetTier: decision.tier,
+    budgetTokens: decision.budgetTokens,
+    baseBudgetTokens: decision.baseBudgetTokens,
+    incrementalBudgetTokens: decision.incrementalBudgetTokens,
+    budgetReason: decision.reason,
+    candidateHits: 0,
+    selectedHits: 0,
+    duplicateHits: 0,
+    incrementalEvidenceTokens: 0
+  };
+}
+function noContextBudget(reason) {
+  return {
+    tier: "none",
+    budgetTokens: 0,
+    baseBudgetTokens: 0,
+    incrementalBudgetTokens: 0,
+    topK: 0,
+    reason
+  };
+}
+function positiveFloor(value) {
+  return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+function countMatches(value, patterns) {
+  return patterns.reduce((total, pattern) => total + [...value.matchAll(pattern)].length, 0);
+}
+function countExplicitPaths(value) {
+  const matches = value.match(/(?:^|[\s'"`(])@?(?:\.{0,2}[/\\]|[A-Za-z]:[/\\]|[\w.-]+[/\\])[\w@%+.,()[\]{}=-]+(?:[/\\][\w@%+.,()[\]{}=-]+)*(?:\.\w+)?/gu);
+  return matches?.length ?? 0;
+}
+
 // src/context/local-index.ts
 import { createHash as createHash5 } from "node:crypto";
 import { lstat as lstat8, readFile as readFile3, stat as stat3 } from "node:fs/promises";
@@ -2604,6 +2710,58 @@ async function pathExists(path) {
   }
 }
 
+// src/utils/tokens.ts
+function estimateTokens(value) {
+  let tokens2 = 0;
+  for (const character of value) tokens2 += estimatedTokenCost(character);
+  return Math.ceil(tokens2 - Number.EPSILON * Math.max(1, value.length) * 32);
+}
+function estimatedTokenCost(character) {
+  const codePoint = character.codePointAt(0) ?? 0;
+  if (codePoint <= 127) return 0.25;
+  if (isEmojiOrSupplementarySymbol(character, codePoint)) return 2;
+  if (/^[\p{P}\p{S}]$/u.test(character)) return 0.5;
+  if (isCjkCharacter(codePoint)) return 1;
+  return 2;
+}
+function sliceStartByTokens(value, budget) {
+  if (budget <= 0) return "";
+  let used = 0;
+  let end = 0;
+  for (const character of value) {
+    const cost = estimatedTokenCost(character);
+    if (used + cost > budget) break;
+    used += cost;
+    end += character.length;
+  }
+  return value.slice(0, end);
+}
+function sliceEndByTokens(value, budget) {
+  if (budget <= 0) return "";
+  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 = estimatedTokenCost(character);
+    if (used + cost > budget) break;
+    used += cost;
+    start = next;
+  }
+  return value.slice(start);
+}
+function isCjkCharacter(codePoint) {
+  return codePoint >= 11904 && codePoint <= 40959 || codePoint >= 44032 && codePoint <= 55215 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 131072 && codePoint <= 195103 || codePoint >= 12352 && codePoint <= 12543;
+}
+function isEmojiOrSupplementarySymbol(character, codePoint) {
+  return codePoint > 65535 || new RegExp("\\p{Extended_Pictographic}", "u").test(character);
+}
+
 // src/context/local-index.ts
 var contentHashSchema = z3.string().regex(/^[a-f\d]{64}$/u);
 var indexedChunkSchema = z3.object({
@@ -3045,17 +3203,31 @@ function packContextHits(hits, roots, maxTokens, engine) {
   const uniquePaths = new Set(hits.map((hit) => hit.path)).size;
   let estimatedTokens = 0;
   let truncated = false;
+  let duplicateHits = 0;
+  let perFileLimitHits = 0;
   for (const hit of hits) {
     const count = perFile.get(hit.path) ?? 0;
-    if (uniquePaths > 1 && count >= 2) continue;
-    if (selected.some((candidate) => hasSubstantialOverlap(candidate, hit))) continue;
+    if (uniquePaths > 1 && count >= 2) {
+      perFileLimitHits += 1;
+      continue;
+    }
+    if (selected.some((candidate) => hasSubstantialOverlap(candidate, hit))) {
+      duplicateHits += 1;
+      continue;
+    }
     const tokens2 = estimateTokens(hit.content);
     if (estimatedTokens + tokens2 > maxTokens) {
-      const remainingChars = Math.max(0, (maxTokens - estimatedTokens) * 4);
-      if (remainingChars >= 32) {
-        selected.push({ ...hit, content: hit.content.slice(0, remainingChars) });
+      const remainingTokens = Math.max(0, maxTokens - estimatedTokens);
+      const content = sliceStartByTokens(hit.content, remainingTokens);
+      if (content.length >= 32) {
+        const returnedLines = Math.max(1, content.split("\n").length);
+        selected.push({
+          ...hit,
+          content,
+          endLine: Math.min(hit.endLine, hit.startLine + returnedLines - 1)
+        });
         perFile.set(hit.path, count + 1);
-        estimatedTokens = maxTokens;
+        estimatedTokens += estimateTokens(content);
       }
       truncated = true;
       break;
@@ -3071,7 +3243,16 @@ function packContextHits(hits, roots, maxTokens, engine) {
 ${hit.content}
 </code>`;
   }).join("\n\n");
-  return { text, hits: selected, estimatedTokens, engine, truncated };
+  return {
+    text,
+    hits: selected,
+    estimatedTokens,
+    engine,
+    truncated,
+    candidateHits: hits.length,
+    selectedHits: selected.length,
+    duplicateHits: duplicateHits + perFileLimitHits
+  };
 }
 function cloneHits(hits) {
   return hits.map((hit) => ({ ...hit }));
@@ -3082,9 +3263,6 @@ function hashContent(content) {
 function createGeneration(files) {
   return createHash5("sha256").update(files.slice().sort((left, right) => left.absolutePath.localeCompare(right.absolutePath)).map((file) => `${file.absolutePath}\0${file.contentHash}`).join("\n"), "utf8").digest("hex").slice(0, 16);
 }
-function estimateTokens(content) {
-  return Math.ceil(content.length / 4);
-}
 function hasSubstantialOverlap(left, right) {
   if (left.path !== right.path) return false;
   const overlap = Math.max(0, Math.min(left.endLine, right.endLine) - Math.max(left.startLine, right.startLine) + 1);
@@ -3205,15 +3383,28 @@ var ContextEngine = class {
   config;
   local;
   degradation;
-  async pack(query) {
+  async pack(query, options = {}) {
+    const decision = selectContextBudget(query, this.config, options);
+    if (decision.budgetTokens === 0 || decision.topK === 0) {
+      this.degradation = void 0;
+      return emptyPackedContext(decision);
+    }
     try {
       const packed = await this.local.pack(
         query,
-        this.config.context.topK,
-        this.config.context.maxTokens
+        decision.topK,
+        decision.budgetTokens
       );
       this.degradation = void 0;
-      return packed;
+      return {
+        ...packed,
+        budgetTier: decision.tier,
+        budgetTokens: decision.budgetTokens,
+        baseBudgetTokens: decision.baseBudgetTokens,
+        incrementalBudgetTokens: decision.incrementalBudgetTokens,
+        budgetReason: decision.reason,
+        incrementalEvidenceTokens: Math.max(0, packed.estimatedTokens - decision.baseBudgetTokens)
+      };
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
       this.degradation = {
@@ -3223,11 +3414,7 @@ var ContextEngine = class {
       };
       const degradation = this.lastDegradation();
       return {
-        text: "",
-        hits: [],
-        estimatedTokens: 0,
-        engine: "local",
-        truncated: false,
+        ...emptyPackedContext(decision),
         ...degradation ? { degradation } : {}
       };
     }
@@ -3324,7 +3511,7 @@ var ContextManager = class {
   status(session, modelContextTokens) {
     const active = activeMessages(session);
     const activeTokens = estimateMessages(active);
-    const summaryTokens = estimateTokens2(session.contextSummary ?? "");
+    const summaryTokens = estimateTokens(session.contextSummary ?? "");
     const toolTokenCount = toolTokens(active);
     const contextLimit = Math.max(
       8e3,
@@ -3351,11 +3538,11 @@ var ContextManager = class {
     const active = activeMessages(session);
     const cut = compactionCut(active);
     if (cut === 0) {
-      return { omittedMessages: 0, summaryTokens: estimateTokens2(session.contextSummary ?? "") };
+      return { omittedMessages: 0, summaryTokens: estimateTokens(session.contextSummary ?? "") };
     }
     const older = active.slice(0, cut);
     if (!older.length) {
-      return { omittedMessages: 0, summaryTokens: estimateTokens2(session.contextSummary ?? "") };
+      return { omittedMessages: 0, summaryTokens: estimateTokens(session.contextSummary ?? "") };
     }
     const transcript = older.map(formatMessageForSummary).join("\n\n").slice(-14e4);
     const response = await provider.complete([
@@ -3376,7 +3563,7 @@ ${transcript}`)
     session.contextCompactions = (session.contextCompactions ?? 0) + 1;
     return {
       omittedMessages: older.length,
-      summaryTokens: estimateTokens2(session.contextSummary)
+      summaryTokens: estimateTokens(session.contextSummary)
     };
   }
   buildShortTermPrompt(session) {
@@ -3505,13 +3692,10 @@ function concise(value, max) {
   return normalized.length <= max ? normalized : `${normalized.slice(0, max - 1)}\u2026`;
 }
 function estimateMessages(messages) {
-  return messages.reduce((sum, message2) => sum + estimateTokens2(message2.content) + estimateTokens2(JSON.stringify(message2.toolCalls ?? [])), 0);
+  return messages.reduce((sum, message2) => sum + estimateTokens(message2.content) + estimateTokens(JSON.stringify(message2.toolCalls ?? [])), 0);
 }
 function toolTokens(messages) {
-  return messages.filter((message2) => message2.role === "tool").reduce((sum, message2) => sum + estimateTokens2(message2.content), 0);
-}
-function estimateTokens2(value) {
-  return Math.ceil(value.length / 4);
+  return messages.filter((message2) => message2.role === "tool").reduce((sum, message2) => sum + estimateTokens(message2.content), 0);
 }
 
 // src/context/mentions.ts
@@ -4755,7 +4939,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 +4960,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 +4984,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 +5022,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 +5153,14 @@ var contextSourceSchema = z5.object({
   tokens: z5.number().int().nonnegative(),
   addedAt: z5.string()
 }).strict();
+var toolArtifactSchema = z5.object({
+  toolCallId: z5.string().min(1).max(512).refine((value) => !/[\u0000-\u001f\u007f-\u009f]/u.test(value)),
+  sha256: z5.string().regex(/^[a-f0-9]{64}$/u),
+  bytes: z5.number().int().nonnegative().max(5 * 1024 * 1024),
+  createdAt: z5.string().datetime(),
+  expiresAt: z5.string().datetime(),
+  redacted: z5.boolean()
+}).strict();
 var verificationEvidenceSchema = z5.object({
   toolCallId: z5.string(),
   tool: z5.enum(["shell", "git"]),
@@ -5037,12 +5237,59 @@ 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(),
-    outputTokens: z5.number().nonnegative()
-  }).strict()
+    outputTokens: z5.number().nonnegative(),
+    source: z5.enum(["actual", "estimated", "mixed", "unknown"]).optional(),
+    inputSource: z5.enum(["actual", "estimated", "mixed", "unknown"]).optional(),
+    outputSource: z5.enum(["actual", "estimated", "mixed", "unknown"]).optional(),
+    actualInputTokens: z5.number().nonnegative().optional(),
+    actualOutputTokens: z5.number().nonnegative().optional(),
+    estimatedInputTokens: z5.number().nonnegative().optional(),
+    estimatedOutputTokens: z5.number().nonnegative().optional()
+  }).strict(),
+  tokenLedger: z5.array(z5.object({
+    requestId: z5.string().uuid(),
+    turn: z5.number().int().positive(),
+    recordedAt: z5.string().datetime(),
+    estimated: z5.object({
+      stableTokens: z5.number().nonnegative(),
+      dynamicTokens: z5.number().nonnegative(),
+      conversationTokens: z5.number().nonnegative(),
+      toolResultTokens: z5.number().nonnegative(),
+      retrievedTokens: z5.number().nonnegative(),
+      toolSchemaTokens: z5.number().nonnegative(),
+      estimatedInputTokens: z5.number().nonnegative(),
+      outputAllowanceTokens: z5.number().nonnegative(),
+      outputTokens: z5.number().nonnegative()
+    }).strict(),
+    actual: z5.object({
+      inputTokens: z5.number().nonnegative().optional(),
+      outputTokens: z5.number().nonnegative().optional()
+    }).strict(),
+    inputSource: z5.enum(["actual", "estimated"]),
+    outputSource: z5.enum(["actual", "estimated"]),
+    tools: z5.object({
+      loaded: z5.array(z5.string()),
+      deferredCount: z5.number().int().nonnegative()
+    }).strict(),
+    retrieval: z5.object({
+      engine: z5.string(),
+      budgetTier: z5.enum(["none", "focused", "standard", "broad", "maximum"]).optional(),
+      budgetTokens: z5.number().nonnegative().optional(),
+      candidateHits: z5.number().int().nonnegative().optional(),
+      selectedHits: z5.number().int().nonnegative().optional(),
+      duplicateHits: z5.number().int().nonnegative().optional(),
+      incrementalEvidenceTokens: z5.number().nonnegative().optional(),
+      discarded: z5.array(z5.object({
+        reason: z5.enum(["overlapping-span", "budget-cap"]),
+        count: z5.number().int().positive()
+      }).strict())
+    }).strict()
+  }).strict()).max(256).optional()
 }).strict();
 var SessionStore = class {
   workspace;
@@ -5298,13 +5545,390 @@ async function exists2(path) {
   }
 }
 
+// src/session/tool-artifacts.ts
+import { createHash as createHash7 } from "node:crypto";
+import { lstat as lstat12, readFile as readFile7, readdir as readdir4, rm as rm2 } from "node:fs/promises";
+import { join as join11, resolve as resolve13 } from "node:path";
+import { z as z6 } from "zod";
+var MAX_ARTIFACT_BYTES = 5 * 1024 * 1024;
+var MAX_TOTAL_BYTES = 20 * 1024 * 1024;
+var RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
+var sessionIdSchema2 = z6.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/);
+var toolCallIdSchema = z6.string().min(1).max(512).refine((value) => !/[\u0000-\u001f\u007f-\u009f]/u.test(value), {
+  message: "Tool call id cannot contain control characters."
+});
+var artifactSchema = z6.object({
+  version: z6.literal(1),
+  sessionId: sessionIdSchema2,
+  toolCallId: toolCallIdSchema,
+  sha256: z6.string().regex(/^[a-f0-9]{64}$/u),
+  bytes: z6.number().int().nonnegative().max(MAX_ARTIFACT_BYTES),
+  createdAt: z6.string().datetime(),
+  expiresAt: z6.string().datetime(),
+  redacted: z6.boolean(),
+  content: z6.string()
+}).strict();
+var ToolArtifactStore = class {
+  workspace;
+  directory;
+  managedDirectory;
+  now;
+  maxArtifactBytes;
+  maxTotalBytes;
+  retentionMs;
+  writes = Promise.resolve();
+  constructor(workspace, options = {}) {
+    this.workspace = resolve13(workspace);
+    this.managedDirectory = options.directory === void 0;
+    this.directory = options.directory ? resolve13(options.directory) : join11(resolveProjectNamespaceSync(this.workspace).active, "tool-artifacts");
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.maxArtifactBytes = options.maxArtifactBytes ?? MAX_ARTIFACT_BYTES;
+    this.maxTotalBytes = options.maxTotalBytes ?? MAX_TOTAL_BYTES;
+    this.retentionMs = options.retentionMs ?? RETENTION_MS;
+    if (!Number.isSafeInteger(this.maxArtifactBytes) || this.maxArtifactBytes < 1 || this.maxArtifactBytes > MAX_ARTIFACT_BYTES) {
+      throw new Error(`maxArtifactBytes must be between 1 and ${MAX_ARTIFACT_BYTES}.`);
+    }
+    if (!Number.isSafeInteger(this.maxTotalBytes) || this.maxTotalBytes < this.maxArtifactBytes) {
+      throw new Error("maxTotalBytes must be at least maxArtifactBytes.");
+    }
+    if (!Number.isSafeInteger(this.retentionMs) || this.retentionMs < 1) {
+      throw new Error("retentionMs must be a positive integer.");
+    }
+  }
+  async archive(sessionId, toolCallId, content, options) {
+    sessionIdSchema2.parse(sessionId);
+    toolCallIdSchema.parse(toolCallId);
+    const bytes = Buffer.byteLength(content);
+    if (bytes > this.maxArtifactBytes) return { stored: false, reason: "too_large" };
+    return this.enqueue(() => this.withManagedLease(async () => {
+      await this.ensureDirectory();
+      const now = this.now();
+      const artifacts = await this.loadArtifacts();
+      await this.removeExpired(artifacts, now);
+      const active = artifacts.filter((artifact2) => artifact2.expiresAt > now.toISOString());
+      const sha256 = hash(content);
+      const existing = active.find((artifact2) => artifact2.sessionId === sessionId && artifact2.toolCallId === toolCallId);
+      if (existing) {
+        if (existing.sha256 === sha256 && existing.bytes === bytes && existing.redacted === options.redacted) {
+          return { stored: true, artifact: reference(existing) };
+        }
+        return { stored: false, reason: "conflict" };
+      }
+      const artifact = {
+        version: 1,
+        sessionId,
+        toolCallId,
+        sha256,
+        bytes,
+        createdAt: now.toISOString(),
+        expiresAt: new Date(now.getTime() + this.retentionMs).toISOString(),
+        redacted: options.redacted,
+        content
+      };
+      const storageBytes = storedBytes(artifact);
+      let retainedBytes = active.reduce((total, retained) => total + storedBytes(retained), 0);
+      const evictable = active.slice().sort(
+        (left, right) => left.createdAt.localeCompare(right.createdAt)
+      );
+      while (retainedBytes + storageBytes > this.maxTotalBytes && evictable.length) {
+        const oldest = evictable.shift();
+        await this.removeArtifact(oldest);
+        retainedBytes -= storedBytes(oldest);
+      }
+      if (retainedBytes + storageBytes > this.maxTotalBytes) return { stored: false, reason: "total_limit" };
+      const path = this.pathFor(sessionId, toolCallId);
+      await ensureWorkspaceStorageDirectory(this.workspace, resolve13(path, ".."), {
+        requireActiveNamespace: this.managedDirectory
+      });
+      await atomicWrite(path, `${JSON.stringify(artifact)}
+`, 384);
+      return { stored: true, artifact: reference(artifact) };
+    }));
+  }
+  async read(sessionId, toolCallId, options = {}) {
+    sessionIdSchema2.parse(sessionId);
+    toolCallIdSchema.parse(toolCallId);
+    const startLine = options.startLine ?? 1;
+    const startByte = options.startByte;
+    const maxLines = options.maxLines ?? 200;
+    const maxBytes = options.maxBytes ?? 3e3;
+    if (startByte !== void 0 && options.startLine !== void 0) {
+      throw new Error("Use either startLine or startByte, not both.");
+    }
+    if (!Number.isInteger(startLine) || startLine < 1) throw new Error("startLine must be a positive integer.");
+    if (startByte !== void 0 && (!Number.isInteger(startByte) || startByte < 0)) {
+      throw new Error("startByte must be a non-negative integer.");
+    }
+    if (!Number.isInteger(maxLines) || maxLines < 1 || maxLines > 1e3) {
+      throw new Error("maxLines must be between 1 and 1000.");
+    }
+    if (!Number.isInteger(maxBytes) || maxBytes < 256 || maxBytes > 32e3) {
+      throw new Error("maxBytes must be between 256 and 32000.");
+    }
+    await this.writes;
+    return this.withManagedLease(async () => {
+      const artifact = await this.readArtifact(sessionId, toolCallId);
+      const now = this.now();
+      if (artifact.expiresAt <= now.toISOString()) {
+        await this.removeArtifact(artifact);
+        throw new Error("The retained tool output has expired. Re-run the tool if it is still needed.");
+      }
+      const page = startByte === void 0 ? readLinePage(artifact.content, startLine, maxLines, maxBytes) : readBytePage(artifact.content, startByte, maxBytes);
+      return {
+        ...reference(artifact),
+        ...page
+      };
+    });
+  }
+  /** Remove expired output and return the still-valid receipts for one session. */
+  async prune(sessionId) {
+    sessionIdSchema2.parse(sessionId);
+    return this.enqueue(() => this.withManagedLease(async () => {
+      const artifacts = await this.loadArtifacts();
+      const now = this.now();
+      await this.removeExpired(artifacts, now);
+      return artifacts.filter((artifact) => artifact.sessionId === sessionId && artifact.expiresAt > now.toISOString()).sort((left, right) => left.createdAt.localeCompare(right.createdAt)).map(reference);
+    }));
+  }
+  /** Delete every retained result owned by a removed session. */
+  async removeSession(sessionId) {
+    sessionIdSchema2.parse(sessionId);
+    await this.enqueue(() => this.withManagedLease(async () => {
+      if (!await this.directoryAvailable()) return;
+      const directory = this.sessionDirectoryFor(sessionId);
+      try {
+        const info = await lstat12(directory);
+        if (info.isSymbolicLink() || !info.isDirectory()) {
+          throw new Error(`Tool artifact session storage is not a regular directory: ${directory}`);
+        }
+        await assertNoSymlinkPath(this.workspace, directory);
+      } catch (error) {
+        if (error.code === "ENOENT") return;
+        throw error;
+      }
+      await rm2(directory, { recursive: true, force: true });
+    }));
+  }
+  async readArtifact(sessionId, toolCallId) {
+    const path = this.pathFor(sessionId, toolCallId);
+    await this.assertRegularFile(path);
+    let artifact;
+    try {
+      artifact = artifactSchema.parse(JSON.parse(await readFile7(path, "utf8")));
+    } catch {
+      throw new Error("Retained tool output is unreadable or corrupt.");
+    }
+    if (artifact.sessionId !== sessionId || artifact.toolCallId !== toolCallId) {
+      throw new Error("Retained tool output does not belong to this session.");
+    }
+    if (artifact.bytes !== Buffer.byteLength(artifact.content) || artifact.sha256 !== hash(artifact.content)) {
+      throw new Error("Retained tool output failed its integrity check.");
+    }
+    return artifact;
+  }
+  async loadArtifacts() {
+    if (!await this.directoryAvailable()) return [];
+    const artifacts = [];
+    for (const entry of await readdir4(this.directory, { withFileTypes: true })) {
+      const sessionDirectory = join11(this.directory, entry.name);
+      if (entry.isSymbolicLink()) throw new Error(`Tool artifact storage contains a symbolic link: ${sessionDirectory}`);
+      if (!entry.isDirectory() || !/^[a-f0-9]{64}$/u.test(entry.name)) continue;
+      await assertNoSymlinkPath(this.workspace, sessionDirectory);
+      for (const file of await readdir4(sessionDirectory, { withFileTypes: true })) {
+        const path = join11(sessionDirectory, file.name);
+        if (file.isSymbolicLink()) throw new Error(`Tool artifact storage contains a symbolic link: ${path}`);
+        if (!file.isFile() || !/^[a-f0-9]{64}\.json$/u.test(file.name)) continue;
+        await this.assertRegularFile(path);
+        try {
+          const artifact = artifactSchema.parse(JSON.parse(await readFile7(path, "utf8")));
+          if (artifact.bytes !== Buffer.byteLength(artifact.content) || artifact.sha256 !== hash(artifact.content)) {
+            throw new Error("integrity");
+          }
+          if (sessionDirectory !== this.sessionDirectoryFor(artifact.sessionId) || path !== this.pathFor(artifact.sessionId, artifact.toolCallId)) {
+            throw new Error("identity");
+          }
+          artifacts.push(artifact);
+        } catch {
+          throw new Error(`Tool artifact is unreadable or corrupt: ${path}`);
+        }
+      }
+    }
+    return artifacts;
+  }
+  async removeExpired(artifacts, now) {
+    for (const artifact of artifacts) {
+      if (artifact.expiresAt <= now.toISOString()) await this.removeArtifact(artifact);
+    }
+  }
+  async removeArtifact(artifact) {
+    await rm2(this.pathFor(artifact.sessionId, artifact.toolCallId), { force: true });
+  }
+  pathFor(sessionId, toolCallId) {
+    return join11(this.sessionDirectoryFor(sessionId), `${hash(`call\0${toolCallId}`)}.json`);
+  }
+  sessionDirectoryFor(sessionId) {
+    return join11(this.directory, hash(`session\0${sessionId}`));
+  }
+  async ensureDirectory() {
+    await ensureWorkspaceStorageDirectory(this.workspace, this.directory, {
+      requireActiveNamespace: this.managedDirectory
+    });
+  }
+  async directoryAvailable() {
+    if (this.managedDirectory) await assertNoSymlinkPath(this.workspace, this.directory);
+    try {
+      const info = await lstat12(this.directory);
+      if (info.isSymbolicLink() || !info.isDirectory()) {
+        throw new Error(`Tool artifact storage is not a regular directory: ${this.directory}`);
+      }
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") return false;
+      throw error;
+    }
+  }
+  async assertRegularFile(path) {
+    await assertNoSymlinkPath(this.workspace, resolve13(path, ".."));
+    try {
+      const info = await lstat12(path);
+      if (info.isSymbolicLink() || !info.isFile()) {
+        throw new Error(`Tool artifact cannot be a symbolic link or non-regular file: ${path}`);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error("No retained tool output matches this tool call in the current session.");
+      }
+      throw error;
+    }
+  }
+  async withManagedLease(operation) {
+    if (!this.managedDirectory) return operation();
+    return withNamespaceLease(projectNamespacePaths(this.workspace).canonical, "shared", async () => {
+      assertActiveProjectNamespacePath(this.workspace, this.directory);
+      return operation();
+    });
+  }
+  async enqueue(operation) {
+    const next = this.writes.then(operation);
+    this.writes = next.then(() => void 0, () => void 0);
+    return next;
+  }
+};
+function reference(artifact) {
+  return {
+    toolCallId: artifact.toolCallId,
+    sha256: artifact.sha256,
+    bytes: artifact.bytes,
+    createdAt: artifact.createdAt,
+    expiresAt: artifact.expiresAt,
+    redacted: artifact.redacted
+  };
+}
+function hash(value) {
+  return createHash7("sha256").update(value).digest("hex");
+}
+function storedBytes(artifact) {
+  return Buffer.byteLength(JSON.stringify(artifact)) + 1;
+}
+function readLinePage(content, startLine, maxLines, maxBytes) {
+  const ranges = lineRanges(content);
+  const startIndex = startLine - 1;
+  if (startIndex >= ranges.length) {
+    const totalBytes = Buffer.byteLength(content);
+    return {
+      content: "",
+      startLine,
+      endLine: startLine - 1,
+      totalLines: ranges.length,
+      startByte: totalBytes,
+      endByte: totalBytes,
+      hasMore: false
+    };
+  }
+  const endIndex = Math.min(ranges.length - 1, startIndex + maxLines - 1);
+  const startCharacter = ranges[startIndex]?.start ?? content.length;
+  const endCharacter = ranges[endIndex]?.end ?? content.length;
+  const startByte = Buffer.byteLength(content.slice(0, startCharacter));
+  const selected = Buffer.from(content.slice(startCharacter, endCharacter));
+  if (selected.length > maxBytes) {
+    const page = sliceUtf8Buffer(selected, 0, maxBytes);
+    const pageContent = page.content;
+    return {
+      content: pageContent,
+      startLine,
+      endLine: startLine + countNewlines(pageContent),
+      totalLines: ranges.length,
+      startByte,
+      endByte: startByte + page.bytes,
+      hasMore: true,
+      nextStartByte: startByte + page.bytes
+    };
+  }
+  const endLine = endIndex + 1;
+  const hasMore = endLine < ranges.length;
+  return {
+    content: selected.toString("utf8"),
+    startLine,
+    endLine,
+    totalLines: ranges.length,
+    startByte,
+    endByte: startByte + selected.length,
+    hasMore,
+    ...hasMore ? { nextStartLine: endLine + 1 } : {}
+  };
+}
+function readBytePage(content, requestedStart, maxBytes) {
+  const buffer = Buffer.from(content);
+  const startByte = Math.min(requestedStart, buffer.length);
+  if (startByte < buffer.length && isUtf8Continuation(buffer[startByte] ?? 0)) {
+    throw new Error("startByte must be an exact UTF-8 boundary shown by a previous page.");
+  }
+  const page = sliceUtf8Buffer(buffer, startByte, maxBytes);
+  const prefix = buffer.subarray(0, startByte).toString("utf8");
+  const startLine = countNewlines(prefix) + 1;
+  const endByte = startByte + page.bytes;
+  const hasMore = endByte < buffer.length;
+  return {
+    content: page.content,
+    startLine,
+    endLine: startLine + countNewlines(page.content),
+    totalLines: countNewlines(content) + 1,
+    startByte,
+    endByte,
+    hasMore,
+    ...hasMore ? { nextStartByte: endByte } : {}
+  };
+}
+function sliceUtf8Buffer(buffer, start, maxBytes) {
+  let end = Math.min(buffer.length, start + maxBytes);
+  while (end > start && isUtf8Continuation(buffer[end] ?? 0)) end -= 1;
+  return { content: buffer.subarray(start, end).toString("utf8"), bytes: end - start };
+}
+function lineRanges(content) {
+  const ranges = [];
+  const expression = /\r?\n/gu;
+  let start = 0;
+  for (const match of content.matchAll(expression)) {
+    ranges.push({ start, end: match.index });
+    start = match.index + match[0].length;
+  }
+  ranges.push({ start, end: content.length });
+  return ranges;
+}
+function countNewlines(value) {
+  return value.match(/\n/gu)?.length ?? 0;
+}
+function isUtf8Continuation(byte) {
+  return byte >= 128 && byte < 192;
+}
+
 // src/tools/apply-patch.ts
-import { lstat as lstat12, readFile as readFile7, unlink as unlink4 } from "node:fs/promises";
+import { lstat as lstat13, readFile as readFile8, unlink as unlink4 } from "node:fs/promises";
 import { applyPatch as applyUnifiedPatch, parsePatch } from "diff";
-import { z as z6 } from "zod";
-var inputSchema2 = z6.object({
-  patch: z6.string().min(1).max(1e7),
-  dry_run: z6.boolean().optional()
+import { z as z7 } from "zod";
+var inputSchema2 = z7.object({
+  patch: z7.string().min(1).max(1e7),
+  dry_run: z7.boolean().optional()
 }).strict();
 var applyPatchTool = {
   definition: {
@@ -5560,10 +6184,10 @@ function findSequence(haystack, needle, hint, minimum) {
 }
 async function readSnapshot2(path) {
   try {
-    const info = await lstat12(path);
+    const info = await lstat13(path);
     if (info.isSymbolicLink()) throw new Error(`Refusing to patch a symbolic link: ${path}`);
     if (!info.isFile()) throw new Error(`Patch target is not a regular file: ${path}`);
-    return { before: await readFile7(path), mode: info.mode };
+    return { before: await readFile8(path), mode: info.mode };
   } catch (error) {
     if (error.code === "ENOENT") return { before: null };
     throw error;
@@ -5612,13 +6236,13 @@ function buffersEqual(left, right) {
 }
 
 // src/tools/git.ts
-import { join as join11 } from "node:path";
-import { z as z7 } from "zod";
-var inputSchema3 = z7.object({
-  args: z7.array(z7.string().max(1e4)).min(1).max(200),
-  cwd: z7.string().min(1).optional(),
-  timeout_ms: z7.number().int().min(100).max(6e5).optional(),
-  stdin: z7.string().max(5e6).optional()
+import { join as join12 } from "node:path";
+import { z as z8 } from "zod";
+var inputSchema3 = z8.object({
+  args: z8.array(z8.string().max(1e4)).min(1).max(200),
+  cwd: z8.string().min(1).optional(),
+  timeout_ms: z8.number().int().min(100).max(6e5).optional(),
+  stdin: z8.string().max(5e6).optional()
 }).strict();
 var networkCommands = /* @__PURE__ */ new Set([
   "clone",
@@ -5831,7 +6455,7 @@ var gitTool = {
     for (const candidate of explicit) {
       if (!candidate || candidate.startsWith("-")) continue;
       try {
-        paths.add(await context.workspace.resolvePath(join11(cwd, candidate), { allowMissing: true }));
+        paths.add(await context.workspace.resolvePath(join12(cwd, candidate), { allowMissing: true }));
       } catch {
       }
     }
@@ -5852,7 +6476,7 @@ var gitTool = {
         const candidates = candidate.includes(" -> ") ? candidate.split(" -> ") : [candidate];
         for (const value of candidates) {
           try {
-            paths.add(await context.workspace.resolvePath(join11(cwd, value), { allowMissing: true }));
+            paths.add(await context.workspace.resolvePath(join12(cwd, value), { allowMissing: true }));
           } catch {
           }
         }
@@ -5933,7 +6557,7 @@ async function collectGitChanges(before, after, runtime, cwd, context) {
   const paths = [];
   for (const candidate of [...candidates].slice(0, 2e3)) {
     try {
-      paths.push(await context.workspace.resolvePath(join11(cwd, candidate), { allowMissing: true }));
+      paths.push(await context.workspace.resolvePath(join12(cwd, candidate), { allowMissing: true }));
     } catch {
     }
   }
@@ -6049,7 +6673,7 @@ async function validateGitWorkspaceArguments(args, command2, cwd, context) {
     if (/^(?:[a-z]+:\/\/|[a-z]+@[^:]+:)/i.test(candidate)) continue;
     if (command2 === "clone" && index === 0 && !candidate) continue;
     await context.workspace.resolvePath(
-      candidate.startsWith("/") ? candidate : join11(cwd, candidate),
+      candidate.startsWith("/") ? candidate : join12(cwd, candidate),
       { allowMissing: true }
     );
   }
@@ -6102,17 +6726,17 @@ function positionalArguments(args, command2) {
 }
 
 // src/tools/list.ts
-import { lstat as lstat13 } from "node:fs/promises";
-import { relative as relative6, resolve as resolve13 } from "node:path";
+import { lstat as lstat14 } from "node:fs/promises";
+import { relative as relative6, resolve as resolve14 } from "node:path";
 import fg3 from "fast-glob";
-import { z as z8 } from "zod";
-var inputSchema4 = z8.object({
-  path: z8.string().min(1).optional(),
-  pattern: z8.string().min(1).optional(),
-  depth: z8.number().int().min(1).max(20).optional(),
-  include_hidden: z8.boolean().optional(),
-  include_directories: z8.boolean().optional(),
-  limit: z8.number().int().min(1).max(5e3).optional()
+import { z as z9 } from "zod";
+var inputSchema4 = z9.object({
+  path: z9.string().min(1).optional(),
+  pattern: z9.string().min(1).optional(),
+  depth: z9.number().int().min(1).max(20).optional(),
+  include_hidden: z9.boolean().optional(),
+  include_directories: z9.boolean().optional(),
+  limit: z9.number().int().min(1).max(5e3).optional()
 }).strict();
 var ignored = [
   "**/.git/**",
@@ -6161,11 +6785,11 @@ var listFilesTool = {
     for (const path of selected) {
       let safePath;
       try {
-        safePath = await context.workspace.resolvePath(resolve13(directory, path), { expect: "any" });
+        safePath = await context.workspace.resolvePath(resolve14(directory, path), { expect: "any" });
       } catch {
         continue;
       }
-      const info = await lstat13(safePath);
+      const info = await lstat14(safePath);
       rendered.push(`${info.isDirectory() ? "d" : "f"} ${relative6(directory, safePath)}${info.isDirectory() ? "/" : ""}`);
     }
     const base = workspaceAliasPath(directory, context.workspace.roots);
@@ -6182,14 +6806,14 @@ var listFilesTool = {
 };
 
 // src/tools/read.ts
-import { readFile as readFile8, stat as stat7 } from "node:fs/promises";
-import { z as z9 } from "zod";
-var inputSchema5 = z9.object({
-  path: z9.string().min(1),
-  start_line: z9.number().int().positive().optional(),
-  end_line: z9.number().int().positive().optional(),
-  line_numbers: z9.boolean().optional(),
-  max_bytes: z9.number().int().positive().max(1e6).optional()
+import { readFile as readFile9, stat as stat7 } from "node:fs/promises";
+import { z as z10 } from "zod";
+var inputSchema5 = z10.object({
+  path: z10.string().min(1),
+  start_line: z10.number().int().positive().optional(),
+  end_line: z10.number().int().positive().optional(),
+  line_numbers: z10.boolean().optional(),
+  max_bytes: z10.number().int().positive().max(1e6).optional()
 }).strict();
 var readFileTool = {
   definition: {
@@ -6212,7 +6836,7 @@ var readFileTool = {
     if (info.size > 1e7) {
       throw new Error(`File is too large to read safely (${info.size} bytes).`);
     }
-    const buffer = await readFile8(path);
+    const buffer = await readFile9(path);
     if (looksBinary(buffer)) throw new Error("Binary files cannot be read with read_file.");
     const raw = buffer.toString("utf8");
     const lines = raw.split("\n");
@@ -6256,6 +6880,73 @@ function truncateUtf8(input2, maxBytes) {
   return buffer.subarray(0, end).toString("utf8");
 }
 
+// src/tools/read-artifact.ts
+import { z as z11 } from "zod";
+var inputSchema6 = z11.object({
+  sha256: z11.string().regex(/^[a-f0-9]{64}$/u),
+  start_line: z11.number().int().positive().optional(),
+  start_byte: z11.number().int().nonnegative().optional(),
+  max_lines: z11.number().int().min(1).max(1e3).optional(),
+  max_bytes: z11.number().int().min(256).max(768).optional()
+}).strict().refine((input2) => input2.start_line === void 0 || input2.start_byte === void 0, {
+  message: "Use either start_line or start_byte, not both."
+});
+var readToolArtifactTool = {
+  definition: {
+    name: "read_tool_artifact",
+    description: "Read a bounded page of oversized tool output retained for this session. Use only the SHA-256 shown in a tool-output receipt.",
+    category: "read",
+    inputSchema: jsonSchema({
+      sha256: { type: "string", description: "The exact 64-character SHA-256 from a retained-output receipt." },
+      start_line: { type: "integer", minimum: 1, default: 1 },
+      start_byte: { type: "integer", minimum: 0, description: "Exact UTF-8 continuation byte shown by a previous page." },
+      max_lines: { type: "integer", minimum: 1, maximum: 1e3, default: 200 },
+      max_bytes: { type: "integer", minimum: 256, maximum: 768, default: 768 }
+    }, ["sha256"])
+  },
+  async execute(arguments_, context) {
+    const input2 = inputSchema6.parse(arguments_);
+    const artifact = context.session.toolArtifacts?.find(
+      (candidate) => candidate.sha256 === input2.sha256 && Date.parse(candidate.expiresAt) > Date.now()
+    );
+    if (!artifact) {
+      throw new Error("No retained tool output matches this tool call in the current session.");
+    }
+    const store = context.toolArtifactStore ?? new ToolArtifactStore(context.workspace.primaryRoot);
+    const page = await store.read(context.session.id, artifact.toolCallId, {
+      ...input2.start_line !== void 0 ? { startLine: input2.start_line } : {},
+      ...input2.start_byte !== void 0 ? { startByte: input2.start_byte } : {},
+      ...input2.max_lines !== void 0 ? { maxLines: input2.max_lines } : {},
+      maxBytes: input2.max_bytes ?? 768
+    });
+    if (page.sha256 !== artifact.sha256 || page.bytes !== artifact.bytes) {
+      throw new Error("Retained tool output no longer matches the session receipt.");
+    }
+    const heading = `Retained output page: lines ${page.startLine}-${page.endLine} of ${page.totalLines}; bytes ${page.startByte}-${page.endByte} of ${page.bytes}`;
+    const continuation = page.nextStartByte !== void 0 ? `continue with start_byte=${page.nextStartByte}` : page.nextStartLine !== void 0 ? `continue with start_line=${page.nextStartLine}` : "";
+    return {
+      content: `${heading}
+${page.content}${page.hasMore ? `
+\u2026 more retained output; ${continuation}` : ""}`,
+      metadata: {
+        artifact: {
+          toolCallId: page.toolCallId,
+          sha256: page.sha256,
+          bytes: page.bytes,
+          expiresAt: page.expiresAt,
+          redacted: page.redacted
+        },
+        startLine: page.startLine,
+        endLine: page.endLine,
+        totalLines: page.totalLines,
+        startByte: page.startByte,
+        endByte: page.endByte,
+        truncated: page.hasMore
+      }
+    };
+  }
+};
+
 // src/tools/registry.ts
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
@@ -6303,19 +6994,19 @@ function assertToolName(name) {
 }
 
 // src/tools/search.ts
-import { readFile as readFile9, stat as stat8 } from "node:fs/promises";
-import { resolve as resolve14 } from "node:path";
+import { readFile as readFile10, stat as stat8 } from "node:fs/promises";
+import { resolve as resolve15 } from "node:path";
 import fg4 from "fast-glob";
-import { z as z10 } from "zod";
-var inputSchema6 = z10.object({
-  query: z10.string().min(1).max(1e4),
-  path: z10.string().min(1).optional(),
-  pattern: z10.string().min(1).optional(),
-  mode: z10.enum(["text", "ranked"]).optional(),
-  literal: z10.boolean().optional(),
-  case_sensitive: z10.boolean().optional(),
-  context_lines: z10.number().int().min(0).max(20).optional(),
-  max_results: z10.number().int().min(1).max(500).optional()
+import { z as z12 } from "zod";
+var inputSchema7 = z12.object({
+  query: z12.string().min(1).max(1e4),
+  path: z12.string().min(1).optional(),
+  pattern: z12.string().min(1).optional(),
+  mode: z12.enum(["text", "ranked"]).optional(),
+  literal: z12.boolean().optional(),
+  case_sensitive: z12.boolean().optional(),
+  context_lines: z12.number().int().min(0).max(20).optional(),
+  max_results: z12.number().int().min(1).max(500).optional()
 }).strict();
 var ignore = [
   "**/.git/**",
@@ -6350,7 +7041,7 @@ var searchCodeTool = {
     }, ["query"])
   },
   async execute(arguments_, context) {
-    const input2 = inputSchema6.parse(arguments_);
+    const input2 = inputSchema7.parse(arguments_);
     const directory = await context.workspace.resolveDirectory(input2.path ?? ".");
     if ((input2.mode ?? "text") === "ranked") {
       if (!context.contextEngine) throw new Error("Local ranked retrieval is unavailable.");
@@ -6374,7 +7065,7 @@ var searchCodeTool = {
       if (results.length >= maxResults) break;
       let path;
       try {
-        path = await context.workspace.resolvePath(resolve14(directory, file), { expect: "file" });
+        path = await context.workspace.resolvePath(resolve15(directory, file), { expect: "file" });
       } catch {
         skipped += 1;
         continue;
@@ -6384,7 +7075,7 @@ var searchCodeTool = {
         skipped += 1;
         continue;
       }
-      const buffer = await readFile9(path);
+      const buffer = await readFile10(path);
       if (buffer.subarray(0, 8192).includes(0)) {
         skipped += 1;
         continue;
@@ -6456,17 +7147,17 @@ ${hit.content}`
 }
 
 // src/tools/shell.ts
-import { createHash as createHash7 } from "node:crypto";
-import { lstat as lstat14, readFile as readFile10, readdir as readdir4 } from "node:fs/promises";
-import { join as join12 } from "node:path";
-import { z as z11 } from "zod";
-var inputSchema7 = z11.object({
-  command: z11.string().min(1).max(1e5),
-  cwd: z11.string().min(1).optional(),
-  timeout_ms: z11.number().int().min(100).max(6e5).optional(),
-  max_output_bytes: z11.number().int().min(1e3).max(5e6).optional(),
-  env: z11.record(z11.string(), z11.string()).optional(),
-  stdin: z11.string().max(5e6).optional()
+import { createHash as createHash8 } from "node:crypto";
+import { lstat as lstat15, readFile as readFile11, readdir as readdir5 } from "node:fs/promises";
+import { join as join13 } from "node:path";
+import { z as z13 } from "zod";
+var inputSchema8 = z13.object({
+  command: z13.string().min(1).max(1e5),
+  cwd: z13.string().min(1).optional(),
+  timeout_ms: z13.number().int().min(100).max(6e5).optional(),
+  max_output_bytes: z13.number().int().min(1e3).max(5e6).optional(),
+  env: z13.record(z13.string(), z13.string()).optional(),
+  stdin: z13.string().max(5e6).optional()
 }).strict();
 var shellTool = {
   definition: {
@@ -6483,7 +7174,7 @@ var shellTool = {
     }, ["command"])
   },
   permissionCategories(arguments_) {
-    const input2 = inputSchema7.parse(arguments_);
+    const input2 = inputSchema8.parse(arguments_);
     validateEnvironment(input2.env);
     return [
       "shell",
@@ -6493,12 +7184,12 @@ var shellTool = {
     ];
   },
   async affectedPaths(arguments_, context) {
-    const input2 = inputSchema7.parse(arguments_);
+    const input2 = inputSchema8.parse(arguments_);
     if (!appearsToModifyWorkspace(input2.command)) return [];
     return collectAffectedPaths(input2.command, input2.cwd ?? ".", context);
   },
   async execute(arguments_, context) {
-    const input2 = inputSchema7.parse(arguments_);
+    const input2 = inputSchema8.parse(arguments_);
     validateEnvironment(input2.env);
     const cwd = await context.workspace.resolveDirectory(input2.cwd ?? ".");
     const candidates = appearsToModifyWorkspace(input2.command) ? await collectAffectedPaths(input2.command, input2.cwd ?? ".", context) : [];
@@ -6538,7 +7229,8 @@ Execution interrupted: ${error instanceof Error ? error.message : String(error)}
       result.stdout ? `stdout:
 ${result.stdout}` : "",
       result.stderr ? `stderr:
-${result.stderr}` : ""
+${result.stderr}` : "",
+      result.stdoutTruncated || result.stderrTruncated ? `Source output exceeded the command capture limit (${result.stdoutBytes} stdout bytes, ${result.stderrBytes} stderr bytes observed). Rerun with max_output_bytes up to 5000000 or narrow the command; omitted source bytes are not recoverable from this result.` : ""
     ].filter(Boolean);
     return {
       ok: result.exitCode === 0 && !result.timedOut,
@@ -6548,6 +7240,9 @@ ${result.stderr}` : ""
         exitCode: result.exitCode,
         timedOut: result.timedOut,
         durationMs: result.durationMs,
+        stdoutBytes: result.stdoutBytes,
+        stderrBytes: result.stderrBytes,
+        sourceTruncated: result.stdoutTruncated || result.stderrTruncated,
         changeTracking: candidates.length ? "targeted" : beforeWorkspace && afterWorkspace && beforeWorkspace.complete && afterWorkspace.complete ? "workspace-snapshot" : beforeWorkspace ? "unresolved" : "read-only"
       },
       ...changedFiles.length ? { changedFiles } : {}
@@ -6611,7 +7306,7 @@ async function collectAffectedPaths(command2, cwdInput, context) {
         allowMissing: true
       });
       try {
-        if ((await lstat14(path)).isDirectory()) continue;
+        if ((await lstat15(path)).isDirectory()) continue;
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
       }
@@ -6639,7 +7334,7 @@ async function changedPaths(paths, before) {
 }
 async function snapshotPath(path) {
   try {
-    const info = await lstat14(path);
+    const info = await lstat15(path);
     return { exists: true, size: info.size, mtimeMs: info.mtimeMs };
   } catch (error) {
     if (error.code === "ENOENT") return { exists: false };
@@ -6655,18 +7350,18 @@ async function captureWorkspaceSnapshot(roots) {
     if (!discovered.complete) complete = false;
     for (const path of discovered.files) {
       try {
-        const info = await lstat14(path);
+        const info = await lstat15(path);
         if (!info.isFile() || info.isSymbolicLink()) continue;
         if (files.size >= MAX_SNAPSHOT_FILES || info.size > MAX_SNAPSHOT_FILE_BYTES || totalBytes + info.size > MAX_SNAPSHOT_TOTAL_BYTES) {
           complete = false;
           continue;
         }
-        const content = await readFile10(path);
+        const content = await readFile11(path);
         totalBytes += content.length;
         files.set(path, {
           size: info.size,
           mtimeMs: info.mtimeMs,
-          hash: createHash7("sha256").update(content).digest("hex")
+          hash: createHash8("sha256").update(content).digest("hex")
         });
       } catch (error) {
         if (error.code !== "ENOENT") complete = false;
@@ -6687,14 +7382,14 @@ async function discoverSnapshotFiles(root) {
     const directory = pending.pop();
     if (!directory) break;
     try {
-      const entries = await readdir4(directory, { withFileTypes: true, encoding: "utf8" });
+      const entries = await readdir5(directory, { withFileTypes: true, encoding: "utf8" });
       for (const entry of entries) {
         if (ignored2.has(entry.name) || /^\.skein\.(?:migrating|rollback)-/u.test(entry.name)) continue;
         if (entry.isSymbolicLink()) {
           complete = false;
           continue;
         }
-        const path = join12(directory, entry.name);
+        const path = join13(directory, entry.name);
         if (entry.isDirectory()) pending.push(path);
         else if (entry.isFile()) files.push(path);
       }
@@ -6708,18 +7403,18 @@ async function discoverSnapshotFiles(root) {
 
 // src/tools/task.ts
 import { randomUUID as randomUUID9 } from "node:crypto";
-import { z as z12 } from "zod";
-var taskSchema2 = z12.object({
-  id: z12.string().min(1).optional(),
-  title: z12.string().min(1).max(500),
-  status: z12.enum(["pending", "in_progress", "completed"])
+import { z as z14 } from "zod";
+var taskSchema2 = z14.object({
+  id: z14.string().min(1).optional(),
+  title: z14.string().min(1).max(500),
+  status: z14.enum(["pending", "in_progress", "completed"])
 }).strict();
-var inputSchema8 = z12.discriminatedUnion("action", [
-  z12.object({ action: z12.literal("list") }).strict(),
-  z12.object({ action: z12.literal("add"), title: z12.string().min(1).max(500), status: z12.enum(["pending", "in_progress", "completed"]).optional() }).strict(),
-  z12.object({ action: z12.literal("update"), id: z12.string().min(1), title: z12.string().min(1).max(500).optional(), status: z12.enum(["pending", "in_progress", "completed"]).optional() }).strict(),
-  z12.object({ action: z12.literal("remove"), id: z12.string().min(1) }).strict(),
-  z12.object({ action: z12.literal("replace"), tasks: z12.array(taskSchema2).max(100) }).strict()
+var inputSchema9 = z14.discriminatedUnion("action", [
+  z14.object({ action: z14.literal("list") }).strict(),
+  z14.object({ action: z14.literal("add"), title: z14.string().min(1).max(500), status: z14.enum(["pending", "in_progress", "completed"]).optional() }).strict(),
+  z14.object({ action: z14.literal("update"), id: z14.string().min(1), title: z14.string().min(1).max(500).optional(), status: z14.enum(["pending", "in_progress", "completed"]).optional() }).strict(),
+  z14.object({ action: z14.literal("remove"), id: z14.string().min(1) }).strict(),
+  z14.object({ action: z14.literal("replace"), tasks: z14.array(taskSchema2).max(100) }).strict()
 ]);
 var taskTool = {
   definition: {
@@ -6750,7 +7445,7 @@ var taskTool = {
     }
   },
   async execute(arguments_, context) {
-    const input2 = inputSchema8.parse(arguments_);
+    const input2 = inputSchema9.parse(arguments_);
     const tasks = context.session.tasks;
     switch (input2.action) {
       case "list":
@@ -6788,7 +7483,7 @@ var taskTool = {
 
 // src/tools/task-contract.ts
 import { randomUUID as randomUUID11 } from "node:crypto";
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // src/agent/task-contract.ts
 import { randomUUID as randomUUID10 } from "node:crypto";
@@ -6869,14 +7564,14 @@ function compact(value, limit) {
 }
 
 // src/agent/completion-gate.ts
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 
 // src/tools/permissions.ts
-import { createHash as createHash8, createHmac, randomBytes } from "node:crypto";
+import { createHash as createHash9, createHmac, randomBytes } from "node:crypto";
 var permissionScopeSecret = randomBytes(32);
 function permissionKey(call, category) {
   const categoryScope = category === "network" ? `\0network-request:${scopeFingerprint(normalizeRequestState(call.arguments))}` : "";
-  const digest = createHash8("sha256").update(`${category}\0${call.name}\0${permissionTarget(call)}${categoryScope}`).digest("hex").slice(0, 24);
+  const digest = createHash9("sha256").update(`${category}\0${call.name}\0${permissionTarget(call)}${categoryScope}`).digest("hex").slice(0, 24);
   return `${category}:${call.name}:${digest}`;
 }
 function permissionTarget(call) {
@@ -7070,7 +7765,7 @@ function captureVerification(call, result, changeSequence, configuredCommands) {
     kind,
     ok: result.ok,
     changeSequence,
-    commandKey: createHash9("sha256").update(normalized).digest("hex")
+    commandKey: createHash10("sha256").update(normalized).digest("hex")
   };
 }
 function buildRunCompletion(changedFiles, evidence, currentChangeSequence, mutationTracking = "complete", taskContract, audit = []) {
@@ -7230,7 +7925,7 @@ function verificationRequirementMet(requirement, checks) {
   const normalized = normalizeCommand2(requirement);
   const broad = normalized.match(/^Record at least one successful (.+) after the final mutation\.?$/iu);
   if (broad) return checks.length > 0;
-  const commandKey = createHash9("sha256").update(normalized).digest("hex");
+  const commandKey = createHash10("sha256").update(normalized).digest("hex");
   return checks.some((item) => item.commandKey === commandKey);
 }
 function acceptanceUnresolved(acceptance) {
@@ -7282,29 +7977,29 @@ function fileCount(count) {
 }
 
 // src/tools/task-contract.ts
-var criterionSchema = z13.object({
-  id: z13.string().min(1).max(128).optional(),
-  description: z13.string().min(1).max(2e3),
-  required: z13.boolean().optional()
+var criterionSchema = z15.object({
+  id: z15.string().min(1).max(128).optional(),
+  description: z15.string().min(1).max(2e3),
+  required: z15.boolean().optional()
 }).strict();
-var inputSchema9 = z13.discriminatedUnion("action", [
-  z13.object({ action: z13.literal("show") }).strict(),
-  z13.object({
-    action: z13.literal("replace"),
-    objective: z13.string().min(1).max(2e4),
-    scope: z13.array(z13.string().min(1).max(2e3)).max(64),
-    constraints: z13.array(z13.string().min(1).max(2e3)).max(64),
-    non_goals: z13.array(z13.string().min(1).max(2e3)).max(64),
-    acceptance_criteria: z13.array(criterionSchema).min(1).max(64),
-    verification_requirements: z13.array(z13.string().min(1).max(2e3)).min(1).max(64)
+var inputSchema10 = z15.discriminatedUnion("action", [
+  z15.object({ action: z15.literal("show") }).strict(),
+  z15.object({
+    action: z15.literal("replace"),
+    objective: z15.string().min(1).max(2e4),
+    scope: z15.array(z15.string().min(1).max(2e3)).max(64),
+    constraints: z15.array(z15.string().min(1).max(2e3)).max(64),
+    non_goals: z15.array(z15.string().min(1).max(2e3)).max(64),
+    acceptance_criteria: z15.array(criterionSchema).min(1).max(64),
+    verification_requirements: z15.array(z15.string().min(1).max(2e3)).min(1).max(64)
   }).strict(),
-  z13.object({ action: z13.literal("activate") }).strict(),
-  z13.object({
-    action: z13.literal("update_criterion"),
-    id: z13.string().min(1).max(128),
-    status: z13.enum(["pending", "satisfied", "blocked"]),
-    evidence_refs: z13.array(z13.string().min(1).max(256)).max(64).optional(),
-    note: z13.string().max(2e3).optional()
+  z15.object({ action: z15.literal("activate") }).strict(),
+  z15.object({
+    action: z15.literal("update_criterion"),
+    id: z15.string().min(1).max(128),
+    status: z15.enum(["pending", "satisfied", "blocked"]),
+    evidence_refs: z15.array(z15.string().min(1).max(256)).max(64).optional(),
+    note: z15.string().max(2e3).optional()
   }).strict()
 ]);
 var taskContractTool = {
@@ -7346,7 +8041,7 @@ var taskContractTool = {
     }
   },
   async execute(arguments_, context) {
-    const input2 = inputSchema9.parse(arguments_);
+    const input2 = inputSchema10.parse(arguments_);
     let contract = context.session.taskContract;
     if (!contract) throw new Error("No Task Contract is active for this session.");
     if (input2.action === "replace") {
@@ -7443,17 +8138,17 @@ function validateVerificationRequirement(requirement) {
 }
 
 // src/tools/working-memory.ts
-import { z as z14 } from "zod";
-var inputSchema10 = z14.discriminatedUnion("action", [
-  z14.object({ action: z14.literal("show") }).strict(),
-  z14.object({ action: z14.literal("set_goal"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("set_focus"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("add_constraint"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("add_decision"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("add_question"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("resolve_question"), value: z14.string().min(1).max(1e3) }).strict(),
-  z14.object({ action: z14.literal("add_file"), path: z14.string().min(1).max(4e3) }).strict(),
-  z14.object({ action: z14.literal("clear"), field: z14.enum(["constraints", "decisions", "openQuestions", "relevantFiles"]) }).strict()
+import { z as z16 } from "zod";
+var inputSchema11 = z16.discriminatedUnion("action", [
+  z16.object({ action: z16.literal("show") }).strict(),
+  z16.object({ action: z16.literal("set_goal"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("set_focus"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("add_constraint"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("add_decision"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("add_question"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("resolve_question"), value: z16.string().min(1).max(1e3) }).strict(),
+  z16.object({ action: z16.literal("add_file"), path: z16.string().min(1).max(4e3) }).strict(),
+  z16.object({ action: z16.literal("clear"), field: z16.enum(["constraints", "decisions", "openQuestions", "relevantFiles"]) }).strict()
 ]);
 var workingMemoryTool = {
   definition: {
@@ -7478,7 +8173,7 @@ var workingMemoryTool = {
     }, ["action"])
   },
   async execute(arguments_, context) {
-    const input2 = inputSchema10.parse(arguments_);
+    const input2 = inputSchema11.parse(arguments_);
     const memory = context.session.workingMemory ?? emptyWorkingMemory2();
     switch (input2.action) {
       case "show":
@@ -7560,6 +8255,7 @@ function render(memory) {
 function createDefaultToolRegistry(_options = {}) {
   return new ToolRegistry([
     readFileTool,
+    readToolArtifactTool,
     listFilesTool,
     searchCodeTool,
     writeFileTool,
@@ -7688,7 +8384,7 @@ function escapeAttribute3(value) {
 }
 
 // src/agent/tool-recovery.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 var RETRY_BUDGET = {
   schema_input: 3,
   unknown_tool: 2,
@@ -7783,10 +8479,10 @@ function isRetryable(failureClass) {
   return RETRY_BUDGET[failureClass] > 0;
 }
 function callSignature(call) {
-  return createHash10("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}`).digest("hex");
+  return createHash11("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}`).digest("hex");
 }
 function failureSignature(call, failureClass) {
-  return createHash10("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}\0${failureClass}`).digest("hex");
+  return createHash11("sha256").update(`${call.name}\0${stableJson(redact(call.arguments))}\0${failureClass}`).digest("hex");
 }
 function redact(value, key = "") {
   if (/api[_-]?key|authorization|cookie|password|secret|token/i.test(key)) return "[redacted]";
@@ -7803,10 +8499,170 @@ function isFailureClass(value) {
   return typeof value === "string" && Object.hasOwn(RETRY_BUDGET, value);
 }
 
+// src/agent/tool-output.ts
+import stripAnsi from "strip-ansi";
+var MIN_TOOL_OUTPUT_TOKENS = 1024;
+var MAX_TOOL_OUTPUT_TOKENS = 8192;
+async function protectToolOutput(options) {
+  const safe = sanitizeToolOutput(options.content);
+  const sanitized = redactToolOutput(safe.text);
+  const estimatedTokens = estimateToolOutputTokens(sanitized.text);
+  const budgetTokens = clamp2(options.budgetTokens, MIN_TOOL_OUTPUT_TOKENS, MAX_TOOL_OUTPUT_TOKENS);
+  const base = {
+    originalChars: options.content.length,
+    originalBytes: Buffer.byteLength(options.content),
+    estimatedTokens,
+    budgetTokens,
+    truncated: estimatedTokens > budgetTokens,
+    redacted: sanitized.redacted,
+    sanitized: safe.sanitized
+  };
+  if (estimatedTokens <= budgetTokens) return { content: sanitized.text, metadata: base };
+  let archived;
+  try {
+    archived = await options.artifacts.archive(
+      options.sessionId,
+      options.toolCallId,
+      sanitized.text,
+      { redacted: sanitized.redacted }
+    );
+  } catch {
+    archived = { stored: false, reason: "storage_error" };
+  }
+  const artifact = archived.stored ? archived.artifact : void 0;
+  const artifactUnavailable = archived.stored ? void 0 : archived.reason;
+  const metadata = {
+    ...base,
+    ...artifact ? {
+      artifact: {
+        toolCallId: artifact.toolCallId,
+        sha256: artifact.sha256,
+        bytes: artifact.bytes,
+        createdAt: artifact.createdAt,
+        expiresAt: artifact.expiresAt
+      }
+    } : artifactUnavailable ? { artifactUnavailable } : {}
+  };
+  const receipt = formatReceipt(options, metadata, "");
+  const previewBudget = Math.max(0, budgetTokens - estimateToolOutputTokens(receipt));
+  const preview = boundedPreview(sanitized.text, previewBudget);
+  return {
+    content: formatReceipt(options, metadata, preview),
+    metadata
+  };
+}
+function dynamicToolOutputBudget(contextWindowTokens, activeContextTokens, remainingSessionTokens) {
+  const contextHeadroom = Math.max(0, contextWindowTokens - activeContextTokens);
+  const sessionHeadroom = Math.max(0, remainingSessionTokens);
+  const budget = Math.min(
+    Math.floor(contextHeadroom * 0.35),
+    Math.floor(sessionHeadroom * 0.12)
+  );
+  return clamp2(budget, MIN_TOOL_OUTPUT_TOKENS, MAX_TOOL_OUTPUT_TOKENS);
+}
+function estimateToolOutputTokens(value) {
+  return Math.max(1, estimateTokens(value));
+}
+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 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 clamp2(value, minimum, maximum) {
+  return Math.max(minimum, Math.min(maximum, value));
+}
+function boundedInlineByTokens(value, maxTokens) {
+  const normalized = value.replace(/[\r\n\t]+/gu, " ").trim();
+  if (estimateToolOutputTokens(normalized) <= maxTokens) return normalized;
+  const suffix = "\u2026";
+  return `${sliceStartByTokens(normalized, Math.max(0, maxTokens - estimatedTokenCost(suffix)))}${suffix}`;
+}
+
 // src/agent/rules.ts
 import { existsSync as existsSync2 } from "node:fs";
-import { join as join13 } from "node:path";
-import { lstat as lstat15, readFile as readFile11 } from "node:fs/promises";
+import { join as join14 } from "node:path";
+import { lstat as lstat16, readFile as readFile12 } from "node:fs/promises";
 var workspaceRulePaths = [
   "AGENTS.md",
   "CLAUDE.md",
@@ -7815,14 +8671,14 @@ var workspaceRulePaths = [
 ];
 async function discoverWorkspaceRules(workspace, maxChars = 12e4) {
   const workspaceAccess = new WorkspaceAccess([workspace]);
-  const activeProjectRules = join13(resolveProjectNamespaceSync(workspace).active, "rules.md");
+  const activeProjectRules = join14(resolveProjectNamespaceSync(workspace).active, "rules.md");
   const projectCandidates = [
-    ...workspaceRulePaths.slice(0, 3).map((path) => join13(workspace, path)),
+    ...workspaceRulePaths.slice(0, 3).map((path) => join14(workspace, path)),
     activeProjectRules,
-    ...workspaceRulePaths.slice(3).map((path) => join13(workspace, path))
+    ...workspaceRulePaths.slice(3).map((path) => join14(workspace, path))
   ];
   const candidates = [
-    { path: join13(resolveHomeNamespace(), "rules.md"), scope: "user" },
+    { path: join14(resolveHomeNamespace(), "rules.md"), scope: "user" },
     ...projectCandidates.map((path) => ({
       path,
       scope: "workspace"
@@ -7833,13 +8689,13 @@ async function discoverWorkspaceRules(workspace, maxChars = 12e4) {
   for (const candidate of candidates) {
     if (remaining <= 0 || !existsSync2(candidate.path)) continue;
     try {
-      const info = await lstat15(candidate.path);
+      const info = await lstat16(candidate.path);
       if (!info.isFile() || info.size > 1e6) continue;
       if (candidate.scope === "workspace") {
         const safePath = await workspaceAccess.resolvePath(candidate.path, { expect: "file" });
         if (safePath !== candidate.path) continue;
       }
-      const raw = await readFile11(candidate.path, "utf8");
+      const raw = await readFile12(candidate.path, "utf8");
       if (raw.includes("\0")) continue;
       const content = raw.slice(0, remaining);
       rules.push({
@@ -7871,13 +8727,10 @@ 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;
-function estimateTokens3(value) {
-  return Math.ceil(value.length / 4);
-}
 function sources(session) {
   return session.contextSources ?? (session.contextSources = []);
 }
@@ -7885,7 +8738,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 = estimateTokens((await readFile13(resolved, "utf8")).slice(0, MAX_SOURCE_CHARS));
   const list2 = sources(session);
   const existing = list2.find((source2) => source2.path === alias);
   if (existing) {
@@ -7935,9 +8788,9 @@ 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);
+      source.tokens = estimateTokens(capped);
       resolved.push({
         path: source.path,
         content: capped,
@@ -7983,6 +8836,7 @@ var AgentRunner = class {
   contextEngine;
   tools;
   sessionStore;
+  toolArtifactStore;
   checkpointStore;
   workspace;
   hooks;
@@ -8004,6 +8858,7 @@ var AgentRunner = class {
       contextEngine: this.contextEngine
     });
     this.sessionStore = options.sessionStore ?? new SessionStore(this.workspace.primaryRoot);
+    this.toolArtifactStore = options.toolArtifactStore ?? new ToolArtifactStore(this.workspace.primaryRoot);
     this.checkpointStore = options.checkpointStore ?? new CheckpointStore(this.workspace);
     this.hooks = new HookRunner(options.config.hooks, this.workspace);
     this.contextManager = options.contextManager ?? new ContextManager(options.config);
@@ -8096,17 +8951,25 @@ var AgentRunner = class {
     };
     try {
       throwIfAborted(options.signal);
+      await this.reconcileToolArtifacts();
       if (this.session.messages.length === 0 && this.session.title === "New session") {
         this.session.title = titleFromInput(request);
       }
       this.contextManager.startTurn(this.session, request);
-      this.session.messages.push(message("user", request));
+      const userMessage = message("user", request);
+      this.session.messages.push(userMessage);
       await this.persist();
       const trivialTurn = isTrivialTurn(request);
-      const packed = await this.packContext(request);
+      const turnDirective = buildTurnDirective(request, {
+        agents: Boolean(this.config.agents?.enabled)
+      });
+      const packed = trivialTurn ? emptyPackedContext(selectContextBudget(request, this.config, {
+        intent: turnDirective.intent,
+        trivial: true
+      })) : await this.packContext(request, { intent: turnDirective.intent });
       if (!trivialTurn) await emit({ type: "context", packed });
       const mentions = await this.packMentions(request);
-      const retrievedContext = buildRetrievedContext(
+      const retrievedContext = trivialTurn && !mentions.length ? "" : buildRetrievedContext(
         packed,
         mentions,
         this.workspace.primaryRoot,
@@ -8132,9 +8995,6 @@ var AgentRunner = class {
           scope: augmentation.memoryScope ?? "session"
         });
       }
-      const turnDirective = buildTurnDirective(request, {
-        agents: Boolean(this.config.agents?.enabled)
-      });
       const contractEnabled = shouldUseTaskContract(
         request,
         turnDirective.intent,
@@ -8158,21 +9018,6 @@ var AgentRunner = class {
         ...augmentation.skills?.length ? [`skills:${augmentation.skills.length}`] : [],
         ...augmentation.memoryCount ? [`memory:${augmentation.memoryCount}`] : []
       ];
-      if (!trivialTurn) await emit({
-        type: "prompt",
-        intent: turnDirective.intent,
-        sections: promptSections,
-        estimatedTokens: Math.ceil([
-          turnDirective.text,
-          buildSessionStatePrompt(this.session),
-          this.contextManager.buildShortTermPrompt(this.session),
-          options.turnInstructions ?? "",
-          augmentation.text,
-          retrievedContext,
-          pinnedContext,
-          workspaceRules
-        ].join("\n").length / 4)
-      });
       let verificationAttempted = false;
       const maxTurns = options.maxTurns ?? this.config.agent.maxTurns;
       const contextBudget = Math.max(24e3, Math.min(1e5, this.config.context.maxTokens * 3));
@@ -8187,24 +9032,29 @@ var AgentRunner = class {
         }
         this.applySteering();
         await emit({ type: "thinking", turn });
+        const dynamicPrompt = [
+          buildSessionStatePrompt(this.session),
+          turnDirective.text,
+          this.contextManager.buildShortTermPrompt(this.session),
+          pinnedContext,
+          options.turnInstructions ?? "",
+          augmentation.text
+        ].filter(Boolean).join("\n\n");
         const messages = packConversation(
           stableSystemPrompt,
-          [
-            buildSessionStatePrompt(this.session),
-            turnDirective.text,
-            this.contextManager.buildShortTermPrompt(this.session),
-            pinnedContext,
-            options.turnInstructions ?? "",
-            augmentation.text
-          ].filter(Boolean).join("\n\n"),
+          dynamicPrompt,
           retrievedContext,
           activeMessages(this.session),
           contextBudget
         );
         const availableTokens = this.config.agent.maxSessionTokens - (this.session.usage.inputTokens + this.session.usage.outputTokens);
-        const estimatedInputTokens = estimateMessages2(messages) + estimateToolDefinitions(
-          visibleToolDefinitions(this.tools, options.askMode === true, contractEnabled)
+        const visibleTools = visibleToolDefinitions(
+          this.tools,
+          options.askMode === true,
+          contractEnabled,
+          this.hasReadableToolArtifact()
         );
+        const estimatedInputTokens = estimateMessages2(messages) + estimateToolDefinitions(visibleTools);
         if (availableTokens <= 0 || estimatedInputTokens >= availableTokens) {
           return finishRun("token_budget");
         }
@@ -8212,7 +9062,23 @@ var AgentRunner = class {
           this.config.model.maxTokens ?? 8192,
           availableTokens - estimatedInputTokens
         ));
-        const visibleTools = visibleToolDefinitions(this.tools, options.askMode === true, contractEnabled);
+        const breakdown = promptTokenBreakdown(
+          messages,
+          stableSystemPrompt,
+          dynamicPrompt,
+          retrievedContext,
+          visibleTools,
+          maxOutputTokens
+        );
+        if (!trivialTurn) {
+          await emit({
+            type: "prompt",
+            intent: turnDirective.intent,
+            sections: promptSections,
+            estimatedTokens: breakdown.estimatedInputTokens,
+            breakdown
+          });
+        }
         const assistantId = randomUUID12();
         const response = await this.completeModel(
           messages,
@@ -8228,17 +9094,49 @@ var AgentRunner = class {
         assistantMessage.id = assistantId;
         this.session.messages.push(assistantMessage);
         if (response.content) await emit({ type: "assistant", id: assistantId, content: response.content });
-        const inputTokens = response.usage?.inputTokens ?? estimatedInputTokens;
-        const outputTokens = response.usage?.outputTokens ?? estimateResponseTokens(response);
-        this.session.usage.inputTokens += inputTokens;
-        this.session.usage.outputTokens += outputTokens;
-        if (inputTokens || outputTokens) {
-          await emit({
-            type: "usage",
-            inputTokens: this.session.usage.inputTokens,
-            outputTokens: this.session.usage.outputTokens
-          });
-        }
+        const turnUsage = recordTokenUsage(
+          this.session,
+          response.usage,
+          estimatedInputTokens,
+          estimateResponseTokens(response)
+        );
+        const { inputTokens, outputTokens } = turnUsage;
+        const actualInputTokens = validTokenCount(response.usage?.inputTokens);
+        const actualOutputTokens = validTokenCount(response.usage?.outputTokens);
+        const receipt = recordTokenLedger(this.session, {
+          requestId: userMessage.id,
+          turn,
+          recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          estimated: {
+            ...breakdown,
+            outputTokens: estimateResponseTokens(response)
+          },
+          actual: {
+            ...actualInputTokens === void 0 ? {} : { inputTokens: actualInputTokens },
+            ...actualOutputTokens === void 0 ? {} : { outputTokens: actualOutputTokens }
+          },
+          inputSource: actualInputTokens === void 0 ? "estimated" : "actual",
+          outputSource: actualOutputTokens === void 0 ? "estimated" : "actual",
+          tools: { loaded: visibleTools.map((tool) => tool.name), deferredCount: 0 },
+          retrieval: tokenRetrievalReceipt(packed)
+        });
+        await emit({
+          type: "usage",
+          inputTokens: this.session.usage.inputTokens,
+          outputTokens: this.session.usage.outputTokens,
+          source: this.session.usage.source ?? "unknown",
+          inputSource: this.session.usage.inputSource ?? "unknown",
+          outputSource: this.session.usage.outputSource ?? "unknown",
+          actual: {
+            inputTokens: this.session.usage.actualInputTokens ?? 0,
+            outputTokens: this.session.usage.actualOutputTokens ?? 0
+          },
+          estimated: {
+            inputTokens: this.session.usage.estimatedInputTokens ?? 0,
+            outputTokens: this.session.usage.estimatedOutputTokens ?? 0
+          },
+          receipt
+        });
         await this.persist();
         if (this.session.usage.inputTokens + this.session.usage.outputTokens >= this.config.agent.maxSessionTokens) {
           for (const call of response.toolCalls) {
@@ -8370,17 +9268,17 @@ ${input2}`
   async executeTool(call, options, emit, recovery = new ToolRecoveryController(), visibleToolNames) {
     const preflight = recovery.preflight(call);
     if (preflight) {
-      const result = failedResult(call, "Tool call rejected by the recovery circuit.", preflight);
+      const result = await this.protectToolResult(
+        failedResult(call, "Tool call rejected by the recovery circuit.", preflight)
+      );
       this.recordToolResult(result);
       await emit({ type: "tool_result", result });
       return result;
     }
     if (visibleToolNames && !visibleToolNames.has(call.name)) {
       const receipt = recovery.recordFailure(call, "unknown_tool");
-      const result = failedResult(
-        call,
-        `Tool is not exposed for this turn: ${call.name}`,
-        receipt
+      const result = await this.protectToolResult(
+        failedResult(call, `Tool is not exposed for this turn: ${call.name}`, receipt)
       );
       this.recordToolResult(result);
       await emit({ type: "tool_result", result });
@@ -8389,7 +9287,7 @@ ${input2}`
     const tool = this.tools.get(call.name);
     if (!tool) {
       const receipt = recovery.recordFailure(call, "unknown_tool");
-      const result = failedResult(call, `Unknown tool: ${call.name}`, receipt);
+      const result = await this.protectToolResult(failedResult(call, `Unknown tool: ${call.name}`, receipt));
       this.recordToolResult(result);
       await emit({ type: "tool_result", result });
       return result;
@@ -8402,17 +9300,15 @@ ${input2}`
     } catch (error) {
       const failureClass = classifyThrownToolFailure(error, options.signal);
       const receipt = recovery.recordFailure(call, failureClass);
-      const result = failedResult(call, formatToolError(error), receipt);
+      const result = await this.protectToolResult(failedResult(call, formatToolError(error), receipt));
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
       return result;
     }
     if (categories.some((category) => category !== "read") && this.session.taskContract?.state === "draft") {
       const receipt = recovery.recordFailure(call, "contract_required");
-      const result = failedResult(
-        call,
-        "Potentially mutating work is paused until the draft Task Contract is activated.",
-        receipt
+      const result = await this.protectToolResult(
+        failedResult(call, "Potentially mutating work is paused until the draft Task Contract is activated.", receipt)
       );
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
@@ -8422,7 +9318,9 @@ ${input2}`
       const allowed = await this.authorize(call, category, options, emit);
       if (!allowed) {
         const receipt = recovery.recordFailure(call, "permission_denied");
-        const result = failedResult(call, `Permission denied for ${category} operation.`, receipt);
+        const result = await this.protectToolResult(
+          failedResult(call, `Permission denied for ${category} operation.`, receipt)
+        );
         this.recordToolResult(result, category);
         await emit({ type: "tool_result", result });
         return result;
@@ -8436,6 +9334,7 @@ ${input2}`
       workspace: this.workspace,
       session: this.session,
       contextEngine: this.contextEngine,
+      toolArtifactStore: this.toolArtifactStore,
       emit,
       ...options.signal ? { signal: options.signal } : {}
     };
@@ -8469,30 +9368,33 @@ ${input2}`
       } catch (error) {
         afterHookError = toError(error);
       }
-      const result = {
-        toolCallId: call.id,
-        name: call.name,
-        ok: execution.ok !== false && !afterHookError,
-        content: truncateToolOutput(afterHookError ? `${execution.content}
+      let completeContent = afterHookError ? `${execution.content}
 
-Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : execution.content),
-        metadata: {
-          ...execution.metadata ?? {},
-          ...changedFiles.length ? { changedFiles } : {},
-          ...checkpointId ? { checkpointId } : {},
-          ...beforeHooks.length || afterHooks.length ? { hooks: { before: beforeHooks.length, after: afterHooks.length } } : {},
-          ...afterHookError ? { toolSucceeded: true, hookError: afterHookError.message } : {}
-        }
+Tool succeeded, but afterTool hook failed: ${afterHookError.message}` : execution.content;
+      const metadata = {
+        ...execution.metadata ?? {},
+        ...changedFiles.length ? { changedFiles } : {},
+        ...checkpointId ? { checkpointId } : {},
+        ...beforeHooks.length || afterHooks.length ? { hooks: { before: beforeHooks.length, after: afterHooks.length } } : {},
+        ...afterHookError ? { toolSucceeded: true, hookError: afterHookError.message } : {}
       };
-      if (!result.ok) {
-        const failureClass = options.signal?.aborted ? "cancelled" : classifyToolFailure(result);
+      const ok = execution.ok !== false && !afterHookError;
+      if (!ok) {
+        const failureClass = options.signal?.aborted ? "cancelled" : classifyToolFailure({ toolCallId: call.id, name: call.name, ok, content: completeContent, metadata });
         const receipt = recovery.recordFailure(call, failureClass);
-        result.content = truncateToolOutput(`${formatFailureReceipt(receipt)}
-${result.content}`);
-        result.metadata = { ...result.metadata, failure: receipt };
+        completeContent = `${formatFailureReceipt(receipt)}
+${completeContent}`;
+        metadata.failure = receipt;
       } else {
         recovery.recordSuccess(call);
       }
+      const result = await this.protectToolResult({
+        toolCallId: call.id,
+        name: call.name,
+        ok,
+        content: completeContent,
+        metadata
+      });
       this.contextManager.recordTool(this.session, call, result);
       if (JSON.stringify(this.session.tasks) !== tasksBefore || call.name === "task") {
         await emit({ type: "tasks", tasks: this.session.tasks.map((task) => ({ ...task })) });
@@ -8507,7 +9409,7 @@ ${result.content}`);
       const normalized = toError(error);
       const failureClass = classifyThrownToolFailure(normalized, options.signal);
       const receipt = recovery.recordFailure(call, failureClass);
-      const result = failedResult(call, formatToolError(error), receipt);
+      const result = await this.protectToolResult(failedResult(call, formatToolError(error), receipt));
       this.recordToolResult(result, tool.definition.category);
       await emit({ type: "tool_result", result });
       return result;
@@ -8613,8 +9515,8 @@ ${result.content}`);
       toolCalls: toolCalls.map((call) => ({ id: call.id, name: call.name }))
     }, signal);
   }
-  async packContext(input2) {
-    return this.contextEngine.pack(input2);
+  async packContext(input2, options) {
+    return this.contextEngine.pack(input2, options);
   }
   async packMentions(input2) {
     try {
@@ -8661,6 +9563,63 @@ ${result.content}`);
   persist() {
     return this.persistSession ? this.sessionStore.save(this.session) : Promise.resolve();
   }
+  toolOutputBudget() {
+    const contextWindowTokens = Math.max(24e3, Math.min(1e5, this.config.context.maxTokens * 3));
+    const activeContextTokens = this.contextManager.status(this.session, contextWindowTokens).activeTokens;
+    const remainingSessionTokens = this.config.agent.maxSessionTokens - (this.session.usage.inputTokens + this.session.usage.outputTokens);
+    return dynamicToolOutputBudget(contextWindowTokens, activeContextTokens, remainingSessionTokens);
+  }
+  async protectToolResult(result) {
+    const metadata = { ...result.metadata ?? {} };
+    const output2 = await protectToolOutput({
+      content: result.content,
+      sessionId: this.session.id,
+      toolCallId: result.toolCallId,
+      tool: result.name,
+      ok: result.ok,
+      budgetTokens: this.toolOutputBudget(),
+      metadata,
+      artifacts: this.toolArtifactStore
+    });
+    if (output2.metadata.artifact) this.registerToolArtifact({
+      ...output2.metadata.artifact,
+      redacted: output2.metadata.redacted
+    });
+    return {
+      ...result,
+      content: output2.content,
+      ...output2.metadata.truncated || output2.metadata.redacted || output2.metadata.sanitized || output2.metadata.artifact || output2.metadata.artifactUnavailable ? { metadata: { ...metadata, toolOutput: output2.metadata } } : Object.keys(metadata).length ? { metadata } : {}
+    };
+  }
+  hasReadableToolArtifact() {
+    const now = Date.now();
+    return (this.session.toolArtifacts ?? []).some(
+      (artifact) => Date.parse(artifact.expiresAt) > now
+    );
+  }
+  registerToolArtifact(artifact) {
+    const now = Date.now();
+    const artifacts = (this.session.toolArtifacts ?? []).filter((candidate) => Date.parse(candidate.expiresAt) > now && candidate.toolCallId !== artifact.toolCallId);
+    artifacts.push(artifact);
+    artifacts.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    if (artifacts.length > 200) artifacts.splice(0, artifacts.length - 200);
+    this.session.toolArtifacts = artifacts;
+  }
+  async reconcileToolArtifacts() {
+    let stored;
+    try {
+      stored = await this.toolArtifactStore.prune(this.session.id);
+    } catch {
+      this.session.toolArtifacts = [];
+      return;
+    }
+    const valid = new Map(stored.map((artifact) => [artifact.toolCallId, artifact]));
+    const reconciled = (this.session.toolArtifacts ?? []).filter((receipt) => {
+      const artifact = valid.get(receipt.toolCallId);
+      return artifact !== void 0 && artifact.sha256 === receipt.sha256 && artifact.bytes === receipt.bytes && artifact.createdAt === receipt.createdAt && artifact.expiresAt === receipt.expiresAt && artifact.redacted === receipt.redacted;
+    });
+    this.session.toolArtifacts = reconciled;
+  }
 };
 function message(role, content, extra = {}) {
   return {
@@ -8675,14 +9634,14 @@ function packConversation(systemPrompt, dynamicPrompt, retrievedContext, history
   const system = message("system", systemPrompt);
   const dynamic = dynamicPrompt ? message("system", dynamicPrompt) : void 0;
   const context = retrievedContext ? message("system", retrievedContext) : void 0;
-  const reserved = estimateTokens4(system.content) + estimateTokens4(dynamic?.content ?? "") + estimateTokens4(context?.content ?? "");
+  const reserved = estimateTokens(system.content) + estimateTokens(dynamic?.content ?? "") + estimateTokens(context?.content ?? "");
   const budget = Math.max(4e3, tokenBudget - reserved);
   const groups = groupMessages(clearOldToolResults(history));
   const selected = [];
   let used = 0;
   for (let index = groups.length - 1; index >= 0; index -= 1) {
     const group = groups[index] ?? [];
-    const cost = group.reduce((sum, item) => sum + estimateTokens4(item.content) + estimateTokens4(JSON.stringify(item.toolCalls ?? [])), 0);
+    const cost = group.reduce((sum, item) => sum + estimateTokens(item.content) + estimateTokens(JSON.stringify(item.toolCalls ?? [])), 0);
     if (selected.length && used + cost > budget) break;
     selected.unshift(group);
     used += cost;
@@ -8720,17 +9679,114 @@ function groupMessages(messages) {
   }
   return groups;
 }
-function estimateTokens4(input2) {
-  return Math.ceil(input2.length / 4);
-}
 function estimateMessages2(messages) {
-  return messages.reduce((total, item) => total + estimateTokens4(item.content) + estimateTokens4(JSON.stringify(item.toolCalls ?? [])), 0);
+  return messages.reduce((total, item) => total + estimateTokens(item.content) + estimateTokens(JSON.stringify(item.toolCalls ?? [])), 0);
 }
 function estimateToolDefinitions(tools) {
-  return estimateTokens4(JSON.stringify(tools));
+  return estimateTokens(JSON.stringify(tools));
 }
 function estimateResponseTokens(response) {
-  return estimateTokens4(response.content) + estimateTokens4(JSON.stringify(response.toolCalls));
+  return estimateTokens(response.content) + estimateTokens(JSON.stringify(response.toolCalls));
+}
+function promptTokenBreakdown(messages, stablePrompt, dynamicPrompt, retrievedContext, tools, outputAllowanceTokens) {
+  const stableTokens = estimateTokens(stablePrompt);
+  const dynamicTokens = estimateTokens(dynamicPrompt);
+  const retrievedTokens = estimateTokens(retrievedContext);
+  const messageTokens = estimateMessages2(messages);
+  const toolSchemaTokens = estimateToolDefinitions(tools);
+  const toolResultTokens = messages.filter((message2) => message2.role === "tool").reduce((total, message2) => total + estimateTokens(message2.content), 0);
+  return {
+    stableTokens,
+    dynamicTokens,
+    conversationTokens: Math.max(0, messageTokens - stableTokens - dynamicTokens - retrievedTokens - toolResultTokens),
+    toolResultTokens,
+    retrievedTokens,
+    toolSchemaTokens,
+    estimatedInputTokens: messageTokens + toolSchemaTokens,
+    outputAllowanceTokens
+  };
+}
+function tokenRetrievalReceipt(packed) {
+  const discarded = [];
+  if ((packed.duplicateHits ?? 0) > 0) {
+    discarded.push({ reason: "overlapping-span", count: packed.duplicateHits ?? 0 });
+  }
+  if (packed.truncated) discarded.push({ reason: "budget-cap", count: 1 });
+  return {
+    engine: packed.engine,
+    ...packed.budgetTier ? { budgetTier: packed.budgetTier } : {},
+    ...packed.budgetTokens === void 0 ? {} : { budgetTokens: packed.budgetTokens },
+    ...packed.candidateHits === void 0 ? {} : { candidateHits: packed.candidateHits },
+    ...packed.selectedHits === void 0 ? {} : { selectedHits: packed.selectedHits },
+    ...packed.duplicateHits === void 0 ? {} : { duplicateHits: packed.duplicateHits },
+    ...packed.incrementalEvidenceTokens === void 0 ? {} : { incrementalEvidenceTokens: packed.incrementalEvidenceTokens },
+    discarded
+  };
+}
+function recordTokenLedger(session, entry) {
+  const ledger = session.tokenLedger ?? (session.tokenLedger = []);
+  ledger.push(entry);
+  if (ledger.length > 256) ledger.splice(0, ledger.length - 256);
+  return entry;
+}
+function recordTokenUsage(session, providerUsage, estimatedInputTokens, estimatedOutputTokens) {
+  const inputActual = validTokenCount(providerUsage?.inputTokens);
+  const outputActual = validTokenCount(providerUsage?.outputTokens);
+  const priorInputSource = existingMeasurementSource(session, "input");
+  const priorOutputSource = existingMeasurementSource(session, "output");
+  const inputTokens = inputActual ?? estimatedInputTokens;
+  const outputTokens = outputActual ?? estimatedOutputTokens;
+  session.usage.inputTokens += inputTokens;
+  session.usage.outputTokens += outputTokens;
+  if (inputActual !== void 0) {
+    session.usage.actualInputTokens = (session.usage.actualInputTokens ?? 0) + inputActual;
+  } else {
+    session.usage.estimatedInputTokens = (session.usage.estimatedInputTokens ?? 0) + inputTokens;
+  }
+  if (outputActual !== void 0) {
+    session.usage.actualOutputTokens = (session.usage.actualOutputTokens ?? 0) + outputActual;
+  } else {
+    session.usage.estimatedOutputTokens = (session.usage.estimatedOutputTokens ?? 0) + outputTokens;
+  }
+  session.usage.inputSource = mergeMeasurementSource(
+    priorInputSource,
+    inputActual === void 0 ? "estimated" : "actual",
+    session.usage.inputTokens
+  );
+  session.usage.outputSource = mergeMeasurementSource(
+    priorOutputSource,
+    outputActual === void 0 ? "estimated" : "actual",
+    session.usage.outputTokens
+  );
+  session.usage.source = combineMeasurementSources(
+    session.usage.inputSource,
+    session.usage.outputSource,
+    session.usage.inputTokens,
+    session.usage.outputTokens
+  );
+  return { inputTokens, outputTokens };
+}
+function validTokenCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
+}
+function existingMeasurementSource(session, channel) {
+  const source = channel === "input" ? session.usage.inputSource : session.usage.outputSource;
+  if (source) return source;
+  const total = channel === "input" ? session.usage.inputTokens : session.usage.outputTokens;
+  return total > 0 ? "unknown" : void 0;
+}
+function mergeMeasurementSource(previous, current, total) {
+  if (total === 0 && !previous) return current;
+  if (!previous) return current;
+  return previous === current ? current : "mixed";
+}
+function combineMeasurementSources(input2, output2, inputTokens, outputTokens) {
+  const active = [
+    ...inputTokens > 0 ? [input2] : [],
+    ...outputTokens > 0 ? [output2] : []
+  ];
+  if (!active.length) return "unknown";
+  return active.every((source) => source === active[0]) ? active[0] ?? "unknown" : "mixed";
 }
 function uniqueCategories(categories) {
   return [...new Set(categories)];
@@ -8740,21 +9796,16 @@ function failedResult(call, content, failure) {
     toolCallId: call.id,
     name: call.name,
     ok: false,
-    content: truncateToolOutput(failure ? `${formatFailureReceipt(failure)}
-${content}` : content),
+    content: failure ? `${formatFailureReceipt(failure)}
+${content}` : content,
     ...failure ? { metadata: { failure } } : {}
   };
 }
-function visibleToolDefinitions(tools, askMode, contractEnabled) {
+function visibleToolDefinitions(tools, askMode, contractEnabled, artifactReadAvailable) {
   return tools.definitions().filter(
-    (tool) => (!askMode || tool.category === "read") && (contractEnabled || tool.name !== "task_contract")
+    (tool) => (!askMode || tool.category === "read") && (contractEnabled || tool.name !== "task_contract") && (artifactReadAvailable || tool.name !== "read_tool_artifact")
   );
 }
-function truncateToolOutput(content) {
-  const max = 8e4;
-  return content.length <= max ? content : `${content.slice(0, max)}
-\u2026 tool output truncated`;
-}
 function formatToolError(error) {
   const normalized = toError(error);
   if (normalized.name === "ZodError") return `Invalid tool arguments: ${normalized.message}`;
@@ -8787,9 +9838,9 @@ async function safeEmit(emit, event) {
 }
 
 // src/agent/profiles.ts
-import { lstat as lstat16, readFile as readFile13, readdir as readdir5 } from "node:fs/promises";
+import { lstat as lstat17, readFile as readFile14, readdir as readdir6 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { basename as basename8, join as join14 } from "node:path";
+import { basename as basename8, join as join15 } from "node:path";
 import { parse as parseYaml2 } from "yaml";
 var builtInProfiles = [
   {
@@ -8881,14 +9932,14 @@ var AgentProfileCatalog = class {
   profiles = new Map(builtInProfiles.map((profile) => [profile.name, profile]));
   async discover() {
     const locations = [
-      { path: join14(resolveHomeNamespace(), "agents"), source: "user" },
-      { path: join14(homedir3(), ".claude", "agents"), source: "user" },
-      { path: join14(resolveProjectNamespaceSync(this.workspace).active, "agents"), source: "workspace" },
-      { path: join14(this.workspace, ".claude", "agents"), source: "workspace" }
+      { path: join15(resolveHomeNamespace(), "agents"), source: "user" },
+      { path: join15(homedir3(), ".claude", "agents"), source: "user" },
+      { path: join15(resolveProjectNamespaceSync(this.workspace).active, "agents"), source: "workspace" },
+      { path: join15(this.workspace, ".claude", "agents"), source: "workspace" }
     ];
     for (const location of locations) {
       for (const file of await markdownFiles(location.path)) {
-        const profile = await readProfile(join14(location.path, file), location.source);
+        const profile = await readProfile(join15(location.path, file), location.source);
         if (profile) this.profiles.set(profile.name, profile);
       }
     }
@@ -8904,18 +9955,18 @@ var AgentProfileCatalog = class {
 };
 async function markdownFiles(directory) {
   try {
-    const info = await lstat16(directory);
+    const info = await lstat17(directory);
     if (!info.isDirectory() || info.isSymbolicLink()) return [];
-    return (await readdir5(directory, { withFileTypes: true })).filter((entry) => entry.isFile() && !entry.isSymbolicLink() && entry.name.endsWith(".md")).map((entry) => entry.name).slice(0, 200);
+    return (await readdir6(directory, { withFileTypes: true })).filter((entry) => entry.isFile() && !entry.isSymbolicLink() && entry.name.endsWith(".md")).map((entry) => entry.name).slice(0, 200);
   } catch {
     return [];
   }
 }
 async function readProfile(path, source) {
   try {
-    const info = await lstat16(path);
+    const info = await lstat17(path);
     if (!info.isFile() || info.isSymbolicLink() || info.size > 1e5) return void 0;
-    const raw = await readFile13(path, "utf8");
+    const raw = await readFile14(path, "utf8");
     const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
     const frontmatter = match ? parseYaml2(match[1] ?? "") : {};
     const prompt = (match ? raw.slice(match[0].length) : raw).trim();
@@ -8943,8 +9994,8 @@ function integer(value, fallback, min, max) {
 
 // src/agent/delegation.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
-import { join as join17 } from "node:path";
-import { z as z16 } from "zod";
+import { join as join18 } from "node:path";
+import { z as z18 } from "zod";
 
 // src/agent/external-runtime.ts
 async function runExternalAgent(request) {
@@ -9071,95 +10122,95 @@ function numeric(...values) {
 }
 
 // src/agent/team-store.ts
-import { createHash as createHash11, randomUUID as randomUUID13 } from "node:crypto";
-import { lstat as lstat17, readFile as readFile14, readdir as readdir6, rm as rm2 } from "node:fs/promises";
-import { join as join15, resolve as resolve15 } from "node:path";
-import { z as z15 } from "zod";
-var runIdSchema = z15.string().uuid();
-var hashSchema = z15.string().regex(/^[a-f0-9]{64}$/u);
-var artifactSchema = z15.object({
+import { createHash as createHash12, randomUUID as randomUUID13 } from "node:crypto";
+import { lstat as lstat18, readFile as readFile15, readdir as readdir7, rm as rm3 } from "node:fs/promises";
+import { join as join16, resolve as resolve16 } from "node:path";
+import { z as z17 } from "zod";
+var runIdSchema = z17.string().uuid();
+var hashSchema = z17.string().regex(/^[a-f0-9]{64}$/u);
+var artifactSchema2 = z17.object({
   sha256: hashSchema,
-  bytes: z15.number().int().nonnegative().max(5e5)
+  bytes: z17.number().int().nonnegative().max(5e5)
 }).strict();
-var phaseSchema = z15.enum(["work", "review", "revision", "write"]);
-var agentRecordSchema = z15.object({
-  id: z15.string().uuid(),
-  profile: z15.string(),
-  provider: z15.string(),
-  model: z15.string(),
+var phaseSchema = z17.enum(["work", "review", "revision", "write"]);
+var agentRecordSchema = z17.object({
+  id: z17.string().uuid(),
+  profile: z17.string(),
+  provider: z17.string(),
+  model: z17.string(),
   phase: phaseSchema,
-  ok: z15.boolean(),
-  createdAt: z15.string(),
-  startedAt: z15.string().optional(),
-  endedAt: z15.string().optional(),
-  durationMs: z15.number().int().nonnegative().optional(),
-  toolCalls: z15.number().int().nonnegative().optional(),
-  usage: z15.object({
-    inputTokens: z15.number().int().nonnegative(),
-    outputTokens: z15.number().int().nonnegative()
+  ok: z17.boolean(),
+  createdAt: z17.string(),
+  startedAt: z17.string().optional(),
+  endedAt: z17.string().optional(),
+  durationMs: z17.number().int().nonnegative().optional(),
+  toolCalls: z17.number().int().nonnegative().optional(),
+  usage: z17.object({
+    inputTokens: z17.number().int().nonnegative(),
+    outputTokens: z17.number().int().nonnegative()
   }).strict().optional(),
-  report: artifactSchema
+  report: artifactSchema2
 }).strict();
-var messageRecordSchema = z15.object({
-  id: z15.string().uuid(),
-  from: z15.string(),
-  to: z15.string(),
-  createdAt: z15.string(),
-  content: artifactSchema
+var messageRecordSchema = z17.object({
+  id: z17.string().uuid(),
+  from: z17.string(),
+  to: z17.string(),
+  createdAt: z17.string(),
+  content: artifactSchema2
 }).strict();
-var writerIntegrationSchema = z15.object({
-  status: z15.enum(["ready", "conflict", "integrated"]),
-  checkedAt: z15.string(),
-  detail: z15.string().max(2e4),
-  checkpoint: z15.object({
-    sessionId: z15.string(),
-    checkpointId: z15.string()
+var writerIntegrationSchema = z17.object({
+  status: z17.enum(["ready", "conflict", "integrated"]),
+  checkedAt: z17.string(),
+  detail: z17.string().max(2e4),
+  checkpoint: z17.object({
+    sessionId: z17.string(),
+    checkpointId: z17.string()
   }).strict().optional(),
-  integratedAt: z15.string().optional()
+  integratedAt: z17.string().optional()
 }).strict();
-var writerLaneSchema = z15.object({
-  profile: z15.string(),
-  reviewer: z15.string(),
-  baseCommit: z15.string().regex(/^[a-f0-9]{40,64}$/u),
-  outcome: z15.enum(["accepted", "rejected", "failed", "cancelled"]),
-  patch: artifactSchema,
-  files: z15.array(z15.string().min(1).max(4e3)).max(2e3),
-  worktreeCleaned: z15.boolean(),
-  review: artifactSchema.optional(),
+var writerLaneSchema = z17.object({
+  profile: z17.string(),
+  reviewer: z17.string(),
+  baseCommit: z17.string().regex(/^[a-f0-9]{40,64}$/u),
+  outcome: z17.enum(["accepted", "rejected", "failed", "cancelled"]),
+  patch: artifactSchema2,
+  files: z17.array(z17.string().min(1).max(4e3)).max(2e3),
+  worktreeCleaned: z17.boolean(),
+  review: artifactSchema2.optional(),
   integration: writerIntegrationSchema.optional()
 }).strict();
 var manifestFields = {
   id: runIdSchema,
-  workspace: z15.string(),
-  objective: z15.string().max(3e4),
-  reviewer: z15.string(),
-  createdAt: z15.string(),
-  updatedAt: z15.string(),
-  status: z15.enum(["running", "accepted", "rejected", "failed"]),
-  maxReviewRounds: z15.number().int().min(0).max(3),
-  reviewRounds: z15.number().int().min(0).max(3),
-  agents: z15.array(agentRecordSchema).max(256),
-  messages: z15.array(messageRecordSchema).max(512)
+  workspace: z17.string(),
+  objective: z17.string().max(3e4),
+  reviewer: z17.string(),
+  createdAt: z17.string(),
+  updatedAt: z17.string(),
+  status: z17.enum(["running", "accepted", "rejected", "failed"]),
+  maxReviewRounds: z17.number().int().min(0).max(3),
+  reviewRounds: z17.number().int().min(0).max(3),
+  agents: z17.array(agentRecordSchema).max(256),
+  messages: z17.array(messageRecordSchema).max(512)
 };
-var manifestV1Schema = z15.object({
-  version: z15.literal(1),
+var manifestV1Schema = z17.object({
+  version: z17.literal(1),
   ...manifestFields
 }).strict();
-var manifestV2Schema = z15.object({
-  version: z15.literal(2),
+var manifestV2Schema = z17.object({
+  version: z17.literal(2),
   ...manifestFields,
   writer: writerLaneSchema.optional()
 }).strict();
-var manifestSchema2 = z15.discriminatedUnion("version", [manifestV1Schema, manifestV2Schema]);
+var manifestSchema2 = z17.discriminatedUnion("version", [manifestV1Schema, manifestV2Schema]);
 var TeamRunStore = class {
   workspace;
   directory;
   managedDirectory;
   writes = Promise.resolve();
   constructor(workspace, directory) {
-    this.workspace = resolve15(workspace);
+    this.workspace = resolve16(workspace);
     this.managedDirectory = directory === void 0;
-    this.directory = directory ? resolve15(directory) : join15(resolveProjectNamespaceSync(this.workspace).active, "team-runs");
+    this.directory = directory ? resolve16(directory) : join16(resolveProjectNamespaceSync(this.workspace).active, "team-runs");
   }
   async create(input2) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -9243,10 +10294,10 @@ var TeamRunStore = class {
     runIdSchema.parse(runId);
     await this.writes;
     await this.assertRunDirectory(runId);
-    const path = join15(this.runDirectory(runId), "manifest.json");
+    const path = join16(this.runDirectory(runId), "manifest.json");
     await this.assertRegularFile(path);
-    const manifest = manifestSchema2.parse(JSON.parse(await readFile14(path, "utf8")));
-    if (manifest.id !== runId || resolve15(manifest.workspace) !== this.workspace) {
+    const manifest = manifestSchema2.parse(JSON.parse(await readFile15(path, "utf8")));
+    if (manifest.id !== runId || resolve16(manifest.workspace) !== this.workspace) {
       throw new Error("Team run manifest identity does not match its location.");
     }
     if (verify) {
@@ -9260,13 +10311,13 @@ var TeamRunStore = class {
   }
   async readArtifact(runId, artifact) {
     await this.verifyArtifact(runId, artifact);
-    return readFile14(this.artifactPath(runId, artifact.sha256), "utf8");
+    return readFile15(this.artifactPath(runId, artifact.sha256), "utf8");
   }
   async list() {
     await this.writes;
     try {
       await assertNoSymlinkPath(this.workspace, this.directory);
-      const entries = await readdir6(this.directory, { withFileTypes: true });
+      const entries = await readdir7(this.directory, { withFileTypes: true });
       const summaries = [];
       for (const entry of entries) {
         if (!entry.isDirectory() || entry.isSymbolicLink() || !runIdSchema.safeParse(entry.name).success) continue;
@@ -9289,9 +10340,9 @@ var TeamRunStore = class {
       const directory = this.runDirectory(runId);
       await assertNoSymlinkPath(this.workspace, directory);
       try {
-        const info = await lstat17(directory);
+        const info = await lstat18(directory);
         if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Team run storage is not a regular directory.");
-        await rm2(directory, { recursive: true });
+        await rm3(directory, { recursive: true });
         return true;
       } catch (error) {
         if (error.code === "ENOENT") return false;
@@ -9314,31 +10365,31 @@ var TeamRunStore = class {
   }
   async loadUnlocked(runId) {
     await this.assertRunDirectory(runId);
-    const path = join15(this.runDirectory(runId), "manifest.json");
+    const path = join16(this.runDirectory(runId), "manifest.json");
     await this.assertRegularFile(path);
-    return manifestSchema2.parse(JSON.parse(await readFile14(path, "utf8")));
+    return manifestSchema2.parse(JSON.parse(await readFile15(path, "utf8")));
   }
   async writeManifest(manifest) {
     const directory = this.runDirectory(manifest.id);
     await ensureWorkspaceStorageDirectory(this.workspace, directory, {
       requireActiveNamespace: this.managedDirectory
     });
-    await atomicWrite(join15(directory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+    await atomicWrite(join16(directory, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, 384);
   }
   async writeArtifact(runId, content, truncate = true) {
     const data = boundedArtifactText(content, 5e5, truncate);
     const bytes = Buffer.byteLength(data);
-    const sha256 = createHash11("sha256").update(data).digest("hex");
-    const directory = join15(this.runDirectory(runId), "blobs");
+    const sha256 = createHash12("sha256").update(data).digest("hex");
+    const directory = join16(this.runDirectory(runId), "blobs");
     await ensureWorkspaceStorageDirectory(this.workspace, directory, {
       requireActiveNamespace: this.managedDirectory
     });
-    const path = join15(directory, `${sha256}.txt`);
+    const path = join16(directory, `${sha256}.txt`);
     try {
       await this.assertRegularFile(path);
-      const existing = await readFile14(path);
-      if (createHash11("sha256").update(existing).digest("hex") !== sha256) {
+      const existing = await readFile15(path);
+      if (createHash12("sha256").update(existing).digest("hex") !== sha256) {
         throw new Error(`Team artifact hash collision or corruption: ${sha256}`);
       }
     } catch (error) {
@@ -9358,27 +10409,27 @@ var TeamRunStore = class {
     hashSchema.parse(artifact.sha256);
     const path = this.artifactPath(runId, artifact.sha256);
     await this.assertRegularFile(path);
-    const data = await readFile14(path);
-    const hash = createHash11("sha256").update(data).digest("hex");
-    if (hash !== artifact.sha256 || data.byteLength !== artifact.bytes) {
+    const data = await readFile15(path);
+    const hash2 = createHash12("sha256").update(data).digest("hex");
+    if (hash2 !== artifact.sha256 || data.byteLength !== artifact.bytes) {
       throw new Error(`Team artifact integrity check failed: ${artifact.sha256}`);
     }
   }
   artifactPath(runId, sha256) {
-    return join15(this.runDirectory(runId), "blobs", `${sha256}.txt`);
+    return join16(this.runDirectory(runId), "blobs", `${sha256}.txt`);
   }
   runDirectory(runId) {
-    return join15(this.directory, runId);
+    return join16(this.directory, runId);
   }
   async assertRunDirectory(runId) {
     const directory = this.runDirectory(runId);
     await assertNoSymlinkPath(this.workspace, directory);
-    const info = await lstat17(directory);
+    const info = await lstat18(directory);
     if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Team run storage is not a regular directory.");
   }
   async assertRegularFile(path) {
-    await assertNoSymlinkPath(this.workspace, resolve15(path, ".."));
-    const info = await lstat17(path);
+    await assertNoSymlinkPath(this.workspace, resolve16(path, ".."));
+    const info = await lstat18(path);
     if (!info.isFile() || info.isSymbolicLink()) throw new Error(`Team run file is not a regular file: ${path}`);
   }
 };
@@ -9422,10 +10473,10 @@ function resolveAgentModelRoute(team, parent, profile) {
 }
 
 // src/agent/writer-lane.ts
-import { createHash as createHash12 } from "node:crypto";
-import { lstat as lstat18, mkdtemp, realpath as realpath7, rm as rm3 } from "node:fs/promises";
+import { createHash as createHash13 } from "node:crypto";
+import { lstat as lstat19, mkdtemp, realpath as realpath7, rm as rm4 } from "node:fs/promises";
 import { tmpdir as tmpdir2 } from "node:os";
-import { isAbsolute as isAbsolute5, join as join16, resolve as resolve16 } from "node:path";
+import { isAbsolute as isAbsolute5, join as join17, resolve as resolve17 } from "node:path";
 var WriterLaneApplyError = class extends Error {
   constructor(message2, attempted, cause) {
     super(message2, cause === void 0 ? void 0 : { cause });
@@ -9438,18 +10489,18 @@ var WriterLane = class {
   workspace;
   constructor(workspace, workspaceRoots) {
     this.workspace = new WorkspaceAccess([
-      resolve16(workspace),
-      ...workspaceRoots.map((root) => resolve16(root))
+      resolve17(workspace),
+      ...workspaceRoots.map((root) => resolve17(root))
     ]);
   }
   async createDraft(maxPatchBytes, operation, signal) {
     const repository = await this.repository();
     const baseCommit = await this.head(repository);
     const lease = await acquireNamespaceLease(
-      join16(repository.commonDirectory, "skein-writer-lane"),
+      join17(repository.commonDirectory, "skein-writer-lane"),
       "exclusive"
     );
-    const worktree = await mkdtemp(join16(tmpdir2(), "skein-writer-"));
+    const worktree = await mkdtemp(join17(tmpdir2(), "skein-writer-"));
     let added = false;
     let value;
     let patch = "";
@@ -9520,7 +10571,7 @@ var WriterLane = class {
     return {
       baseCommit,
       patch,
-      patchSha256: createHash12("sha256").update(patch).digest("hex"),
+      patchSha256: createHash13("sha256").update(patch).digest("hex"),
       files,
       worktreeCleaned,
       value
@@ -9539,7 +10590,7 @@ var WriterLane = class {
     try {
       const repository = await this.repository();
       const lease = await acquireNamespaceLease(
-        join16(repository.commonDirectory, "skein-writer-lane"),
+        join17(repository.commonDirectory, "skein-writer-lane"),
         "exclusive"
       );
       try {
@@ -9647,7 +10698,7 @@ var WriterLane = class {
       if (isAbsolute5(file) || file === ".git" || file.startsWith(".git/") || file.includes("\0")) {
         throw new Error(`Writer patch contains an unsafe path: ${file}`);
       }
-      await this.workspace.resolvePath(join16(repository.root, file), { allowMissing: true });
+      await this.workspace.resolvePath(join17(repository.root, file), { allowMissing: true });
     }
     if (expectedFiles && !sameSet(files, expectedFiles)) {
       throw new Error("Writer patch paths do not match the persisted file manifest.");
@@ -9662,7 +10713,7 @@ var WriterLane = class {
     if (topLevel.exitCode !== 0 || !topLevel.stdout.trim()) {
       throw new Error("The primary workspace must be a Git repository root for writer lanes.");
     }
-    const discoveredRoot = resolve16(topLevel.stdout.trim());
+    const discoveredRoot = resolve17(topLevel.stdout.trim());
     if (await realpath7(discoveredRoot) !== await realpath7(root)) {
       throw new Error("The primary workspace must be the Git repository root for writer lanes.");
     }
@@ -9671,7 +10722,7 @@ var WriterLane = class {
     if (common.exitCode !== 0 || !common.stdout.trim()) {
       throw new Error(`Unable to resolve the Git common directory: ${processDetail(common)}`);
     }
-    const commonDirectory = await realpath7(isAbsolute5(common.stdout.trim()) ? common.stdout.trim() : resolve16(repositoryRoot, common.stdout.trim()));
+    const commonDirectory = await realpath7(isAbsolute5(common.stdout.trim()) ? common.stdout.trim() : resolve17(repositoryRoot, common.stdout.trim()));
     return { root: repositoryRoot, commonDirectory, runtime };
   }
   async head(repository) {
@@ -9683,7 +10734,7 @@ var WriterLane = class {
     return value;
   }
   async cleanupWorktree(repository, worktree, added) {
-    const physicalWorktree = await realpath7(worktree).catch(() => resolve16(worktree));
+    const physicalWorktree = await realpath7(worktree).catch(() => resolve17(worktree));
     if (added) {
       await runIsolatedGit(repository.runtime, [
         "worktree",
@@ -9692,7 +10743,7 @@ var WriterLane = class {
         worktree
       ], repository.root, { timeoutMs: 6e4 }).catch(() => void 0);
     }
-    await rm3(worktree, { recursive: true, force: true }).catch(() => void 0);
+    await rm4(worktree, { recursive: true, force: true }).catch(() => void 0);
     await runIsolatedGit(repository.runtime, [
       "worktree",
       "prune",
@@ -9741,7 +10792,7 @@ function processDetail(result) {
 }
 async function pathExists2(path) {
   try {
-    await lstat18(path);
+    await lstat19(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -9750,14 +10801,14 @@ async function pathExists2(path) {
 }
 
 // src/agent/delegation.ts
-var writerRunInputSchema = z16.object({
-  task: z16.string().min(1).max(2e4),
-  profile: z16.string().max(64).optional(),
-  reviewer: z16.string().max(64).optional()
+var writerRunInputSchema = z18.object({
+  task: z18.string().min(1).max(2e4),
+  profile: z18.string().max(64).optional(),
+  reviewer: z18.string().max(64).optional()
 }).strict();
-var writerIntegrateInputSchema = z16.object({
-  run_id: z16.string().uuid(),
-  patch_sha256: z16.string().regex(/^[a-f0-9]{64}$/u)
+var writerIntegrateInputSchema = z18.object({
+  run_id: z18.string().uuid(),
+  patch_sha256: z18.string().regex(/^[a-f0-9]{64}$/u)
 }).strict();
 var DelegationManager = class {
   constructor(options) {
@@ -9818,10 +10869,10 @@ var DelegationManager = class {
       },
       async execute(arguments_, context) {
         if (!manager.team.enabled) return { ok: false, content: "Multi-agent delegation is disabled." };
-        const input2 = z16.object({
-          tasks: z16.array(z16.object({
-            profile: z16.string().max(64).optional(),
-            task: z16.string().min(1).max(2e4)
+        const input2 = z18.object({
+          tasks: z18.array(z18.object({
+            profile: z18.string().max(64).optional(),
+            task: z18.string().min(1).max(2e4)
           })).min(1).max(manager.team.maxDelegations)
         }).parse(arguments_);
         const tasks = input2.tasks.map((task) => ({
@@ -9867,13 +10918,13 @@ var DelegationManager = class {
       },
       async execute(arguments_, context) {
         if (!manager.team.enabled) return { ok: false, content: "Multi-agent teams are disabled." };
-        const input2 = z16.object({
-          objective: z16.string().min(1).max(3e4),
-          tasks: z16.array(z16.object({
-            profile: z16.string().max(64).optional(),
-            task: z16.string().min(1).max(2e4)
+        const input2 = z18.object({
+          objective: z18.string().min(1).max(3e4),
+          tasks: z18.array(z18.object({
+            profile: z18.string().max(64).optional(),
+            task: z18.string().min(1).max(2e4)
           })).min(1).max(manager.team.maxDelegations),
-          reviewer: z16.string().max(64).optional()
+          reviewer: z18.string().max(64).optional()
         }).parse(arguments_);
         const tasks = input2.tasks.map((task) => ({
           profile: task.profile ?? manager.team.defaultProfile,
@@ -9936,7 +10987,7 @@ var DelegationManager = class {
         const plan = await manager.loadWriterPlan(input2.run_id, input2.patch_sha256);
         const files = await manager.writerLane.inspectPatch(plan.patch, plan.writer.files);
         return Promise.all(files.map(
-          (file) => context.workspace.resolvePath(join17(context.workspace.primaryRoot, file), { allowMissing: true })
+          (file) => context.workspace.resolvePath(join18(context.workspace.primaryRoot, file), { allowMissing: true })
         ));
       },
       async execute(arguments_, context) {
@@ -10123,7 +11174,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;
@@ -11406,9 +12457,10 @@ var HeadlessReporter = class {
     }
     if (!this.options.quiet && !this.options.compact) {
       const usage = session.usage.inputTokens + session.usage.outputTokens;
+      const usageLabel = tokenUsageLabel(session.usage);
       process.stderr.write(this.paint.dim(
         `
-${this.glyphs.meta} ${session.changedFiles.length} changed files ${this.glyphs.separator} ${usage.toLocaleString()} tokens ${this.glyphs.separator} session ${session.id.slice(0, 8)}
+${this.glyphs.meta} ${session.changedFiles.length} changed files ${this.glyphs.separator} ${usage.toLocaleString()} tokens (${usageLabel}) ${this.glyphs.separator} session ${session.id.slice(0, 8)}
 `
       ));
     }
@@ -11432,16 +12484,19 @@ ${this.glyphs.meta} ${session.changedFiles.length} changed files ${this.glyphs.s
         if (!compact2) process.stderr.write(this.paint.dim(`${this.glyphs.meta} reasoning ${this.glyphs.separator} turn ${event.turn}
 `));
         break;
-      case "context":
+      case "context": {
+        const budget = event.packed.budgetTokens === void 0 ? "" : ` ${this.glyphs.separator} ${event.packed.budgetTier ?? "adaptive"} ${event.packed.budgetTokens} budget`;
         process.stderr.write(this.paint.cyan(
-          `${this.glyphs.meta} context ${this.glyphs.separator} ${event.packed.engine} ${this.glyphs.separator} ${event.packed.hits.length} spans ${this.glyphs.separator} ~${event.packed.estimatedTokens} tokens${event.packed.degradation ? ` ${this.glyphs.separator} ${event.packed.degradation.summary}` : ""}
+          `${this.glyphs.meta} context ${this.glyphs.separator} ${event.packed.engine} ${this.glyphs.separator} ${event.packed.hits.length} spans ${this.glyphs.separator} ~${event.packed.estimatedTokens} tokens${budget}${event.packed.degradation ? ` ${this.glyphs.separator} ${event.packed.degradation.summary}` : ""}
 `
         ));
         break;
+      }
       case "prompt":
         if (!compact2) {
+          const partition = event.breakdown ? ` ${this.glyphs.separator} stable ${event.breakdown.stableTokens} ${this.glyphs.separator} dynamic ${event.breakdown.dynamicTokens} ${this.glyphs.separator} history ${event.breakdown.conversationTokens} ${this.glyphs.separator} tool results ${event.breakdown.toolResultTokens} ${this.glyphs.separator} retrieved ${event.breakdown.retrievedTokens} ${this.glyphs.separator} tools ${event.breakdown.toolSchemaTokens} ${this.glyphs.separator} output cap ${event.breakdown.outputAllowanceTokens}` : "";
           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
+            `${this.glyphs.meta} prompt ${this.glyphs.separator} ${event.intent} ${this.glyphs.separator} ~${event.estimatedTokens} estimated tokens${partition}
 `
           ));
         }
@@ -11573,9 +12628,14 @@ function sessionSummary(session) {
     ...session.taskContract ? { taskContract: session.taskContract } : {},
     changedFiles: session.changedFiles,
     ...session.lastRun ? { lastRun: session.lastRun } : {},
+    ...session.tokenLedger?.length ? { tokenLedger: session.tokenLedger } : {},
     usage: session.usage
   };
 }
+function tokenUsageLabel(usage) {
+  if (usage.source) return usage.source;
+  return usage.inputTokens + usage.outputTokens > 0 ? "unknown source" : "no usage";
+}
 function formatToolDetail(call, paint = chalk2, glyphs = resolveCliGlyphs()) {
   const environment = call.name === "shell" && typeof call.arguments.env === "object" && call.arguments.env !== null && !Array.isArray(call.arguments.env) ? Object.keys(call.arguments.env).sort() : [];
   const environmentDetail = environment.length ? ` ${glyphs.separator} env ${environment.join(", ")}` : "";
@@ -11598,7 +12658,7 @@ function formatResultDetail(result, paint = chalk2, glyphs = resolveCliGlyphs())
 }
 
 // src/cli/namespace-leases.ts
-import { resolve as resolve17 } from "node:path";
+import { resolve as resolve18 } from "node:path";
 function cliNamespaceLeaseScopes(actionCommand) {
   const names = commandNames(actionCommand);
   const topLevel = names[1];
@@ -11620,7 +12680,7 @@ async function acquireCliNamespaceLeases(actionCommand) {
   const scopes = cliNamespaceLeaseScopes(actionCommand);
   const localOptions = actionCommand.opts();
   const globalOptions = actionCommand.optsWithGlobals();
-  const workspace = resolve17(localOptions.workspace ?? globalOptions.workspace ?? process.cwd());
+  const workspace = resolve18(localOptions.workspace ?? globalOptions.workspace ?? process.cwd());
   const targets = scopes.map((scope) => scope === "project" ? projectNamespacePaths(workspace).canonical : homeNamespacePaths().canonical);
   const leases = [];
   try {
@@ -11774,11 +12834,11 @@ function command(name, description, usage, aliases) {
 
 // src/ui/text.ts
 import stringWidth from "string-width";
-import stripAnsi from "strip-ansi";
+import stripAnsi2 from "strip-ansi";
 var controlCharacters = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu;
 var escapeSequences = /[[\]][0-9;?=>!]*[ -/]*[@-~]|[[\]][?=>][0-9;?=>!]*[a-zA-Z~]/gu;
 function sanitizeTerminalText(value) {
-  return stripAnsi(value).replace(escapeSequences, "").replace(/\r\n?/g, "\n").replace(controlCharacters, "");
+  return stripAnsi2(value).replace(escapeSequences, "").replace(/\r\n?/g, "\n").replace(controlCharacters, "");
 }
 function terminalEllipsis() {
   return process.env.SKEIN_GLYPHS === "ascii" || process.env.MOSAIC_GLYPHS === "ascii" ? "..." : "\u2026";
@@ -11871,8 +12931,8 @@ function graphemes(value) {
 }
 
 // src/ui/theme.ts
-import { lstat as lstat19, readdir as readdir7, readFile as readFile15 } from "node:fs/promises";
-import { basename as basename9, join as join18, resolve as resolve18 } from "node:path";
+import { lstat as lstat20, readdir as readdir8, readFile as readFile16 } from "node:fs/promises";
+import { basename as basename9, join as join19, resolve as resolve19 } from "node:path";
 import React, { createContext, useContext } from "react";
 function defineTheme(seed) {
   return {
@@ -11994,10 +13054,10 @@ async function reloadUserThemes(directory = userThemeDirectory()) {
   userThemeNames.clear();
   const loaded = [];
   const errors = [];
-  const resolvedDirectory = resolve18(directory);
+  const resolvedDirectory = resolve19(directory);
   let entries;
   try {
-    entries = await readdir7(resolvedDirectory, { encoding: "utf8" });
+    entries = await readdir8(resolvedDirectory, { encoding: "utf8" });
   } catch (error) {
     if (error.code === "ENOENT") {
       return { directory: resolvedDirectory, loaded, errors };
@@ -12006,13 +13066,13 @@ async function reloadUserThemes(directory = userThemeDirectory()) {
   }
   for (const entry of entries) {
     if (!entry.endsWith(".json")) continue;
-    const path = join18(resolvedDirectory, entry);
+    const path = join19(resolvedDirectory, entry);
     try {
-      const info = await lstat19(path);
+      const info = await lstat20(path);
       if (!info.isFile() || info.isSymbolicLink() || info.size > 64e3) {
         throw new Error("must be a regular JSON file smaller than 64 KB");
       }
-      const parsed = JSON.parse(await readFile15(path, "utf8"));
+      const parsed = JSON.parse(await readFile16(path, "utf8"));
       const name = themeName(parsed, basename9(entry, ".json"));
       if (builtInThemeNames.has(name)) throw new Error(`cannot replace built-in theme \`${name}\``);
       themes[name] = defineTheme(themeSeed(parsed, name));
@@ -12025,7 +13085,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 = {
@@ -12300,10 +13360,11 @@ function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = fals
             width,
             glyph: glyphs.context,
             label: "context",
-            detail: `${sanitizeInlineTerminalText(item.engine)} ${glyphs.separator} ${item.hits} spans ${glyphs.separator} ~${formatTokens(item.tokens)}${item.truncated ? ` ${glyphs.separator} truncated` : ""}`,
+            detail: `${sanitizeInlineTerminalText(item.engine)} ${glyphs.separator} ${item.hits} spans ${glyphs.separator} ~${formatTokens(item.tokens)} estimated${item.budgetTokens === void 0 ? "" : ` ${glyphs.separator} ${item.budgetTier ?? "adaptive"} ${formatTokens(item.budgetTokens)} budget`}${item.truncated ? ` ${glyphs.separator} truncated` : ""}`,
             labelColor: theme.accent
           }
         ),
+        !compact2 && item.budgetReason ? /* @__PURE__ */ jsx(Text, { color: theme.dim, children: truncateDisplay(`${glyphs.branchLast} ${sanitizeInlineTerminalText(item.budgetReason)}`, innerWidth) }) : null,
         spans.slice(0, spanLimit).map((span, spanIndex) => {
           const lines = span.startLine === span.endLine ? `${span.startLine}` : `${span.startLine}-${span.endLine}`;
           const location = `${compactDisplayPath(sanitizeInlineTerminalText(span.path), 44)}:${lines}`;
@@ -12325,13 +13386,14 @@ function Timeline({ items, width = 80, glyphMode = "auto", showToolOutput = fals
       ] }, item.id);
     }
     if (item.kind === "prompt") {
+      const detail = item.breakdown ? `~${formatTokens(item.tokens)} estimated ${glyphs.separator} stable ${formatTokens(item.breakdown.stableTokens)} ${glyphs.separator} dynamic ${formatTokens(item.breakdown.dynamicTokens)} ${glyphs.separator} history ${formatTokens(item.breakdown.conversationTokens)} ${glyphs.separator} tool results ${formatTokens(item.breakdown.toolResultTokens)} ${glyphs.separator} retrieved ${formatTokens(item.breakdown.retrievedTokens)} ${glyphs.separator} tools ${formatTokens(item.breakdown.toolSchemaTokens)} ${glyphs.separator} output cap ${formatTokens(item.breakdown.outputAllowanceTokens)}` : `${item.sections.map(sanitizeInlineTerminalText).join(` ${glyphs.separator} `)} ${glyphs.separator} ~${formatTokens(item.tokens)} estimated`;
       return /* @__PURE__ */ jsx(
         MetaRow,
         {
           width,
           glyph: glyphs.pending,
           label: `prompt/${sanitizeInlineTerminalText(item.intent)}`,
-          detail: `${item.sections.map(sanitizeInlineTerminalText).join(` ${glyphs.separator} `)} ${glyphs.separator} ~${formatTokens(item.tokens)}`
+          detail
         },
         item.id
       );
@@ -13252,9 +14314,9 @@ function safeWidth(width) {
 }
 
 // src/utils/update-check.ts
-import { mkdir as mkdir9, readFile as readFile16, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join19 } from "node:path";
-import stripAnsi2 from "strip-ansi";
+import { mkdir as mkdir9, readFile as readFile17, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join20 } from "node:path";
+import stripAnsi3 from "strip-ansi";
 var PACKAGE_NAME = "@skein-code/cli";
 var REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 var CACHE_FILE = "update-check.json";
@@ -13269,7 +14331,7 @@ function sanitizeHighlights(value) {
   const cleaned = [];
   for (const entry of value) {
     if (typeof entry !== "string") continue;
-    const flattened = stripAnsi2(entry).replace(BIDI_CONTROLS, "").replace(/[\u0000-\u001f\u007f-\u009f]/gu, " ").replace(/\s+/gu, " ").trim();
+    const flattened = stripAnsi3(entry).replace(BIDI_CONTROLS, "").replace(/[\u0000-\u001f\u007f-\u009f]/gu, " ").replace(/\s+/gu, " ").trim();
     if (!flattened || flattened.length > MAX_HIGHLIGHT_LENGTH) continue;
     cleaned.push(flattened);
     if (cleaned.length >= MAX_HIGHLIGHTS) break;
@@ -13333,7 +14395,7 @@ function compareVersions(a, b) {
   return 0;
 }
 function updateCachePath(env = process.env) {
-  return join19(resolveHomeNamespace(env), CACHE_FILE);
+  return join20(resolveHomeNamespace(env), CACHE_FILE);
 }
 function upgradeCommand() {
   return `npm i -g ${PACKAGE_NAME}`;
@@ -13350,7 +14412,7 @@ function noticeIfNewer(latest, current, highlights) {
 }
 async function readUpdateCache(env = process.env) {
   try {
-    const raw = await readFile16(updateCachePath(env), "utf8");
+    const raw = await readFile17(updateCachePath(env), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt === "number" && Number.isFinite(parsed.checkedAt) && parsed.checkedAt >= 0 && (parsed.latest === null || typeof parsed.latest === "string" && parseVersion(parsed.latest))) {
       const latest = typeof parsed.latest === "string" ? parsed.latest : null;
@@ -14431,7 +15493,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) {
@@ -14446,6 +15508,9 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
           engine: event.packed.engine,
           hits: event.packed.hits.length,
           tokens: event.packed.estimatedTokens,
+          ...event.packed.budgetTier ? { budgetTier: event.packed.budgetTier } : {},
+          ...event.packed.budgetTokens !== void 0 ? { budgetTokens: event.packed.budgetTokens } : {},
+          ...event.packed.budgetReason ? { budgetReason: event.packed.budgetReason } : {},
           truncated: event.packed.truncated,
           spans: event.packed.hits.slice(0, 5).map((hit) => ({
             path: relative8(runner.workspace.primaryRoot, hit.path) || hit.path,
@@ -14459,7 +15524,14 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
         setActivity({ label: "Assembling relevant context", startedAt: Date.now() });
         break;
       case "prompt":
-        append({ id: nextId(), kind: "prompt", intent: event.intent, sections: event.sections, tokens: event.estimatedTokens });
+        append({
+          id: nextId(),
+          kind: "prompt",
+          intent: event.intent,
+          sections: event.sections,
+          tokens: event.estimatedTokens,
+          ...event.breakdown ? { breakdown: event.breakdown } : {}
+        });
         setActivity({ label: "Preparing the model prompt", startedAt: Date.now() });
         break;
       case "assistant_delta":
@@ -15006,7 +16078,7 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
         { label: config.agents?.enabled ? `${config.agents.maxConcurrent} concurrent` : "disabled", detail: "expert delegation" },
         {
           label: `${usage.inputTokens.toLocaleString()} in ${separator} ${usage.outputTokens.toLocaleString()} out`,
-          detail: `session tokens${separator}${(usage.inputTokens + usage.outputTokens).toLocaleString()} total`
+          detail: `session tokens${separator}${(usage.inputTokens + usage.outputTokens).toLocaleString()} total${separator}${usage.source ?? "unknown source"}`
         },
         {
           label: `${Math.round(status.pressure * 100)}% context pressure`,
@@ -15255,8 +16327,8 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
   }, [append]);
   function settlePermission(grant, stop = false) {
     if (!permission) return;
-    const { call, category, resolve: resolve23 } = permission;
-    resolve23(grant);
+    const { call, category, resolve: resolve24 } = permission;
+    resolve24(grant);
     setPermission(void 0);
     if (grant === "session") {
       append({
@@ -16591,24 +17663,24 @@ async function runFirstRunOnboarding(initialConfig, options = {}) {
 }
 
 // src/runtime/extensions.ts
-import { resolve as resolve21 } from "node:path";
+import { resolve as resolve22 } from "node:path";
 
 // src/mcp/manager.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import stripAnsi4 from "strip-ansi";
+import stripAnsi5 from "strip-ansi";
 
 // src/mcp/tool.ts
-import { createHash as createHash13 } from "node:crypto";
-import stripAnsi3 from "strip-ansi";
+import { createHash as createHash14 } from "node:crypto";
+import stripAnsi4 from "strip-ansi";
 var MAX_ARGUMENT_BYTES = 256e3;
 var MAX_DESCRIPTION_LENGTH = 4e3;
-var MAX_RESULT_LENGTH = 8e4;
+var MAX_RESULT_BYTES = 5 * 1024 * 1024;
 var MAX_SCHEMA_BYTES = 1e5;
 function createMcpToolAdapter(options) {
   const { remoteTool } = options;
-  const inputSchema11 = copyInputSchema(remoteTool.inputSchema);
+  const inputSchema12 = copyInputSchema(remoteTool.inputSchema);
   return {
     definition: {
       name: options.exposedName,
@@ -16616,7 +17688,7 @@ function createMcpToolAdapter(options) {
       // MCP servers are an external trust boundary. Read-only annotations are
       // hints from that server and must not lower the local permission level.
       category: "network",
-      inputSchema: inputSchema11
+      inputSchema: inputSchema12
     },
     permissionCategories: () => ["network"],
     async execute(arguments_, context) {
@@ -16636,6 +17708,8 @@ function createMcpToolAdapter(options) {
         metadata: {
           mcpServer: options.serverName,
           mcpTool: remoteTool.name,
+          sourceBytes: normalized.sourceBytes,
+          sourceTruncated: normalized.sourceTruncated,
           ...normalized.isError ? { mcpError: true } : {}
         }
       };
@@ -16665,8 +17739,8 @@ function isUsableRemoteTool(tool) {
   }
 }
 function describeTool(serverName, tool) {
-  const label = stripAnsi3(tool.title?.trim() || tool.name).replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 200);
-  const description = tool.description ? stripAnsi3(tool.description).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ").trim().slice(0, MAX_DESCRIPTION_LENGTH) : void 0;
+  const label = stripAnsi4(tool.title?.trim() || tool.name).replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, 200);
+  const description = tool.description ? stripAnsi4(tool.description).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, " ").trim().slice(0, MAX_DESCRIPTION_LENGTH) : void 0;
   return description ? `[MCP ${serverName}/${label}] ${description}` : `Call the ${label} tool provided by the ${serverName} MCP server.`;
 }
 function copyInputSchema(schema) {
@@ -16689,7 +17763,7 @@ function assertArguments(arguments_) {
 }
 function normalizeCallResult(result) {
   if (!isRecord2(result)) {
-    return { content: truncateResult(safeJson(result)), isError: false };
+    return boundResult(safeJson(result), false);
   }
   const isError = result.isError === true;
   const sections = [];
@@ -16705,7 +17779,22 @@ ${safeJson(result.structuredContent)}`);
 ${safeJson(result.toolResult)}`);
   }
   const content = sections.filter(Boolean).join("\n\n") || (isError ? "The MCP tool reported an error." : "The MCP tool completed without output.");
-  return { content: truncateResult(content), isError };
+  return boundResult(content, isError);
+}
+function boundResult(content, isError) {
+  const sourceBytes = Buffer.byteLength(content);
+  if (sourceBytes <= MAX_RESULT_BYTES) {
+    return { content, isError, sourceBytes, sourceTruncated: false };
+  }
+  const marker = `
+... ${sourceBytes - MAX_RESULT_BYTES} or more source bytes omitted by the MCP safety limit ...
+`;
+  const markerBytes = Buffer.byteLength(marker);
+  const available = MAX_RESULT_BYTES - markerBytes;
+  const headBytes = Math.floor(available * 0.6);
+  const tailBytes = available - headBytes;
+  const bounded = `${sliceUtf8Start(content, headBytes)}${marker}${sliceUtf8End(content, tailBytes)}`;
+  return { content: bounded, isError, sourceBytes, sourceTruncated: true };
 }
 function formatContentBlock(block) {
   if (!isRecord2(block) || typeof block.type !== "string") return safeJson(block);
@@ -16753,15 +17842,10 @@ function fitToolName(name, identity) {
   return `${name.slice(0, 64 - suffix.length).replace(/_+$/g, "")}${suffix}`;
 }
 function shortHash(value) {
-  return createHash13("sha256").update(value).digest("hex").slice(0, 8);
-}
-function truncateResult(content) {
-  if (content.length <= MAX_RESULT_LENGTH) return content;
-  return `${content.slice(0, MAX_RESULT_LENGTH)}
-... MCP result truncated`;
+  return createHash14("sha256").update(value).digest("hex").slice(0, 8);
 }
 function sanitizeOutputText(value) {
-  return stripAnsi3(value).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+  return stripAnsi4(value).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
 }
 function sanitizeInlineText(value) {
   return sanitizeOutputText(value).replace(/[\r\n\t]+/g, " ").trim().slice(0, 2e3);
@@ -16773,13 +17857,25 @@ function safeJson(value) {
     return String(value);
   }
 }
+function sliceUtf8Start(value, maxBytes) {
+  const buffer = Buffer.from(value);
+  let end = Math.min(buffer.length, maxBytes);
+  while (end > 0 && (buffer[end] ?? 0) >= 128 && (buffer[end] ?? 0) < 192) end -= 1;
+  return buffer.subarray(0, end).toString("utf8");
+}
+function sliceUtf8End(value, maxBytes) {
+  const buffer = Buffer.from(value);
+  let start = Math.max(0, buffer.length - maxBytes);
+  while (start < buffer.length && (buffer[start] ?? 0) >= 128 && (buffer[start] ?? 0) < 192) start += 1;
+  return buffer.subarray(start).toString("utf8");
+}
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // src/mcp/validation.ts
 import { stat as stat10, realpath as realpath8 } from "node:fs/promises";
-import { isAbsolute as isAbsolute6, resolve as resolve19 } from "node:path";
+import { isAbsolute as isAbsolute6, resolve as resolve20 } from "node:path";
 var SERVER_NAME = /^[a-z][a-z0-9_-]{0,63}$/;
 var ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var HEADER_NAME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
@@ -16851,9 +17947,9 @@ async function validateCwd(configured, options) {
   if (configured !== void 0 && (configured.length > 4e3 || CONTROL_CHARACTERS.test(configured))) {
     throw new Error("MCP working directory is invalid or too long");
   }
-  const defaultCwd = resolve19(options.cwd ?? process.cwd());
-  const candidate = configured ? isAbsolute6(configured) ? resolve19(configured) : resolve19(defaultCwd, configured) : defaultCwd;
-  const roots = options.workspaceRoots?.length ? options.workspaceRoots.map((root) => resolve19(root)) : [defaultCwd];
+  const defaultCwd = resolve20(options.cwd ?? process.cwd());
+  const candidate = configured ? isAbsolute6(configured) ? resolve20(configured) : resolve20(defaultCwd, configured) : defaultCwd;
+  const roots = options.workspaceRoots?.length ? options.workspaceRoots.map((root) => resolve20(root)) : [defaultCwd];
   const resolvedCandidate = await realpath8(candidate).catch(() => {
     throw new Error(`MCP working directory does not exist: ${candidate}`);
   });
@@ -17191,7 +18287,7 @@ var McpManager = class {
       stderr: "pipe"
     });
     transport.stderr?.on("data", (chunk) => {
-      const text = stripAnsi4(chunk.toString()).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").trim();
+      const text = stripAnsi5(chunk.toString()).replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "").trim();
       if (text) this.options.logger?.(`MCP ${name} stderr`, { text: text.slice(0, 2e3) });
     });
     return transport;
@@ -17350,7 +18446,7 @@ function errorMessage2(error) {
   return sanitizeStatusText(message2) || "Unknown MCP error";
 }
 function sanitizeStatusText(value) {
-  return stripAnsi4(value).replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, 1e3);
+  return stripAnsi5(value).replace(/[\u0000-\u001f\u007f]/g, " ").trim().slice(0, 1e3);
 }
 function timeoutError(timeoutMs) {
   const error = new Error(`MCP request timed out after ${timeoutMs} ms`);
@@ -17376,9 +18472,9 @@ async function closeTransportQuietly(transport) {
 }
 
 // src/memory/tools.ts
-import { z as z17 } from "zod";
-var scopeSchema = z17.enum(["user", "workspace", "session", "agent"]);
-var kindSchema = z17.enum(["semantic", "episodic", "procedural"]);
+import { z as z19 } from "zod";
+var scopeSchema = z19.enum(["user", "workspace", "session", "agent"]);
+var kindSchema = z19.enum(["semantic", "episodic", "procedural"]);
 function createMemoryTools(store) {
   return [
     {
@@ -17393,10 +18489,10 @@ function createMemoryTools(store) {
         }, ["query"])
       },
       async execute(arguments_, context) {
-        const input2 = z17.object({
-          query: z17.string().max(4e3),
+        const input2 = z19.object({
+          query: z19.string().max(4e3),
           scope: scopeSchema.optional(),
-          limit: z17.number().int().min(1).max(20).optional()
+          limit: z19.number().int().min(1).max(20).optional()
         }).parse(arguments_);
         const scopes = input2.scope ? [{ scope: input2.scope, scopeKey: scopeKey(input2.scope, context) }] : availableScopes(context);
         const records = store.search(input2.query, { scopes, limit: input2.limit ?? 8 });
@@ -17428,17 +18524,17 @@ ${record.content}`
         }, ["content", "rationale"])
       },
       async execute(arguments_, context) {
-        const input2 = z17.object({
-          content: z17.string().min(1).max(12e3),
-          rationale: z17.string().min(1).max(1e3),
+        const input2 = z19.object({
+          content: z19.string().min(1).max(12e3),
+          rationale: z19.string().min(1).max(1e3),
           scope: scopeSchema.optional(),
           kind: kindSchema.optional(),
-          tags: z17.array(z17.string()).max(24).optional(),
-          importance: z17.number().min(0).max(1).optional(),
-          confidence: z17.number().min(0).max(1).optional(),
-          agent: z17.string().max(64).optional(),
-          revision: z17.string().max(240).optional(),
-          conflictKey: z17.string().max(240).optional()
+          tags: z19.array(z19.string()).max(24).optional(),
+          importance: z19.number().min(0).max(1).optional(),
+          confidence: z19.number().min(0).max(1).optional(),
+          agent: z19.string().max(64).optional(),
+          revision: z19.string().max(240).optional(),
+          conflictKey: z19.string().max(240).optional()
         }).strict().parse(arguments_);
         const scope = input2.scope ?? "workspace";
         const candidate = store.propose({
@@ -17476,9 +18572,9 @@ ${record.content}`
         }, ["id"])
       },
       async execute(arguments_) {
-        const input2 = z17.object({
-          id: z17.string().uuid(),
-          permanent: z17.boolean().optional()
+        const input2 = z19.object({
+          id: z19.string().uuid(),
+          permanent: z19.boolean().optional()
         }).parse(arguments_);
         const changed = input2.permanent ? store.remove(input2.id) : store.archive(input2.id);
         return {
@@ -17505,9 +18601,9 @@ function scopeKey(scope, context) {
 }
 
 // src/skills/catalog.ts
-import { lstat as lstat20, readFile as readFile17, readdir as readdir8, realpath as realpath9 } from "node:fs/promises";
+import { lstat as lstat21, readFile as readFile18, readdir as readdir9, realpath as realpath9 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { basename as basename11, join as join20, resolve as resolve20 } from "node:path";
+import { basename as basename11, join as join21, resolve as resolve21 } from "node:path";
 import { parse as parseYaml3 } from "yaml";
 var SkillCatalog = class {
   constructor(workspace, config) {
@@ -17527,7 +18623,7 @@ var SkillCatalog = class {
     for (const location of locations) {
       const entries = await safeDirectories(location.path);
       for (const entry of entries) {
-        const skillPath = join20(location.path, entry, "SKILL.md");
+        const skillPath = join21(location.path, entry, "SKILL.md");
         const metadata = await readMetadata(skillPath);
         if (!metadata) continue;
         const descriptor = {
@@ -17576,31 +18672,31 @@ ${skill.content}
 }
 function discoveryLocations(workspace, configured) {
   const home = homedir4();
-  const workspaceRoot = resolve20(workspace);
+  const workspaceRoot = resolve21(workspace);
   return [
-    { path: join20(home, ".agents", "skills"), scope: "user", trusted: true },
-    { path: join20(home, ".claude", "skills"), scope: "user", trusted: true },
-    { path: join20(home, ".augment", "skills"), scope: "user", trusted: true },
-    { path: join20(resolveHomeNamespace(), "skills"), scope: "user", trusted: true },
+    { path: join21(home, ".agents", "skills"), scope: "user", trusted: true },
+    { path: join21(home, ".claude", "skills"), scope: "user", trusted: true },
+    { path: join21(home, ".augment", "skills"), scope: "user", trusted: true },
+    { path: join21(resolveHomeNamespace(), "skills"), scope: "user", trusted: true },
     ...configured.map((path) => {
-      const resolved = resolve20(workspaceRoot, path);
+      const resolved = resolve21(workspaceRoot, path);
       return {
         path: resolved,
         scope: "configured",
         trusted: !isInside(workspaceRoot, resolved)
       };
     }),
-    { path: join20(workspace, ".agents", "skills"), scope: "workspace", trusted: false },
-    { path: join20(workspace, ".claude", "skills"), scope: "workspace", trusted: false },
-    { path: join20(workspace, ".augment", "skills"), scope: "workspace", trusted: false },
-    { path: join20(resolveProjectNamespaceSync(workspaceRoot).active, "skills"), scope: "workspace", trusted: false }
+    { path: join21(workspace, ".agents", "skills"), scope: "workspace", trusted: false },
+    { path: join21(workspace, ".claude", "skills"), scope: "workspace", trusted: false },
+    { path: join21(workspace, ".augment", "skills"), scope: "workspace", trusted: false },
+    { path: join21(resolveProjectNamespaceSync(workspaceRoot).active, "skills"), scope: "workspace", trusted: false }
   ];
 }
 async function safeDirectories(path) {
   try {
-    const info = await lstat20(path);
+    const info = await lstat21(path);
     if (!info.isDirectory() || info.isSymbolicLink()) return [];
-    const entries = await readdir8(path, { withFileTypes: true });
+    const entries = await readdir9(path, { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory() && !entry.isSymbolicLink()).map((entry) => entry.name).slice(0, 500);
   } catch {
     return [];
@@ -17612,7 +18708,7 @@ async function readMetadata(path) {
   const { frontmatter } = splitFrontmatter(raw);
   if (!frontmatter) return void 0;
   const parsed = parseYaml3(frontmatter);
-  const name = typeof parsed?.name === "string" ? parsed.name.trim() : basename11(resolve20(path, ".."));
+  const name = typeof parsed?.name === "string" ? parsed.name.trim() : basename11(resolve21(path, ".."));
   const description = typeof parsed?.description === "string" ? parsed.description.trim() : "";
   if (!/^[a-z][a-z0-9_-]{0,63}$/.test(name) || !description || description.length > 1e3) {
     return void 0;
@@ -17631,13 +18727,13 @@ async function readSkill(path, maxChars) {
 }
 async function safeRead(path, maxBytes) {
   try {
-    const info = await lstat20(path);
+    const info = await lstat21(path);
     if (!info.isFile() || info.isSymbolicLink() || info.size > maxBytes) return void 0;
-    const parent = resolve20(path, "..");
+    const parent = resolve21(path, "..");
     const resolvedParent = await realpath9(parent);
     const resolvedPath = await realpath9(path);
     if (!resolvedPath.startsWith(`${resolvedParent}/`)) return void 0;
-    return await readFile17(path, "utf8");
+    return await readFile18(path, "utf8");
   } catch {
     return void 0;
   }
@@ -17682,7 +18778,7 @@ function escapeAttribute6(value) {
 }
 
 // src/workflows/catalog.ts
-import { z as z18 } from "zod";
+import { z as z20 } from "zod";
 var builtInWorkflows = [
   {
     name: "implement",
@@ -17773,7 +18869,7 @@ function createWorkflowTool(catalog) {
       }, ["name", "task"])
     },
     async execute(arguments_) {
-      const input2 = z18.object({ name: z18.string(), task: z18.string().min(1).max(2e4) }).parse(arguments_);
+      const input2 = z20.object({ name: z20.string(), task: z20.string().min(1).max(2e4) }).parse(arguments_);
       const workflow = catalog.get(input2.name);
       if (!workflow) return { ok: false, content: `Unknown workflow: ${input2.name}` };
       return {
@@ -17818,7 +18914,7 @@ var ExtensionRuntime = class _ExtensionRuntime {
   delegation;
   initialized = false;
   static async create(config, registry, options = {}) {
-    const runtime = new _ExtensionRuntime(config, resolve21(config.workspaceRoots[0] ?? process.cwd()), options);
+    const runtime = new _ExtensionRuntime(config, resolve22(config.workspaceRoots[0] ?? process.cwd()), options);
     try {
       await runtime.initialize(registry, options.signal);
       return runtime;
@@ -18023,15 +19119,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 });
     });
   });
 }
@@ -18117,7 +19213,7 @@ program.command("context").description("Pack task-oriented context under a token
 
 `);
   process.stderr.write(chalk4.dim(
-    `${cliGlyphs.meta} ${packed.engine} ${cliGlyphs.separator} ${packed.hits.length} spans ${cliGlyphs.separator} ~${packed.estimatedTokens} tokens${packed.truncated ? ` ${cliGlyphs.separator} capped` : ""}${packed.degradation ? ` ${cliGlyphs.separator} ${packed.degradation.summary}` : ""}
+    `${cliGlyphs.meta} ${packed.engine} ${cliGlyphs.separator} ${packed.hits.length} spans ${cliGlyphs.separator} ~${packed.estimatedTokens} estimated tokens${packed.budgetTokens === void 0 ? "" : ` ${cliGlyphs.separator} ${packed.budgetTier ?? "adaptive"} ${packed.budgetTokens} budget`}${packed.truncated ? ` ${cliGlyphs.separator} capped` : ""}${packed.degradation ? ` ${cliGlyphs.separator} ${packed.degradation.summary}` : ""}
 `
   ));
 });
@@ -18280,9 +19376,11 @@ sessionCommand.command("show <id>").description("Show a saved session transcript
   else process.stdout.write(sessionMarkdown(session));
 });
 sessionCommand.command("delete <id>").description("Delete a saved session").option("-w, --workspace <path>", "workspace root").option("--yes", "skip confirmation").action(async (id, options) => {
-  const store = new SessionStore(workspaceOption(options.workspace));
+  const workspace = workspaceOption(options.workspace);
+  const store = new SessionStore(workspace);
   const session = await requireSessionSelector(store, id);
   if (!options.yes && !await confirm(`Delete session ${session.id.slice(0, 8)}?`)) return;
+  await new ToolArtifactStore(workspace).removeSession(session.id);
   await store.remove(session.id);
   process.stdout.write(`Deleted ${session.id}
 `);
@@ -18291,7 +19389,7 @@ sessionCommand.command("export <id>").description("Export a session as Markdown"
   const store = new SessionStore(workspaceOption(options.workspace));
   const session = await requireSessionSelector(store, id);
   const markdown = sessionMarkdown(session);
-  if (options.output) await writeFile3(resolve22(options.output), markdown, "utf8");
+  if (options.output) await writeFile3(resolve23(options.output), markdown, "utf8");
   else process.stdout.write(markdown);
 });
 var checkpointCommand = program.command("checkpoint").description("Inspect and restore pre-mutation snapshots");
@@ -18668,7 +19766,7 @@ async function runChat(prompts, options) {
   const stdinPrompt = !process.stdin.isTTY ? await readStdin() : "";
   const firstPrompt = [...prompts, stdinPrompt].filter(Boolean).join("\n\n").trim();
   if (shouldPrint && !firstPrompt) throw new Error("Provide a prompt argument or pipe input on stdin.");
-  const workspace = resolve22(options.workspace);
+  const workspace = resolve23(options.workspace);
   let config = await runtimeConfig(workspace, options);
   let completedOnboarding = false;
   if (!shouldPrint && needsFirstRunOnboarding(config)) {
@@ -18893,14 +19991,14 @@ async function runAgentSetup(options) {
 `);
 }
 async function runtimeConfig(workspaceInput, options) {
-  const workspace = resolve22(workspaceInput);
+  const workspace = resolve23(workspaceInput);
   const loaded = await loadConfig(workspace, options.config, {
     trustProjectConfig: options.trustProjectConfig === true
   });
   const roots = [
     workspace,
     ...loaded.workspaceRoots,
-    ...(options.addWorkspace ?? []).map((root) => resolve22(workspace, root))
+    ...(options.addWorkspace ?? []).map((root) => resolve23(workspace, root))
   ];
   const provider = options.provider ? validateProvider(options.provider) : loaded.model.provider;
   return {
@@ -19056,7 +20154,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();