@magnusekdahl/parallix 1.3.3 → 1.3.4

package/docs/agents.md

@@ -26,7 +26,7 @@ Opencode (custom agent family) may encounter issues with concurrent tool calls o
 |---------|----------------------------------------------------------------------|
 | codex   | `codex exec --sandbox danger-full-access --cd <worktree> <prompt>` with a worktree-local `HOME` under `.workflow/codex-home`; resume uses `codex exec resume <session-id-or---last> <prompt>`; the launcher also seeds `.workflow/codex-home/.codex/config.toml` with the repo-standard trusted posture and copies `.codex/auth.json` so headless review commands can start and keep localhost Forgejo access |
 | claude  | `claude --dangerously-skip-permissions --output-format stream-json --verbose --include-partial-messages -p <prompt>` (cwd=worktree) — uses `--output-format stream-json --verbose --include-partial-messages` to stream real-time JSONL events (tool calls, assistant text chunks) to the operator's terminal via the spawn-tee mechanism. `--include-partial-messages` is required: without it, the assistant event contains the full response at once and no intermediate progress is emitted. Session-id extraction parses the `result` event from stream-json output, falling back to the `claude --resume <id>` regex on plain text. |
-| mistral | `vibe --prompt <prompt> --trust --output text` (cwd=worktree) — **Note: NOT resume-capable in current Vibe version**; session management uses internal state in `~/.vibe/logs/session/` but does not emit a parseable resume hint to stdout/stderr. |
+| mistral | `vibe --prompt <prompt> --trust --yolo --output text` (cwd=worktree) — `--yolo` approves tool calls non-interactively (mirrors `--dangerously-skip-permissions` for claude/opencode and codex's `trust_level = "trusted"`); `--trust` only bypasses the working-directory trust prompt and does not itself skip tool-call approval. **Note: NOT resume-capable in current Vibe version**; session management uses internal state in `~/.vibe/logs/session/` but does not emit a parseable resume hint to stdout/stderr. |
 | custom    | `opencode run --pure --dangerously-skip-permissions <prompt>` (cwd=worktree); resume uses `-s <session>` when a session id is known or `--continue` when only the family marker is known |
 
 ## Launch output watchdog

package/docs/use-cases.md

@@ -53,7 +53,7 @@ Each use case carries the four required parts: **(P) persona/buyer**, **(B) befo
 ### UC-6 — See which agent family actually pays off, across every repo one runtime drives
 
 - **(P)** Operator/buyer deciding which paid agent subscriptions to keep or cut.
-- **(B)** *Before:* no durable, cross-repo record of how each agent performs, so the keep/cut decision is a hunch. *After:* a single parallix-owned `stats.csv` accumulates per-agent telemetry (`classification, implementer, pr_fix_rounds`, plus an extended 21-column schema) across every repository one runtime drives, keyed so the same mission in different repos stays distinct.
+- **(B)** *Before:* no durable, cross-repo record of how each agent performs, so the keep/cut decision is a hunch. *After:* a single parallix-owned `stats.csv` accumulates per-agent telemetry (`classification, implementer, pr_fix_rounds`, plus an extended 22-column schema including a `closed` flag) across every repository one runtime drives, keyed so the same mission in different repos stays distinct.
 - **(E)** `lib/commands/stats.js:14` (legacy 5-col schema), `:21-30` (extended schema). Tested: `test/stats.test.js` — `upsertStatsRow writes the workflow stats schema and updates existing missions idempotently`, `task-1314: upsertStatsRow keys on (repo, mission, stage) so same mission in different repos stays distinct`. The kind of agent-comparison this enables is demonstrated in `../visualBoard/docs/missions/2026/task-1023/RETROSPECTIVE_P5.md:198-243` (per-family PRs, reviews/PR, durations).
 - **(C)** **Partial.** Schema and CSV upsert are tested, but the value is bounded: the richest per-agent comparison in the evidence came from Forgejo PR data, not `stats.csv`, and two of four families record honest zeros for token usage (`opencode`/local custom and `mistral`/vibe telemetry are zeroed by design, per `README.md:230-231` describing `opencode-telemetry.js`/`mistral-telemetry.js`). So cross-agent *cost/value* comparison is complete only for `codex` and `claude` today.
 

package/lib/agents/agents.js

@@ -115,11 +115,14 @@ const NON_BLOCKING_LAUNCH_ERROR_PATTERNS = Object.freeze([
     /\bmodel\s+(?:identifier|id)\s+(?:is\s+)?invalid\b/i,
     /\b(?:model\s+not\s+found|no\s+such\s+model)\b/i,
     /\bunknown\s+option\b/i,
+    /\bunsupported\s+(flag|option)\b/i,
     /\bauth(?:entication)?\b/i,
     /\bunauthorized\b/i,
     /\bforbidden\b/i,
     /\bapi\s+key\b/i,
-    /\bread-only file system\b/i
+    /\bread-only file system\b/i,
+    /\b(home|bootstrap)\s+(error|failed|cannot|denied|not\s+found)\b/i,
+    /\bpermission\s+denied\b/i
 ]);
 function workflowLauncherStatus(agent) {
     const resolver = RESOLVERS[agent];
@@ -162,6 +165,10 @@ function commandInPath(name) {
     });
     return result.status === 0 && result.stdout.trim().length > 0;
 }
