@cspeach/cli 1.1.53 → 1.1.55

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

@@ -138,7 +138,7 @@ export function pointsIntoSharedCspeach(cwd, realTarget) {
  * 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'];
+const TEAM_OWNED_DIRS = ['writers', 'rulings', 'plan', 'baseline', 'specs'];
 export function isTeamOwnedRel(rel) {
     const segs = rel.split(/[\\/]+/).filter((s) => s !== '' && s !== '.');
     if (!segs.length)
@@ -150,6 +150,30 @@ export function isTeamOwnedRel(rel) {
 }
 /** 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.';
+/**
+ * F5 — a write into a team build's shared specs/ folder: the refusal names
+ * the route, so the model takes it on the same turn instead of saving the
+ * spec somewhere else.
+ */
+export const SPECS_REFUSAL = 'Specs in this folder are written and shared by CSPeach, never by a file write. For a new or changed spec, hand_off with skill "abap-spec-gap"; to build a ready spec, hand_off with skill "abap-app".';
+/** The refusal for a team-owned target: the specs/ route, or today's line. */
+export function teamFileRefusalFor(cwd, realTarget) {
+    const root = teamWorkRoot(cwd);
+    if (root === null)
+        return TEAM_FILE_REFUSAL;
+    const realOf = (p) => { try {
+        return realpathSync.native(p);
+    }
+    catch {
+        return p;
+    } };
+    for (const specs of new Set([path.join(path.resolve(cwd), 'specs'), realOf(path.join(path.resolve(cwd), 'specs'))])) {
+        const rel = path.relative(specs, realTarget);
+        if (rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel))
+            return SPECS_REFUSAL;
+    }
+    return TEAM_FILE_REFUSAL;
+}
 /**
  * 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

package/dist/tools/cap/sap-link-tool.js

@@ -115,6 +115,8 @@ registerTool({
                 `SAP link ${r.reused ? 'already on' : 'on'}: ${r.handle.url} → ${ctx.sapAlias}`,
                 `Services: ${r.services.join(', ')}`,
             ];
+            if (r.seatNote)
+                lines.push(r.seatNote);
             if (r.roleNote)
                 lines.push(r.roleNote);
             if (r.tlsNote)

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 { pointsAtTeamFile, pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, TEAM_FILE_REFUSAL, teamWorkTarget } from '../_team-work-path.js';
+import { pointsAtTeamFile, pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, teamFileRefusalFor, 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) {
@@ -79,7 +79,7 @@ export async function fileEditHandler(args, ctx) {
     //     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 };
+        return { content: `error: ${teamFileRefusalFor(ctx.cwd, realAbs)}`, is_error: true };
     }
     // 5. Read the file
     let content;

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 { pointsAtTeamFile, pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, TEAM_FILE_REFUSAL, teamWorkTarget } from '../_team-work-path.js';
+import { pointsAtTeamFile, pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, teamFileRefusalFor, 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
@@ -112,7 +112,7 @@ export async function fileWriteHandler(args, ctx) {
     //     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 };
+        return { content: `error: ${teamFileRefusalFor(ctx.cwd, target)}`, is_error: true };
     }
     // 4. Ensure parent directory exists (no-op if it already does)
     try {

package/dist/tools/hand-off.js

@@ -107,7 +107,22 @@ registerTool({
         if (request.length > HAND_OFF_REQUEST_MAX) {
             return bad('HAND_OFF_INVALID', `request is too long (${request.length} chars; at most ${HAND_OFF_REQUEST_MAX}). Say it in one short sentence with the object names.`);
         }
-        const command = buildHandOffCommand(skill, request);
+        let command = buildHandOffCommand(skill, request);
+        // F9a (2026-10-29 live run): in a team build folder a hand-off to the
+        // build workflow carries the ready spec, so the app flow starts at the
+        // lane step instead of refusing for want of an @file.
+        if (skill === 'abap-app' && !request.includes('@')) {
+            const { readySpecFor, notReadyLine } = await import('../lane/ready-spec.js');
+            const picked = await readySpecFor(ctx.cwd ?? process.cwd(), request);
+            if (picked && 'notReady' in picked) {
+                return bad('HAND_OFF_SPEC_NOT_READY', `${notReadyLine(picked.notReady)} Tell the person; do not build another spec instead.`);
+            }
+            if (picked && 'ask' in picked) {
+                return bad('HAND_OFF_SPEC_NEEDED', `more than one spec here is ready to build: ${picked.ask.join('; ')}. Ask which one, then hand off with its title in the request.`);
+            }
+            if (picked)
+                command = picked.command;
+        }
         if (isPlanResumeCommand(command)) {
             return bad('PLAN_RESUME_HARNESS_OWNED', 'Plan continuation is owned by CSPeach; never hand off "/abap-plan --resume".');
         }

package/dist/tools/project/spec_answers_record.js

@@ -17,6 +17,11 @@
  * shared team `.cspeach` (teamReadTarget's fallback there is read-only), and
  * only a spec-gap envelope.
  *
+ * 2026-10-28: a spec shared in a team build (`specs/<slug>/<name>.cspeach.json`)
+ * is answered with the blocker form's record mode: the revision is validated,
+ * each answer becomes its own record in `specs/<slug>/answers/`, and the
+ * author's file is never written.
+ *
  * Every refusal is one line and writes nothing: a sub-agent or reader child,
  * a path outside the project, a missing file, a file that is not a spec-gap
  * envelope in `.cspeach/`, the shared team `.cspeach`, an unknown id, a blank
@@ -34,7 +39,9 @@ import { resolveSafePath, assertRealPathContained, PathOutsideRootError, isReadO
 import { pointsIntoSharedCspeach, SHARED_CSPEACH_REFUSAL, teamReadTarget } from '../_team-work-path.js';
 import { SPEC_ANSWERS_RECORD_TOOL } from '../../projects/blocker-answers-note.js';
 import { readProjectFile } from '../../projects/status.js';
-import { openBlockers, saveBlockerAnswers } from '../../projects/answer-blockers.js';
+import { applyBlockerAnswers, openBlockers, saveBlockerAnswers } from '../../projects/answer-blockers.js';
+import { validateEnvelope } from '../../projects/validate.js';
+import { composeSpec, isSharedSpecPath, readAnswers, sharedSpecTargetFor, specAuthorFor, writeAnswerRecord, SPECS_DIR, } from '../../projects/spec-share.js';
 export const SPEC_ANSWERS_RECORD = SPEC_ANSWERS_RECORD_TOOL;
 /** Fix round 1 (item 4): the longest answer recorded. */
 export const MAX_ANSWER = 2000;
@@ -58,6 +65,14 @@ function realOr(p) {
         return path.resolve(p);
     }
 }
