@magnusekdahl/parallix 1.0.4 → 1.1.0

package/lib/agents/opencode.js

@@ -39,7 +39,7 @@ function __setJsonFormatDetectForTest(fn) {
 //   1. Legacy footer:  "Continue  opencode -s ses_<id>"  (older opencode TUI).
 //   2. JSON stream:     `"sessionID":"ses_<id>"`           (opencode v2.0.0
 //      `run --format json`). v2.0.0's plain `run` no longer prints the footer,
-//      so without the JSON field the id is lost and qwen telemetry drops to all
+//      so without the JSON field the id is lost and custom telemetry drops to all
 //      zeros (task-1339). We request `--format json` in buildOpencodeInvocation
 //      so this field is always present.
 const OPENCODE_SESSION_ID_RE = /opencode\s+-s\s+(ses_\S+)/i;
@@ -132,7 +132,7 @@ function buildOpencodeInvocation({ prompt, worktree, env, resume = false, sessio
   };
 }
 
-// Transient qwen/vLLM backend failures that opencode surfaces as a non-zero
+// Transient custom/vLLM backend failures that opencode surfaces as a non-zero
 // exit. These are recoverable: the same prompt frequently succeeds on a second
 // attempt, so the launcher retries once in-family before agents.js reroutes to a
 // different agent family. Limit-hit phrases are intentionally NOT listed here —
@@ -181,6 +181,19 @@ function isHardOpencodeFailure(result) {
   return HARD_OPENCODE_PATTERNS.some((re) => re.test(text));
 }
 
+// Opencode v2.0.0 JSON-mode sometimes exits with code 1 during post-run
+// cleanup (race closing the stdout pipe, EPIPE, or draining pending events).
+// When the transcript contains a valid "reason":"stop" completion event and
+// no "type":"error" event, the exit is spurious – the agent actually
+// completed successfully. See opencode issues #31446 and #33653.
+function isSpuriousOpencodeExit(result) {
+  if (!result || result.status !== 1) return false;
+  const text = failureText(result);
+  const hasStop = /"reason"\s*:\s*"stop"/.test(text);
+  const hasError = /"type"\s*:\s*"error"/.test(text);
+  return hasStop && !hasError;
+}
+
 function isTransientOpencodeFailure(result) {
   if (!result) return false;
   const text = failureText(result);
@@ -197,7 +210,7 @@ function shouldRetryOpencodeFailure(result) {
   if (result.signal) return false;
   if (!(typeof result.status === 'number' && result.status !== 0)) return false;
   if (detectLimitHit({
-    agent: 'qwen',
+    agent: 'custom',
     stdout: result.stdout,
     stderr: result.stderr,
     status: result.status,
@@ -261,7 +274,7 @@ function startOpencodeAgent({
       try {
         const exportJson = await _captureExport(result.sessionId, { worktree, env });
         if (exportJson) {
-          const telemetry = extractOpencodeTelemetryFromExport(exportJson);
+          const telemetry = extractOpencodeTelemetryFromExport(exportJson, model);
           if (telemetry) {
             result.telemetry = telemetry;
             if (telemetry.model) result.model = telemetry.model;
@@ -313,6 +326,7 @@ module.exports = {
   extractOpencodeSessionId,
   resolveOpencodeCommand,
   startOpencodeAgent,
+  isSpuriousOpencodeExit,
   isTransientOpencodeFailure,
   isHardOpencodeFailure,
   shouldRetryOpencodeFailure,

package/lib/commands/active.js

@@ -7,7 +7,7 @@ const agents = require('../agents/agents');
 const { findMissionDir, findCheckpoints, getFirstLine, resolveWorktree, inferSlug, getMissionYear, missionDirForSlug, isWorkflowGeneratedArtifact } = require('../core/mission-utils');
 const handoff = require('./handoff');
 const { resolveTaskFile, transitionTask, getTaskStatus, getTaskImplementer } = require('../tools/backlog');
-const { loadAdapterConfig } = require('../core/product-config');
+const { loadAdapterConfig, resolveAgentModel } = require('../core/product-config');
 const review = require('../review/review');
 const repairHandoff = require('./repair-handoff');
 const stats = require('./stats');
@@ -125,6 +125,7 @@ async function active(args, {
       slug: normalizedSlug,
       rootDir: worktree,
       implementer: agent,
+      model: resolveAgentModel(agent, worktree),
       // Use the windowed Codex rollout (bounded by sinceMs) when present, else
       // the launcher-attached telemetry — same resolution as the review hook,
       // so the execute phase records this stage's delta, not cumulative usage.
@@ -307,7 +308,7 @@ async function attemptAgentRelaunch(slug, worktree, errorMsg, agent, {
   const prompt = buildRelaunchPromptFn(errorMsg, slug, worktree);
 
   log(`Attempting to relaunch ${fmt.agent(agent)} to fix repairable handoff error...`);
-  // startAgent handles resume flags internally for resume-capable agents (codex, claude, gemini, qwen)
+  // startAgent handles resume flags internally for resume-capable agents (codex, claude, gemini, custom)
 
   try {
     const result = await startAgentFn('active', {

package/lib/commands/draft.js

@@ -9,7 +9,7 @@ const { findMissionArea, findMissionDir, inferSlug, getMissionYear, resolveMainR
 const { transitionVirtual } = require('../core/state-map');
 const stats = require('./stats');
 const { formatVerificationCommand } = require('../core/verification');
-const { ensureStandaloneMissionBaseline } = require('../core/product-config');
+const { ensureStandaloneMissionBaseline, resolveAgentModel } = require('../core/product-config');
 const { ensureWorkflowGitignore } = require('../core/gitignore');
 const { unquoteGitStatusPath } = require('./active');
 
@@ -114,6 +114,7 @@ async function runDraftCommand(args, {
   transitionTaskFn = transitionTask,
   transitionVirtualFn = transitionVirtual,
   recordDraftImplementerFn = recordDraftImplementer,
+  recordDraftStatsFn = recordDraftStats,
   enforceDraftCommitSafetyFn = enforceDraftCommitSafety,
   validateDraftClassificationFn = validateDraftClassification,
   normalizeDraftClassificationFn = normalizeDraftClassification,
@@ -169,8 +170,32 @@ async function runDraftCommand(args, {
     return;
   }
 
+  // Detect the branch HEAD is on at draft time (where the human stands). This is
+  // the single source of truth for the mission's base. A non-primary feature
+  // branch is recorded as the mission base; the primary branch (or a detached
+  // HEAD) leaves no record and keeps the byte-identical legacy behaviour.
+  let launchBase = null;
+  try {
+    launchBase = detectLaunchBaseBranchFn(process.cwd());
+  } catch (error) {
+    errorFn(fmt.status('FAIL', error.message));
+    exitFn(1);
+    return;
+  }
+  let recordedBase = null;
+  if (launchBase && launchBase !== getPrimaryBranch(mainRepo)) {
+    recordedBase = launchBase;
+    logFn(fmt.status('INFO', `Feature-branch mission: base branch detected as ${fmt.branch(recordedBase)}.`));
+  }
+
+  // A feature-branch mission may reference a task that was only committed on that
+  // feature branch, so it is absent from the primary checkout (mainRepo). In that
+  // case the task lives in the current worktree (where HEAD is on the feature
+  // branch), which the mission branch is cut from. Resolve preflight checks there.
+  const taskLookupRoot = recordedBase ? process.cwd() : mainRepo;
+
   // Preflight: Ensure Backlog task exists and is unambiguous before side effects
-  const mainResolution = resolveTaskFileFn(normalizedSlug, mainRepo);
+  const mainResolution = resolveTaskFileFn(normalizedSlug, taskLookupRoot);
   if (!mainResolution.ok && !syntheticTask) {
     reportTaskResolutionFn(mainResolution, normalizedSlug, errorFn);
     exitFn(1);
@@ -178,7 +203,7 @@ async function runDraftCommand(args, {
   }
 
   // Preflight: Backlog integrity check (filename vs frontmatter ID)
-  const relevantIssues = syntheticTask ? [] : checkBacklogIntegrityFn(mainRepo, normalizedSlug);
+  const relevantIssues = syntheticTask ? [] : checkBacklogIntegrityFn(taskLookupRoot, normalizedSlug);
   if (relevantIssues.length > 0) {
     errorFn(fmt.status('FAIL', `Backlog integrity issues detected for ${normalizedSlug}:`));
     relevantIssues.forEach(issue => {
@@ -193,24 +218,6 @@ async function runDraftCommand(args, {
     return;
   }
 
-  // Detect the branch HEAD is on at draft time (where the human stands). This is
-  // the single source of truth for the mission's base. A non-primary feature
-  // branch is recorded as the mission base; the primary branch (or a detached
-  // HEAD) leaves no record and keeps the byte-identical legacy behaviour.
-  let launchBase = null;
-  try {
-    launchBase = detectLaunchBaseBranchFn(process.cwd());
-  } catch (error) {
-    errorFn(fmt.status('FAIL', error.message));
-    exitFn(1);
-    return;
-  }
-  let recordedBase = null;
-  if (launchBase && launchBase !== getPrimaryBranch(mainRepo)) {
-    recordedBase = launchBase;
-    logFn(fmt.status('INFO', `Feature-branch mission: base branch detected as ${fmt.branch(recordedBase)}.`));
-  }
-
   const branchName = missionBranchName(normalizedSlug, mainRepo);
   logFn(fmt.bold(`Step 1: Setting up branch ${fmt.branch(branchName)}...`));
   ensureMissionBranchFn(mainRepo, branchName, { logFn, baseBranch: recordedBase });
@@ -299,9 +306,12 @@ async function runDraftCommand(args, {
     worktree: targetWorktree
   });
 
-  recordDraftStats({
+  // Record stats from the mission worktree, where the backlog task always lives
+  // (a feature-branch task is absent from mainRepo/the primary checkout). This
+  // matches how the review and active stages record stats (rootDir: worktree).
+  recordDraftStatsFn({
     slug: normalizedSlug,
-    rootDir: mainRepo,
+    rootDir: targetWorktree,
     agentFamily: actualAgent,
     result,
     log: logFn,
@@ -954,6 +964,7 @@ function recordDraftStats({ slug, rootDir, agentFamily, result, log = fmt.log.pl
       stage: 'draft',
       rootDir,
       implementer: agentFamily,
+      model: resolveAgentModel(agentFamily, rootDir),
       telemetry: result.telemetry || null,
       durationMinutes,
     });

package/lib/commands/integrate.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const child_process = require('child_process');
-const { git, getCurrentBranch } = require('../core/git');
+const { detectRebaseState, git, getCurrentBranch } = require('../core/git');
 const { resolveTaskFile, getTaskStatus, setTaskStatus, completeTask, getTaskAssignee } = require('../tools/backlog');
 const { toVirtual, toActual } = require('../core/state-map');
 const { getPrStatus, getLatestReviewDecision, syncMerged, readToken, resolveTokenFile, resolveForgejoUser, resolveForgejoHome, isForgejoPath, listOpenPrsForSlug } = require('../tools/forgejo');
@@ -587,7 +587,8 @@ async function integrate(args) {
             const syncResult = syncMerged(branch, mergedCommit, {
               rootDir: baseWorktree,
               forgejoUser: context.forgejoUser,
-              token: context.forgejoToken
+              token: context.forgejoToken,
+              baseBranch: context.baseBranch
             });
             if (!syncResult.ok) {
               reportSyncMergedFailure(syncResult);
@@ -617,7 +618,7 @@ async function integrate(args) {
           for (const line of formatMatrixSummary(buildAutonomousReviewMatrix())) {
             fmt.log.info(line);
           }
-          for (const line of buildConflictResolutionPrompt(slug, context.area)) {
+          for (const line of buildConflictResolutionPrompt(slug, context.area, { baseBranch: context.baseBranch })) {
             fmt.log.info(line);
           }
           throw new IntegrationAbort();
@@ -703,7 +704,8 @@ async function integrate(args) {
           const syncResult = syncMerged(branch, mergedCommit, {
             rootDir: baseWorktree,
             forgejoUser: context.forgejoUser,
-            token: context.forgejoToken
+            token: context.forgejoToken,
+            baseBranch: context.baseBranch
           });
           if (!syncResult.ok) {
             reportSyncMergedFailure(syncResult);
@@ -935,6 +937,7 @@ function printIntegrationPreflight(
   {
     readTokenFn = readToken,
     resolveTokenFileFn = resolveTokenFile,
+    detectRebaseStateFn = detectRebaseState,
     getUnresolvedIndexConflictsFn = getUnresolvedIndexConflicts,
     findMissionDocInBranchesFn = findMissionDocInBranches,
     isForgejoReviewEnabledFn = isForgejoReviewEnabled,
@@ -1088,6 +1091,23 @@ function printIntegrationPreflight(
     log(fmt.status('INFO', `Retry with: git -C ${baseWorktree} checkout ${expectedPrimaryBranch}`));
   }
 
+  const rebaseState = detectRebaseStateFn(baseWorktree);
+  if (rebaseState.inProgress) {
+    failures.push('rebase-in-progress');
+    log(fmt.status('FAIL', `Integration checkout rebase: rebase in progress in ${baseWorktree}`));
+    if (rebaseState.rebaseHead) {
+      log(fmt.status('INFO', `Current rebase head: ${rebaseState.rebaseHead}`));
+    }
+    if (rebaseState.unmergedFiles.length > 0) {
+      rebaseState.unmergedFiles.forEach(file => log(fmt.status('INFO', `  - ${file}`)));
+    }
+    log(fmt.status('INFO', 'Finish or abort the existing rebase before retrying:'));
+    log(fmt.status('INFO', `  git -C ${baseWorktree} rebase --continue`));
+    log(fmt.status('INFO', `  git -C ${baseWorktree} rebase --abort`));
+    log(fmt.status('INFO', `  git -C ${baseWorktree} rebase --skip`));
+    log(fmt.status('INFO', `Retry with: px integrate ${context.slug} --dry-run`));
+  }
+
   const indexConflicts = getUnresolvedIndexConflictsFn(baseWorktree);
   if (!indexConflicts.ok) {
     failures.push('main-index-conflict-check');
@@ -1396,7 +1416,7 @@ function findExistingSquashCommit(rootDir, slug) {
  * @param {{ getConflictFilesFn?: Function }} [options] - Overrides for testing
  * @returns {{ ok: boolean, conflictFiles: string[], sharedFiles: string[], missionSpecificFiles: string[] }}
  */
-function resolveConflictsForMission(slug, area, { getConflictFilesFn, resolveWorktreeFn = resolveWorktree, worktreePathOverride = null, rootDir = getPrimaryWorktree() } = {}) {
+function resolveConflictsForMission(slug, area, { getConflictFilesFn, resolveWorktreeFn = resolveWorktree, worktreePathOverride = null, rootDir = getPrimaryWorktree(), baseBranch = null } = {}) {
   // Resolve the actual attached worktree dynamically; fall back to the conventional
   // path only when git worktree list has no entry for this mission branch.
   const conventionalPath = `${conventionalWorktreePath(slug, rootDir)}`;
@@ -1406,7 +1426,15 @@ function resolveConflictsForMission(slug, area, { getConflictFilesFn, resolveWor
     fmt.log.warn(`No registered worktree found for ${missionBranchName(slug, rootDir)}; falling back to conventional path.`);
   }
 
-  const detectFn = getConflictFilesFn || ((_rootDir, _branch) => getConflictFiles(worktreePath, getPrimaryBranch()));
+  // Conflicts must be detected against the branch the mission integrates back
+  // into. For a feature-branch mission that is the recorded base branch, not the
+  // primary branch; for legacy missions resolveMissionBaseBranch returns primary.
+  let targetBranch = baseBranch;
+  if (!targetBranch) {
+    try { targetBranch = resolveMissionBaseBranch(slug, rootDir); } catch (_) { targetBranch = getPrimaryBranch(); }
+  }
+
+  const detectFn = getConflictFilesFn || ((_rootDir, _branch) => getConflictFiles(worktreePath, targetBranch));
 
   if (!fs.existsSync(worktreePath)) {
     fmt.log.fail(`Mission worktree not found: ${worktreePath}`);
@@ -1414,10 +1442,10 @@ function resolveConflictsForMission(slug, area, { getConflictFilesFn, resolveWor
     return { ok: false, error: 'worktree-missing', conflictFiles: [], sharedFiles: [], missionSpecificFiles: [], worktreePath };
   }
 
-  fmt.log.info(`Detecting conflicts in ${worktreePath} against ${getPrimaryBranch()}...`);
+  fmt.log.info(`Detecting conflicts in ${worktreePath} against ${targetBranch}...`);
   let conflictFiles;
   try {
-    conflictFiles = detectFn(worktreePath, getPrimaryBranch());
+    conflictFiles = detectFn(worktreePath, targetBranch);
   } catch (err) {
     fmt.log.fail('Merge check failed with a non-conflict error:');
     fmt.log.fail(err.message);
@@ -1447,7 +1475,7 @@ function resolveConflictsForMission(slug, area, { getConflictFilesFn, resolveWor
     sharedFiles.forEach(f => fmt.log.plain(`  - ${f}`));
     fmt.log.info('Manual resolution path:');
     fmt.log.info(`  cd ${quotedWorktreePath}`);
-    fmt.log.info(`  git rebase ${getPrimaryBranch()}`);
+    fmt.log.info(`  git rebase ${targetBranch}`);
     fmt.log.info('  # resolve each shared file conflict manually');
     fmt.log.info('  git add <resolved-files>');
     fmt.log.info('  git rebase --continue');
@@ -1459,7 +1487,7 @@ function resolveConflictsForMission(slug, area, { getConflictFilesFn, resolveWor
   fmt.log.info(`All ${missionSpecificFiles.length} conflict(s) are in mission-specific files.`);
   fmt.log.info('Skip-all-conflicts path (use --theirs to keep the mission version):');
   fmt.log.info(`  cd ${quotedWorktreePath}`);
-  fmt.log.info(`  git rebase ${getPrimaryBranch()}`);
+  fmt.log.info(`  git rebase ${targetBranch}`);
   fmt.log.info('  # after the rebase pauses on conflicts:');
   missionSpecificFiles.forEach(f => fmt.log.info(`  git checkout --theirs "${f}" && git add "${f}"`));
   fmt.log.info('  git rebase --continue');
@@ -1473,6 +1501,12 @@ function buildConflictResolutionPrompt(slug = '<slug>', area = '<area>', options
   const rootDir = options.rootDir || getPrimaryWorktree();
   const worktreePath = options.worktreePath || resolveWorktree(slug) || conventionalWorktreePath(slug, rootDir);
   const quotedWorktreePath = shellQuote(worktreePath);
+  // Rebase guidance must target the branch the mission integrates back into: the
+  // recorded base for feature-branch missions, the primary branch otherwise.
+  let targetBranch = options.baseBranch;
+  if (!targetBranch) {
+    try { targetBranch = resolveMissionBaseBranch(slug, rootDir); } catch (_) { targetBranch = getPrimaryBranch(); }
+  }
   return [
     'Conflict resolution options:',
     '',
@@ -1485,9 +1519,9 @@ function buildConflictResolutionPrompt(slug = '<slug>', area = '<area>', options
     `  1. Stay in the mission worktree (${worktreePath}); do not resolve non-trivial conflicts inside ${rootDir}.`,
     `     cd ${quotedWorktreePath}`,
     '     git status --short',
-    `  2. Rebase the mission branch onto the local ${getPrimaryBranch()} branch:`,
-    `     git fetch review ${getPrimaryBranch()}`,
-    `     git rebase ${getPrimaryBranch()}`,
+    `  2. Rebase the mission branch onto the local ${targetBranch} branch:`,
+    `     git fetch review ${targetBranch}`,
+    `     git rebase ${targetBranch}`,
     `  3. Re-run the mission gate: ${formatVerificationCommand(area, worktreePath)}`,
     `  4. Retry the dry-run integration preflight: px integrate ${slug} --dry-run`
   ];

package/lib/commands/mission-start.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const fmt = require('../core/fmt');
-const { getCurrentBranch, getLastCommit, run } = require('../core/git');
+const { getCurrentBranch, getLastCommit, git } = require('../core/git');
 const { resolveTaskFile, getTaskStatus, reportTaskResolution } = require('../tools/backlog');
 const { adapterChecklist, evaluateRepositoryReadiness } = require('../core/product-config');
 const { evaluateReviewSetup } = require('../tools/setup-review');
@@ -35,7 +35,7 @@ function missionStart(args, options = {}) {
   const fsExistsSync = options.fsExistsSync || fs.existsSync;
   const resolveMissionBaseBranchFn = options.resolveMissionBaseBranchFn || resolveMissionBaseBranch;
   const getPrimaryBranchFn = options.getPrimaryBranchFn || getPrimaryBranch;
-  const runFn = options.runFn || run;
+  const runFn = options.gitFn || git;
 
   const explicitSlug = args[0];
   const slug = inferSlugFn(explicitSlug);

package/lib/commands/rebase.js

@@ -1,7 +1,7 @@
 const path = require('path');
-const { git, getCurrentBranch } = require('../core/git');
+const { detectRebaseState, git, getCurrentBranch } = require('../core/git');
 const { resolveConflictsForMission } = require('./integrate');
-const { findMissionDir, findMissionArea, inferSlug, resolveWorktree, conventionalWorktreePath, getPrimaryWorktree, getPrimaryBranch, missionBranchName, missionDirForSlug, getMissionYear } = require('../core/mission-utils');
+const { findMissionDir, findMissionArea, inferSlug, resolveWorktree, conventionalWorktreePath, getPrimaryWorktree, getPrimaryBranch, resolveMissionBaseBranch, missionBranchName, missionDirForSlug, getMissionYear } = require('../core/mission-utils');
 const { startAgent } = require('../agents/agents');
   const { createPr, readToken, resolveForgejoUser } = require('../tools/forgejo');
 const { resolveTaskFile, getTaskImplementer } = require('../tools/backlog');
@@ -28,6 +28,8 @@ async function rebase(args, {
   resolveForgejoUserFn = resolveForgejoUser,
   resolveTaskFileFn = resolveTaskFile,
   getTaskImplementerFn = getTaskImplementer,
+  detectRebaseStateFn = detectRebaseState,
+  resolveMissionBaseBranchFn = resolveMissionBaseBranch,
   gitFn = git,
   exitFn = (code) => process.exit(code),
   isForgejoReviewEnabledFn = isForgejoReviewEnabled,
@@ -47,6 +49,24 @@ async function rebase(args, {
   const area = missionDir ? findMissionAreaFn(missionDir) : 'docs';
   const branch = missionBranchName(slug);
 
+  const existingRebase = detectRebaseStateFn(process.cwd());
+  if (existingRebase.inProgress) {
+    fmt.log.fail(`Rebase already in progress for ${fmt.branch(branch)}.`);
+    if (existingRebase.rebaseHead) {
+      fmt.log.info(`Current rebase head: ${existingRebase.rebaseHead}`);
+    }
+    if (existingRebase.unmergedFiles.length > 0) {
+      fmt.log.info('Unmerged files:');
+      existingRebase.unmergedFiles.forEach(file => fmt.log.info(`  - ${file}`));
+    }
+    fmt.log.info('Recovery commands:');
+    fmt.log.info(`  ${fmt.command('git rebase --continue')}`);
+    fmt.log.info(`  ${fmt.command('git rebase --abort')}`);
+    fmt.log.info(`  ${fmt.command('git rebase --skip')}`);
+    exitFn(1);
+    return;
+  }
+
   const performPush = async () => {
     if (!isPush) return;
     if (!isForgejoReviewEnabledFn(process.cwd())) {
@@ -89,9 +109,12 @@ async function rebase(args, {
     return;
   }
 
-  const primaryBranch = getPrimaryBranch(process.cwd(), gitFn);
-  fmt.log.info(`Rebasing ${fmt.branch(branch)} onto local ${fmt.branch(primaryBranch)}...`);
-  const rebaseResult = gitFn(['-c', 'core.editor=true', '-c', 'merge.autoedit=no', 'rebase', primaryBranch]);
+  // Honor the mission's recorded base branch (a feature-branch mission rebases
+  // onto its base, e.g. skunkworks — not the primary branch). Falls back to the
+  // primary branch for every mission without a recorded Base-Branch.
+  const baseBranch = resolveMissionBaseBranchFn(slug, process.cwd(), { gitFn });
+  fmt.log.info(`Rebasing ${fmt.branch(branch)} onto local ${fmt.branch(baseBranch)}...`);
+  const rebaseResult = gitFn(['-c', 'core.editor=true', '-c', 'merge.autoedit=no', 'rebase', baseBranch]);
 
   // Rebase succeeded (status 0) or was already up to date
   // Also handle "Already up to date" variants
@@ -552,9 +575,13 @@ function buildRebasePrompt({ slug, area, worktreePath, missionSpecificFiles, sha
 
   let primaryBranch = 'main';
   try {
-    primaryBranch = getPrimaryBranch(worktreePath, gitFn);
+    primaryBranch = resolveMissionBaseBranch(slug, worktreePath, { gitFn });
   } catch (_) {
-    primaryBranch = 'main';
+    try {
+      primaryBranch = getPrimaryBranch(worktreePath, gitFn);
+    } catch (_e) {
+      primaryBranch = 'main';
+    }
   }
 
   return [

package/lib/commands/stats-backfill.js

@@ -46,7 +46,7 @@ function normalizeHistoricalImplementer(value) {
   if (/(^|[^a-z])codex([^a-z]|$)/.test(normalized)) return 'codex';
   if (/(^|[^a-z])claude([^a-z]|$)/.test(normalized)) return 'claude';
   if (/(^|[^a-z])gemini([^a-z]|$)/.test(normalized)) return 'gemini';
-  if (/(^|[^a-z])qwen([^a-z]|$)/.test(normalized)) return 'qwen';
+  if (/(^|[^a-z])custom([^a-z]|$)/.test(normalized)) return 'custom';
   if (/(^|[^a-z])mistral([^a-z]|$)/.test(normalized)) return 'mistral';
   if (/(^|[^a-z])magnus([^a-z]|$)/.test(normalized)) return 'magnus';
   if (/(^|[^a-z])human([^a-z]|$)/.test(normalized)) return 'human';

package/lib/commands/stats.js

@@ -1348,12 +1348,12 @@ function recordIntegrationStats({
  * before/after/delta attribution is deferred to the follow-up mission that adds
  * the regression model.
  */
-function telemetryToStatsFields(telemetry, { agentFamily, durationMinutes = 0 } = {}) {
+function telemetryToStatsFields(telemetry, { agentFamily, durationMinutes = 0, model } = {}) {
   const t = telemetry || null;
   const usageAfter = t && typeof t.usagePercent === 'number' ? Math.round(t.usagePercent) : 0;
   return {
-    provider: (t && t.provider) || agentFamily || '',
-    model: (t && t.model) || agentFamily || '',
+    provider: (t && t.provider) || model || agentFamily || '',
+    model: (t && t.model) || model || agentFamily || '',
     input_tokens: String((t && t.inputTokens) || 0),
     output_tokens: String((t && t.outputTokens) || 0),
     cached_tokens: String((t && t.cachedTokens) || 0),
@@ -1412,6 +1412,7 @@ function recordStageStats({
   prFixRounds = '0',
   telemetry = null,
   durationMinutes = 0,
+  model = null,
 } = {}) {
   if (!slug) throw new Error('recordStageStats requires a mission slug.');
   if (!stage) throw new Error('recordStageStats requires a stage.');
@@ -1431,7 +1432,7 @@ function recordStageStats({
     implementer_agent: implementer || '',
     reviewer_agent: reviewer || '',
     stage,
-    ...telemetryToStatsFields(telemetry, { agentFamily, durationMinutes }),
+    ...telemetryToStatsFields(telemetry, { agentFamily, durationMinutes, model }),
   }, { filePath, rootDir });
 }
 
@@ -1446,6 +1447,7 @@ function accumulateStageStats({
   prFixRounds = '0',
   telemetry = null,
   durationMinutes = 0,
+  model = null,
 } = {}) {
   if (!slug) throw new Error('accumulateStageStats requires a mission slug.');
   if (!stage) throw new Error('accumulateStageStats requires a stage.');
@@ -1464,7 +1466,7 @@ function accumulateStageStats({
     implementer_agent: implementer || '',
     reviewer_agent: reviewer || '',
     stage,
-    ...telemetryToStatsFields(telemetry, { agentFamily, durationMinutes }),
+    ...telemetryToStatsFields(telemetry, { agentFamily, durationMinutes, model }),
   }, { rootDir });
 
   const data = loadStatsCsv(filePath, { rootDir });
@@ -1513,22 +1515,22 @@ function defaultPrFixRounds(slug, rootDir, provided) {
   return derived ? String(derived.prFixRounds) : '0';
 }
 
-function recordActiveStats({ stage = 'active', slug, rootDir = process.cwd(), prFixRounds, ...rest } = {}) {
+function recordActiveStats({ stage = 'active', slug, rootDir = process.cwd(), prFixRounds, model, ...rest } = {}) {
   return recordStageStats({
-    stage, slug, rootDir,
+    stage, slug, rootDir, model,
     prFixRounds: defaultPrFixRounds(slug, rootDir, prFixRounds),
     ...rest,
   });
 }
 
-function recordReviewStats({ stage = 'review', slug, rootDir = process.cwd(), reviewer, implementer, prFixRounds, ...rest } = {}) {
+function recordReviewStats({ stage = 'review', slug, rootDir = process.cwd(), reviewer, implementer, prFixRounds, model, ...rest } = {}) {
   // A review row's TOKENS belong to the reviewer (telemetry is the reviewer's
   // session), but the row stays keyed to the MISSION'S implementer so the weekly
   // per-implementer summary counts the mission under whoever implemented it — not
   // under the reviewer. The phase report surfaces the reviewer for review phases
   // via `reviewer_agent` (see renderMissionPhaseReport), so no information is lost.
   return recordStageStats({
-    stage, slug, rootDir, reviewer,
+    stage, slug, rootDir, reviewer, model,
     implementer: implementer || reviewer,
     prFixRounds: defaultPrFixRounds(slug, rootDir, prFixRounds),
     ...rest,

package/lib/commands/status.js

@@ -1,4 +1,4 @@
-const { getCurrentBranch, getUncommittedCount, getLastThreeCommits, run } = require('../core/git');
+const { detectRebaseState, getCurrentBranch, getUncommittedCount, getLastThreeCommits, run } = require('../core/git');
 const { findTaskFile, getTaskStatus } = require('../tools/backlog');
 const { findMissionDir, findCheckpoints, getFirstLine, inferSlug, missionBranchPrefix, missionBranchName } = require('../core/mission-utils');
 const { WORKFLOW_AGENT_NAMES, eligibleAgentsForStep, readAgentConfigOrExit, workflowLauncherStatus } = require('../agents/agents');
@@ -77,6 +77,7 @@ function findStaleMissionWorktrees({
       return {
         slug,
         path: entry.path,
+        branch: branchRef,
         taskStatus: taskStatus || 'missing',
         cleanupCommand: taskStatus === 'done'
           ? `scripts/cleanup-mission-worktree.sh ${slug}`
@@ -86,6 +87,19 @@ function findStaleMissionWorktrees({
     .filter(Boolean);
 }
 
+function formatWorktreeBranch(ref) {
+  if (!ref) return '(detached HEAD)';
+  return ref.replace(/^refs\/heads\//, '');
+}
+
+function logRebaseDiagnostics(log, label, rebaseState) {
+  const detachedText = rebaseState.detached ? 'detached HEAD, ' : '';
+  log(`${label}: ${detachedText}${rebaseState.unmergedFiles.length} unmerged file(s)`);
+  rebaseState.unmergedFiles.forEach(file => {
+    log(`  - ${file}`);
+  });
+}
+
 function status(args, options = {}) {
   const exit = options.exit || process.exit;
   const log = options.log || fmt.log.plain;
@@ -104,6 +118,7 @@ function status(args, options = {}) {
   const workflowLauncherStatusFn = options.workflowLauncherStatusFn || workflowLauncherStatus;
   const getLastThreeCommitsFn = options.getLastThreeCommitsFn || getLastThreeCommits;
   const getUncommittedCountFn = options.getUncommittedCountFn || getUncommittedCount;
+  const detectRebaseStateFn = options.detectRebaseStateFn || detectRebaseState;
 
   const explicitSlug = args[0];
   const slug = inferSlugFn(explicitSlug);
@@ -112,6 +127,15 @@ function status(args, options = {}) {
   log(`Branch: ${fmt.branch(getCurrentBranchFn())}`);
   log(`Worktree: ${fmt.path(process.cwd())}`);
 
+  try {
+    const rebaseState = detectRebaseStateFn(process.cwd());
+    if (rebaseState.inProgress && rebaseState.detached) {
+      logRebaseDiagnostics(log, 'Detached HEAD: rebase in progress', rebaseState);
+    }
+  } catch (_) {
+    // Ignore transient worktree/git-state failures in status output.
+  }
+
   if (slug) {
     const taskFile = findTaskFileFn(slug);
     const taskStatus = getTaskStatusFn(taskFile);
@@ -146,6 +170,14 @@ function status(args, options = {}) {
     const staleWorktrees = findStaleMissionWorktreesFn();
     staleWorktrees.forEach(entry => {
       log(`Stale worktree: ${fmt.path(entry.path)} (task: ${entry.taskStatus})`);
+      try {
+        const rebaseState = detectRebaseStateFn(entry.path);
+        if (rebaseState.inProgress) {
+          logRebaseDiagnostics(log, `Rebase in progress on ${formatWorktreeBranch(entry.branch)}`, rebaseState);
+        }
+      } catch (_) {
+        // Ignore stale worktrees that disappear during inspection.
+      }
       log(`  Cleanup: ${fmt.command(entry.cleanupCommand)}`);
     });
   }

package/lib/core/fmt.js

@@ -31,7 +31,7 @@ const agentMap = {
   codex: 'magenta',
   claude: 'blue',
   gemini: 'cyan',
-  qwen: 'yellow',
+  custom: 'yellow',
 };
 
 function colorize(format, text) {
@@ -66,8 +66,12 @@ function status(type, text) {
  */
 function agent(family, text = family) {
   let label = text;
-  if (family === 'qwen' && text === 'qwen') {
-    label = 'qwen (opencode)';
+  // Disambiguate the opencode-backed `custom` family only when the caller
+  // passes a distinct display text (e.g. a model id): show `custom (opencode)`
+  // so the underlying runtime is explicit. When text is just `custom`, render
+  // it plainly to avoid the redundant `custom (opencode)` suffix.
+  if (family === 'custom' && text !== 'custom') {
+    label = 'custom (opencode)';
   }
   const format = agentMap[family];
   if (!format) return label;