zelari-code 2.0.0-alpha.5 → 2.0.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, path63) {
-  if (!path63)
+function getElementAtPath(obj, path64) {
+  if (!path64)
     return obj;
-  return path63.reduce((acc, key) => acc?.[key], obj);
+  return path64.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(path63, issues) {
+function prefixIssues(path64, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path63);
+    iss.path.unshift(path64);
     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, path63 = []) => {
+  const processError = (error52, path64 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path63, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path64, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path63, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path64, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path63, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path64, ...issue2.path]);
       } else {
-        const fullpath = [...path63, ...issue2.path];
+        const fullpath = [...path64, ...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, path63 = []) => {
+  const processError = (error52, path64 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path63, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path64, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path63, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path64, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path63, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path64, ...issue2.path]);
       } else {
-        const fullpath = [...path63, ...issue2.path];
+        const fullpath = [...path64, ...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 path63 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path63) {
+  const path64 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path64) {
     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 path63 = ref.slice(1).split("/").filter(Boolean);
-  if (path63.length === 0) {
+  const path64 = ref.slice(1).split("/").filter(Boolean);
+  if (path64.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path63[0] === defsKey) {
-    const key = path63[1];
+  if (path64[0] === defsKey) {
+    const key = path64[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -19750,11 +19750,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path63 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path64 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path63,
+            path: path64,
             title,
             content,
             format: "markdown",
@@ -19763,7 +19763,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path63}".`;
+          return `Document "${title}" created at "${path64}".`;
         }
       }
     ];
@@ -24197,11 +24197,11 @@ var init_synthesisAudit = __esm({
 import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join2 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path63 = join2(zelariRoot, "nfr-spec.json");
-  if (!existsSync7(path63))
+  const path64 = join2(zelariRoot, "nfr-spec.json");
+  if (!existsSync7(path64))
     return null;
   try {
-    const raw = JSON.parse(readFileSync7(path63, "utf8"));
+    const raw = JSON.parse(readFileSync7(path64, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -26507,9 +26507,9 @@ var init_types4 = __esm({
 import { readFileSync as readFileSync12 } from "node:fs";
 import { join as join8 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path63 = join8(zelariRoot, LESSONS_FILE);
+  const path64 = join8(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync12(path63, "utf8");
+    const raw = readFileSync12(path64, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -26610,8 +26610,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path63 = join9(zelariRoot, LESSONS_FILE);
-  appendFileSync(path63, `${JSON.stringify(lesson)}
+  const path64 = join9(zelariRoot, LESSONS_FILE);
+  appendFileSync(path64, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -27225,9 +27225,9 @@ function findCycle(nodes) {
     if (color.get(start) !== WHITE)
       continue;
     const stack = [[start, 0]];
-    const path63 = [];
+    const path64 = [];
     color.set(start, GRAY);
-    path63.push(start);
+    path64.push(start);
     while (stack.length > 0) {
       const top = stack[stack.length - 1];
       const [id, idx] = top;
@@ -27240,17 +27240,17 @@ function findCycle(nodes) {
           continue;
         const c = color.get(dep);
         if (c === GRAY) {
-          const at = path63.indexOf(dep);
-          return [...path63.slice(at), dep];
+          const at = path64.indexOf(dep);
+          return [...path64.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path63.push(dep);
+          path64.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id, BLACK);
-        path63.pop();
+        path64.pop();
         stack.pop();
       }
     }
@@ -28170,8 +28170,8 @@ var init_runner = __esm({
           failed: [...this.tentaclesById.values()].filter((r) => r.status === "error"),
           pending: []
         };
-        const path63 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
-        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path63}`);
+        const path64 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
+        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path64}`);
         return snapshot;
       }
       callLog(msg, data) {
@@ -28271,7 +28271,14 @@ var init_types8 = __esm({
       "council.member",
       "mission.phase",
       "mission.replan",
+      // F4 (doc §6 advisory continuation): driver → host advice record. State-only
+      // (never model-surface): the recommendation must not feed the model loop.
+      "mission.progress",
       "verification.run",
+      // F3 (ADR-0023 §5 evidence traceability): per-observation state event —
+      // the session-log anchor EvidenceRef.seq points at (command output, fs
+      // observation, digest). Not model-surface. Schema review per ADR-0021.
+      "verification.evidence",
       "note"
     ];
     SessionEventEnvelopeSchema = external_exports.object({
@@ -28590,6 +28597,7 @@ function buildProjection(events, issues = []) {
     toolResults: 0,
     verifications: [],
     missionPhases: [],
+    missionAdvice: [],
     replans: 0,
     issues
   };
@@ -28625,6 +28633,14 @@ function buildProjection(events, issues = []) {
       case "mission.replan":
         projection.replans += 1;
         break;
+      case "mission.progress":
+        projection.missionAdvice.push({
+          seq: e.seq,
+          recommendation: String(e.data.recommendation ?? ""),
+          rationale: String(e.data.rationale ?? "")
+        });
+        break;
+        break;
     }
   }
   return projection;
@@ -29365,7 +29381,12 @@ var init_runtime2 = __esm({
 });
 
 // packages/core/dist/verification/types.js
-var CriterionSourceSchema, CommandCheckSchema, FileExistsCheckSchema, FileContainsCheckSchema, FileAbsentCheckSchema, NoneCheckSchema, DeterministicCheckSchema, CriterionSchema, EvidenceTierSchema, EvidenceRefSchema, VerificationStatusSchema, VerificationSourceSchema, VerificationResultSchema;
+function isEventBackedEvidence(ref) {
+  if (!EVENT_BACKED_EVIDENCE_TIERS.includes(ref.tier))
+    return true;
+  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({
   "packages/core/dist/verification/types.js"() {
     "use strict";
@@ -29428,7 +29449,11 @@ var init_types9 = __esm({
       "human"
     ]);
     EvidenceRefSchema = external_exports.object({
-      /** Seq of the originating session event, when the evidence is logged. */
+      /**
+       * Seq of the originating session event. Required (by policy) for
+       * event-backed tiers on the 2.0 path: evidence without a session anchor
+       * is narration, not traceable output (F3 / ADR-0023 §5).
+       */
       seq: external_exports.number().int().positive().optional(),
       tier: EvidenceTierSchema,
       /** Human-readable pointer: command line, file path, tool call id… */
@@ -29437,6 +29462,11 @@ var init_types9 = __esm({
       /** sha256 of the captured output (audit chain). */
       digest: external_exports.string().optional()
     });
+    EVENT_BACKED_EVIDENCE_TIERS = [
+      "tool-output",
+      "command-output",
+      "fs-observation"
+    ];
     VerificationStatusSchema = external_exports.enum(["pass", "fail", "unknown"]);
     VerificationSourceSchema = external_exports.enum([
       "deterministic-engine",
@@ -29482,21 +29512,52 @@ var init_engine = __esm({
           results.push(await this.evaluateOne(criterion));
         }
         if (this.options.emit) {
-          await this.options.emit({
-            kind: "verification.run",
+          try {
+            await this.options.emit({
+              kind: "verification.run",
+              actor: { type: "system", role: "verification" },
+              data: {
+                source: "deterministic-engine",
+                packId: context.packId,
+                results: results.map((r) => ({
+                  criterionId: r.criterionId,
+                  status: r.status,
+                  evidence: r.evidence.map((e) => ({
+                    tier: e.tier,
+                    ref: e.ref,
+                    digest: e.digest,
+                    ...e.seq !== void 0 ? { seq: e.seq } : {}
+                  }))
+                }))
+              }
+            });
+          } catch {
+          }
+        }
+        return results;
+      }
+      /**
+       * F3: append one `verification.evidence` state event with the raw
+       * observation and resolve to its session seq when the emitter returns it.
+       * Spine failures degrade to `undefined` — an unreachable log must never
+       * fail verification, it only leaves the evidence unanchored.
+       */
+      async emitEvidence(data) {
+        if (!this.options.emit)
+          return void 0;
+        try {
+          const out = await this.options.emit({
+            kind: "verification.evidence",
             actor: { type: "system", role: "verification" },
-            data: {
-              source: "deterministic-engine",
-              packId: context.packId,
-              results: results.map((r) => ({
-                criterionId: r.criterionId,
-                status: r.status,
-                evidence: r.evidence.map((e) => ({ tier: e.tier, ref: e.ref, digest: e.digest }))
-              }))
-            }
+            data
           });
+          if (out && typeof out === "object" && typeof out.seq === "number") {
+            return out.seq;
+          }
+          return void 0;
+        } catch {
+          return void 0;
         }
-        return results;
       }
       async evaluateOne(criterion) {
         const started = this.options.now?.() ?? Date.now();
@@ -29536,12 +29597,23 @@ var init_engine = __esm({
           return done({ status: "unknown", evidence: [], detail: "shell provider unavailable" });
         }
         const result = await shell.exec(check2.command, { timeoutMs: check2.timeoutMs });
+        const digest = sha256(result.stdout);
+        const seq = await this.emitEvidence({
+          observation: "command",
+          command: check2.command,
+          exitCode: result.exitCode,
+          timedOut: result.timedOut,
+          digest,
+          stdoutTail: tail(result.stdout),
+          stderrTail: tail(result.stderr)
+        });
         const evidence = [
           {
             tier: "command-output",
             ref: `${check2.command} \u2192 exit ${result.exitCode ?? "signal"}`,
             capturedAt: Date.now(),
-            digest: sha256(result.stdout)
+            digest,
+            ...seq !== void 0 ? { seq } : {}
           }
         ];
         if (result.timedOut) {
@@ -29564,8 +29636,21 @@ var init_engine = __esm({
         }
         return done({ status: "pass", evidence });
       }
-      fsEvidence(path63, content, sha256) {
-        return { tier: "fs-observation", ref: path63, capturedAt: Date.now(), digest: sha256(content) };
+      /**
+       * F3: the fs observation is logged to the spine (path, existence, optional
+       * content digest) and the returned ref carries the event seq when the
+       * emitter resolved one.
+       */
+      async fsEvidence(observation, path64, sha256, content, extra = {}) {
+        const digest = sha256 && content !== void 0 ? sha256(content) : void 0;
+        const seq = await this.emitEvidence({ observation, path: path64, ...extra, ...digest ? { digest } : {} });
+        return {
+          tier: "fs-observation",
+          ref: path64,
+          capturedAt: Date.now(),
+          ...digest ? { digest } : {},
+          ...seq !== void 0 ? { seq } : {}
+        };
       }
       async evalFileExists(check2, done) {
         const sha256 = this.options.sha256 ?? defaultSha256;
@@ -29573,17 +29658,29 @@ var init_engine = __esm({
         if (!fs37)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
         const exists = await fs37.exists(check2.path);
-        if (!exists)
+        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 fs37.readFile(check2.path).catch(() => "");
-        return done({ status: "pass", evidence: [this.fsEvidence(check2.path, content, sha256)] });
+        return done({
+          status: "pass",
+          evidence: [await this.fsEvidence("file-exists", check2.path, sha256, content, { exists: true })]
+        });
       }
       async evalFileAbsent(check2, done) {
         const fs37 = this.services.fs;
         if (!fs37)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
         const exists = await fs37.exists(check2.path);
-        return exists ? done({ status: "fail", evidence: [], detail: `file still present: ${check2.path}` }) : done({ status: "pass", evidence: [{ tier: "fs-observation", ref: check2.path, capturedAt: Date.now() }] });
+        if (exists) {
+          await this.emitEvidence({ observation: "file-absent", path: check2.path, exists: true });
+          return done({ status: "fail", evidence: [], detail: `file still present: ${check2.path}` });
+        }
+        return done({
+          status: "pass",
+          evidence: [await this.fsEvidence("file-absent", check2.path, void 0, void 0, { exists: false })]
+        });
       }
       async evalFileContains(check2, done) {
         const sha256 = this.options.sha256 ?? defaultSha256;
@@ -29594,9 +29691,10 @@ var init_engine = __esm({
         try {
           content = await fs37.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}` });
         }
-        const evidence = [this.fsEvidence(check2.path, content, sha256)];
+        const evidence = [await this.fsEvidence("file-contains", check2.path, sha256, content)];
         let hit;
         try {
           hit = new RegExp(check2.pattern, "m").test(content);
@@ -29622,6 +29720,7 @@ function evaluateCompletion(criteria, results, policy = STRICT_ALL_POLICY) {
   const order = new Map(criteria.map((c, i) => [c.id, i]));
   const satisfied = [];
   const unsatisfied = [];
+  let unbackedSatisfied = false;
   const ids = [...requiredIds].sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
   for (const id of ids) {
     const result = byId.get(id);
@@ -29645,7 +29744,29 @@ function evaluateCompletion(criteria, results, policy = STRICT_ALL_POLICY) {
       });
       continue;
     }
+    const admissible = policy.admissibleTiers;
+    const tierOk = (e) => !admissible || admissible.includes(e.tier);
+    if (!result.evidence.some(tierOk)) {
+      const tiers = [...new Set(result.evidence.map((e) => e.tier))].join(", ");
+      unsatisfied.push({
+        id,
+        status: "unknown",
+        reason: `pass with inadmissible evidence tiers only (${tiers}) \u2014 not acceptable for completion`
+      });
+      continue;
+    }
+    const backed = result.evidence.filter(tierOk).some(isEventBackedEvidence);
+    if (policy.requireEventBackedEvidence && !backed) {
+      unsatisfied.push({
+        id,
+        status: "unknown",
+        reason: "pass without event-backed evidence \u2014 no EvidenceRef.seq anchored to a session event"
+      });
+      continue;
+    }
     satisfied.push(id);
+    if (!backed)
+      unbackedSatisfied = true;
   }
   const verdict = unsatisfied.length === 0 ? "PASS" : unsatisfied.some((u) => u.status === "fail") ? "REPAIR_REQUIRED" : "BLOCKED";
   return {
@@ -29653,21 +29774,126 @@ function evaluateCompletion(criteria, results, policy = STRICT_ALL_POLICY) {
     satisfied,
     unsatisfied,
     evidenceComplete: unsatisfied.length === 0,
+    eventBackedEvidenceComplete: unsatisfied.length === 0 && !unbackedSatisfied,
     summary: verdict === "PASS" ? `complete: ${satisfied.length}/${ids.length} required criteria pass with evidence` : `incomplete (${verdict}): ${unsatisfied.map((u) => `${u.id}=${u.status}`).join(", ")}`
   };
 }
-var STRICT_ALL_POLICY, strictBuildGate;
+var STRICT_ALL_POLICY, DETERMINISTIC_EVIDENCE_TIERS, STRICT_BUILD_POLICY, strictBuildGate;
 var init_completionPolicy = __esm({
   "packages/core/dist/verification/completionPolicy.js"() {
     "use strict";
+    init_types9();
     STRICT_ALL_POLICY = { mode: "strict", required: "*" };
+    DETERMINISTIC_EVIDENCE_TIERS = [
+      "tool-output",
+      "command-output",
+      "fs-observation",
+      "human"
+    ];
+    STRICT_BUILD_POLICY = {
+      mode: "strict",
+      required: "*",
+      admissibleTiers: DETERMINISTIC_EVIDENCE_TIERS,
+      requireEventBackedEvidence: true
+    };
     strictBuildGate = evaluateCompletion;
   }
 });
 
+// packages/core/dist/verification/sessionEvidence.js
+function asString2(v) {
+  return typeof v === "string" ? v : null;
+}
+function asStringArray(v) {
+  if (!Array.isArray(v))
+    return [];
+  return v.filter((x) => typeof x === "string");
+}
+function asUnsatisfied(v) {
+  if (!Array.isArray(v))
+    return [];
+  const out = [];
+  for (const item of v) {
+    if (!item || typeof item !== "object")
+      continue;
+    const rec = item;
+    const id = asString2(rec.id);
+    if (id === null)
+      continue;
+    out.push({
+      id,
+      status: asString2(rec.status) ?? "unknown",
+      reason: asString2(rec.reason) ?? ""
+    });
+  }
+  return out;
+}
+function parseVerificationRunPayload(ev) {
+  const data = ev.data;
+  if (!data || typeof data !== "object")
+    return null;
+  const rec = data;
+  const verdictRaw = asString2(rec.verdict);
+  const verdict = verdictRaw !== null && VERDICTS.has(verdictRaw) ? verdictRaw : "unknown";
+  const evidence = rec.evidence && typeof rec.evidence === "object" ? rec.evidence : null;
+  const satisfied = asStringArray(evidence?.satisfied);
+  const unsatisfied = asUnsatisfied(evidence?.unsatisfied);
+  const completeRaw = evidence?.complete;
+  return {
+    seq: ev.seq,
+    ts: ev.ts,
+    engine: asString2(rec.engine),
+    strict: rec.strict === true,
+    verdict,
+    satisfied,
+    unsatisfied,
+    evidenceComplete: typeof completeRaw === "boolean" ? completeRaw : verdict === "PASS" && satisfied.length > 0 && unsatisfied.length === 0,
+    summary: asString2(rec.summary) ?? ""
+  };
+}
+function lastVerificationRun(events) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const ev = events[i];
+    if (ev.kind !== "verification.run")
+      continue;
+    const snap = parseVerificationRunPayload(ev);
+    if (snap)
+      return snap;
+  }
+  return null;
+}
+function snapshotToCompletionEvaluation(snap) {
+  if (!snap.strict)
+    return null;
+  const unsatisfied = snap.unsatisfied.map((u) => ({
+    id: u.id,
+    status: u.status === "fail" || u.status === "missing" ? u.status : "unknown",
+    reason: u.reason
+  }));
+  const verdict = snap.verdict === "PASS" || snap.verdict === "REPAIR_REQUIRED" || snap.verdict === "BLOCKED" ? snap.verdict : "BLOCKED";
+  return {
+    verdict,
+    satisfied: [...snap.satisfied],
+    unsatisfied,
+    evidenceComplete: snap.evidenceComplete && unsatisfied.length === 0 && verdict === "PASS",
+    // F3: snapshot summaries do not carry per-ref seq — event-backedness is
+    // auditable from the raw spine events (verification.evidence), unknown here.
+    eventBackedEvidenceComplete: false,
+    summary: snap.summary
+  };
+}
+var VERDICTS;
+var init_sessionEvidence = __esm({
+  "packages/core/dist/verification/sessionEvidence.js"() {
+    "use strict";
+    VERDICTS = /* @__PURE__ */ new Set(["PASS", "REPAIR_REQUIRED", "BLOCKED"]);
+  }
+});
+
 // packages/core/dist/verification/criteriaPack.v1.js
 function codingCriteriaPack(options = {}) {
   const timeoutMs = options.commandTimeoutMs ?? 6e5;
+  const withDefault = (o, d) => o === void 0 ? d : o;
   const command = (command2) => command2 ? { kind: "command", command: command2, timeoutMs } : void 0;
   const criteria = [
     {
@@ -29675,21 +29901,21 @@ function codingCriteriaPack(options = {}) {
       text: "Static checks (typecheck) pass with no new errors.",
       source: "criteria-pack",
       required: true,
-      check: command(options.typecheckCommand ?? "npm run typecheck")
+      check: command(withDefault(options.typecheckCommand, "npm run typecheck"))
     },
     {
       id: "correctness.specification",
       text: "The test suite passes \u2014 behavior matches the specification.",
       source: "criteria-pack",
       required: true,
-      check: command(options.testCommand ?? "npm run test")
+      check: command(withDefault(options.testCommand, "npm run test"))
     },
     {
       id: "correctness.observable-output",
       text: "The project builds successfully (observable output artifact).",
       source: "criteria-pack",
       required: true,
-      check: command(options.buildCommand ?? "npm run build")
+      check: command(withDefault(options.buildCommand, "npm run build"))
     },
     {
       id: "quality.scope-discipline",
@@ -29954,6 +30180,7 @@ var init_verification2 = __esm({
     init_types9();
     init_engine();
     init_completionPolicy();
+    init_sessionEvidence();
     init_criteriaPack_v1();
     init_metrics();
     init_verifier();
@@ -29986,7 +30213,8 @@ function deriveMissionState(projection) {
     verifications: projection.verifications.length,
     lastSeq: projection.lastSeq,
     interrupted: projection.lastSeq > 0 && projection.endedAt === void 0,
-    forkParent: projection.fork?.parentSessionId
+    forkParent: projection.fork?.parentSessionId,
+    lastAdvice: projection.missionAdvice[projection.missionAdvice.length - 1]
   };
 }
 function missionSnapshot(state3) {
@@ -30004,11 +30232,99 @@ var init_missionState = __esm({
   }
 });
 
+// packages/core/dist/mission/continuationPolicy.js
+function requiredBlockers(progress) {
+  const blockers = [];
+  if (progress.ratio === null) {
+    blockers.push("no verification criteria recorded yet");
+    return blockers;
+  }
+  const missing = progress.criteriaTotal - progress.criteriaPassed;
+  if (missing > 0) {
+    blockers.push(`${missing}/${progress.criteriaTotal} required criteria not passing`);
+  }
+  if (progress.criteriaPassed === progress.criteriaTotal && !progress.evidenceComplete) {
+    blockers.push("all criteria pass but evidence is incomplete (not event-backed)");
+  }
+  return blockers;
+}
+function evaluateMissionContinuation(input) {
+  const { progress, verifier, budget, userSteer } = input;
+  const base = { goalRewrite: false, doneByScore: false };
+  const trend = verifier ? { tier: verifier.tier, value: verifier.value } : void 0;
+  const blockers = requiredBlockers(progress);
+  if (userSteer === "stop") {
+    return {
+      ...base,
+      recommendation: "wind-down",
+      rationale: "user steer: explicit stop \u2014 winding down without claiming done",
+      blockers,
+      trend
+    };
+  }
+  if (userSteer === "continue") {
+    return {
+      ...base,
+      recommendation: "continue",
+      rationale: "user steer: explicit continue \u2014 overrides any trend-derived advice",
+      blockers,
+      trend
+    };
+  }
+  if (budget && budget.iterationsUsed >= budget.iterationsMax) {
+    return {
+      ...base,
+      recommendation: "hold-for-user",
+      rationale: `iteration budget exhausted (${budget.iterationsUsed}/${budget.iterationsMax}) \u2014 operator decides: raise budget or hand off`,
+      blockers,
+      trend
+    };
+  }
+  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,
+      recommendation: "continue",
+      rationale: `required criteria incomplete \u2192 no early-stop${trendNote}`,
+      blockers,
+      trend
+    };
+  }
+  const blended = verifier?.tier === "blended" ? verifier.value : null;
+  const rejected = verifier?.verdict === "rejected" || blended !== null && blended <= REJECTED_BLEND;
+  if (rejected) {
+    return {
+      ...base,
+      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: [],
+      trend
+    };
+  }
+  const confirmed = verifier?.verdict === "confirmed" || blended !== null && blended >= CONFIRMED_BLEND;
+  return {
+    ...base,
+    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: [],
+    trend
+  };
+}
+var CONFIRMED_BLEND, REJECTED_BLEND;
+var init_continuationPolicy = __esm({
+  "packages/core/dist/mission/continuationPolicy.js"() {
+    "use strict";
+    CONFIRMED_BLEND = 0.8;
+    REJECTED_BLEND = 0.35;
+  }
+});
+
 // packages/core/dist/mission/index.js
 var init_mission2 = __esm({
   "packages/core/dist/mission/index.js"() {
     "use strict";
     init_missionState();
+    init_continuationPolicy();
   }
 });
 
@@ -30045,8 +30361,10 @@ __export(dist_exports, {
   DESIGN_PHASE_MODE_BANNER: () => DESIGN_PHASE_MODE_BANNER,
   DESIGN_PHASE_REQUIREMENTS: () => DESIGN_PHASE_REQUIREMENTS,
   DESIGN_PHASE_REQUIREMENT_SETS: () => DESIGN_PHASE_REQUIREMENT_SETS,
+  DETERMINISTIC_EVIDENCE_TIERS: () => DETERMINISTIC_EVIDENCE_TIERS,
   DOOM_LOOP_THRESHOLD: () => DOOM_LOOP_THRESHOLD,
   DeterministicCheckSchema: () => DeterministicCheckSchema,
+  EVENT_BACKED_EVIDENCE_TIERS: () => EVENT_BACKED_EVIDENCE_TIERS,
   EXPERIMENTAL_FLAGS: () => EXPERIMENTAL_FLAGS,
   EventBus: () => EventBus,
   EvidenceRefSchema: () => EvidenceRefSchema,
@@ -30100,6 +30418,7 @@ __export(dist_exports, {
   SINGLE_AGENT_IDENTITY_MODULE: () => SINGLE_AGENT_IDENTITY_MODULE,
   SKILL_CATALOG: () => SKILL_CATALOG,
   STRICT_ALL_POLICY: () => STRICT_ALL_POLICY,
+  STRICT_BUILD_POLICY: () => STRICT_BUILD_POLICY,
   STRUCTURED_REASONING_DIRECTIVE: () => STRUCTURED_REASONING_DIRECTIVE,
   ScriptRunner: () => ScriptRunner,
   SessionActorSchema: () => SessionActorSchema,
@@ -30191,6 +30510,7 @@ __export(dist_exports, {
   emptyContextGrowthStats: () => emptyContextGrowthStats,
   enforceDesignPhaseToolEmissions: () => enforceDesignPhaseToolEmissions,
   evaluateCompletion: () => evaluateCompletion,
+  evaluateMissionContinuation: () => evaluateMissionContinuation,
   executeTool: () => executeTool,
   exportSession: () => exportSession,
   exportSessionJson: () => exportSessionJson,
@@ -30246,6 +30566,7 @@ __export(dist_exports, {
   isBrainToolExecutionStartEvent: () => isBrainToolExecutionStartEvent,
   isBrainToolExecutionUpdateEvent: () => isBrainToolExecutionUpdateEvent,
   isConverged: () => isConverged,
+  isEventBackedEvidence: () => isEventBackedEvidence,
   isExperimentalEnabled: () => isExperimentalEnabled,
   isModelSurfaceEvent: () => isModelSurfaceEvent,
   isReviewerKind: () => isReviewerKind,
@@ -30255,6 +30576,7 @@ __export(dist_exports, {
   isVerifyToolCheckSkipped: () => isVerifyToolCheckSkipped,
   jaccardSimilarity: () => jaccardSimilarity,
   jsonBytes: () => jsonBytes,
+  lastVerificationRun: () => lastVerificationRun,
   lineageOf: () => lineageOf,
   lintSynthesisHonesty: () => lintSynthesisHonesty,
   listCodingSkills: () => listCodingSkills,
@@ -30276,6 +30598,7 @@ __export(dist_exports, {
   parseProjectRootFromWorkspaceContext: () => parseProjectRootFromWorkspaceContext,
   parseTextToolCalls: () => parseTextToolCalls,
   parseThinking: () => parseThinking,
+  parseVerificationRunPayload: () => parseVerificationRunPayload,
   parseVerificationTable: () => parseVerificationTable,
   parseVerifyVerdict: () => parseVerifyVerdict,
   pathsOverlap: () => pathsOverlap,
@@ -30325,6 +30648,7 @@ __export(dist_exports, {
   sha256Hex: () => sha256Hex,
   shouldRetryMember: () => shouldRetryMember,
   slugify: () => slugify2,
+  snapshotToCompletionEvaluation: () => snapshotToCompletionEvaluation,
   specificityFromAssumptions: () => specificityFromAssumptions,
   stableStringify: () => stableStringify,
   strictBuildGate: () => strictBuildGate,
@@ -30694,6 +31018,7 @@ var init_sessionSpine = __esm({
     "use strict";
     init_session();
     init_session();
+    init_verification2();
     MAX_STREAM_BUFFERS = 32;
     SessionSpineMirror = class _SessionSpineMirror {
       constructor(sessionId2, options) {
@@ -30702,7 +31027,7 @@ var init_sessionSpine = __esm({
         this.sessionsDir = resolveSessionsDir({ baseDir: options.baseDir });
       }
       writer = null;
-      chain = Promise.resolve();
+      chain = Promise.resolve(null);
       streamBuffers = /* @__PURE__ */ new Map();
       warned = false;
       status = "disabled";
@@ -30781,6 +31106,19 @@ var init_sessionSpine = __esm({
         if (!report || report.events.length === 0) return null;
         return deriveMessages(report.events);
       }
+      /**
+       * E2.1 (ADR-0023 × ADR-0021): last recognizable strict verification record
+       * in this session's log — the completion verdict is reconstructible from
+       * the spine alone (null when degraded/disabled or no record).
+       */
+      async lastVerificationRun() {
+        if (this.status !== "active" && this.status !== "closed") return null;
+        const report = await readSessionLog(
+          path21.join(this.sessionsDir, this.sessionId, "events.jsonl")
+        ).catch(() => null);
+        if (!report) return null;
+        return lastVerificationRun(report.events);
+      }
       /** Mirror one BrainEvent (coalescing message deltas until message_end). */
       mirrorBrainEvent(ev) {
         if (this.status !== "active" || !this.writer) return;
@@ -30825,18 +31163,44 @@ var init_sessionSpine = __esm({
           data: { phase: phase2, ...note ? { note } : {} }
         });
       }
+      /**
+       * F4 (doc §6): append an advisory continuation record. State-only — the
+       * recommendation must never feed the model loop or rewrite the goal.
+       */
+      missionProgress(advice) {
+        void this.append({
+          kind: "mission.progress",
+          actor: ACTOR_SYSTEM,
+          data: {
+            recommendation: advice.recommendation,
+            rationale: advice.rationale,
+            ...advice.blockers ? { blockers: advice.blockers } : {},
+            ...advice.trend ? { trend: advice.trend } : {},
+            ...advice.iteration !== void 0 ? { iteration: advice.iteration } : {}
+          }
+        });
+      }
       note(text, data) {
         void this.append({ kind: "note", actor: ACTOR_SYSTEM, data: { note: text, ...data } });
       }
       append(input) {
-        if (!this.writer || this.status === "closed") return Promise.resolve();
-        this.chain = this.chain.then(() => this.writer.append(input)).then(() => void 0).catch((err) => {
+        if (!this.writer || this.status === "closed") return Promise.resolve(null);
+        this.chain = this.chain.then(() => this.writer.append(input)).then((envelope) => envelope.seq).catch((err) => {
           this.status = "degraded";
           this.writer = null;
           this.warnOnce(err);
+          return null;
         });
         return this.chain;
       }
+      /**
+       * F3 (ADR-0023 §5): append one spine event and resolve to its assigned
+       * seq — the anchor EvidenceRef.seq points at. Null when degraded or
+       * disabled: callers must treat null as "not traceable", never as failure.
+       */
+      appendEvent(input) {
+        return this.append(input);
+      }
       warnOnce(err) {
         if (this.warned || this.options.quiet) return;
         this.warned = true;
@@ -32455,9 +32819,9 @@ function spillToolOutput(fullText, meta3) {
     const rnd = randomBytes2(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 path63 = join11(dir, file2);
-    writeFileSync11(path63, fullText, "utf8");
-    return path63;
+    const path64 = join11(dir, file2);
+    writeFileSync11(path64, fullText, "utf8");
+    return path64;
   } catch {
     return null;
   }
@@ -32503,10 +32867,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail2}`;
   }
   if (doSpill) {
-    const path63 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path63) {
+    const path64 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path64) {
       const spillNote = `
-\u2026 [full output spilled to: ${path63} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path64} \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}
 `);
@@ -35169,28 +35533,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path63) {
-        if (!existsSync19(path63)) {
-          throw new Error(`File not found: ${path63}`);
+      read(path64) {
+        if (!existsSync19(path64)) {
+          throw new Error(`File not found: ${path64}`);
         }
-        const md = readFileSync16(path63, "utf8");
+        const md = readFileSync16(path64, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path63) {
-        if (!existsSync19(path63)) return null;
-        return this.read(path63);
+      readIfExists(path64) {
+        if (!existsSync19(path64)) return null;
+        return this.read(path64);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path63, meta3, body) {
-        mkdirSync11(dirname2(path63), { recursive: true });
-        const tmp = path63 + ".tmp-" + process.pid;
+      write(path64, meta3, body) {
+        mkdirSync11(dirname2(path64), { recursive: true });
+        const tmp = path64 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync13(tmp, md, "utf8");
-        renameSync2(tmp, path63);
+        renameSync2(tmp, path64);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -35252,8 +35616,8 @@ function nextPlanTaskId(store6) {
   return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
-  const path63 = join15(rootDir, "plan-tasks", `${task.id}.md`);
-  mkdirSync12(dirname3(path63), { recursive: true });
+  const path64 = join15(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync12(dirname3(path64), { recursive: true });
   const meta3 = {
     kind: "task",
     id: task.id,
@@ -35274,7 +35638,7 @@ function writePlanTaskArtifact(rootDir, task) {
     task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
     ""
   ].filter((l) => l !== null).join("\n");
-  new Storage().write(path63, meta3, body);
+  new Storage().write(path64, meta3, body);
 }
 function loadHandle(rootDir) {
   const jsonPath = join15(rootDir, "plan.json");
@@ -37832,21 +38196,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path63 = getSshSecretsPath();
-  if (!existsSync23(path63)) return {};
+  const path64 = getSshSecretsPath();
+  if (!existsSync23(path64)) return {};
   try {
-    return JSON.parse(readFileSync20(path63, "utf8"));
+    return JSON.parse(readFileSync20(path64, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path63 = getSshSecretsPath();
-  mkdirSync13(dirname4(path63), { recursive: true });
-  writeFileSync15(path63, `${JSON.stringify(data, null, 2)}
+  const path64 = getSshSecretsPath();
+  mkdirSync13(dirname4(path64), { recursive: true });
+  writeFileSync15(path64, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path63, 384);
+    chmodSync(path64, 384);
   } catch {
   }
 }
@@ -37875,10 +38239,10 @@ function deleteSshPassword(id) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path63 = getSshTargetsPath();
-  if (!existsSync23(path63)) return [];
+  const path64 = getSshTargetsPath();
+  if (!existsSync23(path64)) return [];
   try {
-    const parsed = JSON.parse(readFileSync20(path63, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path64, "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"
@@ -37893,11 +38257,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path63 = getSshTargetsPath();
-  mkdirSync13(dirname4(path63), { recursive: true });
+  const path64 = getSshTargetsPath();
+  mkdirSync13(dirname4(path64), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync15(
-    path63,
+    path64,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -38143,11 +38507,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path63 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path64 = 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}${path63}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path64}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -39857,6 +40221,9 @@ function parseHeadlessFlags(argv) {
       i++;
     } else if (arg === "--strict-done") {
       strictDone = true;
+    } else if (arg === "--no-strict-done") {
+      strictDone = false;
+      process.env.ZELARI_MISSION_STRICT = "0";
     } else if (arg === "--kraken-graph") {
       krakenGraph = argv[i + 1];
       i++;
@@ -39959,8 +40326,16 @@ __export(headlessSpine_exports, {
   missionStateFromSpine: () => missionStateFromSpine,
   openHeadlessSpine: () => openHeadlessSpine,
   resolveHeadlessProfileId: () => resolveHeadlessProfileId,
-  seedHeadlessModelHistory: () => seedHeadlessModelHistory
+  seedHeadlessModelHistory: () => seedHeadlessModelHistory,
+  sessionStartedEvent: () => sessionStartedEvent
 });
+function sessionStartedEvent(handle) {
+  return {
+    type: "session_started",
+    sessionId: handle.sessionId,
+    spine: handle.spine.status
+  };
+}
 function resolveHeadlessProfileId(mode, explicit) {
   if (explicit) return resolveProfile(explicit).id;
   return defaultProfileForMode(mode ?? "kraken");
@@ -40002,9 +40377,18 @@ async function openHeadlessSpine(opts) {
     verificationRun(payload) {
       spine.verificationRun(payload);
     },
+    appendEvent(input) {
+      return spine.appendEvent(input);
+    },
+    lastVerificationRun() {
+      return spine.lastVerificationRun();
+    },
     missionPhase(phase2, note) {
       spine.missionPhase(phase2, note);
     },
+    missionProgress(advice) {
+      spine.missionProgress(advice);
+    },
     note(text, data) {
       spine.note(text, data);
     },
@@ -40114,12 +40498,12 @@ var init_headlessSpine = __esm({
 // src/cli/state/fileStateStore.ts
 import { createHash as createHash10, randomUUID as randomUUID2 } from "node:crypto";
 import { promises as fs21 } from "node:fs";
-import * as path40 from "node:path";
+import * as path41 from "node:path";
 function shortId() {
   return randomUUID2().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
-  await fs21.mkdir(path40.dirname(filePath), { recursive: true });
+  await fs21.mkdir(path41.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
   await fs21.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
   await fs21.rename(tmp, filePath);
@@ -40180,11 +40564,11 @@ var init_fileStateStore = __esm({
       indexPath = "";
       async init(projectRoot) {
         this.root = projectRoot;
-        this.stateDir = path40.join(projectRoot, ".zelari", "state");
-        this.commitsDir = path40.join(this.stateDir, "commits");
-        this.artifactsDir = path40.join(this.stateDir, "artifacts");
-        this.headPath = path40.join(this.stateDir, "HEAD.json");
-        this.indexPath = path40.join(this.stateDir, "index.jsonl");
+        this.stateDir = path41.join(projectRoot, ".zelari", "state");
+        this.commitsDir = path41.join(this.stateDir, "commits");
+        this.artifactsDir = path41.join(this.stateDir, "artifacts");
+        this.headPath = path41.join(this.stateDir, "HEAD.json");
+        this.indexPath = path41.join(this.stateDir, "index.jsonl");
         await fs21.mkdir(this.commitsDir, { recursive: true });
         await fs21.mkdir(this.artifactsDir, { recursive: true });
       }
@@ -40197,13 +40581,13 @@ var init_fileStateStore = __esm({
         const discoveries = input.discoveries ?? [];
         const parent = await this.head();
         const id = shortId();
-        const artifactRel = path40.join("artifacts", id);
-        const artifactAbs = path40.join(this.artifactsDir, id);
+        const artifactRel = path41.join("artifacts", id);
+        const artifactAbs = path41.join(this.artifactsDir, id);
         await fs21.mkdir(artifactAbs, { recursive: true });
         const summary = defaultSummary(input, discoveries);
-        await fs21.writeFile(path40.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
-        await writeJsonAtomic(path40.join(artifactAbs, "discoveries.json"), discoveries);
-        await writeJsonAtomic(path40.join(artifactAbs, "verification.json"), input.verification);
+        await fs21.writeFile(path41.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
+        await writeJsonAtomic(path41.join(artifactAbs, "discoveries.json"), discoveries);
+        await writeJsonAtomic(path41.join(artifactAbs, "verification.json"), input.verification);
         const meta3 = {
           id,
           parentId: parent?.id ?? null,
@@ -40215,14 +40599,14 @@ var init_fileStateStore = __esm({
           workspaceCheckpointId: input.workspaceCheckpointId,
           verification: {
             ...input.verification,
-            reportPath: input.verification.reportPath ?? path40.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
+            reportPath: input.verification.reportPath ?? path41.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
           },
           changedPaths: input.changedPaths ?? [],
           stablePromptHash: input.stablePromptHash,
           discoveryCount: discoveries.length,
           artifactDir: artifactRel.replace(/\\/g, "/")
         };
-        await writeJsonAtomic(path40.join(this.commitsDir, `${id}.json`), meta3);
+        await writeJsonAtomic(path41.join(this.commitsDir, `${id}.json`), meta3);
         await writeJsonAtomic(this.headPath, { id, updatedAt: meta3.createdAt });
         await fs21.appendFile(this.indexPath, JSON.stringify({ id, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
         return stripStored(meta3);
@@ -40233,7 +40617,7 @@ var init_fileStateStore = __esm({
         return this.get(head.id);
       }
       async get(id) {
-        const stored = await readJsonFile(path40.join(this.commitsDir, `${id}.json`));
+        const stored = await readJsonFile(path41.join(this.commitsDir, `${id}.json`));
         return stored ? stripStored(stored) : null;
       }
       async list(limit = 20) {
@@ -40272,9 +40656,9 @@ var init_fileStateStore = __esm({
       async loadDiscoveries(id) {
         const meta3 = id ? await this.get(id) : await this.head();
         if (!meta3) return [];
-        const stored = await readJsonFile(path40.join(this.commitsDir, `${meta3.id}.json`));
+        const stored = await readJsonFile(path41.join(this.commitsDir, `${meta3.id}.json`));
         if (!stored?.artifactDir) return [];
-        const discPath = path40.join(this.stateDir, stored.artifactDir, "discoveries.json");
+        const discPath = path41.join(this.stateDir, stored.artifactDir, "discoveries.json");
         return await readJsonFile(discPath) ?? [];
       }
       async materializeContext(id, maxChars = DEFAULT_MATERIALIZE_CHARS) {
@@ -41984,8 +42368,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path63 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path63);
+  const path64 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path64);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -42163,7 +42547,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path63 = join25(ctx.rootDir, "milestones", `${id}.md`);
+  const path64 = join25(ctx.rootDir, "milestones", `${id}.md`);
   const meta3 = {
     kind: "milestone",
     id,
@@ -42180,7 +42564,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path63, meta3, body);
+  ctx.storage.write(path64, meta3, body);
   return { id, created: true };
 }
 function readPlanSummary(ctx) {
@@ -42384,7 +42768,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path63 = workspaceArtifact(ctx.rootDir, "decisions", id);
+        const path64 = workspaceArtifact(ctx.rootDir, "decisions", id);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -42410,7 +42794,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path63, meta3, body);
+        ctx.storage.write(path64, meta3, body);
         return `ADR ${id} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -42492,14 +42876,14 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path63 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path64 = workspaceArtifact(ctx.rootDir, "docs", slug);
         const meta3 = {
           kind: "doc",
           id: slug,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path63, meta3, content);
+        ctx.storage.write(path64, meta3, content);
         return `Document "${title}" created at docs/${slug}.md.`;
       });
     }
@@ -42720,15 +43104,15 @@ __export(updater_exports, {
 import { createRequire as createRequire2 } from "node:module";
 import { spawn as spawn12 } from "node:child_process";
 import { existsSync as existsSync32 } from "node:fs";
-import path41 from "node:path";
+import path42 from "node:path";
 import { fileURLToPath } from "node:url";
 function resolveBundledNpmCli(execPath = process.execPath) {
-  const dir = path41.dirname(execPath);
+  const dir = path42.dirname(execPath);
   const candidates = [
     // Windows: C:\...\node.exe → C:\...\node_modules\npm\bin\npm-cli.js
-    path41.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
+    path42.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
     // POSIX: <prefix>/bin/node → <prefix>/lib/node_modules/npm/bin/npm-cli.js
-    path41.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+    path42.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
   ];
   for (const candidate of candidates) {
     try {
@@ -42745,7 +43129,7 @@ function looksLikeBrokenShim(exitCode, output) {
 }
 function getCurrentVersion() {
   try {
-    const pkgPath = path41.resolve(__dirname2, "..", "..", "package.json");
+    const pkgPath = path42.resolve(__dirname2, "..", "..", "package.json");
     const pkg = require2(pkgPath);
     return pkg.version;
   } catch {
@@ -42868,7 +43252,7 @@ var init_updater = __esm({
     "use strict";
     init_cmdline();
     require2 = createRequire2(import.meta.url);
-    __dirname2 = path41.dirname(fileURLToPath(import.meta.url));
+    __dirname2 = path42.dirname(fileURLToPath(import.meta.url));
     REGISTRY_URL = "https://registry.npmjs.org/zelari-code/latest";
   }
 });
@@ -43056,10 +43440,10 @@ function getUserMcpPath() {
 function getProjectMcpPath(projectRoot) {
   return join26(projectRoot, ".zelari", "mcp.json");
 }
-function readFile2(path63) {
-  if (!existsSync33(path63)) return {};
+function readFile3(path64) {
+  if (!existsSync33(path64)) return {};
   try {
-    const parsed = JSON.parse(readFileSync28(path63, "utf8"));
+    const parsed = JSON.parse(readFileSync28(path64, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       if (!cfg || typeof cfg.command !== "string" || !cfg.command.trim()) continue;
@@ -43075,17 +43459,17 @@ function readFile2(path63) {
     return {};
   }
 }
-function writeFile(path63, servers) {
-  mkdirSync16(dirname7(path63), { recursive: true });
+function writeFile(path64, servers) {
+  mkdirSync16(dirname7(path64), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync18(path63, `${JSON.stringify(body, null, 2)}
+  writeFileSync18(path64, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
   const userPath = getUserMcpPath();
-  const userServers = readFile2(userPath);
+  const userServers = readFile3(userPath);
   const projectPath = projectRoot && projectRoot.trim() ? getProjectMcpPath(projectRoot.trim()) : null;
-  const projectServers = projectPath ? readFile2(projectPath) : {};
+  const projectServers = projectPath ? readFile3(projectPath) : {};
   const servers = [];
   for (const [name, cfg] of Object.entries(userServers)) {
     servers.push({ name, ...cfg, scope: "user", path: userPath });
@@ -43111,9 +43495,9 @@ function upsertMcpServer(opts) {
   if (!opts.config.command?.trim()) {
     return { ok: false, error: "command is required" };
   }
-  let path63;
+  let path64;
   if (opts.scope === "user") {
-    path63 = getUserMcpPath();
+    path64 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -43122,30 +43506,30 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path63 = getProjectMcpPath(root);
+    path64 = getProjectMcpPath(root);
   }
-  const current = readFile2(path63);
+  const current = readFile3(path64);
   current[name] = {
     command: opts.config.command.trim(),
     args: opts.config.args,
     env: opts.config.env,
     enabled: opts.config.enabled !== false
   };
-  writeFile(path63, current);
-  return { ok: true, path: path63 };
+  writeFile(path64, current);
+  return { ok: true, path: path64 };
 }
 function removeMcpServer(opts) {
-  const path63 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path63) {
+  const path64 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path64) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile2(path63);
+  const current = readFile3(path64);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path63}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path64}` };
   }
   delete current[opts.name];
-  writeFile(path63, current);
-  return { ok: true, path: path63 };
+  writeFile(path64, current);
+  return { ok: true, path: path64 };
 }
 var init_mcpConfigIo = __esm({
   "src/cli/mcp/mcpConfigIo.ts"() {
@@ -43544,12 +43928,12 @@ __export(agentsMd_exports, {
 import { existsSync as existsSync35, readFileSync as readFileSync30, writeFileSync as writeFileSync19 } from "node:fs";
 import { createHash as createHash11 } from "node:crypto";
 import { join as join28 } from "node:path";
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 async function readPackageJson2(projectRoot) {
-  const path63 = join28(projectRoot, "package.json");
-  if (!existsSync35(path63)) return null;
+  const path64 = join28(projectRoot, "package.json");
+  if (!existsSync35(path64)) return null;
   try {
-    return JSON.parse(await readFile3(path63, "utf8"));
+    return JSON.parse(await readFile4(path64, "utf8"));
   } catch {
     return null;
   }
@@ -43631,9 +44015,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path63 = join28(ctx.rootDir, "risks.md");
-  if (!existsSync35(path63)) return "_No open questions._";
-  const content = readFileSync30(path63, "utf8");
+  const path64 = join28(ctx.rootDir, "risks.md");
+  if (!existsSync35(path64)) return "_No open questions._";
+  const content = readFileSync30(path64, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -43907,9 +44291,9 @@ function versionKey(value) {
 function firstString2(v) {
   return typeof v === "string" && v.trim().length > 0 ? v : null;
 }
-function readFileSyncSafe(path63) {
+function readFileSyncSafe(path64) {
   try {
-    return readFileSync31(path63, "utf8");
+    return readFileSync31(path64, "utf8");
   } catch {
     return null;
   }
@@ -44372,8 +44756,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path63 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path63, completion };
+      const path64 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path64, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -44418,7 +44802,7 @@ import {
   writeFileSync as writeFileSync21,
   mkdirSync as mkdirSync17
 } from "node:fs";
-import path42 from "node:path";
+import path43 from "node:path";
 import os10 from "node:os";
 var FeedbackStore;
 var init_councilFeedback = __esm({
@@ -44429,7 +44813,7 @@ var init_councilFeedback = __esm({
       now;
       entries = [];
       constructor(options = {}) {
-        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path42.join(os10.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
+        this.file = options.file ?? (process.env.ANATHEMA_COUNCIL_FEEDBACK_FILE ?? path43.join(os10.homedir(), ".tmp", "zelari-code", "council-feedback.json"));
         this.now = options.now ?? Date.now;
         this.load();
       }
@@ -44535,7 +44919,7 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync17(path42.dirname(this.file), { recursive: true });
+        mkdirSync17(path43.dirname(this.file), { recursive: true });
         writeFileSync21(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
@@ -44603,7 +44987,7 @@ import { execFile as execFile3 } from "node:child_process";
 import { promisify as promisify2 } from "node:util";
 import { mkdtempSync, rmSync as rmSync2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import path43 from "node:path";
+import path44 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 async function git3(cwd, args, env) {
   const { stdout } = await execFileAsync2("git", ["-C", cwd, ...args], {
@@ -44623,8 +45007,8 @@ async function isGitRepo(cwd) {
   return await gitSafe(cwd, ["rev-parse", "--is-inside-work-tree"]) === "true";
 }
 async function withTempIndex(fn) {
-  const dir = mkdtempSync(path43.join(tmpdir2(), "zelari-ckpt-"));
-  const indexFile = path43.join(dir, "index");
+  const dir = mkdtempSync(path44.join(tmpdir2(), "zelari-ckpt-"));
+  const indexFile = path44.join(dir, "index");
   try {
     return await fn(indexFile);
   } finally {
@@ -44715,7 +45099,7 @@ async function restoreCheckpoint(cwd, id) {
     const deleted = [];
     for (const rel2 of added) {
       try {
-        rmSync2(path43.join(cwd, rel2), { force: true });
+        rmSync2(path44.join(cwd, rel2), { force: true });
         deleted.push(rel2);
       } catch {
       }
@@ -44816,7 +45200,7 @@ __export(fileBackend_exports, {
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { promises as fs23 } from "node:fs";
-import * as path44 from "node:path";
+import * as path45 from "node:path";
 function tokenize(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
 }
@@ -44860,8 +45244,8 @@ var init_fileBackend = __esm({
       logPath = "";
       memoryDir = "";
       async init(projectRoot) {
-        this.memoryDir = path44.join(projectRoot, ".zelari", "memory");
-        this.logPath = path44.join(this.memoryDir, "log.jsonl");
+        this.memoryDir = path45.join(projectRoot, ".zelari", "memory");
+        this.logPath = path45.join(this.memoryDir, "log.jsonl");
         await fs23.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata = {}, graph) {
@@ -44934,12 +45318,12 @@ var init_fileBackend = __esm({
 
 // src/cli/traceStore.ts
 import { promises as fs24 } from "node:fs";
-import * as path45 from "node:path";
+import * as path46 from "node:path";
 function traceDir(projectRoot) {
-  return path45.join(projectRoot, ".zelari", "trace");
+  return path46.join(projectRoot, ".zelari", "trace");
 }
 function tracePath(projectRoot, missionId) {
-  return path45.join(traceDir(projectRoot), `${missionId}.json`);
+  return path46.join(traceDir(projectRoot), `${missionId}.json`);
 }
 async function saveTrace(projectRoot, missionId, entries) {
   const dir = traceDir(projectRoot);
@@ -44974,7 +45358,7 @@ __export(zelariMission_exports, {
 });
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { promises as fs25 } from "node:fs";
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 function resolveMaxIterations(env = process.env) {
   const raw = env.ZELARI_MISSION_MAX_ITER;
   const n = raw ? Number.parseInt(raw, 10) : DEFAULT_MAX_ITER;
@@ -45002,10 +45386,10 @@ function isMissionAutoStart(env = process.env) {
   return env.ZELARI_MISSION_AUTO === "1";
 }
 async function writeMissionState(projectRoot, state3) {
-  const dir = path46.join(projectRoot, ".zelari");
+  const dir = path47.join(projectRoot, ".zelari");
   await fs25.mkdir(dir, { recursive: true });
   await fs25.writeFile(
-    path46.join(dir, "mission-state.json"),
+    path47.join(dir, "mission-state.json"),
     JSON.stringify(state3, null, 2) + "\n",
     "utf8"
   );
@@ -45237,6 +45621,17 @@ async function runZelariMission(userMessage, brief, deps) {
         deps.emit(`[zelari] state commit skipped: ${commitRes.error}`);
       }
     }
+    const missionProgress = {
+      criteriaTotal: 1,
+      criteriaPassed: completionOk ? 1 : 0,
+      ratio: completionOk ? 1 : 0,
+      evidenceComplete: completionOk && (typeof result.writeCount === "number" ? result.writeCount > 0 : true)
+    };
+    const advice = evaluateMissionContinuation({
+      progress: missionProgress,
+      budget: { iterationsUsed: implStep, iterationsMax: maxIter }
+    });
+    deps.onMissionProgress?.(advice, step);
     if (completionOk) {
       state3.status = "success";
       deps.onMissionPhase?.("done", "mvp-green");
@@ -45283,6 +45678,7 @@ var DEFAULT_MAX_ITER, DEFAULT_MAX_STALL;
 var init_zelariMission = __esm({
   "src/cli/zelariMission.ts"() {
     "use strict";
+    init_mission2();
     init_fileBackend();
     init_checkpointManager();
     init_fileStateStore();
@@ -45615,7 +46011,7 @@ function safeSocketPath(socketPath) {
   return socketPath.trim();
 }
 function startPermissionBroker(socketPath, handlers, opts) {
-  const path63 = safeSocketPath(socketPath);
+  const path64 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer2((socket) => {
@@ -45715,10 +46111,10 @@ function startPermissionBroker(socketPath, handlers, opts) {
   return new Promise((resolve3, reject) => {
     const onError = (err) => reject(err);
     server.once("error", onError);
-    server.listen(path63, () => {
+    server.listen(path64, () => {
       server.removeListener("error", onError);
       resolve3({
-        socketPath: path63,
+        socketPath: path64,
         stop: () => new Promise((res) => {
           for (const s of sockets) s.destroy();
           sockets.clear();
@@ -45729,7 +46125,7 @@ function startPermissionBroker(socketPath, handlers, opts) {
             if (done) return;
             done = true;
             if (process.platform !== "win32") {
-              unlink(path63, () => res());
+              unlink(path64, () => res());
             } else {
               res();
             }
@@ -45742,11 +46138,11 @@ function startPermissionBroker(socketPath, handlers, opts) {
   });
 }
 function requestBrokerAsk(socketPath, ask, opts) {
-  const path63 = safeSocketPath(socketPath);
+  const path64 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const connectTimeoutMs = opts?.connectTimeoutMs ?? PERMISSION_BROKER_DEFAULT_CONNECT_TIMEOUT_MS;
   return new Promise((resolve3, reject) => {
-    const socket = connect(path63);
+    const socket = connect(path64);
     let buffer = "";
     let settled = false;
     const settle = (fn) => {
@@ -45761,7 +46157,7 @@ function requestBrokerAsk(socketPath, ask, opts) {
       settle(
         () => reject(
           new Error(
-            `permission broker unavailable at "${path63}" (connect timed out after ${connectTimeoutMs}ms)`
+            `permission broker unavailable at "${path64}" (connect timed out after ${connectTimeoutMs}ms)`
           )
         )
       );
@@ -46494,9 +46890,9 @@ __export(graphMemory_exports, {
   toGraphSnapshot: () => toGraphSnapshot
 });
 import { promises as fs26 } from "node:fs";
-import path48 from "node:path";
+import path49 from "node:path";
 function snapshotPath(cwd) {
-  return path48.join(cwd, SNAPSHOT_DIR, SNAPSHOT_FILE);
+  return path49.join(cwd, SNAPSHOT_DIR, SNAPSHOT_FILE);
 }
 function toGraphSnapshot(graph, opts) {
   const unresolved = (opts.unresolvedFindings ?? []).map((u) => ({
@@ -46523,7 +46919,7 @@ async function saveGraphSnapshot(cwd, snapshot) {
   try {
     await fs26.access(cwd);
     const file2 = snapshotPath(cwd);
-    await fs26.mkdir(path48.dirname(file2), { recursive: true });
+    await fs26.mkdir(path49.dirname(file2), { recursive: true });
     await fs26.writeFile(file2, JSON.stringify(snapshot, null, 2) + "\n", "utf8");
   } catch {
   }
@@ -46590,7 +46986,7 @@ var SNAPSHOT_DIR, SNAPSHOT_FILE, MAX_SNAPSHOT_FINDINGS_CHARS;
 var init_graphMemory = __esm({
   "src/cli/kraken/graphMemory.ts"() {
     "use strict";
-    SNAPSHOT_DIR = path48.join(".zelari", "kraken");
+    SNAPSHOT_DIR = path49.join(".zelari", "kraken");
     SNAPSHOT_FILE = "last-graph.json";
     MAX_SNAPSHOT_FINDINGS_CHARS = 400;
   }
@@ -46606,14 +47002,14 @@ var init_tentacle = __esm({
 
 // src/cli/kraken/workbench.ts
 import { promises as fs27 } from "node:fs";
-import path49 from "node:path";
+import path50 from "node:path";
 function isWorkbenchEnabled(env = process.env) {
   const v = (env.ZELARI_KRAKEN_WORKBENCH ?? "1").trim().toLowerCase();
   if (v === "0" || v === "false" || v === "no" || v === "off") return false;
   return true;
 }
 function workbenchPath(cwd, graphId) {
-  return path49.join(cwd, ".zelari", "radio", `workbench-${graphId}.md`);
+  return path50.join(cwd, ".zelari", "radio", `workbench-${graphId}.md`);
 }
 function countByStatus2(nodes) {
   const out = { pending: 0, running: 0, done: 0, error: 0, skipped: 0 };
@@ -46776,7 +47172,7 @@ var init_workbench = __esm({
         if (!this.enabled) return null;
         if (!this.dirty && this.lastWrite) return this.lastWrite;
         const out = workbenchPath(this.cwd, this.graphId);
-        await fs27.mkdir(path49.dirname(out), { recursive: true });
+        await fs27.mkdir(path50.dirname(out), { recursive: true });
         const body = this.render();
         const tmp = `${out}.${process.pid}.${Date.now()}.tmp`;
         await fs27.writeFile(tmp, body, "utf8");
@@ -46973,7 +47369,7 @@ __export(executor_exports, {
   thoroughnessForKind: () => thoroughnessForKind
 });
 import { existsSync as existsSync40 } from "node:fs";
-import path50 from "node:path";
+import path51 from "node:path";
 function resolveMaxParallel(env = process.env) {
   const raw = env.ZELARI_KRAKEN_MAX_PARALLEL;
   if (raw === void 0 || raw === "") return DEFAULT_MAX_PARALLEL;
@@ -47031,7 +47427,7 @@ function isWorldModelGateEnabled(cwd, env = process.env, checksExists = defaultC
 }
 function defaultChecksExists(cwd) {
   try {
-    return existsSync40(path50.join(cwd, ".zelari", "world", "checks.json"));
+    return existsSync40(path51.join(cwd, ".zelari", "world", "checks.json"));
   } catch {
     return false;
   }
@@ -48370,10 +48766,10 @@ var init_prereqChecks = __esm({
 
 // src/cli/plugins/prefs.ts
 import { existsSync as existsSync42, readFileSync as readFileSync35, writeFileSync as writeFileSync22, mkdirSync as mkdirSync18 } from "node:fs";
-import path53 from "node:path";
+import path54 from "node:path";
 import os11 from "node:os";
 function getPluginPrefsPath() {
-  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path53.join(os11.homedir(), ".tmp", "zelari-code", "plugins.json");
+  return process.env.ZELARI_PLUGINS_PREFS_FILE ?? path54.join(os11.homedir(), ".tmp", "zelari-code", "plugins.json");
 }
 function getPluginPrefs() {
   const file2 = getPluginPrefsPath();
@@ -48394,7 +48790,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync18(path53.dirname(file2), { recursive: true });
+  mkdirSync18(path54.dirname(file2), { recursive: true });
   writeFileSync22(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -48431,7 +48827,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync43 } from "node:fs";
-import path54 from "node:path";
+import path55 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -48449,7 +48845,7 @@ function isBinaryOnPath(bin, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const exists = opts.exists ?? existsSync43;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
-  const pathMod = platform === "win32" ? path54.win32 : path54.posix;
+  const pathMod = platform === "win32" ? path55.win32 : path55.posix;
   const sep2 = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep2).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -49396,9 +49792,9 @@ __export(triggerLock_exports, {
   releaseLock: () => releaseLock
 });
 import { promises as fs35 } from "node:fs";
-import * as path59 from "node:path";
+import * as path60 from "node:path";
 function lockPath(projectRoot) {
-  return path59.join(projectRoot, ".zelari", "trigger.lock");
+  return path60.join(projectRoot, ".zelari", "trigger.lock");
 }
 function isPidAlive(pid) {
   try {
@@ -49411,7 +49807,7 @@ function isPidAlive(pid) {
 }
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
-  const dir = path59.dirname(lp);
+  const dir = path60.dirname(lp);
   await fs35.mkdir(dir, { recursive: true });
   try {
     const raw = await fs35.readFile(lp, "utf8");
@@ -50005,7 +50401,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path63 = skillFilePath(dir, name);
+  const path64 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -50014,13 +50410,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path63);
+  const parsed = parseSkillMd(content, path64);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync21(dirname10(path63), { recursive: true });
-  writeFileSync24(path63, content, "utf8");
-  return { ok: true, path: path63 };
+  mkdirSync21(dirname10(path64), { recursive: true });
+  writeFileSync24(path64, content, "utf8");
+  return { ok: true, path: path64 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -50038,8 +50434,8 @@ function removeSkill(opts) {
     dir = getProjectSkillsDir(root);
   }
   const skillDir = join37(dir, name);
-  const path63 = skillFilePath(dir, name);
-  if (!existsSync48(path63) && !existsSync48(skillDir)) {
+  const path64 = skillFilePath(dir, name);
+  if (!existsSync48(path64) && !existsSync48(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -50050,7 +50446,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path63 };
+  return { ok: true, path: path64 };
 }
 var NAME_RE, BUILTIN_SKILL_MODULES, builtinsLoaded;
 var init_skillConfigIo = __esm({
@@ -50368,12 +50764,12 @@ function ensureHome() {
   }
 }
 function loadCompanionConfig() {
-  const path63 = getCompanionConfigPath();
-  if (!existsSync49(path63)) {
+  const path64 = getCompanionConfigPath();
+  if (!existsSync49(path64)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync39(path63, "utf8"));
+    const raw = JSON.parse(readFileSync39(path64, "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) => ({
@@ -50411,16 +50807,16 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path63 = getCompanionTokenPath();
-  if (existsSync49(path63)) {
-    const t = readFileSync39(path63, "utf8").trim();
+  const path64 = getCompanionTokenPath();
+  if (existsSync49(path64)) {
+    const t = readFileSync39(path64, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes5(24).toString("base64url");
-  writeFileSync25(path63, token + "\n", "utf8");
+  writeFileSync25(path64, token + "\n", "utf8");
   try {
     const fs37 = __require("node:fs");
-    fs37.chmodSync?.(path63, 384);
+    fs37.chmodSync?.(path64, 384);
   } catch {
   }
   return { token, created: true };
@@ -50445,17 +50841,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path63 = raw.trim();
-    if (!path63) continue;
-    let id = slugFromPath(path63);
+    const path64 = raw.trim();
+    if (!path64) continue;
+    let id = slugFromPath(path64);
     let n = 2;
-    while (byId.has(id) && byId.get(id).path !== path63) {
-      id = `${slugFromPath(path63)}-${n++}`;
+    while (byId.has(id) && byId.get(id).path !== path64) {
+      id = `${slugFromPath(path64)}-${n++}`;
     }
     byId.set(id, {
       id,
-      name: slugFromPath(path63),
-      path: path63
+      name: slugFromPath(path64),
+      path: path64
     });
   }
   return [...byId.values()];
@@ -50832,9 +51228,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path63 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path64 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path63 === "/health" || path63 === "/v1/health")) {
+      if (req.method === "GET" && (path64 === "/health" || path64 === "/v1/health")) {
         sendJson2(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -50846,18 +51242,18 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path63.startsWith("/v1")) {
+      if (path64.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson2(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path63 === "/v1/config") {
+      if (req.method === "GET" && path64 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson2(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path63 === "/v1/projects") {
+      if (req.method === "GET" && path64 === "/v1/projects") {
         sendJson2(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -50868,7 +51264,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path63 === "/v1/runs") {
+      if (req.method === "GET" && path64 === "/v1/runs") {
         sendJson2(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -50886,7 +51282,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path63 === "/v1/runs") {
+      if (req.method === "POST" && path64 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -50933,7 +51329,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path63);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path64);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -50998,7 +51394,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path63);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path64);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -51151,11 +51547,11 @@ import { execSync as execSync2 } from "node:child_process";
 import { existsSync as existsSync51, readFileSync as readFileSync40, readlinkSync, statSync as statSync10 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import path61 from "node:path";
+import path62 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path61.join(dir, "package.json");
+    const candidate = path62.join(dir, "package.json");
     if (existsSync51(candidate)) {
       try {
         const pkg = JSON.parse(readFileSync40(candidate, "utf8"));
@@ -51163,11 +51559,11 @@ function findPackageRoot(start) {
       } catch {
       }
     }
-    const parent = path61.dirname(dir);
+    const parent = path62.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path61.resolve(__dirname3, "..", "..", "..");
+  return path62.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -51181,7 +51577,7 @@ function tryExec(cmd) {
 }
 function readPackageJson3() {
   try {
-    const pkgPath = path61.join(packageRoot, "package.json");
+    const pkgPath = path62.join(packageRoot, "package.json");
     return JSON.parse(readFileSync40(pkgPath, "utf8"));
   } catch {
     return null;
@@ -51197,7 +51593,7 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path61.join(prefix, shimName);
+  const shimPath = path62.join(prefix, shimName);
   if (!existsSync51(shimPath)) {
     return FAIL(
       `shim not found at ${shimPath}
@@ -51225,8 +51621,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path61.resolve(path61.dirname(shimPath), target);
-    const expected = path61.join(
+    const resolved = path62.resolve(path62.dirname(shimPath), target);
+    const expected = path62.join(
       prefix,
       "node_modules",
       pkgName,
@@ -51265,7 +51661,7 @@ function checkNode(pkg) {
   return OK(`node ${raw}`);
 }
 function checkBundle() {
-  const bundle = path61.join(packageRoot, "dist", "cli", "main.bundled.js");
+  const bundle = path62.join(packageRoot, "dist", "cli", "main.bundled.js");
   if (!existsSync51(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
@@ -51286,7 +51682,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path61.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path62.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -51486,7 +51882,7 @@ var init_doctor = __esm({
     init_metrics2();
     init_contextGrowthSummary();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path61.dirname(fileURLToPath2(import.meta.url));
+    __dirname3 = path62.dirname(fileURLToPath2(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -51670,15 +52066,15 @@ __export(inspect_exports, {
   collectInspectReport: () => collectInspectReport,
   runInspect: () => runInspect
 });
-import path62 from "node:path";
+import path63 from "node:path";
 import { existsSync as existsSync52, readFileSync as readFileSync41, readdirSync as readdirSync11 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
 async function collectInspectReport(cwd = process.cwd()) {
   ensureBuiltinSkillsLoadedSync();
   const snap = listSkillsSnapshot(cwd);
   const mcp = listMcpServers(cwd);
-  const userMcpPath = path62.join(homedir14(), ".zelari-code", "mcp.json");
-  const projectMcpPath = path62.join(cwd, ".zelari", "mcp.json");
+  const userMcpPath = path63.join(homedir14(), ".zelari-code", "mcp.json");
+  const projectMcpPath = path63.join(cwd, ".zelari", "mcp.json");
   const globalHooks = globalHooksDir();
   const projectHooks = projectHooksDir(cwd);
   const projectTrusted = isFolderTrusted(cwd);
@@ -51706,9 +52102,9 @@ async function collectInspectReport(cwd = process.cwd()) {
     configSources: [
       { path: userMcpPath, exists: existsSync52(userMcpPath) },
       { path: projectMcpPath, exists: existsSync52(projectMcpPath) },
-      { path: path62.join(homedir14(), ".zelari-code", "provider.json"), exists: existsSync52(path62.join(homedir14(), ".zelari-code", "provider.json")) },
-      { path: path62.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync52(path62.join(cwd, ".zelari", "AGENTS.md")) },
-      { path: path62.join(cwd, "AGENTS.md"), exists: existsSync52(path62.join(cwd, "AGENTS.md")) }
+      { path: path63.join(homedir14(), ".zelari-code", "provider.json"), exists: existsSync52(path63.join(homedir14(), ".zelari-code", "provider.json")) },
+      { path: path63.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync52(path63.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path63.join(cwd, "AGENTS.md"), exists: existsSync52(path63.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -51748,8 +52144,8 @@ function listJsonFiles(dir) {
 }
 function findAgentsMd(cwd) {
   const candidates = [
-    path62.join(cwd, "AGENTS.md"),
-    path62.join(cwd, ".zelari", "AGENTS.md")
+    path63.join(cwd, "AGENTS.md"),
+    path63.join(cwd, ".zelari", "AGENTS.md")
   ];
   const found = [];
   for (const c of candidates) {
@@ -55024,8 +55420,76 @@ init_completionGate();
 // src/cli/kraken/verificationBridge.ts
 init_candidateRegistry();
 init_completionGate();
+
+// src/cli/kraken/nativeVerification.ts
+init_runtime2();
+init_verification2();
+import { readFile as readFile2 } from "node:fs/promises";
+import path40 from "node:path";
+function nativePackEnabled(env = process.env) {
+  const v = env.ZELARI_VERIFY_PACK?.toLowerCase();
+  return v === "1" || v === "on" || v === "true";
+}
+function resolvePackCommands(env, scripts) {
+  const pick2 = (override, scriptName) => {
+    if (override !== void 0) {
+      const trimmed = override.trim();
+      return trimmed === "" ? null : trimmed;
+    }
+    const script = scripts[scriptName];
+    return typeof script === "string" && script.length > 0 ? `npm run ${scriptName}` : null;
+  };
+  return {
+    typecheckCommand: pick2(env.ZELARI_VERIFY_TYPECHECK_CMD, "typecheck"),
+    testCommand: pick2(env.ZELARI_VERIFY_TEST_CMD, "test"),
+    buildCommand: pick2(env.ZELARI_VERIFY_BUILD_CMD, "build")
+  };
+}
+function packTimeoutMs(env = process.env) {
+  const raw = Number(env.ZELARI_VERIFY_TIMEOUT_MS);
+  if (!Number.isFinite(raw) || raw <= 0) return 6e5;
+  return Math.min(Math.floor(raw), 36e5);
+}
+async function readPackageScripts(cwd = process.cwd()) {
+  try {
+    const raw = await readFile2(path40.join(cwd, "package.json"), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && typeof parsed.scripts === "object") {
+      return parsed.scripts;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function buildNativeCriteria(commands, timeoutMs) {
+  const pack = codingCriteriaPack({ ...commands, commandTimeoutMs: timeoutMs });
+  return pack.criteria.filter(
+    (c) => !(c.required && (!c.check || c.check.kind === "none"))
+  );
+}
+async function evaluateNativePack(deps = {}) {
+  const env = deps.env ?? process.env;
+  if (!nativePackEnabled(env)) return null;
+  const cwd = deps.cwd ?? process.cwd();
+  const commands = resolvePackCommands(env, await readPackageScripts(cwd));
+  if (!commands.typecheckCommand && !commands.testCommand && !commands.buildCommand) return null;
+  const criteria = buildNativeCriteria(commands, packTimeoutMs(env));
+  if (criteria.length === 0) return null;
+  const shell = deps.shell ?? new NodeShellProvider(new LocalWorkspace(cwd));
+  const engine = deps.emit ? new VerificationEngine({ shell }, { emit: deps.emit }) : new VerificationEngine({ shell });
+  const results = await engine.evaluate(criteria, { packId: ZELARI_CODING_PACK_ID });
+  return { packId: ZELARI_CODING_PACK_ID, criteria, results };
+}
+
+// src/cli/kraken/verificationBridge.ts
 init_verification2();
-function strictDoneEnabled() {
+function strictDoneEnabled(surface = "kraken") {
+  if (surface === "mission") {
+    const v2 = process.env.ZELARI_MISSION_STRICT;
+    if (v2 === "0" || v2 === "false") return false;
+    return true;
+  }
   const v = process.env.ZELARI_STRICT_DONE;
   return v === "1" || v === "true";
 }
@@ -55081,32 +55545,71 @@ function krakenResultsToContract(requiredChecks, results, now = Date.now()) {
   });
   return { criteria, results: verifications };
 }
-function evaluateStrictBuildGate(mode) {
+async function anchorSelectionEvidence(results, emit) {
+  if (!emit) return;
+  for (const r of results) {
+    for (const ev of r.evidence) {
+      if (ev.seq !== void 0) continue;
+      if (ev.tier === "verifier-llm" || ev.tier === "human") continue;
+      try {
+        const appended = await emit({
+          kind: "verification.evidence",
+          actor: { type: "system", role: "verification" },
+          data: {
+            observation: "verify-report-note",
+            criterionId: r.criterionId,
+            ref: ev.ref,
+            tier: ev.tier
+          }
+        });
+        const seq = appended && typeof appended === "object" && "seq" in appended ? Number(appended.seq) : NaN;
+        if (Number.isFinite(seq) && seq > 0) ev.seq = seq;
+      } catch {
+      }
+    }
+  }
+}
+async function evaluateStrictBuildGate(mode, options = {}) {
   const gate = evaluateKrakenCompletionGate(mode);
-  if (!gate.selectionUsed || gate.total === 0 || !strictDoneEnabled()) {
+  if (!gate.selectionUsed || gate.total === 0 || !strictDoneEnabled(options.surface ?? "kraken")) {
     return {
       gate,
       strict: false,
       evaluation: null,
+      native: null,
       blocked: gate.blocked,
       summary: gate.blocked ? `blocked: ${gate.failedChecks.length} failed, ${gate.unknownChecks.length} unknown` : "open"
     };
   }
   const checks = krakenRequiredChecks();
   const contract = krakenResultsToContract(checks, getKrakenCheckResults());
-  const evaluation = evaluateCompletion(contract.criteria, contract.results, STRICT_ALL_POLICY);
+  await anchorSelectionEvidence(contract.results, options.emit);
+  const native = await evaluateNativePack({
+    cwd: options.cwd,
+    env: options.env,
+    shell: options.shell,
+    emit: options.emit
+  }).catch(() => null);
+  const allCriteria = [...contract.criteria, ...native?.criteria ?? []];
+  const allResults = [...contract.results, ...native?.results ?? []];
+  const evaluation = evaluateCompletion(allCriteria, allResults, STRICT_BUILD_POLICY);
   const blocked = gate.blocked || evaluation.verdict !== "PASS";
   return {
     gate,
     strict: true,
     evaluation,
+    native,
     blocked,
-    summary: blocked ? `blocked (strict ${evaluation?.verdict ?? "n/a"}): ${gate.passed}/${gate.total} legacy-pass, evidence ${evaluation?.evidenceComplete ? "complete" : "incomplete"}` : `open (strict PASS): ${evaluation?.satisfied.length ?? 0}/${gate.total} criteria pass with evidence`
+    summary: blocked ? `blocked (strict ${evaluation?.verdict ?? "n/a"}): ${gate.passed}/${gate.total} legacy-pass, evidence ${evaluation?.evidenceComplete ? "complete" : "incomplete"}` : `open (strict PASS): ${evaluation?.satisfied.length ?? 0}/${allCriteria.length} criteria pass with evidence`
   };
 }
+var STRICT_DONE_EXIT_CODE = 4;
+function strictGateExitCode(evaluation) {
+  return evaluation.strict && evaluation.blocked ? STRICT_DONE_EXIT_CODE : 0;
+}
 function strictGateEventPayload(evaluation) {
   return {
-    engine: "kraken-legacy+completion-policy",
+    engine: evaluation.native ? "kraken-legacy+completion-policy+criteria-pack" : "kraken-legacy+completion-policy",
     strict: evaluation.strict,
     verdict: evaluation.evaluation?.verdict ?? (evaluation.blocked ? "BLOCKED" : "PASS"),
     legacy: {
@@ -55120,6 +55623,17 @@ function strictGateEventPayload(evaluation) {
       unsatisfied: evaluation.evaluation.unsatisfied,
       complete: evaluation.evaluation.evidenceComplete
     } : null,
+    // F2: deterministic pack results — real command evidence, replayable.
+    native: evaluation.native ? {
+      packId: evaluation.native.packId,
+      criteria: evaluation.native.criteria.map((c) => ({ id: c.id, required: c.required })),
+      results: evaluation.native.results.map((r) => ({
+        criterionId: r.criterionId,
+        status: r.status,
+        evidence: r.evidence.map((e) => ({ tier: e.tier, ref: e.ref, digest: e.digest, ...e.seq !== void 0 ? { seq: e.seq } : {} })),
+        detail: r.detail
+      }))
+    } : null,
     summary: evaluation.summary
   };
 }
@@ -55631,7 +56145,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           });
         }
         const cwd = process.cwd();
-        const budget = await applyBudgetPolicyAsync(getHistory(), getPhase(), {
+        const budget = await applyBudgetPolicyAsync(historyForModel, getPhase(), {
           model: getActiveModel(),
           sessionId: sessionId2,
           // v1.36.0: envelope for full-request metering + cache-aware
@@ -55657,6 +56171,7 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           });
           void writerRef.current?.append(compactionEvent);
         }
+        historyForModel = budget.history;
         historySeedLen = historyForModel.length;
         let composedWorkspace = "";
         let composedInstructions = "";
@@ -55873,8 +56388,9 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
             progressRuntime.observe(event);
             if (event.type === "agent_end") {
               let krakenSuppressFinish = false;
+              const krakenSpineEmit = (input) => writerRef.current?.spine?.appendEvent(input) ?? Promise.resolve(null);
               if (event.reason === "completed" && !krakenRepairEnqueued && isKrakenSelectionEnabled() && workPhase === "build") {
-                const strictGate = evaluateStrictBuildGate("build");
+                const strictGate = await evaluateStrictBuildGate("build", { emit: krakenSpineEmit });
                 const krakenGate = strictGate.gate;
                 writerRef.current?.spine?.verificationRun(strictGateEventPayload(strictGate));
                 if (krakenGate.blocked) {
@@ -55890,8 +56406,17 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
                   krakenSuppressFinish = true;
                 }
               }
-              if (event.reason === "completed" && krakenRepairEnqueued && !evaluateStrictBuildGate("build").blocked) {
+              if (event.reason === "completed" && krakenRepairEnqueued && !(await evaluateStrictBuildGate("build", { emit: krakenSpineEmit })).blocked) {
                 markRepairSucceeded();
+              } else if (event.reason === "completed" && krakenRepairEnqueued) {
+                const still = await evaluateStrictBuildGate("build", { emit: krakenSpineEmit });
+                if (still.blocked) {
+                  appendSystem(
+                    setMessages,
+                    `[kraken] strict done: evidence still incomplete after repair (${still.evaluation?.unsatisfied.length ?? "?"} unresolved) \u2014 turn is NOT verified-complete`,
+                    Date.now()
+                  );
+                }
               }
               if (!krakenSuppressFinish) progressRuntime.finish(event.reason);
             }
@@ -56285,14 +56810,31 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
     return { completionOk: false, ran: false };
   }
   setBusy(true);
-  compactInPlace();
-  const councilBudget = await applyBudgetPolicyAsync(getHistory(), getPhase(), {
+  let councilHistory = getHistory();
+  {
+    const mirror = writerRef.current?.spine ?? null;
+    if (mirror && mirror.status === "active") {
+      const derived = await mirror.derivedPriorTurns();
+      if (derived && derived.length > 0) {
+        councilHistory = derivedModelSeed(derived);
+      }
+    }
+  }
+  const councilBudget = await applyBudgetPolicyAsync(councilHistory, getPhase(), {
     model: envConfig.model
   });
   setHistory(councilBudget.history);
   for (const w of councilBudget.warnings) {
     appendSystem(setMessages, w, Date.now());
   }
+  if ((councilBudget.messagesRemoved ?? 0) > 0) {
+    void writerRef.current?.append(
+      createBrainEvent("session_compacted", sessionId2, {
+        summary: councilBudget.compactSummary ?? "",
+        messagesRemoved: councilBudget.messagesRemoved ?? 0
+      })
+    );
+  }
   const anchored = maybeAnchorShortAnswer(text);
   const effectiveText = anchored ?? text;
   appendSystem(
@@ -57894,7 +58436,7 @@ init_sessionManager();
 // src/cli/gitOps.ts
 import { execFile as execFile4 } from "node:child_process";
 import { promisify as promisify3 } from "node:util";
-import path47 from "node:path";
+import path48 from "node:path";
 var execFileAsync3 = promisify3(execFile4);
 async function git4(cwd, args) {
   try {
@@ -57940,7 +58482,7 @@ async function undoWorkingChanges(opts = {}) {
   };
 }
 function defaultProjectRoot() {
-  return path47.resolve(__dirname, "..", "..", "..");
+  return path48.resolve(__dirname, "..", "..", "..");
 }
 
 // src/cli/slashHandlers/git.ts
@@ -58392,7 +58934,7 @@ import { promises as fs29 } from "node:fs";
 init_zod();
 init_taskTool();
 import { promises as fs28 } from "node:fs";
-import path51 from "node:path";
+import path52 from "node:path";
 import { randomBytes as randomBytes4 } from "node:crypto";
 var CsvFanoutArgsSchema = external_exports.object({
   csv_path: external_exports.string().min(1),
@@ -58486,8 +59028,8 @@ function resolveMaxConcurrency(env = process.env) {
 }
 async function runCsvFanout(args, deps, opts) {
   const start = Date.now();
-  const absCsv = path51.isAbsolute(args.csv_path) ? args.csv_path : path51.join(opts.parentCwd, args.csv_path);
-  const absOut = path51.isAbsolute(args.output_csv_path) ? args.output_csv_path : path51.join(opts.parentCwd, args.output_csv_path);
+  const absCsv = path52.isAbsolute(args.csv_path) ? args.csv_path : path52.join(opts.parentCwd, args.csv_path);
+  const absOut = path52.isAbsolute(args.output_csv_path) ? args.output_csv_path : path52.join(opts.parentCwd, args.output_csv_path);
   const { headers: headers2, rows } = await readCsv(absCsv);
   if (headers2.length === 0) {
     throw new Error(`kraken_csv_fanout: ${absCsv} is empty`);
@@ -58543,7 +59085,7 @@ async function runCsvFanout(args, deps, opts) {
         errored += 1;
         errors.push(`${row[args.id_column] ?? i}: ${res.error}`);
       }
-      await fs28.mkdir(path51.dirname(absOut), { recursive: true });
+      await fs28.mkdir(path52.dirname(absOut), { recursive: true });
       await queueWrite(serializeCsv(outHeaders, outputRecords));
     }
   }
@@ -58738,7 +59280,7 @@ function splitArgs(s) {
 // src/cli/slashHandlers/krakenWorkbench.ts
 init_messageHelpers();
 import { promises as fs30 } from "node:fs";
-import path52 from "node:path";
+import path53 from "node:path";
 
 // src/cli/kraken/workbenchView.ts
 var EMPTY = {
@@ -58855,14 +59397,14 @@ function formatWorkbenchForTerminal(p3) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 async function handleKrakenWorkbench(ctx) {
-  const dir = path52.join(ctx.cwd, ".zelari", "radio");
+  const dir = path53.join(ctx.cwd, ".zelari", "radio");
   let latest = null;
   let latestMtime = 0;
   try {
     const files = await fs30.readdir(dir);
     for (const f of files) {
       if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
-      const full = path52.join(dir, f);
+      const full = path53.join(dir, f);
       const stat = await fs30.stat(full);
       if (stat.mtimeMs > latestMtime) {
         latestMtime = stat.mtimeMs;
@@ -58879,10 +59421,10 @@ async function handleKrakenWorkbench(ctx) {
   const parsed = parseWorkbench(content);
   const rendered = formatWorkbenchForTerminal(parsed);
   if (!rendered.trim()) {
-    appendSystem(ctx.setMessages, `[kraken workbench] ${path52.basename(latest)}: (no nodes / no events yet)`);
+    appendSystem(ctx.setMessages, `[kraken workbench] ${path53.basename(latest)}: (no nodes / no events yet)`);
     return;
   }
-  appendSystem(ctx.setMessages, `[kraken workbench] ${path52.basename(latest)}:
+  appendSystem(ctx.setMessages, `[kraken workbench] ${path53.basename(latest)}:
 ${rendered}`);
 }
 
@@ -59189,15 +59731,15 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 // src/cli/slashHandlers/promoteMember.ts
 init_messageHelpers();
 import { promises as fs31 } from "node:fs";
-import path55 from "node:path";
+import path56 from "node:path";
 import os12 from "node:os";
 async function handlePromoteMember(ctx, memberId) {
   try {
     const { promoteMember: promoteMember2 } = await Promise.resolve().then(() => (init_council(), council_exports));
     const { skill, markdown } = promoteMember2(memberId);
-    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path55.join(os12.homedir(), ".tmp", "zelari-code", "skills");
+    const skillDir = process.env.ANATHEMA_SKILL_DIR ?? path56.join(os12.homedir(), ".tmp", "zelari-code", "skills");
     await fs31.mkdir(skillDir, { recursive: true });
-    const filePath = path55.join(skillDir, `${skill.id}.md`);
+    const filePath = path56.join(skillDir, `${skill.id}.md`);
     await fs31.writeFile(filePath, markdown, "utf8");
     appendSystem(
       ctx.setMessages,
@@ -59215,24 +59757,24 @@ async function handlePromoteMember(ctx, memberId) {
 
 // src/cli/branchManager.ts
 import { promises as fs32, existsSync as existsSync44, readFileSync as readFileSync36, writeFileSync as writeFileSync23, mkdirSync as mkdirSync19, statSync as statSync7, rmSync as rmSync3 } from "node:fs";
-import path56 from "node:path";
+import path57 from "node:path";
 import os13 from "node:os";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
-  return process.env.ANATHEMA_BRANCHES_DIR ?? path56.join(os13.homedir(), ".tmp", "zelari-code", "branches");
+  return process.env.ANATHEMA_BRANCHES_DIR ?? path57.join(os13.homedir(), ".tmp", "zelari-code", "branches");
 }
 function getSessionsBaseDir() {
-  return process.env.ANATHEMA_SESSIONS_DIR ?? path56.join(os13.homedir(), ".tmp", "zelari-code", "sessions");
+  return process.env.ANATHEMA_SESSIONS_DIR ?? path57.join(os13.homedir(), ".tmp", "zelari-code", "sessions");
 }
 function branchPathFor(name, baseDir) {
-  return path56.join(baseDir, name);
+  return path57.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path56.join(baseDir, name, META_FILENAME);
+  return path57.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path56.join(baseDir, name, SESSIONS_SUBDIR);
+  return path57.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -59257,7 +59799,7 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync19(path56.dirname(metaPath), { recursive: true });
+  mkdirSync19(path57.dirname(metaPath), { recursive: true });
   writeFileSync23(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
@@ -59308,14 +59850,14 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path56.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path57.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
   if (!existsSync44(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync19(branchSessionsPath, { recursive: true });
-  const destPath = path56.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  const destPath = path57.join(branchSessionsPath, `${fromSessionId}.jsonl`);
   await fs32.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
@@ -59419,14 +59961,14 @@ async function handleBranchCheckout(ctx, branchName) {
 // src/cli/slashHandlers/workspace.ts
 init_messageHelpers();
 import { promises as fs33 } from "node:fs";
-import path57 from "node:path";
+import path58 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path57.join(process.cwd(), ".zelari");
+    const zelari = path58.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path57.join(zelari, "plan.md");
+        const planPath = path58.join(zelari, "plan.md");
         try {
           content = await fs33.readFile(planPath, "utf-8");
         } catch {
@@ -59435,7 +59977,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "decisions": {
-        const decisionsDir = path57.join(zelari, "decisions");
+        const decisionsDir = path58.join(zelari, "decisions");
         try {
           const files = (await fs33.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
@@ -59445,7 +59987,7 @@ async function handleWorkspaceShow(ctx, what) {
 `];
             const { parseFrontmatter: parseFrontmatter2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
             for (const f of files) {
-              const raw = await fs33.readFile(path57.join(decisionsDir, f), "utf-8");
+              const raw = await fs33.readFile(path58.join(decisionsDir, f), "utf-8");
               const { meta: meta3, body } = parseFrontmatter2(raw);
               const title = meta3.title ?? body.split("\n")[0]?.replace(/^#\s*/, "").trim() ?? f;
               lines.push(`- **${f.replace(/\.md$/, "")}** [${meta3.status ?? "unknown"}] ${title}`);
@@ -59458,7 +60000,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path57.join(zelari, "risks.md");
+        const risksPath = path58.join(zelari, "risks.md");
         try {
           content = await fs33.readFile(risksPath, "utf-8");
         } catch {
@@ -59467,7 +60009,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "agents": {
-        const agentsPath = path57.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path58.join(process.cwd(), "AGENTS.MD");
         try {
           content = await fs33.readFile(agentsPath, "utf-8");
         } catch {
@@ -59476,7 +60018,7 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "docs": {
-        const docsDir = path57.join(zelari, "docs");
+        const docsDir = path58.join(zelari, "docs");
         try {
           const files = (await fs33.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
@@ -59518,7 +60060,7 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path57.join(process.cwd(), ".zelari");
+    const target = path58.join(process.cwd(), ".zelari");
     await fs33.rm(target, { recursive: true, force: true });
     appendSystem(ctx.setMessages, "[workspace] .zelari/ removed");
   } catch (err) {
@@ -59530,7 +60072,7 @@ async function handleWorkspaceReset(ctx, force) {
 init_provider2();
 
 // src/cli/slashHandlers/skills.ts
-import path58 from "node:path";
+import path59 from "node:path";
 import os14 from "node:os";
 
 // src/cli/skillHistory.ts
@@ -59659,7 +60201,7 @@ function handleSkillPicker(ctx, skills, openPicker, fallbackMessage) {
   });
 }
 async function handleSkillStats(ctx, skillId) {
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path58.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path59.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const records = await readSkillHistory(historyFile);
     const stats = getSkillStats(records, skillId);
@@ -59675,7 +60217,7 @@ async function handleSkillCompare(ctx, ids, fallbackMessage) {
     appendSystem(ctx.setMessages, fallbackMessage ?? "[skill-compare] missing args");
     return;
   }
-  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path58.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
+  const historyFile = process.env.ANATHEMA_SKILL_HISTORY_FILE ?? path59.join(os14.homedir(), ".tmp", "zelari-code", "skill-history.jsonl");
   try {
     const formatted = await compareSkillsFromFile(ids[0], ids[1], historyFile);
     appendSystem(ctx.setMessages, formatted);
@@ -61219,7 +61761,7 @@ function createStreamScrubber2() {
 init_taskTool();
 init_sessionTodos();
 import { promises as fs36 } from "node:fs";
-import path60 from "node:path";
+import path61 from "node:path";
 import { randomUUID as randomUUID6 } from "node:crypto";
 init_headlessSpine();
 async function runHeadless(opts) {
@@ -61376,7 +61918,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
   try {
     let preflightGraph;
     if (opts.runPlan && opts.runPlan.trim() !== "") {
-      const planPath = path60.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
+      const planPath = path61.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
       log(`loading pre-flight plan: ${planPath}`);
       let raw;
       try {
@@ -61416,8 +61958,8 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     log(formatKrakenGraphAscii2(graph));
     if (opts.planOnly) {
       const planId = randomUUID6();
-      const planDir = path60.join(cwd, ".zelari", "radio");
-      const planPath = path60.join(planDir, `plan-${planId}.json`);
+      const planDir = path61.join(cwd, ".zelari", "radio");
+      const planPath = path61.join(planDir, `plan-${planId}.json`);
       await fs36.mkdir(planDir, { recursive: true });
       await fs36.writeFile(
         planPath,
@@ -61550,6 +62092,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     workspace: process.cwd()
   });
   const seededHistory = await seedHeadlessModelHistory(spine, opts.history);
+  emitEvent(sessionStartedEvent(spine));
   if (opts.task) spine.userMessage(opts.task);
   resetKrakenCandidates();
   resetKrakenTurnMetrics();
@@ -61862,8 +62405,9 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       emittedWrites: pass.emittedWrites + retry.emittedWrites
     };
   }
+  let strictExit = 0;
   if (pass.finalReason === "completed" && pass.exitCode === 0 && opts.mode === "kraken" && isKrakenSelectionEnabled() && !planModeFromOpts(opts)) {
-    const strictGate = evaluateStrictBuildGate("build");
+    const strictGate = await evaluateStrictBuildGate("build", { emit: (input) => spine.appendEvent(input) });
     const gate = strictGate.gate;
     const verificationPayload = strictGateEventPayload(strictGate);
     spine.verificationRun(verificationPayload);
@@ -61896,13 +62440,20 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
         successfulWrites: pass.successfulWrites + repair.successfulWrites,
         emittedWrites: pass.emittedWrites + repair.emittedWrites
       };
-      const after = evaluateStrictBuildGate("build");
+      const after = await evaluateStrictBuildGate("build", { emit: (input) => spine.appendEvent(input) });
       const afterPayload = strictGateEventPayload(after);
       spine.verificationRun(afterPayload);
       if (opts.output === "json") {
         emitEvent({ type: "verification_run", ...afterPayload });
       }
       if (!after.blocked) markRepairSucceeded();
+      else {
+        strictExit = strictGateExitCode(after);
+        const gateMsg = `[headless] Kraken BUILD: strict completion gate still blocked after repair pass \u2014 closing non-success (exit ${strictExit}): ${after.summary}`;
+        if (opts.output === "json") emitEvent({ type: "log", message: gateMsg });
+        else process.stderr.write(`[zelari-code --headless] ${gateMsg}
+`);
+      }
     }
   }
   progressRuntime.finish(pass.finalReason);
@@ -61951,7 +62502,8 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     }
   }
   try {
-    await spine.close(pass.finalReason === "error" ? "error" : "completed");
+    const closeStatus = pass.finalReason === "error" ? "error" : strictExit !== 0 ? "stopped" : "completed";
+    await spine.close(closeStatus);
   } catch {
   }
   if (opts.exportSessionPath) {
@@ -61960,7 +62512,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       if (json2) {
         if (opts.exportSessionPath === "-") process.stdout.write(json2 + "\n");
         else {
-          await fs36.mkdir(path60.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs36.mkdir(path61.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
           await fs36.writeFile(opts.exportSessionPath, json2, "utf8");
         }
       }
@@ -61968,6 +62520,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     }
   }
   if (pass.finalReason === "error") return 3;
+  if (strictExit !== 0) return strictExit;
   return pass.exitCode;
 }
 async function buildCouncilToolRegistry(planMode, opts) {
@@ -62007,6 +62560,7 @@ async function runHeadlessCouncil(opts, provider, model, providerStream) {
     workspace: process.cwd()
   });
   const seededHistory = await seedHeadlessModelHistory(spine, opts.history);
+  emitEvent(sessionStartedEvent(spine));
   if (opts.task) spine.userMessage(opts.task);
   const { shouldAllowCouncilBuild: shouldAllowCouncilBuild2 } = await Promise.resolve().then(() => (init_buildPolicy(), buildPolicy_exports));
   let councilRunMode = planModeFromOpts(opts) ? "design-phase" : "implementation";
@@ -62125,7 +62679,7 @@ async function runHeadlessCouncil(opts, provider, model, providerStream) {
       if (json2) {
         if (opts.exportSessionPath === "-") process.stdout.write(json2 + "\n");
         else {
-          await fs36.mkdir(path60.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs36.mkdir(path61.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
           await fs36.writeFile(opts.exportSessionPath, json2, "utf8");
         }
       }
@@ -62144,6 +62698,7 @@ async function runHeadlessZelari(opts, provider, model, providerStream) {
     workspace: projectRoot
   });
   const seededHistory = await seedHeadlessModelHistory(spine, opts.history);
+  emitEvent(sessionStartedEvent(spine));
   if (opts.task) spine.userMessage(opts.task);
   spine.missionPhase("design", "mission-start");
   const { buildMissionBrief: buildMissionBrief2 } = await Promise.resolve().then(() => (init_council(), council_exports));
@@ -62210,6 +62765,13 @@ ${JSON.stringify({ deliverable: brief.deliverableThisMission, mvp: brief.sliceMv
       emit,
       buildViaAgent,
       onMissionPhase: (phase2, note) => spine.missionPhase(phase2, note),
+      onMissionProgress: (advice, iteration) => spine.missionProgress({
+        recommendation: advice.recommendation,
+        rationale: advice.rationale,
+        blockers: advice.blockers,
+        ...advice.trend ? { trend: advice.trend } : {},
+        iteration
+      }),
       runSlice: async ({
         userMessage: slicePrompt,
         runMode,
@@ -62414,8 +62976,22 @@ ${ragContext}` : slicePrompt;
     });
     if (state3.status === "error") exitCode = exitCode || 3;
     else if (state3.status === "success") {
-      exitCode = 0;
-      spine.missionPhase("done", "mission-success");
+      const missionGate = await evaluateStrictBuildGate("build", {
+        emit: (input) => spine.appendEvent(input),
+        surface: "mission"
+      });
+      const missionVerificationPayload = strictGateEventPayload(missionGate);
+      spine.verificationRun(missionVerificationPayload);
+      if (opts.output === "json") {
+        emitEvent({ type: "verification_run", ...missionVerificationPayload });
+      }
+      if (missionGate.blocked) {
+        exitCode = strictGateExitCode(missionGate);
+        spine.missionPhase("verification", "mission-strict-blocked");
+      } else {
+        exitCode = 0;
+        spine.missionPhase("done", "mission-success");
+      }
     } else if (state3.status === "stalled" || state3.status === "stopped") {
       exitCode = exitCode || 0;
       spine.missionPhase("verification", `mission-${state3.status}`);
@@ -62443,7 +63019,7 @@ ${ragContext}` : slicePrompt;
         if (json2) {
           if (opts.exportSessionPath === "-") process.stdout.write(json2 + "\n");
           else {
-            await fs36.mkdir(path60.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+            await fs36.mkdir(path61.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
             await fs36.writeFile(opts.exportSessionPath, json2, "utf8");
           }
         }
@@ -62657,8 +63233,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 path63 = 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 = path63 && /^[a-z0-9]/.test(path63) ? path63 : "imported-skill";
+      const path64 = 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 = path64 && /^[a-z0-9]/.test(path64) ? path64 : "imported-skill";
     } catch {
       name = "imported-skill";
     }