+/** The build project when `real` is a spec right inside `<team>/specs/<slug>/`, else null. */
+function sharedSpecFile(cwd, real) {
+    const target = sharedSpecTargetFor(cwd, 'spec-gap');
+    if (!target || !isSharedSpecPath(target.teamDir, real) || !/\.cspeach\.json$/i.test(real))
+        return null;
+    const rel = path.relative(realOr(path.join(target.teamDir, SPECS_DIR)), real);
+    return rel.split(path.sep).length === 2 ? { projectId: target.projectId } : null;
+}
 export async function specAnswersRecordHandler(args, ctx) {
     // Fix round 1 (item 5): only the main conversation records answers (a child could race the form).
     if (ctx.subagent || ctx.readerMode)
@@ -83,9 +98,13 @@ export async function specAnswersRecordHandler(args, ctx) {
     // fallback to it is for reading only, as for the write tools.
     if (pointsIntoSharedCspeach(ctx.cwd, real))
         return fail(`${SHARED_CSPEACH_REFUSAL} ${NOTHING_SAVED}`);
+    // 2026-10-28 — a spec shared in a team build (specs/<slug>/<name>.cspeach.json)
+    // is answered like the blocker form answers it there: one answer record per
+    // question beside it, the author's file never rewritten.
+    const shared = sharedSpecFile(ctx.cwd, real);
     // Fix round 1 (item 3): only a saved result the CLI writes (.cspeach/<name>.cspeach.json),
     // the same shape file_read's denylist carve-out opens (lane files excluded).
-    if (!isReadOnlyProjectFile(real, t.root) || !/\.cspeach\.json$/i.test(real)) {
+    if (!shared && (!isReadOnlyProjectFile(real, t.root) || !/\.cspeach\.json$/i.test(real))) {
         return fail(`${given} is not a spec-gap file. ${NOTHING_SAVED}`);
     }
     if (!(await fs.stat(real)).isFile())
@@ -93,6 +112,9 @@ export async function specAnswersRecordHandler(args, ctx) {
     let env;
     try {
         env = readProjectFile(real);
+        // R11: only the answers recorded for this envelope.
+        if (shared)
+            env = composeSpec(env, readAnswers(path.dirname(real)).filter((a) => a.file === path.basename(real)));
     }
     catch {
         return fail(`${given} is not a spec-gap file. ${NOTHING_SAVED}`);
@@ -138,15 +160,46 @@ export async function specAnswersRecordHandler(args, ctx) {
     }
     if (problems.length > 0)
         return fail(`${problems.join('; ')}. ${NOTHING_SAVED}`);
-    // The form's own save step: apply with the session identity, validate, write in place.
-    const saved = saveBlockerAnswers(real, env, answers, await sessionIdentity(), new Date().toISOString());
-    if (!saved.ok)
-        return fail(`the revised file did not validate (${saved.error}). ${NOTHING_SAVED}`);
+    const identity = await sessionIdentity();
+    const nowIso = new Date().toISOString();
+    let revised;
+    if (shared) {
+        // The blocker form's record mode: check the revision, write records, never the file.
+        revised = applyBlockerAnswers(env, answers, identity, nowIso);
+        const check = validateEnvelope(JSON.parse(JSON.stringify(revised)));
+        if (!check.ok)
+            return fail(`the revised file did not validate (${check.error.message}). ${NOTHING_SAVED}`);
+        const specDir = path.dirname(real);
+        const by = specAuthorFor(shared.projectId, identity.name);
+        const done = [];
+        try {
+            for (const [gapId, answer] of answers) {
+                writeAnswerRecord(specDir, {
+                    projectId: shared.projectId, slug: path.basename(specDir), file: path.basename(real), gapId, answer, by, at: nowIso,
+                });
+                done.push(gapId);
+            }
+        }
+        catch (err) {
+            // A shared folder can fail part-way (full, read-only, sync lock): say what was recorded.
+            const why = err instanceof Error ? err.message : String(err);
+            return fail(done.length === 0
+                ? `could not write the answer records (${why}). ${NOTHING_SAVED}`
+                : `could not write every answer record (${why}). Recorded: ${done.join(', ')}. The others were not saved.`);
+        }
+    }
+    else {
+        // The form's own save step: apply with the session identity, validate, write in place.
+        const saved = saveBlockerAnswers(real, env, answers, identity, nowIso);
+        if (!saved.ok)
+            return fail(`the revised file did not validate (${saved.error}). ${NOTHING_SAVED}`);
+        revised = saved.revised;
+    }
     const rel = path.relative(realOr(t.root), real).split(path.sep).join('/');
-    const open = openBlockers(saved.revised);
+    const open = openBlockers(revised);
     return {
         content: [
-            `Saved in ${rel}.`,
+            shared ? `Recorded for ${rel} (the spec file itself is unchanged).` : `Saved in ${rel}.`,
             ...order.map((id) => `${id}: recorded.`),
             open.length === 0
                 ? 'No blockers are still open.'
@@ -157,7 +210,7 @@ export async function specAnswersRecordHandler(args, ctx) {
 registerTool({
     name: SPEC_ANSWERS_RECORD,
     description: 'Record answers the developer gives in chat to spec-gap questions, in the saved spec-gap file '
-        + '(.cspeach/<name>.cspeach.json): blockers or any question in the file. The file exists only once the document has been saved, after your turn. Give each question id as in the file '
+        + '(.cspeach/<name>.cspeach.json, or in a team build specs/<slug>/<name>.cspeach.json): blockers or any question in the file. The file exists only once the document has been saved, after your turn. Give each question id as in the file '
         + '(for example gap-004) with its answer, at most 2,000 characters. '
         + 'Answering a question that already has an answer replaces it. Nothing is saved if any id or answer is refused. '
         + 'Never edit .cspeach.json files with shell or file-edit tools. No SAP call.',

package/dist/tools/project/team_findings.js

@@ -30,7 +30,7 @@ import { registerTool } from '../index.js';
 import { findingsByObject, shownUpTo } from '../../register/findings.js';
 import { registerFor } from '../../register/picture.js';
 import { ruleProposalOf } from '../../register/decision-rules.js';
-import { activeProject, readProjectFile } from '../../register/store.js';
+import { activeProject, coreProject, 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';
@@ -98,7 +98,7 @@ export async function teamFindingsHandler(args, ctx) {
         const laneId = args.lane?.trim();
         const patterns = (args.packages ?? '').split(',').map((s) => s.trim()).filter(Boolean);
         // The project view, built once: the scope, its parts and every row read it.
-        const view = projectView(register, project);
+        const view = projectView(register, coreProject(project));
         let objects = view.all.objects;
         let scope = { kind: 'project', name: project.name };
         if (laneId) {

package/dist/tools/seat-gate.js

@@ -0,0 +1,41 @@
+import { WRITE_TOOLS } from './write-mode.js';
+export const SEAT_READ_ONLY_REASON = 'This seat reads SAP and never changes it. Describe the change in plain words, or write it up for the developer as cspeach-out/developer-request-<topic>.md. Do not call SAP write, transport, lock, run, test, ATC or approval tools.';
+/**
+ * Refused beyond the generic rule: the two smokes write SAP data over OData
+ * although requiresSap is false; unit tests and ATC runs execute on SAP;
+ * team_lane_move writes the team project's lanes; fiori_deploy uploads an app.
+ * shell_exec and background_run (ruling R8): their safelist runs npm, pnpm,
+ * ui5 and node, a deploy route around the fiori_deploy refusal.
+ */
+export const SEAT_EXTRA_REFUSED = new Set([
+    'fiori_draft_smoke',
+    'cap_link_smoke',
+    'sap_run_unit_test',
+    'team_lane_move',
+    'sap_atc_run',
+    'fiori_deploy',
+    'shell_exec',
+    'background_run',
+]);
+export function isSeatRefusedTool(tool) {
+    return WRITE_TOOLS.has(tool.name) || tool.name === 'request_approval' || SEAT_EXTRA_REFUSED.has(tool.name)
+        || (tool.isMutating === true && tool.requiresSap === true);
+}
+/** The model-facing refusal for this call on this seat, or null when it may run. */
+export function seatRefusal(kind, tool, args) {
+    if (kind !== 'functional')
+        return null;
+    if (isSeatRefusedTool(tool))
+        return SEAT_READ_ONLY_REASON;
+    // No approval minted elsewhere can ever be replayed from a functional seat.
+    if (args && typeof args === 'object'
+        && (Object.prototype.hasOwnProperty.call(args, 'approval_id') || Object.prototype.hasOwnProperty.call(args, 'approval_ids')))
+        return SEAT_READ_ONLY_REASON;
+    return null;
+}
+/** The tools this seat is offered. Developers: the same array, untouched. */
+export function toolsForSeat(tools, kind) {
+    if (kind !== 'functional')
+        return tools;
+    return tools.filter((t) => !isSeatRefusedTool(t));
+}

package/dist/ui/when-listening.js

@@ -0,0 +1,34 @@
+/** Resolves true once `event` has a listener on `emitter`, false after `timeoutMs`. */
+export function whenListening(emitter, event, timeoutMs = 3000) {
+    if (emitter.listenerCount(event) > 0)
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        let timer;
+        const onNew = (name) => {
+            if (name !== event)
+                return;
+            done(true);
+        };
+        const done = (ok) => {
+            emitter.off('newListener', onNew);
+            if (timer)
+                clearTimeout(timer);
+            // 'newListener' fires just before the listener is added: settle on the
+            // next turn so an emit made after awaiting this reaches it.
+            setImmediate(() => resolve(ok));
+        };
+        timer = setTimeout(() => done(false), timeoutMs);
+        emitter.on('newListener', onNew);
+    });
+}
+/** The Ink screen is ready for start-up output: it takes lines, cards and questions. */
+export async function whenInkReady(chunkEmitter, timeoutMs = 3000) {
+    const { cardSlotEmitter } = await import('./card-slot.js');
+    const { askQuestionEmitter } = await import('./ask-question-emitter.js');
+    const ready = await Promise.all([
+        whenListening(chunkEmitter, 'chunk', timeoutMs),
+        whenListening(cardSlotEmitter, 'confirm', timeoutMs),
+        whenListening(askQuestionEmitter, 'request', timeoutMs),
+    ]);
+    return ready.every(Boolean);
+}

package/dist/ui/widgets/files-card.js

@@ -24,6 +24,21 @@ export function filterFileItems(items, query) {
 function fit(text, cells) {
     return truncateToWidth(sanitizeControlChars(text), Math.max(1, cells));
 }
+/** A folder path keeps its END when cut (the project and .cspeach part): `…` + tail. */
+function fitTail(text, cells) {
+    const clean = sanitizeControlChars(text);
+    const room = Math.max(1, cells);
+    if (stringWidth(clean) <= room)
+        return clean;
+    const chars = [...clean];
+    let tail = '';
+    for (let i = chars.length - 1; i >= 0; i--) {
+        if (stringWidth(chars[i] + tail) > room - 1)
+            break;
+        tail = chars[i] + tail;
+    }
+    return `…${tail}`;
+}
 export function FilesCard({ request, width, onResolve }) {
     // Same raw-stdin reclaim as every card (an earlier inquirer prompt can leave
     // Ink's raw-mode bookkeeping stale).
@@ -83,9 +98,12 @@ export function FilesCard({ request, width, onResolve }) {
     const inner = Math.max(1, width - 4);
     const dim = roleProps('dim');
     const searchLabel = 'Search  ';
+    const folderLabel = 'Folder  ';
     // A long query is cut by cells (with …) so the row never wraps.
     const queryShown = fit(query, inner - stringWidth(searchLabel) - 1);
-    return (_jsxs(CardFrame, { tag: "QUESTION", footnote: "/files", width: width, children: [_jsx(Text, { bold: true, wrap: "truncate-end", children: fit(request.title, inner) }), _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { ...dim, children: searchLabel }), _jsx(Text, { children: queryShown }), _jsx(Text, { ...roleProps('sap'), children: "_" })] }), visible.length === 0
+    return (_jsxs(CardFrame, { tag: "QUESTION", footnote: "/files", width: width, children: [_jsx(Text, { bold: true, wrap: "truncate-end", children: fit(request.title, inner) }), request.folder
+                ? _jsx(Text, { wrap: "truncate-end", ...dim, children: folderLabel + fitTail(request.folder, inner - stringWidth(folderLabel)) })
+                : null, _jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { ...dim, children: searchLabel }), _jsx(Text, { children: queryShown }), _jsx(Text, { ...roleProps('sap'), children: "_" })] }), visible.length === 0
                 ? _jsx(Text, { ...dim, children: "No file matches" })
                 : visible.map((it, i) => {
                     const on = start + i === cursor;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.53",
+  "version": "1.1.55",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, signed skills, safety gates.",
   "keywords": [
     "abap",