@sabaiway/agent-workflow-kit 12.0.0 → 12.1.0

package/references/modes/bridge-settings.md

@@ -8,7 +8,7 @@ The reader + consent-gated **writer** for the **host-level** bridge settings fil
 
 | key | bridge | values | note |
 |---|---|---|---|
-| `CODEX_SERVICE_TIER` | codex | `priority` | **SPEND KNOB** — the "Fast" tier: ~1.5× token speed at a **2.5× credit rate** on gpt-5.6-sol, quality-neutral (same model). Default unset ⇒ standard tier. |
+| `CODEX_SERVICE_TIER` | codex | `priority` | **SPEND KNOB** — the "Fast" tier: "2x speed, **increased usage**" in the codex catalog's own words for gpt-6-astra (cache fetched 2026-09-05); it states no credit-rate figure; quality-neutral (same model). Default unset ⇒ standard tier. |
 | `CODEX_HARD_TIMEOUT` | codex | integer `1..86400` | hard wall-clock cap (seconds) via `timeout(1)`. |
 | `CODEX_REVIEW_MAX_TOTAL_BYTES` | codex | integer `1..100000000` | codex-review payload size above which the diff rides a temp file (never truncated). |
 | `AGY_HARD_TIMEOUT` | agy | duration `5m`/`30m`/`90s` (unit required, nonzero) | hard wall-clock cap via `timeout(1)`. |
@@ -25,7 +25,7 @@ The reader + consent-gated **writer** for the **host-level** bridge settings fil
 
 **Refusals (the guarded contract):** an **unknown key** or an **invalid / out-of-range value** → exit `2` (nothing read of the file, nothing written). A file that already carries **duplicate keys** → exit `1`, named and left **byte-untouched** (fix the duplicates by hand first — the writer never edits blindly around them). A **symlinked / non-regular / unreadable** settings file → exit `1` (refuses to write through it). `--apply` with `--dry-run`, a duplicate op for one key, or a malformed `--set` → usage exit `2`.
 
-**Spend consent (D4):** enabling `CODEX_SERVICE_TIER=priority` costs a **2.5× credit rate** — a per-host, consented act, never a default. The preview shows the caveat (from the manifest `effect`); confirm with the user before `--apply`. The tool also warns when an env var currently shadows the key you are writing (the env value wins for that session until unset).
+**Spend consent (D4):** enabling `CODEX_SERVICE_TIER=priority` costs **increased usage** (the catalog states no credit-rate figure) — a per-host, consented act, never a default. The preview shows the caveat (from the manifest `effect`); confirm with the user before `--apply`. The tool also warns when an env var currently shadows the key you are writing (the env value wins for that session until unset).
 
 Output is **English/structured** — **localize it to the user's conversational language** when you narrate.
 

package/references/modes/now.md

@@ -0,0 +1,30 @@
+### Mode: now
+
+<!-- opt-in-capability: none — an inspection surface that configures nothing -->
+
+Read-only. The single answer to where the work stands. It writes no file, cache, receipt, lock or git state; it never commits and never runs a subscription CLI.
+
+Run `node ${CLAUDE_SKILL_DIR}/tools/now-cli.mjs --dir <project> --json`. For a direct terminal render, use `--format=plain|ansi|json`; `--json` is strict sugar for `--format=json`.
+
+Render the returned envelope compactly in the user's conversational language. Never paste the JSON and never expose an internal field name. Preserve every fact, evidence label, annotation and withheld cause while translating only the prose around source-language commands, paths and identifiers.
+
+The four blocks keep this order:
+
+1. **NOW** — every plan in flight, its derived phase, current and next step, then the tree fingerprint, clean state, review verdict lines, final run and red-proof currency. No plan and several plans are rendered states; never pick one silently.
+2. **STEPS** — every ledger row with one of `landed`, `in progress`, `pending` or `unjudged`. The rows are the steps; invent no numbering.
+3. **QUEUE** — every work-carrying row (live, parked, ambiguous) under the full line-numbered heading path it carries, with per-class counts covering every row of the bucket, terminal and record included, and names rather than ids. Only a path through `## Pending / backlog` calls its position priority; every other bucket is archive and calls it position.
+4. **CAMPAIGN** — source-size config state (`absent`, `authored`, `incomplete`, `minted`), caps, roots, recorded over-cap files and aggregate lines. An absent opt-in config is a rendered state.
+
+Evidence alone sets a ledger status: the row's path and verb, then the path fact, changed set and exclusion fact. The plan's prose never sets a status. A checked box or terminal marker is only a claim; when evidence contradicts it, print the claim beside the evidence-derived status. Keep anomaly and current red-proof annotations beside the same status too. Every status line names its evidence source.
+
+A block that cannot be derived is `WITHHELD` and prints its cause on one line. NOW has two halves, plans and tree, each independently a value or `WITHHELD`; NOW itself is `WITHHELD` only when both are. Render every other block normally.
+
+Exit codes:
+
+| Code | Meaning |
+|------|---------|
+| 0 | Anything rendered, including default states, contradictions and a WITHHELD block. |
+| 1 | Nothing rendered: every block withheld, each cause printed on stderr; the usual cause is a `--dir` that is not a git work tree. |
+| 2 | Usage: an unknown flag, an invalid or missing value, conflicting `--json` / `--format`, or `--help` combined with anything. |
+
+**Invariants:** read-only · the plan's prose never sets status · evidence is shown beside every status · compact user-language render with no JSON or internal field names · `process.exitCode`, never `process.exit()`.

