@cspeach/cli 1.1.48 → 1.1.49

package/dist/register/picture.js

@@ -1,14 +1,14 @@
 import path from 'node:path';
 import { buildRegister, narrowedLanes } from '@cspeach/register-core';
 import { collectRecords, readBaseline, readEstate, readLanes, readProjectFile } from './store.js';
-export function registerFor(projectDir, outboxDir) {
-    const project = readProjectFile(projectDir);
+/** `project`: the folder's project file when the caller has already read it (one read, one answer). */
+export function registerFor(projectDir, outboxDir, project = readProjectFile(projectDir)) {
     const collected = collectRecords(projectDir);
     // This laptop's own outbox counts too, so a developer sees their work before
     // handing it in. It is also the one way this picture can legitimately differ
     // from the team project page's, so `status` says out loud when it counted them.
     const own = outboxDir && path.resolve(outboxDir) !== path.resolve(projectDir) ? collectRecords(outboxDir) : { records: [], unreadable: 0, files: 0 };
-    const baseline = readBaseline(projectDir);
+    const baseline = readBaseline(projectDir, project);
     const lanes = readLanes(projectDir);
     // The newest discovery, when the folder holds one: the estate around the team project.
     const estate = readEstate(projectDir)?.estate;

package/dist/register/project-transport.js

@@ -0,0 +1,125 @@
+/**
+ * Task 8 (B11) — the project transport: the request a team or solo project
+ * records its fixes in. Asked once at the start (the journey's transport
+ * card, `team start --transport`) or set later by the lead (`team transport`),
+ * and stored in the project file as `transport: { request, by, at }`.
+ *
+ * `projectTransport(cwd)` is what the approval card and the modify/delete
+ * write tools read: the request of the project joined in THIS folder, or
+ * null. A folder without a project, a copy of one, a project file halfway
+ * through a sync, a value that is not a request number — all null, never a
+ * throw: there the write and the card behave exactly as before.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { RegisterError, TEAM_FILE, activeProject, readProjectFile } from './store.js';
+import { writeWhole } from './write-whole.js';
+/** A transport request number as SAP writes it: three letters or digits, K, six digits. */
+export const TRANSPORT_REQUEST = /^[A-Z0-9]{3}K\d{6}$/;
+/**
+ * The project transport in words, said in one place (Task 3): the journey's
+ * lines (indented, `journey/run.ts`) and `team status` (after the target
+ * lines) print these.
+ */
+export const TRANSPORT_NONE_WORDS = 'Transport: none yet (set it with: cspeach team transport <REQ>).';
+/** The journey's line for the request: "Transport: S4HK900123." */
+export const transportWords = (request) => `Transport: ${request}.`;
+/** `team status`: the request, and that it is the project's: "Transport: S4HK900123 (project)." */
+export const projectTransportWords = (request) => `Transport: ${request} (project).`;
+/** The plain line for a number that is not a request number (shown as typed, cut short). */
+export function notARequestLine(typed) {
+    const t = Array.from(typed.trim()).slice(0, 60).join('');
+    return `"${t}" is not a transport request number.`;
+}
+/**
+ * The same folder, said two ways (as commands/team-discover.ts samePath): on
+ * Windows case does not matter, and a trailing separator never does. Kept
+ * here so the register layer does not reach into the commands.
+ */
+function samePath(a, b) {
+    const norm = (p) => {
+        const r = path.resolve(p).replace(/[\\/]+$/, '');
+        return process.platform === 'win32' ? r.toLowerCase() : r;
+    };
+    return norm(a) === norm(b);
+}
+/** The request of the project joined in this folder, or null. Never throws. */
+export function projectTransport(cwd) {
+    try {
+        if (!cwd || !fs.existsSync(path.join(cwd, TEAM_FILE)))
+            return null;
+        const project = readProjectFile(cwd);
+        const joined = activeProject();
+        if (!joined || joined.projectId !== project.projectId || !samePath(joined.projectDir, cwd))
+            return null;
+        const t = project.transport;
+        const request = t && typeof t === 'object' ? t.request : undefined;
+        if (typeof request !== 'string')
+            return null;
+        const r = request.trim().toUpperCase();
+        return TRANSPORT_REQUEST.test(r) ? r : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The project request a write falls back to (one order for every write tool:
+ * owning lock ?? explicit ?? this ?? session). A plan-grant id stays held to
+ * its own transport claim (args or session), so it never takes it.
+ */
+export function projectTransportForWrite(ctx, payload) {
+    return payload?.grant ? undefined : projectTransport(ctx.cwd) ?? undefined;
+}
+/** The project request as a card and the footer say it: "S4HK903760 (project)". */
+export const projectRequestLabel = (request) => `${request} (project)`;
+/** The plan card's transport when its writes land in more than one request (each in the request its choice names). */
+export const SEVERAL_REQUESTS_LABEL = 'several requests (each change goes to the request that holds it)';
+/**
+ * Task 6 (project view, design §2 "Transport") — the ONE choice of the
+ * request a write goes to, for the approval card and for every write tool:
+ *   - modify / delete: owning lock ?? explicit ?? project ?? session;
+ *   - create: explicit ?? project ?? session (an owning lock is not a create's);
+ *   - activate / release / run: none (those take no transport).
+ * Each caller hands in the facts it uses today: a 'resolve' write
+ * (set_source, update_method, delete) passes no session request; a
+ * 'fallback-resolve' write (class include, messages) and text-elements pass
+ * it. The card for a modify/delete passes none. So in a project folder the
+ * card and every write agree (the project request comes before the session);
+ * outside one, a fallback-resolve or text-elements modify can write under the
+ * session request while its card names none — today's behaviour, kept (byte
+ * rule). Outside a project folder `project` is null and the order is today's.
+ */
+export function transportForWrite(i) {
+    // As the card and the writes always read them: a request named (explicit) or
+    // held for the session counts when it is there at all (??); an owning lock
+    // and the project request count only when they name one.
+    const pick = (from, request) => {
+        const there = from === 'owning' || from === 'project' ? !!request : request !== undefined && request !== null;
+        if (!there)
+            return null;
+        const r = request;
+        return { request: r, from, label: from === 'owning' ? `${r} (object already locked here)` : from === 'project' ? projectRequestLabel(r) : r };
+    };
+    const none = { request: undefined, from: 'none', label: undefined };
+    switch (i.op) {
+        case 'create':
+            return pick('explicit', i.explicit) ?? pick('project', i.project) ?? pick('session', i.session) ?? none;
+        case 'modify':
+        case 'delete':
+            return pick('owning', i.owning) ?? pick('explicit', i.explicit) ?? pick('project', i.project) ?? pick('session', i.session) ?? none;
+        default:
+            return none;
+    }
+}
+/**
+ * Set (or, with null, clear) the project transport. The whole project file is
+ * written, then renamed — a sync tool must never pick up half a project file.
+ */
+export function writeProjectTransport(projectDir, entry) {
+    if (entry && !TRANSPORT_REQUEST.test(entry.request))
+        throw new RegisterError(notARequestLine(entry.request));
+    const { transport: _old, ...rest } = readProjectFile(projectDir);
+    const next = entry ? { ...rest, transport: entry } : rest;
+    writeWhole(path.join(projectDir, TEAM_FILE), `${JSON.stringify(next, null, 2)}\n`);
+}

package/dist/register/records.js

@@ -113,7 +113,9 @@ export function decisionRowsFromCca(content, projectRoot) {
                 rows.set(key, {
                     key, classification: cls,
                     ...(['high', 'medium', 'low'].includes(confidence) ? { confidence: confidence } : {}),
-                    ...(typeof o?.classification?.evidence === 'string' ? { reason: o.classification.evidence.slice(0, 300) } : {}),
+                    // The assessment's words, never a person's (project view §3.2): no one said Yes to them.
+                    ...(typeof o?.classification?.evidence === 'string' && o.classification.evidence.trim()
+                        ? { reason: o.classification.evidence.slice(0, 300), reasonFrom: 'proposal' } : {}),
                 });
             }
         }
@@ -162,20 +164,25 @@ export function fixRowsFromUpgradeProgress(content, baseline) {
     }
     return { rows, ambiguous };
 }
+/** A "Rule <id>: " a reason starts with — written by the model (or an older record), so code takes it off. */
+const RULE_PREFIX = /^\s*rule\s+[A-Za-z0-9_-]{1,20}\s*:\s*/i;
+/** A reason without a leading "Rule <id>:". Rule ids belong to the rules, never inside a recorded reason (project view Task 4). */
+export const withoutRuleId = (reason) => reason.replace(RULE_PREFIX, '');
 /**
  * Decision rows from a saved clean-core triage — CONFIRMED rows only (one Yes
  * per row, clean-core-confirm.ts). The five words map onto the four
- * classifications (spec §4.2); a fix or a rebuild with no target reaches A.
+ * classifications (spec §4.2). Project view §3.2: a row names a target only
+ * when a person picked it (no default A), and its reason says whose words it
+ * is — the person's when the confirm code marked them so (`reasonBy`), else
+ * the proposal's.
  */
 export function decisionRowsFromCleanCore(content, 
 /**
- * Who said Yes, and when. With it, a confirmed row whose proposal NAMED the
- * level its target is read from — a fix/rebuild target, a keep/exception
- * level — carries `targetBy` (F3, M19): the person's Yes set that target.
- * A fix with no target in the proposal still records the legacy A, and that
- * is no target. Absent: rows exactly as before.
+ * Who said Yes, and when. With it, a confirmed row with a level carries
+ * `levelBy` (G8): the card showed that level and the person's Yes confirmed
+ * it. Absent: rows exactly as before.
  */
-by) {
+by, opts = {}) {
     const rows = [];
     for (const r of content.adjudications ?? []) {
         if (r?.confirmed !== true)
@@ -188,14 +195,18 @@ by) {
                         : r.disposition === 'retire' ? { classification: 'retire' } : null;
         if (!base)
             continue;
-        const reason = typeof r.reason === 'string' ? r.reason.trim().slice(0, 300) : '';
+        const key = objectKey(r.objectType, r.objectName);
+        const reason = typeof r.reason === 'string' ? withoutRuleId(r.reason).trim().slice(0, 300) : '';
         const named = moves ? !!r.targetLevel : base.classification === 'keep' && !!r.level;
+        const picked = by !== undefined && named && opts.personPicked?.has(key) === true;
         rows.push({
-            key: objectKey(r.objectType, r.objectName), ...base,
+            key, ...base,
             ...(r.level ? { level: r.level } : {}),
-            ...(moves ? { targetLevel: r.targetLevel ?? 'A' } : {}),
-            ...(reason ? { reason } : {}),
-            ...(by && named ? { targetBy: { name: by.name, at: by.at } } : {}),
+            ...(by && r.level ? { levelBy: { name: by.name, at: by.at } } : {}),
+            // A target only beside the person who picked it: the proposal's is no target.
+            ...(moves && picked && r.targetLevel ? { targetLevel: r.targetLevel } : {}),
+            ...(reason ? { reason, reasonFrom: r.reasonBy === 'person' ? 'person' : 'proposal' } : {}),
+            ...(picked ? { targetBy: { name: by.name, at: by.at } } : {}),
         });
     }
     return rows;
@@ -225,6 +236,7 @@ opts = {}) {
     }
     if (env.artefactType === 'clean-core-decision') {
         // Every row here had a person's Yes (confirmCleanCoreRows / the journey's row card).
+        // No `personPicked`: a target the model proposed is no target (decision 2).
         const at = (opts.now ?? new Date()).toISOString();
         const rows = decisionRowsFromCleanCore(env.content, { name: by.name, at });
         return writeRecord(joined, 'decision', rows, by, { source, ...opts, now: opts.now ?? new Date(at) });

package/dist/register/rules-edit.js

@@ -204,6 +204,11 @@ export const RULE_TEMPLATES = {
     'classic-program': {
         when: { types: ['PROG'], findingRules: ['SEARCH_PROBLEMATIC_STATEMENTS_FOR_ALV_CALLS'], targetAtMost: 'A' }, then: { disposition: 'rebuild' }, note: 'a classic list program cannot reach A in place',
     },
+    // Default rule R6 (project view design §7.2): the same words, for a project whose own rules lack it.
+    'classic-program-fix': {
+        when: { types: ['PROG'], minFindings: 1 }, then: { disposition: 'fix' },
+        note: 'a classic program is fixed in place; a rebuild is decided with a target of A (cspeach team target) or by the lead',
+    },
 };
 /** The next free "R<n>" after the highest one in use. */
 function nextId(rules) {

package/dist/register/status-file/progress-chart.js

@@ -22,6 +22,7 @@
  */
 import { esc } from './register-map.js';
 import { cell, dayWords, n, ownerLabel } from './register-parts.js';
+import { viewOf } from './register-model.js';
 export const NO_RUN_YET = 'No check run yet, so there is no line to draw.';
 /** Back to front, so the line that matters most — proven — is drawn over the others. */
 const SERIES = [
@@ -95,16 +96,26 @@ export function progressChartSvg(points, { width = 640, height = 220, capped } =
 const barRow = (label, pct, proven, active, extra = '') => `<li><span class="pct-label">${label}</span> `
     + `<span class="pct-bar"><span class="pct-fill${extra} ${pctClass(pct)}"></span></span>`
     + `<span class="pct-n">${n(num(pct))}% · ${n(num(proven))} of ${n(num(active))} proven</span></li>`;
-/** How far each lane and each focus is now, as bars with the numbers beside them. */
-function doneBarsHtml(register) {
-    const lanes = (register.lanes ?? []).map((l) => barRow(cell(ownerLabel(l)), l.donePct, l.proven, l.active));
+/**
+ * How far each lane and each focus is now, as bars with the numbers beside them.
+ * A lane's bar is the view's lane done (its own objects, the proven and clean
+ * parts over its active ones), the same Done % the developers table prints.
+ */
+function doneBarsHtml(register, view) {
+    const done = new Map(view.lanes.map((s) => [s.scope.id, s.done]));
+    const lanes = (register.lanes ?? []).map((l) => {
+        const d = done.get(l.id) ?? { pct: 0, proven: 0, active: 0 };
+        return barRow(cell(ownerLabel(l)), d.pct, d.proven, d.active);
+    });
     const focuses = (register.plan?.focuses ?? []).map((f) => barRow(`Focus: ${cell(f.label)}`, f.donePct, f.proven, f.active, ' f-focus'));
     if (!lanes.length && !focuses.length)
         return '';
     return '<h3>Done now, per developer and focus</h3>'
         + `<ul class="pct-bars" data-role="done-bars">${[...lanes, ...focuses].join('')}</ul>`;
 }
-/** The Progress over time section's body, as the page and the status file both draw it. */
-export function progressSectionHtml(register) {
-    return progressChartSvg(register.progress, { capped: register.progressCapped }) + doneBarsHtml(register);
+/** The Progress over time section's body, as the page and the status file both draw it. `view`: the project view (built once by the page). */
+export function progressSectionHtml(register, view) {
+    // No lanes: no lane bar, so no view is needed (an empty folder has no objects to read one from).
+    const lanes = register.lanes?.length ? viewOf(register, view) : { lanes: [] };
+    return progressChartSvg(register.progress, { capped: register.progressCapped }) + doneBarsHtml(register, lanes);
 }

package/dist/register/status-file/register-map.js

@@ -161,11 +161,14 @@ export function blockSvg(block, { cell = 10, gap = 2, role = 'group', colourBy =
         // leave retired objects out, and a cell painted C that no count includes
         // would show a manager two numbers for one folder.
         //
-        // A clean (or verified) object nobody decided has no level and nothing to
-        // decide: it keeps its state colour too, and its title says so — never
-        // "level not decided" (register-core leaves it out of the level counts).
-        const nothing = byLevel && o.inScope !== false && !o.decision && !LEVEL_SET.has(o.levelNow) && (o.state === 'clean' || o.state === 'verified');
-        const asLevel = byLevel && o.state !== 'retired' && !nothing;
+        // A clean (or verified) object nobody decided has nothing to decide: it
+        // keeps its state colour too, and its title says so — never "level A" or
+        // "level not decided". Its level now may read A from the latest check, but
+        // the level counts put it in "clean, nothing to decide", and the map must
+        // agree with them. An out-of-scope object keeps its state colour as well:
+        // the level counts cover active objects only.
+        const nothing = byLevel && o.inScope !== false && !o.decision && (o.state === 'clean' || o.state === 'verified');
+        const asLevel = byLevel && o.inScope !== false && o.state !== 'retired' && !nothing;
         return `<rect class="cell ${asLevel ? levelClass(o.levelNow) : stateClass(o.state)}"${keyed ? ` data-key="${esc(o.key)}"` : ''} x="${x}" y="${y}" width="${cell}" height="${cell}" rx="2">`
             + `<title>${esc(o.name)} · ${esc(o.type)}${asLevel ? ` · level ${esc(LEVEL_WORD[LEVEL_SET.has(o.levelNow) ? o.levelNow : 'none'])}` : nothing ? ' · clean, nothing to decide' : ''} · ${esc(stateWord(o))}</title></rect>`;
     }).join('');

package/dist/register/status-file/register-model.js

@@ -8,11 +8,14 @@
  * Pure: a Register in, plain data out. No DOM and no clock — `now` is handed
  * in — so the page, the status file and the tests all get the same answer.
  *
- * "Proven" means the system said so: verified (had findings, a later
- * measurement has none) or clean (measured, never had any). A developer's
- * "fixed" is a claim and is never counted here.
+ * "Proven" means the system said so: the project view's proven part (a fix the
+ * check proved, also for its own target) or clean (measured, never had any). A
+ * developer's "fixed" is a claim and is never counted here. Every count of
+ * objects reads the project view (register-core `projectView`), which the
+ * caller builds once and hands in, so the page, the status file and the
+ * terminal share one definition of each word.
  */
-import { activeOf, laneActiveOf, laneProvenOf, provenOf, settledOf } from '@cspeach/register-core';
+import { activeOf, laneActiveOf, laneProvenOf, projectView, provenOf, settledOf } from '@cspeach/register-core';
 /**
  * The three counts every surface divides by are defined once, in register-core,
  * where the terminal reads them too. They are passed on from here so that
@@ -20,6 +23,13 @@ import { activeOf, laneActiveOf, laneProvenOf, provenOf, settledOf } from '@cspe
  * status file — takes its numbers from the model, like everything else it draws.
  */
 export { activeOf, laneActiveOf, laneProvenOf, provenOf, settledOf };
+/**
+ * The project view these words read. The page and the status file build it once
+ * (`collectView`) and hand it in; a caller holding only a register (a test, an
+ * older caller) gets one built from the register alone: the same parts, with no
+ * project file to name the lead or a project target's setter.
+ */
+export const viewOf = (register, view) => view ?? projectView(register, { kind: 'team-project', formatVersion: 1, projectId: register.projectId, name: '', type: 'clean-core', lead: { name: 'the lead' } });
 /** Worst first: the order cells are banded in a block and listed in a legend. */
 export const STATE_ORDER = ['regressed', 'did-not-hold', 'untouched', 'decided', 'working', 'claimed', 'verified', 'clean', 'retired'];
 export const STATE_LABEL = {
@@ -119,46 +129,45 @@ function upTo(parts, { tail, cap = LIST_CAP, sep = ', ', more } = {}) {
  * normal pairing. Counting the ways would tell the manager four things need
  * attention when three objects do, so this counts objects.
  */
-function attentionKeys(register) {
-    const keys = new Set();
-    for (const o of register.objects) {
-        if (o.state === 'regressed' || o.state === 'did-not-hold' || o.decision?.conflict)
-            keys.add(o.key);
-    }
-    return keys;
+/** Kinds of the view's needs that call for attention on the map: the system disagrees, or the writers do. */
+const ATTENTION = new Set(['conflict', 'failed', 'regressed']);
+function attentionKeys(view) {
+    return new Set(view.all.needs.filter((x) => ATTENTION.has(x.kind)).map((x) => x.key));
 }
-export function summarize(register, { unreadable = 0 } = {}) {
-    const { totals } = register;
-    const proven = provenOf(totals.byState);
+/** The view's proven part and clean part: what a check run says, over active objects. */
+const provenCount = (view) => view.all.parts.proven + view.all.parts.clean;
+export function summarize(register, { unreadable = 0, view } = {}) {
+    view = viewOf(register, view);
+    const all = view.all;
+    const proven = provenCount(view);
     // Floor, never round: 7,997 of 8,000 is not 100% proven, and a manager who
     // reads 100% stops looking. Only every last object earns the round number.
-    const provenPct = totals.active ? Math.floor((proven / totals.active) * 100) : 0;
-    const needAttention = attentionKeys(register).size;
+    const provenPct = all.active ? Math.floor((proven / all.active) * 100) : 0;
+    const needAttention = attentionKeys(view).size;
     const lastMeasured = register.lastMeasuredAt ? `last measured ${formatWhen(register.lastMeasuredAt)}` : 'never measured';
     // A project where every object was retired has nothing left to prove, and
     // "0% proven" would read as a team that proved nothing. An empty project
     // keeps the percentage: its map already says there is nothing in scope yet.
-    const provenPhrase = totals.objects > 0 && totals.active === 0 ? 'nothing left to prove' : `${provenPct}% proven`;
+    // "of active": the percentage divides by the active objects, never by all of them (Task 3).
+    const provenPhrase = all.total > 0 && all.active === 0 ? 'nothing left to prove' : `${provenPct}% of active proven`;
     // A proof read out of a file is still a proof, and it is not the same thing
     // as a run of the system. The one line a manager reads says how much of what
     // it just called proven came that way, right beside the word.
-    const fromFile = (totals.fromFile?.verified ?? 0) + (totals.fromFile?.clean ?? 0);
+    const fromFile = all.objects.filter((v) => (v.part === 'proven' || v.part === 'clean') && v.proof.basis === 'file').length;
     const fromFilePhrase = fromFile > 0 ? ` · ${count(fromFile)} of them ${FROM_FILE}` : '';
-    // A folder from an older build carries no `undecided`; work it out the same
-    // way register-core does, so the line never prints a blank.
-    const decided = totals.decided ?? 0;
+    const decided = all.objects.filter((v) => v.decision.what !== 'none').length;
     // Recording fix 4 (2026-10-07): a clean object nobody decided has nothing
-    // to decide. register-core counts it on its own; it is never "undecided".
-    const nothingToDecide = Number.isFinite(totals.cleanNothingToDecide) ? totals.cleanNothingToDecide : 0;
-    const undecided = Number.isFinite(totals.undecided) ? totals.undecided : Math.max(0, totals.objects - decided - nothingToDecide);
+    // to decide. It is counted on its own; it is never "undecided".
+    const nothingToDecide = all.levels.nothingToDecide;
+    const undecided = Math.max(0, all.total - decided - nothingToDecide);
     const decidedPhrase = nothingToDecide > 0
         ? `${count(decided)} decided${undecided > 0 ? `, ${count(undecided)} undecided` : ''} · ${count(nothingToDecide)} ${NOTHING_TO_DECIDE}`
         : `${count(decided)} decided, ${count(undecided)} undecided`;
     return {
-        objects: totals.objects, active: totals.active, proven, provenPct, decided: totals.decided, undecided, needAttention,
+        objects: all.total, active: all.active, proven, provenPct, decided, undecided, needAttention,
         lastMeasured, unreadable, fromFile,
         ...(nothingToDecide > 0 ? { nothingToDecide } : {}),
-        line: `${plural(totals.objects, 'object', 'objects')} · ${provenPhrase}${fromFilePhrase} · ${decidedPhrase} · ${plural(needAttention, 'needs attention', 'need attention')} · ${lastMeasured}`,
+        line: `${plural(all.total, 'object', 'objects')} · ${provenPhrase}${fromFilePhrase} · ${decidedPhrase} · ${plural(needAttention, 'needs attention', 'need attention')} · ${lastMeasured}`,
     };
 }
 const DAY_MS = 86_400_000;
@@ -167,19 +176,26 @@ const DAY_MS = 86_400_000;
  * one mark: where a cut list of OBJECTS sends the reader. On the page that is
  * the map, where a cell opens. In the status file the map is a picture, so it
  * is the object list the file carries instead.
+ *
+ * What waits for a person about one object — a regression, a failed fix, a
+ * conflict, an exception with no reason, a retire candidate — is the view's
+ * needs list, the same list the status page prints (one line per object, a fix
+ * proven for its own target is not a failed fix).
  */
-export function needsYou(register, { now, unreadable = 0, quietDays = 6, surface = 'page' } = {}) {
+export function needsYou(register, { now, unreadable = 0, quietDays = 6, surface = 'page', view } = {}) {
+    view = viewOf(register, view);
     const items = [];
-    const inState = (state) => register.objects.filter((o) => o.state === state);
+    const byKey = new Map(register.objects.map((o) => [o.key, o]));
+    const needing = (kind) => view.all.needs.filter((x) => x.kind === kind).map((x) => byKey.get(x.key)).filter(Boolean);
     // The four lists below name objects, and an object is a cell. Everything
     // else here names something the map does not draw.
     const onMap = surface === 'file' ? seeObjectList : seeMap;
-    const regressed = inState('regressed');
+    const regressed = needing('regressed');
     if (regressed.length) {
         items.push({ kind: 'regressed', title: `${plural(regressed.length, 'object has', 'objects have')} more findings than before`,
             detail: upTo(regressed.map((o) => o.name), { tail: onMap }), keys: regressed.map((o) => o.key) });
     }
-    const didNotHold = inState('did-not-hold');
+    const didNotHold = needing('failed');
     if (didNotHold.length) {
         // Objects, not fixes. One object can carry three failed fixes, and "3 fixes
         // did not hold" sends a lead looking for three things to put right.
@@ -194,7 +210,7 @@ export function needsYou(register, { now, unreadable = 0, quietDays = 6, surface
             }), { tail: onMap }),
             keys: didNotHold.map((o) => o.key) });
     }
-    const conflicts = register.objects.filter((o) => o.decision?.conflict);
+    const conflicts = needing('conflict');
     if (conflicts.length) {
         items.push({ kind: 'conflict', title: `${plural(conflicts.length, 'decision needs', 'decisions need')} the lead to rule`,
             detail: upTo(conflicts.map((o) => `${o.name} — ${Object.entries(o.decision.conflict).map(([w, c]) => `${w}: ${c}`).join(', ')}`), { tail: onMap, sep: '; ' }),
@@ -203,7 +219,7 @@ export function needsYou(register, { now, unreadable = 0, quietDays = 6, surface
     // An accepted exception is work nobody has to do — on a reason somebody gave.
     // One with no reason (an older record, a hand-written file) is a decision the
     // lead cannot defend yet.
-    const noReason = register.objects.filter((o) => o.decision?.classification === 'keep' && o.decision?.exception === true && !o.decision?.reason);
+    const noReason = needing('reason');
     if (noReason.length) {
         items.push({ kind: 'exception-no-reason', title: `${plural(noReason.length, 'accepted exception has', 'accepted exceptions have')} no reason`,
             detail: upTo(noReason.map((o) => o.name), { tail: onMap }), keys: noReason.map((o) => o.key) });
@@ -211,7 +227,9 @@ export function needsYou(register, { now, unreadable = 0, quietDays = 6, surface
     // A developer's "retire" is a candidate until the lead confirms it with a
     // reason (spec 2026-10-06 D2). Until then the object stays active, and the
     // lead is the one person who can move it.
-    const candidates = register.objects.filter((o) => o.retireCandidate === true);
+    // From the decision, as the tiles and team status count them: a candidate that waits for a conflict first is still one.
+    const candidates = view.all.objects.filter((v) => v.decision.what === 'retire-candidate' && v.part !== 'retired' && v.part !== 'out-of-scope')
+        .map((v) => byKey.get(v.key)).filter(Boolean);
     if (candidates.length) {
         items.push({ kind: 'retire-candidate', title: `${plural(candidates.length, 'retire candidate waits', 'retire candidates wait')} for your confirmation`,
             detail: upTo(candidates.map((o) => o.name), { tail: onMap }), keys: candidates.map((o) => o.key) });
@@ -223,7 +241,7 @@ export function needsYou(register, { now, unreadable = 0, quietDays = 6, surface
         items.push({ kind: 'out-of-scope-no-reason', title: `${plural(outNoReason.length, 'object was', 'objects were')} taken out of scope with no reason`,
             detail: upTo(outNoReason.map((o) => o.name), { tail: onMap }), keys: outNoReason.map((o) => o.key) });
     }
-    const unowned = register.objects.filter((o) => o.lane === null);
+    const unowned = view.unowned.objects;
     if (unowned.length) {
         const packages = [...new Set(unowned.map((o) => o.package))].sort();
         items.push({ kind: 'unowned', title: `${plural(unowned.length, 'object has', 'objects have')} no owner`,
@@ -311,9 +329,10 @@ export function packageBlocks(register) {
 /**
  * Active objects nobody has measured. Their colour rests on what people said,
  * and the page says so out loud: "not measured" is a state of knowledge, not a
- * blank. A retired object is not counted — there is nothing left to prove.
+ * blank. A retired or out-of-scope object is not counted — there is nothing
+ * left to prove. The view's coverage, the same number the status page prints.
  */
-export const notMeasuredCount = (register) => register.objects.filter((o) => o.state !== 'retired' && (o.lastMeasuredAt ?? null) === null).length;
+export const notMeasuredCount = (register, view) => viewOf(register, view).all.coverage.notChecked;
 /**
  * One object's measurements, newest first: when, by whom, how many open, and
  * whether the numbers came from a system check or from a file somebody read in.