atris 3.52.0 → 3.55.0

package/lib/fleet.js

@@ -30,7 +30,7 @@ const {
   buildOneLapValidatorPrompt,
   parseOneLapValidatorVerdict,
 } = require('./one-lap-validator');
-const { listWorktrees } = require('../commands/worktree');
+const { listWorktrees, defaultMainlineBase } = require('../commands/worktree');
 const { isConductorStatusLine } = require('./conductor-artifacts');
 const { matchLessons } = require('./lesson-preflight');
 const { matchTaste } = require('./taste-lessons');
@@ -81,7 +81,7 @@ const ATRIS_BUILD_PROCESS_PREAMBLE = [
   'claim the task, read the map, and work only the named contract.',
   'run every gate bare and read its real exit code.',
   'report honestly, including failures, and stop at the named stop point.',
-  'never use --no-verify.',
+  'if a git hook blocks your commit, stop and report it; never use --no-verify.',
 ].join('\n');
 
 // The bounded prompt every engine gets. Same contract the manual flight used:
@@ -109,6 +109,7 @@ function buildFleetPrompt(task, { worktreePath, yolo = false } = {}) {
   lines.push(
     'Rules:',
     '- Read atris/MAP.md first to locate the code; never guess file locations.',
+    '- Keep one concern per PR; split anything larger into separate PRs because git history guides future agents and small PRs are cheap to revert and bisect.',
     '- Run git status first. Stage ONLY files you changed. Never revert or touch files another agent modified.',
     '- Include or update a focused regression test; run it with npm run test:fast && node --test <focused files> before committing.',
     `- ${commitRule}`,
@@ -161,6 +162,21 @@ const YOLO_ENGINE_FLAGS = Object.freeze({
   claude: '--dangerously-skip-permissions',
 });
 const DISPATCH_SELF_LAND_TARGET = 'origin/master';
+
+// Dispatch used to cut every build worktree from origin/master and check
+// self-landing against it, hard-coded. A workspace whose protected branch is
+// `main` had no origin/master, so the worktree cut and the ancestry check both
+// failed. Resolve the workspace's real protected branch instead (remote HEAD,
+// then origin/main), falling back to the historical origin/master when nothing
+// else can be determined so single-branch repos and test roots behave as before.
+function resolveDispatchLandTarget(root, explicitBase) {
+  if (explicitBase) return explicitBase;
+  try {
+    const mainline = defaultMainlineBase(root);
+    if (mainline && mainline !== 'HEAD') return mainline;
+  } catch {}
+  return DISPATCH_SELF_LAND_TARGET;
+}
 const DEFAULT_DISPATCH_TIMEOUT_MS = 900000;
 const CODEX_DISPATCH_TIMEOUT_MS = 3660000;
 const CODEX_WATCHDOG_SOURCE = path.join(__dirname, '..', 'scripts', 'det', 'codex-watchdog.js');
@@ -213,12 +229,18 @@ function buildEngineCommand(engineName, promptFile, { yolo = false, sealed = fal
     }
     if (sealed && engineName === 'cursor') cmd = `${cmd} --sandbox enabled`;
     if (sealed && engineName === 'devin') return cmd.replace(/^devin -p /, 'devin -p --sandbox --permission-mode accept-edits ');
+    // Headless print mode has one write gate: blocked by default, open with
+    // --yolo (--auto-accept is interactive-only and does not lift it). Fleet
+    // builds always run in an isolated worktree, so --yolo here rides the
+    // same trust model as every other engine's sealed mode.
+    if (sealed && engineName === 'commandcode') cmd = `${cmd} --yolo --trust`;
     if (sealed && engineName === 'grok') {
       cmd = `${cmd.replace(/\s+--always-approve\b/, '')} --sandbox enabled --permission-mode acceptEdits --no-memory --no-subagents`;
     }
     if (engineName === 'devin') return cmd.replace(/^devin -p /, 'devin -p --permission-mode dangerous ');
     if (yolo && engineName === 'codex') cmd = cmd.replace(/\bexec\b/, `exec ${YOLO_ENGINE_FLAGS.codex}`);
     if (yolo && (engineName === 'claude' || engineName === 'fable')) cmd = `${cmd} ${YOLO_ENGINE_FLAGS.claude}`;
+    if (yolo && engineName === 'commandcode') cmd = `${cmd} --yolo`;
     if (engineName === 'codex') cmd = wrapCodexWithWatchdog(cmd, watchdogPath, watchdogReceiptPath);
     return cmd;
   } finally {
@@ -923,10 +945,14 @@ function assignEngines(staffed, engines) {
 // conductor or a human can take it. `git` is injectable for tests.
 // Ship failures print the cause first (MODULE_NOT_FOUND, command name) and a
 // long node stack after. Tail-only clips hide the cause; keep a head+tail.
-function clipHeadTail(text, { head = 400, tail = 300 } = {}) {
-  const s = String(text || '');
+function headTail(str, head = 400, tail = 500) {
+  const s = String(str || '');
   if (s.length <= head + tail) return s;
-  return `${s.slice(0, head)}\n...\n${s.slice(-tail)}`;
+  return `${s.slice(0, head)} … ${s.slice(-tail)}`;
+}
+
+function clipHeadTail(text, { head = 400, tail = 500 } = {}) {
+  return headTail(text, head, tail);
 }
 
 function dispatchResultToTerminal(entry = {}, result = {}) {
@@ -964,11 +990,11 @@ function shipWithRetry(cli, args, cwd) {
   return shipped;
 }
 
-function shipFailureDetail(shipped, { head = 400, tail = 300 } = {}) {
+function shipFailureDetail(shipped, { head = 400, tail = 500 } = {}) {
   const combined = `${shipped.stderr || ''}\n${shipped.stdout || ''}`;
   const moduleLine = combined.match(/Cannot find module '[^']+'[^\n]*/);
   const cause = moduleLine ? `${moduleLine[0]}${shipped.retried_module_not_found ? ' (persisted after one retry)' : ''}\n` : '';
-  return `${cause}${clipHeadTail(combined.trim(), { head, tail })}`;
+  return `${cause}${headTail(combined.trim(), head, tail)}`;
 }
 
 function fleetShipArgs(entry, check) {
@@ -1095,6 +1121,7 @@ function landArrival({ worktreePath, git = null }) {
 module.exports = {
   DENIED_TAGS,
   DEAD_ENGINE_OUTPUT_PATTERNS,
+  releasePausedClaimsWithoutWork,
   reviewOnlyEngineEnvironment,
   runInReapedProcessGroup,
   shipWithRetry,
@@ -1108,6 +1135,7 @@ module.exports = {
   get prepareReviewSandbox() { return prepareReviewSandbox; },
   YOLO_ENGINE_FLAGS,
   DISPATCH_SELF_LAND_TARGET,
+  resolveDispatchLandTarget,
   parseDoneCheck,
   METHOD_KERNEL,
   ATRIS_BUILD_PROCESS_PREAMBLE,
@@ -1131,6 +1159,7 @@ module.exports = {
   dispatchResultToTerminal,
   failedDispatchLeg,
   fleetShipArgs,
+  headTail,
   clipHeadTail,
   guardGlobalCliLink,
   defaultSelfLandCheck,
@@ -1142,7 +1171,7 @@ module.exports = {
 // Engines that can edit a repo headlessly. atris-fast (ax) is a chat lane,
 // not a repo worker — it keeps owning normal mission ticks, not fleet builds.
 const FLEET_CAPABLE = ['claude', 'codex', 'cursor', 'devin', 'grok'];
-const DISPATCH_CAPABLE = [...FLEET_CAPABLE, 'fable'];
+const DISPATCH_CAPABLE = [...FLEET_CAPABLE, 'fable', 'commandcode'];
 
 let receiptSequence = 0;
 function nowStamp() {
@@ -1880,7 +1909,7 @@ function bindOneLapProof(worktreePath, proofRef, sourceCommit) {
 }
 
 function importReviewCommit(boundary, { cli, taskId, engine, expectedCommit = '', expectedTree = '', startBaseArgs = [] } = {}) {
-  const fail = (stage, detail, extra = {}) => ({ ok: false, stage, detail: String(detail || '').trim().slice(-500), ...extra });
+  const fail = (stage, detail, extra = {}) => ({ ok: false, stage, detail: headTail(String(detail || '').trim()), ...extra });
   const runSandbox = (args) => spawnSync('git', args, {
     cwd: boundary.worktreePath,
     encoding: 'utf8',
@@ -2193,7 +2222,7 @@ async function runIndependentValidator({
     if (exitCode !== 0) {
       const outage = detectDeadEngineDispatch(dispatched);
       if (outage && outage.reason === 'usage_limit' && index + 1 < candidates.length) continue;
-      validatorResult.reason = String(dispatched.stderr || verdict.reason || `validator exited ${exitCode}`).trim().slice(-500);
+      validatorResult.reason = headTail(String(dispatched.stderr || verdict.reason || `validator exited ${exitCode}`).trim());
       return { ok: false, stage: 'validator_failed', validator_result: validatorResult };
     }
     if (verdict.verdict === 'reject') return { ok: false, stage: 'validation_rejected', validator_result: validatorResult };
@@ -2607,7 +2636,7 @@ async function runFleetFlight({
     const check = focusedCheck(entry.task) || 'git log -1 --oneline';
     const shipped = shipWithRetry(cli, fleetShipArgs(entry, check), entry.worktreePath);
     if (shipped.status !== 0 || !/done: worktree shipped/.test(shipped.stdout)) {
-      return { ok: false, stage: 'ship', detail: shipFailureDetail(shipped, { head: 400, tail: 300 }) };
+      return { ok: false, stage: 'ship', detail: shipFailureDetail(shipped) };
     }
     return { ok: true, stage: 'shipped' };
   });
@@ -2643,7 +2672,7 @@ async function runFleetFlight({
       const restaffProof = result.restaffed ? ` Restaffed from ${result.restaffed.from} to ${result.restaffed.to} (${result.restaffed.reason}).` : '';
       cli([
         'task', 'ready', String(entry.task.display_id),
-        '--proof', `Built by ${activeEngine} engine in fleet flight.${restaffProof} Landed via worktree ship gate (rebase-before-ship, verify re-run). Receipt saved at ${path.relative(root, receiptPath)}. Report tail: ${String(result.report || '').slice(-300).replace(/\n/g, ' ')}`,
+        '--proof', `Built by ${activeEngine} engine in fleet flight.${restaffProof} Landed via worktree ship gate (rebase-before-ship, verify re-run). Receipt saved at ${path.relative(root, receiptPath)}. Report tail: ${headTail(String(result.report || '').replace(/\n/g, ' '))}`,
         '--result', 'Operators can now review fleet-shipped work faster because the worktree was verified before landing.',
         '--as', `fleet-${activeEngine}`,
       ]);
@@ -2667,6 +2696,14 @@ async function runFleetFlight({
       : `  alert: global atris link was ${cliLink.reason}; repoint attempted at ${cliLink.restoredTo} but the cli still fails, so every cron/loop/mission is down`);
   }
 
+  releasePausedClaimsWithoutWork(cli, {
+    paused: flight.paused,
+    worktreeByTask: new Map(prepared.map((entry) => [String(entry.task.display_id), entry.worktreePath])),
+    actorByTask: new Map(staffed.map((entry) => [String(entry.task.display_id), `fleet-${entry.engine}`])),
+    baseRef: checkoutBase || 'origin/master',
+    log,
+  });
+
   flight.status = flight.paused.length ? 'failed' : 'completed';
   flight.finished_at = new Date().toISOString();
   atomicWriteFlightReceipt(flight, receiptPath);
@@ -2691,6 +2728,38 @@ function releaseUnstartedDispatchClaim(cli, { taskId, actor, detail }) {
   return { released: releasedOk, detail: base ? `${base}. ${suffix}` : suffix };
 }
 
+// A pause with no work must not keep the task. On 2026-08-21, 49 bug tasks sat
+// falsely "in progress" because guard-blocked engines paused their flights
+// while the claims taken before dispatch outlived them. After landing, any
+// paused task whose worktree holds no commits past base and nothing but
+// conductor litter gets its claim released; a paused task WITH work keeps the
+// claim so takeover stays attributed.
+function releasePausedClaimsWithoutWork(cli, { paused, worktreeByTask, actorByTask, baseRef = 'origin/master', log = () => {} }) {
+  for (const row of paused || []) {
+    if (row.stage === 'claim' || row.stage === 'task_lookup') continue; // claim never held
+    if (row.claim_released !== undefined) continue;
+    const taskId = String(row.task || '');
+    const actor = actorByTask.get(taskId);
+    if (!taskId || !actor) continue;
+    const worktreePath = row.worktree || worktreeByTask.get(taskId) || '';
+    if (worktreePath && fs.existsSync(worktreePath)) {
+      const ahead = spawnSync('git', ['-C', worktreePath, 'rev-list', '--count', `${baseRef}..HEAD`], { encoding: 'utf8' });
+      if (ahead.status !== 0 || parseInt(String(ahead.stdout).trim(), 10) > 0) continue;
+      // -uall lists untracked files one by one; the default collapses a fully
+      // untracked .atris/ into "?? .atris/", which the allowlist cannot judge.
+      const status = spawnSync('git', ['-C', worktreePath, 'status', '--porcelain', '-uall'], { encoding: 'utf8' });
+      if (status.status !== 0) continue;
+      const dirt = String(status.stdout || '').split('\n').filter(Boolean).filter((line) => !isConductorStatusLine(line));
+      if (dirt.length > 0) continue;
+    } else if (row.stage !== 'worktree_start' && row.stage !== 'remote_quarantine' && row.stage !== 'prepare') {
+      continue; // worktree gone and stage ambiguous: leave the claim for a human
+    }
+    const released = cli(['task', 'release', taskId, '--as', actor]);
+    row.claim_released = Boolean(released && released.status === 0);
+    if (row.claim_released) log(`    released claim on ${taskId} (engine produced no work)`);
+  }
+}
+
 // The manual version of this loop took 6 Bash calls per task the night this
 // was written: claim, worktree start, prompt file, engine -p, verify, ship.
 // One or more explicit task ids build in parallel isolated worktrees on ONE
@@ -2710,7 +2779,7 @@ async function runDispatchFlight({
   lander = null,
   verifier = null,
   rebase = null,
-  checkoutBase = 'origin/master',
+  checkoutBase = null,
   installedEngines = null,
   selfLandCheck = null,
   startCommitReader = null,
@@ -2746,6 +2815,9 @@ async function runDispatchFlight({
   }
 
   const cli = ownCli || defaultOwnCli(root);
+  // Cut worktrees from — and check self-landing against — the workspace's real
+  // protected branch, not a hard-coded origin/master (CLI-1298).
+  const landTarget = resolveDispatchLandTarget(root, checkoutBase);
   const verify = verifier || (trustedVerifier ? defaultTrustedVerifyRunner : defaultVerifyRunner);
   const inspectChange = changeInspector || inspectReviewChange;
   const readStartCommit = startCommitReader || defaultDispatchStartCommit;
@@ -2775,9 +2847,9 @@ async function runDispatchFlight({
   log(`  dispatch — ${ids.length} task${ids.length === 1 ? '' : 's'} -> ${engine}`);
   log('');
 
-  // Same rule as the fleet: dispatch worktrees cut from origin/master by
+  // Same rule as the fleet: dispatch worktrees cut from the protected branch by
   // default so rebase-before-ship never replays a launcher feature branch.
-  const startBaseArgs = checkoutBase ? ['--base', checkoutBase] : [];
+  const startBaseArgs = landTarget ? ['--base', landTarget] : [];
   const prepared = [];
   for (const taskId of ids) {
     const task = readTaskById(cli, taskId);
@@ -2807,7 +2879,7 @@ async function runDispatchFlight({
             actor: taskActor,
             detail: String(started.stderr || '').slice(0, 200),
           });
-          flight.paused.push({ task: taskId, stage: 'worktree_start', detail: released.detail });
+          flight.paused.push({ task: taskId, stage: 'worktree_start', detail: released.detail, claim_released: released.released });
           log(`    ✗ ${taskId} worktree start failed`);
           continue;
         }
@@ -2817,13 +2889,14 @@ async function runDispatchFlight({
         const released = releaseUnstartedDispatchClaim(cli, {
           taskId,
           actor: taskActor,
-          detail: String(remoteBoundary && remoteBoundary.detail || 'could not prepare a sealed review sandbox').slice(-500),
+          detail: headTail(String(remoteBoundary && remoteBoundary.detail || 'could not prepare a sealed review sandbox')),
         });
         flight.paused.push({
           task: taskId,
           stage: 'remote_quarantine',
           detail: released.detail,
           worktree: null,
+          claim_released: released.released,
         });
         log(`    paused ${taskId} because its sealed review sandbox could not be prepared`);
         continue;
@@ -2855,7 +2928,7 @@ async function runDispatchFlight({
         actor: taskActor,
         detail: String(err && err.message || err).slice(0, 200),
       });
-      flight.paused.push({ task: taskId, stage: 'prepare', detail: released.detail });
+      flight.paused.push({ task: taskId, stage: 'prepare', detail: released.detail, claim_released: released.released });
       log(`    ✗ ${taskId} prepare failed`);
     }
   }
@@ -2942,12 +3015,12 @@ async function runDispatchFlight({
       const candidate = reviewCandidateSnapshot(entry.remoteBoundary, entry.candidate);
       if (!candidate.ok) return candidate;
     }
-    const change = reviewOnly ? inspectChange(entry.worktreePath, checkoutBase || 'origin/master') : null;
+    const change = reviewOnly ? inspectChange(entry.worktreePath, landTarget) : null;
     if (reviewOnly && (!change || change.has_change !== true)) {
       return {
         ok: false,
         stage: 'no_change',
-        detail: String(change && change.detail || 'the engine produced no committed or worktree diff').slice(-500),
+        detail: headTail(String(change && change.detail || 'the engine produced no committed or worktree diff')),
         change: change || null,
       };
     }
@@ -2975,7 +3048,7 @@ async function runDispatchFlight({
       return {
         ok: false,
         stage: 'verify_failed',
-        detail: `${verified.stdout}${verified.stderr}`.slice(-500),
+        detail: headTail(`${verified.stdout}${verified.stderr}`),
         verifyOutput: `${verified.stdout}${verified.stderr}`,
         check,
         verifier_result: verifierResult,
@@ -2997,7 +3070,7 @@ async function runDispatchFlight({
     }
     const shipped = shipWithRetry(cli, fleetShipArgs({ task: entry.task, engine: entry.engine || engine }, check), entry.worktreePath);
     if (shipped.status !== 0 || !/done: worktree shipped/.test(shipped.stdout)) {
-      return { ok: false, stage: 'ship', detail: shipFailureDetail(shipped, { head: 400, tail: 500 }) };
+      return { ok: false, stage: 'ship', detail: shipFailureDetail(shipped) };
     }
     return {
       ok: true,
@@ -3035,7 +3108,7 @@ async function runDispatchFlight({
         task: entry.taskId,
         engine: activeEngine,
         stage: candidate && candidate.stage || 'candidate_changed',
-        detail: String(candidate && candidate.detail || 'the executor candidate could not be frozen').slice(-500),
+        detail: headTail(String(candidate && candidate.detail || 'the executor candidate could not be frozen')),
         worktree: entry.worktreePath,
       };
       flight.paused.push(paused);
@@ -3066,11 +3139,11 @@ async function runDispatchFlight({
         entry,
         result,
         worktreePath: entry.worktreePath,
-        targetRef: DISPATCH_SELF_LAND_TARGET,
+        targetRef: landTarget,
         startCommit: entry.startCommit,
       });
       if (selfLanded.ok) {
-        const target = selfLanded.target || DISPATCH_SELF_LAND_TARGET;
+        const target = selfLanded.target || landTarget;
         flight.landed.push({
           task: entry.taskId,
           engine: activeEngine,
@@ -3092,7 +3165,7 @@ async function runDispatchFlight({
           task: entry.taskId,
           engine,
           stage,
-          target: selfLanded.target || DISPATCH_SELF_LAND_TARGET,
+          target: selfLanded.target || landTarget,
           detail: selfLanded.detail || '',
         });
         stampDispatchBrief(root, result.brief_id, 'partial', stage === 'no_work_landed'
@@ -3136,13 +3209,13 @@ async function runDispatchFlight({
           continue;
         }
         finalMaster = boundaryBeforeReview.protected_master || finalMaster;
-        const change = landed.change || inspectChange(entry.worktreePath, checkoutBase || 'origin/master');
+        const change = landed.change || inspectChange(entry.worktreePath, landTarget);
         if (!change || change.has_change !== true) {
           flight.paused.push({
             task: entry.taskId,
             engine: activeEngine,
             stage: 'no_change',
-            detail: String(change && change.detail || 'the engine produced no committed or worktree diff').slice(-500),
+            detail: headTail(String(change && change.detail || 'the engine produced no committed or worktree diff')),
             check: landed.check,
             verifier_result: landed.verifier_result,
             worktree: entry.worktreePath,
@@ -3172,7 +3245,7 @@ async function runDispatchFlight({
               task: entry.taskId,
               engine: activeEngine,
               stage: validation.stage,
-              detail: String(validatorResult && validatorResult.reason || 'independent validator failed').slice(-500),
+              detail: headTail(String(validatorResult && validatorResult.reason || 'independent validator failed')),
               check: landed.check,
               verifier_result: landed.verifier_result,
               validator_result: validatorResult,
@@ -3331,14 +3404,14 @@ async function runDispatchFlight({
         writeDispatchReceipt(flight, receiptPath, { ids, reviewOnly, enforceRemoteBoundary });
         const verificationCommit = String(reviewChange.source_commit || reviewChange.commit || reviewChange.head || '').trim();
         const verificationCitation = verificationCommit
-          ? ` Verification snapshot: commit ${verificationCommit}${reviewChange.dirty ? ' with a worktree diff' : ''}; ${landed.check} passed (exit 0).`
-          : ` Verification snapshot: the worktree diff was present; ${landed.check} passed (exit 0).`;
+          ? ` Verification snapshot: commit ${verificationCommit}${reviewChange.dirty ? ' with a worktree diff' : ''}; the declared verifier passed (exit 0).`
+          : ' Verification snapshot: the worktree diff was present; the declared verifier passed (exit 0).';
         const validatorCitation = validatorResult
           ? ` Independent validator ${validatorResult.engine} signed off: ${validatorResult.reason}.`
           : '';
         const readyResult = cli([
           'task', 'ready', entry.taskId,
-          '--proof', `Built by ${activeEngine} engine via one-lap dispatch.${restaffProof} Preserved in isolated worktree ${reviewWorktreePath}. Check re-run: ${landed.check}.${verificationCitation}${validatorCitation} Verify output: ${verifyTail || '(command produced no output, exit 0)'}. Receipt saved at ${path.relative(root, receiptPath)}.`,
+          '--proof', `Built by ${activeEngine} engine via one-lap dispatch.${restaffProof} Preserved in isolated worktree ${reviewWorktreePath}.${verificationCitation}${validatorCitation} Verify output: ${verifyTail || '(command produced no output, exit 0)'}. Receipt saved at ${path.relative(root, receiptPath)}.`,
           '--result', 'Operators can review a completed, verified change before it lands, reducing the risk of unreviewed changes reaching users.',
           '--landing', 'Operators can review the verified change before it reaches users, reducing the risk of an unreviewed release.',
           '--checked', `${landed.check} passed in the isolated worktree`,
@@ -3351,7 +3424,7 @@ async function runDispatchFlight({
             task: entry.taskId,
             engine: activeEngine,
             stage: 'task_ready',
-            detail: String(readyResult && (readyResult.stderr || readyResult.stdout) || 'task ready failed').slice(-500),
+            detail: headTail(String(readyResult && (readyResult.stderr || readyResult.stdout) || 'task ready failed')),
             check: landed.check,
             verifier_result: landed.verifier_result,
             worktree: reviewWorktreePath,
@@ -3375,7 +3448,7 @@ async function runDispatchFlight({
       stampDispatchBrief(root, result.brief_id, 'pass', `landed ${entry.taskId} via engine dispatch`);
       cli([
         'task', 'ready', entry.taskId,
-        '--proof', `Built by ${activeEngine} engine via atris engine dispatch.${restaffProof} Landed via worktree ship gate (rebase-before-ship, verify re-run). Check re-run: ${landed.check}. Verify output: ${verifyTail || '(command produced no output, exit 0)'}. Receipt saved at ${path.relative(root, receiptPath)}.`,
+        '--proof', `Built by ${activeEngine} engine via atris engine dispatch.${restaffProof} Landed via worktree ship gate (rebase-before-ship, verify re-run). The declared verifier passed (exit 0). Verify output: ${verifyTail || '(command produced no output, exit 0)'}. Receipt saved at ${path.relative(root, receiptPath)}.`,
         '--result', 'Operators can now review engine-built work faster because dispatch reran the verifier before landing.',
         '--landing', 'The verified change is on master and ready for review.',
         '--checked', `${landed.check} passed before landing`,
@@ -3396,6 +3469,14 @@ async function runDispatchFlight({
     }
   }
 
+  releasePausedClaimsWithoutWork(cli, {
+    paused: flight.paused,
+    worktreeByTask: new Map(prepared.map((entry) => [String(entry.taskId), entry.worktreePath])),
+    actorByTask: new Map(ids.map((taskId) => [String(taskId), taskActor])),
+    baseRef: landTarget,
+    log,
+  });
+
   flight.status = flight.paused.length ? 'failed' : 'completed';
   flight.finished_at = new Date().toISOString();
   writeDispatchReceipt(flight, receiptPath, { ids, reviewOnly, enforceRemoteBoundary });

package/lib/functional-owner.js

@@ -124,6 +124,16 @@ function resolveFunctionalOwner({ requestedOwner, title, tag, note, goal, root,
   const tagText = tag && tag !== true ? String(tag).toLowerCase() : '';
   const text = [highSignalText, tagText].filter(Boolean).join(' ');
 
+  // Existing workspace members win, even when the slug is also an engine name
+  // (starter team ships `executor`; dogfood expects --owner executor to stick).
+  if (requested && existingMembers.has(requested)) {
+    return {
+      owner: requested,
+      reason: 'explicit_member_owner',
+      requested_owner: requested,
+    };
+  }
+
   if (requested && !isEngineOwner(requested)) {
     return {
       owner: requested,
@@ -137,11 +147,15 @@ function resolveFunctionalOwner({ requestedOwner, title, tag, note, goal, root,
     existingMembers
   );
   if (exact) {
+    const remapped = Boolean(requested && isEngineOwner(requested) && requested !== exact);
     return {
       owner: exact,
       reason: requested ? 'engine_owner_resolved_by_exact_member' : 'inferred_exact_member',
       requested_owner: requested || null,
       executed_by: requested && isEngineOwner(requested) ? requested : null,
+      ...(remapped ? {
+        remap_reason: `"${requested}" is an engine name with no matching member folder; using ${exact}. Override: atris mission start "<objective>" --owner <existing-member> --verify "..."`,
+      } : {}),
     };
   }
 
@@ -158,23 +172,31 @@ function resolveFunctionalOwner({ requestedOwner, title, tag, note, goal, root,
     .sort((a, b) => b.score - a.score);
   const inferred = firstAvailableFunctionalOwner(scored.map(row => row.owner), existingMembers);
   if (inferred) {
+    const remapped = Boolean(requested && isEngineOwner(requested) && requested !== inferred);
     return {
       owner: inferred,
       reason: requested ? 'engine_owner_resolved_by_task_signal' : 'inferred_by_task_signal',
       requested_owner: requested || null,
       executed_by: requested && isEngineOwner(requested) ? requested : null,
+      ...(remapped ? {
+        remap_reason: `"${requested}" is an engine name with no matching member folder; using ${inferred}. Override: atris mission start "<objective>" --owner <existing-member> --verify "..."`,
+      } : {}),
     };
   }
 
   const fallback = firstAvailableFunctionalOwner(fallbackOwners || ['architect', 'task-planner', 'mission-lead', 'validator'], existingMembers)
     || Array.from(existingMembers).find(owner => !isEngineOwner(owner))
     || 'architect';
+  const remapped = Boolean(requested && requested !== fallback);
   return {
     owner: fallback,
     reason: requested ? 'engine_owner_resolved_to_factory_owner' : 'missing_functional_owner_fit',
     requested_owner: requested || null,
     executed_by: requested && isEngineOwner(requested) ? requested : null,
     proposed_member: proposedMemberSlugFromTask({ title, tag }),
+    ...(remapped ? {
+      remap_reason: `"${requested}" could not be kept as owner; using ${fallback}. Override: atris mission start "<objective>" --owner <existing-member> --verify "..."`,
+    } : {}),
   };
 }
 

package/lib/known-commands.js

@@ -1,11 +1,11 @@
 'use strict';
 
-const knownCommands = ['init', 'log', 'logs', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '_start', 'plan', 'do', 'review', 'release',
+const knownCommands = ['init', 'doctor', 'install', 'workspace', 'log', 'logs', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'who', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'revisions', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
-                       'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
+                       'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube', 'x-search',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',
-                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
-                       'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'feed', 'brief'];
+                       'ci', 'github', 'vercel', 'supabase', 'linear', 'stripe', 'balance', 'usage', 'api-key', 'topup', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
+                       'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'playbook', 'feed', 'brief', 'social', 'people', 'follow', 'unfollow', 'friends', 'msg', 'inbox', 'invite', 'join'];
 
 // Damerau-Levenshtein edit distance between two short strings. Counts an
 // adjacent transposition (e.g. "taks" -> "task") as a single edit, since
@@ -39,6 +39,15 @@ function suggestCommand(input, commands = knownCommands) {
   if (!input || typeof input !== 'string') return null;
   const word = input.toLowerCase().trim();
   if (!word) return null;
+  // Semantic near-misses that edit distance will not catch (context ≠ activate).
+  const ALIASES = {
+    context: 'activate',
+    ctx: 'activate',
+    info: 'status',
+    state: 'status',
+    whereami: 'status',
+  };
+  if (ALIASES[word] && commands.includes(ALIASES[word])) return ALIASES[word];
   // Ignore internal/private commands (leading underscore) as suggestions.
   const candidates = commands.filter((c) => !c.startsWith('_'));
   let best = null;
@@ -55,4 +64,21 @@ function suggestCommand(input, commands = knownCommands) {
   return best;
 }
 
-module.exports = { knownCommands, suggestCommand, editDistance };
+function suggestCommands(input, commands = knownCommands) {
+  const primary = suggestCommand(input, commands);
+  const word = String(input || '').toLowerCase().trim();
+  const extras = [];
+  if (word === 'context' || word === 'ctx') {
+    for (const name of ['activate', 'status']) {
+      if (commands.includes(name) && name !== primary) extras.push(name);
+    }
+  }
+  const out = [];
+  if (primary) out.push(primary);
+  for (const name of extras) {
+    if (!out.includes(name)) out.push(name);
+  }
+  return out;
+}
+
+module.exports = { knownCommands, suggestCommand, suggestCommands, editDistance };