zelari-code 2.9.2 → 2.11.0

package/dist/cli/main.bundled.js

@@ -276,8 +276,8 @@ function formatDuration(ms) {
   const rs = s % 60;
   if (m < 60) return rs === 0 ? `${m}m${sign}` : `${m}m ${rs}s${sign}`;
   const h = Math.floor(m / 60);
-  const rm = m % 60;
-  if (h < 24) return rm === 0 ? `${h}h${sign}` : `${h}h ${rm}m${sign}`;
+  const rm2 = m % 60;
+  if (h < 24) return rm2 === 0 ? `${h}h${sign}` : `${h}h ${rm2}m${sign}`;
   const d = Math.floor(h / 24);
   const rh = h % 24;
   return rh === 0 ? `${d}d${sign}` : `${d}d ${rh}h${sign}`;
@@ -1627,12 +1627,12 @@ var init_keyStore = __esm({
 
 // src/cli/thinkingCapability.ts
 function thinkingCapabilityFor(id3, model) {
-  const base = PROVIDER_THINKING_CAPABILITY[id3] ?? {};
+  const base2 = PROVIDER_THINKING_CAPABILITY[id3] ?? {};
   const efforts = effortLevelsFor(id3, model);
   const budget = supportsBudget(id3, model);
   return {
-    ...base,
-    effort: efforts.length > 0 || Boolean(base.effort),
+    ...base2,
+    effort: efforts.length > 0 || Boolean(base2.effort),
     budget,
     efforts: efforts.length > 0 ? efforts : void 0
   };
@@ -18536,8 +18536,8 @@ var init_shellResolver = __esm({
 // packages/core/dist/core/tools/builtin/shell.js
 import { spawn } from "node:child_process";
 import { dirname } from "node:path";
-function withNodeDirOnPath(base) {
-  const env = { ...base };
+function withNodeDirOnPath(base2) {
+  const env = { ...base2 };
   try {
     const nodeDir = dirname(process.execPath);
     if (!nodeDir)
@@ -18840,8 +18840,8 @@ async function searchFile(absPath, relPath, regex, contextLines, remainingSlots)
 }
 async function isDirectory(p3) {
   try {
-    const stat = await fs6.stat(p3);
-    return stat.isDirectory();
+    const stat2 = await fs6.stat(p3);
+    return stat2.isDirectory();
   } catch {
     return false;
   }
@@ -21207,8 +21207,8 @@ function formatTodoStatusSummary(list = todos) {
     (t) => t.status === "completed" || t.status === "cancelled"
   ).length;
   const active = list.filter((t) => t.status === "in_progress").length;
-  const base = `todos ${done}/${list.length}`;
-  return active > 0 ? `${base} \xB7 ${active} active` : base;
+  const base2 = `todos ${done}/${list.length}`;
+  return active > 0 ? `${base2} \xB7 ${active} active` : base2;
 }
 var todos;
 var init_sessionTodos = __esm({
@@ -21622,11 +21622,11 @@ function createRoutedRequestSnapshot(params) {
   };
 }
 function compareReplayPrefix(snapshot, messages) {
-  const base = snapshot.conversation;
-  const n = Math.min(base.length, messages.length);
+  const base2 = snapshot.conversation;
+  const n = Math.min(base2.length, messages.length);
   let matching = 0;
   for (let i = 0; i < n; i++) {
-    if (stableStringify(base[i]) !== stableStringify(messages[i])) {
+    if (stableStringify(base2[i]) !== stableStringify(messages[i])) {
       return { exact: false, matchingMessages: matching, mismatchIndex: i };
     }
     matching++;
@@ -21835,6 +21835,1156 @@ var init_textLoopDetect = __esm({
   }
 });
 
+// packages/core/dist/runtime/observers/types.js
+var CONTINUE;
+var init_types2 = __esm({
+  "packages/core/dist/runtime/observers/types.js"() {
+    "use strict";
+    CONTINUE = { action: "continue" };
+  }
+});
+
+// packages/core/dist/runtime/observers/resolve.js
+function resolveInterventions(results) {
+  if (results.length === 0)
+    return CONTINUE;
+  let best = results[0];
+  let bestRank = ACTION_RANK[best.action];
+  for (let i = 1; i < results.length; i += 1) {
+    const rank = ACTION_RANK[results[i].action];
+    if (rank > bestRank) {
+      best = results[i];
+      bestRank = rank;
+    }
+  }
+  return best;
+}
+var ACTION_RANK;
+var init_resolve = __esm({
+  "packages/core/dist/runtime/observers/resolve.js"() {
+    "use strict";
+    init_types2();
+    ACTION_RANK = {
+      deny_tool: 6,
+      stop: 5,
+      retry: 4,
+      replace: 3,
+      inject: 2,
+      continue: 1
+    };
+  }
+});
+
+// packages/core/dist/runtime/guards/RepetitionGuard.js
+import { createHash as createHash3 } from "node:crypto";
+function toolCallFingerprint(tool, args) {
+  const argsHash = createHash3("sha256").update(stableStringify(args ?? null)).digest("hex");
+  return { tool, argsHash };
+}
+var REASSESS_MESSAGE, RepetitionGuard;
+var init_RepetitionGuard = __esm({
+  "packages/core/dist/runtime/guards/RepetitionGuard.js"() {
+    "use strict";
+    init_requestSnapshot();
+    init_types2();
+    REASSESS_MESSAGE = [
+      "The same tool call has produced no new progress multiple times.",
+      "Reassess the current hypothesis before repeating it again."
+    ].join("\n");
+    RepetitionGuard = class {
+      counts = /* @__PURE__ */ new Map();
+      warnAfter;
+      stopAfter;
+      constructor(config2 = {}) {
+        this.warnAfter = config2.warnAfter ?? 2;
+        this.stopAfter = config2.stopAfter ?? 5;
+      }
+      async onToolCall(event) {
+        const fingerprint = toolCallFingerprint(event.toolName, event.args);
+        const key = `${fingerprint.tool}\0${fingerprint.argsHash}`;
+        const count = (this.counts.get(key) ?? 0) + 1;
+        this.counts.set(key, count);
+        if (count >= this.stopAfter) {
+          return {
+            action: "stop",
+            reason: `repeated tool call "${fingerprint.tool}" ${count} times without new progress`,
+            code: "repeated_tool"
+          };
+        }
+        if (count >= this.warnAfter) {
+          return {
+            action: "inject",
+            message: { role: "user", kind: "runtime-warning", content: REASSESS_MESSAGE }
+          };
+        }
+        return CONTINUE;
+      }
+      reset() {
+        this.counts.clear();
+      }
+    };
+  }
+});
+
+// packages/core/dist/runtime/guards/FailureSignatureGuard.js
+import { createHash as createHash4 } from "node:crypto";
+function stripAnsi(text) {
+  return text.replace(/\u001b\[[0-9;]*[A-Za-z]/g, "");
+}
+function normalizeFailureTail(text, tailChars = 2e3) {
+  const tail2 = stripAnsi(text).slice(-tailChars);
+  const lines = tail2.split(/\r?\n/).map((line) => line.replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:?\d{2})?/g, "<ts>").replace(/\b\d{1,2}:\d{2}:\d{2}(\.\d+)?\b/g, "<time>").replace(/\b\d+(\.\d+)?\s*(ms|s|sec|secs|seconds|min|mins|minutes)\b/gi, "<dur>").replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "<uuid>").replace(/\b(?:pid|process)\s*[:=]?\s*\d+\b/gi, "<pid>").replace(/(?:\/tmp\/|\/var\/tmp\/|\b[A-Za-z]:\\Users\\[^\\]*\\AppData\\Local\\Temp\\)[^\s"']*/gi, "<tmp>"));
+  const meaningful = lines.filter((line) => {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return false;
+    if (/^\s*[✓✔●○◐◑◌]/.test(line))
+      return false;
+    if (/^\s*[|/\\-–—]\s*$/.test(line))
+      return false;
+    if (/^\s*\d+\s*\/\s*\d+\s*$/.test(line))
+      return false;
+    return true;
+  });
+  return meaningful.join("\n");
+}
+function extractFailure(result) {
+  if (typeof result === "string")
+    return { text: result };
+  if (result && typeof result === "object") {
+    const r = result;
+    const parts = [r.stdout, r.stderr, r.output, r.content, r.message].filter((p3) => typeof p3 === "string");
+    if (typeof r.exitCode === "number" || parts.length > 0) {
+      return { exitCode: r.exitCode, text: parts.join("\n") };
+    }
+    return { text: stableStringify(result).slice(0, 4e3) };
+  }
+  return void 0;
+}
+var REASSESS_MESSAGE2, MAX_PENDING, FailureSignatureGuard;
+var init_FailureSignatureGuard = __esm({
+  "packages/core/dist/runtime/guards/FailureSignatureGuard.js"() {
+    "use strict";
+    init_requestSnapshot();
+    init_types2();
+    init_RepetitionGuard();
+    REASSESS_MESSAGE2 = [
+      "The same failure signature has persisted across multiple attempts.",
+      "Do not repeat the previous edit strategy. Re-evaluate the root cause,",
+      "inspect upstream state, or delegate a fresh verification/exploration task."
+    ].join("\n");
+    MAX_PENDING = 256;
+    FailureSignatureGuard = class {
+      counts = /* @__PURE__ */ new Map();
+      pendingArgs = /* @__PURE__ */ new Map();
+      warnAfter;
+      stopAfter;
+      tailChars;
+      constructor(config2 = {}) {
+        this.warnAfter = config2.warnAfter ?? 2;
+        this.stopAfter = config2.stopAfter ?? 5;
+        this.tailChars = config2.tailChars ?? 2e3;
+      }
+      /** Track per-call command hashes so onToolResult can bind args → result. */
+      async onToolCall(event) {
+        const { argsHash } = toolCallFingerprint(event.toolName, event.args);
+        if (this.pendingArgs.size >= MAX_PENDING) {
+          const oldest = this.pendingArgs.keys().next().value;
+          if (oldest !== void 0)
+            this.pendingArgs.delete(oldest);
+        }
+        this.pendingArgs.set(event.toolCallId, `${event.toolName}\0${argsHash}`);
+        return CONTINUE;
+      }
+      async onToolResult(event) {
+        const commandHash = this.pendingArgs.get(event.toolCallId) ?? event.toolName;
+        this.pendingArgs.delete(event.toolCallId);
+        const failure = extractFailure(event.result);
+        if (!failure || !failure.text.trim())
+          return CONTINUE;
+        const failed = failure.exitCode !== void 0 ? failure.exitCode !== 0 : event.ok === false;
+        if (!failed) {
+          for (const key2 of this.counts.keys()) {
+            if (key2.startsWith(`${commandHash}\0`))
+              this.counts.delete(key2);
+          }
+          return CONTINUE;
+        }
+        const tailHash = createHash4("sha256").update(normalizeFailureTail(failure.text, this.tailChars)).digest("hex");
+        const key = `${commandHash}\0${failure.exitCode ?? "x"}\0${tailHash}`;
+        const count = (this.counts.get(key) ?? 0) + 1;
+        this.counts.set(key, count);
+        if (count >= this.stopAfter) {
+          return {
+            action: "stop",
+            reason: `same failure signature (exit ${failure.exitCode ?? "n/a"}) recurred ${count} times after edits`,
+            code: "repeated_failure"
+          };
+        }
+        if (count >= this.warnAfter) {
+          return {
+            action: "inject",
+            message: { role: "user", kind: "runtime-warning", content: REASSESS_MESSAGE2 }
+          };
+        }
+        return CONTINUE;
+      }
+      reset() {
+        this.counts.clear();
+        this.pendingArgs.clear();
+      }
+    };
+  }
+});
+
+// packages/core/dist/runtime/guards/DuplicateSearchGuard.js
+function isSearchTool(tool) {
+  return SEARCH_TOOLS.has(tool);
+}
+function normalizeQuery(text) {
+  return text.toLowerCase().replace(/[.,;:!?()"'`—–…]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 512);
+}
+function queryJaccard(a, b) {
+  const ta = new Set(a.split(" ").filter(Boolean));
+  const tb = new Set(b.split(" ").filter(Boolean));
+  if (ta.size === 0 && tb.size === 0)
+    return 1;
+  if (ta.size === 0 || tb.size === 0)
+    return 0;
+  let intersection2 = 0;
+  for (const token of ta)
+    if (tb.has(token))
+      intersection2++;
+  const union2 = ta.size + tb.size - intersection2;
+  return union2 === 0 ? 0 : intersection2 / union2;
+}
+function extractSearchQuery(toolName, args) {
+  if (!isSearchTool(toolName))
+    return void 0;
+  const a = args ?? {};
+  switch (toolName) {
+    case "grep_content": {
+      if (typeof a.pattern !== "string" || a.pattern.trim() === "")
+        return void 0;
+      const include = Array.isArray(a.include) ? a.include.join(",") : typeof a.include === "string" ? a.include : "";
+      return {
+        scope: [
+          typeof a.path === "string" ? a.path : "",
+          include
+        ].join("\0"),
+        query: normalizeQuery(a.pattern)
+      };
+    }
+    case "semantic_search":
+    case "web_search": {
+      if (typeof a.query !== "string" || a.query.trim() === "")
+        return void 0;
+      return { scope: "", query: normalizeQuery(a.query) };
+    }
+    case "list_files": {
+      if (typeof a.path !== "string" || a.path.trim() === "")
+        return void 0;
+      return { scope: String(a.maxDepth ?? ""), query: normalizeQuery(a.path) };
+    }
+    default:
+      return void 0;
+  }
+}
+var SEARCH_TOOLS, REFINE_MESSAGE, DuplicateSearchGuard;
+var init_DuplicateSearchGuard = __esm({
+  "packages/core/dist/runtime/guards/DuplicateSearchGuard.js"() {
+    "use strict";
+    init_types2();
+    SEARCH_TOOLS = /* @__PURE__ */ new Set([
+      "grep_content",
+      "semantic_search",
+      "web_search",
+      "list_files"
+    ]);
+    REFINE_MESSAGE = [
+      "Search queries are being repeated with only cosmetic differences in the same scope.",
+      "Reuse the results already in context, or change the query/scope meaningfully."
+    ].join("\n");
+    DuplicateSearchGuard = class {
+      buckets = /* @__PURE__ */ new Map();
+      warnAfter;
+      stopAfter;
+      similarityThreshold;
+      window;
+      maxBuckets;
+      constructor(config2 = {}) {
+        this.warnAfter = config2.warnAfter ?? 2;
+        this.stopAfter = config2.stopAfter ?? 5;
+        this.similarityThreshold = config2.similarityThreshold ?? 0.8;
+        this.window = config2.window ?? 8;
+        this.maxBuckets = config2.maxBuckets ?? 256;
+      }
+      async onToolCall(event) {
+        const ref = extractSearchQuery(event.toolName, event.args);
+        if (!ref)
+          return CONTINUE;
+        const key = `${event.toolName}\0${ref.scope}`;
+        let bucket = this.buckets.get(key);
+        if (!bucket) {
+          bucket = { recent: [], duplicateCount: 0 };
+          this.buckets.set(key, bucket);
+          this.evictIfNeeded();
+        }
+        let best = 0;
+        for (const previous of bucket.recent) {
+          best = Math.max(best, queryJaccard(previous, ref.query));
+        }
+        bucket.duplicateCount = best >= this.similarityThreshold ? bucket.duplicateCount + 1 : 1;
+        bucket.recent.push(ref.query);
+        if (bucket.recent.length > this.window)
+          bucket.recent.shift();
+        if (bucket.duplicateCount >= this.stopAfter) {
+          return {
+            action: "stop",
+            reason: `near-duplicate search queries for "${event.toolName}" ${bucket.duplicateCount} times in the same scope`,
+            code: "duplicate_search"
+          };
+        }
+        if (bucket.duplicateCount >= this.warnAfter) {
+          return {
+            action: "inject",
+            message: { role: "user", kind: "runtime-warning", content: REFINE_MESSAGE }
+          };
+        }
+        return CONTINUE;
+      }
+      reset() {
+        this.buckets.clear();
+      }
+      evictIfNeeded() {
+        while (this.buckets.size > this.maxBuckets) {
+          const oldest = this.buckets.keys().next().value;
+          if (oldest === void 0)
+            break;
+          this.buckets.delete(oldest);
+        }
+      }
+    };
+  }
+});
+
+// packages/core/dist/runtime/guards/NoProgressGuard.js
+var FILE_WRITING_TOOLS, REASSESS_MESSAGE3, NoProgressGuard;
+var init_NoProgressGuard = __esm({
+  "packages/core/dist/runtime/guards/NoProgressGuard.js"() {
+    "use strict";
+    init_types2();
+    init_RepetitionGuard();
+    FILE_WRITING_TOOLS = /* @__PURE__ */ new Set([
+      "write_file",
+      "edit_file",
+      "apply_diff"
+    ]);
+    REASSESS_MESSAGE3 = [
+      "The run has made no measurable progress for several turns.",
+      "Change strategy: inspect different files, delegate exploration, or revise the hypothesis."
+    ].join("\n");
+    NoProgressGuard = class {
+      seenFingerprints = /* @__PURE__ */ new Set();
+      soft;
+      hard;
+      stallTurns = 0;
+      turnToolCalls = 0;
+      turnWrites = 0;
+      turnNewFingerprints = 0;
+      constructor(config2 = {}) {
+        this.soft = config2.softStallTurns ?? 2;
+        this.hard = config2.hardStallTurns ?? 5;
+      }
+      async onToolCall(event) {
+        this.turnToolCalls += 1;
+        if (FILE_WRITING_TOOLS.has(event.toolName))
+          this.turnWrites += 1;
+        const fingerprint = toolCallFingerprint(event.toolName, event.args);
+        const key = `${fingerprint.tool}\0${fingerprint.argsHash}`;
+        if (!this.seenFingerprints.has(key)) {
+          this.seenFingerprints.add(key);
+          this.turnNewFingerprints += 1;
+        }
+        return CONTINUE;
+      }
+      async onTurnEnd(_event) {
+        if (this.turnToolCalls === 0) {
+          return CONTINUE;
+        }
+        const productive = this.turnWrites > 0 || this.turnNewFingerprints > 0;
+        this.stallTurns = productive ? 0 : this.stallTurns + 1;
+        this.turnToolCalls = 0;
+        this.turnWrites = 0;
+        this.turnNewFingerprints = 0;
+        if (this.stallTurns >= this.hard) {
+          return {
+            action: "stop",
+            reason: `no measurable progress for ${this.stallTurns} consecutive turns`,
+            code: "no_progress"
+          };
+        }
+        if (this.stallTurns >= this.soft) {
+          return {
+            action: "inject",
+            message: { role: "user", kind: "runtime-warning", content: REASSESS_MESSAGE3 }
+          };
+        }
+        return CONTINUE;
+      }
+      reset() {
+        this.seenFingerprints.clear();
+        this.stallTurns = 0;
+        this.turnToolCalls = 0;
+        this.turnWrites = 0;
+        this.turnNewFingerprints = 0;
+      }
+    };
+  }
+});
+
+// packages/core/dist/runtime/guards/ReasoningWatchdog.js
+function envPositiveInt(name, fallback) {
+  const raw = process.env[name]?.trim();
+  if (!raw)
+    return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+var DEFAULT_FIRST_TOKEN_WARN_MS, DEFAULT_STREAM_IDLE_WARN_MS, MAX_COMPLETED, ReasoningWatchdog;
+var init_ReasoningWatchdog = __esm({
+  "packages/core/dist/runtime/guards/ReasoningWatchdog.js"() {
+    "use strict";
+    init_types2();
+    DEFAULT_FIRST_TOKEN_WARN_MS = 6e4;
+    DEFAULT_STREAM_IDLE_WARN_MS = 3e4;
+    MAX_COMPLETED = 100;
+    ReasoningWatchdog = class {
+      firstTokenWarnMs;
+      streamIdleWarnMs;
+      now;
+      current = null;
+      lastDeltaAt;
+      completed = [];
+      warnings = [];
+      constructor(config2 = {}, now = Date.now) {
+        this.firstTokenWarnMs = config2.firstTokenWarnMs ?? envPositiveInt("ZELARI_MODEL_FIRST_TOKEN_WARN_MS", DEFAULT_FIRST_TOKEN_WARN_MS);
+        this.streamIdleWarnMs = config2.streamIdleWarnMs ?? envPositiveInt("ZELARI_MODEL_STREAM_IDLE_WARN_MS", DEFAULT_STREAM_IDLE_WARN_MS);
+        this.now = now;
+      }
+      async onModelAttempt(event) {
+        this.finalizeCurrent();
+        this.current = {
+          attemptId: event.id,
+          startedAt: this.now(),
+          deltas: 0,
+          warnedFirstToken: false,
+          warnedIdle: false
+        };
+        this.lastDeltaAt = void 0;
+        return CONTINUE;
+      }
+      async onModelDelta(event) {
+        const attempt = this.current;
+        if (!attempt)
+          return CONTINUE;
+        const at = this.now();
+        attempt.deltas += 1;
+        if (attempt.firstTokenAt === void 0) {
+          attempt.firstTokenAt = at;
+          const ttft = at - attempt.startedAt;
+          attempt.timeToFirstTokenMs = ttft;
+          if (!attempt.warnedFirstToken && ttft > this.firstTokenWarnMs) {
+            attempt.warnedFirstToken = true;
+            this.warn("time_to_first_token", attempt, ttft, this.firstTokenWarnMs);
+          }
+        } else {
+          const gap = at - (this.lastDeltaAt ?? attempt.firstTokenAt);
+          if (gap > (attempt.maxStreamIdleMs ?? 0))
+            attempt.maxStreamIdleMs = gap;
+          if (!attempt.warnedIdle && gap > this.streamIdleWarnMs) {
+            attempt.warnedIdle = true;
+            this.warn("stream_idle", attempt, gap, this.streamIdleWarnMs);
+          }
+        }
+        this.lastDeltaAt = at;
+        return CONTINUE;
+      }
+      async onModelResponse(_event) {
+        this.finalizeCurrent();
+        return CONTINUE;
+      }
+      async onRunEnd(_event) {
+        this.finalizeCurrent();
+        return CONTINUE;
+      }
+      async onCancelled(_event) {
+        this.finalizeCurrent();
+        return CONTINUE;
+      }
+      /** Completed attempt metrics, oldest first (bounded). */
+      getAttemptMetrics() {
+        return this.completed.map((attempt) => ({ ...attempt }));
+      }
+      getWarnings() {
+        return this.warnings.map((warning) => ({ ...warning }));
+      }
+      reset() {
+        this.current = null;
+        this.lastDeltaAt = void 0;
+        this.completed.length = 0;
+        this.warnings.length = 0;
+      }
+      finalizeCurrent() {
+        const attempt = this.current;
+        if (!attempt)
+          return;
+        attempt.endedAt = this.now();
+        if (attempt.firstTokenAt !== void 0) {
+          attempt.generationDurationMs = attempt.endedAt - attempt.startedAt;
+        }
+        this.completed.push({ ...attempt });
+        if (this.completed.length > MAX_COMPLETED)
+          this.completed.shift();
+        this.current = null;
+        this.lastDeltaAt = void 0;
+      }
+      warn(metric, attempt, valueMs, thresholdMs) {
+        this.warnings.push({
+          code: "provider_idle",
+          metric,
+          attemptId: attempt.attemptId,
+          valueMs,
+          thresholdMs,
+          message: metric === "time_to_first_token" ? `Provider first token took ${valueMs}ms (threshold ${thresholdMs}ms).` : `Provider stream idle for ${valueMs}ms between deltas (threshold ${thresholdMs}ms).`,
+          ts: this.now()
+        });
+      }
+    };
+  }
+});
+
+// packages/core/dist/runtime/observers/TraceObserver.js
+var DEFAULT_CAPACITY, TraceObserver;
+var init_TraceObserver = __esm({
+  "packages/core/dist/runtime/observers/TraceObserver.js"() {
+    "use strict";
+    init_types2();
+    DEFAULT_CAPACITY = 500;
+    TraceObserver = class {
+      entries = [];
+      sink;
+      capacity;
+      constructor(options = {}) {
+        this.sink = options.sink;
+        this.capacity = Math.max(1, options.capacity ?? DEFAULT_CAPACITY);
+      }
+      async onRunStart(event) {
+        return this.record("onRunStart", event);
+      }
+      async onModelAttempt(event) {
+        return this.record("onModelAttempt", event);
+      }
+      async onModelDelta(event) {
+        return this.record("onModelDelta", event);
+      }
+      async onModelResponse(event) {
+        return this.record("onModelResponse", event);
+      }
+      async onToolCall(event) {
+        return this.record("onToolCall", event);
+      }
+      async onToolResult(event) {
+        return this.record("onToolResult", event);
+      }
+      async onTurnEnd(event) {
+        return this.record("onTurnEnd", event);
+      }
+      async onRunEnd(event) {
+        return this.record("onRunEnd", event);
+      }
+      async onCancelled(event) {
+        return this.record("onCancelled", event);
+      }
+      /** Recorded entries, oldest first. */
+      getEntries() {
+        return [...this.entries];
+      }
+      get size() {
+        return this.entries.length;
+      }
+      clear() {
+        this.entries.length = 0;
+      }
+      record(hook, event) {
+        const entry = {
+          hook,
+          eventId: event.id,
+          ts: event.ts,
+          agentId: event.identity.agentId,
+          role: event.identity.role,
+          turn: event.turn
+        };
+        this.entries.push(entry);
+        if (this.entries.length > this.capacity)
+          this.entries.shift();
+        try {
+          this.sink?.(entry);
+        } catch {
+        }
+        return CONTINUE;
+      }
+    };
+  }
+});
+
+// packages/core/dist/runtime/observers/MetricsObserver.js
+var MetricsObserver;
+var init_MetricsObserver = __esm({
+  "packages/core/dist/runtime/observers/MetricsObserver.js"() {
+    "use strict";
+    init_types2();
+    MetricsObserver = class {
+      runsStarted = 0;
+      modelAttempts = 0;
+      modelDeltas = 0;
+      modelResponses = 0;
+      toolCalls = 0;
+      toolResults = 0;
+      toolFailures = 0;
+      turnsEnded = 0;
+      runsEnded = 0;
+      cancelled = 0;
+      firstEventTs;
+      lastEventTs;
+      async onRunStart(event) {
+        this.tick(event.ts);
+        this.runsStarted += 1;
+        return CONTINUE;
+      }
+      async onModelAttempt(event) {
+        this.tick(event.ts);
+        this.modelAttempts += 1;
+        return CONTINUE;
+      }
+      async onModelDelta(event) {
+        this.tick(event.ts);
+        this.modelDeltas += 1;
+        return CONTINUE;
+      }
+      async onModelResponse(event) {
+        this.tick(event.ts);
+        this.modelResponses += 1;
+        return CONTINUE;
+      }
+      async onToolCall(event) {
+        this.tick(event.ts);
+        this.toolCalls += 1;
+        return CONTINUE;
+      }
+      async onToolResult(event) {
+        this.tick(event.ts);
+        this.toolResults += 1;
+        if (!event.ok)
+          this.toolFailures += 1;
+        return CONTINUE;
+      }
+      async onTurnEnd(event) {
+        this.tick(event.ts);
+        this.turnsEnded += 1;
+        return CONTINUE;
+      }
+      async onRunEnd(event) {
+        this.tick(event.ts);
+        this.runsEnded += 1;
+        return CONTINUE;
+      }
+      async onCancelled(event) {
+        this.tick(event.ts);
+        this.cancelled += 1;
+        return CONTINUE;
+      }
+      snapshot() {
+        return {
+          runsStarted: this.runsStarted,
+          modelAttempts: this.modelAttempts,
+          modelDeltas: this.modelDeltas,
+          modelResponses: this.modelResponses,
+          toolCalls: this.toolCalls,
+          toolResults: this.toolResults,
+          toolFailures: this.toolFailures,
+          turnsEnded: this.turnsEnded,
+          runsEnded: this.runsEnded,
+          cancelled: this.cancelled,
+          firstEventTs: this.firstEventTs,
+          lastEventTs: this.lastEventTs
+        };
+      }
+      reset() {
+        this.runsStarted = 0;
+        this.modelAttempts = 0;
+        this.modelDeltas = 0;
+        this.modelResponses = 0;
+        this.toolCalls = 0;
+        this.toolResults = 0;
+        this.toolFailures = 0;
+        this.turnsEnded = 0;
+        this.runsEnded = 0;
+        this.cancelled = 0;
+        this.firstEventTs = void 0;
+        this.lastEventTs = void 0;
+      }
+      tick(ts) {
+        if (this.firstEventTs === void 0 || ts < this.firstEventTs) {
+          this.firstEventTs = ts;
+        }
+        if (this.lastEventTs === void 0 || ts > this.lastEventTs) {
+          this.lastEventTs = ts;
+        }
+      }
+    };
+  }
+});
+
+// packages/core/dist/runtime/recorder/Redactor.js
+function redactString(input) {
+  let out = input;
+  for (const { re, replacement } of VALUE_PATTERNS) {
+    out = out.replace(re, replacement);
+  }
+  return out;
+}
+function redactRuntimePayload(value) {
+  if (value === null || value === void 0)
+    return value;
+  if (typeof value === "string")
+    return redactString(value);
+  if (typeof value === "number" || typeof value === "boolean")
+    return value;
+  if (Array.isArray(value))
+    return value.map((item) => redactRuntimePayload(item));
+  if (typeof value === "object") {
+    const out = {};
+    for (const [key, val] of Object.entries(value)) {
+      out[key] = SECRET_KEY_RE.test(key) ? REDACTED : redactRuntimePayload(val);
+    }
+    return out;
+  }
+  return REDACTED;
+}
+var REDACTED, SECRET_KEY_RE, VALUE_PATTERNS;
+var init_Redactor = __esm({
+  "packages/core/dist/runtime/recorder/Redactor.js"() {
+    "use strict";
+    REDACTED = "[REDACTED]";
+    SECRET_KEY_RE = /(pass(word|wd)?|secret|token|api[-_]?key|auth(orization)?|credential|private[-_]?key|access[-_]?key)/i;
+    VALUE_PATTERNS = [
+      // "Authorization: <credential>" (with optional bearer/Basic scheme prefix) — whole value.
+      // Value class excludes [ ] so the [REDACTED] marker can never be re-matched.
+      {
+        re: /\b(authorization\s*[:=]\s*)(?:bearer|basic|token)\s+[^\s,;"'}\]\[]+/gi,
+        replacement: "$1[REDACTED]"
+      },
+      {
+        re: /\b(authorization\s*[:=]\s*)[^\s,;"'}\]\[]+/gi,
+        replacement: "$1[REDACTED]"
+      },
+      // Bare bearer schemes anywhere ("bearer <token>", any casing)
+      { re: /\bbearer\s+[A-Za-z0-9\-._~+/]+=*/gi, replacement: "bearer [REDACTED]" },
+      // OpenAI-style keys (sk-, sk-proj-)
+      { re: /\bsk-(proj-)?[A-Za-z0-9_-]{8,}\b/g, replacement: "sk-[REDACTED]" },
+      // GitHub tokens
+      {
+        re: /\b(ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}\b/g,
+        replacement: "[REDACTED]"
+      },
+      { re: /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g, replacement: "[REDACTED]" },
+      // Slack
+      { re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, replacement: "[REDACTED]" },
+      // AWS access keys
+      { re: /\bAKIA[0-9A-Z]{16}\b/g, replacement: "[REDACTED]" },
+      // Google OAuth
+      { re: /\bya29\.[A-Za-z0-9\-_.]+/g, replacement: "[REDACTED]" },
+      // Secret-looking assignments, UPPER_SNAKE or lower: FOO_PASSWORD=x, password: x
+      {
+        re: /\b([A-Za-z0-9_]*(?:password|passwd|secret|token|api[_-]?key|apikey|access[_-]?key|private[_-]?key)[A-Za-z0-9_]*)\s*[:=]\s*("[^"]*"|'[^']*'|[^\s,;}&\]]+)/gi,
+        replacement: "$1=[REDACTED]"
+      }
+    ];
+  }
+});
+
+// packages/core/dist/runtime/recorder/RunRecorder.js
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { randomBytes as randomBytes2 } from "node:crypto";
+function newRunId(now = Date.now) {
+  return `run_${now().toString(36)}_${randomBytes2(4).toString("hex")}`;
+}
+function runRecordEnabled() {
+  const raw = process.env.ZELARI_RUN_RECORD?.trim().toLowerCase();
+  return raw === "1" || raw === "true" || raw === "on";
+}
+function sanitizeAgentId(agentId) {
+  const safe = agentId.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 64);
+  return safe.length > 0 ? safe : "agent";
+}
+var RunRecorder;
+var init_RunRecorder = __esm({
+  "packages/core/dist/runtime/recorder/RunRecorder.js"() {
+    "use strict";
+    init_Redactor();
+    RunRecorder = class {
+      runId;
+      runDir;
+      opts;
+      now;
+      chain = Promise.resolve();
+      startedAt = 0;
+      started = false;
+      finalized = false;
+      models;
+      counters = { modelCalls: 0, toolCalls: 0, toolFailures: 0, turns: 0 };
+      constructor(options) {
+        this.opts = options;
+        this.now = options.now ?? Date.now;
+        this.runId = options.runId ?? newRunId(this.now);
+        this.runDir = join(options.runsDir, this.runId);
+        this.models = { ...options.models ?? {} };
+      }
+      /** Create the run dir and write the initial manifest. Idempotent. */
+      start() {
+        if (this.started)
+          return;
+        this.started = true;
+        this.startedAt = this.now();
+        this.enqueue(async () => {
+          await mkdir(this.runDir, { recursive: true });
+          await mkdir(join(this.runDir, "agents"), { recursive: true });
+          await writeFile(join(this.runDir, "manifest.json"), JSON.stringify(this.buildManifest("running"), null, 2));
+        });
+      }
+      /** Append one redacted event to trace.jsonl. */
+      record(event) {
+        if (!this.started)
+          this.start();
+        this.enqueue(() => appendFile(join(this.runDir, "trace.jsonl"), `${JSON.stringify(redactRuntimePayload(event))}
+`));
+      }
+      /** Append one redacted event to the per-agent stream. */
+      recordAgent(agentId, event) {
+        if (!this.started)
+          this.start();
+        this.enqueue(() => appendFile(join(this.runDir, "agents", `${sanitizeAgentId(agentId)}.jsonl`), `${JSON.stringify(redactRuntimePayload(event))}
+`));
+      }
+      /** Track which model served which role, for the final manifest. */
+      noteModel(role, model) {
+        if (role && model)
+          this.models[role] = model;
+      }
+      bumpModelCall() {
+        this.counters.modelCalls += 1;
+      }
+      bumpToolCall() {
+        this.counters.toolCalls += 1;
+      }
+      bumpToolFailure() {
+        this.counters.toolFailures += 1;
+      }
+      bumpTurn() {
+        this.counters.turns += 1;
+      }
+      getMetrics() {
+        return {
+          durationMs: this.finalized || this.startedAt > 0 ? Math.max(0, this.now() - this.startedAt) : 0,
+          ...this.counters
+        };
+      }
+      /** Write final manifest + metrics.json. Idempotent. */
+      finalize(status) {
+        if (this.finalized)
+          return;
+        if (!this.started)
+          this.start();
+        this.finalized = true;
+        const endedAt = this.now();
+        this.enqueue(async () => {
+          await writeFile(join(this.runDir, "manifest.json"), JSON.stringify(this.buildManifest(status, endedAt), null, 2));
+          await writeFile(join(this.runDir, "metrics.json"), JSON.stringify(this.getMetrics(), null, 2));
+        });
+      }
+      /** Await pending writes (tests / graceful shutdown). */
+      async flush() {
+        await this.chain;
+      }
+      buildManifest(status, endedAt) {
+        return {
+          version: 1,
+          runId: this.runId,
+          sessionId: this.opts.sessionId,
+          mode: this.opts.mode ?? "kraken",
+          phase: this.opts.phase ?? "build",
+          startedAt: this.startedAt,
+          ...endedAt !== void 0 ? { endedAt } : {},
+          status,
+          cwd: this.opts.cwd ?? process.cwd(),
+          models: this.models
+        };
+      }
+      /**
+       * Serial best-effort write queue: preserves trace ordering and swallows
+       * IO errors (§102 — recorder failure must not block the run).
+       */
+      enqueue(write) {
+        this.chain = this.chain.then(write).catch(() => {
+        });
+      }
+    };
+  }
+});
+
+// packages/core/dist/runtime/recorder/recorderObserver.js
+function base(event) {
+  return {
+    id: event.id,
+    ts: event.ts,
+    turn: event.turn,
+    agentId: event.identity.agentId,
+    role: event.identity.role
+  };
+}
+function createRecorderObserver(recorder) {
+  return {
+    onRunStart(event) {
+      recorder.noteModel(event.identity.role, event.identity.model);
+      recorder.start();
+      recorder.record({ type: "run_start", ...base(event) });
+      return CONTINUE;
+    },
+    onModelAttempt(event) {
+      recorder.bumpModelCall();
+      recorder.record({ type: "model_attempt", ...base(event) });
+      return CONTINUE;
+    },
+    onModelResponse(event) {
+      recorder.record({ type: "model_response", ...base(event) });
+      return CONTINUE;
+    },
+    onToolCall(event) {
+      recorder.bumpToolCall();
+      recorder.record({ type: "tool_call", ...base(event), toolCallId: event.toolCallId, tool: event.toolName });
+      return CONTINUE;
+    },
+    onToolResult(event) {
+      if (!event.ok)
+        recorder.bumpToolFailure();
+      const line = { type: "tool_result", ...base(event), toolCallId: event.toolCallId, tool: event.toolName, ok: event.ok };
+      recorder.record(line);
+      recorder.recordAgent(event.identity.agentId, line);
+      return CONTINUE;
+    },
+    onTurnEnd(event) {
+      recorder.bumpTurn();
+      recorder.record({ type: "turn_end", ...base(event) });
+      return CONTINUE;
+    },
+    onRunEnd(event) {
+      recorder.record({ type: "run_end", ...base(event), reason: event.reason });
+      recorder.finalize(event.reason === "completed" ? "completed" : event.reason === "cancelled" ? "cancelled" : "failed");
+      return CONTINUE;
+    },
+    onCancelled(event) {
+      recorder.record({ type: "run_cancelled", ...base(event), reason: event.reason });
+      recorder.finalize("cancelled");
+      return CONTINUE;
+    }
+  };
+}
+var init_recorderObserver = __esm({
+  "packages/core/dist/runtime/recorder/recorderObserver.js"() {
+    "use strict";
+    init_types2();
+  }
+});
+
+// packages/core/dist/runtime/controls/SteeringObserver.js
+function renderSteers(steers) {
+  const lines = ["Runtime user steering received during execution:", ""];
+  steers.forEach((steer, index) => {
+    lines.push(`[${index + 1}]`);
+    lines.push(steer.text);
+    lines.push("");
+  });
+  lines.push("Later instructions may supersede earlier ones.");
+  return lines.join("\n");
+}
+var SteeringObserver;
+var init_SteeringObserver = __esm({
+  "packages/core/dist/runtime/controls/SteeringObserver.js"() {
+    "use strict";
+    init_types2();
+    SteeringObserver = class {
+      queue;
+      constructor(queue) {
+        this.queue = queue;
+      }
+      async onTurnEnd(_event) {
+        const steers = this.queue.drainSteers();
+        if (steers.length === 0) {
+          return CONTINUE;
+        }
+        return {
+          action: "inject",
+          message: {
+            role: "user",
+            kind: "runtime-steer",
+            content: renderSteers(steers)
+          }
+        };
+      }
+    };
+  }
+});
+
+// packages/core/dist/runtime/observers/ObserverBus.js
+import { join as join2 } from "node:path";
+function runtimeObserversEnabled() {
+  const raw = process.env.ZELARI_RUNTIME_OBSERVERS?.trim().toLowerCase();
+  return raw === "1" || raw === "true" || raw === "on";
+}
+function buildRuntimeObserverBus(options = {}) {
+  const steering = options.steeringQueue ? [
+    {
+      id: "steering-observer",
+      priority: 20,
+      failureMode: "warn",
+      observer: new SteeringObserver(options.steeringQueue)
+    }
+  ] : [];
+  if (!runtimeObserversEnabled()) {
+    return steering.length > 0 ? new ObserverBus(steering) : void 0;
+  }
+  const descriptors = [
+    ...steering,
+    {
+      id: "repetition-guard",
+      priority: 30,
+      failureMode: "warn",
+      observer: new RepetitionGuard()
+    },
+    {
+      id: "failure-signature-guard",
+      priority: 30,
+      failureMode: "warn",
+      observer: new FailureSignatureGuard()
+    },
+    {
+      id: "duplicate-search-guard",
+      priority: 30,
+      failureMode: "warn",
+      observer: new DuplicateSearchGuard()
+    },
+    {
+      id: "no-progress-guard",
+      priority: 30,
+      failureMode: "warn",
+      observer: new NoProgressGuard()
+    },
+    {
+      id: "reasoning-watchdog",
+      priority: 30,
+      failureMode: "warn",
+      observer: new ReasoningWatchdog()
+    },
+    {
+      id: "trace-observer",
+      priority: 80,
+      failureMode: "warn",
+      observer: new TraceObserver()
+    },
+    {
+      id: "metrics-observer",
+      priority: 90,
+      failureMode: "ignore",
+      observer: new MetricsObserver()
+    }
+  ];
+  if (runRecordEnabled()) {
+    const recorder = new RunRecorder({
+      runsDir: options.runsDir ?? join2(process.cwd(), ".zelari", "runs"),
+      runId: options.runId ?? newRunId()
+    });
+    descriptors.push({
+      id: "run-recorder",
+      priority: 85,
+      failureMode: "warn",
+      observer: createRecorderObserver(recorder)
+    });
+  }
+  return new ObserverBus(descriptors);
+}
+var ObserverBus;
+var init_ObserverBus = __esm({
+  "packages/core/dist/runtime/observers/ObserverBus.js"() {
+    "use strict";
+    init_types2();
+    init_resolve();
+    init_RepetitionGuard();
+    init_FailureSignatureGuard();
+    init_DuplicateSearchGuard();
+    init_NoProgressGuard();
+    init_ReasoningWatchdog();
+    init_TraceObserver();
+    init_MetricsObserver();
+    init_RunRecorder();
+    init_recorderObserver();
+    init_SteeringObserver();
+    ObserverBus = class {
+      descriptors;
+      logger;
+      constructor(descriptors = [], options = {}) {
+        this.descriptors = [...descriptors].sort((a, b) => a.priority - b.priority);
+        this.logger = options.logger ?? (() => {
+        });
+      }
+      get size() {
+        return this.descriptors.length;
+      }
+      async emit(hook, event) {
+        const results = [];
+        for (const descriptor of this.descriptors) {
+          const callback = descriptor.observer[hook];
+          if (typeof callback !== "function")
+            continue;
+          try {
+            const result = await callback.call(descriptor.observer, event);
+            results.push(result ?? CONTINUE);
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (descriptor.failureMode === "fail-closed") {
+              results.push({
+                action: "stop",
+                reason: `observer "${descriptor.id}" failed: ${message}`,
+                code: "OBSERVER_FAIL_CLOSED"
+              });
+            } else {
+              if (descriptor.failureMode === "warn") {
+                this.logger(`[observers] ${descriptor.id} (${String(hook)}) failed: ${message}`);
+              }
+              results.push(CONTINUE);
+            }
+          }
+        }
+        return results;
+      }
+      async emitResolved(hook, event) {
+        return resolveInterventions(await this.emit(hook, event));
+      }
+    };
+  }
+});
+
 // packages/core/dist/core/AgentHarness.js
 function hashToolCall(toolName, args) {
   const canonical = stableStringify2(args);
@@ -22078,6 +23228,7 @@ var init_AgentHarness = __esm({
     init_contextGrowth();
     init_requestSnapshot();
     init_textLoopDetect();
+    init_ObserverBus();
     init_textLoopDetect();
     BUILD_LIVENESS_RECOVERY_PROMPT = "[build-liveness] The requested task requires an on-disk implementation, but no successful project mutation has occurred yet. Continue working. Inspect only as needed, then make the required change with an available mutating tool. Do not merely describe a patch or claim completion.";
     AgentHarness = class {
@@ -22105,6 +23256,14 @@ var init_AgentHarness = __esm({
        * model must change approach instead of soft-replaying forever.
        */
       toolCallCounts = /* @__PURE__ */ new Map();
+      /**
+       * Frontier PHASE 1: observer bus, or `null` when observers are off. Every
+       * hook site guards on `this.observerBus` so the off-path stays identical
+       * to the pre-observer loop.
+       */
+      observerBus;
+      /** Coarse turn counter attached to observer events (per run, 0-based). */
+      observerTurn = 0;
       /**
        * How many times this run re-entered the provider because the model emitted
        * tool calls as a `---TOOLS---` text block (fallback format) instead of native
@@ -22132,6 +23291,7 @@ var init_AgentHarness = __esm({
         const soft = this.maxToolLoopIterations;
         const hardCfg = config2.maxToolLoopHardCap;
         this.maxToolLoopHardCap = typeof hardCfg === "number" && hardCfg > 0 ? Math.max(soft, hardCfg) : Math.max(soft * 3, soft + 60);
+        this.observerBus = config2.observers?.length ? new ObserverBus(config2.observers) : buildRuntimeObserverBus({ steeringQueue: config2.controlQueue }) ?? null;
       }
       /**
        * Snapshot of the live transcript (`this.config.messages`) as mutated
@@ -22227,6 +23387,57 @@ var init_AgentHarness = __esm({
           return { allowed: true };
         }
       }
+      /** Base fields shared by every observer event this harness emits. */
+      observerEventBase(turn) {
+        return {
+          id: crypto.randomUUID(),
+          ts: Date.now(),
+          turn,
+          identity: {
+            runId: this.sessionId,
+            agentId: this.sessionId,
+            role: this.config.memberId ? "council" : "lead",
+            mode: this.config.memberId ? "council" : "kraken",
+            model: this.config.model,
+            provider: this.config.provider
+          }
+        };
+      }
+      /**
+       * Frontier PHASE 1: observer pre-dispatch gate, consulted after the host
+       * resource gate on EVERY registry dispatch (native + text paths).
+       * `deny_tool` blocks the call with a model-visible reason; `stop` is a
+       * cooperative cancel (agent_end reason 'cancelled'); `inject` appends a
+       * user/system message at the next safe boundary (the in-flight provider
+       * request is never mutated). `retry`/`replace` are not yet honored at
+       * this hook and fall through as continue.
+       */
+      async checkObserverToolGate(toolCallId, toolName, args) {
+        const bus = this.observerBus;
+        if (!bus)
+          return { allowed: true };
+        const result = await bus.emitResolved("onToolCall", {
+          ...this.observerEventBase(this.observerTurn),
+          toolCallId,
+          toolName,
+          args
+        });
+        if (result.action === "deny_tool") {
+          return { allowed: false, reason: result.reason };
+        }
+        if (result.action === "stop") {
+          this.cancel();
+          return { allowed: false, reason: result.reason };
+        }
+        if (result.action === "inject") {
+          this.config.messages.push({
+            role: result.message.role === "system" ? "system" : "user",
+            content: result.message.content
+          });
+          return { allowed: true };
+        }
+        return { allowed: true };
+      }
       async executePendingTools(pending, maxToolCalls) {
         const out = new Array(pending.length);
         const maxParallel = Math.max(1, Number.parseInt(process.env.ZELARI_MAX_PARALLEL_TOOLS ?? "6", 10) || 6);
@@ -22247,6 +23458,14 @@ var init_AgentHarness = __esm({
               durationMs: 0
             };
           }
+          const observerGate = await this.checkObserverToolGate(p3.toolCallId, p3.toolName, p3.args);
+          if (!observerGate.allowed) {
+            return {
+              content: `[observers] ${observerGate.reason ?? "denied by observer policy"}`,
+              isError: true,
+              durationMs: 0
+            };
+          }
           const callKey = hashToolCall(p3.toolName, p3.args);
           const nextCount = (this.toolCallCounts.get(callKey) ?? 0) + 1;
           this.toolCallCounts.set(callKey, nextCount);
@@ -22429,6 +23648,12 @@ ${shared2.content}`,
           recoveries: 0
         };
         const memoryWarning = await this.prepareMemoryContext();
+        this.observerTurn = 0;
+        if (this.observerBus) {
+          const start = await this.observerBus.emitResolved("onRunStart", this.observerEventBase(0));
+          if (start.action === "stop")
+            this.cancel();
+        }
         const startEvent = createBrainEvent("agent_start", this.sessionId, {
           model: this.config.model,
           provider: this.config.provider,
@@ -22638,6 +23863,22 @@ ${shared2.content}`,
         });
         this.emit(growthEvent);
         yield growthEvent;
+        if (this.observerBus) {
+          const endReason = hadError ? "error" : this.cancelled ? "cancelled" : "completed";
+          try {
+            if (endReason === "cancelled") {
+              await this.observerBus.emitResolved("onCancelled", {
+                ...this.observerEventBase(this.observerTurn),
+                reason: "cancelled"
+              });
+            }
+            await this.observerBus.emitResolved("onRunEnd", {
+              ...this.observerEventBase(this.observerTurn),
+              reason: endReason
+            });
+          } catch {
+          }
+        }
         const agentEnd = createBrainEvent("agent_end", this.sessionId, {
           reason: hadError ? "error" : this.cancelled ? "cancelled" : "completed",
           durationMs: Date.now() - startTime,
@@ -22922,6 +24163,21 @@ ${cached2}`
                     executedAny = true;
                     continue;
                   }
+                  const observerGate = await this.checkObserverToolGate(toolCallId, tt.name, tt.args);
+                  if (!observerGate.allowed) {
+                    const denied = `[observers] ${observerGate.reason ?? "denied by observer policy"}`;
+                    const denyEv = createBrainEvent("tool_execution_end", this.sessionId, {
+                      toolCallId,
+                      result: denied,
+                      isError: true,
+                      durationMs: 0
+                    });
+                    this.emit(denyEv);
+                    yield denyEv;
+                    turnToolResults.push({ toolCallId, content: denied });
+                    executedAny = true;
+                    continue;
+                  }
                   let resultStr = "";
                   let isError = false;
                   const startMs = Date.now();
@@ -22981,6 +24237,21 @@ ${cached2}`
                 yield truncErr;
                 finishRef.value = "stop";
               }
+              if (this.observerBus) {
+                this.observerTurn += 1;
+                try {
+                  const turnEnd = await this.observerBus.emitResolved("onTurnEnd", this.observerEventBase(this.observerTurn));
+                  if (turnEnd.action === "inject") {
+                    this.config.messages.push({
+                      role: turnEnd.message.role === "system" ? "system" : "user",
+                      content: turnEnd.message.content
+                    });
+                  } else if (turnEnd.action === "stop") {
+                    this.cancel();
+                  }
+                } catch {
+                }
+              }
               if (turnToolCalls.length > 0 || turnText.length > 0 || turnReasoning.length > 0) {
                 this.config.messages.push({
                   role: "assistant",
@@ -23384,7 +24655,7 @@ function hookMatches(hook, event, toolName) {
   return true;
 }
 var TOOL_ALIASES;
-var init_types2 = __esm({
+var init_types3 = __esm({
   "packages/core/dist/core/hooks/types.js"() {
     "use strict";
     TOOL_ALIASES = {
@@ -23429,7 +24700,7 @@ var DEFAULT_TIMEOUT_MS, LifecycleHookRunner;
 var init_lifecycleHookRunner = __esm({
   "packages/core/dist/core/hooks/lifecycleHookRunner.js"() {
     "use strict";
-    init_types2();
+    init_types3();
     DEFAULT_TIMEOUT_MS = 5e3;
     LifecycleHookRunner = class {
       hooks = [];
@@ -23634,7 +24905,7 @@ var init_lifecycleHookRunner = __esm({
 var init_hooks = __esm({
   "packages/core/dist/core/hooks/index.js"() {
     "use strict";
-    init_types2();
+    init_types3();
     init_lifecycleHookRunner();
   }
 });
@@ -24161,7 +25432,7 @@ var init_parseCssMotion = __esm({
 
 // packages/core/dist/council/verification/citeVerify.js
 import { existsSync as existsSync6, readFileSync as readFileSync6 } from "node:fs";
-import { join } from "node:path";
+import { join as join3 } from "node:path";
 function extractCitations(text) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
@@ -24183,7 +25454,7 @@ function verifyCitations(projectRoot, synthesisText) {
     return [];
   const results = [];
   for (const cite of extractCitations(synthesisText)) {
-    const abs = join(projectRoot, cite.file);
+    const abs = join3(projectRoot, cite.file);
     if (!existsSync6(abs)) {
       results.push({
         id: "synthesis.cite-invalid",
@@ -24461,9 +25732,9 @@ var init_synthesisAudit = __esm({
 
 // packages/core/dist/council/verification/runChecks.js
 import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join4 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path72 = join2(zelariRoot, "nfr-spec.json");
+  const path72 = join4(zelariRoot, "nfr-spec.json");
   if (!existsSync7(path72))
     return null;
   try {
@@ -24478,11 +25749,11 @@ function loadNfrSpec(zelariRoot) {
 function resolveTargets(projectRoot, spec) {
   const found = [];
   for (const rel2 of spec.targets) {
-    if (existsSync7(join2(projectRoot, rel2))) {
+    if (existsSync7(join4(projectRoot, rel2))) {
       found.push(rel2);
     }
   }
-  if (found.length === 0 && existsSync7(join2(projectRoot, "index.html"))) {
+  if (found.length === 0 && existsSync7(join4(projectRoot, "index.html"))) {
     return ["index.html"];
   }
   return found;
@@ -24537,7 +25808,7 @@ function checkDeadCssHooks(html, relFile) {
   return results;
 }
 function checkPlanReality(projectRoot, zelariRoot, targets, keywords) {
-  const planPath = join2(zelariRoot, "plan.json");
+  const planPath = join4(zelariRoot, "plan.json");
   if (!existsSync7(planPath) || keywords.length === 0)
     return [];
   let plan;
@@ -24548,7 +25819,7 @@ function checkPlanReality(projectRoot, zelariRoot, targets, keywords) {
   }
   const milestoneText = (plan.milestones ?? []).map((m) => `${m.name ?? ""} ${m.description ?? ""}`).join(" ").toLowerCase();
   const results = [];
-  const targetContent = targets.map((t) => readFileSync7(join2(projectRoot, t), "utf8").toLowerCase()).join("\n");
+  const targetContent = targets.map((t) => readFileSync7(join4(projectRoot, t), "utf8").toLowerCase()).join("\n");
   for (const kw of keywords) {
     const low = kw.toLowerCase();
     if (!milestoneText.includes(low))
@@ -24577,11 +25848,11 @@ function checkPlanReality(projectRoot, zelariRoot, targets, keywords) {
   return results;
 }
 function checkReadmeStale(projectRoot, targets) {
-  const readmePath = join2(projectRoot, "README.md");
+  const readmePath = join4(projectRoot, "README.md");
   if (!existsSync7(readmePath) || targets.length === 0)
     return [];
   const readme = readFileSync7(readmePath, "utf8");
-  const htmlPath = join2(projectRoot, targets[0]);
+  const htmlPath = join4(projectRoot, targets[0]);
   if (!existsSync7(htmlPath))
     return [];
   const html = readFileSync7(htmlPath, "utf8");
@@ -24622,7 +25893,7 @@ function runImplementationVerification(input) {
     forbidLayoutProps: anim.forbidLayoutProps ?? true
   };
   for (const rel2 of targets) {
-    const html = readFileSync7(join2(input.projectRoot, rel2), "utf8");
+    const html = readFileSync7(join4(input.projectRoot, rel2), "utf8");
     for (const v of scanKeyframesViolations(html, scanOpts)) {
       results.push({
         id: "motion.keyframes",
@@ -24678,7 +25949,7 @@ function runImplementationVerification(input) {
   };
 }
 function writeVerificationReport(zelariRoot, report) {
-  const outPath = join2(zelariRoot, "verification-report.json");
+  const outPath = join4(zelariRoot, "verification-report.json");
   writeFileSync5(outPath, JSON.stringify(report, null, 2), "utf8");
   return outPath;
 }
@@ -24709,7 +25980,7 @@ var init_runChecks = __esm({
 
 // packages/core/dist/council/verification/microGate.js
 import { existsSync as existsSync8, readFileSync as readFileSync8 } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 function checkDeadHooksInHtml(html) {
   const warnings = [];
   const scripts = [];
@@ -24737,7 +26008,7 @@ function checkDeadHooksInHtml(html) {
   return warnings;
 }
 function runMicroVerificationOnFile(projectRoot, relPath, zelariRoot) {
-  const abs = join3(projectRoot, relPath);
+  const abs = join5(projectRoot, relPath);
   if (!existsSync8(abs) || !/\.html?$/i.test(relPath))
     return [];
   const spec = (zelariRoot ? loadNfrSpec(zelariRoot) : null) ?? DEFAULT_NFR_SPEC;
@@ -25103,7 +26374,7 @@ var init_implementationDelivery = __esm({
 
 // packages/core/dist/council/verification/inlineJsAutofix.js
 import { readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 function minifyInlineJs(js) {
   let out = js.replace(/\/\*[\s\S]*?\*\//g, "");
   out = out.split("\n").map((line) => line.replace(/\/\/.*$/, "").trimEnd()).filter((line) => line.trim().length > 0).join("\n");
@@ -25146,7 +26417,7 @@ function applyInlineJsAutofix(projectRoot, report) {
   const fixes = [];
   for (const r of fails) {
     const rel2 = r.file ?? "index.html";
-    const abs = join4(projectRoot, rel2);
+    const abs = join6(projectRoot, rel2);
     let html;
     try {
       html = readFileSync9(abs, "utf8");
@@ -25183,7 +26454,7 @@ var init_inlineJsAutofix = __esm({
 
 // packages/core/dist/agents/councilApi.js
 import { existsSync as existsSync9 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join7 } from "node:path";
 function extractBalancedJsonObject(s) {
   const start = s.indexOf("{");
   if (start < 0)
@@ -25810,7 +27081,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         const zelariRoot = `${chairmanProjectRoot}/.zelari`;
         const spec = loadNfrSpec(zelariRoot) ?? DEFAULT_NFR_SPEC;
         for (const rel2 of spec.targets) {
-          if (!existsSync9(join5(chairmanProjectRoot, rel2)))
+          if (!existsSync9(join7(chairmanProjectRoot, rel2)))
             continue;
           changedTargetFiles.add(rel2);
           for (const w of runChairmanMicroGate({ projectRoot: chairmanProjectRoot, relPath: rel2, zelariRoot })) {
@@ -25830,7 +27101,7 @@ async function* runCouncilPure(userMessage, config2, callbacks = {}) {
         const zelariRootReplay = `${chairmanProjectRoot}/.zelari`;
         const specReplay = loadNfrSpec(zelariRootReplay) ?? DEFAULT_NFR_SPEC;
         for (const rel2 of specReplay.targets) {
-          if (!existsSync9(join5(chairmanProjectRoot, rel2)))
+          if (!existsSync9(join7(chairmanProjectRoot, rel2)))
             continue;
           changedTargetFiles.add(rel2);
           for (const w of runChairmanMicroGate({
@@ -26541,7 +27812,7 @@ var init_missionBrief = __esm({
 });
 
 // packages/core/dist/council/verification/types.js
-var init_types3 = __esm({
+var init_types4 = __esm({
   "packages/core/dist/council/verification/types.js"() {
     "use strict";
   }
@@ -26549,7 +27820,7 @@ var init_types3 = __esm({
 
 // packages/core/dist/council/verification/motionAutofix.js
 import { readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join6 } from "node:path";
+import { join as join8 } from "node:path";
 function sanitizeTransitionPart(part) {
   const tokens = part.trim().split(/\s+/);
   if (tokens.length === 0)
@@ -26624,7 +27895,7 @@ function applyMotionAutofix(projectRoot, report) {
     forbidLayoutProps: DEFAULT_NFR_SPEC.animation?.forbidLayoutProps ?? true
   };
   for (const rel2 of targets) {
-    const abs = join6(projectRoot, rel2);
+    const abs = join8(projectRoot, rel2);
     let html;
     try {
       html = readFileSync10(abs, "utf8");
@@ -26700,7 +27971,7 @@ var init_motionAutofix = __esm({
 
 // packages/core/dist/council/verification/autofix.js
 import { readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join9 } from "node:path";
 function applyDeterministicAutofix(projectRoot, report) {
   const motion = applyMotionAutofix(projectRoot, report);
   const inlineJs = applyInlineJsAutofix(projectRoot, report);
@@ -26714,7 +27985,7 @@ function applyDeterministicAutofix(projectRoot, report) {
     const m = r.evidence?.match(/classList\.add\(\s*['"]([\w-]+)['"]\s*\)/);
     if (!m || m[1] === "rm")
       continue;
-    const abs = join7(projectRoot, rel2);
+    const abs = join9(projectRoot, rel2);
     let html = readFileSync11(abs, "utf8");
     const snippet = m[0];
     if (!html.includes(snippet))
@@ -26745,7 +28016,7 @@ var init_autofix = __esm({
 var init_verification = __esm({
   "packages/core/dist/council/verification/index.js"() {
     "use strict";
-    init_types3();
+    init_types4();
     init_runChecks();
     init_honesty();
     init_parseCssMotion();
@@ -26763,7 +28034,7 @@ var init_verification = __esm({
 });
 
 // packages/core/dist/council/lessons/types.js
-var init_types4 = __esm({
+var init_types5 = __esm({
   "packages/core/dist/council/lessons/types.js"() {
     "use strict";
   }
@@ -26771,9 +28042,9 @@ var init_types4 = __esm({
 
 // packages/core/dist/council/lessons/io.js
 import { readFileSync as readFileSync12 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join10 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path72 = join8(zelariRoot, LESSONS_FILE);
+  const path72 = join10(zelariRoot, LESSONS_FILE);
   try {
     const raw = readFileSync12(path72, "utf8");
     const byId = /* @__PURE__ */ new Map();
@@ -26855,8 +28126,8 @@ function jaccardSimilarity(a, b) {
   return union2 === 0 ? 0 : inter / union2;
 }
 function normalizeForSignature(checkId, message) {
-  const base = `${checkId} ${message}`.toLowerCase().replace(/[A-Za-z]:\\[^\s]+/g, "path").replace(/\/[\w./-]+/g, "path").replace(/l\d{1,6}/gi, "line").replace(/\d+/g, "n");
-  return [...tokenizeForSignature(base)].sort().join(" ");
+  const base2 = `${checkId} ${message}`.toLowerCase().replace(/[A-Za-z]:\\[^\s]+/g, "path").replace(/\/[\w./-]+/g, "path").replace(/l\d{1,6}/gi, "line").replace(/\d+/g, "n");
+  return [...tokenizeForSignature(base2)].sort().join(" ");
 }
 var init_signatures = __esm({
   "packages/core/dist/council/lessons/signatures.js"() {
@@ -26866,7 +28137,7 @@ var init_signatures = __esm({
 
 // packages/core/dist/council/lessons/recordFailure.js
 import { appendFileSync } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join11 } from "node:path";
 function methodologyFor(check2) {
   return METHODOLOGY[check2.id] ?? `When ${check2.id} fails, fix the underlying issue and cite grep/tool evidence before claiming PASS.`;
 }
@@ -26876,7 +28147,7 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path72 = join9(zelariRoot, LESSONS_FILE);
+  const path72 = join11(zelariRoot, LESSONS_FILE);
   appendFileSync(path72, `${JSON.stringify(lesson)}
 `, "utf8");
 }
@@ -27016,7 +28287,7 @@ var init_recallLessons = __esm({
 var init_lessons = __esm({
   "packages/core/dist/council/lessons/index.js"() {
     "use strict";
-    init_types4();
+    init_types5();
     init_io();
     init_isAnswerLeak();
     init_signatures();
@@ -27026,7 +28297,7 @@ var init_lessons = __esm({
 });
 
 // packages/core/dist/council/completion/types.js
-var init_types5 = __esm({
+var init_types6 = __esm({
   "packages/core/dist/council/completion/types.js"() {
     "use strict";
   }
@@ -27034,7 +28305,7 @@ var init_types5 = __esm({
 
 // packages/core/dist/council/completion/buildCompletion.js
 import { writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join12 } from "node:path";
 function openFailsFromReport(report) {
   if (!report)
     return [];
@@ -27093,7 +28364,7 @@ function buildCouncilCompletion(input) {
   };
 }
 function writeCouncilCompletion(zelariRoot, completion) {
-  const outPath = join10(zelariRoot, "completion.json");
+  const outPath = join12(zelariRoot, "completion.json");
   writeFileSync9(outPath, JSON.stringify(completion, null, 2), "utf8");
   return outPath;
 }
@@ -27107,7 +28378,7 @@ var init_buildCompletion = __esm({
 var init_completion2 = __esm({
   "packages/core/dist/council/completion/index.js"() {
     "use strict";
-    init_types5();
+    init_types6();
     init_buildCompletion();
   }
 });
@@ -27428,7 +28699,7 @@ var init_council = __esm({
 
 // packages/core/dist/memory/types.js
 var MEMORY_SCHEMA_VERSION, MEMORY_KINDS, MEMORY_STATUSES, MEMORY_RELATIONS, MEMORY_VISIBILITIES;
-var init_types6 = __esm({
+var init_types7 = __esm({
   "packages/core/dist/memory/types.js"() {
     "use strict";
     MEMORY_SCHEMA_VERSION = 1;
@@ -27479,7 +28750,7 @@ var init_schemas3 = __esm({
   "packages/core/dist/memory/schemas.js"() {
     "use strict";
     init_zod();
-    init_types6();
+    init_types7();
     isoDate = external_exports.string().datetime({ offset: true });
     unit = external_exports.number().finite().min(0).max(1);
     metadata = external_exports.record(external_exports.string(), external_exports.unknown()).refine((value) => {
@@ -28455,18 +29726,18 @@ var init_service = __esm({
         };
       }
       async doctor() {
-        const base = await (this.backend.doctor?.() ?? Promise.resolve({
+        const base2 = await (this.backend.doctor?.() ?? Promise.resolve({
           ok: true,
           backend: "custom",
           checks: [{ name: "backend", ok: true, detail: "No diagnostic API exposed." }]
         }));
         if (!this.semantic)
-          return base;
+          return base2;
         const semantic = await this.semantic.status();
         return {
-          ...base,
+          ...base2,
           checks: [
-            ...base.checks,
+            ...base2.checks,
             {
               name: "semantic",
               ok: semantic.state !== "degraded",
@@ -28770,7 +30041,7 @@ var init_noop = __esm({
 var init_memory = __esm({
   "packages/core/dist/memory/index.js"() {
     "use strict";
-    init_types6();
+    init_types7();
     init_schemas3();
     init_scoring();
     init_policies();
@@ -29287,10 +30558,10 @@ function extractRequirementsBlock(text) {
   }
 }
 function parsePersonaVerdict(text) {
-  const base = parseVerifyVerdict(text);
+  const base2 = parseVerifyVerdict(text);
   return {
-    verdict: base.verdict,
-    findings: base.findings,
+    verdict: base2.verdict,
+    findings: base2.findings,
     requirements: extractRequirementsBlock(text),
     // Bennett's weakness = "how little the reviewer's free text asserts"
     // (arXiv:2301.12987). `weaknessScoreFromText` is the weakness form
@@ -29492,7 +30763,7 @@ var init_personas = __esm({
 
 // packages/core/dist/kraken/runtime/types.js
 var PlanError;
-var init_types7 = __esm({
+var init_types8 = __esm({
   "packages/core/dist/kraken/runtime/types.js"() {
     "use strict";
     PlanError = class extends Error {
@@ -29590,7 +30861,7 @@ var MAX_BUNDLE_BYTES, FORBIDDEN_TOKENS;
 var init_sandbox = __esm({
   "packages/core/dist/kraken/runtime/sandbox.js"() {
     "use strict";
-    init_types7();
+    init_types8();
     MAX_BUNDLE_BYTES = 256 * 1024;
     FORBIDDEN_TOKENS = [
       /\bprocess\b/,
@@ -29653,7 +30924,7 @@ var init_runner = __esm({
     "use strict";
     init_verdict();
     init_personas();
-    init_types7();
+    init_types8();
     DEFAULT_MAX_TENTACLES = 200;
     DEFAULT_PLAN_TIMEOUT_MS = 30 * 6e4;
     ScriptRunner = class {
@@ -29837,7 +31108,7 @@ var init_runner = __esm({
 var init_runtime = __esm({
   "packages/core/dist/kraken/runtime/index.js"() {
     "use strict";
-    init_types7();
+    init_types8();
     init_sandbox();
     init_runner();
   }
@@ -29858,7 +31129,7 @@ var init_kraken = __esm({
 
 // packages/core/dist/session/types.js
 var SESSION_SCHEMA_VERSION, SessionActorSchema, SESSION_EVENT_KINDS, SessionEventEnvelopeSchema, ACTOR_USER, ACTOR_AGENT, ACTOR_SYSTEM;
-var init_types8 = __esm({
+var init_types9 = __esm({
   "packages/core/dist/session/types.js"() {
     "use strict";
     init_zod();
@@ -30422,7 +31693,7 @@ var SessionLogLockedError, DEFAULT_STALE_LOCK_MS, SessionLogWriter;
 var init_writer = __esm({
   "packages/core/dist/session/writer.js"() {
     "use strict";
-    init_types8();
+    init_types9();
     SessionLogLockedError = class extends Error {
       sessionPath;
       owner;
@@ -30734,7 +32005,7 @@ function buildProjection(events, issues = []) {
 var init_replay = __esm({
   "packages/core/dist/session/replay.js"() {
     "use strict";
-    init_types8();
+    init_types9();
     init_modelSurface();
     init_recovery();
   }
@@ -30759,7 +32030,7 @@ var init_store = __esm({
     "use strict";
     init_writer();
     init_replay();
-    init_types8();
+    init_types9();
     SessionStore = class _SessionStore {
       baseDir;
       constructor(baseDir) {
@@ -30915,7 +32186,7 @@ async function lineageOf(store6, sessionId2) {
 var init_lineage = __esm({
   "packages/core/dist/session/lineage.js"() {
     "use strict";
-    init_types8();
+    init_types9();
     init_replay();
     init_recovery();
   }
@@ -31398,7 +32669,7 @@ var init_taskContract = __esm({
 var init_session = __esm({
   "packages/core/dist/session/index.js"() {
     "use strict";
-    init_types8();
+    init_types9();
     init_modelSurface();
     init_compaction();
     init_agentAdapter();
@@ -31734,7 +33005,7 @@ var init_worktreeWorkspace = __esm({
 });
 
 // packages/core/dist/runtime/profiles.js
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 function resolveProfile(id3) {
   const profile = BUILT_IN_PROFILES[id3];
   if (!profile)
@@ -31743,10 +33014,10 @@ function resolveProfile(id3) {
 }
 function toolManifestHash(tools) {
   const manifest = [...tools].sort().join(",");
-  return createHash3("sha256").update(manifest).digest("hex");
+  return createHash5("sha256").update(manifest).digest("hex");
 }
 function profileHash(profile) {
-  return createHash3("sha256").update(stableStringify(profile)).digest("hex");
+  return createHash5("sha256").update(stableStringify(profile)).digest("hex");
 }
 var ProfileSchema, MINIMAL_TOOLS, MINIMAL_V1, KRAKEN_V1, COUNCIL_V1, MISSION_V1, BUILT_IN_PROFILES, UnknownProfileError;
 var init_profiles = __esm({
@@ -31832,7 +33103,7 @@ function hashHarnessManifest(manifest) {
 function harnessInputHash(value) {
   return sha256Hex(stableStringify(value));
 }
-function collectPaths2(base, a, b, out, depth = 0) {
+function collectPaths2(base2, a, b, out, depth = 0) {
   if (depth > 6)
     return;
   if (stableStringify(a) === stableStringify(b))
@@ -31841,11 +33112,11 @@ function collectPaths2(base, a, b, out, depth = 0) {
   const objB = b && typeof b === "object" && !Array.isArray(b) ? b : null;
   if (objA && objB) {
     for (const key of [.../* @__PURE__ */ new Set([...Object.keys(objA), ...Object.keys(objB)])].sort()) {
-      collectPaths2(base ? `${base}.${key}` : key, objA[key], objB[key], out, depth + 1);
+      collectPaths2(base2 ? `${base2}.${key}` : key, objA[key], objB[key], out, depth + 1);
     }
     return;
   }
-  out.push(base);
+  out.push(base2);
 }
 function diffHarnessManifest(oldManifest, newManifest) {
   const changed = [];
@@ -32005,12 +33276,12 @@ var init_executionContext = __esm({
 });
 
 // packages/core/dist/runtime/resourcePolicy.js
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 function defaultResourcePolicy(profileId) {
   return PROFILE_RESOURCE_POLICIES[profileId] ?? PROFILE_RESOURCE_POLICIES["kraken/v1"];
 }
 function resourcePolicyHash(policy) {
-  return createHash4("sha256").update(stableStringify(ResourcePolicySchema.parse(policy))).digest("hex");
+  return createHash6("sha256").update(stableStringify(ResourcePolicySchema.parse(policy))).digest("hex");
 }
 var BudgetPressureSchema, ResourceStageSchema, PressureThresholdsSchema, DEFAULT_PRESSURE_THRESHOLDS, ResourcePolicySchema, PROFILE_RESOURCE_POLICIES;
 var init_resourcePolicy = __esm({
@@ -32155,6 +33426,257 @@ var init_resourceBudget = __esm({
   }
 });
 
+// packages/core/dist/runtime/observers/composeObservers.js
+function composeObservers(observers) {
+  const composed = {};
+  for (const hook of HOOKS) {
+    composed[hook] = async (event) => {
+      const results = [];
+      for (const observer of observers) {
+        const callback = observer[hook];
+        if (typeof callback === "function") {
+          results.push(await callback(event) ?? CONTINUE);
+        }
+      }
+      return resolveInterventions(results);
+    };
+  }
+  return composed;
+}
+var HOOKS;
+var init_composeObservers = __esm({
+  "packages/core/dist/runtime/observers/composeObservers.js"() {
+    "use strict";
+    init_types2();
+    init_resolve();
+    HOOKS = [
+      "onRunStart",
+      "onModelAttempt",
+      "onModelDelta",
+      "onModelResponse",
+      "onToolCall",
+      "onToolResult",
+      "onTurnEnd",
+      "onRunEnd",
+      "onCancelled"
+    ];
+  }
+});
+
+// packages/core/dist/runtime/observers/index.js
+var init_observers = __esm({
+  "packages/core/dist/runtime/observers/index.js"() {
+    "use strict";
+    init_types2();
+    init_resolve();
+    init_ObserverBus();
+    init_composeObservers();
+    init_TraceObserver();
+    init_MetricsObserver();
+  }
+});
+
+// packages/core/dist/runtime/guards/index.js
+var init_guards = __esm({
+  "packages/core/dist/runtime/guards/index.js"() {
+    "use strict";
+    init_RepetitionGuard();
+    init_FailureSignatureGuard();
+    init_DuplicateSearchGuard();
+    init_NoProgressGuard();
+    init_ReasoningWatchdog();
+  }
+});
+
+// packages/core/dist/runtime/recorder/retention.js
+import { readdir, readFile, rm, stat } from "node:fs/promises";
+import { join as join13 } from "node:path";
+function runRetentionFromEnv() {
+  const parseDays = Number(process.env.ZELARI_RUN_RETENTION_DAYS);
+  const parseMb = Number(process.env.ZELARI_RUN_RETENTION_MAX_MB);
+  return {
+    maxAgeDays: Number.isFinite(parseDays) && parseDays > 0 ? parseDays : DEFAULT_RUN_RETENTION_DAYS,
+    maxTotalBytes: Number.isFinite(parseMb) && parseMb > 0 ? Math.round(parseMb * 1024 * 1024) : DEFAULT_RUN_RETENTION_MAX_MB * 1024 * 1024
+  };
+}
+async function dirSize(path72) {
+  let total = 0;
+  let entries;
+  try {
+    entries = await readdir(path72, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  for (const entry of entries) {
+    const child = join13(path72, entry.name);
+    if (entry.isDirectory())
+      total += await dirSize(child);
+    else {
+      try {
+        total += (await stat(child)).size;
+      } catch {
+      }
+    }
+  }
+  return total;
+}
+async function enforceRunRetention(runsDir, options = {}) {
+  const now = options.now ?? Date.now;
+  const maxAgeDays = options.maxAgeDays ?? DEFAULT_RUN_RETENTION_DAYS;
+  const maxTotalBytes = options.maxTotalBytes ?? DEFAULT_RUN_RETENTION_MAX_MB * 1024 * 1024;
+  const result = { deleted: [], freedBytes: 0, kept: 0 };
+  let entries;
+  try {
+    entries = await readdir(runsDir, { withFileTypes: true });
+  } catch {
+    return result;
+  }
+  const infos = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    const path72 = join13(runsDir, entry.name);
+    let startedAt = 0;
+    let endedAt;
+    let completed = false;
+    try {
+      const manifest = JSON.parse(await readFile(join13(path72, "manifest.json"), "utf8"));
+      startedAt = manifest.startedAt ?? 0;
+      endedAt = manifest.endedAt;
+      completed = Boolean(endedAt) && manifest.status !== "running";
+    } catch {
+      completed = false;
+    }
+    infos.push({ name: entry.name, path: path72, startedAt, endedAt, completed, bytes: await dirSize(path72) });
+  }
+  const remove = async (info) => {
+    await rm(info.path, { recursive: true, force: true });
+    result.deleted.push(info.name);
+    result.freedBytes += info.bytes;
+  };
+  const ageCutoffMs = maxAgeDays * 24 * 60 * 60 * 1e3;
+  const expired = infos.filter((info) => info.completed && info.startedAt > 0 && now() - info.startedAt > ageCutoffMs).sort((a, b) => a.startedAt - b.startedAt);
+  for (const info of expired)
+    await remove(info);
+  const survivors = infos.filter((info) => !result.deleted.includes(info.name));
+  let totalBytes = survivors.reduce((sum, info) => sum + info.bytes, 0);
+  const byOldest = survivors.filter((info) => info.completed).sort((a, b) => a.startedAt - b.startedAt);
+  for (const info of byOldest) {
+    if (totalBytes <= maxTotalBytes)
+      break;
+    totalBytes -= info.bytes;
+    await remove(info);
+  }
+  result.kept = infos.filter((info) => !result.deleted.includes(info.name)).length;
+  return result;
+}
+var DEFAULT_RUN_RETENTION_DAYS, DEFAULT_RUN_RETENTION_MAX_MB;
+var init_retention = __esm({
+  "packages/core/dist/runtime/recorder/retention.js"() {
+    "use strict";
+    DEFAULT_RUN_RETENTION_DAYS = 30;
+    DEFAULT_RUN_RETENTION_MAX_MB = 2048;
+  }
+});
+
+// packages/core/dist/runtime/recorder/index.js
+var init_recorder = __esm({
+  "packages/core/dist/runtime/recorder/index.js"() {
+    "use strict";
+    init_Redactor();
+    init_RunRecorder();
+    init_recorderObserver();
+    init_retention();
+  }
+});
+
+// packages/core/dist/runtime/controls/types.js
+function isSteerControlEvent(event) {
+  return event.type === "steer";
+}
+function isFollowUpControlEvent(event) {
+  return event.type === "follow_up";
+}
+function isCancelControlEvent(event) {
+  return event.type === "cancel";
+}
+var init_types10 = __esm({
+  "packages/core/dist/runtime/controls/types.js"() {
+    "use strict";
+  }
+});
+
+// packages/core/dist/runtime/controls/RuntimeControlQueue.js
+var RuntimeControlQueue;
+var init_RuntimeControlQueue = __esm({
+  "packages/core/dist/runtime/controls/RuntimeControlQueue.js"() {
+    "use strict";
+    RuntimeControlQueue = class {
+      items = [];
+      /**
+       * Optional drain listener (CLI control bridge, §24): fired synchronously
+       * whenever a drain* method actually removes events, with the exact events
+       * consumed — lets the host emit `control_applied` at the true boundary.
+       */
+      onDrained;
+      enqueue(event) {
+        this.items.push(event);
+      }
+      /** Next event in arrival order, without removing it. */
+      peek() {
+        return this.items[0];
+      }
+      get size() {
+        return this.items.length;
+      }
+      /**
+       * Remove a not-yet-applied control by id (Desktop queue UI, §32: removal
+       * stays possible until `control_applied`). Returns true when removed.
+       */
+      remove(controlId) {
+        const index = this.items.findIndex((event) => event.id === controlId);
+        if (index === -1)
+          return false;
+        this.items.splice(index, 1);
+        return true;
+      }
+      clear() {
+        this.items = [];
+      }
+      /** All pending steers in arrival order; removes them from the queue. */
+      drainSteers() {
+        return this.drainByType("steer");
+      }
+      /** All pending follow-ups in arrival order; removes them from the queue. */
+      drainFollowUps() {
+        return this.drainByType("follow_up");
+      }
+      /** All pending cancels in arrival order; removes them from the queue. */
+      drainCancels() {
+        return this.drainByType("cancel");
+      }
+      drainByType(type) {
+        const matched = this.items.filter((event) => event.type === type);
+        if (matched.length > 0) {
+          this.items = this.items.filter((event) => event.type !== type);
+          this.onDrained?.(matched);
+        }
+        return matched;
+      }
+    };
+  }
+});
+
+// packages/core/dist/runtime/controls/index.js
+var init_controls = __esm({
+  "packages/core/dist/runtime/controls/index.js"() {
+    "use strict";
+    init_types10();
+    init_RuntimeControlQueue();
+    init_SteeringObserver();
+  }
+});
+
 // packages/core/dist/runtime/index.js
 var init_runtime2 = __esm({
   "packages/core/dist/runtime/index.js"() {
@@ -32168,6 +33690,295 @@ var init_runtime2 = __esm({
     init_executionContext();
     init_resourcePolicy();
     init_resourceBudget();
+    init_observers();
+    init_guards();
+    init_recorder();
+    init_controls();
+  }
+});
+
+// packages/core/dist/context/ContextPolicy.js
+function contextPolicyForRole(role) {
+  return ROLE_POLICIES[role] ?? DEFAULT_CONTEXT_POLICY;
+}
+var KRAKEN_LEAD_POLICY, KRAKEN_EXPLORE_POLICY, KRAKEN_GENERAL_POLICY, KRAKEN_VERIFY_POLICY, DEFAULT_CONTEXT_POLICY, ROLE_POLICIES, CONTEXT_POLICY_VERSION;
+var init_ContextPolicy = __esm({
+  "packages/core/dist/context/ContextPolicy.js"() {
+    "use strict";
+    KRAKEN_LEAD_POLICY = {
+      history: "recent",
+      includeParentSummary: false,
+      includeDurableState: true,
+      includeGraphState: true,
+      includeVerificationState: true,
+      toolResults: "projected"
+    };
+    KRAKEN_EXPLORE_POLICY = {
+      history: "summary",
+      includeParentSummary: true,
+      includeDurableState: true,
+      includeGraphState: false,
+      includeVerificationState: false,
+      toolResults: "projected"
+    };
+    KRAKEN_GENERAL_POLICY = {
+      history: "summary",
+      includeParentSummary: true,
+      includeDurableState: true,
+      includeGraphState: true,
+      includeVerificationState: false,
+      toolResults: "projected"
+    };
+    KRAKEN_VERIFY_POLICY = {
+      history: "summary",
+      includeParentSummary: true,
+      includeDurableState: false,
+      includeGraphState: true,
+      includeVerificationState: true,
+      toolResults: "projected"
+    };
+    DEFAULT_CONTEXT_POLICY = {
+      history: "recent",
+      includeParentSummary: false,
+      includeDurableState: false,
+      includeGraphState: false,
+      includeVerificationState: false,
+      toolResults: "projected"
+    };
+    ROLE_POLICIES = {
+      lead: KRAKEN_LEAD_POLICY,
+      explore: KRAKEN_EXPLORE_POLICY,
+      general: KRAKEN_GENERAL_POLICY,
+      verify: KRAKEN_VERIFY_POLICY,
+      council: DEFAULT_CONTEXT_POLICY,
+      mission: DEFAULT_CONTEXT_POLICY
+    };
+    CONTEXT_POLICY_VERSION = 1;
+  }
+});
+
+// packages/core/dist/context/ContextProjector.js
+function groupTurnUnits(history2) {
+  const units = [];
+  let i = 0;
+  while (i < history2.length) {
+    const msg = history2[i];
+    if (msg.role === "assistant") {
+      const unit2 = [msg];
+      i++;
+      while (i < history2.length && history2[i].role === "tool") {
+        unit2.push(history2[i]);
+        i++;
+      }
+      units.push({ messages: unit2, kind: "assistant" });
+    } else if (msg.role === "tool") {
+      units.push({ messages: [msg], kind: "orphan-tool" });
+      i++;
+    } else {
+      units.push({ messages: [msg], kind: msg.role === "user" ? "user" : "other" });
+      i++;
+    }
+  }
+  return units;
+}
+function firstLine(text, max) {
+  const line = text.split("\n", 1)[0] ?? "";
+  return line.length > max ? `${line.slice(0, max)}\u2026` : line;
+}
+function renderHistoryDigest(units) {
+  const lines = units.map((unit2) => {
+    const head = unit2.messages[0];
+    if (unit2.kind === "user")
+      return `- user: ${firstLine(head.content, 120)}`;
+    if (unit2.kind === "assistant") {
+      const tools = head.toolCalls?.map((t) => t.name).join(", ");
+      return tools ? `- assistant (tools: ${tools})` : `- assistant: ${firstLine(head.content, 120)}`;
+    }
+    if (unit2.kind === "orphan-tool")
+      return `- tool result ${head.toolCallId ?? "?"}: omitted`;
+    return `- ${head.role}: ${firstLine(head.content, 120)}`;
+  });
+  return `[Context digest \u2014 earlier turns omitted]
+${lines.join("\n")}`;
+}
+function truncateProjected(content, maxChars) {
+  if (content.length <= maxChars)
+    return content;
+  const markerLen = TRUNCATION_MARKER.length;
+  const budget = Math.max(maxChars - markerLen, HEAD_TAIL_MIN * 2);
+  const head = Math.floor(budget / 2);
+  const tail2 = budget - head;
+  return `${content.slice(0, head)}${TRUNCATION_MARKER}${content.slice(-tail2)}`;
+}
+function summarizeToolResult(content) {
+  const line = firstLine(content, 200);
+  return `[tool result \u2014 ${content.length} chars, first line] ${line}`;
+}
+function applyToolResultPolicy(messages, policy) {
+  if (policy.toolResults === "full")
+    return { messages, truncated: 0 };
+  const maxChars = policy.maxToolResultChars ?? DEFAULT_MAX_TOOL_RESULT_CHARS;
+  let truncated = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "tool")
+      return msg;
+    if (policy.toolResults === "summary-only") {
+      truncated++;
+      return { ...msg, content: summarizeToolResult(msg.content) };
+    }
+    if (msg.content.length > maxChars)
+      truncated++;
+    return { ...msg, content: truncateProjected(msg.content, maxChars) };
+  });
+  return { messages: out, truncated };
+}
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const m of messages) {
+    chars += m.content.length;
+    if (m.toolCalls)
+      chars += JSON.stringify(m.toolCalls).length;
+    if (m.reasoningContent)
+      chars += m.reasoningContent.length;
+  }
+  return Math.ceil(chars / 4);
+}
+function projectContext(transcript, policy) {
+  const system = transcript.filter((m) => m.role === "system");
+  const body = transcript.filter((m) => m.role !== "system");
+  let lastUserIdx = -1;
+  for (let i = body.length - 1; i >= 0; i--) {
+    if (body[i].role === "user") {
+      lastUserIdx = i;
+      break;
+    }
+  }
+  const history2 = lastUserIdx >= 0 ? body.slice(0, lastUserIdx) : body.slice();
+  const tail2 = lastUserIdx >= 0 ? body.slice(lastUserIdx) : [];
+  const units = groupTurnUnits(history2);
+  const maxTurns = policy.maxHistoryTurns ?? DEFAULT_MAX_HISTORY_TURNS;
+  let selected = [];
+  let digest = false;
+  let includedUnits = 0;
+  if (policy.history === "full") {
+    selected = history2.slice();
+    includedUnits = units.length;
+  } else if (policy.history === "recent") {
+    const keep = units.slice(-maxTurns);
+    includedUnits = keep.length;
+    selected = keep.flatMap((u) => u.messages);
+  } else if (policy.history === "summary") {
+    const recentUnits = units.slice(-2);
+    includedUnits = recentUnits.length;
+    selected = recentUnits.flatMap((u) => u.messages);
+    if (units.length > recentUnits.length) {
+      digest = true;
+      selected.unshift({
+        role: "user",
+        content: renderHistoryDigest(units.slice(0, units.length - recentUnits.length))
+      });
+    }
+  }
+  const includedMessages = selected.length + tail2.length + system.length;
+  const assembled = [...system, ...selected, ...tail2];
+  const { messages, truncated } = applyToolResultPolicy(assembled, policy);
+  return {
+    messages,
+    stats: {
+      estimatedTokens: estimateTokens(messages),
+      includedMessages,
+      omittedMessages: Math.max(0, history2.length - selected.length - (digest ? 1 : 0)),
+      truncatedToolResults: truncated,
+      digest
+    }
+  };
+}
+var DEFAULT_MAX_TOOL_RESULT_CHARS, DEFAULT_MAX_HISTORY_TURNS, TRUNCATION_MARKER, HEAD_TAIL_MIN;
+var init_ContextProjector = __esm({
+  "packages/core/dist/context/ContextProjector.js"() {
+    "use strict";
+    DEFAULT_MAX_TOOL_RESULT_CHARS = 12e3;
+    DEFAULT_MAX_HISTORY_TURNS = 20;
+    TRUNCATION_MARKER = "\n[\u2026tool output truncated by context projection\u2026]\n";
+    HEAD_TAIL_MIN = 200;
+  }
+});
+
+// packages/core/dist/context/parentContext.js
+function renderCompact(m) {
+  if (m.role === "user") {
+    const text2 = m.content.trim();
+    return text2 ? `user \u2014 ${text2}` : null;
+  }
+  if (m.role === "assistant") {
+    const tools = m.toolCalls?.length ? ` (requested: ${m.toolCalls.map((t) => t.name).join(", ")})` : "";
+    const text2 = m.content.trim();
+    return text2 ? `assistant${tools} \u2014 ${text2}` : tools ? `assistant${tools}` : null;
+  }
+  if (m.role === "tool") {
+    const text2 = m.content.trim();
+    return text2 ? `tool result \u2014 ${text2}` : null;
+  }
+  const text = m.content.trim();
+  return text ? `${m.role} \u2014 ${text}` : null;
+}
+function parentContextForRole(role, transcript, opts) {
+  const policy = contextPolicyForRole(role);
+  const body = transcript.filter((m) => m.role !== "system");
+  if (!policy.includeParentSummary || body.length === 0)
+    return null;
+  const projected = projectContext([...body], {
+    ...policy,
+    history: "summary",
+    toolResults: "summary-only"
+  });
+  const lines = [];
+  for (const m of projected.messages) {
+    const line = renderCompact(m);
+    if (line)
+      lines.push(line);
+  }
+  if (lines.length === 0)
+    return null;
+  const maxChars = opts?.maxBlockChars ?? DEFAULT_MAX_BLOCK_CHARS;
+  let body_ = lines.join("\n");
+  let truncated = false;
+  if (body_.length > maxChars) {
+    body_ = body_.slice(0, maxChars) + TRUNCATION_TAIL;
+    truncated = true;
+  }
+  const header = truncated ? "[Parent agent context \u2014 projected summary, full transcript not shared]" : "[Parent agent context \u2014 projected summary]";
+  return {
+    block: `---
+${header}
+
+${body_}
+---`,
+    stats: {
+      estimatedTokens: Math.ceil(body_.length / 4),
+      sourceMessages: body.length,
+      digest: projected.stats.digest
+    }
+  };
+}
+var DEFAULT_MAX_BLOCK_CHARS, TRUNCATION_TAIL;
+var init_parentContext = __esm({
+  "packages/core/dist/context/parentContext.js"() {
+    "use strict";
+    init_ContextPolicy();
+    init_ContextProjector();
+    DEFAULT_MAX_BLOCK_CHARS = 6e3;
+    TRUNCATION_TAIL = "\n[\u2026parent context truncated to fit the role budget\u2026]";
+  }
+});
+
+// packages/core/dist/context/index.js
+var init_context3 = __esm({
+  "packages/core/dist/context/index.js"() {
+    "use strict";
+    init_ContextPolicy();
+    init_ContextProjector();
+    init_parentContext();
   }
 });
 
@@ -32178,7 +33989,7 @@ function isEventBackedEvidence(ref) {
   return typeof ref.seq === "number" && ref.seq > 0;
 }
 var CriterionSourceSchema, CommandCheckSchema, FileExistsCheckSchema, FileContainsCheckSchema, FileAbsentCheckSchema, NoneCheckSchema, DeterministicCheckSchema, CriterionSchema, EvidenceTierSchema, EvidenceRefSchema, EVENT_BACKED_EVIDENCE_TIERS, VerificationStatusSchema, VerificationSourceSchema, VerificationResultSchema;
-var init_types9 = __esm({
+var init_types11 = __esm({
   "packages/core/dist/verification/types.js"() {
     "use strict";
     init_zod();
@@ -32344,9 +34155,9 @@ var init_scopeDiscipline = __esm({
 });
 
 // packages/core/dist/verification/engine.js
-import { createHash as createHash5 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 function defaultSha256(input) {
-  return createHash5("sha256").update(input).digest("hex");
+  return createHash7("sha256").update(input).digest("hex");
 }
 function tail(text, max = 400) {
   return text.length > max ? `\u2026${text.slice(text.length - max)}` : text;
@@ -32419,13 +34230,13 @@ var init_engine = __esm({
       }
       async evaluateOne(criterion, scope) {
         const started = this.options.now?.() ?? Date.now();
-        const base = {
+        const base2 = {
           criterionId: criterion.id,
           source: "deterministic-engine",
           evaluatedAt: started
         };
         const done = (patch) => ({
-          ...base,
+          ...base2,
           ...patch,
           durationMs: Math.max(0, (this.options.now?.() ?? Date.now()) - started)
         });
@@ -32649,7 +34460,7 @@ var STRICT_ALL_POLICY, DETERMINISTIC_EVIDENCE_TIERS, STRICT_BUILD_POLICY, strict
 var init_completionPolicy = __esm({
   "packages/core/dist/verification/completionPolicy.js"() {
     "use strict";
-    init_types9();
+    init_types11();
     STRICT_ALL_POLICY = { mode: "strict", required: "*" };
     DETERMINISTIC_EVIDENCE_TIERS = [
       "tool-output",
@@ -32922,9 +34733,9 @@ var init_verifier = __esm({
       /** Review a claimed completion. Degrades to a declared discrete fallback. */
       async reviewCompletion(request) {
         const effective = this.effectiveModel(request.session);
-        const base = { effectiveModel: effective, usedLogprobs: false };
+        const base2 = { effectiveModel: effective, usedLogprobs: false };
         if (!this.config.enabled) {
-          return { ...base, verdict: "unknown", fallback: "discrete", rationale: "verifier disabled" };
+          return { ...base2, verdict: "unknown", fallback: "discrete", rationale: "verifier disabled" };
         }
         let response;
         try {
@@ -32941,7 +34752,7 @@ var init_verifier = __esm({
           });
         } catch (err) {
           const review2 = {
-            ...base,
+            ...base2,
             verdict: "unknown",
             fallback: "discrete",
             rationale: `verifier call failed: ${err instanceof Error ? err.message : String(err)}`
@@ -32952,7 +34763,7 @@ var init_verifier = __esm({
         const parsed = ReviewOutputSchema.safeParse(extractJson(response.text));
         if (!parsed.success) {
           const review2 = {
-            ...base,
+            ...base2,
             verdict: "unknown",
             fallback: "discrete",
             rationale: "verifier output unparseable \u2014 declared discrete fallback",
@@ -32967,7 +34778,7 @@ var init_verifier = __esm({
         }
         const blockedByDeterministic = request.results.some((r) => r.status === "fail" && parsed.data.verdict === "confirmed");
         const review = {
-          ...base,
+          ...base2,
           verdict: blockedByDeterministic ? "unknown" : parsed.data.verdict,
           score: parsed.data.score,
           rationale: blockedByDeterministic ? "cannot confirm while a deterministic check failed \u2014 downgraded to unknown" : parsed.data.rationale,
@@ -33141,7 +34952,7 @@ __export(verification_exports, {
 var init_verification2 = __esm({
   "packages/core/dist/verification/index.js"() {
     "use strict";
-    init_types9();
+    init_types11();
     init_engine();
     init_completionPolicy();
     init_sessionEvidence();
@@ -33216,12 +35027,12 @@ function requiredBlockers(progress) {
 }
 function evaluateMissionContinuation(input) {
   const { progress, verifier, budget, userSteer } = input;
-  const base = { goalRewrite: false, doneByScore: false };
+  const base2 = { goalRewrite: false, doneByScore: false };
   const trend = verifier ? { tier: verifier.tier, value: verifier.value } : void 0;
   const blockers = requiredBlockers(progress);
   if (userSteer === "stop") {
     return {
-      ...base,
+      ...base2,
       recommendation: "wind-down",
       rationale: "user steer: explicit stop \u2014 winding down without claiming done",
       blockers,
@@ -33230,7 +35041,7 @@ function evaluateMissionContinuation(input) {
   }
   if (userSteer === "continue") {
     return {
-      ...base,
+      ...base2,
       recommendation: "continue",
       rationale: "user steer: explicit continue \u2014 overrides any trend-derived advice",
       blockers,
@@ -33239,7 +35050,7 @@ function evaluateMissionContinuation(input) {
   }
   if (budget && budget.iterationsUsed >= budget.iterationsMax) {
     return {
-      ...base,
+      ...base2,
       recommendation: "hold-for-user",
       rationale: `iteration budget exhausted (${budget.iterationsUsed}/${budget.iterationsMax}) \u2014 operator decides: raise budget or hand off`,
       blockers,
@@ -33249,7 +35060,7 @@ function evaluateMissionContinuation(input) {
   if (blockers.length > 0) {
     const trendNote = verifier ? ` \xB7 verifier trend recorded as context only (tier ${verifier.tier}${verifier.value === null ? "" : `, ${verifier.value.toFixed(2)}`}) \u2014 trend is never authority` : "";
     return {
-      ...base,
+      ...base2,
       recommendation: "continue",
       rationale: `required criteria incomplete \u2192 no early-stop${trendNote}`,
       blockers,
@@ -33260,7 +35071,7 @@ function evaluateMissionContinuation(input) {
   const rejected = verifier?.verdict === "rejected" || blended !== null && blended <= REJECTED_BLEND;
   if (rejected) {
     return {
-      ...base,
+      ...base2,
       recommendation: "hold-for-user",
       rationale: "deterministic evidence is complete and PASSing, but the verifier flags risk \u2014 attention requested; the deterministic verdict stands untouched",
       blockers: [],
@@ -33269,7 +35080,7 @@ function evaluateMissionContinuation(input) {
   }
   const confirmed = verifier?.verdict === "confirmed" || blended !== null && blended >= CONFIRMED_BLEND;
   return {
-    ...base,
+    ...base2,
     recommendation: "wind-down",
     rationale: confirmed ? "required criteria pass with evidence and the verifier confirms \u2014 candidate done (final say: driver + CompletionPolicy)" : "required criteria pass with evidence \u2014 candidate done on deterministic evidence (final say: driver + CompletionPolicy)",
     blockers: [],
@@ -33287,14 +35098,14 @@ var init_continuationPolicy = __esm({
 
 // packages/core/dist/mission/budgetContinuation.js
 function evaluateBudgetContinuation(input) {
-  const base = { passByBudget: false };
+  const base2 = { passByBudget: false };
   const { verdict, budget, pressure, latestGapKey, repairHistory } = input;
   if (verdict === "PASS") {
-    return { ...base, decision: "complete", rationale: "deterministic PASS \u2014 complete without spending residual budget" };
+    return { ...base2, decision: "complete", rationale: "deterministic PASS \u2014 complete without spending residual budget" };
   }
   if (pressure === "critical" && budget.toolCalls.remaining <= budget.reserve.verification) {
     return {
-      ...base,
+      ...base2,
       decision: "hold",
       rationale: `critical pressure (${budget.toolCalls.remaining}/${budget.toolCalls.limit} left, reserve ${budget.reserve.verification} protected) \u2014 hold for operator instead of a doomed repair`
     };
@@ -33303,11 +35114,11 @@ function evaluateBudgetContinuation(input) {
   if (sameGapRepairs >= MAX_SAME_GAP_REPAIRS) {
     const canPivot = budget.toolCalls.remaining - budget.reserve.verification >= 3;
     return canPivot ? {
-      ...base,
+      ...base2,
       decision: "pivot",
       rationale: `gap "${latestGapKey}" unchanged after ${sameGapRepairs} repairs \u2014 pivot approach while budget remains`
     } : {
-      ...base,
+      ...base2,
       decision: "hold",
       rationale: `gap "${latestGapKey}" unchanged after ${sameGapRepairs} repairs and no headroom to pivot \u2014 hold`
     };
@@ -33315,19 +35126,19 @@ function evaluateBudgetContinuation(input) {
   const repairHeadroom = budget.toolCalls.remaining - budget.reserve.verification;
   if (repairHeadroom > 0) {
     return {
-      ...base,
+      ...base2,
       decision: "repair",
       rationale: `${repairHeadroom} spendable tool calls (pressure ${pressure}) \u2014 targeted repair on the known gap`
     };
   }
   if (budget.toolCalls.remaining > 0) {
     return {
-      ...base,
+      ...base2,
       decision: "hold",
       rationale: "only the protected verification reserve remains \u2014 verify/finalize or hold, no further repair"
     };
   }
-  return { ...base, decision: "hold", rationale: "budget exhausted \u2014 hold (BLOCKED, never a false done)" };
+  return { ...base2, decision: "hold", rationale: "budget exhausted \u2014 hold (BLOCKED, never a false done)" };
 }
 var MAX_SAME_GAP_REPAIRS;
 var init_budgetContinuation = __esm({
@@ -33357,7 +35168,7 @@ var init_version = __esm({
 });
 
 // packages/core/dist/runtime/fingerprints.js
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function toolFingerprintHash(tools) {
   const canonical = [...tools].map((t) => ({
     name: t.name,
@@ -33366,7 +35177,7 @@ function toolFingerprintHash(tools) {
     ...t.outputContractVersion !== void 0 ? { outputContractVersion: t.outputContractVersion } : {},
     ...t.capabilityFlags !== void 0 ? { capabilityFlags: [...t.capabilityFlags].sort() } : {}
   })).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
-  return createHash6("sha256").update(stableStringify(canonical)).digest("hex");
+  return createHash8("sha256").update(stableStringify(canonical)).digest("hex");
 }
 function skillFingerprintHash(skills) {
   const canonical = [...skills].map((s) => ({
@@ -33374,7 +35185,7 @@ function skillFingerprintHash(skills) {
     ...s.version !== void 0 ? { version: s.version } : {},
     ...s.contentDigest !== void 0 ? { contentDigest: s.contentDigest } : {}
   })).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
-  return createHash6("sha256").update(stableStringify(canonical)).digest("hex");
+  return createHash8("sha256").update(stableStringify(canonical)).digest("hex");
 }
 var init_fingerprints = __esm({
   "packages/core/dist/runtime/fingerprints.js"() {
@@ -33405,17 +35216,22 @@ __export(dist_exports, {
   CODING_SKILL_CATALOG: () => CODING_SKILL_CATALOG,
   COLLABORATION_DIRECTIVE: () => COLLABORATION_DIRECTIVE,
   COMPOSITOR_ONLY_PROPS: () => COMPOSITOR_ONLY_PROPS,
+  CONTEXT_POLICY_VERSION: () => CONTEXT_POLICY_VERSION,
+  CONTINUE: () => CONTINUE,
   CORE_VERSION: () => CORE_VERSION,
   COUNCIL_V1: () => COUNCIL_V1,
   CommandCheckSchema: () => CommandCheckSchema,
   CriterionSchema: () => CriterionSchema,
   CriterionSourceSchema: () => CriterionSourceSchema,
+  DEFAULT_CONTEXT_POLICY: () => DEFAULT_CONTEXT_POLICY,
   DEFAULT_MAX_NODES: () => DEFAULT_MAX_NODES,
   DEFAULT_MAX_TENTACLES: () => DEFAULT_MAX_TENTACLES,
   DEFAULT_MEMORY_SCORING_WEIGHTS: () => DEFAULT_MEMORY_SCORING_WEIGHTS,
   DEFAULT_NFR_SPEC: () => DEFAULT_NFR_SPEC,
   DEFAULT_PLAN_TIMEOUT_MS: () => DEFAULT_PLAN_TIMEOUT_MS,
   DEFAULT_PRESSURE_THRESHOLDS: () => DEFAULT_PRESSURE_THRESHOLDS,
+  DEFAULT_RUN_RETENTION_DAYS: () => DEFAULT_RUN_RETENTION_DAYS,
+  DEFAULT_RUN_RETENTION_MAX_MB: () => DEFAULT_RUN_RETENTION_MAX_MB,
   DEFAULT_VERIFIER_CONFIG: () => DEFAULT_VERIFIER_CONFIG,
   DEGRADED_RUN_BANNER: () => DEGRADED_RUN_BANNER,
   DESIGN_PHASE_MODE_BANNER: () => DESIGN_PHASE_MODE_BANNER,
@@ -33426,12 +35242,15 @@ __export(dist_exports, {
   DefaultMemorySanitizer: () => DefaultMemorySanitizer,
   DefaultMemoryService: () => DefaultMemoryService,
   DeterministicCheckSchema: () => DeterministicCheckSchema,
+  DuplicateSearchGuard: () => DuplicateSearchGuard,
   EPHEMERAL_TAIL_EVENT_KINDS: () => EPHEMERAL_TAIL_EVENT_KINDS,
   EVENT_BACKED_EVIDENCE_TIERS: () => EVENT_BACKED_EVIDENCE_TIERS,
   EXPERIMENTAL_FLAGS: () => EXPERIMENTAL_FLAGS,
   EventBus: () => EventBus,
   EvidenceRefSchema: () => EvidenceRefSchema,
   EvidenceTierSchema: () => EvidenceTierSchema,
+  FILE_WRITING_TOOLS: () => FILE_WRITING_TOOLS,
+  FailureSignatureGuard: () => FailureSignatureGuard,
   FileAbsentCheckSchema: () => FileAbsentCheckSchema,
   FileContainsCheckSchema: () => FileContainsCheckSchema,
   FileExistsCheckSchema: () => FileExistsCheckSchema,
@@ -33442,10 +35261,14 @@ __export(dist_exports, {
   IMPLEMENTATION_IMPLEMENTER_BANNER: () => IMPLEMENTATION_IMPLEMENTER_BANNER,
   IMPLEMENTATION_MODE_BANNER: () => IMPLEMENTATION_MODE_BANNER,
   IMPLEMENTATION_WRITE_REQUIREMENTS: () => IMPLEMENTATION_WRITE_REQUIREMENTS,
+  KRAKEN_EXPLORE_POLICY: () => KRAKEN_EXPLORE_POLICY,
+  KRAKEN_GENERAL_POLICY: () => KRAKEN_GENERAL_POLICY,
   KRAKEN_IDENTITY_MODULE: () => KRAKEN_IDENTITY_MODULE,
   KRAKEN_LEAD_PLAYBOOK_MODULE: () => KRAKEN_LEAD_PLAYBOOK_MODULE,
+  KRAKEN_LEAD_POLICY: () => KRAKEN_LEAD_POLICY,
   KRAKEN_SELECTION_PLAYBOOK_MODULE: () => KRAKEN_SELECTION_PLAYBOOK_MODULE,
   KRAKEN_V1: () => KRAKEN_V1,
+  KRAKEN_VERIFY_POLICY: () => KRAKEN_VERIFY_POLICY,
   LANGUAGE_POLICY_MODULE_TYPE: () => LANGUAGE_POLICY_MODULE_TYPE,
   LATEST_ONLY_SURFACE_KINDS: () => LATEST_ONLY_SURFACE_KINDS,
   LAYOUT_MOTION_PROPS: () => LAYOUT_MOTION_PROPS,
@@ -33479,17 +35302,20 @@ __export(dist_exports, {
   MemorySourceSchema: () => MemorySourceSchema,
   MemoryStatusSchema: () => MemoryStatusSchema,
   MemoryVisibilitySchema: () => MemoryVisibilitySchema,
+  MetricsObserver: () => MetricsObserver,
   ModelSelectionSchema: () => ModelSelectionSchema,
   NATIVE_TOOL_PROTOCOL_MODULE: () => NATIVE_TOOL_PROTOCOL_MODULE,
   NFR_KEYWORDS: () => NFR_KEYWORDS,
   NON_RETRY_AGENTS: () => NON_RETRY_AGENTS,
   NOOP_SUBAGENT_PROVIDER: () => NOOP_SUBAGENT_PROVIDER,
+  NoProgressGuard: () => NoProgressGuard,
   NodeFsProvider: () => NodeFsProvider,
   NodeShellProvider: () => NodeShellProvider,
   NoneCheckSchema: () => NoneCheckSchema,
   NoopMemoryService: () => NoopMemoryService,
   NoopSubagentProvider: () => NoopSubagentProvider,
   OUTPUT_QUALITY_DIRECTIVE: () => OUTPUT_QUALITY_DIRECTIVE,
+  ObserverBus: () => ObserverBus,
   PROFILE_RESOURCE_POLICIES: () => PROFILE_RESOURCE_POLICIES,
   PROMPT_MODULES: () => PROMPT_MODULES,
   PROPRIETARY_REFUSAL_TEXT: () => PROPRIETARY_REFUSAL_TEXT,
@@ -33498,8 +35324,14 @@ __export(dist_exports, {
   PlanError: () => PlanError,
   PressureThresholdsSchema: () => PressureThresholdsSchema,
   ProfileSchema: () => ProfileSchema,
+  REDACTED: () => REDACTED,
+  ReasoningWatchdog: () => ReasoningWatchdog,
+  RepetitionGuard: () => RepetitionGuard,
   ResourcePolicySchema: () => ResourcePolicySchema,
   ResourceStageSchema: () => ResourceStageSchema,
+  RunRecorder: () => RunRecorder,
+  RuntimeControlQueue: () => RuntimeControlQueue,
+  SEARCH_TOOLS: () => SEARCH_TOOLS,
   SESSION_EVENT_KINDS: () => SESSION_EVENT_KINDS,
   SESSION_EXPORT_FORMAT: () => SESSION_EXPORT_FORMAT,
   SESSION_EXPORT_VERSION: () => SESSION_EXPORT_VERSION,
@@ -33517,6 +35349,7 @@ __export(dist_exports, {
   SessionLogLockedError: () => SessionLogLockedError,
   SessionLogWriter: () => SessionLogWriter,
   SessionStore: () => SessionStore,
+  SteeringObserver: () => SteeringObserver,
   TERMINAL_STATUSES: () => TERMINAL_STATUSES,
   TEXT_LOOP_RECOVERY_SYSTEM: () => TEXT_LOOP_RECOVERY_SYSTEM,
   TEXT_LOOP_RECOVERY_USER_PROMPT: () => TEXT_LOOP_RECOVERY_USER_PROMPT,
@@ -33528,6 +35361,7 @@ __export(dist_exports, {
   TaskContractConflictError: () => TaskContractConflictError,
   TaskContractSchema: () => TaskContractSchema,
   TaskCriterionSchema: () => TaskCriterionSchema,
+  TraceObserver: () => TraceObserver,
   UnknownMemberError: () => UnknownMemberError,
   UnknownProfileError: () => UnknownProfileError,
   VAULT_TOOL_DEFINITIONS: () => VAULT_TOOL_DEFINITIONS,
@@ -33566,6 +35400,7 @@ __export(dist_exports, {
   buildMotionFixPrompt: () => buildMotionFixPrompt,
   buildProjection: () => buildProjection,
   buildRetryPrompt: () => buildRetryPrompt,
+  buildRuntimeObserverBus: () => buildRuntimeObserverBus,
   buildSkillDefinition: () => buildSkillDefinition,
   buildSystemPrompt: () => buildSystemPrompt,
   buildSystemPromptSplit: () => buildSystemPromptSplit,
@@ -33590,10 +35425,12 @@ __export(dist_exports, {
   codingCriteriaPack: () => codingCriteriaPack,
   collapseLoopedAssistantText: () => collapseLoopedAssistantText,
   compareReplayPrefix: () => compareReplayPrefix,
+  composeObservers: () => composeObservers,
   computeAgentSkills: () => computeAgentSkills,
   computeAgentTools: () => computeAgentTools,
   computeBudget: () => computeBudget,
   computeFalseDoneRate: () => computeFalseDoneRate,
+  contextPolicyForRole: () => contextPolicyForRole,
   contractToCompactionFields: () => contractToCompactionFields,
   costPerVerifiedSolve: () => costPerVerifiedSolve,
   councilModeBanner: () => councilModeBanner,
@@ -33605,6 +35442,7 @@ __export(dist_exports, {
   createDefaultSystemPromptConfig: () => createDefaultSystemPromptConfig,
   createExecutionContext: () => createExecutionContext,
   createGraph: () => createGraph,
+  createRecorderObserver: () => createRecorderObserver,
   createRoutedRequestSnapshot: () => createRoutedRequestSnapshot,
   defaultPersonaParse: () => defaultPersonaParse,
   defaultResourcePolicy: () => defaultResourcePolicy,
@@ -33620,6 +35458,7 @@ __export(dist_exports, {
   disjointScopeSets: () => disjointScopeSets,
   emptyContextGrowthStats: () => emptyContextGrowthStats,
   enforceDesignPhaseToolEmissions: () => enforceDesignPhaseToolEmissions,
+  enforceRunRetention: () => enforceRunRetention,
   evaluateBudgetContinuation: () => evaluateBudgetContinuation,
   evaluateCompletion: () => evaluateCompletion,
   evaluateMissionContinuation: () => evaluateMissionContinuation,
@@ -33629,6 +35468,7 @@ __export(dist_exports, {
   exportSessionJson: () => exportSessionJson,
   extractCitations: () => extractCitations,
   extractRequirementsBlock: () => extractRequirementsBlock,
+  extractSearchQuery: () => extractSearchQuery,
   extractTaskScope: () => extractTaskScope,
   failedNodeIds: () => failedNodeIds,
   filterByWeakness: () => filterByWeakness,
@@ -33685,15 +35525,19 @@ __export(dist_exports, {
   isBrainToolExecutionEndEvent: () => isBrainToolExecutionEndEvent,
   isBrainToolExecutionStartEvent: () => isBrainToolExecutionStartEvent,
   isBrainToolExecutionUpdateEvent: () => isBrainToolExecutionUpdateEvent,
+  isCancelControlEvent: () => isCancelControlEvent,
   isConverged: () => isConverged,
   isEventBackedEvidence: () => isEventBackedEvidence,
   isExperimentalEnabled: () => isExperimentalEnabled,
+  isFollowUpControlEvent: () => isFollowUpControlEvent,
   isGeneratedPath: () => isGeneratedPath,
   isModelSurfaceEvent: () => isModelSurfaceEvent,
   isReviewerKind: () => isReviewerKind,
+  isSearchTool: () => isSearchTool,
   isSeqShadowed: () => isSeqShadowed,
   isSettled: () => isSettled,
   isStatusTheaterUnit: () => isStatusTheaterUnit,
+  isSteerControlEvent: () => isSteerControlEvent,
   isValidTool: () => isValidTool,
   isVerificationReserveProtected: () => isVerificationReserveProtected,
   isVerifyToolCheckSkipped: () => isVerifyToolCheckSkipped,
@@ -33713,15 +35557,19 @@ __export(dist_exports, {
   memorySimilarity: () => memorySimilarity,
   memoryTokens: () => memoryTokens,
   missionSnapshot: () => missionSnapshot,
+  newRunId: () => newRunId,
+  normalizeFailureTail: () => normalizeFailureTail,
   normalizeForSignature: () => normalizeForSignature,
   normalizeLoopUnit: () => normalizeLoopUnit,
   normalizeMemoryContent: () => normalizeMemoryContent,
+  normalizeQuery: () => normalizeQuery,
   normalizeScopePath: () => normalizeScopePath,
   normalizeTags: () => normalizeTags,
   normalizeTextToolArgs: () => normalizeTextToolArgs,
   normalizeToolName: () => normalizeToolName,
   normalizedMemoryKey: () => normalizedMemoryKey,
   pairToolCalls: () => pairToolCalls,
+  parentContextForRole: () => parentContextForRole,
   parseClarificationRequest: () => parseClarificationRequest,
   parseCompactedEvent: () => parseCompactedEvent,
   parseEvidenceTier: () => parseEvidenceTier,
@@ -33737,7 +35585,9 @@ __export(dist_exports, {
   pathsOverlap: () => pathsOverlap,
   pickWeakest: () => pickWeakest,
   profileHash: () => profileHash,
+  projectContext: () => projectContext,
   promoteMember: () => promoteMember,
+  queryJaccard: () => queryJaccard,
   rankByWeakness: () => rankByWeakness,
   rankMemoryCandidates: () => rankMemoryCandidates,
   readLessonsDeduped: () => readLessonsDeduped,
@@ -33748,14 +35598,19 @@ __export(dist_exports, {
   recordRequest: () => recordRequest,
   recordToolResult: () => recordToolResult,
   recordUsage: () => recordUsage,
+  redactRuntimePayload: () => redactRuntimePayload,
+  redactString: () => redactString,
   registerCodingSkill: () => registerCodingSkill,
   registerCustomTool: () => registerCustomTool,
   registerPersona: () => registerPersona,
   registerSkill: () => registerSkill,
+  renderHistoryDigest: () => renderHistoryDigest,
   renderSkillMarkdown: () => renderSkillMarkdown,
+  renderSteers: () => renderSteers,
   replayChairmanTextTools: () => replayChairmanTextTools,
   resolveAgentSkills: () => resolveAgentSkills,
   resolveCouncilRunMode: () => resolveCouncilRunMode,
+  resolveInterventions: () => resolveInterventions,
   resolveJailed: () => resolveJailed,
   resolveMaxTentacles: () => resolveMaxTentacles,
   resolvePlanTimeoutMs: () => resolvePlanTimeoutMs,
@@ -33776,7 +35631,10 @@ __export(dist_exports, {
   runImplementationVerification: () => runImplementationVerification,
   runInSandbox: () => runInSandbox,
   runMicroVerificationOnFile: () => runMicroVerificationOnFile,
+  runRecordEnabled: () => runRecordEnabled,
+  runRetentionFromEnv: () => runRetentionFromEnv,
   runRetryTurnForMember: () => runRetryTurnForMember,
+  runtimeObserversEnabled: () => runtimeObserversEnabled,
   sanitizeMemoryMetadata: () => sanitizeMemoryMetadata,
   scanForFootguns: () => scanForFootguns,
   scanKeyframesViolations: () => scanKeyframesViolations,
@@ -33795,12 +35653,14 @@ __export(dist_exports, {
   specificityFromAssumptions: () => specificityFromAssumptions,
   stableStringify: () => stableStringify,
   strictBuildGate: () => strictBuildGate,
+  stripAnsi: () => stripAnsi,
   stripClarificationProtocol: () => stripClarificationProtocol,
   swapMembers: () => swapMembers,
   systemMessagesFromSplit: () => systemMessagesFromSplit,
   taskMatchesNfrKeywords: () => taskMatchesNfrKeywords,
   tierAtLeast: () => tierAtLeast,
   tokenizeForSignature: () => tokenizeForSignature,
+  toolCallFingerprint: () => toolCallFingerprint,
   toolFingerprintHash: () => toolFingerprintHash,
   toolManifestHash: () => toolManifestHash,
   toolMatches: () => toolMatches,
@@ -33837,6 +35697,7 @@ var init_dist = __esm({
     init_kraken();
     init_session();
     init_runtime2();
+    init_context3();
     init_verification2();
     init_mission2();
     init_experimental();
@@ -33902,8 +35763,8 @@ function formatKrakenGraphDigest(graph, opts = {}) {
     if (!n) continue;
     const took = durations[id3] !== void 0 ? `, ${formatDuration2(durations[id3])}` : "";
     const detail = n.status === "error" ? n.error : n.result;
-    const firstLine2 = (detail ?? "").trim().split("\n")[0] ?? "";
-    const body = firstLine2.length > maxChars ? `${firstLine2.slice(0, maxChars)}\u2026` : firstLine2;
+    const firstLine3 = (detail ?? "").trim().split("\n")[0] ?? "";
+    const body = firstLine3.length > maxChars ? `${firstLine3.slice(0, maxChars)}\u2026` : firstLine3;
     lines.push(
       `[${STATUS_ICON[n.status]}] ${n.id} (${n.kind}${took})${body ? ` \u2014 ${body}` : ""}`
     );
@@ -35561,18 +37422,18 @@ var init_observationStore = __esm({
 });
 
 // packages/core/dist/core/tools/toolOutputSpill.js
-import { createHash as createHash7, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash9, randomBytes as randomBytes3 } from "node:crypto";
 import { existsSync as existsSync13, mkdirSync as mkdirSync6, writeFileSync as writeFileSync11 } from "node:fs";
 import { homedir as homedir3, tmpdir } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join14 } from "node:path";
 function resolveToolOutputDir() {
   const fromEnv = process.env.ZELARI_TOOL_OUTPUT_DIR?.trim();
   if (fromEnv)
     return fromEnv;
   try {
-    return join11(homedir3(), ".tmp", "zelari-code", "tool-output");
+    return join14(homedir3(), ".tmp", "zelari-code", "tool-output");
   } catch {
-    return join11(tmpdir(), "zelari-code", "tool-output");
+    return join14(tmpdir(), "zelari-code", "tool-output");
   }
 }
 function isToolSpillEnabled() {
@@ -35591,12 +37452,12 @@ function spillToolOutput(fullText, meta3) {
     if (!existsSync13(dir)) {
       mkdirSync6(dir, { recursive: true });
     }
-    const hash3 = createHash7("sha256").update(fullText).digest("hex").slice(0, 12);
+    const hash3 = createHash9("sha256").update(fullText).digest("hex").slice(0, 12);
     const stamp = Date.now().toString(36);
-    const rnd = randomBytes2(3).toString("hex");
+    const rnd = randomBytes3(3).toString("hex");
     const safeTool = (meta3?.toolName ?? "tool").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
     const file2 = `${stamp}-${safeTool}-${hash3}-${rnd}.txt`;
-    const path72 = join11(dir, file2);
+    const path72 = join14(dir, file2);
     writeFileSync11(path72, fullText, "utf8");
     return path72;
   } catch {
@@ -36308,7 +38169,7 @@ import { execFile as execFile2 } from "node:child_process";
 import { existsSync as existsSync16, mkdirSync as mkdirSync8, rmSync } from "node:fs";
 import path29 from "node:path";
 import { promisify } from "node:util";
-import { randomBytes as randomBytes3 } from "node:crypto";
+import { randomBytes as randomBytes4 } from "node:crypto";
 function isKrakenWorktreeEnabled(env = process.env) {
   const v = (env.ZELARI_KRAKEN_WORKTREE ?? "").trim().toLowerCase();
   return v === "1" || v === "true" || v === "yes" || v === "on";
@@ -36351,7 +38212,7 @@ async function createKrakenWorktree(cwd, label) {
   if (!repoRoot) return null;
   const head = await git2(repoRoot, ["rev-parse", "HEAD"]);
   const baseSha = head.ok ? head.stdout.trim() : void 0;
-  const id3 = `${Date.now().toString(36)}-${randomBytes3(3).toString("hex")}`;
+  const id3 = `${Date.now().toString(36)}-${randomBytes4(3).toString("hex")}`;
   const slug = (label ?? "task").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 24) || "task";
   const branch = `kraken/${slug}-${id3}`;
   const wtRoot = path29.join(repoRoot, ".zelari", "worktrees");
@@ -36862,6 +38723,7 @@ var init_metrics2 = __esm({
 });
 
 // src/cli/tools/taskTool.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
 function resetTaskSpawnCount() {
   const g = globalThis;
   g.__zelariTaskSpawnCount = 0;
@@ -36958,6 +38820,9 @@ async function runSubAgent(harness, opts = {}) {
           ...toolTrace.length > 0 ? { toolTrace } : {}
         };
       }
+      if (opts.onEvent && (ev.type === "agent_start" || ev.type === "agent_end" || ev.type === "tool_execution_start" || ev.type === "tool_execution_update" || ev.type === "tool_execution_end")) {
+        opts.onEvent(ev);
+      }
       if (ev.type === "tool_execution_start") {
         pendingTools.set(ev.toolCallId, { tool: ev.toolName, command: toolCommandHint(ev.args) });
       } else if (ev.type === "tool_execution_end") {
@@ -37044,6 +38909,20 @@ async function runTentacle(opts) {
     ...opts.graphId ? { graphId: opts.graphId } : {},
     ...opts.nodeId ? { nodeId: opts.nodeId } : {}
   });
+  const emitActivity = (ev) => {
+    deps.onTentacleEvent?.({ ...ev, id: randomUUID2(), sessionId: sessionId2 });
+  };
+  const endTentacle = (id3, info) => {
+    krakenTentacleEnd(id3, info);
+    emitActivity({
+      type: "agent_ended",
+      agentId: id3,
+      reason: info.detail ?? (info.ok === false ? "failed" : "completed"),
+      ok: info.ok !== false,
+      durationMs: info.durationMs ?? 0,
+      ts: Date.now()
+    });
+  };
   let sub;
   try {
     sub = await deps.createSubAgentContext({
@@ -37061,7 +38940,7 @@ async function runTentacle(opts) {
       ok: false,
       durationMs: Date.now() - started
     });
-    krakenTentacleEnd(liveId, { ok: false, durationMs: Date.now() - started });
+    endTentacle(liveId, { ok: false, durationMs: Date.now() - started });
     return {
       ok: false,
       agent,
@@ -37078,18 +38957,34 @@ async function runTentacle(opts) {
       ok: false,
       durationMs: Date.now() - started
     });
-    krakenTentacleEnd(liveId, { ok: false, durationMs: Date.now() - started });
+    endTentacle(liveId, { ok: false, durationMs: Date.now() - started });
     return {
       ok: false,
       agent,
       error: "task: no provider configured for the sub-agent (set an API key / run /login)."
     };
   }
-  const userContent = buildTaskUserPrompt({
+  emitActivity({
+    type: "agent_spawned",
+    agentId: liveId,
+    role: agent,
+    title: args.description,
+    ...sub.model ? { model: sub.model } : {},
+    ...sub.provider ? { provider: sub.provider } : {},
+    ...args.scope && args.scope.length > 0 ? { scope: args.scope } : {},
+    ...worktree ? { worktree: worktree.path } : {},
+    ts: Date.now()
+  });
+  emitActivity({ type: "agent_status", agentId: liveId, status: "running", ts: Date.now() });
+  const taskUserContent = buildTaskUserPrompt({
     prompt: args.prompt,
     scope: args.scope,
     acceptance: withKrakenRequiredChecks(agent, args.acceptance)
   });
+  const parentBlock = parentContextForRole(agent, opts.parentTranscript ?? []);
+  const userContent = parentBlock ? `${parentBlock.block}
+
+${taskUserContent}` : taskUserContent;
   const maxToolCalls = maxToolCallsForThoroughness(thoroughness, agent);
   const runCwd = sub.cwd || effectiveCwd;
   const config2 = {
@@ -37112,7 +39007,7 @@ async function runTentacle(opts) {
     ...deps.memoryService ? {
       memoryService: deps.memoryService,
       memoryQuery: `${args.description}
-${userContent}`,
+${taskUserContent}`,
       memoryContextChars: 2400
     } : {}
   };
@@ -37126,15 +39021,24 @@ ${userContent}`,
     }
   } catch (err) {
     if (worktree) await cleanupKrakenWorktree(worktree);
-    krakenTentacleEnd(liveId, { ok: false, durationMs: Date.now() - started });
+    endTentacle(liveId, { ok: false, durationMs: Date.now() - started });
     return {
       ok: false,
       agent,
       error: `task: failed to start sub-agent \u2014 ${err instanceof Error ? err.message : String(err)}`
     };
   }
+  const startedTools = /* @__PURE__ */ new Map();
   const { result, error: error51, aborted: aborted2, usage, toolTrace } = await runSubAgent(harness, {
-    ...opts.signal ? { signal: opts.signal } : {}
+    ...opts.signal ? { signal: opts.signal } : {},
+    onEvent: (ev) => {
+      if (ev.type === "tool_execution_start") {
+        startedTools.set(ev.toolCallId, ev.toolName);
+        emitActivity({ type: "agent_tool", agentId: liveId, toolCallId: ev.toolCallId, tool: ev.toolName, status: "started", ...ev.args ? { summary: toolCommandHint(ev.args) } : {}, ts: Date.now() });
+      } else if (ev.type === "tool_execution_end") {
+        emitActivity({ type: "agent_tool", agentId: liveId, toolCallId: ev.toolCallId, tool: startedTools.get(ev.toolCallId) ?? "unknown", status: ev.isError ? "failed" : "completed", durationMs: ev.durationMs, ts: Date.now() });
+      }
+    }
   });
   const durationMs = Date.now() - started;
   if (aborted2) {
@@ -37150,7 +39054,7 @@ ${userContent}`,
       durationMs,
       ok: false
     });
-    krakenTentacleEnd(liveId, {
+    endTentacle(liveId, {
       ok: false,
       model: sub.model,
       detail: "cancelled",
@@ -37171,7 +39075,7 @@ ${userContent}`,
       durationMs,
       ok: false
     });
-    krakenTentacleEnd(liveId, { ok: false, model: sub.model, detail: error51, durationMs });
+    endTentacle(liveId, { ok: false, model: sub.model, detail: error51, durationMs });
     return {
       ok: false,
       agent,
@@ -37210,7 +39114,7 @@ ${formatWorktreeFooter(worktree, { kept, merge: merge2 })}`;
 ${verifyHintForGeneral(args.acceptance)}`;
     g.__zelariLastGeneralAt = Date.now();
   }
-  krakenTentacleEnd(liveId, {
+  endTentacle(liveId, {
     ok: true,
     model: sub.model,
     detail: result.slice(0, 160),
@@ -37393,6 +39297,7 @@ var init_taskTool = __esm({
   "src/cli/tools/taskTool.ts"() {
     "use strict";
     init_zod();
+    init_context3();
     init_toolTypes();
     init_krakenRadio();
     init_krakenWorktree();
@@ -37849,14 +39754,14 @@ var init_askUser = __esm({
 
 // src/cli/skillsMd.ts
 import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync15 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join15 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function skillMdSearchDirs(projectRoot = process.cwd()) {
   return [
-    join12(projectRoot, ".zelari", "skills"),
-    join12(projectRoot, ".claude", "skills"),
-    join12(projectRoot, ".opencode", "skills"),
-    join12(homedir4(), ".zelari-code", "skills")
+    join15(projectRoot, ".zelari", "skills"),
+    join15(projectRoot, ".claude", "skills"),
+    join15(projectRoot, ".opencode", "skills"),
+    join15(homedir4(), ".zelari-code", "skills")
   ];
 }
 function parseSkillMd(content, sourcePath) {
@@ -37922,7 +39827,7 @@ function loadSkillMdSkills(projectRoot = process.cwd(), options = {}) {
       continue;
     }
     for (const entry of entries) {
-      const skillPath = join12(dir, entry, "SKILL.md");
+      const skillPath = join15(dir, entry, "SKILL.md");
       if (!existsSync17(skillPath)) continue;
       try {
         const parsed = parseSkillMd(readFileSync15(skillPath, "utf8"), skillPath);
@@ -38103,13 +40008,13 @@ import {
   constants,
   realpathSync
 } from "node:fs";
-import { join as join13, basename } from "node:path";
+import { join as join16, basename } from "node:path";
 import { homedir as homedir5 } from "node:os";
-import { createHash as createHash8 } from "node:crypto";
+import { createHash as createHash10 } from "node:crypto";
 function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   const candidates = [
-    join13(projectRoot, ".zelari"),
-    join13(homedir5(), ".zelari-code", "workspace", hashProject(projectRoot))
+    join16(projectRoot, ".zelari"),
+    join16(homedir5(), ".zelari-code", "workspace", hashProject(projectRoot))
   ];
   for (const candidate of candidates) {
     if (isWritableDir(projectRoot) || candidate !== candidates[0]) {
@@ -38121,7 +40026,7 @@ function resolveWorkspaceRoot(projectRoot = process.cwd()) {
   return candidates[0];
 }
 function hashProject(projectPath) {
-  return createHash8("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
+  return createHash10("sha1").update(realpathSync(projectPath)).digest("hex").slice(0, 12);
 }
 function isWritableDir(dir) {
   try {
@@ -38134,8 +40039,8 @@ function isWritableDir(dir) {
 }
 function ensureWorkspaceDir(workspaceDir) {
   mkdirSync9(workspaceDir, { recursive: true });
-  if (workspaceDir.endsWith("/.zelari") && existsSync18(join13(workspaceDir, "..", ".git"))) {
-    const gitignorePath = join13(workspaceDir, ".gitignore");
+  if (workspaceDir.endsWith("/.zelari") && existsSync18(join16(workspaceDir, "..", ".git"))) {
+    const gitignorePath = join16(workspaceDir, ".gitignore");
     if (!existsSync18(gitignorePath)) {
       writeFileSync12(gitignorePath, "*\n!.gitignore\n");
     }
@@ -38144,15 +40049,15 @@ function ensureWorkspaceDir(workspaceDir) {
 function workspaceFile(rootDir, kind2) {
   switch (kind2) {
     case "plan":
-      return join13(rootDir, "plan.md");
+      return join16(rootDir, "plan.md");
     case "risks":
-      return join13(rootDir, "risks.md");
+      return join16(rootDir, "risks.md");
     case "index":
-      return join13(rootDir, "workspace.json");
+      return join16(rootDir, "workspace.json");
   }
 }
 function workspaceArtifact(rootDir, subdir, slug) {
-  return join13(rootDir, subdir, `${slug}.md`);
+  return join16(rootDir, subdir, `${slug}.md`);
 }
 function projectName(projectRoot = process.cwd()) {
   return basename(realpathSync(projectRoot));
@@ -38181,7 +40086,7 @@ import {
   readdirSync as readdirSync4,
   renameSync
 } from "node:fs";
-import { dirname as dirname2, join as join14 } from "node:path";
+import { dirname as dirname2, join as join17 } from "node:path";
 function parseFrontmatter(md) {
   const m = FRONTMATTER_RE.exec(md);
   if (!m) return { meta: {}, body: md };
@@ -38461,7 +40366,7 @@ var init_storage = __esm({
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
         if (!existsSync19(dir)) return [];
-        return readdirSync4(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join14(dir, f));
+        return readdirSync4(dir).filter((f) => f.endsWith(".md") && !f.startsWith(".")).map((f) => join17(dir, f));
       }
     };
     KeyedMutex = class {
@@ -38499,7 +40404,7 @@ import {
   renameSync as renameSync2,
   writeFileSync as writeFileSync14
 } from "node:fs";
-import { dirname as dirname3, join as join15 } from "node:path";
+import { dirname as dirname3, join as join18 } from "node:path";
 async function withPlanStore(projectRoot, fn) {
   const rootDir = resolveWorkspaceRoot(projectRoot);
   return workspaceMutex.run(`${rootDir}:plan`, () => {
@@ -38518,7 +40423,7 @@ function nextPlanTaskId(store6) {
   return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
-  const path72 = join15(rootDir, "plan-tasks", `${task.id}.md`);
+  const path72 = join18(rootDir, "plan-tasks", `${task.id}.md`);
   mkdirSync11(dirname3(path72), { recursive: true });
   const meta3 = {
     kind: "task",
@@ -38543,7 +40448,7 @@ function writePlanTaskArtifact(rootDir, task) {
   new Storage().write(path72, meta3, body);
 }
 function loadHandle(rootDir) {
-  const jsonPath = join15(rootDir, "plan.json");
+  const jsonPath = join18(rootDir, "plan.json");
   if (!existsSync20(jsonPath)) {
     return { rootDir, tasks: [], counter: 0, rootFields: {} };
   }
@@ -38577,7 +40482,7 @@ function saveHandle(rootDir, handle) {
       "PLAN_TOO_MANY_TASKS"
     );
   }
-  const jsonPath = join15(rootDir, "plan.json");
+  const jsonPath = join18(rootDir, "plan.json");
   mkdirSync11(rootDir, { recursive: true });
   if (existsSync20(jsonPath)) {
     copyFileSync(jsonPath, `${jsonPath}.bak`);
@@ -38939,7 +40844,7 @@ var init_inspectTypecheckSafety = __esm({
 
 // src/cli/tools/inspectCommand.ts
 import { spawn as spawn8 } from "node:child_process";
-import { createHash as createHash9 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 import { existsSync as existsSync21, promises as fs16 } from "node:fs";
 import os7 from "node:os";
 import path31 from "node:path";
@@ -39026,7 +40931,7 @@ function buildInspectCommand(op, ctx) {
     }
     case "typecheck": {
       const project = path31.resolve(ctx.cwd, op.project ?? "tsconfig.json");
-      const hash3 = createHash9("sha256").update(project).digest("hex").slice(0, 16);
+      const hash3 = createHash11("sha256").update(project).digest("hex").slice(0, 16);
       const tsBuildInfoFile = path31.join(os7.tmpdir(), "zelari-inspect", `${hash3}.tsbuildinfo`);
       return {
         ok: true,
@@ -40184,7 +42089,7 @@ var init_manager = __esm({
 });
 
 // src/cli/ast/engine.ts
-import { readFile } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 import path33 from "node:path";
 function loadTs() {
   if (!tsPromise) {
@@ -40218,7 +42123,7 @@ async function parseFileSymbolsDiag(file2, cwd) {
   }
   let text;
   try {
-    text = await readFile(resolvedPath, "utf8");
+    text = await readFile2(resolvedPath, "utf8");
   } catch (err) {
     const code = err?.code;
     if (code === "ENOENT") {
@@ -40465,9 +42370,9 @@ var init_store2 = __esm({
 import { promises as fs17, existsSync as existsSync22, readFileSync as readFileSync19 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import path34 from "node:path";
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function getIndexPath(root) {
-  const hash3 = createHash10("sha1").update(path34.resolve(root)).digest("hex").slice(0, 16);
+  const hash3 = createHash12("sha1").update(path34.resolve(root)).digest("hex").slice(0, 16);
   return process.env.ZELARI_SEMANTIC_FILE ?? path34.join(homedir6(), ".tmp", "zelari-code", "semantic", `${hash3}.json`);
 }
 async function collectSourceFiles(root, maxFiles = 1500) {
@@ -41479,10 +43384,10 @@ function asPlaywright(mod) {
   return null;
 }
 async function loadPlaywright(cwd) {
-  const base = cwd && cwd.length > 0 ? path36.resolve(cwd) : void 0;
-  if (base) {
+  const base2 = cwd && cwd.length > 0 ? path36.resolve(cwd) : void 0;
+  if (base2) {
     try {
-      const req = createRequire2(path36.join(base, "package.json"));
+      const req = createRequire2(path36.join(base2, "package.json"));
       const resolved = req.resolve("playwright");
       const mod = await import(pathToFileURL(resolved).href);
       const pw = asPlaywright(mod);
@@ -41533,12 +43438,12 @@ async function runBrowserCheck(options, loader) {
   const pageErrors = [];
   const failedRequests = [];
   const evaluateResults = [];
-  const base = { ok: false, consoleErrors, pageErrors, failedRequests };
+  const base2 = { ok: false, consoleErrors, pageErrors, failedRequests };
   const resolve7 = loader ?? (() => loadPlaywright(options.cwd ?? process.cwd()));
   const pw = await resolve7();
   if (!pw) {
     return {
-      ...base,
+      ...base2,
       error: "browser automation unavailable \u2014 Playwright is not installed in this workspace. Install it with: `zelari-code --plugins-install playwright --cwd .` (or Desktop banner \u201CInstall\u201D, or CLI `/plugins install playwright`, or `npm i -D playwright && npx playwright install chromium`). Then re-run browser_check."
     };
   }
@@ -41678,7 +43583,7 @@ async function runBrowserCheck(options, loader) {
       ...screenshotPath ? { screenshotPath } : {}
     };
   } catch (err) {
-    return { ...base, error: err instanceof Error ? err.message : String(err) };
+    return { ...base2, error: err instanceof Error ? err.message : String(err) };
   } finally {
     try {
       await browser?.close();
@@ -41813,14 +43718,14 @@ import {
   readFileSync as readFileSync20,
   writeFileSync as writeFileSync15
 } from "node:fs";
-import { dirname as dirname4, join as join16 } from "node:path";
+import { dirname as dirname4, join as join19 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 import { spawn as spawn10 } from "node:child_process";
 function getSshTargetsPath() {
-  return join16(homedir7(), ".zelari-code", "ssh-targets.json");
+  return join19(homedir7(), ".zelari-code", "ssh-targets.json");
 }
 function getSshSecretsPath() {
-  return join16(homedir7(), ".zelari-code", "ssh-secrets.json");
+  return join19(homedir7(), ".zelari-code", "ssh-secrets.json");
 }
 function normalizeAuth(auth) {
   if (auth === "keyPath") return "keyPath";
@@ -41993,16 +43898,16 @@ function buildSshBaseArgs(target) {
   return args;
 }
 function ensureAskpassHelper() {
-  const dir = join16(homedir7(), ".zelari-code", "ssh-helpers");
+  const dir = join19(homedir7(), ".zelari-code", "ssh-helpers");
   mkdirSync12(dir, { recursive: true });
-  const cjs = join16(dir, "askpass.cjs");
+  const cjs = join19(dir, "askpass.cjs");
   writeFileSync15(
     cjs,
     "process.stdout.write(process.env.ZELARI_SSH_ASKPASS_PASS || '');\n",
     "utf8"
   );
   if (process.platform === "win32") {
-    const cmd = join16(dir, "askpass.cmd");
+    const cmd = join19(dir, "askpass.cmd");
     writeFileSync15(
       cmd,
       `@echo off\r
@@ -42012,7 +43917,7 @@ node "%~dp0askpass.cjs"\r
     );
     return cmd;
   }
-  const sh = join16(dir, "askpass.sh");
+  const sh = join19(dir, "askpass.sh");
   writeFileSync15(
     sh,
     `#!/bin/sh
@@ -42757,8 +44662,8 @@ function anthropicMessagesProvider(config2) {
       if (t.degraded) console.warn(`[thinking] ${t.note ?? "unsupported"} \u2014 falling back to provider default.`);
       else Object.assign(body, t.patch);
     }
-    const base = config2.baseUrl.replace(/\/$/, "").replace(/\/v1$/, "");
-    const url2 = `${base}/v1/messages`;
+    const base2 = config2.baseUrl.replace(/\/$/, "").replace(/\/v1$/, "");
+    const url2 = `${base2}/v1/messages`;
     let response;
     try {
       response = await fetch(url2, {
@@ -42969,8 +44874,8 @@ function chatgptResponsesProvider(config2) {
       if (t.degraded) console.warn(`[thinking] ${t.note ?? "unsupported"} \u2014 falling back to provider default.`);
       else Object.assign(body, t.patch);
     }
-    const base = config2.baseUrl.replace(/\/$/, "");
-    const url2 = `${base}/responses`;
+    const base2 = config2.baseUrl.replace(/\/$/, "");
+    const url2 = `${base2}/responses`;
     let response;
     try {
       response = await fetch(url2, {
@@ -43293,13 +45198,13 @@ var init_folderTrust = __esm({
 
 // src/cli/safety/lifecycleHooks.ts
 import { homedir as homedir9 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join20 } from "node:path";
 import { readdirSync as readdirSync5, statSync as statSync3 } from "node:fs";
 function globalHooksDir() {
-  return join17(homedir9(), ".zelari-code", "hooks");
+  return join20(homedir9(), ".zelari-code", "hooks");
 }
 function projectHooksDir(projectRoot) {
-  return join17(projectRoot, ".zelari", "hooks");
+  return join20(projectRoot, ".zelari", "hooks");
 }
 function fingerprintHookDirs(dirs) {
   const parts = [];
@@ -43320,7 +45225,7 @@ function fingerprintHookDirs(dirs) {
       continue;
     }
     for (const name of names) {
-      const full = join17(dir, name);
+      const full = join20(dir, name);
       try {
         const st = statSync3(full);
         parts.push(`${full}:${st.mtimeMs}:${st.size}`);
@@ -43361,7 +45266,7 @@ var init_lifecycleHooks = __esm({
 });
 
 // src/cli/toolResultCache.ts
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 import { promises as fs19 } from "node:fs";
 import path40 from "node:path";
 function isToolCacheEnabled() {
@@ -43374,7 +45279,7 @@ function resolveToolCacheTtlMs() {
   return Number.isFinite(n) && n >= 0 ? n : TOOL_CACHE_DEFAULT_TTL_MS;
 }
 function hashKey(parts) {
-  return createHash11("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
+  return createHash13("sha256").update(JSON.stringify(parts), "utf8").digest("hex");
 }
 function resultBytes(result) {
   try {
@@ -43774,7 +45679,8 @@ function createBuiltinToolRegistry(options = {}) {
           ...options.subAgentModel ? { model: options.subAgentModel } : {}
         }),
         ...options.memoryService ? { memoryService: options.memoryService } : {},
-        ...options.memoryAutoWrite !== void 0 ? { memoryAutoWrite: options.memoryAutoWrite } : {}
+        ...options.memoryAutoWrite !== void 0 ? { memoryAutoWrite: options.memoryAutoWrite } : {},
+        ...options.onTentacleEvent ? { onTentacleEvent: options.onTentacleEvent } : {}
       },
       options.planMode === true ? { allowedAgents: ["explore"] } : void 0
     );
@@ -44219,8 +46125,8 @@ var init_metrics3 = __esm({
       maybeRotate() {
         if (!existsSync25(this.file)) return;
         try {
-          const stat = statSync4(this.file);
-          if (stat.size >= METRICS_ROTATE_BYTES) {
+          const stat2 = statSync4(this.file);
+          if (stat2.size >= METRICS_ROTATE_BYTES) {
             const rotated = this.file.replace(/\.jsonl$/, ".1.jsonl");
             renameSync3(this.file, rotated);
           }
@@ -44233,11 +46139,11 @@ var init_metrics3 = __esm({
 });
 
 // src/cli/state/fileStateStore.ts
-import { createHash as createHash13, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash15, randomUUID as randomUUID3 } from "node:crypto";
 import { promises as fs21 } from "node:fs";
 import * as path43 from "node:path";
 function shortId() {
-  return randomUUID2().replace(/-/g, "").slice(0, 12);
+  return randomUUID3().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
   await fs21.mkdir(path43.dirname(filePath), { recursive: true });
@@ -44285,7 +46191,7 @@ async function getStateStore(projectRoot, env = process.env) {
   }
 }
 function hashStablePrompt(stable) {
-  return createHash13("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
+  return createHash15("sha256").update(stable, "utf8").digest("hex").slice(0, 16);
 }
 var DEFAULT_MATERIALIZE_CHARS, FileDurableStateStore, NoopDurableStateStore;
 var init_fileStateStore = __esm({
@@ -44931,9 +46837,9 @@ function compactHistoryDetailed(messages, opts) {
   );
 }
 async function compactHistoryAsync(messages, opts) {
-  const base = compactHistoryDetailed(messages, opts);
-  if (!base.compacted || base.messagesRemoved === 0) return base;
-  const cut = base.messagesRemoved;
+  const base2 = compactHistoryDetailed(messages, opts);
+  if (!base2.compacted || base2.messagesRemoved === 0) return base2;
+  const cut = base2.messagesRemoved;
   const droppedMsgs = messages.slice(0, cut);
   const extractive = extractiveHistorySummary(droppedMsgs);
   let summaryText = extractive;
@@ -45050,7 +46956,7 @@ __export(conversationContext_exports, {
   setLastClarification: () => setLastClarification
 });
 import { existsSync as existsSync26 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join22 } from "node:path";
 function getHistory() {
   return history;
 }
@@ -45059,7 +46965,7 @@ function setHistory(messages) {
   history = projected === messages ? [...messages] : projected;
 }
 function compactInPlace(cwd = process.cwd()) {
-  const durableStatePresent = existsSync26(join19(cwd, ".zelari", "state", "HEAD.json"));
+  const durableStatePresent = existsSync26(join22(cwd, ".zelari", "state", "HEAD.json"));
   history = applySessionSurface(compactHistory(history, { durableStatePresent }));
 }
 function appendMessages(msgs) {
@@ -46102,11 +48008,11 @@ var init_claudeProvider = __esm({
 });
 
 // src/cli/memory/legacyImport.ts
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import { promises as fs22 } from "node:fs";
 import * as path44 from "node:path";
 function sourceId(fact, line) {
-  return `jsonl:${fact.id ?? createHash14("sha256").update(line).digest("hex")}`;
+  return `jsonl:${fact.id ?? createHash16("sha256").update(line).digest("hex")}`;
 }
 function kind(metadata2) {
   const raw = metadata2.memoryKind;
@@ -46604,7 +48510,7 @@ WHERE NOT EXISTS (SELECT 1 FROM memory_fts f WHERE f.node_id = n.id);
 });
 
 // src/cli/memory/sqliteBackend.ts
-import { createHash as createHash15, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash17, randomUUID as randomUUID4 } from "node:crypto";
 import { promises as fs23 } from "node:fs";
 import * as path46 from "node:path";
 function boundedLimit(value, fallback = 50) {
@@ -46619,7 +48525,7 @@ function withOptional(target, key, value) {
   return { ...target, [key]: value };
 }
 function contentHash(content) {
-  return createHash15("sha256").update(content).digest("hex");
+  return createHash17("sha256").update(content).digest("hex");
 }
 var NODE_COLUMNS, INSERT_NODE_SQL, SOURCE_COLUMNS, SQLiteMemoryBackend;
 var init_sqliteBackend = __esm({
@@ -46679,9 +48585,9 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
         const zelariDirectory = path46.join(resolved, ".zelari");
         const directory = path46.join(zelariDirectory, "memory");
         for (const candidate of [zelariDirectory, directory]) {
-          let stat;
+          let stat2;
           try {
-            stat = await fs23.lstat(candidate);
+            stat2 = await fs23.lstat(candidate);
           } catch (error51) {
             if (error51.code !== "ENOENT") throw error51;
             try {
@@ -46689,9 +48595,9 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
             } catch (mkdirError) {
               if (mkdirError.code !== "EEXIST") throw mkdirError;
             }
-            stat = await fs23.lstat(candidate);
+            stat2 = await fs23.lstat(candidate);
           }
-          if (stat.isSymbolicLink() || !stat.isDirectory()) {
+          if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
             throw new Error(`Memory directory is not a real directory: ${candidate}`);
           }
         }
@@ -46727,7 +48633,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
         const createdAt = input.createdAt ?? now;
         const recordedAt = input.recordedAt ?? createdAt;
         const node = MemoryNodeSchema.parse({
-          id: input.id ?? `mem_${randomUUID3()}`,
+          id: input.id ?? `mem_${randomUUID4()}`,
           schemaVersion: 1,
           projectId: input.projectId,
           kind: input.kind,
@@ -46753,7 +48659,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           (version_id, memory_id, revision, snapshot_json, recorded_at, actor, reason)
           VALUES (?, ?, 1, ?, ?, ?, ?)`,
             params: [
-              `ver_${randomUUID3()}`,
+              `ver_${randomUUID4()}`,
               node.id,
               JSON.stringify(node),
               recordedAt,
@@ -46814,7 +48720,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           (version_id, memory_id, revision, snapshot_json, recorded_at, actor, reason)
           VALUES (?, ?, (SELECT COALESCE(MAX(revision), 0) + 1 FROM memory_versions WHERE memory_id=?), ?, ?, ?, ?)`,
             params: [
-              `ver_${randomUUID3()}`,
+              `ver_${randomUUID4()}`,
               updated.id,
               updated.id,
               JSON.stringify(updated),
@@ -47048,7 +48954,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
         if (decoded) return decoded;
         const edge = MemoryEdgeSchema.parse({
           ...input,
-          id: input.id ?? `edge_${randomUUID3()}`,
+          id: input.id ?? `edge_${randomUUID4()}`,
           strength: input.strength ?? 1,
           confidence: input.confidence ?? 0.8,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -47232,7 +49138,7 @@ __export(serviceFactory_exports, {
   isMemorySemanticEnabled: () => isMemorySemanticEnabled,
   isMemoryV2Enabled: () => isMemoryV2Enabled
 });
-import { createHash as createHash16 } from "node:crypto";
+import { createHash as createHash18 } from "node:crypto";
 import { promises as fs24 } from "node:fs";
 import * as path47 from "node:path";
 function isMemoryV2Enabled(env = process.env) {
@@ -47259,7 +49165,7 @@ async function canonicalProjectId(projectRoot) {
   }
   canonical = canonical.replace(/\\/g, "/").replace(/\/$/, "");
   if (process.platform === "win32") canonical = canonical.toLocaleLowerCase("en-US");
-  return `project_${createHash16("sha256").update(canonical).digest("hex").slice(0, 24)}`;
+  return `project_${createHash18("sha256").update(canonical).digest("hex").slice(0, 24)}`;
 }
 async function getMemoryService(projectRoot, env = process.env, options = {}) {
   const projectId2 = await canonicalProjectId(projectRoot);
@@ -47324,10 +49230,10 @@ var init_serviceFactory = __esm({
 
 // src/cli/workspace/projectInstructions.ts
 import { existsSync as existsSync28, readFileSync as readFileSync23 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join26 } from "node:path";
 function loadProjectInstructions(projectRoot = process.cwd(), maxChars = MAX_CHARS) {
   for (const name of CANDIDATES) {
-    const full = join23(projectRoot, name);
+    const full = join26(projectRoot, name);
     if (!existsSync28(full)) continue;
     try {
       let raw = readFileSync23(full, "utf8");
@@ -47375,7 +49281,7 @@ __export(workspaceSummary_exports, {
   buildZelariReadHint: () => buildZelariReadHint
 });
 import { existsSync as existsSync29, readFileSync as readFileSync24, readdirSync as readdirSync6, statSync as statSync5 } from "node:fs";
-import { join as join24, relative as relative2 } from "node:path";
+import { join as join27, relative as relative2 } from "node:path";
 function buildWorkspaceSummary(projectRoot = process.cwd(), options = {}) {
   const { maxEntries = 30, maxChars = 3500, maxDeps = 24, maxScripts = 16 } = options;
   const name = safeProjectName(projectRoot);
@@ -47408,7 +49314,7 @@ function formatTaskLine(t) {
 }
 function buildPlanSummary(projectRoot = process.cwd(), options) {
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  const planPath = join24(zelariRoot, "plan.json");
+  const planPath = join27(zelariRoot, "plan.json");
   if (!existsSync29(planPath)) return null;
   let plan;
   try {
@@ -47551,7 +49457,7 @@ function pickNextTask(open) {
   )[0];
 }
 function buildZelariReadHint(projectRoot = process.cwd()) {
-  const planPath = join24(resolveWorkspaceRoot(projectRoot), "plan.json");
+  const planPath = join27(resolveWorkspaceRoot(projectRoot), "plan.json");
   if (!existsSync29(planPath)) return "";
   return [
     "# Council workspace detected (.zelari/) \u2014 DRAFT vault",
@@ -47567,7 +49473,7 @@ function safeProjectName(root) {
   }
 }
 function readPackageJson(projectRoot) {
-  const p3 = join24(projectRoot, "package.json");
+  const p3 = join27(projectRoot, "package.json");
   if (!existsSync29(p3)) return null;
   try {
     return JSON.parse(readFileSync24(p3, "utf8"));
@@ -47620,11 +49526,11 @@ function listShallow(projectRoot, maxEntries) {
         out.push(`\u2026 (+${top.length - count} more)`);
         break;
       }
-      const rel2 = relative2(projectRoot, join24(projectRoot, entry.name));
+      const rel2 = relative2(projectRoot, join27(projectRoot, entry.name));
       if (entry.isDirectory()) {
         let inner = "";
         try {
-          const sub = readdirSync6(join24(projectRoot, entry.name), {
+          const sub = readdirSync6(join27(projectRoot, entry.name), {
             withFileTypes: true
           }).filter((e) => !e.name.startsWith(".")).slice(0, 4).map((e) => e.name);
           if (sub.length > 0)
@@ -47673,11 +49579,11 @@ var init_workspaceSummary = __esm({
 
 // src/cli/workspace/buildLessonsSummary.ts
 import { existsSync as existsSync30 } from "node:fs";
-import { join as join25 } from "node:path";
+import { join as join28 } from "node:path";
 function buildLessonsSummary(projectRoot = process.cwd(), taskText) {
   if (process.env["ZELARI_LESSONS"] === "0") return null;
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync30(join25(zelariRoot, "lessons.jsonl"))) return null;
+  if (!existsSync30(join28(zelariRoot, "lessons.jsonl"))) return null;
   const lessons = recallLessons(zelariRoot, {
     maxLessons: 5,
     maxBytes: 2048,
@@ -47699,7 +49605,7 @@ __export(composeContext_exports, {
   composeProjectContext: () => composeProjectContext
 });
 import { existsSync as existsSync31, readdirSync as readdirSync7, readFileSync as readFileSync25 } from "node:fs";
-import { join as join26 } from "node:path";
+import { join as join29 } from "node:path";
 function cap2(text, max, label) {
   if (!text || text.length <= max) return { text: text || "", truncated: false };
   return {
@@ -47716,7 +49622,7 @@ function buildDesignIndex(projectRoot, maxChars) {
     "# Design vault index (.zelari/) \u2014 HYPOTHESES only",
     "Full design docs are NOT product source of truth. Open with list_files / read_file / searchDocuments if needed."
   ];
-  const docsDir = join26(root, "docs");
+  const docsDir = join29(root, "docs");
   if (existsSync31(docsDir)) {
     try {
       const docs = readdirSync7(docsDir).filter((n) => n.endsWith(".md")).slice(0, 12);
@@ -47731,11 +49637,11 @@ function buildDesignIndex(projectRoot, maxChars) {
     }
   }
   for (const name of ["risks.md", "plan.json", "nfr-spec.json"]) {
-    if (existsSync31(join26(root, name))) {
+    if (existsSync31(join29(root, name))) {
       lines.push(`- .zelari/${name} present`);
     }
   }
-  const decisionsDir = join26(root, "decisions");
+  const decisionsDir = join29(root, "decisions");
   if (existsSync31(decisionsDir)) {
     try {
       const n = readdirSync7(decisionsDir).filter((f) => f.endsWith(".md")).length;
@@ -47837,14 +49743,14 @@ function composeProjectContext(input) {
 }
 function readDurableHeadSync(projectRoot) {
   try {
-    const headPath = join26(projectRoot, ".zelari", "state", "HEAD.json");
+    const headPath = join29(projectRoot, ".zelari", "state", "HEAD.json");
     if (!existsSync31(headPath)) return "";
     const head = JSON.parse(readFileSync25(headPath, "utf8"));
     if (!head?.id) return "";
-    const metaPath = join26(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
+    const metaPath = join29(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
     if (!existsSync31(metaPath)) return "";
     const meta3 = JSON.parse(readFileSync25(metaPath, "utf8"));
-    const discPath = meta3.artifactDir ? join26(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join26(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
+    const discPath = meta3.artifactDir ? join29(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join29(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
     let discoveries = [];
     if (existsSync31(discPath)) {
       discoveries = JSON.parse(readFileSync25(discPath, "utf8"));
@@ -47881,9 +49787,9 @@ __export(planDetect_exports, {
   hasWorkspacePlan: () => hasWorkspacePlan
 });
 import { existsSync as existsSync32, readFileSync as readFileSync26 } from "node:fs";
-import { join as join27 } from "node:path";
+import { join as join30 } from "node:path";
 function hasWorkspacePlan(projectRoot = process.cwd()) {
-  const planPath = join27(resolveWorkspaceRoot(projectRoot), "plan.json");
+  const planPath = join30(resolveWorkspaceRoot(projectRoot), "plan.json");
   if (!existsSync32(planPath)) return false;
   try {
     const parsed = JSON.parse(readFileSync26(planPath, "utf8"));
@@ -47952,7 +49858,7 @@ import {
   mkdirSync as mkdirSync15,
   renameSync as renameSync4
 } from "node:fs";
-import { join as join28, basename as basename3, dirname as dirname8, relative as relative3 } from "node:path";
+import { join as join31, basename as basename3, dirname as dirname8, relative as relative3 } from "node:path";
 function createWorkspaceContext(projectRoot = process.cwd()) {
   const rootDir = resolveWorkspaceRoot(projectRoot);
   return {
@@ -47962,7 +49868,7 @@ function createWorkspaceContext(projectRoot = process.cwd()) {
   };
 }
 function planJsonPath(ctx) {
-  return join28(ctx.rootDir, "plan.json");
+  return join31(ctx.rootDir, "plan.json");
 }
 function readPlan(ctx) {
   const jsonPath = planJsonPath(ctx);
@@ -48075,7 +49981,7 @@ function renderPlanBody(summary) {
   return lines.join("\n");
 }
 function nextAdrId(ctx) {
-  const decisionsDir = join28(ctx.rootDir, "decisions");
+  const decisionsDir = join31(ctx.rootDir, "decisions");
   if (!existsSync33(decisionsDir)) return "001";
   const existing = readdirSync8(decisionsDir).filter((f) => f.endsWith(".md")).map((f) => f.match(/^(\d+)-/)).filter((m) => !!m).map((m) => parseInt(m[1], 10));
   const max = existing.length === 0 ? 0 : Math.max(...existing);
@@ -48118,7 +50024,7 @@ function addTaskRecord(ctx, summary, phaseId, t, options) {
     status: "pending",
     priority: t.priority
   });
-  const taskPath = join28(ctx.rootDir, "plan-tasks", `${id3}.md`);
+  const taskPath = join31(ctx.rootDir, "plan-tasks", `${id3}.md`);
   const meta3 = {
     kind: "task",
     id: id3,
@@ -48160,7 +50066,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path72 = join28(ctx.rootDir, "milestones", `${id3}.md`);
+  const path72 = join31(ctx.rootDir, "milestones", `${id3}.md`);
   const meta3 = {
     kind: "milestone",
     id: id3,
@@ -48458,7 +50364,7 @@ function createNfrSpecStub(ctx) {
           },
           planFeatureKeywords: Array.isArray(args["planFeatureKeywords"]) ? args["planFeatureKeywords"] : void 0
         };
-        const outPath = join28(ctx.rootDir, "nfr-spec.json");
+        const outPath = join31(ctx.rootDir, "nfr-spec.json");
         writeFileSync17(outPath, JSON.stringify(spec, null, 2), "utf8");
         return `NFR spec written to nfr-spec.json (${targets.length} target(s)).`;
       });
@@ -48522,11 +50428,11 @@ function searchDocumentsStub(ctx) {
         (w) => w.length >= 3 && w !== "or" && w !== "and" && w !== "the"
       );
       const files = [
-        ...ctx.storage.listMarkdown(join28(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join28(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join28(ctx.rootDir, "reviews")),
-        ...ctx.storage.listMarkdown(join28(ctx.rootDir, "plan-tasks")),
-        ...ctx.storage.listMarkdown(join28(ctx.rootDir, "milestones")),
+        ...ctx.storage.listMarkdown(join31(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join31(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join31(ctx.rootDir, "reviews")),
+        ...ctx.storage.listMarkdown(join31(ctx.rootDir, "plan-tasks")),
+        ...ctx.storage.listMarkdown(join31(ctx.rootDir, "milestones")),
         workspaceFile(ctx.rootDir, "plan"),
         workspaceFile(ctx.rootDir, "risks")
       ];
@@ -48584,9 +50490,9 @@ function linkDocumentsStub(ctx) {
         const toId = args["toId"] ?? args["targetId"] ?? args["targetPathOrTitle"];
         if (!fromId || !toId) return "linkDocuments requires fromId and toId.";
         const allFiles = [
-          ...ctx.storage.listMarkdown(join28(ctx.rootDir, "decisions")),
-          ...ctx.storage.listMarkdown(join28(ctx.rootDir, "docs")),
-          ...ctx.storage.listMarkdown(join28(ctx.rootDir, "reviews"))
+          ...ctx.storage.listMarkdown(join31(ctx.rootDir, "decisions")),
+          ...ctx.storage.listMarkdown(join31(ctx.rootDir, "docs")),
+          ...ctx.storage.listMarkdown(join31(ctx.rootDir, "reviews"))
         ];
         const source2 = allFiles.find((f) => {
           try {
@@ -48617,9 +50523,9 @@ function getDocumentBacklinksStub(ctx) {
       const targetId = args["targetId"] ?? args["id"];
       if (!targetId) return "getDocumentBacklinks requires targetId.";
       const allFiles = [
-        ...ctx.storage.listMarkdown(join28(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join28(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join28(ctx.rootDir, "reviews"))
+        ...ctx.storage.listMarkdown(join31(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join31(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join31(ctx.rootDir, "reviews"))
       ];
       const backlinks = [];
       for (const file2 of allFiles) {
@@ -48875,15 +50781,15 @@ import {
   readFileSync as readFileSync28,
   writeFileSync as writeFileSync18
 } from "node:fs";
-import { dirname as dirname9, join as join29 } from "node:path";
+import { dirname as dirname9, join as join32 } from "node:path";
 import { homedir as homedir10 } from "node:os";
 function getUserMcpPath() {
-  return join29(homedir10(), ".zelari-code", "mcp.json");
+  return join32(homedir10(), ".zelari-code", "mcp.json");
 }
 function getProjectMcpPath(projectRoot) {
-  return join29(projectRoot, ".zelari", "mcp.json");
+  return join32(projectRoot, ".zelari", "mcp.json");
 }
-function readFile3(path72) {
+function readFile4(path72) {
   if (!existsSync34(path72)) return {};
   try {
     const parsed = JSON.parse(readFileSync28(path72, "utf8"));
@@ -48902,7 +50808,7 @@ function readFile3(path72) {
     return {};
   }
 }
-function writeFile(path72, servers) {
+function writeFile2(path72, servers) {
   mkdirSync16(dirname9(path72), { recursive: true });
   const body = { mcpServers: servers };
   writeFileSync18(path72, `${JSON.stringify(body, null, 2)}
@@ -48910,9 +50816,9 @@ function writeFile(path72, servers) {
 }
 function listMcpServers(projectRoot) {
   const userPath = getUserMcpPath();
-  const userServers = readFile3(userPath);
+  const userServers = readFile4(userPath);
   const projectPath = projectRoot && projectRoot.trim() ? getProjectMcpPath(projectRoot.trim()) : null;
-  const projectServers = projectPath ? readFile3(projectPath) : {};
+  const projectServers = projectPath ? readFile4(projectPath) : {};
   const servers = [];
   for (const [name, cfg] of Object.entries(userServers)) {
     servers.push({ name, ...cfg, scope: "user", path: userPath });
@@ -48951,14 +50857,14 @@ function upsertMcpServer(opts) {
     }
     path72 = getProjectMcpPath(root);
   }
-  const current = readFile3(path72);
+  const current = readFile4(path72);
   current[name] = {
     command: opts.config.command.trim(),
     args: opts.config.args,
     env: opts.config.env,
     enabled: opts.config.enabled !== false
   };
-  writeFile(path72, current);
+  writeFile2(path72, current);
   return { ok: true, path: path72 };
 }
 function removeMcpServer(opts) {
@@ -48966,12 +50872,12 @@ function removeMcpServer(opts) {
   if (!path72) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile3(path72);
+  const current = readFile4(path72);
   if (!(opts.name in current)) {
     return { ok: false, error: `Server "${opts.name}" not found in ${path72}` };
   }
   delete current[opts.name];
-  writeFile(path72, current);
+  writeFile2(path72, current);
   return { ok: true, path: path72 };
 }
 var init_mcpConfigIo = __esm({
@@ -49115,16 +51021,16 @@ __export(mcpManager_exports, {
   registerMcpTools: () => registerMcpTools
 });
 import { existsSync as existsSync35, readFileSync as readFileSync29 } from "node:fs";
-import { join as join30 } from "node:path";
+import { join as join33 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 function readMcpConfig(projectRoot = process.cwd(), opts) {
   const merged = {};
   const paths = [];
   if (process.env["ZELARI_MCP_USER"] !== "0") {
-    paths.push(join30(homedir11(), ".zelari-code", "mcp.json"));
+    paths.push(join33(homedir11(), ".zelari-code", "mcp.json"));
   }
   if (!opts?.skipProjectMcp) {
-    paths.push(join30(projectRoot, ".zelari", "mcp.json"));
+    paths.push(join33(projectRoot, ".zelari", "mcp.json"));
   }
   for (const p3 of paths) {
     if (!existsSync35(p3)) continue;
@@ -49143,7 +51049,7 @@ async function ensureLoaded(projectRoot) {
   if (state2.loaded) return;
   state2.loaded = true;
   const trusted = isFolderTrusted(projectRoot);
-  if (!trusted && existsSync35(join30(projectRoot, ".zelari", "mcp.json"))) {
+  if (!trusted && existsSync35(join33(projectRoot, ".zelari", "mcp.json"))) {
     state2.warnings.push(
       "[mcp] project .zelari/mcp.json ignored \u2014 folder not trusted (run /trust or `zelari-code --trust` to enable project MCP)"
     );
@@ -49369,14 +51275,14 @@ __export(agentsMd_exports, {
   updateAgentsMd: () => updateAgentsMd
 });
 import { existsSync as existsSync36, readFileSync as readFileSync30, writeFileSync as writeFileSync19 } from "node:fs";
-import { createHash as createHash17 } from "node:crypto";
-import { join as join31 } from "node:path";
-import { readFile as readFile4 } from "node:fs/promises";
+import { createHash as createHash19 } from "node:crypto";
+import { join as join34 } from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path72 = join31(projectRoot, "package.json");
+  const path72 = join34(projectRoot, "package.json");
   if (!existsSync36(path72)) return null;
   try {
-    return JSON.parse(await readFile4(path72, "utf8"));
+    return JSON.parse(await readFile5(path72, "utf8"));
   } catch {
     return null;
   }
@@ -49398,7 +51304,7 @@ async function genTechStack(ctx) {
   ].join("\n");
 }
 async function genDecisions(ctx) {
-  const decisionsDir = join31(ctx.rootDir, "decisions");
+  const decisionsDir = join34(ctx.rootDir, "decisions");
   if (!existsSync36(decisionsDir)) return "_No ADRs yet._";
   const files = ctx.storage.listMarkdown(decisionsDir).sort();
   const accepted = [];
@@ -49424,7 +51330,7 @@ async function genDecisions(ctx) {
 }
 async function genConventions(ctx) {
   const lines = [];
-  const claudeMd = join31(ctx.projectRoot, "CLAUDE.MD");
+  const claudeMd = join34(ctx.projectRoot, "CLAUDE.MD");
   if (existsSync36(claudeMd)) {
     const content = readFileSync30(claudeMd, "utf8");
     const match = content.match(/## Architecture rules[\s\S]+?(?=\n## |\n*$)/);
@@ -49458,7 +51364,7 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path72 = join31(ctx.rootDir, "risks.md");
+  const path72 = join34(ctx.rootDir, "risks.md");
   if (!existsSync36(path72)) return "_No open questions._";
   const content = readFileSync30(path72, "utf8");
   const lines = content.split("\n");
@@ -49534,7 +51440,7 @@ function titleCase(id3) {
   return id3.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
 }
 async function updateAgentsMd(ctx, projectRoot) {
-  const agentsPath = join31(projectRoot, "AGENTS.MD");
+  const agentsPath = join34(projectRoot, "AGENTS.MD");
   if (existsSync36(agentsPath)) {
     const content = readFileSync30(agentsPath, "utf8");
     const hasAnyMarker = AUTO_SECTIONS.some((id3) => content.includes(MARKER_OPEN(id3)));
@@ -49584,7 +51490,7 @@ async function updateAgentsMd(ctx, projectRoot) {
   return { changed: true, sections: changedSections };
 }
 function hash2(s) {
-  return createHash17("sha256").update(s).digest("hex").slice(0, 16);
+  return createHash19("sha256").update(s).digest("hex").slice(0, 16);
 }
 var AUTO_SECTIONS, MARKER_OPEN, MARKER_CLOSE, GENERATORS;
 var init_agentsMd = __esm({
@@ -49706,11 +51612,11 @@ var init_completeDesign = __esm({
 
 // src/cli/workspace/planDriftCheck.ts
 import { existsSync as existsSync37, readFileSync as readFileSync31, readdirSync as readdirSync9, statSync as statSync6, writeFileSync as writeFileSync20 } from "node:fs";
-import { join as join32 } from "node:path";
+import { join as join35 } from "node:path";
 function findCanonicalDoc(rootDir) {
-  const docsDir = join32(rootDir, "docs");
+  const docsDir = join35(rootDir, "docs");
   if (!existsSync37(docsDir)) return null;
-  const candidates = readdirSync9(docsDir).filter((f) => /^plan-canonical.*\.md$/i.test(f)).map((f) => ({ f, mtime: statSync6(join32(docsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const candidates = readdirSync9(docsDir).filter((f) => /^plan-canonical.*\.md$/i.test(f)).map((f) => ({ f, mtime: statSync6(join35(docsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return candidates.length > 0 ? candidates[0].f : null;
 }
 function parseCanonicalDoc(text) {
@@ -49745,7 +51651,7 @@ async function runPlanDriftCheck(rootDir) {
   if (process.env["ZELARI_DRIFT_CHECK"] === "0") {
     return { ran: false, reason: "ZELARI_DRIFT_CHECK=0 (disabled)" };
   }
-  const planPath = join32(rootDir, "plan.json");
+  const planPath = join35(rootDir, "plan.json");
   if (!existsSync37(planPath)) {
     return { ran: false, reason: ".zelari/plan.json missing (not design-phase)" };
   }
@@ -49761,7 +51667,7 @@ async function runPlanDriftCheck(rootDir) {
   const milestones = Array.isArray(plan.milestones) ? plan.milestones : [];
   const phaseIds = new Set(phases.map((p3) => typeof p3.id === "string" ? p3.id : "").filter(Boolean));
   const canonicalName = findCanonicalDoc(rootDir);
-  const canonicalText = canonicalName ? readFileSyncSafe(join32(rootDir, "docs", canonicalName)) : null;
+  const canonicalText = canonicalName ? readFileSyncSafe(join35(rootDir, "docs", canonicalName)) : null;
   if (canonicalText !== null) {
     const { activePhases, blockedPrefixes } = parseCanonicalDoc(canonicalText);
     for (const id3 of activePhases) {
@@ -49840,7 +51746,7 @@ async function runPlanDriftCheck(rootDir) {
   const canonicalParsed = canonicalName !== null && canonicalText !== null;
   let reportPath;
   try {
-    reportPath = join32(rootDir, "drift-report.json");
+    reportPath = join35(rootDir, "drift-report.json");
     writeFileSync20(
       reportPath,
       JSON.stringify(
@@ -49878,7 +51784,7 @@ var init_planDriftCheck = __esm({
 // src/cli/workspace/projectSmoke.ts
 import { spawn as spawn14 } from "node:child_process";
 import { existsSync as existsSync38, readFileSync as readFileSync32 } from "node:fs";
-import { join as join33 } from "node:path";
+import { join as join36 } from "node:path";
 function pickSmokeScript(scripts) {
   if (!scripts) return null;
   for (const name of SMOKE_SCRIPT_PRIORITY) {
@@ -49890,7 +51796,7 @@ async function runProjectSmoke(projectRoot, timeoutMs2 = DEFAULT_TIMEOUT_MS3) {
   if (process.env["ZELARI_SMOKE"] === "0") {
     return { ran: false, reason: "ZELARI_SMOKE=0 (disabled)" };
   }
-  const pkgPath = join33(projectRoot, "package.json");
+  const pkgPath = join36(projectRoot, "package.json");
   if (!existsSync38(pkgPath)) {
     return { ran: false, reason: "no package.json (skipped)" };
   }
@@ -49985,7 +51891,7 @@ __export(postCouncilHook_exports, {
 });
 import { spawn as spawn15 } from "node:child_process";
 import { existsSync as existsSync39, readFileSync as readFileSync33 } from "node:fs";
-import { join as join34 } from "node:path";
+import { join as join37 } from "node:path";
 async function runCompleteDesignPostProcessor(ctx, options) {
   if (options?.runMode === "implementation") {
     return {
@@ -49996,8 +51902,8 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (process.env["ZELARI_COMPLETE_DESIGN"] === "0") {
     return { ran: false, reason: "ZELARI_COMPLETE_DESIGN=0 (disabled)" };
   }
-  const planJsonPath2 = join34(ctx.rootDir, "plan.json");
-  const scriptPath = join34(ctx.projectRoot, "complete-design.mjs");
+  const planJsonPath2 = join37(ctx.rootDir, "plan.json");
+  const scriptPath = join37(ctx.projectRoot, "complete-design.mjs");
   if (!existsSync39(planJsonPath2)) {
     return {
       ran: false,
@@ -50431,7 +52337,7 @@ import { promisify as promisify2 } from "node:util";
 import { mkdtempSync, rmSync as rmSync2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import path49 from "node:path";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 async function git3(cwd, args, env) {
   const { stdout } = await execFileAsync2("git", ["-C", cwd, ...args], {
     maxBuffer: 64 * 1024 * 1024,
@@ -50474,7 +52380,7 @@ async function createCheckpoint(cwd, label = "checkpoint") {
   }
   try {
     const { tree, head } = await snapshotTree(cwd);
-    const id3 = randomUUID4().slice(0, 8);
+    const id3 = randomUUID5().slice(0, 8);
     const createdAt = Date.now();
     const message = `zelari-checkpoint ${id3}: ${label}`;
     const commitArgs = ["commit-tree", tree, "-m", message];
@@ -50641,7 +52547,7 @@ __export(fileBackend_exports, {
   getMemoryBackend: () => getMemoryBackend,
   isMemoryEnabled: () => isMemoryEnabled
 });
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { promises as fs26 } from "node:fs";
 import * as path50 from "node:path";
 function tokenize(text) {
@@ -50700,7 +52606,7 @@ var init_fileBackend = __esm({
       }
       async add(content, metadata2 = {}, graph) {
         const fact = {
-          id: randomUUID5(),
+          id: randomUUID6(),
           content,
           metadata: metadata2,
           ...graph ? { graph } : {},
@@ -50808,7 +52714,7 @@ __export(zelariMission_exports, {
   resolveMaxTokens: () => resolveMaxTokens,
   runZelariMission: () => runZelariMission
 });
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import { promises as fs28 } from "node:fs";
 import * as path52 from "node:path";
 function resolveMaxIterations(env = process.env) {
@@ -50905,7 +52811,7 @@ async function runZelariMission(userMessage, brief, deps) {
   const maxStall = resolveMaxStall(deps.env);
   const maxCost = resolveMaxCost(deps.env);
   const maxTokens = resolveMaxTokens(deps.env);
-  const missionId = deps.missionId ?? `m_${randomUUID6().slice(0, 8)}`;
+  const missionId = deps.missionId ?? `m_${randomUUID7().slice(0, 8)}`;
   const startedAt = now().toISOString();
   const state3 = {
     missionId,
@@ -52174,11 +54080,11 @@ ${prompt.trim()}`];
   parts.push("", "Return ONLY the JSON object described in the system prompt.");
   return parts.join("\n");
 }
-function uniqueId(base, existing) {
-  if (!existing.has(base)) return base;
+function uniqueId(base2, existing) {
+  if (!existing.has(base2)) return base2;
   let i = 2;
-  while (existing.has(`${base}-${i}`)) i += 1;
-  return `${base}-${i}`;
+  while (existing.has(`${base2}-${i}`)) i += 1;
+  return `${base2}-${i}`;
 }
 function buildAutoVerifyPrompt(general) {
   const taskPrompt = general.prompt.length > MAX_VERIFY_TASK_PROMPT_CHARS ? `${general.prompt.slice(0, MAX_VERIFY_TASK_PROMPT_CHARS)}
@@ -52987,7 +54893,7 @@ ${body}`);
 function thoroughnessForKind(kind2) {
   return kind2 === "general" || kind2 === "fix" ? "deep" : "medium";
 }
-function firstLine(text, maxChars = 160) {
+function firstLine2(text, maxChars = 160) {
   const line = text.trim().split("\n").find((l) => l.trim() !== "")?.trim() ?? "";
   return line.length > maxChars ? `${line.slice(0, maxChars)}\u2026` : line;
 }
@@ -53743,7 +55649,7 @@ ${upstream}` : node.prompt,
           });
           writer.result = `${writer.result ?? ""}
 
-[accepted with unresolved verify findings from ` + `"${verify.label}"]${findings ? `: ${firstLine(findings)}` : ""}`.trim();
+[accepted with unresolved verify findings from ` + `"${verify.label}"]${findings ? `: ${firstLine2(findings)}` : ""}`.trim();
           this.radio("node_end", {
             description: writer.label,
             agent: writer.kind,
@@ -56702,7 +58608,7 @@ import {
   rmSync as rmSync4,
   writeFileSync as writeFileSync24
 } from "node:fs";
-import { dirname as dirname13, join as join42 } from "node:path";
+import { dirname as dirname13, join as join45 } from "node:path";
 import { homedir as homedir12 } from "node:os";
 function ensureBuiltinSkillsLoadedSync() {
   if (builtinsLoaded) return;
@@ -56714,13 +58620,13 @@ function ensureBuiltinSkillsLoadedSync() {
   }
 }
 function getUserSkillsDir() {
-  return join42(homedir12(), ".zelari-code", "skills");
+  return join45(homedir12(), ".zelari-code", "skills");
 }
 function getProjectSkillsDir(projectRoot) {
-  return join42(projectRoot, ".zelari", "skills");
+  return join45(projectRoot, ".zelari", "skills");
 }
 function skillFilePath(dir, name) {
-  return join42(dir, name, "SKILL.md");
+  return join45(dir, name, "SKILL.md");
 }
 function classifyScope(skillPath, projectRoot) {
   const userDir = getUserSkillsDir().replace(/\\/g, "/");
@@ -56796,9 +58702,9 @@ function listSkillsSnapshot(projectRoot) {
   const skills = [];
   const seen = /* @__PURE__ */ new Set();
   if (root) {
-    scanSkillsDir(join42(root, ".zelari", "skills"), root, seen, skills);
-    scanSkillsDir(join42(root, ".claude", "skills"), root, seen, skills);
-    scanSkillsDir(join42(root, ".opencode", "skills"), root, seen, skills);
+    scanSkillsDir(join45(root, ".zelari", "skills"), root, seen, skills);
+    scanSkillsDir(join45(root, ".claude", "skills"), root, seen, skills);
+    scanSkillsDir(join45(root, ".opencode", "skills"), root, seen, skills);
   }
   scanSkillsDir(userSkillsDir, root, seen, skills);
   for (const s of listCodingSkills()) {
@@ -56896,7 +58802,7 @@ function removeSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const skillDir = join42(dir, name);
+  const skillDir = join45(dir, name);
   const path72 = skillFilePath(dir, name);
   if (!existsSync49(path72) && !existsSync49(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
@@ -57437,7 +59343,7 @@ var init_mcpCli = __esm({
 
 // src/cli/mcp/mcpPermissionServer.ts
 import { createInterface as createInterface2 } from "node:readline";
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 function startPermissionMcpServer(opts) {
   const socketPath = opts.socketPath.trim();
   const requestTimeoutMs = opts.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
@@ -57533,7 +59439,7 @@ function startPermissionMcpServer(opts) {
         socketPath,
         {
           t: "ask",
-          id: randomUUID8(),
+          id: randomUUID9(),
           kind: "permission",
           tool: toolName,
           input: input2,
@@ -57572,7 +59478,7 @@ function startPermissionMcpServer(opts) {
         socketPath,
         {
           t: "ask",
-          id: randomUUID8(),
+          id: randomUUID9(),
           kind: "question",
           question,
           choices,
@@ -57708,17 +59614,17 @@ import {
   readFileSync as readFileSync39,
   writeFileSync as writeFileSync25
 } from "node:fs";
-import { join as join43 } from "node:path";
+import { join as join46 } from "node:path";
 import { homedir as homedir13 } from "node:os";
-import { createHash as createHash18, randomBytes as randomBytes5, timingSafeEqual } from "node:crypto";
+import { createHash as createHash20, randomBytes as randomBytes6, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
-  return join43(homedir13(), ".zelari-code");
+  return join46(homedir13(), ".zelari-code");
 }
 function getCompanionConfigPath() {
-  return join43(getZelariHome(), "companion.json");
+  return join46(getZelariHome(), "companion.json");
 }
 function getCompanionTokenPath() {
-  return join43(getZelariHome(), "companion.token");
+  return join46(getZelariHome(), "companion.token");
 }
 function ensureHome() {
   const home = getZelariHome();
@@ -57775,7 +59681,7 @@ function loadOrCreateToken(explicit) {
     const t = readFileSync39(path72, "utf8").trim();
     if (t) return { token: t, created: false };
   }
-  const token = randomBytes5(24).toString("base64url");
+  const token = randomBytes6(24).toString("base64url");
   writeFileSync25(path72, token + "\n", "utf8");
   try {
     const fs42 = __require("node:fs");
@@ -57786,8 +59692,8 @@ function loadOrCreateToken(explicit) {
 }
 function tokenMatches(expected, provided) {
   if (!provided) return false;
-  const a = createHash18("sha256").update(expected).digest();
-  const b = createHash18("sha256").update(provided).digest();
+  const a = createHash20("sha256").update(expected).digest();
+  const b = createHash20("sha256").update(provided).digest();
   try {
     return timingSafeEqual(a, b);
   } catch {
@@ -57795,8 +59701,8 @@ function tokenMatches(expected, provided) {
   }
 }
 function slugFromPath(p3) {
-  const base = p3.replace(/[/\\]+$/, "").split(/[/\\]/).pop() || "project";
-  return base.toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "project";
+  const base2 = p3.replace(/[/\\]+$/, "").split(/[/\\]/).pop() || "project";
+  return base2.toLowerCase().replace(/[^a-z0-9-_]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || "project";
 }
 function mergeProjects(cfg, extraPaths) {
   const byId = /* @__PURE__ */ new Map();
@@ -57864,9 +59770,9 @@ var init_config = __esm({
 // src/cli/companion/runManager.ts
 import { spawn as spawn17 } from "node:child_process";
 import { createInterface as createInterface3 } from "node:readline";
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { writeFileSync as writeFileSync26, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join44 } from "node:path";
+import { join as join47 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
 var RunManager;
 var init_runManager = __esm({
@@ -57933,7 +59839,7 @@ var init_runManager = __esm({
         }
         const prompt = args.prompt?.trim();
         if (!prompt) return { ok: false, error: "prompt is required" };
-        const id3 = randomUUID9();
+        const id3 = randomUUID10();
         const mode = (args.mode || "kraken").toLowerCase();
         const phase2 = (args.phase || "build").toLowerCase();
         const run = {
@@ -57970,7 +59876,7 @@ var init_runManager = __esm({
         }
         let historyFile;
         if (args.history && Array.isArray(args.history) && args.history.length > 0) {
-          historyFile = join44(tmpdir3(), `zelari-companion-hist-${id3}.json`);
+          historyFile = join47(tmpdir3(), `zelari-companion-hist-${id3}.json`);
           try {
             writeFileSync26(historyFile, JSON.stringify(args.history), "utf8");
             argv.push("--history-file", historyFile);
@@ -62401,12 +64307,12 @@ init_completionGate();
 // src/cli/kraken/verificationBridge.ts
 init_candidateRegistry();
 init_completionGate();
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 
 // src/cli/kraken/nativeVerification.ts
 init_runtime2();
 init_verification2();
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 import path42 from "node:path";
 function nativePackEnabled(env = process.env) {
   const v = env.ZELARI_VERIFY_PACK?.toLowerCase();
@@ -62434,7 +64340,7 @@ function packTimeoutMs(env = process.env) {
 }
 async function readPackageScripts(cwd = process.cwd()) {
   try {
-    const raw = await readFile2(path42.join(cwd, "package.json"), "utf-8");
+    const raw = await readFile3(path42.join(cwd, "package.json"), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && typeof parsed.scripts === "object") {
       return parsed.scripts;
@@ -62528,7 +64434,7 @@ function krakenResultsToContract(requiredChecks, results, now = Date.now()) {
   return { criteria, results: verifications };
 }
 function sha256Hex2(input) {
-  return createHash12("sha256").update(input).digest("hex");
+  return createHash14("sha256").update(input).digest("hex");
 }
 function matchNoteToToolTrace(note, trace) {
   const n = normalize5(note);
@@ -62867,17 +64773,17 @@ function mergeCompactRange(into, r) {
   if (r.strategy === "llm") into.strategy = "llm";
   else if (r.strategy && !into.strategy) into.strategy = r.strategy;
 }
-function estimateTokens(text) {
+function estimateTokens2(text) {
   if (!text) return 0;
   return Math.max(1, Math.ceil(text.length / 4));
 }
 function estimateHistoryTokens(messages) {
   let n = 0;
   for (const m of messages) {
-    n += estimateTokens(m.content);
+    n += estimateTokens2(m.content);
     if (m.toolCalls) {
       for (const tc of m.toolCalls) {
-        n += estimateTokens(tc.name) + estimateTokens(JSON.stringify(tc.args ?? {}));
+        n += estimateTokens2(tc.name) + estimateTokens2(JSON.stringify(tc.args ?? {}));
       }
     }
   }
@@ -66241,8 +68147,8 @@ async function promoteMemoryToAgentsMd(projectRoot, node) {
   const root = await fs29.realpath(projectRoot).catch(() => path54.resolve(projectRoot));
   const target = path54.join(root, "AGENTS.md");
   try {
-    const stat = await fs29.lstat(target);
-    if (stat.isSymbolicLink() || !stat.isFile()) throw new Error("AGENTS.md must be a regular project file.");
+    const stat2 = await fs29.lstat(target);
+    if (stat2.isSymbolicLink() || !stat2.isFile()) throw new Error("AGENTS.md must be a regular project file.");
   } catch (error51) {
     if (error51.code !== "ENOENT") throw error51;
   }
@@ -66321,8 +68227,8 @@ async function safeExportPath(cwd, requested) {
   for (const segment of relativeParent.split(path55.sep).filter(Boolean)) {
     cursor = path55.join(cursor, segment);
     try {
-      const stat = await fs30.lstat(cursor);
-      if (stat.isSymbolicLink()) {
+      const stat2 = await fs30.lstat(cursor);
+      if (stat2.isSymbolicLink()) {
         throw new Error("Export path must not traverse a symbolic link.");
       }
     } catch (error51) {
@@ -66690,7 +68596,7 @@ init_zod();
 init_taskTool();
 import { promises as fs33 } from "node:fs";
 import path59 from "node:path";
-import { randomBytes as randomBytes4 } from "node:crypto";
+import { randomBytes as randomBytes5 } from "node:crypto";
 var CsvFanoutArgsSchema = external_exports.object({
   csv_path: external_exports.string().min(1),
   id_column: external_exports.string().min(1),
@@ -66861,7 +68767,7 @@ async function runCsvFanout(args, deps, opts) {
   };
 }
 async function atomicWrite(file2, contents) {
-  const tmp = `${file2}.${process.pid}.${Date.now()}.${randomBytes4(6).toString("hex")}.tmp`;
+  const tmp = `${file2}.${process.pid}.${Date.now()}.${randomBytes5(6).toString("hex")}.tmp`;
   await fs33.writeFile(tmp, contents, "utf8");
   await fs33.rename(tmp, file2);
 }
@@ -67160,9 +69066,9 @@ async function handleKrakenWorkbench(ctx) {
     for (const f of files) {
       if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
       const full = path60.join(dir, f);
-      const stat = await fs35.stat(full);
-      if (stat.mtimeMs > latestMtime) {
-        latestMtime = stat.mtimeMs;
+      const stat2 = await fs35.stat(full);
+      if (stat2.mtimeMs > latestMtime) {
+        latestMtime = stat2.mtimeMs;
         latest = full;
       }
     }
@@ -69525,7 +71431,7 @@ init_taskTool();
 init_sessionTodos();
 import { promises as fs41 } from "node:fs";
 import path68 from "node:path";
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 
 // src/cli/kraken/verifierLifecycle.ts
 init_verification2();
@@ -69615,6 +71521,215 @@ async function runAdvisoryVerifierReview(evaluation, deps = {}) {
 // src/cli/runHeadless.ts
 init_metrics3();
 init_headlessSpine();
+init_runtime2();
+
+// src/cli/headless/controlReader.ts
+var CONTROL_TYPES = /* @__PURE__ */ new Set([
+  "steer",
+  "follow_up",
+  "cancel",
+  "pause",
+  "resume"
+]);
+function parseControlEvent(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { ok: false, id: "", reason: "control event must be a JSON object" };
+  }
+  const candidate = raw;
+  const type = candidate["type"];
+  if (typeof type !== "string" || !CONTROL_TYPES.has(type)) {
+    return {
+      ok: false,
+      id: typeof candidate["id"] === "string" ? candidate["id"] : "",
+      reason: `unknown control type: ${String(type)}`
+    };
+  }
+  if (typeof candidate["id"] !== "string" || candidate["id"].length === 0) {
+    return { ok: false, id: "", reason: "missing control id" };
+  }
+  if (type === "steer" || type === "follow_up") {
+    if (typeof candidate["text"] !== "string" || candidate["text"].trim().length === 0) {
+      return {
+        ok: false,
+        id: candidate["id"],
+        reason: `${type} requires a non-empty "text" field`
+      };
+    }
+  }
+  if (type === "cancel" && "reason" in candidate && candidate["reason"] !== void 0 && typeof candidate["reason"] !== "string") {
+    return {
+      ok: false,
+      id: candidate["id"],
+      reason: "cancel reason must be a string"
+    };
+  }
+  return {
+    ok: true,
+    event: {
+      ...candidate,
+      ts: typeof candidate["ts"] === "number" ? candidate["ts"] : Date.now()
+    }
+  };
+}
+function parseControlLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) return null;
+  try {
+    return parseControlEvent(JSON.parse(trimmed));
+  } catch (e) {
+    return { ok: false, id: "", reason: `malformed JSON: ${e.message}` };
+  }
+}
+function startControlReader(input, onLine) {
+  let buffer = "";
+  const onData = (chunk) => {
+    buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      if (line.trim().length > 0) onLine(line.replace(/\r$/, ""));
+      newlineIndex = buffer.indexOf("\n");
+    }
+  };
+  input.on("data", onData);
+  return () => {
+    input.removeListener("data", onData);
+    buffer = "";
+  };
+}
+
+// src/cli/headless/protocol.ts
+var HEADLESS_PROTOCOL_VERSION = 2;
+var HEADLESS_PROTOCOL_CAPABILITIES = [
+  "stdin-control",
+  "steer",
+  "follow_up",
+  "cancel"
+];
+function protocolInfoEvent() {
+  return {
+    type: "protocol_info",
+    version: HEADLESS_PROTOCOL_VERSION,
+    capabilities: HEADLESS_PROTOCOL_CAPABILITIES,
+    ts: Date.now()
+  };
+}
+function controlAcceptedEvent(controlId, controlType) {
+  return {
+    type: "control_accepted",
+    controlId,
+    controlType,
+    ts: Date.now()
+  };
+}
+function controlAppliedEvent(controlId, controlType, boundary) {
+  return {
+    type: "control_applied",
+    controlId,
+    controlType,
+    boundary,
+    ts: Date.now()
+  };
+}
+function controlRejectedEvent(controlId, reason) {
+  return {
+    type: "control_rejected",
+    controlId,
+    reason,
+    ts: Date.now()
+  };
+}
+
+// src/cli/headless/controlBridge.ts
+var APPLIED_BOUNDARY = {
+  steer: "turn-end",
+  follow_up: "run-end",
+  cancel: "cancel"
+};
+function attachControlPlane(opts) {
+  const { input, queue, emit, onCancel } = opts;
+  let finalized = false;
+  queue.onDrained = (events) => {
+    for (const event of events) {
+      emit(
+        controlAppliedEvent(
+          event.id,
+          event.type,
+          APPLIED_BOUNDARY[event.type] ?? "unknown"
+        )
+      );
+    }
+    const cancels = events.filter((e) => e.type === "cancel");
+    if (cancels.length > 0 && onCancel) {
+      const last = cancels[cancels.length - 1];
+      onCancel(last.type === "cancel" ? last.reason : void 0);
+    }
+  };
+  const disposeReader = startControlReader(input, (line) => {
+    const outcome = parseControlLine(line);
+    if (outcome === null) return;
+    if (!outcome.ok) {
+      emit(controlRejectedEvent(outcome.id, outcome.reason));
+      return;
+    }
+    const event = outcome.event;
+    if (event.type === "pause" || event.type === "resume") {
+      emit(
+        controlRejectedEvent(event.id, `${event.type} is not supported yet`)
+      );
+      return;
+    }
+    if (finalized) {
+      if (event.type === "steer") {
+        const converted = toFollowUp(event);
+        queue.enqueue(converted);
+        emit(controlAppliedEvent(event.id, "steer", "converted-to-follow-up"));
+        emit(controlAcceptedEvent(converted.id, "follow_up"));
+      } else if (event.type === "follow_up") {
+        queue.enqueue(event);
+        emit(controlAcceptedEvent(event.id, "follow_up"));
+      } else {
+        emit(controlRejectedEvent(event.id, "run already finished"));
+      }
+      return;
+    }
+    queue.enqueue(event);
+    emit(controlAcceptedEvent(event.id, event.type));
+  });
+  return {
+    dispose() {
+      disposeReader();
+      queue.onDrained = void 0;
+    },
+    finalize() {
+      finalized = true;
+      const lateSteers = queue.drainSteers();
+      for (const steer of lateSteers) {
+        queue.enqueue(toFollowUp(steer));
+        emit(controlAppliedEvent(steer.id, "steer", "converted-to-follow-up"));
+      }
+      const followUps = queue.drainFollowUps();
+      for (const followUp of followUps) {
+        emit(controlAppliedEvent(followUp.id, "follow_up", "run-end"));
+      }
+      return followUps.map((f) => f.text);
+    },
+    get finalized() {
+      return finalized;
+    }
+  };
+}
+function toFollowUp(steer) {
+  return {
+    type: "follow_up",
+    id: `fu-${steer.id}`,
+    text: steer.text,
+    ts: steer.ts
+  };
+}
+
+// src/cli/runHeadless.ts
 async function runHeadless(opts) {
   resetTaskSpawnCount();
   if (opts.todos && opts.todos.length > 0) {
@@ -69822,7 +71937,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     });
     log(formatKrakenGraphAscii2(graph));
     if (opts.planOnly) {
-      const planId = randomUUID7();
+      const planId = randomUUID8();
       const planDir = path68.join(cwd, ".zelari", "radio");
       const planPath = path68.join(planDir, `plan-${planId}.json`);
       await fs41.mkdir(planDir, { recursive: true });
@@ -69949,7 +72064,19 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
   const memoryFactory = await Promise.resolve().then(() => (init_serviceFactory(), serviceFactory_exports));
   const nativeMemory = memoryFactory.isMemoryV2Enabled() ? await memoryFactory.getMemoryService(process.cwd(), process.env) : void 0;
   const memoryAutoWrite = memoryFactory.isMemoryAutoWriteEnabled();
+  const controlQueue = new RuntimeControlQueue();
+  const harnessHolder = {};
+  const controlPlane = opts.output === "json" && process.stdin.isTTY !== true ? (() => {
+    emitEvent(protocolInfoEvent());
+    return attachControlPlane({
+      input: process.stdin,
+      queue: controlQueue,
+      emit: emitEvent,
+      onCancel: () => harnessHolder.cancel?.()
+    });
+  })() : void 0;
   const { registry: toolRegistry } = createBuiltinToolRegistry({
+    onTentacleEvent: (ev) => emitEvent(ev),
     planMode: planModeFromOpts(opts),
     gauntletParent: Boolean(opts.gauntlet) && !planModeFromOpts(opts),
     // Fase 1 (ADR-0020): anchor tentacles to the provider/model THIS run
@@ -70168,12 +72295,15 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       // command is a test/typecheck/build/git-diff line.
       toolCallGate: (name, args) => spine.gateResourceToolCall(name, args) ?? { allowed: true },
       maxToolLoopIterations: maxToolLoop,
+      // PHASE 2: control queue — SteeringObserver drains it at turn ends.
+      controlQueue,
       ...nativeMemory ? {
         memoryService: nativeMemory,
         memoryQuery: opts.task,
         memoryContextChars: 2e3
       } : {}
     });
+    harnessHolder.cancel = () => harness.cancel();
     const readBuildProgress = () => {
       const getter = harness.getBuildProgress;
       return typeof getter === "function" ? getter.call(harness) : { mutationsAttempted: 0, mutationsSucceeded: 0 };
@@ -70390,6 +72520,11 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     }
   }
   await nativeMemory?.close().catch(() => void 0);
+  const pendingFollowUps = controlPlane?.finalize() ?? [];
+  for (const followUp of pendingFollowUps) {
+    emitEvent({ type: "log", message: `follow_up_queued: ${followUp.slice(0, 500)}` });
+  }
+  controlPlane?.dispose();
   if (pass.finalReason === "error") return 3;
   if (strictExit !== 0) return strictExit;
   return pass.exitCode;