@cspeach/cli 1.1.48 → 1.1.49

package/dist/commands/team.js

@@ -14,12 +14,14 @@
  *
  * Every path written here is one a person typed. Nothing is written to a
  * network location on CSPeach's own initiative, and none of this is reachable
- * from a model tool.
+ * from a model tool — except the lane move body (moveLanes), which the
+ * team_lane_move tool runs only after its own checks and the person's Yes on
+ * a card (Task 4, 2026-10-20).
  */
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { isAppLabel, isPatternWord, laneIdFor, levelOf, normalizeRuleId, objectKey, proposeLanes, scopeFromWords, targetsOf, } from '@cspeach/register-core';
+import { decidedCount, decisionWhatOf, isAppLabel, isPatternWord, laneIdFor, levelOf, normalizeRuleId, objectKey, partCounts, proposeLanes, scopeFromWords, targetsOf, viewWords, } from '@cspeach/register-core';
 import { LOCAL_PACKAGE, listCustomPackages, pullBaseline, BaselineError } from '../register/baseline.js';
 import { BASELINE_FILE, TEAM_FILE, RegisterError, activeProject, defaultOutboxDir, loadState, projectIdFor, readBaseline, readEstate, readLanes, readProjectFile, saveState, sha256, VARIANT_NAME, writeLanes, writeProjectVariant, writerIdFor, } from '../register/store.js';
 import { MAX_API_DOCUMENTS, MAX_SECOND_PASS, measure, noVariantYetMessage, scopeLabel, scopeObjects, variantMismatchMessage, } from '../register/measure.js';
@@ -30,10 +32,11 @@ import { registerFor } from '../register/picture.js';
 import { HELD, combinedSheets, regenerateWorkingList, reportFileNames } from '../register/workbooks.js';
 import { writeXlsxFile } from '../register/xlsx.js';
 import { writeWhole } from '../register/write-whole.js';
-import { EXPORTS_DIR, exportsOn, setExports, writeExportFiles } from '../register/export-files.js';
-import { previousAsOfIn, reportViewFor, statusHtmlFor } from '../register/status-html.js';
+import { EXPORTS_DIR, exportsOff, exportsOn, exportsPresent, setExports, writeExportFiles } from '../register/export-files.js';
+import { previousAsOfIn, projectViewFor, reportViewFor, statusHtmlFor } from '../register/status-html.js';
 import { firstBlockLines, awaitingWord, lastCheckWord } from '../register/status-file/report-model.js';
 import { lookupVariant, variantLookupLine } from '../register/variant.js';
+import { TRANSPORT_NONE_WORDS, TRANSPORT_REQUEST, notARequestLine, projectTransportWords, writeProjectTransport } from '../register/project-transport.js';
 import { teamDiscover, evidenceRows, EVIDENCE_LINE, OUTSIDE_LINE } from './team-discover.js';
 import { rulesCommand } from './team-rules.js';
 import { focusCommand, laneChangeRecord, laneProposal, nowLine, planCommand, priorityCommand, reasonFrom } from './team-plan.js';
@@ -52,11 +55,11 @@ const TYPES = ['clean-core', 'upgrade', 'build'];
  */
 export const whoAmI = (deps) => activeProject()?.name ?? deps.identity().name;
 /** After a record this laptop wrote: its working list, made again. One line, or none. */
