zelari-code 2.8.0 → 2.9.1

package/dist/cli/main.bundled.js

@@ -22068,7 +22068,7 @@ function extractToolObjects(text) {
   }
   return out;
 }
-var AgentHarness, DOOM_LOOP_THRESHOLD;
+var BUILD_LIVENESS_RECOVERY_PROMPT, AgentHarness, DOOM_LOOP_THRESHOLD;
 var init_AgentHarness = __esm({
   "packages/core/dist/core/AgentHarness.js"() {
     "use strict";
@@ -22079,6 +22079,7 @@ var init_AgentHarness = __esm({
     init_requestSnapshot();
     init_textLoopDetect();
     init_textLoopDetect();
+    BUILD_LIVENESS_RECOVERY_PROMPT = "[build-liveness] The requested task requires an on-disk implementation, but no successful project mutation has occurred yet. Continue working. Inspect only as needed, then make the required change with an available mutating tool. Do not merely describe a patch or claim completion.";
     AgentHarness = class {
       config;
       eventBus;
@@ -22115,6 +22116,13 @@ var init_AgentHarness = __esm({
       growth = emptyContextGrowthStats();
       /** Ephemeral per-run context; never appended to `config.messages`. */
       activeMemoryContext = "";
+      buildProgress = {
+        toolCalls: 0,
+        mutationsAttempted: 0,
+        mutationsSucceeded: 0,
+        verificationCalls: 0,
+        recoveries: 0
+      };
       constructor(config2) {
         this.config = config2;
         this.eventBus = config2.eventBus;
@@ -22145,6 +22153,33 @@ var init_AgentHarness = __esm({
       getMessages() {
         return this.config.messages;
       }
+      /** Immutable snapshot of host-observed build progress for this run. */
+      getBuildProgress() {
+        return { ...this.buildProgress };
+      }
+      toolPermissions(toolName) {
+        return this.config.toolRegistry?.get(toolName)?.permissions ?? [];
+      }
+      isMutationTool(toolName, args) {
+        const permissions = this.toolPermissions(toolName);
+        if (!permissions.includes("write"))
+          return false;
+        if (args.dryRun === true)
+          return false;
+        return classifyToolConcurrency({
+          toolName,
+          args,
+          permissions,
+          registered: Boolean(this.config.toolRegistry?.get(toolName))
+        }) === "exclusive";
+      }
+      recordSuccessfulTool(toolName, args) {
+        const permissions = this.toolPermissions(toolName);
+        if (this.isMutationTool(toolName, args))
+          this.buildProgress.mutationsSucceeded += 1;
+        if (permissions.includes("execute"))
+          this.buildProgress.verificationCalls += 1;
+      }
       /**
        * Member identity fields (memberId + memberName) to merge into every
        * event payload. Returns an empty object when the run is a direct
@@ -22386,6 +22421,13 @@ ${shared2.content}`,
         this.toolCallCounts = /* @__PURE__ */ new Map();
         this.textToolReentries = 0;
         this.growth = emptyContextGrowthStats();
+        this.buildProgress = {
+          toolCalls: 0,
+          mutationsAttempted: 0,
+          mutationsSucceeded: 0,
+          verificationCalls: 0,
+          recoveries: 0
+        };
         const memoryWarning = await this.prepareMemoryContext();
         const startEvent = createBrainEvent("agent_start", this.sessionId, {
           model: this.config.model,
@@ -22410,7 +22452,11 @@ ${shared2.content}`,
         this.emit(initialMsgStart);
         yield initialMsgStart;
         let initialTurnLength = 0;
-        const initialFinishRef = { value: "stop" };
+        const initialFinishRef = {
+          value: "stop",
+          clarificationRequested: false,
+          providerError: false
+        };
         const initialUsageRef = { value: null };
         for await (const ev of this.runSingleTurn(initialMessageId, initialFinishRef, initialUsageRef)) {
           if (ev.type === "message_delta") {
@@ -22437,16 +22483,51 @@ ${shared2.content}`,
         const hardCap = this.maxToolLoopHardCap;
         let extensions = 0;
         const maxExtensions = 8;
-        while (!this.cancelled && !hadError && toolLoopTurns < softCap && initialFinishRef.value === "tool_calls") {
+        const maxBuildRecoveries = Math.max(0, Math.min(10, this.config.buildLiveness?.maxRecoveries ?? 2));
+        const planBuildRecovery = (turn) => {
+          if (!this.config.buildLiveness?.mutationRequired)
+            return null;
+          if (this.buildProgress.mutationsSucceeded > 0)
+            return null;
+          if (turn.value !== "stop" || turn.clarificationRequested || turn.providerError)
+            return null;
+          if (this.buildProgress.recoveries >= maxBuildRecoveries)
+            return null;
+          this.buildProgress.recoveries += 1;
+          this.config.messages.push({ role: "user", content: BUILD_LIVENESS_RECOVERY_PROMPT });
+          return {
+            purpose: "build-recovery",
+            toolChoice: "required",
+            recoveryAttempt: this.buildProgress.recoveries
+          };
+        };
+        let lastTurnState = initialFinishRef;
+        let recoveryGeneration = planBuildRecovery(initialFinishRef);
+        while (!this.cancelled && !hadError && toolLoopTurns < hardCap && (toolLoopTurns < softCap || recoveryGeneration !== null) && (initialFinishRef.value === "tool_calls" || recoveryGeneration !== null)) {
           toolLoopTurns++;
+          if (recoveryGeneration) {
+            const recoveryEvent = createBrainEvent("error", this.sessionId, {
+              severity: "recoverable",
+              message: `BUILD liveness recovery ${recoveryGeneration.recoveryAttempt}/${maxBuildRecoveries}: no successful mutation observed; continuing instead of completing.`,
+              code: "build_liveness_recovery"
+            });
+            this.emit(recoveryEvent);
+            yield recoveryEvent;
+          }
           const turnMessageId = crypto.randomUUID();
           const msgStart = createBrainEvent("message_start", this.sessionId, { messageId: turnMessageId, role: "assistant", ...this.memberFields() });
           this.emit(msgStart);
           yield msgStart;
           let turnLength = 0;
-          const turnFinishRef = { value: "stop" };
+          const turnFinishRef = {
+            value: "stop",
+            clarificationRequested: false,
+            providerError: false
+          };
           const turnUsageRef = { value: null };
-          for await (const ev of this.runSingleTurn(turnMessageId, turnFinishRef, turnUsageRef)) {
+          const generation = recoveryGeneration ?? void 0;
+          recoveryGeneration = null;
+          for await (const ev of this.runSingleTurn(turnMessageId, turnFinishRef, turnUsageRef, generation)) {
             if (ev.type === "message_delta") {
               turnLength += ev.delta.length;
             } else if (ev.type === "error") {
@@ -22466,6 +22547,10 @@ ${shared2.content}`,
           this.emit(msgEnd);
           yield msgEnd;
           initialFinishRef.value = turnFinishRef.value;
+          initialFinishRef.clarificationRequested = turnFinishRef.clarificationRequested;
+          initialFinishRef.providerError = turnFinishRef.providerError;
+          lastTurnState = turnFinishRef;
+          recoveryGeneration = planBuildRecovery(turnFinishRef);
           if (hadError || this.cancelled)
             break;
           if (initialFinishRef.value === "tool_calls" && toolLoopTurns >= softCap && toolLoopTurns < hardCap && extensions < maxExtensions) {
@@ -22489,10 +22574,23 @@ ${shared2.content}`,
         if (!this.cancelled && !hadError && initialFinishRef.value === "tool_calls" && hitHardCap) {
           yield* this.runFinalAnswerTurn();
         }
+        if (!this.cancelled && !hadError && this.config.buildLiveness?.mutationRequired && this.buildProgress.mutationsSucceeded === 0 && !lastTurnState.clarificationRequested) {
+          hadError = true;
+          const providerFailed = lastTurnState.providerError;
+          const stalled = createBrainEvent("error", this.sessionId, {
+            severity: "fatal",
+            message: providerFailed ? "BUILD provider call failed before any successful on-disk mutation was observed." : `BUILD stalled after ${this.buildProgress.recoveries} recovery turn(s): the task required an on-disk mutation, but no successful mutation was observed.`,
+            code: providerFailed ? "build_liveness_provider_error" : "build_liveness_stalled"
+          });
+          this.emit(stalled);
+          yield stalled;
+        }
         let turns = 0;
         while (turns < this.maxQueuedIterations) {
           if (this.cancelled)
             break;
+          if (hadError)
+            break;
           if (this.queue.length === 0)
             break;
           const queuedPrompt = this.dequeueNext();
@@ -22508,7 +22606,11 @@ ${shared2.content}`,
           this.emit(msgStart);
           yield msgStart;
           let turnLength = 0;
-          const turnFinishRef = { value: "stop" };
+          const turnFinishRef = {
+            value: "stop",
+            clarificationRequested: false,
+            providerError: false
+          };
           const turnUsageRef = { value: null };
           for await (const ev of this.runSingleTurn(turnMessageId, turnFinishRef, turnUsageRef)) {
             if (ev.type === "message_delta") {
@@ -22570,17 +22672,26 @@ ${shared2.content}`,
       }
       /** Build a provider-only view with memory after the stable system prefix. */
       messagesForProvider() {
-        if (!this.activeMemoryContext)
-          return this.config.messages;
+        let messages = this.config.messages;
         let prefixEnd = 0;
-        while (prefixEnd < this.config.messages.length && this.config.messages[prefixEnd]?.role === "system") {
-          prefixEnd += 1;
+        if (this.activeMemoryContext) {
+          while (prefixEnd < messages.length && messages[prefixEnd]?.role === "system") {
+            prefixEnd += 1;
+          }
+          messages = [
+            ...messages.slice(0, prefixEnd),
+            { role: "system", content: this.activeMemoryContext },
+            ...messages.slice(prefixEnd)
+          ];
+        }
+        if (!this.config.requestTail)
+          return messages;
+        try {
+          const tail2 = this.config.requestTail();
+          return tail2.length > 0 ? [...messages, ...tail2] : messages;
+        } catch {
+          return messages;
         }
-        return [
-          ...this.config.messages.slice(0, prefixEnd),
-          { role: "system", content: this.activeMemoryContext },
-          ...this.config.messages.slice(prefixEnd)
-        ];
       }
       /**
        * v1.36.0: capture a deterministic snapshot of the routed request just
@@ -22614,17 +22725,19 @@ ${shared2.content}`,
        * Extracted from the original monolithic `run()` body to enable
        * the queue-draining loop in Task 18.1.
        */
-      async *runSingleTurn(messageId, finishRef, usageRef) {
+      async *runSingleTurn(messageId, finishRef, usageRef, generation) {
         try {
           const requestMessages = this.messagesForProvider();
-          this.emitSnapshot(this.config.tools, void 0, requestMessages);
+          this.emitSnapshot(this.config.tools, generation, requestMessages);
           recordRequest(this.growth, requestMessages);
           const stream = this.config.providerStream({
             messages: requestMessages,
             model: this.config.model,
             provider: this.config.provider,
             tools: this.config.tools,
-            signal: this.activeController?.signal
+            signal: this.activeController?.signal,
+            conversationId: this.sessionId,
+            generation
           });
           let toolCallsThisTurn = 0;
           const maxToolCalls = this.config.maxToolCallsPerTurn;
@@ -22690,6 +22803,10 @@ ${shared2.content}`,
               yield thinkEvent;
             } else if (delta.kind === "tool_call") {
               toolCallsThisTurn++;
+              this.buildProgress.toolCalls += 1;
+              if (this.isMutationTool(delta.toolName, delta.args)) {
+                this.buildProgress.mutationsAttempted += 1;
+              }
               turnToolCalls.push({ id: delta.toolCallId, name: delta.toolName, args: delta.args });
               const toolStartEvent = createBrainEvent("tool_execution_start", this.sessionId, {
                 toolCallId: delta.toolCallId,
@@ -22743,11 +22860,18 @@ ${cached2}`
                     this.toolCallCache.set(item.cacheKey, item.content);
                   }
                 }
+                for (let i = 0; i < executed.length; i++) {
+                  const item = executed[i];
+                  const pending = pendingNativeTools[i];
+                  if (!item.isError)
+                    this.recordSuccessfulTool(pending.toolName, pending.args);
+                }
                 pendingNativeTools.length = 0;
               }
               const clarificationPause = /---QUESTION---/.test(turnText) && /"choices"\s*:\s*\[/.test(turnText);
               if (clarificationPause) {
                 finishRef.value = "stop";
+                finishRef.clarificationRequested = true;
               }
               const textTools = clarificationPause ? [] : parseTextToolCalls(turnText);
               const toolsToRun = textTools.filter((tt) => {
@@ -22770,6 +22894,10 @@ ${cached2}`
                   if (typeof maxToolCalls === "number" && toolCallsThisTurn + 1 > maxToolCalls)
                     break;
                   toolCallsThisTurn++;
+                  this.buildProgress.toolCalls += 1;
+                  if (this.isMutationTool(tt.name, tt.args)) {
+                    this.buildProgress.mutationsAttempted += 1;
+                  }
                   const toolCallId = `text-${crypto.randomUUID().slice(0, 8)}`;
                   turnToolCalls.push({ id: toolCallId, name: tt.name, args: tt.args });
                   const startEv = createBrainEvent("tool_execution_start", this.sessionId, {
@@ -22831,6 +22959,8 @@ ${cached2}`
                   this.emit(endEv);
                   yield endEv;
                   turnToolResults.push({ toolCallId, content: resultStr });
+                  if (!isError)
+                    this.recordSuccessfulTool(tt.name, tt.args);
                   executedAny = true;
                 }
                 if (executedAny) {
@@ -22868,6 +22998,7 @@ ${cached2}`
               }
               break;
             } else if (delta.kind === "error") {
+              finishRef.providerError = true;
               const errEvent = createBrainEvent("error", this.sessionId, {
                 severity: "recoverable",
                 message: delta.message
@@ -22880,6 +23011,7 @@ ${cached2}`
             }
           }
         } catch (err) {
+          finishRef.providerError = true;
           const errorMessage = err instanceof Error ? err.message : String(err);
           const errEvent = createBrainEvent("error", this.sessionId, {
             severity: "recoverable",
@@ -22924,7 +23056,11 @@ ${cached2}`
           content: "[system] Hard tool-iteration ceiling reached. Stop calling tools and give a clear status: what is DONE, what remains, and the exact next steps. Use what you already gathered. Do not apologize for the tools."
         });
         let totalLength = 0;
-        const finishRef = { value: "stop" };
+        const finishRef = {
+          value: "stop",
+          clarificationRequested: false,
+          providerError: false
+        };
         const usageRef = { value: null };
         const requestMessages = this.messagesForProvider();
         recordRequest(this.growth, requestMessages);
@@ -22935,7 +23071,8 @@ ${cached2}`
             model: this.config.model,
             provider: this.config.provider,
             tools: [],
-            signal: this.activeController?.signal
+            signal: this.activeController?.signal,
+            conversationId: this.sessionId
           });
           for await (const delta of stream) {
             if (this.cancelled)
@@ -23506,6 +23643,7 @@ var init_hooks = __esm({
 var harness_exports = {};
 __export(harness_exports, {
   AgentHarness: () => AgentHarness,
+  BUILD_LIVENESS_RECOVERY_PROMPT: () => BUILD_LIVENESS_RECOVERY_PROMPT,
   DOOM_LOOP_THRESHOLD: () => DOOM_LOOP_THRESHOLD,
   LifecycleHookRunner: () => LifecycleHookRunner,
   SessionJsonlWriter: () => SessionJsonlWriter,
@@ -29771,8 +29909,8 @@ var init_types8 = __esm({
       // observation, digest). Not model-surface. Schema review per ADR-0021.
       "verification.evidence",
       // 2.6 Track B (resource-aware execution, doc §9-§12): host-owned resource
-      // state. `resource.snapshot` is model-surface with LATEST-ONLY projection
-      // (doc §10.2 — see modelSurface.ts); limit/reserve events are state-only.
+      // state. `resource.snapshot` is rendered only as a volatile request tail;
+      // it never enters the persistent model-history projection.
       "resource.epoch_started",
       "resource.snapshot",
       "resource.limit_reached",
@@ -30206,13 +30344,6 @@ function deriveMessages(events, options = {}) {
           seq: e.seq
         });
         break;
-      case "resource.snapshot":
-        messages.push({
-          role: "system",
-          content: formatResourceSnapshot(d),
-          seq: e.seq
-        });
-        break;
     }
   }
   pushDueCheckpoints(Number.POSITIVE_INFINITY);
@@ -30239,7 +30370,7 @@ function pairToolCalls(events) {
   }
   return ordered;
 }
-var MODEL_SURFACE_KINDS, LATEST_ONLY_SURFACE_KINDS;
+var MODEL_SURFACE_KINDS, EPHEMERAL_TAIL_EVENT_KINDS, LATEST_ONLY_SURFACE_KINDS;
 var init_modelSurface = __esm({
   "packages/core/dist/session/modelSurface.js"() {
     "use strict";
@@ -30249,11 +30380,12 @@ var init_modelSurface = __esm({
       "assistant.message",
       "tool.call",
       "tool.result",
-      "session.compacted",
-      // 2.6: budget awareness for the model (latest-only projection below).
+      "session.compacted"
+    ]);
+    EPHEMERAL_TAIL_EVENT_KINDS = /* @__PURE__ */ new Set([
       "resource.snapshot"
     ]);
-    LATEST_ONLY_SURFACE_KINDS = /* @__PURE__ */ new Set(["resource.snapshot"]);
+    LATEST_ONLY_SURFACE_KINDS = /* @__PURE__ */ new Set();
   }
 });
 
@@ -33263,6 +33395,7 @@ __export(dist_exports, {
   AgentHarness: () => AgentHarness,
   BENNETTS_RAZOR: () => BENNETTS_RAZOR,
   BENNETTS_RAZOR_SHORT: () => BENNETTS_RAZOR_SHORT,
+  BUILD_LIVENESS_RECOVERY_PROMPT: () => BUILD_LIVENESS_RECOVERY_PROMPT,
   BUILT_IN_PROFILES: () => BUILT_IN_PROFILES,
   BonConfigSchema: () => BonConfigSchema,
   BudgetPressureSchema: () => BudgetPressureSchema,
@@ -33293,6 +33426,7 @@ __export(dist_exports, {
   DefaultMemorySanitizer: () => DefaultMemorySanitizer,
   DefaultMemoryService: () => DefaultMemoryService,
   DeterministicCheckSchema: () => DeterministicCheckSchema,
+  EPHEMERAL_TAIL_EVENT_KINDS: () => EPHEMERAL_TAIL_EVENT_KINDS,
   EVENT_BACKED_EVIDENCE_TIERS: () => EVENT_BACKED_EVIDENCE_TIERS,
   EXPERIMENTAL_FLAGS: () => EXPERIMENTAL_FLAGS,
   EventBus: () => EventBus,
@@ -34875,7 +35009,7 @@ var init_sessionSpine = __esm({
           data: { ...snapshot }
         }).then(() => void 0);
       }
-      /** Latest emitted resource snapshot (the model-visible one), or null. */
+      /** Latest emitted resource snapshot (available for request-tail injection). */
       latestResourceSnapshot() {
         return this.budgetRuntime?.latestEmitted() ?? null;
       }
@@ -36968,6 +37102,10 @@ async function runTentacle(opts) {
     tools: sub.tools,
     toolRegistry: sub.registry,
     providerStream: sub.providerStream,
+    buildLiveness: {
+      mutationRequired: agent === "general",
+      maxRecoveries: 2
+    },
     cwd: runCwd,
     maxToolCallsPerTurn: maxToolCalls,
     maxToolLoopIterations: Math.max(12, maxToolCalls + 4),
@@ -40475,44 +40613,218 @@ var init_semantic2 = __esm({
 });
 
 // src/cli/provider/capabilities.ts
-function resolveHarnessProfile(model) {
-  if (model && DEEPSEEK_V4_RE.test(model)) return "deepseek-v4";
+function frozenProfile(input) {
+  if (input.reasoning.levels) Object.freeze(input.reasoning.levels);
+  Object.freeze(input.reasoning);
+  Object.freeze(input.promptCache);
+  Object.freeze(input.toolCalling);
+  Object.freeze(input.buildRecovery);
+  Object.freeze(input.wire);
+  Object.freeze(input.sampling);
+  Object.freeze(input.compaction);
+  return Object.freeze(input);
+}
+function resolveHarnessProfile(model, providerId) {
+  const provider = providerId?.trim().toLowerCase();
+  if (provider === "deepseek") return "deepseek-v4";
+  if (provider === "grok") return "grok";
+  if (provider === "minimax") return "minimax";
+  if (provider === "glm") return "glm";
+  if (model && DEEPSEEK_RE.test(model)) return "deepseek-v4";
+  if (model && GROK_RE.test(model)) return "grok";
+  if (model && MINIMAX_RE.test(model)) return "minimax";
+  if (model && GLM_RE.test(model)) return "glm";
   return "default";
 }
-function capabilitiesFor(model) {
-  return resolveHarnessProfile(model) === "deepseek-v4" ? DEEPSEEK_V4_CAPS : DEFAULT_CAPS;
+function capabilitiesFor(model, providerId) {
+  switch (resolveHarnessProfile(model, providerId)) {
+    case "deepseek-v4":
+      return DEEPSEEK_V4_CAPS;
+    case "grok":
+      return GROK_CAPS;
+    case "minimax":
+      return model && MINIMAX_M3_RE.test(model) ? MINIMAX_M3_CAPS : MINIMAX_M2_CAPS;
+    case "glm":
+      return GLM_CAPS;
+    default:
+      return DEFAULT_CAPS;
+  }
 }
-var DEFAULT_CAPS, DEEPSEEK_V4_CAPS, DEEPSEEK_V4_RE;
+var SHARED_COMPACTION, DEFAULT_CAPS, DEEPSEEK_V4_CAPS, GROK_CAPS, MINIMAX_M3_CAPS, MINIMAX_M2_CAPS, GLM_CAPS, DEEPSEEK_RE, GROK_RE, MINIMAX_RE, MINIMAX_M3_RE, GLM_RE;
 var init_capabilities = __esm({
   "src/cli/provider/capabilities.ts"() {
     "use strict";
-    DEFAULT_CAPS = Object.freeze({
+    SHARED_COMPACTION = { warnAt: 0.7, compactAt: 0.85, hardAt: 0.95 };
+    DEFAULT_CAPS = frozenProfile({
       contextWindow: 4e5,
-      reasoning: Object.freeze({
-        supported: true,
-        levels: Object.freeze(["low", "medium", "high"]),
-        replayReasoning: true
-      }),
-      promptCache: Object.freeze({ supported: true, pricedCacheRead: false }),
-      toolCalling: Object.freeze({ parallel: true }),
-      sampling: Object.freeze({ temperature: 0.7 }),
-      compaction: Object.freeze({ warnAt: 0.7, compactAt: 0.85, hardAt: 0.95 }),
+      reasoning: { supported: true, levels: ["low", "medium", "high"], replayReasoning: true },
+      promptCache: { supported: true, pricedCacheRead: false },
+      toolCalling: { parallel: true },
+      buildRecovery: { forceToolChoice: false, maxForcedTurns: 0 },
+      wire: {
+        grokRequestHeaders: false,
+        omitAutoToolChoice: false,
+        toolCallDeltasResetIdle: false,
+        retriesBeforeOutput: 0,
+        strictSseJson: false
+      },
+      sampling: { temperature: 0.7 },
+      compaction: { ...SHARED_COMPACTION },
       profile: "default"
     });
-    DEEPSEEK_V4_CAPS = Object.freeze({
+    DEEPSEEK_V4_CAPS = frozenProfile({
       contextWindow: 1e6,
-      reasoning: Object.freeze({
-        supported: true,
-        levels: Object.freeze(["high", "max"]),
-        replayReasoning: true
-      }),
-      promptCache: Object.freeze({ supported: true, pricedCacheRead: true }),
-      toolCalling: Object.freeze({ parallel: true }),
-      sampling: Object.freeze({ temperature: 0.7 }),
-      compaction: Object.freeze({ warnAt: 0.7, compactAt: 0.85, hardAt: 0.95 }),
+      reasoning: { supported: true, levels: ["high", "max"], replayReasoning: true },
+      promptCache: { supported: true, pricedCacheRead: true },
+      toolCalling: { parallel: true },
+      buildRecovery: { forceToolChoice: false, maxForcedTurns: 0 },
+      wire: {
+        grokRequestHeaders: false,
+        omitAutoToolChoice: false,
+        toolCallDeltasResetIdle: false,
+        retriesBeforeOutput: 0,
+        strictSseJson: false
+      },
+      sampling: { temperature: 0.7 },
+      compaction: { ...SHARED_COMPACTION },
       profile: "deepseek-v4"
     });
-    DEEPSEEK_V4_RE = /^deepseek-v4(\.|-|$)/i;
+    GROK_CAPS = frozenProfile({
+      contextWindow: 5e5,
+      reasoning: {
+        supported: true,
+        levels: ["low", "medium", "high", "xhigh"],
+        replayReasoning: false
+      },
+      promptCache: {
+        supported: true,
+        pricedCacheRead: true,
+        conversationAffinityHeader: "x-grok-conv-id"
+      },
+      toolCalling: { parallel: true },
+      buildRecovery: { forceToolChoice: true, maxForcedTurns: 1 },
+      wire: {
+        grokRequestHeaders: true,
+        omitAutoToolChoice: true,
+        toolCallDeltasResetIdle: true,
+        retriesBeforeOutput: 1,
+        strictSseJson: true
+      },
+      sampling: { temperature: 0.7 },
+      compaction: { ...SHARED_COMPACTION },
+      profile: "grok"
+    });
+    MINIMAX_M3_CAPS = frozenProfile({
+      contextWindow: 1e6,
+      reasoning: { supported: true, replayReasoning: true },
+      promptCache: { supported: false, pricedCacheRead: false },
+      toolCalling: { parallel: true },
+      buildRecovery: { forceToolChoice: false, maxForcedTurns: 0 },
+      wire: {
+        grokRequestHeaders: false,
+        omitAutoToolChoice: false,
+        toolCallDeltasResetIdle: false,
+        retriesBeforeOutput: 0,
+        strictSseJson: false
+      },
+      sampling: { temperature: 0.7 },
+      compaction: { ...SHARED_COMPACTION },
+      profile: "minimax"
+    });
+    MINIMAX_M2_CAPS = frozenProfile({
+      contextWindow: 204800,
+      reasoning: { supported: true, replayReasoning: true },
+      promptCache: { supported: false, pricedCacheRead: false },
+      toolCalling: { parallel: true },
+      buildRecovery: { forceToolChoice: false, maxForcedTurns: 0 },
+      wire: {
+        grokRequestHeaders: false,
+        omitAutoToolChoice: false,
+        toolCallDeltasResetIdle: false,
+        retriesBeforeOutput: 0,
+        strictSseJson: false
+      },
+      sampling: { temperature: 0.7 },
+      compaction: { ...SHARED_COMPACTION },
+      profile: "minimax"
+    });
+    GLM_CAPS = frozenProfile({
+      contextWindow: 2e5,
+      reasoning: { supported: true, replayReasoning: true },
+      promptCache: { supported: true, pricedCacheRead: false },
+      toolCalling: { parallel: true },
+      buildRecovery: { forceToolChoice: false, maxForcedTurns: 0 },
+      wire: {
+        grokRequestHeaders: false,
+        omitAutoToolChoice: false,
+        toolCallDeltasResetIdle: false,
+        retriesBeforeOutput: 0,
+        strictSseJson: false
+      },
+      sampling: { temperature: 0.7 },
+      compaction: { ...SHARED_COMPACTION },
+      profile: "glm"
+    });
+    DEEPSEEK_RE = /^deepseek-(?:v4(?:\.|-|$)|chat$|reasoner$)/i;
+    GROK_RE = /^grok(?:\.|-|$)/i;
+    MINIMAX_RE = /^minimax(?:\.|-|$)/i;
+    MINIMAX_M3_RE = /^minimax-m3(?:\.|-|$)/i;
+    GLM_RE = /^glm(?:\.|-|$)/i;
+  }
+});
+
+// src/cli/provider/sse.ts
+var SseDataDecoder;
+var init_sse = __esm({
+  "src/cli/provider/sse.ts"() {
+    "use strict";
+    SseDataDecoder = class {
+      lineBuffer = "";
+      dataLines = [];
+      firstText = true;
+      push(text, final = false) {
+        if (this.firstText) {
+          this.firstText = false;
+          if (text.charCodeAt(0) === 65279) text = text.slice(1);
+        }
+        this.lineBuffer += text;
+        const lines = this.lineBuffer.split("\n");
+        this.lineBuffer = final ? "" : lines.pop() ?? "";
+        const events = [];
+        for (const rawLine of lines) {
+          this.acceptLine(rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine, events);
+        }
+        if (final) {
+          if (this.lineBuffer.length > 0) {
+            this.acceptLine(
+              this.lineBuffer.endsWith("\r") ? this.lineBuffer.slice(0, -1) : this.lineBuffer,
+              events
+            );
+            this.lineBuffer = "";
+          }
+          this.dispatch(events);
+        }
+        return events;
+      }
+      acceptLine(line, events) {
+        if (line.length === 0) {
+          this.dispatch(events);
+          return;
+        }
+        if (line.startsWith(":")) return;
+        const colon = line.indexOf(":");
+        const field = colon < 0 ? line : line.slice(0, colon);
+        if (field !== "data") return;
+        let value = colon < 0 ? "" : line.slice(colon + 1);
+        if (value.startsWith(" ")) value = value.slice(1);
+        this.dataLines.push(value);
+      }
+      dispatch(events) {
+        if (this.dataLines.length === 0) return;
+        events.push(this.dataLines.join("\n"));
+        this.dataLines = [];
+      }
+    };
   }
 });
 
@@ -40524,12 +40836,14 @@ __export(openai_compatible_exports, {
   modelSupportsVision: () => modelSupportsVision,
   openaiCompatibleProvider: () => openaiCompatibleProvider,
   parseCachedPromptTokens: () => parseCachedPromptTokens,
+  parseOpenAiStreamError: () => parseOpenAiStreamError,
   providerConfigFor: () => providerConfigFor,
   providerFromEnv: () => providerFromEnv,
   readChunkWithTimeout: () => readChunkWithTimeout,
   resolveActiveProvider: () => resolveActiveProvider,
   resolveBaseUrl: () => resolveBaseUrl
 });
+import { randomUUID as randomUUID2 } from "node:crypto";
 function abortableSleep(ms, signal) {
   return new Promise((resolve7) => {
     if (signal?.aborted) return resolve7();
@@ -40573,9 +40887,10 @@ async function readChunkWithTimeout(reader, opts) {
       reader.read(),
       new Promise((_, reject) => {
         idleTimer = setTimeout(() => {
+          const totalIdleMs = Math.max(opts.idleMs, Date.now() - opts.lastUsefulAt());
           reject(
             new Error(
-              `Provider stream idle for ${Math.round(waitMs / 1e3)}s (no tokens). The model/gateway stalled \u2014 try again or switch model. Override with ZELARI_PROVIDER_STREAM_IDLE_MS.`
+              `Provider stream idle for ${Math.round(totalIdleMs / 1e3)}s (no useful deltas). The model/gateway stalled \u2014 try again or switch model. Override with ZELARI_PROVIDER_STREAM_IDLE_MS.`
             )
           );
         }, waitMs);
@@ -40623,6 +40938,22 @@ function parseCachedPromptTokens(usage) {
   }
   return 0;
 }
+function parseOpenAiStreamError(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const root = value;
+  const nested = root.error;
+  if (nested && typeof nested === "object" && !Array.isArray(nested)) {
+    const error51 = nested;
+    const message = typeof error51.message === "string" && error51.message.trim() ? error51.message.trim() : "unknown error";
+    const type = typeof error51.type === "string" && error51.type.trim() ? error51.type.trim() : "server_error";
+    return `Provider stream error (${type}): ${message}`;
+  }
+  if (typeof nested === "string" && nested.trim()) {
+    const type = typeof root.code === "string" && root.code.trim() ? root.code.trim() : "server_error";
+    return `Provider stream error (${type}): ${nested.trim()}`;
+  }
+  return null;
+}
 function resolveBaseUrl(providerId) {
   const custom2 = getCustomEndpoint(providerId);
   if (custom2) return custom2;
@@ -40700,7 +41031,8 @@ ${notes}
   return { role: m.role, content: m.content };
 }
 function openaiCompatibleProvider(config2) {
-  return async function* (params) {
+  const run = async function* (params, streamRetryAttempt = 0) {
+    const capabilities = capabilitiesFor(params.model, config2.providerId);
     const vision = modelSupportsVision(params.model);
     const messages = params.messages.map((m) => {
       const cacheable = !(m.role === "user" && m.images && m.images.length > 0);
@@ -40720,7 +41052,7 @@ function openaiCompatibleProvider(config2) {
       model: params.model,
       messages,
       stream: true,
-      temperature: generation?.temperature ?? capabilitiesFor(params.model).sampling.temperature,
+      temperature: generation?.temperature ?? capabilities.sampling.temperature,
       // Task G.4.2 — request the provider to send real token usage in
       // the final chunk (gated by `stream_options.include_usage` on the
       // OpenAI-compatible API). Providers that don't honor this (some
@@ -40756,7 +41088,31 @@ function openaiCompatibleProvider(config2) {
           parameters: t.parameters
         }
       }));
-      body.tool_choice = "auto";
+      const recoveryAttempt = generation?.recoveryAttempt ?? 1;
+      const forceRecoveryTool = generation?.toolChoice === "required" && capabilities.buildRecovery.forceToolChoice && recoveryAttempt <= capabilities.buildRecovery.maxForcedTurns;
+      if (forceRecoveryTool) {
+        body.tool_choice = "required";
+      } else if (!capabilities.wire.omitAutoToolChoice) {
+        body.tool_choice = "auto";
+      }
+    }
+    const headers2 = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config2.apiKey}`,
+      ...config2.extraHeaders ?? {}
+    };
+    const affinityHeader = capabilities.promptCache.conversationAffinityHeader;
+    const conversationId = params.conversationId?.trim();
+    const safeConversationId = conversationId && conversationId.length <= 256 && !/[\u0000-\u001f\u007f]/.test(conversationId) ? conversationId : void 0;
+    if (affinityHeader && safeConversationId) {
+      headers2[affinityHeader] = safeConversationId;
+    }
+    if (capabilities.wire.grokRequestHeaders) {
+      headers2.Accept = "text/event-stream";
+      headers2["x-grok-client-identifier"] = "zelari-code";
+      headers2["x-grok-req-id"] = `zelari-${randomUUID2()}`;
+      headers2["x-grok-model-override"] = params.model;
+      if (safeConversationId) headers2["x-grok-session-id"] = safeConversationId;
     }
     let response;
     let lastErrText = "";
@@ -40781,10 +41137,7 @@ function openaiCompatibleProvider(config2) {
         try {
           response = await fetch(`${config2.baseUrl}/chat/completions`, {
             method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${config2.apiKey}`
-            },
+            headers: headers2,
             body: JSON.stringify(body),
             // Cancel aborts the HTTP request; stream idle is enforced below
             // per-chunk so active multi-minute streams are not killed.
@@ -40827,9 +41180,10 @@ function openaiCompatibleProvider(config2) {
     }
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
-    let buffer = "";
+    const sseDecoder = new SseDataDecoder();
     const toolCallAccumulator = /* @__PURE__ */ new Map();
     let emittedToolCall = false;
+    let emittedProviderDelta = false;
     let reasoningDetailsBuf = "";
     const tryParseArgs = (raw) => {
       const t = raw.trim();
@@ -40852,6 +41206,7 @@ function openaiCompatibleProvider(config2) {
         if (args === null) continue;
         toolCallAccumulator.delete(idx);
         emittedToolCall = true;
+        emittedProviderDelta = true;
         markUseful();
         yield {
           kind: "tool_call",
@@ -40887,18 +41242,19 @@ function openaiCompatibleProvider(config2) {
             await reader.cancel(msg);
           } catch {
           }
+          if (!emittedProviderDelta && streamRetryAttempt < capabilities.wire.retriesBeforeOutput) {
+            await abortableSleep(backoffDelay(streamRetryAttempt, null), params.signal);
+            yield* run(params, streamRetryAttempt + 1);
+            return;
+          }
           yield { kind: "error", message: msg };
           return;
         }
         const { value, done } = chunk;
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          const trimmed = line.trim();
-          if (!trimmed.startsWith("data:")) continue;
-          const data = trimmed.slice(5).trim();
+        const decoded = done ? decoder.decode() : decoder.decode(value, { stream: true });
+        const events = sseDecoder.push(decoded, done);
+        for (const data of events) {
+          if (data.length === 0) continue;
           if (data === "[DONE]") {
             yield* flushToolAccumulator();
             yield {
@@ -40908,7 +41264,22 @@ function openaiCompatibleProvider(config2) {
             return;
           }
           try {
-            const parsed = JSON.parse(data);
+            const rawParsed = JSON.parse(data);
+            const streamError = parseOpenAiStreamError(rawParsed);
+            if (streamError) {
+              try {
+                await reader.cancel(streamError);
+              } catch {
+              }
+              if (!emittedProviderDelta && streamRetryAttempt < capabilities.wire.retriesBeforeOutput) {
+                await abortableSleep(backoffDelay(streamRetryAttempt, null), params.signal);
+                yield* run(params, streamRetryAttempt + 1);
+                return;
+              }
+              yield { kind: "error", message: streamError };
+              return;
+            }
+            const parsed = rawParsed;
             const choice = parsed.choices?.[0];
             const delta = choice?.delta;
             if (parsed.usage && typeof parsed.usage === "object") {
@@ -40917,6 +41288,7 @@ function openaiCompatibleProvider(config2) {
               const totalTokens = typeof parsed.usage.total_tokens === "number" ? parsed.usage.total_tokens : promptTokens + completionTokens;
               const cachedPromptTokens = parseCachedPromptTokens(parsed.usage);
               markUseful();
+              emittedProviderDelta = true;
               yield {
                 kind: "usage",
                 usage: {
@@ -40929,11 +41301,13 @@ function openaiCompatibleProvider(config2) {
             }
             if (typeof delta?.content === "string" && delta.content.length > 0) {
               markUseful();
+              emittedProviderDelta = true;
               yield { kind: "text", delta: delta.content };
             }
             const reasoning = delta?.reasoning_content ?? delta?.reasoning;
             if (typeof reasoning === "string" && reasoning.length > 0) {
               markUseful();
+              emittedProviderDelta = true;
               yield { kind: "thinking", delta: reasoning };
             }
             const details = delta?.reasoning_details;
@@ -40947,16 +41321,21 @@ function openaiCompatibleProvider(config2) {
                   reasoningDetailsBuf = t;
                   if (piece.length > 0) {
                     markUseful();
+                    emittedProviderDelta = true;
                     yield { kind: "thinking", delta: piece };
                   }
                 } else {
                   reasoningDetailsBuf += t;
                   markUseful();
+                  emittedProviderDelta = true;
                   yield { kind: "thinking", delta: t };
                 }
               }
             }
             if (Array.isArray(delta?.tool_calls)) {
+              if (capabilities.wire.toolCallDeltasResetIdle && delta.tool_calls.length > 0) {
+                markUseful();
+              }
               for (const tc of delta.tool_calls) {
                 const idx = tc.index ?? 0;
                 const existing = toolCallAccumulator.get(idx) ?? {
@@ -40973,12 +41352,21 @@ function openaiCompatibleProvider(config2) {
             if (choice?.finish_reason) {
               yield* flushToolAccumulator();
               markUseful();
+              emittedProviderDelta = true;
               const reason = choice.finish_reason === "stop" && emittedToolCall ? "tool_calls" : choice.finish_reason;
               yield { kind: "finish", reason };
             }
           } catch {
+            if (capabilities.wire.strictSseJson) {
+              yield {
+                kind: "error",
+                message: "Malformed Grok SSE data event (expected Chat Completions JSON)."
+              };
+              return;
+            }
           }
         }
+        if (done) break;
       }
       yield* flushToolAccumulator();
       yield {
@@ -40989,6 +41377,7 @@ function openaiCompatibleProvider(config2) {
       reader.releaseLock();
     }
   };
+  return (params) => run(params);
 }
 function extraFromStored(providerId) {
   const stored = getOAuthToken(providerId);
@@ -41031,6 +41420,7 @@ var init_openai_compatible = __esm({
     init_providerConfig();
     init_thinking();
     init_capabilities();
+    init_sse();
     RETRYABLE_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
     MAX_RETRIES = (() => {
       const raw = process.env.ZELARI_PROVIDER_MAX_RETRIES;
@@ -44009,11 +44399,11 @@ var init_metrics3 = __esm({
 });
 
 // src/cli/state/fileStateStore.ts
-import { createHash as createHash13, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash13, randomUUID as randomUUID3 } from "node:crypto";
 import { promises as fs21 } from "node:fs";
 import * as path43 from "node:path";
 function shortId() {
-  return randomUUID2().replace(/-/g, "").slice(0, 12);
+  return randomUUID3().replace(/-/g, "").slice(0, 12);
 }
 async function writeJsonAtomic(filePath, data) {
   await fs21.mkdir(path43.dirname(filePath), { recursive: true });
@@ -44946,7 +45336,7 @@ function expectsDiskImplementation(task, phase2, prior) {
   const trimmed = task.trim();
   if (!trimmed) return false;
   if (isShortContinueReply(trimmed)) return true;
-  if (/\b(implement|implementa|scrivi|scriviamo|applica|modifica|fix|write|edit|crea|aggiungi|aggiorna|apply|patch)\b/i.test(
+  if (/\b(implement(?:a|are)?|scriv(?:i|iamo|ere)|applica(?:re)?|modifica(?:re)?|fix|write|edit|crea(?:re)?|aggiung(?:i|ere)|aggiorn(?:a|are)|apply|patch|refactor|corregg(?:i|ere)|risolv(?:i|ere)|remove|rimuov(?:i|ere)|rename|rinomina(?:re)?|replace|sostituisc(?:i|e)|delete|elimina(?:re)?|build|costruisc(?:i|e)|convert(?:i|ire)?|migra(?:re)?|upgrade)\b/i.test(
     trimmed
   )) {
     return true;
@@ -46380,7 +46770,7 @@ WHERE NOT EXISTS (SELECT 1 FROM memory_fts f WHERE f.node_id = n.id);
 });
 
 // src/cli/memory/sqliteBackend.ts
-import { createHash as createHash15, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash15, randomUUID as randomUUID4 } from "node:crypto";
 import { promises as fs23 } from "node:fs";
 import * as path46 from "node:path";
 function boundedLimit(value, fallback = 50) {
@@ -46503,7 +46893,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
         const createdAt = input.createdAt ?? now;
         const recordedAt = input.recordedAt ?? createdAt;
         const node = MemoryNodeSchema.parse({
-          id: input.id ?? `mem_${randomUUID3()}`,
+          id: input.id ?? `mem_${randomUUID4()}`,
           schemaVersion: 1,
           projectId: input.projectId,
           kind: input.kind,
@@ -46529,7 +46919,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           (version_id, memory_id, revision, snapshot_json, recorded_at, actor, reason)
           VALUES (?, ?, 1, ?, ?, ?, ?)`,
             params: [
-              `ver_${randomUUID3()}`,
+              `ver_${randomUUID4()}`,
               node.id,
               JSON.stringify(node),
               recordedAt,
@@ -46590,7 +46980,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
           (version_id, memory_id, revision, snapshot_json, recorded_at, actor, reason)
           VALUES (?, ?, (SELECT COALESCE(MAX(revision), 0) + 1 FROM memory_versions WHERE memory_id=?), ?, ?, ?, ?)`,
             params: [
-              `ver_${randomUUID3()}`,
+              `ver_${randomUUID4()}`,
               updated.id,
               updated.id,
               JSON.stringify(updated),
@@ -46824,7 +47214,7 @@ VALUES (${Array.from({ length: 19 }, () => "?").join(",")})`;
         if (decoded) return decoded;
         const edge = MemoryEdgeSchema.parse({
           ...input,
-          id: input.id ?? `edge_${randomUUID3()}`,
+          id: input.id ?? `edge_${randomUUID4()}`,
           strength: input.strength ?? 1,
           confidence: input.confidence ?? 0.8,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -50207,7 +50597,7 @@ import { promisify as promisify2 } from "node:util";
 import { mkdtempSync, rmSync as rmSync2 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import path49 from "node:path";
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 async function git3(cwd, args, env) {
   const { stdout } = await execFileAsync2("git", ["-C", cwd, ...args], {
     maxBuffer: 64 * 1024 * 1024,
@@ -50250,7 +50640,7 @@ async function createCheckpoint(cwd, label = "checkpoint") {
   }
   try {
     const { tree, head } = await snapshotTree(cwd);
-    const id3 = randomUUID4().slice(0, 8);
+    const id3 = randomUUID5().slice(0, 8);
     const createdAt = Date.now();
     const message = `zelari-checkpoint ${id3}: ${label}`;
     const commitArgs = ["commit-tree", tree, "-m", message];
@@ -50417,7 +50807,7 @@ __export(fileBackend_exports, {
   getMemoryBackend: () => getMemoryBackend,
   isMemoryEnabled: () => isMemoryEnabled
 });
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 import { promises as fs26 } from "node:fs";
 import * as path50 from "node:path";
 function tokenize(text) {
@@ -50476,7 +50866,7 @@ var init_fileBackend = __esm({
       }
       async add(content, metadata2 = {}, graph) {
         const fact = {
-          id: randomUUID5(),
+          id: randomUUID6(),
           content,
           metadata: metadata2,
           ...graph ? { graph } : {},
@@ -50584,7 +50974,7 @@ __export(zelariMission_exports, {
   resolveMaxTokens: () => resolveMaxTokens,
   runZelariMission: () => runZelariMission
 });
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 import { promises as fs28 } from "node:fs";
 import * as path52 from "node:path";
 function resolveMaxIterations(env = process.env) {
@@ -50681,7 +51071,7 @@ async function runZelariMission(userMessage, brief, deps) {
   const maxStall = resolveMaxStall(deps.env);
   const maxCost = resolveMaxCost(deps.env);
   const maxTokens = resolveMaxTokens(deps.env);
-  const missionId = deps.missionId ?? `m_${randomUUID6().slice(0, 8)}`;
+  const missionId = deps.missionId ?? `m_${randomUUID7().slice(0, 8)}`;
   const startedAt = now().toISOString();
   const state3 = {
     missionId,
@@ -51129,6 +51519,7 @@ async function runAgentMissionSlice(deps) {
       tools: toolSpecs,
       toolRegistry: deps.toolRegistry,
       providerStream: deps.providerStream,
+      buildLiveness: { mutationRequired: writeRetry, maxRecoveries: 2 },
       cwd: deps.projectRoot,
       maxToolCallsPerTurn: maxToolCalls,
       maxToolLoopIterations: maxToolLoop,
@@ -57212,7 +57603,7 @@ var init_mcpCli = __esm({
 
 // src/cli/mcp/mcpPermissionServer.ts
 import { createInterface as createInterface2 } from "node:readline";
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 function startPermissionMcpServer(opts) {
   const socketPath = opts.socketPath.trim();
   const requestTimeoutMs = opts.requestTimeoutMs ?? PERMISSION_BROKER_DEFAULT_TIMEOUT_MS;
@@ -57308,7 +57699,7 @@ function startPermissionMcpServer(opts) {
         socketPath,
         {
           t: "ask",
-          id: randomUUID8(),
+          id: randomUUID9(),
           kind: "permission",
           tool: toolName,
           input: input2,
@@ -57347,7 +57738,7 @@ function startPermissionMcpServer(opts) {
         socketPath,
         {
           t: "ask",
-          id: randomUUID8(),
+          id: randomUUID9(),
           kind: "question",
           question,
           choices,
@@ -57639,7 +58030,7 @@ var init_config = __esm({
 // src/cli/companion/runManager.ts
 import { spawn as spawn17 } from "node:child_process";
 import { createInterface as createInterface3 } from "node:readline";
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 import { writeFileSync as writeFileSync26, unlinkSync as unlinkSync3 } from "node:fs";
 import { join as join44 } from "node:path";
 import { tmpdir as tmpdir3 } from "node:os";
@@ -57708,7 +58099,7 @@ var init_runManager = __esm({
         }
         const prompt = args.prompt?.trim();
         if (!prompt) return { ok: false, error: "prompt is required" };
-        const id3 = randomUUID9();
+        const id3 = randomUUID10();
         const mode = (args.mode || "kraken").toLowerCase();
         const phase2 = (args.phase || "build").toLowerCase();
         const run = {
@@ -62658,12 +63049,12 @@ function estimateHistoryTokens(messages) {
   }
   return n;
 }
-function defaultContextLimitForModel(model) {
-  return capabilitiesFor(model).contextWindow;
+function defaultContextLimitForModel(model, provider) {
+  return capabilitiesFor(model, provider).contextWindow;
 }
-function resolveContextLimit(model) {
+function resolveContextLimit(model, provider) {
   return envNumber(process.env.ZELARI_CONTEXT_LIMIT, {
-    default: defaultContextLimitForModel(model),
+    default: defaultContextLimitForModel(model, provider),
     min: 4e3,
     max: 2e6
   });
@@ -62679,8 +63070,8 @@ function phaseKnobs(phase2) {
 }
 var RESERVED_OUTPUT_TOKENS = 8192;
 async function applyBudgetPolicyAsync(history2, phase2, opts) {
-  const contextLimit = resolveContextLimit(opts?.model);
-  const compact3 = capabilitiesFor(opts?.model).compaction;
+  const contextLimit = resolveContextLimit(opts?.model, opts?.provider);
+  const compact3 = capabilitiesFor(opts?.model, opts?.provider).compaction;
   const sessionExtra = opts?.sessionTokens ?? 0;
   const warnings = [];
   let { historyTurns, maxToolLoopIterations } = phaseKnobs(phase2);
@@ -62955,8 +63346,11 @@ function messageWasRecompacted(message, history2) {
   if (message.compactedFromSeq === void 0) return false;
   return !history2.some((candidate) => candidate.seq !== void 0 && candidate.seq === message.seq);
 }
-function resourceStatusMessage(payload) {
-  return { role: "system", content: formatResourceSnapshot(payload) };
+function resourceStatusTail(payload) {
+  return payload ? [{ role: "system", content: formatResourceSnapshot(payload) }] : [];
+}
+function isLegacyResourceStatus(message) {
+  return message.role === "system" && message.content.startsWith("RESOURCE STATUS");
 }
 async function sessionHistory(session) {
   if (!session || session.status !== "active") return null;
@@ -62967,7 +63361,10 @@ async function sessionHistory(session) {
 async function buildModelContext(input) {
   const derived = await sessionHistory(input.session);
   const source2 = derived ? "session" : "fallback";
-  const sourceHistory = derived ?? [...input.fallbackHistory];
+  const sourceHistory = (derived ?? [...input.fallbackHistory]).filter(
+    (message) => !isLegacyResourceStatus(message)
+  );
+  const requestTail = resourceStatusTail(input.resourceSnapshot);
   const inputTokens = estimateHistoryTokens(sourceHistory);
   const requestSurface = input.systemMessages || input.tools ? {
     provider: input.provider ?? "local",
@@ -62977,7 +63374,8 @@ async function buildModelContext(input) {
   } : null;
   let budget = await applyBudgetPolicyAsync(sourceHistory, input.phase, {
     model: input.model,
-    sessionTokens: input.sessionTokens,
+    provider: input.provider,
+    sessionTokens: (input.sessionTokens ?? 0) + estimateHistoryTokens(requestTail),
     sessionId: input.sessionId,
     signal: input.signal,
     requestSnapshot: input.requestSnapshot,
@@ -63024,16 +63422,11 @@ async function buildModelContext(input) {
     };
     input.onCompactionMetric?.(compactionMetrics);
   }
-  if (input.resourceSnapshot && !history2.some(
-    (m) => m.role === "system" && typeof m.content === "string" && m.content.startsWith("RESOURCE STATUS")
-  )) {
-    history2 = [...history2, resourceStatusMessage(input.resourceSnapshot)];
-  }
   if (requestSurface) {
     const measured = measureRequest({
       systemMessages: requestSurface.systemMessages,
       tools: requestSurface.tools,
-      conversation: history2,
+      conversation: [...history2, ...requestTail],
       anchor: input.requestSnapshot,
       contextLimit: budget.contextLimit,
       reservedOutputTokens: 8192
@@ -63046,7 +63439,7 @@ async function buildModelContext(input) {
       contextPressureTokens: measured.contextPressureTokens
     };
   } else {
-    const estimated = estimateHistoryTokens(history2);
+    const estimated = estimateHistoryTokens([...history2, ...requestTail]);
     budget = {
       ...budget,
       history: history2,
@@ -63056,6 +63449,7 @@ async function buildModelContext(input) {
   }
   return {
     history: history2,
+    requestTail,
     budget,
     source: source2,
     ...compactionPayload ? { compactionPayload } : {},
@@ -63476,6 +63870,17 @@ _(${req.context})_` : "") + "\n\u2192 scegli dalla lista (il turno continua dopo
           })),
           toolRegistry,
           providerStream,
+          buildLiveness: {
+            mutationRequired: expectsDiskImplementation(
+              userText,
+              workPhase,
+              historyForModel
+            ),
+            maxRecoveries: 2
+          },
+          requestTail: () => resourceStatusTail(
+            writerRef.current?.spine?.latestResourceSnapshot() ?? null
+          ),
           // 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
@@ -69243,7 +69648,6 @@ init_harness();
 init_dist();
 init_events2();
 init_conversationContext();
-init_council();
 init_toolRegistry();
 init_candidateRegistry();
 init_metrics2();
@@ -69287,7 +69691,7 @@ init_taskTool();
 init_sessionTodos();
 import { promises as fs41 } from "node:fs";
 import path68 from "node:path";
-import { randomUUID as randomUUID7 } from "node:crypto";
+import { randomUUID as randomUUID8 } from "node:crypto";
 
 // src/cli/kraken/verifierLifecycle.ts
 init_verification2();
@@ -69584,7 +69988,7 @@ async function runHeadlessKrakenGraph(opts, provider, model) {
     });
     log(formatKrakenGraphAscii2(graph));
     if (opts.planOnly) {
-      const planId = randomUUID7();
+      const planId = randomUUID8();
       const planDir = path68.join(cwd, ".zelari", "radio");
       const planPath = path68.join(planDir, `plan-${planId}.json`);
       await fs41.mkdir(planDir, { recursive: true });
@@ -69900,6 +70304,11 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
   }
   const effectiveTask = buildAgentUserWithHistory(opts.task, historySeed);
   if (opts.task) spine.userMessage(effectiveTask);
+  const wantWrites = expectsDiskImplementation(
+    opts.task,
+    opts.phase,
+    historySeed
+  );
   const maxToolLoop = (() => {
     const n = envNumber(process.env.ZELARI_MAX_TOOL_LOOP_ITERATIONS, {
       default: 30,
@@ -69916,6 +70325,8 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
       tools,
       toolRegistry,
       providerStream,
+      buildLiveness: { mutationRequired: wantWrites, maxRecoveries: 2 },
+      requestTail: () => resourceStatusTail(spine.spine.latestResourceSnapshot()),
       // 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).
@@ -69929,12 +70340,13 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
         memoryContextChars: 2e3
       } : {}
     });
+    const readBuildProgress = () => {
+      const getter = harness.getBuildProgress;
+      return typeof getter === "function" ? getter.call(harness) : { mutationsAttempted: 0, mutationsSucceeded: 0 };
+    };
     let finalReason = "completed";
     let exitCode = 0;
     const textBuffer = [];
-    let successfulWrites = 0;
-    let emittedWrites = 0;
-    const pendingToolNames = /* @__PURE__ */ new Map();
     const scrub = createStreamScrubber2();
     try {
       for await (const event of harness.run()) {
@@ -69943,27 +70355,6 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
         if (event.type === "message_start") {
           scrub.reset();
         }
-        if (event.type === "tool_execution_start") {
-          const name = event.toolName ?? "";
-          const id3 = event.toolCallId ?? "";
-          if (id3 && name) pendingToolNames.set(id3, name);
-          if (name === "write_file" || name === "edit_file" || name === "apply_diff") {
-            emittedWrites += 1;
-          }
-        }
-        if (event.type === "tool_execution_end") {
-          const id3 = event.toolCallId ?? "";
-          const name = pendingToolNames.get(id3) ?? "";
-          pendingToolNames.delete(id3);
-          const isError = !!event.isError;
-          const result = String(event.result ?? "");
-          if ((name === "write_file" || name === "edit_file" || name === "apply_diff") && !isError) {
-            const zeroEdit = name === "edit_file" && /occurrencesReplaced["']?\s*[:=]\s*0\b|0 occurrence|no changes/i.test(
-              result
-            );
-            if (!zeroEdit) successfulWrites += 1;
-          }
-        }
         if (event.type === "message_delta" && typeof event.delta === "string") {
           const cleanDelta = scrub.push(event.delta);
           if (opts.output === "json") {
@@ -70003,17 +70394,18 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
         finalReason: "error",
         exitCode: 2,
         textBuffer,
-        successfulWrites,
-        emittedWrites,
+        successfulWrites: readBuildProgress().mutationsSucceeded,
+        emittedWrites: readBuildProgress().mutationsAttempted,
         messages: harness.getMessages()
       };
     }
+    const buildProgress = readBuildProgress();
     return {
       finalReason,
       exitCode,
       textBuffer,
-      successfulWrites,
-      emittedWrites,
+      successfulWrites: buildProgress.mutationsSucceeded,
+      emittedWrites: buildProgress.mutationsAttempted,
       messages: harness.getMessages()
     };
   }
@@ -70037,41 +70429,6 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
     }
   ];
   let pass = await runSinglePass(initialMessages, sessionId2);
-  const wantWrites = expectsDiskImplementation(
-    opts.task,
-    opts.phase,
-    historySeed
-  );
-  if (wantWrites && pass.successfulWrites === 0 && pass.finalReason === "completed" && pass.exitCode === 0) {
-    const retryPrompt = buildImplementationWriteRetryPrompt(opts.task);
-    if (opts.output === "json") {
-      emitEvent({
-        type: "log",
-        message: "[headless] BUILD: no successful write_file/edit_file \u2014 forcing implementation retry"
-      });
-    } else {
-      process.stderr.write(
-        `[zelari-code --headless] BUILD: no successful writes \u2014 forcing implementation retry
-`
-      );
-    }
-    const retryMessages = [
-      ...pass.messages.filter((m) => m.role !== "system")
-    ];
-    const withSystem = [
-      ...systemMessages,
-      ...retryMessages,
-      { role: "user", content: retryPrompt }
-    ];
-    progressRuntime.beginPass();
-    const retry = await runSinglePass(withSystem, `${sessionId2}-write-retry`);
-    pass = {
-      ...retry,
-      textBuffer: [...pass.textBuffer, ...retry.textBuffer],
-      successfulWrites: pass.successfulWrites + retry.successfulWrites,
-      emittedWrites: pass.emittedWrites + retry.emittedWrites
-    };
-  }
   let strictExit = 0;
   const verifierReviewDeps = {
     session: { provider, model },
@@ -70155,7 +70512,7 @@ async function runHeadlessSingle(opts, provider, model, providerStream) {
   }
   process.stdout.write("");
   if (pass.finalReason !== "error" && opts.output === "json" && wantWrites && pass.successfulWrites === 0) {
-    emitEvent({ type: "log", message: "[headless] BUILD warning: still zero successful writes after retry" });
+    emitEvent({ type: "log", message: "[headless] BUILD failed: zero successful mutations after liveness recovery" });
   }
   try {
     const closeStatus = pass.finalReason === "error" ? "error" : strictExit !== 0 ? "stopped" : "completed";