@wrongstack/core 0.264.0 → 0.267.0

package/dist/execution/index.js

@@ -1,11 +1,81 @@
+import * as path3 from 'path';
 import { randomUUID, randomBytes, createHash } from 'crypto';
 import * as fs from 'fs/promises';
-import * as path2 from 'path';
 import * as os from 'os';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
 import { EventEmitter } from 'events';
 
+// src/utils/tool-wire-compact.ts
+var TOOL_DESCRIPTION_MAX_CHARS = 640;
+var SCHEMA_DESCRIPTION_MAX_CHARS = 180;
+var compactCache = /* @__PURE__ */ new WeakMap();
+function compactToolDefinitionForWire(tool, opts = {}) {
+  const useDefaultOptions = opts.descriptionMaxChars === void 0 && opts.schemaDescriptionMaxChars === void 0;
+  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
+    const cached = compactCache.get(tool);
+    if (cached) return cached;
+  }
+  const compact = {
+    name: tool.name,
+    description: compactDescription(
+      tool.description ?? "",
+      opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
+    ),
+    inputSchema: compactSchemaDescriptions(
+      tool.inputSchema,
+      opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+    )
+  };
+  if (useDefaultOptions && typeof tool === "object" && tool !== null) {
+    compactCache.set(tool, compact);
+  }
+  return compact;
+}
+function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
+  const compact = compactSchemaNode(schema, maxDescriptionChars);
+  return isRecord(compact) ? compact : { type: "object", properties: {} };
+}
+function compactSchemaNode(node, maxDescriptionChars) {
+  if (Array.isArray(node)) {
+    return node.map((item) => compactSchemaNode(item, maxDescriptionChars));
+  }
+  if (!isRecord(node)) return node;
+  const out = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "description" && typeof value === "string") {
+      out[key] = compactDescription(value, maxDescriptionChars);
+    } else {
+      out[key] = compactSchemaNode(value, maxDescriptionChars);
+    }
+  }
+  return out;
+}
+function compactDescription(text, maxChars) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (normalized.length <= maxChars) return normalized;
+  if (maxChars <= 20) return normalized.slice(0, maxChars);
+  const hardLimit = maxChars - 12;
+  const boundary = findSemanticBoundary(normalized, hardLimit);
+  const head = normalized.slice(0, boundary > 0 ? boundary : hardLimit).trimEnd();
+  return `${head} ...`;
+}
+function findSemanticBoundary(text, limit) {
+  const punctuation = Math.max(
+    text.lastIndexOf(". ", limit),
+    text.lastIndexOf("; ", limit),
+    text.lastIndexOf(": ", limit)
+  );
+  if (punctuation >= Math.floor(limit * 0.45)) return punctuation + 1;
+  const comma = text.lastIndexOf(", ", limit);
+  if (comma >= Math.floor(limit * 0.6)) return comma + 1;
+  const space = text.lastIndexOf(" ", limit);
+  return space >= Math.floor(limit * 0.6) ? space : limit;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/utils/token-estimate.ts
 var RoughTokenEstimate = (text, charsPerToken = 3.5) => Math.max(1, Math.ceil(text.length / charsPerToken));
 var CALIBRATION_GLOBAL_KEY = "__global__";
@@ -25,12 +95,9 @@ function getCachedEstimate(key, compute) {
   const existing = ESTIMATE_CACHE.get(key);
   if (existing !== void 0) return existing;
   if (ESTIMATE_CACHE.size >= ESTIMATE_CACHE_MAX_SIZE) {
-    let evicted = 0;
-    const maxEvict = Math.floor(ESTIMATE_CACHE_MAX_SIZE / 4);
     for (const k of ESTIMATE_CACHE.keys()) {
-      if (evicted >= maxEvict) break;
+      if (ESTIMATE_CACHE.size <= Math.floor(ESTIMATE_CACHE_MAX_SIZE / 2)) break;
       ESTIMATE_CACHE.delete(k);
-      evicted++;
     }
   }
   const estimate = compute(key);
@@ -76,7 +143,8 @@ function estimateMessageTokens(messages) {
 function estimateToolDefTokens(tool) {
   const cached = tool._estDefTokens;
   if (typeof cached === "number" && cached > 0) return cached;
-  return RoughTokenEstimate(tool.name) + RoughTokenEstimate(tool.description ?? "") + RoughTokenEstimate(JSON.stringify(tool.inputSchema));
+  const compact = compactToolDefinitionForWire(tool);
+  return RoughTokenEstimate(tool.name) + RoughTokenEstimate(compact.description) + RoughTokenEstimate(JSON.stringify(compact.inputSchema));
 }
 function estimateRequestTokens(messages, systemPrompt, tools, calibrationKey = CALIBRATION_GLOBAL_KEY) {
   let messagesTokens = 0;
@@ -254,6 +322,79 @@ function isEmptyMessage(msg) {
   if (typeof msg.content === "string") return msg.content.trim().length === 0;
   return msg.content.length === 0;
 }
+var MAX_DIGEST_CHARS = 4e3;
+function createContextEvidenceState() {
+  return {
+    sessionGoals: [],
+    implicitFacts: [],
+    activeErrors: [],
+    toolCalls: [],
+    fileGraph: {},
+    repeatedReads: [],
+    updatedAt: Date.now()
+  };
+}
+function buildContextEvidenceDigest(ctx) {
+  const state = ensureEvidence(ctx);
+  const lines = [];
+  if (state.currentIntent?.text) {
+    lines.push(`intent: ${state.currentIntent.text}`);
+  }
+  const goals = state.sessionGoals.slice(-3);
+  if (goals.length > 0) {
+    lines.push("session_goals:");
+    for (const goal of goals) lines.push(`- ${goal}`);
+  }
+  const activeErrors = state.activeErrors.slice(-5);
+  if (activeErrors.length > 0) {
+    lines.push("active_errors:");
+    for (const err of activeErrors) lines.push(`- ${err}`);
+  }
+  const files = Object.values(state.fileGraph).sort((a, b) => b.writes - a.writes || b.reads - a.reads || a.path.localeCompare(b.path)).slice(0, 12);
+  if (files.length > 0) {
+    lines.push("dependency_graph:");
+    for (const file of files) {
+      const actions = [
+        file.reads > 0 ? `read ${file.reads}x` : "",
+        file.writes > 0 ? `write ${file.writes}x` : ""
+      ].filter(Boolean).join(", ");
+      const refs = file.referenced ? "; referenced by assistant" : "";
+      const via = file.lastToolUseId ? `; last via ${file.lastToolUseId}` : "";
+      lines.push(`- ${file.path} (${actions || "seen"}${refs}${via})`);
+    }
+  }
+  const referenced = state.toolCalls.filter((tool) => tool.status === "referenced").slice(-10);
+  const recentSeen = state.toolCalls.filter((tool) => tool.status === "seen").slice(-5);
+  const trail = [...referenced, ...recentSeen];
+  if (trail.length > 0) {
+    lines.push("tool_trail:");
+    for (const tool of trail) {
+      const size = tool.outputTokens ? `; ~${tool.outputTokens} tokens` : "";
+      const filesText = tool.files.length > 0 ? `; files=${tool.files.slice(0, 4).join(", ")}` : "";
+      const symbolsText = tool.symbols.length > 0 ? `; symbols=${tool.symbols.slice(0, 4).join(", ")}` : "";
+      lines.push(
+        `- ${tool.toolUseId} ${tool.toolName} ${tool.status}: ${tool.summary}${filesText}${symbolsText}${size}`
+      );
+    }
+  }
+  const facts = state.implicitFacts.slice(-8);
+  if (facts.length > 0) {
+    lines.push("implicit_facts:");
+    for (const fact of facts) lines.push(`- ${fact}`);
+  }
+  const digest = lines.join("\n");
+  if (digest.length <= MAX_DIGEST_CHARS) return digest;
+  return `${digest.slice(0, MAX_DIGEST_CHARS)}... [+${digest.length - MAX_DIGEST_CHARS} chars]`;
+}
+function repeatedReadPressure(ctx) {
+  return ensureEvidence(ctx).repeatedReads.reduce((max, item) => Math.max(max, item.count), 0);
+}
+function ensureEvidence(ctx) {
+  if (!ctx.contextEvidence) {
+    ctx.contextEvidence = createContextEvidenceState();
+  }
+  return ctx.contextEvidence;
+}
 
 // src/types/blocks.ts
 function isTextBlock(b) {
@@ -261,7 +402,11 @@ function isTextBlock(b) {
 }
 
 // src/execution/compaction-core.ts
+function compactionDebugEnabled() {
+  return process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1";
+}
 function emitCompactionMetrics(event, metrics) {
+  if (!compactionDebugEnabled()) return;
   console.log(
     JSON.stringify({
       level: "debug",
@@ -296,38 +441,41 @@ function findPreserveStart(messages, preserveK) {
       preserveStart = i;
     }
   }
-  let forwardWalkIterations = 0;
-  let forwardWalkInnerIterations = 0;
-  for (let i = preserveStart; i < messages.length; i++) {
-    forwardWalkIterations++;
-    const m = messages[i];
-    if (!m || typeof m.content === "string" || !Array.isArray(m.content)) continue;
-    const hasToolUse3 = m.content.some((b) => {
-      forwardWalkInnerIterations++;
-      return b.type === "tool_use";
+  let pairRepairIterations = 0;
+  let pairRepairInnerIterations = 0;
+  while (preserveStart > 0) {
+    pairRepairIterations++;
+    const first = messages[preserveStart];
+    const prev = messages[preserveStart - 1];
+    if (!first || !prev || first.role !== "user" || prev.role !== "assistant") break;
+    if (typeof first.content === "string" || typeof prev.content === "string") break;
+    const resultIds = /* @__PURE__ */ new Set();
+    for (const block of first.content) {
+      pairRepairInnerIterations++;
+      if (block.type === "tool_result") resultIds.add(block.tool_use_id);
+    }
+    if (resultIds.size === 0) break;
+    const hasMatchingUse = prev.content.some((block) => {
+      pairRepairInnerIterations++;
+      return block.type === "tool_use" && resultIds.has(block.id);
     });
-    if (hasToolUse3 && i + 1 < messages.length) {
-      const next = messages[i + 1];
-      if (next && next.role === "user" && typeof next.content !== "string" && Array.isArray(next.content) && next.content.some((b) => {
-        forwardWalkInnerIterations++;
-        return b.type === "tool_result";
-      })) {
-        preserveStart = i + 1;
-      }
-    }
+    if (!hasMatchingUse) break;
+    preserveStart--;
+  }
+  if (compactionDebugEnabled()) {
+    console.log(
+      JSON.stringify({
+        level: "debug",
+        event: "compaction.find_preserve_start.ended",
+        messageCount: messages.length,
+        preserveK,
+        preserveStart,
+        pairRepairIterations,
+        pairRepairInnerIterations,
+        pairRepairInnerPerOuter: pairRepairIterations > 0 ? pairRepairInnerIterations / pairRepairIterations : 0
+      })
+    );
   }
-  console.log(
-    JSON.stringify({
-      level: "debug",
-      event: "compaction.find_preserve_start.ended",
-      messageCount: messages.length,
-      preserveK,
-      preserveStart,
-      forwardWalkIterations,
-      forwardWalkInnerIterations,
-      forwardWalkInnerPerOuter: forwardWalkIterations > 0 ? forwardWalkInnerIterations / forwardWalkIterations : 0
-    })
-  );
   return preserveStart;
 }
 function eliseOldToolResults(messages, opts) {
@@ -341,7 +489,8 @@ function eliseOldToolResults(messages, opts) {
     if (!msg || !Array.isArray(msg.content)) continue;
     for (const b of msg.content) {
       fastPathInnerIterations++;
-      if (b.type === "tool_result" && estimateToolResultTokens(b.content) >= opts.eliseThreshold) {
+      const oversized = b.type === "tool_result" && estimateToolResultTokens(b.content) >= opts.eliseThreshold || b.type === "tool_use" && estimateToolInputTokens(b.input) >= opts.eliseThreshold;
+      if (oversized) {
         hasOversized = true;
         break;
       }
@@ -375,6 +524,13 @@ function eliseOldToolResults(messages, opts) {
     }
     const original = msg.content;
     const newContent = original.map((b) => {
+      if (b.type === "tool_use") {
+        const tokens2 = estimateToolInputTokens(b.input);
+        if (tokens2 < opts.eliseThreshold) return b;
+        const elidedInput = summarizeToolUseInputElision(b, tokens2);
+        saved += Math.max(0, tokens2 - estimateToolInputTokens(elidedInput));
+        return { ...b, input: elidedInput };
+      }
       if (b.type !== "tool_result") return b;
       const tokens = estimateToolResultTokens(b.content);
       if (tokens < opts.eliseThreshold) return b;
@@ -382,7 +538,7 @@ function eliseOldToolResults(messages, opts) {
       const elided = {
         type: "tool_result",
         tool_use_id: b.tool_use_id,
-        content: `[elided: ~${tokens} tokens]`,
+        content: summarizeToolResultElision(b, tokens),
         is_error: b.is_error
       };
       return elided;
@@ -394,7 +550,7 @@ function eliseOldToolResults(messages, opts) {
       changed = true;
     }
     fullPassInnerIterations += original.length;
-    if (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1") {
+    if (compactionDebugEnabled()) {
       const ratio = fullPassInnerIterations / fullPassIterations;
       if (ratio > 10) {
         console.error(
@@ -422,6 +578,65 @@ function eliseOldToolResults(messages, opts) {
   });
   return { messages: changed ? next : messages, saved, changed };
 }
+function summarizeToolUseInputElision(block, tokens) {
+  const fields = {};
+  for (const [key, value] of Object.entries(block.input ?? {})) {
+    fields[key] = summarizeToolUseInputValue(value);
+  }
+  return {
+    __elided_tool_input: `~${tokens} tokens; original arguments are in the session log`,
+    tool: block.name,
+    fields
+  };
+}
+function summarizeToolUseInputValue(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const oneLine = value.replace(/\s+/g, " ").trim();
+    return oneLine.length <= 160 ? oneLine : `${oneLine.slice(0, 120)}...(${oneLine.length} chars)`;
+  }
+  if (Array.isArray(value)) {
+    return `[array:${value.length}]`;
+  }
+  if (typeof value === "object") {
+    const keys = Object.keys(value);
+    return `[object:${keys.slice(0, 8).join(",")}${keys.length > 8 ? ",..." : ""}]`;
+  }
+  return String(value);
+}
+function summarizeToolResultElision(block, tokens) {
+  const parts = [`elided: ~${tokens} tokens`];
+  if (block.name) parts.push(`tool=${block.name}`);
+  const files = extractPathHints(block.content).slice(0, 5);
+  if (files.length > 0) parts.push(`files=${files.join(", ")}`);
+  const error = firstErrorLine(block.content);
+  if (error) parts.push(`error=${error}`);
+  return `[${parts.join("; ")}]`;
+}
+function extractPathHints(content) {
+  const text = typeof content === "string" ? content : JSON.stringify(content);
+  const out = /* @__PURE__ */ new Set();
+  const re = /(?:(?:[A-Za-z]:)?[./\\]?[\w@.-]+(?:[\\/][\w@(). -]+)+\.[A-Za-z0-9]{1,12})/g;
+  for (const match of text.matchAll(re)) {
+    const clean = match[0]?.replace(/\\/g, "/").replace(/^["'`]+|["'`),;:]+$/g, "");
+    if (clean && clean.length <= 220) out.add(clean);
+    if (out.size >= 5) break;
+  }
+  return [...out];
+}
+function firstErrorLine(content) {
+  const text = typeof content === "string" ? content : JSON.stringify(content);
+  for (const line of text.split(/\r?\n/)) {
+    if (!/\b(error|exception|failed|failure|fatal|panic|timeout|denied|enoent|eacces|eperm)\b/i.test(
+      line
+    ))
+      continue;
+    const trimmed = line.replace(/\s+/g, " ").trim();
+    if (trimmed) return trimmed.slice(0, 180);
+  }
+  return void 0;
+}
 function buildLosslessDigest(messages) {
   const lines = [];
   for (const m of messages) {
@@ -532,15 +747,15 @@ function buildSmartDigest(messages) {
     lines.push(`[${m.role}]: ${display}${marker}`);
   }
   if (noiseCount > 0) {
-    lines.push(`[system]: ${noiseCount} low-importance turn(s) collapsed (repeated failures / pure tool I/O)`);
+    lines.push(
+      `[system]: ${noiseCount} low-importance turn(s) collapsed (repeated failures / pure tool I/O)`
+    );
   }
   return lines.join("\n");
 }
 function countToolBlocks(m) {
   if (typeof m.content === "string") return 0;
-  return m.content.filter(
-    (b) => b.type === "tool_use" || b.type === "tool_result"
-  ).length;
+  return m.content.filter((b) => b.type === "tool_use" || b.type === "tool_result").length;
 }
 function firstSentence(text) {
   const trimmed = text.trim();
@@ -609,10 +824,12 @@ var HybridCompactor = class {
     if (elide.changed) ctx.state.replaceMessages(elide.messages);
     if (elide.saved > 0) reductions.push({ phase: "elision", saved: elide.saved });
     let collapsedDigest;
+    let evidenceDigest;
     if (opts.aggressive) {
       const phase2 = this.collapseAncientTurns(ctx, preserveK);
       if (phase2.saved > 0) reductions.push({ phase: "summary", saved: phase2.saved });
       collapsedDigest = phase2.digest;
+      evidenceDigest = phase2.evidenceDigest;
     }
     const repaired = repairToolUseAdjacency(ctx.messages);
     if (repaired.report.changed) {
@@ -620,6 +837,11 @@ var HybridCompactor = class {
     }
     const afterTokens = estimateMessages(ctx.messages);
     const afterFull = this.estimateFullRequest(ctx);
+    const quality = checkCompactionQuality(ctx, {
+      collapsedDigest,
+      evidenceDigest,
+      reduced: beforeTokens > afterTokens || beforeFull > afterFull
+    });
     return {
       before: beforeTokens,
       after: afterTokens,
@@ -627,6 +849,8 @@ var HybridCompactor = class {
       fullRequestTokensAfter: afterFull,
       reductions,
       collapsedDigest,
+      evidenceDigest,
+      quality,
       repaired: repaired.report.changed ? {
         removedToolUses: repaired.report.removedToolUses,
         removedToolResults: repaired.report.removedToolResults,
@@ -668,7 +892,13 @@ var HybridCompactor = class {
     if (boundary <= 0) return { saved: 0 };
     const removed = messages.slice(0, boundary);
     const removedTokens = estimateMessages(removed);
-    const digest = this.smart ? buildSmartDigest(removed) || `${removed.length} earlier turns (no textual content; tool I/O omitted \u2014 see session log)` : buildLosslessDigest(removed) || `${removed.length} earlier turns (no textual content; tool I/O omitted \u2014 see session log)`;
+    const historyDigest = this.smart ? buildSmartDigest(removed) || `${removed.length} earlier turns (no textual content; tool I/O omitted; see session log)` : buildLosslessDigest(removed) || `${removed.length} earlier turns (no textual content; tool I/O omitted; see session log)`;
+    const evidenceDigest = buildContextEvidenceDigest(ctx);
+    const digest = evidenceDigest ? `[context_state]
+${evidenceDigest}
+
+[prior_history]
+${historyDigest}` : historyDigest;
     const summaryMsg = {
       role: "system",
       content: `[prior_turns_digest: ${digest}]`
@@ -677,10 +907,29 @@ var HybridCompactor = class {
     ctx.state.replaceMessages([summaryMsg, ...tail]);
     return {
       saved: Math.max(0, removedTokens - estimateMessages([summaryMsg])),
-      digest
+      digest,
+      evidenceDigest: evidenceDigest || void 0
     };
   }
 };
+function checkCompactionQuality(ctx, opts) {
+  const evidence = ctx.contextEvidence;
+  const digest = `${opts.collapsedDigest ?? ""}
+${opts.evidenceDigest ?? ""}`;
+  const hasIntent = Boolean(evidence?.currentIntent?.text || /\b(intent|goal|session_goals)\b/i.test(digest));
+  const hasPathTrail = Boolean(
+    Object.keys(evidence?.fileGraph ?? {}).length > 0 || (evidence?.toolCalls.length ?? 0) > 0 || /\b(dependency_graph|tool_trail|files=)\b/i.test(digest)
+  );
+  const issues = [];
+  if (opts.reduced && !hasIntent) issues.push("missing intent anchor");
+  if (opts.reduced && !hasPathTrail) issues.push("missing tool/path trail");
+  return {
+    ok: issues.length === 0,
+    hasIntent,
+    hasPathTrail,
+    issues
+  };
+}
 function readContextWindowPolicy(ctx) {
   const policy = ctx.meta?.["contextWindowPolicy"];
   if (!policy || typeof policy !== "object") return null;
@@ -801,7 +1050,12 @@ var IntelligentCompactor = class {
     };
     const ac = ctx.signal ? void 0 : new AbortController();
     const signal = ctx.signal ?? ac?.signal;
-    const res = await this.provider.complete(req, { signal });
+    let res;
+    try {
+      res = await this.provider.complete(req, { signal });
+    } finally {
+      ac?.abort();
+    }
     const textBlocks = res.content.filter(isTextBlock);
     return textBlocks.map((b) => b.text).join("\n").trim() || "(empty summary)";
   }
@@ -845,9 +1099,9 @@ Rules:
 - If unsure, keep rather than collapse (errors are more costly than waste)
 
 Return ONLY the JSON object, no markdown, no explanation outside the JSON.`;
-function formatMessages(messages, maxChars = 8e3) {
+function formatMessages(messages, maxTokens = 2048) {
   const lines = [];
-  let used = 0;
+  let usedTokens = 0;
   for (let i = 0; i < messages.length; i++) {
     const m = expectDefined(messages[i]);
     const role = m.role.padEnd(10, " ");
@@ -859,13 +1113,14 @@ function formatMessages(messages, maxChars = 8e3) {
       text = content.filter(isTextBlock).map((b) => b.text).join(" ");
       const toolUses = content.filter((b) => b.type === "tool_use");
       if (toolUses.length > 0) {
-        text += ` [tools: ${toolUses.map((b) => b.name).join(", ")}]`;
+        text += ` [tools: ${toolUses.map((b) => b.name).filter(Boolean).join(", ")}]`;
       }
     }
     const line = `[${i}][${role}]: ${text}`;
-    if (used + line.length > maxChars) break;
+    const lineTokens = estimateTextTokens(line);
+    if (usedTokens + lineTokens > maxTokens) break;
     lines.push(line);
-    used += line.length;
+    usedTokens += lineTokens;
   }
   return lines.join("\n");
 }
@@ -874,20 +1129,29 @@ var LLMSelector = class {
   model;
   maxContextTokens;
   systemPrompt;
+  maxOutputTokens;
   constructor(opts) {
     this.provider = opts.provider;
     this.model = opts.model ?? "unknown";
+    if (this.model === "unknown" && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
+      console.warn(
+        "[LLMSelector] model not set \u2014 selector will use the provider default. Set `model` explicitly in LLMSelectorOptions to silence this warning."
+      );
+    }
     this.maxContextTokens = opts.maxContextTokens ?? 4e4;
     this.systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.maxOutputTokens = opts.maxOutputTokens ?? 1024;
   }
   async select(messages, maxToKeep) {
     const effectiveBudget = Math.min(maxToKeep, this.maxContextTokens);
-    const historyText = formatMessages(messages);
     const totalTokens = estimateMessageTokens(messages);
     const systemText = `${this.systemPrompt}
 
 Conversation (${messages.length} messages, ~${totalTokens} tokens, budget: ${effectiveBudget}):
 `;
+    const systemTokens = estimateTextTokens(systemText);
+    const historyBudget = Math.max(512, effectiveBudget - systemTokens - this.maxOutputTokens);
+    const historyText = formatMessages(messages, historyBudget);
     const budgetInstruction = totalTokens > effectiveBudget ? `
 
 IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiveBudget}). You MUST collapse enough to fit. Prefer collapsing older/lower-importance ranges.` : "";
@@ -895,18 +1159,26 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       model: this.model,
       system: [{ type: "text", text: systemText + budgetInstruction }],
       messages: [{ role: "user", content: historyText }],
-      maxTokens: 1024
+      maxTokens: this.maxOutputTokens
     };
     let raw;
+    const ac = new AbortController();
     try {
-      const ac = new AbortController();
-      const res = await this.provider.complete(req, { signal: ac.signal });
+      const timeoutSignal = AbortSignal.timeout(3e4);
+      const res = await this.provider.complete(req, {
+        signal: AbortSignal.any([ac.signal, timeoutSignal])
+      });
       const textBlocks = res.content.filter(isTextBlock);
       raw = textBlocks.map((b) => b.text).join("\n").trim();
-    } catch (_err) {
+    } catch (err) {
+      if (err instanceof Error) {
+        console.warn("[LLMSelector] selector call failed, using recency fallback:", err.message);
+      }
       return this.fallbackSelect(messages, effectiveBudget);
+    } finally {
+      ac.abort();
     }
-    return this.parseSelectorOutput(raw, messages.length);
+    return this.parseSelectorOutput(raw, messages);
   }
   fallbackSelect(messages, budget) {
     const toKeep = [];
@@ -933,34 +1205,63 @@ IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiv
       reasoning: `Fallback: kept last ${messages.length - startIdx} messages within ${budget} token budget`
     };
   }
-  parseSelectorOutput(raw, messageCount) {
+  /**
+   * Parse and validate the raw LLM output into a SelectorResult.
+   * Falls back to recency-based selection if the LLM output is malformed,
+   * out-of-bounds, or internally inconsistent.
+   */
+  parseSelectorOutput(raw, messages) {
+    const messageCount = messages.length;
+    if (messageCount === 0) {
+      return { kept: [], collapsed: [], reasoning: "empty session" };
+    }
     const jsonStart = raw.indexOf("{");
     const jsonEnd = raw.lastIndexOf("}");
     if (jsonStart === -1 || jsonEnd === -1) {
-      return this.fallbackSelect(
-        Array.from({ length: messageCount }, () => ({ role: "user", content: "" })),
-        this.maxContextTokens
-      );
+      return this.fallbackSelect(messages, this.maxContextTokens);
     }
     let parsed;
     try {
       parsed = JSON.parse(raw.slice(jsonStart, jsonEnd + 1));
     } catch {
-      return this.fallbackSelect(
-        Array.from({ length: messageCount }, () => ({ role: "user", content: "" })),
-        this.maxContextTokens
-      );
+      return this.fallbackSelect(messages, this.maxContextTokens);
     }
     const obj = parsed;
-    const kept = obj.kept ?? [];
-    const collapsed = obj.collapsed ?? [];
-    return {
-      kept: kept.map((k) => ({
+    const keptRaw = obj.kept ?? [];
+    const collapsedRaw = obj.collapsed ?? [];
+    const kept = [];
+    for (const k of keptRaw) {
+      if (typeof k.from !== "number" || typeof k.to !== "number" || k.from < 0 || k.to >= messageCount || k.from > k.to) {
+        return this.fallbackSelect(messages, this.maxContextTokens);
+      }
+      kept.push({
         from: k.from,
         to: k.to,
         importance: k.importance ?? "medium"
-      })),
-      collapsed: collapsed.map((c) => ({ from: c.from, to: c.to, summary: c.summary })),
+      });
+    }
+    const collapsed = [];
+    for (const c of collapsedRaw) {
+      if (typeof c.from !== "number" || typeof c.to !== "number" || c.from < 0 || c.to >= messageCount || c.from > c.to) {
+        return this.fallbackSelect(messages, this.maxContextTokens);
+      }
+      collapsed.push({ from: c.from, to: c.to, summary: c.summary });
+    }
+    const allRanges = [...kept, ...collapsed];
+    for (let i = 0; i < allRanges.length; i++) {
+      const a = allRanges[i];
+      if (!a) continue;
+      for (let j = i + 1; j < allRanges.length; j++) {
+        const b = allRanges[j];
+        if (!b) continue;
+        if (a.from <= b.to && a.to >= b.from) {
+          return this.fallbackSelect(messages, this.maxContextTokens);
+        }
+      }
+    }
+    return {
+      kept,
+      collapsed,
       reasoning: typeof obj.reasoning === "string" ? obj.reasoning : ""
     };
   }
@@ -980,14 +1281,19 @@ var SelectiveCompactor = class {
   summarizerPrompt;
   constructor(opts) {
     this.provider = opts.provider;
-    this.selector = opts.selector ?? new LLMSelector({ provider: opts.provider, model: opts.selectorModel });
+    this.selector = opts.selector ?? new LLMSelector({ provider: opts.provider, model: opts.selectorModel, maxOutputTokens: opts.selectorMaxOutputTokens });
     this.warnThreshold = opts.warnThreshold ?? 0.6;
     this.softThreshold = opts.softThreshold ?? 0.75;
     this.hardThreshold = opts.hardThreshold ?? 0.9;
     this.maxContext = opts.maxContext ?? 128e3;
     this.preserveK = opts.preserveK ?? 4;
     this.eliseThreshold = opts.eliseThreshold ?? 500;
-    this.summarizerModel = opts.summarizerModel ?? opts.selectorModel ?? "unknown";
+    this.summarizerModel = opts.summarizerModel ?? opts.selectorModel;
+    if (this.summarizerModel === void 0 && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
+      console.warn(
+        "[SelectiveCompactor] summarizerModel not set \u2014 will fall back to ctx.model at summarize time. Set `summarizerModel` explicitly to silence this warning."
+      );
+    }
     this.summarizerPrompt = opts.summarizerPrompt ?? "You are a context summarizer. Given a list of messages, produce a concise summary that preserves all factual information, decisions, file changes, and state changes. Do not add commentary or opinions.";
   }
   async compact(ctx, opts = {}) {
@@ -1093,14 +1399,15 @@ var SelectiveCompactor = class {
 Summarize the following message range:`;
     const body = messages.map((m, i) => `[${i}] ${m.role}: ${this.messagePreview(m)}`).join("\n");
     const req = {
-      model: this.summarizerModel,
+      model: this.summarizerModel ?? ctx.model,
       system: [{ type: "text", text: systemText }],
       messages: [{ role: "user", content: body }],
       maxTokens: 512
     };
     try {
+      const timeoutSignal = AbortSignal.timeout(3e4);
       const res = await this.provider.complete(req, {
-        signal: ctx.signal ?? new AbortController().signal
+        signal: AbortSignal.any([ctx.signal, timeoutSignal])
       });
       return res.content.filter(isTextBlock).map((b) => b.text).join("\n").trim() || "(empty)";
     } catch {
@@ -1159,27 +1466,16 @@ Summarize the following message range:`;
     if (typeof m.content === "string") return m.content.trim().length > 0;
     return m.content.some((b) => b.type === "text" && b.text.trim().length > 0);
   }
+  /**
+   * Estimate message-array tokens via the shared `estimateMessages` primitive
+   * so SelectiveCompactor's before/after/load figures agree with the
+   * middleware threshold math and the other compactors. Previously this used a
+   * private `ceil(len/3.5)` walk that diverged from the calibrated shared
+   * estimator, causing the selective `load`/`targetBudget` comparison to mix
+   * two incompatible token scales.
+   */
   estimateTokens(messages) {
-    let total = 0;
-    for (const m of messages) {
-      if (typeof m.content === "string") {
-        total += this.roughTokenEstimate(m.content);
-      } else {
-        for (const b of m.content) {
-          if (b.type === "text") total += this.roughTokenEstimate(b.text);
-          else if (b.type === "tool_use") total += this.roughTokenEstimate(JSON.stringify(b.input));
-          else if (b.type === "tool_result") {
-            total += this.roughTokenEstimate(
-              typeof b.content === "string" ? b.content : JSON.stringify(b.content)
-            );
-          }
-        }
-      }
-    }
-    return total;
-  }
-  roughTokenEstimate(text) {
-    return Math.max(1, Math.ceil(text.length / 3.5));
+    return estimateMessages(messages);
   }
 };
 
@@ -1234,6 +1530,7 @@ var ProviderBackedCompactor = class {
       return new SelectiveCompactor({
         ...common,
         selectorModel: this.opts.summarizerModel,
+        selectorMaxOutputTokens: this.opts.selectorMaxOutputTokens,
         summarizerModel: this.opts.summarizerModel
       });
     }
@@ -1250,10 +1547,19 @@ function readPolicy(ctx) {
   if (typeof candidate.preserveK !== "number" || !candidate.thresholds) return null;
   return candidate;
 }
+
+// src/utils/assert-never.ts
+function assertNever(x, message) {
+  const err = new Error(
+    `Unhandled case: ${JSON.stringify(x)}`
+  );
+  err.name = "AssertNeverError";
+  throw err;
+}
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path2.dirname(targetPath);
+  const dir = path3.dirname(targetPath);
   await fs.mkdir(dir, { recursive: true });
-  const tmp = path2.join(dir, `.${path2.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const tmp = path3.join(dir, `.${path3.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
       await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
@@ -1306,7 +1612,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve2) => setTimeout(resolve2, delays[i]));
+      await new Promise((resolve3) => setTimeout(resolve3, delays[i]));
     }
   }
   throw lastErr;
@@ -1317,136 +1623,17 @@ function toErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-// src/utils/string.ts
-function truncate(s, max) {
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
-}
-function projectHash(absRoot) {
-  return createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 12);
-}
-function projectSlug(absRoot) {
-  const base = slugify(path2.basename(absRoot));
-  const hash = createHash("sha256").update(path2.resolve(absRoot)).digest("hex").slice(0, 6);
-  return `${base}-${hash}`;
-}
-function slugify(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
-}
-function wstackGlobalRoot() {
-  const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path2.resolve(fromEnv);
-  return path2.join(os.homedir(), ".wrongstack");
-}
-function resolveWstackPaths(opts) {
-  const globalRoot = opts.globalRoot ?? (opts.userHome ? path2.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
-  const hash = projectHash(opts.projectRoot);
-  const slug = projectSlug(opts.projectRoot);
-  const projectDir = path2.join(globalRoot, "projects", slug);
-  return {
-    globalRoot,
-    configDir: globalRoot,
-    globalConfig: path2.join(globalRoot, "config.json"),
-    secretsKey: path2.join(globalRoot, ".key"),
-    globalMemory: path2.join(globalRoot, "memory.md"),
-    globalSkills: path2.join(globalRoot, "skills"),
-    globalPrompts: path2.join(globalRoot, "prompts"),
-    cacheDir: path2.join(globalRoot, "cache"),
-    modelsCache: path2.join(globalRoot, "cache", "models.dev.json"),
-    modelsOverlayCache: path2.join(globalRoot, "cache", "models-overlay.json"),
-    historyFile: path2.join(globalRoot, "history"),
-    logFile: path2.join(globalRoot, "logs", "wrongstack.log"),
-    projectDir,
-    projectCodebaseIndex: path2.join(projectDir, "codebase-index"),
-    projectMemory: path2.join(projectDir, "memory.md"),
-    projectSessions: path2.join(projectDir, "sessions"),
-    projectTrust: path2.join(projectDir, "trust.json"),
-    projectMeta: path2.join(projectDir, "meta.json"),
-    projectLocalConfig: path2.join(projectDir, "config.local.json"),
-    inProjectConfig: path2.join(opts.projectRoot, ".wrongstack", "config.json"),
-    inProjectAgentsFile: path2.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
-    inProjectSkills: path2.join(opts.projectRoot, ".wrongstack", "skills"),
-    inProjectWorktrees: path2.join(opts.projectRoot, ".wrongstack", "worktrees"),
-    projectHash: hash,
-    projectSlug: slug,
-    projectGoal: path2.join(projectDir, "goal.json"),
-    projectSpecs: path2.join(projectDir, "specs"),
-    projectTaskGraphs: path2.join(projectDir, "task-graphs"),
-    projectSddSession: path2.join(projectDir, "sdd-session.json"),
-    projectPlan: path2.join(projectDir, "plan.json"),
-    projectAutophase: path2.join(projectDir, "autophase"),
-    syncConfig: path2.join(globalRoot, "sync.json")
-  };
-}
-
-// src/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-
-// src/utils/assert-never.ts
-function assertNever(x, message) {
-  const err = new Error(
-    `Unhandled case: ${JSON.stringify(x)}`
-  );
-  err.name = "AssertNeverError";
-  throw err;
-}
-
-// src/utils/tool-output-serializer.ts
-function createToolOutputSerializer(opts = {}) {
-  const capBytes = opts.perIterationOutputCapBytes ?? 1e5;
-  function serialize(value) {
-    if (typeof value === "string") return value;
-    if (value === null || value === void 0) return "";
-    if (typeof value === "object") {
-      if (Array.isArray(value)) return value.map(serialize).join("\n");
-      if ("text" in value) {
-        const t = value.text;
-        return typeof t === "string" ? t : JSON.stringify(value, null, 2);
-      }
-      try {
-        return JSON.stringify(value, null, 2);
-      } catch {
-        return String(value);
-      }
-    }
-    return String(value);
-  }
-  function enforceCap(text, remainingBudget) {
-    if (remainingBudget <= 0) {
-      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
-    }
-    const textBytes = Buffer.byteLength(text, "utf8");
-    if (textBytes <= remainingBudget) {
-      return { text, newBudget: remainingBudget - textBytes };
-    }
-    const marker = `
-\u2026[truncated ${textBytes - remainingBudget} bytes]\u2026
-`;
-    const markerBytes = Buffer.byteLength(marker, "utf8");
-    const available = remainingBudget - markerBytes;
-    if (available <= 0) {
-      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
-    }
-    const half = Math.floor(available / 2);
-    const first = text.slice(0, half);
-    const second = text.slice(text.length - half);
-    return { text: `${first}${marker}${second}`, newBudget: 0 };
-  }
-  return { serialize, enforceCap, capBytes };
-}
-
 // src/utils/json-schema-validate.ts
 function validateAgainstSchema(value, schema) {
   const errors = [];
   walk(value, schema, "", errors);
   return { ok: errors.length === 0, errors };
 }
-function walk(value, schema, path4, errors) {
+function walk(value, schema, path6, errors) {
   if (schema.enum !== void 0) {
     if (!schema.enum.some((e) => deepEqual(e, value))) {
       errors.push({
-        path: path4 || "<root>",
+        path: path6 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -1455,7 +1642,7 @@ function walk(value, schema, path4, errors) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path4 || "<root>",
+        path: path6 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)}`
       });
       return;
@@ -1465,20 +1652,20 @@ function walk(value, schema, path4, errors) {
     const obj = value;
     for (const req of schema.required ?? []) {
       if (!(req in obj)) {
-        errors.push({ path: joinPath(path4, req), message: "required property missing" });
+        errors.push({ path: joinPath(path6, req), message: "required property missing" });
       }
     }
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path4, key), errors);
+          walk(obj[key], subSchema, joinPath(path6, key), errors);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path4}[${i}]`, errors);
+      walk(value[i], schema.items, `${path6}[${i}]`, errors);
     }
   }
 }
@@ -1568,6 +1755,714 @@ function compileUserRegex(pattern, flags) {
   }
 }
 
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+
+// src/utils/string.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
+}
+
+// src/utils/tool-output-serializer.ts
+var DEFAULT_LIST_LIMIT = 500;
+var LOG_ENTRY_LIMIT = 200;
+var INLINE_LIMIT = 240;
+var GREP_FILE_LIMIT = 80;
+var GREP_MATCHES_PER_FILE = 3;
+var DIFF_INLINE_LINE_LIMIT = 260;
+var DIFF_HUNK_LIMIT = 8;
+var DIFF_HUNK_CONTEXT = 14;
+function createToolOutputSerializer(opts = {}) {
+  const capBytes = opts.perIterationOutputCapBytes ?? 1e5;
+  function serialize(value, context = {}) {
+    if (typeof value === "string") return value;
+    if (value === null || value === void 0) return "";
+    if (typeof value === "object") {
+      if (Array.isArray(value)) return value.map((item) => serialize(item)).join("\n");
+      if (context.toolName) {
+        const compact = renderToolObject(context.toolName, value, context.input);
+        if (compact !== void 0) return compact;
+        return renderGenericToolObject(context.toolName, value);
+      }
+      if ("text" in value) {
+        const t = value.text;
+        return typeof t === "string" ? t : JSON.stringify(value, null, 2);
+      }
+      try {
+        return JSON.stringify(value, null, 2);
+      } catch {
+        return String(value);
+      }
+    }
+    return String(value);
+  }
+  function enforceCap(text, remainingBudget) {
+    if (remainingBudget <= 0) {
+      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+    }
+    const textBytes = Buffer.byteLength(text, "utf8");
+    if (textBytes <= remainingBudget) {
+      return { text, newBudget: remainingBudget - textBytes };
+    }
+    const marker = `
+\u2026[truncated ${textBytes - remainingBudget} bytes]\u2026
+`;
+    const markerBytes = Buffer.byteLength(marker, "utf8");
+    const available = remainingBudget - markerBytes;
+    if (available <= 0) {
+      return { text: "[truncated: iteration output cap exceeded]", newBudget: 0 };
+    }
+    const half = Math.floor(available / 2);
+    const first = text.slice(0, half);
+    const second = text.slice(text.length - half);
+    return { text: `${first}${marker}${second}`, newBudget: 0 };
+  }
+  return { serialize, enforceCap, capBytes };
+}
+function renderToolObject(toolName, obj, input) {
+  if (toolName === "read" && typeof obj["text"] === "string") {
+    return joinSections([
+      renderHeader(
+        `read: ${stringFromInput(input, "path") ?? stringField(obj, "path") ?? "<unknown>"}`,
+        {
+          offset: numberFromInput(input, "offset"),
+          limit: numberFromInput(input, "limit"),
+          total_lines: obj["total_lines"],
+          encoding: obj["encoding"],
+          truncated: obj["truncated"],
+          cached: obj["cached"],
+          note: obj["note"]
+        }
+      ),
+      obj["text"]
+    ]);
+  }
+  if (toolName === "grep" && Array.isArray(obj["matches"])) {
+    const matches = stringArrayField(obj, "matches");
+    return joinSections([
+      renderHeader(`grep: ${stringFromInput(input, "pattern") ?? "<pattern>"}`, {
+        path: stringFromInput(input, "path"),
+        glob: stringFromInput(input, "glob"),
+        mode: stringFromInput(input, "output_mode"),
+        count: obj["count"],
+        shown: matches.length,
+        truncated: obj["truncated"],
+        used: obj["used"]
+      }),
+      renderGrepMatches(matches, stringFromInput(input, "output_mode"))
+    ]);
+  }
+  if (toolName === "patch" && Array.isArray(obj["files"])) {
+    const files = stringArrayField(obj, "files");
+    return joinSections([
+      renderHeader("patch", {
+        applied: obj["applied"],
+        rejected: obj["rejected"],
+        files: files.length,
+        dry_run: obj["dry_run"]
+      }),
+      typeof obj["message"] === "string" ? `message:
+${obj["message"]}` : void 0,
+      files.length > 0 ? `files:
+${renderStringList(files)}` : void 0
+    ]);
+  }
+  if (toolName === "glob" && Array.isArray(obj["files"])) {
+    const files = stringArrayField(obj, "files");
+    return joinSections([
+      renderHeader(
+        `${toolName}: ${stringFromInput(input, "pattern") ?? stringFromInput(input, "files") ?? stringFromInput(input, "path") ?? ""}`.trim(),
+        {
+          path: stringFromInput(input, "path"),
+          files: files.length,
+          truncated: obj["truncated"]
+        }
+      ),
+      renderStringList(files, "(no files)")
+    ]);
+  }
+  if (toolName === "tree" && typeof obj["tree"] === "string") {
+    return joinSections([
+      renderHeader(
+        `tree: ${stringField(obj, "path") ?? stringFromInput(input, "path") ?? "<cwd>"}`,
+        {
+          total_files: obj["total_files"],
+          total_dirs: obj["total_dirs"],
+          truncated: obj["truncated"]
+        }
+      ),
+      obj["tree"]
+    ]);
+  }
+  if (toolName === "fetch" && typeof obj["content"] === "string") {
+    return joinSections([
+      renderHeader(
+        `fetch: ${stringField(obj, "url") ?? stringFromInput(input, "url") ?? "<url>"}`,
+        {
+          status: obj["status"],
+          content_type: obj["content_type"]
+        }
+      ),
+      obj["content"]
+    ]);
+  }
+  if (toolName === "replace" && Array.isArray(obj["results"])) {
+    const results = obj["results"].filter(isRecord2);
+    const sections = [
+      renderHeader("replace", {
+        files_modified: obj["files_modified"],
+        total_replacements: obj["total_replacements"],
+        dry_run: obj["dry_run"]
+      })
+    ];
+    for (const r of results.slice(0, DEFAULT_LIST_LIMIT)) {
+      sections.push(
+        joinSections([
+          renderHeader(`file: ${stringField(r, "path") ?? "<unknown>"}`, {
+            replacements: r["replacements"]
+          }),
+          typeof r["diff"] === "string" ? r["diff"] : void 0
+        ])
+      );
+    }
+    if (results.length > DEFAULT_LIST_LIMIT) {
+      sections.push(`[serializer omitted ${results.length - DEFAULT_LIST_LIMIT} result item(s)]`);
+    }
+    return joinSections(sections);
+  }
+  if (typeof obj["diff"] === "string") {
+    const diff = obj["diff"];
+    return joinSections([
+      renderHeader(toolName, {
+        path: obj["path"],
+        replacements: obj["replacements"],
+        bytes_written: obj["bytes_written"],
+        created: obj["created"],
+        note: obj["note"],
+        files: Array.isArray(obj["files"]) ? obj["files"].length : void 0,
+        truncated: obj["truncated"],
+        mode: obj["mode"]
+      }),
+      compactDiff(diff)
+    ]);
+  }
+  if (toolName === "test" && typeof obj["output"] === "string") {
+    return renderTestOutput(obj, input);
+  }
+  if ((toolName === "typecheck" || toolName === "lint" || toolName === "format") && typeof obj["output"] === "string") {
+    return renderVerifierOutput(toolName, obj, input);
+  }
+  if (hasCommandOutputShape(obj)) {
+    return renderCommandOutput(toolName, obj, input);
+  }
+  if (toolName === "json" && typeof obj["formatted"] === "string") {
+    return joinSections([
+      renderHeader("json", {
+        type: obj["type"],
+        keys: Array.isArray(obj["keys"]) ? obj["keys"].length : void 0,
+        query: stringFromInput(input, "query"),
+        error: obj["error"]
+      }),
+      obj["formatted"]
+    ]);
+  }
+  if (toolName === "logs" && Array.isArray(obj["entries"])) {
+    const entries = obj["entries"].filter(isRecord2);
+    const lines = entries.slice(0, LOG_ENTRY_LIMIT).map((entry) => {
+      const ts = stringField(entry, "timestamp") ?? "";
+      const level = stringField(entry, "level") ?? "info";
+      const message = stringField(entry, "message") ?? "";
+      const source = stringField(entry, "source");
+      return [ts, level, source, message].filter(Boolean).join(" ");
+    });
+    if (entries.length > LOG_ENTRY_LIMIT) {
+      lines.push(`[serializer omitted ${entries.length - LOG_ENTRY_LIMIT} log entry item(s)]`);
+    }
+    return joinSections([
+      renderHeader(`logs: ${stringField(obj, "source") ?? "<source>"}`, {
+        total: obj["total"],
+        shown: Math.min(entries.length, LOG_ENTRY_LIMIT),
+        truncated: obj["truncated"],
+        stream_mode: obj["stream_mode"]
+      }),
+      lines.length > 0 ? lines.join("\n") : "(no log entries)"
+    ]);
+  }
+  if (toolName === "audit" && Array.isArray(obj["vulnerabilities"])) {
+    const vulns = obj["vulnerabilities"].filter(isRecord2);
+    const lines = vulns.slice(0, DEFAULT_LIST_LIMIT).map((v) => {
+      const severity = stringField(v, "severity") ?? "unknown";
+      const pkg = stringField(v, "package") ?? "<package>";
+      const title = stringField(v, "title") ?? "";
+      const url = stringField(v, "url");
+      return [severity, pkg, title, url].filter(Boolean).join(" | ");
+    });
+    if (vulns.length > DEFAULT_LIST_LIMIT) {
+      lines.push(`[serializer omitted ${vulns.length - DEFAULT_LIST_LIMIT} vulnerability item(s)]`);
+    }
+    return joinSections([
+      renderHeader("audit", {
+        exit_code: obj["exit_code"],
+        total: obj["total"],
+        summary: obj["summary"],
+        truncated: obj["truncated"]
+      }),
+      lines.length > 0 ? lines.join("\n") : stringField(obj, "output")
+    ]);
+  }
+  if (toolName === "outdated" && Array.isArray(obj["packages"])) {
+    const packages = obj["packages"].filter(isRecord2);
+    const lines = packages.slice(0, DEFAULT_LIST_LIMIT).map(
+      (p) => [
+        stringField(p, "name") ?? "<package>",
+        `current=${stringField(p, "current") ?? "unknown"}`,
+        `wanted=${stringField(p, "wanted") ?? "unknown"}`,
+        `latest=${stringField(p, "latest") ?? "unknown"}`,
+        stringField(p, "type")
+      ].filter(Boolean).join(" | ")
+    );
+    if (packages.length > DEFAULT_LIST_LIMIT) {
+      lines.push(`[serializer omitted ${packages.length - DEFAULT_LIST_LIMIT} package item(s)]`);
+    }
+    return joinSections([
+      renderHeader("outdated", {
+        exit_code: obj["exit_code"],
+        total: obj["total"],
+        truncated: obj["truncated"]
+      }),
+      lines.length > 0 ? lines.join("\n") : stringField(obj, "output")
+    ]);
+  }
+  return void 0;
+}
+function renderTestOutput(obj, input) {
+  const exitCode = numberField(obj, "exit_code") ?? 0;
+  const failed = numberField(obj, "failed") ?? 0;
+  const output = stringField(obj, "output") ?? "";
+  const header = renderHeader(`test: ${stringField(obj, "runner") ?? "runner"}`, {
+    exit_code: obj["exit_code"],
+    tests_run: obj["tests_run"],
+    passed: obj["passed"],
+    failed: obj["failed"],
+    duration_ms: obj["duration_ms"],
+    truncated: obj["truncated"],
+    files: inputListSummary(input, "files"),
+    grep: stringFromInput(input, "grep")
+  });
+  if (exitCode === 0 && failed === 0) {
+    return joinSections([
+      header,
+      joinSections([
+        "report:",
+        `status=passed`,
+        `tests_run=${obj["tests_run"] ?? 0}`,
+        `passed=${obj["passed"] ?? 0}`,
+        `failed=${obj["failed"] ?? 0}`,
+        `duration_ms=${obj["duration_ms"] ?? 0}`,
+        extractSpoolNote(output)
+      ])
+    ]);
+  }
+  return joinSections([
+    header,
+    `error_context:
+${compactFailureOutput(output || "(no runner output)")}`
+  ]);
+}
+function renderVerifierOutput(toolName, obj, input) {
+  const exitCode = numberField(obj, "exit_code") ?? 0;
+  const errors = numberField(obj, "errors") ?? 0;
+  const warnings = numberField(obj, "warnings") ?? 0;
+  const output = stringField(obj, "output") ?? "";
+  const changed = numberField(obj, "files_changed") ?? 0;
+  const header = renderHeader(toolName, {
+    exit_code: obj["exit_code"],
+    errors: obj["errors"],
+    warnings: obj["warnings"],
+    files_checked: obj["files_checked"],
+    files_changed: obj["files_changed"],
+    fix_applied: obj["fix_applied"],
+    fixer: obj["fixer"],
+    linter: obj["linter"],
+    project: obj["project"],
+    truncated: obj["truncated"],
+    files: inputListSummary(input, "files"),
+    cwd: stringFromInput(input, "cwd")
+  });
+  if (exitCode === 0 && errors === 0 && (toolName !== "format" || changed === 0)) {
+    return joinSections([
+      header,
+      joinSections([
+        "report:",
+        "status=passed",
+        `errors=${errors}`,
+        `warnings=${warnings}`,
+        toolName === "format" ? `files_changed=${changed}` : void 0,
+        extractSpoolNote(output)
+      ])
+    ]);
+  }
+  if (exitCode === 0 && toolName === "format") {
+    return joinSections([
+      header,
+      joinSections([
+        "report:",
+        "status=changed",
+        `files_changed=${changed}`,
+        extractSpoolNote(output)
+      ])
+    ]);
+  }
+  return joinSections([
+    header,
+    `error_context:
+${compactFailureOutput(output || "(no verifier output)")}`
+  ]);
+}
+function renderGrepMatches(matches, mode) {
+  if (matches.length === 0) return "(no matches)";
+  if (mode === "files_with_matches") return renderStringList(matches, "(no files)");
+  if (mode === "count") return renderStringList(matches, "(no counts)");
+  const groups = /* @__PURE__ */ new Map();
+  const passthrough = [];
+  for (const match of matches) {
+    const parsed = parseGrepContentLine(match);
+    if (!parsed) {
+      passthrough.push(match);
+      continue;
+    }
+    const list = groups.get(parsed.file) ?? [];
+    list.push(`${parsed.line}:${parsed.text}`);
+    groups.set(parsed.file, list);
+  }
+  if (groups.size === 0) return renderStringList(matches, "(no matches)");
+  const sections = [];
+  let fileIndex = 0;
+  for (const [file, lines] of groups) {
+    fileIndex++;
+    if (fileIndex > GREP_FILE_LIMIT) break;
+    const shown = lines.slice(0, GREP_MATCHES_PER_FILE);
+    sections.push(
+      `${file} (${lines.length} match(es), showing ${shown.length})
+${shown.join("\n")}`
+    );
+  }
+  if (groups.size > GREP_FILE_LIMIT) {
+    sections.push(`[serializer omitted ${groups.size - GREP_FILE_LIMIT} file group(s)]`);
+  }
+  if (passthrough.length > 0) {
+    sections.push(`ungrouped:
+${renderStringList(passthrough, "", 50)}`);
+  }
+  return sections.join("\n");
+}
+function parseGrepContentLine(line) {
+  const match = /^(.+?):(\d+):(.*)$/.exec(line);
+  if (!match?.[1] || !match[2]) return void 0;
+  return { file: match[1], line: match[2], text: match[3] ?? "" };
+}
+function compactDiff(diff) {
+  const lines = diff.split(/\r?\n/);
+  if (lines.length <= DIFF_INLINE_LINE_LIMIT) return diff;
+  const fileCount = Math.max(
+    new Set(
+      lines.map(
+        (line) => /^diff --git\s+a\/(.+?)\s+b\//.exec(line)?.[1] ?? /^---\s+(.+)/.exec(line)?.[1]
+      ).filter(Boolean)
+    ).size,
+    0
+  );
+  const hunks = lines.filter((line) => line.startsWith("@@")).length;
+  const added = lines.filter((line) => line.startsWith("+") && !line.startsWith("+++")).length;
+  const removed = lines.filter((line) => line.startsWith("-") && !line.startsWith("---")).length;
+  const selected = /* @__PURE__ */ new Set();
+  let hunkCount = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.startsWith("diff --git") || line.startsWith("--- ") || line.startsWith("+++ ")) {
+      selected.add(i);
+      continue;
+    }
+    if (!line.startsWith("@@")) continue;
+    if (hunkCount >= DIFF_HUNK_LIMIT) continue;
+    hunkCount++;
+    for (let j = i; j <= Math.min(lines.length - 1, i + DIFF_HUNK_CONTEXT); j++) {
+      selected.add(j);
+    }
+  }
+  if (selected.size === 0) {
+    return joinSections([
+      renderHeader("diff_summary", {
+        files: fileCount,
+        hunks,
+        added,
+        removed,
+        lines: lines.length
+      }),
+      lines.slice(0, DIFF_INLINE_LINE_LIMIT).join("\n"),
+      `[serializer omitted ${Math.max(0, lines.length - DIFF_INLINE_LINE_LIMIT)} diff line(s)]`
+    ]);
+  }
+  const excerpt = [];
+  let previous = -1;
+  for (const index of [...selected].sort((a, b) => a - b)) {
+    if (index > previous + 1) {
+      const omitted = previous === -1 ? index : index - previous - 1;
+      excerpt.push(`[serializer omitted ${omitted} diff line(s)]`);
+    }
+    excerpt.push(lines[index] ?? "");
+    previous = index;
+  }
+  const trailing = lines.length - previous - 1;
+  if (trailing > 0) excerpt.push(`[serializer omitted ${trailing} trailing diff line(s)]`);
+  return joinSections([
+    renderHeader("diff_summary", {
+      files: fileCount,
+      hunks,
+      shown_hunks: Math.min(hunks, DIFF_HUNK_LIMIT),
+      added,
+      removed,
+      lines: lines.length
+    }),
+    excerpt.join("\n")
+  ]);
+}
+function compactFailureOutput(output) {
+  const lines = output.split(/\r?\n/);
+  if (lines.length <= 260) return output.trimEnd();
+  const selected = /* @__PURE__ */ new Set();
+  const marker = /\b(fail|failed|failure|error|exception|assertionerror|expected|received|actual|timeout|stack)\b/i;
+  let markerHits = 0;
+  for (let i = 0; i < lines.length; i++) {
+    if (!marker.test(lines[i] ?? "")) continue;
+    markerHits++;
+    for (let j = Math.max(0, i - 4); j <= Math.min(lines.length - 1, i + 10); j++) {
+      selected.add(j);
+    }
+  }
+  if (markerHits === 0) {
+    return lines.slice(-220).join("\n").trimEnd();
+  }
+  const ordered = [...selected].sort((a, b) => a - b);
+  const out = [];
+  let previous = -1;
+  for (const index of ordered) {
+    if (index > previous + 1) {
+      const omitted = previous === -1 ? index : index - previous - 1;
+      out.push(`[serializer omitted ${omitted} line(s)]`);
+    }
+    out.push(lines[index] ?? "");
+    previous = index;
+  }
+  return out.join("\n").trimEnd();
+}
+function extractSpoolNote(output) {
+  return output.split(/\r?\n/).find((line) => line.startsWith("[output truncated") && line.includes("full"));
+}
+function hasCommandOutputShape(obj) {
+  return typeof obj["stdout"] === "string" || typeof obj["stderr"] === "string" || typeof obj["output"] === "string" || typeof obj["exitCode"] === "number" || typeof obj["exit_code"] === "number";
+}
+function renderCommandOutput(toolName, obj, input) {
+  const command = stringField(obj, "command") ?? stringFromInput(input, "command");
+  const args = stringArrayField(obj, "args");
+  const commandLine = command ? [command, ...args].join(" ") : void 0;
+  const output = stringField(obj, "output");
+  const stdout = stringField(obj, "stdout");
+  const stderr = stringField(obj, "stderr");
+  return joinSections([
+    renderHeader(commandLine ? `${toolName}: ${commandLine}` : toolName, {
+      exit_code: obj["exit_code"] ?? obj["exitCode"],
+      timed_out: obj["timed_out"],
+      pid: obj["pid"],
+      allowed: obj["allowed"],
+      truncated: obj["truncated"],
+      runner: obj["runner"],
+      linter: obj["linter"],
+      fixer: obj["fixer"],
+      project: obj["project"],
+      tests_run: obj["tests_run"],
+      passed: obj["passed"],
+      failed: obj["failed"],
+      duration_ms: obj["duration_ms"],
+      errors: obj["errors"],
+      warnings: obj["warnings"],
+      files_checked: obj["files_checked"],
+      files_changed: obj["files_changed"],
+      fix_applied: obj["fix_applied"]
+    }),
+    stringField(obj, "error") ? `error:
+${stringField(obj, "error")}` : void 0,
+    output ? `output:
+${output}` : void 0,
+    stdout ? `stdout:
+${stdout}` : void 0,
+    stderr ? `stderr:
+${stderr}` : void 0
+  ]);
+}
+function renderGenericToolObject(toolName, obj) {
+  const scalars = {};
+  const blocks = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0) continue;
+    if (isScalar(value)) {
+      const inline = String(value);
+      if (inline.length <= INLINE_LIMIT && !inline.includes("\n")) {
+        scalars[key] = value;
+      } else {
+        blocks.push(`${key}:
+${inline}`);
+      }
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.every((item) => typeof item === "string")) {
+        blocks.push(`${key}:
+${renderStringList(value)}`);
+      } else {
+        blocks.push(`${key}:
+${renderUnknownList(value)}`);
+      }
+      continue;
+    }
+    blocks.push(`${key}: ${clipInline(oneLineJson(value))}`);
+  }
+  return joinSections([renderHeader(toolName, scalars), ...blocks]);
+}
+function renderHeader(label, fields) {
+  const parts = Object.entries(fields).filter(([, value]) => value !== void 0 && value !== null && value !== "").map(([key, value]) => `${key}=${clipInline(formatInlineValue(value))}`);
+  return parts.length > 0 ? `${label} (${parts.join(" ")})` : label;
+}
+function renderStringList(items, empty = "", limit = DEFAULT_LIST_LIMIT) {
+  if (items.length === 0) return empty;
+  const shown = items.slice(0, limit);
+  const omitted = items.length - shown.length;
+  return [
+    ...shown,
+    ...omitted > 0 ? [`[serializer omitted ${omitted} item(s); narrow the request for more]`] : []
+  ].join("\n");
+}
+function renderUnknownList(items, limit = DEFAULT_LIST_LIMIT) {
+  const shown = items.slice(0, limit).map((item) => clipInline(oneLineJson(item), 1e3));
+  const omitted = items.length - shown.length;
+  if (omitted > 0)
+    shown.push(`[serializer omitted ${omitted} item(s); narrow the request for more]`);
+  return shown.join("\n");
+}
+function joinSections(sections) {
+  return sections.map((section) => typeof section === "string" ? section.trimEnd() : void 0).filter((section) => !!section).join("\n");
+}
+function formatInlineValue(value) {
+  if (Array.isArray(value)) return `[${value.map(formatInlineValue).join(",")}]`;
+  if (isScalar(value)) return String(value);
+  return oneLineJson(value);
+}
+function clipInline(value, max = INLINE_LIMIT) {
+  const compact = value.replace(/\s+/g, " ").trim();
+  return compact.length <= max ? compact : `${compact.slice(0, max - 15)}...(${compact.length} chars)`;
+}
+function oneLineJson(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function stringField(obj, key) {
+  const value = obj[key];
+  return typeof value === "string" ? value : void 0;
+}
+function numberField(obj, key) {
+  const value = obj[key];
+  return typeof value === "number" ? value : void 0;
+}
+function stringArrayField(obj, key) {
+  const value = obj[key];
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function stringFromInput(input, key) {
+  if (!isRecord2(input)) return void 0;
+  const value = input[key];
+  return typeof value === "string" ? value : void 0;
+}
+function numberFromInput(input, key) {
+  if (!isRecord2(input)) return void 0;
+  const value = input[key];
+  return typeof value === "number" ? value : void 0;
+}
+function inputListSummary(input, key) {
+  if (!isRecord2(input)) return void 0;
+  const value = input[key];
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.filter((item) => typeof item === "string").join(",");
+  return void 0;
+}
+function isRecord2(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isScalar(value) {
+  return value === null || ["string", "number", "boolean"].includes(typeof value);
+}
+function projectHash(absRoot) {
+  return createHash("sha256").update(path3.resolve(absRoot)).digest("hex").slice(0, 12);
+}
+function projectSlug(absRoot) {
+  const base = slugify(path3.basename(absRoot));
+  const hash = createHash("sha256").update(path3.resolve(absRoot)).digest("hex").slice(0, 6);
+  return `${base}-${hash}`;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
+}
+function wstackGlobalRoot() {
+  const fromEnv = process.env["WRONGSTACK_HOME"];
+  if (fromEnv && fromEnv.trim().length > 0) return path3.resolve(fromEnv);
+  return path3.join(os.homedir(), ".wrongstack");
+}
+function resolveWstackPaths(opts) {
+  const globalRoot = opts.globalRoot ?? (opts.userHome ? path3.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
+  const hash = projectHash(opts.projectRoot);
+  const slug = projectSlug(opts.projectRoot);
+  const projectDir = path3.join(globalRoot, "projects", slug);
+  return {
+    globalRoot,
+    configDir: globalRoot,
+    globalConfig: path3.join(globalRoot, "config.json"),
+    secretsKey: path3.join(globalRoot, ".key"),
+    globalMemory: path3.join(globalRoot, "memory.md"),
+    globalSkills: path3.join(globalRoot, "skills"),
+    globalPrompts: path3.join(globalRoot, "prompts"),
+    cacheDir: path3.join(globalRoot, "cache"),
+    modelsCache: path3.join(globalRoot, "cache", "models.dev.json"),
+    modelsOverlayCache: path3.join(globalRoot, "cache", "models-overlay.json"),
+    historyFile: path3.join(globalRoot, "history"),
+    logFile: path3.join(globalRoot, "logs", "wrongstack.log"),
+    projectDir,
+    projectCodebaseIndex: path3.join(projectDir, "codebase-index"),
+    projectMemory: path3.join(projectDir, "memory.md"),
+    projectSessions: path3.join(projectDir, "sessions"),
+    projectTrust: path3.join(projectDir, "trust.json"),
+    projectMeta: path3.join(projectDir, "meta.json"),
+    projectLocalConfig: path3.join(projectDir, "config.local.json"),
+    inProjectConfig: path3.join(opts.projectRoot, ".wrongstack", "config.json"),
+    inProjectAgentsFile: path3.join(opts.projectRoot, ".wrongstack", "AGENTS.md"),
+    inProjectSkills: path3.join(opts.projectRoot, ".wrongstack", "skills"),
+    inProjectWorktrees: path3.join(opts.projectRoot, ".wrongstack", "worktrees"),
+    projectHash: hash,
+    projectSlug: slug,
+    projectGoal: path3.join(projectDir, "goal.json"),
+    projectSpecs: path3.join(projectDir, "specs"),
+    projectTaskGraphs: path3.join(projectDir, "task-graphs"),
+    projectSddSession: path3.join(projectDir, "sdd-session.json"),
+    projectPlan: path3.join(projectDir, "plan.json"),
+    projectAutophase: path3.join(projectDir, "autophase"),
+    syncConfig: path3.join(globalRoot, "sync.json"),
+    projectStatus: (projectHash2) => path3.join(globalRoot, "projects", projectHash2, "status.json")
+  };
+}
+
 // src/types/errors.ts
 var ERROR_CODES = {
   // Provider
@@ -1771,15 +2666,20 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         this._cachedMsgCount = msgCount;
         this._cachedToolCount = toolCount;
       }
-      const load = tokens / this._maxContext;
+      const budget = computeContextWindowBudget(ctx, tokens, this._maxContext);
+      const load = budget.load;
       const policy = this.policyProvider?.(ctx);
       const thresholds = policy?.thresholds ?? {
         warn: this.warnThreshold,
         soft: this.softThreshold,
         hard: this.hardThreshold
       };
+      const repetition = repeatedReadPressure(ctx);
+      const adaptiveThresholds = adaptThresholdsForSignals(thresholds, {
+        repeatedReadCount: repetition
+      });
       const aggressiveOn = policy?.aggressiveOn ?? this.aggressiveOn;
-      const level = load >= thresholds.hard ? "hard" : load >= thresholds.soft ? "soft" : load >= thresholds.warn ? "warn" : null;
+      const level = load >= adaptiveThresholds.hard ? "hard" : load >= adaptiveThresholds.soft ? "soft" : load >= adaptiveThresholds.warn ? "warn" : null;
       if (!level) {
         this.lastNoopAttempt = null;
         return next(ctx);
@@ -1788,7 +2688,13 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         return next(ctx);
       }
       const aggressive = level === "hard" ? true : level === "soft" ? aggressiveOn !== "hard" : aggressiveOn === "warn";
-      await this.compact(ctx, aggressive, { level, tokens, load });
+      await this.compact(ctx, aggressive, {
+        level,
+        tokens,
+        load,
+        budget,
+        signals: { repeatedReadCount: repetition }
+      });
       return next(ctx);
     };
   }
@@ -1841,6 +2747,8 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         tokens: pressure.tokens,
         load: pressure.load,
         maxContext: this._maxContext,
+        budget: pressure.budget,
+        signals: pressure.signals,
         report,
         aggressive
       });
@@ -1852,6 +2760,8 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         level: pressure.level,
         aggressive,
         reductions: report.reductions?.map((r) => ({ phase: r.phase, saved: r.saved })),
+        budget: pressure.budget,
+        signals: pressure.signals,
         // Record what was collapsed so the audit trail shows the preserved
         // content, not just token counts. Bounded to keep the log line small;
         // the full original turns are already in the session JSONL.
@@ -1867,6 +2777,8 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
         level: pressure.level,
         tokens: pressure.tokens,
         maxContext: this._maxContext,
+        budget: pressure.budget,
+        signals: pressure.signals,
         load: pressure.load,
         fatal
       });
@@ -1886,6 +2798,37 @@ var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
     }
   }
 };
+function computeContextWindowBudget(ctx, inputTokens, maxContext) {
+  const reservedOutputTokens = readPositiveMetaNumber(ctx, "contextOutputReserveTokens") ?? Math.floor(Math.min(8192, maxContext * 0.08));
+  const reservedSafetyTokens = readPositiveMetaNumber(ctx, "contextSafetyBufferTokens") ?? Math.floor(Math.min(4096, maxContext * 0.02));
+  const availableInputTokens = Math.max(
+    1,
+    maxContext - reservedOutputTokens - reservedSafetyTokens
+  );
+  const remainingInputTokens = availableInputTokens - inputTokens;
+  return {
+    maxContext,
+    inputTokens,
+    availableInputTokens,
+    remainingInputTokens,
+    reservedOutputTokens,
+    reservedSafetyTokens,
+    load: inputTokens / availableInputTokens,
+    overflowTokens: Math.max(0, -remainingInputTokens)
+  };
+}
+function readPositiveMetaNumber(ctx, key) {
+  const value = ctx.meta?.[key];
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
+}
+function adaptThresholdsForSignals(thresholds, signals) {
+  if (signals.repeatedReadCount < 3) return thresholds;
+  return {
+    warn: Math.max(0.25, thresholds.warn - 0.08),
+    soft: Math.max(0.35, thresholds.soft - 0.04),
+    hard: thresholds.hard
+  };
+}
 
 // src/security/capabilities.ts
 var ToolCapabilities = {
@@ -2028,7 +2971,8 @@ ${errorDetails}`,
       let effectivePermission = decision.permission;
       const policy = this.opts.permissionPolicy;
       const yolo = policy.getYolo?.() === true || policy.getYoloDestructive?.() === true;
-      if (toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo) {
+      const authoritativeAuto = decision.source === "yolo";
+      if (toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo && !authoritativeAuto) {
         effectivePermission = "confirm";
       }
       if (effectivePermission === "deny") {
@@ -2170,9 +3114,10 @@ ${post.additionalContext}`;
     });
     this.opts.renderer?.writeToolCall(tool.name, use.input);
     const output = await this.runWithTimeout(tool, use.input, ctx.signal, ctx, use.id);
-    const text = this.serializer.serialize(output);
+    const text = this.serializer.serialize(output, { toolName: tool.name, input: use.input });
     const scrubbed = this.opts.secretScrubber.scrub(text);
-    const { text: capped, newBudget } = this.serializer.enforceCap(scrubbed, budget);
+    const withArtifact = await maybePersistLargeToolOutput(tool.name, scrubbed, budget);
+    const { text: capped, newBudget } = this.serializer.enforceCap(withArtifact, budget);
     this.opts.renderer?.writeToolResult(tool.name, capped, false);
     return {
       block: {
@@ -2197,38 +3142,27 @@ ${post.additionalContext}`;
       tool.timeoutMs ?? this.iterationTimeoutMs,
       this.maxToolTimeoutMs
     );
-    const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(new Error("tool timeout")), timeoutMs);
-    const combined = AbortSignal.any([parentSignal, ctrl.signal]);
-    let cleanupCalled = false;
-    let caught = false;
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    const combined = AbortSignal.any([parentSignal, timeoutSignal]);
+    let output;
     try {
-      if (typeof tool.executeStream === "function") {
-        return await this.runStreamedTool(tool, input, ctx, combined, toolUseId);
-      }
-      return await tool.execute(input, ctx, { signal: combined });
+      output = typeof tool.executeStream === "function" ? await this.runStreamedTool(tool, input, ctx, combined, toolUseId) : await tool.execute(input, ctx, { signal: combined });
     } catch (err) {
-      caught = true;
-      if (combined.aborted && typeof tool.cleanup === "function") {
-        cleanupCalled = true;
-        try {
-          await tool.cleanup(input, ctx);
-        } catch {
-        }
-      }
+      if (combined.aborted) await this.runToolCleanup(tool, input, ctx);
       throw err;
-    } finally {
-      clearTimeout(timer);
-      if (combined.aborted && !caught) {
-        if (!cleanupCalled && typeof tool.cleanup === "function") {
-          try {
-            await tool.cleanup(input, ctx);
-          } catch {
-          }
-        }
-        const reason = combined.reason instanceof Error ? combined.reason : new Error(typeof combined.reason === "string" ? combined.reason : "aborted");
-        throw reason;
-      }
+    }
+    if (combined.aborted) {
+      await this.runToolCleanup(tool, input, ctx);
+      throw combined.reason instanceof Error ? combined.reason : new Error(typeof combined.reason === "string" ? combined.reason : "tool timeout");
+    }
+    return output;
+  }
+  /** Best-effort tool cleanup; never let it mask the original error. */
+  async runToolCleanup(tool, input, ctx) {
+    if (typeof tool.cleanup !== "function") return;
+    try {
+      await tool.cleanup(input, ctx);
+    } catch {
     }
   }
   async runStreamedTool(tool, input, ctx, signal, toolUseId) {
@@ -2397,6 +3331,25 @@ function extractMalformedRaw(input) {
     return String(value);
   }
 }
+var TOOL_OUTPUT_ARTIFACT_THRESHOLD_BYTES = 64 * 1024;
+async function maybePersistLargeToolOutput(toolName, content, budget) {
+  const bytes = Buffer.byteLength(content, "utf8");
+  if (bytes <= Math.min(TOOL_OUTPUT_ARTIFACT_THRESHOLD_BYTES, Math.max(0, budget))) {
+    return content;
+  }
+  try {
+    const dir = path3.join(wstackGlobalRoot(), "tool-output");
+    await fs.mkdir(dir, { recursive: true });
+    const safeTool = toolName.replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 40) || "tool";
+    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const filePath = path3.join(dir, `${stamp}-${safeTool}-${randomUUID()}.log`);
+    await fs.writeFile(filePath, content, "utf8");
+    return content + `
+[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
+  } catch {
+    return content;
+  }
+}
 
 // src/execution/autonomous-runner.ts
 var DoneConditionChecker = class {
@@ -3592,6 +4545,7 @@ ${recentJournal}` : ""
 
 // src/coordination/subagent-budget.ts
 var TIMEOUT_PREEMPT_FRACTION = 0.85;
+var DECISION_TIMEOUT_MS = 6e4;
 var BudgetExceededError = class extends Error {
   kind;
   limit;
@@ -3621,6 +4575,31 @@ var BudgetThresholdSignal = class extends Error {
 };
 var SubagentBudget = class _SubagentBudget {
   limits;
+  /** Patch one or more budget limits in-place after construction.
+   * Used by the coordinator watchdog when granting an extension.
+   * All fields are optional — only provided fields are updated.
+   * This is the single write path for limit mutations so that future
+   * validation or side-effects live in one place (M1). */
+  patchLimits(ext) {
+    if (ext.maxIterations !== void 0) {
+      this.limits.maxIterations = ext.maxIterations;
+    }
+    if (ext.maxToolCalls !== void 0) {
+      this.limits.maxToolCalls = ext.maxToolCalls;
+    }
+    if (ext.maxTokens !== void 0) {
+      this.limits.maxTokens = ext.maxTokens;
+    }
+    if (ext.maxCostUsd !== void 0) {
+      this.limits.maxCostUsd = ext.maxCostUsd;
+    }
+    if (ext.timeoutMs !== void 0) {
+      this.limits.timeoutMs = ext.timeoutMs;
+    }
+    if (ext.idleTimeoutMs !== void 0) {
+      this.limits.idleTimeoutMs = ext.idleTimeoutMs;
+    }
+  }
   iterations = 0;
   toolCalls = 0;
   tokenInput = 0;
@@ -3641,12 +4620,44 @@ var SubagentBudget = class _SubagentBudget {
    * or hung listener (Director not built / event filter detached mid-run)
    * leaves the budget over-limit and never enforces anything.
    */
-  static DECISION_TIMEOUT_MS = 6e4;
+  static DECISION_TIMEOUT_MS = DECISION_TIMEOUT_MS;
   /**
    * Injected by the runner when wiring the budget to its EventBus.
    * Used to emit `budget.threshold_reached` events in `'auto'` mode.
    */
   _events;
+  /**
+   * Guard against dual-path races between the coordinator watchdog
+   * (`executeWithTimeout`) and the budget's own `checkTimeout()`.
+   * Both paths detect `elapsed >= timeoutMs` and can emit
+   * `budget.threshold_reached` for kind `'timeout'` simultaneously.
+   * Set to the current `timeoutMs` ceiling by the coordinator BEFORE
+   * calling `onThreshold`, and cleared after the negotiation resolves.
+   * `checkTimeout()` skips its wall-clock check while this is set so
+   * the coordinator's watchdog is the sole source of wall-clock timeout
+   * events — `checkTimeout()` focuses exclusively on `idle_timeout`.
+   */
+  _watchdogActive;
+  /** Returns the timeout ceiling currently being negotiated by the watchdog,
+   * or `undefined` when no wall-clock negotiation is in flight.
+   * Used by `executeWithTimeout` to detect a stale lock (M3). */
+  get watchdogActive() {
+    return this._watchdogActive;
+  }
+  /** Called by the coordinator watchdog BEFORE calling `onThreshold` so that
+   * `checkTimeout()` skips its wall-clock check for this ceiling. Prevents
+   * the budget's own `checkTimeout()` from emitting a second
+   * `budget.threshold_reached` event while the watchdog is already
+   * negotiating the same wall-clock deadline (C1). */
+  setWatchdogNegotiation(timeoutMs) {
+    this._watchdogActive = timeoutMs;
+  }
+  /** Clears the watchdog guard after negotiation resolves. Called in the
+   * `finally` block of both the pre-empt and deadline branches so it fires
+   * on every exit path: grant, deny, throw, or error. */
+  clearWatchdogNegotiation() {
+    this._watchdogActive = void 0;
+  }
   /**
    * Negotiation mode — controls whether a threshold hit tries to emit
    * `budget.threshold_reached` and wait for a coordinator decision, or
@@ -3747,7 +4758,8 @@ var SubagentBudget = class _SubagentBudget {
       if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
         exceeded.push({ kind: "idle_timeout", used: idle, limit: this.limits.idleTimeoutMs });
       }
-      if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs) {
+      const wallOwnedByWatchdog = this._onThreshold !== void 0 && this._watchdogActive === this.limits.timeoutMs;
+      if (this.limits.timeoutMs !== void 0 && elapsedMs > this.limits.timeoutMs && !wallOwnedByWatchdog) {
         exceeded.push({ kind: "timeout", used: elapsedMs, limit: this.limits.timeoutMs });
       }
     }
@@ -3761,19 +4773,99 @@ var SubagentBudget = class _SubagentBudget {
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     const bus = this._events;
-    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+    if (!bus) {
       const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
+    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
+    if (bus.hasListenerFor("budget.threshold_reached")) {
+      for (const entry of exceeded) {
+        if (this._pendingNegotiations.has(entry.kind)) continue;
+        this._pendingNegotiations.set(entry.kind, this._negotiateExtension(entry));
+      }
+      const decision = this._pendingNegotiations.get(first.kind);
+      if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
+      throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
+    }
+    let hardStop = null;
     for (const entry of exceeded) {
       if (this._pendingNegotiations.has(entry.kind)) continue;
-      const decision2 = this._negotiateExtension(entry.kind, exceeded);
-      this._pendingNegotiations.set(entry.kind, decision2);
+      const marker = Promise.resolve("stop");
+      this._pendingNegotiations.set(entry.kind, marker);
+      void marker.finally(() => this._pendingNegotiations.delete(entry.kind));
+      const sync = this._invokeHandlerSync(entry);
+      if (!sync) hardStop ??= new BudgetExceededError(entry.kind, entry.limit, entry.used);
     }
-    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
-    const decision = this._pendingNegotiations.get(first.kind);
-    if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
-    throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
+    if (hardStop) throw hardStop;
+    return exceeded;
+  }
+  /**
+   * Invoke `onThreshold` once for `entry` on the NO-LISTENER path and report
+   * whether it decided synchronously. Returns `true` when the handler returned
+   * a synchronous decision (already honored — an `extend` patched the limits),
+   * or `false` when it returned a Promise (async; the caller hard-stops, since
+   * there is no listener to resolve the negotiation). The handler is given the
+   * full info shape (`requestDecision` plus direct `extend`/`deny`) so both
+   * recording handlers and policy handlers work without a wired listener.
+   */
+  _invokeHandlerSync(entry) {
+    const handler = this._onThreshold;
+    if (!handler) return false;
+    let extendArg;
+    const result = handler({
+      kind: entry.kind,
+      used: entry.used,
+      limit: entry.limit,
+      requestDecision: () => this._busRequestDecision(entry),
+      // Direct hooks for synchronous policy/recording handlers.
+      extend: (extra) => {
+        extendArg = extra;
+      },
+      deny: () => {
+      }
+    });
+    if (result && typeof result.then === "function") return false;
+    if (result === "throw") return false;
+    if (result && typeof result === "object" && "extend" in result) {
+      extendArg = result.extend;
+    }
+    if (extendArg) this.patchLimits(extendArg);
+    return true;
+  }
+  /**
+   * Emit `budget.threshold_reached` and resolve to the listener's verdict.
+   * Resolves to `'stop'` immediately when there is no listener (or no bus) so
+   * no negotiation can hang and no fallback timer leaks. Mirrors the
+   * coordinator watchdog's own request path so both agree on the no-listener
+   * default.
+   */
+  _busRequestDecision(entry) {
+    const bus = this._events;
+    if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
+      return Promise.resolve("stop");
+    }
+    return new Promise((resolve3) => {
+      let resolved = false;
+      const respond = (d) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(fallback);
+        resolve3(d);
+      };
+      const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
+      bus.emit("budget.threshold_reached", {
+        kind: entry.kind,
+        used: entry.used,
+        limit: entry.limit,
+        timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
+        // deny() wins over a same-dispatch extend(): a listener that both grants
+        // and denies (or two listeners disagreeing) is resolved as a stop. The
+        // grant is deferred a microtask so a synchronous deny in the same emit
+        // pre-empts it; async grants still resolve normally.
+        extend: (extra) => queueMicrotask(() => respond({ extend: extra })),
+        deny: () => respond("stop")
+      });
+    });
   }
   /**
    * Per-kind in-flight negotiation Promises. Each budget kind can have its
@@ -3793,77 +4885,33 @@ var SubagentBudget = class _SubagentBudget {
    * `{ extend: {} }` — keep going without patching; next overrun fires
    * a fresh signal.
    */
-  async _negotiateExtension(kind, exceeded) {
+  async _negotiateExtension(entry) {
     if (!this._onThreshold) {
       return "stop";
     }
     try {
-      const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       const result = this._onThreshold({
-        kind: first.kind,
-        used: first.used,
-        limit: first.limit,
-        requestDecision: () => {
-          const bus = this._events;
-          if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
-            return Promise.resolve("stop");
-          }
-          return new Promise((resolve2) => {
-            let resolved = false;
-            const respond = (d) => {
-              if (resolved) return;
-              resolved = true;
-              resolve2(d);
-            };
-            const fallback = setTimeout(
-              () => respond("stop"),
-              _SubagentBudget.DECISION_TIMEOUT_MS
-            );
-            for (const { kind: kind2, used, limit } of exceeded) {
-              bus.emit("budget.threshold_reached", {
-                kind: kind2,
-                used,
-                limit,
-                timeoutMs: _SubagentBudget.DECISION_TIMEOUT_MS,
-                extend: (extra) => {
-                  clearTimeout(fallback);
-                  respond({ extend: extra });
-                },
-                deny: () => {
-                  clearTimeout(fallback);
-                  respond("stop");
-                }
-              });
-            }
-          });
+        kind: entry.kind,
+        used: entry.used,
+        limit: entry.limit,
+        // One event for THIS kind only — each exceeded kind has its own
+        // negotiation (and its own resolve), so there is no cross-kind
+        // first-wins drop and no O(N^2) re-emission.
+        requestDecision: () => this._busRequestDecision(entry),
+        extend: (extra) => {
+          this.patchLimits(extra);
+        },
+        deny: () => {
         }
       });
       if (result === "throw") return "stop";
       if (result === "continue") return { extend: {} };
       const decision = await result;
       if (decision === "stop") return "stop";
-      const ext = decision.extend;
-      if (ext.maxIterations !== void 0) {
-        this.limits.maxIterations = ext.maxIterations;
-      }
-      if (ext.maxToolCalls !== void 0) {
-        this.limits.maxToolCalls = ext.maxToolCalls;
-      }
-      if (ext.maxTokens !== void 0) {
-        this.limits.maxTokens = ext.maxTokens;
-      }
-      if (ext.maxCostUsd !== void 0) {
-        this.limits.maxCostUsd = ext.maxCostUsd;
-      }
-      if (ext.timeoutMs !== void 0) {
-        this.limits.timeoutMs = ext.timeoutMs;
-      }
-      if (ext.idleTimeoutMs !== void 0) {
-        this.limits.idleTimeoutMs = ext.idleTimeoutMs;
-      }
+      this.patchLimits(decision.extend);
       return decision;
     } finally {
-      this._pendingNegotiations.delete(kind);
+      this._pendingNegotiations.delete(entry.kind);
     }
   }
   recordIteration() {
@@ -3906,7 +4954,8 @@ var SubagentBudget = class _SubagentBudget {
     const { timeoutMs, idleTimeoutMs } = this.limits;
     if (timeoutMs === void 0 && idleTimeoutMs === void 0) return;
     const elapsed = Date.now() - this.startTime;
-    const wallTripped = timeoutMs !== void 0 && elapsed > timeoutMs;
+    const wallSkipped = this._onThreshold !== void 0 && this._watchdogActive !== void 0 && timeoutMs !== void 0 && this._watchdogActive === timeoutMs;
+    const wallTripped = wallSkipped ? false : timeoutMs !== void 0 && elapsed > timeoutMs;
     const idleTripped = idleTimeoutMs !== void 0 && this.idleMs() > idleTimeoutMs;
     if (!wallTripped && !idleTripped) return;
     void this.checkLimits(elapsed);
@@ -7225,6 +8274,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   terminating = /* @__PURE__ */ new Set();
   constructor(config, options = {}) {
     super();
+    this.setMaxListeners(0);
     this.coordinatorId = config.coordinatorId;
     this.config = config;
     this.runner = options.runner;
@@ -7422,7 +8472,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       taskIds.map((id) => {
         const cached = this.completedResults.find((r) => r.taskId === id);
         if (cached) return cached;
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve3, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -7431,7 +8481,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve2(result);
+              resolve3(result);
             }
           };
           this.on("task.completed", handler);
@@ -7619,7 +8669,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     let result;
     budget.start();
     try {
-      const outcome = await this.executeWithTimeout(this.runner, task, runCtx, budget);
+      const outcome = await this.executeWithTimeout(
+        this.runner,
+        task,
+        runCtx,
+        budget,
+        subagent.config.preemptFraction
+      );
       result = {
         subagentId,
         taskId: task.id,
@@ -7646,7 +8702,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     this.recordCompletion(result);
   }
-  async executeWithTimeout(runner, task, ctx, budget) {
+  async executeWithTimeout(runner, task, ctx, budget, preemptFraction = TIMEOUT_PREEMPT_FRACTION) {
     const initialTimeoutMs = budget.limits.timeoutMs;
     const idleLimitMs = budget.limits.idleTimeoutMs;
     if (initialTimeoutMs === void 0 && idleLimitMs === void 0) {
@@ -7654,8 +8710,21 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
     }
     const start = Date.now();
     let timer = null;
-    let preemptedForLimit = null;
+    let PreemptState;
+    ((PreemptState2) => {
+      PreemptState2["ACTIVE"] = "active";
+      PreemptState2["LOCKED"] = "locked";
+    })(PreemptState || (PreemptState = {}));
+    let preemptedCeiling = null;
+    let preemptState = "active" /* ACTIVE */;
+    let lastGrantActivityTs = -1;
     const timeoutPromise = new Promise((_, reject) => {
+      const terminate = (kind, limit, used) => {
+        this.subagents.get(ctx.subagentId)?.abortController.abort();
+        reject(
+          budget._events?.hasListenerFor("budget.threshold_reached") ? new Error(`subagent stopped: budget ${kind} (limit=${limit}, used=${used})`) : new BudgetExceededError(kind, limit, used)
+        );
+      };
       const armFor = (ms) => {
         if (timer) clearTimeout(timer);
         timer = setTimeout(onTick, Math.max(0, ms));
@@ -7664,7 +8733,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         const wallLimit = budget.limits.timeoutMs ?? initialTimeoutMs;
         const wallRemaining = initialTimeoutMs === void 0 ? Number.POSITIVE_INFINITY : wallLimit - (Date.now() - start);
         const idleRemaining = idleLimitMs === void 0 ? Number.POSITIVE_INFINITY : (budget.limits.idleTimeoutMs ?? idleLimitMs) - budget.idleMs();
-        const preemptRemaining = initialTimeoutMs === void 0 || preemptedForLimit === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * TIMEOUT_PREEMPT_FRACTION - (Date.now() - start);
+        const preemptRemaining = initialTimeoutMs === void 0 || preemptedCeiling === wallLimit ? Number.POSITIVE_INFINITY : wallLimit * preemptFraction - (Date.now() - start);
         armFor(Math.max(25, Math.min(wallRemaining, idleRemaining, preemptRemaining)));
       };
       const negotiateTimeout = async (used, limit) => {
@@ -7674,16 +8743,42 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
           kind: "timeout",
           used,
           limit,
-          requestDecision: () => new Promise((resolveDecision) => {
-            budget._events?.emit("budget.threshold_reached", {
-              kind: "timeout",
-              used,
-              limit,
-              timeoutMs: 6e4,
-              extend: (extra) => resolveDecision({ extend: extra }),
-              deny: () => resolveDecision("stop")
+          requestDecision: () => {
+            if (!budget._events?.hasListenerFor("budget.threshold_reached")) {
+              return Promise.resolve("stop");
+            }
+            return new Promise((resolveDecision) => {
+              let settled = false;
+              const resolve3 = (d) => {
+                if (settled) return;
+                settled = true;
+                resolveDecision(d);
+              };
+              const fallback = setTimeout(() => resolve3("stop"), DECISION_TIMEOUT_MS);
+              budget._events?.emit("budget.threshold_reached", {
+                kind: "timeout",
+                used,
+                limit,
+                // Informational: the budget's own decision deadline. Listeners may use
+                // this to display a countdown. The coordinator does NOT enforce it —
+                // it is the budget's own `setTimeout(fallback)` that races against
+                // the listener's `extend()`/`deny()` call to guarantee progress.
+                timeoutMs: DECISION_TIMEOUT_MS,
+                // deny() wins over a same-dispatch extend(): defer the grant a
+                // microtask so a synchronous deny in the same emit pre-empts it
+                // (a listener that both grants and denies, or two listeners
+                // disagreeing, resolves as a stop). Async grants still resolve.
+                extend: (extra) => {
+                  clearTimeout(fallback);
+                  queueMicrotask(() => resolve3({ extend: extra }));
+                },
+                deny: () => {
+                  clearTimeout(fallback);
+                  resolve3("stop");
+                }
+              });
             });
-          })
+          }
         });
         return typeof result === "string" ? result : await result;
       };
@@ -7694,21 +8789,45 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         const wallExceeded = wallLimit !== void 0 && elapsed >= wallLimit;
         const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
         if (idleExceeded && !wallExceeded) {
+          budget._events?.emit("budget.threshold_reached", {
+            kind: "idle_timeout",
+            used: budget.idleMs(),
+            limit: idleLimit ?? 0,
+            timeoutMs: DECISION_TIMEOUT_MS,
+            extend: () => {
+            },
+            deny: () => {
+            }
+          });
           this.subagents.get(ctx.subagentId)?.abortController.abort();
-          reject(new BudgetExceededError("timeout", idleLimit ?? 0, budget.idleMs()));
+          reject(new BudgetExceededError("idle_timeout", idleLimit ?? 0, budget.idleMs()));
           return;
         }
-        if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptedForLimit !== wallLimit && elapsed >= wallLimit * TIMEOUT_PREEMPT_FRACTION) {
+        if (wallLimit !== void 0 && !wallExceeded && budget.onThreshold && preemptState === "active" /* ACTIVE */ && elapsed >= wallLimit * preemptFraction) {
+          const activityTs = Date.now() - budget.idleMs();
+          if (activityTs <= lastGrantActivityTs) {
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
+            scheduleNext();
+            return;
+          }
+          budget.setWatchdogNegotiation(wallLimit);
           try {
             const decision = await negotiateTimeout(elapsed, wallLimit);
             if (typeof decision !== "string" && decision.extend.timeoutMs !== void 0) {
-              budget.limits.timeoutMs = decision.extend.timeoutMs;
-              preemptedForLimit = null;
+              budget.patchLimits({ timeoutMs: decision.extend.timeoutMs });
+              lastGrantActivityTs = Date.now() - budget.idleMs();
+              preemptState = "active" /* ACTIVE */;
+              preemptedCeiling = null;
             } else {
-              preemptedForLimit = wallLimit;
+              preemptState = "locked" /* LOCKED */;
+              preemptedCeiling = wallLimit;
             }
           } catch {
-            preemptedForLimit = wallLimit;
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
+          } finally {
+            budget.clearWatchdogNegotiation();
           }
           scheduleNext();
           return;
@@ -7723,26 +8842,41 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
           reject(new BudgetExceededError("timeout", limit, elapsed));
           return;
         }
+        budget.setWatchdogNegotiation(limit);
         try {
           const decision = await negotiateTimeout(elapsed, limit);
-          if (decision === "continue" || decision === "throw" || decision === "stop") {
-            preemptedForLimit = null;
+          if (decision === "throw") {
+            terminate("timeout", limit, elapsed);
+            return;
+          }
+          if (decision === "continue") {
+            preemptState = "locked" /* LOCKED */;
+            preemptedCeiling = wallLimit;
             armFor(Math.max(1e3, limit));
             return;
           }
+          if (decision === "stop") {
+            terminate("timeout", limit, elapsed);
+            return;
+          }
           if (decision.extend.timeoutMs !== void 0) {
-            budget.limits.timeoutMs = decision.extend.timeoutMs;
-            preemptedForLimit = null;
+            budget.patchLimits({ timeoutMs: decision.extend.timeoutMs });
+            lastGrantActivityTs = Date.now() - budget.idleMs();
+            preemptState = "active" /* ACTIVE */;
+            preemptedCeiling = null;
             scheduleNext();
             return;
           }
-          this.subagents.get(ctx.subagentId)?.abortController.abort();
-          reject(new BudgetExceededError("timeout", limit, elapsed));
+          terminate("timeout", limit, elapsed);
+          return;
         } catch (err) {
           this.subagents.get(ctx.subagentId)?.abortController.abort();
           reject(
             err instanceof BudgetExceededError ? err : new BudgetExceededError("timeout", limit, elapsed)
           );
+          return;
+        } finally {
+          budget.clearWatchdogNegotiation();
         }
       };
       scheduleNext();
@@ -8595,7 +9729,7 @@ var DefaultSkillLoader = class {
         const entries = await fs.readdir(dir, { withFileTypes: true });
         for (const e of entries) {
           if (!e.isDirectory()) continue;
-          const skillFile = path2.join(dir, e.name, "SKILL.md");
+          const skillFile = path3.join(dir, e.name, "SKILL.md");
           try {
             const raw = await fs.readFile(skillFile, "utf8");
             const meta = parseFrontmatter(raw);
@@ -8620,12 +9754,12 @@ var DefaultSkillLoader = class {
   }
   async find(name) {
     const all = await this.list();
-    return all.find((s) => s.name === name);
+    const lower = name.toLowerCase();
+    return all.find((s) => s.name.toLowerCase() === lower);
   }
   async manifestText() {
-    const skills = await this.list();
-    if (skills.length === 0) return "";
     const entries = await this.listEntries();
+    if (entries.length === 0) return "";
     const lines = ["## Available skills"];
     for (const e of entries) {
       const scopeTag = e.scope.length > 0 ? ` \u2014 ${e.scope.slice(0, 3).join(", ")}` : "";
@@ -8639,12 +9773,8 @@ var DefaultSkillLoader = class {
     const skills = await this.list();
     const entries = [];
     for (const s of skills) {
-      try {
-        const raw = await fs.readFile(s.path, "utf8");
-        const { trigger, scope } = parseDescription(raw);
-        entries.push({ name: s.name, trigger, scope, source: s.source, path: s.path });
-      } catch {
-      }
+      const { trigger, scope } = parseDescriptionFromText(s.description ?? "");
+      entries.push({ name: s.name, trigger, scope, source: s.source, path: s.path });
     }
     this.entriesCache = entries;
     return entries;
@@ -8655,21 +9785,22 @@ var DefaultSkillLoader = class {
     this.bodyCache.clear();
   }
   async readBody(name) {
-    const cached = this.bodyCache.get(name);
+    const key = name.toLowerCase();
+    const cached = this.bodyCache.get(key);
     if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
     const body = await fs.readFile(m.path, "utf8");
-    this.bodyCache.set(name, body);
+    this.bodyCache.set(key, body);
     return body;
   }
   async readSaveBody(name) {
-    const key = `save:${name}`;
+    const key = `save:${name.toLowerCase()}`;
     const cached = this.bodyCache.get(key);
     if (cached !== void 0) return cached;
     const m = await this.find(name);
     if (!m) throw new Error(`Skill "${name}" not found`);
-    const savePath = path2.join(path2.dirname(m.path), "SKILL.save.md");
+    const savePath = path3.join(path3.dirname(m.path), "SKILL.save.md");
     let result;
     try {
       result = await fs.readFile(savePath, "utf8");
@@ -8725,9 +9856,7 @@ function parseFrontmatter(raw) {
   flush();
   return out;
 }
-function parseDescription(raw) {
-  const fm = parseFrontmatter(raw);
-  const desc = fm.description ?? "";
+function parseDescriptionFromText(desc) {
   const firstSentenceEnd = desc.indexOf(". ");
   const trigger = firstSentenceEnd !== -1 ? desc.slice(0, firstSentenceEnd + 1).trim() : desc.trim().split("\n")[0] ?? "";
   const scope = [];