@cspeach/cli 1.1.48 → 1.1.50

package/dist/tools/project/team_findings.js

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

package/dist/tools/project/team_lane_move.js

@@ -0,0 +1,127 @@
+/**
+ * team_lane_move — the lead moves packages between people (Task 4, 2026-10-20;
+ * B2's tool part).
+ *
+ * On a skill turn the person asks to move packages; the model calls this,
+ * never file_write (lanes.json is CSPeach's: the file tools refuse it in a
+ * team folder). Code checks everything first — joined, the lead, package
+ * names in full, each a package of the baseline, a reason — then the person
+ * answers ONE card. Yes runs the same body as `cspeach team lane move`
+ * (moveLanes): lanes.json plus one plan record, always. No writes nothing.
+ * Headless: refused, nobody is there to answer the card.
+ *
+ * Chat refuses this tool at dispatch (CHAT_LANE_MOVE_REASON). Rule 8 does not
+ * count it (project category): its own card is the one card.
+ */
+import { registerTool } from '../index.js';
+import { activeProject, readLanes, readProjectFile, RegisterError } from '../../register/store.js';
+import { isLead, isPlainName, MAX_PERSON_NAME, moveLanes, planLaneMove } from '../../commands/team.js';
+import { key as folderKey } from '../../projects/project-folder.js';
+import { NOT_JOINED_LINE } from './_team-tool-shared.js';
+import { shown, shownUpTo } from '../../register/atc-file.js';
+export { NOT_JOINED_LINE };
+/** The session runs in another folder than the joined project's. */
+export const notInProjectLine = (folder) => `Open CSPeach in the project folder to move work: ${folder}.`;
+export const NAME_LINE = `Give the person's name as plain text, at most ${MAX_PERSON_NAME} characters.`;
+export const NEEDS_REASON_LINE = "A move needs the person's reason.";
+export const HEADLESS_LINE = 'This needs a person at the keyboard.';
+/** Live re-run L1: one sentence so the model never reads to-fix as "no decision yet". */
+export const AFTER_MOVE_NEXT = "Tell the person what moved: the moved packages' own counts. "
+    + 'to-fix objects are decided as fix and not started; decided counts every recorded decision. Do not edit lanes.json.';
+const MAX_REASON = 300;
+const fail = (content) => ({ content, is_error: true });
+const sentence = (s) => (/[.!?]$/.test(s) ? s : `${s}.`);
+async function defaultConfirm(req) {
+    const { cardSlotEmitter } = await import('../../ui/card-slot.js');
+    if (cardSlotEmitter.listenerCount('confirm') > 0) {
+        const { askConfirm } = await import('../../ui/confirm-request.js');
+        return askConfirm(req);
+    }
+    const [{ lineConfirm }, { inkAwarePrompt }] = await Promise.all([import('../../journey/chain.js'), import('../../agent/loop.js')]);
+    return lineConfirm(inkAwarePrompt, (line) => console.log(line))(req);
+}
+async function defaultIdentity() {
+    const { getAuthorIdentity } = await import('../../agent/loop.js');
+    return getAuthorIdentity;
+}
+export async function teamLaneMoveHandler(args, ctx, hooks = {}) {
+    const joined = activeProject();
+    if (!joined)
+        return fail(NOT_JOINED_LINE);
+    // Review round 1 — the move is made from the project's own folder only.
+    if (folderKey(ctx.cwd) !== folderKey(joined.projectDir))
+        return fail(notInProjectLine(shownUpTo(joined.projectDir, 260)));
+    try {
+        const said = [];
+        const deps = {
+            identity: hooks.deps?.identity ?? (await defaultIdentity()),
+            ...hooks.deps,
+            print: (line) => { said.push(line); },
+        };
+        const project = readProjectFile(joined.projectDir);
+        if (!isLead(project, deps))
+            return fail(`Only the lead, ${shown(project.lead.name)}, moves packages.`);
+        const packages = Array.isArray(args.packages) ? args.packages.filter((p) => typeof p === 'string') : [];
+        const to = typeof args.to === 'string' ? args.to : '';
+        if (!packages.some((p) => p.trim()))
+            return fail('Name the packages to move in full, for example ZSD_ORDERS.');
+        if (!to.trim())
+            return fail('Say who the packages go to: a person\'s name or a lane id.');
+        if (!isPlainName(to))
+            return fail(NAME_LINE);
+        const lanes = readLanes(joined.projectDir);
+        const plan = planLaneMove(packages, to, joined, lanes);
+        const reason = typeof args.reason === 'string' ? args.reason.trim() : '';
+        if (!reason)
+            return fail(NEEDS_REASON_LINE);
+        if (reason.length > MAX_REASON)
+            return fail(`Keep the reason under ${MAX_REASON} characters.`);
+        if (plan.kind === 'nothing')
+            return { content: JSON.stringify({ moved: [], reason: plan.line }) };
+        const headless = hooks.headless ?? (await import('../../renderer/tty.js')).isHeadless();
+        if (headless)
+            return fail(HEADLESS_LINE);
+        const from = plan.holders.length ? plan.holders.map((l) => `${shown(l.owner)} (${l.id})`).join(', ') : 'nobody yet';
+        const res = await (hooks.confirm ?? defaultConfirm)({
+            id: 'team-lane-move',
+            tag: 'QUESTION',
+            title: `Move ${plan.names.join(', ')} to ${shown(plan.into.owner)}?`,
+            facts: [`From: ${from}.`, `Why: ${sentence(reason)}`, 'Recorded in the project history.'],
+            choices: [{ value: 'yes', label: 'Yes' }, { value: 'no', label: 'No' }],
+            initial: 0,
+            aliases: { y: 'yes', n: 'no' },
+        });
+        if (res.cancelled || res.value !== 'yes')
+            return { content: JSON.stringify({ moved: [], reason: 'declined' }) };
+        // The card may have waited: the move works on the lanes as they are now.
+        // Task 6 (R5): the result is the view's after the move — each moved package's own
+        // objects and parts, and the lane's total apart from them.
+        const done = moveLanes(plan.names, to, reason, joined, readProjectFile(joined.projectDir), readLanes(joined.projectDir), deps);
+        return { content: JSON.stringify({ ...done, next: AFTER_MOVE_NEXT }) };
+    }
+    catch (e) {
+        if (e instanceof RegisterError)
+            return fail(e.message);
+        throw e;
+    }
+}
+registerTool({
+    name: 'team_lane_move',
+    description: 'Move packages from one person to another in the team project this laptop joined (the lead only). '
+        + 'Give package names in full (no patterns), the person\'s name or lane id, and the person\'s reason in their words. '
+        + 'CSPeach checks it and asks the person on one card; on Yes it changes the lanes and records the move in the project history. '
+        + 'Never edit lanes.json yourself. No SAP call.',
+    isMutating: true,
+    category: 'project',
+    requiresSap: false,
+    input_schema: {
+        type: 'object',
+        properties: {
+            packages: { type: 'array', items: { type: 'string' }, description: 'Package names in full, for example ["ZSD_ORDERS", "ZMM_STOCK"].' },
+            to: { type: 'string', description: 'The person the packages go to (their name), or their lane id.' },
+            reason: { type: 'string', description: 'Why, in the person\'s words. Shown back on the card and kept in the history.' },
+        },
+        required: ['packages', 'to', 'reason'],
+    },
+    handler: (args, ctx) => teamLaneMoveHandler(args, ctx),
+});

