@magnusekdahl/parallix 1.3.2 → 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-telemetry.js

@@ -1,40 +1,139 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MISTRAL_LOG_DIR = void 0;
+exports.parseMistralMeta = parseMistralMeta;
+exports.extractMistralTelemetry = extractMistralTelemetry;
+exports.getMistralProviderModel = getMistralProviderModel;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
 /**
- * Mistral (Vibe) Telemetry Stub
+ * Mistral (Vibe) Telemetry Parser
+ *
+ * Mistral Vibe writes structured token-usage data to per-session meta files:
+ *   ~/.vibe/logs/session/<session_id>/meta.json
  *
- * Mistral Vibe in programmatic mode does not output token-usage data to
- * stdout/stderr, and has no CLI endpoint for querying session usage.
- * This stub records honest zeros for all token columns so the stats CSV
- * never contains fabricated data.
+ * Each meta.json contains a `stats` object with token counts:
+ *   - session_prompt_tokens  → inputTokens
+ *   - session_completion_tokens → outputTokens
+ *   - session_total_llm_tokens → totalTokens
  *
- * Provider and model fields are set to "mistral" to indicate the agent family.
- * The actual model is determined at runtime via VIBE_ACTIVE_MODEL env var
- * but is not captured per-session, so model falls back to "mistral".
+ * This module scans that directory for the most recent meta.json, parses the
+ * stats block, and returns a telemetry object mirroring the shape used by
+ * codex-telemetry.ts.
  *
- * See task-1285 for the full telemetry credibility design. The blocked
- * verification is tracked as follow-up task-1288 ("Verify vibe/mistral
- * telemetry once usage-unblocked"), which names the missing evidence and the
- * reason it could not be collected in the task-1285 environment.
+ * See task-1288 for the discovery that confirmed the structured source.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractMistralTelemetry = extractMistralTelemetry;
-exports.getMistralProviderModel = getMistralProviderModel;
 /**
- * Attempt to extract telemetry from a mistral launcher result.
- * Since mistral/vibe provides no parseable usage data, always returns null.
+ * The default directory where Vibe writes its session meta files.
+ * Overridden by tests via extractMistralTelemetry(basePath).
+ */
+exports.DEFAULT_MISTRAL_LOG_DIR = node_path_1.default.join(node_os_1.default.homedir(), '.vibe', 'logs', 'session');
+/**
+ * Parse the `stats` block from a meta.json file into a telemetry object.
+ * Returns null when the content yields no usable signal (missing stats,
+ * empty object, or non-object stats).
+ */
+function parseMistralMeta(meta) {
+    if (!meta || typeof meta !== 'object') {
+        return null;
+    }
+    const stats = meta.stats;
+    if (!stats || typeof stats !== 'object') {
+        return null;
+    }
+    const s = stats;
+    const inputTokens = Number(s.session_prompt_tokens) || 0;
+    const outputTokens = Number(s.session_completion_tokens) || 0;
+    const totalTokens = Number(s.session_total_llm_tokens) || 0;
+    // Return null when there is no usable signal (all zeros).
+    // Mirrors the codex-telemetry pattern where honest zeros still indicate
+    // a parseable source was found but contained no actual usage.
+    if (!inputTokens && !outputTokens && !totalTokens) {
+        return null;
+    }
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens,
+        contextTokens: Number(s.context_tokens) || 0,
+        toolCallsAgreed: Number(s.tool_calls_agreed) || 0,
+        toolCallsRejected: Number(s.tool_calls_rejected) || 0,
+        toolCallsFailed: Number(s.tool_calls_failed) || 0,
+        toolCallsSucceeded: Number(s.tool_calls_succeeded) || 0,
+        sessionCost: Number(s.session_cost) || 0,
+    };
+}
+/**
+ * Scan ~/.vibe/logs/session/ for the most recent session meta.json, parse its
+ * stats block, and return a telemetry object.
  *
- * @param {object} result - The launcher result object
- * @returns {null} Always null — mistral/vibe has no telemetry parser
+ * @param result - Legacy launcher result object (ignored; kept for API compat)
+ * @param basePath - Override the default session log directory. Used by tests.
  */
