@magnusekdahl/parallix 1.3.1 → 1.3.3

package/README.md

@@ -145,11 +145,13 @@ px active task-042
 
 # Land it: runs configured integration gates, squash-merges to
 # the primary branch, updates board state, removes the branch
-# and worktree.
+# and worktree. In this repo that means a fast general verifier
+# during earlier phases and a stricter lifecycle E2E gate before
+# integrate lands.
 px integrate task-042
 ```
 
-The verification gate that runs at each checkpoint is whatever you declare in `workflow.config.json` (this repo declares `npm test`), so the workflow adopts your existing CI rather than replacing it.
+The verification gate that runs at each phase is whatever you declare in `workflow.config.json`. In this repo that dispatcher is `./scripts/verify-local.sh {{area}}`: earlier phases use the fast general suite, while `px integrate` calls `verify-local.sh integrate`, which resolves repo-side integration gates from `config/integration-pipelines.json` and runs the stricter pre-merge checks there.
 
 ## Use cases
 

package/config/integration-pipelines.json

@@ -4,6 +4,11 @@
       "command": "./scripts/verify-local.sh static-analysis",
       "order": 1,
       "run_last": false
+    },
+    "workflow": {
+      "command": "node test/e2e-mission-lifecycle.test.js",
+      "order": 50,
+      "run_last": true
     }
   }
 }

package/docs/adr/0048-fail-closed-harness-defense-against-agent-hallucinations.md

@@ -0,0 +1,161 @@
+# ADR 0048: Fail-closed harness defense against agent hallucinations
+
+Status: Accepted
+Date: 2026-06-29
+
+Related: ADR 0041 (integration pipeline gates), ADR 0047 (NEL budget), task-1268 (shift-left verification), task-1335 (harden publish path)
+
+## Context
+
+Parallix already has meaningful defenses against agent hallucinations and incomplete work, but they are fragmented across commands and missions rather than expressed as one coherent harness policy. The repo has exact-tree verification proof (task-1335), handoff pre-checks, gatekeeper mandatory-artifact checks (gatekeeper.js), integration-time gates (ADR 0041), and a narrow auto-repair path (repair-handoff.js). It also has open work on shift-left verification (task-1268).
+
+What it does not yet have is one explicit answer to a repository-level question: **given a failed or incomplete agent handoff, which failure classes should auto-repair, which should auto-send-back to the implementer, and which genuinely require human intervention?**
+
+The current `repair-handoff.js` handles only two mechanical error classes (dirty mission artifacts, branch behind primary) and one relaunchable content error (empty goal-check table). All other failures — including genuine gate failures on code issues, the single largest consumer of human time — strand with a generic "not automatically repairable" message that requires manual re-invocation.
+
+This ADR consolidates the existing evidence, classifies the failure modes, and recommends a fully backlog-tracked implementation plan for fail-closed harness behavior. Nothing in the recommended control set is left as an untracked "defer later" idea: every control gets an explicit backlog task, even when the runtime outcome remains "human required".
+
+## Inputs
+
+This decision draws on four prior Parallix artifacts:
+
+1. **Task-1268** (`backlog/tasks/task-1268 - Shift-left.md`): Shift-left verification concept — run the verification gate mechanically before each review round, auto-bounce on failure without consuming a reviewer cycle. Key insight: the machinery exists (`captureVerifiedTreeProof` / `assertVerifiedTreeProof` in `lib/core/verification.js`), but enforcement before review rounds is missing.
+
+2. **Task-1335** (`backlog/completed/task-1335 - Harden-parallix-self-hosting-publish-path...md`): Exact-tree verification proof, implemented and completed. Established the principle that a verification proof must be tied to the exact tree being published — a green run from a different checkout, commit, or pre-squash state cannot satisfy the guard.
+
+3. **ADR 0041** (`docs/adr/0041-integration-pipeline-gates.md`): Integration-time pipeline gates with per-area dispatch, config-driven gate plan, and `--no-integration-gates` escape hatch. Established the pattern of gate execution before squash-merge.
+
+4. **ADR 0047** (`docs/adr/0047-per-mission-change-size-budget.md`): NEL budget with observational capture at handoff. Demonstrates the pattern of observational instrumentation without enforcement — a template for what NOT to do when enforcement is needed.
+
+## Inventory of Existing Checks
+
+The following checks are currently implemented across the harness lifecycle. Each is mapped to the failure class it catches.
+
+### Before Handoff
+
+| # | Check | Location | Failure Class |
+|---|-------|----------|---------------|
+| 1 | Verification gate at checkpoint | `lib/commands/checkpoint.js:44` | Unverifiable test claims (Class 1) |
+| 2 | Checkpoint existence validation | `lib/commands/active.js:386-391` | Missing artifacts (Class 3) |
+| 3 | Checkpoint committed check | `lib/commands/active.js:407-414` | Uncommitted state (Class 4) |
+
+### During Handoff
+
+| # | Check | Location | Failure Class |
+|---|-------|----------|---------------|
+| 4 | Mission branch verification | `lib/commands/handoff.js:37-39` | Git blockers (Class 5) |
+| 5 | MISSION.md existence | `lib/commands/handoff.js:42-44` | Missing artifacts (Class 3) |
+| 6 | MISSION.md uncommitted check | `lib/commands/handoff.js:96-99` | Uncommitted state (Class 4) |
+| 7 | Auto-checkpoint generation | `lib/commands/handoff.js:103-126` | Missing artifacts — auto-repair (Class 3) |
+| 8 | Goal Check heading validation | `lib/commands/handoff.js:141-147` | Incomplete evidence (Class 4) |
+| 9 | Goal Check evidence rows | `lib/commands/handoff.js:152-179` | Incomplete evidence (Class 4) |
+| 10 | Verification gate execution | `lib/commands/handoff.js:200-209` | Gate failure (Class 1, 6) |
+| 11 | Rebase onto primary | `lib/commands/handoff.js:214-229` | Git blockers (Class 5) |
+| 12 | Gatekeeper mandatory artifacts | `lib/commands/handoff.js:322-335` | Missing artifacts (Class 3) |
+| 13 | Declared gates execution | `lib/commands/handoff.js:429-480` | Gate failure (Class 2, 6) |
+
+### Before Review
+
+| # | Check | Location | Failure Class |
+|---|-------|----------|---------------|
+| 14 | Mission dir + branch + status | `lib/review/review-commands.js:367-401` | State violations (Class 8) |
+| 15 | PR existence and state | `lib/review/review-commands.js:403-430` | Infra blockers (Class 7) |
+| 16 | Verification gate | `lib/review/review-commands.js:438-445` | Gate failure (Class 1, 6) |
+
+### During Integration
+
+| # | Check | Location | Failure Class |
+|---|-------|----------|---------------|
+| 17 | Integration preflight | `lib/commands/integrate.js:500-504` | Multiple classes |
+| 18 | Integration gates | `lib/commands/integrate.js:507-534` | Gate failure (Class 6) |
+| 19 | Exact-tree proof capture | `lib/commands/integrate.js:742-749` | Unverifiable claims (Class 1) |
+| 20 | Exact-tree proof assertion | `lib/commands/integrate.js:753-757` | Stale proof (Class 1) |
+
+### Repair Path
+
+| # | Mechanism | Location | Coverage |
+|---|-----------|----------|----------|
+| 21 | Auto-commit mission artifacts | `lib/commands/repair-handoff.js:130-191` | Dirty mission files only (Class 5) |
+| 22 | Auto-rebase | `lib/commands/repair-handoff.js:194-223` | Simple rebase only (Class 5) |
+| 23 | Agent relaunch (empty goal-check) | `lib/commands/active.js:462-483` | Single error sub-class only (Class 4) |
+
+**Total: 23 check points across 5 lifecycle phases.**
+
+## Failure Classification
+
+Eight failure classes have been identified, each classified as auto-repair, auto-send-back, or human-only:
+
+| # | Failure Class | Proposed | Rationale |
+|---|---------------|----------|-----------|
+| 1 | Unverifiable "tests passed" claims | **Auto-send-back** | Gate exit code is deterministic; agent prose is never sufficient |
+| 2 | Malformed or non-runnable declared gates | **Auto-repair** | Static validation (file existence, syntax) can catch before execution |
+| 3 | Missing mandatory mission artifacts | **Auto-send-back** | Unambiguously the implementer's responsibility; no human judgment needed |
+| 4 | Incomplete checkpoint evidence | **Auto-send-back** | Agent-fixable content errors; fix prompt already exists for one sub-class |
+| 5 | Mechanical git/handoff blockers | **Auto-repair** (mission-only); **Human-only** (shared files) | Mission conflicts auto-resolvable; shared-file conflicts require judgment |
+| 6 | Genuine gate failure (code issues) | **Auto-send-back** | Gate output sufficient for agent to diagnose; highest-ROI improvement |
+| 7 | Forgejo/infra blockers | **Human-only** | No agent relaunch will fix infrastructure issues |
+| 8 | Task state machine violations | **Human-only** | State confusion requires human determination of correct state |
+
+## Decision Matrix: Candidate Harness Controls
+
+Seven candidate controls are evaluated and prioritized. The classification column answers backlog treatment, not runtime disposition: every control below is scheduled work with an explicit task.
+
+| # | Candidate Control | Complexity | ROI | Risk | Backlog Treatment |
+|---|-------------------|-----------|-----|------|-------------------|
+| C1 | Pre-review-round gate enforcement with auto-bounce | Medium | High | Low — gate machinery already exists; enforcement is the missing piece | **Implement now** (`TASK-1385`) |
+| C2 | Gate-failure auto-send-back with captured output | Low | High | Low — capture stdout/stderr, build fix prompt, relaunch with retry limit | **Implement now** (`TASK-1387`) |
+| C3 | Error classifier and dispatch table replacing generic strand | Medium | Medium | Low — refactor, not new behavior; existing repair-handoff.js is the seam | **Implement now** (`TASK-1389`) |
+| C4 | Declared-gate pre-validation (syntax + file existence) | Low | Medium | Low — static check before execution | **Implement next wave** (`TASK-1386`) |
+| C5 | Gatekeeper auto-send-back with agent relaunch | Low | Medium | Medium — must avoid relaunch loops when artifacts genuinely cannot be created | **Implement next wave** (`TASK-1388`) |
+| C6 | Forgejo/infrastructure blocker classification and operator handoff | Low | Low | Low — mostly classification and operator guidance, but still worth making explicit | **Implement next wave** (`TASK-1392`) |
+| C7 | Pre-review checkpoint evidence reference validation | Medium | Low | Medium — keep the check mechanical and avoid semantic-quality scoring | **Implement next wave** (`TASK-1393`) |
+
+### Implement Now (C1, C2, C3)
+
+**C1: Pre-review-round gate enforcement** (task-1268 / task-1385). Run the configured verification gate mechanically before each review round. On gate failure, auto-bounce to the implementer with the gate output as a fix prompt. No reviewer cycle consumed. This is the single highest-impact control because it closes the fail-open path where an agent can hand off with a green gate, receive review feedback, "fix" the code, and re-submit without the gate re-running.
+
+**C2: Gate-failure auto-send-back** (task-1387). When the verification gate fails at handoff time (`handoff.js:200-209`), capture the gate stdout/stderr, classify the error as "genuine gate failure — code issue", and relaunch the implementer with the captured output. Limit relaunch attempts to 2 to prevent infinite loops. This is the highest-ROI single control because it eliminates the most common human-intervention scenario: manually copying gate output and re-invoking the agent.
+
+**C3: Error classifier and dispatch table** (task-1389). Replace the binary `isRelaunchableError` / `isDirtyError` / `isBehind` classification in `repair-handoff.js` with a structured error classifier that maps each error message pattern to a failure class and a dispatch action (auto-repair, auto-send-back with prompt, or human-only with clear message). This is foundational work that makes C1 and C2 cleaner to implement.
+
+### Implement Next Wave (C4, C5, C6, C7)
+
+**C4: Declared-gate pre-validation** (`TASK-1386`). Validate that gate commands reference existing files and are syntactically valid before executing them. This stays after C1-C3 only because the earlier controls close larger fail-open paths first, not because C4 is optional.
+
+**C5: Gatekeeper auto-send-back** (`TASK-1388`). When gatekeeper detects missing mandatory artifacts and the task strands in `active`, auto-send-back to the implementer with explicit artifact creation instructions. The auto-checkpoint generation at `handoff.js:103-126` already covers one sub-case, but the remaining cases still deserve explicit automation and therefore explicit backlog tracking.
+
+**C6: Forgejo/infrastructure blocker classification and operator handoff** (`TASK-1392`). Label Forgejo and related infrastructure failures as "infrastructure — human required", preserve the existing runtime outcome, and make the operator message deterministic and actionable. Human-required runtime behavior is still harness work and therefore still gets a backlog task.
+
+**C7: Pre-review checkpoint evidence reference validation** (`TASK-1393`). Validate that checkpoint evidence rows cite real file:line references, ADR references, or test names rather than placeholder prose. The task must stay mechanical: it should verify reference shape and existence, not attempt to score evidence quality semantically.
+
+## Implementation Order
+
+```
+C3 (error classifier) → C2 (gate-failure send-back) → C1 (pre-review gate) → C4 → C5 → C6 → C7
+```
+
+C3 first because it provides the dispatch framework that C1 and C2 plug into. C2 before C1 because C2 is lower complexity and higher immediate ROI (handoff-time gate failures are already the blocking point; pre-review-round enforcement adds a new check point). C4-C7 remain sequenced backlog work rather than untracked ideas.
+
+## Consequences
+
+### Positive
+
+- The most common human-intervention scenario (copying gate output and re-invoking agent) is eliminated by C2
+- The fail-open path between review rounds is closed by C1 (task-1268)
+- Error handling moves from binary (repairable / not) to a classified dispatch table (C3)
+- Each failure class has an explicit owner (auto-repair, auto-send-back, or human)
+
+### Negative
+
+- Automatic relaunching (C2) increases compute cost per failed handoff (bounded by retry limit)
+- The error classifier (C3) adds a maintenance surface — new error patterns must be classified
+- Pre-review gate enforcement (C1) adds wall-time to each review round (bounded by gate duration)
+
+## See Also
+
+- Task-1268: Shift-left verification concept (backlog)
+- Task-1335: Exact-tree verification proof (completed)
+- ADR 0041: Integration pipeline gates
+- ADR 0047: NEL budget (observational pattern)
+- `lib/commands/repair-handoff.js`: Current repair path
+- `lib/commands/active.js:426-498`: Automated handoff-and-repair flow

package/docs/adr/index.md

@@ -17,5 +17,7 @@ ADR 0023 remains in WrGroceries and is cross-referenced here instead of copied.
 - `docs/adr/0046-npm-publish-process-and-security.md` — Adopt public npm registry publication for `@magnusekdahl/parallix` alongside the local tarball path; zero-dependency security posture, manual publish process, and rollback considerations
 - `docs/adr/0047-per-mission-change-size-budget.md` — Change the mission size-estimation basis from agent-usage % to **Net Engineering Lines (NEL)** — code+test diff, excluding docs and workflow/admin bookkeeping (the +0.65 reverse-causation confound). Draft estimate becomes a NEL bucket (0–80 / 81–235 / 235+, the empirical risk terciles); capture actual NEL at handoff to calibrate the estimate. No enforcement until the draft bucket is shown reliable.
 
+- `docs/adr/0048-fail-closed-harness-defense-against-agent-hallucinations.md` — Fail-closed harness defense against agent hallucinations: error classification, auto-send-back policy, and prioritized implementation plan for closing fail-open paths in the handoff/review/integrate lifecycle
+
 ## Cross-reference
 - `docs/adr/0023-ai-sdlc-configuration.md` remains in WrGroceries at `/home/magnus/code/visualBoard-task-1302/docs/adr/0023-ai-sdlc-configuration.md`.

package/docs/authority-reference.md

@@ -153,7 +153,7 @@ Complete when: mission reviewed, landing from the correct integration checkout,
 
 - **Config location:** `config/integration-pipelines.json`
 - **Schema:** `{"gates": {"<area>": {"command": "<shell-command>", "order": <number>, "run_last": <boolean>}}}`
-- **Supported areas:** `server`, `auth-server`, `web-client`, `web-e2e`
+- **Supported areas:** `lib`, `workflow`, `server`, `auth-server`, `web-client`, `web-e2e`, `docs`, `android`, `kubernetes`
 - **Ordering:** Gates are executed in ascending `order` value; `run_last: true` ensures the gate runs after all others (regardless of order value)
 - **Change detection:** Gates are only invoked for areas with changed files in the mission branch vs the primary branch
 - **Opt-out:** `px integrate <slug> --no-integration-gates` skips all integration gates
@@ -163,16 +163,19 @@ Example config:
 ```json
 {
   "gates": {
-    "server": {"command": "./server/updateStaging.sh", "order": 1, "run_last": false},
-    "auth-server": {"command": "./auth-server/updateStaging.sh", "order": 2, "run_last": false},
-    "web-client": {"command": "SKIP_E2E=1 ./web-client/updateStaging.sh", "order": 3, "run_last": false},
-    "web-e2e": {"command": "./web-client/scripts/run-playwright-stage.sh", "order": 4, "run_last": true}
+    "lib": {"command": "./scripts/verify-local.sh static-analysis", "order": 1, "run_last": false},
+    "workflow": {"command": "node test/e2e-mission-lifecycle.test.js", "order": 50, "run_last": true}
   }
 }
 ```
 
 If the config file is missing or empty, `px integrate` logs `integration-gates: no config present, skipping` and proceeds without error.
 
+In this repo, `workflow.config.json` points verification at `./scripts/verify-local.sh {{area}}`. That gives Parallix two validation layers:
+
+- earlier phases such as draft/active/review run the repo's fast general verifier (`all`, currently `npm test`)
+- `px integrate` invokes `verify-local.sh integrate`, which resolves the stricter integration gate plan from `config/integration-pipelines.json` after the target tree is exact
+
 ## 5. Checkpoint Model
 
 Each completed checkpoint must produce: (1) checkpoint doc under the configured mission base dir for the repo (`missions/<slug>/` in this repo), (2) non-generic `Next action:`, (3) passing relevant gate, (4) commit on `mission/<slug>`. Checkpoint docs make resume and handoff deterministic.

package/lib/agents/agents.js

@@ -64,9 +64,11 @@ const limit_hit_js_1 = require("./limit-hit.js");
 const storage = __importStar(require("../core/storage.js"));
 const product_config_js_1 = require("../core/product-config.js");
 const persistent_data_migration_js_1 = require("../core/persistent-data-migration.js");
+const node_module_1 = require("node:module");
 // tools/sessions is still CJS (not converted in this wave); require keeps it
 // untyped (any) without pulling a non-included .js into the typecheck program.
-const sessions = require('../tools/sessions');
+const _require = (0, node_module_1.createRequire)(__filename);
+const sessions = _require('../tools/sessions');
 // Launchers whose CLI accepts a per-call resume flag threaded by startAgent.
 // Each launcher outputs a session resume hint at the end of its run (e.g.
 // "codex resume <id>", "opencode -s ses_<id>",

package/lib/agents/agents.ts

@@ -10,9 +10,11 @@ import { detectLimitHit, formatBlockUntil, DEFAULT_FALLBACK_HOURS } from './limi
 import * as storage from '../core/storage.js';
 import { resolveAgentModel } from '../core/product-config.js';
 import { migrateAgentBlocklists } from '../core/persistent-data-migration.js';
+import { createRequire } from 'node:module';
 // tools/sessions is still CJS (not converted in this wave); require keeps it
 // untyped (any) without pulling a non-included .js into the typecheck program.
-const sessions = require('../tools/sessions');
+const _require = createRequire(__filename);
+const sessions = _require('../tools/sessions');
 
 interface LauncherStatus {
   agent: string;

package/lib/agents/claude.js

@@ -10,9 +10,11 @@ exports.__setSessionsForTest = __setSessionsForTest;
 const spawn_tee_js_1 = require("../core/spawn-tee.js");
 const claude_telemetry_js_1 = require("./claude-telemetry.js");
 Object.defineProperty(exports, "extractClaudeTelemetryFromStdout", { enumerable: true, get: function () { return claude_telemetry_js_1.extractClaudeTelemetryFromStdout; } });
+const node_module_1 = require("node:module");
 // tools/sessions is still CJS (not converted in this wave); require keeps it
 // untyped (any) without pulling a non-included .js into the typecheck program.
-const sessions = require('../tools/sessions');
+const _require = (0, node_module_1.createRequire)(__filename);
+const sessions = _require('../tools/sessions');
 // Injectable I/O for tests. Production uses the real spawn-tee / export capture.
 let _spawnAndTee = spawn_tee_js_1.spawnAndTee;
 let _sessions = sessions;

package/lib/agents/claude.ts

@@ -1,8 +1,10 @@
 import { spawnAndTee } from '../core/spawn-tee.js';
 import { extractClaudeTelemetryFromStdout } from './claude-telemetry.js';
+import { createRequire } from 'node:module';
 // tools/sessions is still CJS (not converted in this wave); require keeps it
 // untyped (any) without pulling a non-included .js into the typecheck program.
-const sessions = require('../tools/sessions');
+const _require = createRequire(__filename);
+const sessions = _require('../tools/sessions');
 
 interface ClaudeInvocationOptions {
   prompt: string;

package/lib/agents/codex.js

@@ -21,9 +21,11 @@ const node_path_1 = __importDefault(require("node:path"));
 const spawn_tee_js_1 = require("../core/spawn-tee.js");
 const codex_telemetry_js_1 = require("./codex-telemetry.js");
 Object.defineProperty(exports, "extractCodexTelemetry", { enumerable: true, get: function () { return codex_telemetry_js_1.extractCodexTelemetry; } });
+const node_module_1 = require("node:module");
 // tools/sessions is still CJS (not converted in this wave); require keeps it
 // untyped (any) without pulling a non-included .js into the typecheck program.
-const sessions = require('../tools/sessions');
+const _require = (0, node_module_1.createRequire)(__filename);
+const sessions = _require('../tools/sessions');
 // Injectable I/O for tests. Production uses the real spawn-tee / export capture.
 let _spawnAndTee = spawn_tee_js_1.spawnAndTee;
 let _sessions = sessions;

package/lib/agents/codex.ts

@@ -3,9 +3,11 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnAndTee } from '../core/spawn-tee.js';
 import { extractCodexTelemetry } from './codex-telemetry.js';
+import { createRequire } from 'node:module';
 // tools/sessions is still CJS (not converted in this wave); require keeps it
 // untyped (any) without pulling a non-included .js into the typecheck program.
-const sessions = require('../tools/sessions');
+const _require = createRequire(__filename);
+const sessions = _require('../tools/sessions');
 
 interface CodexInvocationOptions {
   prompt: string;

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' };