@polymorphism-tech/morph-spec 8.6.0 → 8.8.0

package/src/commands/state/list.js

@@ -44,8 +44,14 @@ function buildRow(name, fj, fdir, location) {
   const gates = {};
   for (const g of G) gates[g] = fj.approvalGates?.[g]?.approved === true;
 
+  // Gate 3 approved WITHOUT the independent evaluator (`approve --self-assessed`).
+  // A recorded degradation is only worth recording if it is visible — this is
+  // the surface that makes it so (D2).
+  const selfAssessed = fj.approvalGates?.review?.selfAssessed === true;
+
   const flags = [];
   if (fj.__corrupt) flags.push('corrupt');
+  if (selfAssessed) flags.push('self-assessed-g3');
   // Identity + gate-order anomalies come from the shared rules
   // (core/state/feature-identity.js, core/state/gate-order.js) — same source
   // doctor reports from.
@@ -60,6 +66,7 @@ function buildRow(name, fj, fdir, location) {
     status: fj.status || 'unknown',
     phase: location === 'archived' ? 'archived' : derivePhase(fdir),
     gates,
+    selfAssessed,
     flags,
     location,
     createdAt: fj.createdAt || null,
@@ -93,7 +100,8 @@ export function listCommand(options = {}) {
   ));
   for (const r of rows) {
     const flag = r.flags.length ? chalk.yellow('⚠') : ' ';
-    const desc = r.description ? truncate(r.description, 44) : chalk.yellow('(sem descrição)');
+    const desc = (r.selfAssessed ? chalk.yellow('[G3 self-assessed] ') : '')
+      + (r.description ? truncate(r.description, 44) : chalk.yellow('(sem descrição)'));
     // padEnd counts the invisible color codes; pad the plain marks manually.
     console.log(
       col(r.feature, 22) + col(r.workType, 9) + col(r.status, 13) + col(r.phase, 11)

package/src/commands/state/report-check.js

@@ -0,0 +1,202 @@
+/**
+ * `morph-spec report-check <feature> [task] [--json]` — the deterministic half
+ * of the missing-report protocol (B4).
+ *
+ * MORPH.md already made the sub-agent's canonical report file the authoritative
+ * return value ("o ARQUIVO é o retorno, a última mensagem é cortesia"), but it
+ * never said what to do when the file is not there. The naive reading — "no
+ * report, so the agent failed" — is wrong and expensive: the agent may have
+ * done every bit of the work and lost the means to record it (observed: a
+ * worktree removed out from under a running sub-agent).
+ *
+ * So this command answers the question the orchestrator actually has, and
+ * answers it from evidence rather than from the agent's own word: **did the
+ * WORK land, independently of whether the REPORT did?**
+ *
+ *   verdict                          action
+ *   ─────────────────────────────    ──────────────────
+ *   ok                               proceed
+ *   report-incomplete                complete-degraded
+ *   work-landed-report-missing       accept-degraded
+ *   no-work-no-report                redispatch
+ *   report-missing-evidence-unknown  redispatch   (conservative default)
+ *
+ * Exit 0 only for `ok` — anything needing an action exits non-zero so a caller
+ * can branch on it. `--json` always prints the machine-readable verdict.
+ */
+
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * The four mandatory items of the report contract, as detectable markers.
+ *
+ * HEURISTIC BY CONSTRUCTION, and deliberately loose: the contract asks for
+ * content, not for a fixed template, and reports written before this command
+ * existed must still audit cleanly. A false "complete" is the cheap error here
+ * (the orchestrator reads the report anyway); a false "incomplete" would send
+ * it re-dispatching finished work, which is the expensive one.
+ */
+const REPORT_MARKERS = [
+  // (2) files touched — a list line carrying a path or a backticked identifier
+  { id: 'files', re: /^\s*[-*]\s+.*[`/\\].*$/m },
+  // (4) self-score 0-10
+  { id: 'score', re: /score[^\n]*?\b(10|\d)(?:[.,]\d+)?\b/i },
+  // (3) problems found (or an explicit "none")
+  { id: 'problems', re: /problema|issue|blocker|nenhum|impedimento/i },
+];
+
+/** (1) "what was done" — prose beyond the structural markers. */
+const MIN_PROSE_CHARS = 80;
+
+function reportPath(cwd, feature, taskId) {
+  return join(cwd, '.morph', 'features', feature, '3-implement', 'reports', `${taskId}.md`);
+}
+
+function evaluatorPath(cwd, feature) {
+  return join(cwd, '.morph', 'features', feature, '4-review', 'evaluator-report.md');
+}
+
+/**
+ * Inspect one report file: does it exist, and which of the four mandatory
+ * items can be found in it.
+ */
+export function inspectReport(path) {
+  if (!existsSync(path)) return { exists: false, complete: false, missing: ['what', 'files', 'problems', 'score'] };
+  let body = '';
+  try {
+    body = readFileSync(path, 'utf8');
+  } catch {
+    return { exists: true, complete: false, missing: ['what', 'files', 'problems', 'score'], unreadable: true };
+  }
+
+  const missing = REPORT_MARKERS.filter((m) => !m.re.test(body)).map((m) => m.id);
+  // Prose = the body minus headings and list lines, so a bare file list does
+  // not pass as "what was done".
+  const prose = body
+    .split('\n')
+    .filter((l) => !/^\s*(#|[-*]\s)/.test(l))
+    .join(' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (prose.length < MIN_PROSE_CHARS) missing.unshift('what');
+
+  return { exists: true, complete: missing.length === 0, missing };
+}
+
+/** How many of a task's declared outputs actually exist on disk. */
+function outputEvidence(cwd, taskOutputs) {
+  const expected = Array.isArray(taskOutputs) ? taskOutputs : [];
+  const present = expected.filter((rel) => {
+    try {
+      return existsSync(join(cwd, rel));
+    } catch {
+      return false;
+    }
+  }).length;
+  return { outputsExpected: expected.length, outputsPresent: present };
+}
+
+/** Combine report state + evidence into a verdict and the action it implies. */
+function decide(report, evidence) {
+  if (report.exists && report.complete) return { verdict: 'ok', action: 'proceed' };
+  if (report.exists) return { verdict: 'report-incomplete', action: 'complete-degraded' };
+  if (evidence.outputsExpected === 0) {
+    // No declared outputs means no evidence either way. Re-dispatching costs a
+    // sub-agent; silently accepting a phantom completion costs correctness.
+    return { verdict: 'report-missing-evidence-unknown', action: 'redispatch' };
+  }
+  return evidence.outputsPresent > 0
+    ? { verdict: 'work-landed-report-missing', action: 'accept-degraded' }
+    : { verdict: 'no-work-no-report', action: 'redispatch' };
+}
+
+function checkTask(cwd, feature, task) {
+  const report = inspectReport(reportPath(cwd, feature, task.id));
+  const evidence = outputEvidence(cwd, task.outputs);
+  return { task: task.id, report, evidence, ...decide(report, evidence) };
+}
+
+const ACTION_HINT = {
+  proceed: 'relatório íntegro — siga o fluxo normal.',
+  'complete-degraded': 'complete os itens faltantes a partir da mensagem de retorno do sub-agent, carimbe o relatório como DEGRADADO e registre a falha de protocolo no recap.',
+  'accept-degraded': 'o TRABALHO entrou — não re-despache. Grave você mesmo o relatório canônico a partir da mensagem de retorno, carimbado como DEGRADADO, e registre a falha de protocolo no recap e nas `notes` da task.',
+  redispatch: 're-despache a task UMA vez com o mesmo prompt. Segunda ausência sem trabalho entregue = falha real: escale ao humano.',
+};
+
+/**
+ * @param {string} feature
+ * @param {string|undefined} taskId
+ * @param {{ json?: boolean, cwd?: string }} [options]
+ */
+export function reportCheckCommand(feature, taskId, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const emit = (obj, code) => {
+    if (options.json) console.log(JSON.stringify(obj, null, 2));
+    else printHuman(obj);
+    process.exit(code);
+  };
+
+  const tasksPath = join(cwd, '.morph', 'features', feature, '2-plan', 'tasks.json');
+  if (!existsSync(tasksPath)) {
+    emit({ error: `feature "${feature}" não tem 2-plan/tasks.json — nada a auditar`, feature }, 1);
+  }
+
+  let tasks = [];
+  try {
+    const parsed = JSON.parse(readFileSync(tasksPath, 'utf8'));
+    tasks = Array.isArray(parsed.tasks) ? parsed.tasks : [];
+  } catch {
+    emit({ error: `2-plan/tasks.json de "${feature}" está corrompido`, feature }, 1);
+  }
+
+  if (taskId) {
+    const task = tasks.find((t) => t.id === taskId);
+    if (!task) emit({ error: `task "${taskId}" não existe em tasks.json`, feature }, 1);
+    const result = checkTask(cwd, feature, task);
+    emit({ feature, ...result, hint: ACTION_HINT[result.action] }, result.verdict === 'ok' ? 0 : 1);
+  }
+
+  // Whole-feature audit: every DONE task owes a report; a pending one does not.
+  const results = tasks.filter((t) => t.status === 'done').map((t) => checkTask(cwd, feature, t));
+  const evaluator = inspectReport(evaluatorPath(cwd, feature));
+  const clean = results.every((r) => r.verdict === 'ok');
+  emit({ feature, results, evaluator, clean }, clean ? 0 : 1);
+}
+
+function printHuman(obj) {
+  if (obj.error) {
+    console.error(chalk.red(`\n❌ ${obj.error}\n`));
+    return;
+  }
+  const line = (r) => {
+    const icon = r.verdict === 'ok' ? chalk.green('✓') : chalk.yellow('⚠');
+    const ev = r.evidence.outputsExpected
+      ? `outputs ${r.evidence.outputsPresent}/${r.evidence.outputsExpected}`
+      : 'outputs não declarados';
+    console.log(`  ${icon} ${String(r.task).padEnd(6)} ${r.verdict.padEnd(32)} ${ev}`);
+    if (r.verdict !== 'ok') {
+      if (r.report.exists && r.report.missing.length) {
+        console.log(chalk.gray(`      faltando no relatório: ${r.report.missing.join(', ')}`));
+      }
+      console.log(chalk.gray(`      → ${ACTION_HINT[r.action]}`));
+    }
+  };
+
+  if (obj.task) {
+    console.log(chalk.bold(`\n📄 report-check ${obj.feature} ${obj.task}`));
+    line(obj);
+    console.log('');
+    return;
+  }
+
+  console.log(chalk.bold(`\n📄 report-check ${obj.feature}`));
+  if (!obj.results.length) console.log(chalk.gray('  nenhuma task done — nada a auditar'));
+  for (const r of obj.results) line(r);
+  console.log(
+    `  ${obj.evaluator.exists ? chalk.green('✓') : chalk.yellow('⚠')} ${'Gate 3'.padEnd(6)} `
+    + `evaluator-report.md ${obj.evaluator.exists ? (obj.evaluator.complete ? 'íntegro' : 'incompleto') : 'ausente'}`,
+  );
+  console.log('');
+}

package/src/core/state/lifecycle-audit.js

@@ -10,14 +10,68 @@
  *   • orphan-folder — a feature folder with no feature.json
  *   • stale-index   — a root-index entry with no feature folder (auto-heals on
  *                     the next loadState, but surfaced so it's not a mystery)
+ *   • branch-drift  — the root's copy of a feature.json disagrees with the copy
+ *                     committed on `morph/{f}` (B5 — the root's view lags)
  *   • corrupt       — a feature.json that won't parse
  */
 
+import { execFileSync } from 'child_process';
 import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
 import { join } from 'path';
 import { gateOrderViolations } from './gate-order.js';
 import { missingIdentity } from './feature-identity.js';
 
+/** The operational truth of a feature.json: its status and which gates are approved. */
+function operationalShape(fj) {
+  const gates = {};
+  for (const [g, v] of Object.entries(fj?.approvalGates || {})) gates[g] = v?.approved === true;
+  return JSON.stringify({ status: fj?.status ?? null, gates });
+}
+
+/**
+ * Does the root's working-tree copy of a feature.json disagree with the copy
+ * COMMITTED on that feature's own branch?
+ *
+ * `.morph/state.json` is gitignored and derived, and every worktree keeps its
+ * own — so "the index diverges between worktrees" is by design, not a defect to
+ * fix by making the index authoritative (that would undo the whole per-feature
+ * state model). The defect is that the divergence was INVISIBLE: since v8.4 the
+ * authoritative feature.json travels committed on `morph/{f}`, so a primary root
+ * parked on the default holds a copy that silently lags, and everything derived
+ * from it (status, gates, and the index rebuilt from it) lags with it.
+ *
+ * Comparison is on the OPERATIONAL fields only — status and approved-gate flags
+ * — not on bytes: reformatting or a timestamp bump is not a divergence anyone
+ * needs to hear about.
+ *
+ * Fail-open at every step: no repo, no branch, no blob, unparseable JSON → no
+ * issue. A diagnostic that invents problems is worse than one that misses some.
+ *
+ * @returns {string|null} the issue detail, or null when the copies agree
+ */
+function branchDrift(baseDir, feature, rootFj) {
+  const branch = `morph/${feature}`;
+  try {
+    const current = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: baseDir, stdio: 'pipe' })
+      .toString().trim();
+    // On the feature's own branch the working tree IS the branch — nothing to compare.
+    if (current === branch) return null;
+
+    execFileSync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], { cwd: baseDir, stdio: 'pipe' });
+
+    const raw = execFileSync('git', ['show', `${branch}:.morph/features/${feature}/feature.json`], {
+      cwd: baseDir, stdio: 'pipe',
+    }).toString();
+    const branchFj = JSON.parse(raw);
+
+    if (operationalShape(branchFj) === operationalShape(rootFj)) return null;
+    return `root copy disagrees with ${branch} (status/gates) — the branch is authoritative; `
+      + `rode \`git show ${branch}:.morph/features/${feature}/feature.json\` para ver`;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * @param {string} [baseDir] - project root (defaults to cwd)
  * @returns {Array<{ feature: string, type: string, detail: string }>} issues
@@ -49,6 +103,9 @@ export function auditFeatureLifecycle(baseDir = process.cwd()) {
         continue;
       }
 
+      const drift = branchDrift(baseDir, name, fj);
+      if (drift) issues.push({ feature: name, type: 'branch-drift', detail: drift });
+
       const miss = missingIdentity(fj);
       if (miss.length) {
         issues.push({ feature: name, type: 'identity', detail: `missing ${miss.join(', ')}` });

package/src/dashboard/scanner/state-scanner.js

@@ -1,5 +1,6 @@
 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { join } from 'path';
+import { WORKTREE_DIR_NAMES } from '../../commands/project/worktree.js';
 
 export function scanState(projectDir) {
   const statePath = join(projectDir, '.morph', 'state.json');
@@ -32,15 +33,22 @@ export function scanState(projectDir) {
   }
 
   // Aggregate in-progress features that only exist inside a feature worktree
-  // (.worktrees/{wt}/.morph/features/*/feature.json). In the v8 multi-instance
+  // (worktrees/{wt}/.morph/features/*/feature.json). In the v8 multi-instance
   // model a feature's authoritative feature.json is committed on its
   // `morph/{feature}` branch and only lands in the root .morph/features/ after
   // `morph-spec finish`. This is read-only visibility for the dashboard — root
   // features (the merged, authoritative state) always take precedence, and
   // worktree-sourced entries are tagged with `_worktree` so the UI can
   // distinguish them.
-  const worktreesDir = join(projectDir, '.worktrees');
-  if (existsSync(worktreesDir)) {
+  //
+  // BOTH directory names are scanned: this scanner resolves worktrees by
+  // CONVENTION (unlike fleet/finish, which read `git worktree list`), so it is
+  // the one that would otherwise go blind to pre-C1 `.worktrees/` checkouts.
+  const worktreeDirs = WORKTREE_DIR_NAMES
+    .map((name) => join(projectDir, name))
+    .filter((dir) => existsSync(dir));
+
+  for (const worktreesDir of worktreeDirs) {
     let worktreeNames = [];
     try {
       worktreeNames = readdirSync(worktreesDir, { withFileTypes: true })

package/src/lib/generators/architecture-scanner.js

@@ -19,7 +19,7 @@ import path from 'path';
 import { existsSync, readFileSync } from 'fs';
 import { renderTemplate } from '../../core/templates/template-renderer.js';
 
-const SKIP_DIRS = new Set(['node_modules', 'bin', 'obj', '.git', '.morph', '.next', 'dist', 'out', '.worktrees']);
+const SKIP_DIRS = new Set(['node_modules', 'bin', 'obj', '.git', '.morph', '.next', 'dist', 'out', 'worktrees', '.worktrees']);
 const MAX_FILES_PER_SCANNER = 200;
 
 /**

package/src/lib/tasks/tasks-json-parser.js

@@ -201,6 +201,14 @@ export function groupTasks(data) {
  * Convert tasks.json to the legacy taskList shape used in state.json.
  * Lets the rest of the codebase keep using feature.taskList while migration
  * is in progress.
+ *
+ * BOUNDARY — this is the ONE place `done` becomes `completed`, and it is a
+ * one-way translation OUT of the tasks.json vocabulary. In tasks.json the
+ * terminal status is `done` (tasks.schema.json's enum has no `completed`);
+ * `completed` belongs to the legacy taskList and to Claude Code's native
+ * session tasks. Leaking `completed` back into a tasks.json write is rejected
+ * by `protect-spec-files` — see framework/rules/morph-task-tracking.md, which
+ * spells the split out for the author.
  */
 export function toTaskList(data) {
   return data.tasks.map(t => ({

package/src/lib/worktree/fleet-scanner.js

@@ -17,18 +17,118 @@ import { execSync, execFileSync } from 'child_process';
 import { existsSync, readdirSync, readFileSync } from 'fs';
 import { join, resolve } from 'path';
 import { isGitRepo, resolvePrimaryRoot, parseWorktreeList } from '../../commands/project/worktree.js';
+import { hasOriginRemote } from '../git/default-branch.js';
 import { registryPath, resolveFleetConfig } from './env-allocator.js';
 import {
   getFeature,
   derivePhaseForFeature,
+  derivePhaseFrom,
   getPendingGates,
+  pendingGatesFrom,
 } from '../../../framework/hooks/shared/state-reader.js';
+import { listClaims } from '../../../framework/hooks/shared/claim-registry.js';
+
+function countFrom(raw) {
+  const data = JSON.parse(raw);
+  if (!Array.isArray(data.tasks)) return null;
+  return { done: data.tasks.filter((t) => t.status === 'done').length, total: data.tasks.length };
+}
+
+/**
+ * Which branch holds this feature's truth, when the working tree at `path` does
+ * NOT — or `null` when the working tree IS the feature's own checkout.
+ *
+ * The ONE place this condition lives. `tasks` (B3) and `phase`/`pendingGates`
+ * (B3b) are the same defect read through different files, so they must agree on
+ * when to look at the branch; two drifting copies of this test would resurrect
+ * the bug on one field while the other stayed fixed.
+ *
+ * A worktree entry is the feature's checkout by construction. A root entry is
+ * only the feature's checkout when the root happens to be ON `morph/{f}`.
+ *
+ * @returns {string|null} branch name to read from, or null for "read the disk"
+ */
+function branchToReadFrom(root, feature, location, branch) {
+  if (location === 'worktree' || !root || !feature) return null;
+  const featureBranch = branch || `morph/${feature}`;
+  try {
+    const current = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: root, stdio: 'pipe' })
+      .toString().trim();
+    return current === featureBranch ? null : featureBranch;
+  } catch {
+    return null; // no HEAD to compare against — trust the disk
+  }
+}
+
+/**
+ * The feature's committed state on its own branch: the feature.json blob plus
+ * the set of files under its feature dir.
+ *
+ * `git ls-tree -z` is deliberate: without it git QUOTES paths containing
+ * non-ASCII bytes (`"a\303\247/…"`), which would silently fail the prefix strip
+ * and leave the artifact set empty — a predicate that is always false looks
+ * exactly like "this feature has no artifacts".
+ *
+ * Fail-open in layers: no blob → null (caller reads the disk); no tree → the
+ * gates alone still beat a stale working tree.
+ *
+ * @returns {{ fj: Object, files: Set<string> }|null}
+ */
+function branchView(root, feature, featureBranch) {
+  const prefix = `.morph/features/${feature}/`;
+  let fj;
+  try {
+    fj = JSON.parse(execFileSync('git', ['show', `${featureBranch}:${prefix}feature.json`], {
+      cwd: root, stdio: 'pipe',
+    }).toString());
+  } catch {
+    return null;
+  }
+
+  const files = new Set();
+  try {
+    const out = execFileSync('git', ['ls-tree', '-r', '--name-only', '-z', featureBranch, '--', prefix], {
+      cwd: root, stdio: 'pipe',
+    }).toString();
+    for (const raw of out.split('\0')) {
+      const p = raw.trim();
+      if (p.startsWith(prefix)) files.add(p.slice(prefix.length));
+    }
+  } catch { /* no tree — gates alone still beat the stale working tree */ }
+
+  return { fj, files };
+}
+
+/**
+ * Task progress for one feature.
+ *
+ * DIVERGENCE from the bug report, which blamed "a cached state.json/feature.json
+ * snapshot": this never read either — it always read `2-plan/tasks.json`
+ * directly. The real mechanism is which COPY of that file is on disk. Since
+ * v8.4 every feature is born on `morph/{f}` and its tasks.json is COMMITTED
+ * there; the primary root's working tree only ever holds the copy of the
+ * CHECKED-OUT branch. An operator sitting on the default therefore read the
+ * pre-work copy — the reported `2/2` for a feature whose branch already had
+ * T1..T3 all done.
+ *
+ * @param {string} featureDir - the feature dir inside `path`
+ * @param {{ root: string, feature: string, featureBranch: string|null }} ctx
+ */
+function taskCounts(featureDir, { root, feature, featureBranch } = {}) {
+  if (featureBranch && root && feature) {
+    try {
+      const raw = execFileSync(
+        'git',
+        ['show', `${featureBranch}:.morph/features/${feature}/2-plan/tasks.json`],
+        { cwd: root, stdio: 'pipe' },
+      ).toString();
+      const counted = countFrom(raw);
+      if (counted) return counted;
+    } catch { /* no such branch/blob — fall through to the working tree */ }
+  }
 
-function taskCounts(featureDir) {
   try {
-    const data = JSON.parse(readFileSync(join(featureDir, '2-plan', 'tasks.json'), 'utf8'));
-    if (!Array.isArray(data.tasks)) return null;
-    return { done: data.tasks.filter((t) => t.status === 'done').length, total: data.tasks.length };
+    return countFrom(readFileSync(join(featureDir, '2-plan', 'tasks.json'), 'utf8'));
   } catch {
     return null;
   }
@@ -63,17 +163,108 @@ function dirtyCount(worktreePath) {
   }
 }
 
-function buildEntry(feature, { location, path, branch, root, allocations, blockSize }) {
+/**
+ * One `git ls-remote --heads origin` for the WHOLE scan → Map<branch, sha>.
+ *
+ * The fleet used to read only local state, so a feature whose branch (and PR)
+ * already lived on origin still showed up as "pending, nothing pushed" — that
+ * reading is what made a second session redo finished work. Resolved once per
+ * scan, never per entry.
+ *
+ * Returns `null` when there is no origin, or the probe fails/times out: the
+ * entries then carry `remote: null` ("unknown"), never a false `pushed: false`.
+ *
+ * @param {string} root
+ * @returns {Map<string,string>|null}
+ */
+function remoteHeads(root) {
+  if (!hasOriginRemote(root)) return null;
+  try {
+    const out = execFileSync('git', ['ls-remote', '--heads', 'origin'], {
+      cwd: root, stdio: 'pipe', timeout: 5000,
+    }).toString();
+    const map = new Map();
+    for (const line of out.split('\n')) {
+      const m = line.match(/^([0-9a-f]{7,64})\s+refs\/heads\/(.+)$/);
+      if (m) map.set(m[2].trim(), m[1]);
+    }
+    return map;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * One `gh pr list` for the whole scan → Map<headRefName, {number, state}>.
+ *
+ * Gated on the origin URL actually pointing at github.com — `gh` against any
+ * other host is a guaranteed error, and paying its start-up cost to learn that
+ * on every `fleet` call is pure latency. Fail-open: no `gh`, not authenticated,
+ * or a timeout all yield `null`, which just leaves the PR half of the column
+ * empty while `pushed` still works.
+ *
+ * @param {string} root
+ * @returns {Map<string,{number:number,state:string}>|null}
+ */
+function remotePrs(root) {
+  try {
+    const url = execFileSync('git', ['remote', 'get-url', 'origin'], { cwd: root, stdio: 'pipe' }).toString();
+    if (!/github\.com/i.test(url)) return null;
+    const out = execFileSync('gh', ['pr', 'list', '--state', 'all', '--limit', '100', '--json', 'number,state,headRefName'], {
+      cwd: root, stdio: 'pipe', timeout: 8000,
+    }).toString();
+    const map = new Map();
+    for (const pr of JSON.parse(out)) {
+      // First wins: `gh` lists newest-first, so an OPEN PR shadows an older
+      // closed one on the same branch.
+      if (pr?.headRefName && !map.has(pr.headRefName)) map.set(pr.headRefName, { number: pr.number, state: pr.state });
+    }
+    return map;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The remote fact for one feature. Worktree entries know their real branch
+ * (which may carry a `--fresh` date suffix); root-resident features fall back
+ * to the canonical `morph/{feature}` every feature is born on.
+ */
+function buildRemote(feature, branch, heads, prs) {
+  if (!heads) return null;
+  const remoteBranch = branch || `morph/${feature}`;
+  const sha = heads.get(remoteBranch) || null;
+  return { branch: remoteBranch, pushed: sha !== null, sha, pr: prs?.get(remoteBranch) || null };
+}
+
+function buildEntry(feature, { location, path, branch, root, allocations, blockSize, heads, prs, claims }) {
   let workType = null;
   let status = 'unknown';
   let phase = 'proposal';
   let pendingGates = [];
+
+  // Resolved once and shared with taskCounts — see branchToReadFrom.
+  const featureBranch = branchToReadFrom(root, feature, location, branch);
+
   try {
-    const fj = getFeature(feature, path);
-    workType = fj?.workType || null;
-    status = fj?.status || 'unknown';
-    phase = derivePhaseForFeature(feature, path);
-    pendingGates = getPendingGates(feature, path);
+    // B3b: phase and gates suffered the same branch-staleness B3 fixed for
+    // tasks. They read `.morph/features/{f}/` through the working tree, so a
+    // root parked on the default reported the PRE-WORK phase for a feature
+    // whose branch was already at implement — and re-asked for a gate the
+    // feature branch had already approved.
+    const view = featureBranch ? branchView(root, feature, featureBranch) : null;
+    if (view) {
+      workType = view.fj?.workType || null;
+      status = view.fj?.status || 'unknown';
+      phase = derivePhaseFrom(view.fj, (rel) => view.files.has(rel));
+      pendingGates = pendingGatesFrom(view.fj);
+    } else {
+      const fj = getFeature(feature, path);
+      workType = fj?.workType || null;
+      status = fj?.status || 'unknown';
+      phase = derivePhaseForFeature(feature, path);
+      pendingGates = getPendingGates(feature, path);
+    }
   } catch { /* field-level fail-open */ }
 
   const featureDir = join(path, '.morph', 'features', feature);
@@ -87,13 +278,19 @@ function buildEntry(feature, { location, path, branch, root, allocations, blockS
     location,
     path,
     branch,
-    tasks: taskCounts(featureDir),
+    tasks: taskCounts(featureDir, { root, feature, featureBranch }),
     env: alloc && Number.isInteger(alloc.base)
       ? { base: alloc.base, range: [alloc.base, alloc.base + blockSize - 1] }
       : null,
     handoff: handoffInfo(featureDir),
     lastCommit: location === 'worktree' && branch ? lastCommitRelative(root, branch) : null,
     dirty: location === 'worktree' ? dirtyCount(path) : null,
+    remote: buildRemote(feature, branch, heads, prs),
+    // Advisory ownership (B1): which session is on this feature right now.
+    // `live` is what matters for the operator — a stale claim is reported as
+    // stale rather than hidden, so "nobody is here" and "somebody died here"
+    // stay distinguishable.
+    claim: claims?.[feature] || null,
   };
 }
 
@@ -110,15 +307,24 @@ export function scanFleet(cwd = process.cwd()) {
   const root = resolvePrimaryRoot(cwd);
 
   let allocations = {};
+  const claims = {};
   try {
     const common = execSync('git rev-parse --git-common-dir', { cwd: root, stdio: 'pipe' }).toString().trim();
     if (common) {
-      const reg = JSON.parse(readFileSync(registryPath(resolve(root, common)), 'utf8'));
-      if (reg && typeof reg.allocations === 'object' && reg.allocations !== null) allocations = reg.allocations;
+      const gitCommonDir = resolve(root, common);
+      try {
+        const reg = JSON.parse(readFileSync(registryPath(gitCommonDir), 'utf8'));
+        if (reg && typeof reg.allocations === 'object' && reg.allocations !== null) allocations = reg.allocations;
+      } catch { /* no env registry yet — env stays null per entry */ }
+      for (const c of listClaims(gitCommonDir)) claims[c.feature] = c;
     }
-  } catch { /* no registry yet — env stays null per entry */ }
+  } catch { /* no common dir — env and claim both stay null per entry */ }
   const { blockSize } = resolveFleetConfig(root);
 
+  // Remote awareness, resolved ONCE for the whole scan (see remoteHeads/remotePrs).
+  const heads = remoteHeads(root);
+  const prs = heads ? remotePrs(root) : null;
+
   const entries = [];
   const inWorktree = new Set();
 
@@ -133,6 +339,9 @@ export function scanFleet(cwd = process.cwd()) {
       root,
       allocations,
       blockSize,
+      heads,
+      prs,
+      claims,
     }));
   }
 
@@ -146,7 +355,7 @@ export function scanFleet(cwd = process.cwd()) {
         .filter((name) => !inWorktree.has(name) && existsSync(join(featuresDir, name, 'feature.json')));
       for (const name of names) {
         entries.push(buildEntry(name, {
-          location: 'root', path: root, branch: null, root, allocations, blockSize,
+          location: 'root', path: root, branch: null, root, allocations, blockSize, heads, prs, claims,
         }));
       }
     }