+// Deterministic config/setup errors (invalid model IDs, auth failures,
+// unsupported CLI flags, home/bootstrap failures) must not poison the
+// persistent blocklist — only transient failures (runtime crashes, network
+// errors) deserve a block. Custom agents are never blocked.
 function shouldPersistLaunchFailureBlock(agent, result) {
     if (!result || agent === 'custom') {
         return false;
@@ -543,7 +550,7 @@ function defaultIsAgentBlockedNow(agent) {
         const config = readAgentConfig(CONFIG_PATH, {});
         return isAgentBlocked(agent, config);
     }
-    catch (err) {
+    catch (_err) {
         // If the config is malformed, surface that through the launcher path
         // (assertAgentSupported / launch) instead of silently rerouting. Treat as
         // not-blocked here so the existing error path runs.
@@ -823,10 +830,20 @@ async function startAgent(step, opts = { prompt: '' }) {
             // setup/config errors (invalid model id, auth failure, read-only HOME, etc.)
             // should fall through to the next family without poisoning agents.local.json.
             if (shouldPersistLaunchFailureBlock(chosen || '', result)) {
+                let blockReason = 'transient crash';
+                if (result?.signal) {
+                    blockReason = `signal ${result.signal}`;
+                }
+                else if (result?.error?.code) {
+                    blockReason = result.error.code;
+                }
+                else if (result?.status !== null && result?.status !== 0) {
+                    blockReason = `exit ${result.status}`;
+                }
                 const blockUntil = (0, limit_hit_js_1.formatBlockUntil)(new Date(Date.now() + limit_hit_js_1.DEFAULT_FALLBACK_HOURS * 60 * 60 * 1000));
                 try {
                     const blockResult = updateAgentBlockFn(chosen || '', blockUntil);
-                    log(fmt.status('INFO', `Wrote blocklist entry for ${fmt.agent(chosen || '')} -> ${fmt.path(blockResult.path)} (${limit_hit_js_1.DEFAULT_FALLBACK_HOURS}h block)`));
+                    log(fmt.status('INFO', `Wrote blocklist entry for ${fmt.agent(chosen || '')} -> ${fmt.path(blockResult.path)} (${limit_hit_js_1.DEFAULT_FALLBACK_HOURS}h block, ${blockReason})`));
                 }
                 catch (err) {
                     log(fmt.status('WARN', `Could not persist blocklist entry for ${fmt.agent(chosen || '')}: ${err.message}`));

package/lib/agents/agents.ts

@@ -115,11 +115,14 @@ const NON_BLOCKING_LAUNCH_ERROR_PATTERNS = Object.freeze([
   /\bmodel\s+(?:identifier|id)\s+(?:is\s+)?invalid\b/i,
   /\b(?:model\s+not\s+found|no\s+such\s+model)\b/i,
   /\bunknown\s+option\b/i,
+  /\bunsupported\s+(flag|option)\b/i,
   /\bauth(?:entication)?\b/i,
   /\bunauthorized\b/i,
   /\bforbidden\b/i,
   /\bapi\s+key\b/i,
-  /\bread-only file system\b/i
+  /\bread-only file system\b/i,
+  /\b(home|bootstrap)\s+(error|failed|cannot|denied|not\s+found)\b/i,
+  /\bpermission\s+denied\b/i
 ]);
 
 function workflowLauncherStatus(agent: string): LauncherStatus {
@@ -168,6 +171,10 @@ function commandInPath(name: string) {
   return result.status === 0 && result.stdout.trim().length > 0;
 }
 
+// Deterministic config/setup errors (invalid model IDs, auth failures,
+// unsupported CLI flags, home/bootstrap failures) must not poison the
+// persistent blocklist — only transient failures (runtime crashes, network
+// errors) deserve a block. Custom agents are never blocked.
 function shouldPersistLaunchFailureBlock(agent: string, result: LaunchResultLike | null | undefined) {
   if (!result || agent === 'custom') {return false;}
   const combined = [
@@ -592,7 +599,7 @@ function defaultIsAgentBlockedNow(agent: string) {
   try {
     const config = readAgentConfig(CONFIG_PATH, {});
     return isAgentBlocked(agent, config);
-  } catch (err) {
+  } catch (_err) {
     // If the config is malformed, surface that through the launcher path
     // (assertAgentSupported / launch) instead of silently rerouting. Treat as
     // not-blocked here so the existing error path runs.
@@ -907,10 +914,14 @@ async function startAgent(step: string, opts: StartAgentOptions = { prompt: '' }
       // setup/config errors (invalid model id, auth failure, read-only HOME, etc.)
       // should fall through to the next family without poisoning agents.local.json.
       if (shouldPersistLaunchFailureBlock(chosen || '', result)) {
+        let blockReason = 'transient crash';
+        if (result?.signal) { blockReason = `signal ${result.signal}`; }
+        else if (result?.error?.code) { blockReason = result.error.code; }
+        else if (result?.status !== null && result?.status !== 0) { blockReason = `exit ${result.status}`; }
         const blockUntil = formatBlockUntil(new Date(Date.now() + DEFAULT_FALLBACK_HOURS * 60 * 60 * 1000));
         try {
           const blockResult = updateAgentBlockFn(chosen || '', blockUntil);
-          log(fmt.status('INFO', `Wrote blocklist entry for ${fmt.agent(chosen || '')} -> ${fmt.path(blockResult.path)} (${DEFAULT_FALLBACK_HOURS}h block)`));
+          log(fmt.status('INFO', `Wrote blocklist entry for ${fmt.agent(chosen || '')} -> ${fmt.path(blockResult.path)} (${DEFAULT_FALLBACK_HOURS}h block, ${blockReason})`));
         } catch (err) {
           log(fmt.status('WARN', `Could not persist blocklist entry for ${fmt.agent(chosen || '')}: ${(err as any).message}`));
         }

package/lib/agents/mistral.js

@@ -1,22 +1,128 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMistralProviderModel = void 0;
 exports.buildMistralInvocation = buildMistralInvocation;
 exports.extractMistralSessionId = extractMistralSessionId;
+exports.processResult = processResult;
 exports.resolveMistralCommand = resolveMistralCommand;
 exports.startMistralAgent = startMistralAgent;
 const spawn_tee_js_1 = require("../core/spawn-tee.js");
-// Mistral Vibe in programmatic mode (-p/--prompt) does NOT output a resume
-// hint to stdout/stderr like other agents do. Session IDs are stored in
-// ~/.vibe/logs/session/session_<timestamp>_<short_id>/meta.json with UUID format,
-// but there is no reliable stdout pattern to extract. Therefore, Mistral is
-// NOT marked as RESUME_CAPABLE in agents.js. If future Vibe versions add
-// a resume hint, update this regex and add 'mistral' to RESUME_CAPABLE.
-// Current session ID format in meta.json: UUID like "a3dd3d4d-f97d-d57d-4942-a1f694e3a922"
-// Directory naming uses first 8 chars: session_20260521_162703_a3dd3d4d
-// No stdout marker detected in testing, so we leave this as null.
-// Telemetry: mistral/vibe does not expose token-usage data. See mistral-telemetry.ts
-// for the honest-zero stub. Stats hooks in active.js and review-loop.js call
-// recordStageStats which defaults to '0' for tokens when telemetry is null.
+const mistral_telemetry_js_1 = require("./mistral-telemetry.js");
+Object.defineProperty(exports, "getMistralProviderModel", { enumerable: true, get: function () { return mistral_telemetry_js_1.getMistralProviderModel; } });
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Maximum acceptable age (in minutes) for a mistral session's start_time
+ * relative to the invocation start. Sessions older than this window are
+ * rejected as potentially misattributed across concurrent missions.
+ */
+const MAX_SESSION_AGE_MINUTES = 120;
+function processResult(result, basePath, invocationStart) {
+    if (!result || typeof result !== 'object') {
+        return { sessionId: null, telemetry: null };
+    }
+    const scanDir = basePath || mistral_telemetry_js_1.DEFAULT_MISTRAL_LOG_DIR;
+    // Determine the invocation window for session correlation.
+    // When invocationStart is provided, only consider sessions whose
+    // start_time falls within MAX_SESSION_AGE_MINUTES of the invocation.
+    // This prevents cross-mission telemetry misattribution when multiple
+    // mistral phases run concurrently against a shared session directory.
+    let invokeTime = NaN;
+    let invokeWindow = null;
+    if (invocationStart) {
+        invokeTime = Date.parse(invocationStart);
+        if (!Number.isNaN(invokeTime)) {
+            const deltaMs = MAX_SESSION_AGE_MINUTES * 60000;
+            invokeWindow = { start: invokeTime - deltaMs, end: invokeTime + deltaMs };
+        }
+    }
+    // Scan session directories chronologically (sorted by basename).
+    // For each session, check if its start_time falls within the invocation
+    // window, then pick the session closest to the invocation start time.
+    // This replaces the previous approach of calling extractMistralTelemetry
+    // which always returned the globally newest session regardless of which
+    // invocation it belonged to.
+    let bestTelemetry = null;
+    let bestDistance = Infinity;
+    try {
+        const entries = node_fs_1.default.readdirSync(scanDir);
+        const dirs = entries.filter((d) => d.startsWith('session_')).sort();
+        for (const dir of dirs) {
+            const metaPath = node_path_1.default.join(scanDir, dir, 'meta.json');
+            if (!node_fs_1.default.existsSync(metaPath)) {
+                continue;
+            }
+            let content;
+            try {
+                content = node_fs_1.default.readFileSync(metaPath, 'utf8');
+            }
+            catch (_) {
+                continue;
+            }
+            let meta;
+            try {
+                meta = JSON.parse(content);
+            }
+            catch (_) {
+                continue;
+            }
+            const startTime = meta.start_time;
+            if (typeof startTime !== 'string') {
+                continue;
+            }
+            const sessionTime = Date.parse(startTime);
+            if (Number.isNaN(sessionTime)) {
+                continue;
+            }
+            // Check invocation window if applicable
+            if (invokeWindow && (sessionTime < invokeWindow.start || sessionTime > invokeWindow.end)) {
+                continue;
+            }
+            const telemetry = (0, mistral_telemetry_js_1.parseMistralMeta)(meta);
+            if (!telemetry) {
+                continue;
+            }
+            // When no invocationStart is provided, pick the first valid session.
+            // When invocationStart is provided, pick the session closest in time.
+            if (Number.isNaN(invokeTime)) {
+                bestTelemetry = telemetry;
+                break;
+            }
+            const distance = Math.abs(sessionTime - invokeTime);
+            if (distance < bestDistance) {
+                bestTelemetry = telemetry;
+                bestDistance = distance;
+            }
+        }
+    }
+    catch (_) {
+        // Directory unreadable — fall through to null telemetry
+    }
+    if (!bestTelemetry) {
+        return { ...result, sessionId: result.sessionId || null, telemetry: null };
+    }
+    const allToolCalls = (bestTelemetry.toolCallsAgreed || 0) +
+        (bestTelemetry.toolCallsRejected || 0) +
+        (bestTelemetry.toolCallsFailed || 0) +
+        (bestTelemetry.toolCallsSucceeded || 0);
+    const pm = (0, mistral_telemetry_js_1.getMistralProviderModel)();
+    const model = bestTelemetry.contextTokens > 0 || bestTelemetry.inputTokens > 0 ? 'mistral' : pm.model;
+    result.telemetry = {
+        provider: pm.provider,
+        model,
+        inputTokens: bestTelemetry.inputTokens,
+        outputTokens: bestTelemetry.outputTokens,
+        cachedTokens: bestTelemetry.contextTokens,
+        totalTokens: bestTelemetry.totalTokens,
+        toolCalls: allToolCalls,
+        usagePercent: null,
+        cost_usd: bestTelemetry.sessionCost,
+    };
+    return { ...result, sessionId: result.sessionId || null };
+}
 function extractMistralSessionId(stdout) {
     void stdout;
     // Vibe does not currently emit a resume hint in programmatic mode.
@@ -29,7 +135,14 @@ function resolveMistralCommand() {
 function buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model = null }) {
     void resume;
     void sessionId;
-    const args = ['--prompt', prompt, '--trust', '--output', 'text'];
+    // --trust only bypasses the working-directory trust prompt; tool-call
+    // approval is a separate gate that vibe --help documents as controlled by
+    // --auto-approve/--yolo. Without it, any prompt that needs a tool call
+    // blocks on interactive approval outside a TTY and fails with a generic
+    // error, which then gets misread as a real launch failure and persisted
+    // to the blocklist (claude/opencode/codex all pass their own equivalent
+    // non-interactive bypass already).
+    const args = ['--prompt', prompt, '--trust', '--yolo', '--output', 'text'];
     // Vibe programmatic mode does not support --resume flag in the same way
     // as other agents. The --resume flag exists but requires interactive selection
     // or a session picker. Since we cannot reliably pass a session ID via
@@ -50,11 +163,12 @@ function buildMistralInvocation({ prompt, worktree, env, resume, sessionId, mode
 }
 function startMistralAgent({ prompt, worktree, env, resume = false, sessionId = null, model = null, teeOptions = {} }) {
     const invocation = buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model });
+    const invocationStart = new Date().toISOString();
     const resultPromise = (0, spawn_tee_js_1.spawnAndTee)(invocation.command, invocation.args, { ...invocation.options, ...teeOptions }).then((result) => {
         if (result && result.stdout) {
             result.sessionId = extractMistralSessionId(result.stdout);
         }
-        return result;
+        return processResult(result, undefined, invocationStart);
     });
     return { invocation, resultPromise };
 }

package/lib/agents/mistral.ts

@@ -1,4 +1,14 @@
 import { spawnAndTee } from '../core/spawn-tee.js';
+import { parseMistralMeta, getMistralProviderModel, DEFAULT_MISTRAL_LOG_DIR } from './mistral-telemetry.js';
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * Maximum acceptable age (in minutes) for a mistral session's start_time
+ * relative to the invocation start. Sessions older than this window are
+ * rejected as potentially misattributed across concurrent missions.
+ */
+const MAX_SESSION_AGE_MINUTES = 120;
 
 interface MistralInvocationOptions {
   prompt: string;
@@ -22,10 +32,130 @@ interface StartMistralAgentOptions extends MistralInvocationOptions {
 // Current session ID format in meta.json: UUID like "a3dd3d4d-f97d-d57d-4942-a1f694e3a922"
 // Directory naming uses first 8 chars: session_20260521_162703_a3dd3d4d
 // No stdout marker detected in testing, so we leave this as null.
-// Telemetry: mistral/vibe does not expose token-usage data. See mistral-telemetry.ts
-// for the honest-zero stub. Stats hooks in active.js and review-loop.js call
-// recordStageStats which defaults to '0' for tokens when telemetry is null.
+// Telemetry: mistral/vibe writes structured token-usage data to meta.json files
+// in ~/.vibe/logs/session/. This module's processResult function scans session
+// directories and correlates by start_time window to prevent cross-mission
+// telemetry misattribution. The mapped telemetry is consumed by
+// telemetryToStatsFields in lib/commands/stats.ts.
+
+
+interface ProcessedResult {
+  sessionId: string | null;
+  telemetry: {
+    provider: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    cachedTokens: number;
+    totalTokens: number;
+    toolCalls: number;
+    usagePercent: null;
+    cost_usd: number;
+  } | null;
+  [key: string]: unknown;
+}
+
+function processResult(result: any, basePath?: string, invocationStart?: string): ProcessedResult {
+  if (!result || typeof result !== 'object') {
+    return { sessionId: null, telemetry: null };
+  }
+
+  const scanDir = basePath || DEFAULT_MISTRAL_LOG_DIR;
+
+  // Determine the invocation window for session correlation.
+  // When invocationStart is provided, only consider sessions whose
+  // start_time falls within MAX_SESSION_AGE_MINUTES of the invocation.
+  // This prevents cross-mission telemetry misattribution when multiple
+  // mistral phases run concurrently against a shared session directory.
+  let invokeTime = NaN;
+  let invokeWindow: { start: number; end: number } | null = null;
+  if (invocationStart) {
+    invokeTime = Date.parse(invocationStart);
+    if (!Number.isNaN(invokeTime)) {
+      const deltaMs = MAX_SESSION_AGE_MINUTES * 60000;
+      invokeWindow = { start: invokeTime - deltaMs, end: invokeTime + deltaMs };
+    }
+  }
+
+  // Scan session directories chronologically (sorted by basename).
+  // For each session, check if its start_time falls within the invocation
+  // window, then pick the session closest to the invocation start time.
+  // This replaces the previous approach of calling extractMistralTelemetry
+  // which always returned the globally newest session regardless of which
+  // invocation it belonged to.
+  let bestTelemetry: ReturnType<typeof parseMistralMeta> | null = null;
+  let bestDistance = Infinity;
+
+  try {
+    const entries = fs.readdirSync(scanDir);
+    const dirs = entries.filter((d: string) => d.startsWith('session_')).sort();
+
+    for (const dir of dirs) {
+      const metaPath = path.join(scanDir, dir, 'meta.json');
+      if (!fs.existsSync(metaPath)) { continue; }
+
+      let content: string;
+      try { content = fs.readFileSync(metaPath, 'utf8'); } catch (_) { continue; }
 
+      let meta: Record<string, unknown>;
+      try { meta = JSON.parse(content); } catch (_) { continue; }
+
+      const startTime = meta.start_time;
+      if (typeof startTime !== 'string') { continue; }
+      const sessionTime = Date.parse(startTime);
+      if (Number.isNaN(sessionTime)) { continue; }
+
+      // Check invocation window if applicable
+      if (invokeWindow && (sessionTime < invokeWindow.start || sessionTime > invokeWindow.end)) {
+        continue;
+      }
+
+      const telemetry = parseMistralMeta(meta);
+      if (!telemetry) { continue; }
+
+      // When no invocationStart is provided, pick the first valid session.
+      // When invocationStart is provided, pick the session closest in time.
+      if (Number.isNaN(invokeTime)) {
+        bestTelemetry = telemetry;
+        break;
+      }
+      const distance = Math.abs(sessionTime - invokeTime);
+      if (distance < bestDistance) {
+        bestTelemetry = telemetry;
+        bestDistance = distance;
+      }
+    }
+  } catch (_) {
+    // Directory unreadable — fall through to null telemetry
+  }
+
+  if (!bestTelemetry) {
+    return { ...result, sessionId: result.sessionId || null, telemetry: null } as ProcessedResult;
+  }
+
+  const allToolCalls =
+    (bestTelemetry.toolCallsAgreed || 0) +
+    (bestTelemetry.toolCallsRejected || 0) +
+    (bestTelemetry.toolCallsFailed || 0) +
+    (bestTelemetry.toolCallsSucceeded || 0);
+
+  const pm = getMistralProviderModel();
+  const model = bestTelemetry.contextTokens > 0 || bestTelemetry.inputTokens > 0 ? 'mistral' : pm.model;
+
+  result.telemetry = {
+    provider: pm.provider,
+    model,
+    inputTokens: bestTelemetry.inputTokens,
+    outputTokens: bestTelemetry.outputTokens,
+    cachedTokens: bestTelemetry.contextTokens,
+    totalTokens: bestTelemetry.totalTokens,
+    toolCalls: allToolCalls,
+    usagePercent: null,
+    cost_usd: bestTelemetry.sessionCost,
+  };
+
+  return { ...result, sessionId: result.sessionId || null } as ProcessedResult;
+}
 
 function extractMistralSessionId(stdout: string) {
   void stdout;
@@ -41,7 +171,14 @@ function resolveMistralCommand() {
 function buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model = null }: MistralInvocationOptions) {
   void resume;
   void sessionId;
-  const args = ['--prompt', prompt, '--trust', '--output', 'text'];
+  // --trust only bypasses the working-directory trust prompt; tool-call
+  // approval is a separate gate that vibe --help documents as controlled by
+  // --auto-approve/--yolo. Without it, any prompt that needs a tool call
+  // blocks on interactive approval outside a TTY and fails with a generic
+  // error, which then gets misread as a real launch failure and persisted
+  // to the blocklist (claude/opencode/codex all pass their own equivalent
+  // non-interactive bypass already).
+  const args = ['--prompt', prompt, '--trust', '--yolo', '--output', 'text'];
 
   // Vibe programmatic mode does not support --resume flag in the same way
   // as other agents. The --resume flag exists but requires interactive selection
@@ -66,11 +203,12 @@ function buildMistralInvocation({ prompt, worktree, env, resume, sessionId, mode
 
 function startMistralAgent({ prompt, worktree, env, resume = false, sessionId = null, model = null, teeOptions = {} }: StartMistralAgentOptions) {
   const invocation = buildMistralInvocation({ prompt, worktree, env, resume, sessionId, model });
+  const invocationStart = new Date().toISOString();
   const resultPromise = spawnAndTee(invocation.command, invocation.args, { ...invocation.options, ...teeOptions } as any).then((result: any) => {
     if (result && result.stdout) {
       result.sessionId = extractMistralSessionId(result.stdout);
     }
-    return result;
+    return processResult(result, undefined, invocationStart);
   });
 
   return { invocation, resultPromise };
@@ -79,6 +217,8 @@ function startMistralAgent({ prompt, worktree, env, resume = false, sessionId =
 export {
   buildMistralInvocation,
   extractMistralSessionId,
+  getMistralProviderModel,
+  processResult,
   resolveMistralCommand,
   startMistralAgent
 };

package/lib/commands/active.js

@@ -297,14 +297,14 @@ function applyExecuteFallback(opts) {
  * @returns {Promise<{relaunched: boolean, error?: string}>} Result of relaunch attempt
  */
 /**
- * @param {string} slug
- * @param {string} worktree
- * @param {string} errorMsg
- * @param {string} agent
- * @param {{isRelaunchableErrorFn?: Function, buildRelaunchPromptFn?: Function, workflowLauncherStatusFn?: Function, startAgentFn?: Function, log?: Function, error?: Function}} [options]
- */
+  * @param {string} slug
+  * @param {string} worktree
+  * @param {string} errorMsg
+  * @param {string} agent
+  * @param {{isRelaunchableErrorFn?: Function, buildRelaunchPromptFn?: Function, workflowLauncherStatusFn?: Function, startAgentFn?: Function, log?: Function, error?: Function, gateOutput?: {stdout: string, stderr: string}}} [options]
+  */
 async function attemptAgentRelaunch(slug, worktree, errorMsg, agent, options = {}) {
-    const { isRelaunchableErrorFn = repairHandoff.isRelaunchableError, buildRelaunchPromptFn = repairHandoff.buildRelaunchPrompt, workflowLauncherStatusFn = agents.workflowLauncherStatus, startAgentFn = agents.startAgent, log = fmt.log.plain, error = fmt.log.plainError } = options;
+    const { isRelaunchableErrorFn = repairHandoff.isRelaunchableError, buildRelaunchPromptFn = repairHandoff.buildRelaunchPrompt, workflowLauncherStatusFn = agents.workflowLauncherStatus, startAgentFn = agents.startAgent, log = fmt.log.plain, error = fmt.log.plainError, gateOutput } = options;
     // Check if this is a relaunchable error
     if (!isRelaunchableErrorFn(errorMsg)) {
         log(`Error is not relaunchable: ${errorMsg}`);
@@ -316,8 +316,8 @@ async function attemptAgentRelaunch(slug, worktree, errorMsg, agent, options = {
         error(`Agent ${fmt.agent(agent)} is not available for relaunch: ${status.detail || status.reason || 'unknown'}`);
         return { relaunched: false, error: `Agent ${agent} launcher is not available` };
     }
-    // Build the relaunch prompt
-    const prompt = buildRelaunchPromptFn(errorMsg, slug, worktree);
+    // Build the relaunch prompt, passing captured gate output if available (task-1387)
+    const prompt = buildRelaunchPromptFn(errorMsg, slug, worktree, gateOutput);
     log(`Attempting to relaunch ${fmt.agent(agent)} to fix repairable handoff error...`);
     // startAgent handles resume flags internally for resume-capable agents (codex, claude, gemini, custom)
     try {
@@ -394,7 +394,7 @@ function validateCheckpointsBeforeHandoff(slug, worktree, options = {}) {
   * @param {{taskFile?: string | null, validateCheckpointsBeforeHandoffFn?: Function, performHandoff?: Function, startReviewLoop?: Function, repairHandoffFn?: {isRelaunchableError: Function, buildRelaunchPrompt: Function}, attemptAgentRelaunchFn?: Function, log?: Function, error?: Function}} [options]
  */
 async function runHandoffAndReview(slug, worktree, agent, options = {}) {
-    const { taskFile = null, validateCheckpointsBeforeHandoffFn = validateCheckpointsBeforeHandoff, performHandoff: _performHandoff = (/** @type{string} */ s, /** @type{object} */ o) => handoff.performHandoff(s, o), startReviewLoop: _startReviewLoop = (/** @type{string} */ s, /** @type{object} */ o) => review.startReviewLoop(s, o), repairHandoffFn = /** @type{(s: string, w: string, e: string, o: object) => Promise<{repaired: boolean, blocker?: string}>} */ (repairHandoff), attemptAgentRelaunchFn = attemptAgentRelaunch, log = fmt.log.plain, error = fmt.log.plainError } = options;
+    const { taskFile = null, validateCheckpointsBeforeHandoffFn = validateCheckpointsBeforeHandoff, performHandoff: _performHandoff = (/** @type{string} */ s, /** @type{object} */ o) => handoff.performHandoff(s, o), startReviewLoop: _startReviewLoop = (/** @type{string} */ s, /** @type{object} */ o) => review.startReviewLoop(s, o), repairHandoffFn = /** @type{(s: string, w: string, e: string, o: object) => Promise<{repaired: boolean, blocker?: string}>} */ (repairHandoff.default), attemptAgentRelaunchFn = attemptAgentRelaunch, log = fmt.log.plain, error = fmt.log.plainError } = options;
     // Pre-handoff checkpoint enforcement: validate checkpoints exist before calling performHandoff()
     // This catches missing checkpoints immediately after the execute agent exits,
     // before the repair flow runs, and provides an explicit instruction to create them.
@@ -407,38 +407,68 @@ async function runHandoffAndReview(slug, worktree, agent, options = {}) {
     }
     let handoffResult = await _performHandoff(slug, { forgejoUser: agent, worktree });
     if (!handoffResult.ok) {
-        // Attempt single repair for routine hygiene issues (dirty artifacts, rebase needed)
-        log(`\nAutomated handoff failed: ${handoffResult.error}`);
-        log(`Attempting post-execute repair...`);
-        const { repaired, blocker } = await /** @type{Function} */ (repairHandoffFn)(slug, worktree, /** @type{string} */ (handoffResult.error), { taskFile, log, error });
-        if (repaired) {
-            log(`Repair successful. Retrying automated handoff...`);
-            handoffResult = await _performHandoff(slug, { forgejoUser: agent, worktree, force: true });
-        }
-        else if (blocker) {
-            // If repair failed but provided a specific blocker (e.g. rebase failure),
-            // report that blocker as the final error instead of the original handoff error.
-            handoffResult.error = blocker;
+        // Check for genuine gate failure (task-1387): automatic relaunch with captured output
+        const isGenuineGateFailure = handoffResult.gateOutput ||
+            (handoffResult.error && (/verification gate failed/i.test(handoffResult.error) ||
+                (/\bdeclared gate\b/i.test(handoffResult.error) && /\bfailed\b/i.test(handoffResult.error))));
+        if (isGenuineGateFailure) {
+            // Automatic relaunch with captured gate output, bounded to max 2 attempts
+            let relaunchCount = 0;
+            const maxRelaunches = 2;
+            while (relaunchCount < maxRelaunches) {
+                relaunchCount++;
+                log(`\nGenuine gate failure detected. Relaunch attempt ${relaunchCount}/${maxRelaunches}...`);
+                const { relaunched, error: relaunchError } = await attemptAgentRelaunchFn(slug, worktree, /** @type{string} */ (handoffResult.error), agent, { log, error, gateOutput: handoffResult.gateOutput });
+                if (relaunched) {
+                    handoffResult = await _performHandoff(slug, { forgejoUser: agent, worktree, force: true });
+                    if (handoffResult.ok) {
+                        break; // Success — proceed to review loop
+                    }
+                    // Handoff still failed; continue loop for another relaunch attempt
+                }
+                else {
+                    log(`Agent relaunch failed: ${relaunchError || 'unknown error'}`);
+                    break; // Relaunch itself failed; stop
+                }
+            }
+            if (!handoffResult.ok && relaunchCount >= maxRelaunches) {
+                handoffResult.error = `Gate failure persisting after ${maxRelaunches} relaunch attempts. Manual intervention required.`;
+            }
         }
-        else if (!repaired && repairHandoff.isRelaunchableError(handoffResult.error)) {
-            // Attempt agent relaunch for repairable content errors (missing goal-check table)
-            log(`Content error detected. Attempting agent relaunch to fix...`);
-            const { relaunched, error: relaunchError } = await attemptAgentRelaunchFn(slug, worktree, /** @type{string} */ (handoffResult.error), agent, { log, error });
-            if (relaunched) {
-                // Agent was relaunched successfully; re-invoke performHandoff to verify
-                // the handoff-to-review transition actually completed, matching the
-                // contract of the repair-success path above.
-                log(`Agent relaunched. It will fix the checkpoint and retry handoff.`);
+        else {
+            // Original logic: attempt single repair for routine hygiene issues (dirty artifacts, rebase needed)
+            log(`\nAutomated handoff failed: ${handoffResult.error}`);
+            log(`Attempting post-execute repair...`);
+            const { repaired, blocker } = await /** @type{Function} */ (repairHandoffFn)(slug, worktree, /** @type{string} */ (handoffResult.error), { taskFile, log, error });
+            if (repaired) {
+                log(`Repair successful. Retrying automated handoff...`);
                 handoffResult = await _performHandoff(slug, { forgejoUser: agent, worktree, force: true });
-                if (!handoffResult.ok) {
-                    handoffResult.error = `Post-relaunch handoff failed: ${handoffResult.error || 'unknown'}`;
-                }
-                // Fall through to gatekeeper pushback / review loop / failure handling below.
             }
-            else {
-                // Relaunch failed or was not possible
-                log(`Agent relaunch failed: ${relaunchError || 'unknown error'}`);
-                // Fall through to manual handoff message
+            else if (blocker) {
+                // If repair failed but provided a specific blocker (e.g. rebase failure),
+                // report that blocker as the final error instead of the original handoff error.
+                handoffResult.error = blocker;
+            }
+            else if (!repaired && repairHandoff.isRelaunchableError(handoffResult.error)) {
+                // Attempt agent relaunch for repairable content errors (missing goal-check table)
+                log(`Content error detected. Attempting agent relaunch to fix...`);
+                const { relaunched, error: relaunchError } = await attemptAgentRelaunchFn(slug, worktree, /** @type{string} */ (handoffResult.error), agent, { log, error });
+                if (relaunched) {
+                    // Agent was relaunched successfully; re-invoke performHandoff to verify
+                    // the handoff-to-review transition actually completed, matching the
+                    // contract of the repair-success path above.
+                    log(`Agent relaunched. It will fix the checkpoint and retry handoff.`);
+                    handoffResult = await _performHandoff(slug, { forgejoUser: agent, worktree, force: true });
+                    if (!handoffResult.ok) {
+                        handoffResult.error = `Post-relaunch handoff failed: ${handoffResult.error || 'unknown'}`;
+                    }
+                    // Fall through to gatekeeper pushback / review loop / failure handling below.
+                }
+                else {
+                    // Relaunch failed or was not possible
+                    log(`Agent relaunch failed: ${relaunchError || 'unknown error'}`);
+                    // Fall through to manual handoff message
+                }
             }
         }
     }