@cspeach/cli 1.1.30 → 1.1.32

package/dist/session/store.js

@@ -7,6 +7,7 @@ import { sessionsDir, pinnedSessionsDir } from '../config/paths.js';
 import { SCHEMA_VERSION } from './schema.js';
 import { userPromptText, isUserPrompt, promptPreviewText } from './user-prompt.js';
 import { stripUnsignedThinking, dropTrailingThinkingOnly } from '../agent/repair-partial.js';
+import { normDir, sessionMatchesFolder } from './project-match.js';
 export function makeSessionId() {
     return crypto.randomBytes(4).toString('hex');
 }
@@ -71,6 +72,9 @@ function validateSchema(parsed) {
     // Phase 4 chunk 4A: agentMode defaults to 'skill' for sessions written
     // before this chunk landed. Mirrors the lastUserPrompt back-compat above.
     parsed.agentMode ??= 'skill';
+    // 2026-10-08: sessions are listed per folder. Older files have no folder.
+    parsed.project_dir ??= null;
+    parsed.project_id ??= null;
     // Phase 1 cost tracking (2026-05-16): cache_creation_input_tokens added
     // to usage. Pre-2026-05-16 sessions don't have it; default to 0 so the
     // cost calculator can safely treat usage as a TokenCounts shape.
@@ -130,11 +134,17 @@ export const RESUME_PICKER_LIMIT = 20;
 async function recentSessionFiles(dir, limit) {
     // Merge note — Task 18 reader-* child sessions are skipped by NAME here, so a
     // burst of reader files can never crowd real sessions out of the window.
-    const files = (await fs.readdir(dir).catch(() => []))
-        .filter((f) => f.endsWith('.json') && !f.includes('-reader-'));
+    const files = await sessionFileNames(dir);
     const cap = Math.max(limit * 3, 50);
     if (files.length <= cap)
         return files;
+    return (await newestFirst(dir, files)).slice(0, cap);
+}
+async function sessionFileNames(dir) {
+    return (await fs.readdir(dir).catch(() => []))
+        .filter((f) => f.endsWith('.json') && !f.includes('-reader-'));
+}
+async function newestFirst(dir, files) {
     const stamped = await Promise.all(files.map(async (f) => {
         try {
             return { f, t: (await fs.stat(path.join(dir, f))).mtimeMs };
@@ -144,78 +154,113 @@ async function recentSessionFiles(dir, limit) {
         }
     }));
     stamped.sort((a, b) => b.t - a.t);
-    return stamped.slice(0, cap).map((x) => x.f);
+    return stamped.map((x) => x.f);
+}
+/** 2026-10-08 — every session file, newest first by mtime (no cap): `--continue` / `--resume` scans. */
+async function allSessionFilesNewestFirst(dir) {
+    return newestFirst(dir, await sessionFileNames(dir));
+}
+/** One picker row from a session file; null for a reader child or a corrupt file. */
+async function summaryOf(file, filename) {
+    try {
+        const raw = await fs.readFile(file, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (isReaderSessionId(parsed.id))
+            return null; // Task 18 — internal child, never resumed
+        const messages = parsed.messages ?? [];
+        // First user message that's a plain string (not a tool_result array) — the
+        // most recent prompt text that initiated a turn. We pick the LAST such
+        // message because the picker wants the freshest turn's prompt, not the
+        // first one of the session.
+        let promptSnippet = null;
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const m = messages[i];
+            const text = m ? userPromptText(m) : null;
+            if (text !== null) {
+                // Strip <session_context>...</session_context> wrapper that the
+                // first turn injects, leaving only the user-typed prompt visible
+                // in the picker.
+                // (fix round 3: every injected block, e.g. <project_context>, and
+                // newlines — they broke the picker's table row.)
+                const stripped = promptPreviewText(text);
+                promptSnippet = (stripped || '<empty>').slice(0, 80);
+                break;
+            }
+        }
+        const userTurnCount = messages.filter((m) => m && isUserPrompt(m)).length;
+        return {
+            id: parsed.id,
+            startedAt: parsed.started_at,
+            lastTurnAt: parsed.last_turn_at,
+            skill: parsed.skill,
+            sapSystem: parsed.sap_system,
+            filename,
+            interrupted: parsed.turnInterrupted === true,
+            interruptedReason: parsed.turnInterruptedReason ?? null,
+            promptSnippet,
+            userTurnCount,
+            projectDir: parsed.project_dir ?? null,
+            projectId: parsed.project_id ?? null,
+        };
+    }
+    catch {
+        return null; // skip corrupt
+    }
 }
+/**
+ * The most recent sessions, newest first by last_turn_at.
+ * - `here`: only the sessions of that folder (sessionMatchesFolder).
+ * - `scanAll` (with `here`): walk every file newest-first instead of the
+ *   startup window, stopping once `limit` matches are found
+ *   (`--continue`, `--resume`). Without `here` the window is always used.
+ */
 export async function listSessions(limit = 10, opts = {}) {
     // NOTE: bypasses validateSchema() for performance — reads JSON directly via
     // JSON.parse + cast. Any new SessionState field accessed here must be
     // defaulted at the read site (e.g. `?? 'skill'`) because pre-chunk-4A
     // serialised sessions on disk lack the field.
     const dir = sessionsDir();
-    const files = await recentSessionFiles(dir, limit);
+    const scanAll = !!opts.here && opts.scanAll === true;
+    const files = scanAll ? await allSessionFilesNewestFirst(dir) : await recentSessionFiles(dir, limit);
+    const hereDirNorm = opts.here ? normDir(opts.here.dir) : undefined; // once per call, not per file
     const results = [];
     for (const f of files) {
-        try {
-            const raw = await fs.readFile(path.join(dir, f), 'utf-8');
-            const parsed = JSON.parse(raw);
-            if (isReaderSessionId(parsed.id))
-                continue; // Task 18 — internal child, never resumed
-            const messages = parsed.messages ?? [];
-            // First user message that's a plain string (not a tool_result array) — the
-            // most recent prompt text that initiated a turn. We pick the LAST such
-            // message because the picker wants the freshest turn's prompt, not the
-            // first one of the session.
-            let promptSnippet = null;
-            for (let i = messages.length - 1; i >= 0; i--) {
-                const m = messages[i];
-                const text = m ? userPromptText(m) : null;
-                if (text !== null) {
-                    // Strip <session_context>...</session_context> wrapper that the
-                    // first turn injects, leaving only the user-typed prompt visible
-                    // in the picker.
-                    // (fix round 3: every injected block, e.g. <project_context>, and
-                    // newlines — they broke the picker's table row.)
-                    const stripped = promptPreviewText(text);
-                    promptSnippet = (stripped || '<empty>').slice(0, 80);
-                    break;
-                }
-            }
-            const userTurnCount = messages.filter((m) => m && isUserPrompt(m)).length;
-            results.push({
-                id: parsed.id,
-                startedAt: parsed.started_at,
-                lastTurnAt: parsed.last_turn_at,
-                skill: parsed.skill,
-                sapSystem: parsed.sap_system,
-                filename: f,
-                interrupted: parsed.turnInterrupted === true,
-                interruptedReason: parsed.turnInterruptedReason ?? null,
-                promptSnippet,
-                userTurnCount,
-            });
-        }
-        catch { /* skip corrupt */ }
+        const s = await summaryOf(path.join(dir, f), f);
+        if (!s)
+            continue;
+        if (opts.here && !sessionMatchesFolder(s, opts.here, hereDirNorm))
+            continue;
+        // Round 6 review M1 — the picker drops 0-turn sessions (unless interrupted)
+        // BEFORE the limit, so a pile of start-then-quit files cannot crowd out
+        // the sessions worth resuming.
+        if (opts.skipEmpty && !(s.userTurnCount > 0 || s.interrupted))
+            continue;
+        results.push(s);
+        if (scanAll && results.length >= limit)
+            break;
     }
     results.sort((a, b) => b.lastTurnAt.localeCompare(a.lastTurnAt));
-    // Round 6 review M1 — the picker drops 0-turn sessions (unless interrupted)
-    // BEFORE the limit, so a pile of start-then-quit files cannot crowd out
-    // the sessions worth resuming.
-    const kept = opts.skipEmpty ? results.filter((r) => r.userTurnCount > 0 || r.interrupted) : results;
-    return kept.slice(0, limit);
+    return results.slice(0, limit);
+}
+/** 2026-10-08 — the latest non-empty session of this folder (`--continue`), or null. */
+export async function latestSessionHere(here, opts = {}) {
+    const [s] = await listSessions(1, { here, skipEmpty: true, scanAll: opts.scanAll ?? false });
+    return s ?? null;
 }
 /**
  * Count interrupted sessions for the startup banner — among the sessions the
  * `--resume` picker can show (RESUME_PICKER_LIMIT most recent), so the
  * "! N unfinished sessions" notice never points at sessions the picker does
  * not list (fix round 3, item 11d). Returns 0 on any IO failure.
+ * 2026-10-08 — with `here`, only that folder's sessions count.
  */
-export async function countInterruptedSessions() {
+export async function countInterruptedSessions(here) {
     try {
         // Round 8 item 7 — a turn the USER stopped (Ctrl+C, /exit mid-turn) is
         // not unfinished work: counting it kept "! 1 unfinished session" on every
         // start until that session happened to finish a turn. The picker still
         // lists it as "Stopped by you".
-        return (await listSessions(RESUME_PICKER_LIMIT))
+        return (await listSessions(RESUME_PICKER_LIMIT, here ? { here } : {}))
             .filter((s) => s.interrupted && !isUserStopReason(s.interruptedReason)).length;
     }
     catch {

package/dist/skill-catalog.js

@@ -168,8 +168,8 @@ export const SKILL_CATALOG = [
     {
         name: 'abap-cca',
         category: 'Upgrade / Migrate',
-        description: 'Custom code analysis pipeline for S/4 upgrade — whole-estate inventory + tier classification + ATC findings + report. Multi-session project with state file.',
-        whenToUse: `pick this to discover + classify the whole custom estate (not /abap-migrate — that's per object)`,
+        description: 'Reads the estate inventory the lead pulled; proposes scope, areas, retire candidates and next commands; read-only.',
+        whenToUse: `pick this after cspeach team discover, to choose packages, lanes and a first focus (not /abap-migrate — that's per object)`,
         asks: 'which package or namespace? e.g. "Z*" or "package ZTEST_LAS"',
     },
     {