package/dist/tools/project/upgrade_merge_progress.js

@@ -1,10 +1,14 @@
 /**
  * upgrade_merge_progress — deterministic reconciliation of N parallel
  * /abap-upgrade-fix progress envelopes (the /abap-upgrade-merge skill's
- * execution seam). See cca_merge.ts for the design rationale: the tool
- * does the arithmetic (battery S4 D6/D7), the model presents; the
- * pre-rendered manifest block is pasted verbatim and persisted by the
- * normal save hook.
+ * execution seam). The tool does the arithmetic (battery S4 D6/D7: models
+ * cannot keep counts consistent with rows by hand), the model presents;
+ * the pre-rendered manifest block is pasted verbatim and persisted by the
+ * normal save hook — persistence stays on the one existing save path
+ * instead of the tool minting envelopes through a second door, and the
+ * extractor's counts-vs-rows validation is a tamper backstop if the model
+ * edits the pasted block. (The twin cca_merge tool was cut 2026-10-20,
+ * drift spec §3.6.)
  *
  * Baseline discipline:
  *   - every input's baselineRef.sha256 must match the merge baseline —

package/dist/tools/text-elements/tools.js

@@ -35,6 +35,7 @@ import { appendPending, finalizeToolCall } from '../../session/pending.js';
 import { snapshots, auditLog } from '@cspeach/sap-client';
 import { ERR } from '../../errors/codes.js';
 import { resolveWriteTransport } from '../transport-resolution.js';
+import { projectTransportForWrite, transportForWrite } from '../../register/project-transport.js';
 import { noteWriteTransport } from '../../repl/current-transport.js';
 import { loadConfig } from '../../config/loader.js';
 import { getEffectiveWriteMode } from '../../repl/mode-cycle.js';
@@ -246,7 +247,12 @@ registerTool({
         if (args.transport && sessionTransport && args.transport !== sessionTransport) {
             ctx.chunkEmitter?.emit('warn', `LLM passed transport=${args.transport} but session current-transport=${sessionTransport}`);
         }
-        const resolved = await resolveWriteTransport(ctx, 'PROG', name, args.transport ?? sessionTransport ?? undefined);
+        // Task 8 (B11) / Task 6: the one choice (transportForWrite) — explicit ?? the project request of
+        // this folder ?? session; the owning lock is looked up inside resolveWriteTransport and wins.
+        const supplied = transportForWrite({
+            op: 'modify', explicit: args.transport, project: projectTransportForWrite(ctx, verify.payload), session: sessionTransport,
+        }).request;
+        const resolved = await resolveWriteTransport(ctx, 'PROG', name, supplied);
         // 2026-10-04 — a plan-grant id never writes into a transport other than the grant's.
         if (grantOwningTransportMismatch(verify.payload, resolved.owning)) {
             return errorEnvelope({ error: ERR.APPROVAL_INVALID, reason: 'transport_mismatch', detail: grantOwningTransportDetail(name, resolved.owning) });

package/dist/tools/tool-loading.js

@@ -58,7 +58,7 @@ export const SKILL_STARTERS = Object.freeze({
     'abap-app': ['app_lane_resolve', 'read_document'],
     'abap-atc-fix': ['sap_atc_run'],
     'abap-cca': ['team_estate', 'sap_atc_run', 'sap_usage_references', 'sap_api_state'],
-    'abap-clean-core': ['sap_api_state', 'sap_atc_run', 'sap_usage_references', 'team_findings'],
+    'abap-clean-core': ['sap_api_state', 'sap_atc_run', 'sap_usage_references', 'team_findings', 'team_lane_move'],
     'abap-data-model': ['sap_create_domain', 'sap_create_data_element'],
     'abap-document': ['sap_usage_references'],
     'abap-handover': ['sap_usage_references'],

package/dist/tools/tool-output-read.js

@@ -95,7 +95,11 @@ export async function toolOutputReadHandler(args, ctx) {
         next = i + 1;
     }
     const rest = all.length - next;
-    return { content: out.join('\n') + (rest > 0 ? `\n... (${rest} more lines — next offset=${next})` : '') };
+    return { content: out.join('\n') + (rest > 0 ? `\n${sliceTrailer(rest, next)}` : '') };
+}
+/** The slice trailer (also refused in SAP writes: tools/cut-markers.ts). */
+export function sliceTrailer(rest, next) {
+    return `... (${rest} more lines — next offset=${next})`;
 }
 registerTool({
     name: 'tool_output_read',

package/dist/tools/update-method-intercept.js

@@ -28,7 +28,9 @@ export class CancelledByUserError extends Error {
  */
 export async function interceptUpdateMethod(client, call, hook) {
     const classSource = await client.getSource({ type: 'CLAS', name: call.className });
-    const currentBody = extractMethodBody(classSource, call.methodName);
+    // C9 (Task 9): the proposed source is the body only, so compare body with
+    // body — the METHOD / ENDMETHOD wrapper lines are not part of the change.
+    const currentBody = methodBodyOf(extractMethodBody(classSource, call.methodName));
     const proposedBody = call.methodSource;
     const result = await hook({
         className: call.className,
@@ -87,6 +89,21 @@ export function extractMethodBody(classSource, methodName) {
     // diff still surfaces the partial body to the user.
     return lines.slice(start).join('\n');
 }
+/**
+ * C9 (Task 9): the lines between `METHOD x.` and `ENDMETHOD.` of a block
+ * from extractMethodBody. Drops the first line when it opens the method and
+ * the last when it closes it; anything else is kept. Empty stays empty.
+ */
+export function methodBodyOf(block) {
+    if (!block)
+        return block;
+    const lines = block.split('\n');
+    if (lines.length > 0 && /^\s*METHOD\b/i.test(lines[0]))
+        lines.shift();
+    if (lines.length > 0 && /^\s*ENDMETHOD\s*\./i.test(lines[lines.length - 1]))
+        lines.pop();
+    return lines.join('\n');
+}
 function stripCommentsAndStrings(line) {
     // Walk the line and replace string-literal contents and trailing `"` comments
     // with spaces so keyword matching ignores them. Cheap and good enough for

package/dist/tools/write-pipeline.js

@@ -28,6 +28,7 @@ import { auditLog, SapError } from '@cspeach/sap-client';
 import { verifyAndSpendApprovalId } from '../approvals/jwt.js';
 import { grantClaimMismatch, grantOwningTransportMismatch, grantOwningTransportDetail } from '../approvals/grant-claims.js';
 import { typeCode } from '../approvals/risk-floor.js';
+import { projectTransportForWrite, transportForWrite } from '../register/project-transport.js';
 import { autoSnapshot, autoSnapshotClassInclude, autoSnapshotMessageClass } from './snapshot.js';
 import { includeSnapshotType } from './include-snapshot.js';
 import { buildWriteChainLine } from '../renderer/verify-chain.js';
@@ -43,6 +44,7 @@ import { resolveWriteTransport } from './transport-resolution.js';
 import { noteWriteTransport } from '../repl/current-transport.js';
 import { presentSafetyConfirmation } from '../repl/safety-confirm.js';
 import { isSafetyConfirmEnabled } from '../repl/safety-mode-state.js';
+import { argsHaveCutNote, CUT_NOTE_REFUSAL } from './cut-markers.js';
 // ── Transcript visibility helpers (D16-display + tour slide-7, 2026-06-12) ──
 //
 // Rule 7 auto-snapshots always fired but the transcript never said so
@@ -333,6 +335,10 @@ function auditOutcome(syntax, stillExists, postCheckError) {
  */
 export async function runWritePipeline(args, ctx, spec) {
     const raw = args;
+    // ── 2026-10-22 — never write our own cut / spill notes into SAP ────────────
+    // First, before the approval is spent or SAP is called (cut-markers.ts).
+    if (argsHaveCutNote(args))
+        return refuse({ error: 'source_has_cut_note', detail: CUT_NOTE_REFUSAL });
     // ── Before the approval is spent (input / capability checks) ──────────────
     if (spec.beforeApproval) {
         const refusal = spec.beforeApproval(args, ctx);
@@ -367,9 +373,17 @@ export async function runWritePipeline(args, ctx, spec) {
     if (spec.transport.mode === 'resolve' || spec.transport.mode === 'fallback-resolve') {
         // D15/D20 — an object already locked in an open request is written under
         // THAT request; any other transport is a guaranteed CTS lock conflict.
-        const supplied = spec.transport.mode === 'fallback-resolve'
-            ? raw.transport ?? ctx.currentTransport?.get() ?? undefined
-            : raw.transport;
+        // Task 8 (B11): one order for every write — owning lock (resolve below)
+        // ?? explicit ?? the project request of this folder ?? the session (where
+        // the mode has always used it). No joined project → null → as before.
+        // Task 6 (project view): the choice is transportForWrite's, the card's too; the
+        // owning lock is looked up below. A 'resolve' write has never used the session.
+        const supplied = transportForWrite({
+            op: spec.approval.op,
+            explicit: raw.transport,
+            project: projectTransportForWrite(ctx, verify.payload),
+            session: spec.transport.mode === 'fallback-resolve' ? ctx.currentTransport?.get() : undefined,
+        }).request;
         const resolved = await resolveWriteTransport(ctx, spec.transport.type(args), spec.transport.name(args), supplied);
         pre.transport = resolved.transport;
         pre.owning = resolved.owning;
@@ -383,8 +397,13 @@ export async function runWritePipeline(args, ctx, spec) {
         }
     }
     else {
-        // Three-tier fallback: explicit arg → session current-transport → none.
-        pre.transport = raw.transport ?? ctx.currentTransport?.get() ?? undefined;
+        // Three-tier fallback: explicit arg → (Task 8) project request → session current-transport → none.
+        pre.transport = transportForWrite({
+            op: spec.approval.op,
+            explicit: raw.transport,
+            project: projectTransportForWrite(ctx, verify.payload),
+            session: ctx.currentTransport?.get(),
+        }).request;
     }
     // ── Gate 2: Snapshot (Rule 7) ─────────────────────────────────────────────
     const snapRefusal = await snapshotGate(args, ctx, spec, pre);

package/dist/ui/approval-modal.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRef, useState } from 'react';
 import { Box, Text, useInput, useStdout } from 'ink';
 import { riskReasonText, shownRiskReasons } from '../approvals/risk-floor.js';
-import { verbLine, viewAffordance, toSourceLines, affectsLine, releaseLines } from '../approvals/op-labels.js';
+import { verbLine, viewAffordance, toSourceLines, affectsLine, releaseLines, behaviourLines } from '../approvals/op-labels.js';
 // BUG-1 (2026-07-05 live smoke): the interactive approval modal mounted
 // DEAD — every keypress ignored — when it appeared after a guarded
 // /abap-plan turn. Root cause is identical to the one AskCard
@@ -41,14 +41,17 @@ export function riskRows(effectiveRisk, width) {
 export const AFFECTS_MAX_ROWS = 2;
 /**
  * The rows under the verb line: "Affects: …" (none when the change names no
- * process), then — Part 3 D12 — a release card's fact lines, each wrapping
- * onto up to AFFECTS_MAX_ROWS rows. Any other change: exactly as before.
+ * process), then "Behaviour: …" (Task 7, up to 3 rows, none when absent),
+ * then — Part 3 D12 — a release card's fact lines, each wrapping onto up to
+ * AFFECTS_MAX_ROWS rows. Any other change: exactly as before.
  */
 export function affectsRows(change, width) {
     const cols = Math.max(1, width - MODAL_CHROME_COLS);
     const line = affectsLine(change);
     return [
         ...(line ? wrapRows(line, cols, AFFECTS_MAX_ROWS) : []),
+        // Task 7 — "Behaviour: …" (at most 3 rows; none when absent or 'none').
+        ...behaviourLines(change, cols),
         ...releaseLines(change).flatMap((l) => wrapRows(l, cols, AFFECTS_MAX_ROWS)),
     ];
 }

package/dist/ui/footer-line.js

@@ -3,6 +3,22 @@ import { Text, useStdout } from 'ink';
 import { useSapState } from './sap-state-store.js';
 import { formatFooterLine, footerStateFrom } from '../renderer/footer-line.js';
 import { inputBoxWidth } from './footer.js';
+import { projectTransport } from '../register/project-transport.js';
+/** How long the footer trusts its last read of the project file (the line redraws often). */
+const PROJECT_READ_MS = 2_000;
+let lastRead = null;
+/**
+ * Task 6 (project view, R8): the request of the project joined in this folder,
+ * read at most every two seconds. Null outside a project folder (never throws:
+ * `projectTransport` reads null for anything it cannot use).
+ */
+export function footerProjectTransport(cwd = process.cwd(), now = Date.now()) {
+    if (lastRead && lastRead.cwd === cwd && now - lastRead.at < PROJECT_READ_MS)
+        return lastRead.request;
+    const request = projectTransport(cwd);
+    lastRead = { cwd, at: now, request };
+    return request;
+}
 /**
  * The one footer line under the input box (piece 2, spec §8) — replaces the
  * StatusLine. Same width as the input box so the two align. Single truncating
@@ -12,5 +28,7 @@ export function FooterLine() {
     const s = useSapState();
     const { stdout } = useStdout();
     const width = inputBoxWidth(stdout?.columns || 80);
-    return _jsx(Text, { wrap: "truncate-end", children: formatFooterLine(footerStateFrom(s), width) });
+    // In a project folder with a request, the footer says it (a write that names none lands there).
+    const project = footerProjectTransport();
+    return _jsx(Text, { wrap: "truncate-end", children: formatFooterLine(footerStateFrom(s, project), width) });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.48",
+  "version": "1.1.50",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, signed skills, safety gates.",
   "keywords": [
     "abap",
@@ -53,8 +53,8 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.90.0",
     "@azure/msal-node": "6.0.1",
-    "@cspeach/register-core": "0.4.0",
-    "@cspeach/sap-client": "0.1.29",
+    "@cspeach/register-core": "0.4.2",
+    "@cspeach/sap-client": "0.1.30",
     "@iarna/toml": "^2.2.5",
     "@inkjs/ui": "^2.0.0",
     "@inquirer/prompts": "^7.0.0",