@cspeach/cli 1.1.30 → 1.1.31

package/dist/tools/filesystem/extract-xlsx.js

@@ -43,10 +43,11 @@ export function colIndex(ref) {
     return n - 1;
 }
 /** One worksheet's cells as a rectangular grid of strings. */
-export function sheetRows(xml, strings, budget) {
+export function sheetRows(xml, strings, budget, opts = {}) {
+    const maxRows = opts.maxRows ?? MAX_SHEET_ROWS;
     const rows = [];
     for (const rowMatch of xml.matchAll(/<row[^>]*>([\s\S]*?)<\/row>/g)) {
-        if (rows.length >= MAX_SHEET_ROWS || budget.cells <= 0)
+        if (rows.length >= maxRows || budget.cells <= 0)
             break;
         const cells = [];
         for (const cell of rowMatch[1].matchAll(/<c\b([^>]*)>([\s\S]*?)<\/c>|<c\b([^>]*)\/>/g)) {
@@ -68,7 +69,7 @@ export function sheetRows(xml, strings, budget) {
             }
             while (cells.length < at)
                 cells.push('');
-            cells[at] = value.replace(/[\t\r\n]+/g, ' ').trim();
+            cells[at] = (opts.keepLines ? value.replace(/\r\n?/g, '\n') : value.replace(/[\t\r\n]+/g, ' ')).trim();
             budget.cells -= 1;
             if (budget.cells <= 0)
                 break;
@@ -137,3 +138,26 @@ export function extractXlsx(buffer) {
         warnings.push('no cell text found — the workbook may be empty or hold only charts/images');
     return { text, sheets: sheets.length, warnings };
 }
+/**
+ * Every sheet as rows of cell text, for a caller that reads a workbook back as
+ * data (the Plan sheet, spec 2026-10-06 §8). Numbers come back as their text
+ * (`2`, `46000`), shared and inline strings as written, line breaks inside a
+ * cell kept. No row cap: a Plan sheet holds one row per object. Throws on a
+ * file that is not a readable .xlsx.
+ */
+export function readSheets(buffer) {
+    const zip = new AdmZip(buffer);
+    const read = (p) => {
+        const entry = zip.getEntry(p);
+        return entry ? entry.getData().toString('utf-8') : null;
+    };
+    const strings = sharedStrings(read('xl/sharedStrings.xml'));
+    const budget = { cells: Number.POSITIVE_INFINITY };
+    const out = [];
+    for (const s of sheetOrder(read('xl/workbook.xml'), read('xl/_rels/workbook.xml.rels'))) {
+        const xml = read(s.path);
+        if (xml !== null)
+            out.push({ name: s.name, rows: sheetRows(xml, strings, budget, { maxRows: Number.POSITIVE_INFINITY, keepLines: true }) });
+    }
+    return out;
+}

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

@@ -15,6 +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';
 export async function fileEditHandler(args, ctx) {
     // 1. Validate args before any IO
     if (args.old_string === args.new_string) {
@@ -24,9 +25,11 @@ export async function fileEditHandler(args, ctx) {
         };
     }
     // 2. Path containment — sync phase (pure string math)
+    //    Task 15 — in a team folder a skill working file is edited in 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) {
@@ -37,7 +40,7 @@ export async function fileEditHandler(args, ctx) {
     // 3. Path containment — async phase (follows symlinks)
     let realAbs;
     try {
-        realAbs = await assertRealPathContained(abs, ctx.cwd);
+        realAbs = await assertRealPathContained(abs, t.root);
     }
     catch (err) {
         if (err instanceof PathOutsideRootError) {
@@ -49,7 +52,7 @@ export async function fileEditHandler(args, ctx) {
         return { content: `error: ${err instanceof Error ? err.message : String(err)}`, is_error: true };
     }
     // 4. Denylist check: refuse sensitive in-root paths
-    const denylist = isDenylistedPath(realAbs, ctx.cwd);
+    const denylist = isDenylistedPath(realAbs, t.root);
     if (denylist.blocked) {
         return {
             content: `error: refusing to edit sensitive path "${denylist.relFromRoot}" (denylist: ${DENYLIST_DESCRIPTION})`,
@@ -66,6 +69,11 @@ export async function fileEditHandler(args, ctx) {
             is_error: true,
         };
     }
+    // 4c. Team folder: the real path never lies in the shared .cspeach
+    //     (an 8.3 name, a junction or an odd spelling would get it there).
+    if (pointsIntoSharedCspeach(ctx.cwd, realAbs)) {
+        return { content: `error: ${SHARED_CSPEACH_REFUSAL}`, is_error: true };
+    }
     // 5. Read the file
     let content;
     try {
@@ -114,7 +122,7 @@ export async function fileEditHandler(args, ctx) {
         return { content: `error: write failed — ${err.message}`, is_error: true };
     }
     const noun = replacementCount === 1 ? 'replacement' : 'replacements';
-    const relPath = path.relative(path.resolve(ctx.cwd), realAbs).replace(/\\/g, '/');
+    const relPath = path.relative(path.resolve(t.root), realAbs).replace(/\\/g, '/');
     return { content: `edited ${relPath} (${replacementCount} ${noun})` };
 }
 registerTool({

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

@@ -11,6 +11,7 @@
 import { promises as fs } from 'node:fs';
 import { registerTool } from '../index.js';
 import { resolveSafePath, assertRealPathContained, PathOutsideRootError, DENYLIST_DESCRIPTION, isDenylistedPath, isReadOnlyProjectFile } from '../_filesystem-shared.js';
+import { teamReadTarget } from '../_team-work-path.js';
 import { spillToolResult, isUnderSpillRoot } from '../result-spill.js';
 import { basename } from 'node:path';
 const MAX_LINES = 2000;
@@ -22,9 +23,12 @@ export async function fileReadHandler(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, a saved result
+    // (.cspeach/*.cspeach.json) or a lane decision is read from the seat.
+    const t = teamReadTarget(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) {
@@ -34,7 +38,7 @@ export async function fileReadHandler(args, ctx) {
     }
     let realAbs;
     try {
-        realAbs = await assertRealPathContained(abs, ctx.cwd);
+        realAbs = await assertRealPathContained(abs, t.root);
     }
     catch (err) {
         if (err instanceof PathOutsideRootError) {
@@ -48,8 +52,8 @@ export async function fileReadHandler(args, ctx) {
     // Denylist check: refuse sensitive in-root paths. The project's own saved
     // results (.cspeach/*.cspeach.json, .cspeach/lane/*.json) are readable —
     // isReadOnlyProjectFile; the write tools never get this carve-out.
-    const denylist = isDenylistedPath(realAbs, ctx.cwd);
-    if (denylist.blocked && !isReadOnlyProjectFile(realAbs, ctx.cwd)) {
+    const denylist = isDenylistedPath(realAbs, t.root);
+    if (denylist.blocked && !isReadOnlyProjectFile(realAbs, t.root)) {
         return {
             content: `error: refusing to read sensitive path "${denylist.relFromRoot}" (denylist: ${DENYLIST_DESCRIPTION})`,
             is_error: true,

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

@@ -19,6 +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';
 /**
  * 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
@@ -57,9 +58,11 @@ function noteGuideWritten(relPath, ctx) {
 }
 export async function fileWriteHandler(args, ctx) {
     // 1. Path containment — sync phase (pure string math, catches .. traversals)
+    //    Task 15 — in a team folder a skill working file goes to 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) {
@@ -74,7 +77,7 @@ export async function fileWriteHandler(args, ctx) {
     //    `.git` behind a link (`docs -> .git`) or a short name (`GIT~1`).
     let target;
     try {
-        target = await realPathForWrite(abs, ctx.cwd);
+        target = await realPathForWrite(abs, t.root);
     }
     catch (err) {
         if (err instanceof PathOutsideRootError) {
@@ -83,7 +86,7 @@ export async function fileWriteHandler(args, ctx) {
         return { content: `error: ${err instanceof Error ? err.message : String(err)}`, is_error: true };
     }
     // 3. Denylist check: refuse sensitive in-root paths
-    const denylist = isDenylistedPath(target, ctx.cwd);
+    const denylist = isDenylistedPath(target, t.root);
     if (denylist.blocked) {
         return {
             content: `error: refusing to write sensitive path "${denylist.relFromRoot}" (denylist: ${DENYLIST_DESCRIPTION})`,
@@ -99,6 +102,11 @@ export async function fileWriteHandler(args, ctx) {
             is_error: true,
         };
     }
+    // 3c. Team folder: the real landing path never lies in the shared .cspeach
+    //     (an 8.3 name, a junction or an odd spelling would get it there).
+    if (pointsIntoSharedCspeach(ctx.cwd, target)) {
+        return { content: `error: ${SHARED_CSPEACH_REFUSAL}`, is_error: true };
+    }
     // 4. Ensure parent directory exists (no-op if it already does)
     try {
         await fs.mkdir(path.dirname(target), { recursive: true });
@@ -117,7 +125,7 @@ export async function fileWriteHandler(args, ctx) {
         await fs.unlink(tmpPath).catch(() => undefined);
         return { content: `error: write failed — ${err.message}`, is_error: true };
     }
-    const relPath = path.relative(path.resolve(ctx.cwd), target).replace(/\\/g, '/');
+    const relPath = path.relative(path.resolve(t.root), target).replace(/\\/g, '/');
     const bytes = Buffer.byteLength(args.content, 'utf-8');
     noteGuideWritten(relPath, ctx);
     return { content: `wrote ${relPath} (${bytes} bytes)` };

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/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/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,52 @@
  * 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.
  */
 import { dispositionOf, DISPOSITION_WORD, inLane } from '@cspeach/register-core';
 import { registerTool } from '../index.js';
 import { findingsByObject, shownUpTo } from '../../register/findings.js';
 import { registerFor } from '../../register/picture.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 +72,28 @@ 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 list = slice.map((o) => {
             const f = findings.get(o.key);
             const d = dispositionOf(o.decision);
             return {
@@ -46,9 +101,23 @@ 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 },
             };
         });
-        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 } : {}),
+                ...(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 +126,9 @@ 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, and its priority. '
+        + 'Use it for a /abap-clean-core triage. No SAP call.',
     isMutating: false,
     category: 'project',
     requiresSap: false,
@@ -66,6 +137,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),