@magnusekdahl/parallix 1.0.0 → 1.0.2

package/lib/commands/integrate.js

@@ -987,8 +987,13 @@ function printIntegrationPreflight(
     log(fmt.status('PASS', `Backlog task: ${path.basename(context.task.taskFile)} (${context.taskStatus})`));
     
     try {
-      const { classification } = stats.resolveMissionClassification(context.slug);
-      log(fmt.status('PASS', `Backlog classification: ${classification}`));
+      const { classification, error: classificationError } = stats.resolveMissionClassification(context.slug);
+      if (!classification) {
+        failures.push('classification');
+        log(fmt.status('FAIL', `Backlog classification: ${classificationError || 'missing'}`));
+      } else {
+        log(fmt.status('PASS', `Backlog classification: ${classification}`));
+      }
     } catch (error) {
       failures.push('classification');
       log(fmt.status('FAIL', `Backlog classification: ${error.message}`));
@@ -1009,8 +1014,8 @@ function printIntegrationPreflight(
     log(fmt.status('FAIL', `Backlog task: ambiguous slug ${context.slug}`));
     context.task.matches.forEach(match => log(`  - ${match}`));
   } else {
-    failures.push('task-missing');
-    log(fmt.status('FAIL', `Backlog task: no task file found for ${context.slug}`));
+    log(fmt.status('WARN', `Backlog task: no task file found for ${context.slug}; continuing with synthetic/unknown task metadata.`));
+    log(fmt.status('PASS', 'Backlog classification: unknown'));
   }
 
   if (isForgejoReviewEnabledFn(baseWorktree)) {

package/lib/commands/mission-start.js

@@ -143,15 +143,26 @@ function missionStart(args, options = {}) {
       }
 
       try {
-        const { classification } = resolveMissionClassificationFn(slug);
-        log(fmt.status('PASS', `Backlog classification: ${classification}`));
+        const { classification, error: classificationError } = resolveMissionClassificationFn(slug);
+        if (!classification) {
+          log(fmt.status('FAIL', `Backlog classification: ${classificationError || 'missing'}`));
+          overallFail = true;
+        } else {
+          log(fmt.status('PASS', `Backlog classification: ${classification}`));
+        }
       } catch (error) {
         log(fmt.status('FAIL', `Backlog classification: ${error.message}`));
         overallFail = true;
       }
     } else {
-      reportTaskResolution(taskResolution, slug, log);
-      overallFail = true;
+      if (taskResolution.reason === 'missing') {
+        const fallbackClassification = resolveMissionClassificationFn(slug, cwd);
+        log(fmt.status('WARN', `Backlog task: no task file found for ${fmt.slug(slug)}; continuing with classification ${fallbackClassification.classification}.`));
+        log(fmt.status('PASS', `Backlog classification: ${fallbackClassification.classification}`));
+      } else {
+        reportTaskResolution(taskResolution, slug, log);
+        overallFail = true;
+      }
     }
   }
 

package/lib/commands/stats-backfill.js

@@ -154,22 +154,20 @@ function inferHistoricalClassificationFromMissionDoc(slug, rootDir = process.cwd
 }
 
 function resolveHistoricalClassification(slug, taskFile, rootDir = process.cwd()) {
-  try {
-    return {
-      value: stats.resolveMissionClassification(slug, rootDir).classification,
-      source: 'backlog-label',
-    };
-  } catch (_) {
-    const legacy = stats._internals.normalizeClassification(getTaskFrontmatterValue(taskFile, 'classification'));
-    if (legacy) {
-      return { value: legacy, source: 'backlog-classification' };
-    }
-    const inferred = inferHistoricalClassificationFromMissionDoc(slug, rootDir);
-    if (inferred) {
-      return { value: inferred, source: 'mission-doc-heuristic' };
-    }
-    return { value: null, source: null };
+  const resolution = stats.resolveMissionClassification(slug, rootDir);
+  if (resolution.classification) {
+    return { value: resolution.classification, source: 'backlog-label' };
+  }
+  // Classification missing or invalid — fall through to fallbacks.
+  const legacy = stats._internals.normalizeClassification(getTaskFrontmatterValue(taskFile, 'classification'));
+  if (legacy) {
+    return { value: legacy, source: 'backlog-classification' };
+  }
+  const inferred = inferHistoricalClassificationFromMissionDoc(slug, rootDir);
+  if (inferred) {
+    return { value: inferred, source: 'mission-doc-heuristic' };
   }
+  return { value: null, source: null };
 }
 
 function collectHistoricalStatsBackfill(rootDir = process.cwd(), filePath = null) {
@@ -215,7 +213,7 @@ function collectHistoricalStatsBackfill(rootDir = process.cwd(), filePath = null
       implementerError = error.message;
     }
 
-    if (!implementerInfo?.implementer) {
+    if (!implementerInfo?.implementer || implementerInfo.implementer === 'unknown') {
       const gitHistoryImplementer = deriveImplementerFromGitHistory(slug, taskFile, rootDir);
       if (gitHistoryImplementer) {
         implementerInfo = {

package/lib/commands/stats.js

@@ -32,7 +32,7 @@ const USAGE_NUMBERS = new Set([
   'openai_usage_delta', 'duration_minutes'
 ]);
 
-const VALID_CLASSIFICATIONS = new Set(['ai_sdlc', 'user_value']);
+const VALID_CLASSIFICATIONS = new Set(['ai_sdlc', 'user_value', 'unknown']);
 const SHIPPED_STATS_CSV_PATH = path.join(__dirname, '..', 'data', 'stats.seed.csv');
 let STORAGE = null;
 
@@ -462,6 +462,14 @@ function normalizeImplementer(value) {
   return String(value || '').trim().replace(/^@/, '').toLowerCase() || null;
 }
 
+function statsRowActorKey(row = {}) {
+  const stage = String(row.stage || 'default').trim().toLowerCase() || 'default';
+  if (stage === 'review') {
+    return normalizeImplementer(row.reviewer_agent || row.implementer_agent || row.implementer || '') || '';
+  }
+  return normalizeImplementer(row.implementer_agent || row.implementer || '') || '';
+}
+
 function parseDateOnly(value) {
   return new Date(`${value}T00:00:00Z`);
 }
@@ -553,13 +561,16 @@ function summarizeMissionWindow(rows, window) {
     seenMissions.add(key);
     return true;
   });
-  const userValue = uniqueMissions.filter(row => row.classification === 'user_value').length;
-  const aiSdlc = uniqueMissions.filter(row => row.classification === 'ai_sdlc').length;
+  const userValue = uniqueMissions.filter(row => normalizeClassification(row.classification) === 'user_value').length;
+  const aiSdlc = uniqueMissions.filter(row => normalizeClassification(row.classification) === 'ai_sdlc').length;
+  const unknown = uniqueMissions.filter(row => normalizeClassification(row.classification) === 'unknown').length;
+  const validMissions = uniqueMissions.filter(row => normalizeClassification(row.classification) !== null);
   return {
     rows: windowRows,
-    total: uniqueMissions.length,
+    total: validMissions.length,
     userValue,
     aiSdlc,
+    unknown,
   };
 }
 
@@ -712,14 +723,14 @@ function renderWeeklyStatsReport(rows, { today = new Date(), rootDir = null } =
   const lines = [];
   lines.push(fmt.bold(`Current week (${windows.current.label})`));
   lines.push(formatStatsTable(
-    ['# missions', '# user value missions', '# AI SDLC missions'],
-    [[String(currentMissionStats.total), String(currentMissionStats.userValue), String(currentMissionStats.aiSdlc)]]
+    ['# missions', '# user value missions', '# AI SDLC missions', '# unknown missions'],
+    [[String(currentMissionStats.total), String(currentMissionStats.userValue), String(currentMissionStats.aiSdlc), String(currentMissionStats.unknown)]]
   ));
   lines.push('');
   lines.push(fmt.bold(`Previous week (${windows.previous.label})`));
   lines.push(formatStatsTable(
-    ['# missions', '# user value missions', '# AI SDLC missions'],
-    [[String(previousMissionStats.total), String(previousMissionStats.userValue), String(previousMissionStats.aiSdlc)]]
+    ['# missions', '# user value missions', '# AI SDLC missions', '# unknown missions'],
+    [[String(previousMissionStats.total), String(previousMissionStats.userValue), String(previousMissionStats.aiSdlc), String(previousMissionStats.unknown)]]
   ));
   lines.push('');
   lines.push(fmt.bold(`Agent performance this week (${windows.current.label})`));
@@ -750,8 +761,8 @@ function renderRangeStatsReport(rows, { from, to, rootDir = null } = {}) {
   const lines = [];
   lines.push(fmt.bold(`Missions (${window.label})`));
   lines.push(formatStatsTable(
-    ['# missions', '# user value missions', '# AI SDLC missions'],
-    [[String(missionStats.total), String(missionStats.userValue), String(missionStats.aiSdlc)]]
+    ['# missions', '# user value missions', '# AI SDLC missions', '# unknown missions'],
+    [[String(missionStats.total), String(missionStats.userValue), String(missionStats.aiSdlc), String(missionStats.unknown)]]
   ));
   lines.push('');
   lines.push(fmt.bold(`Agent performance (${window.label})`));
@@ -796,7 +807,16 @@ function renderMissionPhaseReport(rows, slug, options = {}) {
   const byStage = new Map();
   for (const row of missionRows) {
     const stage = String(row.stage || 'default').trim().toLowerCase() || 'default';
-    byStage.set(stage, row);
+    if (!byStage.has(stage)) byStage.set(stage, []);
+    byStage.get(stage).push(row);
+  }
+
+  for (const stageRows of byStage.values()) {
+    stageRows.sort((a, b) =>
+      statsRowActorKey(a).localeCompare(statsRowActorKey(b))
+      || String(a.provider || '').localeCompare(String(b.provider || ''))
+      || String(a.model || '').localeCompare(String(b.model || ''))
+    );
   }
 
   const orderedStages = MISSION_PHASE_ORDER.map(entry => entry.stage);
@@ -814,7 +834,7 @@ function renderMissionPhaseReport(rows, slug, options = {}) {
   if (missionRows.length === 0) {
     lines.push(formatStatsTable(
       ['Phase', 'Provider', 'Model', 'Implementer', 'Input', 'Output', 'Cached', 'Tool calls', 'Duration (min)', 'Usage %', 'Cost ($)'],
-      MISSION_PHASE_ORDER.map(entry => [entry.label, '—', '—', '—', '0', '0', '0', '0', '0', '0', '0'])
+      MISSION_PHASE_ORDER.map(entry => [entry.label, '—', '—', '—', '0', '0', '0', '0', '0', '—', '0'])
     ));
     lines.push('');
     lines.push(`No telemetry rows recorded for mission "${wanted}".`);
@@ -830,35 +850,50 @@ function renderMissionPhaseReport(rows, slug, options = {}) {
     if (!Number.isFinite(n) || n === 0) return '0';
     return String(Math.round(n * 100) / 100);
   };
-  const tableRows = phases.map(({ stage, label }) => {
-    const row = byStage.get(stage);
-    if (!row) {
-      return [label, '—', '—', '—', '0', '0', '0', '0', '0', '0', '0'];
+  const tableRows = [];
+  for (const { stage, label } of phases) {
+    const stageRows = byStage.get(stage) || [];
+    if (stageRows.length === 0) {
+      tableRows.push([label, '—', '—', '—', '0', '0', '0', '0', '0', '—', '0']);
+      continue;
     }
-    // For review phases the actor is the reviewer (the row's tokens are the
-    // reviewer's), so surface `reviewer_agent`; other phases show the implementer.
-    const actor = stage === 'review'
-      ? (row.reviewer_agent || row.implementer_agent || row.implementer || '—')
-      : (row.implementer_agent || row.implementer || '—');
-    return [
-      label,
-      row.provider || '—',
-      row.model || '—',
-      actor,
-      num(row, 'input_tokens'),
-      num(row, 'output_tokens'),
-      num(row, 'cached_tokens'),
-      num(row, 'tool_calls'),
-      num(row, 'duration_minutes'),
-      num(row, 'openai_usage_after'),
-      cost(row.cost_usd),
-    ];
-  });
+    for (const row of stageRows) {
+      const actor = stage === 'review'
+        ? (row.reviewer_agent || row.implementer_agent || row.implementer || '—')
+        : (row.implementer_agent || row.implementer || '—');
+      tableRows.push([
+        label,
+        row.provider || '—',
+        row.model || '—',
+        actor,
+        num(row, 'input_tokens'),
+        num(row, 'output_tokens'),
+        num(row, 'cached_tokens'),
+        num(row, 'tool_calls'),
+        num(row, 'duration_minutes'),
+        (() => {
+          const displayActor = (stage === 'review'
+            ? (row.reviewer_agent || row.implementer_agent || row.implementer || '')
+            : (row.implementer_agent || row.implementer || ''));
+          const actorLower = displayActor.trim().toLowerCase();
+          if (actorLower === 'claude') return '—';
+          return (row.provider && row.provider.toLowerCase() === 'openai')
+            ? num(row, 'openai_usage_after')
+            : '—';
+        })(),
+        cost(row.cost_usd),
+      ]);
+    }
+  }
 
   const totals = ['input_tokens', 'output_tokens', 'cached_tokens', 'tool_calls', 'duration_minutes']
     .map(key => missionRows.reduce((sum, row) => sum + (Number.parseInt(row[key], 10) || 0), 0));
-  const totalCost = missionRows.reduce((sum, row) => sum + (Number.parseFloat(row.cost_usd) || 0), 0);
-  tableRows.push(['total', '', '', '', String(totals[0]), String(totals[1]), String(totals[2]), String(totals[3]), String(totals[4]), '', cost(totalCost)]);
+  // Compute total cost from rounded individual costs so the total equals
+  // the sum of displayed phase costs (avoids floating-point rounding drift).
+  const totalCost = tableRows
+    .filter(r => r[0] !== 'total')
+    .reduce((sum, r) => sum + (Number.parseFloat(cost(r[10])) || 0), 0);
+  tableRows.push(['total', '', '', '', String(totals[0]), String(totals[1]), String(totals[2]), String(totals[3]), String(totals[4]), '—', cost(totalCost)]);
 
   lines.push(formatStatsTable(
     ['Phase', 'Provider', 'Model', 'Implementer', 'Input', 'Output', 'Cached', 'Tool calls', 'Duration (min)', 'Usage %', 'Cost ($)'],
@@ -1156,31 +1191,41 @@ function deriveImplementerAndFixRounds(slug, rootDir = process.cwd()) {
   }
 
   const resolution = resolveTaskFile(slug, rootDir);
-  if (!resolution.ok) {
-    throw new Error(`Could not resolve backlog task for ${slug}.`);
-  }
-
-  const implementer = normalizeImplementer(getTaskImplementer(resolution.taskFile) || getTaskAssignee(resolution.taskFile));
-  if (!implementer) {
-    throw new Error(`Could not determine final implementer for ${slug}.`);
+  if (resolution.ok) {
+    const implementer = normalizeImplementer(getTaskImplementer(resolution.taskFile) || getTaskAssignee(resolution.taskFile));
+    if (implementer) {
+      return {
+        implementer,
+        prFixRounds: deriveFixRoundsFromTaskText(resolution.taskFile),
+        source: 'backlog-fallback',
+      };
+    }
   }
 
   return {
-    implementer,
-    prFixRounds: deriveFixRoundsFromTaskText(resolution.taskFile),
-    source: 'backlog-fallback',
+    implementer: 'unknown',
+    prFixRounds: 0,
+    source: 'unknown-fallback',
   };
 }
 
 function resolveMissionClassification(slug, rootDir = process.cwd()) {
   const resolution = resolveTaskFile(slug, rootDir);
   if (!resolution.ok) {
-    throw new Error(`Could not resolve backlog task for ${slug}.`);
+    return {
+      classification: null,
+      taskFile: null,
+      error: `Could not resolve backlog task for ${slug}.`,
+    };
   }
 
   const classification = normalizeClassification(getTaskClassification(resolution.taskFile));
   if (!classification) {
-    throw new Error(`Missing or invalid classification for ${slug}; expected exactly one of ai_sdlc or user_value in the labels of ${resolution.taskFile}. Fix: add exactly one of those labels and do not use a separate frontmatter field for mission type.`);
+    return {
+      classification: null,
+      taskFile: resolution.taskFile,
+      error: `Missing or invalid classification for ${slug}; expected exactly one of ai_sdlc, user_value, or unknown in the labels of ${resolution.taskFile}. Fix: add exactly one of those labels and do not use a separate frontmatter field for mission type.`,
+    };
   }
 
   return {
@@ -1224,7 +1269,8 @@ function upsertStatsRow(row, options = {}) {
   const existingIndex = data.rows.findIndex(existing =>
     existing.repo === canonicalRow.repo &&
     existing.mission === canonicalRow.mission &&
-    (existing.stage || 'default') === canonicalRow.stage
+    (existing.stage || 'default') === canonicalRow.stage &&
+    statsRowActorKey(existing) === statsRowActorKey(canonicalRow)
   );
   let changed = false;
 
@@ -1259,7 +1305,11 @@ function recordIntegrationStats({
     throw new Error('recordIntegrationStats requires a mission slug.');
   }
 
-  const { classification } = resolveMissionClassification(slug, rootDir);
+  const resolution = resolveMissionClassification(slug, rootDir);
+  if (!resolution.classification) {
+    throw new Error(`Cannot record integration stats for ${slug}: ${resolution.error || 'missing classification'}`);
+  }
+  const { classification } = resolution;
   const implementerInfo = deriveImplementerAndFixRounds(slug, rootDir);
   const result = upsertStatsRow({
     date,
@@ -1317,6 +1367,35 @@ function telemetryToStatsFields(telemetry, { agentFamily, durationMinutes = 0 }
   };
 }
 
+function sameStatsIdentity(a, b) {
+  return a.repo === b.repo
+    && a.mission === b.mission
+    && (a.stage || 'default') === (b.stage || 'default')
+    && statsRowActorKey(a) === statsRowActorKey(b);
+}
+
+function accumulateIntegerStrings(existing, incoming, { mode = 'sum' } = {}) {
+  const current = Number.parseInt(existing, 10) || 0;
+  const next = Number.parseInt(incoming, 10) || 0;
+  if (mode === 'max') return String(Math.max(current, next));
+  if (mode === 'replace') return String(next);
+  return String(current + next);
+}
+
+function accumulateDecimalStrings(existing, incoming) {
+  const current = Number.parseFloat(existing) || 0;
+  const next = Number.parseFloat(incoming) || 0;
+  return String(current + next);
+}
+
+function mergeLabel(existing, incoming) {
+  const a = String(existing || '').trim();
+  const b = String(incoming || '').trim();
+  if (!a) return b;
+  if (!b) return a;
+  return a === b ? a : 'mixed';
+}
+
 /**
  * Record one stage row (draft/active/review/...) keyed by (repo, mission, stage).
  * Shared by the draft launcher and the review-loop hooks. Token columns come
@@ -1337,7 +1416,10 @@ function recordStageStats({
   if (!slug) throw new Error('recordStageStats requires a mission slug.');
   if (!stage) throw new Error('recordStageStats requires a stage.');
 
-  const { classification } = resolveMissionClassification(slug, rootDir);
+  const { classification, error: classificationError } = resolveMissionClassification(slug, rootDir);
+  if (!classification) {
+    throw new Error(`Cannot record stage stats for ${slug}: ${classificationError || 'missing classification'}`);
+  }
   const agentFamily = implementer || reviewer || 'unknown';
 
   return upsertStatsRow({
@@ -1353,6 +1435,69 @@ function recordStageStats({
   }, { filePath, rootDir });
 }
 
+function accumulateStageStats({
+  slug,
+  stage,
+  rootDir = process.cwd(),
+  filePath = resolveStatsPath({ rootDir, forWrite: true }),
+  date = formatDateOnly(new Date()),
+  implementer,
+  reviewer = '',
+  prFixRounds = '0',
+  telemetry = null,
+  durationMinutes = 0,
+} = {}) {
+  if (!slug) throw new Error('accumulateStageStats requires a mission slug.');
+  if (!stage) throw new Error('accumulateStageStats requires a stage.');
+
+  const { classification, error: classificationError } = resolveMissionClassification(slug, rootDir);
+  if (!classification) {
+    throw new Error(`Cannot record stage stats for ${slug}: ${classificationError || 'missing classification'}`);
+  }
+  const agentFamily = implementer || reviewer || 'unknown';
+  const incomingRow = canonicalizeStatsRow({
+    date,
+    mission: slug,
+    classification,
+    implementer: agentFamily,
+    pr_fix_rounds: prFixRounds ?? '0',
+    implementer_agent: implementer || '',
+    reviewer_agent: reviewer || '',
+    stage,
+    ...telemetryToStatsFields(telemetry, { agentFamily, durationMinutes }),
+  }, { rootDir });
+
+  const data = loadStatsCsv(filePath, { rootDir });
+  const existing = data.rows.find(row => sameStatsIdentity(row, incomingRow));
+  if (!existing) {
+    return upsertStatsRow(incomingRow, { filePath, rootDir });
+  }
+
+  const mergedRow = {
+    ...existing,
+    date: incomingRow.date,
+    classification: incomingRow.classification,
+    implementer: incomingRow.implementer,
+    pr_fix_rounds: incomingRow.pr_fix_rounds,
+    implementer_agent: incomingRow.implementer_agent,
+    reviewer_agent: incomingRow.reviewer_agent,
+    provider: mergeLabel(existing.provider, incomingRow.provider),
+    model: mergeLabel(existing.model, incomingRow.model),
+    input_tokens: accumulateIntegerStrings(existing.input_tokens, incomingRow.input_tokens),
+    output_tokens: accumulateIntegerStrings(existing.output_tokens, incomingRow.output_tokens),
+    cached_tokens: accumulateIntegerStrings(existing.cached_tokens, incomingRow.cached_tokens),
+    context_tokens: accumulateIntegerStrings(existing.context_tokens, incomingRow.context_tokens),
+    tool_calls: accumulateIntegerStrings(existing.tool_calls, incomingRow.tool_calls),
+    openai_usage_before: accumulateIntegerStrings(existing.openai_usage_before, incomingRow.openai_usage_before, { mode: 'replace' }),
+    openai_usage_after: accumulateIntegerStrings(existing.openai_usage_after, incomingRow.openai_usage_after, { mode: 'max' }),
+    openai_usage_delta: accumulateIntegerStrings(existing.openai_usage_delta, incomingRow.openai_usage_delta),
+    duration_minutes: accumulateIntegerStrings(existing.duration_minutes, incomingRow.duration_minutes),
+    cost_usd: accumulateDecimalStrings(existing.cost_usd, incomingRow.cost_usd),
+  };
+
+  return upsertStatsRow(mergedRow, { filePath, rootDir });
+}
+
 /**
  * Default the per-mission fix-round count from the mission-local review event
  * store when the caller didn't supply one. Fix rounds are a property of the
@@ -1570,6 +1715,7 @@ module.exports.saveStatsCsv = saveStatsCsv;
 module.exports.normalizeStatsRow = normalizeStatsRow;
 module.exports.canonicalizeStatsRow = canonicalizeStatsRow;
 module.exports.recordStageStats = recordStageStats;
+module.exports.accumulateStageStats = accumulateStageStats;
 module.exports.recordActiveStats = recordActiveStats;
 module.exports.recordReviewStats = recordReviewStats;
 module.exports.telemetryToStatsFields = telemetryToStatsFields;

package/lib/core/mission-utils.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const fmt = require('./fmt');
-const { loadAdapterConfig } = require('./product-config');
+const { loadAdapterConfig, resolveTaskStorage } = require('./product-config');
 
 function normalizeBranchPrefix(prefix) {
   if (typeof prefix !== 'string' || !prefix.trim()) {
@@ -54,6 +54,10 @@ function missionBranchRef(slug, rootDir = process.cwd()) {
   return `refs/heads/${missionBranchName(slug, rootDir)}`;
 }
 
+function isMissionSlugCandidate(value) {
+  return typeof value === 'string' && /^(task|adhoc)-[a-z0-9][a-z0-9-]*$/i.test(value.trim());
+}
+
 function extractSlugFromBranch(branch, rootDir = process.cwd()) {
   const prefix = missionBranchPrefix(rootDir);
   if (!branch || !branch.startsWith(prefix)) return null;
@@ -654,7 +658,7 @@ function missionDirForSlug(rootDir, slug) {
  * @returns {string|null}
  */
 function inferSlug(slugCandidate) {
-  if (slugCandidate && slugCandidate.toLowerCase().startsWith('task-')) {
+  if (isMissionSlugCandidate(slugCandidate)) {
     return slugCandidate.toLowerCase();
   }
 
@@ -672,8 +676,9 @@ function inferSlug(slugCandidate) {
   // 3. Check directory name
   const cwd = process.cwd();
   const dirName = path.basename(cwd);
-  if (dirName.includes('-task-')) {
-    return dirName.slice(dirName.lastIndexOf('task-')).toLowerCase();
+  const dirSlugMatch = dirName.match(/((?:task|adhoc)-[a-z0-9][a-z0-9-]*)$/i);
+  if (dirSlugMatch) {
+    return dirSlugMatch[1].toLowerCase();
   }
 
 
@@ -938,8 +943,8 @@ function findMissionDocInBranches(slug, rootDir = process.cwd(), gitRunner = nul
  * Check if a file path is a mission artifact for a specific slug.
  * Mission artifacts include:
  * - missions/<slug>/* by default, or the adapter-configured legacy path
- * - backlog/tasks/<slug> - *.md
- * - backlog/completed/<slug> - *.md
+ * - the adapter-configured task storage path for active tasks
+ * - the adapter-configured task storage path for completed tasks
  *
  * @param {string} file - Relative file path
  * @param {string} slug - Mission slug (e.g. task-1107)
@@ -954,10 +959,14 @@ function isMissionArtifact(file, slug, rootDir = process.cwd()) {
   const legacyMissionDir = `docs/missions/${getMissionYear(slug, rootDir)}/${slug}/`;
   if (file.startsWith(legacyMissionDir)) return true;
 
-  // Backlog tasks: task-NNN - title.md or task-NNN.md
+  // Task files: task-NNN - title.md or task-NNN.md in the configured storage.
   const escapedSlug = slug.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const backlogPattern = new RegExp(`^backlog/(tasks|completed)/${escapedSlug}(?:\\s+-\\s+[^/]+\\.md|\\.md)$`, 'i');
-  if (backlogPattern.test(file)) return true;
+  const taskStorage = resolveTaskStorage(rootDir);
+  const taskDirs = [taskStorage.tasksDir, taskStorage.completedDir]
+    .map(dir => path.relative(rootDir, dir).split(path.sep).join('/'))
+    .map(dir => dir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  const taskPattern = new RegExp(`^(?:${taskDirs.join('|')})/${escapedSlug}(?:\\s+-\\s+[^/]+\\.md|\\.md)$`, 'i');
+  if (taskPattern.test(file)) return true;
 
   return false;
 }
@@ -979,6 +988,7 @@ module.exports = {
   missionBranchName,
   missionBranchRef,
   extractSlugFromBranch,
+  isMissionSlugCandidate,
   getPrimaryBranch,
   getPrimaryWorktree,
   resolveMainRepo,

package/lib/core/product-config.js

@@ -371,10 +371,12 @@ function resolveTaskStorage(rootDir = process.cwd()) {
     baseDir: fallbackBaseDir,
     tasksDir: path.join(fallbackBaseDir, 'tasks'),
     completedDir: path.join(fallbackBaseDir, 'completed'),
+    archiveTasksDir: path.join(fallbackBaseDir, 'archive', 'tasks'),
     draftsDir: path.join(fallbackBaseDir, 'drafts'),
   };
 
-  const storage = loadAdapterConfig(rootDir).tasks && loadAdapterConfig(rootDir).tasks.storage;
+  const tasksAdapter = loadAdapterConfig(rootDir).tasks || {};
+  const storage = tasksAdapter.storagePath || tasksAdapter.storage;
   if (!storage) {
     return fallback;
   }
@@ -388,6 +390,7 @@ function resolveTaskStorage(rootDir = process.cwd()) {
         baseDir,
         tasksDir: storageDir,
         completedDir: path.join(baseDir, 'completed'),
+        archiveTasksDir: path.join(baseDir, 'archive', 'tasks'),
         draftsDir: path.join(baseDir, 'drafts'),
       };
     }
@@ -396,6 +399,7 @@ function resolveTaskStorage(rootDir = process.cwd()) {
       baseDir: storageDir,
       tasksDir: path.join(storageDir, 'tasks'),
       completedDir: path.join(storageDir, 'completed'),
+      archiveTasksDir: path.join(storageDir, 'archive', 'tasks'),
       draftsDir: path.join(storageDir, 'drafts'),
     };
   }
@@ -413,6 +417,9 @@ function resolveTaskStorage(rootDir = process.cwd()) {
       baseDir,
       tasksDir,
       completedDir,
+      archiveTasksDir: storage.archiveTasksDir
+        ? path.resolve(rootDir, storage.archiveTasksDir)
+        : path.join(baseDir, 'archive', 'tasks'),
       draftsDir: path.join(baseDir, 'drafts'),
     };
   }

package/lib/review/review-commands.js

@@ -1190,6 +1190,7 @@ async function review(args, options = {}) {
   const submitReviewRoundFn = options.submitReviewRoundFn || submitReviewRound;
   const closeMissionPrFn = options.closeMissionPrFn || closeMissionPr;
   const startReviewLoopFn = options.startReviewLoopFn || require('./review-loop').startReviewLoop;
+const recordStageStatsSafeFn = options.recordStageStatsSafeFn || require('./review-loop').recordStageStatsSafe;
   const startAgentFn = options.startAgentFn || startAgent;
   const resolveTaskFileFn = options.resolveTaskFileFn || resolveTaskFile;
   const getTaskImplementerFn = options.getTaskImplementerFn || getTaskImplementer;
@@ -1295,7 +1296,8 @@ async function review(args, options = {}) {
       isContinue,
       verbose,
       pollTimeoutSeconds,
-      missionPath
+      missionPath,
+      recordStageStatsSafeFn
     });
   } else {
     const pr = getPrStatusFn(missionBranchName(slug, process.cwd()), process.cwd());