@cspeach/cli 1.1.30 → 1.1.32

package/dist/projects/workspace.js

@@ -7,56 +7,23 @@
  * the user — the path-copy circus. The workspace folder is one configurable
  * directory that the CLI saves into and resolves bare @<name> tokens against.
  *
- * Default resolution (2026-05-08, "project-rooted workspace"):
- *   1. `cfg.workspace_folder` in `~/.cspeach/config.toml` — explicit override,
- *      highest priority.
- *   2. `<git-root>/.cspeach/` — when the cwd is inside a git repository.
- *      Each customer / project gets its own workspace; multi-project
- *      consultants don't have artefacts piling up in one folder.
- *   3. `<cwd>/.cspeach/` — fallback when cwd isn't inside a git repo.
- *
- * Earlier (pre-2026-05-08) default was `~/CSPeach/`. A first-run migration
- * prompt (see src/projects/migration.ts) offers to move existing artefacts
- * into the new project-rooted workspace, or pin workspace_folder back to
- * `~/CSPeach/` for users who prefer the old behaviour.
+ * Resolution (2026-10-08): see projects/project-folder.ts — the folder you
+ * start in; team folders save to the seat. No git walk; workspace_folder is
+ * ignored.
  *
  * The folder is created on first use — no `cspeach init` ceremony.
  */
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, isAbsolute } from 'node:path';
-import os from 'node:os';
-import toml from '@iarna/toml';
-import { loadConfig } from '../config/loader.js';
-import { configFile } from '../config/paths.js';
+import { legacyDirsFor, resolveProjectFolderSync } from './project-folder.js';
+import { cspeachRoot } from '../config/paths.js';
+import { normDir } from '../session/project-match.js';
 /**
- * Walk up the directory tree from `startDir` looking for a `.git` entry
- * (file or directory — submodules use a file). Returns the directory
- * containing `.git`, or null when the search hits the filesystem root
- * without finding one.
- *
- * Bounded by parent === dir, which terminates at "/" on POSIX and at
- * each drive root on Windows.
- */
-export function findProjectRoot(startDir) {
-    let dir = startDir;
-    for (let i = 0; i < 200; i++) {
-        if (existsSync(join(dir, '.git')))
-            return dir;
-        const parent = dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-    return null;
-}
-/**
- * Resolve the project-rooted default workspace path for a given cwd.
- * Pure: does NOT touch the filesystem (other than the .git existence
- * check via findProjectRoot). Caller decides whether to mkdir.
+ * The workspace path for a given cwd (see projects/project-folder.ts).
+ * Pure: does NOT create anything. Caller decides whether to mkdir.
  */
 export function defaultWorkspaceFor(cwd) {
-    const root = findProjectRoot(cwd);
-    return join(root ?? cwd, '.cspeach');
+    return resolveProjectFolderSync(cwd).workDir;
 }
 /**
  * If the workspace lives directly under a project root that has a
@@ -92,17 +59,13 @@ function maybeAddToGitignore(workspaceDir) {
     }
 }
 /**
- * Resolve the workspace folder PATH without creating it. Same resolution
- * order as ensureWorkspace (config override > project-rooted default) but
- * strictly read-only: no mkdir, no .gitignore append. For callers that only
- * need to LOOK at the workspace — e.g. the pre-confirm prior-plan scan in
- * save-command.ts, which must not leave filesystem side effects before the
- * user says yes to the save.
+ * Resolve the workspace folder PATH without creating it. Strictly read-only:
+ * no mkdir, no .gitignore append. For callers that only need to LOOK at the
+ * workspace — e.g. the pre-confirm prior-plan scan in save-command.ts, which
+ * must not leave filesystem side effects before the user says yes to the save.
  */
 export async function resolveWorkspacePath() {
-    const cfg = await loadConfig();
-    const configured = cfg.workspace_folder?.trim();
-    return resolveTarget(configured);
+    return defaultWorkspaceFor(process.cwd());
 }
 /**
  * App lane routing I3 — the same read-only resolution as resolveWorkspacePath,
@@ -110,64 +73,35 @@ export async function resolveWorkspacePath() {
  * real session the two are the same folder; tests pass a temp cwd.
  */
 export async function resolveWorkspacePathFor(cwd) {
-    const cfg = await loadConfig();
-    const configured = cfg.workspace_folder?.trim();
-    return configured && configured.length > 0 ? expandHome(configured) : defaultWorkspaceFor(cwd);
-}
-function resolveTarget(configured) {
-    return configured && configured.length > 0
-        ? expandHome(configured)
-        : defaultWorkspaceFor(process.cwd());
+    return defaultWorkspaceFor(cwd);
 }
 /**
- * Resolve the workspace folder path, creating it if missing.
- * Returns the absolute path. Idempotent.
+ * Resolve the workspace folder path for `cwd` (default: process.cwd()),
+ * creating it if missing. Returns the absolute path. Idempotent.
  */
-export async function ensureWorkspace() {
-    const cfg = await loadConfig();
-    const configured = cfg.workspace_folder?.trim();
-    const target = resolveTarget(configured);
-    const justCreated = !existsSync(target);
-    if (justCreated) {
-        mkdirSync(target, { recursive: true });
-        // Only add to .gitignore for default project-rooted workspaces.
-        // Explicit overrides (e.g. ~/CSPeach/, /shared/team/cspeach/) are
-        // outside any project tree by design — adding to a parent .gitignore
-        // would be overreach.
-        if (!configured)
-            maybeAddToGitignore(target);
-    }
-    return target;
+export async function ensureWorkspace(cwd = process.cwd()) {
+    const pf = resolveProjectFolderSync(cwd);
+    if (!existsSync(pf.workDir)) {
+        mkdirSync(pf.workDir, { recursive: true });
+        // Only for the folder you start in. The .gitignore beside a team folder
+        // or ~/CSPeach is not ours to edit.
+        if (pf.kind === 'solo')
+            maybeAddToGitignore(pf.workDir);
+    }
+    return pf.workDir;
 }
 /**
  * Synchronous variant for callers that cannot await — most importantly
- * Node's readline `completer` interface, which is sync. Reads the TOML
- * config directly via fs.readFileSync. Falls back to project-rooted
- * default on any error (missing config, parse failure, etc.) — the
- * completer should never throw.
- *
- * Earlier revision used `require('@iarna/toml')` here, which threw in
- * ESM context (cspeach-cli has `"type": "module"`) and silently broke
- * Tab completion. Top-level import is correct for ESM modules.
+ * Node's readline `completer` interface, which is sync. Never throws.
  */
-export function ensureWorkspaceSync() {
-    let target = defaultWorkspaceFor(process.cwd());
+export function ensureWorkspaceSync(cwd = process.cwd()) {
+    const target = defaultWorkspaceFor(cwd);
     try {
-        const cfgPath = configFile();
-        if (existsSync(cfgPath)) {
-            const raw = readFileSync(cfgPath, 'utf-8');
-            const parsed = toml.parse(raw);
-            const configured = parsed.workspace_folder?.trim();
-            if (configured && configured.length > 0) {
-                target = expandHome(configured);
-            }
-        }
+        if (!existsSync(target))
+            mkdirSync(target, { recursive: true });
     }
     catch {
-        // Fall through to default — completer must never throw on a borked config.
-    }
-    if (!existsSync(target)) {
-        mkdirSync(target, { recursive: true });
+        // The completer must never throw.
     }
     return target;
 }
@@ -206,16 +140,6 @@ export function listProjectFilesSync(workspace) {
         return [];
     }
 }
-/**
- * Expand a leading `~/` to the user's home directory. Other paths are
- * returned unchanged.
- */
-function expandHome(p) {
-    if (p.startsWith('~/') || p === '~') {
-        return join(os.homedir(), p.slice(p === '~' ? 1 : 2));
-    }
-    return p;
-}
 /** File suffixes recognised as text-input candidates for skills. */
 const TEXT_SUFFIXES = ['.txt', '.md'];
 /**
@@ -252,18 +176,63 @@ export function isAttachableFilename(name) {
  * yield an `unknown` summary rather than throwing — callers see the
  * file name with no metadata so the user can investigate.
  */
-export async function listProjectFiles() {
-    const ws = await ensureWorkspace();
-    const entries = readdirSync(ws);
+export async function listProjectFiles(cwd = process.cwd()) {
+    const ws = await ensureWorkspace(cwd);
+    const out = summarizeDir(readdirSync(ws), ws, false);
+    out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    // 2026-10-08 (sessions/folders, Task 11) — for one release the old save
+    // locations stay readable: their files follow the new folder's, marked
+    // `earlier`. Read-only: nothing is created or written there. A file with
+    // the same name in the new folder wins.
+    const seen = new Set(out.map((f) => f.filename.toLowerCase()));
+    let legacy;
+    try {
+        legacy = legacyDirsFor(cwd);
+    }
+    catch {
+        legacy = [];
+    }
+    for (const dir of legacy) {
+        let names;
+        try {
+            names = readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        const rows = summarizeDir(names, dir, isCliHome(dir)).filter((f) => !seen.has(f.filename.toLowerCase()));
+        rows.sort((a, b) => b.mtimeMs - a.mtimeMs);
+        for (const f of rows) {
+            seen.add(f.filename.toLowerCase());
+            out.push({ ...f, earlier: true });
+        }
+    }
+    return out;
+}
+/**
+ * Whether `dir` is the CLI home. In the CLI home only `*.cspeach.json` files
+ * directly in it are ever listed — never config.toml, auth or sessions.
+ */
+function isCliHome(dir) {
+    return normDir(dir) === normDir(cspeachRoot());
+}
+/** The supported files among `names` in `dir`, parsed for the summary. */
+function summarizeDir(names, dir, envelopesOnly) {
     const out = [];
-    for (const name of entries) {
+    for (const name of names) {
         const isEnvelope = name.endsWith('.cspeach.json');
-        const isText = isTextFilename(name);
-        const isDoc = isDocFilename(name);
+        const isText = !envelopesOnly && isTextFilename(name);
+        const isDoc = !envelopesOnly && isDocFilename(name);
         if (!isEnvelope && !isText && !isDoc)
             continue;
-        const path = join(ws, name);
-        const stat = statSync(path);
+        const path = join(dir, name);
+        let stat;
+        try {
+            stat = statSync(path);
+        }
+        catch {
+            continue;
+        }
         if (!stat.isFile())
             continue;
         if (isEnvelope) {
@@ -307,9 +276,95 @@ export async function listProjectFiles() {
             });
         }
     }
-    out.sort((a, b) => b.mtimeMs - a.mtimeMs);
     return out;
 }
+/**
+ * The @ completer's view of the old save locations (sync, names only): the
+ * same files listProjectFiles marks `earlier`; names in `skip` (the new
+ * folder's) are left out. Never throws.
+ */
+export function listLegacyFilesSync(cwd, skip) {
+    const out = [];
+    const seen = new Set([...skip].map((n) => n.toLowerCase()));
+    let dirs;
+    try {
+        dirs = legacyDirsFor(cwd);
+    }
+    catch {
+        return out;
+    }
+    for (const dir of dirs) {
+        const home = isCliHome(dir);
+        for (const f of listProjectFilesSync(dir)) {
+            if (home && f.kind !== 'envelope')
+                continue;
+            if (seen.has(f.filename.toLowerCase()))
+                continue;
+            seen.add(f.filename.toLowerCase());
+            out.push(f);
+        }
+    }
+    return out;
+}
+/** Number of `*.cspeach.json` files directly in `dir` (0 when unreadable). */
+function countEnvelopes(dir) {
+    try {
+        return readdirSync(dir).filter((n) => n.endsWith('.cspeach.json')).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * The start-up hint for files left in old save locations, or null when
+ * there are none. Names the first old folder; counts envelopes in all.
+ */
+export function legacyHintLine(cwd) {
+    let dirs;
+    try {
+        dirs = legacyDirsFor(cwd);
+    }
+    catch {
+        return null;
+    }
+    const n = dirs.reduce((sum, d) => sum + countEnvelopes(d), 0);
+    if (n === 0)
+        return null;
+    const lead = n === 1
+        ? `1 project file from earlier builds is in ${dirs[0]}.`
+        : `${n} project files from earlier builds are in ${dirs[0]}.`;
+    return `${lead} Run: cspeach files sort`;
+}
+function localDay(d) {
+    const pad = (x) => String(x).padStart(2, '0');
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+/**
+ * At most once per folder per day (spec §3.6): true when the hint for `cwd`
+ * was not shown today, and records today in <CSPEACH_HOME>/hints.json.
+ * Best-effort: a missing or broken file counts as "not shown"; never throws.
+ */
+export function claimLegacyHintToday(cwd, now = new Date()) {
+    const file = join(cspeachRoot(), 'hints.json');
+    const today = localDay(now);
+    let map = {};
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed))
+            map = parsed;
+    }
+    catch { /* missing or broken — start fresh */ }
+    const k = normDir(cwd);
+    if (map[k] === today)
+        return false;
+    map[k] = today;
+    try {
+        mkdirSync(dirname(file), { recursive: true });
+        writeFileSync(file, `${JSON.stringify(map, null, 2)}\n`, 'utf8');
+    }
+    catch { /* best-effort */ }
+    return true;
+}
 /**
  * Inspect a `design` envelope and decide whether the design describes a
  * RAP stack (Behavior Definition / Behavior Pool / Service Binding) or a
@@ -390,6 +445,12 @@ export function resolveAtToken(args) {
     if (exact.length === 1) {
         return { kind: 'path', path: exact[0].path };
     }
+    // Final fix wave, item 6 — one match in this folder beats matches that are
+    // only in an earlier location.
+    const here = matches.filter((f) => !f.earlier);
+    if (here.length === 1) {
+        return { kind: 'path', path: here[0].path };
+    }
     return { kind: 'ambiguous', matches };
 }
 /**
@@ -478,8 +539,8 @@ export function resolveBareTokenInCwd(token, cwd) {
  * a plain `@spec.txt` instead of an absolute path.
  */
 export async function resolveAtTokenAsync(token, cwd) {
-    const workspace = await ensureWorkspace();
-    const files = await listProjectFiles();
+    const workspace = await ensureWorkspace(cwd);
+    const files = await listProjectFiles(cwd);
     const result = resolveAtToken({ token, cwd, workspace, files });
     if (result.kind === 'notFound' && isBareToken(token)) {
         const cwdResult = resolveBareTokenInCwd(token, cwd);
@@ -506,7 +567,7 @@ export function formatProjectFileList(files, workspace) {
         const meta = f.kind === 'envelope'
             ? `${f.artefactType.padEnd(9)} v${f.version ?? '?'}`
             : `${f.kind.padEnd(9)} ${formatBytes(f.sizeBytes).padStart(7)}`;
-        lines.push(`  ${f.filename}  —  ${meta}  ${ageStr}`);
+        lines.push(`  ${f.filename}  —  ${meta}  ${ageStr}${f.earlier ? '  (earlier location)' : ''}`);
     }
     lines.push('');
     lines.push(`${files.length} file(s). Use @<partial-name> to load — e.g. @${shortHint(files[0].filename)}`);

package/dist/register/baseline.js

@@ -50,6 +50,43 @@ export async function listCustomPackages(sql, prefixes = ['Z', 'Y']) {
     }
     return [...out.values()].sort((a, b) => a.package.localeCompare(b.package));
 }
+/** The data preview never returns more than this many rows in one answer. */
+export const SQL_ROW_CAP = 5000;
+/** A quote in a paging key is doubled, so it cannot end the literal. */
+const lit = (v) => v.replace(/\x27/g, '\x27\x27');
+/**
+ * One package (or one $TMP prefix). Below the cap: today's single query for
+ * `expected + 50` rows. Above it (`expected + 50 > 5000`, review I14): keyset
+ * pages of 5,000 by OBJ_NAME until a page is short. The key is `>=` with the
+ * rows already seen dropped, so a name held by two object types that a page
+ * boundary splits is never lost. The control total of the caller still decides.
+ */
+async function pullOne(sql, pkg, select, expected) {
+    if (expected + 50 <= SQL_ROW_CAP)
+        return (await sql(select, expected + 50)).rows;
+    const rows = [];
+    const seen = new Set();
+    let last;
+    for (;;) {
+        const page = (await sql(`${select}${last === undefined ? '' : ` AND OBJ_NAME >= '${lit(last)}'`} ORDER BY OBJ_NAME, OBJECT`, SQL_ROW_CAP)).rows;
+        let fresh = 0;
+        for (const r of page) {
+            const k = `${clean(r.OBJECT)}|${clean(r.OBJ_NAME)}`;
+            if (seen.has(k))
+                continue;
+            seen.add(k);
+            rows.push(r);
+            fresh += 1;
+        }
+        if (page.length < SQL_ROW_CAP)
+            return rows;
+        const next = clean(page[page.length - 1].OBJ_NAME);
+        if (fresh === 0 || next === last) {
+            throw new BaselineError(`Package ${pkg}: the pull could not page past ${next}. The baseline was NOT written.`);
+        }
+        last = next;
+    }
+}
 export async function pullBaseline(sql, opts) {
     const types = new Set((opts.objectTypes ?? CODE_OBJECT_TYPES).map((t) => t.toUpperCase()));
     const objects = [];
@@ -65,11 +102,11 @@ export async function pullBaseline(sql, opts) {
             for (const [prefix, n] of Object.entries(byPrefix)) {
                 if (!PREFIX_RE.test(prefix))
                     throw new BaselineError(`Not a valid name prefix: ${prefix}`);
-                res.rows.push(...(await sql(`${select} AND OBJ_NAME LIKE '${prefix}%'`, n + 50)).rows);
+                res.rows.push(...(await pullOne(sql, pkg, `${select} AND OBJ_NAME LIKE '${prefix}%'`, n)));
             }
         }
         else {
-            res.rows.push(...(await sql(select, expected + 50)).rows);
+            res.rows.push(...(await pullOne(sql, pkg, select, expected)));
         }
         if (res.rows.length !== expected) {
             throw new BaselineError(`Package ${pkg}: the system counted ${expected} objects but the pull returned ${res.rows.length}. `

package/dist/register/decision-rules.js

@@ -0,0 +1,35 @@
+/**
+ * Decision rules for the joined team project (step 2, D6): which rule decides
+ * each object, read from the same register and findings team_findings shows,
+ * with the project's own rules or the defaults. The row cards use it to say
+ * "Rule <id>: …" or "Differs from rule <id>: …". Read only; never writes the
+ * rules to the file.
+ */
+import { evaluateRules, readDecisionRules } from '@cspeach/register-core';
+import { findingsByObject } from './findings.js';
+import { registerFor } from './picture.js';
+import { readProjectFile } from './store.js';
+/** The rule that decides one register object, from its latest counted run's findings. */
+export function ruleProposalOf(o, f, rules) {
+    return evaluateRules(o, rules, f ? { findings: f.latest } : {});
+}
+/** "TYPE|NAME" → the deciding rule (or null), for every object of the team project; `warning` when the file's rules could not be read. */
+export function ruleProposalsFor(projectDir, outboxDir) {
+    const rules = readDecisionRules(readProjectFile(projectDir));
+    const { register } = registerFor(projectDir, outboxDir);
+    const findings = findingsByObject(projectDir, outboxDir);
+    const byKey = new Map(register.objects.map((o) => [o.key.toUpperCase(), o]));
+    const cache = new Map();
+    return {
+        lookup: (key) => {
+            const k = key.trim().toUpperCase();
+            if (cache.has(k))
+                return cache.get(k);
+            const o = byKey.get(k);
+            const p = o ? ruleProposalOf(o, findings.get(o.key), rules.rules) : null;
+            cache.set(k, p);
+            return p;
+        },
+        ...(rules.warning ? { warning: rules.warning } : {}),
+    };
+}