-function extractMistralTelemetry() {
-    // Mistral Vibe does not emit token usage data. Honest zero.
+function extractMistralTelemetry(result, basePath) {
+    void result; // legacy param, ignored — telemetry comes from on-disk meta.json
+    const scanDir = basePath || exports.DEFAULT_MISTRAL_LOG_DIR;
+    // Scan session subdirectories for the newest meta.json.
+    // Basenames are session_<YYYYMMDD>_<HHMMSS>_<id>, so alphabetical sort = chronological.
+    let sessionDirs;
+    try {
+        sessionDirs = node_fs_1.default.readdirSync(scanDir);
+    }
+    catch (_) {
+        return null;
+    }
+    const dirs = sessionDirs
+        .filter((d) => {
+        if (!d.startsWith('session_')) {
+            return false;
+        }
+        const full = node_path_1.default.join(scanDir, d);
+        try {
+            return node_fs_1.default.statSync(full).isDirectory();
+        }
+        catch (_) {
+            return false;
+        }
+    })
+        .sort();
+    if (dirs.length === 0) {
+        return null;
+    }
+    // Walk newest-first; return the first session that has a parseable meta.json.
+    for (let i = dirs.length - 1; i >= 0; i--) {
+        const metaPath = node_path_1.default.join(scanDir, dirs[i], '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 telemetry = parseMistralMeta(meta);
+        if (!telemetry) {
+            continue;
+        }
+        return { ...telemetry, path: metaPath };
+    }
     return null;
 }
 /**
  * Return the provider/model pair for mistral tasks.
  * Used as fallback when telemetry is null.
- *
- * @returns {{provider: string, model: string}}
  */
 function getMistralProviderModel() {
     return { provider: 'mistral', model: 'mistral' };

package/lib/agents/mistral-telemetry.ts

@@ -1,44 +1,159 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
 /**
- * Mistral (Vibe) Telemetry Stub
+ * Mistral (Vibe) Telemetry Parser
+ *
+ * Mistral Vibe writes structured token-usage data to per-session meta files:
+ *   ~/.vibe/logs/session/<session_id>/meta.json
  *
- * Mistral Vibe in programmatic mode does not output token-usage data to
- * stdout/stderr, and has no CLI endpoint for querying session usage.
- * This stub records honest zeros for all token columns so the stats CSV
- * never contains fabricated data.
+ * Each meta.json contains a `stats` object with token counts:
+ *   - session_prompt_tokens  → inputTokens
+ *   - session_completion_tokens → outputTokens
+ *   - session_total_llm_tokens → totalTokens
  *
- * Provider and model fields are set to "mistral" to indicate the agent family.
- * The actual model is determined at runtime via VIBE_ACTIVE_MODEL env var
- * but is not captured per-session, so model falls back to "mistral".
+ * This module scans that directory for the most recent meta.json, parses the
+ * stats block, and returns a telemetry object mirroring the shape used by
+ * codex-telemetry.ts.
  *
- * See task-1285 for the full telemetry credibility design. The blocked
- * verification is tracked as follow-up task-1288 ("Verify vibe/mistral
- * telemetry once usage-unblocked"), which names the missing evidence and the
- * reason it could not be collected in the task-1285 environment.
+ * See task-1288 for the discovery that confirmed the structured source.
+ */
+
+/**
+ * The default directory where Vibe writes its session meta files.
+ * Overridden by tests via extractMistralTelemetry(basePath).
  */
+export const DEFAULT_MISTRAL_LOG_DIR = path.join(os.homedir(), '.vibe', 'logs', 'session');
+
+interface TelemetryResult {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+  contextTokens: number;
+  toolCallsAgreed: number;
+  toolCallsRejected: number;
+  toolCallsFailed: number;
+  toolCallsSucceeded: number;
+  sessionCost: number;
+  path?: string;
+}
+
+interface ParseableMeta {
+  stats?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+interface StatsBlock {
+  session_prompt_tokens?: unknown;
+  session_completion_tokens?: unknown;
+  session_total_llm_tokens?: unknown;
+  context_tokens?: unknown;
+  tool_calls_agreed?: unknown;
+  tool_calls_rejected?: unknown;
+  tool_calls_failed?: unknown;
+  tool_calls_succeeded?: unknown;
+  session_cost?: unknown;
+  [key: string]: unknown;
+}
 
 /**
- * Attempt to extract telemetry from a mistral launcher result.
- * Since mistral/vibe provides no parseable usage data, always returns null.
+ * Parse the `stats` block from a meta.json file into a telemetry object.
+ * Returns null when the content yields no usable signal (missing stats,
+ * empty object, or non-object stats).
+ */
+export function parseMistralMeta(meta: ParseableMeta | null | undefined): TelemetryResult | null {
+  if (!meta || typeof meta !== 'object') {return null;}
+
+  const stats = meta.stats;
+  if (!stats || typeof stats !== 'object') {return null;}
+
+  const s = stats as StatsBlock;
+  const inputTokens = Number(s.session_prompt_tokens) || 0;
+  const outputTokens = Number(s.session_completion_tokens) || 0;
+  const totalTokens = Number(s.session_total_llm_tokens) || 0;
+
+  // Return null when there is no usable signal (all zeros).
+  // Mirrors the codex-telemetry pattern where honest zeros still indicate
+  // a parseable source was found but contained no actual usage.
+  if (!inputTokens && !outputTokens && !totalTokens) {return null;}
+
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    contextTokens: Number(s.context_tokens) || 0,
+    toolCallsAgreed: Number(s.tool_calls_agreed) || 0,
+    toolCallsRejected: Number(s.tool_calls_rejected) || 0,
+    toolCallsFailed: Number(s.tool_calls_failed) || 0,
+    toolCallsSucceeded: Number(s.tool_calls_succeeded) || 0,
+    sessionCost: Number(s.session_cost) || 0,
+  };
+}
+
+/**
+ * Scan ~/.vibe/logs/session/ for the most recent session meta.json, parse its
+ * stats block, and return a telemetry object.
  *
- * @param {object} result - The launcher result object
- * @returns {null} Always null — mistral/vibe has no telemetry parser
+ * @param result - Legacy launcher result object (ignored; kept for API compat)
+ * @param basePath - Override the default session log directory. Used by tests.
  */
-function extractMistralTelemetry() {
-  // Mistral Vibe does not emit token usage data. Honest zero.
+export function extractMistralTelemetry(result: unknown, basePath?: string): TelemetryResult | null {
+  void result; // legacy param, ignored — telemetry comes from on-disk meta.json
+
+  const scanDir = basePath || DEFAULT_MISTRAL_LOG_DIR;
+
+  // Scan session subdirectories for the newest meta.json.
+  // Basenames are session_<YYYYMMDD>_<HHMMSS>_<id>, so alphabetical sort = chronological.
+  let sessionDirs: string[];
+  try {
+    sessionDirs = fs.readdirSync(scanDir);
+  } catch (_) {
+    return null;
+  }
+
+  const dirs = sessionDirs
+    .filter((d: string) => {
+      if (!d.startsWith('session_')) {return false;}
+      const full = path.join(scanDir, d);
+      try { return fs.statSync(full).isDirectory(); } catch (_) { return false; }
+    })
+    .sort();
+
+  if (dirs.length === 0) {return null;}
+
+  // Walk newest-first; return the first session that has a parseable meta.json.
+  for (let i = dirs.length - 1; i >= 0; i--) {
+    const metaPath = path.join(scanDir, dirs[i], 'meta.json');
+    if (!fs.existsSync(metaPath)) {continue;}
+
+    let content: string;
+    try {
+      content = fs.readFileSync(metaPath, 'utf8');
+    } catch (_) {
+      continue;
+    }
+
+    let meta: ParseableMeta;
+    try {
+      meta = JSON.parse(content);
+    } catch (_) {
+      continue;
+    }
+
+    const telemetry = parseMistralMeta(meta);
+    if (!telemetry) {continue;}
+
+    return { ...telemetry, path: metaPath };
+  }
+
   return null;
 }
 
 /**
  * Return the provider/model pair for mistral tasks.
  * Used as fallback when telemetry is null.
- *
- * @returns {{provider: string, model: string}}
  */
-function getMistralProviderModel() {
+export function getMistralProviderModel(): { provider: string; model: string } {
   return { provider: 'mistral', model: 'mistral' };
 }
-
-export {
-  extractMistralTelemetry,
-  getMistralProviderModel,
-};

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.js
-// 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 };
 }