atris 3.53.0 → 3.55.0

package/commands/mission.js

@@ -6,6 +6,11 @@ const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
 const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
+const {
+  compactErrorPayload,
+  compactSuccessPayload,
+  printCliJson,
+} = require('../lib/cli-json');
 const escapeRegExp = require('../lib/escape-regexp');
 const {
   appendBriefRecord,
@@ -83,6 +88,7 @@ const {
   resolveDefaultVerifier,
 } = require('../lib/default-verifier');
 const { resolveWorkspaceRoot, redirectToWorkspaceRoot } = require('../lib/mission-root');
+const { isFreshWorkspace, speakFirstMinute } = require('../lib/first-minute');
 const { readJson, writeJson } = require('../lib/json-file');
 const {
   normalizeHumanAsks,
@@ -427,8 +433,22 @@ function applyMissionRunnerProfile(runner) {
 }
 
 function exitMissionError(message, code = 1, asJson = false) {
-  if (asJson) console.log(JSON.stringify({ ok: false, error: message }, null, 2));
-  else console.error(message);
+  if (asJson) {
+    printCliJson(
+      {
+        ok: false,
+        error: message,
+        reason: 'mission_error',
+        detail: message,
+        selected_ref: null,
+        next_command: null,
+      },
+      compactErrorPayload({ reason: 'mission_error', detail: message }),
+      process.argv.slice(2),
+    );
+  } else {
+    console.error(message);
+  }
   process.exit(code);
 }
 
@@ -518,7 +538,7 @@ function assertMissionVerifier(command, asJson = false) {
 
 function stripKnownFlags(args, valueNames, booleanNames = []) {
   const valueSet = new Set(valueNames);
-  const booleanSet = new Set(booleanNames);
+  const booleanSet = new Set(['--full', '--verbose', ...booleanNames]);
   const out = [];
   for (let i = 0; i < args.length; i += 1) {
     const arg = String(args[i]);
@@ -569,6 +589,8 @@ const MISSION_RUN_VALUE_FLAGS = [
 ];
 const MISSION_RUN_BOOLEAN_FLAGS = [
   '--json',
+  '--full',
+  '--verbose',
   '--due',
   '--detach',
   '--headless',
@@ -727,7 +749,72 @@ function missionXpTaskTitle(objective) {
   return `${prefix}${shortClause || 'mission work'}`;
 }
 
+function normalizeMissionTaskMatchText(text) {
+  return String(text || '')
+    .replace(/^Mission XP:\s*/i, '')
+    .toLowerCase()
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function missionObjectiveTaskMatch(objective, title) {
+  const want = normalizeMissionTaskMatchText(objective);
+  const have = normalizeMissionTaskMatchText(title);
+  if (!want || !have) return false;
+  if (want === have) return true;
+  // First clause of a long objective often matches the claimed task title.
+  const wantClause = want.split(/:|[.!?](?=\s|$)/)[0].trim();
+  const haveClause = have.split(/:|[.!?](?=\s|$)/)[0].trim();
+  if (wantClause && haveClause && (wantClause === haveClause || want.startsWith(haveClause) || have.startsWith(wantClause))) {
+    return true;
+  }
+  return false;
+}
+
+function taskRowToMissionXpBinding(task, ownerResolution, outPath, { inserted = false, reused = true } = {}) {
+  return {
+    task_id: task.id,
+    ref: missionTaskRef(task) || task.id,
+    title: task.title,
+    operator_title_warning: warnIfTaskTitleNeedsOperatorWhy(task.title),
+    status: task.status || 'claimed',
+    assigned_to: task.claimed_by || ownerResolution.owner,
+    owner_resolution: ownerResolution.reason,
+    executed_by: ownerResolution.executed_by ? normalizeOwnerSlug(ownerResolution.executed_by) : null,
+    inserted,
+    reused,
+    projection_path: outPath,
+  };
+}
+
+function findOpenTaskMatchingMissionObjective(mission, root = process.cwd(), asJson = false) {
+  const taskDb = loadTaskDb(asJson);
+  const db = taskDb.open();
+  const workspaceRoot = taskDb.workspaceRoot(root);
+  const rows = taskDb.withTaskDisplayRefs(taskDb.listTasks(db, { workspaceRoot }));
+  const open = rows.filter((row) => row && ['open', 'claimed', 'review'].includes(row.status));
+  const explicitIds = Array.isArray(mission.task_ids) ? mission.task_ids.filter(Boolean) : [];
+  for (const id of explicitIds) {
+    const hit = open.find((row) => row.id === id || row.display_id === id || missionTaskRef(row) === id);
+    if (hit) return hit;
+  }
+  return open.find((row) => missionObjectiveTaskMatch(mission.objective, row.title)) || null;
+}
+
+function bindExistingMissionTask(mission, task, root = process.cwd(), asJson = false) {
+  const taskDb = loadTaskDb(asJson);
+  const db = taskDb.open();
+  const workspaceRoot = taskDb.workspaceRoot(root);
+  const ownerResolution = resolveMissionOwner(mission, workspaceRoot);
+  const { outPath } = writeMissionTaskProjection(taskDb, db, workspaceRoot);
+  return taskRowToMissionXpBinding(task, ownerResolution, outPath, { inserted: false, reused: true });
+}
+
 function createMissionXpTask(mission, root = process.cwd(), asJson = false) {
+  const existing = findOpenTaskMatchingMissionObjective(mission, root, asJson);
+  if (existing) {
+    return bindExistingMissionTask(mission, existing, root, asJson);
+  }
   const taskDb = loadTaskDb(asJson);
   const db = taskDb.open();
   const workspaceRoot = taskDb.workspaceRoot(root);
@@ -782,6 +869,7 @@ function createMissionXpTask(mission, root = process.cwd(), asJson = false) {
     owner_resolution: ownerResolution.reason,
     executed_by: ownerResolution.executed_by ? normalizeOwnerSlug(ownerResolution.executed_by) : null,
     inserted: result.inserted !== false,
+    reused: false,
     projection_path: outPath,
   };
 }
@@ -1238,11 +1326,27 @@ function exitMissingMission(ref, code = 1, asJson = false, root = process.cwd())
     } catch { /* best-effort hint only */ }
   }
   if (asJson) {
-    const payload = { ok: false, error };
-    if (hints.length) payload.workspace_hint = hints[0];
-    if (hints.length > 1) payload.workspace_hints = hints;
-    if (candidates.length) payload.nearest_candidates = candidates;
-    console.log(JSON.stringify(payload, null, 2));
+    const nextCommand = hints[0] && hints[0].command ? hints[0].command : null;
+    printCliJson(
+      {
+        ok: false,
+        error,
+        reason: 'mission_not_found',
+        detail: error,
+        selected_ref: ref || null,
+        next_command: nextCommand,
+        ...(hints.length ? { workspace_hint: hints[0] } : {}),
+        ...(hints.length > 1 ? { workspace_hints: hints } : {}),
+        ...(candidates.length ? { nearest_candidates: candidates } : {}),
+      },
+      compactErrorPayload({
+        reason: 'mission_not_found',
+        detail: error,
+        selected_ref: ref || null,
+        next_command: nextCommand,
+      }),
+      process.argv.slice(2),
+    );
   } else {
     console.error(error);
     if (hints.length) {
@@ -1688,8 +1792,26 @@ function verifierTimeoutSeconds(verifierResult) {
   return Number.isFinite(ms) ? Math.round(ms / 1000) : 0;
 }
 
-function missionVerifierCheckedText(verifierResult, mission) {
-  if (!verifierResult) return 'UNVERIFIED: tick recorded but nothing was checked; treat this increment as unproven.';
+function missionGuardBlockedText(guard) {
+  if (!guard || guard.allowed !== false) return '';
+  const detail = String(guard.detail || '').trim();
+  const reason = String(guard.reason || 'the check was held').trim();
+  return `VERIFY DID NOT RUN: ${reason}${detail ? ` (${detail})` : ''}. Treat this increment as unproven.`;
+}
+
+function missionGuardNextText(guard, missionId) {
+  if (!guard || guard.allowed !== false || !missionId) return '';
+  if (guard.unreadable) {
+    return `repair the mission diff tooling failure, then rerun: atris mission tick ${missionId} --verify`;
+  }
+  return `review the protected diff and receipt before resuming: atris mission run ${missionId}`;
+}
+
+function missionVerifierCheckedText(verifierResult, mission, guard = null) {
+  if (!verifierResult) {
+    return missionGuardBlockedText(guard)
+      || 'UNVERIFIED: tick recorded but nothing was checked; treat this increment as unproven.';
+  }
   if (verifierResult.mode === 'engine-unavailable') {
     return 'VERIFY FAILED: the engine verify pass was unavailable; treat this increment as unproven.';
   }
@@ -1715,8 +1837,15 @@ function missionVerifierCheckedText(verifierResult, mission) {
   return `VERIFY FAILED: ${command}.`;
 }
 
-function missionVerifierHighLevelTestText(verifierResult, mission) {
-  if (!verifierResult) return 'No automated verifier ran for this receipt; judge it from the receipt, changed files, and next action.';
+function missionVerifierHighLevelTestText(verifierResult, mission, guard = null) {
+  if (!verifierResult) {
+    if (guard && guard.allowed === false) {
+      const detail = String(guard.detail || '').trim();
+      const reason = String(guard.reason || 'the check was held').trim();
+      return `No automated verifier ran: ${reason}${detail ? ` (${detail})` : ''}. Clear the hold, then rerun to get a real verdict.`;
+    }
+    return 'No automated verifier ran for this receipt; judge it from the receipt, changed files, and next action.';
+  }
   if (verifierResult.mode === 'engine-unavailable') {
     return 'No changed-surface commands were confirmed because the engine verify pass was unavailable.';
   }
@@ -1767,11 +1896,12 @@ function missionFallbackChangedText(mission, status, tickIndex, { ranTicks = nul
   return `${mission.objective} recorded tick ${tickIndex}.`;
 }
 
-function missionTickResultLines(mission, tickIndex, receiptPath, verifierResult = null, stepSummary = '') {
+function missionTickResultLines(mission, tickIndex, receiptPath, verifierResult = null, stepSummary = '', guard = null) {
   return missionLandingLines(missionReceiptLanding(mission, {
-    tick: { tick_index: tickIndex },
+    tick: { tick_index: tickIndex, protected_lane_guard: guard },
     summary: stepSummary,
     verifier_result: verifierResult,
+    protected_lane_guard: guard,
   }, receiptPath));
 }
 
@@ -1801,6 +1931,9 @@ function missionReceiptStatus(mission, result) {
 function missionReceiptNextText(mission, result, receiptPath = '') {
   if (result?.next) return String(result.next);
   if (result?.landing?.next) return String(result.landing.next);
+  const guard = result?.protected_lane_guard || result?.tick?.protected_lane_guard || null;
+  const guardNext = missionGuardNextText(guard, mission?.id);
+  if (guardNext) return guardNext;
   if (result?.verifier_result?.passed === true) {
     if (!mission?.always_on && receiptPath) {
       return `Review proof, then run: atris mission complete ${mission.id} --proof "${receiptPath}".`;
@@ -1817,8 +1950,9 @@ function missionReceiptLanding(mission, result, receiptPath = '') {
   const summary = missionReceiptSummaryText(result);
   const changed = missionLandingStepSummary(summary)
     || missionFallbackChangedText(mission, status, missionReceiptTickIndex(mission, result));
-  const checked = missionVerifierCheckedText(verifierResult, mission);
-  const tested = missionVerifierHighLevelTestText(verifierResult, mission);
+  const guard = result?.protected_lane_guard || result?.tick?.protected_lane_guard || null;
+  const checked = missionVerifierCheckedText(verifierResult, mission, guard);
+  const tested = missionVerifierHighLevelTestText(verifierResult, mission, guard);
   const reason = missionHumanReasonText(mission, changed);
   return {
     schema: 'atris.result_landing.v1',
@@ -2373,20 +2507,25 @@ function missionRunSummaryLines(mission, ranTicks, effectiveMaxTicks, finalRecei
   const changed = missionRunChangedText(mission, ranTicks, effectiveMaxTicks, ticks, createdNext);
   const reason = missionHumanReasonText(mission, changed);
   const lastTick = ticks[ticks.length - 1] || null;
+  const guard = lastTick?.protected_lane_guard || null;
   const verifier = lastTick && lastTick.verifier_passed == null ? null : mission.verifier_result;
   const checked = verifier
-    ? missionVerifierCheckedText(verifier, mission)
-    : pauseReason === 'no-progress'
-      ? `Run stopped: ${mission.stop_reason || 'no progress across consecutive ticks'}.`
-      : pauseReason
-        ? `Run paused: ${pauseReason}.`
-        : 'UNVERIFIED: run recorded but nothing was checked; treat this increment as unproven.';
+    ? missionVerifierCheckedText(verifier, mission, guard)
+    : missionGuardBlockedText(guard)
+      || (pauseReason === 'no-progress'
+        ? `Run stopped: ${mission.stop_reason || 'no progress across consecutive ticks'}.`
+        : pauseReason
+          ? `Run paused: ${pauseReason}.`
+          : 'UNVERIFIED: run recorded but nothing was checked; treat this increment as unproven.');
   const tested = verifier
-    ? missionVerifierHighLevelTestText(verifier, mission)
-    : mission.verifier
-      ? `Verifier was configured but not completed: ${mission.verifier}.`
-      : 'No verifier command was recorded for this mission.';
-  const nextLine = missionRunCreatedNextLine(createdNext, continuationGoal, mission);
+    ? missionVerifierHighLevelTestText(verifier, mission, guard)
+    : (guard && guard.allowed === false)
+      ? missionVerifierHighLevelTestText(null, mission, guard)
+      : mission.verifier
+        ? `Verifier was configured but not completed: ${mission.verifier}.`
+        : 'No verifier command was recorded for this mission.';
+  const nextLine = missionGuardNextText(guard, mission?.id)
+    || missionRunCreatedNextLine(createdNext, continuationGoal, mission);
   const lines = [
     'Landing:',
     `  Changed: ${changed}`,
@@ -2660,6 +2799,7 @@ function missionFromArgs(args) {
     ...(ownerResolution.requested_owner && ownerResolution.requested_owner !== owner ? { requested_owner: ownerResolution.requested_owner } : {}),
     ...(ownerResolution.executed_by ? { executed_by: normalizeOwnerSlug(ownerResolution.executed_by) } : {}),
     ...(ownerResolution.proposed_member ? { proposed_member: ownerResolution.proposed_member } : {}),
+    ...(ownerResolution.remap_reason ? { remap_reason: ownerResolution.remap_reason } : {}),
     status: 'planning',
     cadence,
     runner,
@@ -3971,9 +4111,23 @@ function startMission(args, options = {}) {
     const xpTask = createMissionXpTask(mission, process.cwd(), asJson);
     mission.xp_task = xpTask;
     mission.task_ids = Array.from(new Set([...(mission.task_ids || []), xpTask.task_id]));
+    mission.current_task_id = xpTask.task_id;
+    mission.task_ref = xpTask.ref;
     if (!mission.verifier && !mission.always_on) {
       mission.next_action = `work task then run: atris task current-step --goal-id ${mission.id} --as ${mission.owner} --proof "<proof>" --json`;
     }
+  } else if (!(mission.task_ids && mission.task_ids.length)) {
+    // Bind a live open/claimed task with the same objective instead of leaving
+    // task_ids empty and forcing attach-task to spawn a Mission XP twin later.
+    const existing = findOpenTaskMatchingMissionObjective(mission, process.cwd(), asJson);
+    if (existing) {
+      const bound = bindExistingMissionTask(mission, existing, process.cwd(), asJson);
+      mission.task_ids = [bound.task_id];
+      mission.current_task_id = bound.task_id;
+      mission.task_ref = bound.ref;
+      mission.xp_task = bound;
+      mission.xp_task_enabled = true;
+    }
   }
   if (typeof options.beforeMissionSave === 'function') {
     mission = options.beforeMissionSave(mission) || mission;
@@ -4008,6 +4162,7 @@ function startMission(args, options = {}) {
       dirty_count: worktreeBaseline.dirty_count,
       dirty_hash: worktreeBaseline.dirty_hash,
     } : null,
+    ...(saved.remap_reason ? { remap_reason: saved.remap_reason } : {}),
   };
   if (!options.silent) {
     printJsonOrText(
@@ -4016,6 +4171,7 @@ function startMission(args, options = {}) {
         `Started mission: ${saved.objective}`,
         `Owner: ${saved.owner}`,
         `State: ${saved.status}`,
+        ...(saved.remap_reason ? [`Remap: ${saved.remap_reason}`] : []),
         ...(saved.worktree ? [`Worktree: ${saved.worktree.path}`, `Branch: ${saved.worktree.branch}`] : []),
         ...warnings.map((warning) => `Warning: ${warning.message}`),
         ...(saved.xp_task ? [`AgentXP task: ${saved.xp_task.ref}`] : []),
@@ -4136,6 +4292,8 @@ async function startMissionFromRunObjective(objective, args) {
     const xpTask = createMissionXpTask(mission, process.cwd(), asJson);
     mission.xp_task = xpTask;
     mission.task_ids = Array.from(new Set([...(mission.task_ids || []), xpTask.task_id]));
+    mission.current_task_id = xpTask.task_id;
+    mission.task_ref = xpTask.ref;
   }
   if (landRun) {
     const repoPath = path.resolve(readFlag(args, '--repo', process.cwd()));
@@ -4262,14 +4420,16 @@ async function startMissionFromRunObjective(objective, args) {
 function attachMissionTask(args) {
   const asJson = wantsJson(args);
   if (hasFlag(args, '--help') || hasFlag(args, '-h') || String(args[0] || '').trim() === 'help') {
-    console.log('Usage: atris mission attach-task <id> [--json]');
+    console.log('Usage: atris mission attach-task <id> [--task <task-id>] [--json]');
+    console.log('Binds an open task with the same objective when one exists; pass --task to choose explicitly.');
     console.log('Run `atris mission --help` for the full option list.');
     process.exit(0);
   }
-  const ref = stripKnownFlags(args, [], ['--json'])[0] || '';
+  const ref = stripKnownFlags(args, ['--task'], ['--json'])[0] || '';
   if (!ref) {
-    exitMissionError('Usage: atris mission attach-task <id> [--json]', 1, asJson);
+    exitMissionError('Usage: atris mission attach-task <id> [--task <task-id>] [--json]', 1, asJson);
   }
+  const explicitTaskIds = readRepeatedFlag(args, '--task');
   let mission = resolveMission(ref);
   if (!mission) {
     exitMissingMission(ref, 1, asJson);
@@ -4287,6 +4447,13 @@ function attachMissionTask(args) {
       exitMissionError(`Mission "${ref}" is ${mission.status}; task spines attach only to active missions.`, 2, asJson);
     }
 
+    if (explicitTaskIds.length) {
+      mission = {
+        ...mission,
+        task_ids: Array.from(new Set([...(mission.task_ids || []), ...explicitTaskIds])),
+      };
+    }
+
     const existingSpine = missionTaskSpine(mission);
     if (existingSpine?.has_task) {
       let currentMission = mission;
@@ -4362,6 +4529,8 @@ function attachMissionTask(args) {
       xp_task_enabled: true,
       xp_task: xpTask,
       task_ids: Array.from(new Set([...(baseMission.task_ids || []), xpTask.task_id])),
+      current_task_id: xpTask.task_id,
+      task_ref: xpTask.ref,
     };
     if (nextMission.status === 'ready' && nextMission.receipt_path) {
       nextMission.next_action = missionXpReadyAction(nextMission, nextMission.receipt_path) || nextMission.next_action;
@@ -4373,17 +4542,17 @@ function attachMissionTask(args) {
       nextMission.next_action = `work task then run: atris task current-step --goal-id ${nextMission.id} --as ${nextMission.owner} --proof "<proof>" --json`;
     }
 
-    const { mission: saved } = saveMission(nextMission, process.cwd(), 'mission_task_spine_attached', { task_id: xpTask.task_id, task_ref: xpTask.ref });
+    const { mission: saved } = saveMission(nextMission, process.cwd(), 'mission_task_spine_attached', { task_id: xpTask.task_id, task_ref: xpTask.ref, reused: xpTask.reused === true });
     const memberState = renderMemberMissionState(saved.owner);
-    const logPath = appendMemberLog(saved.owner, 'Mission task spine attached', {
+    const logPath = appendMemberLog(saved.owner, xpTask.reused ? 'Mission task spine bound to existing task' : 'Mission task spine attached', {
       mission: saved.objective,
       task: xpTask.ref,
     });
     const view = missionStatusView(saved);
     printJsonOrText(
-      { ok: true, action: 'mission_task_spine_attached', mission: view, task: xpTask, task_spine: view.task_spine, member_state: memberState, log_path: logPath },
+      { ok: true, action: xpTask.reused ? 'mission_task_spine_bound' : 'mission_task_spine_attached', mission: view, task: xpTask, task_spine: view.task_spine, member_state: memberState, log_path: logPath },
       [
-        `Attached task spine: ${saved.objective}`,
+        xpTask.reused ? `Bound existing task spine: ${saved.objective}` : `Attached task spine: ${saved.objective}`,
         `Task: ${xpTask.ref}`,
         `Next: ${view.task_spine.current_step_command}`,
       ],
@@ -5188,6 +5357,14 @@ function missionReportFor(mission, root = process.cwd()) {
     ? 'The last verifier passed; full-budget work is continuing.'
     : mission.operator_outcome
     || (verifierPassed ? 'Verifier passed.' : mission.status === 'complete' ? 'Mission is complete.' : mission.status === 'blocked' ? 'Mission is blocked.' : 'Mission is still in progress.');
+  // Keep summary aligned with outcome: never claim a Codex handoff when the
+  // same report also says no receipt / no live worker.
+  let workerSummary = missionWorkerSummary(mission, receipt);
+  if (awaitingFirstWorker || noLiveWorker) {
+    workerSummary = awaitingFirstWorker
+      ? 'Waiting for the first worker check-in; no receipt yet.'
+      : 'No worker receipt yet.';
+  }
   return {
     id: mission.id,
     objective: mission.objective,
@@ -5201,7 +5378,7 @@ function missionReportFor(mission, root = process.cwd()) {
     operator_outcome: operatorOutcome,
     verification: verificationDebt,
     worker: mission.worker || missionWorkerLabel(mission),
-    worker_summary: missionWorkerSummary(mission, receipt),
+    worker_summary: workerSummary,
     timeline,
     worker_receipt_path: workerReceiptPath,
     verifier_receipt_path: verifierReceiptPath,
@@ -9528,6 +9705,7 @@ async function executeMissionRunTicksPhase(context) {
           tick: tickRecord,
           frozen,
           verifier_result: verifierResult,
+          protected_lane_guard: result.protected_lane_guard || null,
           rate_limit_info: lastRateLimit,
           worktree: tickWorktree,
         });
@@ -9585,7 +9763,7 @@ async function executeMissionRunTicksPhase(context) {
         last_tick_index: tickIdx,
         last_tick_layer: result.layer,
         last_tick_layer_source: result.layer_source,
-        verifier_result: verifierResult || latestOnDisk.verifier_result || null,
+        verifier_result: verifierResult || (verifyEach && result.protected_lane_guard && result.protected_lane_guard.allowed === false ? null : latestOnDisk.verifier_result) || null,
         last_check_feedback: verifierResult
           ? extractCheckFeedback(verifierResult)
           : latestOnDisk.last_check_feedback || '',
@@ -10096,9 +10274,7 @@ function tickMission(args) {
 	    const protectedLaneGuard = tickRecord.protected_lane_guard || { allowed: true };
 	    if (!protectedLaneGuard.allowed) {
 	      status = 'paused';
-	      nextAction = protectedLaneGuard.unreadable
-	        ? `repair the mission diff tooling failure, then rerun: atris mission run ${mission.id}`
-	        : `review the protected diff and receipt before resuming: atris mission run ${mission.id}`;
+	      nextAction = missionGuardNextText(protectedLaneGuard, mission.id);
 	    } else if (verifierResult?.passed && nextGoalChain && !nextGoalChain.pause_ready) {
 	      status = 'running';
 	      nextAction = missionGoalChainNextAction(nextGoalChain);
@@ -10136,7 +10312,7 @@ function tickMission(args) {
       last_tick_index: tickIdx,
 	      last_tick_layer: tickRecord.layer,
 	      last_tick_layer_source: tickRecord.layer_source,
-	      verifier_result: verifierResult || mission.verifier_result || null,
+	      verifier_result: verifierResult || (verify && !protectedLaneGuard.allowed ? null : mission.verifier_result) || null,
 	      last_check_feedback: verifierResult
 	        ? extractCheckFeedback(verifierResult)
 	        : mission.last_check_feedback || '',
@@ -10169,16 +10345,64 @@ function tickMission(args) {
     const outputMission = continuationGoal?.parent || saved;
     const atrisGoalState = refreshAtrisGoalController(process.cwd(), { missionId: outputMission.id });
     const codexGoalState = refreshCodexGoalController(process.cwd());
-    printJsonOrText(
-      { ok: true, action: 'mission_tick', mission: outputMission, tick: tickRecord, verifier_result: verifierResult, blocker, receipt_path: receiptPath, log_path: logPath, atris_goal_state: atrisGoalState, codex_goal_state: codexGoalState, continuation_goal: continuationGoal, operator_summary_warning: operatorSummaryWarning, cached: Boolean(tickRecord.cached) },
-      [
-        ...(tickRecord.cached ? [`Reused receipt for tick ${tickIdx}: ${receiptPath}`] : []),
-        ...missionTickResultLines(outputMission, tickIdx, receiptPath, verifierResult, summary || tickRecord.summary),
-        ...(missionBlockerReceiptLine(blocker) ? [missionBlockerReceiptLine(blocker)] : []),
-        ...(continuationGoal?.mission ? [`Next goal: ${continuationGoal.mission.objective}`] : []),
-      ],
-      asJson,
-    );
+    const verifyToolingFailed = Boolean(verify && !verifierResult && protectedLaneGuard.unreadable);
+    const skipDetail = missionGuardBlockedText(protectedLaneGuard)
+      || 'VERIFY DID NOT RUN: the check could not start. Treat this increment as unproven.';
+    const fullTick = {
+      ok: !verifyToolingFailed,
+      action: 'mission_tick',
+      mission: outputMission,
+      tick: tickRecord,
+      verifier_result: verifierResult,
+      blocker,
+      receipt_path: receiptPath,
+      log_path: logPath,
+      atris_goal_state: atrisGoalState,
+      codex_goal_state: codexGoalState,
+      continuation_goal: continuationGoal,
+      operator_summary_warning: operatorSummaryWarning,
+      cached: Boolean(tickRecord.cached),
+      next_command: outputMission.next_action || null,
+      ...(verifyToolingFailed ? {
+        reason: 'verify_did_not_run',
+        detail: skipDetail,
+      } : {}),
+    };
+    if (asJson) {
+      printCliJson(
+        fullTick,
+        verifyToolingFailed
+          ? compactErrorPayload({
+            reason: 'verify_did_not_run',
+            detail: skipDetail,
+            selected_ref: outputMission.id,
+            next_command: outputMission.next_action || null,
+          })
+          : compactSuccessPayload({
+            action: 'mission_tick',
+            ids: {
+              mission_id: outputMission.id,
+              tick_index: tickIdx,
+              status: outputMission.status,
+              receipt_path: receiptPath,
+            },
+            next_command: outputMission.next_action || null,
+          }),
+        args,
+      );
+    } else {
+      printJsonOrText(
+        fullTick,
+        [
+          ...(tickRecord.cached ? [`Reused receipt for tick ${tickIdx}: ${receiptPath}`] : []),
+          ...missionTickResultLines(outputMission, tickIdx, receiptPath, verifierResult, summary || tickRecord.summary, protectedLaneGuard),
+          ...(missionBlockerReceiptLine(blocker) ? [missionBlockerReceiptLine(blocker)] : []),
+          ...(continuationGoal?.mission ? [`Next goal: ${continuationGoal.mission.objective}`] : []),
+        ],
+        false,
+      );
+    }
+    if (verifyToolingFailed) process.exitCode = 2;
   } finally {
     releaseMissionLock(lock);
   }
@@ -11149,6 +11373,18 @@ function missionCommand(args) {
     return require('./human-missions').answerCommand(args.slice(1));
   }
   if (isBareMission && !hasLocalMissionState(resolveWorkspaceRoot())) {
+    const root = resolveWorkspaceRoot();
+    // Empty folder talks like bare atris. After init, stay on the current
+    // card or an honest no-mission, and do not bounce back to init.
+    if (isFreshWorkspace(root)) {
+      const code = speakFirstMinute({
+        root,
+        fresh: true,
+        asJson: args.includes('--json'),
+      });
+      process.exitCode = code;
+      return code;
+    }
     return require('./human-missions').currentMissionCommand(args);
   }
   const subcommand = isBareMission ? 'status' : (args[0] || 'status');
@@ -11300,6 +11536,7 @@ module.exports = {
   missionVerifierTimeoutMs,
   missionLandingStepSummary,
   missionLandingLines,
+  missionGuardNextText,
   missionVerifierCheckedText,
   missionVerifierHighLevelTestText,
   buildEngineVerifyPrompt,

package/commands/now.js

@@ -579,7 +579,7 @@ function refreshNowFile(root = process.cwd(), options = {}) {
 function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
   const help = args.includes('--help') || args.includes('-h') || args[0] === 'help';
   if (help) {
-    console.log('Usage: atris now [--init|--refresh|--all|--path]');
+    console.log('Usage: atris now [--init|--refresh|--all|--path] [--json]');
     console.log('');
     console.log('Show the current operating truth for this workspace.');
     console.log('');
@@ -588,6 +588,7 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
     console.log('  atris now --refresh Regenerate a small local now.md');
     console.log('  atris now --all     Refresh this parent and every child Atris workspace');
     console.log('  atris now --path    Print the file path only');
+    console.log('  atris now --json    Emit path and content as JSON');
     return;
   }
 
@@ -595,6 +596,7 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
   const refresh = args.includes('--refresh');
   const all = args.includes('--all');
   const pathOnly = args.includes('--path');
+  const asJson = args.includes('--json');
 
   let result;
   if (all) {
@@ -603,7 +605,7 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
       refreshNowFile(workspace.root);
     }
     result = refreshNowFile(root);
-    if (!pathOnly) {
+    if (!pathOnly && !asJson) {
       console.log(`Refreshed ${workspaces.length} child workspace${workspaces.length === 1 ? '' : 's'}.`);
       console.log('');
     }
@@ -621,12 +623,22 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
     return;
   }
 
+  const content = fs.readFileSync(result.path, 'utf8').trimEnd();
+  if (asJson) {
+    console.log(JSON.stringify({
+      ok: true,
+      path: rel,
+      created: Boolean(result.created),
+      content,
+    }, null, 2));
+    return;
+  }
+
   if (result.created) {
     console.log(`Created ${rel}`);
     console.log('');
   }
 
-  const content = fs.readFileSync(result.path, 'utf8').trimEnd();
   console.log(content);
 }