zelari-code 1.17.0 → 1.17.1

package/dist/cli/main.bundled.js

@@ -28622,7 +28622,7 @@ function composeProjectContext(input) {
     default: 3e3,
     min: 200
   });
-  const wantDurable = input.includeDurableState ?? (input.mode === "council" || input.mode === "zelari");
+  const wantDurable = input.includeDurableState ?? (process.env.ZELARI_STATE !== "0" && (input.mode === "council" || input.mode === "zelari" || input.mode === "agent"));
   let durableRaw = input.durableState?.trim() ?? "";
   if (!durableRaw && wantDurable) {
     durableRaw = readDurableHeadSync(cwd);
@@ -28712,6 +28712,42 @@ var init_planDetect = __esm({
   }
 });
 
+// src/cli/state/loadDurableContext.ts
+var loadDurableContext_exports = {};
+__export(loadDurableContext_exports, {
+  clearDurableContextCache: () => clearDurableContextCache,
+  loadDurableContext: () => loadDurableContext
+});
+function clearDurableContextCache() {
+  cache = null;
+}
+async function loadDurableContext(projectRoot, opts) {
+  const env = opts?.env ?? process.env;
+  if (!isStateEnabled(env)) return "";
+  const cacheMs = opts?.cacheMs ?? DEFAULT_CACHE_MS;
+  const now = Date.now();
+  if (cache && cache.projectRoot === projectRoot && now - cache.at < cacheMs) {
+    return cache.text;
+  }
+  try {
+    const store = await getStateStore(projectRoot, env);
+    const text = await store.materializeContext(void 0, opts?.maxChars);
+    cache = { text: text || "", at: now, projectRoot };
+    return cache.text;
+  } catch {
+    return "";
+  }
+}
+var DEFAULT_CACHE_MS, cache;
+var init_loadDurableContext = __esm({
+  "src/cli/state/loadDurableContext.ts"() {
+    "use strict";
+    init_fileStateStore();
+    DEFAULT_CACHE_MS = 2e3;
+    cache = null;
+  }
+});
+
 // src/cli/workspace/storage.ts
 var storage_exports = {};
 __export(storage_exports, {
@@ -31539,8 +31575,8 @@ __export(commitHelpers_exports, {
 async function tryStateCommit(args) {
   try {
     const store = args.store ?? await getStateStore(args.projectRoot, args.env);
-    let workspaceCheckpointId;
-    if (args.withCheckpoint && (args.env ?? process.env).ZELARI_CHECKPOINT !== "0") {
+    let workspaceCheckpointId = args.workspaceCheckpointId;
+    if (!workspaceCheckpointId && args.withCheckpoint && (args.env ?? process.env).ZELARI_CHECKPOINT !== "0") {
       const cp = await createCheckpoint(
         args.projectRoot,
         `state ${args.layer ?? args.label}`.slice(0, 80)
@@ -31556,9 +31592,15 @@ async function tryStateCommit(args) {
       verification: args.verification,
       changedPaths: args.changedPaths,
       discoveries: args.discoveries,
+      stablePromptHash: args.stablePromptHash,
       force: args.force
     });
     if (!meta3.id) return { ok: false, error: "noop store", checkpointId: workspaceCheckpointId };
+    try {
+      const { clearDurableContextCache: clearDurableContextCache2 } = await Promise.resolve().then(() => (init_loadDurableContext(), loadDurableContext_exports));
+      clearDurableContextCache2();
+    } catch {
+    }
     return { ok: true, meta: meta3, checkpointId: workspaceCheckpointId };
   } catch (err) {
     return {
@@ -31840,14 +31882,7 @@ async function runZelariMission(userMessage, brief, deps) {
       limit: 8,
       metadataFilter: { projectRoot: deps.projectRoot }
     });
-    let durableBlock = "";
-    try {
-      durableBlock = await stateStore.materializeContext();
-    } catch {
-      durableBlock = "";
-    }
-    const memBlock = formatMemoryHits(hits);
-    const ragContext = [durableBlock, memBlock].filter(Boolean).join("\n\n");
+    const ragContext = formatMemoryHits(hits);
     const promptIter = runMode === "implementation" ? implStep : 1;
     const slicePrompt = buildSlicePrompt(brief, userMessage, runMode, promptIter);
     const implementerRetry = runMode === "implementation" && implStep > 1;
@@ -31919,7 +31954,9 @@ async function runZelariMission(userMessage, brief, deps) {
         sessionId: missionId,
         verification: { ok: hard, ran: result.ran },
         force: !hard,
-        withCheckpoint: hard,
+        // Prefer linking the mission-start checkpoint (no explosion).
+        workspaceCheckpointId: missionCheckpointId,
+        withCheckpoint: hard && !missionCheckpointId,
         discoveries: discoveriesFromOutcome({
           stepId: `${missionId}-${step}`,
           synthesis: result.synthesisText,
@@ -31930,7 +31967,7 @@ async function runZelariMission(userMessage, brief, deps) {
       if (commitRes.ok && commitRes.meta?.id) {
         if (hard) {
           state2.lastGoodCommitId = commitRes.meta.id;
-          if (commitRes.checkpointId) {
+          if (commitRes.checkpointId && !missionCheckpointId) {
             missionCheckpointId = commitRes.checkpointId;
           }
         }
@@ -36673,6 +36710,48 @@ function finalizeStreamingAssistant(setMessages) {
 // src/cli/hooks/useChatTurn.ts
 init_conversationContext();
 
+// src/cli/state/promptCacheStats.ts
+function emptyPromptCacheStats() {
+  return {
+    promptTokens: 0,
+    cachedTokens: 0,
+    premiumTokens: 0,
+    hitRate: 0,
+    estimatedCostUsd: 0,
+    stableBustCount: 0,
+    turns: 0
+  };
+}
+function accumulatePromptCacheStats(prev2, turn) {
+  const promptTokens = prev2.promptTokens + Math.max(0, turn.promptTokens);
+  const cachedTokens = prev2.cachedTokens + Math.max(0, turn.cachedTokens);
+  const premiumDelta = Math.max(0, turn.promptTokens - turn.cachedTokens);
+  const premiumTokens = prev2.premiumTokens + premiumDelta;
+  const hitRate = promptTokens > 0 ? cachedTokens / promptTokens : 0;
+  let stableBustCount = prev2.stableBustCount;
+  let lastStableHash = prev2.lastStableHash;
+  if (turn.stableHash) {
+    if (lastStableHash && lastStableHash !== turn.stableHash) {
+      stableBustCount += 1;
+    }
+    lastStableHash = turn.stableHash;
+  }
+  return {
+    promptTokens,
+    cachedTokens,
+    premiumTokens,
+    hitRate,
+    estimatedCostUsd: prev2.estimatedCostUsd + (turn.costUsd ?? 0),
+    lastStableHash,
+    stableBustCount,
+    turns: prev2.turns + 1
+  };
+}
+function formatCacheStatsLine(stats) {
+  const pct = stats.promptTokens > 0 ? Math.round(stats.hitRate * 100) : 0;
+  return `cache hit ${pct}% \xB7 premium ${stats.premiumTokens} \xB7 cached ${stats.cachedTokens} \xB7 stable busts ${stats.stableBustCount} \xB7 turns ${stats.turns}`;
+}
+
 // src/cli/hooks/chatStats.ts
 function computeSessionStatsDelta(realUsage, userText, assistantContent, model, prev2, opts) {
   const promptTokens = realUsage ? realUsage.promptTokens : Math.ceil(userText.length / 4);
@@ -36680,31 +36759,41 @@ function computeSessionStatsDelta(realUsage, userText, assistantContent, model,
   const cachedPromptTokens = realUsage?.cachedPromptTokens ?? 0;
   const turnCost = calculateCost(model, promptTokens, completionTokens, cachedPromptTokens);
   const contextTokens = realUsage ? realUsage.totalTokens || promptTokens + completionTokens : promptTokens + completionTokens;
-  const nextCached = (prev2.cachedTokens ?? 0) + cachedPromptTokens;
-  const nextPrompt = (prev2.promptTokens ?? 0) + promptTokens;
-  const premiumDelta = Math.max(0, promptTokens - cachedPromptTokens);
-  const nextPremium = (prev2.premiumTokens ?? 0) + premiumDelta;
-  const cacheHitRate = nextPrompt > 0 ? nextCached / nextPrompt : 0;
-  let stableBustCount = prev2.stableBustCount ?? 0;
-  let lastStableHash = prev2.lastStableHash;
-  if (opts?.stableHash) {
-    if (lastStableHash && lastStableHash !== opts.stableHash) {
-      stableBustCount += 1;
-    }
-    lastStableHash = opts.stableHash;
-  }
+  const prevCache = {
+    ...emptyPromptCacheStats(),
+    promptTokens: prev2.promptTokens ?? 0,
+    cachedTokens: prev2.cachedTokens ?? 0,
+    premiumTokens: prev2.premiumTokens ?? 0,
+    hitRate: prev2.cacheHitRate ?? 0,
+    estimatedCostUsd: prev2.totalCostUsd,
+    lastStableHash: prev2.lastStableHash,
+    stableBustCount: prev2.stableBustCount ?? 0,
+    turns: 0
+  };
+  const nextCache = accumulatePromptCacheStats(prevCache, {
+    promptTokens,
+    cachedTokens: cachedPromptTokens,
+    costUsd: turnCost,
+    stableHash: opts?.stableHash
+  });
   return {
     totalTokens: prev2.totalTokens + promptTokens + completionTokens,
     totalCostUsd: prev2.totalCostUsd + turnCost,
-    cachedTokens: nextCached,
+    cachedTokens: nextCache.cachedTokens,
     contextTokens,
-    premiumTokens: nextPremium,
-    cacheHitRate,
-    promptTokens: nextPrompt,
-    lastStableHash,
-    stableBustCount
+    premiumTokens: nextCache.premiumTokens,
+    cacheHitRate: nextCache.hitRate,
+    promptTokens: nextCache.promptTokens,
+    lastStableHash: nextCache.lastStableHash,
+    stableBustCount: nextCache.stableBustCount
   };
 }
+function resolvePromptCacheTtl(env = process.env) {
+  const raw = (env.ZELARI_PROMPT_CACHE_TTL ?? "auto").toLowerCase().trim();
+  if (raw === "1h" || raw === "1hour" || raw === "long") return "1h";
+  if (raw === "5m" || raw === "5min" || raw === "short") return "5m";
+  return "auto";
+}
 
 // src/cli/hooks/useChatTurn.ts
 init_envNumber();
@@ -36901,14 +36990,22 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           const { composeProjectContext: composeProjectContext2 } = await Promise.resolve().then(() => (init_composeContext(), composeContext_exports));
           const { hasWorkspacePlan: hasWorkspacePlan2 } = await Promise.resolve().then(() => (init_planDetect(), planDetect_exports));
           hasPlan = hasWorkspacePlan2(cwd);
+          const { loadDurableContext: loadDurableContext2 } = await Promise.resolve().then(() => (init_loadDurableContext(), loadDurableContext_exports));
+          const durableState = await loadDurableContext2(cwd);
           const composed = composeProjectContext2({
             mode: "agent",
             cwd,
             userMessage: userText,
-            includeLessons: false
+            includeLessons: false,
+            durableState: durableState || void 0,
+            // Pre-loaded async — skip sync fallback double-read.
+            includeDurableState: false
           });
           composedWorkspace = composed.workspaceContext;
           composedInstructions = composed.projectInstructions;
+          if (composed.ragContext) {
+            composedWorkspace = [composedWorkspace, composed.ragContext].filter(Boolean).join("\n\n");
+          }
           for (const w of composed.warnings) {
             appendSystem(setMessages, w, Date.now());
           }
@@ -37514,6 +37611,35 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
   let sliceRan = false;
   let sliceDegraded = false;
   const PROVIDER_ERROR_ABORT_THRESHOLD = 2;
+  let councilCompose = { workspaceContext: formatHistoryForCouncil(4) || "" };
+  try {
+    const { loadDurableContext: loadDurableContext2 } = await Promise.resolve().then(() => (init_loadDurableContext(), loadDurableContext_exports));
+    const durableState = await loadDurableContext2(process.cwd());
+    const composed = composeProjectContext2({
+      mode: overrides.ragContext ? "zelari" : "council",
+      cwd: process.cwd(),
+      userMessage: effectiveText,
+      memoryHits: overrides.ragContext,
+      durableState: durableState || void 0,
+      historySnippet: formatHistoryForCouncil(4) || void 0,
+      includeLessons: true,
+      includeDurableState: false
+    });
+    for (const w of composed.warnings) {
+      appendSystem(setMessages, w, Date.now());
+    }
+    councilCompose = {
+      workspaceContext: composed.workspaceContext,
+      ...composed.ragContext ? { ragContext: composed.ragContext } : {}
+    };
+  } catch {
+    if (overrides.ragContext) {
+      councilCompose = {
+        workspaceContext: formatHistoryForCouncil(4) || "",
+        ragContext: overrides.ragContext
+      };
+    }
+  }
   try {
     for await (const event of dispatchCouncil2(effectiveText, {
       apiKey: envConfig.apiKey,
@@ -37523,33 +37649,8 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il membro riprende dop
       sessionId,
       tools: councilToolRegistry,
       feedbackStore: councilFeedbackStore,
-      // v1.16: unified compose — product truth + draft plan ops + design index
-      // (not full vault). Memory RAG only via overrides.ragContext.
-      // Fail-soft: never block a council run if compose throws in tests/odd cwd.
-      ...(() => {
-        try {
-          const composed = composeProjectContext2({
-            mode: overrides.ragContext ? "zelari" : "council",
-            cwd: process.cwd(),
-            userMessage: effectiveText,
-            memoryHits: overrides.ragContext,
-            historySnippet: formatHistoryForCouncil(4) || void 0,
-            includeLessons: true
-          });
-          for (const w of composed.warnings) {
-            appendSystem(setMessages, w, Date.now());
-          }
-          return {
-            workspaceContext: composed.workspaceContext,
-            ...composed.ragContext ? { ragContext: composed.ragContext } : {}
-          };
-        } catch {
-          return {
-            workspaceContext: formatHistoryForCouncil(4) || "",
-            ...overrides.ragContext ? { ragContext: overrides.ragContext } : {}
-          };
-        }
-      })(),
+      workspaceContext: councilCompose.workspaceContext,
+      ...councilCompose.ragContext ? { ragContext: councilCompose.ragContext } : {},
       maxToolCallsPerTurn: councilMaxToolCalls,
       maxToolLoopIterations: councilMaxToolLoop,
       ...councilMaxToolLoopHard > 0 ? { maxToolLoopHardCap: councilMaxToolLoopHard } : {},
@@ -38848,20 +38949,28 @@ async function handleStateStatus(ctx) {
   if (!head) {
     appendSystem(
       ctx.setMessages,
-      "[state] no durable commits yet. Run a verified Zelari slice or `/state commit [label]`."
+      "[state] no durable commits yet. Run a verified Zelari slice or `/state commit [label]`.\n  Kill switch: ZELARI_STATE=0 disables the store."
     );
     return;
   }
-  const recent = await store.list(5);
+  const discoveries = await store.loadDiscoveries(head.id);
+  const reusable = discoveries.filter((d) => d.reusable).length;
+  const recent = await store.list(8);
   const lines = recent.map((c, i) => {
-    const ver = c.verification.ran ? c.verification.ok ? "ok" : "fail" : "n/a";
-    return `  ${i === 0 ? "\u2192" : " "} ${c.id}  ${ago2(c.createdAt)}  ${c.label}  ver=${ver}` + (c.layer ? `  [${c.layer}]` : "");
+    const ver2 = c.verification.ran ? c.verification.ok ? "ok" : "fail" : "n/a";
+    return `  ${i === 0 ? "\u2192" : " "} ${c.id}  ${ago2(c.createdAt)}  ${c.label}  ver=${ver2}` + (c.layer ? `  [${c.layer}]` : "") + (c.stablePromptHash ? `  hash=${c.stablePromptHash.slice(0, 8)}` : "");
   });
+  const ver = head.verification;
   appendSystem(
     ctx.setMessages,
-    `[state] HEAD ${head.id} \xB7 ${head.discoveryCount} discoveries \xB7 mode ${head.mode}
-` + (head.workspaceCheckpointId ? `linked checkpoint: ${head.workspaceCheckpointId}
-` : "") + lines.join("\n")
+    `[state] HEAD ${head.id} \xB7 mode ${head.mode}` + (head.layer ? ` \xB7 layer ${head.layer}` : "") + `
+  discoveries: ${head.discoveryCount} total, ${reusable} reusable
+  verification: ran=${ver.ran} ok=${ver.ok}` + (ver.reportPath ? `  report=${ver.reportPath}` : "") + (head.parentId ? `
+  parent: ${head.parentId}` : "") + (head.workspaceCheckpointId ? `
+  workspaceCheckpoint: ${head.workspaceCheckpointId}` : "") + (head.stablePromptHash ? `
+  stablePromptHash: ${head.stablePromptHash}` : "") + `
+  created: ${ago2(head.createdAt)}
+` + lines.join("\n")
   );
 }
 async function handleStateCommit(ctx, label) {
@@ -38916,19 +39025,16 @@ async function handleStateRestore(ctx, id, opts) {
   appendSystem(ctx.setMessages, res.message);
 }
 
-// src/cli/state/promptCacheStats.ts
-function formatCacheStatsLine(stats) {
-  const pct = stats.promptTokens > 0 ? Math.round(stats.hitRate * 100) : 0;
-  return `cache hit ${pct}% \xB7 premium ${stats.premiumTokens} \xB7 cached ${stats.cachedTokens} \xB7 stable busts ${stats.stableBustCount} \xB7 turns ${stats.turns}`;
-}
-
 // src/cli/slashHandlers/cache.ts
 function handleCacheStats(ctx) {
+  const ttl = resolvePromptCacheTtl();
   const s = ctx.sessionStats;
   if (!s || !(s.promptTokens || s.cachedTokens || s.totalTokens)) {
     appendSystem(
       ctx.setMessages,
-      "[cache] no session usage yet. Complete a model turn to see hit rate.\n  Tip: stable prompt (identity+tools) should stay byte-stable; workspace/plan is volatile.\n  Env: ZELARI_PROMPT_CACHE_TTL=1h|5m|auto (Anthropic path when available)."
+      `[cache] no session usage yet. Complete a model turn to see hit rate.
+  Tip: stable prompt (identity+tools) should stay byte-stable; workspace/plan is volatile.
+  ZELARI_PROMPT_CACHE_TTL=${ttl} (OpenAI-compat: automatic prefix cache; TTL is a preference for future Anthropic markers).`
     );
     return;
   }
@@ -38938,15 +39044,18 @@ function handleCacheStats(ctx) {
     premiumTokens: s.premiumTokens ?? Math.max(0, (s.promptTokens ?? 0) - (s.cachedTokens ?? 0)),
     hitRate: s.cacheHitRate ?? 0,
     estimatedCostUsd: s.totalCostUsd ?? 0,
+    lastStableHash: s.lastStableHash,
     stableBustCount: s.stableBustCount ?? 0,
     turns: 0
   };
   const pct = stats.promptTokens > 0 ? Math.round(stats.hitRate * 100) : 0;
+  const hashShort = stats.lastStableHash ? stats.lastStableHash.slice(0, 8) : "\u2014";
   appendSystem(
     ctx.setMessages,
     `[cache] ${formatCacheStatsLine(stats)}
-  hit rate: ${pct}%  \xB7 cost ~$${stats.estimatedCostUsd.toFixed(4)}
-  (OpenAI-compat: automatic prefix cache; keep system stable prefix free of plan/memory churn.)`
+  hit rate: ${pct}%  \xB7 premium ${stats.premiumTokens}  \xB7 cached ${stats.cachedTokens}
+  cost ~$${stats.estimatedCostUsd.toFixed(4)}  \xB7 stable hash ${hashShort}  \xB7 busts ${stats.stableBustCount}
+  TTL pref: ${ttl} (OpenAI-compat path uses automatic prefix caching; keep stable prefix free of plan/memory churn.)`
   );
 }
 
@@ -40702,7 +40811,8 @@ function App() {
     premiumTokens: 0,
     cacheHitRate: 0,
     promptTokens: 0,
-    stableBustCount: 0
+    stableBustCount: 0,
+    lastStableHash: void 0
   });
   const [clearEpoch, setClearEpoch] = useState8(0);
   const [mode, setMode] = useState8("agent");
@@ -41816,11 +41926,16 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       ].join("\n")
     };
     const { composeProjectContext: composeProjectContext2 } = await Promise.resolve().then(() => (init_composeContext(), composeContext_exports));
+    const { loadDurableContext: loadDurableContext2 } = await Promise.resolve().then(() => (init_loadDurableContext(), loadDurableContext_exports));
+    const cwd = process.cwd();
+    const durableState = await loadDurableContext2(cwd);
     const composed = composeProjectContext2({
       mode: "agent",
-      cwd: process.cwd(),
+      cwd,
       userMessage: opts.task,
-      includeLessons: false
+      includeLessons: false,
+      durableState: durableState || void 0,
+      includeDurableState: false
     });
     let sshBlock = "";
     try {
@@ -41829,6 +41944,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     } catch {
     }
     const rolePrompt = [headlessRole.systemPrompt, sshBlock].filter(Boolean).join("\n\n");
+    const agentWorkspace = [composed.workspaceContext, composed.ragContext].filter(Boolean).join("\n\n");
     systemPrompt = buildSystemPrompt(
       { ...headlessRole, systemPrompt: rolePrompt },
       {
@@ -41836,7 +41952,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
         toolNames,
         mode: "agent",
         projectInstructions: composed.projectInstructions || void 0,
-        workspaceContext: composed.workspaceContext || void 0,
+        workspaceContext: agentWorkspace || void 0,
         // Plan lives in workspaceContext as draft ops — never as RAG.
         ragContext: void 0,
         aiConfig: {
@@ -42104,11 +42220,16 @@ async function runHeadlessCouncil(opts, provider, model, providerStream) {
   let currentAssistantText = "";
   try {
     const { composeProjectContext: composeProjectContext2 } = await Promise.resolve().then(() => (init_composeContext(), composeContext_exports));
+    const { loadDurableContext: loadDurableContext2 } = await Promise.resolve().then(() => (init_loadDurableContext(), loadDurableContext_exports));
+    const cwd = process.cwd();
+    const durableState = await loadDurableContext2(cwd);
     const composed = composeProjectContext2({
       mode: "council",
-      cwd: process.cwd(),
+      cwd,
       userMessage: opts.task,
-      includeLessons: true
+      includeLessons: true,
+      durableState: durableState || void 0,
+      includeDurableState: false
     });
     for await (const event of dispatchCouncil2(effectiveTask, {
       apiKey: "REDACTED",
@@ -42249,13 +42370,17 @@ ${ragContext}` : slicePrompt;
         let membersCompleted = 0;
         const scrub = createStreamScrubber();
         const { composeProjectContext: composeProjectContext2 } = await Promise.resolve().then(() => (init_composeContext(), composeContext_exports));
+        const { loadDurableContext: loadDurableContext2 } = await Promise.resolve().then(() => (init_loadDurableContext(), loadDurableContext_exports));
         const memOnly = ragContext?.trim() ? ragContext : void 0;
+        const durableState = await loadDurableContext2(projectRoot);
         const composed = composeProjectContext2({
           mode: "zelari",
           cwd: projectRoot,
           userMessage: slicePrompt,
           memoryHits: memOnly,
-          includeLessons: true
+          durableState: durableState || void 0,
+          includeLessons: true,
+          includeDurableState: false
         });
         for await (const event of dispatchCouncil2(fullPrompt, {
           apiKey: "REDACTED",