package/tools/bridge-settings.mjs

@@ -273,7 +273,7 @@ export const main = (argv = [], ctx = {}) => {
     const body = joinLines(newLines);
 
     // The machine surface carries the SAME spend/credit-rate caveats the human preview prints (D4) — a
-    // --json consumer must not miss the 2.5x-credit consent warning the human render shows.
+    // --json consumer must not miss the spend consent warning the human render shows.
     const jsonBody = (wrote) => ({ path, wrote, noop, changes: changes.map((c) => ({ key: c.key, kind: c.kind, before: c.before, after: c.after })), envShadows, caveats });
 
     if (!apply || noop) {

package/tools/commands.mjs

@@ -84,6 +84,13 @@ const CATALOG = [
     kind: READ_ONLY,
     oneLine: 'Show what is installed and at what version, your settings and backends, and what is deployed in this project.',
   },
+  {
+    key: 'now',
+    invocation: invocationOf('now'),
+    group: 'Inspect',
+    kind: READ_ONLY,
+    oneLine: 'Show where work stands: NOW answers the plan and tree, STEPS the evidence-derived ledger state, QUEUE its named positions, and CAMPAIGN its size-practice figures; the plan’s own text never sets a status.',
+  },
   {
     key: 'backends',
     invocation: invocationOf('backends'),

package/tools/feedback-record.mjs

@@ -18,7 +18,11 @@ const NOTES_HEADING = '## Notes';
 const TABLE_HEADER = '| # | Claim | Evidence | Verdict | Disposition |';
 const OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/iu;
 const ANCHOR = /^`([^`,\s]+):([1-9][0-9]*)(?:-([1-9][0-9]*))?`$/u;
-const ROW_ID = '[A-Z0-9][A-Z0-9-]*';
+// The row id a checked record hands over, and the ONE home of that grammar: the queue's name
+// judge reads it back for the EXPLICITLY marked form (`— id <ID>`), so every id this writer may
+// legally emit round-trips through the judge — including `FOO`, `TASK-123` and `1-TASK`, which
+// the judge's own heuristic deliberately does not read unmarked.
+export const ROW_ID = '[A-Z0-9][A-Z0-9-]*';
 const QUEUE = new RegExp(`^queue (${ROW_ID})$`, 'u');
 const ALREADY_QUEUED = new RegExp(`^already-queued (${ROW_ID})$`, 'u');
 const REASONED_DISPOSITION = /^(?:declined|folded): (.+)$/u;
@@ -227,7 +231,7 @@ export const renderRows = (record, { date, recordPath }) => {
   return ids.map((id) => {
     const claims = record.claims.filter((claim) => QUEUE.exec(claim.disposition)?.[1] === id);
     return [
-      `- [ ] ${id}: ${claims[0].claim} (${date})`,
+      `- [ ] ${claims[0].claim} — id ${id} (${date})`,
       ...claims.map((claim) => `  - ${claim.claim}; verdict ${claim.verdict}; evidence ${claim.anchors.map(rendersAnchor).join(', ')}`),
       `  - record: ${recordPath}`,
       `  - head: ${record.head}`,

package/tools/now-cli.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+// The CLI half of `now`: argv, the io seam and the pipeline. The rules live in now-status.mjs, the
+// facts in now-facts.mjs, the phrases in now-render.mjs.
+
+import { resolve } from 'node:path';
+import { fail } from '../references/scripts/markdown-blocks.mjs';
+import { isDirectRun } from './direct-run.mjs';
+import { FORMATS, detectSurface } from './surface.mjs';
+import { gatherNowFacts } from './now-facts.mjs';
+import { isWithheld } from './now-status.mjs';
+import { renderNow, toNowViewModel } from './now-render.mjs';
+
+const BLOCKS = Object.freeze(['now', 'steps', 'queue', 'campaign']);
+const SCHEMA = 1;
+const FORMAT_FLAG = '--format=';
+const HELP = `now — read-only: where the work stands, in four blocks.
+
+Usage:
+  node now-cli.mjs [--dir <project>] [--format=<${FORMATS.join('|')}>] [--json]
+
+--dir     the project to read (default: the current directory).
+--format  the output surface; --json is strict sugar for --format=json, and naming both with
+          different values is usage.
+--help    answered only when it is the whole invocation.
+
+Blocks: NOW (the plans in flight, the phase, the current and the next step, the tree), STEPS (the
+ledger rows, one status each), QUEUE (the backlog folded under each row's heading path), CAMPAIGN
+(the size practice). A block that cannot be derived is WITHHELD with its cause on one line.
+
+A status is a function of the row's (path, verb) pair and the evidence at that path; the row's prose
+is printed as a claim beside a status it never moves.
+
+Exit codes: 0 anything rendered, a withheld block included; 1 nothing rendered at all (a --dir that
+is not a git work tree); 2 usage.
+
+Reads only: no store, no receipt, no cache, no lock.`;
+
+const valueAt = (argv, index, flag) => {
+  const value = argv[index + 1];
+  if (value === undefined || value === '' || value.startsWith('-')) throw fail(2, `${flag} takes a value`);
+  return value;
+};
+
+export const parseArgv = (argv) => {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    if (argv.length !== 1) throw fail(2, '--help is answered only when it is the whole invocation');
+    return { help: true, dir: null, formats: [] };
+  }
+  const parsed = argv.reduce((state, arg, index) => {
+    if (state.skip) return { ...state, skip: false };
+    if (arg === '--dir') return { ...state, dir: valueAt(argv, index, arg), skip: true };
+    if (arg === '--format') return { ...state, formats: [...state.formats, valueAt(argv, index, arg)], skip: true };
+    if (arg.startsWith(FORMAT_FLAG)) return { ...state, formats: [...state.formats, arg.slice(FORMAT_FLAG.length)] };
+    if (arg === '--json') return { ...state, formats: [...state.formats, 'json'], json: true };
+    throw fail(2, `unknown argument "${arg}" — run with --help`);
+  }, { help: false, dir: null, formats: [], json: false, skip: false });
+  if (parsed.json && parsed.formats.some((format) => format !== 'json')) {
+    throw fail(2, '--json is strict sugar for --format=json — naming both with different values is usage');
+  }
+  return parsed;
+};
+
+const resolveSurface = (formats, env, io) => detectSurface({
+  argv: formats.map((format) => `${FORMAT_FLAG}${format}`),
+  env,
+  isTTY: io.isTTY ?? Boolean(process.stdout.isTTY),
+  columns: io.columns ?? process.stdout.columns,
+  platform: io.platform ?? process.platform,
+});
+
+const toEnvelope = (dir, vm) => ({ schema: SCHEMA, command: 'now', dir, ...vm });
+
+export const main = (argv, io = {}) => {
+  const log = io.log ?? console.log;
+  const error = io.error ?? console.error;
+  const env = io.env ?? process.env;
+  const start = (() => {
+    try {
+      const options = parseArgv(argv);
+      return options.help ? { help: true } : { options, surface: resolveSurface(options.formats, env, io) };
+    } catch (err) {
+      error(err?.message ?? String(err));
+      return { code: err?.exitCode ?? 2 };
+    }
+  })();
+  if (start.code !== undefined) return start.code;
+  if (start.help) {
+    log(HELP);
+    return 0;
+  }
+  const cwd = resolve(io.cwd ?? process.cwd(), start.options.dir ?? '.');
+  // The composed readers spawn git under process.env alone, so the flag must reach them there too.
+  process.env.GIT_OPTIONAL_LOCKS = '0';
+  const vm = toNowViewModel(gatherNowFacts({ cwd, env: { ...env, GIT_OPTIONAL_LOCKS: '0' } }));
+  const blocks = BLOCKS.map((name) => vm[name]);
+  if (blocks.every(isWithheld)) {
+    for (const cause of new Set(blocks.map(({ withheld }) => withheld))) error(cause);
+    return 1;
+  }
+  log(start.surface.mode === 'json' ? JSON.stringify(toEnvelope(cwd, vm), null, 2) : renderNow(vm, start.surface));
+  return 0;
+};
+
+if (isDirectRun(import.meta.url)) process.exitCode = main(process.argv.slice(2));

package/tools/now-facts.mjs

@@ -0,0 +1,67 @@
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { buildSummaryState, isTreeClean } from './core-evidence.mjs';
+import { readRegularFileNoFollow } from './fs-read-nofollow.mjs';
+import { resolveGitLocation } from './git-env.mjs';
+import { auditQueue } from './queue-audit.mjs';
+import { loadSourceSizeConfig, practiceFacts } from './source-size-config.mjs';
+import { gatherPlanFacts, readSummaryFacts } from './now-plan-facts.mjs';
+import { isWithheld } from './now-status.mjs';
+
+const QUEUE_REL = 'docs/plans/queue.md';
+const BLOCKS = Object.freeze(['plans', 'tree', 'queue', 'campaign']);
+
+const attempt = (label, read) => {
+  try {
+    return read();
+  } catch (error) {
+    return { withheld: `${label}: ${error?.message ?? error}` };
+  }
+};
+
+const readQueueFacts = (cwd, deps) => {
+  const read = readRegularFileNoFollow(join(cwd, QUEUE_REL), deps.io ?? {});
+  if (read.outcome !== 'ok') throw new Error(`${QUEUE_REL} is not a readable regular file (${read.className ?? read.code ?? read.outcome})`);
+  const { rows, counts, total } = auditQueue(read.content, { label: QUEUE_REL });
+  return { path: QUEUE_REL, rows, counts, total };
+};
+
+// The practice is opt-in: an absent declaration is a rendered STATE, only an unreadable one is withheld.
+const readCampaignFacts = (cwd, deps) => {
+  const loaded = loadSourceSizeConfig(cwd, deps);
+  return loaded.state === 'absent' ? { state: loaded.state } : { state: loaded.state, ...practiceFacts(loaded.config) };
+};
+
+// A store the summary cannot trust never attests: the tree is withheld with the store's own cause.
+const describeUntrustedStore = (summary) => {
+  if (summary.evidenceUnavailable) return `the core-evidence store is malformed or unreadable (${summary.storeReadError ?? `${summary.storeMalformed} malformed line(s)`})`;
+  if (summary.receiptsUnavailable) return `the review receipts store is malformed or unreadable (${summary.receiptsReadError ?? `${summary.receiptsMalformed} malformed line(s)`})`;
+  return null;
+};
+
+const toTreeFacts = (summary, clean) => {
+  const untrusted = describeUntrustedStore(summary);
+  if (untrusted) return { withheld: untrusted };
+  const { redProofs, receipts } = readSummaryFacts(summary);
+  return { fingerprint: summary.fingerprint, clean, verdicts: receipts.verdicts, finalRun: receipts.finalRun, redProofs };
+};
+
+export const gatherNowFacts = ({ cwd, env: given = process.env, deps = {} }) => {
+  // Every reader honouring an env argument spawns under this one: a plain `git diff` rewrites .git/index without the flag.
+  const env = { ...given, GIT_OPTIONAL_LOCKS: '0' };
+  const location = resolveGitLocation(cwd, { spawn: deps.spawn ?? spawnSync, env });
+  if (location.state !== 'work-tree') {
+    const withheld = `${cwd} is not a git work tree (${location.state}: ${location.cause})`;
+    return Object.fromEntries(BLOCKS.map((block) => [block, { withheld }]));
+  }
+  const root = location.top;
+  const summary = attempt('the evidence summary', () => deps.summary ?? buildSummaryState({ cwd: root, env }));
+  return {
+    plans: attempt('the plans in flight', () => ({
+      entries: gatherPlanFacts({ cwd: root, env, deps }).plans,
+    })),
+    tree: isWithheld(summary) ? summary : attempt('the tree state', () => toTreeFacts(summary, isTreeClean(root, { env }))),
+    queue: attempt('the queue', () => readQueueFacts(root, deps)),
+    campaign: attempt('the practice', () => readCampaignFacts(root, deps)),
+  };
+};

package/tools/now-plan-facts.mjs

@@ -0,0 +1,129 @@
+import { spawnSync } from 'node:child_process';
+import { join, posix } from 'node:path';
+import { computeWorkingState, coverageQualifierFor, describeMissingReviewAttestation } from './core-evidence.mjs';
+import { readRegularFileNoFollow } from './fs-read-nofollow.mjs';
+import { GIT_MAX_BUFFER, stripGitLocationEnv, withGitPath } from './git-env.mjs';
+import { PLANS_REL, plansInFlight } from './plan-files.mjs';
+import { isSweep, parseLedger, unique } from './plan-shape.mjs';
+import { buildFacts, expandPatterns } from './plan-shape-facts.mjs';
+
+const VERIFICATION = '## Verification';
+const NUL = String.fromCharCode(0);
+const STAGED_ARGV = Object.freeze(['diff', '--cached', '--name-only', '-z', '--no-renames']);
+const IGNORE_ARGV = Object.freeze(['check-ignore', '-z', '--stdin']);
+
+const detailOf = (result) => {
+  const stderr = String(result.stderr ?? '').trim();
+  return stderr ? ` (${stderr})` : '';
+};
+
+// Every spawn outcome is named — an error, a signal, an unaccepted status, a throw — never an empty success read as "nothing is staged".
+export const readGitPaths = (argv, { cwd, env, spawn = spawnSync, input, accept = [0] }) => {
+  const label = `git ${argv[0]}`;
+  const runEnv = withGitPath({ ...stripGitLocationEnv(env), LC_ALL: 'C', GIT_OPTIONAL_LOCKS: '0' });
+  const result = (() => {
+    try {
+      return spawn('git', argv, { cwd, env: runEnv, input, maxBuffer: GIT_MAX_BUFFER, windowsHide: true });
+    } catch (error) {
+      throw new Error(`${label} threw synchronously (${error?.message ?? error})`);
+    }
+  })();
+  if (result === null || typeof result !== 'object') throw new Error(`${label} returned no result`);
+  if (result.error) throw new Error(`${label} could not run (${result.error.code ?? result.error.message ?? result.error})`);
+  if (result.signal) throw new Error(`${label} was killed by ${result.signal}`);
+  if (!accept.includes(result.status)) throw new Error(`${label} exited ${result.status}${detailOf(result)}`);
+  return String(result.stdout ?? '').split(NUL).filter(Boolean);
+};
+
+const refused = (path, parseError) => ({ path, parsed: null, parseError, rows: [] });
+
+const readPlanEntry = (cwd, name) => {
+  const path = `${PLANS_REL}/${name}`;
+  const read = readRegularFileNoFollow(join(cwd, PLANS_REL, name));
+  if (read.outcome !== 'ok') return refused(path, `${path} is not a readable regular file (${read.className ?? read.code ?? read.outcome})`);
+  try {
+    const parsed = parseLedger(read.content);
+    const verification = parsed.document.headings.find(({ text }) => text === VERIFICATION);
+    return verification
+      ? { path, parsed, parseError: null, rows: [] }
+      : refused(path, `${path} carries no "${VERIFICATION}" heading, so its ledger cannot be located`);
+  } catch (error) {
+    return refused(path, `${path} cannot be parsed (${error?.message ?? error})`);
+  }
+};
+
+const describeCurrency = ({ state, detail }) => detail ? `${state} (${detail})` : state;
+const toVerdict = ({ backend, summary }) => {
+  const missing = describeMissingReviewAttestation(summary);
+  return { backend, line: `${backend}: ${missing ?? `${summary.receipt.verdict} (attesting, ${summary.receipt.timestamp})`}` };
+};
+
+const describeFinalRun = (record) => {
+  if (!record) return null;
+  const qualifier = coverageQualifierFor(record);
+  return {
+    status: String(record.status).toUpperCase(),
+    gates: Array.isArray(record.results) ? `${record.results.filter(({ ok }) => ok === true).length}/${record.results.length}` : 'unknown',
+    fingerprintBefore: record.fingerprintBefore,
+    timestamp: record.timestamp,
+    coverage: qualifier ? qualifier.replace(/^ \u2014 /, '') : `coverage=${record.coverage ?? 'unknown'}`,
+  };
+};
+
+// The summary's review half, mapped ONCE: the tree block and the per-row red-proof annotation read the same records.
+export const readSummaryFacts = (summary) => ({
+  redProofs: summary.redProofs.map((record) => ({ path: record.file, currency: describeCurrency(record.currency) })),
+  receipts: { path: summary.receiptsPath, verdicts: summary.verdicts.map(toVerdict), finalRun: describeFinalRun(summary.finalRun) },
+});
+
+// A sweep row is judged as a SET: presence from the expansion on disk, each changed-set flag from the glob over that FULL git set (a deleted member still counts), exclusion only when every member is excluded.
+// git names a path in one spelling; a ledger may write `./src/a.mjs` or `src//a.mjs`, so every lookup uses the canonical form.
+const canonical = (path) => posix.normalize(path).replace(/\/$/, '');
+const matchesAny = (pattern, paths) => expandPatterns(paths, [pattern])[pattern].length > 0;
+const sweepEvidenceFor = (pattern, expansions, sets) => {
+  const members = expansions[pattern] ?? [];
+  return {
+    pathFact: members.length > 0 ? { kind: 'sweep', members: members.length } : { kind: 'absent' },
+    staged: matchesAny(pattern, sets.staged),
+    unstaged: matchesAny(pattern, sets.unstaged),
+    untracked: matchesAny(pattern, sets.untracked),
+    excluded: members.length > 0 && members.every((member) => sets.excluded.includes(member)),
+  };
+};
+// `path` is the canonical form every reader of the row's evidence keys on; a row the ledger grammar refused carries none.
+const hasPath = (row) => typeof row.path === 'string' && row.path.length > 0;
+const evidenceFor = (row, pathFacts, expansions, sets) => {
+  if (!hasPath(row)) return { path: null, pathFact: null, staged: false, unstaged: false, untracked: false, excluded: false };
+  const path = canonical(row.path);
+  if (isSweep(path)) return { path, ...sweepEvidenceFor(path, expansions, sets) };
+  return {
+    path,
+    pathFact: pathFacts[path] ?? null,
+    staged: sets.staged.includes(path),
+    unstaged: sets.unstaged.includes(path),
+    untracked: sets.untracked.includes(path),
+    excluded: sets.excluded.includes(path),
+  };
+};
+
+export const gatherPlanFacts = ({ cwd, env = process.env, deps = {} }) => {
+  const entries = plansInFlight(cwd, deps.readdir).map((name) => readPlanEntry(cwd, name));
+  const ledgerPaths = unique(entries.flatMap(({ parsed }) => (parsed ? parsed.rows : []))
+    .filter(hasPath)
+    .map(({ path }) => canonical(path)));
+  const { pathFacts, expansions } = buildFacts(cwd, { paths: ledgerPaths });
+  const concretePaths = unique([...ledgerPaths.filter((path) => !isSweep(path)), ...Object.values(expansions).flat()]);
+  const working = computeWorkingState(cwd, { env });
+  if (working === null) throw new Error(`the working state of ${cwd} is not decidable`);
+  const staged = readGitPaths(STAGED_ARGV, { cwd, env, spawn: deps.spawn });
+  const excluded = concretePaths.length === 0
+    ? []
+    : readGitPaths(IGNORE_ARGV, { cwd, env, spawn: deps.spawn, accept: [0, 1], input: `${concretePaths.join(NUL)}${NUL}` });
+  const changed = { staged, unstaged: working.unstagedPaths, untracked: working.untrackedPaths };
+  const sets = { staged, unstaged: changed.unstaged, untracked: changed.untracked, excluded };
+  const plans = entries.map((entry) => ({
+    ...entry,
+    rows: (entry.parsed?.rows ?? []).map((row) => ({ row, raw: row.raw, evidence: evidenceFor(row, pathFacts, expansions, sets) })),
+  }));
+  return { plans, pathFacts, changed, excluded };
+};

package/tools/now-render.mjs

@@ -0,0 +1,162 @@
+import { glyphsFor } from './presentation.mjs';
+import { visibleLength } from './renderers.mjs';
+import { foldQueue, isWithheld, judgeRow, derivePhase } from './now-status.mjs';
+
+const BLOCK_TITLE = Object.freeze({ now: 'NOW', steps: 'STEPS', queue: 'QUEUE', campaign: 'CAMPAIGN' });
+const STATUS_GLYPH = Object.freeze({
+  landed: 'present',
+  'in progress': 'note',
+  pending: 'missing',
+  unjudged: 'unknown',
+});
+const SGR = Object.freeze({ bold: '\x1b[1m', reset: '\x1b[0m' });
+
+const getHeading = (title, color) => color ? `${SGR.bold}${title}${SGR.reset}` : title;
+const getStepName = (step) => step?.row ? `${step.row.id} · ${step.row.path}` : step?.name ?? 'none';
+const getRedProof = (tree, path) => isWithheld(tree) ? null : tree.redProofs.find((proof) => proof.path === path) ?? null;
+
+const getPlanView = (plan, tree) => {
+  if (!plan.parsed) return { path: plan.path, parseError: plan.parseError, phase: null, rows: [] };
+  const rows = plan.rows.map(({ row, raw, evidence }) => judgeRow({ ...row, raw }, {
+    ...evidence,
+    redProof: getRedProof(tree, evidence.path),
+  }));
+  return { path: plan.path, parseError: plan.parseError, phase: derivePhase(plan.parsed, rows), rows };
+};
+
+const getPhaseMarker = (step) => step?.row
+  ? { row: { id: step.row.id, path: step.row.path } }
+  : step ? { name: step.name } : null;
+const getPhaseView = (phase) => ({
+  name: phase.name,
+  current: getPhaseMarker(phase.current),
+  next: getPhaseMarker(phase.next),
+  inProgress: phase.inProgress,
+});
+
+const getPlanBlocks = (plans, tree) => {
+  if (isWithheld(plans)) return { plans: plans, steps: plans };
+  const entries = plans.entries.map((plan) => getPlanView(plan, tree));
+  return {
+    plans: { entries: entries.map(({ path, parseError, phase }) => ({ path, parseError, phase: phase ? getPhaseView(phase) : null })) },
+    steps: { entries: entries.map(({ path, parseError, rows }) => ({ path, parseError, rows })) },
+  };
+};
+
+export const toNowViewModel = (facts) => {
+  const planBlocks = getPlanBlocks(facts.plans, facts.tree);
+  const plans = isWithheld(planBlocks.plans) ? planBlocks.plans : planBlocks.plans.entries;
+  const tree = isWithheld(facts.tree) ? facts.tree : { ...facts.tree };
+  const now = isWithheld(plans) && isWithheld(tree)
+    ? { withheld: [...new Set([plans.withheld, tree.withheld])].join(' \u00b7 ') }
+    : { plans, tree };
+  const queue = isWithheld(facts.queue)
+    ? facts.queue
+    : { path: facts.queue.path, ...foldQueue(facts.queue.rows) };
+  return { now, steps: planBlocks.steps, queue, campaign: isWithheld(facts.campaign) ? facts.campaign : { ...facts.campaign } };
+};
+
+const getWithheldLines = (title, block, color) => [getHeading(title, color), `${title} — WITHHELD: ${block.withheld}`];
+const getAnnotationText = (annotation) => annotation.kind === 'red-proof'
+  ? `red-proof ${annotation.text}`
+  : annotation.text;
+const getStatusTail = (step) => {
+  const detail = step.detail ? ` (${step.detail})` : '';
+  const annotations = step.annotations.map((annotation) => ` (${getAnnotationText(annotation)})`).join('');
+  return ` [${step.evidenceSource}]${detail}${annotations}`;
+};
+
+const renderNowBlock = (block, color, glyph) => {
+  if (isWithheld(block)) return getWithheldLines(BLOCK_TITLE.now, block, color);
+  const lines = [getHeading(BLOCK_TITLE.now, color)];
+  if (isWithheld(block.plans)) lines.push(`  plans \u2014 WITHHELD: ${block.plans.withheld}`);
+  else if (block.plans.length === 0) lines.push('  no plan in flight');
+  for (const plan of isWithheld(block.plans) ? [] : block.plans) {
+    lines.push(`  plan: ${plan.path}`);
+    if (plan.parseError) {
+      lines.push(`    ${glyph.unknown} could not parse: ${plan.parseError}`);
+      continue;
+    }
+    lines.push(`    phase: ${plan.phase.name}`);
+    lines.push(`    current: ${getStepName(plan.phase.current)}`);
+    lines.push(`    next: ${getStepName(plan.phase.next)}`);
+    for (const step of plan.phase.inProgress) lines.push(`    ${glyph.note} in progress: ${getStepName(step)} — ${step.status}${getStatusTail(step)}`);
+  }
+  const tree = block.tree;
+  if (isWithheld(tree)) {
+    lines.push(`  tree \u2014 WITHHELD: ${tree.withheld}`);
+    return lines;
+  }
+  const clean = tree.clean === null ? 'unknown' : tree.clean ? 'clean' : 'changed';
+  lines.push(`  tree: ${tree.fingerprint} · ${clean}`);
+  for (const verdict of tree.verdicts) lines.push(`    ${glyph.note} ${verdict.line}`);
+  lines.push(tree.finalRun
+    ? `    final run: ${tree.finalRun.status} ${tree.finalRun.gates} gates · ${tree.finalRun.fingerprintBefore} · ${tree.finalRun.timestamp} · ${tree.finalRun.coverage}`
+    : '    final run: none');
+  for (const proof of tree.redProofs) lines.push(`    red-proof: ${proof.path} · ${proof.currency}`);
+  return lines;
+};
+
+const renderStepsBlock = (block, color, glyph) => {
+  if (isWithheld(block)) return getWithheldLines(BLOCK_TITLE.steps, block, color);
+  const lines = [getHeading(BLOCK_TITLE.steps, color)];
+  if (block.entries.length === 0) lines.push('  no steps — no plan in flight');
+  for (const plan of block.entries) {
+    lines.push(`  plan: ${plan.path}`);
+    if (plan.parseError) {
+      lines.push(`    WITHHELD: ${plan.parseError}`);
+      continue;
+    }
+    for (const step of plan.rows) {
+      lines.push(`    ${glyph[STATUS_GLYPH[step.status]]} ${getStepName(step)} — ${step.status}${getStatusTail(step)}`);
+    }
+  }
+  return lines;
+};
+
+const renderQueueBlock = (block, color) => {
+  if (isWithheld(block)) return getWithheldLines(BLOCK_TITLE.queue, block, color);
+  const counts = Object.entries(block.counts).map(([klass, count]) => `${klass} ${count}`).join(' · ');
+  const lines = [getHeading(BLOCK_TITLE.queue, color), `  ${block.path} · ${block.total} rows · ${counts}`];
+  for (const bucket of block.buckets) {
+    const domain = bucket.order === 'priority' ? 'priority' : 'archive';
+    const bucketCounts = Object.entries(bucket.counts).map(([klass, count]) => `${klass} ${count}`).join(' · ');
+    lines.push(`  ${domain} · ${bucket.label} · ${bucketCounts}`);
+    for (const row of bucket.rows) lines.push(`  ${domain} · ${bucket.label} · ${bucket.order} ${row.position}: ${row.name} — ${row.klass}`);
+  }
+  return lines;
+};
+
+const getFigure = (value) => value === null || value === undefined ? 'not recorded' : String(value);
+const renderCampaignBlock = (block, color) => {
+  if (isWithheld(block)) return getWithheldLines(BLOCK_TITLE.campaign, block, color);
+  const lines = [getHeading(BLOCK_TITLE.campaign, color), `  state: ${block.state}`];
+  if (block.state !== 'absent') {
+    lines.push(`  caps: ${block.maxLines} lines · ${block.maxLineBytes} bytes per line`);
+    lines.push(`  roots: ${block.roots} · recorded files: ${getFigure(block.recordedFiles)} · aggregate lines: ${getFigure(block.aggregateLines)}`);
+  }
+  return lines;
+};
+
+const padLine = (line, width) => {
+  const visible = visibleLength(line);
+  return line === '' || visible >= width ? line : line + ' '.repeat(width - visible);
+};
+
+export const renderNow = (vm, surface = {}) => {
+  if (surface.mode === 'json') return '';
+  const color = surface.mode === 'ansi' && Boolean(surface.color);
+  const glyph = glyphsFor(Boolean(surface.ascii));
+  const lines = [
+    ...renderNowBlock(vm.now, color, glyph),
+    '',
+    ...renderStepsBlock(vm.steps, color, glyph),
+    '',
+    ...renderQueueBlock(vm.queue, color),
+    '',
+    ...renderCampaignBlock(vm.campaign, color),
+  ];
+  return surface.mode === 'ansi'
+    ? lines.map((line) => padLine(line, surface.width ?? 80)).join('\n')
+    : lines.join('\n');
+};