@magnusekdahl/parallix 1.3.3 → 1.3.4

package/lib/commands/repair-handoff.ts

@@ -3,19 +3,155 @@ import * as missionUtils from '../core/mission-utils.js';
 import rebase from './rebase.js';
 import * as fmt from '../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',
+} as const;
+
+type FailureClassType = (typeof FailureClass)[keyof typeof FailureClass];
+
+// ── DispatchAction: 3 actions from ADR 0048 ──────────────────────────────────
+const DispatchAction = {
+  AutoRepair: 'AutoRepair',
+  AutoSendBack: 'AutoSendBack',
+  HumanOnly: 'HumanOnly',
+} as const;
+
+type DispatchActionType = (typeof DispatchAction)[keyof typeof DispatchAction];
+
+// ── Dispatch table: maps each failure class to its prescribed action (ADR 0048) ─
+const DISPATCH_TABLE: Record<FailureClassType, DispatchActionType> = {
+  [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
+ */
+export function getDispatchAction(failureClass: FailureClassType): DispatchActionType | null {
+  return DISPATCH_TABLE[failureClass] ?? null;
+}
+
+/**
+ * Sub-reason for GitBlockers classification: distinguishes dirty-artifact from behind-branch errors.
+ * Used by repairHandoff() to decide whether to auto-rebase (behind) vs auto-commit only (dirty).
+ */
+type GitBlockerReason = 'dirty' | 'behind' | 'other';
+
+/**
+ * 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
+ */
+export function classifyError(errorMsg: string): { failureClass: FailureClassType; dispatchAction: DispatchActionType; reason?: GitBlockerReason } {
+  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: string) {
+function isRelaunchableError(errorMsg: string): boolean {
   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;
 }
 
 /**
@@ -26,45 +162,57 @@ function isRelaunchableError(errorMsg: string) {
  * @param {string} worktree - Path to the mission worktree
  * @returns {string} The relaunch prompt
   */
-function buildRelaunchPrompt(errorMsg: string, slug: string, worktree: string) {
+function buildRelaunchPrompt(errorMsg: string, slug: string, worktree: string, gateOutput?: { stdout: string; stderr: string }) {
   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 ` +
-         `with real evidence rows (file:line references, test names). The Goal Check table must have ` +
-         `a header row and at least one evidence row using pipe syntax (|).
+          `Please fix the final checkpoint document in ${missionDir} by adding a Goal Check table ` +
+          `with real evidence rows (file:line references, test names). The Goal Check table must have ` +
+          `a header row and at least one evidence row using pipe syntax (|).
 
 ` +
-         `Steps:
+          `Steps:
 ` +
-         `1. Open the final checkpoint document (CP-N.md) in ${missionDir}
+          `1. Open the final checkpoint document (CP-N.md) in ${missionDir}
 ` +
-         `2. Add or update the "## Goal Check" section
+          `2. Add or update the "## Goal Check" section
 ` +
-         `3. Create a markdown table with columns for: Goal Check description | Evidence | Status
+          `3. Create a markdown table with columns for: Goal Check description | Evidence | Status
 ` +
-         `4. Add at least one evidence row with real file:line or test name references
+          `4. Add at least one evidence row with real file:line or test name references
 ` +
-         `5. Commit the updated checkpoint with a descriptive commit message
+          `5. Commit the updated checkpoint with a descriptive commit message
 ` +
-         `6. Re-run: node parallix review ${slug} --submit
+          `6. Re-run: node parallix review ${slug} --submit
 
 ` +
-         `Example Goal Check table:
+          `Example Goal Check table:
 ` +
-         `| Goal Check | Evidence | Status |
+          `| Goal Check | Evidence | Status |
 ` +
-         `|---|---|---|
+          `|---|---|---|
 ` +
-         `| Final checkpoint has Goal Check section | docs/missions/${year}/${slug}/CP-1.md:15 | PASS |
+          `| Final checkpoint has Goal Check section | docs/missions/${year}/${slug}/CP-1.md:15 | PASS |
 ` +
-         `| Tests pass | npm test -- parallix/test/repair-handoff.test.js | PASS |
+          `| Tests pass | npm test -- parallix/test/repair-handoff.test.js | PASS |
 
 ` +
-         `Do NOT add placeholder or generic evidence. Each row must cite real, verifiable artifacts.`;
+          `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;
 }
 
 /**
@@ -100,32 +248,19 @@ async function repairHandoff(slug: string, worktree: string, errorMsg: string, o
     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')
@@ -224,9 +359,14 @@ async function repairHandoff(slug: string, worktree: string, errorMsg: string, o
 
 (repairHandoff as any).isRelaunchableError = isRelaunchableError;
 (repairHandoff as any).buildRelaunchPrompt = buildRelaunchPrompt;
+(repairHandoff as any).classifyError = classifyError;
+(repairHandoff as any).getDispatchAction = getDispatchAction;
+(repairHandoff as any).FailureClass = FailureClass;
+(repairHandoff as any).DispatchAction = DispatchAction;
 
 export default repairHandoff;
 export { repairHandoff, isRelaunchableError, buildRelaunchPrompt };
+export { FailureClass, DispatchAction };
 
 // CJS compat: ensure require() returns the function directly
 declare const module: { exports: any } | undefined;

package/lib/commands/resolve-conflict.js

@@ -80,7 +80,7 @@ function buildAgentResolutionPrompt({ slug, area, worktreePath, missionSpecificF
     ].join('\n');
 }
 /** @param {string[]} args @param {{resolveConflictsFn?: Function, startAgentFn?: Function, exitFn?: Function}} opts */
-async function resolveConflict(args, { resolveConflictsFn = integrate_js_1.default.resolveConflictsForMission, startAgentFn = agents_js_1.startAgent, exitFn = ((code) => process.exit(code)), } = {}) {
+async function resolveConflict(args, { resolveConflictsFn = integrate_js_1.default.resolveConflictsForMission, startAgentFn = agents_js_1.startAgent, exitFn = ((_code) => process.exit(_code)), } = {}) {
     const explicitSlug = args[0];
     const slug = (0, mission_utils_js_1.inferSlug)(explicitSlug);
     if (!slug) {

package/lib/commands/resolve-conflict.ts

@@ -47,8 +47,8 @@ function buildAgentResolutionPrompt({ slug, area, worktreePath, missionSpecificF
 async function resolveConflict(args: string[], {
   resolveConflictsFn = (integrate as any).resolveConflictsForMission,
   startAgentFn = startAgent,
-  exitFn = ((code: number) => process.exit(code)) as (code: number) => void,
-}: {resolveConflictsFn?: Function, startAgentFn?: Function, exitFn?: (code: number) => void} = {}) {
+  exitFn = ((_code: number) => process.exit(_code)) as (_code: number) => void,
+}: {resolveConflictsFn?: Function, startAgentFn?: Function, exitFn?: (_code: number) => void} = {}) {
   const explicitSlug = args[0];
   const slug = inferSlug(explicitSlug);
   if (!slug) {

package/lib/commands/stats-backfill.ts

@@ -12,13 +12,13 @@ import {
 import { findMissionDir } from '../core/mission-utils.js';
 
 interface StatsAugmented {
-  resolveMissionClassification: (slug: string, rootDir?: string) => { classification?: string; source?: string };
-  _internals: Record<string, (...args: unknown[]) => unknown>;
-  resolveStatsPath: (options?: { ensureDir?: boolean }) => string;
-  resolveStatsRepoName: (rootDir: string) => string;
-  loadStatsCsv: (filePath: string, options?: { rootDir?: string }) => { rows: Record<string, string>[] };
-  deriveImplementerAndFixRounds: (slug: string, rootDir?: string) => { implementer: string; prFixRounds: number; source: string };
-  upsertStatsRow: (row: Record<string, string>, options: { filePath: string; rootDir?: string }) => { changed: boolean };
+  resolveMissionClassification: (_slug: string, _rootDir?: string) => { classification?: string; source?: string };
+  _internals: Record<string, (..._args: unknown[]) => unknown>;
+  resolveStatsPath: (_options?: { ensureDir?: boolean }) => string;
+  resolveStatsRepoName: (_rootDir: string) => string;
+  loadStatsCsv: (_filePath: string, _options?: { rootDir?: string }) => { rows: Record<string, string>[] };
+  deriveImplementerAndFixRounds: (_slug: string, _rootDir?: string) => { implementer: string; prFixRounds: number; source: string };
+  upsertStatsRow: (_row: Record<string, string>, _options: { filePath: string; rootDir?: string }) => { changed: boolean };
 }
 
 function getStats(): StatsAugmented {
@@ -175,7 +175,7 @@ function resolveHistoricalClassification(slug: string, taskFile: string, rootDir
   }
   // Classification missing or invalid — fall through to fallbacks.
   const classificationValue = getTaskFrontmatterValue(taskFile, 'classification');
-  const legacy = (s._internals as Record<string, (v: string) => string | null>).normalizeClassification(classificationValue ?? '');
+  const legacy = (s._internals as Record<string, (_v: string) => string | null>).normalizeClassification(classificationValue ?? '');
   if (legacy) {
     return { value: legacy, source: 'backlog-classification' };
   }
@@ -347,8 +347,8 @@ Notes:
 }
 
 interface BackfillOptions {
-  log?: (msg: string) => string | null;
-  error?: (msg: string) => string | null;
+  log?: (_msg: string) => string | null;
+  error?: (_msg: string) => string | null;
   rootDir?: string;
 }
 

package/lib/commands/stats.js

@@ -76,16 +76,19 @@ const storage = __importStar(require("../core/storage.js"));
 // and one-time header migration of legacy stats files (task-1251).
 const LEGACY_HEADERS = ['date', 'mission', 'classification', 'implementer', 'pr_fix_rounds'];
 exports.LEGACY_HEADERS = LEGACY_HEADERS;
-// Extended 21-column telemetry schema (task-1314 + task-1251). Legacy 5-column rows are
-// migrated in-memory on load: the legacy columns are preserved and the new
-// columns default to '' (text) or '0' (numeric). On the next write the file
-// header is upgraded and existing rows gain the new columns.
+// Extended 22-column telemetry schema (task-1314 + task-1251 + task-1380). Legacy
+// 5-column rows are migrated in-memory on load: the legacy columns are preserved
+// and the new columns default to '' (text) or '0' (numeric). On the next write the
+// file header is upgraded and existing rows gain the new columns. The `closed`
+// column (task-1380) stores 'yes' for closed/integrated missions and is empty for
+// in-progress stage rows; filtering by `closed === 'yes'` excludes in-progress
+// missions from weekly and range mission counts.
 const STATS_HEADERS = [
     'date', 'repo', 'mission', 'classification', 'implementer', 'pr_fix_rounds',
     'provider', 'model', 'implementer_agent', 'reviewer_agent', 'stage',
     'input_tokens', 'output_tokens', 'cached_tokens', 'context_tokens',
     'tool_calls', 'openai_usage_before', 'openai_usage_after',
-    'openai_usage_delta', 'duration_minutes', 'cost_usd'
+    'openai_usage_delta', 'duration_minutes', 'cost_usd', 'closed'
 ];
 exports.STATS_HEADERS = STATS_HEADERS;
 // Columns coerced to non-negative integers on canonicalization.
@@ -271,16 +274,30 @@ function loadStatsCsv(filePath = null, options = {}) {
     if (data.headers.length === 0) {
         return { headers: [...STATS_HEADERS], rows: [] };
     }
+    // Detect whether the loaded CSV already has the `closed` column (task-1380).
+    // Legacy CSVs (pre-closed) lack the column; their rows represent completed
+    // missions written at integration time, so default `closed` to 'yes' for
+    // backward compatibility. Modern CSVs already have the column set per-row.
+    const hasClosedColumn = data.headers.includes('closed');
+    const migratedRows = data.rows.map((row) => {
+        const normalized = normalizeStatsRow(row, { rootDir: options.rootDir });
+        if (!hasClosedColumn) {
+            // Legacy CSV: all rows are from integration time, treat as closed.
+            return { ...normalized, closed: 'yes' };
+        }
+        return { ...normalized, closed: row.closed || '' };
+    });
     return {
         headers: [...STATS_HEADERS],
-        rows: data.rows.map((row) => normalizeStatsRow(row, { rootDir: options.rootDir })),
+        rows: migratedRows,
     };
 }
 /**
  * Map any row (legacy 5-column or full 21-column) to the full schema, defaulting
  * missing text columns to '' and numeric columns to '0'. `stage` defaults to
  * 'default' so legacy rows and integration rows share the (repo, mission, stage)
- * upsert key.
+ * upsert key. `closed` defaults to '' (unset) — the backward-compat default of
+ * 'yes' for legacy CSV rows is applied exclusively in `loadStatsCsv`.
  */
 function normalizeStatsRow(row = {}, options = {}) {
     const repo = String(row.repo || options.repo || resolveStatsRepoName(options.rootDir)).trim();
@@ -306,6 +323,7 @@ function normalizeStatsRow(row = {}, options = {}) {
         openai_usage_delta: row.openai_usage_delta || '0',
         duration_minutes: row.duration_minutes || '0',
         cost_usd: row.cost_usd || '0',
+        closed: row.closed || '',
     };
 }
 /**
@@ -695,11 +713,14 @@ function rowInWindow(row, window) {
  */
 function summarizeMissionWindow(rows, window) {
     const windowRows = rows.filter(row => rowInWindow(row, window));
+    // Filter to only closed missions (task-1380): rows without closed:'yes' are
+    // in-progress stage rows and should not inflate mission counts.
+    const closedRows = windowRows.filter(row => row.closed === 'yes');
     // Deduplicate by mission so multi-stage telemetry rows don't inflate counts.
     // One row per unique repo+mission pair is kept (first occurrence is sufficient
     // since classification is stable across stages for the same mission in a repo).
     const seenMissions = new Set();
-    const uniqueMissions = windowRows.filter(row => {
+    const uniqueMissions = closedRows.filter(row => {
         const key = statsMissionKey(row);
         if (seenMissions.has(key)) {
             return false;
@@ -712,7 +733,7 @@ function summarizeMissionWindow(rows, window) {
     const unknown = uniqueMissions.filter(row => normalizeClassification(row.classification) === 'unknown').length;
     const validMissions = uniqueMissions.filter(row => normalizeClassification(row.classification) !== null);
     return {
-        rows: windowRows,
+        rows: closedRows,
         total: validMissions.length,
         userValue,
         aiSdlc,
@@ -760,10 +781,12 @@ function summarizeAgentWindow(rows, window, options = {}) {
     const opts = options;
     const { rootDir = null, deriveFixRoundsFn = deriveFixRoundsLocalAuthoritative } = opts;
     const windowRows = rows.filter(row => rowInWindow(row, window));
+    // Filter to only closed missions (task-1380).
+    const closedWindowRows = windowRows.filter(row => row.closed === 'yes');
     // Only count missions with a valid classification so the agent table totals
     // align with the mission-count table (which also excludes null/invalid
     // classifications via summarizeMissionWindow → validMissions).
-    const validWindowRows = windowRows.filter(row => normalizeClassification(row.classification) !== null);
+    const validWindowRows = closedWindowRows.filter(row => normalizeClassification(row.classification) !== null);
     // Deduplicate globally by (repo, mission) first so each mission is counted
     // exactly once across all agent groups — matching the mission-count table.
     // Prefer the row where model === implementer (the implementer's own model),
@@ -988,7 +1011,8 @@ function renderMissionPhaseReport(rows, slug, options = {}) {
     const opts = options;
     const wantedRepo = String(opts.repo || resolveStatsRepoName(opts.rootDir)).trim();
     const missionRows = (rows || []).filter(row => String(row.mission || '').trim().toLowerCase() === wanted &&
-        String(row.repo || '').trim() === wantedRepo);
+        String(row.repo || '').trim() === wantedRepo &&
+        row.closed === 'yes');
     const byStage = new Map();
     for (const row of missionRows) {
         const stage = String(row.stage || 'default').trim().toLowerCase() || 'default';
@@ -1438,6 +1462,7 @@ function canonicalizeStatsRow(row, options = {}) {
         classification: /** @type{string|number|boolean|undefined} */ (normalizeClassification(row.classification)),
         implementer: /** @type{string|number|boolean|undefined} */ (normalizeImplementer(row.implementer)),
         stage: String(row.stage || '').trim().toLowerCase() || 'default',
+        closed: row.closed || '',
     };
     for (const key of USAGE_NUMBERS) {
         canonical[key] = String(Math.max(0, Number.parseInt(String(/** @type{any} */ (normalized)[key]), 10) || 0));
@@ -1516,6 +1541,7 @@ function recordIntegrationStats(options = {}) {
         classification,
         implementer: implementerInfo.implementer,
         pr_fix_rounds: implementerInfo.prFixRounds,
+        closed: 'yes',
     }, { filePath, rootDir });
     return {
         ...result,
@@ -1982,6 +2008,7 @@ stats._internals = {
     deriveFinalImplementerFromBranchHistory,
     deriveImplementerAndFixRoundsFromPrComments,
     deriveImplementerAndFixRounds,
+    summarizeMissionWindow,
     summarizeAgentWindow,
     colorAverageFixRounds,
     colorMissionCounts,