zelari-code 2.22.0 → 2.23.0

package/dist/cli/main.bundled.js

@@ -3288,10 +3288,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path91) {
-  if (!path91)
+function getElementAtPath(obj, path92) {
+  if (!path92)
     return obj;
-  return path91.reduce((acc, key) => acc?.[key], obj);
+  return path92.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -3619,11 +3619,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path91, issues) {
+function prefixIssues(path92, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path91);
+    iss.path.unshift(path92);
     return iss;
   });
 }
@@ -3841,16 +3841,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path91 = []) => {
+  const processError = (error52, path92 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path91, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path92, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path91, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path92, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path91, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path92, ...issue2.path]);
       } else {
-        const fullpath = [...path91, ...issue2.path];
+        const fullpath = [...path92, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -3877,17 +3877,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path91 = []) => {
+  const processError = (error52, path92 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path91, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path92, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path91, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path92, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path91, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path92, ...issue2.path]);
       } else {
-        const fullpath = [...path91, ...issue2.path];
+        const fullpath = [...path92, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -3919,8 +3919,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path91 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path91) {
+  const path92 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path92) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -17423,13 +17423,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path91 = ref.slice(1).split("/").filter(Boolean);
-  if (path91.length === 0) {
+  const path92 = ref.slice(1).split("/").filter(Boolean);
+  if (path92.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path91[0] === defsKey) {
-    const key = path91[1];
+  if (path92[0] === defsKey) {
+    const key = path92[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -19887,11 +19887,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path91 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path92 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path91,
+            path: path92,
             title,
             content,
             format: "markdown",
@@ -19900,7 +19900,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path91}".`;
+          return `Document "${title}" created at "${path92}".`;
         }
       }
     ];
@@ -26246,11 +26246,11 @@ var init_synthesisAudit = __esm({
 import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join4 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path91 = join4(zelariRoot, "nfr-spec.json");
-  if (!existsSync7(path91))
+  const path92 = join4(zelariRoot, "nfr-spec.json");
+  if (!existsSync7(path92))
     return null;
   try {
-    const raw = JSON.parse(readFileSync7(path91, "utf8"));
+    const raw = JSON.parse(readFileSync7(path92, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -28556,9 +28556,9 @@ var init_types5 = __esm({
 import { readFileSync as readFileSync12 } from "node:fs";
 import { join as join10 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path91 = join10(zelariRoot, LESSONS_FILE);
+  const path92 = join10(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync12(path91, "utf8");
+    const raw = readFileSync12(path92, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -28659,8 +28659,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path91 = join11(zelariRoot, LESSONS_FILE);
-  appendFileSync(path91, `${JSON.stringify(lesson)}
+  const path92 = join11(zelariRoot, LESSONS_FILE);
+  appendFileSync(path92, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -30624,9 +30624,9 @@ function findCycle(nodes) {
     if (color.get(start) !== WHITE)
       continue;
     const stack = [[start, 0]];
-    const path91 = [];
+    const path92 = [];
     color.set(start, GRAY);
-    path91.push(start);
+    path92.push(start);
     while (stack.length > 0) {
       const top = stack[stack.length - 1];
       const [id3, idx] = top;
@@ -30639,17 +30639,17 @@ function findCycle(nodes) {
           continue;
         const c = color.get(dep);
         if (c === GRAY) {
-          const at = path91.indexOf(dep);
-          return [...path91.slice(at), dep];
+          const at = path92.indexOf(dep);
+          return [...path92.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path91.push(dep);
+          path92.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id3, BLACK);
-        path91.pop();
+        path92.pop();
         stack.pop();
       }
     }
@@ -31569,8 +31569,8 @@ var init_runner = __esm({
           failed: [...this.tentaclesById.values()].filter((r) => r.status === "error"),
           pending: []
         };
-        const path91 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
-        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path91}`);
+        const path92 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
+        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path92}`);
         return snapshot;
       }
       callLog(msg, data) {
@@ -32206,7 +32206,40 @@ var init_agentAdapter = __esm({
 import { promises as fs9 } from "node:fs";
 import path14 from "node:path";
 import crypto2 from "node:crypto";
-var SessionLogLockedError, DEFAULT_STALE_LOCK_MS, SessionLogWriter;
+function defaultLockLivenessProbe(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+function resolveHeartbeatStaleMs(env = process.env) {
+  const raw = env.ZELARI_SPINE_HEARTBEAT_STALE_MS;
+  if (raw) {
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed > 0)
+      return parsed;
+  }
+  return DEFAULT_HEARTBEAT_STALE_MS;
+}
+function evaluateLockTakeover(lockInfo, opts) {
+  const heartbeatStaleMs = opts.heartbeatStaleMs ?? DEFAULT_HEARTBEAT_STALE_MS;
+  const staleLockMs = opts.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
+  const ts = typeof lockInfo.ts === "number" && Number.isFinite(lockInfo.ts) && lockInfo.ts > 0 ? lockInfo.ts : 0;
+  const pid = typeof lockInfo.pid === "number" && Number.isFinite(lockInfo.pid) && lockInfo.pid > 0 ? lockInfo.pid : void 0;
+  if (pid !== void 0) {
+    if (!opts.probe(pid))
+      return { takeover: true, reason: "pid-dead" };
+    if (ts > 0 && opts.now - ts < heartbeatStaleMs)
+      return { takeover: false, reason: "alive-fresh" };
+    return { takeover: true, reason: "heartbeat-stale" };
+  }
+  if (ts > 0 && opts.now - ts > staleLockMs)
+    return { takeover: true, reason: "stale" };
+  return { takeover: false, reason: "no-pid-locked" };
+}
+var SessionLogLockedError, DEFAULT_STALE_LOCK_MS, DEFAULT_HEARTBEAT_STALE_MS, SessionLogWriter;
 var init_writer = __esm({
   "packages/core/dist/session/writer.js"() {
     "use strict";
@@ -32223,13 +32256,18 @@ var init_writer = __esm({
       }
     };
     DEFAULT_STALE_LOCK_MS = 10 * 60 * 1e3;
+    DEFAULT_HEARTBEAT_STALE_MS = 12e4;
     SessionLogWriter = class _SessionLogWriter {
       sessionId;
       eventsPath;
       lockPath;
       ownership = crypto2.randomUUID();
       staleLockMs;
+      heartbeatStaleMs;
+      probe;
       now;
+      /** Last heartbeat ts written into the lock (throttle window anchor). */
+      lastHeartbeatAt = 0;
       nextSeq;
       closed = false;
       chain = Promise.resolve();
@@ -32239,6 +32277,8 @@ var init_writer = __esm({
         this.lockPath = path14.join(sessionDir, "writer.lock");
         this.nextSeq = startSeq;
         this.staleLockMs = options.staleLockMs ?? DEFAULT_STALE_LOCK_MS;
+        this.heartbeatStaleMs = options.heartbeatStaleMs ?? resolveHeartbeatStaleMs();
+        this.probe = options.probe ?? defaultLockLivenessProbe;
         this.now = options.now ?? Date.now;
       }
       /** Create the writer and acquire the ownership lock. */
@@ -32261,6 +32301,7 @@ var init_writer = __esm({
         const payload = this.lockPayload();
         try {
           await fs9.writeFile(this.lockPath, payload, { encoding: "utf-8", flag: "wx", mode: 420 });
+          this.lastHeartbeatAt = this.now();
           return;
         } catch (err) {
           if (err.code !== "EEXIST")
@@ -32268,19 +32309,43 @@ var init_writer = __esm({
         }
         const existing = await fs9.readFile(this.lockPath, "utf-8").catch(() => null);
         let owner = "unknown";
-        let ts = 0;
+        const lockInfo = {};
         if (existing) {
           try {
             const parsed = JSON.parse(existing);
             owner = parsed.ownership ?? owner;
-            ts = parsed.ts ?? ts;
+            lockInfo.ownership = parsed.ownership;
+            lockInfo.pid = parsed.pid;
+            lockInfo.ts = parsed.ts;
           } catch {
           }
         }
-        const stale = ts > 0 && this.now() - ts > this.staleLockMs;
-        if (!stale)
+        const verdict = evaluateLockTakeover(lockInfo, {
+          now: this.now(),
+          probe: this.probe,
+          heartbeatStaleMs: this.heartbeatStaleMs,
+          staleLockMs: this.staleLockMs
+        });
+        if (!verdict.takeover)
           throw new SessionLogLockedError(this.eventsPath, owner);
         await fs9.writeFile(this.lockPath, payload, { encoding: "utf-8" });
+        this.lastHeartbeatAt = this.now();
+      }
+      /** Min interval between lock-ts refreshes (≤ ~1 rewrite/second). */
+      static HEARTBEAT_MIN_INTERVAL_MS = 1e3;
+      /**
+       * Lock heartbeat: while we own the lock, refresh its ts so concurrent
+       * writers can tell a live owner from a hung one. Best-effort and throttled
+       * to at most ~1 rewrite/second; it rides the append chain so close() always
+       * lands AFTER the last heartbeat (never resurrects a removed lock).
+       */
+      maybeHeartbeat() {
+        const ts = this.now();
+        if (ts - this.lastHeartbeatAt < _SessionLogWriter.HEARTBEAT_MIN_INTERVAL_MS)
+          return;
+        this.lastHeartbeatAt = ts;
+        void fs9.writeFile(this.lockPath, this.lockPayload(), { encoding: "utf-8" }).catch(() => {
+        });
       }
       /** Append one event; returns the validated envelope with its assigned seq. */
       async append(input) {
@@ -32297,6 +32362,7 @@ var init_writer = __esm({
         };
         SessionEventEnvelopeSchema.parse(envelope);
         this.nextSeq += 1;
+        this.chain = this.chain.then(() => this.maybeHeartbeat());
         const line = JSON.stringify(envelope) + "\n";
         this.chain = this.chain.then(() => fs9.appendFile(this.eventsPath, line, "utf-8"));
         await this.chain;
@@ -33771,7 +33837,7 @@ async function createExecutionContext(options = {}) {
       workspaceKind: workspace.kind
     }
   });
-  const fs45 = options.fs ?? new NodeFsProvider(workspace);
+  const fs46 = options.fs ?? new NodeFsProvider(workspace);
   const shell = options.shell ?? new NodeShellProvider(workspace);
   const subagent = options.subagent ?? NOOP_SUBAGENT_PROVIDER;
   const env = options.env ?? process.env;
@@ -33779,7 +33845,7 @@ async function createExecutionContext(options = {}) {
     sessionId: sessionId2,
     profile,
     workspace,
-    fs: fs45,
+    fs: fs46,
     shell,
     subagent,
     appendSessionEvent: (input) => writer.append(input),
@@ -34030,16 +34096,16 @@ function runRetentionFromEnv() {
     maxTotalBytes: Number.isFinite(parseMb) && parseMb > 0 ? Math.round(parseMb * 1024 * 1024) : DEFAULT_RUN_RETENTION_MAX_MB * 1024 * 1024
   };
 }
-async function dirSize(path91) {
+async function dirSize(path92) {
   let total = 0;
   let entries;
   try {
-    entries = await readdir(path91, { withFileTypes: true });
+    entries = await readdir(path92, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child = join13(path91, entry.name);
+    const child = join13(path92, entry.name);
     if (entry.isDirectory())
       total += await dirSize(child);
     else {
@@ -34066,19 +34132,19 @@ async function enforceRunRetention(runsDir, options = {}) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const path91 = join13(runsDir, entry.name);
+    const path92 = join13(runsDir, entry.name);
     let startedAt = 0;
     let endedAt;
     let completed = false;
     try {
-      const manifest = JSON.parse(await readFile(join13(path91, "manifest.json"), "utf8"));
+      const manifest = JSON.parse(await readFile(join13(path92, "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: path91, startedAt, endedAt, completed, bytes: await dirSize(path91) });
+    infos.push({ name: entry.name, path: path92, startedAt, endedAt, completed, bytes: await dirSize(path92) });
   }
   const remove = async (info) => {
     await rm(info.path, { recursive: true, force: true });
@@ -34850,12 +34916,12 @@ var init_engine = __esm({
        * content digest) and the returned ref carries the event seq when the
        * emitter resolved one.
        */
-      async fsEvidence(observation, path91, sha256, content, extra = {}) {
+      async fsEvidence(observation, path92, sha256, content, extra = {}) {
         const digest = sha256 && content !== void 0 ? sha256(content) : void 0;
-        const seq = await this.emitEvidence({ observation, path: path91, ...extra, ...digest ? { digest } : {} });
+        const seq = await this.emitEvidence({ observation, path: path92, ...extra, ...digest ? { digest } : {} });
         return {
           tier: "fs-observation",
-          ref: path91,
+          ref: path92,
           capturedAt: Date.now(),
           ...digest ? { digest } : {},
           ...seq !== void 0 ? { seq } : {}
@@ -34863,25 +34929,25 @@ var init_engine = __esm({
       }
       async evalFileExists(check2, done) {
         const sha256 = this.options.sha256 ?? defaultSha256;
-        const fs45 = this.services.fs;
-        if (!fs45)
+        const fs46 = this.services.fs;
+        if (!fs46)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
-        const exists = await fs45.exists(check2.path);
+        const exists = await fs46.exists(check2.path);
         if (!exists) {
           await this.emitEvidence({ observation: "file-exists", path: check2.path, exists: false });
           return done({ status: "fail", evidence: [], detail: `file not found: ${check2.path}` });
         }
-        const content = await fs45.readFile(check2.path).catch(() => "");
+        const content = await fs46.readFile(check2.path).catch(() => "");
         return done({
           status: "pass",
           evidence: [await this.fsEvidence("file-exists", check2.path, sha256, content, { exists: true })]
         });
       }
       async evalFileAbsent(check2, done) {
-        const fs45 = this.services.fs;
-        if (!fs45)
+        const fs46 = this.services.fs;
+        if (!fs46)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
-        const exists = await fs45.exists(check2.path);
+        const exists = await fs46.exists(check2.path);
         if (exists) {
           await this.emitEvidence({ observation: "file-absent", path: check2.path, exists: true });
           return done({ status: "fail", evidence: [], detail: `file still present: ${check2.path}` });
@@ -34893,12 +34959,12 @@ var init_engine = __esm({
       }
       async evalFileContains(check2, done) {
         const sha256 = this.options.sha256 ?? defaultSha256;
-        const fs45 = this.services.fs;
-        if (!fs45)
+        const fs46 = this.services.fs;
+        if (!fs46)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
         let content;
         try {
-          content = await fs45.readFile(check2.path);
+          content = await fs46.readFile(check2.path);
         } catch {
           await this.emitEvidence({ observation: "file-contains", path: check2.path, readable: false });
           return done({ status: "fail", evidence: [], detail: `file not readable: ${check2.path}` });
@@ -35762,6 +35828,7 @@ __export(dist_exports, {
   CriterionSchema: () => CriterionSchema,
   CriterionSourceSchema: () => CriterionSourceSchema,
   DEFAULT_CONTEXT_POLICY: () => DEFAULT_CONTEXT_POLICY,
+  DEFAULT_HEARTBEAT_STALE_MS: () => DEFAULT_HEARTBEAT_STALE_MS,
   DEFAULT_MAX_NODES: () => DEFAULT_MAX_NODES,
   DEFAULT_MAX_TENTACLES: () => DEFAULT_MAX_TENTACLES,
   DEFAULT_MEMORY_SCORING_WEIGHTS: () => DEFAULT_MEMORY_SCORING_WEIGHTS,
@@ -35992,6 +36059,7 @@ __export(dist_exports, {
   createGraph: () => createGraph,
   createRecorderObserver: () => createRecorderObserver,
   createRoutedRequestSnapshot: () => createRoutedRequestSnapshot,
+  defaultLockLivenessProbe: () => defaultLockLivenessProbe,
   defaultPersonaParse: () => defaultPersonaParse,
   defaultResourcePolicy: () => defaultResourcePolicy,
   deriveInitialContract: () => deriveInitialContract,
@@ -36009,6 +36077,7 @@ __export(dist_exports, {
   enforceRunRetention: () => enforceRunRetention,
   evaluateBudgetContinuation: () => evaluateBudgetContinuation,
   evaluateCompletion: () => evaluateCompletion,
+  evaluateLockTakeover: () => evaluateLockTakeover,
   evaluateMissionContinuation: () => evaluateMissionContinuation,
   evaluateResourceReserveGate: () => evaluateResourceReserveGate,
   executeTool: () => executeTool,
@@ -36160,6 +36229,7 @@ __export(dist_exports, {
   replayChairmanTextTools: () => replayChairmanTextTools,
   resolveAgentSkills: () => resolveAgentSkills,
   resolveCouncilRunMode: () => resolveCouncilRunMode,
+  resolveHeartbeatStaleMs: () => resolveHeartbeatStaleMs,
   resolveInterventions: () => resolveInterventions,
   resolveJailed: () => resolveJailed,
   resolveMaxTentacles: () => resolveMaxTentacles,
@@ -37360,6 +37430,11 @@ var init_sessionSpine = __esm({
         } catch (err) {
           if (err instanceof SessionLogLockedError) {
             mirror.status = "locked";
+            mirror.warnOnce(
+              err,
+              `session lock held by another (possibly dead) owner: ${err.message} \u2014 the turn resumed WITHOUT derived spine context`,
+              "locked"
+            );
           } else {
             mirror.status = "degraded";
             mirror.warnOnce(err);
@@ -37662,13 +37737,13 @@ var init_sessionSpine = __esm({
       appendEvent(input) {
         return this.append(input);
       }
-      warnOnce(err) {
+      warnOnce(err, message, label = "degraded") {
         if (this.warned || this.options.quiet) return;
         this.warned = true;
-        const msg = err instanceof Error ? err.message : String(err);
+        const msg = message ?? (err instanceof Error ? err.message : String(err));
         try {
           process.stderr.write(
-            `[zelari] session spine degraded for ${this.sessionId.slice(0, 8)}\u2026: ${msg} (transcript continues on the 1.x log)
+            `[zelari] session spine ${label} for ${this.sessionId.slice(0, 8)}\u2026: ${msg} (transcript continues on the 1.x log)
 `
           );
         } catch {
@@ -38029,9 +38104,9 @@ function spillToolOutput(fullText, meta3) {
     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 path91 = join14(dir, file2);
-    writeFileSync11(path91, fullText, "utf8");
-    return path91;
+    const path92 = join14(dir, file2);
+    writeFileSync11(path92, fullText, "utf8");
+    return path92;
   } catch {
     return null;
   }
@@ -38077,10 +38152,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail2}`;
   }
   if (doSpill) {
-    const path91 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path91) {
+    const path92 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path92) {
       const spillNote = `
-\u2026 [full output spilled to: ${path91} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path92} \u2014 re-read with read_file if you need the complete text] \u2026`;
       if (preview.includes("] \u2026\n")) {
         preview = preview.replace("] \u2026\n", `] \u2026${spillNote}
 `);
@@ -42052,28 +42127,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path91) {
-        if (!existsSync19(path91)) {
-          throw new Error(`File not found: ${path91}`);
+      read(path92) {
+        if (!existsSync19(path92)) {
+          throw new Error(`File not found: ${path92}`);
         }
-        const md = readFileSync16(path91, "utf8");
+        const md = readFileSync16(path92, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path91) {
-        if (!existsSync19(path91)) return null;
-        return this.read(path91);
+      readIfExists(path92) {
+        if (!existsSync19(path92)) return null;
+        return this.read(path92);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path91, meta3, body) {
-        mkdirSync10(dirname2(path91), { recursive: true });
-        const tmp = path91 + ".tmp-" + process.pid;
+      write(path92, meta3, body) {
+        mkdirSync10(dirname2(path92), { recursive: true });
+        const tmp = path92 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync13(tmp, md, "utf8");
-        renameSync(tmp, path91);
+        renameSync(tmp, path92);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -42135,8 +42210,8 @@ function nextPlanTaskId(store6) {
   return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
-  const path91 = join18(rootDir, "plan-tasks", `${task.id}.md`);
-  mkdirSync11(dirname3(path91), { recursive: true });
+  const path92 = join18(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync11(dirname3(path92), { recursive: true });
   const meta3 = {
     kind: "task",
     id: task.id,
@@ -42157,7 +42232,7 @@ function writePlanTaskArtifact(rootDir, task) {
     task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
     ""
   ].filter((l) => l !== null).join("\n");
-  new Storage().write(path91, meta3, body);
+  new Storage().write(path92, meta3, body);
 }
 function loadHandle(rootDir) {
   const jsonPath = join18(rootDir, "plan.json");
@@ -42863,6 +42938,100 @@ var init_inspectCommand = __esm({
   }
 });
 
+// src/cli/safety/selfKillGuard.ts
+function cleanToken(raw) {
+  return raw.replace(/^["']+|["',]+\s*$/g, "").trim();
+}
+function isProtectedImage(name) {
+  return PROTECTED_IMAGE_RE.test(cleanToken(name));
+}
+function stripSubstitutions(cmd) {
+  return cmd.replace(/\$\([^)]*\)/g, " ( ) ").replace(/\$\{[^}]*\}/g, " ").replace(/`[^`]*`/g, " ` ` ");
+}
+function findImageKill(cmd) {
+  const im = cmd.match(/\/{1,2}im\s+["']?([a-z0-9_.-]+)/i);
+  if (im && /\btaskkill\b/i.test(cmd) && isProtectedImage(im[1])) {
+    return `taskkill /IM ${cleanToken(im[1])}`;
+  }
+  const fi = cmd.match(/imagename\s+eq\s+["']?([a-z0-9_.-]+)/i);
+  if (fi && /\btaskkill\b/i.test(cmd) && isProtectedImage(fi[1])) {
+    return `taskkill /FI "IMAGENAME eq ${cleanToken(fi[1])}"`;
+  }
+  const nm = cmd.match(/\b(?:stop-process|kill)\b[^|;&]*-name\s+["']?([a-z0-9_.-]+)/i);
+  if (nm && isProtectedImage(nm[1])) {
+    return `Stop-Process -Name ${cleanToken(nm[1])}`;
+  }
+  if (/\bget-process\b[^|;&]*\bnode(?:\.exe)?\b/i.test(cmd) && /\|\s*[^|]*?(?:stop-process|\.\s*kill\s*\(|\bkill\b)/i.test(cmd)) {
+    return "Get-Process node | Stop-Process";
+  }
+  if (/\bpkill\b[^|;&]*\bnode(?:\.exe)?\b/i.test(cmd)) return "pkill node";
+  if (/\bkillall\b[^|;&]*\bnode(?:\.exe)?\b/i.test(cmd)) return "killall node";
+  if (/\bwmic\b[^|;&]*name\s*=\s*["']?node(?:\.exe)?["']?/i.test(cmd) && /\b(?:delete|terminate)\b/i.test(cmd)) {
+    return "wmic process delete node.exe";
+  }
+  return null;
+}
+function findPsPipelineKill(cmd) {
+  if (!/\bps\b[^|;&]*\|\s*(?:grep|findstr|awk|sed)[^|;&]*\bnode(?:\.exe)?\b/i.test(cmd)) {
+    return null;
+  }
+  if (!/\b(?:xargs\s+)?(?:kill|taskkill|pkill|killall|stop-process)\b/i.test(cmd)) {
+    return null;
+  }
+  return "ps | grep node | kill";
+}
+function findProtectedPidKill(cmd, ctx) {
+  const protectedPids = /* @__PURE__ */ new Set([
+    ctx.selfPid,
+    ...ctx.parentPid !== void 0 ? [ctx.parentPid] : [],
+    ...ctx.extraProtectedPids ?? []
+  ]);
+  const hit = (pid, shape) => protectedPids.has(pid) ? `${shape} ${pid}` : null;
+  const stripped = stripSubstitutions(cmd);
+  for (const m of stripped.matchAll(/\/{1,2}pid(?:list)?\s+([\d,\s]+)/gi)) {
+    for (const tok of m[1].split(/[\s,]+/)) {
+      const pid = Number.parseInt(tok, 10);
+      if (Number.isFinite(pid) && pid > 0) {
+        const h = hit(pid, "taskkill /PID");
+        if (h) return h;
+      }
+    }
+  }
+  for (const m of stripped.matchAll(/\b(?:stop-process|kill)\b[^|;&]*?-(?:id|pid)\s+(\d+)/gi)) {
+    const h = hit(Number.parseInt(m[1], 10), "Stop-Process -Id");
+    if (h) return h;
+  }
+  for (const m of stripped.matchAll(/\bkill\b([^|;&]*)/gi)) {
+    for (const tok of m[1].split(/\s+/)) {
+      if (!/^\d+$/.test(tok)) continue;
+      const h = hit(Number.parseInt(tok, 10), "kill");
+      if (h) return h;
+    }
+  }
+  return null;
+}
+function blockedVerdict(reason, match) {
+  return { blocked: true, reason, match, message: SELF_KILL_DENIAL_MESSAGE };
+}
+function inspectCommand(command, ctx) {
+  if (typeof command !== "string" || command.length === 0) return { blocked: false };
+  const imageMatch = findImageKill(command);
+  if (imageMatch) return blockedVerdict("node-image", imageMatch);
+  const pipelineMatch = findPsPipelineKill(command);
+  if (pipelineMatch) return blockedVerdict("ps-pipeline", pipelineMatch);
+  const pidMatch = findProtectedPidKill(command, ctx);
+  if (pidMatch) return blockedVerdict("protected-pid", pidMatch);
+  return { blocked: false };
+}
+var SELF_KILL_DENIAL_MESSAGE, PROTECTED_IMAGE_RE;
+var init_selfKillGuard = __esm({
+  "src/cli/safety/selfKillGuard.ts"() {
+    "use strict";
+    SELF_KILL_DENIAL_MESSAGE = "Blocked: this command would kill the agent host process itself (node image / own process tree). To stop a dev server, kill by PORT instead: run `netstat -ano | findstr :<port>` to find the listener PID, then `taskkill //PID <listener-pid>` \u2014 never kill node by image name.";
+    PROTECTED_IMAGE_RE = /^(?:node(?:\.exe)?|zelari(?:-code)?(?:\.exe)?)$/i;
+  }
+});
+
 // src/cli/safety/policyLoadMode.ts
 var policyLoadMode_exports = {};
 __export(policyLoadMode_exports, {
@@ -43252,6 +43421,13 @@ function createExecProcessTool(root, opts = {}) {
       if (blocked) {
         return typedErr(`[shell-blocked] exec_process refused (${blocked.reason}): ${blocked.pattern}`);
       }
+      const selfKill = inspectCommand([input.program, ...argv].join(" "), {
+        selfPid: process.pid,
+        parentPid: process.ppid
+      });
+      if (selfKill.blocked && selfKill.message) {
+        return typedErr(`[self-kill] exec_process refused: ${selfKill.message}`);
+      }
       let cwd;
       try {
         cwd = resolveSandboxedPath(input.cwd ?? ".", { root });
@@ -43326,6 +43502,7 @@ var init_execProcess = __esm({
     init_zod();
     init_toolTypes();
     init_shellBlocklist();
+    init_selfKillGuard();
     init_sandboxPath();
     init_osJail();
     execProcessInputSchema = external_exports.object({
@@ -45831,21 +46008,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path91 = getSshSecretsPath();
-  if (!existsSync25(path91)) return {};
+  const path92 = getSshSecretsPath();
+  if (!existsSync25(path92)) return {};
   try {
-    return JSON.parse(readFileSync20(path91, "utf8"));
+    return JSON.parse(readFileSync20(path92, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path91 = getSshSecretsPath();
-  mkdirSync12(dirname4(path91), { recursive: true });
-  writeFileSync15(path91, `${JSON.stringify(data, null, 2)}
+  const path92 = getSshSecretsPath();
+  mkdirSync12(dirname4(path92), { recursive: true });
+  writeFileSync15(path92, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path91, 384);
+    chmodSync(path92, 384);
   } catch {
   }
 }
@@ -45874,10 +46051,10 @@ function deleteSshPassword(id3) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path91 = getSshTargetsPath();
-  if (!existsSync25(path91)) return [];
+  const path92 = getSshTargetsPath();
+  if (!existsSync25(path92)) return [];
   try {
-    const parsed = JSON.parse(readFileSync20(path91, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path92, "utf8"));
     const list = Array.isArray(parsed.targets) ? parsed.targets : [];
     return list.filter(
       (t) => t && typeof t.id === "string" && typeof t.host === "string" && typeof t.user === "string"
@@ -45892,11 +46069,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path91 = getSshTargetsPath();
-  mkdirSync12(dirname4(path91), { recursive: true });
+  const path92 = getSshTargetsPath();
+  mkdirSync12(dirname4(path92), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync15(
-    path91,
+    path92,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -46142,11 +46319,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path91 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path92 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
     const allow = t.allowedCommands?.length ? ` allowed=${t.allowedCommands.join("|")}` : " allowed=status-only";
     const auth = t.auth === "password" ? " auth=password" : t.auth === "keyPath" ? " auth=key" : " auth=agent";
     lines.push(
-      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path91}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path92}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -49201,6 +49378,23 @@ function wrapWithShellSafety(original, audit, sessionId2, root, jail) {
           }
           throw err;
         }
+        const selfKill = inspectCommand(cmd, { selfPid: process.pid, parentPid: process.ppid });
+        if (selfKill.blocked && selfKill.message) {
+          await audit.append({
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            sessionId: sessionId2,
+            tool: original.name,
+            args: redactForAudit(args),
+            ok: false,
+            resultSummary: selfKill.match ?? "self_kill",
+            durationMs: 0,
+            error: "self_kill_blocked"
+          });
+          return {
+            ok: false,
+            error: `[self-kill] ${selfKill.message}`
+          };
+        }
       }
       const rawCwd = args["cwd"];
       try {
@@ -49327,6 +49521,7 @@ var init_toolRegistry = __esm({
     init_resourceClaims();
     init_osJail();
     init_toolResultCache();
+    init_selfKillGuard();
     init_toolTypes();
     init_skills2();
     HARNESS_BUILTIN_NAMES = /* @__PURE__ */ new Set([
@@ -54634,8 +54829,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path91 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path91);
+  const path92 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path92);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -54813,7 +55008,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path91 = join31(ctx.rootDir, "milestones", `${id3}.md`);
+  const path92 = join31(ctx.rootDir, "milestones", `${id3}.md`);
   const meta3 = {
     kind: "milestone",
     id: id3,
@@ -54830,7 +55025,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path91, meta3, body);
+  ctx.storage.write(path92, meta3, body);
   return { id: id3, created: true };
 }
 function readPlanSummary(ctx) {
@@ -55034,7 +55229,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id3 = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path91 = workspaceArtifact(ctx.rootDir, "decisions", id3);
+        const path92 = workspaceArtifact(ctx.rootDir, "decisions", id3);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -55060,7 +55255,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path91, meta3, body);
+        ctx.storage.write(path92, meta3, body);
         return `ADR ${id3} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -55142,14 +55337,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path91 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path92 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path91, meta3, content);
+        ctx.storage.write(path92, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -55775,10 +55970,10 @@ function getUserMcpPath() {
 function getProjectMcpPath(projectRoot) {
   return join32(projectRoot, ".zelari", "mcp.json");
 }
-function readFile6(path91) {
-  if (!existsSync37(path91)) return {};
+function readFile6(path92) {
+  if (!existsSync37(path92)) return {};
   try {
-    const parsed = JSON.parse(readFileSync29(path91, "utf8"));
+    const parsed = JSON.parse(readFileSync29(path92, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       const hasCommand = !!cfg && typeof cfg.command === "string" && !!cfg.command.trim();
@@ -55800,10 +55995,10 @@ function readFile6(path91) {
     return {};
   }
 }
-function writeFile2(path91, servers) {
-  mkdirSync16(dirname9(path91), { recursive: true });
+function writeFile2(path92, servers) {
+  mkdirSync16(dirname9(path92), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync18(path91, `${JSON.stringify(body, null, 2)}
+  writeFileSync18(path92, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -55841,9 +56036,9 @@ function upsertMcpServer(opts) {
       error: "either command (stdio) or url (http) is required"
     };
   }
-  let path91;
+  let path92;
   if (opts.scope === "user") {
-    path91 = getUserMcpPath();
+    path92 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -55852,9 +56047,9 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path91 = getProjectMcpPath(root);
+    path92 = getProjectMcpPath(root);
   }
-  const current = readFile6(path91);
+  const current = readFile6(path92);
   current[name] = {
     command: hasCommand ? opts.config.command.trim() : void 0,
     args: opts.config.args,
@@ -55865,21 +56060,21 @@ function upsertMcpServer(opts) {
     serial: opts.config.serial,
     enabled: opts.config.enabled !== false
   };
-  writeFile2(path91, current);
-  return { ok: true, path: path91 };
+  writeFile2(path92, current);
+  return { ok: true, path: path92 };
 }
 function removeMcpServer(opts) {
-  const path91 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path91) {
+  const path92 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path92) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile6(path91);
+  const current = readFile6(path92);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path91}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path92}` };
   }
   delete current[opts.name];
-  writeFile2(path91, current);
-  return { ok: true, path: path91 };
+  writeFile2(path92, current);
+  return { ok: true, path: path92 };
 }
 var init_mcpConfigIo = __esm({
   "src/cli/mcp/mcpConfigIo.ts"() {
@@ -56348,10 +56543,10 @@ import { createHash as createHash20 } from "node:crypto";
 import { join as join34 } from "node:path";
 import { readFile as readFile7 } from "node:fs/promises";
 async function readPackageJson3(projectRoot) {
-  const path91 = join34(projectRoot, "package.json");
-  if (!existsSync39(path91)) return null;
+  const path92 = join34(projectRoot, "package.json");
+  if (!existsSync39(path92)) return null;
   try {
-    return JSON.parse(await readFile7(path91, "utf8"));
+    return JSON.parse(await readFile7(path92, "utf8"));
   } catch {
     return null;
   }
@@ -56433,9 +56628,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path91 = join34(ctx.rootDir, "risks.md");
-  if (!existsSync39(path91)) return "_No open questions._";
-  const content = readFileSync31(path91, "utf8");
+  const path92 = join34(ctx.rootDir, "risks.md");
+  if (!existsSync39(path92)) return "_No open questions._";
+  const content = readFileSync31(path92, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -56709,9 +56904,9 @@ function versionKey(value) {
 function firstString2(v) {
   return typeof v === "string" && v.trim().length > 0 ? v : null;
 }
-function readFileSyncSafe(path91) {
+function readFileSyncSafe(path92) {
   try {
-    return readFileSync32(path91, "utf8");
+    return readFileSync32(path92, "utf8");
   } catch {
     return null;
   }
@@ -57174,8 +57369,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path91 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path91, completion };
+      const path92 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path92, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -58511,7 +58706,7 @@ function safeSocketPath(socketPath) {
   return socketPath.trim();
 }
 function startPermissionBroker(socketPath, handlers, opts) {
-  const path91 = safeSocketPath(socketPath);
+  const path92 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer2((socket) => {
@@ -58611,10 +58806,10 @@ function startPermissionBroker(socketPath, handlers, opts) {
   return new Promise((resolve9, reject) => {
     const onError = (err) => reject(err);
     server.once("error", onError);
-    server.listen(path91, () => {
+    server.listen(path92, () => {
       server.removeListener("error", onError);
       resolve9({
-        socketPath: path91,
+        socketPath: path92,
         stop: () => new Promise((res) => {
           for (const s of sockets) s.destroy();
           sockets.clear();
@@ -58625,7 +58820,7 @@ function startPermissionBroker(socketPath, handlers, opts) {
             if (done) return;
             done = true;
             if (process.platform !== "win32") {
-              unlink(path91, () => res());
+              unlink(path92, () => res());
             } else {
               res();
             }
@@ -58638,11 +58833,11 @@ function startPermissionBroker(socketPath, handlers, opts) {
   });
 }
 function requestBrokerAsk(socketPath, ask, opts) {
-  const path91 = safeSocketPath(socketPath);
+  const path92 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const connectTimeoutMs = opts?.connectTimeoutMs ?? PERMISSION_BROKER_DEFAULT_CONNECT_TIMEOUT_MS;
   return new Promise((resolve9, reject) => {
-    const socket = connect(path91);
+    const socket = connect(path92);
     let buffer = "";
     let settled = false;
     const settle = (fn) => {
@@ -58657,7 +58852,7 @@ function requestBrokerAsk(socketPath, ask, opts) {
       settle(
         () => reject(
           new Error(
-            `permission broker unavailable at "${path91}" (connect timed out after ${connectTimeoutMs}ms)`
+            `permission broker unavailable at "${path92}" (connect timed out after ${connectTimeoutMs}ms)`
           )
         )
       );
@@ -64475,7 +64670,7 @@ async function loadExtensionsFromDirs(dirs, options = {}) {
     skipped
   };
   const fsRoot = options.fsRoot ?? process.cwd();
-  let fs45 = null;
+  let fs46 = null;
   const pending = [];
   for (const dir of dirs) {
     const files = candidateFiles(dir.path);
@@ -64530,9 +64725,9 @@ async function loadExtensionsFromDirs(dirs, options = {}) {
       skipped.push(`${file2}: missing ZelariExtension export`);
       continue;
     }
-    if (!fs45) fs45 = bindSandboxedFs(fsRoot);
+    if (!fs46) fs46 = bindSandboxedFs(fsRoot);
     try {
-      await runtime.registry.registerExtension(ext, { fs: fs45 });
+      await runtime.registry.registerExtension(ext, { fs: fs46 });
       runtime.loaded.push({ id: ext.id, file: file2, scope });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -67846,7 +68041,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path91 = skillFilePath(dir, name);
+  const path92 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -67855,13 +68050,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path91);
+  const parsed = parseSkillMd(content, path92);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync21(dirname13(path91), { recursive: true });
-  writeFileSync24(path91, content, "utf8");
-  return { ok: true, path: path91 };
+  mkdirSync21(dirname13(path92), { recursive: true });
+  writeFileSync24(path92, content, "utf8");
+  return { ok: true, path: path92 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -67879,8 +68074,8 @@ function removeSkill(opts) {
     dir = getProjectSkillsDir(root);
   }
   const skillDir = join46(dir, name);
-  const path91 = skillFilePath(dir, name);
-  if (!existsSync52(path91) && !existsSync52(skillDir)) {
+  const path92 = skillFilePath(dir, name);
+  if (!existsSync52(path92) && !existsSync52(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -67891,7 +68086,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path91 };
+  return { ok: true, path: path92 };
 }
 var NAME_RE, BUILTIN_SKILL_MODULES, builtinsLoaded;
 var init_skillConfigIo = __esm({
@@ -68710,12 +68905,12 @@ function ensureHome() {
   }
 }
 function loadCompanionConfig() {
-  const path91 = getCompanionConfigPath();
-  if (!existsSync53(path91)) {
+  const path92 = getCompanionConfigPath();
+  if (!existsSync53(path92)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync41(path91, "utf8"));
+    const raw = JSON.parse(readFileSync41(path92, "utf8"));
     const projects = Array.isArray(raw.projects) ? raw.projects.filter(
       (p3) => p3 && typeof p3.path === "string" && p3.path.trim() && typeof (p3.id ?? p3.name) === "string"
     ).map((p3) => ({
@@ -68753,16 +68948,16 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path91 = getCompanionTokenPath();
-  if (existsSync53(path91)) {
-    const t = readFileSync41(path91, "utf8").trim();
+  const path92 = getCompanionTokenPath();
+  if (existsSync53(path92)) {
+    const t = readFileSync41(path92, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes7(24).toString("base64url");
-  writeFileSync25(path91, token + "\n", "utf8");
+  writeFileSync25(path92, token + "\n", "utf8");
   try {
-    const fs45 = __require("node:fs");
-    fs45.chmodSync?.(path91, 384);
+    const fs46 = __require("node:fs");
+    fs46.chmodSync?.(path92, 384);
   } catch {
   }
   return { token, created: true };
@@ -68787,17 +68982,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path91 = raw.trim();
-    if (!path91) continue;
-    let id3 = slugFromPath(path91);
+    const path92 = raw.trim();
+    if (!path92) continue;
+    let id3 = slugFromPath(path92);
     let n = 2;
-    while (byId.has(id3) && byId.get(id3).path !== path91) {
-      id3 = `${slugFromPath(path91)}-${n++}`;
+    while (byId.has(id3) && byId.get(id3).path !== path92) {
+      id3 = `${slugFromPath(path92)}-${n++}`;
     }
     byId.set(id3, {
       id: id3,
-      name: slugFromPath(path91),
-      path: path91
+      name: slugFromPath(path92),
+      path: path92
     });
   }
   return [...byId.values()];
@@ -68844,6 +69039,63 @@ var init_config = __esm({
   }
 });
 
+// src/cli/serve/spineLockSweep.ts
+import { promises as fs45 } from "node:fs";
+import path88 from "node:path";
+async function sweepOrphanSpineLocks(sessionsDir, options = {}) {
+  const dir = sessionsDir ?? resolveSessionsDir();
+  const onSwept = options.onSwept ?? ((sessionId2, reason) => {
+    console.error(
+      `[zelari] spine-lock sweep: removed orphan writer.lock for session ${sessionId2} (${reason})`
+    );
+  });
+  const now = options.now ?? Date.now;
+  const probe = options.probe ?? defaultLockLivenessProbe;
+  const result = { swept: 0, kept: 0, errors: 0 };
+  let entries;
+  try {
+    entries = await fs45.readdir(dir);
+  } catch {
+    return result;
+  }
+  for (const sessionId2 of entries) {
+    const lockPath2 = path88.join(dir, sessionId2, "writer.lock");
+    try {
+      const raw = await fs45.readFile(lockPath2, "utf-8");
+      let lockInfo = {};
+      try {
+        lockInfo = JSON.parse(raw);
+      } catch {
+        result.kept += 1;
+        continue;
+      }
+      const verdict = evaluateLockTakeover(lockInfo, {
+        now: now(),
+        probe,
+        heartbeatStaleMs: options.heartbeatStaleMs ?? resolveHeartbeatStaleMs()
+      });
+      if (!verdict.takeover) {
+        result.kept += 1;
+        continue;
+      }
+      await fs45.rm(lockPath2, { force: true });
+      result.swept += 1;
+      onSwept(sessionId2, verdict.reason);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT" || code === "ENOTDIR") continue;
+      result.errors += 1;
+    }
+  }
+  return result;
+}
+var init_spineLockSweep = __esm({
+  "src/cli/serve/spineLockSweep.ts"() {
+    "use strict";
+    init_session();
+  }
+});
+
 // src/cli/serve/harnessServer.ts
 var harnessServer_exports = {};
 __export(harnessServer_exports, {
@@ -69091,6 +69343,10 @@ function startHarnessServer(options = {}) {
 async function runHarnessServer() {
   setActivePolicyLoadSurface("headless");
   setActiveProofPersistenceSurface("headless");
+  try {
+    await sweepOrphanSpineLocks();
+  } catch {
+  }
   process.env.ZELARI_SERVE_HARNESS = "1";
   const started = startHarnessServer();
   await new Promise((resolvePromise) => {
@@ -69115,6 +69371,7 @@ var init_harnessServer = __esm({
     init_completionProofPersist();
     init_policyGate();
     init_policyLoadMode();
+    init_spineLockSweep();
   }
 });
 
@@ -69772,9 +70029,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path91 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path92 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path91 === "/health" || path91 === "/v1/health")) {
+      if (req.method === "GET" && (path92 === "/health" || path92 === "/v1/health")) {
         sendJson2(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -69786,18 +70043,18 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path91.startsWith("/v1")) {
+      if (path92.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson2(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path91 === "/v1/config") {
+      if (req.method === "GET" && path92 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson2(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path91 === "/v1/projects") {
+      if (req.method === "GET" && path92 === "/v1/projects") {
         sendJson2(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -69808,7 +70065,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path91 === "/v1/runs") {
+      if (req.method === "GET" && path92 === "/v1/runs") {
         sendJson2(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -69826,7 +70083,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path91 === "/v1/runs") {
+      if (req.method === "POST" && path92 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -69874,7 +70131,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path91);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path92);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -69939,7 +70196,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path91);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path92);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -69950,7 +70207,7 @@ async function runCompanionServe(opts = {}) {
         sendJson2(res, 200, { ok: true, cancelled: runId });
         return;
       }
-      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path91);
+      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path92);
       if (req.method === "POST" && steerMatch) {
         const runId = steerMatch[1];
         const raw = await readBody(req);
@@ -70117,11 +70374,11 @@ import { execSync as execSync2 } from "node:child_process";
 import { existsSync as existsSync55, readFileSync as readFileSync42, readlinkSync, statSync as statSync10 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import path88 from "node:path";
+import path89 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path88.join(dir, "package.json");
+    const candidate = path89.join(dir, "package.json");
     if (existsSync55(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync42(candidate, "utf8"));
@@ -70129,11 +70386,11 @@ function findPackageRoot(start) {
       } catch {
       }
     }
-    const parent = path88.dirname(dir);
+    const parent = path89.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path88.resolve(__dirname3, "..", "..", "..");
+  return path89.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -70147,7 +70404,7 @@ function tryExec(cmd) {
 }
 function readPackageJson4() {
   try {
-    const pkgPath = path88.join(packageRoot, "package.json");
+    const pkgPath = path89.join(packageRoot, "package.json");
     return JSON.parse(readFileSync42(pkgPath, "utf8"));
   } catch {
     return null;
@@ -70163,7 +70420,7 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path88.join(prefix, shimName);
+  const shimPath = path89.join(prefix, shimName);
   if (!existsSync55(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
@@ -70191,8 +70448,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path88.resolve(path88.dirname(shimPath), target);
-    const expected = path88.join(
+    const resolved = path89.resolve(path89.dirname(shimPath), target);
+    const expected = path89.join(
       prefix,
       "node_modules",
       pkgName,
@@ -70234,7 +70491,7 @@ function checkNode(pkg) {
   return OK(`node ${raw} (engines.node ${enginesNode ?? ">= 20.0.0"})`);
 }
 function checkBundle() {
-  const bundle = path88.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path89.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync55(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -70255,7 +70512,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path88.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path89.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -70455,7 +70712,7 @@ var init_doctor = __esm({
     init_metrics3();
     init_contextGrowthSummary();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path88.dirname(fileURLToPath3(import.meta.url));
+    __dirname3 = path89.dirname(fileURLToPath3(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -70639,7 +70896,7 @@ __export(inspectSession_exports, {
   renderInspectReport: () => renderInspectReport,
   runInspectSession: () => runInspectSession
 });
-import path89 from "node:path";
+import path90 from "node:path";
 import { existsSync as existsSync56 } from "node:fs";
 function formatLimit(limit) {
   return `${Math.round(limit / 1e3)}k`;
@@ -70673,8 +70930,8 @@ function renderInspectReport(state3) {
 }
 async function runInspectSession(opts) {
   const sessionsDir = resolveSessionsDir({ workspaceRoot: opts.cwd ?? process.cwd() });
-  const sessionDir = path89.join(sessionsDir, opts.sessionId);
-  const eventsPath = path89.join(sessionDir, "events.jsonl");
+  const sessionDir = path90.join(sessionsDir, opts.sessionId);
+  const eventsPath = path90.join(sessionDir, "events.jsonl");
   if (!existsSync56(sessionDir)) {
     console.error(`zelari-code inspect: no session directory at ${sessionDir}`);
     return 1;
@@ -70708,15 +70965,15 @@ __export(inspect_exports, {
   collectInspectReport: () => collectInspectReport,
   runInspect: () => runInspect
 });
-import path90 from "node:path";
+import path91 from "node:path";
 import { existsSync as existsSync57, readFileSync as readFileSync43, readdirSync as readdirSync12 } from "node:fs";
 import { homedir as homedir17 } from "node:os";
 async function collectInspectReport(cwd = process.cwd()) {
   ensureBuiltinSkillsLoadedSync();
   const snap = listSkillsSnapshot(cwd);
   const mcp = listMcpServers(cwd);
-  const userMcpPath = path90.join(homedir17(), ".zelari-code", "mcp.json");
-  const projectMcpPath = path90.join(cwd, ".zelari", "mcp.json");
+  const userMcpPath = path91.join(homedir17(), ".zelari-code", "mcp.json");
+  const projectMcpPath = path91.join(cwd, ".zelari", "mcp.json");
   const globalHooks = globalHooksDir();
   const projectHooks = projectHooksDir(cwd);
   const projectTrusted = isFolderTrusted(cwd);
@@ -70744,9 +71001,9 @@ async function collectInspectReport(cwd = process.cwd()) {
     configSources: [
       { path: userMcpPath, exists: existsSync57(userMcpPath) },
       { path: projectMcpPath, exists: existsSync57(projectMcpPath) },
-      { path: path90.join(homedir17(), ".zelari-code", "provider.json"), exists: existsSync57(path90.join(homedir17(), ".zelari-code", "provider.json")) },
-      { path: path90.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync57(path90.join(cwd, ".zelari", "AGENTS.md")) },
-      { path: path90.join(cwd, "AGENTS.md"), exists: existsSync57(path90.join(cwd, "AGENTS.md")) }
+      { path: path91.join(homedir17(), ".zelari-code", "provider.json"), exists: existsSync57(path91.join(homedir17(), ".zelari-code", "provider.json")) },
+      { path: path91.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync57(path91.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path91.join(cwd, "AGENTS.md"), exists: existsSync57(path91.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -70786,8 +71043,8 @@ function listJsonFiles(dir) {
 }
 function findAgentsMd(cwd) {
   const candidates = [
-    path90.join(cwd, "AGENTS.md"),
-    path90.join(cwd, ".zelari", "AGENTS.md")
+    path91.join(cwd, "AGENTS.md"),
+    path91.join(cwd, ".zelari", "AGENTS.md")
   ];
   const found = [];
   for (const c of candidates) {
@@ -80432,8 +80689,8 @@ function normalizeDraft(raw, sourceUrl, provider, model) {
   let name = String(o.name ?? "").trim().toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
   if (!name || !/^[a-z0-9][a-z0-9-]{0,63}$/.test(name)) {
     try {
-      const path91 = new URL(sourceUrl).pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
-      name = path91 && /^[a-z0-9]/.test(path91) ? path91 : "imported-skill";
+      const path92 = new URL(sourceUrl).pathname.split("/").filter(Boolean).pop()?.replace(/\.[a-z0-9]+$/i, "").toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+      name = path92 && /^[a-z0-9]/.test(path92) ? path92 : "imported-skill";
     } catch {
       name = "imported-skill";
     }