-function refreshSheet(deps) {
+function refreshSheet(deps, read) {
     const joined = activeProject();
     if (!joined)
         return;
-    const res = regenerateWorkingList(joined, whoAmI(deps), deps.now?.());
+    const res = regenerateWorkingList(joined, whoAmI(deps), deps.now?.(), read);
     if (res.line)
         deps.print(res.line);
 }
@@ -107,6 +110,16 @@ export function flags(args, flagOnly = []) {
 export const list = (v) => (v ?? '').split(',').map((s) => s.trim()).filter(Boolean);
 /** "1 object", "3 objects" — every count this command prints reads as a sentence. */
 const plural = (count, one, many) => `${count} ${count === 1 ? one : many}`;
+/**
+ * `lane add` for a lane that owns none of what it matches: whose lanes hold
+ * those objects, by each owner's name (never he/she), in the order met.
+ */
+export function heldElsewhereLine(id, held) {
+    const owners = [...new Set(held.map((h) => `${shown(h.owner)}'s`))];
+    const named = owners.length === 1 ? owners[0] : `${owners.slice(0, -1).join(', ')} and ${owners.at(-1)}`;
+    const n = held.length;
+    return `✓ Lane ${id} added: 0 objects of its own — ${plural(n, 'object', 'objects')} it matches already ${n === 1 ? 'belongs' : 'belong'} to ${named} ${owners.length === 1 ? 'lane' : 'lanes'}.`;
+}
 /** `ZFI_*` style match, used only to expand --packages patterns against the real package list. */
 function matches(pattern, value) {
     const re = new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`, 'i');
@@ -128,6 +141,7 @@ export async function runTeamCommand(args, deps) {
             case 'leave': return leave(deps);
             case 'decide': return decide(rest, deps);
             case 'target': return target(rest, deps);
+            case 'transport': return transportVerb(rest, deps);
             case 'fixed': return await fixed(rest, deps);
             case 'sheet': return sheet(deps);
             case 'report': return report(rest, deps);
@@ -138,7 +152,7 @@ export async function runTeamCommand(args, deps) {
             case 'plan': return await planCommand(rest, deps);
             case 'rebuild': return await rebuildVerb(rest, deps);
             default:
-                deps.print('Usage: cspeach team init|join|lane|refresh|status|outbox|rule|leave|decide|target|fixed|sheet|report|export|discover|focus|priority|plan|start|rebuild|rules   (cspeach --help for details)');
+                deps.print('Usage: cspeach team init|join|lane|refresh|status|outbox|rule|leave|decide|target|transport|fixed|sheet|report|export|discover|focus|priority|plan|start|rebuild|rules   (cspeach --help for details)');
                 return sub ? 1 : 0;
         }
     }
@@ -156,9 +170,13 @@ export async function runTeamCommand(args, deps) {
         return 1;
     }
 }
+/** True when this seat is the project's lead. The one test: requireLead and team_lane_move both use it. */
+export function isLead(project, deps) {
+    return whoAmI(deps).trim().toLowerCase() === project.lead.name.trim().toLowerCase();
+}
 export function requireLead(project, deps) {
     const me = whoAmI(deps);
-    if (me.trim().toLowerCase() !== project.lead.name.trim().toLowerCase()) {
+    if (!isLead(project, deps)) {
         throw new RegisterError(`Only the team project lead (${project.lead.name}) changes this. You are ${me}.`);
     }
 }
@@ -201,8 +219,8 @@ function unknownInitOption(name) {
     return `${said} Did you mean --${guess}?`;
 }
 const START_USAGE = 'Usage: cspeach team start <packages> | --for "<area words, e.g. FI and SD>" [--developers "<names>, me"] '
-    + '[--name "<name>"] [--atc-variant <NAME>] [--folder <folder>] [--no-measure] [--sap-alias <name>]';
-const START_OPTIONS = ['name', 'atc-variant', 'folder', 'no-measure', 'sap-alias', 'for', 'developers'];
+    + '[--name "<name>"] [--atc-variant <NAME>] [--transport <REQUEST>] [--folder <folder>] [--no-measure] [--sap-alias <name>]';
+const START_OPTIONS = ['name', 'atc-variant', 'folder', 'no-measure', 'sap-alias', 'for', 'developers', 'transport'];
 /** The check a project measures with when nobody names one. */
 export const DEFAULT_ATC_VARIANT = 'ABAP_CLOUD_READINESS';
 /** I16: `--for` reads the packages from the folder's discovery; without one there is nothing to read them from. */
@@ -220,6 +238,8 @@ const firstWordOf = (name) => (name.trim().split(/\s+/)[0] ?? '').toLowerCase();
  * `lane move --to`): plain text, no control characters, at most 60 characters.
  * `what` starts the message, so the line says which option was wrong.
  */
+/** A plain person's name: not empty, no control characters, at most 60 characters. */
+export const isPlainName = (raw) => !!raw.trim() && !CONTROL.test(raw.trim()) && raw.trim().length <= MAX_PERSON_NAME;
 export function personName(raw, what, example = 'James Miller') {
     const name = raw === undefined || raw === 'true' ? '' : raw.trim();
     if (!name)
@@ -281,6 +301,14 @@ async function start(args, deps) {
     const developers = developersOf(opts.developers);
     if (!forWords && !typed.length)
         throw new RegisterError(START_USAGE);
+    // Task 8 (B11): the request the fixes are recorded in, checked before anything is written.
+    let request;
+    if (opts.transport !== undefined) {
+        const t = opts.transport === 'true' ? '' : opts.transport.trim().toUpperCase();
+        if (!TRANSPORT_REQUEST.test(t))
+            throw new RegisterError(notARequestLine(opts.transport === 'true' ? '' : opts.transport));
+        request = t;
+    }
     const dir = path.resolve(opts.folder && opts.folder !== 'true' ? opts.folder : process.cwd());
     if (fs.existsSync(path.join(dir, TEAM_FILE)))
         throw new RegisterError('This folder already holds a team project. Start a new one in an empty folder, or carry on with this one.');
@@ -317,6 +345,8 @@ async function start(args, deps) {
         return code;
     }
     join([dir, '--outbox', dir], quiet);
+    if (request)
+        writeProjectTransport(dir, { request, by: lead, at: (deps.now ?? (() => new Date()))().toISOString() });
     let lanesWritten = null;
     let note = '';
     let laneId = (lead.trim().split(/\s+/)[0] ?? '').toLowerCase().replace(/[^a-z0-9]/g, '') || 'me';
@@ -348,6 +378,8 @@ async function start(args, deps) {
     // §3.1: what the variant lookup found, said on every path (init's own line, kept back above).
     for (const l of said.filter((x) => /^ {2}(! )?CSPeach could not (find|confirm) the variant /.test(x)))
         deps.print(l);
+    if (request)
+        deps.print(`  Transport: ${request}.`);
     deps.print(`  ${plural(objects, 'object', 'objects')}, matched against the system's own count.`);
     if (measured)
         deps.print(`  First check (${variant.toUpperCase()}): ${measured[2]} of ${measured[1]} objects with findings.`);
@@ -355,7 +387,7 @@ async function start(args, deps) {
     else if (said.includes(FIRST_CHECK_PER_PACKAGE_LINE) || objects > FIRST_CHECK_WHOLE_MAX)
         deps.print(FIRST_CHECK_PER_PACKAGE_LINE);
     else if (lanesWritten)
-        deps.print('  No check run yet: cspeach team refresh --all measures it.');
+        deps.print(NO_CHECK_ALL_LINE);
     else if (noMeasure)
         deps.print('  No check run yet: cspeach team refresh measures it.');
     if (lanesWritten) {
@@ -502,6 +534,8 @@ ${INIT_USAGE}`);
 /** Above this many objects, `init` does not run the first check over the whole baseline (I15). */
 export const FIRST_CHECK_WHOLE_MAX = 500;
 export const FIRST_CHECK_PER_PACKAGE_LINE = '  First check per package: cspeach team refresh --all --per-package (it resumes if stopped).';
+/** What a start with --developers says: nothing measured yet, for anyone (the journey runs the first check per package then). */
+export const NO_CHECK_ALL_LINE = '  No check run yet: cspeach team refresh --all measures it.';
 /**
  * Per chosen package, what the estate knows beside the live count: its
  * description, application area and last change. Packages the estate does
@@ -810,15 +844,24 @@ async function lane(args, deps) {
     }
     writeLanes(joined.projectDir, project.projectId, [...lanes.filter((l) => l.id !== id), next]);
     const reg = registerFor(joined.projectDir, joined.outboxDir);
-    const mine = reg.register.lanes.find((l) => l.id === id);
-    // The count is every object this lane MATCHES, so it can never disagree with
-    // the overlap line under it (F2).
-    deps.print(`✓ Lane ${id}: ${next.owner}, ${plural(mine.objects, 'object', 'objects')}.`);
+    // Owner decision (final review): the count is the objects this lane OWNS, the
+    // view's lane total, as on every other surface. An object another lane owns
+    // too is said by the overlap line under it. A lane that owns none of what it
+    // matches says whose lanes hold those objects instead, and the overlap line
+    // is left out when it would only say the same thing again.
+    const view = projectViewFor(reg.register, project);
+    const owned = view.lanes.find((l) => l.scope.kind === 'lane' && l.scope.id === id)?.total ?? 0;
+    const held = owned === 0 ? view.all.objects.filter((v) => v.alsoMatches.includes(id) && v.owner) : [];
+    if (held.length)
+        deps.print(heldElsewhereLine(id, held.map((v) => ({ owner: v.owner.name }))));
+    else
+        deps.print(`✓ Lane ${id}: ${next.owner}, ${plural(owned, 'object', 'objects')}.`);
     if (next.packages.length && next.namePatterns.length) {
         deps.print(`  Lane ${id} means: in these packages AND matching these names.`);
     }
-    if (reg.register.totals.overlapping)
-        deps.print(`  ! ${plural(reg.register.totals.overlapping, 'object now sits', 'objects now sit')} in more than one lane.`);
+    const overlapping = reg.register.totals.overlapping ?? 0;
+    if (overlapping && overlapping !== held.length)
+        deps.print(`  ! ${plural(overlapping, 'object now sits', 'objects now sit')} in more than one lane.`);
     if (reg.register.totals.unowned)
         deps.print(`  ${plural(reg.register.totals.unowned, 'object still has', 'objects still have')} no owner.`);
     if (reason)
@@ -834,18 +877,34 @@ const patternOf = (l) => l.packages.find((p) => p.includes('*')) ?? l.namePatter
  * lane of names when that developer has none yet. Lanes of names only: a lane
  * that holds a pattern cannot give up one package, so the move is refused in
  * one line and nothing is written. A lane left empty is removed.
+ *
+ * The verb parses the flags; moveLanes is the body, shared with the
+ * team_lane_move tool (Task 4, 2026-10-20).
  */
 function laneMove(positional, opts, joined, project, lanes, deps) {
     const names = [...new Set(list(opts.packages === 'true' ? '' : opts.packages).map((p) => p.toUpperCase()))];
     if (positional.length || !names.length || !opts.to || opts.to === 'true')
         throw new RegisterError(MOVE_USAGE);
+    const reason = reasonFrom(opts, false);
+    moveLanes(names, opts.to, reason, joined, project, lanes, deps);
+    return 0;
+}
+/**
+ * The checks and the new lanes of a move, nothing written: names typed in
+ * full, each a package of the baseline, no pattern lane on either side.
+ * Throws RegisterError with the one line a person reads.
+ */
+export function planLaneMove(names, toRaw, joined, lanes) {
+    names = [...new Set(names.map((n) => n.trim().toUpperCase()).filter(Boolean))];
+    if (!names.length)
+        throw new RegisterError(MOVE_USAGE);
     if (names.some(isPatternWord))
         throw new RegisterError('Name each package in full, for example ZSD_ORDERS — not a pattern.');
     const known = new Set(readBaseline(joined.projectDir).map((o) => o.package.toUpperCase()));
     for (const n of names)
         if (!known.has(n))
             throw new RegisterError(`${shown(n)} is not a package of this team project.`);
-    const to = personName(opts.to, '--to');
+    const to = personName(toRaw, '--to');
     const target = lanes.find((l) => l.id.toLowerCase() === to.toLowerCase()) ?? lanes.find((l) => sameName(l.owner, to));
     const holders = lanes.filter((l) => l !== target && l.packages.some((p) => names.some((n) => matches(p, n))));
     for (const l of [...holders, ...(target ? [target] : [])]) {
@@ -857,10 +916,8 @@ function laneMove(positional, opts, joined, project, lanes, deps) {
     }
     // Review finding 7: a move that changes nothing says so and writes nothing.
     if (target && !holders.length && names.every((n) => target.packages.some((p) => p.toUpperCase() === n))) {
-        deps.print(`Nothing to move: ${names.join(', ')} ${names.length === 1 ? 'is' : 'are'} already in ${shown(target.owner)}'s lane.`);
-        return 0;
+        return { kind: 'nothing', line: `Nothing to move: ${names.join(', ')} ${names.length === 1 ? 'is' : 'are'} already in ${shown(target.owner)}'s lane.` };
     }
-    const reason = reasonFrom(opts, false);
     const into = target
         ? { ...target, packages: [...target.packages, ...names.filter((n) => !target.packages.some((p) => p.toUpperCase() === n))] }
         : { id: laneIdFor(to, new Set(lanes.map((l) => l.id))), owner: to, packages: names, namePatterns: [] };
@@ -883,15 +940,42 @@ function laneMove(positional, opts, joined, project, lanes, deps) {
     }
     if (!target)
         next.push(into);
-    writeLanes(joined.projectDir, project.projectId, next);
-    const mine = registerFor(joined.projectDir, joined.outboxDir).register.lanes.find((l) => l.id === into.id);
-    deps.print(`✓ ${names.join(', ')} moved to ${shown(into.owner)} (${into.id}): `
-        + `${plural(into.packages.length, 'package', 'packages')}, ${plural(mine?.objects ?? 0, 'object', 'objects')}.`);
+    return { kind: 'move', names, target, into, holders, next, removed };
+}
+/**
+ * The move itself: lanes.json, then ALWAYS one plan record
+ * `lane: { change: 'move' }` (with the reason when one was given), and the
+ * lines a person reads through `deps.print`. The caller has checked the lead.
+ * A move that changes nothing prints so and writes nothing: `moved` is empty.
+ */
+export function moveLanes(names, to, reason, joined, project, lanes, deps) {
+    const plan = planLaneMove(names, to, joined, lanes);
+    if (plan.kind === 'nothing') {
+        deps.print(plan.line);
+        return { moved: [], to: personName(to, '--to'), lane: null };
+    }
+    const { into, removed } = plan;
+    writeLanes(joined.projectDir, project.projectId, plan.next);
+    // The view after the move: the packages' own objects, and the lane's.
+    const view = projectViewFor(registerFor(joined.projectDir, joined.outboxDir).register, project);
+    const moved = plan.names.map((name) => {
+        const objects = view.all.objects.filter((o) => o.package.toUpperCase() === name.toUpperCase());
+        return { package: name, objects: objects.length, parts: partCounts(objects), decided: decidedCount(objects) };
+    });
+    const laneObjects = view.lanes.find((s) => s.scope.kind === 'lane' && s.scope.id === into.id)?.objects ?? [];
+    const movedObjects = moved.reduce((n, m) => n + m.objects, 0);
+    // Never a pronoun (nobody's is known): the person's name, else the lane id.
+    const whose = into.owner.trim() ? shown(into.owner) : into.id;
+    deps.print(`✓ ${plan.names.join(', ')} moved to ${shown(into.owner)} (${into.id}): `
+        + `${plural(movedObjects, 'object', 'objects')} in the ${plan.names.length === 1 ? 'package' : 'packages'}; `
+        + `${whose}'s lane now holds ${plural(into.packages.length, 'package', 'packages')}, ${plural(laneObjects.length, 'object', 'objects')}.`);
     for (const id of removed)
         deps.print(`  Lane ${id} held nothing else and was removed.`);
-    if (reason)
-        deps.print(laneChangeRecord(deps, 'add', target, into, into.id, reason));
-    return 0;
+    deps.print(laneChangeRecord(deps, 'move', plan.target, into, into.id, reason, plan.names, plan.holders.map((l) => ({ id: l.id, owner: l.owner }))));
+    return {
+        moved, to: into.owner,
+        lane: { id: into.id, owner: into.owner, objects: laneObjects.length, parts: partCounts(laneObjects), decided: decidedCount(laneObjects) },
+    };
 }
 // ── status ──────────────────────────────────────────────────────────────────
 function status(args, deps) {
@@ -909,13 +993,17 @@ function status(args, deps) {
     // previous page in reports/ says where "changed since" starts.
     const asOf = (deps.now?.() ?? new Date()).toISOString();
     const previousAsOf = previousAsOfIn(path.join(projectDir, 'reports', reportFileNames(project.name).html));
-    const view = reportViewFor({ project, register: r, asOf, previousAsOf });
+    // The project view, built once: the first block, the lane table and the transport line read it.
+    const pv = projectViewFor(r, project);
+    const view = reportViewFor({ view: pv, register: r, asOf, previousAsOf });
     for (const l of firstBlockLines(view))
         deps.print(l);
     deps.print('');
     deps.print(nowLine(r));
     for (const l of targetLines(project))
         deps.print(l);
+    // The request this project's fixes are recorded in, or how to set one.
+    deps.print(pv.project.transport ? projectTransportWords(pv.project.transport.request) : TRANSPORT_NONE_WORDS);
     // Spec §3.6: a joiner who owns nothing reads that first, never a finished picture.
     if (!positional[0] && joined) {
         const owns = ownsNothingLine(projectDir, project, whoAmI(deps));
@@ -924,11 +1012,12 @@ function status(args, deps) {
     }
     deps.print('');
     if (view.lanes.length) {
-        // Every lane together, in the order the lanes were set up — never ranked.
-        deps.print(`${'Developer'.padEnd(20)} Objects Decided Fixes proven Awaiting check      Kept Rebuilds Fix failed  Last check`);
+        // Every lane together, in the order the lanes were set up — never ranked. Each object
+        // counts once, in the lane that owns it (the view's lane parts), so the rows add up.
+        deps.print(`${'Developer'.padEnd(20)} Objects Active Retired Decided Fixes proven Awaiting check      Kept Rebuilds Fix failed  Last check`);
         for (const row of view.lanes) {
-            deps.print(`${row.developer.padEnd(20)} ${String(row.objects).padStart(7)} ${String(row.decided).padStart(7)} `
-                + `${String(row.fixesProven).padStart(12)} ${awaitingWord(row).padEnd(18)} ${String(row.kept).padStart(4)} `
+            deps.print(`${row.developer.padEnd(20)} ${String(row.objects).padStart(7)} ${String(row.active).padStart(6)} ${String(row.retired).padStart(7)} `
+                + `${String(row.decided).padStart(7)} ${String(row.fixesProven).padStart(12)} ${awaitingWord(row).padEnd(18)} ${String(row.kept).padStart(4)} `
                 + `${String(row.rebuilds).padStart(8)} ${String(row.fixFailed).padStart(10)}  ${lastCheckWord(row)}`);
         }
         // What each lane does next, in the priority order every surface sorts by. No %.
@@ -945,8 +1034,10 @@ function status(args, deps) {
         deps.print(`! ${plural(t.unowned, 'object has', 'objects have')} no owner.`);
     if (t.overlapping)
         deps.print(`! ${plural(t.overlapping, 'object sits', 'objects sit')} in more than one lane.`);
-    if (t.retireCandidates)
-        deps.print(`${plural(t.retireCandidates, 'retire candidate waits', 'retire candidates wait')} for the lead.`);
+    // From the decision, as the page tile and the business sheet count it (the view's count).
+    const candidates = pv.all.retireCandidates;
+    if (candidates)
+        deps.print(`${plural(candidates, 'retire candidate waits', 'retire candidates wait')} for the lead.`);
     if (t.outOfScope)
         deps.print(`${plural(t.outOfScope, 'object', 'objects')} out of scope.`);
     if (t.conflicts) {
@@ -1843,7 +1934,18 @@ function rule(args, deps) {
     // Read the way `decide` reads one: trimmed, a bare flag refused, at most 300.
     if (opts.reason === 'true')
         throw new RegisterError('--reason needs words, for example: --reason "reads BSID directly"');
-    const reason = (opts.reason ?? '').trim();
+    ruleObject({ type, name, classification: classification, reason: opts.reason }, deps);
+    return 0;
+}
+/**
+ * The body of `team rule` (Task 6): the lead's ruling, written to `rulings/`.
+ * The journey's retire Yes runs it in process — the same record, the same
+ * checks (a retire needs its reason, only the lead rules). Throws a
+ * RegisterError with the plain reason when it cannot be written.
+ */
+export function ruleObject(r, deps) {
+    const { type, name, classification } = r;
+    const reason = (r.reason ?? '').trim();
     if (reason.length > MAX_REASON)
         throw new RegisterError(`Keep the reason under ${MAX_REASON} characters.`);
     // The lead's retire is what makes an object retired (D2), so it carries what was checked.
@@ -1851,14 +1953,22 @@ function rule(args, deps) {
         throw new RegisterError(RETIRE_RULING_NEEDS_REASON);
     const joined = joinedOrThrow();
     requireLead(readProjectFile(joined.projectDir), deps);
-    const res = writeRecord(joined, 'ruling', [{ key: objectKey(type, name), classification, ...(reason ? { reason } : {}) }], { name: whoAmI(deps) }, {
+    const res = writeRecord(joined, 'ruling', 
+    // The lead typed these words (project view §3.2): a person's, said so on the row.
+    [{ key: objectKey(type, name), classification, ...(reason ? { reason, reasonFrom: 'person' } : {}) }], { name: whoAmI(deps) }, {
         dir: path.join(joined.projectDir, 'rulings'), now: deps.now?.(),
         ...(deps.rand ? { rand: deps.rand } : {}),
     });
     if (!res.file)
         throw new RegisterError(`${objectKey(type, name)} is not in this team project's baseline.`);
-    deps.print(`✓ Ruled ${objectKey(type, name)} = ${classification}.`);
-    return 0;
+    // The ruling is what the project now holds: its words read back through the view (design §5 "rule lines").
+    const read = readBack(joined.projectDir, joined.outboxDir);
+    const o = read?.view.object(objectKey(type, name));
+    const shownName = `${type.toUpperCase()} ${name.toUpperCase()}`;
+    deps.print(o && read
+        ? `✓ Ruled: ${shownName} — ${read.view.words.decision(o.decision, whoAmI(deps))}. ${sentence(read.view.words.reason(o.decision.reason))}`
+        : `✓ Ruled: ${shownName} — ${classification}.`);
+    return { key: objectKey(type, name) };
 }
 // ── decide ──────────────────────────────────────────────────────────────────
 const DECIDE_USAGE = 'Usage: cspeach team decide <TYPE> <NAME> keep|fix|retire|rebuild|exception [--level A-D] [--target A-D] [--reason "<why>"] [--kind app|class|api] [--app <APP>]';
@@ -1922,36 +2032,80 @@ export function parseDecideArgs(args) {
         ok: true,
         value: {
             type: type.toUpperCase(), name: name.toUpperCase(),
-            // F3 / M19: a person NAMED the level this decision's target is read from —
-            // `--target` on a fix or rebuild, `--level` on a keep or an exception.
-            // Only then does `decide` stamp `targetBy`; the default A is no target.
-            targetNamed: moves ? !!target.value : said.classification === 'keep' && !!level.value,
+            // F3 / M19, Task 6 round 1: only `--target` (on a fix or rebuild) names a
+            // target, and only then does `decide` stamp `targetBy`. Project view §3.2:
+            // without `--target` no `targetLevel` is written (no default A). A kept
+            // level is a level (`levelBy`), never a target.
+            targetNamed: moves && !!target.value,
             row: {
                 classification: said.classification,
                 ...(said.exception ? { exception: true } : {}),
                 ...(level.value ? { level: level.value } : {}),
-                // Spec §4.2: a fix or a rebuild reaches A unless the person says otherwise.
-                ...(moves ? { targetLevel: target.value ?? 'A' } : {}),
-                ...(reason ? { reason } : {}),
+                ...(moves && target.value ? { targetLevel: target.value } : {}),
+                // The words after --reason are the person's own.
+                ...(reason ? { reason, reasonFrom: 'person' } : {}),
                 ...(kind ? { rebuildKind: kind } : {}),
                 ...(app ? { app } : {}),
             },
         },
     };
 }
-const DECISION_WORDS = { keep: 'keep', fix: 'fix', redesign: 'rebuild beside the core', retire: 'retire' };
-function decisionWords(row, targetNamed) {
-    const parts = [row.exception ? 'accepted exception' : DECISION_WORDS[row.classification]];
+/** The register and the view of this folder (with this laptop's outbox), read once; null when it cannot be read. */
+function readBack(projectDir, outboxDir) {
+    try {
+        const { register } = registerFor(projectDir, outboxDir);
+        return { register, view: projectViewFor(register, readProjectFile(projectDir)) };
+    }
+    catch {
+        return null;
+    }
+}
+/** A word table's text as a sentence: one full stop at the end. */
+const sentence = (text) => `${text}${/[.!?]$/.test(text) ? '' : '.'}`;
+const samePerson = (a, b) => a.trim().toLowerCase() === b.trim().toLowerCase();
+/**
+ * The `✓ Recorded:` words for the row the person just wrote, in the view's
+ * word tables (project view Task 4, fix round 1): "fix (decided by you),
+ * level C (decided by you), no target set. Why: …" — their classification
+ * and their reason first, whatever the register settles on.
+ */
+function writtenWords(row, w, me, at) {
+    const mine = { name: me, at };
+    const what = decisionWhatOf({ classification: row.classification, exception: row.exception === true, ruling: false });
+    const parts = [w.decision({ what, from: 'person', by: mine, reason: null }, me)];
     if (row.level)
-        parts.push(`level ${row.level}`);
-    // Step 2 (F3): the default A is recorded but is no target, so it is not said as one.
-    if (row.targetLevel)
-        parts.push(targetNamed ? `target ${row.targetLevel}` : 'no target set');
+        parts.push(w.level({ now: null, decided: row.level, by: mine }, me));
+    if (what === 'fix' || what === 'rebuild') {
+        parts.push(w.target(row.targetLevel ? { level: row.targetLevel, from: 'person', by: mine } : { level: null, from: 'none', by: null }, me));
+    }
     if (row.rebuildKind)
         parts.push(REBUILD_KIND_WORDS[row.rebuildKind]);
     if (row.app)
         parts.push(`app ${row.app}`);
-    return `${parts.join(', ')}${row.reason ? `, because: ${row.reason}` : ''}`;
+    return `${parts.join(', ')}. ${sentence(w.reason(row.reason ? { text: row.reason, from: 'person' } : null))}`;
+}
+/**
+ * When what the project now shows is not the row just written, one line from
+ * the view: a lead's ruling, a conflict (named by person, never by a writer
+ * id), or another writer's row that stands. Null when they agree.
+ * A conflict the lead wrote names the command that settles it (live re-run
+ * L3): the lead is never told "the lead settles it".
+ */
+function projectShowsLine(o, me, mine, view) {
+    const d = o.decision;
+    const w = view.words;
+    if (d.from === 'ruling')
+        return `The team project shows: ${w.decision(d, me)}.`;
+    if (d.conflict) {
+        const names = [...new Set((d.standing ?? []).filter((x) => x.what !== mine && !samePerson(x.name, me)).map((x) => x.name))];
+        const whose = names.length ? names.map((n) => `${n}'s`).join(' and ') : "another person's";
+        if (samePerson(view.project.lead, me))
+            return `Your decision differs from ${whose}. As the lead, settle it with: cspeach team rule ${o.type} ${o.name} <decision>`;
+        return `Your decision differs from ${whose}; the lead settles it.`;
+    }
+    if (d.by && !samePerson(d.by.name, me))
+        return `The team project shows: ${w.decision(d, me)}.`;
+    return null;
 }
 function decide(args, deps) {
     const parsed = parseDecideArgs(args);
@@ -1964,15 +2118,25 @@ function decide(args, deps) {
     const res = writeRecord(joined, 'decision', [{
             key: objectKey(type, name), ...row,
             ...(targetNamed ? { targetBy: { name: by, at: now.toISOString() } } : {}),
+            // G8: the level the person typed says who decided it; no --level, nothing stamped.
+            ...(row.level ? { levelBy: { name: by, at: now.toISOString() } } : {}),
         }], { name: by }, {
         now, ...(deps.rand ? { rand: deps.rand } : {}),
     });
     if (!res.file)
         throw new RegisterError(`${type} ${name} is not in this team project's object list.`);
-    deps.print(`✓ Recorded: ${type} ${name} — ${decisionWords(row, targetNamed)}.`);
+    deps.print(`✓ Recorded: ${type} ${name} — ${writtenWords(row, viewWords, by, now.toISOString())}`);
+    // Fix round 1: what the project now shows, read once through the view, when it is not this row.
+    const read = readBack(joined.projectDir, joined.outboxDir);
+    const o = read?.view.object(objectKey(type, name));
+    const mine = decisionWhatOf({ classification: row.classification, exception: row.exception === true, ruling: false });
+    const shows = o && read ? projectShowsLine(o, by, mine, read.view) : null;
+    if (shows)
+        deps.print(shows);
     if (row.classification === 'retire')
         deps.print('Recorded as a retire candidate. It becomes retired when the lead confirms it.');
-    refreshSheet(deps);
+    // The register just read, handed on: the working list does not read the folder again.
+    refreshSheet(deps, read ?? undefined);
     return 0;
 }
 // ── rebuild ─────────────────────────────────────────────────────────────────
@@ -2096,6 +2260,54 @@ function targetLines(project) {
     return targetsOf(project).map((t) => `Target ${t.level}${t.variant ? ` — variant ${t.variant} (stored, not yet used for measuring)` : ''}`
         + `, for ${forWhom(t.packages)}. Set by ${shown(t.by)}.`);
 }
+// ── transport ───────────────────────────────────────────────────────────────
+const TRANSPORT_USAGE = 'Usage: cspeach team transport <REQUEST> [--reason "<why>"]   |   cspeach team transport clear';
+/**
+ * Task 8 (B11) — the request this project's fixes are recorded in, set or
+ * cleared by the lead (a project started before this release sets it here).
+ * Stored as `transport: { request, by, at }` (and `reason` when one is said);
+ * the whole project file is written, then renamed. The modify/delete tools
+ * write under it when a change names no transport; a request that already
+ * holds the object still wins (the write is forced there).
+ */
+function transportVerb(args, deps) {
+    const { positional, opts } = flags(args);
+    for (const name of Object.keys(opts)) {
+        if (name !== 'reason')
+            throw new RegisterError(`--${name} is not an option of team transport.
+${TRANSPORT_USAGE}`);
+    }
+    const [word] = positional;
+    if (!word || positional.length !== 1)
+        throw new RegisterError(TRANSPORT_USAGE);
+    const clearing = word.toLowerCase() === 'clear';
+    const joined = joinedOrThrow();
+    const project = readProjectFile(joined.projectDir);
+    requireLead(project, deps);
+    if (clearing) {
+        if (!project.transport) {
+            deps.print('Nothing to clear: no transport is set.');
+            return 0;
+        }
+        writeProjectTransport(joined.projectDir, null);
+        deps.print('✓ Transport cleared. No transport yet.');
+        return 0;
+    }
+    const request = word.trim().toUpperCase();
+    if (!TRANSPORT_REQUEST.test(request))
+        throw new RegisterError(notARequestLine(word));
+    let reason;
+    if (opts.reason !== undefined) {
+        reason = Array.from(shownUpTo(opts.reason === 'true' ? '' : opts.reason, Number.POSITIVE_INFINITY)).slice(0, MAX_REASON).join('').trim();
+        if (!reason)
+            throw new RegisterError('--reason needs words, for example: --reason "the clean-core request for Q4"');
+    }
+    writeProjectTransport(joined.projectDir, {
+        request, by: whoAmI(deps), at: (deps.now ?? (() => new Date()))().toISOString(), ...(reason ? { reason } : {}),
+    });
+    deps.print(`✓ Transport: fixes in this team project are recorded in ${request}.`);
+    return 0;
+}
 // ── fixed ───────────────────────────────────────────────────────────────────
 const FIXED_USAGE = 'Usage: cspeach team fixed <TYPE> <NAME> [--rule <id>] [--transport <request>]';
 const utcLine = (iso) => `${iso.slice(0, 16).replace('T', ' ')} UTC`;
@@ -2186,8 +2398,19 @@ export const heldReportLine = (name) => `  ! "${name}" is open in another progra
  * other, and the caller is told by file name which one was not updated.
  * writeWhole has already removed its .tmp when it throws.
  */
+/**
+ * Design §5 "Register inputs": a report or export of the joined project reads
+ * this laptop's outbox too, as `team status` does, so it never lags this seat.
+ * Another folder (one named on the command line) is read as it is.
+ */
+function outboxFor(projectDir) {
+    const joined = activeProject();
+    return joined && path.resolve(joined.projectDir) === path.resolve(projectDir) ? joined.outboxDir : undefined;
+}
 export function writeReports(projectDir, project, outDir, deps) {
-    const picture = registerFor(projectDir);
+    const picture = registerFor(projectDir, outboxFor(projectDir));
+    // The project view, built once for both files.
+    const pv = projectViewFor(picture.register, project);
     const asOf = (deps.now?.() ?? new Date()).toISOString();
     const folderName = path.basename(projectDir);
     const names = reportFileNames(project.name);
@@ -2211,9 +2434,9 @@ export function writeReports(projectDir, project, outDir, deps) {
     // "changed since" block starts there. Read BEFORE it is overwritten.
     const previousAsOf = previousAsOfIn(path.join(outDir, names.html));
     const saved = [
-        attempt(names.xlsx, () => writeXlsxFile(path.join(outDir, names.xlsx), combinedSheets(picture.register, asOf, folderName, project))) ? names.xlsx : null,
+        attempt(names.xlsx, () => writeXlsxFile(path.join(outDir, names.xlsx), combinedSheets(picture.register, asOf, folderName, project, pv))) ? names.xlsx : null,
         attempt(names.html, () => writeWhole(path.join(outDir, names.html), statusHtmlFor({
-            project, register: picture.register, files: picture.files, unreadable: picture.unreadable,
+            project, register: picture.register, files: picture.files, unreadable: picture.unreadable, projectView: pv,
             checksum: project.baseline?.sha256 ? 'ok' : 'not-checked', asOf, folderName, previousAsOf,
             ...(discovery ? { estate: discovery.estate } : {}),
         }))) ? names.html : null,
@@ -2240,23 +2463,27 @@ function report(args, deps) {
         deps.print(`✓ Saved ${saved.map((n) => `"${n}"`).join(' and ')} in ${where}.`);
     for (const name of held)
         deps.print(heldReportLine(name));
-    // D2: the CSV export rides along only when the project file switched it on.
-    if (exportsOn(project)) {
-        const out = writeExports(joined.projectDir, project, path.join(outDir, EXPORTS_DIR), deps);
-        if (out.saved.length)
-            deps.print('✓ Saved the CSV export in the exports folder beside the report.');
+    // D2: the CSV export rides along when the project file switched it on.
+    // G5: an export already beside the report is rewritten too, so it never goes stale.
+    const exportsDir = path.join(outDir, EXPORTS_DIR);
+    const refresh = !exportsOn(project) && !exportsOff(project) && exportsPresent(exportsDir);
+    if (exportsOn(project) || refresh) {
+        const out = writeExports(joined.projectDir, project, exportsDir, deps);
+        if (out.saved.length) {
+            deps.print(refresh ? '✓ Updated the CSV export in the exports folder beside the report.' : '✓ Saved the CSV export in the exports folder beside the report.');
+        }
         for (const name of out.held)
             deps.print(heldExportLine(name));
         held.push(...out.held);
     }
-    // Records on this laptop that have not reached the folder are not in the report.
+    // Records on this laptop that have not reached the folder ARE in the report (it reads the
+    // outbox, as team status does), and the team page does not have them yet: said, as status says it.
     const ownDir = path.join(joined.outboxDir, 'writers', joined.writerId, 'records');
     const inFolder = path.join(joined.projectDir, 'writers', joined.writerId, 'records');
     if (path.resolve(ownDir) !== path.resolve(inFolder) && fs.existsSync(ownDir)) {
         const missing = fs.readdirSync(ownDir).filter((f) => f.endsWith('.json') && !fs.existsSync(path.join(inFolder, f))).length;
         if (missing) {
-            deps.print(`  ${plural(missing, 'record file on this laptop is', 'record files on this laptop are')} not in the team project folder yet, `
-                + `so ${missing === 1 ? 'it is' : 'they are'} not in this report.`);
+            deps.print(`  Includes ${missing} record file${missing === 1 ? '' : 's'} from this laptop that ${missing === 1 ? 'has' : 'have'} not been handed in yet.`);
         }
     }
     return held.length ? 1 : 0;
@@ -2266,7 +2493,7 @@ const EXPORT_USAGE = 'Usage: cspeach team export [--out <folder>] [--always | --
 const heldExportLine = (name) => `  ! "${name}" is open in another program, so it was not updated. Close it and run: cspeach team export`;
 /** The CSV export of the team project folder, as the team page reads it, into `dir`. */
 export function writeExports(projectDir, project, dir, deps) {
-    const { register } = registerFor(projectDir);
+    const { register } = registerFor(projectDir, outboxFor(projectDir));
     return writeExportFiles(register, project, dir, (deps.now?.() ?? new Date()).toISOString());
 }
 /**