zelari-code 2.56.0 → 2.57.0

package/dist/cli/main.bundled.js

@@ -3876,10 +3876,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path126) {
-  if (!path126)
+function getElementAtPath(obj, path128) {
+  if (!path128)
     return obj;
-  return path126.reduce((acc, key) => acc?.[key], obj);
+  return path128.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -4207,11 +4207,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path126, issues) {
+function prefixIssues(path128, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path126);
+    iss.path.unshift(path128);
     return iss;
   });
 }
@@ -4429,16 +4429,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path126 = []) => {
+  const processError = (error52, path128 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path126, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path128, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path126, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path128, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path126, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path128, ...issue2.path]);
       } else {
-        const fullpath = [...path126, ...issue2.path];
+        const fullpath = [...path128, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -4465,17 +4465,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path126 = []) => {
+  const processError = (error52, path128 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path126, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path128, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path126, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path128, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path126, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path128, ...issue2.path]);
       } else {
-        const fullpath = [...path126, ...issue2.path];
+        const fullpath = [...path128, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -4507,8 +4507,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path126 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path126) {
+  const path128 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path128) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -18011,13 +18011,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path126 = ref.slice(1).split("/").filter(Boolean);
-  if (path126.length === 0) {
+  const path128 = ref.slice(1).split("/").filter(Boolean);
+  if (path128.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path126[0] === defsKey) {
-    const key = path126[1];
+  if (path128[0] === defsKey) {
+    const key = path128[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -18851,17 +18851,17 @@ var init_newlines = __esm({
 });
 
 // packages/core/dist/core/tools/builtin/fileEvents.js
-function fileReadEvent(path126, snapshotId) {
-  return { kind: "file.read", actor: { type: "tool" }, data: { path: path126, snapshotId } };
+function fileReadEvent(path128, snapshotId) {
+  return { kind: "file.read", actor: { type: "tool" }, data: { path: path128, snapshotId } };
 }
-function fileAppliedEvent(path126, snapshotId, bytes) {
-  return { kind: "file.applied", actor: { type: "tool" }, data: { path: path126, snapshotId, bytes } };
+function fileAppliedEvent(path128, snapshotId, bytes) {
+  return { kind: "file.applied", actor: { type: "tool" }, data: { path: path128, snapshotId, bytes } };
 }
-function fileRejectedEvent(path126, reason, hint) {
+function fileRejectedEvent(path128, reason, hint) {
   return {
     kind: "file.rejected",
     actor: { type: "tool" },
-    data: hint === void 0 ? { path: path126, reason } : { path: path126, reason, hint }
+    data: hint === void 0 ? { path: path128, reason } : { path: path128, reason, hint }
   };
 }
 function reReadHint(reject) {
@@ -20817,11 +20817,11 @@ var init_tools = __esm({
           if (!ctx.addDocument)
             return "Knowledge vault tool not available.";
           const title = args["title"] || "New Document";
-          const path126 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+          const path128 = args["path"] || `notes/${title.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
           const content = args["content"] || "";
           const tags = args["tags"] || [];
           ctx.addDocument({
-            path: path126,
+            path: path128,
             title,
             content,
             format: "markdown",
@@ -20830,7 +20830,7 @@ var init_tools = __esm({
             workspaceId: ctx.workspaceId
           });
           ctx.addActivity("vault", "created document", title);
-          return `Document "${title}" created at "${path126}".`;
+          return `Document "${title}" created at "${path128}".`;
         }
       }
     ];
@@ -24666,7 +24666,7 @@ async function createExecutionContext(options = {}) {
       workspaceKind: workspace.kind
     }
   });
-  const fs51 = options.fs ?? new NodeFsProvider(workspace);
+  const fs52 = options.fs ?? new NodeFsProvider(workspace);
   const shell = options.shell ?? new NodeShellProvider(workspace);
   const subagent = options.subagent ?? NOOP_SUBAGENT_PROVIDER;
   const env = options.env ?? process.env;
@@ -24674,7 +24674,7 @@ async function createExecutionContext(options = {}) {
     sessionId: sessionId2,
     profile,
     workspace,
-    fs: fs51,
+    fs: fs52,
     shell,
     subagent,
     appendSessionEvent: (input) => writer.append(input),
@@ -26075,16 +26075,16 @@ function runRetentionFromEnv() {
     maxTotalBytes: Number.isFinite(parseMb) && parseMb > 0 ? Math.round(parseMb * 1024 * 1024) : DEFAULT_RUN_RETENTION_MAX_MB * 1024 * 1024
   };
 }
-async function dirSize(path126) {
+async function dirSize(path128) {
   let total = 0;
   let entries;
   try {
-    entries = await readdir(path126, { withFileTypes: true });
+    entries = await readdir(path128, { withFileTypes: true });
   } catch {
     return 0;
   }
   for (const entry of entries) {
-    const child = join3(path126, entry.name);
+    const child = join3(path128, entry.name);
     if (entry.isDirectory())
       total += await dirSize(child);
     else {
@@ -26111,19 +26111,19 @@ async function enforceRunRetention(runsDir, options = {}) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const path126 = join3(runsDir, entry.name);
+    const path128 = join3(runsDir, entry.name);
     let startedAt = 0;
     let endedAt;
     let completed = false;
     try {
-      const manifest = JSON.parse(await readFile(join3(path126, "manifest.json"), "utf8"));
+      const manifest = JSON.parse(await readFile(join3(path128, "manifest.json"), "utf8"));
       startedAt = manifest.startedAt ?? 0;
       endedAt = manifest.endedAt;
       completed = Boolean(endedAt) && manifest.status !== "running";
     } catch {
       completed = false;
     }
-    infos.push({ name: entry.name, path: path126, startedAt, endedAt, completed, bytes: await dirSize(path126) });
+    infos.push({ name: entry.name, path: path128, startedAt, endedAt, completed, bytes: await dirSize(path128) });
   }
   const remove = async (info) => {
     await rm(info.path, { recursive: true, force: true });
@@ -26681,12 +26681,12 @@ var init_engine = __esm({
        * content digest) and the returned ref carries the event seq when the
        * emitter resolved one.
        */
-      async fsEvidence(observation, path126, sha2562, content, extra = {}) {
+      async fsEvidence(observation, path128, sha2562, content, extra = {}) {
         const digest = sha2562 && content !== void 0 ? sha2562(content) : void 0;
-        const seq = await this.emitEvidence({ observation, path: path126, ...extra, ...digest ? { digest } : {} });
+        const seq = await this.emitEvidence({ observation, path: path128, ...extra, ...digest ? { digest } : {} });
         return {
           tier: "fs-observation",
-          ref: path126,
+          ref: path128,
           capturedAt: Date.now(),
           ...digest ? { digest } : {},
           ...seq !== void 0 ? { seq } : {}
@@ -26694,25 +26694,25 @@ var init_engine = __esm({
       }
       async evalFileExists(check2, done) {
         const sha2562 = this.options.sha256 ?? defaultSha256;
-        const fs51 = this.services.fs;
-        if (!fs51)
+        const fs52 = this.services.fs;
+        if (!fs52)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
-        const exists = await fs51.exists(check2.path);
+        const exists = await fs52.exists(check2.path);
         if (!exists) {
           await this.emitEvidence({ observation: "file-exists", path: check2.path, exists: false });
           return done({ status: "fail", evidence: [], detail: `file not found: ${check2.path}` });
         }
-        const content = await fs51.readFile(check2.path).catch(() => "");
+        const content = await fs52.readFile(check2.path).catch(() => "");
         return done({
           status: "pass",
           evidence: [await this.fsEvidence("file-exists", check2.path, sha2562, content, { exists: true })]
         });
       }
       async evalFileAbsent(check2, done) {
-        const fs51 = this.services.fs;
-        if (!fs51)
+        const fs52 = this.services.fs;
+        if (!fs52)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
-        const exists = await fs51.exists(check2.path);
+        const exists = await fs52.exists(check2.path);
         if (exists) {
           await this.emitEvidence({ observation: "file-absent", path: check2.path, exists: true });
           return done({ status: "fail", evidence: [], detail: `file still present: ${check2.path}` });
@@ -26724,12 +26724,12 @@ var init_engine = __esm({
       }
       async evalFileContains(check2, done) {
         const sha2562 = this.options.sha256 ?? defaultSha256;
-        const fs51 = this.services.fs;
-        if (!fs51)
+        const fs52 = this.services.fs;
+        if (!fs52)
           return done({ status: "unknown", evidence: [], detail: "fs provider unavailable" });
         let content;
         try {
-          content = await fs51.readFile(check2.path);
+          content = await fs52.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}` });
@@ -28463,8 +28463,8 @@ function strictEnvOverlay(knobs, base2 = process.env) {
   return overlay;
 }
 function criterionId(check2, index) {
-  const slug = check2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
-  return `check-${index + 1}-${slug || "criterion"}`;
+  const slug2 = check2.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+  return `check-${index + 1}-${slug2 || "criterion"}`;
 }
 function normalize3(text) {
   return text.toLowerCase().replace(/\s+/g, " ").trim();
@@ -34430,11 +34430,11 @@ var init_synthesisAudit = __esm({
 import { existsSync as existsSync16, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
 import { join as join5 } from "node:path";
 function loadNfrSpec(zelariRoot) {
-  const path126 = join5(zelariRoot, "nfr-spec.json");
-  if (!existsSync16(path126))
+  const path128 = join5(zelariRoot, "nfr-spec.json");
+  if (!existsSync16(path128))
     return null;
   try {
-    const raw = JSON.parse(readFileSync15(path126, "utf8"));
+    const raw = JSON.parse(readFileSync15(path128, "utf8"));
     if (raw.version !== 1 || !Array.isArray(raw.targets))
       return null;
     return raw;
@@ -36835,9 +36835,9 @@ var init_types9 = __esm({
 import { readFileSync as readFileSync20 } from "node:fs";
 import { join as join11 } from "node:path";
 function readLessonsDeduped(zelariRoot) {
-  const path126 = join11(zelariRoot, LESSONS_FILE);
+  const path128 = join11(zelariRoot, LESSONS_FILE);
   try {
-    const raw = readFileSync20(path126, "utf8");
+    const raw = readFileSync20(path128, "utf8");
     const byId = /* @__PURE__ */ new Map();
     for (const line of raw.split(/\r?\n/)) {
       if (!line.trim())
@@ -36938,8 +36938,8 @@ function keywordsFrom(check2, signature) {
   return [.../* @__PURE__ */ new Set([...fromId, ...words])].slice(0, 12);
 }
 function writeLesson(zelariRoot, lesson) {
-  const path126 = join12(zelariRoot, LESSONS_FILE);
-  appendFileSync(path126, `${JSON.stringify(lesson)}
+  const path128 = join12(zelariRoot, LESSONS_FILE);
+  appendFileSync(path128, `${JSON.stringify(lesson)}
 `, "utf8");
 }
 function findSimilar(lessons, signature) {
@@ -37550,7 +37550,7 @@ var init_types11 = __esm({
 });
 
 // packages/core/dist/memory/schemas.js
-var isoDate, unit, metadata, MemoryKindSchema, MemoryStatusSchema, MemoryRelationSchema, MemoryVisibilitySchema, MemorySourceSchema, MemoryNodeInputSchema, MemoryNodeSchema, MemoryEdgeInputSchema, MemoryEdgeSchema;
+var isoDate, unit, metadata, relevantWhen, MemoryKindSchema, MemoryStatusSchema, MemoryRelationSchema, MemoryVisibilitySchema, MemorySourceSchema, MemoryNodeInputSchema, MemoryNodeSchema, MemoryEdgeInputSchema, MemoryEdgeSchema;
 var init_schemas3 = __esm({
   "packages/core/dist/memory/schemas.js"() {
     "use strict";
@@ -37565,6 +37565,7 @@ var init_schemas3 = __esm({
         return false;
       }
     }, "Memory metadata must be JSON-serializable and no larger than 128 KB.");
+    relevantWhen = external_exports.array(external_exports.string().min(1).max(120)).max(8).optional();
     MemoryKindSchema = external_exports.enum(MEMORY_KINDS);
     MemoryStatusSchema = external_exports.enum(MEMORY_STATUSES);
     MemoryRelationSchema = external_exports.enum(MEMORY_RELATIONS);
@@ -37596,6 +37597,7 @@ var init_schemas3 = __esm({
       status: MemoryStatusSchema.optional(),
       visibility: MemoryVisibilitySchema.optional(),
       tags: external_exports.array(external_exports.string().min(1).max(120)).max(64).optional(),
+      relevantWhen,
       source: MemorySourceSchema.optional(),
       createdAt: isoDate.optional(),
       recordedAt: isoDate.optional(),
@@ -37678,11 +37680,13 @@ function scoreMemoryCandidate(candidate, query, options = {}) {
     confidence: node.confidence,
     recency: recencyScore(node.updatedAt, options.now, options.recencyHalfLifeDays),
     graphProximity: Math.max(0, Math.min(1, candidate.graphProximity ?? 0)),
-    verificationBonus: verified(node)
+    verificationBonus: verified(node),
+    triggerMatch: Math.max(0, Math.min(1, candidate.triggerMatch ?? 0))
   };
   const weights = { ...DEFAULT_MEMORY_SCORING_WEIGHTS, ...options.weights };
   const semanticAvailable = candidate.semanticRelevance !== void 0;
-  const activeEntries = Object.entries(weights).filter(([key]) => semanticAvailable || key !== "semanticRelevance");
+  const triggerAvailable = candidate.triggerMatch !== void 0;
+  const activeEntries = Object.entries(weights).filter(([key]) => (semanticAvailable || key !== "semanticRelevance") && (triggerAvailable || key !== "triggerMatch"));
   const totalWeight = activeEntries.reduce((sum, [, weight]) => sum + Math.max(0, weight), 0);
   const weighted = activeEntries.reduce((sum, [key, weight]) => sum + signals[key] * Math.max(0, weight), 0);
   const score = totalWeight > 0 ? weighted / totalWeight : 0;
@@ -37702,11 +37706,117 @@ var init_scoring = __esm({
       confidence: 0.1,
       recency: 0.1,
       graphProximity: 0.1,
-      verificationBonus: 0.05
+      verificationBonus: 0.05,
+      // A trigger hit is a strong "this memory is useful now" signal; weight it
+      // above lexical overlap so an associative match beats a loose keyword match.
+      triggerMatch: 0.4
     };
   }
 });
 
+// packages/core/dist/memory/relevantWhen.js
+function keyTokens(value) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const token of memoryTokens(value)) {
+    if (token.length < 3 || token.length > MAX_TOKEN_LENGTH)
+      continue;
+    if (STOPWORDS.has(token) || seen.has(token))
+      continue;
+    seen.add(token);
+    out.push(token);
+  }
+  return out;
+}
+function clip(phrase) {
+  const trimmed = phrase.replace(/\s+/g, " ").trim();
+  return trimmed.length <= MAX_PHRASE_LENGTH ? trimmed : `${trimmed.slice(0, MAX_PHRASE_LENGTH - 1).trimEnd()}\u2026`;
+}
+function deriveRelevantWhen(content, kind2, tags = []) {
+  const tokens = keyTokens(content);
+  for (const tag of tags) {
+    for (const token of keyTokens(tag)) {
+      if (!tokens.includes(token))
+        tokens.push(token);
+    }
+  }
+  if (tokens.length === 0)
+    return [];
+  if (kind2 === "failure") {
+    const errorClass = tokens.find((token) => ERRORISH.test(token));
+    const tool = tokens.find((token) => TOOLISH.test(token) && token !== errorClass) ?? tokens[0];
+    return [clip(errorClass ? `when ${tool} fails with ${errorClass}` : `when ${tool} fails`)];
+  }
+  if (kind2 === "procedure") {
+    const command = tokens.find((token) => TOOLISH.test(token)) ?? tokens[0];
+    return [clip(`when running ${command}`)];
+  }
+  const phrases = [];
+  for (const token of tokens) {
+    if (phrases.length >= RELEVANT_WHEN_CAP)
+      break;
+    phrases.push(clip(`when ${token}`));
+  }
+  return [...new Set(phrases)];
+}
+var RELEVANT_WHEN_CAP, MAX_PHRASE_LENGTH, MAX_TOKEN_LENGTH, STOPWORDS, TOOLISH, ERRORISH;
+var init_relevantWhen = __esm({
+  "packages/core/dist/memory/relevantWhen.js"() {
+    "use strict";
+    init_scoring();
+    RELEVANT_WHEN_CAP = 3;
+    MAX_PHRASE_LENGTH = 120;
+    MAX_TOKEN_LENGTH = 24;
+    STOPWORDS = /* @__PURE__ */ new Set([
+      "the",
+      "and",
+      "for",
+      "with",
+      "that",
+      "this",
+      "from",
+      "when",
+      "into",
+      "your",
+      "you",
+      "are",
+      "was",
+      "were",
+      "has",
+      "have",
+      "had",
+      "not",
+      "but",
+      "its",
+      "also",
+      "will",
+      "can",
+      "should",
+      "must",
+      "them",
+      "they",
+      "our",
+      "out",
+      "any",
+      "all",
+      "each",
+      "per",
+      "via",
+      "use",
+      "using",
+      "get",
+      "set",
+      "new",
+      "old",
+      "one",
+      "two",
+      "may"
+    ]);
+    TOOLISH = /(?:npm|pnpm|yarn|node|tsc|vitest|jest|eslint|prettier|docker|git|cargo|rustc|python|pip|go|mvn|gradle|make|curl|http|fetch|sqlite|postgres|redis|deploy|build|test|lint|install|migrate|migration)/i;
+    ERRORISH = /(?:timeout|timedout|etimedout|econn|eaddrinuse|enoent|eacces|enospc|eexist|lock|locked|denied|refused|crash|signal|exhaust|oom|heap|exception|error|traceback|segfault|panic)/i;
+  }
+});
+
 // packages/core/dist/memory/policies.js
 function shannonEntropy(value) {
   const counts = /* @__PURE__ */ new Map();
@@ -38148,6 +38258,7 @@ var init_service = __esm({
     init_context2();
     init_policies();
     init_scoring();
+    init_relevantWhen();
     init_semantic();
     MemoryPolicyError = class extends Error {
       constructor(message) {
@@ -38162,6 +38273,7 @@ var init_service = __esm({
       onEvent;
       now;
       defaultContextChars;
+      relevantWhenEnabled;
       semantic;
       constructor(projectId2, backend, options = {}) {
         this.backend = backend;
@@ -38172,6 +38284,7 @@ var init_service = __esm({
         this.onEvent = options.onEvent;
         this.now = options.now ?? (() => /* @__PURE__ */ new Date());
         this.defaultContextChars = options.defaultContextChars ?? 2e3;
+        this.relevantWhenEnabled = options.relevantWhen ?? true;
         if (options.embeddingProvider) {
           this.semantic = new SemanticMemoryController(projectId2, backend, options.embeddingProvider, {
             now: this.now,
@@ -38181,6 +38294,31 @@ var init_service = __esm({
           });
         }
       }
+      /** Sanitize, dedupe, and cap associative triggers before persistence. */
+      cleanRelevantWhen(proposed) {
+        const out = [];
+        for (const phrase of proposed) {
+          if (typeof phrase !== "string")
+            continue;
+          const cleaned = this.sanitizer.sanitize(phrase);
+          if (cleaned.rejected)
+            continue;
+          const value = cleaned.content.trim().slice(0, 120).trim();
+          if (!value || out.includes(value))
+            continue;
+          out.push(value);
+          if (out.length >= RELEVANT_WHEN_CAP)
+            break;
+        }
+        return out;
+      }
+      /** Use host-supplied triggers, else derive them purely from the content. */
+      buildRelevantWhen(input, content, kind2, tags) {
+        if (!this.relevantWhenEnabled)
+          return [];
+        const proposed = input && input.length > 0 ? input : deriveRelevantWhen(content, kind2, tags);
+        return this.cleanRelevantWhen(proposed);
+      }
       emit(event) {
         if (!this.onEvent)
           return;
@@ -38213,6 +38351,7 @@ var init_service = __esm({
           ...sanitized.redactions.length > 0 ? { secretRedactions: sanitized.redactions } : {}
         };
         const tags = normalizeTags(parsed.tags);
+        const relevantWhen2 = this.buildRelevantWhen(parsed.relevantWhen, sanitized.content, parsed.kind, tags);
         const exactKey = normalizedMemoryKey(sanitized.content);
         const possible = await this.backend.search({
           text: sanitized.content,
@@ -38225,13 +38364,18 @@ var init_service = __esm({
         const duplicate = possible.find(({ node: node2 }) => normalizedMemoryKey(node2.content) === exactKey && (visibility === "project" || node2.source.client === source2.client))?.node;
         if (duplicate) {
           const mergedTags = normalizeTags([...duplicate.tags, ...tags]);
-          const shouldUpdate = confidence > duplicate.confidence || clampUnit(parsed.importance, 0.5) > duplicate.importance || mergedTags.length !== duplicate.tags.length || sanitized.redactions.length > 0;
+          const mergedRelevantWhen = this.cleanRelevantWhen([
+            ...duplicate.relevantWhen ?? [],
+            ...relevantWhen2
+          ]);
+          const shouldUpdate = confidence > duplicate.confidence || clampUnit(parsed.importance, 0.5) > duplicate.importance || mergedTags.length !== duplicate.tags.length || mergedRelevantWhen.length !== (duplicate.relevantWhen?.length ?? 0) || sanitized.redactions.length > 0;
           if (!shouldUpdate)
             return duplicate;
           const updated = await this.backend.update(duplicate.id, {
             confidence: Math.max(duplicate.confidence, confidence),
             importance: Math.max(duplicate.importance, clampUnit(parsed.importance, 0.5)),
             tags: mergedTags,
+            ...mergedRelevantWhen.length ? { relevantWhen: mergedRelevantWhen } : {},
             source: source2,
             metadata: { ...duplicate.metadata, ...metadata2 },
             actor: source2.agent,
@@ -38250,6 +38394,7 @@ var init_service = __esm({
           status: parsed.status ?? "active",
           visibility,
           tags,
+          ...relevantWhen2.length ? { relevantWhen: relevantWhen2 } : {},
           source: source2,
           ...parsed.createdAt ? { createdAt: parsed.createdAt } : {},
           ...parsed.recordedAt ? { recordedAt: parsed.recordedAt } : {},
@@ -38283,6 +38428,21 @@ var init_service = __esm({
           if (candidate.node.projectId === this.projectId && (!raw.externalClient || candidate.node.visibility === "project" || candidate.node.source.client === raw.externalClient))
             byId.set(candidate.node.id, candidate);
         }
+        if (this.relevantWhenEnabled && !raw.asOf && text && this.backend.searchRelevantWhen) {
+          const triggers = await this.backend.searchRelevantWhen({
+            ...recallQuery,
+            text,
+            projectId: this.projectId,
+            statuses: raw.statuses ?? (raw.includeHistorical ? void 0 : ["active"]),
+            limit: Math.max(limit, Math.min(200, limit * 5))
+          });
+          for (const hit of triggers) {
+            if (hit.node.projectId !== this.projectId || raw.externalClient && hit.node.visibility === "private" && hit.node.source.client !== raw.externalClient)
+              continue;
+            const prior = byId.get(hit.node.id);
+            byId.set(hit.node.id, prior ? { ...prior, triggerMatch: 1 } : { ...hit, lexicalRelevance: 1, triggerMatch: 1 });
+          }
+        }
         if (this.semantic) {
           const semantic = await this.semantic.search({
             ...raw,
@@ -38850,6 +39010,7 @@ var init_memory = __esm({
     init_types11();
     init_schemas3();
     init_scoring();
+    init_relevantWhen();
     init_policies();
     init_context2();
     init_service();
@@ -38917,9 +39078,9 @@ function findCycle(nodes) {
     if (color.get(start) !== WHITE)
       continue;
     const stack = [[start, 0]];
-    const path126 = [];
+    const path128 = [];
     color.set(start, GRAY);
-    path126.push(start);
+    path128.push(start);
     while (stack.length > 0) {
       const top = stack[stack.length - 1];
       const [id3, idx] = top;
@@ -38932,17 +39093,17 @@ function findCycle(nodes) {
           continue;
         const c = color.get(dep);
         if (c === GRAY) {
-          const at = path126.indexOf(dep);
-          return [...path126.slice(at), dep];
+          const at = path128.indexOf(dep);
+          return [...path128.slice(at), dep];
         }
         if (c === WHITE) {
           color.set(dep, GRAY);
-          path126.push(dep);
+          path128.push(dep);
           stack.push([dep, 0]);
         }
       } else {
         color.set(id3, BLACK);
-        path126.pop();
+        path128.pop();
         stack.pop();
       }
     }
@@ -39862,8 +40023,8 @@ var init_runner = __esm({
           failed: [...this.tentaclesById.values()].filter((r) => r.status === "error"),
           pending: []
         };
-        const path126 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
-        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path126}`);
+        const path128 = await this.host.saveSnapshot(snapshot, ".zelari/kraken/snapshots");
+        this.host.log(`checkpoint: ${label ?? "auto"} \u2192 ${path128}`);
         return snapshot;
       }
       callLog(msg, data) {
@@ -40421,7 +40582,7 @@ var CORE_VERSION;
 var init_version = __esm({
   "packages/core/dist/version.js"() {
     "use strict";
-    CORE_VERSION = "2.56.0";
+    CORE_VERSION = "2.57.0";
   }
 });
 
@@ -40596,6 +40757,7 @@ __export(dist_exports, {
   PressureThresholdsSchema: () => PressureThresholdsSchema,
   ProfileSchema: () => ProfileSchema,
   REDACTED: () => REDACTED,
+  RELEVANT_WHEN_CAP: () => RELEVANT_WHEN_CAP,
   ReasoningWatchdog: () => ReasoningWatchdog,
   RepetitionGuard: () => RepetitionGuard,
   ResourcePolicySchema: () => ResourcePolicySchema,
@@ -40737,6 +40899,7 @@ __export(dist_exports, {
   deriveInitialContract: () => deriveInitialContract,
   deriveMessages: () => deriveMessages,
   deriveMissionState: () => deriveMissionState,
+  deriveRelevantWhen: () => deriveRelevantWhen,
   derivedToAgentMessages: () => derivedToAgentMessages,
   detectAssistantTextLoop: () => detectAssistantTextLoop,
   detectAssistantTextLoopWindow: () => detectAssistantTextLoopWindow,
@@ -43145,9 +43308,9 @@ function spillToolOutput(fullText, meta3) {
     const rnd = randomBytes3(3).toString("hex");
     const safeTool = (meta3?.toolName ?? "tool").replace(/[^a-zA-Z0-9._-]+/g, "_").slice(0, 32);
     const file2 = `${stamp}-${safeTool}-${hash3}-${rnd}.txt`;
-    const path126 = join14(dir, file2);
-    writeFileSync13(path126, fullText, "utf8");
-    return path126;
+    const path128 = join14(dir, file2);
+    writeFileSync13(path128, fullText, "utf8");
+    return path128;
   } catch {
     return null;
   }
@@ -43158,7 +43321,7 @@ var init_toolOutputSpill = __esm({
   }
 });
 
-// packages/core/dist/core/tools/registry.js
+// packages/core/dist/core/tools/observationCompactor.js
 function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
   if (text.length === 0)
     return text;
@@ -43193,10 +43356,10 @@ function truncateToolResult(text, capOrOpts = TOOL_RESULT_LINE_CAP) {
 ${tail2}`;
   }
   if (doSpill) {
-    const path126 = spillToolOutput(text, { toolName: opts.toolName });
-    if (path126) {
+    const path128 = spillToolOutput(text, { toolName: opts.toolName });
+    if (path128) {
       const spillNote = `
-\u2026 [full output spilled to: ${path126} \u2014 re-read with read_file if you need the complete text] \u2026`;
+\u2026 [full output spilled to: ${path128} \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}
 `);
@@ -43207,14 +43370,47 @@ ${tail2}`;
   }
   return preview;
 }
-var TOOL_NAME_ALIASES, TOOL_RESULT_LINE_CAP, ToolRegistry;
+function compactToolResult(result, opts = {}) {
+  if (!result.ok)
+    return result;
+  const truncOpts = { toolName: opts.toolName };
+  if (opts.cap !== void 0)
+    truncOpts.cap = opts.cap;
+  if (opts.spill !== void 0)
+    truncOpts.spill = opts.spill;
+  if (typeof result.value === "string") {
+    result.value = truncateToolResult(result.value, truncOpts);
+  } else if (result.value && typeof result.value === "object") {
+    const v = result.value;
+    if (typeof v.content === "string") {
+      v.content = truncateToolResult(v.content, truncOpts);
+    }
+  }
+  return result;
+}
+var TOOL_RESULT_LINE_CAP;
+var init_observationCompactor = __esm({
+  "packages/core/dist/core/tools/observationCompactor.js"() {
+    "use strict";
+    init_toolOutputSpill();
+    TOOL_RESULT_LINE_CAP = (() => {
+      const raw = process.env.ZELARI_TOOL_RESULT_LINES;
+      const n = raw ? Number.parseInt(raw, 10) : 200;
+      return Number.isFinite(n) && n >= 10 ? n : 200;
+    })();
+  }
+});
+
+// packages/core/dist/core/tools/registry.js
+var TOOL_NAME_ALIASES, ToolRegistry;
 var init_registry2 = __esm({
   "packages/core/dist/core/tools/registry.js"() {
     "use strict";
     init_zodBridge();
-    init_toolOutputSpill();
+    init_observationCompactor();
     init_toolTypes();
     init_toolOutputSpill();
+    init_observationCompactor();
     TOOL_NAME_ALIASES = {
       read: "read_file",
       readfile: "read_file",
@@ -43239,11 +43435,6 @@ var init_registry2 = __esm({
       run: "bash",
       exec: "bash"
     };
-    TOOL_RESULT_LINE_CAP = (() => {
-      const raw = process.env.ZELARI_TOOL_RESULT_LINES;
-      const n = raw ? Number.parseInt(raw, 10) : 200;
-      return Number.isFinite(n) && n >= 10 ? n : 200;
-    })();
     ToolRegistry = class {
       tools = /* @__PURE__ */ new Map();
       /** v0.10.0: lifecycle hooks (PreToolUse/PostToolUse). Null = no hooks. */
@@ -43373,17 +43564,7 @@ var init_registry2 = __esm({
             })
           ]);
           if (result.ok) {
-            const tName = options.toolName ?? name;
-            if (typeof result.value === "string") {
-              result.value = truncateToolResult(result.value, {
-                toolName: tName
-              });
-            } else if (result.value && typeof result.value === "object") {
-              const v = result.value;
-              if (typeof v.content === "string") {
-                v.content = truncateToolResult(v.content, { toolName: tName });
-              }
-            }
+            compactToolResult(result, { toolName: options.toolName ?? name });
           }
           if (this.lifecycleHooks) {
             try {
@@ -43756,8 +43937,8 @@ function workspaceFile(rootDir, kind2) {
       return join15(rootDir, "workspace.json");
   }
 }
-function workspaceArtifact(rootDir, subdir, slug) {
-  return join15(rootDir, subdir, `${slug}.md`);
+function workspaceArtifact(rootDir, subdir, slug2) {
+  return join15(rootDir, subdir, `${slug2}.md`);
 }
 function projectName(projectRoot = process.cwd()) {
   return basename(realpathSync(projectRoot));
@@ -44041,28 +44222,28 @@ var init_storage = __esm({
     VALID_SCALARS = /^(true|false|null|~)$/i;
     Storage = class {
       /** Read a Markdown file with frontmatter. Throws if not found. */
-      read(path126) {
-        if (!existsSync25(path126)) {
-          throw new Error(`File not found: ${path126}`);
+      read(path128) {
+        if (!existsSync25(path128)) {
+          throw new Error(`File not found: ${path128}`);
         }
-        const md = readFileSync24(path126, "utf8");
+        const md = readFileSync24(path128, "utf8");
         return parseFrontmatter(md);
       }
       /** Read a Markdown file; returns null if not found. */
-      readIfExists(path126) {
-        if (!existsSync25(path126)) return null;
-        return this.read(path126);
+      readIfExists(path128) {
+        if (!existsSync25(path128)) return null;
+        return this.read(path128);
       }
       /**
        * Write a Markdown file atomically (tmp + rename). Creates parent dirs.
        * The meta object is serialized as YAML frontmatter; body as Markdown.
        */
-      write(path126, meta3, body) {
-        mkdirSync11(dirname2(path126), { recursive: true });
-        const tmp = path126 + ".tmp-" + process.pid;
+      write(path128, meta3, body) {
+        mkdirSync11(dirname2(path128), { recursive: true });
+        const tmp = path128 + ".tmp-" + process.pid;
         const md = serializeFrontmatter(meta3, body);
         writeFileSync15(tmp, md, "utf8");
-        renameSync2(tmp, path126);
+        renameSync2(tmp, path128);
       }
       /** List all .md files in a directory (non-recursive). */
       listMarkdown(dir) {
@@ -44173,8 +44354,8 @@ function nextPlanTaskId(store6) {
   return `t${store6.counter}`;
 }
 function writePlanTaskArtifact(rootDir, task) {
-  const path126 = join17(rootDir, "plan-tasks", `${task.id}.md`);
-  mkdirSync12(dirname3(path126), { recursive: true });
+  const path128 = join17(rootDir, "plan-tasks", `${task.id}.md`);
+  mkdirSync12(dirname3(path128), { recursive: true });
   const meta3 = {
     kind: "task",
     id: task.id,
@@ -44195,7 +44376,7 @@ function writePlanTaskArtifact(rootDir, task) {
     task.notes?.trim() ? task.notes.trim() : "_(no notes)_",
     ""
   ].filter((l) => l !== null).join("\n");
-  new Storage().write(path126, meta3, body);
+  new Storage().write(path128, meta3, body);
 }
 function loadHandle(rootDir) {
   const jsonPath = join17(rootDir, "plan.json");
@@ -45352,8 +45533,8 @@ async function createKrakenWorktreeDetailed(cwd, label) {
   const head = await git3(repoRoot, ["rev-parse", "HEAD"]);
   const baseSha = head.ok ? head.stdout.trim() : void 0;
   const id3 = `${Date.now().toString(36)}-${randomBytes4(3).toString("hex")}`;
-  const slug = (label ?? "task").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 24) || "task";
-  const branch = `kraken/${slug}-${id3}`;
+  const slug2 = (label ?? "task").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 24) || "task";
+  const branch = `kraken/${slug2}-${id3}`;
   const wtRoot = path50.join(repoRoot, ".zelari", "worktrees");
   const wtPath = path50.join(wtRoot, `kraken-${id3}`);
   const longPaths = isLongPath(repoRoot, wtPath);
@@ -53056,7 +53237,7 @@ function upsertSkill(opts) {
     }
     dir = getProjectSkillsDir(root);
   }
-  const path126 = skillFilePath(dir, name);
+  const path128 = skillFilePath(dir, name);
   const content = serializeSkillMd({
     name,
     description,
@@ -53065,13 +53246,13 @@ function upsertSkill(opts) {
     tools: opts.tools,
     cost: opts.cost
   });
-  const parsed = parseSkillMd(content, path126);
+  const parsed = parseSkillMd(content, path128);
   if (!parsed) {
     return { ok: false, error: "Generated SKILL.md failed validation" };
   }
-  mkdirSync15(dirname4(path126), { recursive: true });
-  writeFileSync18(path126, content, "utf8");
-  return { ok: true, path: path126 };
+  mkdirSync15(dirname4(path128), { recursive: true });
+  writeFileSync18(path128, content, "utf8");
+  return { ok: true, path: path128 };
 }
 function removeSkill(opts) {
   const name = opts.name.trim().toLowerCase();
@@ -53089,8 +53270,8 @@ function removeSkill(opts) {
     dir = getProjectSkillsDir(root);
   }
   const skillDir = join20(dir, name);
-  const path126 = skillFilePath(dir, name);
-  if (!existsSync35(path126) && !existsSync35(skillDir)) {
+  const path128 = skillFilePath(dir, name);
+  if (!existsSync35(path128) && !existsSync35(skillDir)) {
     return { ok: false, error: `Skill "${name}" not found in ${dir}` };
   }
   try {
@@ -53101,7 +53282,7 @@ function removeSkill(opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  return { ok: true, path: path126 };
+  return { ok: true, path: path128 };
 }
 var NAME_RE, BUILTIN_SKILL_MODULES, builtinsLoaded;
 var init_skillConfigIo = __esm({
@@ -53161,16 +53342,16 @@ function createCreateSkillTool(opts) {
       const overwrite = args?.overwrite === true;
       const dir = scope === "user" ? getUserSkillsDir() : getProjectSkillsDir(root);
       const skillDir = resolve3(dir, name);
-      const path126 = resolve3(skillDir, "SKILL.md");
-      if (!path126.startsWith(resolve3(dir) + sep)) {
+      const path128 = resolve3(skillDir, "SKILL.md");
+      if (!path128.startsWith(resolve3(dir) + sep)) {
         return typedErr(
           `Refused: "${name}" would resolve outside the ${scope} skills directory (${resolve3(dir)}).`
         );
       }
-      const existed = existsSync36(path126);
+      const existed = existsSync36(path128);
       if (existed && !overwrite) {
         return typedErr(
-          `Skill "${name}" already exists at ${path126} \u2014 nothing was written. Call create_skill again with overwrite: true to replace it, or pick another name.`
+          `Skill "${name}" already exists at ${path128} \u2014 nothing was written. Call create_skill again with overwrite: true to replace it, or pick another name.`
         );
       }
       const written = upsertSkill({
@@ -56785,21 +56966,21 @@ function normalizeAuth(auth) {
   return "agent";
 }
 function readSecrets() {
-  const path126 = getSshSecretsPath();
-  if (!existsSync39(path126)) return {};
+  const path128 = getSshSecretsPath();
+  if (!existsSync39(path128)) return {};
   try {
-    return JSON.parse(readFileSync31(path126, "utf8"));
+    return JSON.parse(readFileSync31(path128, "utf8"));
   } catch {
     return {};
   }
 }
 function writeSecrets(data) {
-  const path126 = getSshSecretsPath();
-  mkdirSync16(dirname5(path126), { recursive: true });
-  writeFileSync19(path126, `${JSON.stringify(data, null, 2)}
+  const path128 = getSshSecretsPath();
+  mkdirSync16(dirname5(path128), { recursive: true });
+  writeFileSync19(path128, `${JSON.stringify(data, null, 2)}
 `, "utf8");
   try {
-    chmodSync(path126, 384);
+    chmodSync(path128, 384);
   } catch {
   }
 }
@@ -56828,10 +57009,10 @@ function deleteSshPassword(id3) {
   writeSecrets({ passwords });
 }
 function readStore2() {
-  const path126 = getSshTargetsPath();
-  if (!existsSync39(path126)) return [];
+  const path128 = getSshTargetsPath();
+  if (!existsSync39(path128)) return [];
   try {
-    const parsed = JSON.parse(readFileSync31(path126, "utf8"));
+    const parsed = JSON.parse(readFileSync31(path128, "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"
@@ -56846,11 +57027,11 @@ function readStore2() {
   }
 }
 function writeStore2(targets) {
-  const path126 = getSshTargetsPath();
-  mkdirSync16(dirname5(path126), { recursive: true });
+  const path128 = getSshTargetsPath();
+  mkdirSync16(dirname5(path128), { recursive: true });
   const clean = targets.map(({ hasPassword: _hp, ...t }) => t);
   writeFileSync19(
-    path126,
+    path128,
     `${JSON.stringify({ targets: clean }, null, 2)}
 `,
     "utf8"
@@ -57096,11 +57277,11 @@ function formatSshTargetsForPrompt() {
   ];
   for (const t of targets) {
     const tags = t.tags?.length ? ` tags=[${t.tags.join(",")}]` : "";
-    const path126 = t.defaultRemotePath ? ` remotePath=${t.defaultRemotePath}` : "";
+    const path128 = 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}${path126}${tags}${allow}`
+      `- id=${t.id} name=${t.name} ${t.user}@${t.host}:${t.port ?? 22}${auth}${path128}${tags}${allow}`
     );
   }
   return lines.join("\n");
@@ -59888,26 +60069,7 @@ function cloneResult(result) {
   }
 }
 function applyTruncation(result, toolName2) {
-  if (!result.ok) return result;
-  if (typeof result.value === "string") {
-    return {
-      ok: true,
-      value: truncateToolResult(result.value, { toolName: toolName2, spill: false })
-    };
-  }
-  if (result.value && typeof result.value === "object") {
-    const v = result.value;
-    if (typeof v.content === "string") {
-      return {
-        ok: true,
-        value: {
-          ...v,
-          content: truncateToolResult(v.content, { toolName: toolName2, spill: false })
-        }
-      };
-    }
-  }
-  return result;
+  return compactToolResult(result, { toolName: toolName2, spill: false });
 }
 function evictOldest() {
   let oldestKey = null;
@@ -62479,6 +62641,7 @@ function decodeNode(row) {
     status: row.status,
     visibility: row.visibility ?? "project",
     tags: json2(row.tags_json, []),
+    relevantWhen: json2(row.relevant_when_json, []),
     source: json2(row.source_json, {}),
     createdAt: row.created_at,
     updatedAt: row.updated_at,
@@ -62503,6 +62666,7 @@ function nodeSqlValues(node) {
     node.status,
     node.visibility ?? "project",
     JSON.stringify(node.tags),
+    JSON.stringify(node.relevantWhen ?? []),
     JSON.stringify(node.source),
     node.createdAt,
     node.updatedAt,
@@ -62687,7 +62851,7 @@ var SQLITE_MEMORY_SCHEMA_VERSION, SQLITE_MEMORY_BASE_SCHEMA, SQLITE_MEMORY_MIGRA
 var init_sqliteSchema = __esm({
   "src/cli/memory/sqliteSchema.ts"() {
     "use strict";
-    SQLITE_MEMORY_SCHEMA_VERSION = 2;
+    SQLITE_MEMORY_SCHEMA_VERSION = 3;
     SQLITE_MEMORY_BASE_SCHEMA = `
 PRAGMA foreign_keys = ON;
 PRAGMA journal_mode = WAL;
@@ -62705,6 +62869,7 @@ CREATE TABLE IF NOT EXISTS memory_nodes (
   status TEXT NOT NULL CHECK (status IN ('active','superseded','retracted','archived')),
   visibility TEXT NOT NULL DEFAULT 'project' CHECK (visibility IN ('project','private')),
   tags_json TEXT NOT NULL DEFAULT '[]',
+  relevant_when_json TEXT NOT NULL DEFAULT '[]',
   source_json TEXT NOT NULL DEFAULT '{}',
   created_at TEXT NOT NULL,
   updated_at TEXT NOT NULL,
@@ -62834,6 +62999,15 @@ SELECT id, visibility, json_extract(source_json, '$.client'), updated_at FROM me
       END;
       INSERT INTO memory_access(memory_id, visibility, owner_client, updated_at)
       SELECT id, visibility, json_extract(source_json, '$.client'), updated_at FROM memory_nodes;
+    `
+      },
+      {
+        // S3 (T-Mem lite): additive associative-trigger column. Legacy rows default
+        // to '[]'; the FTS triggers are untouched (triggers are matched via
+        // json_each, and json_each('[]') yields zero rows, so '[]' never explodes).
+        version: 3,
+        sql: `
+      ALTER TABLE memory_nodes ADD COLUMN relevant_when_json TEXT NOT NULL DEFAULT '[]';
     `
       }
     ];
@@ -62897,10 +63071,10 @@ var init_sqliteBackend = __esm({
     init_sqliteSchema();
     NODE_COLUMNS = `
   id, schema_version, project_id, kind, content, importance, confidence,
-  status, visibility, tags_json, source_json, created_at, updated_at, valid_from,
+  status, visibility, tags_json, relevant_when_json, source_json, created_at, updated_at, valid_from,
   valid_until, recorded_at, retracted_at, embedding_ref, metadata_json`;
     INSERT_NODE_SQL = `INSERT INTO memory_nodes (${NODE_COLUMNS})
-VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
+VALUES (${Array.from({ length: 20 }, () => "?").join(",")})`;
     IMPORT_ID_CHUNK = 500;
     SOURCE_COLUMNS = {
       agent: "agent",
@@ -63004,6 +63178,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           status: input.status ?? "active",
           visibility: input.visibility ?? "project",
           tags: input.tags ?? [],
+          relevantWhen: input.relevantWhen ?? [],
           source: input.source ?? {},
           createdAt,
           updatedAt: now,
@@ -63053,6 +63228,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           ...patch.status ? { status: patch.status } : {},
           ...patch.visibility ? { visibility: patch.visibility } : {},
           ...patch.tags ? { tags: patch.tags } : {},
+          ...patch.relevantWhen ? { relevantWhen: patch.relevantWhen } : {},
           ...patch.source ? { source: patch.source } : {},
           ...patch.metadata ? { metadata: patch.metadata } : {},
           updatedAt: now,
@@ -63071,7 +63247,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           {
             sql: `UPDATE memory_nodes SET
           schema_version=?, project_id=?, kind=?, content=?, importance=?, confidence=?,
-          status=?, visibility=?, tags_json=?, source_json=?, created_at=?, updated_at=?, valid_from=?,
+          status=?, visibility=?, tags_json=?, relevant_when_json=?, source_json=?, created_at=?, updated_at=?, valid_from=?,
           valid_until=?, recorded_at=?, retracted_at=?, embedding_ref=?, metadata_json=?
           WHERE id=?`,
             params: [...nodeSqlValues(updated).slice(1), updated.id]
@@ -63107,6 +63283,36 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           return this.searchCurrent(query, text, expression, false);
         }
       }
+      /**
+       * T-Mem lite: retrieve nodes whose `relevantWhen` triggers overlap the query
+       * tokens. Runs as a separate query so the lexical similarity prefilter in
+       * `search` can never drop an associative hit. `json_each('[]')` yields zero
+       * rows, so empty/legacy triggers are harmless.
+       */
+      async searchRelevantWhen(query) {
+        this.assertReady();
+        const text = query.text?.trim() ?? "";
+        if (!text) return [];
+        const tokens = [
+          ...new Set(text.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{3,}/gu) ?? [])
+        ].slice(0, 24);
+        if (tokens.length === 0) return [];
+        const params = [];
+        const where = [];
+        const clauses = tokens.map(
+          () => `EXISTS (SELECT 1 FROM json_each(n.relevant_when_json) je WHERE instr(' ' || lower(je.value) || ' ', ' ' || ? || ' ') > 0)`
+        );
+        where.push(`(${clauses.join(" OR ")})`);
+        params.push(...tokens);
+        this.addFilters(query, where, params, "n");
+        params.push(boundedLimit(query.limit));
+        const rows = await this.rpc.statement({
+          sql: `SELECT n.* FROM memory_nodes n WHERE ${where.join(" AND ")} ORDER BY n.importance DESC, n.updated_at DESC LIMIT ?`,
+          params,
+          mode: "all"
+        });
+        return rows.map(decodeNode).filter((node) => Boolean(node)).map((node) => ({ node, lexicalRelevance: 1, triggerMatch: 1 }));
+      }
       async searchCurrent(query, text, expression, useFts) {
         const params = [];
         const where = [];
@@ -63507,6 +63713,7 @@ __export(serviceFactory_exports, {
   getMemoryService: () => getMemoryService,
   isMemoryAutoWriteEnabled: () => isMemoryAutoWriteEnabled,
   isMemorySemanticEnabled: () => isMemorySemanticEnabled,
+  isMemoryTriggersEnabled: () => isMemoryTriggersEnabled,
   isMemoryV2Enabled: () => isMemoryV2Enabled
 });
 import { createHash as createHash22 } from "node:crypto";
@@ -63523,6 +63730,9 @@ function isMemoryAutoWriteEnabled(env = process.env) {
 function isMemorySemanticEnabled(env = process.env) {
   return isMemoryV2Enabled(env) && env.ZELARI_MEMORY_SEMANTIC === "1";
 }
+function isMemoryTriggersEnabled(env = process.env) {
+  return isMemoryV2Enabled(env) && env.ZELARI_MEMORY_TRIGGERS !== "0";
+}
 function semanticMinScore(env) {
   const value = Number(env.ZELARI_MEMORY_SEMANTIC_MIN_SCORE);
   return Number.isFinite(value) ? Math.max(0, Math.min(value, 1)) : void 0;
@@ -63560,7 +63770,8 @@ async function getMemoryService(projectRoot, env = process.env, options = {}) {
     const service = new DefaultMemoryService(projectId2, backend, {
       ...options.onEvent ? { onEvent: options.onEvent } : {},
       ...embeddingProvider ? { embeddingProvider } : {},
-      ...semanticMinScore(env) !== void 0 ? { minSemanticRelevance: semanticMinScore(env) } : {}
+      ...semanticMinScore(env) !== void 0 ? { minSemanticRelevance: semanticMinScore(env) } : {},
+      relevantWhen: isMemoryTriggersEnabled(env)
     });
     if (backend.lastMigration) {
       const migration = backend.lastMigration;
@@ -63842,6 +64053,75 @@ var init_opsKnowledge = __esm({
   }
 });
 
+// src/cli/memory/onePager.ts
+import { promises as fs33 } from "node:fs";
+import * as path84 from "node:path";
+function isOnePagerEnabled(env = process.env) {
+  return env.ZELARI_ONE_PAGER !== "0";
+}
+function slug(text, max = 48) {
+  const line = text.split(/\r?\n/, 1)[0].trim();
+  return line.length <= max ? line : `${line.slice(0, max - 1)}\u2026`;
+}
+async function howWeTestIndex(cwd) {
+  try {
+    const stat9 = await fs33.stat(path84.join(cwd, HOW_WE_TEST_RELATIVE));
+    return `${HOW_WE_TEST_RELATIVE} \xB7 ${new Date(stat9.mtimeMs).toISOString()}`;
+  } catch {
+    return null;
+  }
+}
+async function procedureAliases(memory) {
+  if (!memory) return null;
+  const nodes = await listVerifiedProcedureNodes(memory);
+  if (!nodes || nodes.length === 0) return null;
+  return nodes.slice(0, MAX_PROCEDURES).map((node) => `- ${slug(node.tags[0] ?? node.content)}`).join("\n");
+}
+function truncate(text, cap3) {
+  if (text.length <= cap3) return text;
+  return `${text.slice(0, cap3 - TRUNCATION_MARKER2.length).trimEnd()}${TRUNCATION_MARKER2}`;
+}
+async function buildOnePager(opts = {}) {
+  if (!isOnePagerEnabled(opts.env)) return [];
+  try {
+    const cwd = opts.cwd ?? process.cwd();
+    const sections = [];
+    const todos2 = formatTodosForModel(listSessionTodos());
+    if (todos2 && todos2 !== "(no todos)") sections.push(`## Open loops
+${todos2}`);
+    const index = await howWeTestIndex(cwd);
+    if (index) sections.push(`## How we test
+${index}`);
+    const procedures = await procedureAliases(opts.memory);
+    if (procedures) sections.push(`## Procedures
+${procedures}`);
+    if (!opts.skipCompactRecap) {
+      const recap = opts.compactSummary?.trim();
+      if (recap) sections.push(`## Compact recap
+${recap.slice(0, SECTION_RECAP_CAP)}`);
+    }
+    if (sections.length === 0) return [];
+    const body = `${ONE_PAGER_PREFIX}
+${sections.join("\n\n")}`;
+    return [{ role: "system", content: truncate(body, ONE_PAGER_CHAR_CAP) }];
+  } catch {
+    return [];
+  }
+}
+var ONE_PAGER_CHAR_CAP, ONE_PAGER_PREFIX, SECTION_RECAP_CAP, MAX_PROCEDURES, TRUNCATION_MARKER2;
+var init_onePager = __esm({
+  "src/cli/memory/onePager.ts"() {
+    "use strict";
+    init_sessionTodos();
+    init_howWeTest();
+    ONE_PAGER_CHAR_CAP = 1500;
+    ONE_PAGER_PREFIX = "WORKING SET";
+    SECTION_RECAP_CAP = 400;
+    MAX_PROCEDURES = 8;
+    TRUNCATION_MARKER2 = "\n\u2026(working set truncated)";
+  }
+});
+
 // src/cli/memory/spineTelemetry.ts
 function spineMemoryEventNote(handle, event) {
   try {
@@ -63925,20 +64205,20 @@ var init_askUserTimeout = __esm({
 
 // src/cli/state/fileStateStore.ts
 import { createHash as createHash24, randomUUID as randomUUID6 } from "node:crypto";
-import { promises as fs33 } from "node:fs";
-import * as path84 from "node:path";
+import { promises as fs34 } from "node:fs";
+import * as path85 from "node:path";
 function shortId() {
   return randomUUID6().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
-  await fs33.mkdir(path84.dirname(filePath), { recursive: true });
+  await fs34.mkdir(path85.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await fs33.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
-  await fs33.rename(tmp, filePath);
+  await fs34.writeFile(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
+  await fs34.rename(tmp, filePath);
 }
 async function readJsonFile(filePath) {
   try {
-    const raw = await fs33.readFile(filePath, "utf8");
+    const raw = await fs34.readFile(filePath, "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -63992,13 +64272,13 @@ var init_fileStateStore = __esm({
       indexPath = "";
       async init(projectRoot) {
         this.root = projectRoot;
-        this.stateDir = path84.join(projectRoot, ".zelari", "state");
-        this.commitsDir = path84.join(this.stateDir, "commits");
-        this.artifactsDir = path84.join(this.stateDir, "artifacts");
-        this.headPath = path84.join(this.stateDir, "HEAD.json");
-        this.indexPath = path84.join(this.stateDir, "index.jsonl");
-        await fs33.mkdir(this.commitsDir, { recursive: true });
-        await fs33.mkdir(this.artifactsDir, { recursive: true });
+        this.stateDir = path85.join(projectRoot, ".zelari", "state");
+        this.commitsDir = path85.join(this.stateDir, "commits");
+        this.artifactsDir = path85.join(this.stateDir, "artifacts");
+        this.headPath = path85.join(this.stateDir, "HEAD.json");
+        this.indexPath = path85.join(this.stateDir, "index.jsonl");
+        await fs34.mkdir(this.commitsDir, { recursive: true });
+        await fs34.mkdir(this.artifactsDir, { recursive: true });
       }
       async commit(input) {
         if (!input.force && input.verification.ran && !input.verification.ok) {
@@ -64009,13 +64289,13 @@ var init_fileStateStore = __esm({
         const discoveries = input.discoveries ?? [];
         const parent = await this.head();
         const id3 = shortId();
-        const artifactRel = path84.join("artifacts", id3);
-        const artifactAbs = path84.join(this.artifactsDir, id3);
-        await fs33.mkdir(artifactAbs, { recursive: true });
+        const artifactRel = path85.join("artifacts", id3);
+        const artifactAbs = path85.join(this.artifactsDir, id3);
+        await fs34.mkdir(artifactAbs, { recursive: true });
         const summary = defaultSummary(input, discoveries);
-        await fs33.writeFile(path84.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
-        await writeJsonAtomic(path84.join(artifactAbs, "discoveries.json"), discoveries);
-        await writeJsonAtomic(path84.join(artifactAbs, "verification.json"), input.verification);
+        await fs34.writeFile(path85.join(artifactAbs, "summary.md"), summary + "\n", "utf8");
+        await writeJsonAtomic(path85.join(artifactAbs, "discoveries.json"), discoveries);
+        await writeJsonAtomic(path85.join(artifactAbs, "verification.json"), input.verification);
         const meta3 = {
           id: id3,
           parentId: parent?.id ?? null,
@@ -64027,16 +64307,16 @@ var init_fileStateStore = __esm({
           workspaceCheckpointId: input.workspaceCheckpointId,
           verification: {
             ...input.verification,
-            reportPath: input.verification.reportPath ?? path84.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
+            reportPath: input.verification.reportPath ?? path85.join(".zelari", "state", artifactRel, "verification.json").replace(/\\/g, "/")
           },
           changedPaths: input.changedPaths ?? [],
           stablePromptHash: input.stablePromptHash,
           discoveryCount: discoveries.length,
           artifactDir: artifactRel.replace(/\\/g, "/")
         };
-        await writeJsonAtomic(path84.join(this.commitsDir, `${id3}.json`), meta3);
+        await writeJsonAtomic(path85.join(this.commitsDir, `${id3}.json`), meta3);
         await writeJsonAtomic(this.headPath, { id: id3, updatedAt: meta3.createdAt });
-        await fs33.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
+        await fs34.appendFile(this.indexPath, JSON.stringify({ id: id3, createdAt: meta3.createdAt, label: meta3.label }) + "\n", "utf8");
         return stripStored(meta3);
       }
       async head() {
@@ -64045,13 +64325,13 @@ var init_fileStateStore = __esm({
         return this.get(head.id);
       }
       async get(id3) {
-        const stored = await readJsonFile(path84.join(this.commitsDir, `${id3}.json`));
+        const stored = await readJsonFile(path85.join(this.commitsDir, `${id3}.json`));
         return stored ? stripStored(stored) : null;
       }
       async list(limit = 20) {
         let raw;
         try {
-          raw = await fs33.readFile(this.indexPath, "utf8");
+          raw = await fs34.readFile(this.indexPath, "utf8");
         } catch {
           return [];
         }
@@ -64084,9 +64364,9 @@ var init_fileStateStore = __esm({
       async loadDiscoveries(id3) {
         const meta3 = id3 ? await this.get(id3) : await this.head();
         if (!meta3) return [];
-        const stored = await readJsonFile(path84.join(this.commitsDir, `${meta3.id}.json`));
+        const stored = await readJsonFile(path85.join(this.commitsDir, `${meta3.id}.json`));
         if (!stored?.artifactDir) return [];
-        const discPath = path84.join(this.stateDir, stored.artifactDir, "discoveries.json");
+        const discPath = path85.join(this.stateDir, stored.artifactDir, "discoveries.json");
         return await readJsonFile(discPath) ?? [];
       }
       async materializeContext(id3, maxChars = DEFAULT_MATERIALIZE_CHARS) {
@@ -64297,7 +64577,7 @@ __export(conversationContext_exports, {
   setLastClarification: () => setLastClarification
 });
 import { existsSync as existsSync44 } from "node:fs";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 function getHistory() {
   return history;
 }
@@ -64306,7 +64586,7 @@ function setHistory(messages) {
   history = projected === messages ? [...messages] : projected;
 }
 function compactInPlace(cwd = process.cwd()) {
-  const durableStatePresent = existsSync44(join28(cwd, ".zelari", "state", "HEAD.json"));
+  const durableStatePresent = existsSync44(join29(cwd, ".zelari", "state", "HEAD.json"));
   history = applySessionSurface(compactHistory(history, { durableStatePresent }));
 }
 function appendMessages(msgs) {
@@ -64365,10 +64645,10 @@ function formatHistoryMessages(messages, maxTurns = 6, maxTotalChars = 12e3) {
   for (let i = messages.length - 1; i >= 0 && turns < maxTurns; i--) {
     const m = messages[i];
     if (m.role === "user") {
-      chunk.push(`User: ${truncate(m.content, 800)}`);
+      chunk.push(`User: ${truncate2(m.content, 800)}`);
       turns += 1;
     } else if (m.role === "assistant" && m.content.trim()) {
-      chunk.push(`Assistant: ${truncate(m.content, 2e3)}`);
+      chunk.push(`Assistant: ${truncate2(m.content, 2e3)}`);
     }
   }
   if (chunk.length === 0) return "";
@@ -64407,7 +64687,7 @@ The user CONFIRMED the plan and wants you to IMPLEMENT it ON DISK NOW.
 - Do NOT restart from zero or re-ask for the overall goal.
 
 ## Prior assistant output (plan to implement \u2014 authoritative)
-${truncate(lastAsst.content, max)}
+${truncate2(lastAsst.content, max)}
 
 ## Instruction
 Implement the plan on disk now with mutating tools, then briefly list the files you wrote/edited.`;
@@ -64458,7 +64738,7 @@ function buildAgentUserWithHistory(task, prior) {
   if (anchored) return anchored;
   return buildContinueUserMessage(task, messages, { maxPriorChars: 8e3 }) ?? task;
 }
-function truncate(s, max) {
+function truncate2(s, max) {
   const t = s.replace(/\s+/g, " ").trim();
   if (t.length <= max) return t;
   return `${t.slice(0, max - 1)}\u2026`;
@@ -64700,10 +64980,10 @@ __export(headless_exports, {
   resolveHeadlessProvider: () => resolveHeadlessProvider
 });
 import { readFileSync as readFileSync34 } from "node:fs";
-import path85 from "node:path";
+import path86 from "node:path";
 function resolveHeadlessCwd(opts) {
   const raw = typeof opts.cwd === "string" ? opts.cwd.trim() : "";
-  return path85.resolve(raw.length > 0 ? raw : process.cwd());
+  return path86.resolve(raw.length > 0 ? raw : process.cwd());
 }
 function defaultProfileForMode(mode) {
   switch (mode) {
@@ -65069,7 +65349,7 @@ __export(headlessSpine_exports, {
   seedHeadlessModelHistory: () => seedHeadlessModelHistory,
   sessionStartedEvent: () => sessionStartedEvent
 });
-import path86 from "node:path";
+import path87 from "node:path";
 function sessionStartedEvent(handle) {
   return {
     type: "session_started",
@@ -65086,7 +65366,7 @@ async function countVerificationEvidenceInLog(mirror, sessionId2) {
   try {
     await mirror.flush().catch(() => void 0);
     const report = await readSessionLogCached(
-      path86.join(mirror.sessionsDir, sessionId2, "events.jsonl"),
+      path87.join(mirror.sessionsDir, sessionId2, "events.jsonl"),
       mirror.replayCache
     );
     return report.events.filter((e) => e.kind === "verification.evidence").length;
@@ -65396,7 +65676,10 @@ async function buildModelContext(input) {
   const sourceHistory = (derived ?? [...input.fallbackHistory]).filter(
     (message) => !isLegacyResourceStatus(message)
   );
-  const requestTail = resourceStatusTail(input.resourceSnapshot);
+  const requestTail = [
+    ...resourceStatusTail(input.resourceSnapshot),
+    ...input.volatileOnePager ?? []
+  ];
   const inputTokens = estimateHistoryTokens(sourceHistory);
   const requestSurface = input.systemMessages || input.tools ? {
     provider: input.provider ?? "local",
@@ -65862,9 +66145,9 @@ __export(planDetect_exports, {
   hasWorkspacePlan: () => hasWorkspacePlan
 });
 import { existsSync as existsSync45, readFileSync as readFileSync35 } from "node:fs";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 function hasWorkspacePlan(projectRoot = process.cwd()) {
-  const planPath = join29(resolveWorkspaceRoot(projectRoot), "plan.json");
+  const planPath = join30(resolveWorkspaceRoot(projectRoot), "plan.json");
   if (!existsSync45(planPath)) return false;
   try {
     const parsed = JSON.parse(readFileSync35(planPath, "utf8"));
@@ -65882,10 +66165,10 @@ var init_planDetect = __esm({
 
 // src/cli/workspace/projectInstructions.ts
 import { existsSync as existsSync46, readFileSync as readFileSync36 } from "node:fs";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 function loadProjectInstructions(projectRoot = process.cwd(), maxChars = MAX_CHARS) {
   for (const name of CANDIDATES) {
-    const full = join30(projectRoot, name);
+    const full = join31(projectRoot, name);
     if (!existsSync46(full)) continue;
     try {
       let raw = readFileSync36(full, "utf8");
@@ -65933,7 +66216,7 @@ __export(workspaceSummary_exports, {
   buildZelariReadHint: () => buildZelariReadHint
 });
 import { existsSync as existsSync47, readFileSync as readFileSync37, readdirSync as readdirSync9, statSync as statSync8 } from "node:fs";
-import { join as join31, relative as relative2 } from "node:path";
+import { join as join32, relative as relative2 } from "node:path";
 function buildWorkspaceSummary(projectRoot = process.cwd(), options = {}) {
   const { maxEntries = 30, maxChars = 3500, maxDeps = 24, maxScripts = 16 } = options;
   const name = safeProjectName(projectRoot);
@@ -65966,7 +66249,7 @@ function formatTaskLine(t) {
 }
 function buildPlanSummary(projectRoot = process.cwd(), options) {
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  const planPath = join31(zelariRoot, "plan.json");
+  const planPath = join32(zelariRoot, "plan.json");
   if (!existsSync47(planPath)) return null;
   let plan;
   try {
@@ -66109,7 +66392,7 @@ function pickNextTask(open2) {
   )[0];
 }
 function buildZelariReadHint(projectRoot = process.cwd()) {
-  const planPath = join31(resolveWorkspaceRoot(projectRoot), "plan.json");
+  const planPath = join32(resolveWorkspaceRoot(projectRoot), "plan.json");
   if (!existsSync47(planPath)) return "";
   return [
     "# Council workspace detected (.zelari/) \u2014 DRAFT vault",
@@ -66125,7 +66408,7 @@ function safeProjectName(root) {
   }
 }
 function readPackageJson2(projectRoot) {
-  const p3 = join31(projectRoot, "package.json");
+  const p3 = join32(projectRoot, "package.json");
   if (!existsSync47(p3)) return null;
   try {
     return JSON.parse(readFileSync37(p3, "utf8"));
@@ -66178,11 +66461,11 @@ function listShallow(projectRoot, maxEntries) {
         out.push(`\u2026 (+${top.length - count} more)`);
         break;
       }
-      const rel2 = relative2(projectRoot, join31(projectRoot, entry.name));
+      const rel2 = relative2(projectRoot, join32(projectRoot, entry.name));
       if (entry.isDirectory()) {
         let inner = "";
         try {
-          const sub = readdirSync9(join31(projectRoot, entry.name), {
+          const sub = readdirSync9(join32(projectRoot, entry.name), {
             withFileTypes: true
           }).filter((e) => !e.name.startsWith(".")).slice(0, 4).map((e) => e.name);
           if (sub.length > 0)
@@ -66231,11 +66514,11 @@ var init_workspaceSummary = __esm({
 
 // src/cli/workspace/buildLessonsSummary.ts
 import { existsSync as existsSync48 } from "node:fs";
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 function buildLessonsSummary(projectRoot = process.cwd(), taskText) {
   if (process.env["ZELARI_LESSONS"] === "0") return null;
   const zelariRoot = resolveWorkspaceRoot(projectRoot);
-  if (!existsSync48(join32(zelariRoot, "lessons.jsonl"))) return null;
+  if (!existsSync48(join33(zelariRoot, "lessons.jsonl"))) return null;
   const lessons = recallLessons(zelariRoot, {
     maxLessons: 5,
     maxBytes: 2048,
@@ -66257,7 +66540,7 @@ __export(composeContext_exports, {
   composeProjectContext: () => composeProjectContext
 });
 import { existsSync as existsSync49, readdirSync as readdirSync10, readFileSync as readFileSync38 } from "node:fs";
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 function cap2(text, max, label) {
   if (!text || text.length <= max) return { text: text || "", truncated: false };
   return {
@@ -66274,7 +66557,7 @@ function buildDesignIndex(projectRoot, maxChars) {
     "# Design vault index (.zelari/) \u2014 HYPOTHESES only",
     "Full design docs are NOT product source of truth. Open with list_files / read_file / searchDocuments if needed."
   ];
-  const docsDir = join33(root, "docs");
+  const docsDir = join34(root, "docs");
   if (existsSync49(docsDir)) {
     try {
       const docs = readdirSync10(docsDir).filter((n) => n.endsWith(".md")).slice(0, 12);
@@ -66289,11 +66572,11 @@ function buildDesignIndex(projectRoot, maxChars) {
     }
   }
   for (const name of ["risks.md", "plan.json", "nfr-spec.json"]) {
-    if (existsSync49(join33(root, name))) {
+    if (existsSync49(join34(root, name))) {
       lines.push(`- .zelari/${name} present`);
     }
   }
-  const decisionsDir = join33(root, "decisions");
+  const decisionsDir = join34(root, "decisions");
   if (existsSync49(decisionsDir)) {
     try {
       const n = readdirSync10(decisionsDir).filter((f) => f.endsWith(".md")).length;
@@ -66395,14 +66678,14 @@ function composeProjectContext(input) {
 }
 function readDurableHeadSync(projectRoot) {
   try {
-    const headPath = join33(projectRoot, ".zelari", "state", "HEAD.json");
+    const headPath = join34(projectRoot, ".zelari", "state", "HEAD.json");
     if (!existsSync49(headPath)) return "";
     const head = JSON.parse(readFileSync38(headPath, "utf8"));
     if (!head?.id) return "";
-    const metaPath = join33(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
+    const metaPath = join34(projectRoot, ".zelari", "state", "commits", `${head.id}.json`);
     if (!existsSync49(metaPath)) return "";
     const meta3 = JSON.parse(readFileSync38(metaPath, "utf8"));
-    const discPath = meta3.artifactDir ? join33(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join33(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
+    const discPath = meta3.artifactDir ? join34(projectRoot, ".zelari", "state", meta3.artifactDir, "discoveries.json") : join34(projectRoot, ".zelari", "state", "artifacts", head.id, "discoveries.json");
     let discoveries = [];
     if (existsSync49(discPath)) {
       discoveries = JSON.parse(readFileSync38(discPath, "utf8"));
@@ -66486,7 +66769,7 @@ import {
   mkdirSync as mkdirSync19,
   renameSync as renameSync5
 } from "node:fs";
-import { join as join34, basename as basename4, dirname as dirname10, relative as relative3 } from "node:path";
+import { join as join35, basename as basename4, dirname as dirname10, relative as relative3 } from "node:path";
 function createWorkspaceContext(projectRoot = process.cwd()) {
   const rootDir = resolveWorkspaceRoot(projectRoot);
   return {
@@ -66496,7 +66779,7 @@ function createWorkspaceContext(projectRoot = process.cwd()) {
   };
 }
 function planJsonPath(ctx) {
-  return join34(ctx.rootDir, "plan.json");
+  return join35(ctx.rootDir, "plan.json");
 }
 function readPlan(ctx) {
   const jsonPath = planJsonPath(ctx);
@@ -66515,8 +66798,8 @@ function readPlan(ctx) {
     } catch {
     }
   }
-  const path126 = workspaceFile(ctx.rootDir, "plan");
-  const doc = ctx.storage.readIfExists(path126);
+  const path128 = workspaceFile(ctx.rootDir, "plan");
+  const doc = ctx.storage.readIfExists(path128);
   if (!doc) return { phases: [], tasks: [], milestones: [] };
   const meta3 = doc.meta;
   return {
@@ -66609,7 +66892,7 @@ function renderPlanBody(summary) {
   return lines.join("\n");
 }
 function nextAdrId(ctx) {
-  const decisionsDir = join34(ctx.rootDir, "decisions");
+  const decisionsDir = join35(ctx.rootDir, "decisions");
   if (!existsSync50(decisionsDir)) return "001";
   const existing = readdirSync11(decisionsDir).filter((f) => f.endsWith(".md")).map((f) => f.match(/^(\d+)-/)).filter((m) => !!m).map((m) => parseInt(m[1], 10));
   const max = existing.length === 0 ? 0 : Math.max(...existing);
@@ -66634,14 +66917,14 @@ function addPhaseRecord(summary, input) {
   return { id: id3, created: true };
 }
 function addTaskRecord(ctx, summary, phaseId, t, options) {
-  const slug = slugify3(t.title);
+  const slug2 = slugify3(t.title);
   if (options.dedupe) {
     const existing = summary.tasks.find(
-      (k) => k.phaseId === phaseId && k.id.replace(/-\d+$/, "") === `${phaseId}-${slug}`
+      (k) => k.phaseId === phaseId && k.id.replace(/-\d+$/, "") === `${phaseId}-${slug2}`
     );
     if (existing) return { id: existing.id, created: false };
   }
-  const id3 = `${phaseId}-${slug}-${summary.tasks.filter((k) => k.phaseId === phaseId).length + 1}`;
+  const id3 = `${phaseId}-${slug2}-${summary.tasks.filter((k) => k.phaseId === phaseId).length + 1}`;
   summary.tasks.push({
     kind: "task",
     id: id3,
@@ -66655,7 +66938,7 @@ function addTaskRecord(ctx, summary, phaseId, t, options) {
     // plan.json record (they already live in tags + the artifact body md).
     files: t.fileRefs
   });
-  const taskPath = join34(ctx.rootDir, "plan-tasks", `${id3}.md`);
+  const taskPath = join35(ctx.rootDir, "plan-tasks", `${id3}.md`);
   const meta3 = {
     kind: "task",
     id: id3,
@@ -66697,7 +66980,7 @@ function addMilestoneRecord(ctx, summary, input) {
     dueDate: input.dueDate,
     targetVersion: version2
   });
-  const path126 = join34(ctx.rootDir, "milestones", `${id3}.md`);
+  const path128 = join35(ctx.rootDir, "milestones", `${id3}.md`);
   const meta3 = {
     kind: "milestone",
     id: id3,
@@ -66714,7 +66997,7 @@ function addMilestoneRecord(ctx, summary, input) {
     `Target version: ${version2}`,
     ""
   ].join("\n");
-  ctx.storage.write(path126, meta3, body);
+  ctx.storage.write(path128, meta3, body);
   return { id: id3, created: true };
 }
 function readPlanSummary(ctx) {
@@ -66918,7 +67201,7 @@ function addIdeaStub(ctx) {
         const tags = args["tags"] ?? [];
         const category = args["category"] ?? "General";
         const id3 = `${nextAdrId(ctx)}-${slugify3(title)}`;
-        const path126 = workspaceArtifact(ctx.rootDir, "decisions", id3);
+        const path128 = workspaceArtifact(ctx.rootDir, "decisions", id3);
         const meta3 = {
           kind: "adr",
           status: "proposed",
@@ -66944,7 +67227,7 @@ function addIdeaStub(ctx) {
           ...consequences.map((c) => `- ${c}`),
           ""
         ].join("\n");
-        ctx.storage.write(path126, meta3, body);
+        ctx.storage.write(path128, meta3, body);
         return `ADR ${id3} created: "${title}". Status: proposed. Promote to accepted via /update ADR or manual edit.`;
       });
     }
@@ -66995,7 +67278,7 @@ function createNfrSpecStub(ctx) {
           },
           planFeatureKeywords: Array.isArray(args["planFeatureKeywords"]) ? args["planFeatureKeywords"] : void 0
         };
-        const outPath = join34(ctx.rootDir, "nfr-spec.json");
+        const outPath = join35(ctx.rootDir, "nfr-spec.json");
         writeFileSync21(outPath, JSON.stringify(spec, null, 2), "utf8");
         return `NFR spec written to nfr-spec.json (${targets.length} target(s)).`;
       });
@@ -67014,8 +67297,8 @@ function createDocumentStub(ctx) {
         const content = args["content"] ?? "";
         const tags = args["tags"] ?? [];
         const normalizedTitle = title.replace(/\.(md|markdown)\s*$/i, "");
-        const slug = slugify3(normalizedTitle) || `doc-${Date.now()}`;
-        if (slug === "risks") {
+        const slug2 = slugify3(normalizedTitle) || `doc-${Date.now()}`;
+        if (slug2 === "risks") {
           const risksPath = workspaceFile(ctx.rootDir, "risks");
           const riskMeta = {
             kind: "risk",
@@ -67026,15 +67309,15 @@ function createDocumentStub(ctx) {
           ctx.storage.write(risksPath, riskMeta, content);
           return `Document "${title}" created at risks.md (workspace root).`;
         }
-        const path126 = workspaceArtifact(ctx.rootDir, "docs", slug);
+        const path128 = workspaceArtifact(ctx.rootDir, "docs", slug2);
         const meta3 = {
           kind: "doc",
-          id: slug,
+          id: slug2,
           date: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
           tags
         };
-        ctx.storage.write(path126, meta3, content);
-        return `Document "${title}" created at docs/${slug}.md.`;
+        ctx.storage.write(path128, meta3, content);
+        return `Document "${title}" created at docs/${slug2}.md.`;
       });
     }
   };
@@ -67059,11 +67342,11 @@ function searchDocumentsStub(ctx) {
         (w) => w.length >= 3 && w !== "or" && w !== "and" && w !== "the"
       );
       const files = [
-        ...ctx.storage.listMarkdown(join34(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join34(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join34(ctx.rootDir, "reviews")),
-        ...ctx.storage.listMarkdown(join34(ctx.rootDir, "plan-tasks")),
-        ...ctx.storage.listMarkdown(join34(ctx.rootDir, "milestones")),
+        ...ctx.storage.listMarkdown(join35(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join35(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join35(ctx.rootDir, "reviews")),
+        ...ctx.storage.listMarkdown(join35(ctx.rootDir, "plan-tasks")),
+        ...ctx.storage.listMarkdown(join35(ctx.rootDir, "milestones")),
         workspaceFile(ctx.rootDir, "plan"),
         workspaceFile(ctx.rootDir, "risks")
       ];
@@ -67121,9 +67404,9 @@ function linkDocumentsStub(ctx) {
         const toId = args["toId"] ?? args["targetId"] ?? args["targetPathOrTitle"];
         if (!fromId || !toId) return "linkDocuments requires fromId and toId.";
         const allFiles = [
-          ...ctx.storage.listMarkdown(join34(ctx.rootDir, "decisions")),
-          ...ctx.storage.listMarkdown(join34(ctx.rootDir, "docs")),
-          ...ctx.storage.listMarkdown(join34(ctx.rootDir, "reviews"))
+          ...ctx.storage.listMarkdown(join35(ctx.rootDir, "decisions")),
+          ...ctx.storage.listMarkdown(join35(ctx.rootDir, "docs")),
+          ...ctx.storage.listMarkdown(join35(ctx.rootDir, "reviews"))
         ];
         const source2 = allFiles.find((f) => {
           try {
@@ -67154,9 +67437,9 @@ function getDocumentBacklinksStub(ctx) {
       const targetId = args["targetId"] ?? args["id"];
       if (!targetId) return "getDocumentBacklinks requires targetId.";
       const allFiles = [
-        ...ctx.storage.listMarkdown(join34(ctx.rootDir, "decisions")),
-        ...ctx.storage.listMarkdown(join34(ctx.rootDir, "docs")),
-        ...ctx.storage.listMarkdown(join34(ctx.rootDir, "reviews"))
+        ...ctx.storage.listMarkdown(join35(ctx.rootDir, "decisions")),
+        ...ctx.storage.listMarkdown(join35(ctx.rootDir, "docs")),
+        ...ctx.storage.listMarkdown(join35(ctx.rootDir, "reviews"))
       ];
       const backlinks = [];
       for (const file2 of allFiles) {
@@ -67656,17 +67939,17 @@ import {
   readFileSync as readFileSync40,
   writeFileSync as writeFileSync22
 } from "node:fs";
-import { dirname as dirname11, join as join35 } from "node:path";
+import { dirname as dirname11, join as join36 } from "node:path";
 function getUserMcpPath() {
-  return join35(zelariHome(), "mcp.json");
+  return join36(zelariHome(), "mcp.json");
 }
 function getProjectMcpPath(projectRoot) {
-  return join35(projectRoot, ".zelari", "mcp.json");
+  return join36(projectRoot, ".zelari", "mcp.json");
 }
-function readFile10(path126) {
-  if (!existsSync51(path126)) return {};
+function readFile10(path128) {
+  if (!existsSync51(path128)) return {};
   try {
-    const parsed = JSON.parse(readFileSync40(path126, "utf8"));
+    const parsed = JSON.parse(readFileSync40(path128, "utf8"));
     const out = {};
     for (const [name, cfg] of Object.entries(parsed.mcpServers ?? {})) {
       const hasCommand = !!cfg && typeof cfg.command === "string" && !!cfg.command.trim();
@@ -67688,10 +67971,10 @@ function readFile10(path126) {
     return {};
   }
 }
-function writeFile4(path126, servers) {
-  mkdirSync20(dirname11(path126), { recursive: true });
+function writeFile4(path128, servers) {
+  mkdirSync20(dirname11(path128), { recursive: true });
   const body = { mcpServers: servers };
-  writeFileSync22(path126, `${JSON.stringify(body, null, 2)}
+  writeFileSync22(path128, `${JSON.stringify(body, null, 2)}
 `, "utf8");
 }
 function listMcpServers(projectRoot) {
@@ -67769,9 +68052,9 @@ function upsertMcpServer(opts) {
       error: "either command (stdio) or url (http) is required"
     };
   }
-  let path126;
+  let path128;
   if (opts.scope === "user") {
-    path126 = getUserMcpPath();
+    path128 = getUserMcpPath();
   } else {
     const root = opts.projectRoot?.trim();
     if (!root) {
@@ -67780,9 +68063,9 @@ function upsertMcpServer(opts) {
         error: "projectRoot required for project scope (Open Folder first)"
       };
     }
-    path126 = getProjectMcpPath(root);
+    path128 = getProjectMcpPath(root);
   }
-  const current = readFile10(path126);
+  const current = readFile10(path128);
   const previous = current[name];
   current[name] = {
     command: hasCommand ? opts.config.command.trim() : void 0,
@@ -67798,21 +68081,21 @@ function upsertMcpServer(opts) {
     serial: opts.config.serial,
     enabled: opts.config.enabled !== false
   };
-  writeFile4(path126, current);
-  return { ok: true, path: path126 };
+  writeFile4(path128, current);
+  return { ok: true, path: path128 };
 }
 function removeMcpServer(opts) {
-  const path126 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
-  if (!path126) {
+  const path128 = opts.scope === "user" ? getUserMcpPath() : opts.projectRoot ? getProjectMcpPath(opts.projectRoot) : null;
+  if (!path128) {
     return { ok: false, error: "projectRoot required for project scope" };
   }
-  const current = readFile10(path126);
+  const current = readFile10(path128);
   if (!(opts.name in current)) {
-    return { ok: false, error: `Server "${opts.name}" not found in ${path126}` };
+    return { ok: false, error: `Server "${opts.name}" not found in ${path128}` };
   }
   delete current[opts.name];
-  writeFile4(path126, current);
-  return { ok: true, path: path126 };
+  writeFile4(path128, current);
+  return { ok: true, path: path128 };
 }
 var ENV_KEY_RE;
 var init_mcpConfigIo = __esm({
@@ -67987,15 +68270,15 @@ __export(mcpManager_exports, {
   registerMcpTools: () => registerMcpTools
 });
 import { existsSync as existsSync52, readFileSync as readFileSync41 } from "node:fs";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 function readMcpConfig(projectRoot = process.cwd(), opts) {
   const merged = {};
   const paths = [];
   if (process.env["ZELARI_MCP_USER"] !== "0") {
-    paths.push(join36(zelariHome(), "mcp.json"));
+    paths.push(join37(zelariHome(), "mcp.json"));
   }
   if (!opts?.skipProjectMcp) {
-    paths.push(join36(projectRoot, ".zelari", "mcp.json"));
+    paths.push(join37(projectRoot, ".zelari", "mcp.json"));
   }
   for (const p3 of paths) {
     if (!existsSync52(p3)) continue;
@@ -68016,7 +68299,7 @@ async function ensureLoaded(projectRoot) {
   if (state2.loaded) return;
   state2.loaded = true;
   const trusted = isFolderTrusted(projectRoot);
-  if (!trusted && existsSync52(join36(projectRoot, ".zelari", "mcp.json"))) {
+  if (!trusted && existsSync52(join37(projectRoot, ".zelari", "mcp.json"))) {
     state2.warnings.push(
       "[mcp] project .zelari/mcp.json ignored \u2014 folder not trusted (run /trust or `zelari-code --trust` to enable project MCP)"
     );
@@ -68286,13 +68569,13 @@ __export(agentsMd_exports, {
 });
 import { existsSync as existsSync53, readFileSync as readFileSync42, writeFileSync as writeFileSync23 } from "node:fs";
 import { createHash as createHash25 } from "node:crypto";
-import { join as join37 } from "node:path";
+import { join as join38 } from "node:path";
 import { readFile as readFile11 } from "node:fs/promises";
 async function readPackageJson3(projectRoot) {
-  const path126 = join37(projectRoot, "package.json");
-  if (!existsSync53(path126)) return null;
+  const path128 = join38(projectRoot, "package.json");
+  if (!existsSync53(path128)) return null;
   try {
-    return JSON.parse(await readFile11(path126, "utf8"));
+    return JSON.parse(await readFile11(path128, "utf8"));
   } catch {
     return null;
   }
@@ -68314,7 +68597,7 @@ async function genTechStack(ctx) {
   ].join("\n");
 }
 async function genDecisions(ctx) {
-  const decisionsDir = join37(ctx.rootDir, "decisions");
+  const decisionsDir = join38(ctx.rootDir, "decisions");
   if (!existsSync53(decisionsDir)) return "_No ADRs yet._";
   const files = ctx.storage.listMarkdown(decisionsDir).sort();
   const accepted = [];
@@ -68340,7 +68623,7 @@ async function genDecisions(ctx) {
 }
 async function genConventions(ctx) {
   const lines = [];
-  const claudeMd = join37(ctx.projectRoot, "CLAUDE.MD");
+  const claudeMd = join38(ctx.projectRoot, "CLAUDE.MD");
   if (existsSync53(claudeMd)) {
     const content = readFileSync42(claudeMd, "utf8");
     const match = content.match(/## Architecture rules[\s\S]+?(?=\n## |\n*$)/);
@@ -68374,9 +68657,9 @@ async function genBuild(ctx) {
   ].join("\n");
 }
 async function genOpenQuestions(ctx) {
-  const path126 = join37(ctx.rootDir, "risks.md");
-  if (!existsSync53(path126)) return "_No open questions._";
-  const content = readFileSync42(path126, "utf8");
+  const path128 = join38(ctx.rootDir, "risks.md");
+  if (!existsSync53(path128)) return "_No open questions._";
+  const content = readFileSync42(path128, "utf8");
   const lines = content.split("\n");
   const questions = [];
   let currentTitle = "";
@@ -68450,7 +68733,7 @@ function titleCase(id3) {
   return id3.split("-").map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
 }
 async function updateAgentsMd(ctx, projectRoot) {
-  const agentsPath = join37(projectRoot, "AGENTS.MD");
+  const agentsPath = join38(projectRoot, "AGENTS.MD");
   if (existsSync53(agentsPath)) {
     const content = readFileSync42(agentsPath, "utf8");
     const hasAnyMarker = AUTO_SECTIONS.some((id3) => content.includes(MARKER_OPEN(id3)));
@@ -68622,11 +68905,11 @@ var init_completeDesign = __esm({
 
 // src/cli/workspace/planDriftCheck.ts
 import { existsSync as existsSync54, readFileSync as readFileSync43, readdirSync as readdirSync12, statSync as statSync9, writeFileSync as writeFileSync24 } from "node:fs";
-import { join as join38 } from "node:path";
+import { join as join39 } from "node:path";
 function findCanonicalDoc(rootDir) {
-  const docsDir = join38(rootDir, "docs");
+  const docsDir = join39(rootDir, "docs");
   if (!existsSync54(docsDir)) return null;
-  const candidates = readdirSync12(docsDir).filter((f) => /^plan-canonical.*\.md$/i.test(f)).map((f) => ({ f, mtime: statSync9(join38(docsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const candidates = readdirSync12(docsDir).filter((f) => /^plan-canonical.*\.md$/i.test(f)).map((f) => ({ f, mtime: statSync9(join39(docsDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   return candidates.length > 0 ? candidates[0].f : null;
 }
 function parseCanonicalDoc(text) {
@@ -68650,9 +68933,9 @@ function versionKey(value) {
 function firstString2(v) {
   return typeof v === "string" && v.trim().length > 0 ? v : null;
 }
-function readFileSyncSafe(path126) {
+function readFileSyncSafe(path128) {
   try {
-    return readFileSync43(path126, "utf8");
+    return readFileSync43(path128, "utf8");
   } catch {
     return null;
   }
@@ -68661,7 +68944,7 @@ async function runPlanDriftCheck(rootDir) {
   if (process.env["ZELARI_DRIFT_CHECK"] === "0") {
     return { ran: false, reason: "ZELARI_DRIFT_CHECK=0 (disabled)" };
   }
-  const planPath = join38(rootDir, "plan.json");
+  const planPath = join39(rootDir, "plan.json");
   if (!existsSync54(planPath)) {
     return { ran: false, reason: ".zelari/plan.json missing (not design-phase)" };
   }
@@ -68677,7 +68960,7 @@ async function runPlanDriftCheck(rootDir) {
   const milestones = Array.isArray(plan.milestones) ? plan.milestones : [];
   const phaseIds = new Set(phases.map((p3) => typeof p3.id === "string" ? p3.id : "").filter(Boolean));
   const canonicalName = findCanonicalDoc(rootDir);
-  const canonicalText = canonicalName ? readFileSyncSafe(join38(rootDir, "docs", canonicalName)) : null;
+  const canonicalText = canonicalName ? readFileSyncSafe(join39(rootDir, "docs", canonicalName)) : null;
   if (canonicalText !== null) {
     const { activePhases, blockedPrefixes } = parseCanonicalDoc(canonicalText);
     for (const id3 of activePhases) {
@@ -68756,7 +69039,7 @@ async function runPlanDriftCheck(rootDir) {
   const canonicalParsed = canonicalName !== null && canonicalText !== null;
   let reportPath;
   try {
-    reportPath = join38(rootDir, "drift-report.json");
+    reportPath = join39(rootDir, "drift-report.json");
     writeFileSync24(
       reportPath,
       JSON.stringify(
@@ -68794,7 +69077,7 @@ var init_planDriftCheck = __esm({
 // src/cli/workspace/projectSmoke.ts
 import { spawn as spawn15 } from "node:child_process";
 import { existsSync as existsSync55, readFileSync as readFileSync44 } from "node:fs";
-import { join as join39 } from "node:path";
+import { join as join40 } from "node:path";
 function pickSmokeScript(scripts) {
   if (!scripts) return null;
   for (const name of SMOKE_SCRIPT_PRIORITY) {
@@ -68806,7 +69089,7 @@ async function runProjectSmoke(projectRoot, timeoutMs2 = DEFAULT_TIMEOUT_MS3) {
   if (process.env["ZELARI_SMOKE"] === "0") {
     return { ran: false, reason: "ZELARI_SMOKE=0 (disabled)" };
   }
-  const pkgPath = join39(projectRoot, "package.json");
+  const pkgPath = join40(projectRoot, "package.json");
   if (!existsSync55(pkgPath)) {
     return { ran: false, reason: "no package.json (skipped)" };
   }
@@ -68900,7 +69183,7 @@ __export(evidenceFromSpine_exports, {
   evidenceRefsFromEventLines: () => evidenceRefsFromEventLines
 });
 import { existsSync as existsSync56, readFileSync as readFileSync45 } from "node:fs";
-import path87 from "node:path";
+import path88 from "node:path";
 function asRecord5(v) {
   return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
 }
@@ -68938,7 +69221,7 @@ function evidenceRefsFromEventLines(lines) {
 }
 function collectSessionEvidenceRefs(sessionId2) {
   try {
-    const file2 = path87.join(sessionsDir(), sessionId2, "events.jsonl");
+    const file2 = path88.join(sessionsDir(), sessionId2, "events.jsonl");
     if (!existsSync56(file2)) return [];
     return evidenceRefsFromEventLines(readFileSync45(file2, "utf8").split("\n"));
   } catch {
@@ -68964,7 +69247,7 @@ __export(postCouncilHook_exports, {
 });
 import { spawn as spawn16 } from "node:child_process";
 import { existsSync as existsSync57, readFileSync as readFileSync46 } from "node:fs";
-import { join as join40 } from "node:path";
+import { join as join41 } from "node:path";
 async function runCompleteDesignPostProcessor(ctx, options) {
   if (options?.runMode === "implementation") {
     return {
@@ -68975,8 +69258,8 @@ async function runCompleteDesignPostProcessor(ctx, options) {
   if (process.env["ZELARI_COMPLETE_DESIGN"] === "0") {
     return { ran: false, reason: "ZELARI_COMPLETE_DESIGN=0 (disabled)" };
   }
-  const planJsonPath2 = join40(ctx.rootDir, "plan.json");
-  const scriptPath = join40(ctx.projectRoot, "complete-design.mjs");
+  const planJsonPath2 = join41(ctx.rootDir, "plan.json");
+  const scriptPath = join41(ctx.projectRoot, "complete-design.mjs");
   if (!existsSync57(planJsonPath2)) {
     return {
       ran: false,
@@ -69188,8 +69471,8 @@ async function runPostCouncilHook(ctx, options) {
           sources: scope.sources
         } : void 0
       });
-      const path126 = writeCouncilCompletion(ctx.rootDir, completion);
-      completionHook = { ran: true, path: path126, completion };
+      const path128 = writeCouncilCompletion(ctx.rootDir, completion);
+      completionHook = { ran: true, path: path128, completion };
     } catch (err) {
       completionHook = {
         ran: true,
@@ -69228,13 +69511,13 @@ __export(councilFeedback_exports, {
   FeedbackStore: () => FeedbackStore
 });
 import {
-  promises as fs34,
+  promises as fs35,
   existsSync as existsSync58,
   readFileSync as readFileSync47,
   writeFileSync as writeFileSync25,
   mkdirSync as mkdirSync21
 } from "node:fs";
-import path88 from "node:path";
+import path89 from "node:path";
 var FeedbackStore;
 var init_councilFeedback = __esm({
   "src/cli/councilFeedback.ts"() {
@@ -69351,7 +69634,7 @@ var init_councilFeedback = __esm({
         }
       }
       save() {
-        mkdirSync21(path88.dirname(this.file), { recursive: true });
+        mkdirSync21(path89.dirname(this.file), { recursive: true });
         writeFileSync25(
           this.file,
           JSON.stringify({ entries: this.entries }, null, 2),
@@ -69361,7 +69644,7 @@ var init_councilFeedback = __esm({
       /** Async variant of load for callers that prefer async IO. */
       async loadAsync() {
         try {
-          const raw = await fs34.readFile(this.file, "utf-8");
+          const raw = await fs35.readFile(this.file, "utf-8");
           const parsed = JSON.parse(raw);
           if (parsed && Array.isArray(parsed.entries)) {
             this.entries = parsed.entries.filter(
@@ -69418,22 +69701,77 @@ var init_buildPolicy = __esm({
 var ledger_exports = {};
 __export(ledger_exports, {
   EVOLUTION_ENV: () => EVOLUTION_ENV,
+  EVOLUTION_PATHS: () => EVOLUTION_PATHS,
+  FINDINGS_REL: () => FINDINGS_REL,
   HONESTY_CHECK_PREFIX: () => HONESTY_CHECK_PREFIX,
   LEDGER_REL: () => LEDGER_REL,
+  appendFindings: () => appendFindings,
   appendLedgerEntry: () => appendLedgerEntry,
   evolutionMode: () => evolutionMode,
+  findingFingerprint: () => findingFingerprint,
+  findingsPath: () => findingsPath,
   honestyFromVerificationResults: () => honestyFromVerificationResults,
   ledgerPath: () => ledgerPath,
   ledgerStats: () => ledgerStats,
+  readFindings: () => readFindings,
   readLedger: () => readLedger
 });
 import { appendFileSync as appendFileSync4, existsSync as existsSync59, mkdirSync as mkdirSync22, readFileSync as readFileSync48 } from "node:fs";
-import path89 from "node:path";
+import path90 from "node:path";
+function findingFingerprint(f) {
+  return [f.kind || "unknown", f.operator || "-", f.surface || "-", f.signal || "-"].join("|");
+}
+function findingsPath(cwd) {
+  return path90.join(cwd, FINDINGS_REL);
+}
+function appendFindings(cwd, findings) {
+  if (evolutionMode() === "0") {
+    return { written: false, reason: `${EVOLUTION_ENV} != shadow \u2014 findings write skipped` };
+  }
+  if (findings.length === 0) {
+    return { written: false, reason: "no findings" };
+  }
+  try {
+    const file2 = findingsPath(cwd);
+    mkdirSync22(path90.dirname(file2), { recursive: true });
+    appendFileSync4(file2, `${findings.map((f) => JSON.stringify(f)).join("\n")}
+`, "utf8");
+    return { written: true, path: file2 };
+  } catch (err) {
+    return {
+      written: false,
+      reason: `findings append failed (fail-open): ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function readFindings(cwd) {
+  const file2 = findingsPath(cwd);
+  if (!existsSync59(file2)) return [];
+  let raw;
+  try {
+    raw = readFileSync48(file2, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && typeof parsed.kind === "string") {
+        out.push(parsed);
+      }
+    } catch {
+    }
+  }
+  return out;
+}
 function evolutionMode(env = process.env) {
   return env[EVOLUTION_ENV] === "shadow" ? "shadow" : "0";
 }
 function ledgerPath(cwd) {
-  return path89.join(cwd, LEDGER_REL);
+  return path90.join(cwd, LEDGER_REL);
 }
 function honestyFromVerificationResults(results) {
   if (!results) return void 0;
@@ -69448,7 +69786,7 @@ function appendLedgerEntry(cwd, entry) {
   }
   try {
     const file2 = ledgerPath(cwd);
-    mkdirSync22(path89.dirname(file2), { recursive: true });
+    mkdirSync22(path90.dirname(file2), { recursive: true });
     appendFileSync4(file2, `${JSON.stringify(entry)}
 `, "utf8");
     return { written: true, path: file2 };
@@ -69559,12 +69897,23 @@ function ledgerStats(entries) {
     byClassFitness
   };
 }
-var EVOLUTION_ENV, LEDGER_REL, HONESTY_CHECK_PREFIX, TIER_WEIGHTS, UNTIERED_WEIGHT;
+var EVOLUTION_ENV, LEDGER_REL, FINDINGS_REL, EVOLUTION_PATHS, HONESTY_CHECK_PREFIX, TIER_WEIGHTS, UNTIERED_WEIGHT;
 var init_ledger = __esm({
   "src/cli/evolution/ledger.ts"() {
     "use strict";
     EVOLUTION_ENV = "ZELARI_EVOLUTION";
-    LEDGER_REL = path89.join(".zelari", "evolution", "ledger.jsonl");
+    LEDGER_REL = path90.join(".zelari", "evolution", "ledger.jsonl");
+    FINDINGS_REL = path90.join(".zelari", "evolution", "findings.jsonl");
+    EVOLUTION_PATHS = {
+      /** Outcome ledger (ADR-0036) — one JSON object per run. */
+      ledger: LEDGER_REL,
+      /** Instance-level findings ledger — the input to the pattern ledger (S1). */
+      findings: FINDINGS_REL,
+      /** Proposals store — owned by tools/eval evolvePropose (read-only here). */
+      proposals: path90.join(".zelari", "evolution", "proposals.jsonl"),
+      /** Failure-pattern clusters — derived, append-only (S1). */
+      patternLedger: path90.join(".zelari", "evolution", "pattern-ledger.jsonl")
+    };
     HONESTY_CHECK_PREFIX = "synthesis.";
     TIER_WEIGHTS = {
       build: 1,
@@ -69706,8 +70055,8 @@ __export(fileBackend_exports, {
   isMemoryEnabled: () => isMemoryEnabled
 });
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { promises as fs35 } from "node:fs";
-import * as path90 from "node:path";
+import { promises as fs36 } from "node:fs";
+import * as path91 from "node:path";
 function tokenize2(text) {
   return text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((t) => t.length >= 3);
 }
@@ -69760,9 +70109,9 @@ var init_fileBackend = __esm({
       logPath = "";
       memoryDir = "";
       async init(projectRoot) {
-        this.memoryDir = path90.join(projectRoot, ".zelari", "memory");
-        this.logPath = path90.join(this.memoryDir, "log.jsonl");
-        await fs35.mkdir(this.memoryDir, { recursive: true });
+        this.memoryDir = path91.join(projectRoot, ".zelari", "memory");
+        this.logPath = path91.join(this.memoryDir, "log.jsonl");
+        await fs36.mkdir(this.memoryDir, { recursive: true });
       }
       async add(content, metadata2 = {}, graph) {
         const fact = {
@@ -69772,7 +70121,7 @@ var init_fileBackend = __esm({
           ...graph ? { graph } : {},
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         };
-        await fs35.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
+        await fs36.appendFile(this.logPath, JSON.stringify(fact) + "\n", "utf8");
         return fact.id;
       }
       async search(query, options = {}) {
@@ -69800,7 +70149,7 @@ var init_fileBackend = __esm({
       async readAll() {
         let raw;
         try {
-          raw = await fs35.readFile(this.logPath, "utf8");
+          raw = await fs36.readFile(this.logPath, "utf8");
         } catch {
           return [];
         }
@@ -69833,23 +70182,23 @@ var init_fileBackend = __esm({
 });
 
 // src/cli/traceStore.ts
-import { promises as fs36 } from "node:fs";
-import * as path91 from "node:path";
+import { promises as fs37 } from "node:fs";
+import * as path92 from "node:path";
 function traceDir(projectRoot) {
-  return path91.join(projectRoot, ".zelari", "trace");
+  return path92.join(projectRoot, ".zelari", "trace");
 }
 function tracePath(projectRoot, missionId) {
-  return path91.join(traceDir(projectRoot), `${missionId}.json`);
+  return path92.join(traceDir(projectRoot), `${missionId}.json`);
 }
 async function saveTrace(projectRoot, missionId, entries) {
   const dir = traceDir(projectRoot);
-  await fs36.mkdir(dir, { recursive: true });
+  await fs37.mkdir(dir, { recursive: true });
   const payload = {
     missionId,
     ts: Date.now(),
     entries
   };
-  await fs36.writeFile(
+  await fs37.writeFile(
     tracePath(projectRoot, missionId),
     JSON.stringify(payload, null, 2) + "\n",
     "utf8"
@@ -69880,8 +70229,8 @@ __export(zelariMission_exports, {
   runZelariMission: () => runZelariMission
 });
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { promises as fs37 } from "node:fs";
-import * as path92 from "node:path";
+import { promises as fs38 } from "node:fs";
+import * as path93 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;
@@ -69924,10 +70273,10 @@ function isMissionAutoStart(env = process.env) {
   return env.ZELARI_MISSION_AUTO === "1";
 }
 async function writeMissionState(projectRoot, state3) {
-  const dir = path92.join(projectRoot, ".zelari");
-  await fs37.mkdir(dir, { recursive: true });
-  await fs37.writeFile(
-    path92.join(dir, "mission-state.json"),
+  const dir = path93.join(projectRoot, ".zelari");
+  await fs38.mkdir(dir, { recursive: true });
+  await fs38.writeFile(
+    path93.join(dir, "mission-state.json"),
     JSON.stringify(state3, null, 2) + "\n",
     "utf8"
   );
@@ -69940,8 +70289,8 @@ async function writeMissionState(projectRoot, state3) {
 }
 async function loadMissionState(projectRoot) {
   try {
-    const raw = await fs37.readFile(
-      path92.join(projectRoot, ".zelari", "mission-state.json"),
+    const raw = await fs38.readFile(
+      path93.join(projectRoot, ".zelari", "mission-state.json"),
       "utf8"
     );
     const parsed = JSON.parse(raw);
@@ -70700,7 +71049,7 @@ function safeSocketPath(socketPath) {
   return socketPath.trim();
 }
 function startPermissionBroker(socketPath, handlers, opts) {
-  const path126 = safeSocketPath(socketPath);
+  const path128 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const sockets = /* @__PURE__ */ new Set();
   const server = createServer2((socket) => {
@@ -70800,10 +71149,10 @@ function startPermissionBroker(socketPath, handlers, opts) {
   return new Promise((resolve11, reject) => {
     const onError = (err) => reject(err);
     server.once("error", onError);
-    server.listen(path126, () => {
+    server.listen(path128, () => {
       server.removeListener("error", onError);
       resolve11({
-        socketPath: path126,
+        socketPath: path128,
         stop: () => new Promise((res) => {
           for (const s of sockets) s.destroy();
           sockets.clear();
@@ -70814,7 +71163,7 @@ function startPermissionBroker(socketPath, handlers, opts) {
             if (done) return;
             done = true;
             if (process.platform !== "win32") {
-              unlink(path126, () => res());
+              unlink(path128, () => res());
             } else {
               res();
             }
@@ -70827,11 +71176,11 @@ function startPermissionBroker(socketPath, handlers, opts) {
   });
 }
 function requestBrokerAsk(socketPath, ask, opts) {
-  const path126 = safeSocketPath(socketPath);
+  const path128 = safeSocketPath(socketPath);
   const requestTimeoutMs = opts?.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
   const connectTimeoutMs = opts?.connectTimeoutMs ?? PERMISSION_BROKER_DEFAULT_CONNECT_TIMEOUT_MS;
   return new Promise((resolve11, reject) => {
-    const socket = connect(path126);
+    const socket = connect(path128);
     let buffer = "";
     let settled = false;
     const settle = (fn) => {
@@ -70846,7 +71195,7 @@ function requestBrokerAsk(socketPath, ask, opts) {
       settle(
         () => reject(
           new Error(
-            `permission broker unavailable at "${path126}" (connect timed out after ${connectTimeoutMs}ms)`
+            `permission broker unavailable at "${path128}" (connect timed out after ${connectTimeoutMs}ms)`
           )
         )
       );
@@ -72087,7 +72436,7 @@ var init_prereqChecks = __esm({
 
 // src/cli/plugins/prefs.ts
 import { existsSync as existsSync63, readFileSync as readFileSync51, writeFileSync as writeFileSync26, mkdirSync as mkdirSync23 } from "node:fs";
-import path99 from "node:path";
+import path100 from "node:path";
 function getPluginPrefsPath() {
   return pluginsPrefsPath();
 }
@@ -72110,7 +72459,7 @@ function getPluginPrefs() {
 }
 function writePluginPrefs(prefs) {
   const file2 = getPluginPrefsPath();
-  mkdirSync23(path99.dirname(file2), { recursive: true });
+  mkdirSync23(path100.dirname(file2), { recursive: true });
   writeFileSync26(file2, JSON.stringify(prefs, null, 2), {
     encoding: "utf-8",
     mode: 384
@@ -72148,7 +72497,7 @@ __export(registry_exports, {
   isBinaryOnPath: () => isBinaryOnPath
 });
 import { existsSync as existsSync64 } from "node:fs";
-import path100 from "node:path";
+import path101 from "node:path";
 function detectLocalBin(bin) {
   return (cwd) => {
     try {
@@ -72166,7 +72515,7 @@ function isBinaryOnPath(bin, opts = {}) {
   const platform = opts.platform ?? process.platform;
   const exists = opts.exists ?? existsSync64;
   const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
-  const pathMod = platform === "win32" ? path100.win32 : path100.posix;
+  const pathMod = platform === "win32" ? path101.win32 : path101.posix;
   const sep5 = platform === "win32" ? ";" : ":";
   const dirs = pathEnv.split(sep5).filter((d) => d.length > 0);
   const candidates = [bin];
@@ -73305,11 +73654,11 @@ var init_policy = __esm({
 });
 
 // src/cli/orchestration/facts.ts
-import { promises as fs46 } from "node:fs";
-import path104 from "node:path";
+import { promises as fs47 } from "node:fs";
+import path105 from "node:path";
 async function collectRepoFileCount(root = process.cwd()) {
   try {
-    await fs46.readdir(root);
+    await fs47.readdir(root);
   } catch {
     return void 0;
   }
@@ -73320,13 +73669,13 @@ async function collectRepoFileCount(root = process.cwd()) {
       const dir = queue.pop();
       let entries;
       try {
-        entries = await fs46.readdir(dir, { withFileTypes: true });
+        entries = await fs47.readdir(dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const e of entries) {
         if (e.isDirectory()) {
-          if (!SKIP_DIRS2.has(e.name)) queue.push(path104.join(dir, e.name));
+          if (!SKIP_DIRS2.has(e.name)) queue.push(path105.join(dir, e.name));
         } else if (e.isFile()) {
           count++;
           if (count > MAX_WALK_FILES) return count;
@@ -73424,7 +73773,7 @@ var init_streamScrub = __esm({
 });
 
 // src/cli/harnessState.ts
-import path105 from "node:path";
+import path106 from "node:path";
 function asString4(v) {
   return typeof v === "string" ? v : "";
 }
@@ -73599,7 +73948,7 @@ function contractFor(t) {
   };
 }
 async function readHarnessState(sessionDir, cache5) {
-  const report = await readSessionLogCached(path105.join(sessionDir, "events.jsonl"), cache5);
+  const report = await readSessionLogCached(path106.join(sessionDir, "events.jsonl"), cache5);
   return deriveHarnessState(report.events);
 }
 var init_harnessState = __esm({
@@ -73610,12 +73959,12 @@ var init_harnessState = __esm({
 });
 
 // src/cli/headless/harnessStateEmit.ts
-import path106 from "node:path";
+import path107 from "node:path";
 async function emitHarnessStateEvent(opts) {
   if (opts.output !== "json") return;
   try {
     const sessionsDir2 = resolveSessionsDir({ workspaceRoot: opts.workspaceRoot });
-    const state3 = await readHarnessState(path106.join(sessionsDir2, opts.spine.sessionId));
+    const state3 = await readHarnessState(path107.join(sessionsDir2, opts.spine.sessionId));
     opts.emitEvent({ type: "harness_state", ...state3 });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -74154,13 +74503,13 @@ var init_verifierLifecycle = __esm({
 
 // src/cli/extensions/sandboxedFs.ts
 import { promises as fsp } from "node:fs";
-import path107 from "node:path";
+import path108 from "node:path";
 function errText(prefix, p3, err) {
   const msg = err instanceof Error ? err.message : String(err);
   return `[extension-fs] ${prefix} "${p3}": ${msg}`;
 }
 function bindSandboxedFs(root) {
-  const resolvedRoot = path107.resolve(root);
+  const resolvedRoot = path108.resolve(root);
   return {
     root: resolvedRoot,
     async readFile(relativePath) {
@@ -74176,7 +74525,7 @@ function bindSandboxedFs(root) {
       try {
         const target = resolveSandboxedPath(relativePath, { root: resolvedRoot });
         verifyContainment(target, { root: resolvedRoot });
-        await fsp.mkdir(path107.dirname(target), { recursive: true });
+        await fsp.mkdir(path108.dirname(target), { recursive: true });
         await fsp.writeFile(target, data, "utf8");
         return typedOk({ path: target });
       } catch (err) {
@@ -74203,15 +74552,15 @@ var init_sandboxedFs = __esm({
 });
 
 // src/cli/extensions/loader.ts
-import { join as join46 } from "node:path";
+import { join as join47 } from "node:path";
 import { readdirSync as readdirSync14, readFileSync as readFileSync54 } from "node:fs";
 import { createHash as createHash26 } from "node:crypto";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 function globalExtensionsDir() {
-  return join46(zelariHome(), "extensions");
+  return join47(zelariHome(), "extensions");
 }
 function projectExtensionsDir(projectRoot) {
-  return join46(projectRoot, ".zelari", "extensions");
+  return join47(projectRoot, ".zelari", "extensions");
 }
 function sha256File(file2) {
   return createHash26("sha256").update(readFileSync54(file2)).digest("hex");
@@ -74223,7 +74572,7 @@ function candidateFiles(dir) {
   } catch {
     return [];
   }
-  return names.filter((n) => EXTENSION_FILE_EXTS.has(n.slice(n.lastIndexOf(".")).toLowerCase())).sort().map((n) => join46(dir, n));
+  return names.filter((n) => EXTENSION_FILE_EXTS.has(n.slice(n.lastIndexOf(".")).toLowerCase())).sort().map((n) => join47(dir, n));
 }
 function extractExtension(mod) {
   const m = mod;
@@ -74245,14 +74594,14 @@ async function loadExtensionsFromDirs(dirs, options = {}) {
     skipped
   };
   const fsRoot = options.fsRoot ?? process.cwd();
-  let fs51 = null;
+  let fs52 = null;
   const pending = [];
   for (const dir of dirs) {
     const files = candidateFiles(dir.path);
     if (files.length === 0) continue;
     let lock = null;
     try {
-      lock = JSON.parse(readFileSync54(join46(dir.path, EXTENSIONS_LOCK_FILE), "utf8"));
+      lock = JSON.parse(readFileSync54(join47(dir.path, EXTENSIONS_LOCK_FILE), "utf8"));
     } catch {
       lock = null;
       if (dirHasLockFile(dir.path)) {
@@ -74300,9 +74649,9 @@ async function loadExtensionsFromDirs(dirs, options = {}) {
       skipped.push(`${file2}: missing ZelariExtension export`);
       continue;
     }
-    if (!fs51) fs51 = bindSandboxedFs(fsRoot);
+    if (!fs52) fs52 = bindSandboxedFs(fsRoot);
     try {
-      await runtime.registry.registerExtension(ext, { fs: fs51 });
+      await runtime.registry.registerExtension(ext, { fs: fs52 });
       runtime.loaded.push({ id: ext.id, file: file2, scope });
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -74319,7 +74668,7 @@ function basenameOf(file2) {
 }
 function dirHasLockFile(dir) {
   try {
-    readFileSync54(join46(dir, EXTENSIONS_LOCK_FILE));
+    readFileSync54(join47(dir, EXTENSIONS_LOCK_FILE));
     return true;
   } catch {
     return false;
@@ -74360,8 +74709,8 @@ var init_loader = __esm({
 });
 
 // src/cli/headless/runOneTurn.ts
-import { promises as fs47 } from "node:fs";
-import path108 from "node:path";
+import { promises as fs48 } from "node:fs";
+import path109 from "node:path";
 function planModeFromOpts(opts) {
   return (opts.phase ?? "build") === "plan";
 }
@@ -74683,10 +75032,16 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
     wireSplit = { stable: systemMessages[0].content, volatile: "" };
   }
   await spine.beginResourceTurn();
+  const onePager = await buildOnePager({
+    cwd,
+    memory: nativeMemory ?? null,
+    skipCompactRecap: true
+  });
   const modelContext = await buildModelContext({
     fallbackHistory: seededHistory.history,
     session: spine.spine,
     resourceSnapshot: spine.spine.latestResourceSnapshot(),
+    volatileOnePager: onePager,
     phase: opts.phase ?? "build",
     model,
     provider,
@@ -74735,7 +75090,10 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
       cwd,
       providerStream,
       buildLiveness: { mutationRequired: wantWrites, maxRecoveries: 2 },
-      requestTail: () => resourceStatusTail(spine.spine.latestResourceSnapshot()),
+      requestTail: () => [
+        ...resourceStatusTail(spine.spine.latestResourceSnapshot()),
+        ...onePager
+      ],
       // 2.6 Phase 3: host-owned pre-dispatch resource gate (doc section 11.3).
       // Advisory by default; ZELARI_RESOURCE_ENFORCEMENT=protected enables the
       // protected verification reserve. Degrade-and-stop (null gate = allow).
@@ -74991,8 +75349,8 @@ async function runOneTurn(opts, provider, model, providerStream, extras) {
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs47.mkdir(path108.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-          await fs47.writeFile(opts.exportSessionPath, json3, "utf8");
+          await fs48.mkdir(path109.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs48.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
     } catch {
@@ -75065,6 +75423,7 @@ var init_runOneTurn = __esm({
     init_nativeVerification();
     init_verifierLifecycle();
     init_modelContextBuilder();
+    init_onePager();
     init_metrics3();
     init_messageUsage();
     init_headlessSpine();
@@ -75968,6 +76327,150 @@ var init_run = __esm({
   }
 });
 
+// src/cli/evolution/patternLedger.ts
+var patternLedger_exports = {};
+__export(patternLedger_exports, {
+  DEFAULT_MIN_DISTINCT_TASKS: () => DEFAULT_MIN_DISTINCT_TASKS,
+  PATTERN_LEDGER_REL: () => PATTERN_LEDGER_REL,
+  appendClusters: () => appendClusters,
+  categorizeCluster: () => categorizeCluster,
+  clusterFailures: () => clusterFailures,
+  clusterKeyFor: () => clusterKeyFor,
+  makeTaskKey: () => makeTaskKey,
+  patternLedgerPath: () => patternLedgerPath,
+  readClusters: () => readClusters
+});
+import { createHash as createHash27 } from "node:crypto";
+import { appendFileSync as appendFileSync6, existsSync as existsSync69, mkdirSync as mkdirSync26, readFileSync as readFileSync55 } from "node:fs";
+import path110 from "node:path";
+function nonEmpty2(v) {
+  return typeof v === "string" && v.trim() !== "" ? v : void 0;
+}
+function makeTaskKey(input) {
+  const mission = input.missionTaskId?.trim();
+  if (mission) return mission;
+  const normalized = (input.taskText ?? "").trim().replace(/\s+/g, " ").toLowerCase();
+  if (normalized) return createHash27("sha256").update(normalized).digest("hex").slice(0, 12);
+  return input.sessionId;
+}
+function clusterKeyFor(input) {
+  const tool = nonEmpty2(input.tool) ?? "unknown";
+  const errorClass = nonEmpty2(input.errorClass) ?? "unknown";
+  const termination = nonEmpty2(input.termination) ?? nonEmpty2(input.kind) ?? "unknown";
+  return `${tool}|${errorClass}|${termination}`;
+}
+function categorizeCluster(input) {
+  const operator = nonEmpty2(input.operator) ?? "";
+  const haystack = `${input.kind ?? ""} ${operator} ${input.patchHint ?? ""}`.toLowerCase();
+  const touchesHarness = /tool|verif|observ|compact|resource|budget|boundary|interrupt|loop|context/.test(haystack);
+  if (operator === "revise_skill" && !touchesHarness) return "model-accommodation";
+  return "harness-repair";
+}
+function deriveTool(f) {
+  const ev = f.evidence ?? {};
+  const explicit = nonEmpty2(ev.toolName) ?? nonEmpty2(ev.tool);
+  if (explicit) return explicit;
+  const signal = nonEmpty2(f.signal);
+  return signal && signal.includes(":") ? signal.slice(0, signal.indexOf(":")) : "unknown";
+}
+function clusterFailures(findings, opts) {
+  const minDistinct = Math.max(1, Math.floor(opts?.minDistinctTasks ?? DEFAULT_MIN_DISTINCT_TASKS));
+  const buckets = /* @__PURE__ */ new Map();
+  let unmapped = 0;
+  for (const f of findings) {
+    const sessions = f.sessions ?? [];
+    const taskKey = nonEmpty2(f.taskKey) ?? nonEmpty2(sessions[0]);
+    if (!taskKey) {
+      unmapped += 1;
+      continue;
+    }
+    const tool = deriveTool(f);
+    const errorClass = nonEmpty2(f.evidence?.errorClass) ?? "unknown";
+    const termination = nonEmpty2(f.evidence?.termination) ?? nonEmpty2(f.kind) ?? "unknown";
+    const key = clusterKeyFor({ tool, errorClass, termination, kind: f.kind });
+    let b = buckets.get(key);
+    if (!b) {
+      b = { tool, errorClass, termination, count: 0, findings: 0, sessions: /* @__PURE__ */ new Set(), taskKeys: /* @__PURE__ */ new Set(), taskClasses: /* @__PURE__ */ new Set() };
+      buckets.set(key, b);
+    }
+    b.findings += 1;
+    b.count += typeof f.count === "number" ? f.count : 1;
+    for (const s of sessions) b.sessions.add(s);
+    b.taskKeys.add(taskKey);
+    if (!b.operator) b.operator = nonEmpty2(f.operator);
+    if (!b.patchHint) b.patchHint = nonEmpty2(f.surface);
+    const taskClass = nonEmpty2(f.taskClass);
+    if (taskClass) b.taskClasses.add(taskClass);
+    if (f.firstAt && (!b.firstAt || f.firstAt < b.firstAt)) b.firstAt = f.firstAt;
+    if (f.lastAt && (!b.lastAt || f.lastAt > b.lastAt)) b.lastAt = f.lastAt;
+  }
+  const clusters = [];
+  for (const [key, b] of [...buckets.entries()].sort(([a], [c]) => a < c ? -1 : a > c ? 1 : 0)) {
+    if (b.taskKeys.size < minDistinct) {
+      unmapped += b.findings;
+      continue;
+    }
+    clusters.push({
+      id: `c-${String(clusters.length + 1).padStart(4, "0")}`,
+      key,
+      category: categorizeCluster({ kind: b.termination, operator: b.operator, patchHint: b.patchHint ?? key }),
+      tool: b.tool,
+      errorClass: b.errorClass,
+      termination: b.termination,
+      count: b.count,
+      sessions: [...b.sessions].sort(),
+      taskKeys: [...b.taskKeys].sort(),
+      distinctTasks: b.taskKeys.size,
+      taskClasses: [...b.taskClasses].sort(),
+      firstAt: b.firstAt ?? "",
+      lastAt: b.lastAt ?? ""
+    });
+  }
+  return { clusters, unmapped };
+}
+function patternLedgerPath(cwd = process.cwd()) {
+  return path110.join(cwd, PATTERN_LEDGER_REL);
+}
+async function appendClusters(clusters, cwd = process.cwd()) {
+  if (clusters.length === 0) return;
+  try {
+    const file2 = patternLedgerPath(cwd);
+    mkdirSync26(path110.dirname(file2), { recursive: true });
+    appendFileSync6(file2, `${clusters.map((c) => JSON.stringify(c)).join("\n")}
+`, "utf8");
+  } catch {
+  }
+}
+async function readClusters(cwd = process.cwd()) {
+  const file2 = patternLedgerPath(cwd);
+  if (!existsSync69(file2)) return [];
+  let raw;
+  try {
+    raw = readFileSync55(file2, "utf8");
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && typeof parsed.key === "string") out.push(parsed);
+    } catch {
+    }
+  }
+  return out;
+}
+var PATTERN_LEDGER_REL, DEFAULT_MIN_DISTINCT_TASKS;
+var init_patternLedger = __esm({
+  "src/cli/evolution/patternLedger.ts"() {
+    "use strict";
+    PATTERN_LEDGER_REL = path110.join(".zelari", "evolution", "pattern-ledger.jsonl");
+    DEFAULT_MIN_DISTINCT_TASKS = 2;
+  }
+});
+
 // src/cli/evolution/runTelemetry.ts
 var runTelemetry_exports = {};
 __export(runTelemetry_exports, {
@@ -76045,10 +76548,10 @@ __export(triggerLock_exports, {
   lockPath: () => lockPath,
   releaseLock: () => releaseLock
 });
-import { promises as fs48 } from "node:fs";
-import * as path109 from "node:path";
+import { promises as fs49 } from "node:fs";
+import * as path111 from "node:path";
 function lockPath(projectRoot) {
-  return path109.join(projectRoot, ".zelari", "trigger.lock");
+  return path111.join(projectRoot, ".zelari", "trigger.lock");
 }
 function isPidAlive(pid) {
   try {
@@ -76061,10 +76564,10 @@ function isPidAlive(pid) {
 }
 async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date()) {
   const lp = lockPath(projectRoot);
-  const dir = path109.dirname(lp);
-  await fs48.mkdir(dir, { recursive: true });
+  const dir = path111.dirname(lp);
+  await fs49.mkdir(dir, { recursive: true });
   try {
-    const raw = await fs48.readFile(lp, "utf8");
+    const raw = await fs49.readFile(lp, "utf8");
     const existing = JSON.parse(raw);
     if (existing.pid && isPidAlive(existing.pid)) {
       return { acquired: false, heldBy: existing.pid, lockPath: lp };
@@ -76075,13 +76578,13 @@ async function acquireLock(projectRoot, now = () => /* @__PURE__ */ new Date())
     pid: process.pid,
     acquiredAt: now().toISOString()
   };
-  await fs48.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
+  await fs49.writeFile(lp, JSON.stringify(payload, null, 2) + "\n", "utf8");
   return { acquired: true, lockPath: lp };
 }
 async function releaseLock(projectRoot) {
   const lp = lockPath(projectRoot);
   try {
-    await fs48.unlink(lp);
+    await fs49.unlink(lp);
   } catch {
   }
 }
@@ -76098,8 +76601,8 @@ __export(runHeadless_exports, {
   dispatchHeadlessTurn: () => dispatchHeadlessTurn,
   runHeadless: () => runHeadless
 });
-import { promises as fs49 } from "node:fs";
-import path110 from "node:path";
+import { promises as fs50 } from "node:fs";
+import path112 from "node:path";
 import { randomUUID as randomUUID10 } from "node:crypto";
 async function runHeadless(opts) {
   resetTaskSpawnCount();
@@ -76386,11 +76889,11 @@ async function runHeadlessKrakenGraph(opts, provider, model, providerStream, ext
   try {
     let preflightGraph;
     if (opts.runPlan && opts.runPlan.trim() !== "") {
-      const planPath = path110.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
+      const planPath = path112.join(cwd, ".zelari", "radio", `plan-${opts.runPlan}.json`);
       log(`loading pre-flight plan: ${planPath}`);
       let raw;
       try {
-        raw = await fs49.readFile(planPath, "utf8");
+        raw = await fs50.readFile(planPath, "utf8");
       } catch (e) {
         log(`plan file not found: ${planPath} (${e.message})`);
         exitCode = 1;
@@ -76444,10 +76947,10 @@ async function runHeadlessKrakenGraph(opts, provider, model, providerStream, ext
       log(formatKrakenGraphAscii2(graph));
       if (opts.planOnly) {
         const planId = randomUUID10();
-        const planDir = path110.join(cwd, ".zelari", "radio");
-        const planPath = path110.join(planDir, `plan-${planId}.json`);
-        await fs49.mkdir(planDir, { recursive: true });
-        await fs49.writeFile(
+        const planDir = path112.join(cwd, ".zelari", "radio");
+        const planPath = path112.join(planDir, `plan-${planId}.json`);
+        await fs50.mkdir(planDir, { recursive: true });
+        await fs50.writeFile(
           planPath,
           JSON.stringify(
             { id: graph.id, nodes: [...graph.nodes.values()] },
@@ -76549,16 +77052,32 @@ ${formatKrakenGraphDigest2(
     } catch {
     }
     try {
-      const { appendLedgerEntry: appendLedgerEntry2, evolutionMode: evolutionMode2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports));
+      const { appendLedgerEntry: appendLedgerEntry2, appendFindings: appendFindings2, evolutionMode: evolutionMode2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports));
       const { classifyTask: classifyTask2 } = await Promise.resolve().then(() => (init_classifyTask(), classifyTask_exports));
+      const { makeTaskKey: makeTaskKey2 } = await Promise.resolve().then(() => (init_patternLedger(), patternLedger_exports));
       if (evolutionMode2() === "shadow") {
+        const taskText = opts.task ?? "";
+        const at = (/* @__PURE__ */ new Date()).toISOString();
+        const taskClass = classifyTask2({ prompt: taskText }).taskClass;
         appendLedgerEntry2(cwd, {
           runId: spine.sessionId,
-          at: (/* @__PURE__ */ new Date()).toISOString(),
+          at,
           mode: "shadow",
-          taskClass: classifyTask2({ prompt: opts.task ?? "" }).taskClass,
+          taskClass,
           verdict: exitCode === 0 ? "PASS" : exitCode === 3 ? "FAIL" : "UNKNOWN"
         });
+        appendFindings2(cwd, [{
+          kind: "run-termination",
+          operator: "needs_human_review",
+          surface: "run:outcome",
+          signal: exitCode === 0 ? "completed" : "failed",
+          count: 1,
+          sessions: [spine.sessionId],
+          taskKey: makeTaskKey2({ taskText, sessionId: spine.sessionId }),
+          taskClass,
+          firstAt: at,
+          evidence: { termination: exitCode === 0 ? "completed" : exitCode === 3 ? "not-converged" : "error" }
+        }]);
       }
     } catch {
     }
@@ -76692,9 +77211,15 @@ async function runHeadlessCouncilBody(opts, provider, model, providerStream, ext
     parameters: tool.function.parameters
   }));
   await spine.beginResourceTurn();
+  const onePager = await buildOnePager({
+    cwd,
+    memory: nativeMemory ?? null,
+    skipCompactRecap: true
+  });
   const councilContext = await buildModelContext({
     fallbackHistory: seededHistory.history,
     session: spine.spine,
+    volatileOnePager: onePager,
     phase: councilRunMode === "design-phase" ? "plan" : "build",
     model,
     provider,
@@ -76829,14 +77354,17 @@ async function runHeadlessCouncilBody(opts, provider, model, providerStream, ext
   } catch {
   }
   try {
-    const { appendLedgerEntry: appendLedgerEntry2, evolutionMode: evolutionMode2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports));
+    const { appendLedgerEntry: appendLedgerEntry2, appendFindings: appendFindings2, evolutionMode: evolutionMode2 } = await Promise.resolve().then(() => (init_ledger(), ledger_exports));
     const { classifyTask: classifyTask2 } = await Promise.resolve().then(() => (init_classifyTask(), classifyTask_exports));
+    const { makeTaskKey: makeTaskKey2 } = await Promise.resolve().then(() => (init_patternLedger(), patternLedger_exports));
     if (evolutionMode2() === "shadow") {
+      const taskClass = classifyTask2({ prompt: effectiveTask }).taskClass;
+      const verdict = signal.aborted ? "UNKNOWN" : exitCode === 0 ? "PASS" : exitCode === 3 ? "FAIL" : "UNKNOWN";
       appendLedgerEntry2(cwd, {
         runId: spine.sessionId,
         at: (/* @__PURE__ */ new Date()).toISOString(),
         mode: "shadow",
-        taskClass: classifyTask2({ prompt: effectiveTask }).taskClass,
+        taskClass,
         // Steal #1/#2 wiring: real efficiency + attribution fields — the
         // ledger schema carried them since ADR-0036, this site never wrote them.
         latencyMs: Date.now() - councilStartedAt,
@@ -76851,8 +77379,20 @@ async function runHeadlessCouncilBody(opts, provider, model, providerStream, ext
         // post-council hook (no verification report in scope, see
         // runHeadlessZelariBody for that path), so the key is omitted.
         ...telemetry.usage().usageReports > 0 ? { cacheHitTokens: telemetry.usage().cacheHitTokens } : {},
-        verdict: signal.aborted ? "UNKNOWN" : exitCode === 0 ? "PASS" : exitCode === 3 ? "FAIL" : "UNKNOWN"
+        verdict
       });
+      appendFindings2(cwd, [{
+        kind: "run-termination",
+        operator: "needs_human_review",
+        surface: "run:outcome",
+        signal: verdict === "PASS" ? "completed" : "failed",
+        count: 1,
+        sessions: [spine.sessionId],
+        taskKey: makeTaskKey2({ taskText: effectiveTask, sessionId: spine.sessionId }),
+        taskClass,
+        firstAt: (/* @__PURE__ */ new Date()).toISOString(),
+        evidence: { termination: verdict === "PASS" ? "completed" : verdict === "FAIL" ? "not-converged" : "error" }
+      }]);
     }
   } catch {
   }
@@ -76863,8 +77403,8 @@ async function runHeadlessCouncilBody(opts, provider, model, providerStream, ext
       if (json3) {
         if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
         else {
-          await fs49.mkdir(path110.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-          await fs49.writeFile(opts.exportSessionPath, json3, "utf8");
+          await fs50.mkdir(path112.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+          await fs50.writeFile(opts.exportSessionPath, json3, "utf8");
         }
       }
     } catch {
@@ -76964,9 +77504,15 @@ async function runHeadlessZelariBody(opts, provider, model, providerStream, extr
     parameters: tool.function.parameters
   }));
   await spine.beginResourceTurn();
+  const onePager = await buildOnePager({
+    cwd: projectRoot,
+    memory: nativeMissionMemory ?? null,
+    skipCompactRecap: true
+  });
   const missionContext = await buildModelContext({
     fallbackHistory: seededHistory.history,
     session: spine.spine,
+    volatileOnePager: onePager,
     phase: opts.phase ?? "build",
     model,
     provider,
@@ -77341,8 +77887,8 @@ ${ragContext}` : slicePrompt;
         if (json3) {
           if (opts.exportSessionPath === "-") process.stdout.write(json3 + "\n");
           else {
-            await fs49.mkdir(path110.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
-            await fs49.writeFile(opts.exportSessionPath, json3, "utf8");
+            await fs50.mkdir(path112.dirname(opts.exportSessionPath), { recursive: true }).catch(() => void 0);
+            await fs50.writeFile(opts.exportSessionPath, json3, "utf8");
           }
         }
       } catch {
@@ -77374,6 +77920,7 @@ var init_runHeadless = __esm({
     init_verificationBridge();
     init_completionProofPersist();
     init_modelContextBuilder();
+    init_onePager();
     init_metrics3();
     init_headlessSpine();
     init_harnessStateEmit();
@@ -77874,7 +78421,7 @@ var init_jsonApi = __esm({
 });
 
 // src/cli/memory/mcpAdapter.ts
-import * as path111 from "node:path";
+import * as path113 from "node:path";
 var id2, projectId, source, SearchSchema, AddSchema, LinkSchema, RetractSchema, MEMORY_MCP_TOOLS, MemoryMcpAdapter;
 var init_mcpAdapter = __esm({
   "src/cli/memory/mcpAdapter.ts"() {
@@ -77910,6 +78457,7 @@ var init_mcpAdapter = __esm({
       confidence: external_exports.number().finite().min(0).max(1).optional(),
       visibility: MemoryVisibilitySchema.default("private"),
       tags: external_exports.array(external_exports.string().min(1).max(120)).max(64).optional(),
+      relevant_when: external_exports.array(external_exports.string().min(1).max(120)).max(8).optional(),
       source,
       metadata: external_exports.record(external_exports.string(), external_exports.unknown()).optional()
     }).strict();
@@ -77940,7 +78488,7 @@ var init_mcpAdapter = __esm({
       {
         name: "zelari_memory_add",
         description: "Add a scoped memory. Secrets are scanned and source.client is enforced by the server.",
-        inputSchema: { type: "object", properties: { project_id: { type: "string" }, kind: { type: "string" }, content: { type: "string", maxLength: 64e3 }, importance: { type: "number", minimum: 0, maximum: 1 }, confidence: { type: "number", minimum: 0, maximum: 1 }, visibility: { type: "string", enum: ["project", "private"], default: "private" }, tags: { type: "array", items: { type: "string" } }, source: { type: "object" }, metadata: { type: "object" } }, required: ["project_id", "kind", "content"] }
+        inputSchema: { type: "object", properties: { project_id: { type: "string" }, kind: { type: "string" }, content: { type: "string", maxLength: 64e3 }, importance: { type: "number", minimum: 0, maximum: 1 }, confidence: { type: "number", minimum: 0, maximum: 1 }, visibility: { type: "string", enum: ["project", "private"], default: "private" }, tags: { type: "array", items: { type: "string" } }, relevant_when: { type: "array", items: { type: "string", maxLength: 120 }, maxItems: 8 }, source: { type: "object" }, metadata: { type: "object" } }, required: ["project_id", "kind", "content"] }
       },
       {
         name: "zelari_memory_link",
@@ -78044,8 +78592,8 @@ var init_mcpAdapter = __esm({
         this.takeWrite();
         const externalFile = args.source?.file;
         if (externalFile) {
-          const normalized = path111.normalize(externalFile);
-          if (path111.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path111.sep}`)) {
+          const normalized = path113.normalize(externalFile);
+          if (path113.isAbsolute(normalized) || normalized === ".." || normalized.startsWith(`..${path113.sep}`)) {
             throw new Error("source.file must be project-relative and cannot escape the project");
           }
         }
@@ -78056,6 +78604,7 @@ var init_mcpAdapter = __esm({
           confidence: args.confidence,
           visibility: args.visibility,
           tags: args.tags,
+          relevantWhen: args.relevant_when,
           source: {
             ...args.source ?? {},
             ...externalFile ? { file: externalFile.replace(/\\/g, "/") } : {},
@@ -78549,36 +79098,36 @@ var init_permissionCli = __esm({
 
 // src/cli/companion/config.ts
 import {
-  existsSync as existsSync69,
-  mkdirSync as mkdirSync26,
-  readFileSync as readFileSync55,
+  existsSync as existsSync70,
+  mkdirSync as mkdirSync27,
+  readFileSync as readFileSync56,
   statSync as statSync13,
   writeFileSync as writeFileSync28
 } from "node:fs";
-import { join as join48, resolve as resolve9 } from "node:path";
-import { createHash as createHash27, randomBytes as randomBytes7, timingSafeEqual } from "node:crypto";
+import { join as join49, resolve as resolve9 } from "node:path";
+import { createHash as createHash28, randomBytes as randomBytes7, timingSafeEqual } from "node:crypto";
 function getZelariHome() {
   return zelariHome();
 }
 function getCompanionConfigPath() {
-  return join48(getZelariHome(), "companion.json");
+  return join49(getZelariHome(), "companion.json");
 }
 function getCompanionTokenPath() {
-  return join48(getZelariHome(), "companion.token");
+  return join49(getZelariHome(), "companion.token");
 }
 function ensureHome() {
   const home = getZelariHome();
-  if (!existsSync69(home)) {
-    mkdirSync26(home, { recursive: true });
+  if (!existsSync70(home)) {
+    mkdirSync27(home, { recursive: true });
   }
 }
 function loadCompanionConfig() {
-  const path126 = getCompanionConfigPath();
-  if (!existsSync69(path126)) {
+  const path128 = getCompanionConfigPath();
+  if (!existsSync70(path128)) {
     return { projects: [] };
   }
   try {
-    const raw = JSON.parse(readFileSync55(path126, "utf8"));
+    const raw = JSON.parse(readFileSync56(path128, "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) => ({
@@ -78616,24 +79165,24 @@ function loadOrCreateToken(explicit) {
     return { token: explicit.trim(), created: false };
   }
   ensureHome();
-  const path126 = getCompanionTokenPath();
-  if (existsSync69(path126)) {
-    const t = readFileSync55(path126, "utf8").trim();
+  const path128 = getCompanionTokenPath();
+  if (existsSync70(path128)) {
+    const t = readFileSync56(path128, "utf8").trim();
     if (t) return { token: t, created: false };
   }
   const token = randomBytes7(24).toString("base64url");
-  writeFileSync28(path126, token + "\n", "utf8");
+  writeFileSync28(path128, token + "\n", "utf8");
   try {
-    const fs51 = __require("node:fs");
-    fs51.chmodSync?.(path126, 384);
+    const fs52 = __require("node:fs");
+    fs52.chmodSync?.(path128, 384);
   } catch {
   }
   return { token, created: true };
 }
 function tokenMatches(expected, provided) {
   if (!provided) return false;
-  const a = createHash27("sha256").update(expected).digest();
-  const b = createHash27("sha256").update(provided).digest();
+  const a = createHash28("sha256").update(expected).digest();
+  const b = createHash28("sha256").update(provided).digest();
   try {
     return timingSafeEqual(a, b);
   } catch {
@@ -78665,8 +79214,8 @@ function resolveFsDirectory(rawPath) {
     return { ok: false, error: `not a directory: ${trimmed}` };
   }
   const abs = resolve9(trimmed);
-  const slug = slugFromPath(abs);
-  return { ok: true, project: { id: slug, name: slug, path: abs } };
+  const slug2 = slugFromPath(abs);
+  return { ok: true, project: { id: slug2, name: slug2, path: abs } };
 }
 function mergeProjects(cfg, extraPaths) {
   const byId = /* @__PURE__ */ new Map();
@@ -78674,17 +79223,17 @@ function mergeProjects(cfg, extraPaths) {
     byId.set(p3.id, p3);
   }
   for (const raw of extraPaths) {
-    const path126 = raw.trim();
-    if (!path126) continue;
-    let id3 = slugFromPath(path126);
+    const path128 = raw.trim();
+    if (!path128) continue;
+    let id3 = slugFromPath(path128);
     let n = 2;
-    while (byId.has(id3) && byId.get(id3).path !== path126) {
-      id3 = `${slugFromPath(path126)}-${n++}`;
+    while (byId.has(id3) && byId.get(id3).path !== path128) {
+      id3 = `${slugFromPath(path128)}-${n++}`;
     }
     byId.set(id3, {
       id: id3,
-      name: slugFromPath(path126),
-      path: path126
+      name: slugFromPath(path128),
+      path: path128
     });
   }
   return [...byId.values()];
@@ -78974,8 +79523,8 @@ var init_askUserBridge = __esm({
 });
 
 // src/cli/serve/spineLockSweep.ts
-import { promises as fs50 } from "node:fs";
-import path112 from "node:path";
+import { promises as fs51 } from "node:fs";
+import path114 from "node:path";
 async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
   const dir = sessionsDir2 ?? resolveSessionsDir();
   const onSwept = options.onSwept ?? ((sessionId2, reason) => {
@@ -78988,14 +79537,14 @@ async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
   const result = { swept: 0, kept: 0, errors: 0 };
   let entries;
   try {
-    entries = await fs50.readdir(dir);
+    entries = await fs51.readdir(dir);
   } catch {
     return result;
   }
   for (const sessionId2 of entries) {
-    const lockPath2 = path112.join(dir, sessionId2, "writer.lock");
+    const lockPath2 = path114.join(dir, sessionId2, "writer.lock");
     try {
-      const raw = await fs50.readFile(lockPath2, "utf-8");
+      const raw = await fs51.readFile(lockPath2, "utf-8");
       let lockInfo = {};
       try {
         lockInfo = JSON.parse(raw);
@@ -79012,7 +79561,7 @@ async function sweepOrphanSpineLocks(sessionsDir2, options = {}) {
         result.kept += 1;
         continue;
       }
-      await fs50.rm(lockPath2, { force: true });
+      await fs51.rm(lockPath2, { force: true });
       result.swept += 1;
       onSwept(sessionId2, verdict.reason);
     } catch (err) {
@@ -79110,7 +79659,7 @@ __export(harnessServer_exports, {
   startHarnessServer: () => startHarnessServer
 });
 import { createInterface as createInterface3 } from "node:readline";
-import path113 from "node:path";
+import path115 from "node:path";
 import { randomUUID as randomUUID12 } from "node:crypto";
 function createCliWorkspaceServices(workspaceRoot) {
   const mode = activePolicyLoadMode();
@@ -79145,7 +79694,7 @@ function resolveSessionCreateRoot(params, cwd = process.cwd()) {
     };
   }
   const root = raw.trim();
-  if (!path113.isAbsolute(root)) {
+  if (!path115.isAbsolute(root)) {
     return {
       ok: false,
       message: `session.create workspaceRoot must be an absolute path (got '${root}') \u2014 a relative root would resolve against the sidecar cwd (${cwd}) and mix conversations (ADR-0016)`
@@ -79560,7 +80109,7 @@ import { spawn as spawn19 } from "node:child_process";
 import { createInterface as createInterface4 } from "node:readline";
 import { randomUUID as randomUUID13 } from "node:crypto";
 import { writeFileSync as writeFileSync29, unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join49 } from "node:path";
+import { join as join50 } from "node:path";
 import { tmpdir as tmpdir4 } from "node:os";
 function harnessServerMode() {
   return process.env[HARNESS_SERVER_ENV] === "1";
@@ -79767,7 +80316,7 @@ var init_runManager = __esm({
         }
         let historyFile;
         if (args.history && Array.isArray(args.history) && args.history.length > 0) {
-          historyFile = join49(tmpdir4(), `zelari-companion-hist-${run.id}.json`);
+          historyFile = join50(tmpdir4(), `zelari-companion-hist-${run.id}.json`);
           try {
             writeFileSync29(historyFile, JSON.stringify(args.history), "utf8");
             argv.push("--history-file", historyFile);
@@ -80154,8 +80703,8 @@ __export(serve_exports, {
   runCompanionServe: () => runCompanionServe
 });
 import { createServer as createServer3 } from "node:http";
-import { existsSync as existsSync70, readdirSync as readdirSync15 } from "node:fs";
-import { join as join50, resolve as resolve10 } from "node:path";
+import { existsSync as existsSync71, readdirSync as readdirSync15 } from "node:fs";
+import { join as join51, resolve as resolve10 } from "node:path";
 function readBody(req, max = 2e6) {
   return new Promise((resolveBody, reject) => {
     const chunks = [];
@@ -80203,7 +80752,7 @@ async function runCompanionServe(opts = {}) {
   let projects = mergeProjects(fileCfg, opts.projects ?? []);
   projects = projects.filter((p3) => {
     const abs = resolve10(p3.path);
-    if (!existsSync70(abs)) {
+    if (!existsSync71(abs)) {
       process.stderr.write(
         `[zelari-code serve] skip missing project path: ${p3.path}
 `
@@ -80255,9 +80804,9 @@ async function runCompanionServe(opts = {}) {
       return;
     }
     const url2 = parseUrl(req);
-    const path126 = url2.pathname.replace(/\/+$/, "") || "/";
+    const path128 = url2.pathname.replace(/\/+$/, "") || "/";
     try {
-      if (req.method === "GET" && (path126 === "/health" || path126 === "/v1/health")) {
+      if (req.method === "GET" && (path128 === "/health" || path128 === "/v1/health")) {
         sendJson2(res, 200, {
           ok: true,
           service: "zelari-companion",
@@ -80269,25 +80818,25 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (path126.startsWith("/v1")) {
+      if (path128.startsWith("/v1")) {
         if (!tokenMatches(token, getBearer(req))) {
           sendJson2(res, 401, { ok: false, error: "unauthorized" });
           return;
         }
       }
-      if (req.method === "GET" && path126 === "/v1/config") {
+      if (req.method === "GET" && path128 === "/v1/config") {
         const snap = buildDesktopConfigSnapshot();
         sendJson2(res, 200, { ok: true, ...snap });
         return;
       }
-      if (req.method === "GET" && path126 === "/v1/fs") {
+      if (req.method === "GET" && path128 === "/v1/fs") {
         const listFsRootsInline = () => {
           if (process.platform === "win32") {
             const roots = [];
             for (let code = 65; code <= 90; code++) {
               const letter = String.fromCharCode(code);
               const drive = `${letter}:\\`;
-              if (existsSync70(drive)) {
+              if (existsSync71(drive)) {
                 roots.push({
                   id: `fs-${letter.toLowerCase()}`,
                   name: drive,
@@ -80315,7 +80864,7 @@ async function runCompanionServe(opts = {}) {
           sendJson2(res, 403, { ok: false, error: "path outside allowed roots" });
           return;
         }
-        if (!existsSync70(rawParam)) {
+        if (!existsSync71(rawParam)) {
           sendJson2(res, 404, { ok: false, error: "path not found" });
           return;
         }
@@ -80333,13 +80882,13 @@ async function runCompanionServe(opts = {}) {
           parent,
           entries: dirs.map((d) => ({
             name: d.name,
-            path: join50(rawParam, d.name),
+            path: join51(rawParam, d.name),
             dir: true
           }))
         });
         return;
       }
-      if (req.method === "GET" && path126 === "/v1/projects") {
+      if (req.method === "GET" && path128 === "/v1/projects") {
         sendJson2(res, 200, {
           ok: true,
           projects: projects.map((p3) => ({
@@ -80350,7 +80899,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "GET" && path126 === "/v1/runs") {
+      if (req.method === "GET" && path128 === "/v1/runs") {
         sendJson2(res, 200, {
           ok: true,
           active: runs.getActive(),
@@ -80368,7 +80917,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path126 === "/v1/runs") {
+      if (req.method === "POST" && path128 === "/v1/runs") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -80428,7 +80977,7 @@ async function runCompanionServe(opts = {}) {
         });
         return;
       }
-      if (req.method === "POST" && path126 === "/v1/trust") {
+      if (req.method === "POST" && path128 === "/v1/trust") {
         const raw = await readBody(req);
         let body = {};
         try {
@@ -80469,11 +81018,11 @@ async function runCompanionServe(opts = {}) {
         sendJson2(res, 200, { ok: true, denied: runId });
         return;
       }
-      if (req.method === "GET" && path126 === "/v1/trust/pending") {
+      if (req.method === "GET" && path128 === "/v1/trust/pending") {
         sendJson2(res, 200, { ok: true, pending: runs.pendingTrust() });
         return;
       }
-      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path126);
+      const eventsMatch = /^\/v1\/runs\/([^/]+)\/events$/.exec(path128);
       if (req.method === "GET" && eventsMatch) {
         const runId = eventsMatch[1];
         const run = runs.getRun(runId);
@@ -80538,7 +81087,7 @@ async function runCompanionServe(opts = {}) {
         }, 500);
         return;
       }
-      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path126);
+      const cancelMatch = /^\/v1\/runs\/([^/]+)\/cancel$/.exec(path128);
       if (req.method === "POST" && cancelMatch) {
         const runId = cancelMatch[1];
         const result = runs.cancel(runId);
@@ -80549,7 +81098,7 @@ async function runCompanionServe(opts = {}) {
         sendJson2(res, 200, { ok: true, cancelled: runId });
         return;
       }
-      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path126);
+      const steerMatch = /^\/v1\/runs\/([^/]+)\/steer$/.exec(path128);
       if (req.method === "POST" && steerMatch) {
         const runId = steerMatch[1];
         const raw = await readBody(req);
@@ -80573,7 +81122,7 @@ async function runCompanionServe(opts = {}) {
         sendJson2(res, 200, { ok: true, steered: runId, result: result.result });
         return;
       }
-      const askMatch = /^\/v1\/runs\/([^/]+)\/(permission|ask)$/.exec(path126);
+      const askMatch = /^\/v1\/runs\/([^/]+)\/(permission|ask)$/.exec(path128);
       if (req.method === "POST" && askMatch) {
         const runId = askMatch[1];
         const kind2 = askMatch[2];
@@ -80834,26 +81383,26 @@ __export(doctor_exports, {
   runDoctor: () => runDoctor
 });
 import { execSync as execSync3 } from "node:child_process";
-import { existsSync as existsSync71, readFileSync as readFileSync56, readlinkSync, statSync as statSync14 } from "node:fs";
+import { existsSync as existsSync72, readFileSync as readFileSync57, readlinkSync, statSync as statSync14 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import path114 from "node:path";
+import path116 from "node:path";
 function findPackageRoot(start) {
   let dir = start;
   for (let i = 0; i < 6; i += 1) {
-    const candidate = path114.join(dir, "package.json");
-    if (existsSync71(candidate)) {
+    const candidate = path116.join(dir, "package.json");
+    if (existsSync72(candidate)) {
       try {
-        const pkg = JSON.parse(readFileSync56(candidate, "utf8"));
+        const pkg = JSON.parse(readFileSync57(candidate, "utf8"));
         if (pkg.name === "zelari-code") return dir;
       } catch {
       }
     }
-    const parent = path114.dirname(dir);
+    const parent = path116.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return path114.resolve(__dirname3, "..", "..", "..");
+  return path116.resolve(__dirname3, "..", "..", "..");
 }
 function tryExec(cmd) {
   try {
@@ -80867,8 +81416,8 @@ function tryExec(cmd) {
 }
 function readPackageJson4() {
   try {
-    const pkgPath = path114.join(packageRoot, "package.json");
-    return JSON.parse(readFileSync56(pkgPath, "utf8"));
+    const pkgPath = path116.join(packageRoot, "package.json");
+    return JSON.parse(readFileSync57(pkgPath, "utf8"));
   } catch {
     return null;
   }
@@ -80879,7 +81428,7 @@ function getGlobalPrefix2() {
   return (process.env.npm_config_prefix || process.env.NPM_CONFIG_PREFIX || "").trim();
 }
 function isSourceCheckout() {
-  return existsSync71(path114.join(packageRoot, "src", "cli", "main.ts")) && existsSync71(path114.join(packageRoot, "apps", "desktop", "package.json"));
+  return existsSync72(path116.join(packageRoot, "src", "cli", "main.ts")) && existsSync72(path116.join(packageRoot, "apps", "desktop", "package.json"));
 }
 function checkShim(pkgName) {
   const prefix = getGlobalPrefix2();
@@ -80888,10 +81437,10 @@ function checkShim(pkgName) {
   }
   const isWin = process.platform === "win32";
   const shimName = isWin ? "zelari-code.cmd" : "zelari-code";
-  const shimPath = path114.join(prefix, shimName);
-  if (!existsSync71(shimPath)) {
-    const localBin = path114.join(packageRoot, "bin", "zelari-code.js");
-    if (isSourceCheckout() && existsSync71(localBin)) {
+  const shimPath = path116.join(prefix, shimName);
+  if (!existsSync72(shimPath)) {
+    const localBin = path116.join(packageRoot, "bin", "zelari-code.js");
+    if (isSourceCheckout() && existsSync72(localBin)) {
       return WARN(
         `global shim not found at ${shimPath}
          source checkout \u2014 using ${localBin}
@@ -80914,7 +81463,7 @@ function checkShim(pkgName) {
   try {
     const st = statSync14(shimPath);
     if (isWin) {
-      const content = readFileSync56(shimPath, "utf8");
+      const content = readFileSync57(shimPath, "utf8");
       if (content.includes(`${pkgName}\\bin\\`) || content.includes(`${pkgName}/bin/`)) {
         return OK(`shim OK at ${shimPath} (${st.size} bytes)`);
       }
@@ -80932,8 +81481,8 @@ function checkShim(pkgName) {
          fix:  npm install -g ${pkgName}@latest --force`
       );
     }
-    const resolved = path114.resolve(path114.dirname(shimPath), target);
-    const expected = path114.join(
+    const resolved = path116.resolve(path116.dirname(shimPath), target);
+    const expected = path116.join(
       prefix,
       "node_modules",
       pkgName,
@@ -80975,8 +81524,8 @@ function checkNode(pkg) {
   return OK(`node ${raw} (engines.node ${enginesNode ?? ">= 20.0.0"})`);
 }
 function checkBundle() {
-  const bundle = path114.join(packageRoot, "dist", "cli", "main.bundled.js");
-  if (!existsSync71(bundle)) {
+  const bundle = path116.join(packageRoot, "dist", "cli", "main.bundled.js");
+  if (!existsSync72(bundle)) {
     return FAIL(
       `dist/cli/main.bundled.js missing at ${bundle}
          fix:  npm run build:cli   (then reinstall or run via tsx)`
@@ -80996,7 +81545,7 @@ function checkRuntimeDeps() {
   const missing = [];
   for (const dep of required2) {
     try {
-      const localReq = createRequire3(path114.join(packageRoot, "package.json"));
+      const localReq = createRequire3(path116.join(packageRoot, "package.json"));
       localReq.resolve(dep);
     } catch {
       missing.push(dep);
@@ -81297,7 +81846,7 @@ var init_doctor = __esm({
     init_cacheHitReport();
     init_updater();
     require3 = createRequire3(import.meta.url);
-    __dirname3 = path114.dirname(fileURLToPath3(import.meta.url));
+    __dirname3 = path116.dirname(fileURLToPath3(import.meta.url));
     packageRoot = findPackageRoot(__dirname3);
     OK = (message) => ({
       ok: true,
@@ -81480,8 +82029,8 @@ __export(inspectSession_exports, {
   renderInspectReport: () => renderInspectReport,
   runInspectSession: () => runInspectSession
 });
-import path115 from "node:path";
-import { existsSync as existsSync72 } from "node:fs";
+import path117 from "node:path";
+import { existsSync as existsSync73 } from "node:fs";
 function formatLimit(limit) {
   return `${Math.round(limit / 1e3)}k`;
 }
@@ -81514,13 +82063,13 @@ function renderInspectReport(state3) {
 }
 async function runInspectSession(opts) {
   const sessionsDir2 = resolveSessionsDir({ workspaceRoot: opts.cwd ?? process.cwd() });
-  const sessionDir = path115.join(sessionsDir2, opts.sessionId);
-  const eventsPath = path115.join(sessionDir, "events.jsonl");
-  if (!existsSync72(sessionDir)) {
+  const sessionDir = path117.join(sessionsDir2, opts.sessionId);
+  const eventsPath = path117.join(sessionDir, "events.jsonl");
+  if (!existsSync73(sessionDir)) {
     console.error(`zelari-code inspect: no session directory at ${sessionDir}`);
     return 1;
   }
-  if (!existsSync72(eventsPath)) {
+  if (!existsSync73(eventsPath)) {
     console.error(`zelari-code inspect: session directory has no events.jsonl at ${eventsPath}`);
     return 1;
   }
@@ -81549,14 +82098,14 @@ __export(inspect_exports, {
   collectInspectReport: () => collectInspectReport,
   runInspect: () => runInspect
 });
-import path116 from "node:path";
-import { existsSync as existsSync73, readFileSync as readFileSync57, readdirSync as readdirSync16 } from "node:fs";
+import path118 from "node:path";
+import { existsSync as existsSync74, readFileSync as readFileSync58, readdirSync as readdirSync16 } from "node:fs";
 async function collectInspectReport(cwd = process.cwd()) {
   ensureBuiltinSkillsLoadedSync();
   const snap = listSkillsSnapshot(cwd);
   const mcp = listMcpServers(cwd);
-  const userMcpPath = path116.join(zelariHome(), "mcp.json");
-  const projectMcpPath = path116.join(cwd, ".zelari", "mcp.json");
+  const userMcpPath = path118.join(zelariHome(), "mcp.json");
+  const projectMcpPath = path118.join(cwd, ".zelari", "mcp.json");
   const globalHooks = globalHooksDir();
   const projectHooks = projectHooksDir(cwd);
   const projectTrusted = isFolderTrusted(cwd);
@@ -81582,11 +82131,11 @@ async function collectInspectReport(cwd = process.cwd()) {
       folders: listTrustedFolders()
     },
     configSources: [
-      { path: userMcpPath, exists: existsSync73(userMcpPath) },
-      { path: projectMcpPath, exists: existsSync73(projectMcpPath) },
-      { path: path116.join(zelariHome(), "provider.json"), exists: existsSync73(path116.join(zelariHome(), "provider.json")) },
-      { path: path116.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync73(path116.join(cwd, ".zelari", "AGENTS.md")) },
-      { path: path116.join(cwd, "AGENTS.md"), exists: existsSync73(path116.join(cwd, "AGENTS.md")) }
+      { path: userMcpPath, exists: existsSync74(userMcpPath) },
+      { path: projectMcpPath, exists: existsSync74(projectMcpPath) },
+      { path: path118.join(zelariHome(), "provider.json"), exists: existsSync74(path118.join(zelariHome(), "provider.json")) },
+      { path: path118.join(cwd, ".zelari", "AGENTS.md"), exists: existsSync74(path118.join(cwd, ".zelari", "AGENTS.md")) },
+      { path: path118.join(cwd, "AGENTS.md"), exists: existsSync74(path118.join(cwd, "AGENTS.md")) }
     ],
     skills: {
       total: snap.skills.length,
@@ -81599,7 +82148,7 @@ async function collectInspectReport(cwd = process.cwd()) {
       user: mcp.servers.filter((s) => s.scope === "user").map((s) => ({ name: s.name, enabled: s.enabled !== false })),
       project: mcp.servers.filter((s) => s.scope === "project").map((s) => ({ name: s.name, enabled: s.enabled !== false })),
       projectTrusted,
-      projectConfigExists: existsSync73(projectMcpPath)
+      projectConfigExists: existsSync74(projectMcpPath)
     },
     hooks: {
       global: {
@@ -81626,14 +82175,14 @@ function listJsonFiles(dir) {
 }
 function findAgentsMd(cwd) {
   const candidates = [
-    path116.join(cwd, "AGENTS.md"),
-    path116.join(cwd, ".zelari", "AGENTS.md")
+    path118.join(cwd, "AGENTS.md"),
+    path118.join(cwd, ".zelari", "AGENTS.md")
   ];
   const found = [];
   for (const c of candidates) {
-    if (existsSync73(c)) {
+    if (existsSync74(c)) {
       try {
-        const text = readFileSync57(c, "utf8");
+        const text = readFileSync58(c, "utf8");
         found.push(`${c} (${text.length} bytes)`);
       } catch {
         found.push(`${c} (unreadable)`);
@@ -81701,8 +82250,8 @@ __export(skillsCheck_exports, {
   formatSkillsCheckReport: () => formatSkillsCheckReport,
   parseFrontmatter: () => parseFrontmatter2
 });
-import { existsSync as existsSync74, readdirSync as readdirSync17, readFileSync as readFileSync58 } from "node:fs";
-import { join as join51 } from "node:path";
+import { existsSync as existsSync75, readdirSync as readdirSync17, readFileSync as readFileSync59 } from "node:fs";
+import { join as join52 } from "node:path";
 function parseFrontmatter2(content) {
   const fm = FRONTMATTER_RE2.exec(content);
   if (!fm) return null;
@@ -81723,10 +82272,10 @@ function parseFrontmatter2(content) {
 function messageOf(err) {
   return err instanceof Error ? err.message : String(err);
 }
-function checkSkillMd(path126, content) {
+function checkSkillMd(path128, content) {
   const lines = [];
   const push = (level, detail) => {
-    lines.push({ level, what: `${path126}: ${detail}` });
+    lines.push({ level, what: `${path128}: ${detail}` });
   };
   if (content.length === 0) {
     push("error", "file is empty (the loader requires frontmatter AND a body)");
@@ -81784,7 +82333,7 @@ function checkSkillFiles(options = {}) {
   let existingRoots = 0;
   let skillsChecked = 0;
   for (const root of roots) {
-    if (!existsSync74(root)) continue;
+    if (!existsSync75(root)) continue;
     existingRoots += 1;
     let entries;
     try {
@@ -81794,31 +82343,31 @@ function checkSkillFiles(options = {}) {
       continue;
     }
     for (const entry of entries) {
-      const dir = join51(root, entry);
-      const path126 = join51(dir, "SKILL.md");
-      if (!existsSync74(path126)) {
+      const dir = join52(root, entry);
+      const path128 = join52(dir, "SKILL.md");
+      if (!existsSync75(path128)) {
         lines.push({ level: "warn", what: `${dir}: no SKILL.md inside this skills directory (ignored by the loader)` });
         continue;
       }
       let content;
       try {
-        content = readFileSync58(path126, "utf8");
+        content = readFileSync59(path128, "utf8");
       } catch (err) {
-        lines.push({ level: "error", what: `${path126}: unreadable \u2014 ${messageOf(err)}` });
+        lines.push({ level: "error", what: `${path128}: unreadable \u2014 ${messageOf(err)}` });
         continue;
       }
       skillsChecked += 1;
-      lines.push(...checkSkillMd(path126, content));
+      lines.push(...checkSkillMd(path128, content));
       const name = (parseFrontmatter2(content)?.fields["name"] ?? "").trim().toLowerCase();
       if (!name) continue;
       const owner = ownerByName.get(name);
       if (owner) {
         lines.push({
           level: "warn",
-          what: `${path126}: name "${name}" is already provided by ${owner} (earlier directory wins; this file is skipped)`
+          what: `${path128}: name "${name}" is already provided by ${owner} (earlier directory wins; this file is skipped)`
         });
       } else {
-        ownerByName.set(name, path126);
+        ownerByName.set(name, path128);
       }
     }
   }
@@ -82868,13 +83417,13 @@ var init_command = __esm({
 });
 
 // src/cli/plugins/bundleManifest.ts
-import path117 from "node:path";
+import path119 from "node:path";
 function stripComment2(value) {
   const { $comment: _comment, ...rest } = value;
   return rest;
 }
 function escapesBundleRoot(p3) {
-  if (path117.isAbsolute(p3) || path117.win32.isAbsolute(p3)) return true;
+  if (path119.isAbsolute(p3) || path119.win32.isAbsolute(p3)) return true;
   return p3.split(/[\\/]+/).includes("..");
 }
 function formatIssues(error51, filePath) {
@@ -82987,7 +83536,7 @@ var init_bundleManifest = __esm({
 
 // src/cli/plugins/bundleFs.ts
 import { stat as stat8 } from "node:fs/promises";
-import path118 from "node:path";
+import path120 from "node:path";
 async function isFile(p3) {
   try {
     return (await stat8(p3)).isFile();
@@ -83006,9 +83555,9 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function resolveInsideBundle(root, relPath, at, manifestPath, errors) {
-  const abs = path118.resolve(root, relPath);
-  const rel2 = path118.relative(root, abs);
-  if (rel2 === "" || rel2.startsWith("..") || path118.isAbsolute(rel2)) {
+  const abs = path120.resolve(root, relPath);
+  const rel2 = path120.relative(root, abs);
+  if (rel2 === "" || rel2.startsWith("..") || path120.isAbsolute(rel2)) {
     errors.push(
       `${manifestPath}: invalid bundle manifest at '${at}': path escapes the bundle directory ('${relPath}')`
     );
@@ -83137,7 +83686,7 @@ var init_bundleMcp = __esm({
 
 // src/cli/plugins/bundleLoad.ts
 import { readFile as readFile12 } from "node:fs/promises";
-import path119 from "node:path";
+import path121 from "node:path";
 async function readSkills(manifestSkills, root, manifestPath, errors) {
   const skills = [];
   for (let i = 0; i < manifestSkills.length; i += 1) {
@@ -83186,8 +83735,8 @@ async function readHooks(manifestHooks, root, manifestPath, errors, warnings) {
 async function readBundle(dir, manifestFileName = BUNDLE_MANIFEST_FILE) {
   const errors = [];
   const warnings = [];
-  const root = path119.resolve(dir);
-  const manifestPath = path119.join(root, manifestFileName);
+  const root = path121.resolve(dir);
+  const manifestPath = path121.join(root, manifestFileName);
   if (!await isDir(root)) {
     return { errors: [`${root}: not a bundle directory`], warnings };
   }
@@ -83250,12 +83799,12 @@ var init_bundleLoad = __esm({
 
 // src/cli/plugins/bundleDiscover.ts
 import { readdir as readdir4 } from "node:fs/promises";
-import path120 from "node:path";
+import path122 from "node:path";
 function defaultBundleRoots(projectRoot, state3) {
-  const roots = [path120.join(projectRoot, "examples", "extensions")];
-  for (const p3 of state3.paths) roots.push(path120.resolve(projectRoot, p3));
+  const roots = [path122.join(projectRoot, "examples", "extensions")];
+  for (const p3 of state3.paths) roots.push(path122.resolve(projectRoot, p3));
   const unique = /* @__PURE__ */ new Map();
-  for (const root of roots) unique.set(path120.resolve(root).toLowerCase(), root);
+  for (const root of roots) unique.set(path122.resolve(root).toLowerCase(), root);
   return [...unique.values()];
 }
 async function discoverBundles(roots) {
@@ -83270,9 +83819,9 @@ async function discoverBundles(roots) {
       continue;
     }
     for (const entry of entries) {
-      const dir = path120.join(root, entry);
-      if (!await isFile(path120.join(dir, BUNDLE_MANIFEST_FILE))) continue;
-      const key = path120.resolve(dir);
+      const dir = path122.join(root, entry);
+      if (!await isFile(path122.join(dir, BUNDLE_MANIFEST_FILE))) continue;
+      const key = path122.resolve(dir);
       if (seen.has(key)) continue;
       seen.add(key);
       const result = await readBundle(dir);
@@ -83299,12 +83848,12 @@ var init_bundleDiscover = __esm({
 
 // src/cli/plugins/bundleState.ts
 import { mkdir as mkdir6, readFile as readFile13, writeFile as writeFile5 } from "node:fs/promises";
-import path121 from "node:path";
+import path123 from "node:path";
 function emptyBundleState() {
   return { enabled: {}, paths: [] };
 }
 function bundleStatePath(projectRoot) {
-  return path121.join(projectRoot, BUNDLE_STATE_FILE);
+  return path123.join(projectRoot, BUNDLE_STATE_FILE);
 }
 function isBundleEnabled(state3, name) {
   return state3.enabled[name] === true;
@@ -83344,11 +83893,11 @@ async function readBundleState(projectRoot) {
   return { state: state3, path: file2, errors: [] };
 }
 function withRegisteredScanRoot(state3, projectRoot, bundleDir) {
-  const abs = path121.dirname(path121.resolve(bundleDir));
-  const rel2 = path121.relative(path121.resolve(projectRoot), abs);
-  const value = rel2 === "" || rel2.startsWith("..") || path121.isAbsolute(rel2) ? abs : rel2;
-  const paths = state3.paths.map((p3) => path121.normalize(p3));
-  if (paths.includes(path121.normalize(value))) return state3;
+  const abs = path123.dirname(path123.resolve(bundleDir));
+  const rel2 = path123.relative(path123.resolve(projectRoot), abs);
+  const value = rel2 === "" || rel2.startsWith("..") || path123.isAbsolute(rel2) ? abs : rel2;
+  const paths = state3.paths.map((p3) => path123.normalize(p3));
+  if (paths.includes(path123.normalize(value))) return state3;
   return { ...state3, paths: [...state3.paths, value] };
 }
 async function setBundleEnabled(opts) {
@@ -83365,7 +83914,7 @@ async function setBundleEnabled(opts) {
   };
   const next = opts.dir ? withRegisteredScanRoot(named, opts.projectRoot, opts.dir) : named;
   try {
-    await mkdir6(path121.dirname(read.path), { recursive: true });
+    await mkdir6(path123.dirname(read.path), { recursive: true });
     await writeFile5(read.path, `${JSON.stringify(next, null, 2)}
 `, "utf8");
   } catch (err) {
@@ -83400,7 +83949,7 @@ __export(bundleCommand_exports, {
   runPluginValidate: () => runPluginValidate
 });
 import { readFile as readFile14 } from "node:fs/promises";
-import path122 from "node:path";
+import path124 from "node:path";
 function parsePluginFlags(argv) {
   const out = {};
   if (argv.includes("--help") || argv.includes("-h")) out.help = true;
@@ -83413,9 +83962,9 @@ function pluginHelpText() {
   return 'zelari-code plugin \u2014 plugin bundles (format v1)\n\nA bundle is a directory with a zelari-plugin.json manifest declaring\nskills, hooks, MCP servers and agents. Validation is static: nothing is\ninstalled, executed or fetched. Bundles are DISABLED until enabled, and\nenablement lives in the project file .zelari/plugins.json.\n\nUsage:\n  zelari-code plugin validate <dir>       Validate one bundle (exit 0/1)\n  zelari-code plugin list [dir...]        List discovered bundles + state\n  zelari-code plugin enable <dir|name>    Enable a bundle (validates first)\n  zelari-code plugin disable <dir|name>   Disable a bundle (always allowed)\n\nOptions:\n  --cwd <path>       Project root holding .zelari/plugins.json\n                     (default: current directory)\n  --help, -h         This text\n\n`list` scans <projectRoot>/examples/extensions plus every directory\nrecorded in "paths" of .zelari/plugins.json, then any extra dirs given.\n';
 }
 async function resolveBundleName(target, projectRoot, roots) {
-  const asDir = path122.resolve(projectRoot, target);
+  const asDir = path124.resolve(projectRoot, target);
   if (await isDir(asDir)) {
-    const manifestPath = path122.join(asDir, BUNDLE_MANIFEST_FILE);
+    const manifestPath = path124.join(asDir, BUNDLE_MANIFEST_FILE);
     let raw;
     try {
       raw = await readFile14(manifestPath, "utf8");
@@ -83473,7 +84022,7 @@ async function runPluginList(extraDirs, projectRoot) {
 `);
   const roots = [
     ...defaultBundleRoots(projectRoot, read.state),
-    ...extraDirs.map((d) => path122.resolve(projectRoot, d))
+    ...extraDirs.map((d) => path124.resolve(projectRoot, d))
   ];
   const found = await discoverBundles(roots);
   process.stdout.write(`zelari-code plugin list \u2014 project ${projectRoot}
@@ -83538,7 +84087,7 @@ async function runPluginCommand(argv) {
   try {
     const args = argv[0] === "plugin" ? argv.slice(1) : [...argv];
     const opts = parsePluginFlags(args);
-    const projectRoot = path122.resolve(opts.cwd ?? process.cwd());
+    const projectRoot = path124.resolve(opts.cwd ?? process.cwd());
     const positional = args.filter((a, i) => !a.startsWith("-") && args[i - 1] !== "--cwd");
     const [subcommand, ...rest] = positional;
     if (opts.help === true || subcommand === void 0) {
@@ -83591,19 +84140,19 @@ var init_bundleCommand = __esm({
 });
 
 // src/cli/commands/spineSession.ts
-import { existsSync as existsSync75, readFileSync as readFileSync59, readdirSync as readdirSync18 } from "node:fs";
-import path123 from "node:path";
+import { existsSync as existsSync76, readFileSync as readFileSync60, readdirSync as readdirSync18 } from "node:fs";
+import path125 from "node:path";
 function newestSpineSessionId(sessionsDir2) {
   let names;
   try {
-    names = readdirSync18(sessionsDir2).filter((n) => existsSync75(path123.join(sessionsDir2, n, "events.jsonl")));
+    names = readdirSync18(sessionsDir2).filter((n) => existsSync76(path125.join(sessionsDir2, n, "events.jsonl")));
   } catch {
     return null;
   }
   if (names.length === 0) return null;
   const scored = names.map((n) => {
     try {
-      const text = readFileSync59(path123.join(sessionsDir2, n, "events.jsonl"), "utf-8");
+      const text = readFileSync60(path125.join(sessionsDir2, n, "events.jsonl"), "utf-8");
       const events = parseSessionLogText("events.jsonl", text).events;
       return { n, ts: events[events.length - 1]?.ts ?? 0 };
     } catch {
@@ -83619,16 +84168,16 @@ function resolveSpineSession(query = {}) {
   const at = (sessionId2) => ({
     sessionId: sessionId2,
     sessionsDir: sessionsDir2,
-    eventsPath: path123.join(sessionsDir2, sessionId2, "events.jsonl")
+    eventsPath: path125.join(sessionsDir2, sessionId2, "events.jsonl")
   });
   if (query.sessionId !== void 0 && query.sessionId !== "") {
     const candidate = at(query.sessionId);
-    return existsSync75(candidate.eventsPath) ? candidate : { error: `no session spine at ${candidate.eventsPath}` };
+    return existsSync76(candidate.eventsPath) ? candidate : { error: `no session spine at ${candidate.eventsPath}` };
   }
   const marker = getCurrentSessionId();
   if (marker !== null) {
     const candidate = at(marker);
-    if (existsSync75(candidate.eventsPath)) return candidate;
+    if (existsSync76(candidate.eventsPath)) return candidate;
   }
   const newest = newestSpineSessionId(sessionsDir2);
   if (newest === null) {
@@ -83652,8 +84201,8 @@ __export(replay_exports, {
   replayHelpText: () => replayHelpText,
   runReplayCommand: () => runReplayCommand
 });
-import { readFileSync as readFileSync60 } from "node:fs";
-import path124 from "node:path";
+import { readFileSync as readFileSync61 } from "node:fs";
+import path126 from "node:path";
 function parseReplayFlags(argv) {
   const args = argv[0] === "replay" ? argv.slice(1) : [...argv];
   const out = {};
@@ -83670,7 +84219,7 @@ function replayHelpText() {
   return "zelari-code replay \u2014 replay a session spine (read-only, no LLM, no network)\n\nRe-reads one session log with the core tolerant reader and prints what it\ncontains: tool calls, verify debt, verify runs and decision events\n(permission asks/denials, auto-approvals, jail blocks, ask_user, verify\nrequests). Nothing is written: the log it reads is never modified.\n\nUsage:\n  zelari-code replay [<sessionId>] [--json]\n\nWith no <sessionId>: the current-session marker, else the newest spine.\n\nOptions:\n  --json             Print the full projection as JSON\n  --cwd <path>       Workspace root for the sessions dir\n                     (default: current directory;\n                     ZELARI_SESSIONS_DIR overrides both)\n  --help, -h         This text\n\nExit code: 0 on a successful replay (spine issues are reported, not\nfatal \u2014 see `zelari-code session validate` to fail on them), 1 when there\nwas nothing to replay.\n";
 }
 function shortPath2(p3, cwd) {
-  const rel2 = path124.relative(cwd, p3);
+  const rel2 = path126.relative(cwd, p3);
   return rel2 && !rel2.startsWith("..") ? rel2 : p3;
 }
 function renderReplayReport(input) {
@@ -83745,7 +84294,7 @@ async function runReplayCommand(argv) {
       process.stdout.write(replayHelpText());
       return 0;
     }
-    const cwd = path124.resolve(opts.cwd ?? process.cwd());
+    const cwd = path126.resolve(opts.cwd ?? process.cwd());
     const resolved = resolveSpineSession({
       ...opts.sessionId !== void 0 ? { sessionId: opts.sessionId } : {},
       cwd
@@ -83755,7 +84304,7 @@ async function runReplayCommand(argv) {
 `);
       return 1;
     }
-    const text = readFileSync60(resolved.eventsPath, "utf-8");
+    const text = readFileSync61(resolved.eventsPath, "utf-8");
     const report = parseSessionLogText(resolved.eventsPath, text);
     const projection = buildProjection(report.events, report.issues);
     if (opts.json === true) {
@@ -83808,8 +84357,8 @@ __export(session_exports, {
   runSessionCommand: () => runSessionCommand,
   sessionHelpText: () => sessionHelpText
 });
-import { readFileSync as readFileSync61 } from "node:fs";
-import path125 from "node:path";
+import { readFileSync as readFileSync62 } from "node:fs";
+import path127 from "node:path";
 function parseSessionFlags(argv) {
   const args = argv[0] === "session" ? argv.slice(1) : [...argv];
   const out = {};
@@ -83830,7 +84379,7 @@ function sessionHelpText() {
   return "zelari-code session \u2014 inspect and curate one session spine\n\nUsage:\n  zelari-code session validate [<sessionId>] [--json]\n  zelari-code session waive-debt <sessionId> <taskId> [--note <text>]\n\nvalidate re-reads the log with the core tolerant reader and reports the\nReplayIssues it collected (corrupt lines, schema mismatches, seq gaps /\nduplicates / non-monotonic seq) with line, seq and reason. With no\n<sessionId>: the current-session marker, else the newest spine.\n\nwaive-debt closes ONE open verify-debt slot (a verify.debt_open with no\nmatching verify.debt_cleared) by appending the cleared event through the\nsame locked writer the runtime uses. A waiver is an OPERATOR assertion,\nnot a verification (ADR-0023) \u2014 the event carries source=waiver plus the\noptional --note, so replay can always tell the two apart.\n\nOptions:\n  --json             (validate) Print the report as JSON\n  --note <text>      (waive-debt) Why the slot is being waived\n  --cwd <path>       Workspace root for the sessions dir\n                     (default: current directory;\n                     ZELARI_SESSIONS_DIR overrides both)\n  --help, -h         This text\n\nExit codes: validate \u2014 0 clean / 1 issues (or no spine). waive-debt \u2014\n0 cleared / 1 bad invocation or unknown taskId / 2 spine locked by a\nlive writer / 3 read or write error.\n";
 }
 function shortPath3(p3, cwd) {
-  const rel2 = path125.relative(cwd, p3);
+  const rel2 = path127.relative(cwd, p3);
   return rel2 && !rel2.startsWith("..") ? rel2 : p3;
 }
 function formatIssue(issue2) {
@@ -83870,7 +84419,7 @@ async function runWaiveDebt(opts, cwd) {
   }
   let report;
   try {
-    report = parseSessionLogText(resolved.eventsPath, readFileSync61(resolved.eventsPath, "utf-8"));
+    report = parseSessionLogText(resolved.eventsPath, readFileSync62(resolved.eventsPath, "utf-8"));
   } catch (err) {
     process.stderr.write(`[session] ${err instanceof Error ? err.message : String(err)}
 `);
@@ -83893,7 +84442,7 @@ async function runWaiveDebt(opts, cwd) {
     return 1;
   }
   const last = report.events[report.events.length - 1];
-  const sessionDir = path125.dirname(resolved.eventsPath);
+  const sessionDir = path127.dirname(resolved.eventsPath);
   let writer;
   try {
     writer = await SessionLogWriter.open(sessionDir, resolved.sessionId, (last?.seq ?? 0) + 1);
@@ -83950,7 +84499,7 @@ async function runSessionCommand(argv) {
       return 1;
     }
     if (subcommand === "waive-debt") {
-      return await runWaiveDebt(opts, path125.resolve(opts.cwd ?? process.cwd()));
+      return await runWaiveDebt(opts, path127.resolve(opts.cwd ?? process.cwd()));
     }
     if (subcommand !== "validate") {
       process.stderr.write(`[session] unknown subcommand '${subcommand}'
@@ -83959,7 +84508,7 @@ async function runSessionCommand(argv) {
       process.stdout.write(sessionHelpText());
       return 1;
     }
-    const cwd = path125.resolve(opts.cwd ?? process.cwd());
+    const cwd = path127.resolve(opts.cwd ?? process.cwd());
     const resolved = resolveSpineSession({
       ...opts.sessionId !== void 0 ? { sessionId: opts.sessionId } : {},
       cwd
@@ -83969,7 +84518,7 @@ async function runSessionCommand(argv) {
 `);
       return 1;
     }
-    const text = readFileSync61(resolved.eventsPath, "utf-8");
+    const text = readFileSync62(resolved.eventsPath, "utf-8");
     const report = parseSessionLogText(resolved.eventsPath, text);
     const last = report.events[report.events.length - 1];
     if (opts.json === true) {
@@ -84103,7 +84652,7 @@ __export(evolve_exports2, {
   parseEvolveFlags: () => parseEvolveFlags,
   runEvolveCommand: () => runEvolveCommand
 });
-import { readFileSync as readFileSync62 } from "node:fs";
+import { readFileSync as readFileSync63 } from "node:fs";
 function asString5(value) {
   return typeof value === "string" ? value : "";
 }
@@ -84195,9 +84744,9 @@ function verdictLine(v) {
     return `  [hold  ] ${v.reason}`;
   }
   const at = `@seq ${v.proposal.decisiveSeq}`;
-  const path126 = v.proposal.path !== void 0 ? ` \xB7 ${v.proposal.path}` : "";
+  const path128 = v.proposal.path !== void 0 ? ` \xB7 ${v.proposal.path}` : "";
   const saved = v.action === "shadow" ? ` \xB7 saves ~${v.proposal.estSavedCalls} call` : "";
-  return `  [${v.action === "shadow" ? "shadow" : "hold  "}] ${v.proposal.kind} ${at}${path126}${saved}${v.action === "shadow" ? "" : ` \u2014 ${v.reason}`}`;
+  return `  [${v.action === "shadow" ? "shadow" : "hold  "}] ${v.proposal.kind} ${at}${path128}${saved}${v.action === "shadow" ? "" : ` \u2014 ${v.reason}`}`;
 }
 async function runEvolveCommand(argv) {
   const flags = parseEvolveFlags(argv);
@@ -84221,7 +84770,7 @@ ${evolveHelpText()}`);
   }
   let parsed;
   try {
-    parsed = parseSessionLogText("events.jsonl", readFileSync62(target.eventsPath, "utf-8"));
+    parsed = parseSessionLogText("events.jsonl", readFileSync63(target.eventsPath, "utf-8"));
   } catch (err) {
     process.stderr.write(
       `[zelari-code evolve] cannot read ${target.eventsPath}: ${err instanceof Error ? err.message : String(err)}
@@ -88255,6 +88804,7 @@ init_verificationBridge();
 init_completionProof();
 init_opsKnowledge();
 init_repeatCheck();
+init_onePager();
 init_verifyStatus();
 init_nativeVerification();
 init_spineTelemetry();
@@ -88625,10 +89175,16 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
         const cwd = process.cwd();
         const requestSnapshot = getRequestSnapshotWithUsage(sessionId2);
         await writerRef.current?.spine?.beginResourceTurn();
+        const onePager = await buildOnePager({
+          cwd,
+          memory: memoryService ?? null,
+          skipCompactRecap: true
+        });
         const modelContext = await buildModelContext({
           fallbackHistory: historyForModel,
           session: writerRef.current?.spine ?? null,
           resourceSnapshot: writerRef.current?.spine?.latestResourceSnapshot() ?? null,
+          volatileOnePager: onePager,
           phase: workPhase,
           model: getActiveModel(),
           provider: envConfig?.providerId ?? (localCli || "local"),
@@ -88881,9 +89437,12 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
             ),
             maxRecoveries: 2
           },
-          requestTail: () => resourceStatusTail(
-            writerRef.current?.spine?.latestResourceSnapshot() ?? null
-          ),
+          requestTail: () => [
+            ...resourceStatusTail(
+              writerRef.current?.spine?.latestResourceSnapshot() ?? null
+            ),
+            ...onePager
+          ],
           // 2.6 Phase 3: host-owned pre-dispatch resource gate via the spine
           // mirror (doc section 11.3). Degrade-and-stop (null gate = allow).
           // 2.6.1 (plan §13): argument-aware — bash is essential only when
@@ -89470,9 +90029,15 @@ async function dispatchCouncilPromptImpl(text, deps, overrides = {}) {
   const anchored = maybeAnchorShortAnswer(text);
   const effectiveText = anchored ?? text;
   await writerRef.current?.spine?.beginResourceTurn();
+  const onePager = await buildOnePager({
+    cwd: process.cwd(),
+    memory: null,
+    skipCompactRecap: true
+  });
   const councilContext = await buildModelContext({
     fallbackHistory: getHistory(),
     session: writerRef.current?.spine ?? null,
+    volatileOnePager: onePager,
     phase: getPhase(),
     model: envConfig.model,
     provider: envConfig.providerId,
@@ -90490,10 +91055,10 @@ init_ledger();
 
 // src/cli/evolution/proposals.ts
 import { existsSync as existsSync60, readFileSync as readFileSync49 } from "node:fs";
-import path93 from "node:path";
-var PROPOSALS_REL = path93.join(".zelari", "evolution", "proposals.jsonl");
+import path94 from "node:path";
+var PROPOSALS_REL = path94.join(".zelari", "evolution", "proposals.jsonl");
 function proposalsPath(cwd) {
-  return path93.join(cwd, PROPOSALS_REL);
+  return path94.join(cwd, PROPOSALS_REL);
 }
 function readProposalStore(cwd) {
   const file2 = proposalsPath(cwd);
@@ -90680,15 +91245,15 @@ function handleStatusLine(args, opts = {}) {
 init_session();
 init_sessionManager();
 import { existsSync as existsSync61, readFileSync as readFileSync50, readdirSync as readdirSync13 } from "node:fs";
-import path94 from "node:path";
+import path95 from "node:path";
 var FILE_TOOLS2 = /* @__PURE__ */ new Set(["read_file", "write_file", "edit"]);
 function newestSessionId(sessionsDir2) {
   try {
-    const names = readdirSync13(sessionsDir2).filter((n) => existsSync61(path94.join(sessionsDir2, n, "events.jsonl")));
+    const names = readdirSync13(sessionsDir2).filter((n) => existsSync61(path95.join(sessionsDir2, n, "events.jsonl")));
     if (names.length === 0) return null;
     const scored = names.map((n) => {
       try {
-        const text = readFileSync50(path94.join(sessionsDir2, n, "events.jsonl"), "utf-8");
+        const text = readFileSync50(path95.join(sessionsDir2, n, "events.jsonl"), "utf-8");
         const last = parseSessionLogText("events.jsonl", text).events;
         return { n, ts: last[last.length - 1]?.ts ?? 0 };
       } catch {
@@ -90702,7 +91267,7 @@ function newestSessionId(sessionsDir2) {
   }
 }
 function shortPath(p3, cwd) {
-  const rel2 = path94.relative(cwd, p3);
+  const rel2 = path95.relative(cwd, p3);
   return rel2 && !rel2.startsWith("..") ? rel2 : p3;
 }
 function render(report, cwd, sessionId2) {
@@ -90861,7 +91426,7 @@ function buildSessionReport(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const sessionsDir2 = resolveSessionsDir({ workspaceRoot: cwd, env: opts.env });
   const marker = opts.sessionId ?? getCurrentSessionId() ?? void 0;
-  const marked = marker ? path94.join(sessionsDir2, marker, "events.jsonl") : null;
+  const marked = marker ? path95.join(sessionsDir2, marker, "events.jsonl") : null;
   const sessionId2 = marker && marked && existsSync61(marked) ? marker : newestSessionId(sessionsDir2);
   if (!sessionId2) {
     return {
@@ -90870,7 +91435,7 @@ function buildSessionReport(opts = {}) {
       markdown: `no session spine found under ${sessionsDir2} \u2014 nothing to report (this is not an error).`
     };
   }
-  const eventsPath = path94.join(sessionsDir2, sessionId2, "events.jsonl");
+  const eventsPath = path95.join(sessionsDir2, sessionId2, "events.jsonl");
   let text;
   try {
     text = readFileSync50(eventsPath, "utf-8");
@@ -90964,7 +91529,7 @@ function handleSlashCommand(text, availableSkills) {
   /resume-mission \u2014 resume the persisted mission (.zelari/mission-state.json; TUI twin of --resume-mission)
   /council-feedback <memberId> <1-5> [note] \u2014 rate a council member for future ranking (Task I.2)
   /promote-member <memberId> \u2014 promote a council member to a standalone skill (v3-K)
-  /memory [stats|search|show|related|history|retract|forget|consolidate|index|promote|doctor|export|audit] \u2014 inspect native project memory
+  /memory [stats|search|show|related|history|retract|forget|consolidate|dream|index|promote|doctor|export|audit] \u2014 inspect native project memory
   /update [--yes|-y] \u2014 check for zelari-code updates; --yes performs the update (v3-N)
   /plugins \u2014 list optional tool plugins (Playwright, eslint, ruff, LSP servers)
   /plugins install <id> \u2014 install a plugin now (e.g. /plugins install eslint)
@@ -91780,7 +92345,7 @@ async function handleUndo(ctx, warningMessage, doConfirm) {
 init_session();
 init_sessionManager();
 init_messageHelpers();
-import path95 from "node:path";
+import path96 from "node:path";
 var EMPTY_FIELDS = { name: "", engine: "", cwd: "" };
 function sessionSearchText(fields) {
   return [fields.name, fields.engine, fields.cwd].map((s) => s.trim()).filter((s) => s.length > 0).join(" ");
@@ -91796,7 +92361,7 @@ function shortenPath(p3, max = 28) {
 }
 async function readSessionSearchFields(id3, sessionsDir2 = resolveSessionsDir()) {
   try {
-    const report = await readSessionLog(path95.join(sessionsDir2, id3, "events.jsonl"));
+    const report = await readSessionLog(path96.join(sessionsDir2, id3, "events.jsonl"));
     const started = report.events.find((e) => e.kind === "session.started");
     const firstUser = report.events.find((e) => e.kind === "user.message");
     const data = started?.data ?? {};
@@ -92105,8 +92670,8 @@ init_howWeTest();
 init_promotion();
 init_repeatCheck();
 init_worldModel();
-import { promises as fs38 } from "node:fs";
-import * as path96 from "node:path";
+import { promises as fs39 } from "node:fs";
+import * as path97 from "node:path";
 var USAGE = [
   "/memory \u2014 backend summary",
   "/memory search <query>",
@@ -92116,6 +92681,7 @@ var USAGE = [
   "/memory retract <id> [reason]",
   "/memory forget <id> --yes",
   "/memory consolidate [query]",
+  "/memory dream [--min-candidates N] \u2014 consolidate pending candidates into durable nodes",
   "/memory index [--force]",
   "/memory promote <id> \u2014 append durable knowledge to managed AGENTS.md section",
   '/memory promote con-<fp> --as-check --command "<cmd>" [--expect-exit N] \u2014 append a WorldCheck',
@@ -92131,25 +92697,34 @@ function sourceLine(source2) {
   const entries = Object.entries(source2).filter(([, value]) => value !== void 0 && value !== "");
   return entries.length ? entries.map(([key, value]) => `${key}=${value}`).join(" \xB7 ") : "unknown";
 }
+function parseMinCandidates(args) {
+  const flagIndex = args.findIndex(
+    (arg) => arg === "--min-candidates" || arg === "--min-occurrences"
+  );
+  const raw = flagIndex >= 0 ? args[flagIndex + 1] : args.find((arg) => /^\d+$/.test(arg));
+  if (raw === void 0) return void 0;
+  const value = Number.parseInt(raw, 10);
+  return Number.isFinite(value) && value > 0 ? value : void 0;
+}
 function isInside(root, target) {
-  const relative6 = path96.relative(root, target);
-  return relative6 === "" || !relative6.startsWith("..") && !path96.isAbsolute(relative6);
+  const relative6 = path97.relative(root, target);
+  return relative6 === "" || !relative6.startsWith("..") && !path97.isAbsolute(relative6);
 }
 async function safeExportPath(cwd, requested) {
-  const lexicalRoot = path96.resolve(cwd);
-  const root = await fs38.realpath(lexicalRoot).catch(() => lexicalRoot);
-  const fallback = path96.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
-  const target = requested?.trim() ? path96.resolve(root, requested.trim()) : fallback;
+  const lexicalRoot = path97.resolve(cwd);
+  const root = await fs39.realpath(lexicalRoot).catch(() => lexicalRoot);
+  const fallback = path97.join(root, ".zelari", "memory", `export-${Date.now()}.json`);
+  const target = requested?.trim() ? path97.resolve(root, requested.trim()) : fallback;
   if (!isInside(root, target)) {
     throw new Error("Export path must stay inside the active project.");
   }
-  const parent = path96.dirname(target);
-  const relativeParent = path96.relative(root, parent);
+  const parent = path97.dirname(target);
+  const relativeParent = path97.relative(root, parent);
   let cursor = root;
-  for (const segment of relativeParent.split(path96.sep).filter(Boolean)) {
-    cursor = path96.join(cursor, segment);
+  for (const segment of relativeParent.split(path97.sep).filter(Boolean)) {
+    cursor = path97.join(cursor, segment);
     try {
-      const stat9 = await fs38.lstat(cursor);
+      const stat9 = await fs39.lstat(cursor);
       if (stat9.isSymbolicLink()) {
         throw new Error("Export path must not traverse a symbolic link.");
       }
@@ -92159,7 +92734,7 @@ async function safeExportPath(cwd, requested) {
     }
   }
   try {
-    if ((await fs38.lstat(target)).isSymbolicLink()) {
+    if ((await fs39.lstat(target)).isSymbolicLink()) {
       throw new Error("Export target must not be a symbolic link.");
     }
   } catch (error51) {
@@ -92288,6 +92863,15 @@ ${message}` : message
         emit(`[memory] consolidation scanned ${result.scanned} candidate(s), created ${result.created.length} durable node(s), archived ${result.archivedSourceIds.length} source duplicate(s).`);
         return;
       }
+      case "dream": {
+        const minOccurrences = parseMinCandidates(args);
+        const result = await memory.consolidate({
+          source: { agent: "user-cli-dream" },
+          ...minOccurrences === void 0 ? {} : { minOccurrences }
+        });
+        emit(`[memory dream] consolidated ${result.scanned} candidate(s), created ${result.created.length} durable node(s), archived ${result.archivedSourceIds.length} source duplicate(s).`);
+        return;
+      }
       case "index": {
         const result = memory.index ? await memory.index({ force: args.includes("--force") || args.includes("-f") }) : { status: "disabled", scanned: 0, indexed: 0, skipped: 0, failed: 0, interrupted: false };
         emit(
@@ -92350,13 +92934,13 @@ ${message}` : message
       }
       case "export": {
         const target = await safeExportPath(ctx.cwd, args.join(" ").trim() || void 0);
-        await fs38.mkdir(path96.dirname(target), { recursive: true });
-        const root = await fs38.realpath(ctx.cwd).catch(() => path96.resolve(ctx.cwd));
-        const realParent = await fs38.realpath(path96.dirname(target));
+        await fs39.mkdir(path97.dirname(target), { recursive: true });
+        const root = await fs39.realpath(ctx.cwd).catch(() => path97.resolve(ctx.cwd));
+        const realParent = await fs39.realpath(path97.dirname(target));
         if (!isInside(root, realParent)) {
           throw new Error("Export path resolves outside the active project.");
         }
-        await fs38.writeFile(target, JSON.stringify(await memory.export(), null, 2) + "\n", "utf8");
+        await fs39.writeFile(target, JSON.stringify(await memory.export(), null, 2) + "\n", "utf8");
         emit(`[memory] export written to ${target}`);
         return;
       }
@@ -92761,13 +93345,13 @@ ${digest}
 init_auditLogger();
 init_toolRegistry();
 init_messageHelpers();
-import { promises as fs40 } from "node:fs";
+import { promises as fs41 } from "node:fs";
 
 // src/cli/tools/krakenCsvFanout.ts
 init_zod();
 init_taskTool();
-import { promises as fs39 } from "node:fs";
-import path97 from "node:path";
+import { promises as fs40 } from "node:fs";
+import path98 from "node:path";
 import { randomBytes as randomBytes6 } from "node:crypto";
 var CsvFanoutArgsSchema = external_exports.object({
   csv_path: external_exports.string().min(1),
@@ -92788,7 +93372,7 @@ var CsvFanoutArgsSchema = external_exports.object({
   max_runtime_seconds: external_exports.number().int().positive().optional()
 });
 async function readCsv(filePath) {
-  const text = await fs39.readFile(filePath, "utf8");
+  const text = await fs40.readFile(filePath, "utf8");
   return parseCsv(text);
 }
 function parseCsv(text) {
@@ -92861,8 +93445,8 @@ function resolveMaxConcurrency(env = process.env) {
 }
 async function runCsvFanout(args, deps, opts) {
   const start = Date.now();
-  const absCsv = path97.isAbsolute(args.csv_path) ? args.csv_path : path97.join(opts.parentCwd, args.csv_path);
-  const absOut = path97.isAbsolute(args.output_csv_path) ? args.output_csv_path : path97.join(opts.parentCwd, args.output_csv_path);
+  const absCsv = path98.isAbsolute(args.csv_path) ? args.csv_path : path98.join(opts.parentCwd, args.csv_path);
+  const absOut = path98.isAbsolute(args.output_csv_path) ? args.output_csv_path : path98.join(opts.parentCwd, args.output_csv_path);
   const { headers: headers3, rows } = await readCsv(absCsv);
   if (headers3.length === 0) {
     throw new Error(`kraken_csv_fanout: ${absCsv} is empty`);
@@ -92918,7 +93502,7 @@ async function runCsvFanout(args, deps, opts) {
         errored += 1;
         errors.push(`${row[args.id_column] ?? i}: ${res.error}`);
       }
-      await fs39.mkdir(path97.dirname(absOut), { recursive: true });
+      await fs40.mkdir(path98.dirname(absOut), { recursive: true });
       await queueWrite(serializeCsv(outHeaders, outputRecords));
     }
   }
@@ -92940,8 +93524,8 @@ async function runCsvFanout(args, deps, opts) {
 }
 async function atomicWrite(file2, contents) {
   const tmp = `${file2}.${process.pid}.${Date.now()}.${randomBytes6(6).toString("hex")}.tmp`;
-  await fs39.writeFile(tmp, contents, "utf8");
-  await fs39.rename(tmp, file2);
+  await fs40.writeFile(tmp, contents, "utf8");
+  await fs40.rename(tmp, file2);
 }
 
 // src/cli/slashHandlers/krakenFanout.ts
@@ -93039,7 +93623,7 @@ async function handleKrakenFanout(ctx, raw) {
   }
   const absCsv = isAbsolute4(parsed.args.csv_path) ? parsed.args.csv_path : joinPath(ctx.cwd, parsed.args.csv_path);
   try {
-    await fs40.access(absCsv);
+    await fs41.access(absCsv);
   } catch {
     appendSystem(ctx.setMessages, `[kraken fanout] source CSV not found: ${absCsv}`);
     return;
@@ -93112,8 +93696,8 @@ function splitArgs(s) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 init_messageHelpers();
-import { promises as fs41 } from "node:fs";
-import path98 from "node:path";
+import { promises as fs42 } from "node:fs";
+import path99 from "node:path";
 
 // src/cli/kraken/workbenchView.ts
 var EMPTY = {
@@ -93230,15 +93814,15 @@ function formatWorkbenchForTerminal(p3) {
 
 // src/cli/slashHandlers/krakenWorkbench.ts
 async function handleKrakenWorkbench(ctx) {
-  const dir = path98.join(ctx.cwd, ".zelari", "radio");
+  const dir = path99.join(ctx.cwd, ".zelari", "radio");
   let latest = null;
   let latestMtime = 0;
   try {
-    const files = await fs41.readdir(dir);
+    const files = await fs42.readdir(dir);
     for (const f of files) {
       if (!f.startsWith("workbench-") || !f.endsWith(".md")) continue;
-      const full = path98.join(dir, f);
-      const stat9 = await fs41.stat(full);
+      const full = path99.join(dir, f);
+      const stat9 = await fs42.stat(full);
       if (stat9.mtimeMs > latestMtime) {
         latestMtime = stat9.mtimeMs;
         latest = full;
@@ -93250,14 +93834,14 @@ async function handleKrakenWorkbench(ctx) {
     appendSystem(ctx.setMessages, "[kraken workbench] no workbench file found (.zelari/radio/workbench-*.md)");
     return;
   }
-  const content = await fs41.readFile(latest, "utf8");
+  const content = await fs42.readFile(latest, "utf8");
   const parsed = parseWorkbench(content);
   const rendered = formatWorkbenchForTerminal(parsed);
   if (!rendered.trim()) {
-    appendSystem(ctx.setMessages, `[kraken workbench] ${path98.basename(latest)}: (no nodes / no events yet)`);
+    appendSystem(ctx.setMessages, `[kraken workbench] ${path99.basename(latest)}: (no nodes / no events yet)`);
     return;
   }
-  appendSystem(ctx.setMessages, `[kraken workbench] ${path98.basename(latest)}:
+  appendSystem(ctx.setMessages, `[kraken workbench] ${path99.basename(latest)}:
 ${rendered}`);
 }
 
@@ -93576,20 +94160,20 @@ ${result.output.split("\n").slice(-8).join("\n")}` : "";
 // src/cli/slashHandlers/promoteMember.ts
 init_messageHelpers();
 init_paths();
-import { promises as fs42 } from "node:fs";
-import path101 from "node:path";
+import { promises as fs43 } from "node:fs";
+import path102 from "node:path";
 async function handlePromoteMember(ctx, memberId) {
   try {
     const { promoteMember: promoteMember2 } = await Promise.resolve().then(() => (init_council(), council_exports));
     const { skill, markdown } = promoteMember2(memberId);
     const skillDir = skillsDir();
-    await fs42.mkdir(skillDir, { recursive: true });
-    const filePath = path101.join(skillDir, `${skill.id}.md`);
-    const previous = await fs42.readFile(filePath, "utf8").catch(() => null);
-    const { createHash: createHash28 } = await import("node:crypto");
-    const sha = (s) => createHash28("sha256").update(s, "utf8").digest("hex");
+    await fs43.mkdir(skillDir, { recursive: true });
+    const filePath = path102.join(skillDir, `${skill.id}.md`);
+    const previous = await fs43.readFile(filePath, "utf8").catch(() => null);
+    const { createHash: createHash29 } = await import("node:crypto");
+    const sha = (s) => createHash29("sha256").update(s, "utf8").digest("hex");
     const lineage = `<!-- lineage: genome=sha256:${sha(markdown)} parent=${previous ? `sha256:${sha(previous)}` : "none"} promotedBy=user promotedAt=${(/* @__PURE__ */ new Date()).toISOString()} -->`;
-    await fs42.writeFile(filePath, `${markdown}
+    await fs43.writeFile(filePath, `${markdown}
 ${lineage}
 `, "utf8");
     appendSystem(
@@ -93609,8 +94193,8 @@ ${lineage}
 
 // src/cli/branchManager.ts
 init_paths();
-import { promises as fs43, existsSync as existsSync65, readFileSync as readFileSync52, writeFileSync as writeFileSync27, mkdirSync as mkdirSync24, statSync as statSync10, rmSync as rmSync5 } from "node:fs";
-import path102 from "node:path";
+import { promises as fs44, existsSync as existsSync65, readFileSync as readFileSync52, writeFileSync as writeFileSync27, mkdirSync as mkdirSync24, statSync as statSync10, rmSync as rmSync5 } from "node:fs";
+import path103 from "node:path";
 var META_FILENAME = "meta.json";
 var SESSIONS_SUBDIR = "sessions";
 function getBranchesBaseDir() {
@@ -93620,13 +94204,13 @@ function getSessionsBaseDir() {
   return sessionsDir();
 }
 function branchPathFor(name, baseDir) {
-  return path102.join(baseDir, name);
+  return path103.join(baseDir, name);
 }
 function metaPathFor(name, baseDir) {
-  return path102.join(baseDir, name, META_FILENAME);
+  return path103.join(baseDir, name, META_FILENAME);
 }
 function sessionsPathFor(name, baseDir) {
-  return path102.join(baseDir, name, SESSIONS_SUBDIR);
+  return path103.join(baseDir, name, SESSIONS_SUBDIR);
 }
 function readBranchMeta(name, baseDir) {
   const metaPath = metaPathFor(name, baseDir);
@@ -93651,13 +94235,13 @@ function readBranchMeta(name, baseDir) {
 }
 function writeBranchMeta(name, baseDir, meta3) {
   const metaPath = metaPathFor(name, baseDir);
-  mkdirSync24(path102.dirname(metaPath), { recursive: true });
+  mkdirSync24(path103.dirname(metaPath), { recursive: true });
   writeFileSync27(metaPath, JSON.stringify(meta3, null, 2), "utf-8");
 }
 async function countSessions(name, baseDir) {
   const sessionsPath = sessionsPathFor(name, baseDir);
   try {
-    const entries = await fs43.readdir(sessionsPath);
+    const entries = await fs44.readdir(sessionsPath);
     return entries.filter((e) => e.endsWith(".jsonl")).length;
   } catch (err) {
     if (err.code === "ENOENT") return 0;
@@ -93702,15 +94286,15 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
   if (branchExists(name, baseDir)) {
     throw new BranchAlreadyExistsError(name);
   }
-  const sourcePath = path102.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
+  const sourcePath = path103.join(sessionsBaseDir, `${fromSessionId}.jsonl`);
   if (!existsSync65(sourcePath)) {
     throw new SessionNotFoundError(`Source session "${fromSessionId}" not found at ${sourcePath}`);
   }
   const branchPath = branchPathFor(name, baseDir);
   const branchSessionsPath = sessionsPathFor(name, baseDir);
   mkdirSync24(branchSessionsPath, { recursive: true });
-  const destPath = path102.join(branchSessionsPath, `${fromSessionId}.jsonl`);
-  await fs43.copyFile(sourcePath, destPath);
+  const destPath = path103.join(branchSessionsPath, `${fromSessionId}.jsonl`);
+  await fs44.copyFile(sourcePath, destPath);
   const meta3 = {
     name,
     createdAt: Date.now(),
@@ -93728,7 +94312,7 @@ async function createBranch(name, fromSessionId, baseDir = getBranchesBaseDir(),
 async function listBranches(baseDir = getBranchesBaseDir()) {
   let entries;
   try {
-    entries = await fs43.readdir(baseDir);
+    entries = await fs44.readdir(baseDir);
   } catch (err) {
     if (err.code === "ENOENT") return [];
     throw err;
@@ -93812,26 +94396,26 @@ async function handleBranchCheckout(ctx, branchName) {
 
 // src/cli/slashHandlers/workspace.ts
 init_messageHelpers();
-import { promises as fs44 } from "node:fs";
-import path103 from "node:path";
+import { promises as fs45 } from "node:fs";
+import path104 from "node:path";
 async function handleWorkspaceShow(ctx, what) {
   try {
-    const zelari = path103.join(process.cwd(), ".zelari");
+    const zelari = path104.join(process.cwd(), ".zelari");
     let content;
     switch (what) {
       case "plan": {
-        const planPath = path103.join(zelari, "plan.md");
+        const planPath = path104.join(zelari, "plan.md");
         try {
-          content = await fs44.readFile(planPath, "utf-8");
+          content = await fs45.readFile(planPath, "utf-8");
         } catch {
           content = "(no plan.md yet \u2014 run a council session first)";
         }
         break;
       }
       case "decisions": {
-        const decisionsDir = path103.join(zelari, "decisions");
+        const decisionsDir = path104.join(zelari, "decisions");
         try {
-          const files = (await fs44.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs45.readdir(decisionsDir)).filter((f) => f.endsWith(".md")).sort();
           if (files.length === 0) {
             content = "(no ADRs yet \u2014 invoke /council to generate some)";
           } else {
@@ -93839,7 +94423,7 @@ async function handleWorkspaceShow(ctx, what) {
 `];
             const { parseFrontmatter: parseFrontmatter3 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
             for (const f of files) {
-              const raw = await fs44.readFile(path103.join(decisionsDir, f), "utf-8");
+              const raw = await fs45.readFile(path104.join(decisionsDir, f), "utf-8");
               const { meta: meta3, body } = parseFrontmatter3(raw);
               const title = meta3.title ?? body.split("\n")[0]?.replace(/^#\s*/, "").trim() ?? f;
               lines.push(`- **${f.replace(/\.md$/, "")}** [${meta3.status ?? "unknown"}] ${title}`);
@@ -93852,27 +94436,27 @@ async function handleWorkspaceShow(ctx, what) {
         break;
       }
       case "risks": {
-        const risksPath = path103.join(zelari, "risks.md");
+        const risksPath = path104.join(zelari, "risks.md");
         try {
-          content = await fs44.readFile(risksPath, "utf-8");
+          content = await fs45.readFile(risksPath, "utf-8");
         } catch {
           content = "(no risks.md yet)";
         }
         break;
       }
       case "agents": {
-        const agentsPath = path103.join(process.cwd(), "AGENTS.MD");
+        const agentsPath = path104.join(process.cwd(), "AGENTS.MD");
         try {
-          content = await fs44.readFile(agentsPath, "utf-8");
+          content = await fs45.readFile(agentsPath, "utf-8");
         } catch {
           content = "(no AGENTS.MD yet at project root \u2014 run `/workspace sync` after a council session)";
         }
         break;
       }
       case "docs": {
-        const docsDir = path103.join(zelari, "docs");
+        const docsDir = path104.join(zelari, "docs");
         try {
-          const files = (await fs44.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
+          const files = (await fs45.readdir(docsDir)).filter((f) => f.endsWith(".md")).sort();
           content = files.length ? `# Docs (${files.length})
 
 ` + files.map((f) => `- ${f}`).join("\n") : "(no docs drafts yet)";
@@ -93912,8 +94496,8 @@ async function handleWorkspaceReset(ctx, force) {
     return;
   }
   try {
-    const target = path103.join(process.cwd(), ".zelari");
-    await fs44.rm(target, { recursive: true, force: true });
+    const target = path104.join(process.cwd(), ".zelari");
+    await fs45.rm(target, { recursive: true, force: true });
     appendSystem(ctx.setMessages, "[workspace] .zelari/ removed");
   } catch (err) {
     appendSystem(ctx.setMessages, `[workspace reset error] ${err instanceof Error ? err.message : String(err)}`);
@@ -93924,13 +94508,13 @@ async function handleWorkspaceReset(ctx, force) {
 init_provider2();
 
 // src/cli/skillHistory.ts
-import { promises as fs45, existsSync as existsSync66, statSync as statSync11, renameSync as renameSync6, appendFileSync as appendFileSync5, mkdirSync as mkdirSync25 } from "node:fs";
+import { promises as fs46, existsSync as existsSync66, statSync as statSync11, renameSync as renameSync6, appendFileSync as appendFileSync5, mkdirSync as mkdirSync25 } from "node:fs";
 init_paths();
 var SKILL_HISTORY_ROTATE_BYTES = 10 * 1024 * 1024;
 async function readSkillHistory(file2) {
   let raw = "";
   try {
-    raw = await fs45.readFile(file2, "utf-8");
+    raw = await fs46.readFile(file2, "utf-8");
   } catch {
     return [];
   }
@@ -95822,8 +96406,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 path126 = 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 = path126 && /^[a-z0-9]/.test(path126) ? path126 : "imported-skill";
+      const path128 = 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 = path128 && /^[a-z0-9]/.test(path128) ? path128 : "imported-skill";
     } catch {
       name = "imported-skill";
     }