@cspeach/cli 1.1.48 → 1.1.50

package/dist/session/fresh-start.js

@@ -0,0 +1,15 @@
+export function startFreshConversation(session) {
+    session.messages = [];
+    session.turnInterrupted = false;
+    session.turnInterruptedReason = undefined;
+    delete session.last_context_tokens;
+    delete session.lastAutoCompactTurn;
+    // An open plan step does not survive: "continue" must not resume it.
+    session.plan_in_flight = null;
+}
+/** The one line /new prints. */
+export function freshStartText(lane) {
+    return lane === 'chat'
+        ? 'Fresh start · the conversation is cleared.'
+        : 'Fresh start · the conversation is cleared · the next prompt picks a skill again';
+}

package/dist/skill-catalog.js

@@ -200,13 +200,6 @@ export const SKILL_CATALOG = [
         whenToUse: 'pick this when a multi-dev team ran scoped fix slices in parallel — merges N progress files for /abap-upgrade-verify',
         asks: 'which progress files. e.g. "merge the three @upgrade-progress files here"',
     },
-    {
-        name: 'abap-cca-merge',
-        category: 'Upgrade / Migrate',
-        description: 'Reconcile multiple parallel /abap-cca assessment files into one consolidated cca-assessment',
-        whenToUse: 'pick this when multiple consultants ran scoped /abap-cca slices — merges N assessments into one team view',
-        asks: 'which assessments. e.g. "merge the ZFI and ZSD cca files"',
-    },
     {
         name: 'abap-migrate',
         category: 'Upgrade / Migrate',
@@ -277,6 +270,10 @@ export const SKILL_CATALOG = [
 export const SKILL_ALIASES = {
     'abap-dump-analyze': 'abap-dump',
     'abap-dump-triage': 'abap-dump',
+    // Drift spec §3.6 (2026-10-20) — /abap-cca-merge is cut. A stale proxy
+    // router or an old manifest may still answer with the old name; a chat
+    // hand_off to it lands here too (tools/hand-off.ts normaliseSkill).
+    'abap-cca-merge': 'abap-cca',
 };
 /**
  * Resolve a (possibly retired) skill name to its current catalog name.

package/dist/tools/_filesystem-shared.js

@@ -45,6 +45,13 @@ export const BLOCKED_BASENAME_RE = /^\.env(\.|$)/i;
  * (skill detail files) — only the rest of `.cspeach/` is blocked.
  */
 export const DENYLIST_DESCRIPTION = [...BLOCKED_PREFIXES, '.env*'].join(', ');
+/**
+ * The paging trailer of file_read and read_document (also refused in SAP
+ * writes: tools/cut-markers.ts).
+ */
+export function rereadTrailer(more, nextOffset) {
+    return `... (truncated, ${more} more lines — re-read with offset=${nextOffset})`;
+}
 /**
  * Executable / script file extensions the filesystem write tools refuse to
  * create. Defense-in-depth: shell_exec / background_run only run a safelisted

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/cut-markers.js

@@ -0,0 +1,47 @@
+/**
+ * Cut-note guard for SAP writes (2026-10-22, owner go).
+ *
+ * Large tool results reach the model shortened, each with a note of ours:
+ *  - agent/oversized-results.ts — "[result cut: N more chars …]" and
+ *    "[removed: this result was too large to send …]";
+ *  - agent/cold-prune.ts — "[result elided at cold start — N chars]";
+ *  - tools/result-spill.ts — the spill preview: the pointer line ("… full
+ *    output saved to …; read slices with tool_output_read(…)"), the omitted
+ *    line ("[… lines A–B omitted …]" / "[… N lines omitted — tool_output_read
+ *    offset=K …]") and a clipped line ("… [+N chars]");
+ *  - the paging trailers (tool_output_read, file_read, read_document) and the
+ *    @file attachment note "... [truncated, file exceeds 64 KB]".
+ * A model that writes back what it saw would write those notes into SAP in
+ * place of the real code. The write pipeline refuses any write whose
+ * arguments carry one of them, before the approval is spent or SAP is
+ * called. Only our own notes: "[image N]" and other bracket text can be
+ * legitimate ABAP and are never refused. A write without them is untouched.
+ */
+export const CUT_NOTE_REFUSAL = 'This source still contains a note that part of an earlier read was cut or moved to a file. Read the full source first (in parts if needed), then write the complete text.';
+const CUT_NOTE_RES = [
+    /\[result cut: \d+ more chars\./,
+    /\[removed: this result was too large to send — \d+ chars\./,
+    /\[result elided at cold start — \d+ chars\]/,
+    /full output saved to .*; read slices with tool_output_read\(path, offset, limit\)\]/,
+    /\[… lines \d+–\d+ omitted …\]/,
+    /\[… \d+ lines omitted — tool_output_read offset=\d+ …\]/,
+    /… \[\+\d+ chars\]/,
+    // tool-output-read.ts sliceTrailer; _filesystem-shared.ts rereadTrailer
+    // (file_read, read_document); workspace.ts ATTACHMENT_TRUNCATED_NOTE (@file).
+    /\.\.\. \(\d+ more lines — next offset=\d+\)/,
+    /\.\.\. \(truncated, \d+ more lines — re-read with offset=\d+\)/,
+    /\.\.\. \[truncated, file exceeds 64 KB\]/,
+];
+/** True when `text` carries one of our cut / removed / spill notes. */
+export function hasCutNote(text) {
+    return CUT_NOTE_RES.some((re) => re.test(text));
+}
+/** True when any string anywhere in `value` (objects, arrays) carries a cut note. */
+export function argsHaveCutNote(value, depth = 0) {
+    if (typeof value === 'string')
+        return hasCutNote(value);
+    if (depth > 8 || value === null || typeof value !== 'object')
+        return false;
+    const items = Array.isArray(value) ? value : Object.values(value);
+    return items.some((v) => argsHaveCutNote(v, depth + 1));
+}

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

@@ -50,11 +50,59 @@ async function extractPdf(buffer, maxPages) {
     }).join('\n\n');
     return { text: body, pages: total, warnings: hasText ? [] : [NO_TEXT_WARNING] };
 }
+/**
+ * Longest line a document read hands to the model. A longer one is split
+ * into consecutive lines, so paging by line reaches every character; a real
+ * line (a dense PDF page is a few thousand chars) fits well inside it.
+ */
+export const DOC_MAX_LINE_CHARS = 10_000;
+/** Longest picture description kept in an `[image N: …]` marker. */
+const IMAGE_ALT_MAX_CHARS = 120;
+// 2026-10-22 customer bug — mammoth's default inlines every picture as a
+// base64 data: URI (a 1.5 MB picture ≈ 670k tokens on ONE line), and the
+// prompt was then too long for every later turn. Pictures never become text:
+// mammoth gets an img converter that never reads the bytes, and turndown
+// writes each <img> as a short numbered marker.
+const NO_IMAGE_DATA = mammoth.images.imgElement(async () => ({ src: '' }));
+/** Remove any data: URI left in the text (a linked or pasted picture). */
+export function stripDataUris(text) {
+    return text.replace(/data:[a-z0-9.+\/-]*(?:;[a-z0-9=._-]+)*;base64,[a-z0-9+\/=]*/gi, '');
+}
+/**
+ * Split every line longer than `maxLineChars` into consecutive lines of at
+ * most `maxLineChars`, so nothing is lost. Text whose lines all fit is
+ * returned unchanged (the same string).
+ */
+export function splitLongLines(text, maxLineChars) {
+    const lines = text.split('\n');
+    if (!lines.some((l) => l.length > maxLineChars))
+        return text;
+    const out = [];
+    for (const l of lines) {
+        if (l.length <= maxLineChars) {
+            out.push(l);
+            continue;
+        }
+        for (let i = 0; i < l.length; i += maxLineChars)
+            out.push(l.slice(i, i + maxLineChars));
+    }
+    return out.join('\n');
+}
 async function extractDocx(buffer) {
     // Fix 2: esModuleInterop:true makes the default import correct — no interop guard needed.
-    const { value: html } = await mammoth.convertToHtml({ buffer });
+    const { value: html } = await mammoth.convertToHtml({ buffer }, { convertImage: NO_IMAGE_DATA });
     const td = new TurndownService({ headingStyle: 'atx', bulletListMarker: '-' });
-    const raw = td.turndown(html).trim();
+    let images = 0;
+    td.addRule('pictureMarker', {
+        filter: 'img',
+        replacement: (_content, node) => {
+            images++;
+            const alt = (node.getAttribute('alt') ?? '')
+                .replace(/\s+/g, ' ').trim().slice(0, IMAGE_ALT_MAX_CHARS).trim();
+            return alt ? `[image ${images}: ${alt}]` : `[image ${images}]`;
+        },
+    });
+    const raw = stripDataUris(td.turndown(html)).trim();
     // Turndown emits "-   text" (3 spaces) for bullet items; collapse to "- text".
     // The regex anchors on a line-leading "-" so mid-line double spaces (e.g. "Col A  Col B")
     // and indented nested bullets (leading whitespace is captured in $1) are both preserved.

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-read.js

@@ -10,7 +10,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 { resolveSafePath, assertRealPathContained, PathOutsideRootError, DENYLIST_DESCRIPTION, isDenylistedPath, isReadOnlyProjectFile, rereadTrailer } from '../_filesystem-shared.js';
 import { teamReadTarget } from '../_team-work-path.js';
 import { spillToolResult, isUnderSpillRoot } from '../result-spill.js';
 import { basename } from 'node:path';
@@ -74,7 +74,7 @@ export async function fileReadHandler(args, ctx) {
     const numbered = window.map((line, i) => `${offset + i + 1}\t${line}`).join('\n');
     const truncated = allLines.length > offset + window.length;
     const trailer = truncated
-        ? `\n... (truncated, ${allLines.length - (offset + window.length)} more lines — re-read with offset=${offset + window.length})`
+        ? `\n${rereadTrailer(allLines.length - (offset + window.length), offset + window.length)}`
         : '';
     // Task 17 (spec D12) — a window above 8 000 chars is saved to the session
     // spill file and previewed; today's trailer stays last, byte-identical. A

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/filesystem/read-document.js

@@ -7,10 +7,15 @@
 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 { resolveSafePath, assertRealPathContained, PathOutsideRootError, DENYLIST_DESCRIPTION, isDenylistedPath, rereadTrailer, } from '../_filesystem-shared.js';
 import { teamWorkTarget } from '../_team-work-path.js';
-import { extractDocument, DocumentTooLargeError } from './extract-document.js';
+import { extractDocument, DocumentTooLargeError, splitLongLines, DOC_MAX_LINE_CHARS, } from './extract-document.js';
 const MAX_LINES = 2000;
+// 2026-10-22 customer bug — one read returned ~2.3M tokens and every later
+// turn of the session failed. A read now has a hard size: long lines are split
+// (DOC_MAX_LINE_CHARS) and one call returns at most DOC_MAX_CHARS_PER_READ
+// chars (about 60k tokens); the offset trailer says where to read on.
+export const DOC_MAX_CHARS_PER_READ = 200_000;
 const MAX_BYTES = 50 * 1024 * 1024; // 50 MB
 const MAX_PAGES = 150;
 const SUPPORTED = new Set(['.pdf', '.docx', '.xlsx']);
@@ -89,14 +94,25 @@ export async function readDocumentHandler(args, ctx) {
             : 'document';
     const header = `${args.path} — ${scale}`;
     const warnLines = result.warnings.map((w) => `[warning] ${w}`);
-    const allLines = result.text.replace(/\n$/, '').split('\n');
+    const allLines = splitLongLines(result.text.replace(/\n$/, ''), DOC_MAX_LINE_CHARS).split('\n');
     const offset = Math.max(0, args.offset ?? 0);
     const limit = Math.min(args.limit ?? MAX_LINES, MAX_LINES);
     const window = allLines.slice(offset, offset + limit);
+    // Total cap: stop before the line that would pass it (always keep one line).
+    let used = 0;
+    let fit = 0;
+    for (const line of window) {
+        const cost = `${offset + fit + 1}\t${line}`.length + 1;
+        if (fit > 0 && used + cost > DOC_MAX_CHARS_PER_READ)
+            break;
+        used += cost;
+        fit++;
+    }
+    window.length = fit;
     const numbered = window.map((line, i) => `${offset + i + 1}\t${line}`).join('\n');
     const truncated = allLines.length > offset + window.length;
     const trailer = truncated
-        ? `\n... (truncated, ${allLines.length - (offset + window.length)} more lines — re-read with offset=${offset + window.length})`
+        ? `\n${rereadTrailer(allLines.length - (offset + window.length), offset + window.length)}`
         : '';
     return { content: [header, ...warnLines, numbered].join('\n') + trailer };
 }

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/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);