@wrongstack/core 0.260.0 → 0.265.1

package/dist/execution/index.js

@@ -1,9 +1,9 @@
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import * as fs from 'fs/promises';
 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/token-estimate.ts
@@ -25,12 +25,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);
@@ -261,7 +258,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",
@@ -316,18 +317,20 @@ function findPreserveStart(messages, preserveK) {
       }
     }
   }
-  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
-    })
-  );
+  if (compactionDebugEnabled()) {
+    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) {
@@ -394,7 +397,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(
@@ -801,7 +804,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 +853,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 +867,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 +883,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 +913,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 +959,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,7 +1035,7 @@ 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;
@@ -988,6 +1043,11 @@ var SelectiveCompactor = class {
     this.preserveK = opts.preserveK ?? 4;
     this.eliseThreshold = opts.eliseThreshold ?? 500;
     this.summarizerModel = opts.summarizerModel ?? opts.selectorModel ?? "unknown";
+    if (this.summarizerModel === "unknown" && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
+      console.warn(
+        "[SelectiveCompactor] summarizerModel not set \u2014 will use provider default. 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 = {}) {
@@ -1099,8 +1159,9 @@ Summarize the following message range:`;
       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 {
@@ -1234,6 +1295,7 @@ var ProviderBackedCompactor = class {
       return new SelectiveCompactor({
         ...common,
         selectorModel: this.opts.summarizerModel,
+        selectorMaxOutputTokens: this.opts.selectorMaxOutputTokens,
         summarizerModel: this.opts.summarizerModel
       });
     }
@@ -1250,168 +1312,503 @@ function readPolicy(ctx) {
   if (typeof candidate.preserveK !== "number" || !candidate.thresholds) return null;
   return candidate;
 }
-
-// src/types/errors.ts
-var ERROR_CODES = {
-  // Provider
-  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
-  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
-  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
-  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
-  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
-  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
-  // Agent
-  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
-  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
-  AGENT_ABORTED: "AGENT_ABORTED",
-  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
-  // File system
-  FS_READ_FAILED: "FS_READ_FAILED",
-  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED"};
-var WrongStackError = class extends Error {
-  code;
-  subsystem;
-  severity;
-  recoverable;
-  context;
-  constructor(opts) {
-    super(opts.message, { cause: opts.cause });
-    this.name = "WrongStackError";
-    this.code = opts.code;
-    this.subsystem = opts.subsystem;
-    this.severity = opts.severity ?? "error";
-    this.recoverable = opts.recoverable ?? false;
-    this.context = opts.context;
-  }
-  /**
-   * Render a one-line user-facing description.
-   * Subclasses should override for domain-specific formatting.
-   */
-  describe() {
-    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
-    return `${this.code}: ${this.message}${ctx}`;
+async function atomicWrite(targetPath, content, opts = {}) {
+  const dir = path2.dirname(targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmp = path2.join(dir, `.${path2.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    if (typeof content === "string") {
+      await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+    } else {
+      await fs.writeFile(tmp, content, { flag: "wx" });
+    }
+    try {
+      const fh = await fs.open(tmp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    }
+    let mode;
+    try {
+      const stat2 = await fs.stat(targetPath);
+      mode = stat2.mode & 511;
+    } catch {
+      mode = opts.mode;
+    }
+    if (mode !== void 0) {
+      await fs.chmod(tmp, mode);
+    }
+    await renameWithRetry(tmp, targetPath);
+  } catch (err) {
+    try {
+      await fs.unlink(tmp);
+    } catch {
+    }
+    throw err;
   }
-};
-function formatContext(ctx) {
-  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
-  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
 }
-var AgentError = class extends WrongStackError {
-  constructor(opts) {
-    super({
-      message: opts.message,
-      code: opts.code,
-      subsystem: "agent",
-      severity: opts.code === ERROR_CODES.AGENT_ABORTED ? "warning" : "error",
-      recoverable: opts.recoverable ?? opts.code === ERROR_CODES.AGENT_ITERATION_LIMIT,
-      context: opts.context,
-      cause: opts.cause
-    });
-    this.name = "AgentError";
+var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
+async function renameWithRetry(from, to) {
+  if (process.platform !== "win32") {
+    await fs.rename(from, to);
+    return;
   }
-};
-function toWrongStackError(err, code = ERROR_CODES.AGENT_RUN_FAILED) {
-  if (err instanceof WrongStackError) return err;
-  const message = err instanceof Error ? err.message : String(err);
-  return new AgentError({
-    message,
-    code: code === "UNKNOWN" ? ERROR_CODES.AGENT_RUN_FAILED : code,
-    cause: err
-  });
-}
-var FsError = class extends WrongStackError {
-  path;
-  constructor(opts) {
-    super({
-      message: opts.message,
-      code: opts.code,
-      subsystem: "fs",
-      severity: "error",
-      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
-      context: { path: opts.path, ...opts.context },
-      cause: opts.cause
-    });
-    this.name = "FsError";
-    this.path = opts.path;
+  const delays = [10, 25, 60, 120, 250];
+  let lastErr;
+  for (let i = 0; i <= delays.length; i++) {
+    try {
+      await fs.rename(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
+        throw err;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, delays[i]));
+    }
   }
-};
+  throw lastErr;
+}
 
-// src/execution/auto-compaction-middleware.ts
-var LEVEL_RANK = { warn: 0, soft: 1, hard: 2 };
-var MAX_DIGEST_LOG_CHARS = 4e3;
-function truncateDigest(digest) {
-  if (digest.length <= MAX_DIGEST_LOG_CHARS) return digest;
-  return `${digest.slice(0, MAX_DIGEST_LOG_CHARS)}\u2026 [+${digest.length - MAX_DIGEST_LOG_CHARS} chars; full turns in session log]`;
+// src/utils/error.ts
+function toErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
 }
-var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
-  name = "AutoCompaction";
-  compactor;
-  /** Deprecated. Kept for backward compat with tests that pass simpleEstimator. */
-  _estimator;
-  warnThreshold;
-  softThreshold;
-  hardThreshold;
-  /** Writable so model-switch can update the denominator without re-registering the middleware. */
-  _maxContext;
-  aggressiveOn;
-  events;
-  failureMode;
-  policyProvider;
-  sessionBridge;
-  /**
-   * Once a compaction attempt reduces nothing (preserveK protects everything,
-   * no oversized tool_results remain to elide), retrying on every iteration
-   * just spams `compaction.fired` events without making progress. We remember
-   * the no-op and skip until either the pressure level escalates or context
-   * has grown by at least this many tokens since the failed attempt.
-   */
-  static NOOP_RETRY_DELTA_TOKENS = 2e3;
-  /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
-  lastNoopAttempt = null;
-  /**
-   * Cached token estimate from the last handler() invocation. When the
-   * message count and tool count haven't changed since the last estimate
-   * (autonomous idle loops), we skip the expensive O(n) token estimation
-   * and reuse this value. Reset to -1 when the context changes.
-   */
-  _cachedTokens = -1;
-  _cachedMsgCount = -1;
-  _cachedToolCount = -1;
-  /**
-   * @param compactor        Compactor to use for compaction.
-   * @param maxContext Provider's max context window in tokens.
-   * @param _estimator       Deprecated parameter kept for backward compatibility.
-   *                         The middleware now uses `estimateRequestTokens` internally
-   *                         for accurate full-request token counting (messages +
-   *                         systemPrompt + toolDefs).
-   * @param thresholds       Threshold fractions (0-1) of maxContext.
-   * @param opts             Optional behavior. By default, failures at the
-   *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
-   *                         the agent does not continue into a likely
-   *                         provider context overflow. Warn/soft failures
-   *                         still emit compaction.failed and continue.
-   */
-  constructor(compactor, maxContext, _estimator, thresholds, optsOrAggressiveOn = {}, events) {
-    const opts = typeof optsOrAggressiveOn === "string" ? { aggressiveOn: optsOrAggressiveOn, events } : optsOrAggressiveOn;
-    this.compactor = compactor;
-    this._maxContext = maxContext;
-    this._estimator = _estimator;
-    this.warnThreshold = thresholds.warn;
-    this.softThreshold = thresholds.soft;
-    this.hardThreshold = thresholds.hard;
-    this.aggressiveOn = opts.aggressiveOn ?? "soft";
-    this.events = opts.events;
-    this.failureMode = opts.failureMode ?? "throw_on_hard";
-    this.policyProvider = opts.policyProvider;
-    this.sessionBridge = opts.sessionBridge;
-  }
-  /** Allow callers (e.g. model-switch in WebUI) to update the context window
-   *  denominator when the active model changes. */
-  setMaxContext(maxContext) {
-    this._maxContext = maxContext;
-  }
-  handler() {
+
+// 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"),
+    projectStatus: (projectHash2) => path2.join(globalRoot, "projects", projectHash2, "status.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) {
+  if (schema.enum !== void 0) {
+    if (!schema.enum.some((e) => deepEqual(e, value))) {
+      errors.push({
+        path: path4 || "<root>",
+        message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
+      });
+      return;
+    }
+  }
+  if (typeof schema.type === "string") {
+    if (!checkType(value, schema.type)) {
+      errors.push({
+        path: path4 || "<root>",
+        message: `expected ${schema.type}, got ${describeType(value)}`
+      });
+      return;
+    }
+  }
+  if (schema.type === "object" && isPlainObject(value)) {
+    const obj = value;
+    for (const req of schema.required ?? []) {
+      if (!(req in obj)) {
+        errors.push({ path: joinPath(path4, 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);
+        }
+      }
+    }
+  }
+  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);
+    }
+  }
+}
+function checkType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && !Number.isNaN(value);
+    case "integer":
+      return typeof value === "number" && Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return isPlainObject(value);
+    default:
+      return true;
+  }
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function describeType(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function joinPath(parent, key) {
+  if (!parent) return key;
+  return `${parent}.${key}`;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length) return false;
+    return ak.every(
+      (k) => deepEqual(a[k], b[k])
+    );
+  }
+  return false;
+}
+
+// src/utils/regex-guard.ts
+var MAX_PATTERN_LEN = 512;
+var DANGEROUS_PATTERNS = [
+  /(\([^)]*[+*][^)]*\))[+*]/,
+  // (a+)+, (.*)+, etc
+  /(\(\?:[^)]*[+*][^)]*\))[+*]/
+  // same, with non-capturing group
+];
+function compileUserRegex(pattern, flags) {
+  if (typeof pattern !== "string") {
+    return { ok: false, reason: "pattern must be a string" };
+  }
+  if (pattern.length === 0) {
+    return { ok: false, reason: "pattern is empty" };
+  }
+  if (pattern.length > MAX_PATTERN_LEN) {
+    return { ok: false, reason: `pattern exceeds ${MAX_PATTERN_LEN} characters` };
+  }
+  for (const rx of DANGEROUS_PATTERNS) {
+    if (rx.test(pattern)) {
+      return {
+        ok: false,
+        reason: "pattern looks vulnerable to catastrophic backtracking \u2014 rewrite without nested quantifiers"
+      };
+    }
+  }
+  try {
+    return { ok: true, regex: new RegExp(pattern, flags) };
+  } catch (err) {
+    return {
+      ok: false,
+      reason: err instanceof Error ? err.message : "invalid regex"
+    };
+  }
+}
+
+// src/types/errors.ts
+var ERROR_CODES = {
+  // Provider
+  PROVIDER_RATE_LIMITED: "PROVIDER_RATE_LIMITED",
+  PROVIDER_AUTH_FAILED: "PROVIDER_AUTH_FAILED",
+  PROVIDER_OVERLOADED: "PROVIDER_OVERLOADED",
+  PROVIDER_INVALID_REQUEST: "PROVIDER_INVALID_REQUEST",
+  PROVIDER_SERVER_ERROR: "PROVIDER_SERVER_ERROR",
+  PROVIDER_NETWORK_ERROR: "PROVIDER_NETWORK_ERROR",
+  // Agent
+  AGENT_ITERATION_LIMIT: "AGENT_ITERATION_LIMIT",
+  AGENT_CONTEXT_OVERFLOW: "AGENT_CONTEXT_OVERFLOW",
+  AGENT_ABORTED: "AGENT_ABORTED",
+  AGENT_RUN_FAILED: "AGENT_RUN_FAILED",
+  // File system
+  FS_READ_FAILED: "FS_READ_FAILED",
+  FS_ATOMIC_WRITE_FAILED: "FS_ATOMIC_WRITE_FAILED"};
+var WrongStackError = class extends Error {
+  code;
+  subsystem;
+  severity;
+  recoverable;
+  context;
+  constructor(opts) {
+    super(opts.message, { cause: opts.cause });
+    this.name = "WrongStackError";
+    this.code = opts.code;
+    this.subsystem = opts.subsystem;
+    this.severity = opts.severity ?? "error";
+    this.recoverable = opts.recoverable ?? false;
+    this.context = opts.context;
+  }
+  /**
+   * Render a one-line user-facing description.
+   * Subclasses should override for domain-specific formatting.
+   */
+  describe() {
+    const ctx = this.context ? ` ${formatContext(this.context)}` : "";
+    return `${this.code}: ${this.message}${ctx}`;
+  }
+};
+function formatContext(ctx) {
+  const parts = Object.entries(ctx).filter(([, v]) => v !== void 0).slice(0, 3).map(([k, v]) => `${k}=${String(v)}`);
+  return parts.length > 0 ? `[${parts.join(" ")}]` : "";
+}
+var AgentError = class extends WrongStackError {
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "agent",
+      severity: opts.code === ERROR_CODES.AGENT_ABORTED ? "warning" : "error",
+      recoverable: opts.recoverable ?? opts.code === ERROR_CODES.AGENT_ITERATION_LIMIT,
+      context: opts.context,
+      cause: opts.cause
+    });
+    this.name = "AgentError";
+  }
+};
+function toWrongStackError(err, code = ERROR_CODES.AGENT_RUN_FAILED) {
+  if (err instanceof WrongStackError) return err;
+  const message = toErrorMessage(err);
+  return new AgentError({
+    message,
+    code: code === "UNKNOWN" ? ERROR_CODES.AGENT_RUN_FAILED : code,
+    cause: err
+  });
+}
+var FsError = class extends WrongStackError {
+  path;
+  constructor(opts) {
+    super({
+      message: opts.message,
+      code: opts.code,
+      subsystem: "fs",
+      severity: "error",
+      recoverable: opts.code !== ERROR_CODES.FS_READ_FAILED,
+      context: { path: opts.path, ...opts.context },
+      cause: opts.cause
+    });
+    this.name = "FsError";
+    this.path = opts.path;
+  }
+};
+
+// src/execution/auto-compaction-middleware.ts
+var LEVEL_RANK = { warn: 0, soft: 1, hard: 2 };
+var MAX_DIGEST_LOG_CHARS = 4e3;
+function truncateDigest(digest) {
+  if (digest.length <= MAX_DIGEST_LOG_CHARS) return digest;
+  return `${digest.slice(0, MAX_DIGEST_LOG_CHARS)}\u2026 [+${digest.length - MAX_DIGEST_LOG_CHARS} chars; full turns in session log]`;
+}
+var AutoCompactionMiddleware = class _AutoCompactionMiddleware {
+  name = "AutoCompaction";
+  compactor;
+  /** Deprecated. Kept for backward compat with tests that pass simpleEstimator. */
+  _estimator;
+  warnThreshold;
+  softThreshold;
+  hardThreshold;
+  /** Writable so model-switch can update the denominator without re-registering the middleware. */
+  _maxContext;
+  /**
+   * Runtime on/off gate. The middleware is always installed in the pipeline so
+   * auto-compaction can be toggled live from the TUI `/settings` picker; when
+   * disabled the handler is a pass-through. Defaults to enabled.
+   */
+  _enabled = true;
+  aggressiveOn;
+  events;
+  failureMode;
+  policyProvider;
+  sessionBridge;
+  /**
+   * Once a compaction attempt reduces nothing (preserveK protects everything,
+   * no oversized tool_results remain to elide), retrying on every iteration
+   * just spams `compaction.fired` events without making progress. We remember
+   * the no-op and skip until either the pressure level escalates or context
+   * has grown by at least this many tokens since the failed attempt.
+   */
+  static NOOP_RETRY_DELTA_TOKENS = 2e3;
+  /** Tracks the most recent no-op attempt so we can avoid re-firing per turn. */
+  lastNoopAttempt = null;
+  /**
+   * Cached token estimate from the last handler() invocation. When the
+   * message count and tool count haven't changed since the last estimate
+   * (autonomous idle loops), we skip the expensive O(n) token estimation
+   * and reuse this value. Reset to -1 when the context changes.
+   */
+  _cachedTokens = -1;
+  _cachedMsgCount = -1;
+  _cachedToolCount = -1;
+  /**
+   * @param compactor        Compactor to use for compaction.
+   * @param maxContext Provider's max context window in tokens.
+   * @param _estimator       Deprecated parameter kept for backward compatibility.
+   *                         The middleware now uses `estimateRequestTokens` internally
+   *                         for accurate full-request token counting (messages +
+   *                         systemPrompt + toolDefs).
+   * @param thresholds       Threshold fractions (0-1) of maxContext.
+   * @param opts             Optional behavior. By default, failures at the
+   *                         hard threshold throw AGENT_CONTEXT_OVERFLOW so
+   *                         the agent does not continue into a likely
+   *                         provider context overflow. Warn/soft failures
+   *                         still emit compaction.failed and continue.
+   */
+  constructor(compactor, maxContext, _estimator, thresholds, optsOrAggressiveOn = {}, events) {
+    const opts = typeof optsOrAggressiveOn === "string" ? { aggressiveOn: optsOrAggressiveOn, events } : optsOrAggressiveOn;
+    this.compactor = compactor;
+    this._maxContext = maxContext;
+    this._estimator = _estimator;
+    this.warnThreshold = thresholds.warn;
+    this.softThreshold = thresholds.soft;
+    this.hardThreshold = thresholds.hard;
+    this.aggressiveOn = opts.aggressiveOn ?? "soft";
+    this.events = opts.events;
+    this.failureMode = opts.failureMode ?? "throw_on_hard";
+    this.policyProvider = opts.policyProvider;
+    this.sessionBridge = opts.sessionBridge;
+  }
+  /** Allow callers (e.g. model-switch in WebUI) to update the context window
+   *  denominator when the active model changes. */
+  setMaxContext(maxContext) {
+    this._maxContext = maxContext;
+  }
+  /** Whether auto-compaction is currently active. */
+  get enabled() {
+    return this._enabled;
+  }
+  /** Toggle auto-compaction on a live session (TUI `/settings`). When disabled
+   *  the middleware passes every iteration straight through without estimating
+   *  tokens or compacting. */
+  setEnabled(enabled) {
+    this._enabled = enabled;
+  }
+  handler() {
     return async (ctx, next) => {
+      if (!this._enabled) return next(ctx);
       const msgCount = ctx.messages.length;
       const toolCount = (ctx.tools ?? []).length;
       let tokens;
@@ -1597,144 +1994,6 @@ function getDangerousCapabilities(toolOrCaps) {
   );
 }
 
-// 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) {
-  if (schema.enum !== void 0) {
-    if (!schema.enum.some((e) => deepEqual(e, value))) {
-      errors.push({
-        path: path4 || "<root>",
-        message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
-      });
-      return;
-    }
-  }
-  if (typeof schema.type === "string") {
-    if (!checkType(value, schema.type)) {
-      errors.push({
-        path: path4 || "<root>",
-        message: `expected ${schema.type}, got ${describeType(value)}`
-      });
-      return;
-    }
-  }
-  if (schema.type === "object" && isPlainObject(value)) {
-    const obj = value;
-    for (const req of schema.required ?? []) {
-      if (!(req in obj)) {
-        errors.push({ path: joinPath(path4, 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);
-        }
-      }
-    }
-  }
-  if (schema.type === "array" && Array.isArray(value) && schema.items) {
-    value.forEach((item, i) => walk(item, schema.items, `${path4}[${i}]`, errors));
-  }
-}
-function checkType(value, type) {
-  switch (type) {
-    case "string":
-      return typeof value === "string";
-    case "number":
-      return typeof value === "number" && !Number.isNaN(value);
-    case "integer":
-      return typeof value === "number" && Number.isInteger(value);
-    case "boolean":
-      return typeof value === "boolean";
-    case "null":
-      return value === null;
-    case "array":
-      return Array.isArray(value);
-    case "object":
-      return isPlainObject(value);
-    default:
-      return true;
-  }
-}
-function isPlainObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function describeType(v) {
-  if (v === null) return "null";
-  if (Array.isArray(v)) return "array";
-  return typeof v;
-}
-function joinPath(parent, key) {
-  if (!parent) return key;
-  return `${parent}.${key}`;
-}
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (typeof a !== typeof b) return false;
-  if (a === null || b === null) return a === b;
-  if (Array.isArray(a) && Array.isArray(b)) {
-    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
-  }
-  if (typeof a === "object" && typeof b === "object") {
-    const ak = Object.keys(a);
-    const bk = Object.keys(b);
-    if (ak.length !== bk.length) return false;
-    return ak.every(
-      (k) => deepEqual(a[k], b[k])
-    );
-  }
-  return false;
-}
-
-// 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/execution/tool-executor.ts
 var ToolExecutor = class _ToolExecutor {
   constructor(registry, opts) {
@@ -1898,7 +2157,7 @@ ${post.additionalContext}`;
         );
         return { result, tool, durationMs: Date.now() - start };
       } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = toErrorMessage(err);
         const scrubbed = this.opts.secretScrubber.scrub(msg);
         this.opts.renderer?.writeToolResult(tool.name, scrubbed, true);
         const result = {
@@ -1919,7 +2178,7 @@ ${post.additionalContext}`;
       try {
         return await runOne(use);
       } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = toErrorMessage(err);
         const scrubbed = this.opts.secretScrubber.scrub(msg);
         const result = {
           type: "tool_result",
@@ -2161,89 +2420,44 @@ ${excerpt}`;
         return isPathKey ? normalizePath(v) : escapeGlob(v);
       }
     }
-    if (toolName === "bash" && typeof obj.command === "string") {
-      return escapeGlob(obj.command);
-    }
-    if (typeof obj.path === "string") {
-      return normalizePath(obj.path);
-    }
-    if (typeof obj.url === "string") {
-      return escapeGlob(obj.url);
-    }
-    if (typeof obj.name === "string") {
-      return escapeGlob(obj.name);
-    }
-    return void 0;
-  }
-};
-function clampTimeoutMs(timeoutMs, maxTimeoutMs) {
-  const fallback = 3e5;
-  const finiteTimeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : fallback;
-  const finiteMax = Number.isFinite(maxTimeoutMs) && maxTimeoutMs > 0 ? maxTimeoutMs : fallback;
-  return Math.max(1, Math.min(finiteTimeout, finiteMax));
-}
-var MALFORMED_ARG_MARKERS = ["__raw", "__raw_arguments", "_raw"];
-function hasMalformedArguments(input) {
-  if (!input || typeof input !== "object" || Array.isArray(input)) return false;
-  const obj = input;
-  const keys = Object.keys(obj);
-  return keys.length === 1 && MALFORMED_ARG_MARKERS.includes(keys[0]);
-}
-function extractMalformedRaw(input) {
-  if (!hasMalformedArguments(input)) return void 0;
-  const obj = input;
-  const value = obj[expectDefined(Object.keys(obj)[0])];
-  if (value === void 0 || value === null) return void 0;
-  if (typeof value === "string") return value;
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-
-// 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/regex-guard.ts
-var MAX_PATTERN_LEN = 512;
-var DANGEROUS_PATTERNS = [
-  /(\([^)]*[+*][^)]*\))[+*]/,
-  // (a+)+, (.*)+, etc
-  /(\(\?:[^)]*[+*][^)]*\))[+*]/
-  // same, with non-capturing group
-];
-function compileUserRegex(pattern, flags) {
-  if (typeof pattern !== "string") {
-    return { ok: false, reason: "pattern must be a string" };
-  }
-  if (pattern.length === 0) {
-    return { ok: false, reason: "pattern is empty" };
-  }
-  if (pattern.length > MAX_PATTERN_LEN) {
-    return { ok: false, reason: `pattern exceeds ${MAX_PATTERN_LEN} characters` };
-  }
-  for (const rx of DANGEROUS_PATTERNS) {
-    if (rx.test(pattern)) {
-      return {
-        ok: false,
-        reason: "pattern looks vulnerable to catastrophic backtracking \u2014 rewrite without nested quantifiers"
-      };
-    }
+    if (toolName === "bash" && typeof obj.command === "string") {
+      return escapeGlob(obj.command);
+    }
+    if (typeof obj.path === "string") {
+      return normalizePath(obj.path);
+    }
+    if (typeof obj.url === "string") {
+      return escapeGlob(obj.url);
+    }
+    if (typeof obj.name === "string") {
+      return escapeGlob(obj.name);
+    }
+    return void 0;
   }
+};
+function clampTimeoutMs(timeoutMs, maxTimeoutMs) {
+  const fallback = 3e5;
+  const finiteTimeout = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : fallback;
+  const finiteMax = Number.isFinite(maxTimeoutMs) && maxTimeoutMs > 0 ? maxTimeoutMs : fallback;
+  return Math.max(1, Math.min(finiteTimeout, finiteMax));
+}
+var MALFORMED_ARG_MARKERS = ["__raw", "__raw_arguments", "_raw"];
+function hasMalformedArguments(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return false;
+  const obj = input;
+  const keys = Object.keys(obj);
+  return keys.length === 1 && MALFORMED_ARG_MARKERS.includes(keys[0]);
+}
+function extractMalformedRaw(input) {
+  if (!hasMalformedArguments(input)) return void 0;
+  const obj = input;
+  const value = obj[expectDefined(Object.keys(obj)[0])];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
   try {
-    return { ok: true, regex: new RegExp(pattern, flags) };
-  } catch (err) {
-    return {
-      ok: false,
-      reason: err instanceof Error ? err.message : "invalid regex"
-    };
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
   }
 }
 
@@ -2423,125 +2637,6 @@ var AutonomousRunner = class {
     this.stopped = true;
   }
 };
-async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path2.dirname(targetPath);
-  await fs.mkdir(dir, { recursive: true });
-  const tmp = path2.join(dir, `.${path2.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
-  try {
-    if (typeof content === "string") {
-      await fs.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
-    } else {
-      await fs.writeFile(tmp, content, { flag: "wx" });
-    }
-    try {
-      const fh = await fs.open(tmp, "r+");
-      try {
-        await fh.sync();
-      } finally {
-        await fh.close();
-      }
-    } catch {
-    }
-    let mode;
-    try {
-      const stat2 = await fs.stat(targetPath);
-      mode = stat2.mode & 511;
-    } catch {
-      mode = opts.mode;
-    }
-    if (mode !== void 0) {
-      await fs.chmod(tmp, mode);
-    }
-    await renameWithRetry(tmp, targetPath);
-  } catch (err) {
-    try {
-      await fs.unlink(tmp);
-    } catch {
-    }
-    throw err;
-  }
-}
-var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
-async function renameWithRetry(from, to) {
-  if (process.platform !== "win32") {
-    await fs.rename(from, to);
-    return;
-  }
-  const delays = [10, 25, 60, 120, 250];
-  let lastErr;
-  for (let i = 0; i <= delays.length; i++) {
-    try {
-      await fs.rename(from, to);
-      return;
-    } catch (err) {
-      lastErr = err;
-      const code = err?.code;
-      if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
-        throw err;
-      }
-      await new Promise((resolve2) => setTimeout(resolve2, delays[i]));
-    }
-  }
-  throw lastErr;
-}
-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/storage/goal-store.ts
 var MAX_JOURNAL_ENTRIES = 500;
 function goalFilePath(projectRoot) {
   return resolveWstackPaths({ projectRoot }).projectGoal;
@@ -2569,7 +2664,7 @@ async function loadGoal(filePath, events) {
       store: "goal",
       filePath,
       operation: "load",
-      error: err instanceof Error ? err.message : String(err),
+      error: toErrorMessage(err),
       recoverable: false
     });
     throw err;
@@ -2642,11 +2737,11 @@ async function saveGoal(filePath, goal, events) {
       store: "goal",
       filePath,
       operation: "save",
-      error: err instanceof Error ? err.message : String(err),
+      error: toErrorMessage(err),
       recoverable: false
     });
     throw new FsError({
-      message: err instanceof Error ? err.message : String(err),
+      message: toErrorMessage(err),
       code: ERROR_CODES.FS_ATOMIC_WRITE_FAILED,
       path: filePath,
       cause: err
@@ -2700,11 +2795,6 @@ function computeTrend(history) {
   return "steady";
 }
 
-// src/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-
 // src/execution/autonomy-brain.ts
 var RISK_LEVELS = {
   low: 0,
@@ -2941,7 +3031,7 @@ var EternalAutonomyEngine = class {
       console.error(JSON.stringify({
         level: "error",
         event: "engine.persist_state_failed",
-        message: err instanceof Error ? err.message : String(err),
+        message: toErrorMessage(err),
         context: { expectedState: "stopped" },
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
@@ -2974,7 +3064,7 @@ var EternalAutonomyEngine = class {
         } catch (err) {
           this.consecutiveFailures++;
           this.opts.onError?.(err instanceof Error ? err : new Error(String(err)), this.consecutiveFailures);
-          await this.appendFailure("engine error", err instanceof Error ? err.message : String(err));
+          await this.appendFailure("engine error", toErrorMessage(err));
         }
         if (iterationOk) {
           this.consecutiveFailures = 0;
@@ -3075,7 +3165,7 @@ var EternalAutonomyEngine = class {
     } catch (err) {
       const isAbort = err instanceof Error && (err.name === "AbortError" || err.message.includes("abort"));
       status = isAbort ? "aborted" : "failure";
-      note = err instanceof Error ? err.message : String(err);
+      note = toErrorMessage(err);
       if (!isAbort && typeof err?.recoverable === "boolean") {
         isTransientFailure = err.recoverable;
       }
@@ -3565,6 +3655,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;
@@ -3594,6 +3685,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;
@@ -3614,12 +3730,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
@@ -3720,7 +3868,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 });
       }
     }
@@ -3734,19 +3883,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((resolve2) => {
+      let resolved = false;
+      const respond = (d) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(fallback);
+        resolve2(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
@@ -3766,77 +3995,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() {
@@ -3879,7 +4064,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);
@@ -6819,11 +7005,6 @@ async function dispatchAgent(task, opts = {}) {
   };
 }
 
-// src/utils/string.ts
-function truncate(s, max) {
-  return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
-}
-
 // src/types/provider.ts
 var ProviderError = class extends WrongStackError {
   status;
@@ -6903,7 +7084,7 @@ function classifySubagentError(err, hints = {}) {
     const baseMessage2 = err.describe();
     return providerErrorToSubagentError(err, baseMessage2, cause);
   }
-  const baseMessage = err instanceof Error ? err.message : String(err);
+  const baseMessage = toErrorMessage(err);
   if (err instanceof BudgetExceededError) {
     const map = {
       iterations: "budget_iterations",
@@ -7203,6 +7384,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;
@@ -7597,7 +7779,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,
@@ -7624,7 +7812,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) {
@@ -7632,8 +7820,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));
@@ -7642,7 +7843,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) => {
@@ -7652,16 +7853,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 resolve2 = (d) => {
+                if (settled) return;
+                settled = true;
+                resolveDecision(d);
+              };
+              const fallback = setTimeout(() => resolve2("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(() => resolve2({ extend: extra }));
+                },
+                deny: () => {
+                  clearTimeout(fallback);
+                  resolve2("stop");
+                }
+              });
             });
-          })
+          }
         });
         return typeof result === "string" ? result : await result;
       };
@@ -7672,21 +7899,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;
@@ -7701,26 +7952,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();
@@ -7883,7 +8149,7 @@ var ParallelEternalEngine = class {
       console.error(JSON.stringify({
         level: "error",
         event: "engine.persist_state_failed",
-        message: err instanceof Error ? err.message : String(err),
+        message: toErrorMessage(err),
         context: { expectedState: "stopped" },
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       }));
@@ -7919,7 +8185,7 @@ var ParallelEternalEngine = class {
           );
           await this.appendFailure(
             "engine error",
-            err instanceof Error ? err.message : String(err)
+            toErrorMessage(err)
           );
         }
         if (this.stopRequested) break;
@@ -8598,12 +8864,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(", ")}` : "";
@@ -8617,12 +8883,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;
@@ -8633,16 +8895,17 @@ 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);
@@ -8703,15 +8966,13 @@ 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 = [];
   const coversMatch = /(?:covers|for|including)\s+([^.]+)/i.exec(desc);
   if (coversMatch) {
-    const items = coversMatch[1] ?? "".replace(/[·•]/g, ",").split(",").map((s) => s.trim()).filter(Boolean);
+    const items = (coversMatch[1] ?? "").replace(/[·•]/g, ",").split(",").map((s) => s.trim()).filter(Boolean);
     scope.push(...items);
   }
   return { trigger, scope };