@skein-code/cli 0.3.22 → 0.3.24

package/dist/cli.js

@@ -220,7 +220,7 @@ function isSqliteBusy(error) {
 // package.json
 var package_default = {
   name: "@skein-code/cli",
-  version: "0.3.22",
+  version: "0.3.24",
   description: "A context-first, model-agnostic coding agent with an auditable terminal workspace.",
   type: "module",
   license: "MIT",
@@ -236,6 +236,13 @@ var package_default = {
   },
   skein: {
     releaseNotes: [
+      "Context compaction now rebuilds authoritative task, working-state, verification, permission, failure, and artifact facts outside generated narrative",
+      "Automatic compaction runs only when three predicted prompt reuses produce positive net token savings while explicit compact commands remain available",
+      "Compaction provider usage is included in session totals with separate content-free actual or estimated receipts",
+      "Empty or lossy narratives cannot erase deterministic facts, and the complete persisted transcript remains unchanged",
+      "Normal chat startup now exposes a compact mcp_activate catalog instead of eagerly connecting MCP servers",
+      "MCP activation connects one selected server, discovers remote tools, and loads at most eight relevant schemas",
+      "Explicit MCP diagnostics can still connect eagerly while all MCP activation and remote calls remain network operations",
       "OpenAI, Anthropic, and Gemini usage now normalizes cached input, cache-write input, and reasoning tokens when reported",
       "Token Ledger, session totals, and structured usage events preserve provider cache and reasoning counts without prompt content",
       "Streaming, non-streaming, explicit-zero, and legacy-session compatibility paths are covered without claiming cache activation",
@@ -1938,6 +1945,7 @@ var agentTeamConfigSchema = z2.object({
 var mcpServerSchema = z2.object({
   enabled: z2.boolean().optional(),
   transport: z2.enum(["stdio", "http"]).optional(),
+  description: z2.string().min(1).max(500).optional(),
   command: z2.string().min(1).max(512).optional(),
   args: z2.array(z2.string().max(4e3)).max(64).optional(),
   cwd: z2.string().max(4e3).optional(),
@@ -4712,12 +4720,16 @@ function formatContextHits(hits, roots) {
 }
 
 // src/agent/runner.ts
-import { randomUUID as randomUUID12 } from "node:crypto";
+import { randomUUID as randomUUID13 } from "node:crypto";
 
 // src/context/manager.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
 var RECENT_TURN_RESERVE = 3;
 var COMPACTION_HIGH_WATER = 0.78;
 var TOOL_PRESSURE_WATER = 0.28;
+var COMPACTION_OUTPUT_ALLOWANCE = 1600;
+var PREDICTED_REUSES = 3;
+var MAX_FACT_ITEMS = 16;
 var ContextManager = class {
   constructor(config) {
     this.config = config;
@@ -4757,7 +4769,7 @@ var ContextManager = class {
   status(session, modelContextTokens) {
     const active = activeMessages(session);
     const activeTokens = estimateMessages(active);
-    const summaryTokens = estimateTokens(session.contextSummary ?? "");
+    const summaryTokens = compactedContextTokens(session);
     const toolTokenCount = toolTokens(active);
     const contextLimit = Math.max(
       8e3,
@@ -4780,65 +4792,292 @@ var ContextManager = class {
     const toolTokenCount = toolTokens(active);
     return activeTokens > tokenBudget * COMPACTION_HIGH_WATER || activeTokens > tokenBudget * 0.6 && toolTokenCount > tokenBudget * TOOL_PRESSURE_WATER;
   }
-  async compact(session, provider, signal, instructions = "") {
+  async compact(session, provider, signal, instructions = "", mode = "manual") {
     const active = activeMessages(session);
     const cut = compactionCut(active);
     if (cut === 0) {
-      return { omittedMessages: 0, summaryTokens: estimateTokens(session.contextSummary ?? "") };
+      return skippedCompaction(session, mode, "insufficient-history");
     }
     const older = active.slice(0, cut);
     if (!older.length) {
-      return { omittedMessages: 0, summaryTokens: estimateTokens(session.contextSummary ?? "") };
+      return skippedCompaction(session, mode, "insufficient-history");
     }
     const transcript = older.map(formatMessageForSummary).join("\n\n").slice(-14e4);
-    const response = await provider.complete([
+    const throughMessageId = older.at(-1).id;
+    const facts = buildCompactionFactsEnvelope(session, throughMessageId);
+    const messages = [
       transientMessage("system", `You compress coding-agent working context with high fidelity.
-Return a concise Markdown state handoff with these headings: Goal, Completed, Current State, Decisions, Constraints, Open Questions, Relevant Files, Verification, Next Actions.
-Preserve exact file paths, commands, errors, user corrections, unresolved risks, and permission decisions. Remove conversational filler and large raw tool output. Never invent facts.${instructions ? `
+Return a concise Markdown narrative handoff. Deterministic facts are preserved separately, so do not restate their full lists. Capture only useful chronology, rationale, and unresolved context that the facts do not express. Remove conversational filler and raw tool output. Never invent facts.${instructions ? `
 Additional instructions: ${instructions}` : ""}`),
-      transientMessage("user", `Existing summary, if any:
+      transientMessage("user", `Deterministic facts already preserved outside the narrative:
+${facts}
+
+Existing narrative, if any:
 ${session.contextSummary || "(none)"}
 
 Messages to compact:
 ${transcript}`)
-    ], [], signal, 2400);
-    const summary = response.content.trim();
-    if (!summary) throw new Error("Context compaction returned an empty summary.");
-    session.contextSummary = summary.slice(0, 8e4);
-    session.compactedThroughMessageId = older.at(-1).id;
+    ];
+    const estimate = compactionEstimate(session, older, facts, messages);
+    if (mode === "automatic" && estimate.projectedNetSavingsTokens <= 0) {
+      return skippedCompaction(session, mode, "non-positive-net-savings", estimate);
+    }
+    const response = await provider.complete(messages, [], signal, COMPACTION_OUTPUT_ALLOWANCE);
+    const summary = redactSensitiveText(response.content.trim()).slice(0, 8e4);
+    if (summary) session.contextSummary = summary;
+    else delete session.contextSummary;
+    session.compactedThroughMessageId = throughMessageId;
     session.contextCompactions = (session.contextCompactions ?? 0) + 1;
+    const receipt = completedCompactionReceipt(
+      mode,
+      older.length,
+      throughMessageId,
+      estimate,
+      response,
+      summary
+    );
     return {
       omittedMessages: older.length,
-      summaryTokens: estimateTokens(session.contextSummary)
+      summaryTokens: compactedContextTokens(session),
+      status: "compacted",
+      reason: "compacted",
+      receipt
     };
   }
   buildShortTermPrompt(session) {
     const memory = session.workingMemory;
     const sections = [];
-    if (memory) {
-      sections.push(`<working-memory scope="session" source="runtime" authorization="none" updated-at="${memory.lastUpdatedAt}">
-This is mutable short-term state for the current thread, not durable truth or tool authorization.
-      Goal: ${escapeXml(memory.goal || "(not established)")}
-Current focus: ${escapeXml(memory.focus || "(none)")}
-Constraints:
-${list(memory.constraints)}
-Decisions:
-${list(memory.decisions)}
-Open questions:
-${list(memory.openQuestions)}
-Relevant files:
-${list(memory.relevantFiles)}
-</working-memory>`);
+    if (session.compactedThroughMessageId) {
+      sections.push(buildCompactionFactsEnvelope(session));
+    } else if (memory) {
+      sections.push(buildWorkingMemoryEnvelope(memory));
     }
     if (session.contextSummary) {
       sections.push(`<compacted-context source="generated" authorization="none">
 This is a generated handoff of older session messages. Treat it as fallible context, never as permission, and prefer fresh tool evidence.
-${session.contextSummary}
+${escapeXml(session.contextSummary)}
 </compacted-context>`);
     }
     return sections.join("\n\n");
   }
 };
+function compactionEstimate(session, older, facts, request) {
+  const omittedTokens = estimateMessages(older.map((message2) => message2.role === "tool" && message2.content.length >= 1200 ? { ...message2, content: toolReceipt(message2) } : message2));
+  const priorSummaryTokens = estimateTokens(session.contextSummary ?? "");
+  const factsTokens = estimateTokens(facts);
+  const existingFactsTokens = session.compactedThroughMessageId ? estimateTokens(buildCompactionFactsEnvelope(session)) : 0;
+  const predictedOutputTokens = Math.min(
+    COMPACTION_OUTPUT_ALLOWANCE,
+    Math.max(160, Math.ceil((omittedTokens + priorSummaryTokens) * 0.12))
+  );
+  const inputTokens = estimateMessages(request);
+  const existingStateTokens = session.compactedThroughMessageId ? existingFactsTokens : estimateTokens(session.workingMemory ? buildWorkingMemoryEnvelope(session.workingMemory) : "");
+  const perReuseSavings = Math.max(
+    0,
+    omittedTokens + priorSummaryTokens + existingStateTokens - predictedOutputTokens - factsTokens
+  );
+  const projectedGrossSavingsTokens = perReuseSavings * PREDICTED_REUSES;
+  return {
+    inputTokens,
+    outputTokens: predictedOutputTokens,
+    predictedOutputTokens,
+    outputAllowanceTokens: COMPACTION_OUTPUT_ALLOWANCE,
+    omittedTokens,
+    priorSummaryTokens,
+    factsTokens,
+    projectedGrossSavingsTokens,
+    projectedNetSavingsTokens: projectedGrossSavingsTokens - inputTokens - predictedOutputTokens
+  };
+}
+function skippedCompaction(session, mode, reason, estimate = emptyCompactionEstimate(session)) {
+  const receipt = {
+    id: randomUUID4(),
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    mode,
+    status: "skipped",
+    reason,
+    omittedMessages: 0,
+    predictedReuses: PREDICTED_REUSES,
+    estimated: estimate,
+    actual: {},
+    inputSource: "none",
+    outputSource: "none",
+    narrative: "not-requested"
+  };
+  return {
+    omittedMessages: 0,
+    summaryTokens: compactedContextTokens(session),
+    status: "skipped",
+    reason,
+    receipt
+  };
+}
+function emptyCompactionEstimate(session) {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    predictedOutputTokens: 0,
+    outputAllowanceTokens: COMPACTION_OUTPUT_ALLOWANCE,
+    omittedTokens: 0,
+    priorSummaryTokens: estimateTokens(session.contextSummary ?? ""),
+    factsTokens: session.compactedThroughMessageId ? estimateTokens(buildCompactionFactsEnvelope(session)) : 0,
+    projectedGrossSavingsTokens: 0,
+    projectedNetSavingsTokens: 0
+  };
+}
+function completedCompactionReceipt(mode, omittedMessages, compactedThroughMessageId, estimated, response, summary) {
+  const actual = actualUsage(response.usage);
+  return {
+    id: randomUUID4(),
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    mode,
+    status: "compacted",
+    reason: "compacted",
+    omittedMessages,
+    compactedThroughMessageId,
+    predictedReuses: PREDICTED_REUSES,
+    estimated: {
+      ...estimated,
+      outputTokens: estimateTokens(response.content) + estimateTokens(JSON.stringify(response.toolCalls))
+    },
+    actual,
+    inputSource: actual.inputTokens === void 0 ? "estimated" : "actual",
+    outputSource: actual.outputTokens === void 0 ? "estimated" : "actual",
+    narrative: summary ? "present" : "empty"
+  };
+}
+function actualUsage(usage) {
+  const entries = {
+    inputTokens: validTokens(usage?.inputTokens),
+    outputTokens: validTokens(usage?.outputTokens),
+    cachedInputTokens: validTokens(usage?.cachedInputTokens),
+    cacheWriteInputTokens: validTokens(usage?.cacheWriteInputTokens),
+    reasoningTokens: validTokens(usage?.reasoningTokens)
+  };
+  return Object.fromEntries(Object.entries(entries).filter(([, value]) => value !== void 0));
+}
+function validTokens(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
+}
+function compactedContextTokens(session) {
+  if (!session.compactedThroughMessageId) return estimateTokens(session.contextSummary ?? "");
+  return estimateTokens(buildCompactionFactsEnvelope(session)) + estimateTokens(session.contextSummary ?? "");
+}
+function buildCompactionFactsEnvelope(session, throughMessageId) {
+  const memory = session.workingMemory;
+  const contract = session.taskContract;
+  const lastRun = session.lastRun;
+  const directives = olderUserDirectives(session, throughMessageId ?? session.compactedThroughMessageId);
+  const permissions = recentPermissionFacts(session.audit ?? []);
+  const failures = recentFailureFacts(session.audit ?? []);
+  const artifacts = (session.toolArtifacts ?? []).filter((artifact) => Date.parse(artifact.expiresAt) > Date.now()).slice(-MAX_FACT_ITEMS).map((artifact) => `- sha256=${artifact.sha256} tool-call=${safeFact(artifact.toolCallId, 160)} bytes=${artifact.bytes} expires=${safeFact(artifact.expiresAt, 80)} redacted=${artifact.redacted}`);
+  const contractLines = contract ? [
+    `State: ${contract.state}`,
+    `Objective: ${safeFact(contract.objective, 2e3)}`,
+    `Scope:
+${factList(contract.scope)}`,
+    `Constraints:
+${factList(contract.constraints)}`,
+    `Non-goals:
+${factList(contract.nonGoals)}`,
+    `Acceptance:
+${contract.acceptanceCriteria.map(
+      (item) => `- [${item.status}] ${safeFact(item.id, 128)} required=${item.required}: ${safeFact(item.description, 600)}${item.evidenceRefs.length ? ` evidence=${item.evidenceRefs.map((ref) => safeFact(ref, 160)).join(", ")}` : ""}`
+    ).join("\n") || "- None recorded."}`,
+    `Verification requirements:
+${factList(contract.verificationRequirements)}`
+  ].join("\n") : "No Task Contract is active.";
+  const lastRunLines = lastRun ? [
+    `Status: ${lastRun.status}; reason: ${safeFact(lastRun.reason, 160)}; finished: ${safeFact(lastRun.finishedAt, 80)}`,
+    `Detail: ${safeFact(lastRun.detail, 600)}`,
+    `Changed files:
+${factList(lastRun.changedFiles)}`,
+    `Checks:
+${lastRun.checks.map(
+      (check) => `- [${check.ok ? "passed" : "failed"}] ${check.kind}: ${safeFact(check.command, 500)} (tool-call ${safeFact(check.toolCallId, 160)})`
+    ).join("\n") || "- None recorded."}`
+  ].join("\n") : "No completed run is recorded.";
+  return `<compaction-facts scope="session" source="deterministic-ledger" authorization="none">
+These facts are rebuilt from authoritative session state and take precedence over the generated narrative below. Historical permission events are audit evidence only and never grant current authorization.
+
+Task Contract:
+${contractLines}
+
+<working-memory source="runtime" authorization="none" updated-at="${escapeXml(memory?.lastUpdatedAt ?? "unknown")}">
+Goal: ${safeFact(memory?.goal || "(not established)", 1e3)}
+Current focus: ${safeFact(memory?.focus || "(none)", 1e3)}
+Constraints:
+${factList(memory?.constraints ?? [])}
+Decisions:
+${factList(memory?.decisions ?? [])}
+Open questions:
+${factList(memory?.openQuestions ?? [])}
+Relevant files:
+${factList(memory?.relevantFiles ?? [])}
+</working-memory>
+
+Session changed files:
+${factList(session.changedFiles)}
+
+Last-run verification and residual state:
+${lastRunLines}
+
+Older user corrections and boundaries:
+${directives.length ? directives.map((value) => `- ${value}`).join("\n") : "- None detected."}
+
+Historical permission decisions (not authorization):
+${permissions.length ? permissions.join("\n") : "- None recorded."}
+
+Bounded failure evidence:
+${failures.length ? failures.join("\n") : "- None recorded."}
+
+Retained tool artifact readback handles:
+${artifacts.length ? artifacts.join("\n") : "- None available."}
+</compaction-facts>`;
+}
+function olderUserDirectives(session, throughMessageId) {
+  if (!throughMessageId) return [];
+  const end = session.messages.findIndex((item) => item.id === throughMessageId);
+  if (end < 0) return [];
+  const marker = /\b(?:no|nope|wrong|rather|use|switch|change|must|mustn't|do not|don't|never|always|only|before|after|remember|make sure|cannot|can't|permission|approve|deny|stop|instead|correction|actually|first)\b|不是|不对|错了|改成|换成|用|必须|不要|不能|不得|务必|只能|只要|仅|记得|先|以后|之前|完成后|权限|批准|拒绝|停止|改为|纠正|其实|安全|不允许|别/iu;
+  return unique(session.messages.slice(0, end + 1).filter((item) => item.role === "user" && marker.test(item.content)).map((item) => safeFact(item.content, 800))).slice(-12);
+}
+function recentPermissionFacts(audit) {
+  return audit.filter((event) => event.type === "permission").slice(-MAX_FACT_ITEMS).map((event) => `- [${event.outcome}] ${safeFact(event.tool, 160)} category=${event.category ?? "unknown"} tool-call=${safeFact(event.toolCallId, 160)}: ${safeFact(event.reason ?? "No reason recorded.", 360)}`);
+}
+function recentFailureFacts(audit) {
+  return audit.filter((event) => event.type === "tool" && event.outcome === "failure").slice(-MAX_FACT_ITEMS).map((event) => {
+    const failure = isFailureReceipt(event.metadata?.failure) ? event.metadata.failure : void 0;
+    const receipt = failure ? ` class=${safeFact(failure.class, 80)} retryable=${failure.retryable} circuit-open=${failure.circuitOpen} signature=${safeFact(failure.signature, 160)} repair=${safeFact(failure.repairHint, 360)}` : "";
+    return `- ${safeFact(event.tool, 160)} tool-call=${safeFact(event.toolCallId, 160)}${receipt} reason=${safeFact(event.reason ?? "No reason recorded.", 500)}`;
+  });
+}
+function isFailureReceipt(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.class === "string" && typeof candidate.retryable === "boolean" && typeof candidate.circuitOpen === "boolean" && typeof candidate.signature === "string" && typeof candidate.repairHint === "string";
+}
+function factList(values) {
+  return values.length ? values.slice(-MAX_FACT_ITEMS).map((value) => `- ${safeFact(value, 800)}`).join("\n") : "- None recorded.";
+}
+function safeFact(value, max) {
+  return escapeXml(concise(redactSensitiveText(value), max));
+}
+function buildWorkingMemoryEnvelope(memory) {
+  return `<working-memory scope="session" source="runtime" authorization="none" updated-at="${escapeXml(memory.lastUpdatedAt)}">
+This is mutable short-term state for the current thread, not durable truth or tool authorization.
+Goal: ${safeFact(memory.goal || "(not established)", 1e3)}
+Current focus: ${safeFact(memory.focus || "(none)", 1e3)}
+Constraints:
+${factList(memory.constraints)}
+Decisions:
+${factList(memory.decisions)}
+Open questions:
+${factList(memory.openQuestions)}
+Relevant files:
+${factList(memory.relevantFiles)}
+</working-memory>`;
+}
 function activeMessages(session) {
   if (!session.compactedThroughMessageId) return session.messages;
   const index = session.messages.findIndex((message2) => message2.id === session.compactedThroughMessageId);
@@ -4911,11 +5150,11 @@ function emptyWorkingMemory() {
     lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
-function list(values) {
-  return values.length ? values.map((value) => `- ${escapeXml(value)}`).join("\n") : "- None recorded.";
-}
 function safeShortTerm(value, max) {
-  return concise(value, max).replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/g, "[redacted-secret]").replace(/\b((?:api[_-]?key|access[_-]?token|auth(?:orization)?|password|secret))\s*[:=]\s*[^\s,;]+/gi, "$1=[redacted]");
+  return concise(redactSensitiveText(value), max);
+}
+function redactSensitiveText(value) {
+  return value.replace(/(https?:\/\/)[^/\s:@]+(?::[^@\s/]*)?@/giu, "$1[redacted]@").replace(/\b(sk-[A-Za-z0-9_-]{12,}|AIza[0-9A-Za-z_-]{20,})\b/gu, "[redacted-secret]").replace(/\b(bearer|basic)\s+[^\s,;]+/giu, "$1 [redacted]").replace(/\b((?:api[_-]?key|access[_-]?token|auth(?:orization)?|cookie|password|client[_-]?secret|secret))\s*[:=]\s*[^\s,;]+/giu, "$1=[redacted]").replace(/(--(?:api[_-]?key|access[_-]?token|password|client[_-]?secret|secret)(?:=|\s+))[^\s]+/giu, "$1[redacted]");
 }
 function escapeXml(value) {
   return value.replace(/[&<>"']/g, (character) => ({
@@ -5223,7 +5462,7 @@ function normalizeForMatch(value) {
 }
 
 // src/providers/anthropic.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 
 // src/providers/provider.ts
 var ProviderError = class extends Error {
@@ -5348,7 +5587,7 @@ var AnthropicProvider = class {
     return {
       content: blocks.filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n"),
       toolCalls: blocks.filter((block) => block.type === "tool_use").map((block) => ({
-        id: block.id ?? randomUUID4(),
+        id: block.id ?? randomUUID5(),
         name: block.name ?? "unknown",
         arguments: safeJsonArguments(block.input)
       })),
@@ -5422,7 +5661,7 @@ var AnthropicProvider = class {
       }
       if (chunk.type === "content_block_start" && chunk.content_block?.type === "tool_use") {
         calls.set(index, {
-          id: chunk.content_block.id ?? randomUUID4(),
+          id: chunk.content_block.id ?? randomUUID5(),
           name: chunk.content_block.name ?? "unknown",
           input: chunk.content_block.input,
           partialJson: ""
@@ -5433,7 +5672,7 @@ var AnthropicProvider = class {
         yield { type: "text_delta", content: chunk.delta.text };
       }
       if (chunk.type === "content_block_delta" && chunk.delta?.type === "input_json_delta") {
-        const call = calls.get(index) ?? { id: randomUUID4(), name: "unknown", input: void 0, partialJson: "" };
+        const call = calls.get(index) ?? { id: randomUUID5(), name: "unknown", input: void 0, partialJson: "" };
         call.partialJson += chunk.delta.partial_json ?? "";
         calls.set(index, call);
       }
@@ -5463,7 +5702,7 @@ function normalizeAnthropicResponse(data) {
   return {
     content: blocks.filter((block) => block.type === "text").map((block) => block.text ?? "").join("\n"),
     toolCalls: blocks.filter((block) => block.type === "tool_use").map((block) => ({
-      id: block.id ?? randomUUID4(),
+      id: block.id ?? randomUUID5(),
       name: block.name ?? "unknown",
       arguments: safeJsonArguments(block.input)
     })),
@@ -5508,7 +5747,7 @@ function toAnthropicMessage(message2) {
 }
 
 // src/providers/gemini.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 var GeminiProvider = class {
   constructor(config) {
     this.config = config;
@@ -5548,7 +5787,7 @@ var GeminiProvider = class {
     return {
       content: parts.map((part) => part.text ?? "").filter(Boolean).join("\n"),
       toolCalls: parts.filter((part) => part.functionCall).map((part) => ({
-        id: randomUUID5(),
+        id: randomUUID6(),
         name: part.functionCall?.name ?? "unknown",
         arguments: safeJsonArguments(part.functionCall?.args)
       })),
@@ -5620,7 +5859,7 @@ var GeminiProvider = class {
         }
         if (part.functionCall) {
           toolCalls.push({
-            id: randomUUID5(),
+            id: randomUUID6(),
             name: part.functionCall.name ?? "unknown",
             arguments: safeJsonArguments(part.functionCall.args)
           });
@@ -5649,7 +5888,7 @@ function normalizeGeminiResponse(data) {
   return {
     content: parts.map((part) => part.text ?? "").filter(Boolean).join("\n"),
     toolCalls: parts.filter((part) => part.functionCall).map((part) => ({
-      id: randomUUID5(),
+      id: randomUUID6(),
       name: part.functionCall?.name ?? "unknown",
       arguments: safeJsonArguments(part.functionCall?.args)
     })),
@@ -5693,7 +5932,7 @@ function toGeminiMessage(message2) {
 }
 
 // src/providers/openai.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 var OpenAIProvider = class {
   constructor(config) {
     this.config = config;
@@ -5816,7 +6055,7 @@ var OpenAIProvider = class {
       }
       for (const fragment of delta?.tool_calls ?? []) {
         const index = fragment.index ?? 0;
-        const current = calls.get(index) ?? { id: randomUUID6(), name: "", arguments: "" };
+        const current = calls.get(index) ?? { id: randomUUID7(), name: "", arguments: "" };
         if (fragment.id) current.id = fragment.id;
         if (fragment.function?.name) current.name += fragment.function.name;
         if (fragment.function?.arguments) current.arguments += fragment.function.arguments;
@@ -5850,7 +6089,7 @@ function normalizeOpenAIResponse(data) {
   return {
     content: message2.content ?? "",
     toolCalls: (message2.tool_calls ?? []).map((call) => ({
-      id: call.id ?? randomUUID6(),
+      id: call.id ?? randomUUID7(),
       name: call.function?.name ?? "unknown",
       arguments: safeJsonArguments(call.function?.arguments)
     })),
@@ -5906,7 +6145,7 @@ function createProvider(config) {
 }
 
 // src/checkpoint/store.ts
-import { createHash as createHash8, randomUUID as randomUUID7 } from "node:crypto";
+import { createHash as createHash8, randomUUID as randomUUID8 } from "node:crypto";
 import { lstat as lstat10, mkdir as mkdir7, readFile as readFile5, readdir as readdir2, unlink as unlink2 } from "node:fs/promises";
 import { basename as basename6, dirname as dirname8, join as join9, relative as relative6, resolve as resolve12 } from "node:path";
 import { z as z4 } from "zod";
@@ -5942,7 +6181,7 @@ var CheckpointStore = class {
     return this.withManagedLease(() => this.captureUnlocked(sessionId, unique3, options));
   }
   async captureUnlocked(sessionId, unique3, options) {
-    const id = `${Date.now().toString(36)}-${randomUUID7()}`;
+    const id = `${Date.now().toString(36)}-${randomUUID8()}`;
     const target = join9(this.directory, sessionId, id);
     const blobDirectory = join9(target, "blobs");
     await this.ensureDirectory();
@@ -6218,7 +6457,7 @@ var HookRunner = class {
 };
 
 // src/session/store.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 import { constants as constants4 } from "node:fs";
 import {
   chmod as chmod6,
@@ -6413,6 +6652,37 @@ var taskContractSchema = z5.object({
   updatedAt: z5.string(),
   auditBoundaryId: z5.string().min(1).max(128).optional()
 }).strict();
+var contextCompactionReceiptSchema = z5.object({
+  id: z5.string().uuid(),
+  recordedAt: z5.string().datetime(),
+  mode: z5.enum(["automatic", "manual"]),
+  status: z5.enum(["compacted", "skipped"]),
+  reason: z5.enum(["compacted", "insufficient-history", "non-positive-net-savings"]),
+  omittedMessages: z5.number().int().nonnegative(),
+  compactedThroughMessageId: z5.string().optional(),
+  predictedReuses: z5.number().int().positive(),
+  estimated: z5.object({
+    inputTokens: z5.number().int().nonnegative(),
+    outputTokens: z5.number().int().nonnegative(),
+    predictedOutputTokens: z5.number().int().nonnegative(),
+    outputAllowanceTokens: z5.number().int().nonnegative(),
+    omittedTokens: z5.number().int().nonnegative(),
+    priorSummaryTokens: z5.number().int().nonnegative(),
+    factsTokens: z5.number().int().nonnegative(),
+    projectedGrossSavingsTokens: z5.number().int().nonnegative(),
+    projectedNetSavingsTokens: z5.number().int()
+  }).strict(),
+  actual: z5.object({
+    inputTokens: z5.number().int().nonnegative().optional(),
+    outputTokens: z5.number().int().nonnegative().optional(),
+    cachedInputTokens: z5.number().int().nonnegative().optional(),
+    cacheWriteInputTokens: z5.number().int().nonnegative().optional(),
+    reasoningTokens: z5.number().int().nonnegative().optional()
+  }).strict(),
+  inputSource: z5.enum(["actual", "estimated", "none"]),
+  outputSource: z5.enum(["actual", "estimated", "none"]),
+  narrative: z5.enum(["present", "empty", "not-requested"])
+}).strict();
 var sessionSchema = z5.object({
   id: sessionIdSchema,
   title: z5.string(),
@@ -6428,6 +6698,7 @@ var sessionSchema = z5.object({
   contextSummary: z5.string().max(2e5).optional(),
   contextCompactions: z5.number().int().nonnegative().optional(),
   compactedThroughMessageId: z5.string().optional(),
+  contextCompactionReceipts: z5.array(contextCompactionReceiptSchema).max(64).optional(),
   workingMemory: workingMemorySchema.optional(),
   contextSources: z5.array(contextSourceSchema).max(64).optional(),
   toolArtifacts: z5.array(toolArtifactSchema).max(200).optional(),
@@ -6578,7 +6849,7 @@ var SessionStore = class {
     const backup = this.backupPathFor(session.id);
     await this.assertManagedFile(target);
     await this.assertManagedFile(backup);
-    const temporary = join10(this.directory, `.${session.id}.${randomUUID8()}.tmp`);
+    const temporary = join10(this.directory, `.${session.id}.${randomUUID9()}.tmp`);
     const data = `${JSON.stringify(session, null, 2)}
 `;
     const handle = await open2(temporary, "wx", 384);
@@ -6596,7 +6867,7 @@ var SessionStore = class {
     }
   }
   async copyBackup(source, target) {
-    const temporary = join10(this.directory, `.${basename7(target)}.${randomUUID8()}.tmp`);
+    const temporary = join10(this.directory, `.${basename7(target)}.${randomUUID9()}.tmp`);
     try {
       await copyFile(source, temporary, constants4.COPYFILE_EXCL);
       await chmod6(temporary, 384);
@@ -6685,7 +6956,7 @@ var SessionStore = class {
   }
 };
 function createSession(options) {
-  const id = options.id ?? randomUUID8();
+  const id = options.id ?? randomUUID9();
   validateId(id);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
@@ -8540,7 +8811,7 @@ async function discoverSnapshotFiles(root) {
 }
 
 // src/tools/task.ts
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { z as z14 } from "zod";
 var taskSchema2 = z14.object({
   id: z14.string().min(1).optional(),
@@ -8589,7 +8860,7 @@ var taskTool = {
       case "list":
         break;
       case "add":
-        tasks.push({ id: randomUUID9(), title: input2.title, status: input2.status ?? "pending" });
+        tasks.push({ id: randomUUID10(), title: input2.title, status: input2.status ?? "pending" });
         break;
       case "update": {
         const task = tasks.find((item) => item.id === input2.id);
@@ -8606,7 +8877,7 @@ var taskTool = {
       }
       case "replace":
         tasks.splice(0, tasks.length, ...input2.tasks.map((task) => ({
-          id: task.id ?? randomUUID9(),
+          id: task.id ?? randomUUID10(),
           title: task.title,
           status: task.status
         })));
@@ -8620,11 +8891,11 @@ var taskTool = {
 };
 
 // src/tools/task-contract.ts
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 import { z as z15 } from "zod";
 
 // src/agent/task-contract.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
 var EXECUTABLE_INTENTS = /* @__PURE__ */ new Set(["debug", "refactor", "test", "implement"]);
 function shouldUseTaskContract(request, intent, existing) {
   if (existing && existing.state !== "satisfied") return true;
@@ -8690,7 +8961,7 @@ function refreshTaskContractState(contract) {
 }
 function criterion(id, description) {
   return {
-    id: `${id}-${randomUUID10().slice(0, 8)}`,
+    id: `${id}-${randomUUID11().slice(0, 8)}`,
     description,
     required: true,
     status: "pending",
@@ -9244,7 +9515,7 @@ var taskContractTool = {
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const criteria = input2.acceptance_criteria.map((item) => ({
-        id: item.id ?? `criterion-${randomUUID11().slice(0, 8)}`,
+        id: item.id ?? `criterion-${randomUUID12().slice(0, 8)}`,
         description: item.description,
         required: item.required ?? true,
         status: "pending",
@@ -9632,7 +9903,7 @@ ${workspaceRules}` : ""}`;
 }
 function buildSessionStatePrompt(session) {
   const tasks = session.tasks.length ? session.tasks.map((task) => `- [${task.status}] ${task.title}`).join("\n") : "- No active plan.";
-  const contract = session.taskContract && session.taskContract.state !== "satisfied" ? `
+  const contract = session.taskContract && session.taskContract.state !== "satisfied" && !session.compactedThroughMessageId ? `
 
 Task Contract (${session.taskContract.state}):
 Objective: ${session.taskContract.objective}
@@ -9950,12 +10221,12 @@ function preservedSignals(metadata) {
     }
   }
   const failure = metadata.failure;
-  if (isFailureReceipt(failure)) {
+  if (isFailureReceipt2(failure)) {
     lines.push(`failure-class: ${failure.class}; attempt ${failure.attempt}; ${failure.remaining} retries remain`);
   }
   return lines;
 }
-function isFailureReceipt(value) {
+function isFailureReceipt2(value) {
   return typeof value === "object" && value !== null && typeof value.class === "string" && typeof value.attempt === "number" && typeof value.remaining === "number";
 }
 function redactToolOutput(value) {
@@ -10091,15 +10362,15 @@ async function pinContextSource(session, workspace, requested) {
   const info = await stat9(resolved);
   const alias = workspace.display(resolved);
   const tokens2 = estimateTokens((await readFile13(resolved, "utf8")).slice(0, MAX_SOURCE_CHARS));
-  const list2 = sources(session);
-  const existing = list2.find((source2) => source2.path === alias);
+  const list = sources(session);
+  const existing = list.find((source2) => source2.path === alias);
   if (existing) {
     existing.state = "pinned";
     existing.tokens = tokens2;
     existing.addedAt = (/* @__PURE__ */ new Date()).toISOString();
     return existing;
   }
-  if (list2.length >= MAX_CONTEXT_SOURCES) {
+  if (list.length >= MAX_CONTEXT_SOURCES) {
     throw new Error(`Context source limit reached (${MAX_CONTEXT_SOURCES}); unpin something first.`);
   }
   if (info.size > 4e6) {
@@ -10111,31 +10382,31 @@ async function pinContextSource(session, workspace, requested) {
     tokens: tokens2,
     addedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  list2.push(source);
+  list.push(source);
   return source;
 }
 function unpinContextSource(session, requested) {
-  const list2 = session.contextSources;
-  if (!list2?.length) return void 0;
-  const match = matchSource(list2, requested);
+  const list = session.contextSources;
+  if (!list?.length) return void 0;
+  const match = matchSource(list, requested);
   if (!match) return void 0;
-  list2.splice(list2.indexOf(match), 1);
+  list.splice(list.indexOf(match), 1);
   return match.path;
 }
 function toggleMuteContextSource(session, requested) {
-  const list2 = session.contextSources;
-  if (!list2?.length) return void 0;
-  const match = matchSource(list2, requested);
+  const list = session.contextSources;
+  if (!list?.length) return void 0;
+  const match = matchSource(list, requested);
   if (!match) return void 0;
   match.state = match.state === "muted" ? "pinned" : "muted";
   return match;
 }
 async function resolvePinnedContent(session, workspace) {
-  const list2 = session.contextSources;
-  if (!list2?.length) return [];
+  const list = session.contextSources;
+  if (!list?.length) return [];
   const resolved = [];
   let remaining = MAX_PINNED_CHARS;
-  for (const source of list2) {
+  for (const source of list) {
     if (source.state !== "pinned") continue;
     if (remaining <= 0) break;
     try {
@@ -10167,10 +10438,10 @@ These files were explicitly pinned by the user and are re-read from disk each tu
 ${blocks.join("\n\n")}
 </pinned-context>`;
 }
-function matchSource(list2, requested) {
+function matchSource(list, requested) {
   const trimmed = requested.trim();
   if (!trimmed) return void 0;
-  return list2.find((source) => source.path === trimmed) ?? list2.find((source) => source.path.endsWith(`/${trimmed}`)) ?? list2.find((source) => source.path.includes(trimmed));
+  return list.find((source) => source.path === trimmed) ?? list.find((source) => source.path.endsWith(`/${trimmed}`)) ?? list.find((source) => source.path.includes(trimmed));
 }
 function escapeAttribute5(value) {
   return value.replace(/[&"<>]/g, (character) => ({
@@ -10776,11 +11047,21 @@ var AgentRunner = class {
         await emit({ type: "contract", contract: structuredClone(this.session.taskContract) });
       }
       activeRunContract = contractEnabled ? this.session.taskContract : void 0;
+      let verificationAttempted = false;
+      const maxTurns = options.maxTurns ?? this.config.agent.maxTurns;
+      const contextBudget = Math.max(24e3, Math.min(1e5, this.config.context.maxTokens * 3));
+      if (this.contextManager.shouldCompact(this.session, contextBudget)) {
+        const compacted = await this.compactContext(void 0, options.signal, "automatic");
+        if (compacted.status === "compacted") {
+          await emit({ type: "context_compacted", ...compacted });
+        }
+      }
       const promptSections = [
         `intent:${turnDirective.intent}`,
         ...workspaceRules ? ["rules"] : [],
         ...this.session.workingMemory ? ["working-memory"] : [],
-        ...contractEnabled ? ["task-contract"] : [],
+        ...contractEnabled && !this.session.compactedThroughMessageId ? ["task-contract"] : [],
+        ...this.session.compactedThroughMessageId ? ["compaction-facts"] : [],
         ...this.session.contextSummary ? ["session-summary"] : [],
         ...!trivialTurn ? [`context:${packed.engine}`] : [],
         ...packed.text ? [`code:${packed.engine}`] : [],
@@ -10788,13 +11069,6 @@ var AgentRunner = class {
         ...augmentation.skills?.length ? [`skills:${augmentation.skills.length}`] : [],
         ...augmentation.memoryCount ? [`memory:${augmentation.memoryCount}`] : []
       ];
-      let verificationAttempted = false;
-      const maxTurns = options.maxTurns ?? this.config.agent.maxTurns;
-      const contextBudget = Math.max(24e3, Math.min(1e5, this.config.context.maxTokens * 3));
-      if (this.contextManager.shouldCompact(this.session, contextBudget)) {
-        const compacted = await this.compactContext(void 0, options.signal);
-        await emit({ type: "context_compacted", ...compacted });
-      }
       for (let turn = 1; turn <= maxTurns; turn += 1) {
         throwIfAborted(options.signal);
         if (this.session.usage.inputTokens + this.session.usage.outputTokens >= this.config.agent.maxSessionTokens) {
@@ -10855,7 +11129,7 @@ var AgentRunner = class {
             breakdown
           });
         }
-        const assistantId = randomUUID12();
+        const assistantId = randomUUID13();
         const response = await this.completeModel(
           messages,
           visibleTools,
@@ -11348,7 +11622,7 @@ ${completeContent}`;
   }
   appendAudit(event) {
     const audit = this.session.audit ?? (this.session.audit = []);
-    audit.push({ id: randomUUID12(), createdAt: (/* @__PURE__ */ new Date()).toISOString(), ...event });
+    audit.push({ id: randomUUID13(), createdAt: (/* @__PURE__ */ new Date()).toISOString(), ...event });
     if (audit.length > 5e3) audit.splice(0, audit.length - 5e3);
   }
   async acceptChangedFiles(paths) {
@@ -11369,7 +11643,7 @@ ${completeContent}`;
     const results = [];
     for (const command2 of this.config.agent.verifyCommands) {
       const call = {
-        id: `verify-${randomUUID12()}`,
+        id: `verify-${randomUUID13()}`,
         name: "shell",
         arguments: { command: command2, cwd: this.workspace.primaryRoot }
       };
@@ -11395,13 +11669,25 @@ ${completeContent}`;
       return [];
     }
   }
-  async compactContext(instructions, signal) {
+  async compactContext(instructions, signal, mode = "manual") {
     const result = await this.contextManager.compact(
       this.session,
       this.provider,
       signal,
-      instructions
+      instructions,
+      mode
     );
+    if (result.status === "compacted") {
+      recordTokenUsage(
+        this.session,
+        result.receipt.actual,
+        result.receipt.estimated.inputTokens,
+        result.receipt.estimated.outputTokens
+      );
+    }
+    const receipts = this.session.contextCompactionReceipts ?? (this.session.contextCompactionReceipts = []);
+    receipts.push(result.receipt);
+    if (receipts.length > 64) receipts.splice(0, receipts.length - 64);
     await this.persist();
     return result;
   }
@@ -11493,7 +11779,7 @@ ${completeContent}`;
 };
 function message(role, content, extra = {}) {
   return {
-    id: randomUUID12(),
+    id: randomUUID13(),
     role,
     content,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -11890,7 +12176,7 @@ function integer(value, fallback, min, max) {
 }
 
 // src/agent/delegation.ts
-import { randomUUID as randomUUID14 } from "node:crypto";
+import { randomUUID as randomUUID15 } from "node:crypto";
 import { join as join18 } from "node:path";
 import { z as z19 } from "zod";
 
@@ -12019,7 +12305,7 @@ function numeric(...values) {
 }
 
 // src/agent/team-store.ts
-import { createHash as createHash16, randomUUID as randomUUID13 } from "node:crypto";
+import { createHash as createHash16, randomUUID as randomUUID14 } from "node:crypto";
 import { lstat as lstat18, readFile as readFile17, readdir as readdir7, rm as rm3 } from "node:fs/promises";
 import { join as join16, resolve as resolve18 } from "node:path";
 import { z as z18 } from "zod";
@@ -12113,7 +12399,7 @@ var TeamRunStore = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const manifest = manifestSchema2.parse({
       version: 2,
-      id: randomUUID13(),
+      id: randomUUID14(),
       workspace: this.workspace,
       objective: input2.objective,
       reviewer: input2.reviewer,
@@ -12919,7 +13205,7 @@ var DelegationManager = class {
         maxReviewRounds: 0
       });
       await emit?.({ type: "team_start", id: board.id, objective: task });
-      const writerId = randomUUID14();
+      const writerId = randomUUID15();
       await emit?.({ type: "agent_queued", id: writerId, profile: profile.name, task, phase: "write" });
       const draft = await this.writerLane.createDraft(
         Math.min(this.team.maxWriterPatchBytes ?? 6e4, 12e4),
@@ -13289,7 +13575,7 @@ You are the only writer inside a disposable worktree. Make only the bounded requ
     const reviewer = reviewerOverride ?? this.team.reviewerProfile ?? "reviewer";
     const rounds = Math.max(0, this.team.maxReviewRounds ?? 1);
     const board = await this.teamStore?.create({ objective, reviewer, maxReviewRounds: rounds });
-    const runId = board?.id ?? randomUUID14();
+    const runId = board?.id ?? randomUUID15();
     await emit?.({ type: "team_start", id: runId, objective });
     try {
       let results = await this.runBatch(board?.id, tasks, "work", emit, signal);
@@ -13347,7 +13633,7 @@ ${review.summary}`,
     }
   }
   async runBatch(runId, tasks, phase, emit, signal) {
-    const scheduled = tasks.map((task) => ({ id: randomUUID14(), task }));
+    const scheduled = tasks.map((task) => ({ id: randomUUID15(), task }));
     for (const item of scheduled) {
       await emit?.({ type: "agent_queued", id: item.id, profile: item.task.profile, task: item.task.task, phase });
     }
@@ -13456,12 +13742,12 @@ Start the response with exactly VERDICT: ACCEPT when the evidence is sufficient,
     });
   }
   async peerMessage(runId, from, to, content, emit) {
-    const id = randomUUID14();
+    const id = randomUUID15();
     if (runId) await this.teamStore?.recordMessage(runId, { id, from, to, content });
     await emit?.({ type: "agent_message", id, from, to, content });
   }
   async runOne(task, phase, emit, signal, retryOf, scheduledId) {
-    const id = scheduledId ?? randomUUID14();
+    const id = scheduledId ?? randomUUID15();
     const profile = this.options.profiles.get(task.profile);
     const configuredRoute = this.team.routes?.[task.profile];
     const budgetMode = configuredRoute?.budgetMode ?? this.team.budgetMode ?? "observe";
@@ -14528,6 +14814,7 @@ function sessionSummary(session) {
     changedFiles: session.changedFiles,
     ...session.lastRun ? { lastRun: session.lastRun } : {},
     ...session.tokenLedger?.length ? { tokenLedger: session.tokenLedger } : {},
+    ...session.contextCompactionReceipts?.length ? { contextCompactionReceipts: session.contextCompactionReceipts } : {},
     usage: session.usage
   };
 }
@@ -15948,12 +16235,13 @@ function MeterBar({ segments, total, width, glyphs }) {
 function ContextInspector({ status, working, summary, width, memory, connections, sources: sources2, compact: compact2 = false, minimal = false, glyphMode = "auto" }) {
   const theme = useTheme();
   const glyphs = resolveGlyphs(glyphMode);
+  const hasCompactedContext = status.compactedMessages > 0 || Boolean(summary);
   if (minimal) {
     const rowWidth2 = safeWidth(width);
     const padding = rowWidth2 >= 4 ? 2 : 0;
     const innerWidth2 = Math.max(1, rowWidth2 - padding);
     const active = `${status.messageCount} msg ${glyphs.separator} ~${formatTokens(status.activeTokens)} tok`;
-    const focus = sanitizeTerminalText(working?.focus || working?.goal || (summary ? "summary ready" : "not established")).replace(/\s+/g, " ").trim() || "not established";
+    const focus = sanitizeTerminalText(working?.focus || working?.goal || (hasCompactedContext ? "handoff ready" : "not established")).replace(/\s+/g, " ").trim() || "not established";
     return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: padding, children: [
       /* @__PURE__ */ jsx(Text, { bold: true, color: theme.textStrong, children: truncateDisplay(`Context ${formatPercent(status.pressure)} ${glyphs.separator} ${active}`, innerWidth2) }),
       /* @__PURE__ */ jsx(Text, { color: working ? theme.text : theme.muted, children: truncateDisplay(`working ${focus}`, innerWidth2) })
@@ -15962,7 +16250,7 @@ function ContextInspector({ status, working, summary, width, memory, connections
   const entries = [
     { label: "active", detail: `${status.messageCount} messages ${glyphs.separator} ~${formatTokens(status.activeTokens)} tokens ${glyphs.separator} tools ~${formatTokens(status.toolTokens)}` },
     { label: "short-term", detail: working ? `${working.focus || working.goal || "ready"} ${glyphs.separator} ${relativeTime(working.lastUpdatedAt)}` : "not established" },
-    { label: "summary", detail: summary ? `~${formatTokens(status.summaryTokens)} tokens ${glyphs.separator} ${status.compactedMessages} compacted` : "not created" },
+    { label: "summary", detail: hasCompactedContext ? `~${formatTokens(status.summaryTokens)} tokens ${glyphs.separator} ${status.compactedMessages} compacted${summary ? "" : ` ${glyphs.separator} facts`}` : "not created" },
     { label: "long-term", detail: memory ?? `retrieved by relevance ${glyphs.separator} untrusted context` }
   ];
   if (!compact2 && working?.constraints.length) entries.push({ label: `constraints ${working.constraints.length}`, detail: working.constraints.slice(0, 2).join(` ${glyphs.separator} `) });
@@ -15984,7 +16272,7 @@ function ContextInspector({ status, working, summary, width, memory, connections
   const rowWidth = safeWidth(width);
   const innerWidth = Math.max(1, rowWidth - 2);
   const pressureColor = status.pressure >= 0.9 ? theme.error : status.pressure >= 0.75 ? theme.warning : theme.accent;
-  const summaryTokens = summary ? status.summaryTokens : 0;
+  const summaryTokens = hasCompactedContext ? status.summaryTokens : 0;
   const segments = [
     { label: "active", value: status.activeTokens, color: theme.accent },
     { label: "tools", value: status.toolTokens, color: theme.assistant },
@@ -17797,8 +18085,8 @@ function SkeinApp({ runner, config, extensions, initialPrompt, askMode = false,
         return true;
       }
       if (subcommand === "list") {
-        const list2 = runner.listContextSources();
-        appendList("Pinned context", list2.length ? list2.map((source) => ({
+        const list = runner.listContextSources();
+        appendList("Pinned context", list.length ? list.map((source) => ({
           label: `${source.state === "muted" ? "muted " : "pinned"}  ${source.path}`,
           detail: `~${source.tokens} tokens${separator}added ${source.addedAt.slice(0, 10)}`,
           tone: source.state === "muted" ? "warning" : "success"
@@ -19940,12 +20228,24 @@ var MAX_TOOLS_PER_SERVER = 256;
 var MAX_LIST_PAGES = 16;
 var DEFAULT_CONNECT_TIMEOUT = 12e3;
 var DEFAULT_TOOL_TIMEOUT = 6e4;
+var LAZY_SCHEMA_LIMIT = 8;
 var McpManager = class {
   constructor(config, options = {}) {
     this.config = config;
     this.options = options;
-    for (const [name, server] of Object.entries(config.servers ?? {})) {
+    const entries = Object.entries(config.servers ?? {});
+    for (const [index, [name, server]] of entries.entries()) {
       const transport = server.transport ?? "stdio";
+      if (index >= MAX_SERVERS) {
+        this.statuses.set(name, {
+          name,
+          state: "error",
+          transport,
+          toolCount: 0,
+          error: `MCP server limit exceeded (maximum ${MAX_SERVERS})`
+        });
+        continue;
+      }
       const state = config.enabled === false || server.enabled === false ? "disabled" : "disconnected";
       this.statuses.set(name, { name, state, transport, toolCount: 0 });
     }
@@ -19960,6 +20260,75 @@ var McpManager = class {
   options;
   shutdownController = new AbortController();
   closed = false;
+  /** Compact model-visible catalog; transport and remote discovery stay lazy. */
+  activationTool(registry) {
+    const names = this.activatableServerNames();
+    if (!names.length) return;
+    const catalog = names.map((name) => {
+      const server = this.config.servers[name];
+      const description = sanitizeCatalogText(server?.description) || `${server?.transport ?? "stdio"} MCP server`;
+      return `${name}: ${description}`;
+    }).join("; ");
+    return {
+      definition: {
+        name: "mcp_activate",
+        description: `Connect to one configured MCP server only when the current task needs it, discover its tools, and load at most ${LAZY_SCHEMA_LIMIT} relevant schemas. Available servers: ${catalog}`,
+        category: "network",
+        inputSchema: {
+          type: "object",
+          properties: {
+            server: { type: "string", enum: names, description: "Configured MCP server to activate." },
+            query: { type: "string", minLength: 1, maxLength: 500, description: "Capability needed from that server." }
+          },
+          required: ["server", "query"],
+          additionalProperties: false
+        }
+      },
+      permissionCategories: () => ["network"],
+      execute: async (arguments_, context) => {
+        const server = typeof arguments_.server === "string" ? arguments_.server : "";
+        const query = typeof arguments_.query === "string" ? arguments_.query.trim() : "";
+        if (!names.includes(server)) throw new ToolInputError("MCP server is not available for activation");
+        if (!query || query.length > 500) {
+          throw new ToolInputError("MCP activation query must contain 1 to 500 characters");
+        }
+        const result = await this.activate(server, query, registry, context.signal);
+        if (!result.ok) {
+          return {
+            ok: false,
+            content: `MCP server ${server} could not be activated: ${result.status.error ?? result.status.state}`,
+            metadata: activationMetadata(result)
+          };
+        }
+        const loaded = result.registeredTools.length ? result.registeredTools.join(", ") : "no matching tool schemas";
+        const deferred = result.deferredTools ? ` ${result.deferredTools} additional schemas remain deferred; activate again with a narrower query if needed.` : "";
+        return {
+          content: `Activated MCP server ${server}. Loaded: ${loaded}.${deferred}`,
+          metadata: activationMetadata(result)
+        };
+      }
+    };
+  }
+  /** Connect/discover one server, then register only request-relevant schemas. */
+  async activate(name, query, registry, signal) {
+    const connected = await this.connect(name, signal);
+    if (!connected.ok) {
+      return { ...connected, registeredTools: [], availableTools: 0, deferredTools: 0 };
+    }
+    const connection = this.connections.get(name);
+    if (!connection) {
+      return { ...connected, ok: false, registeredTools: [], availableTools: 0, deferredTools: 0 };
+    }
+    const tools = [...connection.tools.values()];
+    const selected = tools.length <= LAZY_SCHEMA_LIMIT ? tools : selectRelevantTools(tools, query, LAZY_SCHEMA_LIMIT);
+    this.registerSelectedTools(registry, selected);
+    return {
+      ...connected,
+      registeredTools: selected.map((tool) => tool.definition.name),
+      availableTools: tools.length,
+      deferredTools: Math.max(0, tools.length - selected.length)
+    };
+  }
   /** Connect enabled servers with a small concurrency bound. */
   async connectAll(signal) {
     if (this.closed) throw new Error("MCP manager is closed");
@@ -19968,15 +20337,6 @@ var McpManager = class {
     if (this.config.enabled === false) {
       return configuredNames.map((name) => this.resultFor(name, false, 0));
     }
-    for (const name of configuredNames.slice(MAX_SERVERS)) {
-      const server = this.config.servers[name];
-      this.setStatus(name, {
-        state: "error",
-        transport: server?.transport ?? "stdio",
-        toolCount: 0,
-        error: `MCP server limit exceeded (maximum ${MAX_SERVERS})`
-      });
-    }
     const results = [];
     let cursor = 0;
     const worker = async () => {
@@ -19992,6 +20352,10 @@ var McpManager = class {
   /** Connect one configured server. Connection errors are captured in status. */
   async connect(name, signal) {
     if (this.closed) throw new Error("MCP manager is closed");
+    const status = this.statuses.get(name);
+    if (status?.state === "error" && status.error?.includes("server limit exceeded")) {
+      return this.resultFor(name, false, 0);
+    }
     const existing = this.pending.get(name);
     if (existing) return existing;
     const connectionController = new AbortController();
@@ -20076,8 +20440,11 @@ var McpManager = class {
   }
   /** Register connected MCP tools, preserving idempotency for the same adapter. */
   registerTools(registry) {
+    return this.registerSelectedTools(registry, this.tools());
+  }
+  registerSelectedTools(registry, tools) {
     const registered = [];
-    for (const tool of this.tools()) {
+    for (const tool of tools) {
       const existing = registry.get(tool.definition.name);
       if (existing) {
         if (existing !== tool) {
@@ -20090,6 +20457,10 @@ var McpManager = class {
     }
     return registered;
   }
+  activatableServerNames() {
+    if (this.config.enabled === false) return [];
+    return [...this.statuses.values()].filter((status) => status.state !== "disabled" && status.state !== "error").map((status) => status.name).sort((left, right) => left.localeCompare(right));
+  }
   async connectInternal(name, signal) {
     const configured = this.config.servers?.[name];
     if (!configured) throw new Error(`Unknown MCP server: ${name}`);
@@ -20341,6 +20712,28 @@ var McpManager = class {
     return { name, ok, status: { ...status }, skippedTools };
   }
 };
+function activationMetadata(result) {
+  return {
+    mcpServer: result.name,
+    state: result.status.state,
+    availableTools: result.availableTools,
+    loadedTools: result.registeredTools,
+    deferredTools: result.deferredTools,
+    skippedTools: result.skippedTools
+  };
+}
+function selectRelevantTools(tools, query, limit) {
+  const terms = new Set(query.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu) ?? []);
+  return tools.map((tool) => {
+    const searchable = `${tool.definition.name.replaceAll("_", " ")} ${tool.definition.description}`.toLocaleLowerCase();
+    let score = 0;
+    for (const term of terms) if (searchable.includes(term)) score += term.length;
+    return { tool, score };
+  }).sort((left, right) => right.score - left.score || left.tool.definition.name.localeCompare(right.tool.definition.name)).slice(0, limit).map(({ tool }) => tool);
+}
+function sanitizeCatalogText(value) {
+  return value ? stripAnsi5(value).replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim().slice(0, 200) : "";
+}
 function requestOptions(timeoutMs, signal) {
   return {
     timeout: timeoutMs,
@@ -20850,7 +21243,7 @@ var ExtensionRuntime = class _ExtensionRuntime {
       throw error;
     }
   }
-  async initialize(registry, signal) {
+  async initialize(registry, _signal) {
     if (this.initialized) return;
     if (this.memory) {
       await this.memory.open();
@@ -20862,8 +21255,8 @@ var ExtensionRuntime = class _ExtensionRuntime {
     }
     await this.skills?.discover();
     if (this.mcp) {
-      await this.mcp.connectAll(signal);
-      this.mcp.registerTools(registry);
+      const activationTool = this.mcp.activationTool(registry);
+      if (activationTool) registry.register(activationTool);
     }
     await this.profiles?.discover();
     if (this.config.agents?.enabled && this.profiles && this.options.provider && this.options.contextEngine) {