zelari-code 2.8.0 → 2.9.0

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,120 @@ 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.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 },
+      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 },
+      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 },
+      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 },
+      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 },
+      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 },
+      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;
   }
 });
 
@@ -40701,6 +40915,7 @@ ${notes}
 }
 function openaiCompatibleProvider(config2) {
   return async function* (params) {
+    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 +40935,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 +40971,19 @@ 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;
+      body.tool_choice = forceRecoveryTool ? "required" : "auto";
+    }
+    const headers2 = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config2.apiKey}`,
+      ...config2.extraHeaders ?? {}
+    };
+    const affinityHeader = capabilities.promptCache.conversationAffinityHeader;
+    const conversationId = params.conversationId?.trim();
+    if (affinityHeader && conversationId && conversationId.length <= 256 && !/[\u0000-\u001f\u007f]/.test(conversationId)) {
+      headers2[affinityHeader] = conversationId;
     }
     let response;
     let lastErrText = "";
@@ -40781,10 +41008,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.
@@ -44946,7 +45170,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;
@@ -51129,6 +51353,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,
@@ -62658,12 +62883,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 +62904,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 +63180,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 +63195,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 +63208,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 +63256,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 +63273,7 @@ async function buildModelContext(input) {
       contextPressureTokens: measured.contextPressureTokens
     };
   } else {
-    const estimated = estimateHistoryTokens(history2);
+    const estimated = estimateHistoryTokens([...history2, ...requestTail]);
     budget = {
       ...budget,
       history: history2,
@@ -63056,6 +63283,7 @@ async function buildModelContext(input) {
   }
   return {
     history: history2,
+    requestTail,
     budget,
     source: source2,
     ...compactionPayload ? { compactionPayload } : {},
@@ -63476,6 +63704,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 +69482,6 @@ init_harness();
 init_dist();
 init_events2();
 init_conversationContext();
-init_council();
 init_toolRegistry();
 init_candidateRegistry();
 init_metrics2();
@@ -69900,6 +70138,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 +70159,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 +70174,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 +70189,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 +70228,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 +70263,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 +70346,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";