@cspeach/cli 1.1.47 → 1.1.49

package/dist/tools/_team-work-path.js

@@ -131,3 +131,56 @@ export function pointsIntoSharedCspeach(cwd, realTarget) {
     }
     return false;
 }
+/**
+ * Task 4 (B3, 2026-10-20) — the files a team project is made of. CSPeach
+ * writes them (team commands, cards, team_lane_move); a model's file write
+ * never does. Root-relative path, either separator; segments compared the way
+ * Windows opens them, so `LANES.JSON`, `plan\x.json` or `lanes.json.` count.
+ */
+const TEAM_OWNED_FILES = ['cspeach-team.json', 'lanes.json'];
+const TEAM_OWNED_DIRS = ['writers', 'rulings', 'plan', 'baseline'];
+export function isTeamOwnedRel(rel) {
+    const segs = rel.split(/[\\/]+/).filter((s) => s !== '' && s !== '.');
+    if (!segs.length)
+        return false;
+    const first = nameKey(segs[0]);
+    if (TEAM_OWNED_DIRS.includes(first))
+        return true;
+    return segs.length === 1 && TEAM_OWNED_FILES.includes(first);
+}
+/** The refusal for a model write to one of the team project's own files. */
+export const TEAM_FILE_REFUSAL = 'This file belongs to the project and CSPeach writes it. Say what you want changed instead.';
+/**
+ * True when `cwd` is a team folder and the REAL landing path of a write lies
+ * on one of its own files (isTeamOwnedRel), whatever spelling, link or short
+ * name got it there. Only refuses; never maps anything. A folder without a
+ * team project: always false.
+ */
+export function pointsAtTeamFile(cwd, realTarget) {
+    if (teamWorkRoot(cwd) === null)
+        return false;
+    const absRoot = path.resolve(cwd);
+    const realOf = (p) => { try {
+        return realpathSync.native(p);
+    }
+    catch {
+        return null;
+    } };
+    for (const base of new Set([absRoot, realOf(absRoot) ?? absRoot])) {
+        const rel = path.relative(base, realTarget);
+        if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel))
+            continue;
+        if (isTeamOwnedRel(rel))
+            return true;
+    }
+    // A link into one of the project folders: the real folder, not its name.
+    for (const dir of TEAM_OWNED_DIRS) {
+        const real = realOf(path.join(absRoot, dir));
+        if (real === null)
+            continue;
+        const rel = path.relative(real, realTarget);
+        if (rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel)))
+            return true;
+    }
+    return false;
+}

package/dist/tools/approval.js

@@ -3,7 +3,7 @@ import { notModifiableText } from './release-texts.js';
 import { isModifiable, knownObjectCount } from '@cspeach/sap-client';
 import { registerTool } from './index.js';
 import { isHeadless, shouldUseInk } from '../renderer/tty.js';
