zelari-code 2.2.0 → 2.3.0

package/dist/cli/main.bundled.js

@@ -18246,14 +18246,15 @@ var init_filesystem = __esm({
     init_toolTypes();
     ReadFileArgsSchema = external_exports.object({
       path: external_exports.string().min(1),
-      startLine: external_exports.number().int().nonnegative().optional(),
-      endLine: external_exports.number().int().positive().optional(),
+      startLine: external_exports.number().int().nonnegative().optional().describe("0-based first line to include. Range is applied to the full file before maxBytes."),
+      endLine: external_exports.number().int().positive().optional().describe("Exclusive 0-based end line. Omit to read through EOF (still capped by maxBytes)."),
       maxBytes: external_exports.number().int().positive().max(1e7).default(1e6)
     });
     readFileTool = {
       name: "read_file",
-      description: "Read a file with optional line range. Returns content + metadata. Use before edit_file.",
+      description: "Read a file with optional 0-based line range (endLine exclusive). maxBytes caps the selected range, not a prefix of the file. Returns content + metadata. Use before edit_file.",
       permissions: ["read"],
+      sideEffect: "none",
       timeoutMs: 5e3,
       inputSchema: ReadFileArgsSchema,
       execute: async (args, ctx) => {
@@ -18262,24 +18263,31 @@ var init_filesystem = __esm({
           const buf = await fs4.readFile(absPath, { encoding: "utf-8", signal: ctx.signal });
           const content = typeof buf === "string" ? buf : buf.toString("utf-8");
           const allLines = content.split("\n");
-          const truncated = content.length > args.maxBytes ? content.slice(0, args.maxBytes) : content;
-          const lines = truncated === content ? allLines : truncated.split("\n");
           const totalLines = allLines.length;
           const start = args.startLine ?? 0;
-          const end = Math.min(args.endLine ?? lines.length, lines.length);
-          const wasTruncated = truncated !== content;
+          const endExclusive = Math.min(args.endLine ?? totalLines, totalLines);
           const empty = content.length === 0;
-          const status = empty ? "empty" : wasTruncated ? "partial" : "complete";
+          const rangeEmpty = !empty && (start >= totalLines || endExclusive <= start);
+          const selected = rangeEmpty ? [] : allLines.slice(start, endExclusive);
+          let text = selected.join("\n");
+          const wasTruncated = text.length > args.maxBytes;
+          if (wasTruncated)
+            text = text.slice(0, args.maxBytes);
+          const returnedLines = text.length === 0 ? 0 : text.split("\n").length;
+          const readEnd = returnedLines === 0 ? Math.max(0, start - 1) : start + returnedLines - 1;
+          const status = empty || rangeEmpty ? "empty" : wasTruncated ? "partial" : "complete";
           const warnings = [];
           if (empty)
             warnings.push("EMPTY_FILE");
+          if (rangeEmpty)
+            warnings.push("LINE_RANGE_EMPTY");
           if (wasTruncated)
             warnings.push("MAX_BYTES_TRUNCATED");
           return typedOk({
             path: absPath,
-            content: lines.slice(start, end).join("\n"),
+            content: text,
             totalLines,
-            readLines: { start, end: end - 1 },
+            readLines: { start, end: readEnd },
             sizeBytes: content.length
           }, {
             status,
@@ -18305,6 +18313,7 @@ var init_filesystem = __esm({
       name: "write_file",
       description: "Write or create a file. Use createDirs=true to auto-create parent directories.",
       permissions: ["write"],
+      sideEffect: "local",
       timeoutMs: 1e4,
       inputSchema: WriteFileArgsSchema,
       execute: async (args, ctx) => {
@@ -18330,6 +18339,7 @@ var init_filesystem = __esm({
       name: "edit_file",
       description: "Replace exact string match in a file. Idempotent: returns 0 occurrences if no match.",
       permissions: ["write"],
+      sideEffect: "local",
       timeoutMs: 1e4,
       inputSchema: EditFileArgsSchema,
       execute: async (args, ctx) => {
@@ -18561,6 +18571,7 @@ var init_shell = __esm({
       name: "bash",
       description: "Run a shell command. On Windows uses Git Bash when available (POSIX semantics: ls, $VAR, && work); falls back to cmd.exe otherwise. Streams stdout/stderr. Respects timeout and cancellation. Returns exit code. stdin is CLOSED (non-interactive): any command that prompts for input will fail or be cancelled \u2014 always pass non-interactive flags (--yes, -y, --template), and if a scaffolder insists on prompting (e.g. create-vite in a non-empty directory), create the files manually with write_file instead.",
       permissions: ["execute"],
+      sideEffect: "local",
       timeoutMs: 6e4,
       inputSchema: BashArgsSchema,
       execute: async (args, ctx) => {
@@ -18870,6 +18881,7 @@ var init_search = __esm({
       name: "grep_content",
       description: 'Regex search for content in a file OR recursively in a directory. When path is a directory, include/exclude globs filter which files are searched (default: all files, excluding node_modules/dist/.git/etc.). Glob semantics: "*" matches ONE path segment only ("*.ts" does NOT match "sub/file.ts"); use "**" for recursive matching ("**/*.ts" matches at any depth). include/exclude accept a single glob string (e.g. "*.ts") OR an array of globs. Returns matches with line numbers and context, plus filesWalked/filesInTree counts and a warning when the include globs matched suspiciously few files.',
       permissions: ["read"],
+      sideEffect: "none",
       timeoutMs: 3e4,
       inputSchema: GrepContentArgsSchema,
       execute: async (args, ctx) => {
@@ -18987,6 +18999,7 @@ var init_listFiles = __esm({
       name: "list_files",
       description: "List files and directories in the given path (defaults to the working directory). Returns names with types (file/directory). Use this to discover the project structure before reading specific files. Supports a maxDepth for recursive listing and excludes common dependency/build directories by default.",
       permissions: ["read"],
+      sideEffect: "none",
       timeoutMs: 15e3,
       inputSchema: ListFilesArgsSchema,
       execute: async (args, ctx) => {
@@ -19241,6 +19254,7 @@ var init_diff = __esm({
       name: "show_diff",
       description: "Show unified diff between current file content and proposed content. Read-only \u2014 does NOT modify the file. Use this to preview edits before applying with edit_file or apply_diff.",
       permissions: ["read"],
+      sideEffect: "none",
       timeoutMs: 15e3,
       inputSchema: ShowDiffArgsSchema,
       execute: async (args, ctx) => {
@@ -19343,6 +19357,7 @@ var init_diff = __esm({
       name: "apply_diff",
       description: "Apply a unified diff patch to a file. Parses ---/+++/@@ headers and applies each hunk sequentially. With fuzzyMatch=true, tolerates whitespace differences. With dryRun=true, returns the final content without writing. Atomic: if any hunk fails, no partial write occurs.",
       permissions: ["write"],
+      sideEffect: "local",
       timeoutMs: 15e3,
       inputSchema: ApplyDiffArgsSchema,
       execute: async (args, ctx) => {
@@ -21471,6 +21486,42 @@ var init_types = __esm({
   }
 });
 
+// packages/core/dist/core/tools/concurrency.js
+function taskAgent(args) {
+  if (!args || typeof args !== "object")
+    return "explore";
+  const agent = args.agent;
+  return typeof agent === "string" && agent.trim() ? agent : "explore";
+}
+function classifyToolConcurrency(input) {
+  const env = input.env ?? process.env;
+  if (env.ZELARI_PARALLEL_TOOLS === "0")
+    return "exclusive";
+  const name = input.toolName;
+  if (name === "task") {
+    return taskAgent(input.args) === "general" ? "exclusive" : "parallel-safe";
+  }
+  if (input.registered === false) {
+    if (name.startsWith("mcp_")) {
+      const lower = name.toLowerCase();
+      if (lower.includes("write") || lower.includes("edit") || lower.includes("delete")) {
+        return "exclusive";
+      }
+      return "parallel-safe";
+    }
+    return "exclusive";
+  }
+  const perms = input.permissions ?? [];
+  if (perms.includes("write") || perms.includes("execute"))
+    return "exclusive";
+  return "parallel-safe";
+}
+var init_concurrency = __esm({
+  "packages/core/dist/core/tools/concurrency.js"() {
+    "use strict";
+  }
+});
+
 // packages/core/dist/core/contextGrowth.js
 function emptyContextGrowthStats() {
   return {
@@ -22022,6 +22073,7 @@ var init_AgentHarness = __esm({
   "packages/core/dist/core/AgentHarness.js"() {
     "use strict";
     init_events();
+    init_concurrency();
     init_toolTypes();
     init_contextGrowth();
     init_requestSnapshot();
@@ -22106,30 +22158,19 @@ var init_AgentHarness = __esm({
         };
       }
       /**
-       * v1.8.0: true when a tool may run concurrently with other parallel-safe
-       * tools. Write/execute tools stay serial (preserve file/order safety).
-       * `task` is parallel-safe (read-only sub-agents). Opt out: ZELARI_PARALLEL_TOOLS=0.
+       * v1.8.0 / 2.x F: true when a tool may run concurrently with other
+       * parallel-safe tools. Write/execute stay serial. `task agent=general`
+       * is exclusive (it writes); explore/verify tentacles stay parallel-safe.
+       * Opt out: ZELARI_PARALLEL_TOOLS=0.
        */
-      isParallelSafeTool(toolName) {
-        if (process.env.ZELARI_PARALLEL_TOOLS === "0")
-          return false;
-        if (toolName === "task")
-          return true;
+      isParallelSafeTool(toolName, args) {
         const def = this.config.toolRegistry?.get(toolName);
-        if (!def) {
-          if (toolName.startsWith("mcp_")) {
-            const lower = toolName.toLowerCase();
-            if (lower.includes("write") || lower.includes("edit") || lower.includes("delete")) {
-              return false;
-            }
-            return true;
-          }
-          return false;
-        }
-        const perms = def.permissions ?? [];
-        if (perms.includes("write") || perms.includes("execute"))
-          return false;
-        return true;
+        return classifyToolConcurrency({
+          toolName,
+          args,
+          permissions: def?.permissions,
+          registered: Boolean(def) || toolName === "task"
+        }) === "parallel-safe";
       }
       /**
        * Execute buffered native tool calls: consecutive parallel-safe tools run
@@ -22234,13 +22275,13 @@ ${shared2.content}`,
         let i = 0;
         while (i < pending.length) {
           const p3 = pending[i];
-          if (p3.skipped || p3.cached !== void 0 || !this.isParallelSafeTool(p3.toolName)) {
+          if (p3.skipped || p3.cached !== void 0 || !this.isParallelSafeTool(p3.toolName, p3.args)) {
             out[i] = toOut(p3, await invokeOne(p3));
             i += 1;
             continue;
           }
           let j = i;
-          while (j < pending.length && !pending[j].skipped && pending[j].cached === void 0 && this.isParallelSafeTool(pending[j].toolName)) {
+          while (j < pending.length && !pending[j].skipped && pending[j].cached === void 0 && this.isParallelSafeTool(pending[j].toolName, pending[j].args)) {
             j += 1;
           }
           for (let off = i; off < j; off += maxParallel) {
@@ -28263,6 +28304,8 @@ var init_types8 = __esm({
       "assistant.message",
       "tool.call",
       "tool.result",
+      // 2.x B (crash-safe recovery): dangling call classified. State-only.
+      "tool.interrupted",
       "context.injected",
       "session.compacted",
       "task.created",
@@ -28515,6 +28558,82 @@ var init_writer = __esm({
   }
 });
 
+// packages/core/dist/session/recovery.js
+function sideEffectForTool(tool, declared) {
+  if (declared)
+    return declared;
+  if (EXTERNAL.has(tool))
+    return "external";
+  if (READ_ONLY.has(tool))
+    return "none";
+  return "local";
+}
+function retrySafetyForSideEffect(sideEffect) {
+  return sideEffect === "none" ? "safe" : "inspect-first";
+}
+function toolNameOf(call) {
+  return typeof call.data.tool === "string" && call.data.tool.trim() ? call.data.tool : "unknown";
+}
+function callIdOf(call) {
+  return typeof call.data.callId === "string" ? call.data.callId : `seq:${call.seq}`;
+}
+function classifyInterruptedTools(events, sideEffects = /* @__PURE__ */ new Map()) {
+  const alreadyClassified = new Set(events.filter((e) => e.kind === "tool.interrupted").map((e) => typeof e.data.callId === "string" ? e.data.callId : void 0).filter((id) => Boolean(id)));
+  const out = [];
+  for (const pair of pairToolCalls(events)) {
+    if (pair.result)
+      continue;
+    const callId = callIdOf(pair.call);
+    if (alreadyClassified.has(callId))
+      continue;
+    const tool = toolNameOf(pair.call);
+    const sideEffect = sideEffectForTool(tool, sideEffects.get(tool));
+    const retrySafety = retrySafetyForSideEffect(sideEffect);
+    out.push({
+      toolCallSeq: pair.call.seq,
+      callId,
+      tool,
+      state: retrySafety === "safe" ? "not-started" : "started-outcome-unknown",
+      retrySafety,
+      sideEffect
+    });
+  }
+  return out;
+}
+function interruptedEventData(item) {
+  return {
+    toolCallSeq: item.toolCallSeq,
+    callId: item.callId,
+    tool: item.tool,
+    state: item.state,
+    retrySafety: item.retrySafety,
+    sideEffect: item.sideEffect
+  };
+}
+var READ_ONLY, EXTERNAL;
+var init_recovery = __esm({
+  "packages/core/dist/session/recovery.js"() {
+    "use strict";
+    init_modelSurface();
+    READ_ONLY = /* @__PURE__ */ new Set([
+      "read_file",
+      "list_files",
+      "grep_content",
+      "show_diff",
+      "web_search",
+      "fetch_url",
+      "lsp_definition",
+      "lsp_references",
+      "lsp_hover",
+      "lsp_symbols",
+      "ast_outline",
+      "ast_find_symbol",
+      "semantic_search"
+    ]);
+    EXTERNAL = /* @__PURE__ */ new Set(["fetch_url", "web_search"]);
+  }
+});
+
 // packages/core/dist/session/replay.js
 import { promises as fs10 } from "node:fs";
 async function readSessionLog(filePath) {
@@ -28599,7 +28718,8 @@ function buildProjection(events, issues = []) {
     missionPhases: [],
     missionAdvice: [],
     replans: 0,
-    issues
+    issues,
+    interruptedTools: classifyInterruptedTools(events)
   };
   for (const e of events) {
     switch (e.kind) {
@@ -28650,6 +28770,7 @@ var init_replay = __esm({
     "use strict";
     init_types8();
     init_modelSurface();
+    init_recovery();
   }
 });
 
@@ -28789,12 +28910,20 @@ async function forkSession(store6, parentSessionId, options = {}) {
 }
 async function resumeSession(store6, sessionId2) {
   const opened = await store6.open(sessionId2);
+  const classified = [];
+  for (const item of classifyInterruptedTools(opened.report.events)) {
+    classified.push(await opened.writer.append({
+      kind: "tool.interrupted",
+      actor: ACTOR_SYSTEM,
+      data: interruptedEventData(item)
+    }));
+  }
   const resumed = await opened.writer.append({
     kind: "session.resumed",
     actor: ACTOR_SYSTEM,
     data: { fromSeq: opened.projection.lastSeq }
   });
-  const projection = buildProjection([...opened.report.events, resumed]);
+  const projection = buildProjection([...opened.report.events, ...classified, resumed]);
   return { writer: opened.writer, projection };
 }
 async function lineageOf(store6, sessionId2) {
@@ -28822,6 +28951,7 @@ var init_lineage = __esm({
     "use strict";
     init_types8();
     init_replay();
+    init_recovery();
   }
 });
 
@@ -28862,6 +28992,104 @@ var init_exportSession = __esm({
   }
 });
 
+// packages/core/dist/session/invariants.js
+function asSeq(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function collectEvidenceSeqs(events) {
+  const out = [];
+  const walk2 = (ownerSeq, value) => {
+    if (Array.isArray(value)) {
+      for (const item of value)
+        walk2(ownerSeq, item);
+      return;
+    }
+    if (!value || typeof value !== "object")
+      return;
+    const rec = value;
+    const seq = asSeq(rec.seq);
+    if (seq !== void 0 && ("digest" in rec || "tier" in rec || "ref" in rec)) {
+      out.push({ ownerSeq, refSeq: seq });
+    }
+    for (const v of Object.values(rec))
+      walk2(ownerSeq, v);
+  };
+  for (const e of events)
+    walk2(e.seq, e.data);
+  return out;
+}
+function validateSessionTrace(events, mode = "minimal") {
+  const violations = [];
+  let expected = 1;
+  for (const e of events) {
+    if (e.seq !== expected) {
+      violations.push({
+        code: "SEQ_NOT_MONOTONIC",
+        seq: e.seq,
+        message: `expected seq ${expected}, got ${e.seq}`
+      });
+    }
+    expected = e.seq + 1;
+  }
+  const pairs = pairToolCalls(events);
+  const resultCounts = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.kind !== "tool.result")
+      continue;
+    const callId = typeof e.data.callId === "string" ? e.data.callId : `seq:${e.seq}`;
+    resultCounts.set(callId, (resultCounts.get(callId) ?? 0) + 1);
+  }
+  for (const [callId, n] of resultCounts) {
+    if (n > 1) {
+      violations.push({
+        code: "DUPLICATE_TOOL_RESULT",
+        message: `callId ${callId} has ${n} tool.result events`
+      });
+    }
+  }
+  const interruptedCallIds = new Set(events.filter((e) => e.kind === "tool.interrupted").map((e) => typeof e.data.callId === "string" ? e.data.callId : void 0).filter((id) => Boolean(id)));
+  for (const pair of pairs) {
+    if (pair.result)
+      continue;
+    const callId = typeof pair.call.data.callId === "string" ? pair.call.data.callId : `seq:${pair.call.seq}`;
+    if (interruptedCallIds.has(callId))
+      continue;
+    if (mode === "strict") {
+      violations.push({
+        code: "DANGLING_TOOL_CALL",
+        seq: pair.call.seq,
+        message: `tool.call ${callId} has no tool.result and no tool.interrupted`
+      });
+    }
+  }
+  const knownSeq = new Set(events.map((e) => e.seq));
+  for (const ref of collectEvidenceSeqs(events)) {
+    if (!knownSeq.has(ref.refSeq)) {
+      violations.push({
+        code: "EVIDENCE_SEQ_MISSING",
+        seq: ref.ownerSeq,
+        message: `EvidenceRef.seq ${ref.refSeq} is not an event in this trace`
+      });
+    }
+  }
+  const firstVerification = events.find((e) => e.kind === "verification.run");
+  const firstEnded = events.find((e) => e.kind === "session.ended");
+  if (firstVerification && firstEnded && firstEnded.seq < firstVerification.seq) {
+    violations.push({
+      code: "COMPLETION_BEFORE_VERIFICATION",
+      seq: firstEnded.seq,
+      message: `session.ended seq ${firstEnded.seq} precedes verification.run seq ${firstVerification.seq}`
+    });
+  }
+  return violations;
+}
+var init_invariants = __esm({
+  "packages/core/dist/session/invariants.js"() {
+    "use strict";
+    init_modelSurface();
+  }
+});
+
 // packages/core/dist/session/index.js
 var init_session = __esm({
   "packages/core/dist/session/index.js"() {
@@ -28874,6 +29102,8 @@ var init_session = __esm({
     init_store();
     init_lineage();
     init_exportSession();
+    init_invariants();
+    init_recovery();
   }
 });
 
@@ -29486,6 +29716,72 @@ var init_types9 = __esm({
   }
 });
 
+// packages/core/dist/verification/scopeDiscipline.js
+function normalize(p3) {
+  return p3.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isGeneratedPath(file2) {
+  const n = normalize(file2);
+  return GENERATED_NAME.test(n) || GENERATED_DIR.test(n);
+}
+function parseNameOnlyDiff(stdout) {
+  return stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean).map(normalize);
+}
+function analyzeScope(input) {
+  const changed = input.changedFiles.map(normalize);
+  if (changed.length === 0) {
+    return {
+      status: "unknown",
+      expected: [],
+      unexpected: [],
+      generated: [],
+      reasons: ["no changed files observed"]
+    };
+  }
+  const expectedSet = new Set((input.expectedFiles ?? []).map(normalize));
+  const generatedExtra = new Set((input.generatedFiles ?? []).map(normalize));
+  const generated = [];
+  const unexpected = [];
+  const expectedHit = [];
+  for (const file2 of changed) {
+    if (generatedExtra.has(file2) || isGeneratedPath(file2)) {
+      generated.push(file2);
+      continue;
+    }
+    if (expectedSet.size === 0) {
+      expectedHit.push(file2);
+      continue;
+    }
+    if (expectedSet.has(file2))
+      expectedHit.push(file2);
+    else
+      unexpected.push(file2);
+  }
+  const reasons = [];
+  if (unexpected.length > 0) {
+    reasons.push(`${unexpected.length} file(s) outside expected scope: ${unexpected.join(", ")}`);
+  }
+  if (generated.length > 0) {
+    reasons.push(`${generated.length} generated/lockfile path(s) ignored for the concern`);
+  }
+  let status = "pass";
+  if (expectedSet.size === 0) {
+    status = "unknown";
+    reasons.push("no expected-files allowlist \u2014 cannot judge scope");
+  } else if (unexpected.length > 0) {
+    status = "concern";
+  }
+  return { status, expected: expectedHit, unexpected, generated, reasons };
+}
+var GENERATED_NAME, GENERATED_DIR;
+var init_scopeDiscipline = __esm({
+  "packages/core/dist/verification/scopeDiscipline.js"() {
+    "use strict";
+    GENERATED_NAME = /(?:^|\/)(?:package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb|Cargo\.lock|go\.sum|poetry\.lock|composer\.lock)$/i;
+    GENERATED_DIR = /(?:^|\/)(?:dist|build|out|coverage|\.next|node_modules)\//;
+  }
+});
+
 // packages/core/dist/verification/engine.js
 import { createHash as createHash4 } from "node:crypto";
 function defaultSha256(input) {
@@ -29498,6 +29794,7 @@ var VerificationEngine;
 var init_engine = __esm({
   "packages/core/dist/verification/engine.js"() {
     "use strict";
+    init_scopeDiscipline();
     VerificationEngine = class {
       services;
       options;
@@ -29509,7 +29806,7 @@ var init_engine = __esm({
       async evaluate(criteria, context = {}) {
         const results = [];
         for (const criterion of criteria) {
-          results.push(await this.evaluateOne(criterion));
+          results.push(await this.evaluateOne(criterion, context.scope));
         }
         if (this.options.emit) {
           try {
@@ -29559,7 +29856,7 @@ var init_engine = __esm({
           return void 0;
         }
       }
-      async evaluateOne(criterion) {
+      async evaluateOne(criterion, scope) {
         const started = this.options.now?.() ?? Date.now();
         const base = {
           criterionId: criterion.id,
@@ -29571,6 +29868,15 @@ var init_engine = __esm({
           ...patch,
           durationMs: Math.max(0, (this.options.now?.() ?? Date.now()) - started)
         });
+        if (criterion.id === "quality.scope-discipline" && scope) {
+          const analysis = analyzeScope(scope);
+          const status = analysis.status === "pass" ? "pass" : "unknown";
+          return done({
+            status,
+            evidence: [],
+            detail: analysis.reasons.join("; ") || analysis.status
+          });
+        }
         const check2 = criterion.check;
         if (!check2 || check2.kind === "none") {
           return done({
@@ -30184,6 +30490,7 @@ var init_verification2 = __esm({
     init_criteriaPack_v1();
     init_metrics();
     init_verifier();
+    init_scopeDiscipline();
   }
 });
 
@@ -30448,6 +30755,7 @@ __export(dist_exports, {
   WorkspacePathEscapeError: () => WorkspacePathEscapeError,
   WorktreeWorkspace: () => WorktreeWorkspace,
   ZELARI_CODING_PACK_ID: () => ZELARI_CODING_PACK_ID,
+  analyzeScope: () => analyzeScope,
   applyCompletionRetry: () => applyCompletionRetry,
   applyDeterministicAutofix: () => applyDeterministicAutofix,
   applyImplementationWriteRetry: () => applyImplementationWriteRetry,
@@ -30478,6 +30786,7 @@ __export(dist_exports, {
   checkImplementationDelivery: () => checkImplementationDelivery,
   checkMemberToolEmissionSets: () => checkMemberToolEmissionSets,
   checkMemberToolEmissions: () => checkMemberToolEmissions,
+  classifyInterruptedTools: () => classifyInterruptedTools,
   classifyMission: () => classifyMission,
   classifyTaskScope: () => classifyTaskScope,
   cleanAgentContent: () => cleanAgentContent,
@@ -30545,6 +30854,7 @@ __export(dist_exports, {
   hasInteractiveClarification: () => hasInteractiveClarification,
   hashToolCall: () => hashToolCall,
   hookMatches: () => hookMatches,
+  interruptedEventData: () => interruptedEventData,
   isAnswerLeak: () => isAnswerLeak,
   isBrainAgentEndEvent: () => isBrainAgentEndEvent,
   isBrainAgentStartEvent: () => isBrainAgentStartEvent,
@@ -30568,6 +30878,7 @@ __export(dist_exports, {
   isConverged: () => isConverged,
   isEventBackedEvidence: () => isEventBackedEvidence,
   isExperimentalEnabled: () => isExperimentalEnabled,
+  isGeneratedPath: () => isGeneratedPath,
   isModelSurfaceEvent: () => isModelSurfaceEvent,
   isReviewerKind: () => isReviewerKind,
   isSettled: () => isSettled,
@@ -30594,6 +30905,7 @@ __export(dist_exports, {
   parseClarificationRequest: () => parseClarificationRequest,
   parseEvidenceTier: () => parseEvidenceTier,
   parseMinimaxStyleToolCalls: () => parseMinimaxStyleToolCalls,
+  parseNameOnlyDiff: () => parseNameOnlyDiff,
   parsePersonaVerdict: () => parsePersonaVerdict,
   parseProjectRootFromWorkspaceContext: () => parseProjectRootFromWorkspaceContext,
   parseTextToolCalls: () => parseTextToolCalls,
@@ -30631,6 +30943,7 @@ __export(dist_exports, {
   resolveVerifyRetryTool: () => resolveVerifyRetryTool,
   restrictImplementationWrites: () => restrictImplementationWrites,
   resumeSession: () => resumeSession,
+  retrySafetyForSideEffect: () => retrySafetyForSideEffect,
   runChairmanDeliveryLoop: () => runChairmanDeliveryLoop,
   runChairmanFixLoop: () => runChairmanFixLoop,
   runChairmanMicroGate: () => runChairmanMicroGate,
@@ -30647,6 +30960,7 @@ __export(dist_exports, {
   setWorkspaceStubs: () => setWorkspaceStubs,
   sha256Hex: () => sha256Hex,
   shouldRetryMember: () => shouldRetryMember,
+  sideEffectForTool: () => sideEffectForTool,
   slugify: () => slugify2,
   snapshotToCompletionEvaluation: () => snapshotToCompletionEvaluation,
   specificityFromAssumptions: () => specificityFromAssumptions,
@@ -30666,6 +30980,7 @@ __export(dist_exports, {
   utf8Bytes: () => utf8Bytes,
   validateCodingSkillRequires: () => validateCodingSkillRequires,
   validateGraph: () => validateGraph,
+  validateSessionTrace: () => validateSessionTrace,
   verificationCostRatio: () => verificationCostRatio,
   verifiedSolveRate: () => verifiedSolveRate,
   verifyCitations: () => verifyCitations,
@@ -32967,9 +33282,25 @@ var init_registry2 = __esm({
           return typedErr(`Invalid input: ${parsed.error.message}`);
         }
         const timeoutMs = options.timeoutMs ?? tool.timeoutMs ?? 3e4;
-        const signal = options.signal;
+        const parentSignal = options.signal;
+        const controller = new AbortController();
+        let timer;
+        let rejectRace;
+        const onParentAbort = () => {
+          if (timer !== void 0)
+            clearTimeout(timer);
+          if (!controller.signal.aborted)
+            controller.abort();
+          rejectRace?.(new Error(`Tool "${name}" aborted`));
+        };
+        if (parentSignal) {
+          if (parentSignal.aborted)
+            onParentAbort();
+          else
+            parentSignal.addEventListener("abort", onParentAbort);
+        }
         const ctx = {
-          signal: signal ?? new AbortController().signal,
+          signal: controller.signal,
           cwd: options.cwd ?? process.cwd(),
           audit: () => {
           },
@@ -32982,6 +33313,7 @@ var init_registry2 = __esm({
               cwd: ctx.cwd
             });
             if (!pre.ok) {
+              parentSignal?.removeEventListener("abort", onParentAbort);
               return typedErr(`[hook:${pre.hookName ?? "unknown"}] ${pre.reason ?? "denied"}`);
             }
           } catch (hookErr) {
@@ -32991,11 +33323,16 @@ var init_registry2 = __esm({
           const result = await Promise.race([
             tool.execute(parsed.data, ctx),
             new Promise((_, reject) => {
-              const timer = setTimeout(() => reject(new Error(`Tool "${name}" timed out after ${timeoutMs}ms`)), timeoutMs);
-              signal?.addEventListener("abort", () => {
-                clearTimeout(timer);
-                reject(new Error(`Tool "${name}" aborted`));
-              });
+              rejectRace = reject;
+              if (parentSignal?.aborted) {
+                onParentAbort();
+                return;
+              }
+              timer = setTimeout(() => {
+                if (!controller.signal.aborted)
+                  controller.abort();
+                reject(new Error(`Tool "${name}" timed out after ${timeoutMs}ms`));
+              }, timeoutMs);
             })
           ]);
           if (result.ok) {
@@ -33030,6 +33367,11 @@ var init_registry2 = __esm({
         } catch (err) {
           const error51 = err instanceof Error ? err.message : String(err);
           return typedErr(error51);
+        } finally {
+          rejectRace = void 0;
+          if (timer !== void 0)
+            clearTimeout(timer);
+          parentSignal?.removeEventListener("abort", onParentAbort);
         }
       }
       /** Return all tool definitions in OpenAI function-calling format (memoized). */
@@ -33829,7 +34171,7 @@ var init_candidateRegistry = __esm({
 });
 
 // src/cli/kraken/verifyReport.ts
-function normalize(text) {
+function normalize2(text) {
   return text.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function extractVerifyReportBlocks(raw) {
@@ -33858,11 +34200,11 @@ function extractVerifyReportBlocks(raw) {
 function parseVerifyReport(raw, requiredChecks) {
   const byCriterion = /* @__PURE__ */ new Map();
   for (const block of extractVerifyReportBlocks(raw)) {
-    byCriterion.set(normalize(block.check), block);
+    byCriterion.set(normalize2(block.check), block);
   }
   const keys = [...byCriterion.keys()];
   return requiredChecks.map((check2) => {
-    const norm = normalize(check2);
+    const norm = normalize2(check2);
     let block = byCriterion.get(norm) ?? null;
     if (!block) {
       for (const key of keys) {
@@ -33901,18 +34243,18 @@ var init_verifyReport = __esm({
 });
 
 // src/cli/kraken/completionGate.ts
-function normalize2(text) {
+function normalize3(text) {
   return text.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function classifyKrakenChecks(requiredChecks, results) {
   const byCriterion = /* @__PURE__ */ new Map();
   for (const result of results ?? []) {
-    byCriterion.set(normalize2(result.check), result);
+    byCriterion.set(normalize3(result.check), result);
   }
   const keys = [...byCriterion.keys()];
   const out = { passed: [], failed: [], unknown: [] };
   for (const check2 of requiredChecks) {
-    const norm = normalize2(check2);
+    const norm = normalize3(check2);
     let result = byCriterion.get(norm) ?? null;
     if (!result) {
       for (const key of keys) {
@@ -34137,69 +34479,79 @@ async function runSubAgent(harness, opts = {}) {
   let usage;
   const pendingTools = /* @__PURE__ */ new Map();
   const toolTrace = [];
-  if (signal?.aborted) return { result: "", aborted: true };
-  for await (const ev of harness.run()) {
-    if (signal?.aborted) {
-      return {
-        result: (lastCompleted || current).trim(),
-        ...error51 ? { error: error51 } : {},
-        aborted: true,
-        ...toolTrace.length > 0 ? { toolTrace } : {}
-      };
-    }
-    if (ev.type === "tool_execution_start") {
-      pendingTools.set(ev.toolCallId, { tool: ev.toolName, command: toolCommandHint(ev.args) });
-    } else if (ev.type === "tool_execution_end") {
-      const started = pendingTools.get(ev.toolCallId);
-      pendingTools.delete(ev.toolCallId);
-      toolTrace.push({
-        tool: started?.tool ?? "unknown",
-        callId: ev.toolCallId,
-        ok: !ev.isError,
-        ...started?.command ? { command: started.command } : {},
-        output: String(ev.result ?? "").slice(0, TOOL_TRACE_OUTPUT_MAX),
-        durationMs: ev.durationMs,
-        endedAt: Date.now()
-      });
-      if (toolTrace.length > TOOL_TRACE_RING) {
-        toolTrace.splice(0, toolTrace.length - TOOL_TRACE_RING);
+  const onAbort = () => harness.cancel?.();
+  if (signal?.aborted) {
+    onAbort();
+    return { result: "", aborted: true };
+  }
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    for await (const ev of harness.run()) {
+      if (signal?.aborted) {
+        onAbort();
+        return {
+          result: (lastCompleted || current).trim(),
+          ...error51 ? { error: error51 } : {},
+          aborted: true,
+          ...toolTrace.length > 0 ? { toolTrace } : {}
+        };
       }
-    }
-    switch (ev.type) {
-      case "message_start":
-        current = "";
-        break;
-      case "message_delta":
-        current += ev.delta;
-        break;
-      case "message_end":
-        if (current.trim()) lastCompleted = current;
-        if (ev.usage) {
-          usage = usage ? {
-            promptTokens: usage.promptTokens + ev.usage.promptTokens,
-            completionTokens: usage.completionTokens + ev.usage.completionTokens,
-            totalTokens: usage.totalTokens + ev.usage.totalTokens,
-            ...(usage.cachedPromptTokens ?? 0) + (ev.usage.cachedPromptTokens ?? 0) > 0 ? {
-              cachedPromptTokens: (usage.cachedPromptTokens ?? 0) + (ev.usage.cachedPromptTokens ?? 0)
-            } : {}
-          } : ev.usage;
+      if (ev.type === "tool_execution_start") {
+        pendingTools.set(ev.toolCallId, { tool: ev.toolName, command: toolCommandHint(ev.args) });
+      } else if (ev.type === "tool_execution_end") {
+        const started = pendingTools.get(ev.toolCallId);
+        pendingTools.delete(ev.toolCallId);
+        toolTrace.push({
+          tool: started?.tool ?? "unknown",
+          callId: ev.toolCallId,
+          ok: !ev.isError,
+          ...started?.command ? { command: started.command } : {},
+          output: String(ev.result ?? "").slice(0, TOOL_TRACE_OUTPUT_MAX),
+          durationMs: ev.durationMs,
+          endedAt: Date.now()
+        });
+        if (toolTrace.length > TOOL_TRACE_RING) {
+          toolTrace.splice(0, toolTrace.length - TOOL_TRACE_RING);
         }
-        current = "";
-        break;
-      case "error":
-        error51 = ev.message;
-        break;
-      default:
-        break;
+      }
+      switch (ev.type) {
+        case "message_start":
+          current = "";
+          break;
+        case "message_delta":
+          current += ev.delta;
+          break;
+        case "message_end":
+          if (current.trim()) lastCompleted = current;
+          if (ev.usage) {
+            usage = usage ? {
+              promptTokens: usage.promptTokens + ev.usage.promptTokens,
+              completionTokens: usage.completionTokens + ev.usage.completionTokens,
+              totalTokens: usage.totalTokens + ev.usage.totalTokens,
+              ...(usage.cachedPromptTokens ?? 0) + (ev.usage.cachedPromptTokens ?? 0) > 0 ? {
+                cachedPromptTokens: (usage.cachedPromptTokens ?? 0) + (ev.usage.cachedPromptTokens ?? 0)
+              } : {}
+            } : ev.usage;
+          }
+          current = "";
+          break;
+        case "error":
+          error51 = ev.message;
+          break;
+        default:
+          break;
+      }
     }
+    const result = (lastCompleted || current).trim();
+    return {
+      result,
+      ...error51 ? { error: error51 } : {},
+      ...usage ? { usage } : {},
+      ...toolTrace.length > 0 ? { toolTrace } : {}
+    };
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
   }
-  const result = (lastCompleted || current).trim();
-  return {
-    result,
-    ...error51 ? { error: error51 } : {},
-    ...usage ? { usage } : {},
-    ...toolTrace.length > 0 ? { toolTrace } : {}
-  };
 }
 async function runTentacle(opts) {
   const { deps, args, agent, thoroughness, parentCwd, sessionId: sessionId2 } = opts;
@@ -34429,7 +34781,7 @@ function createTaskTool(deps, policy = {}) {
     description: "Delegate a focused sub-task to an isolated sub-agent with its own context; returns only a concise conclusion (keeps parent context lean).\n- agent=explore (default): read-only research/search\n- agent=general: can edit files for one bounded unit of work\n- agent=verify: read + bash to run tests/checks\nProvide a fully self-contained `prompt` (sub-agent cannot see this conversation). Optional scope[] + acceptance[] contracts. After general, follow up with verify." + (restricted ? `
 RESTRICTED in this mode: only agent=${allowedAgents.join("|")} is allowed.` : ""),
     permissions: ["read", "network", "write", "execute"],
-    timeoutMs: 3e5,
+    timeoutMs: TASK_TOOL_TIMEOUT_MS,
     inputSchema: inputSchema2,
     execute: async (args, ctx) => {
       const agent = args.agent ?? "explore";
@@ -34532,7 +34884,7 @@ ${res.result}${res.footer}`,
     }
   };
 }
-var EXPLORE_PROMPT, GENERAL_PROMPT, VERIFY_PROMPT, TaskArgsSchema, TaskPurposeSchema, TaskArgsWithPurposeSchema, TOOL_TRACE_RING, TOOL_TRACE_OUTPUT_MAX;
+var TASK_TOOL_TIMEOUT_MS, EXPLORE_PROMPT, GENERAL_PROMPT, VERIFY_PROMPT, TaskArgsSchema, TaskPurposeSchema, TaskArgsWithPurposeSchema, TOOL_TRACE_RING, TOOL_TRACE_OUTPUT_MAX;
 var init_taskTool = __esm({
   "src/cli/tools/taskTool.ts"() {
     "use strict";
@@ -34544,6 +34896,7 @@ var init_taskTool = __esm({
     init_candidateRegistry();
     init_verifyReport();
     init_metrics3();
+    TASK_TOOL_TIMEOUT_MS = 9e5;
     EXPLORE_PROMPT = [
       "You are a focused EXPLORE tentacle of Kraken (parent super-agent).",
       "READ-ONLY tools only (read, list, grep, fetch). No edits, no shell.",
@@ -39077,7 +39430,7 @@ import path38 from "node:path";
 function trustStorePath() {
   return _overrideStorePath ?? path38.join(homedir8(), ".zelari-code", "trust.json");
 }
-function normalize3(p3) {
+function normalize4(p3) {
   const resolved = path38.resolve(p3);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
@@ -39114,14 +39467,14 @@ function isFolderTrusted(folderPath) {
   const env = envTrustedFolder();
   if (env === "all") return true;
   if (env === "none") return false;
-  if (env) return normalize3(env) === normalize3(folderPath);
-  const target = normalize3(folderPath);
-  return readStore3().folders.some((f) => normalize3(f.path) === target);
+  if (env) return normalize4(env) === normalize4(folderPath);
+  const target = normalize4(folderPath);
+  return readStore3().folders.some((f) => normalize4(f.path) === target);
 }
 function trustFolder(folderPath) {
   const store6 = readStore3();
   const normalized = path38.resolve(folderPath);
-  if (!store6.folders.some((f) => normalize3(f.path) === normalize3(normalized))) {
+  if (!store6.folders.some((f) => normalize4(f.path) === normalize4(normalized))) {
     store6.folders.push({ path: normalized, trustedAt: (/* @__PURE__ */ new Date()).toISOString() });
     writeStore3(store6);
   }
@@ -39129,9 +39482,9 @@ function trustFolder(folderPath) {
 }
 function untrustFolder(folderPath) {
   const store6 = readStore3();
-  const target = normalize3(folderPath);
+  const target = normalize4(folderPath);
   const before = store6.folders.length;
-  store6.folders = store6.folders.filter((f) => normalize3(f.path) !== target);
+  store6.folders = store6.folders.filter((f) => normalize4(f.path) !== target);
   if (store6.folders.length === before) return { ok: true, removed: false };
   writeStore3(store6);
   return { ok: true, removed: true };
@@ -47538,7 +47891,7 @@ var init_executor = __esm({
     DEFAULT_MAX_REVIEW_ROUNDS = 1;
     DEFAULT_GRAPH_TIMEOUT_MS = 0;
     DEFAULT_NODE_TIMEOUT_MS = 3e5;
-    DEFAULT_WRITER_NODE_TIMEOUT_MS = 9e5;
+    DEFAULT_WRITER_NODE_TIMEOUT_MS = TASK_TOOL_TIMEOUT_MS;
     DEFAULT_CANCEL_GRACE_MS = 3e4;
     MAX_UPSTREAM_CHARS_PER_DEP = 2800;
     MAX_UPSTREAM_CHARS_TOTAL = 8e3;
@@ -55543,11 +55896,11 @@ function criterionId(check2, index) {
   const slug = check2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
   return `check-${index + 1}-${slug || "criterion"}`;
 }
-function normalize4(text) {
+function normalize5(text) {
   return text.toLowerCase().replace(/\s+/g, " ").trim();
 }
 function matchResult(check2, byNormalized) {
-  const norm = normalize4(check2);
+  const norm = normalize5(check2);
   const direct = byNormalized.get(norm);
   if (direct) return direct;
   for (const key of byNormalized.keys()) {
@@ -55559,7 +55912,7 @@ function matchResult(check2, byNormalized) {
 }
 function krakenResultsToContract(requiredChecks, results, now = Date.now()) {
   const byNormalized = /* @__PURE__ */ new Map();
-  for (const r of results ?? []) byNormalized.set(normalize4(r.check), r);
+  for (const r of results ?? []) byNormalized.set(normalize5(r.check), r);
   const criteria = [];
   const verifications = [];
   requiredChecks.forEach((check2, i) => {
@@ -55595,16 +55948,16 @@ function sha256Hex2(input) {
   return createHash10("sha256").update(input).digest("hex");
 }
 function matchNoteToToolTrace(note, trace) {
-  const n = normalize4(note);
+  const n = normalize5(note);
   if (!n) return null;
   for (let i = trace.length - 1; i >= 0; i--) {
     const t = trace[i];
-    const cmd = t.command ? normalize4(t.command) : "";
+    const cmd = t.command ? normalize5(t.command) : "";
     if (cmd.length >= 4 && (n.includes(cmd) || cmd.includes(n))) return t;
   }
   for (let i = trace.length - 1; i >= 0; i--) {
     const t = trace[i];
-    const out = normalize4(t.output);
+    const out = normalize5(t.output);
     if (!out) continue;
     if (n.length >= 8 && out.includes(n)) return t;
     const fragments = n.match(/\S*\d[\d.,/%]*\S*/g) ?? [];