@cspeach/cli 1.1.28 → 1.1.30

package/dist/tools/_filesystem-shared.js

@@ -9,7 +9,7 @@
  */
 import * as path from 'node:path';
 import { promises as fsPromises, realpathSync, existsSync } from 'node:fs';
-import { cspeachRoot } from '../config/paths.js';
+import { cspeachRoot, defaultCspeachRoot } from '../config/paths.js';
 /**
  * Phase 3 sensitive in-root directory prefixes — refused by all filesystem
  * tools. Matched as `rel === prefix` or `rel` starts with `prefix + '/'`.
@@ -229,18 +229,25 @@ function relIsInside(p, rel) {
     return rel === '' || (!rel.startsWith('..') && !p.isAbsolute(rel));
 }
 /**
- * True if `absPath` is the CLI home (`cspeachRoot()`, `~/.cspeach`) or below
- * it — auth tokens, config, sessions, snapshots, logs. Checked against the
+ * True if `absPath` is the CLI home (`cspeachRoot()`) or `~/.cspeach`, or below
+ * either — auth tokens, config, sessions, snapshots, logs. Checked against the
  * spelled and the real home, and through NTFS spellings of the `.cspeach`
  * segment (`.cspeach.`, `.cspeach `), case-insensitively.
  */
 function isUnderCliHome(absPath, p, native) {
-    const home = cspeachRoot();
-    const homes = [p.resolve(home)];
-    if (native) {
-        const real = realDirOrNull(home);
-        if (real && real !== homes[0])
-            homes.push(real);
+    // Both homes: the one CSPEACH_HOME chose AND ~/.cspeach, which still holds
+    // history, logs, streams — and maybe an auth.json from before the move.
+    const chosen = [cspeachRoot(), defaultCspeachRoot()];
+    const homes = [];
+    for (const home of chosen) {
+        const spelled = p.resolve(home);
+        if (!homes.includes(spelled))
+            homes.push(spelled);
+        if (native) {
+            const real = realDirOrNull(home);
+            if (real && !homes.includes(real))
+                homes.push(real);
+        }
     }
     for (const h of homes) {
         const fromParent = p.relative(p.dirname(h), absPath).replace(/\\/g, '/');

package/dist/tools/project/team_findings.js

@@ -0,0 +1,72 @@
+/**
+ * team_findings — read-only (spec 2026-10-06 §4.2, triage).
+ *
+ * What a /abap-clean-core triage proposes from: the objects of a lane (or of
+ * 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.
+ */
+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';
+const CAP = 200;
+/** 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;
+const match = (pattern, value) => new RegExp(`^${pattern.trim().replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`, 'i').test(value);
+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 };
+    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';
+        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}`;
+        }
+        else if (patterns.length) {
+            objects = objects.filter((o) => patterns.some((p) => match(p, o.package)));
+            scope = `packages ${patterns.join(', ')}`;
+        }
+        const findings = findingsByObject(joined.projectDir, joined.outboxDir);
+        const shown = objects.slice(0, CAP).map((o) => {
+            const f = findings.get(o.key);
+            const d = dispositionOf(o.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,
+            };
+        });
+        return { content: JSON.stringify({ teamProject: project.name, scope, objects: shown, ...(objects.length > CAP ? { more: objects.length - CAP } : {}) }) };
+    }
+    catch (e) {
+        return { content: `The team project could not be read: ${e instanceof Error ? e.message : String(e)}`, is_error: true };
+    }
+}
+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.',
+    isMutating: false,
+    category: 'project',
+    requiresSap: false,
+    input_schema: {
+        type: 'object',
+        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.' },
+        },
+    },
+    handler: (args, ctx) => teamFindingsHandler(args, ctx),
+});

package/dist/tools/sap-write.js

@@ -34,6 +34,7 @@ import { getLook } from '../renderer/look.js';
 import { getEffectiveBodyWidth } from '../renderer/tty.js';
 import { verifySyntax, verifyActive } from './verify.js';
 import { hasRecordedSyntaxErrorsByName, clearSyntaxErrorsAfterActivation } from './syntax-state.js';
+import { teamFixOffers } from '../register/offer.js';
 import { appendPending, finalizeToolCall } from '../session/pending.js';
 import { auditLog } from '@cspeach/sap-client';
 import { ERR } from '../errors/codes.js';
@@ -1314,6 +1315,7 @@ registerTool({
         // still inactive with syntax errors" incident.
         const stillInactive = [];
         const unverifiable = [];
+        const verified = [];
         for (const obj of args.objects) {
             const v = await verifyActive(ctx.adt, obj.name, obj.type);
             if (v.verifyError) {
@@ -1325,6 +1327,7 @@ registerTool({
             else if (activationResults.find((r) => r.name === obj.name && r.type === obj.type)?.success) {
                 // Final review A M-2 — activated AND verified: the source compiles.
                 clearSyntaxErrorsAfterActivation(obj.name);
+                verified.push({ name: obj.name, type: obj.type });
             }
         }
         const overallSuccess = !anyError && stillInactive.length === 0 && unverifiable.length === 0;
@@ -1342,6 +1345,11 @@ registerTool({
         // successful write op. Without this, Rule 8 counts a failed activate
         // as if it had run, inflating the "batch in progress" count and
         // confusing the user about how many real writes have happened.
+        // 2026-10-06 — an object of the team project this laptop joined: offer the
+        // claim in one line. Nothing is recorded; only the developer claims a fix.
+        if (overallSuccess)
+            for (const line of teamFixOffers(verified))
+                ctx.chunkEmitter?.emit('info', line);
         return {
             content: JSON.stringify({
                 success: overallSuccess,

package/dist/tools/tool-loading.js

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

package/dist/ui/app.js

@@ -24,6 +24,7 @@ import { RewindPanel } from './rewind-panel.js';
 import { rewindEmitter } from './rewind-emitter.js';
 import { todoEmitter } from './todo-emitter.js';
 import { approvalEmitter } from './approval-emitter.js';
+import { useHoldRawMode } from './widgets/hold-raw-mode.js';
 import { SapStateContext, globalStore } from './sap-state-store.js';
 import { coachingPickerEmitter } from './coaching-picker-emitter.js';
 import { CoachingPicker } from './widgets/coaching-picker.js';
@@ -66,6 +67,9 @@ export function isAskingOccupant(occupant) {
  * The terminal's native scrollback handles everything above the live area.
  */
 export function App({ chunkEmitter, onSubmit, onSlashTrigger, onHistoryTrigger, getToolCalls, getTodos, getRewindCandidates, onRewindRestore, sapRole, sapAlias, onInterrupt, onExitRequest }) {
+    // 1.1.29 — keep raw mode held across card hand-overs (Windows froze the
+    // approval card when Ink released it between cards). See hold-raw-mode.ts.
+    useHoldRawMode();
     const [pendingApproval, setPendingApproval] = useState(null);
     // Task 3 review I1(b): synchronous mirror + monotonic remount key — the same
     // I2 treatment ask-question already has. A second approval request arriving

package/dist/ui/widgets/hold-raw-mode.js

@@ -0,0 +1,26 @@
+import { useEffect } from 'react';
+import { useStdin } from 'ink';
+/**
+ * Hold one Ink raw-mode reference for the life of the component (1.1.29).
+ *
+ * Ink ref-counts raw mode: every active useInput takes a reference, and when
+ * the count falls to 0 Ink calls setRawMode(false) + unref on stdin. The main
+ * input boxes go inactive while a card is open, so at every card hand-over
+ * (plan card closes → per-change approval card opens) the count touched 0 and
+ * back. On Windows that release leaves a cooked console read pending and
+ * stdin delivers no more keys — the approval card sat frozen (live, 1.1.28;
+ * reproduced in a ConPTY replay, and fixed there by suppressing the release).
+ *
+ * Mounted once at the <App> root, this reference keeps the count above 0
+ * until the app unmounts, so hand-overs never release raw mode. It reads no
+ * keys itself: key routing is unchanged.
+ */
+export function useHoldRawMode() {
+    const { setRawMode, isRawModeSupported } = useStdin();
+    useEffect(() => {
+        if (!isRawModeSupported)
+            return;
+        setRawMode(true);
+        return () => { setRawMode(false); };
+    }, [isRawModeSupported, setRawMode]);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "1.1.28",
+  "version": "1.1.30",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, 34 skills, safety gates.",
   "keywords": [
     "abap",
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.90.0",
-    "@cspeach/register-core": "0.1.0",
+    "@cspeach/register-core": "0.2.0",
     "@cspeach/sap-client": "0.1.16",
     "@iarna/toml": "^2.2.5",
     "@inkjs/ui": "^2.0.0",