@magnusekdahl/parallix 1.3.3 → 1.3.4

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

package/lib/commands/handoff.ts

@@ -58,18 +58,19 @@ import * as nels from '../core/nels.js';
   * @param {{skipGate?: boolean, worktree?: string|null, force?: boolean, forceWithLease?: boolean, log?: Function, error?: Function, rebaseFn?: Function, isForgejoReviewEnabledFn?: Function}} [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}} */
-   const opts = options;
-   const {
-     skipGate = false,
-     worktree = null,
-     force = false,
-     forceWithLease = true,
-     log = fmt.log.info,
-     error = fmt.log.fail,
-     rebaseFn = rebaseBeforeReviewRound
-   } = opts;
+async function performHandoff(slug, options = {}) {
+   /** @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 = rebaseBeforeReviewRound,
+      runVerificationGateFn = runVerificationGate
+    } = opts;
 
    const verification = verifyHandoff(slug, { worktree: worktree || undefined });
   if (!verification.ok) {
@@ -198,15 +199,17 @@ import * as nels from '../core/nels.js';
     fmt.log.warn('Step 1: Skipping final verification gate (--no-gate)');
   } else {
     log(`Step 1: Running final verification gate for area: ${fmt.bold(area || 'docs')}...`);
-    const verifyResult = 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 } };
     }
   }
 
@@ -346,7 +349,7 @@ import * as nels from '../core/nels.js';
   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}).`);
@@ -463,16 +466,19 @@ function runDeclaredGates(missionDir, rootDir, options = {}) {
     const result = 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
       };
     }
   }

package/lib/commands/rebase.js

@@ -58,7 +58,7 @@ const verification_js_1 = require("../core/verification.js");
  * Usage: px rebase [<slug>] [--push]
  */
 /** @param {string[]} args @param {{inferSlugFn?: Function, findMissionDirFn?: Function, findMissionAreaFn?: Function, getCurrentBranchFn?: Function, resolveConflictsFn?: Function, startAgentFn?: Function, createPrFn?: Function, readTokenFn?: Function, resolveForgejoUserFn?: Function, resolveTaskFileFn?: Function, getTaskImplementerFn?: Function, detectRebaseStateFn?: Function, resolveMissionBaseBranchFn?: Function, gitFn?: Function, exitFn?: Function, isForgejoReviewEnabledFn?: Function, fetchReviewBranchFn?: Function}} opts */
-async function rebase(args, { inferSlugFn = mission_utils_js_1.inferSlug, findMissionDirFn = mission_utils_js_1.findMissionDir, findMissionAreaFn = mission_utils_js_1.findMissionArea, getCurrentBranchFn = git_js_1.getCurrentBranch, resolveConflictsFn = integrate_js_1.default.resolveConflictsForMission, startAgentFn = agents_js_1.startAgent, createPrFn = forgejo_js_1.createPr, readTokenFn = forgejo_js_1.readToken, resolveForgejoUserFn = forgejo_js_1.resolveForgejoUser, resolveTaskFileFn = backlog_js_1.resolveTaskFile, getTaskImplementerFn = backlog_js_1.getTaskImplementer, detectRebaseStateFn = git_js_1.detectRebaseState, resolveMissionBaseBranchFn = mission_utils_js_1.resolveMissionBaseBranch, gitFn = git_js_1.git, exitFn = ((code) => process.exit(code)), isForgejoReviewEnabledFn = product_config_js_1.isForgejoReviewEnabled, fetchReviewBranchFn = forgejo_js_1.fetchReviewBranch, } = {}) {
+async function rebase(args, { inferSlugFn = mission_utils_js_1.inferSlug, findMissionDirFn = mission_utils_js_1.findMissionDir, findMissionAreaFn = mission_utils_js_1.findMissionArea, getCurrentBranchFn = git_js_1.getCurrentBranch, resolveConflictsFn = integrate_js_1.default.resolveConflictsForMission, startAgentFn = agents_js_1.startAgent, createPrFn = forgejo_js_1.createPr, readTokenFn = forgejo_js_1.readToken, resolveForgejoUserFn = forgejo_js_1.resolveForgejoUser, resolveTaskFileFn = backlog_js_1.resolveTaskFile, getTaskImplementerFn = backlog_js_1.getTaskImplementer, detectRebaseStateFn = git_js_1.detectRebaseState, resolveMissionBaseBranchFn = mission_utils_js_1.resolveMissionBaseBranch, gitFn = git_js_1.git, exitFn = ((_code) => process.exit(_code)), isForgejoReviewEnabledFn = product_config_js_1.isForgejoReviewEnabled, fetchReviewBranchFn = forgejo_js_1.fetchReviewBranch, } = {}) {
     const flags = args.filter(a => a.startsWith('--'));
     const params = args.filter(a => !a.startsWith('--'));
     const isPush = flags.includes('--push');

package/lib/commands/rebase.ts

@@ -32,10 +32,10 @@ async function rebase(args: string[], {
   detectRebaseStateFn = detectRebaseState,
   resolveMissionBaseBranchFn = resolveMissionBaseBranch,
   gitFn = git,
-  exitFn = ((code: number) => process.exit(code)) as (code: number) => void,
+  exitFn = ((_code: number) => process.exit(_code)) as (_code: number) => void,
   isForgejoReviewEnabledFn = isForgejoReviewEnabled,
   fetchReviewBranchFn = fetchReviewBranch,
-}: {inferSlugFn?: Function, findMissionDirFn?: Function, findMissionAreaFn?: Function, getCurrentBranchFn?: Function, resolveConflictsFn?: Function, startAgentFn?: Function, createPrFn?: Function, readTokenFn?: Function, resolveForgejoUserFn?: Function, resolveTaskFileFn?: Function, getTaskImplementerFn?: Function, detectRebaseStateFn?: Function, resolveMissionBaseBranchFn?: Function, gitFn?: Function, exitFn?: (code: number) => void, isForgejoReviewEnabledFn?: Function, fetchReviewBranchFn?: Function} = {}) {
+}: {inferSlugFn?: Function, findMissionDirFn?: Function, findMissionAreaFn?: Function, getCurrentBranchFn?: Function, resolveConflictsFn?: Function, startAgentFn?: Function, createPrFn?: Function, readTokenFn?: Function, resolveForgejoUserFn?: Function, resolveTaskFileFn?: Function, getTaskImplementerFn?: Function, detectRebaseStateFn?: Function, resolveMissionBaseBranchFn?: Function, gitFn?: Function, exitFn?: (_code: number) => void, isForgejoReviewEnabledFn?: Function, fetchReviewBranchFn?: Function} = {}) {
   const flags = args.filter(a => a.startsWith('--'));
   const params = args.filter(a => !a.startsWith('--'));
   const isPush = flags.includes('--push');

package/lib/commands/repair-handoff.js

@@ -36,6 +36,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DispatchAction = exports.FailureClass = void 0;
+exports.getDispatchAction = getDispatchAction;
+exports.classifyError = classifyError;
 exports.repairHandoff = repairHandoff;
 exports.isRelaunchableError = isRelaunchableError;
 exports.buildRelaunchPrompt = buildRelaunchPrompt;
@@ -43,19 +46,129 @@ const git_js_1 = require("../core/git.js");
 const missionUtils = __importStar(require("../core/mission-utils.js"));
 const rebase_js_1 = __importDefault(require("./rebase.js"));
 const fmt = __importStar(require("../core/fmt.js"));
+// ── FailureClass: 8 classes from ADR 0048 ────────────────────────────────────
+const FailureClass = {
+    UnverifiableClaims: 'UnverifiableClaims',
+    MalformedGates: 'MalformedGates',
+    MissingArtifacts: 'MissingArtifacts',
+    IncompleteEvidence: 'IncompleteEvidence',
+    GitBlockers: 'GitBlockers',
+    GateFailure: 'GateFailure',
+    InfraBlocker: 'InfraBlocker',
+    StateMachineViolation: 'StateMachineViolation',
+};
+exports.FailureClass = FailureClass;
+// ── DispatchAction: 3 actions from ADR 0048 ──────────────────────────────────
+const DispatchAction = {
+    AutoRepair: 'AutoRepair',
+    AutoSendBack: 'AutoSendBack',
+    HumanOnly: 'HumanOnly',
+};
+exports.DispatchAction = DispatchAction;
+// ── Dispatch table: maps each failure class to its prescribed action (ADR 0048) ─
+const DISPATCH_TABLE = {
+    [FailureClass.UnverifiableClaims]: DispatchAction.AutoSendBack,
+    [FailureClass.MalformedGates]: DispatchAction.AutoRepair,
+    [FailureClass.MissingArtifacts]: DispatchAction.AutoSendBack,
+    [FailureClass.IncompleteEvidence]: DispatchAction.AutoSendBack,
+    [FailureClass.GitBlockers]: DispatchAction.AutoRepair,
+    [FailureClass.GateFailure]: DispatchAction.AutoSendBack,
+    [FailureClass.InfraBlocker]: DispatchAction.HumanOnly,
+    [FailureClass.StateMachineViolation]: DispatchAction.HumanOnly,
+};
+/**
+ * Look up the dispatch action for a given failure class.
+ *
+ * @param failureClass - One of the 8 failure class values from ADR 0048
+ * @returns The prescribed dispatch action, or null if unknown
+ */
+function getDispatchAction(failureClass) {
+    return DISPATCH_TABLE[failureClass] ?? null;
+}
+/**
+ * Classify an error message into one of the 8 failure classes from ADR 0048
+ * and return the associated dispatch action.
+ *
+ * Patterns are checked in order of specificity to avoid collisions.
+ * Returns a `reason` field for GitBlockers to distinguish dirty-artifact from behind-branch errors,
+ * allowing callers to derive repair-strategy flags without duplicating pattern matching.
+ *
+ * @param errorMsg - The error message to classify
+ * @returns Object with failureClass, dispatchAction, and (for GitBlockers) reason
+ */
+function classifyError(errorMsg) {
+    if (!errorMsg || typeof errorMsg !== 'string') {
+        return { failureClass: FailureClass.InfraBlocker, dispatchAction: DispatchAction.HumanOnly };
+    }
+    // 1. IncompleteEvidence: goal-check table missing evidence rows (most specific — checked before generic gate patterns)
+    if (errorMsg.includes('has a "## Goal Check" section but no evidence rows') &&
+        errorMsg.includes('A goal-check table with real evidence is required before handoff')) {
+        return { failureClass: FailureClass.IncompleteEvidence, dispatchAction: DispatchAction.AutoSendBack };
+    }
+    // 2. GitBlockers: dirty/uncommitted mission artifacts (mechanical git blocker — auto-repairable)
+    if (errorMsg.includes('is modified but uncommitted') ||
+        errorMsg.includes('Commit the mission contract before handoff') ||
+        errorMsg.includes('Commit the implementation evidence before handoff')) {
+        return { failureClass: FailureClass.GitBlockers, dispatchAction: DispatchAction.AutoRepair, reason: 'dirty' };
+    }
+    // 3. GitBlockers: branch behind primary / push rejected (mechanical git blocker — auto-repairable via rebase)
+    if (errorMsg.includes('Updates were rejected') ||
+        errorMsg.includes('fetch first') ||
+        errorMsg.includes('non-fast-forward') ||
+        errorMsg.includes('behind its remote') ||
+        (errorMsg.includes('git push failed') && (errorMsg.includes('rejected') ||
+            errorMsg.includes('remote contains work')))) {
+        return { failureClass: FailureClass.GitBlockers, dispatchAction: DispatchAction.AutoRepair, reason: 'behind' };
+    }
+    // 4. GateFailure: verification gate failed
+    if (/verification gate failed/i.test(errorMsg)) {
+        return { failureClass: FailureClass.GateFailure, dispatchAction: DispatchAction.AutoSendBack };
+    }
+    // 5. GateFailure: declared gate failed
+    if (/\bdeclared gate\b/i.test(errorMsg) && /\bfailed\b/i.test(errorMsg)) {
+        return { failureClass: FailureClass.GateFailure, dispatchAction: DispatchAction.AutoSendBack };
+    }
+    // 6. UnverifiableClaims: test claims that cannot be verified
+    if (/test(s?\s+)?passed/i.test(errorMsg) && /cannot\s+verify|unverifiable|proof\s+(not\s+)?found|stale\s+proof/i.test(errorMsg)) {
+        return { failureClass: FailureClass.UnverifiableClaims, dispatchAction: DispatchAction.AutoSendBack };
+    }
+    // 7. MalformedGates: malformed or non-runnable declared gates
+    if (/malformed\s+gate|invalid\s+gate\s+config|gate\s+command\s+(not\s+found|syntax\s+error|not\s+runnable)/i.test(errorMsg) ||
+        (/gate/i.test(errorMsg) && /syntax\s+error|not\s+found|missing\s+(file|command)/i.test(errorMsg))) {
+        return { failureClass: FailureClass.MalformedGates, dispatchAction: DispatchAction.AutoRepair };
+    }
+    // 8. MissingArtifacts: mandatory mission artifacts missing
+    if (/mandatory\s+(artifact|file|document)|missing\s+(mission\s+)?(artifact|file|document)|required\s+(artifact|file|document)\s+(not\s+)?found/i.test(errorMsg) ||
+        (/gatekeeper/i.test(errorMsg) && /missing\s+(artifact|file|document)/i.test(errorMsg))) {
+        return { failureClass: FailureClass.MissingArtifacts, dispatchAction: DispatchAction.AutoSendBack };
+    }
+    // 9. StateMachineViolation: task state machine violations
+    if (/state\s+violation|invalid\s+state|transition\s+not\s+allowed|cannot\s+(move|transition)\s+(from|to)\s+\w+\s+(to|from)/i.test(errorMsg) ||
+        (/task\s+state/i.test(errorMsg) && /invalid|violation|incorrect/i.test(errorMsg))) {
+        return { failureClass: FailureClass.StateMachineViolation, dispatchAction: DispatchAction.HumanOnly };
+    }
+    // 10. InfraBlocker: forgejo/infrastructure blockers
+    if (/forgejo|infrastructure|authentication\s+failed|token\s+(expired|invalid|missing)|forbidden|unauthorized\s+(access|request)|rate\s+limit|connection\s+(refused|timed?\s*out)|network\s+error/i.test(errorMsg)) {
+        return { failureClass: FailureClass.InfraBlocker, dispatchAction: DispatchAction.HumanOnly };
+    }
+    // Default: human-only for unrecognized errors
+    return { failureClass: FailureClass.InfraBlocker, dispatchAction: DispatchAction.HumanOnly };
+}
 /**
  * Check if an error message indicates a relaunchable content error (missing/empty goal-check table).
+ * Delegates to classifyError for backward-compatible classification.
  *
- * @param {string} errorMsg - The error message to check
- * @returns {boolean} True if the error is relaunchable
+ * @param errorMsg - The error message to check
+ * @returns True if the error is relaunchable (IncompleteEvidence or GateFailure)
  */
 function isRelaunchableError(errorMsg) {
     if (!errorMsg || typeof errorMsg !== 'string') {
         return false;
     }
-    // Match the exact error message from handoff.js when final checkpoint has no evidence rows
-    return errorMsg.includes('has a "## Goal Check" section but no evidence rows') &&
-        errorMsg.includes('A goal-check table with real evidence is required before handoff');
+    const { failureClass } = classifyError(errorMsg);
+    // IncompleteEvidence and GateFailure are the only classes that were relaunchable under the old logic
+    return failureClass === FailureClass.IncompleteEvidence
+        || failureClass === FailureClass.GateFailure;
 }
 /**
  * Build a relaunch prompt for an agent to fix a relaunchable error.
@@ -65,10 +178,10 @@ function isRelaunchableError(errorMsg) {
  * @param {string} worktree - Path to the mission worktree
  * @returns {string} The relaunch prompt
   */
-function buildRelaunchPrompt(errorMsg, slug, worktree) {
+function buildRelaunchPrompt(errorMsg, slug, worktree, gateOutput) {
     const year = missionUtils.getMissionYear(slug, worktree);
     const missionDir = missionUtils.findMissionDir(slug, worktree) || missionUtils.missionDirForSlug(worktree, slug);
-    return `Automated handoff failed for mission ${slug} with a repairable error: ${errorMsg}
+    let prompt = `Automated handoff failed for mission ${slug} with a repairable error: ${errorMsg}
 
 ` +
         `Please fix the final checkpoint document in ${missionDir} by adding a Goal Check table ` +
@@ -103,6 +216,16 @@ function buildRelaunchPrompt(errorMsg, slug, worktree) {
 
 ` +
         `Do NOT add placeholder or generic evidence. Each row must cite real, verifiable artifacts.`;
+    // Append captured gate output if available (task-1387)
+    if (gateOutput && (gateOutput.stdout || gateOutput.stderr)) {
+        const totalOutput = (gateOutput.stdout || '') + (gateOutput.stderr || '');
+        // Truncate if total output exceeds 16000 chars; keep last 8000 chars
+        const truncated = totalOutput.length > 16000
+            ? `[truncated — total ${totalOutput.length} chars, showing last 8000]\n` + totalOutput.slice(-8000)
+            : totalOutput;
+        prompt += `\n\n--- Captured Gate Output ---\n${truncated}`;
+    }
+    return prompt;
 }
 /**
  * Attempt to repair a failed automated handoff by auto-committing mission
@@ -129,23 +252,17 @@ async function repairHandoff(slug, worktree, errorMsg, options = {}) {
         const cleanPath = (pathPart.startsWith('"') && pathPart.endsWith('"')) ? pathPart.slice(1, -1) : pathPart;
         return { xy, file: cleanPath };
     }
-    // 0. Check if error is repairable
-    const isDirtyError = errorMsg && (errorMsg.includes('is modified but uncommitted') ||
-        errorMsg.includes('Commit the mission contract before handoff') ||
-        errorMsg.includes('Commit the implementation evidence before handoff'));
-    const isBehind = errorMsg && (errorMsg.includes('Updates were rejected') ||
-        errorMsg.includes('fetch first') ||
-        errorMsg.includes('non-fast-forward') ||
-        errorMsg.includes('behind its remote') ||
-        // Ensure we don't match generic git push failed unless it has non-fast-forward hints
-        (errorMsg.includes('git push failed') && (errorMsg.includes('rejected') ||
-            errorMsg.includes('remote contains work'))));
-    if (!isDirtyError && !isBehind) {
+    // 0. Check if error is repairable via classifyError
+    const classification = classifyError(errorMsg);
+    const isGitBlocker = classification.failureClass === FailureClass.GitBlockers;
+    // Derive isBehind from classification result (avoids duplicating classifyError's behind-branch patterns)
+    const isBehind = classification.reason === 'behind';
+    if (!isGitBlocker) {
         log(`Handoff error is not automatically repairable: ${errorMsg}`);
         return { repaired: false, blocker: null };
     }
     // 1. Auto-commit mission artifacts if uncommitted
-    if (isDirtyError || isBehind) {
+    if (isGitBlocker) {
         const statusResult = gitFn(['-C', rootDir, 'status', '--porcelain']);
         if (statusResult.status === 0 && statusResult.stdout) {
             const dirtyLines = statusResult.stdout.split('\n')
@@ -236,6 +353,10 @@ async function repairHandoff(slug, worktree, errorMsg, options = {}) {
 }
 repairHandoff.isRelaunchableError = isRelaunchableError;
 repairHandoff.buildRelaunchPrompt = buildRelaunchPrompt;
+repairHandoff.classifyError = classifyError;
+repairHandoff.getDispatchAction = getDispatchAction;
+repairHandoff.FailureClass = FailureClass;
+repairHandoff.DispatchAction = DispatchAction;
 exports.default = repairHandoff;
 if (typeof module !== 'undefined') {
     module.exports = repairHandoff;