project-autopilot 12.0.0 → 12.0.1

package/scripts/role-fallback.mjs

@@ -22,6 +22,7 @@
 export const RATE_LIMITED_FAILURE_CLASS = "RATE_LIMITED";
 export const IDLE_HANG_FAILURE_CLASS = "IDLE_HANG";
 export const PROVIDER_ERROR_FAILURE_CLASS = "PROVIDER_ERROR";
+export const AUTH_REQUIRED_FAILURE_CLASS = "AUTH_REQUIRED";
 
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -175,8 +176,13 @@ export function skipExhaustedRoleModel({role, roleConfig, activeModel = null, ex
 //   fallback left: run the same run at once on `next` (fresh copy).
 // - `{action: "escalate", reason}` — RATE_LIMITED with no fallback left
 //   (or no fallbacks configured): keep today's escalate-and-stop.
-// - `{action: "none", reason}` — any non-RATE_LIMITED class: no switch,
-//   caller behavior unchanged.
+// - `{action: "none", reason}` — any other class: no switch, caller
+//   behavior unchanged.
+//
+// AUTH_REQUIRED (the CLI is logged out) switches only to a fallback on a
+// DIFFERENT adapter: another model on the same adapter shares the same dead
+// credentials, so it is never retried. With no other-adapter fallback it
+// escalates at once with the log-in instruction.
 //
 // IDLE_HANG with `noOutput: true` (the run produced 0 bytes for its whole
 // life) is treated like RATE_LIMITED for the switch (sticky, next untried
@@ -187,21 +193,24 @@ export function decideRoleFallback({role, roleConfig, activeModel = null, failur
   const name = typeof role === "string" && role ? role : "unknown";
   const silentHang = failureClass === IDLE_HANG_FAILURE_CLASS && noOutput === true;
   const providerError = failureClass === PROVIDER_ERROR_FAILURE_CLASS;
-  if (failureClass !== RATE_LIMITED_FAILURE_CLASS && !silentHang && !providerError) {
+  const authRequired = failureClass === AUTH_REQUIRED_FAILURE_CLASS;
+  if (failureClass !== RATE_LIMITED_FAILURE_CLASS && !silentHang && !providerError && !authRequired) {
     return {
       action: "none",
       reason: `${name}: failure class ${String(failureClass)} is not RATE_LIMITED; no fallback switch`,
     };
   }
   const fallbacks = fallbackListOf(roleConfig);
-  const label = silentHang ? "IDLE_HANG (no output)" : providerError ? "PROVIDER_ERROR" : "RATE_LIMITED";
+  const label = silentHang ? "IDLE_HANG (no output)" : authRequired ? "AUTH_REQUIRED" : providerError ? "PROVIDER_ERROR" : "RATE_LIMITED";
   if (fallbacks.length === 0) {
     if (silentHang) {
       return {action: "none", reason: `${name}: ${label} with no fallbacks configured; normal retry`};
     }
     return {
       action: "escalate",
-      reason: `${name}: ${label} with no fallbacks configured; human intervention required`,
+      reason: authRequired
+        ? `${name}: ${label} with no fallback on another adapter; log in required`
+        : `${name}: ${label} with no fallbacks configured; human intervention required`,
     };
   }
   // Sticky order: the current position is the active entry when it matches
@@ -218,17 +227,23 @@ export function decideRoleFallback({role, roleConfig, activeModel = null, failur
       currentIndex = found === -1 ? 0 : found + 1;
     }
   }
-  const next = fallbacks.slice(currentIndex).find((entry) => !isExhausted(exhausted, entry, policy, nowMs)) ?? null;
+  const from = currentIndex === 0 ? primary : fallbacks[currentIndex - 1];
+  // AUTH_REQUIRED is scoped to the CLI's own credentials, so a fallback model
+  // on the SAME adapter cannot help — only a different adapter (another CLI)
+  // can. Never retry the logged-out CLI, even through a configured sibling.
+  const next = fallbacks.slice(currentIndex).find((entry) =>
+    (!authRequired || entry.adapter !== from?.adapter) && !isExhausted(exhausted, entry, policy, nowMs)) ?? null;
   if (!next) {
     if (silentHang) {
       return {action: "none", reason: `${name}: ${label} with all ${fallbacks.length} fallback(s) exhausted; normal retry`};
     }
     return {
       action: "escalate",
-      reason: `${name}: ${label} with all ${fallbacks.length} fallback(s) exhausted; human intervention required`,
+      reason: authRequired
+        ? `${name}: ${label} with no untried fallback on another adapter; log in required`
+        : `${name}: ${label} with all ${fallbacks.length} fallback(s) exhausted; human intervention required`,
     };
   }
-  const from = currentIndex === 0 ? primary : fallbacks[currentIndex - 1];
   return {
     action: "switch",
     next: copyModelEntry(next),

package/scripts/run-history.mjs

@@ -8,6 +8,7 @@ import { defaultIsPidAlive } from "./run-recovery.mjs";
 import { growingTerm } from "./per-task-budget.mjs";
 import { readOwnerPid, ownerPidAlive } from "./owner-pid.mjs";
 import { buildReportModel, renderReport } from "./watch-report.mjs";
+import { detectUiProject } from "./e2e-detect.mjs";
 import { phases as standalonePhases } from "../adapters/standalone.mjs";
 
 // true = alive, false = provably gone, null = could not tell (no/invalid pid, or
@@ -196,6 +197,9 @@ export function readRunMeta(dir, id) {
     // only and may be stale or null (see observabilityMeta in
     // autopilot.mjs). result.json first (#110), status.json fallback for old runs.
     taskRef: result?.taskRef ?? status?.taskRef ?? null,
+  // The SpecKit/GSD planning stage this run worked on, recorded at launch.
+  // Null for non-planning runs and for standalone planning (`plan/tasks`).
+  planningStage: status?.planningStage ?? result?.planningStage ?? null,
   attempt: status?.attempt ?? result?.attempt ?? null,
   // Backlog #26 Step B: wrap-up marker (status.json only). Renders as a
   // NOTE suffix on the run line; runs without it read null and render
@@ -537,6 +541,30 @@ function sameResetEvent(a, b) {
 // same displayStatusLabel the old layout used (a run left "running" by a dead
 // orchestrator reads as the stale label, never RUNNING), and a cancelled
 // mission has no current run. All optional inputs are injectable for tests.
+// Final-report note: shown only when tests.e2e is none/unset and a UI was detected.
+export const NO_E2E_REPORT_NOTE = "no E2E — UI checked by component tests only";
+export function noE2eReportNote(repo, layout) {
+  let raw = layout;
+  if (raw === undefined) {
+    try { raw = JSON.parse(fs.readFileSync(path.join(repo, ".autopilot", "config.json"), "utf8")); } catch { raw = null; }
+  }
+  const e2e = raw?.tests?.e2e;
+  if (e2e && e2e !== "none") return null;
+  try { return detectUiProject(repo) ? NO_E2E_REPORT_NOTE : null; } catch { return null; }
+}
+
+// Append the no-E2E note to a mission REPORT.md once (idempotent); returns true when written.
+export function appendNoE2eNoteToReport(repo, file) {
+  try {
+    const note = noE2eReportNote(repo);
+    if (!note || !fs.existsSync(file)) return false;
+    const cur = fs.readFileSync(file, "utf8");
+    if (cur.includes(note)) return false;
+    fs.writeFileSync(file, `${cur.replace(/\n+$/, "")}\n\nNote: ${note}\n`);
+    return true;
+  } catch { return false; }
+}
+
 export function renderWatchReport(repo, mission, { tail = 40, isOwnerAlive, isAlive, phases, policy, events, now, skill, gateLog } = {}) {
   const d = new Date();
   const p = (n) => String(n).padStart(2, "0");
@@ -623,10 +651,13 @@ export function renderWatchReport(repo, mission, { tail = 40, isOwnerAlive, isAl
     gateLog: gateLogText,
     now: now ?? d.toISOString(),
     skill: skill ?? null,
+    command: state?.command ?? null,
     missionFallback: mission ?? null,
     ownerAlive,
   });
-  return renderReport(model, { stamp });
+  const e2eNote = noE2eReportNote(repo, configResult?.layout ?? null);
+  const out = renderReport(model, { stamp });
+  return e2eNote ? `${out.replace(/\n+$/, "")}\nNote: ${e2eNote}\n` : out;
 }
 
 // Direct-write the watch report file (same principle as progress.log: the

package/scripts/run-observability.mjs

@@ -169,6 +169,10 @@ export function initRun(dir, meta = {}) {
     // This is the field to read; `taskGroup` above is grouping-only (see
     // observabilityMeta in autopilot.mjs) and may be stale or null.
     taskRef: meta.taskRef ?? null,
+    // SpecKit/GSD planning stage this run worked on (`spec`/`plan`/`tasks` or
+    // `discuss`/`research`/`plan`/`plan-check`). Null for every other run and
+    // for standalone planning, whose report label stays `plan/tasks`.
+    planningStage: meta.planningStage ?? null,
     attempt: meta.attempt ?? null,
     // Backlog #26 Step B: wrap-up marker (`note: "wrap-up"` on the forced
     // hand-off run). Shown in the watch report so the extra run after a cap
@@ -182,6 +186,11 @@ export function initRun(dir, meta = {}) {
     configuredModel: meta.configuredModel ?? null,
     resolvedModel: meta.resolvedModel ?? null,
     modelMismatch: meta.modelMismatch ?? null,
+    // Backlog #7: reasoning level / opencode variant of the model actually
+    // launched (the active fallback/escalation entry's own values, never the
+    // primary's). Null when the CLI default applies. Additive.
+    reasoning: meta.reasoning ?? null,
+    variant: meta.variant ?? null,
     // Mission 093 Part 1 task 2.3: run-scoped layout fields. snapshotBeforeAt
     // and snapshotAfterAt are the end wall-clock times of the relay's safety
     // snapshots; the matching *StartedAt fields let the report print the
@@ -207,10 +216,20 @@ export function initRun(dir, meta = {}) {
     // list; a non-list or empty list degrades to null here. Additive — every
     // reader above is untouched.
     carriedForwardTasks: (Array.isArray(meta.carriedForwardTasks) && meta.carriedForwardTasks.length > 0 ? meta.carriedForwardTasks : null),
-    last_action: "started",
+    // The pre-run seed call defers the START line until the child process
+    // actually exists (onStart re-inits with the real pid). Until then the
+    // run is visibly PREPARING, never a fake START with PID=-.
+    last_action: meta.last_action ?? (meta.deferStart === true ? "preparing" : "started"),
   };
   fs.writeFileSync(path.join(dir, "status.json"), JSON.stringify(status, null, 2));
-  appendProgress(dir, `START | ROLE=${meta.role ?? "-"} | PHASE=${meta.phase ?? "-"} | TASK=${meta.taskRef ?? "-"} | ATTEMPT=${meta.attempt ?? "-"} | PID=${meta.pid ?? "-"}`);
+  if (meta.deferStart !== true) {
+    appendProgress(dir, `START | ROLE=${meta.role ?? "-"} | PHASE=${meta.phase ?? "-"} | TASK=${meta.taskRef ?? "-"} | ATTEMPT=${meta.attempt ?? "-"} | PID=${meta.pid ?? "-"}`);
+  } else {
+    // Seed an empty progress.log so readers can tail it while the pre-run
+    // steps write their PREPARE lines; no fake START with PID=-.
+    const progressFile = path.join(dir, "progress.log");
+    if (!fs.existsSync(progressFile)) fs.writeFileSync(progressFile, "");
+  }
   // Mission 094 Phase 3 task 3.2: keep the compact watch-summary cache current
   // at the run-write points so a later render never re-reads every run dir.
   // Best-effort (a failed cache write must never break a run); a dir that is
@@ -219,6 +238,31 @@ export function initRun(dir, meta = {}) {
   return status;
 }
 
+// Mark a run as PREPARING (before its CLI exists) so status.json, and therefore
+// the watch report, names the setup step that is running instead of showing a
+// running run with pid null. Best-effort like every observability write.
+export function setRunPreparing(dir, action) {
+  const name = String(action || "").trim();
+  if (!name) return false;
+  updateStatus(dir, { updated_at: localIso(), last_action: `preparing: ${name}` });
+  try { updateSummaryForRunDir(dir); } catch { /* ignore */ }
+  return true;
+}
+
+// Append one `PREPARE | <action>[ (<detail>)] | DURATION=<h:mm:ss>` line for a
+// completed pre-run step (git guard, snapshot-before, …). The START line stays
+// the only line that names the real PID, and keeps its existing format.
+export function prepareRun(dir, { action, detail = null, durationMs = null } = {}) {
+  const name = String(action || "").trim();
+  if (!name) return false;
+  const suffix = detail ? ` (${detail})` : "";
+  const duration = Number.isFinite(Number(durationMs)) && Number(durationMs) >= 0 ? ` | DURATION=${formatDuration(Number(durationMs))}` : "";
+  appendProgress(dir, `PREPARE | ${name}${suffix}${duration}`);
+  updateStatus(dir, { updated_at: localIso(), last_action: `preparing: ${name}` });
+  try { updateSummaryForRunDir(dir); } catch { /* ignore */ }
+  return true;
+}
+
 export function observe(dir, { stream = "stdout", bytes = 0, minIntervalMs = 1000, last } = {}) {
   // Backlog #6a: a chunk carrying a real tool action writes its OWN progress
   // line (tool + command/file, extracted before the ACTIVITY snippet is

package/scripts/setup-discovery.mjs

@@ -1,11 +1,12 @@
 import { discoverAgentContract } from './agent-contract.mjs';
 import { discoverCapabilities } from './model-discovery.mjs';
 
-export async function buildDiscoveryCaches(availableIds, agentsMap, discoverFn = discoverAgentContract) {
+export async function buildDiscoveryCaches(availableIds, agentsMap, discoverFn = discoverAgentContract, {onStart = null} = {}) {
   const capabilityCache = new Map();
   const contractCache = new Map();
   for (const id of availableIds) {
     try {
+      if (typeof onStart === "function") onStart(id, agentsMap[id]);
       const contract = await discoverFn(id, agentsMap[id]);
       contractCache.set(id, contract);
       capabilityCache.set(id, contract?.capabilities || await discoverCapabilities(agentsMap[id]));