@magnusekdahl/parallix 1.3.2 → 1.3.4

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.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.
+// 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
+                }
             }
         }
     }

package/lib/commands/active.ts

@@ -302,36 +302,37 @@ 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]
- */
-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;
-  // Check if this is a relaunchable error
-  if (!isRelaunchableErrorFn(errorMsg)) {
-    log(`Error is not relaunchable: ${errorMsg}`);
-    return { relaunched: false, error: 'Error is not relaunchable for agent relaunch' };
-  }
-
-  // Check if the agent launcher is available
-  const status = workflowLauncherStatusFn(agent);
-  if (!status.supported) {
-    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);
+  * @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,
+     gateOutput
+   } = options;
+   // Check if this is a relaunchable error
+   if (!isRelaunchableErrorFn(errorMsg)) {
+     log(`Error is not relaunchable: ${errorMsg}`);
+     return { relaunched: false, error: 'Error is not relaunchable for agent relaunch' };
+   }
+
+   // Check if the agent launcher is available
+   const status = workflowLauncherStatusFn(agent);
+   if (!status.supported) {
+     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, 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)
@@ -430,7 +431,7 @@ async function runHandoffAndReview(slug, worktree, agent, options = {}) {
     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),
+    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
@@ -449,37 +450,73 @@ 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;
-    } 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.`);
+    // 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 {
+      // 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'}`;
+      } 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
         }
-        // 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
       }
     }
   }

package/lib/commands/config.ts

@@ -4,9 +4,9 @@ import * as fmt from '../core/fmt.js';
 import { loadEffectiveConfig, loadWorkflowConfig, validateWorkflowConfig } from '../core/product-config.js';
 
 interface ConfigOptions {
-  logFn?: (msg: string) => void;
-  errorFn?: (msg: string) => void;
-  exitFn?: (code: number) => void;
+  logFn?: (_msg: string) => void;
+  errorFn?: (_msg: string) => void;
+  exitFn?: (_code: number) => void;
   rootDir?: string;
 }
 

package/lib/commands/coverage-gate.ts

@@ -301,7 +301,7 @@ if (typeof require !== 'undefined' && require.main === module) {
 }
 
 interface CoverageGateOptions {
-  exitFn?: (code: number) => void;
+  exitFn?: (_code: number) => void;
 }
 
 function run(args: string[], options: CoverageGateOptions = {}) {

package/lib/commands/draft.js

@@ -468,7 +468,7 @@ function ensureWorktree(mainRepo, targetWorktree, branchName, { existsFn = fs.ex
         try {
             gitFn(['-C', mainRepo, 'worktree', 'add', targetWorktree, branchName]);
         }
-        catch (error) {
+        catch (_error) {
             // Ignore "already exists" style failures; the directory is already usable.
         }
         return;

package/lib/commands/draft.ts

@@ -488,7 +488,7 @@ function ensureWorktree(mainRepo, targetWorktree, branchName, {
     logFn(fmt.status('PASS', `Worktree directory ${fmt.path(targetWorktree)} already exists.`));
     try {
       gitFn(['-C', mainRepo, 'worktree', 'add', targetWorktree, branchName]);
-    } catch (error) {
+    } catch (_error) {
       // Ignore "already exists" style failures; the directory is already usable.
     }
     return;

package/lib/commands/handoff.js

@@ -94,9 +94,9 @@ function verifyHandoff(slug, options = {}) {
   * @returns {Promise<{ ok: boolean, error?: string, gatekeeperPushedBack?: boolean }>}
   */
 async function performHandoff(slug, options = {}) {
-    /** @type{{skipGate?: boolean, worktree?: string|null, force?: boolean, forceWithLease?: boolean, log?: Function, error?: Function, rebaseFn?: Function, isForgejoReviewEnabledFn?: Function}} */
+    /** @type{{skipGate?: boolean, worktree?: string|null, force?: boolean, forceWithLease?: boolean, log?: Function, error?: Function, rebaseFn?: Function, isForgejoReviewEnabledFn?: Function, runVerificationGateFn?: Function}} */
     const opts = options;
-    const { skipGate = false, worktree = null, force = false, forceWithLease = true, log = fmt.log.info, error = fmt.log.fail, rebaseFn = rebase_js_1.rebaseBeforeReviewRound } = opts;
+    const { skipGate = false, worktree = null, force = false, forceWithLease = true, log = fmt.log.info, error = fmt.log.fail, rebaseFn = rebase_js_1.rebaseBeforeReviewRound, runVerificationGateFn = verification_js_1.runVerificationGate } = opts;
     const verification = verifyHandoff(slug, { worktree: worktree || undefined });
     if (!verification.ok) {
         error(verification.error);
@@ -213,15 +213,17 @@ async function performHandoff(slug, options = {}) {
     }
     else {
         log(`Step 1: Running final verification gate for area: ${fmt.bold(area || 'docs')}...`);
-        const verifyResult = (0, verification_js_1.runVerificationGate)(area || 'docs', {
+        const verifyResult = runVerificationGateFn(area || 'docs', {
             rootDir,
-            stdio: 'inherit',
+            stdio: 'pipe',
             runFn: git.run
         });
         if (verifyResult.status !== 0) {
+            const stdout = (verifyResult.stdout || '').trim();
+            const stderr = (verifyResult.stderr || '').trim();
             const msg = 'Final verification gate failed. Fix errors before submitting or use --no-gate if appropriate.';
             error(msg);
-            return { ok: false, error: msg };
+            return { ok: false, error: msg, gateOutput: { stdout, stderr } };
         }
     }
     // Step 1.5: Rebase mission branch onto latest primary before PR creation
@@ -356,7 +358,7 @@ async function performHandoff(slug, options = {}) {
     if (!gatesResult.ok) {
         const msg = `Declared gate "${gatesResult.gate}" failed for ${fmt.slug(slug)}: ${gatesResult.error || gatesResult.reason}. Blocking handoff — task remains in active.`;
         error(msg);
-        return { ok: false, error: msg };
+        return { ok: false, error: msg, gateOutput: { stdout: (gatesResult.stdout || ''), stderr: (gatesResult.stderr || '') } };
     }
     if (gatesResult.skipped) {
         log(`No declared gates for ${fmt.slug(slug)} (${gatesResult.reason}).`);
@@ -464,15 +466,18 @@ function runDeclaredGates(missionDir, rootDir, options = {}) {
         const result = (0, node_child_process_1.spawnSync)('bash', ['-c', cmd], {
             cwd: rootDir,
             encoding: 'utf8',
-            stdio: ['inherit', 'pipe', 'pipe']
+            stdio: 'pipe'
         });
         if (result.status !== 0) {
+            const stdout = (result.stdout || '').trim();
             const stderr = (result.stderr || '').trim();
             return {
                 ok: false,
                 gate: cmd,
                 reason: 'gate-failed',
-                error: stderr || `Gate exited with status ${result.status}`
+                error: stderr || `Gate exited with status ${result.status}`,
+                stdout,
+                stderr
             };
         }
     }