@wrongstack/core 0.287.0 → 0.291.0

package/dist/defaults/index.js

@@ -36,8 +36,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat12 = await fs.stat(targetPath);
-      mode = stat12.mode & 511;
+      const stat13 = await fs.stat(targetPath);
+      mode = stat13.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -66,7 +66,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
   const dir = path.dirname(targetPath);
   await fs.mkdir(dir, { recursive: true });
   const lockPath = path.join(dir, `.${path.basename(targetPath)}.lock`);
-  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const timeoutMs = opts.timeoutMs ?? 15e3;
   const staleMs = opts.staleMs ?? 3e4;
   const started = Date.now();
   let handle;
@@ -76,6 +76,13 @@ async function withFileLock(targetPath, fn, opts = {}) {
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
+      if (handle) {
+        await handle.close().catch(() => {
+        });
+        await fs.unlink(lockPath).catch(() => {
+        });
+        handle = void 0;
+      }
       const code = err.code;
       if (code === "ENOENT") {
         await fs.mkdir(dir, { recursive: true });
@@ -83,8 +90,8 @@ async function withFileLock(targetPath, fn, opts = {}) {
       }
       if (code !== "EEXIST" && code !== "EPERM") throw err;
       try {
-        const stat12 = await fs.stat(lockPath);
-        if (Date.now() - stat12.mtimeMs > staleMs) {
+        const stat13 = await fs.stat(lockPath);
+        if (Date.now() - stat13.mtimeMs > staleMs) {
           await fs.unlink(lockPath);
           continue;
         }
@@ -120,13 +127,13 @@ async function waitForLockRelease(lockPath, remainingMs) {
   const parentDir = path.dirname(lockPath);
   const lockName = path.basename(lockPath);
   const intervalMs = Math.min(remainingMs, 100);
-  return new Promise((resolve12) => {
+  return new Promise((resolve14) => {
     let settled = false;
     let watcher = null;
     const timer = setTimeout(() => {
       settled = true;
       watcher?.close();
-      resolve12();
+      resolve14();
     }, intervalMs);
     try {
       watcher = watchDir(parentDir, (eventType, filename) => {
@@ -135,14 +142,14 @@ async function waitForLockRelease(lockPath, remainingMs) {
           settled = true;
           clearTimeout(timer);
           watcher?.close();
-          resolve12();
+          resolve14();
         }
       });
     } catch {
       clearTimeout(timer);
       if (!settled) {
         settled = true;
-        setTimeout(resolve12, Math.min(remainingMs, 25));
+        setTimeout(resolve14, Math.min(remainingMs, 25));
       }
       return;
     }
@@ -154,7 +161,7 @@ async function waitForLockRelease(lockPath, remainingMs) {
           settled = true;
           clearTimeout(timer);
           watcher?.close();
-          resolve12();
+          resolve14();
         }
       }
     );
@@ -178,7 +185,7 @@ async function renameWithRetry(from, to) {
       if (!code || !TRANSIENT_RENAME_CODES.has(code) || i === delays.length) {
         throw err;
       }
-      await new Promise((resolve12) => setTimeout(resolve12, delays[i]));
+      await new Promise((resolve14) => setTimeout(resolve14, delays[i]));
     }
   }
   throw lastErr;
@@ -336,6 +343,12 @@ function writeTo(s, stream) {
 function writeErr(s, stream = process.stderr) {
   return writeTo(s, stream);
 }
+var ESCAPE_TERMINATOR = Object.freeze({
+  BEL: "\x07",
+  // OSC 0 / OSC 2 (title)
+  ST: "\x1B\\"
+  // DCS / strict OSC
+});
 
 // src/utils/color.ts
 var isColorTty = () => {
@@ -618,8 +631,8 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat12 = await fsp.stat(full);
-          if (stat12.isDirectory()) await walk3(full, rest);
+          const stat13 = await fsp.stat(full);
+          if (stat13.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -636,8 +649,8 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat12 = await fsp.stat(full);
-          if (stat12.isDirectory()) await walk3(full, rest);
+          const stat13 = await fsp.stat(full);
+          if (stat13.isDirectory()) await walk3(full, rest);
         } catch {
         }
       }
@@ -828,10 +841,10 @@ function validateAgainstSchema(value, schema) {
   return { ok: errors.length === 0, errors };
 }
 var MAX_SCHEMA_DEPTH = 64;
-function walk(value, schema, path28, errors, depth) {
+function walk(value, schema, path29, errors, depth) {
   if (depth > MAX_SCHEMA_DEPTH) {
     errors.push({
-      path: path28 || "<root>",
+      path: path29 || "<root>",
       message: `schema nesting exceeds maximum depth (${MAX_SCHEMA_DEPTH})`
     });
     return;
@@ -839,7 +852,7 @@ function walk(value, schema, path28, errors, depth) {
   if (schema.enum !== void 0) {
     if (!enumIncludes(schema.enum, value)) {
       errors.push({
-        path: path28 || "<root>",
+        path: path29 || "<root>",
         message: `expected one of ${JSON.stringify(schema.enum)}, got ${JSON.stringify(value)}`
       });
       return;
@@ -848,7 +861,7 @@ function walk(value, schema, path28, errors, depth) {
   if (typeof schema.type === "string") {
     if (!checkType(value, schema.type)) {
       errors.push({
-        path: path28 || "<root>",
+        path: path29 || "<root>",
         message: `expected ${schema.type}, got ${describeType(value)} (${previewValue(value)})`
       });
       return;
@@ -860,7 +873,7 @@ function walk(value, schema, path28, errors, depth) {
       if (!(req in obj)) {
         const expected = schema.properties?.[req]?.type;
         errors.push({
-          path: joinPath(path28, req),
+          path: joinPath(path29, req),
           message: `required property missing${typeof expected === "string" ? ` (expected ${expected})` : ""}`
         });
       }
@@ -868,14 +881,14 @@ function walk(value, schema, path28, errors, depth) {
     if (schema.properties) {
       for (const [key, subSchema] of Object.entries(schema.properties)) {
         if (key in obj) {
-          walk(obj[key], subSchema, joinPath(path28, key), errors, depth + 1);
+          walk(obj[key], subSchema, joinPath(path29, key), errors, depth + 1);
         }
       }
     }
   }
   if (schema.type === "array" && Array.isArray(value) && schema.items) {
     for (let i = 0; i < value.length; i++) {
-      walk(value[i], schema.items, `${path28}[${i}]`, errors, depth + 1);
+      walk(value[i], schema.items, `${path29}[${i}]`, errors, depth + 1);
     }
   }
 }
@@ -1069,6 +1082,16 @@ function stripUndefined(obj) {
 }
 
 // src/utils/message-invariants.ts
+function hasMeaningfulContent(content) {
+  if (typeof content === "string") return content.trim().length > 0;
+  return content.some((block) => {
+    if (block.type === "text") return block.text.trim().length > 0;
+    if (block.type === "thinking") {
+      return block.thinking.trim().length > 0 || Boolean(block.signature);
+    }
+    return true;
+  });
+}
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
   const removedToolResults = [];
@@ -1156,8 +1179,7 @@ function mapContent(msg, fn) {
   return { ...msg, content: next };
 }
 function isEmptyMessage(msg) {
-  if (typeof msg.content === "string") return msg.content.trim().length === 0;
-  return msg.content.length === 0;
+  return !hasMeaningfulContent(msg.content);
 }
 
 // src/utils/regex-guard.ts
@@ -1198,7 +1220,7 @@ function compileUserRegex(pattern, flags) {
 
 // src/utils/safe-json.ts
 function safeParse(input, maxBytes = 5e6) {
-  if (input.length > maxBytes) {
+  if (Buffer.byteLength(input, "utf8") > maxBytes) {
     return { ok: false, error: `Input exceeds limit (${maxBytes} bytes)` };
   }
   try {
@@ -1254,84 +1276,21 @@ function invalid(sessionId) {
   });
 }
 
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve14) => setTimeout(resolve14, ms));
+}
+
 // src/utils/slug.ts
 function slugify(name, fallback = "prompt", maxLen = 64) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, maxLen).replace(/-+$/g, "") || fallback;
 }
 
-// src/utils/ulid.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var ENCODING_LEN = ENCODING.length;
-var TIME_LEN = 10;
-var RANDOM_LEN = 16;
-function encodeTime(now, len) {
-  let mod;
-  let str = "";
-  for (let i = len - 1; i >= 0; i--) {
-    mod = now % ENCODING_LEN;
-    str = ENCODING[mod] + str;
-    now = (now - mod) / ENCODING_LEN;
-  }
-  return str;
-}
-function encodeRandom(len) {
-  const bytes = randomBytes2(len);
-  let str = "";
-  for (let i = 0; i < len; i++) {
-    str += ENCODING[bytes[i] % ENCODING_LEN];
-  }
-  return str;
-}
-function ulid(seedTime = Date.now()) {
-  return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
-}
-
-// src/utils/sleep.ts
-function sleep(ms) {
-  return new Promise((resolve12) => setTimeout(resolve12, ms));
-}
-
 // src/utils/string.ts
 function truncate(s, max) {
   return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
 }
 
-// src/utils/tool-subject.ts
-var GLOB_METACHARACTERS = /[*?[\]]/g;
-function escapeGlobSubject(value) {
-  return value.replace(GLOB_METACHARACTERS, (char) => `\\${char}`);
-}
-function normalizePathSubject(value) {
-  return escapeGlobSubject(value.replace(/\\/g, "/"));
-}
-function isPathSubjectKey(subjectKey) {
-  return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
-}
-function subjectForToolInput(toolName, input, subjectKey) {
-  if (!input || typeof input !== "object") return void 0;
-  const obj = input;
-  if (subjectKey) {
-    const value = obj[subjectKey];
-    if (typeof value === "string") {
-      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
-    }
-  }
-  if (toolName === "bash" && typeof obj.command === "string") {
-    return escapeGlobSubject(obj.command);
-  }
-  if (typeof obj.path === "string") {
-    return normalizePathSubject(obj.path);
-  }
-  if (typeof obj.url === "string") {
-    return escapeGlobSubject(obj.url);
-  }
-  if (typeof obj.name === "string") {
-    return escapeGlobSubject(obj.name);
-  }
-  return void 0;
-}
-
 // src/utils/tool-wire-compact.ts
 var TOOL_DESCRIPTION_MAX_CHARS = 400;
 var SCHEMA_DESCRIPTION_MAX_CHARS = 120;
@@ -1348,9 +1307,11 @@ function compactToolDefinitionForWire(tool, opts = {}) {
       tool.description ?? "",
       opts.descriptionMaxChars ?? TOOL_DESCRIPTION_MAX_CHARS
     ),
-    inputSchema: compactSchemaDescriptions(
-      tool.inputSchema,
-      opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+    inputSchema: normalizeTopLevelToolSchema(
+      compactSchemaDescriptions(
+        tool.inputSchema,
+        opts.schemaDescriptionMaxChars ?? SCHEMA_DESCRIPTION_MAX_CHARS
+      )
     )
   };
   if (useDefaultOptions && typeof tool === "object" && tool !== null) {
@@ -1358,6 +1319,44 @@ function compactToolDefinitionForWire(tool, opts = {}) {
   }
   return compact;
 }
+function normalizeTopLevelToolSchema(schema) {
+  const combinators = ["oneOf", "anyOf", "allOf"].map((keyword) => ({ keyword, branches: schema[keyword] })).filter(
+    (entry) => Array.isArray(entry.branches)
+  );
+  if (combinators.length === 0) return schema;
+  const out = { ...schema, type: "object" };
+  delete out["oneOf"];
+  delete out["anyOf"];
+  delete out["allOf"];
+  const properties = isRecord(schema["properties"]) ? { ...schema["properties"] } : {};
+  let required = stringSet(schema["required"]);
+  for (const { keyword, branches } of combinators) {
+    const objectBranches = branches.filter(isRecord);
+    for (const branch of objectBranches) {
+      if (isRecord(branch["properties"])) Object.assign(properties, branch["properties"]);
+    }
+    const branchRequired = objectBranches.map((branch) => stringSet(branch["required"]));
+    if (keyword === "allOf") {
+      for (const fields of branchRequired) for (const field of fields) required.add(field);
+    } else if (branchRequired.length > 0) {
+      const common = new Set(
+        [...branchRequired[0]].filter(
+          (field) => branchRequired.slice(1).every((fields) => fields.has(field))
+        )
+      );
+      required = /* @__PURE__ */ new Set([...required, ...common]);
+    }
+  }
+  out["properties"] = properties;
+  if (required.size > 0) out["required"] = [...required];
+  else delete out["required"];
+  return out;
+}
+function stringSet(value) {
+  return new Set(
+    Array.isArray(value) ? value.filter((item) => typeof item === "string") : []
+  );
+}
 function compactSchemaDescriptions(schema, maxDescriptionChars = SCHEMA_DESCRIPTION_MAX_CHARS) {
   const compact = compactSchemaNode(schema, maxDescriptionChars);
   return isRecord(compact) ? compact : { type: "object", properties: {} };
@@ -2252,6 +2251,69 @@ function resolveToolResultRenderMode(modes, toolName) {
   return normalizeToolResultRenderMode(modes?.[toolName]) ?? DEFAULT_TOOL_RESULT_RENDER_MODE;
 }
 
+// src/utils/tool-subject.ts
+var GLOB_METACHARACTERS = /[*?[\]]/g;
+function escapeGlobSubject(value) {
+  return value.replace(GLOB_METACHARACTERS, (char) => `\\${char}`);
+}
+function normalizePathSubject(value) {
+  return escapeGlobSubject(value.replace(/\\/g, "/"));
+}
+function isPathSubjectKey(subjectKey) {
+  return subjectKey === "path" || subjectKey === "file" || subjectKey === "files";
+}
+function subjectForToolInput(toolName, input, subjectKey) {
+  if (!input || typeof input !== "object") return void 0;
+  const obj = input;
+  if (subjectKey) {
+    const value = obj[subjectKey];
+    if (typeof value === "string") {
+      return isPathSubjectKey(subjectKey) ? normalizePathSubject(value) : escapeGlobSubject(value);
+    }
+  }
+  if (toolName === "bash" && typeof obj.command === "string") {
+    return escapeGlobSubject(obj.command);
+  }
+  if (typeof obj.path === "string") {
+    return normalizePathSubject(obj.path);
+  }
+  if (typeof obj.url === "string") {
+    return escapeGlobSubject(obj.url);
+  }
+  if (typeof obj.name === "string") {
+    return escapeGlobSubject(obj.name);
+  }
+  return void 0;
+}
+
+// src/utils/ulid.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(now, len) {
+  let mod;
+  let str = "";
+  for (let i = len - 1; i >= 0; i--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING[mod] + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function encodeRandom(len) {
+  const bytes = randomBytes2(len);
+  let str = "";
+  for (let i = 0; i < len; i++) {
+    str += ENCODING[bytes[i] % ENCODING_LEN];
+  }
+  return str;
+}
+function ulid(seedTime = Date.now()) {
+  return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
+}
+
 // src/utils/wstack-paths.ts
 import { createHash } from "node:crypto";
 import * as fs2 from "node:fs";
@@ -2281,8 +2343,8 @@ function projectHash(absRoot) {
 function projectSlug(absRoot) {
   const identityRoot = canonicalProjectRoot(absRoot);
   const base = slugify2(path3.basename(identityRoot));
-  const hash = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
-  return `${base}-${hash}`;
+  const hash2 = createHash("sha256").update(identityRoot).digest("hex").slice(0, 6);
+  return `${base}-${hash2}`;
 }
 function slugify2(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "project";
@@ -2295,7 +2357,7 @@ function wstackGlobalRoot() {
 function resolveWstackPaths(opts) {
   const globalRoot = opts.globalRoot ?? (opts.userHome ? path3.join(opts.userHome, ".wrongstack") : wstackGlobalRoot());
   const homeDir = opts.userHome ?? os.homedir();
-  const hash = projectHash(opts.projectRoot);
+  const hash2 = projectHash(opts.projectRoot);
   const slug = projectSlug(opts.projectRoot);
   const projectDir = path3.join(globalRoot, "projects", slug);
   return {
@@ -2304,6 +2366,11 @@ function resolveWstackPaths(opts) {
     homeDir,
     configDir: globalRoot,
     globalConfig: path3.join(globalRoot, "config.json"),
+    profilesDir: path3.join(globalRoot, "profiles"),
+    profileConfig: (name) => {
+      const safe = name.replace(/[/\\:]/g, "_").replace(/\.\./g, "_");
+      return path3.join(globalRoot, "profiles", safe || "default", "config.json");
+    },
     secretsKey: path3.join(globalRoot, ".key"),
     globalMemory: path3.join(globalRoot, "memory.md"),
     globalSkills: path3.join(globalRoot, "skills"),
@@ -2332,7 +2399,7 @@ function resolveWstackPaths(opts) {
     inProjectInstructions: path3.join(opts.projectRoot, ".wrongstack", "instructions"),
     inProjectDesignKits: path3.join(opts.projectRoot, ".wrongstack", "design-kits"),
     inProjectWorktrees: path3.join(opts.projectRoot, ".wrongstack", "worktrees"),
-    projectHash: hash,
+    projectHash: hash2,
     projectSlug: slug,
     projectGoal: path3.join(projectDir, "goal.json"),
     projectInputHistory: path3.join(projectDir, "input-history.json"),
@@ -2636,7 +2703,7 @@ var InMemoryAgentBridge = class {
       });
     }
     this.inflightGuards.add(correlationId);
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve14, reject) => {
       const timer = setTimeout(() => {
         this.inflightGuards.delete(correlationId);
         this.pendingRequests.delete(correlationId);
@@ -2655,7 +2722,7 @@ var InMemoryAgentBridge = class {
         return;
       }
       this.pendingRequests.set(correlationId, {
-        resolve: resolve12,
+        resolve: resolve14,
         reject,
         timer
       });
@@ -2898,7 +2965,7 @@ var SubagentBudget = class _SubagentBudget {
    *
    * Returns the kinds that were found to be exceeded (for logging/debugging).
    */
-  checkLimits(elapsedMs) {
+  checkLimits(elapsedMs2) {
     const exceeded = [];
     if (this.limits.maxIterations !== void 0 && this.iterations > this.limits.maxIterations) {
       exceeded.push({ kind: "iterations", used: this.iterations, limit: this.limits.maxIterations });
@@ -2913,14 +2980,14 @@ var SubagentBudget = class _SubagentBudget {
     if (this.limits.maxCostUsd !== void 0 && this.costUsd > this.limits.maxCostUsd) {
       exceeded.push({ kind: "cost", used: this.costUsd, limit: this.limits.maxCostUsd });
     }
-    if (elapsedMs !== void 0) {
+    if (elapsedMs2 !== void 0) {
       const idle = this.idleMs();
       if (this.limits.idleTimeoutMs !== void 0 && idle > this.limits.idleTimeoutMs) {
         exceeded.push({ kind: "idle_timeout", used: idle, limit: this.limits.idleTimeoutMs });
       }
       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 });
+      if (this.limits.timeoutMs !== void 0 && elapsedMs2 > this.limits.timeoutMs && !wallOwnedByWatchdog) {
+        exceeded.push({ kind: "timeout", used: elapsedMs2, limit: this.limits.timeoutMs });
       }
     }
     if (exceeded.length === 0) return [];
@@ -3004,13 +3071,13 @@ var SubagentBudget = class _SubagentBudget {
     if (!bus?.hasListenerFor("budget.threshold_reached")) {
       return Promise.resolve("stop");
     }
-    return new Promise((resolve12) => {
+    return new Promise((resolve14) => {
       let resolved = false;
       const respond = (d) => {
         if (resolved) return;
         resolved = true;
         clearTimeout(fallback);
-        resolve12(d);
+        resolve14(d);
       };
       const fallback = setTimeout(() => respond("stop"), _SubagentBudget.DECISION_TIMEOUT_MS);
       const sessionId = this.currentSessionId();
@@ -3316,8 +3383,8 @@ function stringArray(value) {
 
 // src/coordination/agent-subagent-runner.ts
 function withDisabledToolFiltering(factory) {
-  return async (config) => {
-    const result = await factory(config);
+  return async (config, task) => {
+    const result = await factory(config, task);
     const disabled = config.disabledTools ?? [];
     if (disabled.length === 0) return result;
     const registry = result.agent.tools;
@@ -3333,10 +3400,36 @@ function makeAgentSubagentRunner(opts) {
   const format = opts.formatTaskInput ?? defaultFormatTaskInput;
   return async (task, ctx) => {
     const taskStartedAt = Date.now();
-    const factoryResult = await opts.factory(ctx.config);
+    const factoryResult = await opts.factory(ctx.config, task);
     const { agent, events } = factoryResult;
+    const taskContext = task.context ?? {};
+    const hasExplicitTelemetryTask = typeof taskContext["telemetryTaskId"] === "string";
+    const telemetryTaskId = hasExplicitTelemetryTask ? taskContext["telemetryTaskId"] : task.id;
+    const telemetryRunId = typeof taskContext["telemetryRunId"] === "string" ? taskContext["telemetryRunId"] : void 0;
+    const telemetryBoardId = typeof taskContext["telemetryBoardId"] === "string" ? taskContext["telemetryBoardId"] : void 0;
     const agentContext = agent.ctx;
-    if (agentContext?.meta) agentContext.meta["subagentTaskId"] = task.id;
+    if (agentContext?.meta) {
+      agentContext.meta["subagentTaskId"] = task.id;
+      const kanbanContext = taskContext["kanban"];
+      if (kanbanContext && typeof kanbanContext === "object") {
+        agentContext.meta["kanban"] = kanbanContext;
+      }
+      if (hasExplicitTelemetryTask) {
+        agentContext.meta["telemetryTaskId"] = telemetryTaskId;
+        if (telemetryRunId) agentContext.meta["telemetryRunId"] = telemetryRunId;
+      }
+    }
+    if (hasExplicitTelemetryTask) {
+      agentContext?.setCurrentKanbanTask?.(telemetryTaskId, telemetryBoardId);
+    } else {
+      const kanbanContext = taskContext["kanban"];
+      if (kanbanContext && typeof kanbanContext === "object") {
+        const kanban = kanbanContext;
+        const boardId = typeof kanban["boardId"] === "string" ? kanban["boardId"] : void 0;
+        const taskId = typeof kanban["taskId"] === "string" ? kanban["taskId"] : void 0;
+        if (taskId) agentContext?.setCurrentKanbanTask?.(taskId, boardId);
+      }
+    }
     const detachFleet = opts.fleetBus?.attach(ctx.subagentId, events, task.id);
     const aborter = new AbortController();
     ctx.budget._events = events;
@@ -3361,6 +3454,27 @@ function makeAgentSubagentRunner(opts) {
     const unsub = [];
     unsub.push(
       events.on("tool.executed", (e) => {
+        if (hasExplicitTelemetryTask) {
+          opts.hostEvents?.emit("subagent.tool_executed", {
+            sessionId: e.sessionId,
+            subagentId: ctx.subagentId,
+            agentSessionId: e.sessionId,
+            agentName: e.agentName ?? ctx.config.name,
+            taskId: telemetryTaskId,
+            runId: telemetryRunId,
+            traceId: e.traceId,
+            id: e.id,
+            name: e.name,
+            durationMs: e.durationMs,
+            ok: e.ok,
+            // Raw tool inputs may contain credentials or sensitive arguments.
+            // Task telemetry crosses from the isolated worker bus to the shared
+            // host bus, so expose only execution metadata at this boundary.
+            outputBytes: e.outputBytes,
+            outputTokens: e.outputTokens,
+            outputLines: e.outputLines
+          });
+        }
         try {
           ctx.budget.recordToolCall();
         } catch (eb) {
@@ -3372,6 +3486,17 @@ function makeAgentSubagentRunner(opts) {
           lastToolFailed = null;
         }
       }),
+      events.on("file.event", (e) => {
+        if (!hasExplicitTelemetryTask) return;
+        if (e.runId === telemetryRunId && e.taskId === telemetryTaskId) return;
+        opts.hostEvents?.emit("file.event", {
+          ...e,
+          scope: "task",
+          taskId: telemetryTaskId,
+          boardId: telemetryBoardId,
+          runId: telemetryRunId
+        });
+      }),
       events.on("provider.response", (e) => {
         try {
           ctx.budget.recordUsage(e.usage);
@@ -4665,6 +4790,40 @@ var DOMAIN_AGENTS = [
         "information architecture"
       ]
     }
+  },
+  {
+    config: {
+      id: "ios",
+      name: "iOS",
+      role: "ios",
+      tools: [...TOOLS.build, "fetch"],
+      prompt: agentPrompt("ios")
+    },
+    budget: HEAVY_BUDGET,
+    capability: {
+      phase: "domain",
+      summary: "Apple-platform app development in Swift against the latest Xcode/iOS-SDK line: SwiftUI, UIKit, SwiftData, concurrency, accessibility, and App Store submission.",
+      keywords: [
+        "ios",
+        "iphone",
+        "ipad",
+        "ipados",
+        "watchos",
+        "tvos",
+        "visionos",
+        "macos",
+        "swift",
+        "swiftui",
+        "uikit",
+        "xcode",
+        "swiftdata",
+        "app store",
+        "app intents",
+        "swift package manager",
+        "cocoapods",
+        "foundation models"
+      ]
+    }
   }
 ];
 
@@ -5239,7 +5398,11 @@ var FLEET_ROSTER_BUDGETS = {
     idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
     maxIterations: 1e3,
     maxToolCalls: 2500,
-    maxTokens: 3e4,
+    // Monitoring passes routinely include a large system prompt plus fleet
+    // context. 30k was below observed single-pass usage and therefore triggered
+    // a post-response negotiation every run; 96k leaves headroom while the cost
+    // and tool/iteration caps still bound runaway work.
+    maxTokens: 96e3,
     maxCostUsd: 0.5
   },
   ...Object.fromEntries(
@@ -5642,7 +5805,7 @@ function createDelegateTool(opts) {
   };
 }
 async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abortSignal) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve14) => {
     let settled = false;
     let timer;
     let offAbort = () => {
@@ -5655,7 +5818,7 @@ async function awaitDelegateAttempt(director, subagentId, taskId, timeoutMs, abo
       offIter();
       offProgress();
       offAbort();
-      resolve12(value);
+      resolve14(value);
     };
     const arm = () => {
       if (timer) clearTimeout(timer);
@@ -6351,7 +6514,7 @@ var CollabSession = class extends EventEmitter {
     }
     for (const filePath of allFiles) {
       try {
-        const [content, stat12] = await Promise.all([
+        const [content, stat13] = await Promise.all([
           fsp4.readFile(filePath, "utf8"),
           fsp4.stat(filePath)
         ]);
@@ -6361,8 +6524,8 @@ var CollabSession = class extends EventEmitter {
           path: filePath,
           content,
           language,
-          snapshotMtimeMs: stat12.mtimeMs,
-          snapshotSizeBytes: stat12.size
+          snapshotMtimeMs: stat13.mtimeMs,
+          snapshotSizeBytes: stat13.size
         });
       } catch {
         this.snapshot.files.push({ path: filePath, content: "", language: void 0 });
@@ -6612,7 +6775,9 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
         level: "warning" /* WARNING */,
         message: `${role} hit ${payload.kind} soft limit (${payload.used}/${payload.limit})`,
         budgetKind: payload.kind,
-        elapsedMs: payload.timeoutMs,
+        // `used` is elapsed milliseconds for timeout kinds. `timeoutMs` is the
+        // negotiation response deadline (normally 60s), not agent runtime.
+        elapsedMs: payload.kind === "timeout" || payload.kind === "idle_timeout" ? payload.used : void 0,
         limit: payload.limit,
         btwNotes
       };
@@ -6636,12 +6801,10 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
           return;
         }
         this.lastTimeoutProgress.set(e.subagentId, progress);
-        const newLimit = Math.min(
-          Math.ceil((payload.timeoutMs ?? payload.limit) * 2),
-          24 * 60 * 6e4
-        );
+        const newLimit = Math.min(Math.ceil(payload.limit * 2), 24 * 60 * 6e4);
         setImmediate(() => {
-          payload.extend({ timeoutMs: newLimit });
+          const field = payload.kind === "timeout" ? "timeoutMs" : "idleTimeoutMs";
+          payload.extend({ [field]: newLimit });
         });
         return;
       }
@@ -6781,9 +6944,9 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     for (const file of this.snapshot.files) {
       if (file.snapshotMtimeMs === void 0 && file.snapshotSizeBytes === void 0) continue;
       try {
-        const stat12 = await fsp4.stat(file.path);
-        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat12.mtimeMs > file.snapshotMtimeMs + 1;
-        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat12.size !== file.snapshotSizeBytes;
+        const stat13 = await fsp4.stat(file.path);
+        const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat13.mtimeMs > file.snapshotMtimeMs + 1;
+        const sizeChanged = file.snapshotSizeBytes !== void 0 && stat13.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
           warnings.push(`${file.path} changed after the collab snapshot was captured.`);
         }
@@ -7046,6 +7209,8 @@ function rosterSummaryFromConfigs(roster) {
 import { randomUUID as randomUUID4 } from "node:crypto";
 import {
   claimReadyTask,
+  describeKanbanBoundary,
+  heartbeatTaskAssignment,
   listReadyTasks,
   updateTaskAssignment
 } from "@wrongstack/kanban";
@@ -7800,13 +7965,19 @@ function makeKanbanQueueTool(director, roster) {
       const projectRoot = ctx.projectRoot;
       if (!projectRoot) return { error: "kanban_queue requires ctx.projectRoot." };
       const maxTasks = Math.max(1, Math.min(20, Math.floor(i.maxTasks ?? 1)));
-      const leaseTtlMs = Math.max(1e3, Math.floor(i.leaseTtlMs ?? 5 * 60 * 1e3));
+      const baseLeaseTtlMs = Math.max(1e3, Math.floor(i.leaseTtlMs ?? 5 * 60 * 1e3));
+      const leaseTtlMs = i.awaitCompletion === true && i.timeoutMs !== void 0 ? Math.max(baseLeaseTtlMs, i.timeoutMs + 6e4) : baseLeaseTtlMs;
+      const heartbeatIntervalMs = Math.max(
+        5e3,
+        i.heartbeatIntervalMs ?? Math.floor(leaseTtlMs / 2)
+      );
+      const effectiveLeaseTtlMs = Math.max(leaseTtlMs, heartbeatIntervalMs * 2);
       const claimedAt = nowIso();
       const leaseSeeding = {
         leaseId: randomUUID4(),
         claimedAt,
         heartbeatAt: claimedAt,
-        leaseExpiresAt: new Date(Date.now() + leaseTtlMs).toISOString()
+        leaseExpiresAt: new Date(Date.now() + effectiveLeaseTtlMs).toISOString()
       };
       const candidateTaskIds = i.taskId !== void 0 ? [i.taskId] : i.query ? (await listReadyTasks(projectRoot, {
         ...i.boardId !== void 0 ? { boardId: i.boardId } : {}
@@ -7814,9 +7985,11 @@ function makeKanbanQueueTool(director, roster) {
       const dispatches = [];
       const errors = [];
       const resultFailures = [];
+      const budgetRejectedTaskIds = /* @__PURE__ */ new Set();
       for (let index = 0; index < maxTasks; index++) {
         const candidateTaskId = candidateTaskIds?.[index];
         if (candidateTaskIds && !candidateTaskId) break;
+        if (candidateTaskId && budgetRejectedTaskIds.has(candidateTaskId)) continue;
         const claim = await claimReadyTask(projectRoot, {
           ...i.boardId !== void 0 ? { boardId: i.boardId } : {},
           ...candidateTaskId !== void 0 ? { taskId: candidateTaskId } : {},
@@ -7841,14 +8014,22 @@ function makeKanbanQueueTool(director, roster) {
         if (costCeiling !== void 0) {
           const remaining = director.getRemainingBudgetUsd();
           if (remaining !== void 0 && remaining < costCeiling) {
-            await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
-              status: "failed",
-              error: `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`,
-              lastResult: "Skipped by kanban_queue cost gate (Sprint 3)"
-            });
+            budgetRejectedTaskIds.add(claim.task.id);
+            const budgetError = `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`;
+            await updateTaskAssignment(
+              projectRoot,
+              claim.board.id,
+              claim.task.id,
+              {
+                ...claim.task.assignment ?? {},
+                status: "failed",
+                error: budgetError
+              },
+              { expectedLeaseId: leaseSeeding.leaseId }
+            );
             errors.push({
               taskId: claim.task.id,
-              error: `Cost ceiling ${costCeiling} exceeds remaining budget ${remaining.toFixed(4)}`
+              error: budgetError
             });
             continue;
           }
@@ -7856,31 +8037,75 @@ function makeKanbanQueueTool(director, roster) {
         try {
           const config = buildKanbanSubagentConfig(claim.task, i, roster);
           subagentId = await director.spawn(config);
-          runTaskId = await director.assign({
-            id: randomUUID4(),
+          const dispatchTaskId = randomUUID4();
+          const taskSpec = {
+            id: dispatchTaskId,
             subagentId,
             description: buildKanbanFleetTaskPrompt(claim.board, claim.task, {
-              heartbeatIntervalMs: i.heartbeatIntervalMs ?? 6e4,
-              leaseTtlMs,
+              // The worker must heartbeat against the lease it actually holds.
+              // effectiveLeaseTtlMs is the real lease window (raised from the
+              // requested TTL when needed so the first heartbeat always lands
+              // before expiry), and the computed heartbeatIntervalMs is always
+              // strictly shorter than that window. Passing the raw requested
+              // values here would give the worker a 60s cadence against a
+              // 10s lease, letting the lease expire before its first renewal.
+              heartbeatIntervalMs,
+              leaseTtlMs: effectiveLeaseTtlMs,
               leaseId: leaseSeeding.leaseId,
               leaseExpiresAt: leaseSeeding.leaseExpiresAt
             }),
             ...i.maxToolCalls !== void 0 ? { maxToolCalls: i.maxToolCalls } : {},
             ...i.timeoutMs !== void 0 ? { timeoutMs: i.timeoutMs } : {},
             context: {
+              ...claim.task.type !== void 0 ? { taskType: claim.task.type } : {},
               kanban: {
                 boardId: claim.board.id,
                 taskId: claim.task.id,
-                origin: claim.task.origin
+                origin: claim.task.origin,
+                projectRoot
               }
             }
-          });
-          await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
-            ...claim.task.assignment ?? {},
-            status: "running",
-            subagentId,
-            runTaskId
-          });
+          };
+          const dispatched = await updateTaskAssignment(
+            projectRoot,
+            claim.board.id,
+            claim.task.id,
+            {
+              ...claim.task.assignment ?? {},
+              status: "running",
+              subagentId,
+              runTaskId: dispatchTaskId,
+              // Renew the lease from the actual dispatch moment, not from claim
+              // time. The claim-time lease starts before spawn + queueing, so
+              // `timeoutMs + 60_000` can expire while the worker is still
+              // queued or running, letting recover_stale reclaim and duplicate
+              // the assignment (see auto-extend.ts: timeout extensions can push
+              // execution well past the original timeoutMs). Both heartbeatAt
+              // and leaseExpiresAt are stamped from now so the worker has a
+              // full lease window from the moment it was actually dispatched.
+              heartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+              leaseExpiresAt: new Date(Date.now() + effectiveLeaseTtlMs).toISOString()
+            },
+            { expectedLeaseId: leaseSeeding.leaseId }
+          );
+          if (dispatched === null) {
+            try {
+              await director.terminate(subagentId);
+            } catch (cleanupErr) {
+              errors.push({
+                taskId: claim.task.id,
+                error: `Lease lost during dispatch; orphan subagent ${subagentId} termination failed: ${toErrorMessage(cleanupErr)}`
+              });
+              continue;
+            }
+            errors.push({
+              taskId: claim.task.id,
+              error: `Lease lost during dispatch (reassigned by recovery); subagent ${subagentId} terminated.`
+            });
+            continue;
+          }
+          await director.assign(taskSpec);
+          runTaskId = dispatchTaskId;
           dispatches.push({
             boardId: claim.board.id,
             taskId: claim.task.id,
@@ -7899,28 +8124,97 @@ function makeKanbanQueueTool(director, roster) {
               message = `${message}; cleanup failed for spawned subagent ${subagentId}: ${toErrorMessage(cleanupErr)}`;
             }
           }
-          await updateTaskAssignment(projectRoot, claim.board.id, claim.task.id, {
-            ...claim.task.assignment ?? {},
-            status: "failed",
-            ...subagentId !== void 0 ? { subagentId } : {},
-            ...runTaskId !== void 0 ? { runTaskId } : {},
-            error: message
-          });
+          await updateTaskAssignment(
+            projectRoot,
+            claim.board.id,
+            claim.task.id,
+            {
+              ...claim.task.assignment ?? {},
+              status: "failed",
+              ...subagentId !== void 0 ? { subagentId } : {},
+              ...runTaskId !== void 0 ? { runTaskId } : {},
+              error: message
+            },
+            { expectedLeaseId: leaseSeeding.leaseId }
+          );
           errors.push({ taskId: claim.task.id, error: message });
         }
       }
+      if (!i.awaitCompletion && dispatches.length > 0 && typeof director.fleet?.subscribe === "function") {
+        const ourLeaseId = leaseSeeding.leaseId;
+        const disposers = /* @__PURE__ */ new Map();
+        const renewalStartedAt = Date.now();
+        const maxRenewalWindowMs = 24 * 60 * 6e4;
+        const stopAll = () => {
+          clearInterval(renewalTimer);
+          for (const dispose of disposers.values()) dispose();
+          disposers.clear();
+        };
+        const renewalTimer = setInterval(() => {
+          if (disposers.size === 0 || Date.now() - renewalStartedAt > maxRenewalWindowMs) {
+            stopAll();
+            return;
+          }
+          const refreshedExpiry = new Date(Date.now() + effectiveLeaseTtlMs).toISOString();
+          for (const dispatch of dispatches) {
+            if (!disposers.has(dispatch.runTaskId)) continue;
+            void heartbeatTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
+              leaseExpiresAt: refreshedExpiry,
+              expectedLeaseId: ourLeaseId
+            }).catch(() => {
+            });
+          }
+        }, heartbeatIntervalMs);
+        renewalTimer.unref?.();
+        for (const dispatch of dispatches) {
+          const dispose = director.fleet.subscribe(dispatch.subagentId, (event) => {
+            if (event.type !== "subagent.completed" && event.type !== "subagent.stopped") return;
+            if (event.type === "subagent.completed" && event.taskId !== dispatch.runTaskId) return;
+            disposers.get(dispatch.runTaskId)?.();
+            disposers.delete(dispatch.runTaskId);
+            if (disposers.size === 0) clearInterval(renewalTimer);
+          });
+          disposers.set(dispatch.runTaskId, dispose);
+        }
+      }
       let results;
       if (i.awaitCompletion && dispatches.length > 0) {
-        results = await director.awaitTasks(dispatches.map((dispatch) => dispatch.runTaskId));
+        const ourLeaseId = leaseSeeding.leaseId;
+        const runTaskIds = new Set(dispatches.map((dispatch) => dispatch.runTaskId));
+        const heartbeatTimer = setInterval(async () => {
+          const refreshedExpiry = new Date(Date.now() + effectiveLeaseTtlMs).toISOString();
+          for (const dispatch of dispatches) {
+            if (!runTaskIds.has(dispatch.runTaskId)) continue;
+            try {
+              await heartbeatTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
+                leaseExpiresAt: refreshedExpiry,
+                expectedLeaseId: ourLeaseId
+              });
+            } catch {
+            }
+          }
+        }, heartbeatIntervalMs);
+        try {
+          results = await director.awaitTasks(dispatches.map((dispatch) => dispatch.runTaskId));
+        } finally {
+          clearInterval(heartbeatTimer);
+        }
         for (const result of results) {
           const dispatch = dispatches.find((candidate) => candidate.runTaskId === result.taskId);
           if (!dispatch) continue;
-          await updateTaskAssignment(projectRoot, dispatch.boardId, dispatch.taskId, {
-            status: result.status === "success" ? "completed" : "failed",
-            subagentId: result.subagentId,
-            runTaskId: result.taskId,
-            ...result.status === "success" ? { lastResult: resultToText(result) } : { error: resultErrorText(result) }
-          });
+          runTaskIds.delete(dispatch.runTaskId);
+          await updateTaskAssignment(
+            projectRoot,
+            dispatch.boardId,
+            dispatch.taskId,
+            {
+              status: result.status === "success" ? "completed" : "failed",
+              subagentId: result.subagentId,
+              runTaskId: result.taskId,
+              ...result.status === "success" ? { lastResult: resultToText(result) } : { error: resultErrorText(result) }
+            },
+            { expectedLeaseId: ourLeaseId }
+          );
           if (result.status !== "success") {
             resultFailures.push({
               taskId: dispatch.taskId,
@@ -8028,6 +8322,16 @@ function buildKanbanFleetTaskPrompt(board, task, lease) {
     task.origin.phaseId ? `phaseId: ${task.origin.phaseId}` : "",
     task.origin.taskId ? `sourceTaskId: ${task.origin.taskId}` : ""
   ].filter(Boolean).join("\n") : "";
+  const boundaries = [
+    board.boundary?.enabled ? `board: ${describeKanbanBoundary(board.boundary)}` : "",
+    task.boundary?.enabled ? `task: ${describeKanbanBoundary(task.boundary)}` : "",
+    ...(board.boundary?.allow ?? []).map(
+      (selector) => `board allow ${selector.access} ${selector.kind}:${selector.path}`
+    ),
+    ...(task.boundary?.allow ?? []).map(
+      (selector) => `task allow ${selector.access} ${selector.kind}:${selector.path}`
+    )
+  ].filter(Boolean);
   return [
     "You are processing a claimed WrongStack Kanban task.",
     "",
@@ -8050,6 +8354,8 @@ ${checks}` : "",
     metrics ? `Goal metrics:
 ${metrics}` : "",
     task.labels?.length ? `Labels: ${task.labels.join(", ")}` : "",
+    boundaries.length ? `BOUNDARY CONTRACT (enforced by the tool runtime; do not attempt to bypass):
+${boundaries.map((line) => `- ${line}`).join("\n")}` : "",
     "Lease contract (Sprint 1):",
     `- leaseId: ${lease.leaseId}`,
     `- claimedAt: ${task.assignment?.claimedAt ?? "<unknown>"}`,
@@ -8062,10 +8368,24 @@ ${metrics}` : "",
     `- maxAttempts: ${task.assignment?.maxAttempts ?? "<unset>"}`,
     `- costCeilingUsd: ${task.assignment?.costCeilingUsd ?? task.costCeilingUsd ?? "<unset>"}`,
     "",
-    "Work this task end-to-end. If scope is too broad or too small, use the kanban tool to split_task or merge_tasks instead of losing traceability.",
-    `When you start, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", and assignmentStatus "running". Include subagentId and runTaskId when you have them.`,
-    `To stay alive in the queue, call kanban with action "heartbeat_assignment", boardId "${board.id}", taskId "${task.id}", and heartbeatAt set to the current time. Cadence must be <= heartbeatIntervalMs and well before leaseExpiresAt.`,
-    `When you finish, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", and assignmentStatus "completed" or "failed". Include lastResult or error.`,
+    "Work this task end-to-end. Treat the board as a live plan, not a frozen assignment snapshot.",
+    `Before material work and whenever evidence changes the plan, call kanban with action "get_board" and boardId "${board.id}" to reassess current tasks, dependencies, priorities, and peer changes.`,
+    "You may use kanban add_task, update_task, split_task, merge_tasks, move_task, delete_task, or dependency actions when reassessment shows the plan should change. Preserve traceability and do not keep obsolete work merely because it existed at dispatch time.",
+    "",
+    "FIELD MAINTENANCE \u2014 keep every task detail current:",
+    '- Call "update_task" to refresh description, priority, type, labels, or estimatedHours as the work evolves.',
+    '- Call "add_note" with author and content to record progress, decisions, or roadblock context.',
+    '- Call "add_check" / "update_check" with description and status (pending/passed/failed) to track acceptance criteria.',
+    '- Call "add_goal_metric" / "update_goal_metric" with name and current/target to report measurable progress.',
+    '- Call "add_link" with url and type (issue/pr/doc/commit/design/file/url/other) to attach evidence.',
+    '- Call "update_task" to set actualHours when you have a final time estimate.',
+    "Do not leave stale or placeholder field values \u2014 the kanban board is the shared source of truth for every stakeholder.",
+    "",
+    "LEASE & LIFECYCLE:",
+    "Every successful board mutation updates shared pending work and notifies the owning session. Re-read the board after mutations and adapt to changes made by other agents; never assume your initial todo list remains authoritative.",
+    `When you start, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", assignmentStatus "running", and expectedLeaseId "${lease.leaseId}". Include subagentId and runTaskId when you have them. The expectedLeaseId fence makes the write a safe no-op if recover_stale already reassigned the task because your lease expired.`,
+    `To stay alive in the queue, call kanban with action "heartbeat_assignment", boardId "${board.id}", taskId "${task.id}", heartbeatAt set to the current time, and expectedLeaseId "${lease.leaseId}". Cadence must be <= heartbeatIntervalMs and well before leaseExpiresAt. The expectedLeaseId fence makes the heartbeat a safe no-op if the lease was reassigned, so a stale worker cannot renew a successor's lease.`,
+    `When you finish, call kanban with action "mark_assignment", boardId "${board.id}", taskId "${task.id}", assignmentStatus "completed" or "failed", and expectedLeaseId "${lease.leaseId}". Include lastResult or error. Populate every relevant detail field before the terminal mark_assignment so the card's final state is complete.`,
     `If you cannot finish in time, call kanban with action "heartbeat_assignment" to extend the lease, or with action "release_task" to release so another worker can claim. Do NOT silently abandon the assignment.`,
     'On failure the host may call kanban with action "recover_stale" (mode: retry/release/fail); respect its decisions and do not duplicate work in parallel.',
     "When finished, report what changed, what you verified, and any remaining blockers."
@@ -8549,25 +8869,32 @@ var FleetBus = class {
   }
   emit(event) {
     const byId = this.byId.get(event.subagentId);
-    if (byId)
-      for (const h of byId) {
+    if (byId && byId.size > 0) {
+      const snapshot = [...byId];
+      for (const h of snapshot) {
         try {
           h(event);
         } catch {
         }
       }
+    }
     const byType = this.byType.get(event.type);
-    if (byType)
-      for (const h of byType) {
+    if (byType && byType.size > 0) {
+      const snapshot = [...byType];
+      for (const h of snapshot) {
         try {
           h(event);
         } catch {
         }
       }
-    for (const h of this.any) {
-      try {
-        h(event);
-      } catch {
+    }
+    if (this.any.size > 0) {
+      const snapshot = [...this.any];
+      for (const h of snapshot) {
+        try {
+          h(event);
+        } catch {
+        }
       }
     }
   }
@@ -8749,21 +9076,28 @@ function hashStr(s) {
   return (h >>> 0).toString(36);
 }
 
+// src/types/blocks.ts
+function isTextBlock(b) {
+  return b.type === "text";
+}
+
 // src/types/provider.ts
 var CONTEXT_OVERFLOW_RE = /context.length|context.window|max.*tokens?.*exceeded|prompt is too long|too long|exceeds the context|\btokens\b.*exceed|context_length_exceeded/i;
 var CONTENT_FILTER_RE = /content.(filter|policy|moderation)|safety (system|filter)/i;
+var QUOTA_EXHAUSTED_RE = /(?:insufficient|exhausted|depleted|exceeded|no|not enough)[-_\s]*(?:quota|credit|balance)|(?:quota|credit|balance)[-_\s]*(?:exhausted|depleted|exceeded|insufficient)|billing[_\s-]*(?:hard[_\s-]*)?limit|payment required|spending limit|plan limit/i;
 function classifyProviderError(status, body, message) {
   const type = body?.type;
+  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
   if (status === 0) return "network";
   if (status === 408) return "timeout";
   if (status === 599) return "stream_hang";
+  if (status === 402 || QUOTA_EXHAUSTED_RE.test(text)) return "quota_exhausted";
   if (type === "rate_limit_error" || status === 429) return "rate_limit";
   if (type === "overloaded_error" || status === 529) return "overloaded";
   if (status >= 500) return "server";
   if (type === "authentication_error" || type === "permission_error" || status === 401 || status === 403) {
     return "auth";
   }
-  const text = [message, body?.message, type, body?.raw].filter(Boolean).join("\n");
   if (type === "content_filter" || CONTENT_FILTER_RE.test(text)) return "content_filter";
   if (status === 413 || status >= 400 && CONTEXT_OVERFLOW_RE.test(text)) {
     return "context_overflow";
@@ -8776,6 +9110,7 @@ function isRetryableKind(kind) {
 }
 var RETRYABLE_BY_KIND = {
   rate_limit: true,
+  quota_exhausted: false,
   overloaded: true,
   server: true,
   timeout: true,
@@ -8854,6 +9189,7 @@ var KIND_TO_CODE = {
   network: ERROR_CODES.PROVIDER_NETWORK_ERROR,
   timeout: ERROR_CODES.PROVIDER_NETWORK_ERROR,
   rate_limit: ERROR_CODES.PROVIDER_RATE_LIMITED,
+  quota_exhausted: ERROR_CODES.PROVIDER_RATE_LIMITED,
   auth: ERROR_CODES.PROVIDER_AUTH_FAILED,
   overloaded: ERROR_CODES.PROVIDER_OVERLOADED,
   context_overflow: ERROR_CODES.PROVIDER_CONTEXT_OVERFLOW,
@@ -8953,6 +9289,7 @@ function classifySubagentError(err, hints = {}) {
 function providerErrorToSubagentError(err, message, cause) {
   switch (err.kind) {
     case "rate_limit":
+    case "quota_exhausted":
       return {
         kind: "provider_rate_limit",
         message,
@@ -9360,7 +9697,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((resolve12, reject) => {
+        return new Promise((resolve14, reject) => {
           const timeout = setTimeout(() => {
             this.off("task.completed", handler);
             reject(new Error(`awaitTasks timed out waiting for task "${id}"`));
@@ -9369,7 +9706,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             if (result.taskId === id) {
               clearTimeout(timeout);
               this.off("task.completed", handler);
-              resolve12(result);
+              resolve14(result);
             }
           };
           this.on("task.completed", handler);
@@ -9394,13 +9731,13 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       const done = new Set(completed.map((r) => r.taskId));
       return { completed, pending: taskIds.filter((id) => !done.has(id)) };
     }
-    return new Promise((resolve12) => {
+    return new Promise((resolve14) => {
       let timer;
       const handler = ({ result }) => {
         if (!ids.has(result.taskId)) return;
         if (timer) clearTimeout(timer);
         this.off("task.completed", handler);
-        resolve12({
+        resolve14({
           completed: [result],
           pending: taskIds.filter((id) => id !== result.taskId)
         });
@@ -9408,7 +9745,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
       if (opts?.timeoutMs !== void 0) {
         timer = setTimeout(() => {
           this.off("task.completed", handler);
-          resolve12({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve14({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.on("task.completed", handler);
@@ -9690,12 +10027,12 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
             }
             return new Promise((resolveDecision) => {
               let settled = false;
-              const resolve12 = (d) => {
+              const resolve14 = (d) => {
                 if (settled) return;
                 settled = true;
                 resolveDecision(d);
               };
-              const fallback = setTimeout(() => resolve12("stop"), DECISION_TIMEOUT_MS);
+              const fallback = setTimeout(() => resolve14("stop"), DECISION_TIMEOUT_MS);
               const sessionId = this.currentSessionId();
               budget._events?.emit("budget.threshold_reached", {
                 ...sessionId ? { sessionId } : {},
@@ -9713,11 +10050,11 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
                 // disagreeing, resolves as a stop). Async grants still resolve.
                 extend: (extra) => {
                   clearTimeout(fallback);
-                  queueMicrotask(() => resolve12({ extend: extra }));
+                  queueMicrotask(() => resolve14({ extend: extra }));
                 },
                 deny: () => {
                   clearTimeout(fallback);
-                  resolve12("stop");
+                  resolve14("stop");
                 }
               });
             });
@@ -10340,6 +10677,8 @@ var Director = class _Director {
   collab;
   /** Prevents large `ask_subagent` answers from bloating the leader's context window. */
   largeAnswerStore;
+  /** Shared provider/model status tracker, or undefined. */
+  statusTracker;
   constructor(opts) {
     this.id = opts.config.coordinatorId || randomUUID6();
     this.brain = opts.brain;
@@ -10378,6 +10717,7 @@ var Director = class _Director {
       opts.checkpointDebounceMs ?? 250
     ) : null;
     this.fleetManager = opts.fleetManager;
+    this.statusTracker = opts.statusTracker;
     this.logger = opts.logger;
     if (this.sharedScratchpadPath) {
       void fsp5.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
@@ -10500,6 +10840,14 @@ var Director = class _Director {
         title
       }
     );
+    if (failed) {
+      void this.appendSessionEvent({
+        type: "agent_error",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        agentId: r.subagentId,
+        error: errorString ?? r.status
+      });
+    }
     if (this.fleetManager) {
       void this.fleetManager.flushManifest();
     } else {
@@ -10582,53 +10930,53 @@ var Director = class _Director {
           payload.extend(extra);
         });
       };
-      if (this.brain) {
-        void this.brain.decide({
-          id: `director-budget-${e.subagentId}-${payload.kind}`,
-          sessionId: this.currentSessionId(),
-          source: "director",
-          question: `Should the director extend the ${payload.kind} budget for subagent ${e.subagentId}?`,
-          context: [
-            e.taskId ? `Task id: ${e.taskId}` : void 0,
-            `Used: ${payload.used}`,
-            `Limit: ${payload.limit}`,
-            `Prior extensions for this kind: ${prior}`
-          ].filter(Boolean).join("\n"),
-          risk: payload.kind === "cost" ? "high" : "medium",
-          fallback: "continue",
-          options: [
-            {
-              id: "extend",
-              label: "Grant the director default budget extension",
-              consequence: "The subagent continues with a larger per-kind budget.",
-              risk: payload.kind === "cost" ? "high" : "medium",
-              recommended: true
-            },
-            {
-              id: "stop",
-              label: "Stop this subagent at the current budget limit",
-              consequence: "The current task will fail or stop due to budget pressure.",
-              risk: "low"
-            }
-          ]
-        }).then((decision) => {
-          if (decision.type === "deny") {
-            payload.deny();
-            return;
-          }
-          if (decision.type === "ask_human") {
-            payload.deny();
-            return;
-          }
-          if (decision.optionId === "stop") {
-            payload.deny();
-            return;
-          }
-          grantExtension();
-        }).catch(() => payload.deny());
+      if (payload.kind !== "cost" || !this.brain) {
+        grantExtension();
         return;
       }
-      grantExtension();
+      void this.brain.decide({
+        id: `director-budget-${e.subagentId}-${payload.kind}`,
+        sessionId: this.currentSessionId(),
+        source: "director",
+        question: `Should the director extend the ${payload.kind} budget for subagent ${e.subagentId}?`,
+        context: [
+          e.taskId ? `Task id: ${e.taskId}` : void 0,
+          `Used: ${payload.used}`,
+          `Limit: ${payload.limit}`,
+          `Prior extensions for this kind: ${prior}`
+        ].filter(Boolean).join("\n"),
+        risk: "high",
+        fallback: "continue",
+        options: [
+          {
+            id: "extend",
+            label: "Grant the director default budget extension",
+            consequence: "The subagent continues with a larger cost budget.",
+            risk: "high",
+            recommended: true
+          },
+          {
+            id: "stop",
+            label: "Stop this subagent at the current budget limit",
+            consequence: "The current task will fail or stop due to budget pressure.",
+            risk: "low"
+          }
+        ]
+      }).then((decision) => {
+        if (decision.type === "deny") {
+          payload.deny();
+          return;
+        }
+        if (decision.type === "ask_human") {
+          payload.deny();
+          return;
+        }
+        if (decision.optionId === "stop") {
+          payload.deny();
+          return;
+        }
+        grantExtension();
+      }).catch(() => payload.deny());
     });
   }
   /**
@@ -10886,7 +11234,18 @@ var Director = class _Director {
       if (entry?.model) {
         config.model = entry.model;
         if (entry.provider) config.provider = entry.provider;
+        if (entry.fallbackProfile) config.fallbackProfile = entry.fallbackProfile;
         if (entry.modelRuntime) config.modelRuntime = entry.modelRuntime;
+      } else if (entry?.fallbackProfile) {
+        config.fallbackProfile = entry.fallbackProfile;
+        if (entry.modelRuntime) config.modelRuntime = entry.modelRuntime;
+      }
+    }
+    if (this.statusTracker && config.provider && config.model) {
+      if (!this.statusTracker.isAvailable(config.provider, config.model)) {
+        this.logger?.warn(
+          `spawn: resolved model "${config.provider}/${config.model}" for role "${config.role ?? "?"}" is blocked by the status tracker. The subagent will attempt its fallback chain.`
+        );
       }
     }
   }
@@ -11291,11 +11650,11 @@ var Director = class _Director {
         if (cached) return cached;
         const existing = this.taskWaiters.get(id);
         if (existing) return existing.promise;
-        let resolve12;
+        let resolve14;
         const promise = new Promise((res) => {
-          resolve12 = res;
+          resolve14 = res;
         });
-        this.taskWaiters.set(id, { promise, resolve: resolve12 });
+        this.taskWaiters.set(id, { promise, resolve: resolve14 });
         return promise;
       })
     );
@@ -11324,10 +11683,10 @@ var Director = class _Director {
         pending: taskIds.filter((id) => !done.has(id))
       });
     }
-    return new Promise((resolve12) => {
+    return new Promise((resolve14) => {
       const entry = {
         ids: new Set(taskIds),
-        resolve: (r) => resolve12({
+        resolve: (r) => resolve14({
           completed: [r],
           pending: taskIds.filter((id) => id !== r.taskId)
         })
@@ -11335,7 +11694,7 @@ var Director = class _Director {
       if (opts?.timeoutMs !== void 0) {
         entry.timer = setTimeout(() => {
           this.anyWaiters.delete(entry);
-          resolve12({ completed: [], pending: [...taskIds], timedOut: true });
+          resolve14({ completed: [], pending: [...taskIds], timedOut: true });
         }, opts.timeoutMs);
       }
       this.anyWaiters.add(entry);
@@ -11396,6 +11755,11 @@ var Director = class _Director {
   }
   async remove(subagentId) {
     this.clearSubagentIdleRetirement(subagentId);
+    void this.appendSessionEvent({
+      type: "agent_stopped",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      agentId: subagentId
+    });
     await this.coordinator.remove(subagentId);
     const bridge = this.subagentBridges.get(subagentId);
     if (bridge) {
@@ -11770,24 +12134,24 @@ var FileSessionWriter = class _FileSessionWriter {
   /**
    * Scrub secrets out of conversation-turn events before they are observed
    * for the summary, written to the JSONL log, or surfaced on resume. Only
-   * `user_input`, `llm_response`, and `context_snapshot` carry free-form
-   * user/model text; other event types either have no secret-bearing content
-   * or are already scrubbed upstream (tool results). Snapshot normalization
-   * also strips transient token-cache fields even when no scrubber is set.
+   * Conversation events carry free-form user/model text. Snapshot and exact
+   * message-journal normalization also strips transient token-cache fields
+   * even when no scrubber is set.
    */
   scrubEvent(event) {
     const s = this.secretScrubber;
-    if (event.type === "context_snapshot") {
+    const persistMessage = (message) => {
+      const { _estTokens: _ignored, ...persisted } = message;
       return {
-        ...event,
-        messages: event.messages.map((message) => {
-          const { _estTokens: _ignored, ...persisted } = message;
-          return {
-            ...persisted,
-            content: typeof persisted.content === "string" ? s?.scrub(persisted.content) ?? persisted.content : s?.scrubObject(persisted.content) ?? persisted.content
-          };
-        })
+        ...persisted,
+        content: typeof persisted.content === "string" ? s?.scrub(persisted.content) ?? persisted.content : s?.scrubObject(persisted.content) ?? persisted.content
       };
+    };
+    if (event.type === "context_snapshot" || event.type === "messages_replaced") {
+      return { ...event, messages: event.messages.map(persistMessage) };
+    }
+    if (event.type === "message_appended" || event.type === "message_updated") {
+      return { ...event, message: persistMessage(event.message) };
     }
     if (!s) return event;
     if (event.type === "user_input") {
@@ -11842,7 +12206,8 @@ var FileSessionWriter = class _FileSessionWriter {
     this.bufferSynchronousEvent(event);
   }
   recordFileObservation(input) {
-    if (!input.path || !/^[a-f\d]{64}$/i.test(input.hash) || !Number.isFinite(input.mtimeMs)) return;
+    if (!input.path || !/^[a-f\d]{64}$/i.test(input.hash) || !Number.isFinite(input.mtimeMs))
+      return;
     this.bufferSynchronousEvent({
       type: "file_observation",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
@@ -12004,12 +12369,7 @@ var FileSessionWriter = class _FileSessionWriter {
       const now = Date.now();
       if (now - this.lastAppendWarnAt > 5e3) {
         const suppressed = this.appendFailCount - 1;
-        const tail = suppressed > 0 ? ` (+${suppressed} suppressed)` : "";
-        console.warn(
-          "[session] flush failed:",
-          toErrorMessage(err),
-          tail
-        );
+        console.warn(JSON.stringify({ level: "warn", event: "session.flush_failed", sessionId: this.id, message: toErrorMessage(err), ...suppressed > 0 ? { suppressed } : {}, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
         this.lastAppendWarnAt = now;
         this.appendFailCount = 0;
       }
@@ -12029,6 +12389,43 @@ var FileSessionWriter = class _FileSessionWriter {
       });
     }
   }
+  /**
+   * Rebuild every accumulated summary counter by replaying the JSONL as it now
+   * stands on disk.
+   *
+   * Only truncation needs this: the counters are fed by `observeForSummary` as
+   * events go by and cannot un-count. Reading the whole file is fine here —
+   * rewind is a rare, explicitly user-driven operation, and the alternative
+   * (reversing each counter per discarded event) has to stay in lockstep with
+   * observeForSummary forever.
+   *
+   * `title` is deliberately re-derived too: the first surviving user_input may
+   * differ once earlier prompts are gone.
+   */
+  async recomputeSummaryFromDisk() {
+    if (!this.filePath) return;
+    const raw = await fsp6.readFile(this.filePath, "utf8").catch(() => null);
+    if (raw === null) return;
+    this.iterationCount = 0;
+    this.toolCallCount = 0;
+    this.toolErrorCount = 0;
+    this.toolBreakdown = {};
+    this.fileChangeCount = 0;
+    this.compactionCount = 0;
+    this.outcome = void 0;
+    this.openToolUses = /* @__PURE__ */ new Set();
+    this.tokenIn = 0;
+    this.tokenOut = 0;
+    this.summary = { ...this.summary, title: "(empty session)", tokenTotal: 0 };
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) continue;
+      try {
+        this.observeForSummary(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+  }
   observeForSummary(event) {
     if (event.type === "llm_response") {
       for (const block of event.content) {
@@ -12079,10 +12476,7 @@ var FileSessionWriter = class _FileSessionWriter {
   }
   async doClose() {
     if (this.pendingFileSnapshots.length > 0) {
-      await this.writeFileSnapshot(
-        this.activePromptIndex ?? 0,
-        [...this.pendingFileSnapshots]
-      );
+      await this.writeFileSnapshot(this.activePromptIndex ?? 0, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
     this.closed = true;
@@ -12202,7 +12596,7 @@ var FileSessionWriter = class _FileSessionWriter {
    * so post-checkpoint content is never read or parsed — O(1) memory instead
    * of O(N) JSON.parse calls over the full file.
    */
-  async truncateToCheckpoint(targetPromptIndex) {
+  async truncateToCheckpoint(targetPromptIndex, revertedFiles = []) {
     if (!this.filePath) return 0;
     if (this.flushTimer) {
       clearTimeout(this.flushTimer);
@@ -12213,7 +12607,7 @@ var FileSessionWriter = class _FileSessionWriter {
     const CHUNK_SIZE = 65536;
     let fd;
     let fileOffset = 0;
-    let lineStartOffset = 0;
+    let pendingLine = Buffer.alloc(0);
     let checkpointByteOffset = -1;
     let removedCount = 0;
     let targetCheckpointSeen = false;
@@ -12223,17 +12617,18 @@ var FileSessionWriter = class _FileSessionWriter {
         const buf = Buffer.alloc(CHUNK_SIZE);
         const { bytesRead } = await fd.read(buf, 0, CHUNK_SIZE, fileOffset);
         if (bytesRead === 0) break;
+        const carriedBytes = pendingLine.length;
+        const chunk = carriedBytes === 0 ? buf.subarray(0, bytesRead) : Buffer.concat([pendingLine, buf.subarray(0, bytesRead)]);
+        const chunkFileOffset = fileOffset - carriedBytes;
         let chunkPos = 0;
-        while (chunkPos < bytesRead) {
-          const idx = buf.indexOf("\n", chunkPos);
-          if (idx === -1) {
-            lineStartOffset = fileOffset + chunkPos;
-            break;
-          }
+        while (chunkPos < chunk.length) {
+          const idx = chunk.indexOf("\n", chunkPos);
+          if (idx === -1) break;
+          const lineStartOffset = chunkFileOffset + chunkPos;
           if (checkpointByteOffset !== -1) {
             removedCount++;
           } else {
-            const lineBytes = buf.subarray(chunkPos, idx);
+            const lineBytes = chunk.subarray(chunkPos, idx);
             const line = new TextDecoder("utf-8", { fatal: false }).decode(lineBytes);
             if (line.trim()) {
               try {
@@ -12259,12 +12654,9 @@ var FileSessionWriter = class _FileSessionWriter {
             }
           }
           chunkPos = idx + 1;
-          lineStartOffset = fileOffset + chunkPos;
         }
+        pendingLine = chunk.subarray(chunkPos);
         fileOffset += bytesRead;
-        if (chunkPos >= bytesRead) {
-          lineStartOffset = fileOffset;
-        }
       }
     } finally {
       await fd?.close();
@@ -12344,17 +12736,19 @@ var FileSessionWriter = class _FileSessionWriter {
       this.handle = await fsp6.open(this.filePath, "a", 384).catch(() => this.handle);
       throw err;
     }
+    await this.recomputeSummaryFromDisk();
+    const reverted = [...revertedFiles];
     await this.append({
       type: "rewound",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       toPromptIndex: targetPromptIndex,
-      revertedFiles: []
+      revertedFiles: reverted
     });
     this.activePromptIndex = targetPromptIndex;
     this.events?.emit("session.rewound", {
       sessionId: this.id,
       toPromptIndex: targetPromptIndex,
-      revertedFiles: [],
+      revertedFiles: reverted,
       removedEvents: removedCount
     });
     return removedCount;
@@ -12395,7 +12789,11 @@ var FileSessionWriter = class _FileSessionWriter {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       context
     });
-    this.events?.emit("in_flight.started", { sessionId: this.id, context, ts: (/* @__PURE__ */ new Date()).toISOString() });
+    this.events?.emit("in_flight.started", {
+      sessionId: this.id,
+      context,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
   /**
    * Close the in-flight marker. Idempotent in spirit
@@ -12406,10 +12804,7 @@ var FileSessionWriter = class _FileSessionWriter {
    */
   async clearInFlightMarker(reason) {
     if (this.pendingFileSnapshots.length > 0) {
-      await this.writeFileSnapshot(
-        this.activePromptIndex ?? 0,
-        [...this.pendingFileSnapshots]
-      );
+      await this.writeFileSnapshot(this.activePromptIndex ?? 0, [...this.pendingFileSnapshots]);
       this.pendingFileSnapshots = [];
     }
     await this.append({
@@ -12417,7 +12812,11 @@ var FileSessionWriter = class _FileSessionWriter {
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       reason
     });
-    this.events?.emit("in_flight.ended", { sessionId: this.id, reason, ts: (/* @__PURE__ */ new Date()).toISOString() });
+    this.events?.emit("in_flight.ended", {
+      sessionId: this.id,
+      reason,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
 };
 
@@ -12456,8 +12855,8 @@ function sha256(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
 function isInside(root, target) {
-  const relative4 = path9.relative(root, target);
-  return relative4 === "" || !relative4.startsWith("..") && !path9.isAbsolute(relative4);
+  const relative5 = path9.relative(root, target);
+  return relative5 === "" || !relative5.startsWith("..") && !path9.isAbsolute(relative5);
 }
 function normalizeRelative(input) {
   if (!input || path9.isAbsolute(input)) return null;
@@ -12469,8 +12868,8 @@ function normalizeRelative(input) {
 function parseNulPaths(output) {
   return output.split("\0").map(normalizeRelative).filter((value) => value !== null);
 }
-function isWrongStackWorktreePath(relative4) {
-  return relative4 === ".wrongstack/worktrees" || relative4.startsWith(".wrongstack/worktrees/");
+function isWrongStackWorktreePath(relative5) {
+  return relative5 === ".wrongstack/worktrees" || relative5.startsWith(".wrongstack/worktrees/");
 }
 var SessionCheckpointCas = class {
   rootDir;
@@ -12496,60 +12895,60 @@ var SessionCheckpointCas = class {
     }
     const relativePaths = [
       .../* @__PURE__ */ new Set([...parseNulPaths(tracked.stdout), ...parseNulPaths(untracked.stdout)])
-    ].filter((relative4) => !isWrongStackWorktreePath(relative4)).sort();
+    ].filter((relative5) => !isWrongStackWorktreePath(relative5)).sort();
     const unresolved = [];
     let scheduledBytes = 0;
     const captured = await mapWithConcurrency(
       relativePaths,
       CAPTURE_CONCURRENCY,
-      async (relative4) => {
-        const absolute = path9.resolve(this.projectRoot, ...relative4.split("/"));
+      async (relative5) => {
+        const absolute = path9.resolve(this.projectRoot, ...relative5.split("/"));
         if (!isInside(this.projectRoot, absolute)) {
-          unresolved.push({ path: relative4, reason: "path escapes project root" });
+          unresolved.push({ path: relative5, reason: "path escapes project root" });
           return null;
         }
         try {
-          const stat12 = await fsp7.lstat(absolute);
-          if (stat12.isSymbolicLink()) {
+          const stat13 = await fsp7.lstat(absolute);
+          if (stat13.isSymbolicLink()) {
             const linkTarget = await fsp7.readlink(absolute);
             const resolvedLink = path9.resolve(path9.dirname(absolute), linkTarget);
             if (path9.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
               unresolved.push({
-                path: relative4,
+                path: relative5,
                 reason: "symlink target escapes project root"
               });
               return null;
             }
-            return { path: relative4, state: "symlink", linkTarget };
+            return { path: relative5, state: "symlink", linkTarget };
           }
-          if (!stat12.isFile()) {
-            unresolved.push({ path: relative4, reason: "changed path is not a regular file" });
+          if (!stat13.isFile()) {
+            unresolved.push({ path: relative5, reason: "changed path is not a regular file" });
             return null;
           }
-          if (stat12.size > MAX_BLOB_BYTES) {
+          if (stat13.size > MAX_BLOB_BYTES) {
             unresolved.push({
-              path: relative4,
+              path: relative5,
               reason: `file exceeds ${MAX_BLOB_BYTES}-byte checkpoint blob limit`
             });
             return null;
           }
-          if (scheduledBytes + stat12.size > MAX_CHECKPOINT_BYTES) {
+          if (scheduledBytes + stat13.size > MAX_CHECKPOINT_BYTES) {
             unresolved.push({
-              path: relative4,
+              path: relative5,
               reason: `checkpoint exceeds ${MAX_CHECKPOINT_BYTES}-byte aggregate blob limit`
             });
             return null;
           }
-          scheduledBytes += stat12.size;
+          scheduledBytes += stat13.size;
           const content = await fsp7.readFile(absolute);
           const blobHash = sha256(content);
           await this.putBlob(blobHash, content);
-          return { path: relative4, state: "file", blobHash, mode: stat12.mode & 511 };
+          return { path: relative5, state: "file", blobHash, mode: stat13.mode & 511 };
         } catch (err) {
           if (err.code === "ENOENT") {
-            return { path: relative4, state: "absent" };
+            return { path: relative5, state: "absent" };
           }
-          unresolved.push({ path: relative4, reason: toErrorMessage(err) });
+          unresolved.push({ path: relative5, reason: toErrorMessage(err) });
           return null;
         }
       }
@@ -12661,20 +13060,20 @@ var SessionCheckpointCas = class {
     }
     return { targetRoot: target, writtenFiles, deletedFiles, errors };
   }
-  objectPath(hash) {
-    if (!HASH_RE.test(hash)) throw new Error(`Invalid CAS object hash: ${hash}`);
-    return path9.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
+  objectPath(hash2) {
+    if (!HASH_RE.test(hash2)) throw new Error(`Invalid CAS object hash: ${hash2}`);
+    return path9.join(this.rootDir, "objects", hash2.slice(0, 2), hash2.slice(2));
   }
-  manifestPath(hash) {
-    if (!HASH_RE.test(hash)) throw new Error(`Invalid checkpoint manifest hash: ${hash}`);
-    return path9.join(this.rootDir, "manifests", `${hash}.json`);
+  manifestPath(hash2) {
+    if (!HASH_RE.test(hash2)) throw new Error(`Invalid checkpoint manifest hash: ${hash2}`);
+    return path9.join(this.rootDir, "manifests", `${hash2}.json`);
   }
-  async putBlob(hash, content) {
-    const target = this.objectPath(hash);
+  async putBlob(hash2, content) {
+    const target = this.objectPath(hash2);
     await fsp7.mkdir(path9.dirname(target), { recursive: true });
     try {
       const existing = await fsp7.readFile(target);
-      if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
+      if (sha256(existing) !== hash2) throw new Error(`Corrupt CAS object collision: ${hash2}`);
       return;
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
@@ -12695,33 +13094,33 @@ var SessionCheckpointCas = class {
       } catch (err) {
         if (err.code !== "EEXIST") throw err;
         const existing = await fsp7.readFile(target);
-        if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
+        if (sha256(existing) !== hash2) throw new Error(`Corrupt CAS object collision: ${hash2}`);
       }
     } finally {
       await handle?.close().catch(() => void 0);
       await fsp7.unlink(temp).catch(() => void 0);
     }
   }
-  async putManifest(hash, encoded) {
-    const target = this.manifestPath(hash);
+  async putManifest(hash2, encoded) {
+    const target = this.manifestPath(hash2);
     const existing = await fsp7.readFile(target).catch(() => null);
     if (existing) {
-      if (sha256(existing) !== hash) throw new Error(`Corrupt checkpoint manifest collision: ${hash}`);
+      if (sha256(existing) !== hash2) throw new Error(`Corrupt checkpoint manifest collision: ${hash2}`);
       return;
     }
     await atomicWrite(target, encoded, { mode: 384 });
   }
-  async readBlob(hash) {
-    const content = await fsp7.readFile(this.objectPath(hash));
-    if (sha256(content) !== hash) throw new Error(`CAS blob integrity check failed: ${hash}`);
+  async readBlob(hash2) {
+    const content = await fsp7.readFile(this.objectPath(hash2));
+    if (sha256(content) !== hash2) throw new Error(`CAS blob integrity check failed: ${hash2}`);
     return content;
   }
-  async loadManifest(hash) {
-    const raw = await fsp7.readFile(this.manifestPath(hash));
-    if (sha256(raw) !== hash) throw new Error(`Checkpoint manifest integrity check failed: ${hash}`);
+  async loadManifest(hash2) {
+    const raw = await fsp7.readFile(this.manifestPath(hash2));
+    if (sha256(raw) !== hash2) throw new Error(`Checkpoint manifest integrity check failed: ${hash2}`);
     const parsed = JSON.parse(raw.toString("utf8"));
     if (parsed.version !== 1 || typeof parsed.baseHead !== "string" || parsed.coverage !== "git-head-plus-dirty" || !Array.isArray(parsed.entries) || !Array.isArray(parsed.unresolved)) {
-      throw new Error(`Invalid workspace checkpoint manifest: ${hash}`);
+      throw new Error(`Invalid workspace checkpoint manifest: ${hash2}`);
     }
     const entriesValid = parsed.entries.every((entry) => {
       if (!entry || typeof entry !== "object") return false;
@@ -12735,12 +13134,12 @@ var SessionCheckpointCas = class {
       (entry) => entry !== null && typeof entry === "object" && typeof entry.path === "string" && typeof entry.reason === "string"
     );
     if (!entriesValid || !unresolvedValid) {
-      throw new Error(`Invalid workspace checkpoint manifest entries: ${hash}`);
+      throw new Error(`Invalid workspace checkpoint manifest entries: ${hash2}`);
     }
     return parsed;
   }
-  async safeOutputPath(target, realTarget, relative4) {
-    const normalized = normalizeRelative(relative4);
+  async safeOutputPath(target, realTarget, relative5) {
+    const normalized = normalizeRelative(relative5);
     if (!normalized) throw new Error("invalid relative path");
     const output = path9.resolve(target, ...normalized.split("/"));
     if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
@@ -12760,7 +13159,7 @@ var SessionCheckpointCas = class {
   }
 };
 function defaultRunGit(args, cwd) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve14) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     let stdoutBytes = 0;
@@ -12803,11 +13202,18 @@ function defaultRunGit(args, cwd) {
       stdoutTruncated,
       stderrTruncated
     });
-    child.on("error", (err) => resolve12(result(1, err.message)));
-    child.on("close", (code) => resolve12(result(code ?? 1)));
+    child.on("error", (err) => resolve14(result(1, err.message)));
+    child.on("close", (code) => resolve14(result(code ?? 1)));
   });
 }
 
+// src/storage/session-id.ts
+function generateSessionId(startedAt, _model) {
+  const date = startedAt.slice(0, 10);
+  const seedTime = Number.isNaN(Date.parse(startedAt)) ? Date.now() : Date.parse(startedAt);
+  return `${date}/sess_${ulid(seedTime)}`;
+}
+
 // src/storage/session-resume-validation.ts
 import { createHash as createHash3 } from "node:crypto";
 import * as fsp8 from "node:fs/promises";
@@ -12816,8 +13222,8 @@ var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
 var VALIDATION_CONCURRENCY = 8;
 var NOTICE_PATH_LIMIT = 20;
 function isInside2(root, target) {
-  const relative4 = path10.relative(root, target);
-  return relative4 === "" || !relative4.startsWith("..") && !path10.isAbsolute(relative4);
+  const relative5 = path10.relative(root, target);
+  return relative5 === "" || !relative5.startsWith("..") && !path10.isAbsolute(relative5);
 }
 function errno(err) {
   return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
@@ -12865,11 +13271,11 @@ async function validateOne(observation, lexicalRoot, realRoot) {
     };
   }
   try {
-    const stat12 = await fsp8.stat(realFile);
-    if (!stat12.isFile()) {
+    const stat13 = await fsp8.stat(realFile);
+    if (!stat13.isFile()) {
       return { ...base, status: "unreadable", detail: "Path is no longer a regular file." };
     }
-    if (stat12.size > MAX_REVALIDATE_BYTES) {
+    if (stat13.size > MAX_REVALIDATE_BYTES) {
       return {
         ...base,
         status: "unreadable",
@@ -12904,8 +13310,8 @@ function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
   const root = path10.resolve(projectRoot);
   const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
-    const relative4 = path10.relative(root, entry.path);
-    const display = isInside2(root, entry.path) ? relative4 || "." : entry.path;
+    const relative5 = path10.relative(root, entry.path);
+    const display = isInside2(root, entry.path) ? relative5 || "." : entry.path;
     return `- ${JSON.stringify(display)} [${entry.status}]`;
   });
   const omitted = validation.staleFiles.length - shown.length;
@@ -12917,12 +13323,14 @@ function formatResumeValidationNotice(validation, projectRoot) {
     ...shown
   ].join("\n");
 }
-
-// src/storage/session-id.ts
-function generateSessionId(startedAt, _model) {
-  const date = startedAt.slice(0, 10);
-  const seedTime = Number.isNaN(Date.parse(startedAt)) ? Date.now() : Date.parse(startedAt);
-  return `${date}/sess_${ulid(seedTime)}`;
+function formatInterruptedToolNotice(pendingToolUseCount) {
+  if (!Number.isFinite(pendingToolUseCount) || pendingToolUseCount <= 0) return null;
+  const plural = pendingToolUseCount === 1 ? "tool call was" : "tool calls were";
+  return [
+    "[SESSION RESUME INTERRUPTED WORK]",
+    `The previous run left ${pendingToolUseCount} ${plural} in flight \u2014 no result was recorded before it stopped (crash or interrupt).`,
+    "Those interrupted tool calls were removed from the restored conversation and were NOT re-executed. Re-run the work if it still needs doing."
+  ].join("\n");
 }
 
 // src/storage/session-summary.ts
@@ -12968,18 +13376,27 @@ function isReplayableMessage(value) {
   const candidate = value;
   return (candidate.role === "user" || candidate.role === "assistant" || candidate.role === "system") && (typeof candidate.content === "string" || Array.isArray(candidate.content));
 }
+function trackMessageToolState(message, openToolUses) {
+  if (!Array.isArray(message.content)) return;
+  for (const block of message.content) {
+    if (block.type === "tool_use") openToolUses.add(block.id);
+    else if (block.type === "tool_result") openToolUses.delete(block.tool_use_id);
+  }
+}
+function replayableMessage(value, fallbackTs) {
+  if (!isReplayableMessage(value)) return null;
+  const { _estTokens: _ignored, ...message } = value;
+  return message.ts === void 0 && fallbackTs ? { ...message, ts: fallbackTs } : message;
+}
 function applyContextSnapshot(target, openToolUses, snapshot) {
   if (!Array.isArray(snapshot) || !snapshot.every(isReplayableMessage)) return false;
   target.length = 0;
   openToolUses.clear();
   for (const raw of snapshot) {
-    const { _estTokens: _ignored, ...message } = raw;
+    const message = replayableMessage(raw);
+    if (!message) return false;
     target.push(message);
-    if (!Array.isArray(message.content)) continue;
-    for (const block of message.content) {
-      if (block.type === "tool_use") openToolUses.add(block.id);
-      else if (block.type === "tool_result") openToolUses.delete(block.tool_use_id);
-    }
+    trackMessageToolState(message, openToolUses);
   }
   return true;
 }
@@ -13132,10 +13549,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       handle = await fsp9.open(file, "a", 384);
     } catch (err) {
       this.emitError(id, file, "create", toErrorMessage(err), false);
-      throw new Error(
-        `Failed to open session file: ${toErrorMessage(err)}`,
-        { cause: err }
-      );
+      throw new Error(`Failed to open session file: ${toErrorMessage(err)}`, { cause: err });
     }
     try {
       const writer = new FileSessionWriter(id, handle, startedAt, meta, this.events, {
@@ -13148,10 +13562,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite(id, file, "create", "success", Date.now() - t0);
       return writer;
     } catch (err) {
-      await handle.close().catch((e) => this.logWarn(
-        "Session handle close failed",
-        { event: "session_store.handle_close_failed", message: e instanceof Error ? e.message : String(e) }
-      ));
+      await handle.close().catch(
+        (e) => this.logWarn("Session handle close failed", {
+          event: "session_store.handle_close_failed",
+          message: e instanceof Error ? e.message : String(e)
+        })
+      );
       this.emitError(id, file, "create", toErrorMessage(err), true);
       throw err;
     }
@@ -13170,9 +13586,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
         }
       }
       if (boundary === -1) {
-        throw new Error(
-          `Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`
-        );
+        throw new Error(`Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`);
       }
     }
     const parentPrefix = parent.events.slice(0, boundary + 1);
@@ -13219,7 +13633,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
   }
   async materializeWorkspaceCheckpoint(checkpoint, targetRoot) {
     if (!this.checkpointCas) {
-      throw new Error("Workspace checkpoint materialization requires a projectRoot-aware session store");
+      throw new Error(
+        "Workspace checkpoint materialization requires a projectRoot-aware session store"
+      );
     }
     return this.checkpointCas.materialize(checkpoint, targetRoot);
   }
@@ -13227,34 +13643,44 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const file = this.sessionPath(id, ".jsonl");
     const t0 = Date.now();
     const data = await this.load(id);
-    let resumedData = data;
+    const noticeMessages = [];
+    let resumeValidation;
     if (this.projectRoot) {
       try {
-        const resumeValidation = await validateResumeFileObservations(data.events, this.projectRoot);
+        resumeValidation = await validateResumeFileObservations(data.events, this.projectRoot);
         const notice = formatResumeValidationNotice(resumeValidation, this.projectRoot);
-        resumedData = {
-          ...data,
-          resumeValidation,
-          ...notice ? {
-            messages: [
-              ...data.messages,
-              { role: "system", content: notice, ts: resumeValidation.checkedAt }
-            ]
-          } : {}
-        };
+        if (notice) {
+          noticeMessages.push({
+            role: "system",
+            content: notice,
+            ts: resumeValidation.checkedAt
+          });
+        }
       } catch (err) {
         this.emitError(id, file, "resume_validation", toErrorMessage(err), true);
       }
     }
+    const interruptedNotice = formatInterruptedToolNotice(data.pendingToolUseCount ?? 0);
+    if (interruptedNotice) {
+      noticeMessages.push({
+        role: "system",
+        content: interruptedNotice,
+        ts: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    const resumedData = {
+      ...data,
+      ...resumeValidation ? { resumeValidation } : {},
+      ...noticeMessages.length > 0 ? { messages: [...data.messages, ...noticeMessages] } : {}
+    };
     let handle;
     try {
       handle = await fsp9.open(file, "a", 384);
     } catch (err) {
       this.emitError(id, file, "resume", toErrorMessage(err), false);
-      throw new Error(
-        `Failed to open session "${id}" for append: ${toErrorMessage(err)}`,
-        { cause: err }
-      );
+      throw new Error(`Failed to open session "${id}" for append: ${toErrorMessage(err)}`, {
+        cause: err
+      });
     }
     try {
       const writer = new FileSessionWriter(
@@ -13282,10 +13708,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
       this.emitWrite(id, file, "resume", "success", Date.now() - t0);
       return { writer, data: resumedData };
     } catch (err) {
-      await handle.close().catch((e) => this.logWarn(
-        "Session handle close failed",
-        { event: "session_store.handle_close_failed", message: e instanceof Error ? e.message : String(e) }
-      ));
+      await handle.close().catch(
+        (e) => this.logWarn("Session handle close failed", {
+          event: "session_store.handle_close_failed",
+          message: e instanceof Error ? e.message : String(e)
+        })
+      );
       this.emitError(id, file, "resume", toErrorMessage(err), true);
       throw err;
     }
@@ -13318,9 +13746,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let cacheHit = false;
     try {
       const s = await fsp9.stat(file);
-      const stat12 = { mtimeMs: s.mtimeMs, size: s.size };
+      const stat13 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
-      if (cached && cached.mtimeMs === stat12.mtimeMs && cached.size === stat12.size) {
+      if (cached && cached.mtimeMs === stat13.mtimeMs && cached.size === stat13.size) {
         cacheHit = true;
         this._loadCache.delete(id);
         this._loadCache.set(id, cached);
@@ -13336,6 +13764,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       let sessionForkedEvent;
       const messages = mode.full ? [] : void 0;
       const openToolUses = mode.full ? /* @__PURE__ */ new Set() : void 0;
+      let exactJournalActive = false;
       let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
       const stream = createReadStream(file, { encoding: "utf8" });
       const rl = createInterface({ input: stream, crlfDelay: Infinity });
@@ -13360,20 +13789,59 @@ var DefaultSessionStore = class _DefaultSessionStore {
                 sessionForkedEvent = ev;
               }
               if (mode.full && messages !== void 0 && openToolUses !== void 0) {
-                if (ev.type === "context_snapshot") {
+                if (ev.type === "message_appended" && ev.version === 1) {
+                  const message = replayableMessage(ev.message, ev.ts);
+                  if (message) {
+                    if (!exactJournalActive) {
+                      messages.length = 0;
+                      openToolUses.clear();
+                      exactJournalActive = true;
+                    }
+                    messages.push(message);
+                    trackMessageToolState(message, openToolUses);
+                  } else {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: "Ignored malformed message_appended event"
+                    });
+                  }
+                } else if (ev.type === "message_updated" && ev.version === 1) {
+                  const message = replayableMessage(ev.message, ev.ts);
+                  if (message && exactJournalActive && ev.index >= 0 && ev.index < messages.length) {
+                    messages[ev.index] = message;
+                    openToolUses.clear();
+                    for (const current of messages) trackMessageToolState(current, openToolUses);
+                  } else {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: `Ignored malformed message_updated event at index ${ev.index}`
+                    });
+                  }
+                } else if (ev.type === "messages_replaced" && ev.version === 1) {
+                  if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
+                    exactJournalActive = true;
+                  } else {
+                    this.events?.emit("session.damaged", {
+                      sessionId: id,
+                      detail: "Ignored malformed messages_replaced event"
+                    });
+                  }
+                } else if (ev.type === "context_snapshot") {
                   if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
                     this.events?.emit("session.damaged", {
                       sessionId: id,
                       detail: "Ignored malformed context_snapshot event"
                     });
                   }
-                } else if (ev.type === "user_input") {
+                } else if (!exactJournalActive && ev.type === "user_input") {
                   openToolUses.clear();
                   messages.push({ role: "user", content: ev.content, ts: ev.ts });
                 } else if (ev.type === "llm_response") {
-                  messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
-                  for (const b of ev.content) {
-                    if (b.type === "tool_use") openToolUses.add(b.id);
+                  if (!exactJournalActive) {
+                    messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
+                    for (const b of ev.content) {
+                      if (b.type === "tool_use") openToolUses.add(b.id);
+                    }
                   }
                   usage = {
                     input: usage.input + (ev.usage.input ?? 0),
@@ -13381,7 +13849,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
                     cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
                     cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
                   };
-                } else if (ev.type === "tool_result") {
+                } else if (!exactJournalActive && ev.type === "tool_result") {
                   if (!openToolUses.has(ev.id)) {
                     this.events?.emit("session.damaged", {
                       sessionId: id,
@@ -13453,7 +13921,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
         } : void 0
       };
       const toolCallEnds = extractToolCallEnds(events);
-      const data = { metadata: meta, events, messages: finalMessages, usage, toolCallEnds };
+      const pendingToolUseCount = openToolUses && openToolUses.size > 0 ? openToolUses.size : void 0;
+      const data = {
+        metadata: meta,
+        events,
+        messages: finalMessages,
+        usage,
+        toolCallEnds,
+        ...pendingToolUseCount !== void 0 ? { pendingToolUseCount } : {}
+      };
       if (mode.full) {
         if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
           const oldest = this._loadCache.keys().next().value;
@@ -13461,7 +13937,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
             this._loadCache.delete(oldest);
           }
         }
-        this._loadCache.set(id, { mtimeMs: stat12.mtimeMs, size: stat12.size, data });
+        this._loadCache.set(id, { mtimeMs: stat13.mtimeMs, size: stat13.size, data });
       }
       return data;
     } catch (err) {
@@ -13469,7 +13945,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
       errorMsg = toErrorMessage(err);
       throw err;
     } finally {
-      this.emitRead(id, file, mode.full ? "load" : "load_events_only", outcome, Date.now() - t0, errorMsg);
+      this.emitRead(
+        id,
+        file,
+        mode.full ? "load" : "load_events_only",
+        outcome,
+        Date.now() - t0,
+        errorMsg
+      );
       if (cacheHit) {
         this.events?.emit("storage.cache_hit", {
           sessionId: id,
@@ -13503,14 +13986,14 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const limit = opts?.limit;
     const signal = opts?.signal;
     const out = [];
-    let stat12;
+    let stat13;
     try {
-      stat12 = await fsp9.stat(file);
+      stat13 = await fsp9.stat(file);
     } catch (err) {
       if (err.code === "ENOENT") return [];
       throw err;
     }
-    if (stat12.size === 0) return [];
+    if (stat13.size === 0) return [];
     let fh;
     try {
       fh = await fsp9.open(file, "r");
@@ -13671,7 +14154,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
     } finally {
-      this.emitWrite("~compact~", this.indexFile, "compact", outcome, Date.now() - t0, void 0, errorMsg);
+      this.emitWrite(
+        "~compact~",
+        this.indexFile,
+        "compact",
+        outcome,
+        Date.now() - t0,
+        void 0,
+        errorMsg
+      );
     }
   }
   /**
@@ -13693,15 +14184,15 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
-    let stat12;
+    let stat13;
     try {
       const s = await fsp9.stat(this.indexFile);
-      stat12 = { mtimeMs: s.mtimeMs, size: s.size };
+      stat13 = { mtimeMs: s.mtimeMs, size: s.size };
     } catch {
       this._indexCache = null;
       return [];
     }
-    if (this._indexCache !== null && this._indexCache.mtimeMs === stat12.mtimeMs && this._indexCache.size === stat12.size) {
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat13.mtimeMs && this._indexCache.size === stat13.size) {
       return [...this._indexCache.summaries];
     }
     let raw;
@@ -13734,7 +14225,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (a.startedAt > b.startedAt) return -1;
       return a.id.localeCompare(b.id);
     });
-    this._indexCache = { ...stat12, summaries };
+    this._indexCache = { ...stat13, summaries };
     return [...summaries];
   }
   /**
@@ -13743,7 +14234,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
    */
   async rebuildIndex() {
     const ids = await this.collectSessionIds(this.dir);
-    const summaries = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
+    const summaries = await Promise.all(
+      ids.map((id) => this.summaryFor(id).catch(() => null))
+    );
     const valid = summaries.filter((s) => s !== null);
     const lines = valid.map((s) => JSON.stringify(s)).join("\n") + "\n";
     await withFileLock(this.indexFile, async () => {
@@ -13784,7 +14277,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const shardKeys = [""];
     for (const entry of entries) {
       if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
-      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments") continue;
+      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+        continue;
       if (entry.isDirectory()) shardKeys.push(entry.name);
     }
     return shardKeys;
@@ -13901,15 +14395,16 @@ var DefaultSessionStore = class _DefaultSessionStore {
     if (fromManifest) return fromManifest;
     try {
       const full = this.sessionPath(id, ".jsonl");
-      const stat12 = await fsp9.stat(full);
-      const summary = await this.summarize(id, stat12.mtime.toISOString());
+      const stat13 = await fsp9.stat(full);
+      const summary = await this.summarize(id, stat13.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         const msg = toErrorMessage(err);
         this.emitError(id, manifest, "summary_fallback", msg, true);
-        this.logWarn(
-          "Session manifest write failed",
-          { event: "session_store.manifest_write_failed", sessionId: id, message: msg }
-        );
+        this.logWarn("Session manifest write failed", {
+          event: "session_store.manifest_write_failed",
+          sessionId: id,
+          message: msg
+        });
       });
       outcome = "failure";
       errorMsg = "summary fallback \xE2\u20AC\u201D manifest rebuilt";
@@ -13942,18 +14437,18 @@ var DefaultSessionStore = class _DefaultSessionStore {
   async summaryHeaderFor(ref) {
     let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
     try {
-      const stat12 = await fsp9.stat(ref.filePath);
-      if (!stat12.isFile()) {
+      const stat13 = await fsp9.stat(ref.filePath);
+      if (!stat13.isFile()) {
         return {
           id: ref.id,
           title: "(damaged)",
-          startedAt: stat12.mtime.toISOString(),
+          startedAt: stat13.mtime.toISOString(),
           model: "unknown",
           provider: "unknown",
           tokenTotal: 0
         };
       }
-      mtime = stat12.mtime.toISOString();
+      mtime = stat13.mtime.toISOString();
     } catch {
       return null;
     }
@@ -14016,24 +14511,28 @@ var DefaultSessionStore = class _DefaultSessionStore {
       if (r.status === "rejected") {
         const msg = r.reason instanceof Error ? r.reason.message : String(r.reason);
         if (r.reason?.code !== "ENOENT") {
-          console.warn(JSON.stringify({
-            level: "warn",
-            event: "session_store.delete_failed",
-            sessionId: id,
-            message: msg,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }));
+          console.warn(
+            JSON.stringify({
+              level: "warn",
+              event: "session_store.delete_failed",
+              sessionId: id,
+              message: msg,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
         }
       }
     }
     await fsp9.rm(sessDir, { recursive: true, force: true }).catch((err) => {
-      console.warn(JSON.stringify({
-        level: "warn",
-        event: "session_store.rmdir_failed",
-        sessionId: id,
-        message: toErrorMessage(err),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "session_store.rmdir_failed",
+          sessionId: id,
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
     });
     await this.writeTombstone(id);
   }
@@ -14109,8 +14608,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const pruneFile = async (dir, name, prefix) => {
       const jsonlPath = path11.join(dir, name);
       try {
-        const stat12 = await fsp9.stat(jsonlPath);
-        if (stat12.mtimeMs >= cutoff) return;
+        const stat13 = await fsp9.stat(jsonlPath);
+        if (stat13.mtimeMs >= cutoff) return;
       } catch {
         return;
       }
@@ -14998,11 +15497,6 @@ ${journalTail.join("\n")}` : "Recent journal: (none \u2014 this is the first ite
   };
 }
 
-// src/types/blocks.ts
-function isTextBlock(b) {
-  return b.type === "text";
-}
-
 // src/execution/compaction-core.ts
 var FAILURE_PATTERN = /(error|fail|exception|timeout|enonet|eacces|eperm|enoent|abort)/i;
 var CORRECTION_PATTERN = /\b(wrong|no\b|stop\b|don'?t\b|actually|fix that|undo|revert|forget|ignore|skip)\b/i;
@@ -15110,6 +15604,14 @@ function hasMatchingToolPair(resultContent, useContent) {
 }
 function eliseOldToolResults(messages, opts) {
   const preserveStart = findPreserveStart(messages, opts.preserveK);
+  const tokenCache = /* @__PURE__ */ new Map();
+  const tokensFor = (b) => {
+    const cached = tokenCache.get(b);
+    if (cached !== void 0) return cached;
+    const t = b.type === "tool_result" ? estimateToolResultTokens(b.content) : b.type === "tool_use" ? estimateToolInputTokens(b.input) : 0;
+    tokenCache.set(b, t);
+    return t;
+  };
   let hasOversized = false;
   let firstOversizedIndex = -1;
   let fastPathIterations = 0;
@@ -15120,7 +15622,7 @@ function eliseOldToolResults(messages, opts) {
     if (!msg || !Array.isArray(msg.content)) continue;
     for (const b of msg.content) {
       fastPathInnerIterations++;
-      const oversized = b.type === "tool_result" && estimateToolResultTokens(b.content) >= opts.eliseThreshold || b.type === "tool_use" && estimateToolInputTokens(b.input) >= opts.eliseThreshold;
+      const oversized = tokensFor(b) >= opts.eliseThreshold;
       if (oversized) {
         hasOversized = true;
         firstOversizedIndex = i;
@@ -15158,7 +15660,7 @@ function eliseOldToolResults(messages, opts) {
       const b = original[idx];
       if (!b) continue;
       if (b.type === "tool_use") {
-        const tokens2 = estimateToolInputTokens(b.input);
+        const tokens2 = tokensFor(b);
         if (tokens2 < opts.eliseThreshold) continue;
         const elidedInput = summarizeToolUseInputElision(b, tokens2);
         saved += Math.max(0, tokens2 - estimateToolInputTokens(elidedInput));
@@ -15167,7 +15669,7 @@ function eliseOldToolResults(messages, opts) {
         continue;
       }
       if (b.type !== "tool_result") continue;
-      const tokens = estimateToolResultTokens(b.content);
+      const tokens = tokensFor(b);
       if (tokens < opts.eliseThreshold) continue;
       saved += tokens;
       const elided = {
@@ -16095,12 +16597,12 @@ function verifyFiles(tokens, files) {
   const violations = [];
   let onPalette = 0;
   let offPalette = 0;
-  for (const { path: path28, text } of files) {
+  for (const { path: path29, text } of files) {
     const lines = text.split("\n");
     lines.forEach((lineText, i) => {
       const lineNo = i + 1;
       const flag = (snippet, reason) => {
-        violations.push({ file: path28, line: lineNo, snippet: snippet.slice(0, 80), reason });
+        violations.push({ file: path29, line: lineNo, snippet: snippet.slice(0, 80), reason });
       };
       for (const re of [HEX_RE, FUNC_COLOR_RE]) {
         re.lastIndex = 0;
@@ -16609,16 +17111,20 @@ function buildRecoveryStrategies(opts) {
         const delayMs = err.body?.retryAfterMs ?? 5e3;
         const delay = Math.min(6e4, Math.max(1e3, delayMs));
         if (ctx?.signal) {
-          await new Promise((resolve12) => {
+          await new Promise((resolve14) => {
             if (ctx.signal.aborted) {
-              resolve12();
+              resolve14();
               return;
             }
-            const timer = setTimeout(resolve12, delay);
-            ctx.signal.addEventListener("abort", () => {
-              clearTimeout(timer);
-              resolve12();
-            }, { once: true });
+            const timer = setTimeout(resolve14, delay);
+            ctx.signal.addEventListener(
+              "abort",
+              () => {
+                clearTimeout(timer);
+                resolve14();
+              },
+              { once: true }
+            );
           });
         } else {
           await new Promise((r) => setTimeout(r, delay));
@@ -16709,6 +17215,7 @@ function buildRecoveryStrategies(opts) {
 var DEFAULT_RECOVERY_STRATEGIES = buildRecoveryStrategies();
 var HANDLER_KIND_BY_PROVIDER_KIND = {
   rate_limit: "rate_limit",
+  quota_exhausted: "rate_limit",
   overloaded: "overloaded",
   server: "server",
   stream_hang: "server",
@@ -16756,6 +17263,217 @@ var DefaultErrorHandler = class {
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 
+// src/storage/goal-coordination.ts
+import { updateTask } from "@wrongstack/kanban";
+
+// src/storage/goal-kanban.ts
+import {
+  addColumn,
+  addTask,
+  createBoard,
+  getBoard,
+  listBoards,
+  removeBoard
+} from "@wrongstack/kanban";
+var GOAL_BOARD_TAG_PREFIX = "goal:";
+async function findGoalKanbanBoard(projectRoot, boardId) {
+  if (!projectRoot || !boardId) return null;
+  try {
+    return await getBoard(projectRoot, boardId);
+  } catch {
+    return null;
+  }
+}
+async function findGoalBoardByTag(projectRoot, goalFile) {
+  if (!projectRoot) return null;
+  const tag = goalTag(goalFile);
+  const boards = await listBoards(projectRoot);
+  const matched = boards.find((b) => b.tags?.includes(tag));
+  if (!matched) return null;
+  return getBoard(projectRoot, matched.id).catch(() => null);
+}
+function goalTag(goalFile) {
+  const goal = (goalFile.refinedGoal || goalFile.goal).replace(/\s+/g, "-").slice(0, 24).toLowerCase();
+  return `${GOAL_BOARD_TAG_PREFIX}${goal}`;
+}
+
+// src/storage/goal-coordination.ts
+var DONE_MARKER = /\[done:\s*([^\]]+)\]/gi;
+var DONE_PREFIX = /^\s*(?:✅|\[[x✓]\]|\(done\))\s*/i;
+function parseCompletedGoalDeliverables(finalText, deliverables) {
+  if (!finalText || deliverables.length === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const completed = [];
+  for (const match of finalText.matchAll(DONE_MARKER)) {
+    const raw = match[1]?.trim();
+    if (!raw) continue;
+    const numeric = /^\d+$/.test(raw) ? Number.parseInt(raw, 10) : void 0;
+    let index = numeric === void 0 ? -1 : numeric === 0 ? 0 : numeric - 1;
+    if (index < 0 || index >= deliverables.length) {
+      const prefix = raw.toLowerCase();
+      index = deliverables.findIndex(
+        (item) => stripGoalDeliverableMarker(item).toLowerCase().startsWith(prefix)
+      );
+    }
+    if (index < 0 || index >= deliverables.length || seen.has(index)) continue;
+    const source = deliverables[index] ?? "";
+    if (isGoalDeliverableComplete(source)) continue;
+    seen.add(index);
+    completed.push({ index, text: stripGoalDeliverableMarker(source) });
+  }
+  return completed;
+}
+function isGoalDeliverableComplete(value) {
+  return DONE_PREFIX.test(value);
+}
+function stripGoalDeliverableMarker(value) {
+  return value.replace(DONE_PREFIX, "").trim();
+}
+function applyGoalDeliverableCompletions(goal, completed) {
+  if (completed.length === 0) return recomputeGoalProgress(goal);
+  const completedIndices = new Set(completed.map((item) => item.index));
+  let next = {
+    ...goal,
+    deliverables: (goal.deliverables ?? []).map(
+      (item, index) => completedIndices.has(index) && !isGoalDeliverableComplete(item) ? `\u2705 ${item}` : item
+    )
+  };
+  for (const item of completed) {
+    next = appendJournal(next, {
+      source: "deliverable",
+      task: `Deliverable completed: ${item.text}`.slice(0, 240),
+      status: "success",
+      note: `[DONE: ${item.index + 1}]`
+    });
+  }
+  return recomputeGoalProgress(next);
+}
+function recomputeGoalProgress(goal) {
+  const deliverables = goal.deliverables ?? [];
+  if (deliverables.length === 0) return goal;
+  const done = deliverables.filter(isGoalDeliverableComplete).length;
+  const progress = Math.round(done / deliverables.length * 100);
+  return recordProgress(goal, progress, `${done}/${deliverables.length} deliverables complete`);
+}
+async function coordinateGoalIteration(options) {
+  const current = await loadGoal(options.goalPath, options.events);
+  if (!current) return null;
+  const completed = parseCompletedGoalDeliverables(
+    options.finalText,
+    current.deliverables ?? []
+  );
+  let goal = applyGoalDeliverableCompletions(current, completed);
+  await saveGoal(options.goalPath, goal, options.events);
+  const kanbanUpdatedTaskIds = await refreshGoalKanban(
+    options.projectRoot,
+    goal,
+    completed
+  );
+  goal = await recomputeGoalProgressFromKanban(options.projectRoot, goal);
+  let reached = false;
+  const allComplete = (goal.deliverables?.length ?? 0) > 0 && goal.deliverables?.every(isGoalDeliverableComplete) === true;
+  if (allComplete && options.brain) {
+    const decision = await options.brain.decide({
+      id: `goal-reached-${goal.iterations}`,
+      sessionId: options.sessionId,
+      source: "system",
+      question: "Have all goal deliverables been reached and verified?",
+      context: [
+        `Goal: ${goal.refinedGoal ?? goal.goal}`,
+        `Progress: ${goal.progress ?? 0}%`,
+        "Completed deliverables:",
+        ...(goal.deliverables ?? []).map(
+          (item, index) => `${index + 1}. ${stripGoalDeliverableMarker(item)}`
+        )
+      ].join("\n"),
+      risk: "high",
+      fallback: "continue",
+      options: [
+        {
+          id: "goal_reached",
+          label: "Goal reached",
+          consequence: "Persist the completed goal and stop the eternal loop."
+        },
+        {
+          id: "keep_working",
+          label: "Keep working",
+          consequence: "Leave the goal active for another iteration."
+        }
+      ]
+    });
+    reached = decision.type === "answer" && decision.optionId === "goal_reached";
+  }
+  if (reached) {
+    const reachedAt = (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+    goal = appendJournal(
+      {
+        ...goal,
+        goalState: "completed",
+        engineState: "stopped",
+        progress: 100,
+        progressNote: "goal reached",
+        reachedAt,
+        reachedNote: "goal reached"
+      },
+      {
+        source: "deliverable",
+        task: "GOAL REACHED",
+        status: "success",
+        note: "goal reached"
+      }
+    );
+  }
+  await saveGoal(options.goalPath, goal, options.events);
+  return { goal, completed, kanbanUpdatedTaskIds, reached };
+}
+async function resolveGoalBoard(projectRoot, goal) {
+  const boardId = goal.kanbanBoardId;
+  if (boardId) {
+    const board = await findGoalKanbanBoard(projectRoot, boardId);
+    if (board) return board;
+  }
+  return findGoalBoardByTag(projectRoot, goal);
+}
+async function refreshGoalKanban(projectRoot, goal, completed) {
+  if (completed.length === 0) return [];
+  const board = await resolveGoalBoard(projectRoot, goal);
+  if (!board) return [];
+  const doneColumn = board.columns.find((column) => column.title.toLowerCase() === "done");
+  if (!doneColumn) return [];
+  const completedTitles = new Set(completed.map((item) => normalizeTitle(item.text)));
+  const updated = [];
+  for (const task of board.tasks) {
+    if (!completedTitles.has(normalizeTitle(task.title))) continue;
+    const result = await updateTask(
+      projectRoot,
+      board.id,
+      task.id,
+      { columnId: doneColumn.id, status: "completed" },
+      {
+        actor: "goal-coordinator",
+        note: "deliverable-completed: Updated from [DONE:] marker."
+      }
+    );
+    if (result) updated.push(task.id);
+  }
+  return updated;
+}
+async function recomputeGoalProgressFromKanban(projectRoot, goal) {
+  const board = await resolveGoalBoard(projectRoot, goal);
+  if (!board || !goal.deliverables?.length) return recomputeGoalProgress(goal);
+  const completedTitles = new Set(
+    board.tasks.filter((task) => task.status === "completed").map((task) => normalizeTitle(task.title))
+  );
+  const deliverables = goal.deliverables.map((item) => {
+    if (isGoalDeliverableComplete(item)) return item;
+    return completedTitles.has(normalizeTitle(item)) ? `\u2705 ${item}` : item;
+  });
+  return recomputeGoalProgress({ ...goal, deliverables });
+}
+function normalizeTitle(value) {
+  return stripGoalDeliverableMarker(value).replace(/\s+/g, " ").trim().toLowerCase();
+}
+
 // src/execution/autonomy-brain.ts
 function formatDecisionSummary(decision, request) {
   const question = request.question.length > 80 ? request.question.slice(0, 77) + "\u2026" : request.question;
@@ -16773,6 +17491,7 @@ function formatDecisionSummary(decision, request) {
 var execFileP = promisify(execFile);
 var BRAINSTORM_DONE = /* @__PURE__ */ Symbol("brainstorm-done");
 var GOAL_COMPLETE_MARKER = /^\s*\[goal[_\s-]*complete\]\s*$/im;
+var DONE_DELIVERABLE_MARKER = /\[done:\s*[^\]]+\]/i;
 var GOAL_CLEAR_MARKER = /^\s*\[\/?goal\s*clear\]\s*$/im;
 var EternalAutonomyEngine = class {
   constructor(opts) {
@@ -17027,6 +17746,24 @@ var EternalAutonomyEngine = class {
     const cycleGapMs = this.opts.cycleGapMs ?? 1e3;
     emit({ phase: "sleep", ms: cycleGapMs });
     await sleep(cycleGapMs);
+    let coordinatedProgress;
+    if (DONE_DELIVERABLE_MARKER.test(finalText)) {
+      const coordinated = await coordinateGoalIteration({
+        projectRoot: this.opts.projectRoot,
+        goalPath: this.goalPath,
+        finalText,
+        brain: this.opts.brain,
+        sessionId: this.opts.agent.ctx.session?.id,
+        events: this.opts.events,
+        now: this.opts.now
+      });
+      coordinatedProgress = coordinated?.goal.progress;
+      if (coordinated?.reached) {
+        this.stopRequested = true;
+        this.opts.onEternalStop?.();
+        return true;
+      }
+    }
     if (GOAL_COMPLETE_MARKER.test(finalText)) {
       await this.clearGoalManually(finalText);
       this.stopRequested = true;
@@ -17039,8 +17776,9 @@ var EternalAutonomyEngine = class {
     }
     const parsed = parseProgressFromText(finalText);
     if (parsed) {
-      await this.updateProgress(parsed.progress, parsed.note);
-      if (parsed.progress >= 100) {
+      const progress = Math.max(parsed.progress, coordinatedProgress ?? 0);
+      await this.updateProgress(progress, parsed.note);
+      if (parsed.progress >= 100 && coordinatedProgress === void 0) {
         await this.markGoalCompleted(
           { source: action.source, task: action.task, directive: action.directive },
           `progress reached 100%: ${parsed.note ?? "goal complete"}`
@@ -17605,7 +18343,7 @@ ${summaryText}` : summaryText;
         timeoutMs: 3e4,
         maxTokens: 1024,
         signal: ctx.signal,
-        fallbackProfile: "summary"
+        fallbackModels: ["/summary"]
       });
       if (result.text && !result.error) return result.text;
     } else {
@@ -18372,8 +19110,8 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
         });
         await Promise.race([
           drainPromise,
-          new Promise((resolve12) => {
-            drainTimer = setTimeout(resolve12, STREAM_DRAIN_TIMEOUT_MS);
+          new Promise((resolve14) => {
+            drainTimer = setTimeout(resolve14, STREAM_DRAIN_TIMEOUT_MS);
           })
         ]);
       } finally {
@@ -18396,7 +19134,145 @@ async function streamProviderToResponse(provider, req, signal, ctx, events, logg
   return buildResponse(state);
 }
 
+// src/chronicle/prompt-manifest.ts
+import { createHash as createHash5 } from "node:crypto";
+function createChroniclePromptManifest(request) {
+  const roleCounts = {}, blockCounts = {};
+  const messages = request.messages.map((message, index) => messageSummary(message, index, roleCounts, blockCounts));
+  const systemText = (request.system ?? []).map((block) => block.text).join("\n");
+  const toolRecords = (request.tools ?? []).map((tool) => ({
+    name: tool.name,
+    schemaHash: hash(stable(tool.inputSchema)),
+    permission: tool.permission,
+    mutating: tool.mutating,
+    riskTier: tool.riskTier,
+    capabilities: tool.capabilities,
+    estimatedTokens: tool._estDefTokens ?? 0
+  }));
+  const core = {
+    systemHash: hash(systemText),
+    messages: messages.map(({ hash: contentHash, ...rest }) => ({ ...rest, contentHash })),
+    tools: toolRecords,
+    model: request.model,
+    maxTokens: request.maxTokens,
+    temperature: request.temperature,
+    topP: request.topP,
+    topK: request.topK,
+    seed: request.seed,
+    toolChoice: request.toolChoice,
+    reasoning: request.reasoning,
+    cache: request.cache,
+    responseFormat: request.responseFormat?.type
+  };
+  return {
+    manifestId: `prompt_${hash(stable(core))}`,
+    messageCount: messages.length,
+    estimatedMessageTokens: messages.reduce((sum, message) => sum + (message.estimatedTokens ?? 0), 0),
+    contentBytes: messages.reduce((sum, message) => sum + message.bytes, 0) + Buffer.byteLength(systemText),
+    roleCounts,
+    blockCounts,
+    system: { blockCount: request.system?.length ?? 0, bytes: Buffer.byteLength(systemText), hash: hash(systemText) },
+    messages,
+    tools: {
+      count: toolRecords.length,
+      estimatedDefinitionTokens: toolRecords.reduce((sum, tool) => sum + tool.estimatedTokens, 0),
+      manifestHash: hash(stable(toolRecords)),
+      names: toolRecords.map((tool) => tool.name),
+      mutating: toolRecords.filter((tool) => tool.mutating).length,
+      destructive: toolRecords.filter((tool) => tool.riskTier === "destructive").length
+    },
+    request: {
+      maxTokens: request.maxTokens,
+      temperature: request.temperature,
+      topP: request.topP,
+      topK: request.topK,
+      frequencyPenalty: request.frequencyPenalty,
+      presencePenalty: request.presencePenalty,
+      seed: request.seed,
+      candidateCount: request.candidateCount,
+      logprobs: request.logprobs,
+      topLogprobs: request.topLogprobs,
+      stopSequenceCount: request.stopSequences?.length ?? 0,
+      toolChoice: request.toolChoice,
+      reasoning: request.reasoning,
+      cache: request.cache,
+      responseFormat: request.responseFormat?.type,
+      safetySettingCount: request.safetySettings?.length ?? 0,
+      userHash: request.user ? hash(request.user) : void 0
+    }
+  };
+}
+function messageSummary(message, index, roles, totals) {
+  roles[message.role] = (roles[message.role] ?? 0) + 1;
+  const blocks = typeof message.content === "string" ? { text: 1 } : countBlocks(message.content);
+  for (const [type, count] of Object.entries(blocks)) totals[type] = (totals[type] ?? 0) + count;
+  const content = contentIdentity(message.content);
+  return {
+    index,
+    role: message.role,
+    bytes: content.bytes,
+    ...message._estTokens !== void 0 ? { estimatedTokens: message._estTokens } : {},
+    hash: content.hash,
+    blocks
+  };
+}
+function countBlocks(blocks) {
+  const counts = {};
+  for (const block of blocks) counts[block.type] = (counts[block.type] ?? 0) + 1;
+  return counts;
+}
+function hash(value) {
+  return createHash5("sha256").update(value).digest("hex");
+}
+function contentIdentity(content) {
+  if (typeof content === "string") return { hash: hash(content), bytes: Buffer.byteLength(content) };
+  const digest = createHash5("sha256");
+  let bytes = 0;
+  const add = (value) => {
+    if (!value) return;
+    digest.update(value);
+    bytes += Buffer.byteLength(value);
+  };
+  for (const block of content) {
+    add(block.type);
+    if (block.type === "text") add(block.text);
+    else if (block.type === "thinking") {
+      add(block.thinking);
+      add(block.signature);
+    } else if (block.type === "tool_use") {
+      add(block.id);
+      add(block.name);
+      add(stable(block.input));
+    } else if (block.type === "tool_result") {
+      add(block.tool_use_id);
+      add(block.name);
+      add(block.content);
+      add(String(block.is_error ?? false));
+    } else if (block.type === "image") {
+      add(block.source.type);
+      add(block.source.media_type);
+      add(block.source.url);
+      add(block.source.data);
+    }
+  }
+  return { hash: digest.digest("hex"), bytes };
+}
+function stable(value) {
+  if (value === void 0) return "undefined";
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => `${JSON.stringify(key)}:${stable(child)}`).join(",")}}`;
+}
+
+// src/observability/network-telemetry.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var storage = new AsyncLocalStorage();
+function runWithNetworkTelemetry(context, run) {
+  return storage.run(context, run);
+}
+
 // src/core/provider-runner.ts
+import { randomUUID as randomUUID10 } from "node:crypto";
 function providerLogCtx(p, r) {
   return {
     providerId: p.id,
@@ -18408,8 +19284,31 @@ function providerLogCtx(p, r) {
 }
 async function runProviderWithRetry(opts) {
   const { provider, request, signal, ctx, events, retry, logger, tracer } = opts;
+  const logicalRequestId = randomUUID10();
+  const promptManifest = createChroniclePromptManifest(request);
   let attempt = 0;
   for (; ; ) {
+    const attemptId = randomUUID10();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startedNs = process.hrtime.bigint();
+    const correlation = {
+      sessionId: ctx.session.id,
+      ...ctx.traceId ? { traceId: ctx.traceId } : {},
+      ...ctx.agentId ? { agentId: ctx.agentId } : {},
+      logicalRequestId,
+      attemptId,
+      attempt,
+      providerId: provider.id,
+      model: request.model
+    };
+    events.emit("provider.attempt.started", {
+      ...correlation,
+      streaming: provider.capabilities.streaming,
+      messageCount: request.messages.length,
+      toolCount: request.tools?.length ?? 0,
+      promptManifest,
+      startedAt
+    });
     const span = tracer?.startSpan("provider.complete", {
       "provider.id": provider.id,
       "provider.model": request.model,
@@ -18418,11 +19317,27 @@ async function runProviderWithRetry(opts) {
     });
     logger.debug(`Provider attempt ${attempt + 1} starting`, providerLogCtx(provider, request));
     try {
-      const res = provider.capabilities.streaming ? await streamProviderToResponse(provider, request, signal, ctx, events, logger) : await provider.complete(request, { signal });
+      const res = await runWithNetworkTelemetry({
+        events,
+        sessionId: ctx.session.id,
+        ...ctx.traceId ? { traceId: ctx.traceId } : {},
+        ...ctx.agentId ? { agentId: ctx.agentId } : {},
+        attemptId,
+        initiator: "provider",
+        operationName: `${provider.id}.complete`
+      }, () => provider.capabilities.streaming ? streamProviderToResponse(provider, request, signal, ctx, events, logger) : provider.complete(request, { signal }));
       span?.setAttribute("provider.stopReason", res.stopReason);
       span?.setAttribute("provider.usage_in", res.usage.input);
       span?.setAttribute("provider.usage_out", res.usage.output);
       span?.end();
+      events.emit("provider.attempt.completed", {
+        ...correlation,
+        startedAt,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: elapsedMs(startedNs),
+        stopReason: res.stopReason,
+        usage: res.usage
+      });
       logger.debug("Provider call succeeded", {
         ...providerLogCtx(provider, request),
         stopReason: res.stopReason,
@@ -18441,16 +19356,28 @@ async function runProviderWithRetry(opts) {
       const errAsErr = err instanceof Error ? err : new Error(String(err));
       const canRetry = retry.shouldRetry(isProviderErr ? err : errAsErr, attempt);
       const description = isProviderErr ? err.describe() : errAsErr.message;
+      const delay = canRetry ? Math.round(retry.delayMs(attempt, isProviderErr ? err : errAsErr)) : void 0;
+      events.emit("provider.attempt.failed", {
+        ...correlation,
+        startedAt,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        durationMs: elapsedMs(startedNs),
+        status: isProviderErr ? err.status : 0,
+        failureKind: isProviderErr ? err.kind : "unknown",
+        description,
+        retryable: canRetry,
+        retryScheduled: canRetry,
+        ...delay !== void 0 ? { retryDelayMs: delay } : {},
+        ...isProviderErr && err.body?.requestId ? { providerRequestId: err.body.requestId } : {}
+      });
       if (!canRetry) {
-        if (isProviderErr) {
-          events.emit("provider.error", {
-            sessionId: ctx.session.id,
-            providerId: err.providerId,
-            status: err.status,
-            description,
-            retryable: false
-          });
-        }
+        events.emit("provider.error", {
+          sessionId: ctx.session.id,
+          providerId: isProviderErr ? err.providerId : provider.id,
+          status: isProviderErr ? err.status : 0,
+          description,
+          retryable: false
+        });
         logger.error(`Provider call failed after ${attempt + 1} attempt(s) \u2014 ${description}`, {
           ...providerLogCtx(provider, request),
           attempts: attempt + 1,
@@ -18461,9 +19388,6 @@ async function runProviderWithRetry(opts) {
         });
         throw toWrongStackError(err);
       }
-      const delay = Math.round(
-        retry.delayMs(attempt, isProviderErr ? err : errAsErr)
-      );
       const attemptNum = attempt + 1;
       const maxAttempts = retry.maxAttempts(isProviderErr ? err : errAsErr);
       logger.warn(`Provider retry ${attemptNum}/${maxAttempts} in ${delay}ms \u2014 ${description}`, {
@@ -18474,17 +19398,15 @@ async function runProviderWithRetry(opts) {
         errorDescription: description,
         status: isProviderErr ? err.status : void 0
       });
-      if (isProviderErr) {
-        events.emit("provider.retry", {
-          sessionId: ctx.session.id,
-          providerId: err.providerId,
-          attempt: attemptNum,
-          delayMs: delay,
-          status: err.status,
-          description
-        });
-      }
-      await new Promise((resolve12, reject) => {
+      events.emit("provider.retry", {
+        sessionId: ctx.session.id,
+        providerId: isProviderErr ? err.providerId : provider.id,
+        attempt: attemptNum,
+        delayMs: delay,
+        status: isProviderErr ? err.status : 0,
+        description
+      });
+      await new Promise((resolve14, reject) => {
         let settled = false;
         const cleanup = () => {
           clearTimeout(t);
@@ -18500,7 +19422,7 @@ async function runProviderWithRetry(opts) {
           if (settled) return;
           settled = true;
           cleanup();
-          resolve12();
+          resolve14();
         }, delay);
         if (signal.aborted) {
           onAbort();
@@ -18512,6 +19434,9 @@ async function runProviderWithRetry(opts) {
     }
   }
 }
+function elapsedMs(startedNs) {
+  return Number(process.hrtime.bigint() - startedNs) / 1e6;
+}
 
 // src/execution/provider-runner-impl.ts
 var DefaultProviderRunner = class {
@@ -18525,6 +19450,7 @@ import { randomInt } from "node:crypto";
 var MAX_RETRY_AFTER_MS = 6e4;
 var MAX_ATTEMPTS_BY_KIND = {
   rate_limit: 5,
+  quota_exhausted: 0,
   stream_hang: 5,
   // transient, worth retrying aggressively
   overloaded: 3,
@@ -19263,7 +20189,9 @@ var DefaultSkillLoader = class {
     const seen = /* @__PURE__ */ new Set();
     for (const { dir, source, originTool } of this.dirs) {
       try {
-        const entries = await fs5.readdir(dir, { withFileTypes: true });
+        const entries = (await fs5.readdir(dir, { withFileTypes: true })).sort(
+          (a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0
+        );
         for (const e of entries) {
           if (!await entryIsDirectory(dir, e)) continue;
           const skillFile = path15.join(dir, e.name, "SKILL.md");
@@ -19890,10 +20818,178 @@ function readPolicy(ctx) {
 }
 
 // src/execution/tool-executor.ts
-import { randomUUID as randomUUID10 } from "node:crypto";
+import { randomUUID as randomUUID11 } from "node:crypto";
+
+// src/observability/process-telemetry.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var storage2 = new AsyncLocalStorage2();
+function runWithProcessTelemetry(context, run) {
+  return storage2.run(context, run);
+}
+
+// src/execution/tool-executor.ts
 import { isDeepStrictEqual } from "node:util";
 import * as fs8 from "node:fs/promises";
+import * as path19 from "node:path";
+
+// src/security/kanban-boundary.ts
+import { realpath as realpath3 } from "node:fs/promises";
 import * as path18 from "node:path";
+import {
+  evaluateKanbanBoundaryOpaque,
+  evaluateKanbanBoundaryPath,
+  readBoard,
+  resolveKanbanBoundaryLayers
+} from "@wrongstack/kanban";
+var PATH_KEYS = /* @__PURE__ */ new Set([
+  "path",
+  "paths",
+  "file",
+  "files",
+  "directory",
+  "dir",
+  "cwd",
+  "root",
+  "baseDir",
+  "out",
+  "outputPath",
+  "sourcePath",
+  "targetPath",
+  "destinationPath",
+  "fromPath",
+  "toPath",
+  "worktreePath"
+]);
+var TOOL_PATH_KEYS = {
+  // `target` is an identifier in tools such as plan/task/document, but a
+  // filesystem target in language_info. Keep ambiguous names tool-specific.
+  language_info: ["target"]
+};
+async function evaluateToolKanbanBoundary(tool, input, ctx) {
+  const identity = resolveKanbanIdentity(ctx);
+  if (!identity.boardId) return { decision: "allow" };
+  const board = await readBoard(identity.policyRoot ?? ctx.projectRoot, identity.boardId);
+  if (!board) return { decision: "allow" };
+  const task = identity.taskId ? board.tasks.find((candidate) => candidate.id === identity.taskId) : void 0;
+  const layers = resolveKanbanBoundaryLayers(board, task);
+  if (layers.length === 0) return { decision: "allow" };
+  const caps = tool.capabilities ?? [];
+  const access2 = caps.includes("fs.write") || caps.includes("fs.write.outside-project") ? "write" : caps.includes("fs.read") ? "read" : void 0;
+  const shellLike = caps.some((capability) => capability.startsWith("shell."));
+  const candidates = access2 ? await extractCandidatePaths(tool.name, input, ctx) : [];
+  let evaluation;
+  if (shellLike || access2 && candidates.length === 0) {
+    evaluation = evaluateKanbanBoundaryOpaque(layers, tool.name);
+  } else if (access2) {
+    const results = candidates.map(
+      (candidate) => evaluateKanbanBoundaryPath(layers, candidate, access2)
+    );
+    evaluation = results.find((result) => result.decision === "block") ?? results.find((result) => result.decision === "confirm") ?? { decision: "allow" };
+  } else {
+    evaluation = { decision: "allow" };
+  }
+  return {
+    ...evaluation,
+    boardId: board.id,
+    ...task ? { taskId: task.id } : {}
+  };
+}
+function resolveKanbanIdentity(ctx) {
+  const metaKanban = ctx.meta["kanban"];
+  const record = metaKanban && typeof metaKanban === "object" ? metaKanban : void 0;
+  const boardId = ctx.currentKanbanBoardId ?? (typeof record?.["boardId"] === "string" ? record["boardId"] : void 0);
+  const taskId = ctx.currentKanbanTaskId ?? (typeof record?.["taskId"] === "string" ? record["taskId"] : void 0);
+  const policyRoot = typeof record?.["projectRoot"] === "string" ? record["projectRoot"] : void 0;
+  return {
+    ...boardId ? { boardId } : {},
+    ...taskId ? { taskId } : {},
+    ...policyRoot ? { policyRoot } : {}
+  };
+}
+async function extractCandidatePaths(toolName, input, ctx) {
+  if (toolName === "patch" && typeof input["patch"] === "string") {
+    const directoryInput = stringValue(input["directory"]) ?? ctx.workingDir;
+    const directory = path18.isAbsolute(directoryInput) ? directoryInput : path18.resolve(ctx.workingDir, directoryInput);
+    const strip = Math.max(1, numericValue(input["strip"]) ?? 1);
+    const targets = extractPatchTargets(input["patch"], strip).map(
+      (target) => relativeToProject(path18.resolve(directory, target), ctx.projectRoot)
+    );
+    return Promise.all(targets.map((target) => canonicalizeCandidatePath(target, ctx)));
+  }
+  const values = [];
+  const pathKeys = new Set(PATH_KEYS);
+  for (const key of TOOL_PATH_KEYS[toolName] ?? []) pathKeys.add(key);
+  collectPathValues(input, values, pathKeys);
+  if (toolName === "scaffold" && typeof input["name"] === "string") {
+    const cwd = stringValue(input["cwd"]) ?? ctx.workingDir;
+    values.push(path18.join(cwd, input["name"]));
+  }
+  const candidates = [
+    ...new Set(values.flatMap(splitPathList).map((value) => resolveInputPath(value, ctx)))
+  ];
+  return Promise.all(candidates.map((candidate) => canonicalizeCandidatePath(candidate, ctx)));
+}
+async function canonicalizeCandidatePath(candidate, ctx) {
+  if (path18.isAbsolute(candidate)) return candidate;
+  const absolute = path18.resolve(ctx.projectRoot, candidate);
+  const canonicalRoot = await realpath3(ctx.projectRoot).catch(() => ctx.projectRoot);
+  let probe = absolute;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const canonical = path18.join(await realpath3(probe), ...missingSegments);
+      return relativeToProject(canonical, canonicalRoot);
+    } catch (cause) {
+      const code = cause.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") return absolute;
+      const parent = path18.dirname(probe);
+      if (parent === probe) return absolute;
+      missingSegments.unshift(path18.basename(probe));
+      probe = parent;
+    }
+  }
+}
+function collectPathValues(value, output, pathKeys, key) {
+  if (typeof value === "string") {
+    if (key && pathKeys.has(key)) output.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectPathValues(item, output, pathKeys, key);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  for (const [childKey, child] of Object.entries(value)) {
+    collectPathValues(child, output, pathKeys, childKey);
+  }
+}
+function splitPathList(value) {
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function resolveInputPath(value, ctx) {
+  const absolute = path18.isAbsolute(value) ? value : path18.resolve(ctx.workingDir, value);
+  return relativeToProject(absolute, ctx.projectRoot);
+}
+function relativeToProject(absolute, projectRoot) {
+  const relative5 = path18.relative(projectRoot, absolute).replace(/\\/g, "/");
+  return relative5.startsWith("../") || path18.isAbsolute(relative5) ? absolute : relative5 || ".";
+}
+function extractPatchTargets(patchText, strip) {
+  const targets = [];
+  for (const match of patchText.matchAll(/^\+\+\+\s+([^\t\r\n]+)/gm)) {
+    const raw = match[1]?.trim();
+    if (!raw || raw === "/dev/null") continue;
+    const parts = raw.replace(/\\/g, "/").split("/").filter((part) => part && part !== ".");
+    if (parts.length > strip) targets.push(parts.slice(strip).join("/"));
+  }
+  return targets;
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function numericValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
 
 // src/types/tool-executor.ts
 var GOVERNED_TOOL_EXECUTOR_META_KEY = "toolExecutor.executeGoverned";
@@ -20114,6 +21210,17 @@ ${errorDetails}`,
           return { result, tool, durationMs: Date.now() - start };
         }
       }
+      const boundary = await evaluateToolKanbanBoundary(tool, use.input, ctx);
+      if (boundary.decision === "block") {
+        const result = {
+          type: "tool_result",
+          tool_use_id: use.id,
+          content: `Tool "${tool.name}" blocked by Kanban boundary. ${boundary.reason ?? ""}`.trim(),
+          is_error: true
+        };
+        budget = this.budgetForString(result.content, budget);
+        return { result, tool, durationMs: Date.now() - start };
+      }
       const decision = await this.opts.permissionPolicy.evaluate(tool, use.input, ctx);
       let effectivePermission = decision.permission;
       const policy = this.opts.permissionPolicy;
@@ -20122,27 +21229,31 @@ ${errorDetails}`,
       if (toolDangerousCaps.length > 0 && effectivePermission === "auto" && !yolo && !authoritativeAuto) {
         effectivePermission = "confirm";
       }
+      if (boundary.decision === "confirm" && effectivePermission !== "deny") {
+        effectivePermission = "confirm";
+      }
       if (effectivePermission === "deny") {
         const result = this.deniedResult(use, decision.reason);
         budget = this.budgetForString(result.content, budget);
         return { result, tool, durationMs: Date.now() - start };
       }
       if (effectivePermission === "confirm") {
+        const suggestedPattern = boundary.decision === "confirm" ? `kanban-boundary:${boundary.path ?? tool.name}` : subjectForToolInput(tool.name, use.input, tool.subjectKey) ?? tool.name;
         if (this.opts.confirmAwaiter) {
           const awaiter = this.opts.confirmAwaiter;
           const choice = await new Promise(
-            (resolve12, reject) => {
+            (resolve14, reject) => {
               const signal = ctx.signal;
-              const onAbort = () => resolve12("abort");
+              const onAbort = () => resolve14("abort");
               if (signal.aborted) {
-                resolve12("abort");
+                resolve14("abort");
                 return;
               }
               signal.addEventListener("abort", onAbort, { once: true });
-              awaiter(tool, use.input, use.id, tool.name).then(
+              awaiter(tool, use.input, use.id, suggestedPattern).then(
                 (c) => {
                   signal.removeEventListener("abort", onAbort);
-                  resolve12(c);
+                  resolve14(c);
                 },
                 (e) => {
                   signal.removeEventListener("abort", onAbort);
@@ -20162,7 +21273,6 @@ ${errorDetails}`,
             return { result, tool, durationMs: Date.now() - start };
           }
         } else {
-          const suggestedPattern = subjectForToolInput(tool.name, use.input, tool.subjectKey) ?? tool.name;
           const pending = {
             type: "tool_confirm_pending",
             toolUseId: use.id,
@@ -20170,7 +21280,8 @@ ${errorDetails}`,
             input: use.input,
             suggestedPattern,
             decisionSource: decision.source,
-            riskTier: decision.riskTier ?? tool.riskTier
+            riskTier: decision.riskTier ?? tool.riskTier,
+            ...boundary.decision === "confirm" && boundary.reason ? { boundaryReason: boundary.reason } : {}
           };
           return { result: pending, tool, durationMs: Date.now() - start };
         }
@@ -20184,6 +21295,17 @@ ${errorDetails}`,
         "tool.has_dangerous_capabilities": toolCapsForAudit.length > 0
       });
       try {
+        const inputPath = use.input && typeof use.input === "object" ? use.input.path : void 0;
+        const caps = tool.capabilities ?? [];
+        const hasFileCapability = caps.includes("fs.read") || caps.includes("fs.write");
+        const absPath = hasFileCapability && typeof inputPath === "string" ? path19.isAbsolute(inputPath) ? inputPath : path19.resolve(ctx.projectRoot, inputPath) : void 0;
+        let writeTargetExisted;
+        if (tool.name === "write" && caps.includes("fs.write") && absPath) {
+          writeTargetExisted = await fs8.stat(absPath).then(
+            (stat13) => stat13.isFile(),
+            (error2) => error2.code === "ENOENT" ? false : void 0
+          );
+        }
         const producedText = await this.produceToolOutput(tool, use, ctx, budget);
         let { block: result, bytes } = this.settleToolOutput(tool, use, producedText, budget);
         budget -= bytes;
@@ -20212,6 +21334,35 @@ ${post.additionalContext}`;
         span?.setAttribute("tool.is_error", !!result.is_error);
         span?.setAttribute("tool.output_bytes", outputChars);
         this.logToolSuccess(ctx, use, tool.name, Date.now() - start, outputChars);
+        if (!result.is_error && typeof inputPath === "string" && absPath) {
+          const operation = tool.name === "read" ? "read" : caps.includes("fs.write") && tool.name === "write" ? writeTargetExisted === false ? "create" : "update" : caps.includes("fs.write") ? "update" : "read";
+          const ts = (/* @__PURE__ */ new Date()).toISOString();
+          ctx.recordFileEvent?.({
+            operation,
+            filePath: inputPath,
+            absPath,
+            toolName: tool.name,
+            toolUseId: use.id,
+            durationMs: Date.now() - start
+          });
+          this.opts.events?.emit("file.event", {
+            operation,
+            filePath: inputPath,
+            absPath,
+            sessionId: ctx.session.id,
+            agentId: ctx.agentId,
+            agentName: ctx.agentName,
+            provider: typeof ctx.provider === "object" ? ctx.provider.id : String(ctx.provider),
+            model: ctx.model,
+            toolName: tool.name,
+            toolUseId: use.id,
+            scope: ctx.currentKanbanTaskId ? "task" : "session",
+            taskId: ctx.currentKanbanTaskId,
+            boardId: ctx.currentKanbanBoardId,
+            timestamp: ts,
+            durationMs: Date.now() - start
+          });
+        }
         return { result, tool, durationMs: Date.now() - start };
       } catch (err) {
         if (isWrongStackError(err)) {
@@ -20309,7 +21460,7 @@ ${post.additionalContext}`;
     const bridge = async (toolName, input) => {
       const nestedUse = {
         type: "tool_use",
-        id: `nested-${randomUUID10()}`,
+        id: `nested-${randomUUID11()}`,
         name: toolName,
         input
       };
@@ -20363,6 +21514,9 @@ ${post.additionalContext}`;
   async produceToolOutput(tool, use, ctx, budgetHint) {
     this.opts.events?.emit("tool.started", {
       sessionId: ctx.session.id,
+      ...ctx.traceId ? { traceId: ctx.traceId } : {},
+      agentId: ctx.agentId,
+      agentName: ctx.agentName,
       name: tool.name,
       id: use.id,
       input: use.input
@@ -20413,11 +21567,31 @@ ${post.additionalContext}`;
       )
     ]);
     let output;
-    const toolPromise = typeof tool.executeStream === "function" ? this.runStreamedTool(tool, input, ctx, combined, toolUseId) : (async () => tool.execute(input, ctx, { signal: combined }))();
+    const execute = () => typeof tool.executeStream === "function" ? this.runStreamedTool(tool, input, ctx, combined, toolUseId) : (async () => tool.execute(input, ctx, { signal: combined }))();
+    const telemetryToolCallId = toolUseId ?? `nested-${randomUUID11()}`;
+    const toolPromise = this.opts.events ? runWithNetworkTelemetry({
+      events: this.opts.events,
+      sessionId: ctx.session.id,
+      ...ctx.traceId ? { traceId: ctx.traceId } : {},
+      ...ctx.agentId ? { agentId: ctx.agentId } : {},
+      toolCallId: telemetryToolCallId,
+      initiator: "tool",
+      operationName: tool.name
+    }, () => runWithProcessTelemetry(
+      {
+        events: this.opts.events,
+        sessionId: ctx.session.id,
+        ...ctx.traceId ? { traceId: ctx.traceId } : {},
+        ...ctx.agentId ? { agentId: ctx.agentId } : {},
+        toolCallId: telemetryToolCallId,
+        toolName: tool.name
+      },
+      execute
+    )) : execute();
     toolPromise.catch(() => {
     });
     try {
-      output = await new Promise((resolve12, reject) => {
+      output = await new Promise((resolve14, reject) => {
         const onAbort = () => {
           setTimeout(() => reject(abortReasonToError(combined.reason)), 0);
         };
@@ -20425,7 +21599,7 @@ ${post.additionalContext}`;
         toolPromise.then(
           (v) => {
             combined.removeEventListener("abort", onAbort);
-            resolve12(v);
+            resolve14(v);
           },
           (e) => {
             combined.removeEventListener("abort", onAbort);
@@ -20471,6 +21645,9 @@ ${post.additionalContext}`;
     const emitProgress = (ev) => {
       this.opts.events?.emit("tool.progress", {
         sessionId: ctx.session.id,
+        ...ctx.traceId ? { traceId: ctx.traceId } : {},
+        agentId: ctx.agentId,
+        agentName: ctx.agentName,
         name: tool.name,
         id: toolUseId ?? "<unknown>",
         event: ev
@@ -20685,13 +21862,25 @@ function httpStatusToCategory(status) {
     return { category: "transient" /* TRANSIENT */, retryable: true, detail: `HTTP ${status}` };
   }
   if (status === 404 || status === 410) {
-    return { category: "not_found" /* NOT_FOUND */, retryable: false, detail: `HTTP ${status}` };
+    return {
+      category: "not_found" /* NOT_FOUND */,
+      retryable: false,
+      detail: `HTTP ${status}`
+    };
   }
   if (status === 401 || status === 403) {
-    return { category: "permission" /* PERMISSION */, retryable: false, detail: `HTTP ${status}` };
+    return {
+      category: "permission" /* PERMISSION */,
+      retryable: false,
+      detail: `HTTP ${status}`
+    };
   }
   if (status === 400) {
-    return { category: "validation" /* VALIDATION */, retryable: false, detail: `HTTP ${status}` };
+    return {
+      category: "validation" /* VALIDATION */,
+      retryable: false,
+      detail: `HTTP ${status}`
+    };
   }
   return { category: "fatal" /* FATAL */, retryable: false, detail: `HTTP ${status}` };
 }
@@ -20701,11 +21890,11 @@ async function maybePersistLargeToolOutput(toolName, content, budget) {
     return content;
   }
   try {
-    const dir = path18.join(wstackGlobalRoot(), "tool-output");
+    const dir = path19.join(wstackGlobalRoot(), "tool-output");
     await fs8.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 = path18.join(dir, `${stamp}-${safeTool}-${randomUUID10()}.log`);
+    const filePath = path19.join(dir, `${stamp}-${safeTool}-${randomUUID11()}.log`);
     await fs8.writeFile(filePath, content, "utf8");
     const marker = `[full tool output: ${bytes} bytes at ${filePath}; read/grep that file selectively instead of re-running or requesting more output]`;
     const fixedBytes = Buffer.byteLength(marker + TOOL_OUTPUT_ARTIFACT_OMISSION, "utf8");
@@ -21017,7 +22206,7 @@ var contextManagerTool = createContextManagerTool();
 
 // src/infrastructure/logger.ts
 import * as fsp11 from "node:fs/promises";
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 var LEVEL_RANK2 = {
   error: 0,
   warn: 1,
@@ -21081,7 +22270,7 @@ var DefaultLogger = class _DefaultLogger {
     this.stderr = opts.stderr !== false;
     this.maxFileBytes = opts.maxFileBytes ?? 10 * 1024 * 1024;
     if (this.file) {
-      const dir = path19.dirname(this.file);
+      const dir = path20.dirname(this.file);
       this._tail = this._tail.then(async () => {
         await fsp11.mkdir(dir, { recursive: true });
       }).catch(() => void 0);
@@ -21403,27 +22592,27 @@ function codexModelMeta(id) {
 
 // src/models/mode-store.ts
 import * as fs9 from "node:fs/promises";
-import * as path21 from "node:path";
+import * as path22 from "node:path";
 
 // src/types/mode-prompts.ts
 import { readFileSync as readFileSync4, statSync as statSync4 } from "node:fs";
-import * as path20 from "node:path";
+import * as path21 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function modePrompt(id) {
   for (const dir of modePromptDirCandidates()) {
     try {
-      return readFileSync4(path20.join(dir, `${id}.md`), "utf8").trimEnd();
+      return readFileSync4(path21.join(dir, `${id}.md`), "utf8").trimEnd();
     } catch {
     }
   }
   return "";
 }
 function modePromptDirCandidates() {
-  const here = path20.dirname(fileURLToPath4(import.meta.url));
+  const here = path21.dirname(fileURLToPath4(import.meta.url));
   const candidates = [
-    path20.resolve(here, "../../instructions/modes"),
-    path20.resolve(here, "../instructions/modes"),
-    path20.resolve(here, "instructions/modes")
+    path21.resolve(here, "../../instructions/modes"),
+    path21.resolve(here, "../instructions/modes"),
+    path21.resolve(here, "instructions/modes")
   ];
   return candidates.sort((a, b) => Number(!isDirectory3(a)) - Number(!isDirectory3(b)));
 }
@@ -21655,7 +22844,7 @@ var DefaultModeStore = class {
   }
   async loadActiveMode() {
     try {
-      const configPath = path21.join(this.configDir, "mode.json");
+      const configPath = path22.join(this.configDir, "mode.json");
       const content = await fs9.readFile(configPath, "utf8");
       const data = JSON.parse(content);
       this.activeModeId = data.activeMode ?? null;
@@ -21666,7 +22855,7 @@ var DefaultModeStore = class {
   async saveActiveMode() {
     try {
       await fs9.mkdir(this.configDir, { recursive: true });
-      const configPath = path21.join(this.configDir, "mode.json");
+      const configPath = path22.join(this.configDir, "mode.json");
       await atomicWrite(
         configPath,
         JSON.stringify({ activeMode: this.activeModeId }, null, 2)
@@ -21681,11 +22870,11 @@ async function loadProjectModes(modesDir) {
     const entries = await fs9.readdir(modesDir);
     for (const entry of entries) {
       if (!entry.endsWith(".md") && !entry.endsWith(".txt")) continue;
-      const filePath = path21.join(modesDir, entry);
-      const stat12 = await fs9.stat(filePath);
-      if (!stat12.isFile()) continue;
+      const filePath = path22.join(modesDir, entry);
+      const stat13 = await fs9.stat(filePath);
+      if (!stat13.isFile()) continue;
       const content = await fs9.readFile(filePath, "utf8");
-      const id = path21.basename(entry, path21.extname(entry));
+      const id = path22.basename(entry, path22.extname(entry));
       modes.push({
         id,
         name: id.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
@@ -21701,7 +22890,7 @@ async function loadProjectModes(modesDir) {
 async function loadUserModes(modesDir) {
   const modes = [];
   try {
-    const manifestPath = path21.join(modesDir, "modes.json");
+    const manifestPath = path22.join(modesDir, "modes.json");
     const content = await fs9.readFile(manifestPath, "utf8");
     const manifest = JSON.parse(content);
     for (const mode of manifest.modes) {
@@ -21714,7 +22903,7 @@ async function loadUserModes(modesDir) {
 
 // src/models/models-registry.ts
 import * as fs10 from "node:fs/promises";
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 var DEFAULT_URL = "https://models.dev/api.json";
 var ENV_URL_KEY = "WRONGSTACK_MODELS_DEV_URL";
 var DEFAULT_TTL_SECONDS = 24 * 3600;
@@ -21790,7 +22979,7 @@ var DefaultModelsRegistry = class {
     this.overlay = opts.overlay;
     this.overlayUrl = opts.overlayUrl;
     this.overlayFile = opts.overlayFile;
-    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path22.join(path22.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
+    this.overlayCacheFile = opts.overlayCacheFile ?? (opts.overlayUrl ? path23.join(path23.dirname(opts.cacheFile), "models-overlay-cache.json") : void 0);
   }
   async load(opts = {}) {
     if (this.payload && !opts.force) return this.payload;
@@ -22042,7 +23231,7 @@ var DefaultModelsRegistry = class {
   }
   /** Used by `wstack models refresh` to expose where the cache lives. */
   cacheLocation() {
-    return path22.resolve(this.cacheFile);
+    return path23.resolve(this.cacheFile);
   }
 };
 function formatAge(seconds) {
@@ -22280,9 +23469,9 @@ var DefaultHealthRegistry = class {
   }
   async runOne(check) {
     let timer = null;
-    const timeout = new Promise((resolve12) => {
+    const timeout = new Promise((resolve14) => {
       timer = setTimeout(
-        () => resolve12({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
+        () => resolve14({ status: "unhealthy", detail: `timeout after ${this.timeoutMs}ms` }),
         this.timeoutMs
       );
     });
@@ -22466,7 +23655,7 @@ async function startMetricsServer(opts) {
   const tls = opts.tls;
   const useHttps = !!(tls?.cert && tls?.key);
   const host = opts.host ?? "127.0.0.1";
-  const path28 = opts.path ?? "/metrics";
+  const path29 = opts.path ?? "/metrics";
   const healthPath = opts.healthPath ?? "/healthz";
   const healthRegistry = opts.healthRegistry;
   const listener = (req, res) => {
@@ -22476,7 +23665,7 @@ async function startMetricsServer(opts) {
       return;
     }
     const url = req.url.split("?")[0];
-    if (url === path28) {
+    if (url === path29) {
       let body;
       try {
         body = renderPrometheus(opts.sink.snapshot());
@@ -22522,14 +23711,14 @@ async function startMetricsServer(opts) {
     const { createServer } = await import("node:http");
     server = createServer(listener);
   }
-  await new Promise((resolve12, reject) => {
+  await new Promise((resolve14, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve12();
+      resolve14();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -22540,9 +23729,9 @@ async function startMetricsServer(opts) {
   const protocol = useHttps ? "https" : "http";
   return {
     port: boundPort,
-    url: `${protocol}://${host}:${boundPort}${path28}`,
-    close: () => new Promise((resolve12, reject) => {
-      server.close((err) => err ? reject(err) : resolve12());
+    url: `${protocol}://${host}:${boundPort}${path29}`,
+    close: () => new Promise((resolve14, reject) => {
+      server.close((err) => err ? reject(err) : resolve14());
     })
   };
 }
@@ -22857,19 +24046,19 @@ var UNSAFE_PROPERTY_NAMES = /* @__PURE__ */ new Set(["__proto__", "prototype", "
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function error(diagnostics, code, path28, message) {
-  diagnostics.push({ severity: "error", code, path: path28, message });
+function error(diagnostics, code, path29, message) {
+  diagnostics.push({ severity: "error", code, path: path29, message });
 }
-function validatePatterns(value, path28, diagnostics) {
+function validatePatterns(value, path29, diagnostics) {
   if (!Array.isArray(value)) {
-    error(diagnostics, "invalid_pattern_list", path28, "must be an array of strings");
+    error(diagnostics, "invalid_pattern_list", path29, "must be an array of strings");
     return void 0;
   }
   if (value.length > TRUST_POLICY_LIMITS.maxPatternsPerRule) {
     error(
       diagnostics,
       "too_many_patterns",
-      path28,
+      path29,
       `must contain at most ${TRUST_POLICY_LIMITS.maxPatternsPerRule} patterns`
     );
     return void 0;
@@ -22877,7 +24066,7 @@ function validatePatterns(value, path28, diagnostics) {
   const patterns = [];
   const seen = /* @__PURE__ */ new Set();
   for (const [index, pattern] of value.entries()) {
-    const itemPath = `${path28}[${index}]`;
+    const itemPath = `${path29}[${index}]`;
     if (typeof pattern !== "string" || pattern.length === 0 || pattern.length > TRUST_POLICY_LIMITS.maxPatternChars) {
       error(
         diagnostics,
@@ -22989,8 +24178,8 @@ var LruCache = class {
     this.capacity = capacity;
   }
   get(key) {
+    if (!this.store.has(key)) return void 0;
     const value = this.store.get(key);
-    if (value === void 0) return void 0;
     this.store.delete(key);
     this.store.set(key, value);
     return value;
@@ -23247,9 +24436,21 @@ var DefaultPermissionPolicy = class {
     this._evalCache.clear();
     this.loaded = true;
   }
+  _logDeny(tool, subject, reason) {
+    console.warn(JSON.stringify({
+      level: "warn",
+      event: "permission.denied",
+      message: `Permission denied: ${tool}${subject ? ` (subject: ${subject})` : ""} \u2014 ${reason}`,
+      tool,
+      subject,
+      reason,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  }
   async evaluate(tool, input, ctx) {
     if (!this.loaded) await this.reload();
     if (this.policyInvalid) {
+      this._logDeny(tool.name, void 0, "trust policy is invalid");
       return {
         permission: "deny",
         source: "deny",
@@ -23265,6 +24466,7 @@ var DefaultPermissionPolicy = class {
       if (cached !== void 0) return cached;
     }
     if (this.sessionDenied.has(cacheKey)) {
+      this._logDeny(tool.name, subject, "session soft deny (user pressed no)");
       const decision = { permission: "deny", source: "deny", reason: "session soft deny (user pressed no)" };
       this._evalCache.set(cacheKey, decision);
       return decision;
@@ -23279,11 +24481,13 @@ var DefaultPermissionPolicy = class {
       return decision;
     }
     if (entry?.deny && subject && matchesTrust(entry.deny, subject)) {
+      this._logDeny(tool.name, subject, "matched deny pattern");
       const decision = { permission: "deny", source: "deny", reason: "matched deny pattern" };
       this._evalCache.set(cacheKey, decision);
       return decision;
     }
     if (tool.permission === "deny") {
+      this._logDeny(tool.name, subject, "tool default deny");
       const decision = { permission: "deny", source: "default", reason: "tool default deny" };
       this._evalCache.set(cacheKey, decision);
       return decision;
@@ -23311,6 +24515,7 @@ var DefaultPermissionPolicy = class {
         }
         if (userDecision === "deny") {
           await this.deny({ tool: tool.name, pattern: subject ?? tool.name });
+          this._logDeny(tool.name, subject, "user denied sensitive read");
           return { permission: "deny", source: "user", reason: "user denied sensitive read" };
         }
         return {
@@ -23363,6 +24568,7 @@ var DefaultPermissionPolicy = class {
       }
       if (decision === "deny") {
         await this.deny({ tool: tool.name, pattern: subject ?? tool.name });
+        this._logDeny(tool.name, subject, "user denied");
         return { permission: "deny", source: "user", reason: "user denied" };
       }
       return { permission: decision === "yes" ? "auto" : "deny", source: "user" };
@@ -23681,7 +24887,7 @@ var DefaultSecretScrubber = class {
 import { createCipheriv, createDecipheriv, randomBytes as randomBytes4, scryptSync } from "node:crypto";
 import * as fs12 from "node:fs";
 import * as fsp12 from "node:fs/promises";
-import * as path23 from "node:path";
+import * as path24 from "node:path";
 
 // src/types/secret-vault.ts
 var ENCRYPTED_PREFIX_PATTERN = /^enc:v(\d+):/;
@@ -23821,8 +25027,8 @@ function checkKeyFilePermissions(keyFile, opts) {
   if (process.platform === "win32") return;
   const warn = opts?.warn ?? ((msg) => console.warn(msg));
   try {
-    const stat12 = fs12.statSync(keyFile);
-    const actualMode = stat12.mode & 511;
+    const stat13 = fs12.statSync(keyFile);
+    const actualMode = stat13.mode & 511;
     if (actualMode !== KEY_FILE_MODE) {
       warn(
         `Key file ${keyFile} has mode ${actualMode.toString(8)} \u2014 expected ${KEY_FILE_MODE.toString(8)}. Run: chmod ${KEY_FILE_MODE.toString(8)} ${keyFile}`
@@ -23918,7 +25124,7 @@ var DefaultSecretVault = class {
     const oldVersion = this._keyVersion;
     const newKey = randomBytes4(KEY_BYTES);
     const newVersion = oldVersion + 1;
-    fs12.mkdirSync(path23.dirname(this.keyFile), { recursive: true });
+    fs12.mkdirSync(path24.dirname(this.keyFile), { recursive: true });
     const passphrase = getVaultPassphrase();
     if (passphrase) {
       fs12.writeFileSync(this.keyFile, wrapDataKey(newKey, newVersion, passphrase), { mode: 384 });
@@ -24002,7 +25208,7 @@ var DefaultSecretVault = class {
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
     }
-    fs12.mkdirSync(path23.dirname(this.keyFile), { recursive: true });
+    fs12.mkdirSync(path24.dirname(this.keyFile), { recursive: true });
     const key = randomBytes4(KEY_BYTES);
     const passphrase = getVaultPassphrase();
     const initialBytes = passphrase ? wrapDataKey(key, 1, passphrase) : key;
@@ -24060,7 +25266,7 @@ async function rewriteConfigEncrypted(configPath, vault, patch) {
   }
   const merged = deepMerge(current, patch ?? {});
   const encrypted = encryptConfigSecrets(merged, vault);
-  await fsp12.mkdir(path23.dirname(configPath), { recursive: true });
+  await fsp12.mkdir(path24.dirname(configPath), { recursive: true });
   await atomicWrite(configPath, JSON.stringify(encrypted, null, 2), { mode: 384 });
   await restrictFilePermissions(configPath);
 }
@@ -24144,7 +25350,7 @@ function walkCount(node, vault, counter) {
 // src/storage/attachment-store.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
 import * as fsp13 from "node:fs/promises";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 var DEFAULT_SPOOL_THRESHOLD = 256 * 1024;
 var PLACEHOLDER_RE = /\[(pasted|image|file) #(\d+)[^\]]*\]|\[file:([^\]]+)\]/g;
 var DefaultAttachmentStore = class {
@@ -24165,7 +25371,7 @@ var DefaultAttachmentStore = class {
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
       await fsp13.mkdir(this.spoolDir, { recursive: true });
-      spooledPath = path24.join(this.spoolDir, `${id}.bin`);
+      spooledPath = path25.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
       });
@@ -24285,7 +25491,7 @@ function mergeAdjacentText(blocks) {
 
 // src/storage/config-loader.ts
 import * as fs13 from "node:fs/promises";
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 
 // src/types/config.ts
 var DEFAULT_TUI_THINKING_WORD = "thinking";
@@ -24545,6 +25751,7 @@ var defaultIndexing = {
 };
 var IN_PROJECT_ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "version",
+  "activeProfile",
   "model",
   "cwd",
   "context",
@@ -24567,6 +25774,7 @@ var IN_PROJECT_ALLOWED_KEYS = /* @__PURE__ */ new Set([
   "fallbackProfiles",
   "favoriteModels",
   "favoriteModelsOnly",
+  "modelAvailabilitySchedule",
   "fallbackAuto",
   "models",
   "modelMatrix",
@@ -24602,6 +25810,7 @@ var KNOWN_DENIED_IN_PROJECT = [
 ];
 var KNOWN_CONFIG_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "version",
+  "activeProfile",
   "provider",
   "model",
   "apiKey",
@@ -24618,6 +25827,7 @@ var KNOWN_CONFIG_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "fallbackProfiles",
   "favoriteModels",
   "favoriteModelsOnly",
+  "modelAvailabilitySchedule",
   "fallbackAuto",
   "hooks",
   "plugins",
@@ -24739,9 +25949,9 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
   }
   const outSuperMemory = out["superMemory"];
   if (outSuperMemory && typeof outSuperMemory === "object") {
-    const storage = outSuperMemory["storage"];
-    if (storage && typeof storage === "object" && "directory" in storage) {
-      const clonedStorage = { ...storage };
+    const storage3 = outSuperMemory["storage"];
+    if (storage3 && typeof storage3 === "object" && "directory" in storage3) {
+      const clonedStorage = { ...storage3 };
       delete clonedStorage["directory"];
       out["superMemory"] = {
         ...outSuperMemory,
@@ -24765,8 +25975,8 @@ function stripUnsafeInProjectFields(inProject, sourcePath, warn = (msg) => conso
   return out;
 }
 function samePath(a, b) {
-  let ra = path25.resolve(a);
-  let rb = path25.resolve(b);
+  let ra = path26.resolve(a);
+  let rb = path26.resolve(b);
   if (process.platform === "win32" || process.platform === "darwin") {
     ra = ra.toLowerCase();
     rb = rb.toLowerCase();
@@ -24822,12 +26032,17 @@ var DefaultConfigLoader = class {
     let cfg = { ...BEHAVIOR_DEFAULTS };
     await this.ensureGlobalDefaults();
     const inProjectCollides = samePath(this.paths.inProjectConfig, this.paths.globalConfig) || samePath(this.paths.inProjectConfig, this.paths.projectLocalConfig);
-    const [global, local, inProject] = await Promise.all([
+    const [bootstrap, local, inProject] = await Promise.all([
       this.readJson(this.paths.globalConfig),
       this.readJson(this.paths.projectLocalConfig),
       inProjectCollides ? Promise.resolve({}) : this.readJson(this.paths.inProjectConfig)
     ]);
-    cfg = deepMerge2(cfg, global);
+    cfg = deepMerge2(cfg, bootstrap);
+    const profileName = bootstrap.activeProfile ?? "default";
+    const profileCfg = await this.readJson(this.paths.profileConfig(profileName));
+    if (Object.keys(profileCfg).length > 0) {
+      cfg = deepMerge2(cfg, profileCfg);
+    }
     cfg = deepMerge2(cfg, local);
     cfg = deepMerge2(
       cfg,
@@ -24853,10 +26068,11 @@ var DefaultConfigLoader = class {
           cfg = deepMerge2(cfg, patch);
         }
       } catch (err) {
-        this.logWarn(
-          "Config source load failed",
-          { event: "config.source_load_failed", source: src.name, message: toErrorMessage(err) }
-        );
+        this.logWarn("Config source load failed", {
+          event: "config.source_load_failed",
+          source: src.name,
+          message: toErrorMessage(err)
+        });
       }
     }
     if (opts.cliFlags) {
@@ -24895,6 +26111,7 @@ var DefaultConfigLoader = class {
     try {
       await withFileLock(fp, async () => {
         let parsed;
+        let fileExisted = true;
         try {
           const raw = await fs13.readFile(fp, "utf8");
           const result = safeParse(raw);
@@ -24915,25 +26132,115 @@ var DefaultConfigLoader = class {
               durationMs: Date.now() - t0,
               ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
             });
-            this.logWarn(
-              "Config defaults read failed",
-              { event: "config.defaults_read_failed", path: fp, message: toErrorMessage(err) }
-            );
+            this.logWarn("Config defaults read failed", {
+              event: "config.defaults_read_failed",
+              path: fp,
+              message: toErrorMessage(err)
+            });
             return;
           }
+          fileExisted = false;
           parsed = {};
         }
-        const { value, changed } = fillMissingDefaults(
-          parsed,
-          BEHAVIOR_DEFAULTS
-        );
-        if (!changed) return;
-        await atomicWrite(fp, JSON.stringify(value, null, 2), { mode: 384 });
+        const bootstrap = {
+          version: 1,
+          activeProfile: parsed.activeProfile ?? "default"
+        };
+        let needsBootstrapWrite = false;
+        if (parsed.version !== 1) {
+          needsBootstrapWrite = true;
+        }
+        if (parsed.activeProfile === void 0) {
+          needsBootstrapWrite = true;
+        }
+        if (needsBootstrapWrite) {
+          await atomicWrite(fp, JSON.stringify(bootstrap, null, 2), { mode: 384 });
+          this.events?.emit("storage.write", {
+            sessionId: "~config~",
+            store: "config",
+            filePath: fp,
+            operation: "ensure_defaults",
+            outcome: "success",
+            durationMs: Date.now() - t0,
+            ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+          });
+        }
+        const profileName = bootstrap.activeProfile ?? "default";
+        const profileFp = this.paths.profileConfig(profileName);
+        await this.ensureProfileConfig(profileFp, parsed, fileExisted);
+      });
+    } catch (err) {
+      this.events?.emit("storage.error", {
+        sessionId: "~config~",
+        store: "config",
+        filePath: fp,
+        operation: "ensure_defaults",
+        outcome: "failure",
+        error: storageErrorString(err),
+        recoverable: false,
+        durationMs: Date.now() - t0,
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      this.logWarn("Config defaults write failed", {
+        event: "config.defaults_write_failed",
+        path: fp,
+        message: toErrorMessage(err)
+      });
+    }
+  }
+  /**
+   * Ensure a profile config file exists at the given path.
+   * On first boot: migrate content from the old flat global config, or seed
+   * with behavior defaults. Subsequent boots: fill any missing keys from
+   * BEHAVIOR_DEFAULTS (keeping user settings intact).
+   */
+  async ensureProfileConfig(profileFp, oldGlobalParsed, oldFileExisted) {
+    const t0 = Date.now();
+    try {
+      await withFileLock(profileFp, async () => {
+        let parsed;
+        let existed = true;
+        try {
+          const raw = await fs13.readFile(profileFp, "utf8");
+          const result = safeParse(raw);
+          if (!result.ok || !isPlainRecord(result.value)) {
+            this.logWarn("Profile config parse failed \u2014 falling back to defaults", {
+              event: "config.profile_parse_failed",
+              path: profileFp
+            });
+            parsed = {};
+          } else {
+            parsed = result.value;
+          }
+        } catch (err) {
+          if (err.code !== "ENOENT") {
+            this.logWarn("Profile config read failed", {
+              event: "config.profile_read_failed",
+              path: profileFp,
+              message: toErrorMessage(err)
+            });
+            return;
+          }
+          existed = false;
+          parsed = {};
+        }
+        let seed;
+        if (!existed && oldFileExisted && Object.keys(oldGlobalParsed).length >= 1) {
+          seed = { ...oldGlobalParsed };
+          delete seed["activeProfile"];
+          const filled = fillMissingDefaults(seed, BEHAVIOR_DEFAULTS);
+          seed = filled.value;
+        } else {
+          const filled = fillMissingDefaults(parsed, BEHAVIOR_DEFAULTS);
+          if (!filled.changed) return;
+          seed = filled.value;
+        }
+        await atomicWrite(profileFp, JSON.stringify(seed, null, 2), { mode: 384 });
         this.events?.emit("storage.write", {
           sessionId: "~config~",
           store: "config",
-          filePath: fp,
-          operation: "ensure_defaults",
+          filePath: profileFp,
+          operation: "ensure_profile_defaults",
           outcome: "success",
           durationMs: Date.now() - t0,
           ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
@@ -24943,18 +26250,19 @@ var DefaultConfigLoader = class {
       this.events?.emit("storage.error", {
         sessionId: "~config~",
         store: "config",
-        filePath: fp,
-        operation: "ensure_defaults",
+        filePath: profileFp,
+        operation: "ensure_profile_defaults",
         outcome: "failure",
         error: storageErrorString(err),
         recoverable: false,
         durationMs: Date.now() - t0,
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config defaults write failed",
-        { event: "config.defaults_write_failed", path: fp, message: toErrorMessage(err) }
-      );
+      this.logWarn("Profile config defaults write failed", {
+        event: "config.profile_write_failed",
+        path: profileFp,
+        message: toErrorMessage(err)
+      });
     }
   }
   /**
@@ -25056,10 +26364,10 @@ var DefaultConfigLoader = class {
         error: storageErrorString(err),
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config sync load failed",
-        { event: "config.sync_load_failed", message: toErrorMessage(err) }
-      );
+      this.logWarn("Config sync load failed", {
+        event: "config.sync_load_failed",
+        message: toErrorMessage(err)
+      });
       return null;
     }
   }
@@ -25067,8 +26375,8 @@ var DefaultConfigLoader = class {
     const t0 = Date.now();
     let mtimeMs = null;
     try {
-      const stat12 = await fs13.stat(file);
-      mtimeMs = stat12.mtimeMs;
+      const stat13 = await fs13.stat(file);
+      mtimeMs = stat13.mtimeMs;
       const cached = this.jsonCache.get(file);
       if (cached && cached.mtimeMs === mtimeMs) {
         return structuredClone(cached.value);
@@ -25088,10 +26396,11 @@ var DefaultConfigLoader = class {
         error: storageErrorString(err),
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config read failed (stat)",
-        { event: "config.read_failed", path: file, message: toErrorMessage(err) }
-      );
+      this.logWarn("Config read failed (stat)", {
+        event: "config.read_failed",
+        path: file,
+        message: toErrorMessage(err)
+      });
       return {};
     }
     let raw;
@@ -25109,10 +26418,11 @@ var DefaultConfigLoader = class {
           error: storageErrorString(err),
           ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
         });
-        this.logWarn(
-          "Config read failed (read)",
-          { event: "config.read_failed", path: file, message: toErrorMessage(err) }
-        );
+        this.logWarn("Config read failed (read)", {
+          event: "config.read_failed",
+          path: file,
+          message: toErrorMessage(err)
+        });
       }
       this.jsonCache.set(file, { mtimeMs: null, value: {} });
       return {};
@@ -25129,10 +26439,10 @@ var DefaultConfigLoader = class {
         error: "parse error or empty file",
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      this.logWarn(
-        "Config parse failed \u2014 falling back to defaults",
-        { event: "config.parse_failed", path: file }
-      );
+      this.logWarn("Config parse failed \u2014 falling back to defaults", {
+        event: "config.parse_failed",
+        path: file
+      });
       return {};
     }
     this.jsonCache.set(file, { mtimeMs, value: structuredClone(parsed.value) });
@@ -25328,7 +26638,7 @@ function deepFreeze(obj) {
 
 // src/storage/plan-store.ts
 import * as fsp14 from "node:fs/promises";
-import { randomUUID as randomUUID11 } from "node:crypto";
+import { randomUUID as randomUUID12 } from "node:crypto";
 async function loadPlan(filePath, events) {
   const t0 = Date.now();
   let raw;
@@ -25426,7 +26736,7 @@ function emptyPlan(sessionId, title) {
 function addPlanItem(plan, title, details) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const item = {
-    id: `plan_${Date.now()}_${randomUUID11().slice(0, 6)}`,
+    id: `plan_${Date.now()}_${randomUUID12().slice(0, 6)}`,
     title,
     details,
     status: "open",
@@ -25498,7 +26808,7 @@ function deriveTodosFromPlanItem(plan, idOrIndex, subtasks) {
   if (subtasks && subtasks.length > 0) {
     for (const st of subtasks) {
       todos.push({
-        id: `todo_${Date.now()}_${randomUUID11().slice(0, 6)}`,
+        id: `todo_${Date.now()}_${randomUUID12().slice(0, 6)}`,
         content: st,
         status: "pending",
         promotedFromPlan: item.id
@@ -25626,7 +26936,7 @@ ${cat}:`);
 
 // src/storage/queue-store.ts
 import * as fsp15 from "node:fs/promises";
-import * as path26 from "node:path";
+import * as path27 from "node:path";
 var QueueStore = class {
   file;
   // Use `| undefined` (not `?`) so exactOptionalPropertyTypes doesn't
@@ -25635,7 +26945,7 @@ var QueueStore = class {
   traceId;
   logger;
   constructor(opts) {
-    this.file = path26.join(opts.dir, "queue.json");
+    this.file = path27.join(opts.dir, "queue.json");
     this.events = opts.events;
     this.traceId = opts.traceId;
     this.logger = opts.logger;
@@ -25793,7 +27103,7 @@ function isPersistedQueueItem(v) {
 // src/storage/recovery-lock.ts
 import * as fsp16 from "node:fs/promises";
 import * as os3 from "node:os";
-import * as path27 from "node:path";
+import * as path28 from "node:path";
 var LOCK_FILE = "active.json";
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var RecoveryLock = class {
@@ -25804,7 +27114,7 @@ var RecoveryLock = class {
   sessionStore;
   probe;
   constructor(opts) {
-    this.file = path27.join(opts.dir, LOCK_FILE);
+    this.file = path28.join(opts.dir, LOCK_FILE);
     this.pid = opts.pid ?? process.pid;
     this.hostname = opts.hostname ?? os3.hostname();
     this.maxAgeMs = opts.maxAgeMs ?? DEFAULT_MAX_AGE_MS;
@@ -25865,7 +27175,7 @@ var RecoveryLock = class {
    * null return before calling this.
    */
   async write(sessionId) {
-    await ensureDir(path27.dirname(this.file));
+    await ensureDir(path28.dirname(this.file));
     const lock = {
       v: 1,
       sessionId,
@@ -26040,6 +27350,9 @@ var CORE_RECONSTRUCT_EVENTS = /* @__PURE__ */ new Set([
   "user_input",
   "llm_response",
   "tool_result",
+  "message_appended",
+  "message_updated",
+  "messages_replaced",
   "context_snapshot",
   "checkpoint",
   "file_snapshot",
@@ -26060,11 +27373,22 @@ var STANDARD_AUDIT_EVENTS = /* @__PURE__ */ new Set([
   "provider_retry",
   "provider_error",
   "skill_activated",
-  "skill_deactivated"
-]);
-var FULL_ONLY_EVENTS = /* @__PURE__ */ new Set([
-  "tool_progress"
+  "skill_deactivated",
+  // Resume markers and fleet lifecycle. These reach disk today only because
+  // every producer appends to the raw SessionWriter and bypasses this bridge —
+  // routed through it while absent from both sets, `isAllowed` would drop them
+  // at the DEFAULT level and the resume timeline would lose them silently.
+  "mode_changed",
+  "agent_spawned",
+  "agent_stopped",
+  "agent_error",
+  "task_created",
+  "task_updated",
+  "task_completed",
+  "task_failed",
+  "side_effect"
 ]);
+var FULL_ONLY_EVENTS = /* @__PURE__ */ new Set(["tool_progress"]);
 function isAllowed(type, level) {
   if (CORE_RECONSTRUCT_EVENTS.has(type)) return true;
   if (level === "minimal") return false;
@@ -26119,9 +27443,7 @@ function createSessionEventBridge(writer, level = "standard", options = {}) {
     async appendBatch(events) {
       const target = resolveWriter();
       if (!target || events.length === 0) return;
-      const allowed = events.filter(
-        (e) => isAllowed(e.type, currentLevel) && shouldSample(e)
-      );
+      const allowed = events.filter((e) => isAllowed(e.type, currentLevel) && shouldSample(e));
       if (allowed.length === 0) return;
       try {
         await target.appendBatch(allowed);
@@ -26170,8 +27492,8 @@ var DefaultSessionReader = class _DefaultSessionReader {
     const sessionPath = sessionScopedPath(rootDir, sessionId, ".jsonl");
     let mtimeMs = null;
     try {
-      const stat12 = await fs14.stat(sessionPath);
-      mtimeMs = stat12.mtimeMs;
+      const stat13 = await fs14.stat(sessionPath);
+      mtimeMs = stat13.mtimeMs;
     } catch {
       this.eventCache.delete(sessionId);
       this.eventCacheMtimes.delete(sessionId);