-import { effectiveRisk, riskReasonText, typeCode } from '../approvals/risk-floor.js';
+import { effectiveRisk, riskResultFields, typeCode } from '../approvals/risk-floor.js';
 import { objectsWithSyntaxErrors } from './syntax-state.js';
 import { noteWriteTransport } from '../repl/current-transport.js';
 /**
@@ -19,6 +19,7 @@ function noteApprovedTransport(t) {
 import { mintChangeApproval } from '../approvals/jwt.js';
 import { canonicalApprovalObject } from '../approvals/canonical.js';
 import { renderPlanGate, renderPerChangeApprovalV3 } from '../approvals/render.js';
+import { collapseImplicitActivates } from '../approvals/visible-changes.js';
 import { loadConfig, effectiveApprovals } from '../config/loader.js';
 import { getPlanGrant, grantCovers, noteGrantUse, noteApprovalsSetting, grantClaimsFor } from '../approvals/plan-grant.js';
 import { normalizeObjectType } from '../projects/plan-objects.js';
@@ -29,6 +30,8 @@ import { markPlanGateApproved } from '../repl/rule8-detector.js';
 import { getEffectiveWriteMode } from '../repl/mode-cycle.js';
 import { getCurrentTransport } from '../repl/current-transport.js';
 import { displayTransport } from '../approvals/op-labels.js';
+import { canonicalApprovalObject as bareObjectName } from '../approvals/canonical.js';
+import { projectTransport, SEVERAL_REQUESTS_LABEL, transportForWrite, TRANSPORT_REQUEST } from '../register/project-transport.js';
 import { NOT_ON_THIS_RELEASE, approvalRefusedByProfile } from '../sap/profile-gate.js';
 import { isGuardedRunActive, getCurrentPhaseWrites, notePlanDeviation, PLAN_DEVIATION_DETAIL, } from '../commands/plan-gate.js';
 /**
@@ -171,6 +174,39 @@ async function attachReleaseFacts(changes, ctx) {
     }
     return null;
 }
+/** What the owning-request lookup accepts as a name (sap-client's identifier guard): nothing else is looked up. */
+const LOOKUP_NAME = /^[A-Z0-9_/]+$/;
+/**
+ * Task 8 (B11) — before any card: for every modify/delete, the open request
+ * that already holds the object, looked up the way the write tools resolve it
+ * (resolveWriteTransport: one owning request forces the write into it). The
+ * model's value is dropped first, on every change. One owning request →
+ * `c.owningTransport`; several candidates, a capped or failed lookup, or a
+ * free object → nothing, so the card is today's. Standalone's `ctx.adt`
+ * throws on every call, which is the failed-lookup path. Never refuses.
+ */
+async function attachOwningTransport(changes, ctx) {
+    for (const c of changes) {
+        if (!c)
+            continue;
+        // Never the model's — on any change.
+        delete c.owningTransport;
+        if (c.op !== 'modify' && c.op !== 'delete')
+            continue;
+        const name = bareObjectName(String(c.object ?? ''));
+        if (!LOOKUP_NAME.test(name))
+            continue;
+        try {
+            const r = await ctx.adt.transportForObject(typeCode(c.type), name);
+            const t = typeof r?.transport === 'string' ? r.transport.trim().toUpperCase() : '';
+            if (!r?.capped && TRANSPORT_REQUEST.test(t))
+                c.owningTransport = t;
+        }
+        catch {
+            // Best-effort, as at write time: the card stays as it is today.
+        }
+    }
+}
 registerTool({
     name: 'request_approval',
     description: 'Request user approval for one or more SAP mutations. Returns approval_ids (one per change) to be passed as approval_id on matching mutating tool calls.',
@@ -192,6 +228,7 @@ registerTool({
                         diff: { type: 'string', description: 'For a CREATE op this MUST be the exact, complete source that will be written — verbatim, character-for-character, NOT a description, summary, or paraphrase. It is shown to the developer in the approval box as the exact thing they are approving, so a one-line summary here means they approve a write they cannot inspect. For a MODIFY op, the real unified diff of the change (again verbatim, not a description).' },
                         package: { type: 'string', description: 'Target package (development class) for the object, if known — shown on the approval box' },
                         affects: { type: 'string', description: 'The standard SAP process this change runs inside, in plain words — REQUIRED for type ENHO (a BAdI implementation): name the BAdI, its spot and what calls it, e.g. "purchase order check before save (BAdI ME_PROCESS_PO_CUST, spot ES_MM_PO)". Shown on the approval card.' },
+                        behaviour: { type: 'string', description: "What changes for callers or users, in plain words, before the write: a changed type, a dropped step, a check that returns fewer rows. One or two short sentences, no greeting, no joke. 'none' when nothing changes." },
                     },
                     required: ['op', 'object', 'type'],
                 },
@@ -274,6 +311,8 @@ registerTool({
         const releaseRefusal = await attachReleaseFacts(args.changes ?? [], ctx);
         if (releaseRefusal)
             return { content: JSON.stringify(releaseRefusal), is_error: true };
+        // Task 8 (B11) — the request that already holds each modified object, before any card.
+        await attachOwningTransport(args.changes ?? [], ctx);
         let sapCfg = cfg.sap[ctx.sapAlias];
         const riskCtx = {
             sapAlias: ctx.sapAlias,
@@ -320,8 +359,7 @@ registerTool({
                     approved: true,
                     approved_by: 'the plan object list',
                     approval_ids: ids,
-                    effective_risk: eff.level,
-                    raised_by: eff.raisedBy.map(riskReasonText),
+                    ...riskResultFields(eff),
                 }),
             };
         }
@@ -334,9 +372,31 @@ registerTool({
         // displayTransport in approvals/op-labels.ts. The plan gate is a batch
         // summary: session fallback applies only when the batch contains a
         // create (the only op it is true for).
+        //
+        // Task 8 (B11): a modify/delete already held by a request is forced into
+        // it (owningTransport, looked up above); with none named, the project
+        // request of this folder is used (null outside a joined project, so the
+        // card is today's). One order for card and write: owning lock
+        // (modify/delete) ?? explicit ?? project ?? session. The plan gate names
+        // the request the writes will use (owner decision, final review): each
+        // write's own transportForWrite choice, as on its per-change card. When
+        // they all land in one request, the card names it; when every write has a
+        // request and they differ, it says "several requests" (never one request
+        // for every object). A write with no request at all leaves today's "no
+        // transport". A plan with no write at all (activate only) keeps today's fact.
         const sessionTransport = getCurrentTransport();
-        const planGateTransport = args.transport
-            ?? (changes.some((c) => c.op === 'create') ? sessionTransport ?? undefined : undefined);
+        const project = projectTransport(ctx.cwd);
+        const session = changes.some((c) => c.op === 'create') ? sessionTransport : undefined;
+        const writes = changes.filter((c) => c.op === 'create' || c.op === 'modify' || c.op === 'delete');
+        const choices = writes.map((c) => transportForWrite({
+            op: c.op, explicit: args.transport, owning: c.owningTransport, project, session,
+        }));
+        const requests = new Set(choices.map((c) => c.request));
+        const planGateTransport = writes.length === 0
+            ? args.transport ?? transportForWrite({ op: 'create', project, session }).label
+            : requests.size === 1
+                ? (choices.every((c) => c.from === choices[0].from) ? choices[0].label : choices[0].request)
+                : requests.has(undefined) ? undefined : SEVERAL_REQUESTS_LABEL;
         // Task 6 (agentic-flow, 2026-07-03) — guarded plan chains disable
         // auto-approve entirely: the user's auto_approve consent was given for
         // hand-driven turns, not for phases the harness auto-dispatched. When the
@@ -386,8 +446,7 @@ registerTool({
                     approved: true,
                     auto_approved: true,
                     approval_ids: ids,
-                    effective_risk: eff.level,
-                    raised_by: eff.raisedBy.map(riskReasonText), // round 8 item 4: plain words, never codes
+                    ...riskResultFields(eff),
                 }),
             };
         }
@@ -408,8 +467,7 @@ registerTool({
                     message: 'Headless run: writes cannot be approved without a user at the terminal, and headless runs never auto-approve. ' +
                         'No approval IDs were minted — do not attempt any write operations. ' +
                         'Summarise the proposed changes so the user can re-run interactively or switch write_mode to "advisory-only".',
-                    effective_risk: eff.level,
-                    raised_by: eff.raisedBy.map(riskReasonText), // round 8 item 4: plain words, never codes
+                    ...riskResultFields(eff),
                 }),
                 is_error: true,
             };
@@ -419,16 +477,22 @@ registerTool({
         // it skips the redundant per-change prompts that produced the "3 prompts
         // for one task" complaint. Review-each falls back to the per-change
         // gate. Cancel rejects the whole plan.
+        //
+        // Task 9 (C8): only for more than one VISIBLE change — the same count the
+        // plan gate shows (an activate whose write is in the list is not a change
+        // a person sees). A modify + its activate on one class gets the
+        // per-change card only; the activate follows its approved write below.
         let skipPerChangeGates = false;
-        if (changes.length > 1) {
+        // Raw keys on purpose: the same collapse (and count) the plan gate displays.
+        const visibleCount = collapseImplicitActivates(changes).length;
+        if (visibleCount > 1) {
             const mode = await renderPlanGate(args.summary, changes, planGateTransport, eff, ctx.sapAlias);
             if (mode === 'cancel') {
                 return {
                     content: JSON.stringify({
                         approved: false,
                         reason: 'plan_rejected',
-                        effective_risk: eff.level,
-                        raised_by: eff.raisedBy.map(riskReasonText), // round 8 item 4: plain words, never codes
+                        ...riskResultFields(eff),
                     }),
                 };
             }
@@ -461,7 +525,18 @@ registerTool({
             if (c.op === 'modify' || c.op === 'create')
                 writeKeys.add(`${c.type}:${canonicalApprovalObject(c.object)}`);
         }
-        for (const c of changes) {
+        // Task 9 (C8): with no plan gate, an activate listed before its own write
+        // waits for that write's card, so one change is one card. With the plan
+        // gate (more than one visible change) the order stays as today.
+        const followsItsWrite = (c) => c.op === 'activate' && writeKeys.has(`${c.type}:${canonicalApprovalObject(c.object)}`);
+        const cardOrder = visibleCount > 1 ? changes : [
+            ...changes.filter((c) => !followsItsWrite(c)),
+            ...changes.filter(followsItsWrite),
+        ];
+        // The cards may run in another order; the ids go back in the declared
+        // changes[] order (final review), so ids[i] still belongs to changes[i].
+        const idFor = new Map();
+        for (const c of cardOrder) {
             const objKey = `${c.type}:${canonicalApprovalObject(c.object)}`;
             let outcome;
             if (skipPerChangeGates) {
@@ -474,14 +549,14 @@ registerTool({
                 outcome = { approved: false, reason: 'sibling_write_skipped' };
             }
             else {
-                outcome = await renderPerChangeApprovalV3(c, eff, displayTransport(c.op, args.transport, sessionTransport));
+                outcome = await renderPerChangeApprovalV3(c, eff, displayTransport(c.op, args.transport, sessionTransport, c.owningTransport, project));
             }
             if (outcome.approved) {
                 if (c.op === 'modify' || c.op === 'create')
                     autoApproveActivateFor.add(objKey);
                 // Task A3: mint via the canonical path (same code path the write
                 // tools' validators compare against).
-                approvalIds.push(await mintChangeApproval(c, ctx.session.id));
+                idFor.set(c, await mintChangeApproval(c, ctx.session.id));
             }
             else {
                 if (outcome.reason === '__cancel_turn__') {
@@ -489,8 +564,7 @@ registerTool({
                         content: JSON.stringify({
                             approved: false,
                             reason: 'user_cancelled_turn',
-                            effective_risk: eff.level,
-                            raised_by: eff.raisedBy.map(riskReasonText), // round 8 item 4: plain words, never codes
+                            ...riskResultFields(eff),
                         }),
                     };
                 }
@@ -504,6 +578,11 @@ registerTool({
                 rejections.push({ object: c.object, op: c.op, reason: outcome.reason ?? 'skipped' });
             }
         }
+        for (const c of changes) {
+            const id = idFor.get(c);
+            if (id)
+                approvalIds.push(id);
+        }
         // Tell Rule 8 the user has explicitly approved (some/all of) this
         // batch via the plan-gate / per-change flow. Suppresses the redundant
         // Rule 8 prompt at every subsequent dispatch this turn.
@@ -516,8 +595,7 @@ registerTool({
                 approved: approvalIds.length > 0,
                 approval_ids: approvalIds,
                 skipped: rejections,
-                effective_risk: eff.level,
-                raised_by: eff.raisedBy.map(riskReasonText), // round 8 item 4: plain words, never codes
+                ...riskResultFields(eff),
             }),
         };
     },

package/dist/tools/filesystem/file-edit.js

@@ -15,7 +15,7 @@ import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { registerTool } from '../index.js';
 import { resolveSafePath, assertRealPathContained, PathOutsideRootError, DENYLIST_DESCRIPTION, isDenylistedPath, blockedExecutableExtension, } from '../_filesystem-shared.js';
-import { pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, teamWorkTarget } from '../_team-work-path.js';
+import { pointsAtTeamFile, pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, TEAM_FILE_REFUSAL, teamWorkTarget } from '../_team-work-path.js';
 export async function fileEditHandler(args, ctx) {
     // 1. Validate args before any IO
     if (args.old_string === args.new_string) {
@@ -74,6 +74,13 @@ export async function fileEditHandler(args, ctx) {
     if (pointsIntoSharedCspeach(ctx.cwd, realAbs)) {
         return { content: `error: ${SHARED_CSPEACH_REFUSAL}`, is_error: true };
     }
+    // 4d. Team folder (Task 4, B3): the project's own files — cspeach-team.json,
+    //     lanes.json, writers/, rulings/, plan/, baseline/ — are CSPeach's to
+    //     write. Judged on the real landing path. A folder without a team
+    //     project never gets here.
+    if (pointsAtTeamFile(ctx.cwd, realAbs)) {
+        return { content: `error: ${TEAM_FILE_REFUSAL}`, is_error: true };
+    }
     // 5. Read the file
     let content;
     try {

package/dist/tools/filesystem/file-write.js

@@ -19,7 +19,7 @@ import { promises as fs, readFileSync } from 'node:fs';
 import * as path from 'node:path';
 import { registerTool } from '../index.js';
 import { resolveSafePath, realPathForWrite, PathOutsideRootError, DENYLIST_DESCRIPTION, isDenylistedPath, blockedExecutableExtension, } from '../_filesystem-shared.js';
-import { pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, teamWorkTarget } from '../_team-work-path.js';
+import { pointsAtTeamFile, pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, TEAM_FILE_REFUSAL, teamWorkTarget } from '../_team-work-path.js';
 /**
  * 2026-09-23 (Glenn's first run) — a standalone run writes GUIDE.md and said
  * nothing about it. He opened it in a text editor, then tried to drop it into
@@ -107,6 +107,13 @@ export async function fileWriteHandler(args, ctx) {
     if (pointsIntoSharedCspeach(ctx.cwd, target)) {
         return { content: `error: ${SHARED_CSPEACH_REFUSAL}`, is_error: true };
     }
+    // 3d. Team folder (Task 4, B3): the project's own files — cspeach-team.json,
+    //     lanes.json, writers/, rulings/, plan/, baseline/ — are CSPeach's to
+    //     write. Judged on the real landing path. A folder without a team
+    //     project never gets here.
+    if (pointsAtTeamFile(ctx.cwd, target)) {
+        return { content: `error: ${TEAM_FILE_REFUSAL}`, is_error: true };
+    }
     // 4. Ensure parent directory exists (no-op if it already does)
     try {
         await fs.mkdir(path.dirname(target), { recursive: true });

package/dist/tools/local-files.js

@@ -0,0 +1,31 @@
+// cspeach-cli/src/tools/local-files.ts
+/**
+ * Startup wiring for the persisted `local_files` config toggle.
+ *
+ * When `cfg.local_files === true`, the otherwise flag-gated filesystem tools
+ * (file_read/file_write/file_edit/glob/grep) are force-enabled via the
+ * in-memory override in `_flag.ts`, BEFORE the first listTools()/turn. This is
+ * what makes /abap-fiori-build runnable — it writes local app files.
+ *
+ * The toggle is PERSISTED (config.toml), not re-consented each session, so
+ * `applyLocalFilesConfig` returns an announce line the entry point prints
+ * whenever the tools are live — the user must always see that local file
+ * access is on this session (trust-visibility requirement). The FS tools'
+ * own cwd-sandbox (writes confined to the project root; .cspeach/.env/.git
+ * denylisted) still applies regardless of this toggle.
+ */
+import { enableToolFlags } from './_flag.js';
+/** The exact tool NAMEs the flag uses (file_read → CSPEACH_TOOL_FILE_READ). */
+export const LOCAL_FILE_TOOLS = ['file_read', 'file_write', 'file_edit', 'glob', 'grep'];
+/**
+ * Apply the persisted `local_files` toggle. When on, force-enables the FS
+ * tools and returns a one-line announce string (undefined when off, so the
+ * caller prints nothing). `cwd` is surfaced so the user sees exactly which
+ * directory tree read/write/edit operate under.
+ */
+export function applyLocalFilesConfig(localFiles, cwd) {
+    if (localFiles !== true)
+        return undefined;
+    enableToolFlags([...LOCAL_FILE_TOOLS]);
+    return `local file tools enabled (read/write/edit under ${cwd}) — cspeach config set local_files off to disable`;
+}

package/dist/tools/project/_merge-shared.js

@@ -1,6 +1,6 @@
 /**
- * Shared input-resolution for the two merge tools (cca_merge,
- * upgrade_merge_progress).
+ * Shared input-resolution for the merge tool (upgrade_merge_progress;
+ * its cca_merge twin was cut 2026-10-20, drift spec §3.6).
  *
  * Inputs arrive as the same `@<token>` forms the rest of the CLI uses
  * (workspace.ts:resolveAtToken): absolute path, relative path, or a bare

package/dist/tools/project/_team-tool-shared.js

@@ -0,0 +1,5 @@
+/**
+ * Lines the team project tools share, so they never drift apart.
+ * Model-facing: the developer runs the command, the model does not.
+ */
+export const NOT_JOINED_LINE = 'This laptop has not joined a team project. The developer runs: cspeach team join <folder>';

package/dist/tools/project/cca_merge.js

@@ -29,8 +29,6 @@ import { dirname, isAbsolute, join } from 'node:path';
 import { registerTool } from '../index.js';
 import { mergeCcaAssessments, renderCcaMergeManifest, } from '../../projects/merge-cca.js';
 import { loadEnvelope, MANIFEST_PASTE_INSTRUCTIONS } from './_merge-shared.js';
-import { assertWritable } from '../_filesystem-shared.js';
-import { pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, teamWorkTarget } from '../_team-work-path.js';
 export async function ccaMergeHandler(args, ctx) {
     if (!Array.isArray(args.inputs) || args.inputs.some((i) => typeof i !== 'string')) {
         return { content: 'error: inputs must be an array of envelope paths / @-tokens.', is_error: true };
@@ -99,16 +97,8 @@ export async function ccaMergeHandler(args, ctx) {
     //     mergedFrom:   the input envelopes [{ file, label }]
     //   }
     let detailWritten = true;
-    // Task 15 — in a team folder the detail file is a working file: the seat's.
-    const t = teamWorkTarget(ctx.cwd, merged.detailPath);
-    const detailAbs = isAbsolute(t.path) ? t.path : join(t.root, t.path);
+    const detailAbs = isAbsolute(merged.detailPath) ? merged.detailPath : join(ctx.cwd, merged.detailPath);
     try {
-        // SEC (review round 2): the real landing path must stay in the project and
-        // not be protected (a junctioned .cspeach/<domain> -> .git is refused).
-        const realDetail = await assertWritable(detailAbs, t.root);
-        // Final fix wave, item 3 — never into the shared .cspeach of a team folder.
-        if (pointsIntoSharedCspeach(ctx.cwd, realDetail))
-            throw new Error(SHARED_CSPEACH_REFUSAL);
         mkdirSync(dirname(detailAbs), { recursive: true });
         writeFileSync(detailAbs, JSON.stringify({
             generatedAt: new Date().toISOString(),

package/dist/tools/project/rules_propose.js

@@ -13,10 +13,11 @@ import { registerTool } from '../index.js';
 import { activeProject, readProjectFile, RegisterError } from '../../register/store.js';
 import { addProposed, ruleWords } from '../../register/rules-edit.js';
 import { setRuleProposal } from '../../register/rule-proposal.js';
+import { NOT_JOINED_LINE } from './_team-tool-shared.js';
 export async function rulesProposeHandler(args, _ctx) {
     const joined = activeProject();
     if (!joined)
-        return { content: 'This laptop has not joined a team project. The developer runs: cspeach team join <folder>', is_error: true };
+        return { content: NOT_JOINED_LINE, is_error: true };
     try {
         const project = readProjectFile(joined.projectDir);
         const current = readDecisionRules(project);

package/dist/tools/project/team_findings.js

@@ -13,12 +13,19 @@
  * handed out (journey/flow.ts, at most 40 keys) is shown: the skill needs no
  * change to work in pages.
  *
- * Decision rules (step 2, D6): every row carries `ruleProposal` — the first
+ * Decision rules (step 2, D6): every row carries `proposal` — the first
  * rule of the team project (or the defaults) that decides it, or null when no
  * rule does and the row is CSPeach's judgement. Rules the file names but this
  * build cannot read give `rulesWarning` (one line) and the defaults.
+ *
+ * Task 6 (project view, R5/R6): every fact comes from the project view —
+ * `scope: { kind, name, total, parts }` says the whole scope (so a decided row
+ * is never read as "none triaged"), each row says its part, its decision
+ * (`{ what, by, reason, reason_from }`), its level and who decided it, and its
+ * target with where it came from (never a bare letter). The usage sentence the
+ * rows share is said once, in `usage_note`; a row with usage of its own keeps it.
  */
-import { dispositionOf, DISPOSITION_WORD, inLane, readDecisionRules, } from '@cspeach/register-core';
+import { DECISION_WORDS, partCounts, projectView, readDecisionRules, } from '@cspeach/register-core';
 import { registerTool } from '../index.js';
 import { findingsByObject, shownUpTo } from '../../register/findings.js';
 import { registerFor } from '../../register/picture.js';
@@ -26,6 +33,7 @@ import { ruleProposalOf } from '../../register/decision-rules.js';
 import { activeProject, readProjectFile } from '../../register/store.js';
 import { shown } from '../../register/atc-file.js';
 import { journeyPage } from '../../journey/flow.js';
+import { NOT_JOINED_LINE } from './_team-tool-shared.js';
 const CAP = 200;
 /** One page when `after` or `limit` is given. */
 const PAGE = 40;
@@ -39,7 +47,7 @@ const REASON_CAP = 300;
  */
 export const JOURNEY_NOTE = "This triage is one step of CSPeach's guided clean-core run. The person types no commands: "
     + 'never suggest a cspeach command (not cspeach team decide, not any other). Say instead that CSPeach asks about each row, '
-    + 'and a row skipped is asked again later. Use plain words: "your objects", "your project" — never team, lane, outbox or writer.';
+    + 'and a row skipped is asked about again at the end of this run, or when the person says carry on. Use plain words: "your objects", "your project" — never team, lane, outbox or writer.';
 const match = (pattern, value) => new RegExp(`^${pattern.trim().replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`, 'i').test(value);
 function usageOf(u) {
     return {
@@ -50,6 +58,30 @@ function usageOf(u) {
         ...(u.why ? { why: shownUpTo(u.why, REASON_CAP) } : {}),
     };
 }
+/** The usage every row shares when none of them was read: unknown, with the one sentence that says why. */
+const sharedUsage = (u) => u.state === 'unknown' && Object.keys(u).every((k) => k === 'state' || k === 'why');
+export const usageNoteOf = (why) => `Usage, for every row without a usage field: unknown.${why ? ` ${why}` : ''}`;
+export const OWN_USAGE_NOTE = 'Every row gives its own usage.';
+/**
+ * Task 6 (R6): the usage sentence most rows of the page share goes to one note;
+ * those rows drop their usage. Any other row keeps its own.
+ */
+function usageNote(usages) {
+    const counts = new Map();
+    for (const u of usages)
+        if (sharedUsage(u))
+            counts.set(String(u.why ?? ''), (counts.get(String(u.why ?? '')) ?? 0) + 1);
+    if (!counts.size)
+        return { note: OWN_USAGE_NOTE, shared: () => false };
+    let why = '';
+    let most = 0;
+    for (const [w, n] of counts)
+        if (n > most) {
+            why = w;
+            most = n;
+        }
+    return { note: usageNoteOf(why || undefined), shared: (u) => sharedUsage(u) && String(u.why ?? '') === why };
+}
 /** A number only when the index was read; otherwise why not, in words. */
 function callersOf(c) {
     if (!c)
@@ -59,25 +91,30 @@ function callersOf(c) {
 export async function teamFindingsHandler(args, ctx) {
     const joined = activeProject();
     if (!joined)
-        return { content: 'This laptop has not joined a team project. The developer runs: cspeach team join <folder>', is_error: true };
+        return { content: NOT_JOINED_LINE, is_error: true };
     try {
         const project = readProjectFile(joined.projectDir);
         const { register } = registerFor(joined.projectDir, joined.outboxDir);
         const laneId = args.lane?.trim();
         const patterns = (args.packages ?? '').split(',').map((s) => s.trim()).filter(Boolean);
-        let objects = register.objects;
-        let scope = 'all objects';
+        // The project view, built once: the scope, its parts and every row read it.
+        const view = projectView(register, project);
+        let objects = view.all.objects;
+        let scope = { kind: 'project', name: project.name };
         if (laneId) {
             const lane = register.lanes.find((l) => l.id.toLowerCase() === laneId.toLowerCase());
             if (!lane)
                 return { content: `There is no lane "${laneId}". Lanes: ${register.lanes.map((l) => l.id).join(', ') || 'none yet'}.`, is_error: true };
-            objects = objects.filter((o) => inLane(o, lane.id));
-            scope = `lane ${lane.id}`;
+            // The lane's own objects (design §2): an object another lane's pattern also matches is its owner's.
+            objects = view.lanes.find((s) => s.scope.kind === 'lane' && s.scope.id === lane.id)?.objects ?? [];
+            scope = { kind: 'lane', name: lane.id };
         }
         else if (patterns.length) {
             objects = objects.filter((o) => patterns.some((p) => match(p, o.package)));
-            scope = `packages ${patterns.join(', ')}`;
+            scope = { kind: 'packages', name: shown(patterns.join(', ')) };
         }
+        // The header is the whole scope's, not the page's.
+        const header = { ...scope, total: objects.length, parts: partCounts(objects) };
         // A journey triage sees only the page the journey handed out.
         const page = journeyPage(ctx?.session);
         if (page) {
@@ -100,28 +137,42 @@ export async function teamFindingsHandler(args, ctx) {
         const more = objects.length - start - slice.length;
         const findings = findingsByObject(joined.projectDir, joined.outboxDir);
         const rules = readDecisionRules(project);
-        const list = slice.map((o) => {
+        const registerObject = new Map(register.objects.map((o) => [o.key, o]));
+        const usages = slice.map((v) => usageOf(registerObject.get(v.key).evidence.usage));
+        const usage = usageNote(usages);
+        const list = slice.map((v, i) => {
+            const o = registerObject.get(v.key);
             const f = findings.get(o.key);
-            const d = dispositionOf(o.decision);
+            const d = v.decision;
             return {
-                type: o.type, name: o.name, package: o.package,
-                owner: register.lanes.find((l) => l.id === o.lane)?.owner ?? null,
-                decided: d ? { disposition: DISPOSITION_WORD[d], level: o.decision.level ?? null, targetLevel: o.decision.targetLevel ?? null, reason: typeof o.decision.reason === 'string' ? shownUpTo(o.decision.reason, REASON_CAP) : null } : null,
-                baselineAt: f?.baselineAt ?? null, baseline: f?.baseline ?? [], openNow: o.openFindings,
-                // Evidence (spec 2026-10-06 §10): usage only with its source, callers only when the index was read,
-                // and when the code last CHANGED — which is never use.
-                usage: usageOf(o.evidence.usage),
+                type: v.type, name: v.name, package: v.package,
+                owner: v.owner?.name ?? null,
+                part: v.part,
+                // The view's decision, in words: who decided it and whose words the reason is. Never a bare target letter.
+                decided: d.what === 'none' ? null : {
+                    what: DECISION_WORDS[d.what],
+                    by: d.by ? shown(d.by.name) : null,
+                    reason: d.reason?.text ? shownUpTo(d.reason.text, REASON_CAP) : null,
+                    reason_from: d.reason?.from ?? 'none',
+                },
+                level: { decided: v.level.decided, by: v.level.by ? shown(v.level.by.name) : null },
+                target: { level: v.target.level, from: v.target.from },
+                // The rule that decides this row, from the latest counted run's findings; null = no rule decides.
+                proposal: ruleProposalOf(o, f, rules.rules),
+                baselineAt: f?.baselineAt ?? null, baseline: f?.baseline ?? [], openNow: v.proof.open,
+                // Evidence (spec 2026-10-06 §10): usage only with its source (the shared sentence is usage_note),
+                // callers only when the index was read, and when the code last CHANGED — which is never use.
+                ...(usage.shared(usages[i]) ? {} : { usage: usages[i] }),
                 callers: callersOf(o.evidence.callers),
                 lastChanged: o.evidence.changed?.at ? shownUpTo(o.evidence.changed.at, 30) : null,
-                retireCandidate: o.retireCandidate,
-                priority: { band: o.priority.effective.band, source: o.priority.effective.source },
-                // The rule that decides this row, from the latest counted run's findings; null = no rule decides.
-                ruleProposal: ruleProposalOf(o, f, rules.rules),
+                priority: { band: v.priority.band, source: v.priority.source },
+                retireCandidate: d.what === 'retire-candidate',
             };
         });
         return {
             content: JSON.stringify({
-                teamProject: project.name, scope, objects: list,
+                // An empty page has no rows to share a usage: no note.
+                teamProject: project.name, scope: header, ...(list.length ? { usage_note: usage.note } : {}), objects: list,
                 ...(page ? { journey: JOURNEY_NOTE } : {}),
                 ...(rules.warning ? { rulesWarning: rules.warning } : {}),
                 ...(more > 0 ? { more } : {}),
@@ -135,11 +186,13 @@ export async function teamFindingsHandler(args, ctx) {
 }
 registerTool({
     name: 'team_findings',
-    description: 'Read-only. The objects of a lane (or package patterns) in the team project this laptop joined, with the findings '
-        + 'measurement zero recorded for each, any decision already recorded, and per object: usage (state and source), callers from the '
-        + 'index (or why they were not read), last change (a change, not use), whether it is a retire candidate, its priority, and '
-        + 'ruleProposal: the decision rule that decides the row (null = no rule decides; your judgement). '
-        + 'Use it for a /abap-clean-core triage. No SAP call.',
+    description: 'Read-only. The objects of a lane (or package patterns) in the team project this laptop joined. '
+        + 'scope gives the whole scope: total and parts (how many are decided, fixed, not decided yet). Per object: its part, '
+        + 'the findings measurement zero recorded, any decision already recorded (decided: what, by whom, the reason and whose '
+        + 'words it is), the level and who decided it, the target and where it came from, usage when it has its own (otherwise '
+        + 'usage_note says it once), callers from the index (or why they were not read), last change (a change, not use), whether '
+        + 'it is a retire candidate, its priority, and proposal: the decision rule that decides the row (null = no rule decides; '
+        + 'your judgement). Use it for a /abap-clean-core triage. No SAP call.',
     isMutating: false,
     category: 'project',
     requiresSap: false,