@cspeach/cli 1.1.30 → 1.1.32

package/dist/tools/filesystem/glob.js

@@ -19,7 +19,8 @@
 import { promises as fs } from 'node:fs';
 import * as path from 'node:path';
 import { registerTool } from '../index.js';
-import { resolveSafePath, assertRealPathContained, PathOutsideRootError, isDenylistedPath, isReadOnlyProjectFile, DENYLIST_DESCRIPTION, } from '../_filesystem-shared.js';
+import { resolveSafePath, assertRealPathContained, PathOutsideRootError, isDenylistedPath, isReadOnlyProjectFile, isSeatReadOnlyFile, DENYLIST_DESCRIPTION, } from '../_filesystem-shared.js';
+import { isReadOnlyRel, isWorkRel, teamWorkRoot, teamWorkTarget } from '../_team-work-path.js';
 const MAX_RESULTS = 500;
 const MAX_FILES_TRAVERSED = 10_000;
 const ALWAYS_SKIPPED_DIRS = new Set([
@@ -85,10 +86,14 @@ export async function globHandler(args, ctx) {
     if (!args.pattern || typeof args.pattern !== 'string') {
         return { content: 'error: pattern is required (non-empty string)', is_error: true };
     }
+    // Task 15 — in a team folder a search root under `.cspeach/<work-subdir>`
+    // is the seat's; `root` is then the seat work root for every check below.
+    const t = args.cwd ? teamWorkTarget(ctx.cwd, args.cwd) : { root: ctx.cwd, path: '' };
+    const root = t.root;
     // Resolve search root — defaults to ctx.cwd
     let searchRoot;
     try {
-        searchRoot = args.cwd ? resolveSafePath(ctx.cwd, args.cwd) : path.resolve(ctx.cwd);
+        searchRoot = args.cwd ? resolveSafePath(root, t.path) : path.resolve(root);
     }
     catch (err) {
         if (err instanceof PathOutsideRootError) {
@@ -115,7 +120,7 @@ export async function globHandler(args, ctx) {
     const wantsCspeach = isCspeachPattern(args.pattern);
     const collected = [];
     let budget = MAX_FILES_TRAVERSED;
-    async function walk(dir, relPrefix) {
+    async function walk(dir, relPrefix, denyRoot = root) {
         if (budget <= 0 || collected.length >= MAX_RESULTS * 4)
             return;
         let entries;
@@ -146,7 +151,7 @@ export async function globHandler(args, ctx) {
                 // work subdirs); the per-file read check decides what is listed.
                 if (ALWAYS_SKIPPED_DIRS.has(ent.name) && !intoCspeach && !inCspeach(relPrefix))
                     continue;
-                await walk(path.join(dir, ent.name), relPath);
+                await walk(path.join(dir, ent.name), relPath, denyRoot);
             }
             else if (ent.isFile()) {
                 budget--;
@@ -154,8 +159,8 @@ export async function globHandler(args, ctx) {
                     continue;
                 // Denylist check on the matched path
                 const abs = path.join(dir, ent.name);
-                const denylist = isDenylistedPath(abs, ctx.cwd);
-                if (denylist.blocked && !isReadOnlyProjectFile(abs, ctx.cwd))
+                const denylist = isDenylistedPath(abs, denyRoot);
+                if (denylist.blocked && !isReadOnlyProjectFile(abs, denyRoot))
                     continue;
                 let mtime = 0;
                 try {
@@ -175,7 +180,7 @@ export async function globHandler(args, ctx) {
     // per-file denylist check below sees real paths too.
     let realRoot;
     try {
-        realRoot = await assertRealPathContained(searchRoot, ctx.cwd);
+        realRoot = await assertRealPathContained(searchRoot, root);
     }
     catch (err) {
         if (err instanceof PathOutsideRootError) {
@@ -184,7 +189,7 @@ export async function globHandler(args, ctx) {
         return { content: `error: ${err instanceof Error ? err.message : String(err)}`, is_error: true };
     }
     for (const cand of [searchRoot, realRoot]) {
-        const verdict = isDenylistedPath(cand, ctx.cwd);
+        const verdict = isDenylistedPath(cand, root);
         if (verdict.blocked) {
             return {
                 content: `error: refusing to list protected path "${verdict.relFromRoot}" (denylist: ${DENYLIST_DESCRIPTION})`,
@@ -193,6 +198,26 @@ export async function globHandler(args, ctx) {
         }
     }
     await walk(realRoot, '');
+    // Task 15 + ruling 27 — a `.cspeach/…` pattern from a TEAM folder's root
+    // lists what a save and the skills left in the seat (working files, saved
+    // results `.cspeach/*.cspeach.json`, lane decisions `.cspeach/lane/*.json`),
+    // as a solo folder lists its own: the seat's `.cspeach` is walked as
+    // `.cspeach`, every file judged against the seat work root, so only those
+    // shapes are listed. The team folder's own copies of those shapes (left
+    // from before) are not listed — file_read would not reach them.
+    const seatRoot = wantsCspeach && searchRoot === path.resolve(ctx.cwd) ? teamWorkRoot(ctx.cwd) : null;
+    if (seatRoot !== null) {
+        for (let i = collected.length - 1; i >= 0; i--) {
+            const rel = collected[i].relPath;
+            if (isWorkRel(rel) || isReadOnlyRel(rel))
+                collected.splice(i, 1);
+        }
+        const seatCspeach = path.join(seatRoot, '.cspeach');
+        // The folder itself must be the seat's, spelled and real (no link on the way).
+        if (isSeatReadOnlyFile(path.join(seatCspeach, '_.cspeach.json'))) {
+            await walk(seatCspeach, '.cspeach', seatRoot);
+        }
+    }
     // Sort by mtime descending, cap at MAX_RESULTS
     collected.sort((a, b) => b.mtime - a.mtime);
     const sample = collected.slice(0, MAX_RESULTS).map((f) => f.relPath);

package/dist/tools/filesystem/grep.js

@@ -22,6 +22,7 @@ import * as path from 'node:path';
 import { registerTool } from '../index.js';
 import { resolveSafePath, assertRealPathContained, PathOutsideRootError, isDenylistedPath, DENYLIST_DESCRIPTION, } from '../_filesystem-shared.js';
 import { globToRegex } from './glob.js';
+import { teamWorkTarget } from '../_team-work-path.js';
 const MAX_MATCHES = 250;
 const MAX_FILES_TRAVERSED = 10_000;
 const MAX_FILE_BYTES = 2_000_000;
@@ -40,9 +41,13 @@ export async function grepHandler(args, ctx) {
     catch (err) {
         return { content: `error: invalid regex — ${err.message}`, is_error: true };
     }
+    // Task 15 — in a team folder a search root under `.cspeach/<work-subdir>`
+    // is the seat's; `root` is then the seat work root for every check below.
+    const t = args.path ? teamWorkTarget(ctx.cwd, args.path) : { root: ctx.cwd, path: '' };
+    const root = t.root;
     let searchRoot;
     try {
-        searchRoot = args.path ? resolveSafePath(ctx.cwd, args.path) : path.resolve(ctx.cwd);
+        searchRoot = args.path ? resolveSafePath(root, t.path) : path.resolve(root);
     }
     catch (err) {
         if (err instanceof PathOutsideRootError) {
@@ -98,7 +103,7 @@ export async function grepHandler(args, ctx) {
                 if (fileFilter && !fileFilter.test(relPath))
                     continue;
                 const abs = path.join(dir, ent.name);
-                const denylist = isDenylistedPath(abs, ctx.cwd);
+                const denylist = isDenylistedPath(abs, root);
                 if (denylist.blocked)
                     continue;
                 let stat;
@@ -135,7 +140,7 @@ export async function grepHandler(args, ctx) {
     // per-file denylist check below sees real paths too.
     let realRoot;
     try {
-        realRoot = await assertRealPathContained(searchRoot, ctx.cwd);
+        realRoot = await assertRealPathContained(searchRoot, root);
     }
     catch (err) {
         if (err instanceof PathOutsideRootError) {
@@ -144,7 +149,7 @@ export async function grepHandler(args, ctx) {
         return { content: `error: ${err instanceof Error ? err.message : String(err)}`, is_error: true };
     }
     for (const cand of [searchRoot, realRoot]) {
-        const verdict = isDenylistedPath(cand, ctx.cwd);
+        const verdict = isDenylistedPath(cand, root);
         if (verdict.blocked) {
             return {
                 content: `error: refusing to search protected path "${verdict.relFromRoot}" (denylist: ${DENYLIST_DESCRIPTION})`,

package/dist/tools/filesystem/read-document.js

@@ -8,6 +8,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, } from '../_filesystem-shared.js';
+import { teamWorkTarget } from '../_team-work-path.js';
 import { extractDocument, DocumentTooLargeError } from './extract-document.js';
 const MAX_LINES = 2000;
 const MAX_BYTES = 50 * 1024 * 1024; // 50 MB
@@ -20,9 +21,11 @@ export async function readDocumentHandler(args, ctx) {
     if (args.limit !== undefined && args.limit < 1) {
         return { content: `error: limit must be a positive integer (got ${args.limit})`, is_error: true };
     }
+    // Task 15 — in a team folder a skill working file is read from the seat.
+    const t = teamWorkTarget(ctx.cwd, args.path);
     let abs;
     try {
-        abs = resolveSafePath(ctx.cwd, args.path);
+        abs = resolveSafePath(t.root, t.path);
     }
     catch (err) {
         if (err instanceof PathOutsideRootError)
@@ -41,7 +44,7 @@ export async function readDocumentHandler(args, ctx) {
     }
     let realAbs;
     try {
-        realAbs = await assertRealPathContained(abs, ctx.cwd);
+        realAbs = await assertRealPathContained(abs, t.root);
     }
     catch (err) {
         if (err instanceof PathOutsideRootError)
@@ -50,7 +53,7 @@ export async function readDocumentHandler(args, ctx) {
             return { content: 'error: file not found', is_error: true };
         return { content: `error: ${err instanceof Error ? err.message : String(err)}`, is_error: true };
     }
-    const denylist = isDenylistedPath(realAbs, ctx.cwd);
+    const denylist = isDenylistedPath(realAbs, t.root);
     if (denylist.blocked) {
         return { content: `error: refusing to read sensitive path "${denylist.relFromRoot}" (denylist: ${DENYLIST_DESCRIPTION})`, is_error: true };
     }

package/dist/tools/lane/app-lane-resolve.js

@@ -284,7 +284,7 @@ export async function appLaneResolveHandler(args, ctx, deps = {}) {
         ctx.chunkEmitter?.emit('info', `Lane chosen by the rules (no confirm card in this terminal): ${shown}.`);
     }
     if (flow?.specGapPath && planCmd) {
-        ctx.pendingDispatch?.set(planCmd);
+        ctx.pendingDispatch?.set(planCmd, { by: 'app' }); // audit M-2: CSPeach's step, never shown as typed
         lines.push('Next: the plan is being created.');
     }
     else if (flow?.specGapPath && headless) {

package/dist/tools/project/cca_merge.js

@@ -30,6 +30,7 @@ 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 };
@@ -98,11 +99,16 @@ export async function ccaMergeHandler(args, ctx) {
     //     mergedFrom:   the input envelopes [{ file, label }]
     //   }
     let detailWritten = true;
-    const detailAbs = isAbsolute(merged.detailPath) ? merged.detailPath : join(ctx.cwd, merged.detailPath);
+    // 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);
     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).
-        await assertWritable(detailAbs, ctx.cwd);
+        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

@@ -0,0 +1,59 @@
+/**
+ * rules_propose — read-only (step 2, Task 10, optional step; spec 2026-10-08 §7 D7).
+ *
+ * "Rule from words": the person says a rule in words, the model turns it into
+ * the decision-rule shape and calls this. Code checks it with register-core's
+ * strict reader against the team project's rules and says it back in plain
+ * words. Nothing is written: the proposal is kept in this process, and the
+ * person saves it from `/rules` (Add the proposed rule → card → Save), lead
+ * only. The model never writes the rules.
+ */
+import { readDecisionRules } from '@cspeach/register-core';
+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';
+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 };
+    try {
+        const project = readProjectFile(joined.projectDir);
+        const current = readDecisionRules(project);
+        if (current.warning)
+            return { content: `${current.warning} Nothing can be added until the file is fixed or the rules are restored (/rules → Restore defaults).`, is_error: true };
+        const edit = addProposed(current.rules, args.rule, { by: 'proposed', at: new Date(0).toISOString() });
+        const rule = edit.after;
+        const { id: _id, on: _on, changedBy: _by, changedAt: _at, ...proposal } = rule;
+        setRuleProposal({ projectId: joined.projectId, proposal, words: ruleWords(rule) });
+        return {
+            content: JSON.stringify({
+                ok: true, id: rule.id, words: ruleWords(rule), note: rule.note, saved: false,
+                next: 'Nothing is saved. Tell the person: open /rules and pick "Add the proposed rule"; it is saved only when they press Save (the lead only). New rules go last: the first rule that is on and holds decides.',
+            }),
+        };
+    }
+    catch (e) {
+        if (e instanceof RegisterError)
+            return { content: e.message, is_error: true };
+        throw e;
+    }
+}
+registerTool({
+    name: 'rules_propose',
+    description: 'Read-only. Check a decision rule the person described in words, for the team project this laptop joined. '
+        + 'Give it as { when: { types?, levelNow?, targetAtMost?, minFindings?, maxFindings?, findingClasses?, onlyClasses?, findingRules? (rule-id prefixes, e.g. SEARCH_PROBLEMATIC_STATEMENTS_FOR_ALV_CALLS), callers?, noOpenForTarget? }, '
+        + 'then: { disposition: keep|fix|rebuild|retire-candidate, target? }, note }. Returns the rule in plain words or why it cannot be read. '
+        + 'Never saves: the person saves it from /rules. No SAP call.',
+    isMutating: false,
+    category: 'project',
+    requiresSap: false,
+    input_schema: {
+        type: 'object',
+        properties: {
+            rule: { type: 'object', description: 'The proposed rule: { when, then, note }. Any id, on or changedBy given is ignored.' },
+        },
+        required: ['rule'],
+    },
+    handler: (args, ctx) => rulesProposeHandler(args, ctx),
+});

package/dist/tools/project/team_estate.js

@@ -0,0 +1,91 @@
+/**
+ * team_estate — read-only (spec 2026-10-06 §10).
+ *
+ * The estate inventory the lead already pulled with `cspeach team discover`:
+ * packages, totals, the usage sentence and its sources, unknowns, modifications
+ * of SAP objects and how far the cross-reference index was read — and, on
+ * request, the objects of named packages with their evidence. What
+ * /abap-cca judges from. No SAP call, no SQL, no write.
+ *
+ * Read from the newest discovery in the team project this laptop joined, or
+ * from the working folder's `discovery/` when no team project is joined.
+ */
+import { estateSummaryOf } from '@cspeach/register-core';
+import { registerTool } from '../index.js';
+import { shownUpTo } from '../../register/findings.js';
+import { activeProject, readEstate } from '../../register/store.js';
+const CAP = 200;
+const MODIFICATIONS = 50;
+const TEXT_CAP = 300;
+const NO_ESTATE = 'No estate inventory yet. The lead runs: cspeach team discover --out <folder>';
+const match = (pattern, value) => new RegExp(`^${pattern.trim().replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`, 'i').test(value);
+/**
+ * Every string cleaned the way a finding title is, before it reaches the model:
+ * the discovery files were written on the lead's laptop out of SAP text.
+ */
+function clean(v, depth = 0) {
+    if (typeof v === 'string')
+        return shownUpTo(v, TEXT_CAP);
+    if (depth > 4 || v === null || typeof v !== 'object')
+        return v;
+    if (Array.isArray(v))
+        return v.map((x) => clean(x, depth + 1));
+    return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, clean(x, depth + 1)]));
+}
+export async function teamEstateHandler(args, ctx) {
+    try {
+        const dir = activeProject()?.projectDir ?? ctx.cwd;
+        const found = readEstate(dir);
+        const summary = found ? estateSummaryOf(found.estate) : null;
+        if (!found || !summary)
+            return { content: NO_ESTATE, is_error: true };
+        const body = {
+            takenAt: summary.takenAt,
+            packages: summary.packages,
+            totals: summary.totals,
+            usageLine: summary.usageLine,
+            usageSources: summary.usageSources,
+            unknowns: summary.unknowns,
+            modifications: summary.modifications.slice(0, MODIFICATIONS),
+            ...(summary.modifications.length > MODIFICATIONS ? { modificationsMore: summary.modifications.length - MODIFICATIONS } : {}),
+            xref: summary.xref,
+        };
+        const patterns = (args.packages ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+        if (patterns.length) {
+            const all = found.objects?.kind === 'estate-objects'
+                && Array.isArray(found.objects.objects)
+                ? found.objects.objects : [];
+            const picked = all.filter((o) => !!o && typeof o === 'object'
+                && typeof o.name === 'string' && typeof o.type === 'string' && typeof o.package === 'string'
+                && patterns.some((p) => match(p, o.package)));
+            body.objects = picked.slice(0, CAP).map((o) => ({
+                type: o.type, name: o.name, package: o.package,
+                changed: o.changed ?? null, callers: o.callers ?? null, batch: o.batch ?? null, usage: o.usage ?? { state: 'unknown' },
+            }));
+            if (picked.length > CAP)
+                body.more = picked.length - CAP;
+            if (!found.objects)
+                body.objectsNote = 'The object list of this inventory could not be read.';
+        }
+        return { content: JSON.stringify(clean(body)) };
+    }
+    catch (e) {
+        return { content: `The estate inventory could not be read: ${e instanceof Error ? e.message : String(e)}`, is_error: true };
+    }
+}
+registerTool({
+    name: 'team_estate',
+    description: 'Read-only. The newest estate inventory the lead pulled with cspeach team discover: packages, totals, usage sources and '
+        + 'the usage sentence, unknowns, modifications of SAP objects, cross-reference coverage. With packages, also the objects of those '
+        + 'packages with callers, batch runs, usage and last change (at most 200). Use it for /abap-cca. No SAP call.',
+    isMutating: false,
+    category: 'project',
+    requiresSap: false,
+    input_schema: {
+        type: 'object',
+        properties: {
+            packages: { type: 'string', description: 'Package patterns, comma-separated, e.g. "ZFI_*,ZOLD_TOOLS". Adds their objects.' },
+        },
+    },
+    handler: (args, ctx) => teamEstateHandler(args, ctx),
+});

package/dist/tools/project/team_findings.js

@@ -5,17 +5,58 @@
  * package patterns) with the findings measurement zero recorded for them, read
  * from the team project this laptop joined. No SAP call, no second ATC run, no
  * write: every decision is still recorded by program code, one Yes per row.
+ *
+ * Pages (guided journey, Task 4): `limit` (default 40, at most 200) and
+ * `after` (the key "TYPE|NAME" of the last object seen) give one page, with
+ * `more` and `next`. Without either, the first 200 and `more`, as before.
+ * While a journey triage is queued in the session, only the page the journey
+ * 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
+ * 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.
  */
-import { dispositionOf, DISPOSITION_WORD, inLane } from '@cspeach/register-core';
+import { dispositionOf, DISPOSITION_WORD, inLane, readDecisionRules, } from '@cspeach/register-core';
 import { registerTool } from '../index.js';
 import { findingsByObject, shownUpTo } from '../../register/findings.js';
 import { registerFor } from '../../register/picture.js';
+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';
 const CAP = 200;
+/** One page when `after` or `limit` is given. */
+const PAGE = 40;
 /** A decision's reason was written on another laptop and goes to the model: cleaned like a finding title, kept whole up to 300. */
 const REASON_CAP = 300;
+/**
+ * Guided journey (Task 7): the triage skill tells the person to record a row
+ * "your way with `cspeach team decide`". In the journey the person types no
+ * command, and the skill is not reseeded in this slice, so the page the
+ * journey hands out carries this note for the model.
+ */
+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.';
 const match = (pattern, value) => new RegExp(`^${pattern.trim().replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`, 'i').test(value);
-export async function teamFindingsHandler(args, _ctx) {
+function usageOf(u) {
+    return {
+        state: u.state,
+        ...(u.source ? { source: shownUpTo(u.source, 60) } : {}),
+        ...(u.period ? { period: { from: shownUpTo(u.period.from, 30), to: shownUpTo(u.period.to, 30) } } : {}),
+        ...(u.lastUsed ? { lastUsed: shownUpTo(u.lastUsed, 30) } : {}),
+        ...(u.why ? { why: shownUpTo(u.why, REASON_CAP) } : {}),
+    };
+}
+/** A number only when the index was read; otherwise why not, in words. */
+function callersOf(c) {
+    if (!c)
+        return 'not read: no estate inventory for this object';
+    return c.read ? c.objects : `not read: ${shownUpTo(c.why, REASON_CAP)}`;
+}
+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 };
@@ -37,8 +78,29 @@ export async function teamFindingsHandler(args, _ctx) {
             objects = objects.filter((o) => patterns.some((p) => match(p, o.package)));
             scope = `packages ${patterns.join(', ')}`;
         }
+        // A journey triage sees only the page the journey handed out.
+        const page = journeyPage(ctx?.session);
+        if (page) {
+            const keys = new Set(page.map((k) => k.toUpperCase()));
+            objects = objects.filter((o) => keys.has(o.key.toUpperCase()));
+        }
+        // An empty after is no after.
+        const paged = (typeof args.after === 'string' && args.after.trim() !== '') || args.limit !== undefined;
+        let start = 0;
+        if (typeof args.after === 'string' && args.after.trim()) {
+            const after = args.after.trim().toUpperCase();
+            const at = objects.findIndex((o) => o.key.toUpperCase() === after);
+            if (at === -1)
+                return { content: `There is no object ${shown(args.after)} in this scope. Leave out after to start at the first.`, is_error: true };
+            start = at + 1;
+        }
+        const limit = !paged ? CAP
+            : Number.isFinite(args.limit) ? Math.min(CAP, Math.max(1, Math.floor(args.limit))) : PAGE;
+        const slice = objects.slice(start, start + limit);
+        const more = objects.length - start - slice.length;
         const findings = findingsByObject(joined.projectDir, joined.outboxDir);
-        const shown = objects.slice(0, CAP).map((o) => {
+        const rules = readDecisionRules(project);
+        const list = slice.map((o) => {
             const f = findings.get(o.key);
             const d = dispositionOf(o.decision);
             return {
@@ -46,9 +108,26 @@ export async function teamFindingsHandler(args, _ctx) {
                 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),
+                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),
             };
         });
-        return { content: JSON.stringify({ teamProject: project.name, scope, objects: shown, ...(objects.length > CAP ? { more: objects.length - CAP } : {}) }) };
+        return {
+            content: JSON.stringify({
+                teamProject: project.name, scope, objects: list,
+                ...(page ? { journey: JOURNEY_NOTE } : {}),
+                ...(rules.warning ? { rulesWarning: rules.warning } : {}),
+                ...(more > 0 ? { more } : {}),
+                ...(paged && more > 0 && slice.length ? { next: slice[slice.length - 1].key } : {}),
+            }),
+        };
     }
     catch (e) {
         return { content: `The team project could not be read: ${e instanceof Error ? e.message : String(e)}`, is_error: true };
@@ -57,7 +136,10 @@ 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 and any decision already recorded. Use it for a /abap-clean-core triage. No SAP call.',
+        + '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.',
     isMutating: false,
     category: 'project',
     requiresSap: false,
@@ -66,6 +148,8 @@ registerTool({
         properties: {
             lane: { type: 'string', description: 'Lane id, e.g. "fin".' },
             packages: { type: 'string', description: 'Package patterns, comma-separated, e.g. "ZCC_DEMO_*". Ignored when lane is given.' },
+            after: { type: 'string', description: 'Page on: the key "TYPE|NAME" of the last object seen (the `next` of the previous page).' },
+            limit: { type: 'number', description: 'Objects per page, 1 to 200 (default 40 when paging). Leave out both after and limit for the first 200.' },
         },
     },
     handler: (args, ctx) => teamFindingsHandler(args, ctx),

package/dist/tools/project/upgrade_merge_progress.js

@@ -32,6 +32,7 @@ import { registerTool } from '../index.js';
 import { mergeUpgradeProgress, renderUpgradeMergeManifest, } from '../../projects/merge-upgrade.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';
 import { resolveDetailFile } from '../../projects/detail-path.js';
 function sha256OfFile(path) {
     return createHash('sha256').update(readFileSync(path)).digest('hex');
@@ -149,11 +150,16 @@ export async function upgradeMergeProgressHandler(args, ctx) {
     //     mergedFrom: the input envelopes [{ file, label }]
     //   }
     let detailWritten = true;
-    const mergedDetailAbs = isAbsolute(merged.detailPath) ? merged.detailPath : join(ctx.cwd, merged.detailPath);
+    // Task 15 — in a team folder the detail file is a working file: the seat's.
+    const t = teamWorkTarget(ctx.cwd, merged.detailPath);
+    const mergedDetailAbs = isAbsolute(t.path) ? t.path : join(t.root, t.path);
     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).
-        await assertWritable(mergedDetailAbs, ctx.cwd);
+        const realDetail = await assertWritable(mergedDetailAbs, 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(mergedDetailAbs), { recursive: true });
         writeFileSync(mergedDetailAbs, JSON.stringify({
             generatedAt: new Date().toISOString(),

package/dist/tools/sap-read.js

@@ -400,9 +400,12 @@ registerTool({
 // -----------------------------------------------------------------------
 // 8. sap_usage_references
 // -----------------------------------------------------------------------
+/** T001 alone has ~20,000 callers on an S/4 box; list the first 200, count the rest. */
+const USAGE_REFERENCES_MAX_LINES = 200;
 registerTool({
     name: 'sap_usage_references',
-    description: 'Find all places where a given ABAP object is referenced (where-used list).',
+    description: 'Find all places where a given ABAP object is referenced (where-used list). '
+        + 'Widely used SAP objects (T001, BUKRS …) can take minutes; prefer custom objects.',
     isMutating: false,
     requiresSap: true,
     input_schema: {
@@ -414,9 +417,23 @@ registerTool({
         required: ['name', 'type'],
     },
     handler: async (args, ctx) => {
-        // usageReferences(objectType, objectName) — type first
-        const refs = await ctx.adt.usageReferences(args.type, args.name);
-        return { content: JSON.stringify(refs, null, 2) };
+        // usageReferences(objectType, objectName) — type first. `unreadable` is
+        // never "no callers" (spec 2026-10-06 §5.3) — and never a bare `[]`.
+        const result = await ctx.adt.usageReferences(args.type, args.name);
+        if (result.status !== 'ok') {
+            return { content: `Where-used could not be read: ${result.note || 'no reason given'}` };
+        }
+        if (result.refs.length === 0)
+            return { content: 'No callers found (where-used read OK)' };
+        const shown = result.refs.slice(0, USAGE_REFERENCES_MAX_LINES).map((r) => `${r.type} ${r.name}`);
+        const hidden = result.refs.length - shown.length;
+        return {
+            content: [
+                `Callers found: ${result.refs.length} (where-used read OK)`,
+                ...shown,
+                ...(hidden > 0 ? [`… and ${hidden} more not shown`] : []),
+            ].join('\n'),
+        };
     },
 });
 // -----------------------------------------------------------------------