@cspeach/cli 1.1.21 → 1.1.23

package/dist/commands/project.js

@@ -1,301 +0,0 @@
-/**
- * `cspeach project …` — the Project Register from the terminal
- * (spec: docs/superpowers/specs/2026-09-18-project-register-folder-mode.md §6).
- *
- *   init <folder>   lead: pull the baseline from SAP, write the project folder
- *   join <folder>   everyone: start recording against a project
- *   lane …          lead: who owns which packages
- *   status [folder] anyone: the register as text
- *   outbox          what this laptop has recorded, and where
- *   rule …          lead: settle a disagreement
- *   leave           stop recording
- *
- * Every path written here is one a person typed. Nothing is written to a
- * network location on CSPeach's own initiative, and none of this is reachable
- * from a model tool.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import { buildRegister, objectKey } from '@cspeach/register-core';
-import { LOCAL_PACKAGE, listCustomPackages, pullBaseline, BaselineError } from '../register/baseline.js';
-import { BASELINE_FILE, PROJECT_FILE, RegisterError, activeProject, collectRecords, defaultOutboxDir, loadState, projectIdFor, readBaseline, readLanes, readProjectFile, saveState, sha256, writeLanes, writerIdFor, } from '../register/store.js';
-import { writeRecord } from '../register/records.js';
-const CLASSIFICATIONS = ['keep', 'fix', 'retire', 'redesign'];
-const TYPES = ['clean-core', 'upgrade', 'build'];
-function flags(args) {
-    const positional = [];
-    const opts = {};
-    for (let i = 0; i < args.length; i++) {
-        const a = args[i];
-        if (a.startsWith('--')) {
-            opts[a.slice(2)] = args[i + 1] && !args[i + 1].startsWith('--') ? args[++i] : 'true';
-        }
-        else
-            positional.push(a);
-    }
-    return { positional, opts };
-}
-const list = (v) => (v ?? '').split(',').map((s) => s.trim()).filter(Boolean);
-/** `ZFI_*` style match, used only to expand --packages patterns against the real package list. */
-function matches(pattern, value) {
-    const re = new RegExp(`^${pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*')}$`, 'i');
-    return re.test(value);
-}
-export async function runProjectCommand(args, deps) {
-    const [sub, ...rest] = args;
-    try {
-        switch (sub) {
-            case 'init': return await init(rest, deps);
-            case 'join': return join(rest, deps);
-            case 'lane': return lane(rest, deps);
-            case 'status': return status(rest, deps);
-            case 'outbox': return outbox(rest, deps);
-            case 'rule': return rule(rest, deps);
-            case 'leave': return leave(deps);
-            default:
-                deps.print('Usage: cspeach project init|join|lane|status|outbox|rule|leave   (cspeach --help for details)');
-                return sub ? 1 : 0;
-        }
-    }
-    catch (e) {
-        if (e instanceof RegisterError || e instanceof BaselineError) {
-            deps.print(`✗ ${e.message}`);
-            return 1;
-        }
-        throw e;
-    }
-}
-function requireLead(project, deps) {
-    const me = deps.identity().name;
-    if (me.trim().toLowerCase() !== project.lead.name.trim().toLowerCase()) {
-        throw new RegisterError(`Only the project lead (${project.lead.name}) changes this. You are ${me}.`);
-    }
-}
-function joinedOrThrow() {
-    const joined = activeProject();
-    if (!joined)
-        throw new RegisterError('This laptop has not joined a project. Run: cspeach project join <folder>');
-    return joined;
-}
-// ── init ────────────────────────────────────────────────────────────────────
-async function init(args, deps) {
-    const { positional, opts } = flags(args);
-    const folder = positional[0];
-    if (!folder)
-        throw new RegisterError('Usage: cspeach project init <folder> --name "<name>" [--type clean-core|upgrade|build] [--packages ZFI_*,ZSD_*] [--include-local]');
-    const dir = path.resolve(folder);
-    if (fs.existsSync(path.join(dir, PROJECT_FILE)))
-        throw new RegisterError(`${dir} already holds a project. Pick an empty folder.`);
-    const name = opts.name ?? path.basename(dir);
-    const type = (opts.type ?? 'clean-core');
-    if (!TYPES.includes(type))
-        throw new RegisterError(`--type must be one of: ${TYPES.join(', ')}`);
-    if (!deps.connect)
-        throw new RegisterError('init needs a SAP connection to pull the object list.');
-    const { sql, system } = await deps.connect(opts['sap-alias']);
-    deps.print('Reading the package list from SAP…');
-    const all = await listCustomPackages(sql);
-    const patterns = list(opts.packages);
-    let chosen = all.filter((p) => patterns.some((pat) => matches(pat, p.package)));
-    if (!patterns.length && deps.choosePackages) {
-        const picked = new Set(await deps.choosePackages(all));
-        chosen = all.filter((p) => picked.has(p.package));
-    }
-    const local = all.find((p) => p.package === LOCAL_PACKAGE)?.objects ?? 0;
-    if (!opts['include-local'])
-        chosen = chosen.filter((p) => p.package !== LOCAL_PACKAGE);
-    if (!chosen.length) {
-        throw new RegisterError(`No package chosen. ${all.length} customer packages exist; name them with --packages, e.g. --packages "ZFI_*,ZSD_*".`);
-    }
-    deps.print(`Pulling ${chosen.length} package${chosen.length === 1 ? '' : 's'}, checking each against the system's own count…`);
-    const pull = await pullBaseline(sql, { packages: chosen });
-    if (!pull.objects.length)
-        throw new RegisterError('Those packages hold no code objects. Nothing was written.');
-    const now = (deps.now ?? (() => new Date()))();
-    const projectId = projectIdFor(name);
-    const baselineText = `${JSON.stringify({ kind: 'baseline', formatVersion: 1, projectId, objects: pull.objects }, null, 1)}\n`;
-    const project = {
-        kind: 'project', formatVersion: 1, projectId, name, type, lead: { name: deps.identity().name },
-        ...(system ? { system } : {}),
-        ...(opts['atc-variant'] ? { atcVariant: opts['atc-variant'] } : {}),
-        baseline: { file: BASELINE_FILE.replace(/\\/g, '/'), sha256: sha256(baselineText), takenAt: now.toISOString(), objectCount: pull.objects.length },
-        setAside: { local: opts['include-local'] ? 0 : local, generated: pull.setAside.generated, otherTypes: pull.setAside.otherTypes },
-        createdAt: now.toISOString(),
-    };
-    fs.mkdirSync(path.join(dir, 'baseline'), { recursive: true });
-    fs.writeFileSync(path.join(dir, BASELINE_FILE), baselineText);
-    fs.writeFileSync(path.join(dir, PROJECT_FILE), `${JSON.stringify(project, null, 2)}\n`);
-    writeLanes(dir, projectId, []);
-    deps.print(`✓ ${name}: ${pull.objects.length} objects in ${chosen.length} packages. Every package matched the system's count.`);
-    deps.print(`  Set aside, not in scope: ${project.setAside.local} local ($TMP), ${pull.setAside.generated} generated, ${pull.setAside.otherTypes} non-code entries.`);
-    deps.print(`  Written to ${dir}`);
-    deps.print('  Next: cspeach project lane add <id> --owner "<name>" --packages "ZFI_*"   then each person: cspeach project join <folder>');
-    return join([dir], deps);
-}
-// ── join / leave ────────────────────────────────────────────────────────────
-function join(args, deps) {
-    const { positional, opts } = flags(args);
-    if (!positional[0])
-        throw new RegisterError('Usage: cspeach project join <project folder> [--outbox <folder>]');
-    const projectDir = path.resolve(positional[0]);
-    const project = readProjectFile(projectDir);
-    const objects = readBaseline(projectDir).length; // also verifies the checksum
-    const state = loadState();
-    const outboxDir = path.resolve(opts.outbox ?? state.projects[project.projectId]?.outboxDir ?? defaultOutboxDir(project.projectId));
-    const writerId = writerIdFor(deps.identity().name);
-    fs.mkdirSync(path.join(outboxDir, 'writers', writerId, 'records'), { recursive: true });
-    state.projects[project.projectId] = { projectDir, outboxDir, writerId };
-    state.active = project.projectId;
-    saveState(state);
-    deps.print(`✓ Joined "${project.name}" (${objects} objects, lead ${project.lead.name}) as ${writerId}.`);
-    deps.print(`  Your results are recorded on this laptop, in ${outboxDir}`);
-    deps.print('  CSPeach does not send them anywhere. Hand them in by copying that folder\'s "writers" folder into the project folder,');
-    deps.print('  or keep the outbox inside your own synced folder: cspeach project join <folder> --outbox <folder>');
-    return 0;
-}
-function leave(deps) {
-    const state = loadState();
-    if (!state.active) {
-        deps.print('This laptop is not recording against a project.');
-        return 0;
-    }
-    const was = state.active;
-    state.active = null;
-    saveState(state);
-    deps.print(`✓ Stopped recording against ${was}. Files already written stay where they are.`);
-    return 0;
-}
-// ── lane ────────────────────────────────────────────────────────────────────
-function lane(args, deps) {
-    const [verb, ...rest] = args;
-    const { positional, opts } = flags(rest);
-    const joined = joinedOrThrow();
-    const project = readProjectFile(joined.projectDir);
-    const lanes = readLanes(joined.projectDir);
-    if (verb === 'list' || !verb) {
-        if (!lanes.length)
-            deps.print('No lanes yet. cspeach project lane add <id> --owner "<name>" --packages "ZFI_*"');
-        for (const l of lanes)
-            deps.print(`${l.id.padEnd(12)} ${l.owner.padEnd(20)} ${[...l.packages, ...l.namePatterns.map((n) => `name:${n}`)].join(', ')}`);
-        return 0;
-    }
-    requireLead(project, deps);
-    const id = positional[0];
-    if (!id)
-        throw new RegisterError('Usage: cspeach project lane add <id> --owner "<name>" --packages "ZFI_*" [--names "ZCL_TAX_*"]  |  lane remove <id>');
-    if (verb === 'remove') {
-        writeLanes(joined.projectDir, project.projectId, lanes.filter((l) => l.id !== id));
-        deps.print(`✓ Lane ${id} removed.`);
-        return 0;
-    }
-    if (verb !== 'add')
-        throw new RegisterError('lane: use add, remove or list.');
-    const next = { id, owner: opts.owner ?? '', packages: list(opts.packages), namePatterns: list(opts.names) };
-    if (!next.owner || (!next.packages.length && !next.namePatterns.length)) {
-        throw new RegisterError('A lane needs --owner and at least one of --packages or --names.');
-    }
-    writeLanes(joined.projectDir, project.projectId, [...lanes.filter((l) => l.id !== id), next]);
-    const reg = registerFor(joined.projectDir, joined.outboxDir);
-    const mine = reg.register.lanes.find((l) => l.id === id);
-    deps.print(`✓ Lane ${id}: ${next.owner}, ${mine.objects} objects.`);
-    if (reg.register.totals.overlapping)
-        deps.print(`  ! ${reg.register.totals.overlapping} objects now sit in more than one lane.`);
-    if (reg.register.totals.unowned)
-        deps.print(`  ${reg.register.totals.unowned} objects still have no owner.`);
-    return 0;
-}
-// ── status ──────────────────────────────────────────────────────────────────
-function registerFor(projectDir, outboxDir) {
-    const project = readProjectFile(projectDir);
-    const collected = collectRecords(projectDir);
-    // This laptop's own outbox counts too, so a developer sees their work before handing it in.
-    const own = outboxDir && path.resolve(outboxDir) !== path.resolve(projectDir) ? collectRecords(outboxDir) : { records: [], unreadable: 0, files: 0 };
-    const register = buildRegister({
-        project, baseline: readBaseline(projectDir), lanes: readLanes(projectDir),
-        records: [...collected.records, ...own.records],
-    });
-    return { register, files: collected.files + own.files, unreadable: collected.unreadable + own.unreadable };
-}
-const STATE_WORDS = [
-    ['verified', 'verified'], ['clean', 'clean'], ['claimed', 'claimed, not measured since'], ['working', 'in work'],
-    ['decided', 'decided, not started'], ['untouched', 'untouched'], ['did-not-hold', 'fix did not hold'],
-    ['regressed', 'regressed'], ['retired', 'retired'],
-];
-function status(args, deps) {
-    const { positional } = flags(args);
-    const joined = activeProject();
-    const projectDir = positional[0] ? path.resolve(positional[0]) : joined?.projectDir;
-    if (!projectDir)
-        throw new RegisterError('Usage: cspeach project status [<project folder>]');
-    const project = readProjectFile(projectDir);
-    const { register: r, files, unreadable } = registerFor(projectDir, positional[0] ? undefined : joined?.outboxDir);
-    const t = r.totals;
-    deps.print(`${project.name}  (${project.type}, lead ${project.lead.name})`);
-    deps.print(`${t.objects} objects, ${t.active} active. ${t.decided} decided. ${t.byState.verified} verified, ${t.byState.clean} clean.`);
-    deps.print(r.lastMeasuredAt ? `Last measured ${r.lastMeasuredAt.slice(0, 16).replace('T', ' ')} UTC.` : 'Not measured yet: "verified" and "clean" need an ATC run.');
-    deps.print('');
-    for (const [state, word] of STATE_WORDS)
-        if (t.byState[state])
-            deps.print(`  ${String(t.byState[state]).padStart(6)}  ${word}`);
-    deps.print('');
-    if (r.lanes.length) {
-        deps.print('Lane         Owner                Objects  Done  Last record');
-        for (const l of r.lanes) {
-            const done = l.byState.verified + l.byState.clean + l.byState.retired;
-            deps.print(`${l.id.padEnd(12)} ${l.owner.padEnd(20)} ${String(l.objects).padStart(7)} ${String(done).padStart(5)}  ${l.lastRecordAt ? l.lastRecordAt.slice(0, 10) : 'nothing yet'}`);
-        }
-        deps.print('');
-    }
-    if (t.unowned)
-        deps.print(`! ${t.unowned} objects have no owner.`);
-    if (t.overlapping)
-        deps.print(`! ${t.overlapping} objects sit in more than one lane.`);
-    if (t.conflicts) {
-        deps.print(`! ${t.conflicts} objects have conflicting decisions. The lead settles each with: cspeach project rule <TYPE> <NAME> <decision>`);
-        for (const o of r.objects.filter((x) => x.decision?.conflict).slice(0, 10)) {
-            deps.print(`    ${o.key}: ${Object.entries(o.decision.conflict).map(([w, c]) => `${w} says ${c}`).join(', ')}`);
-        }
-    }
-    const s = r.skipped;
-    if (unreadable)
-        deps.print(`  ${unreadable} of ${files} files could not be read yet (still syncing, or damaged).`);
-    if (s.rowsNotInBaseline)
-        deps.print(`  ${s.rowsNotInBaseline} rows named objects that are not in this project: ${r.unknownKeys.slice(0, 5).join(', ')}`);
-    if (s.otherProject)
-        deps.print(`  ${s.otherProject} files belong to another project and were ignored.`);
-    if (s.rulingsNotFromLead)
-        deps.print(`  ${s.rulingsNotFromLead} rulings were not from the lead and were ignored.`);
-    return 0;
-}
-// ── outbox / rule ───────────────────────────────────────────────────────────
-function outbox(_args, deps) {
-    const joined = joinedOrThrow();
-    const dir = path.join(joined.outboxDir, 'writers', joined.writerId, 'records');
-    const files = fs.existsSync(dir) ? fs.readdirSync(dir).filter((f) => f.endsWith('.json')).sort() : [];
-    deps.print(`Records this laptop has written for ${joined.projectId}: ${files.length}`);
-    deps.print(`  ${dir}`);
-    for (const f of files.slice(-15)) {
-        let rows = '?';
-        try {
-            rows = String(JSON.parse(fs.readFileSync(path.join(dir, f), 'utf8')).rows.length);
-        }
-        catch { /* listed anyway */ }
-        deps.print(`  ${f}  (${rows} rows)`);
-    }
-    deps.print('Each file is plain JSON: object names, decisions, statuses. No source code. Open one in Notepad to check.');
-    return 0;
-}
-function rule(args, deps) {
-    const { positional, opts } = flags(args);
-    const [type, name, classification] = positional;
-    if (!type || !name || !CLASSIFICATIONS.includes(classification)) {
-        throw new RegisterError(`Usage: cspeach project rule <TYPE> <NAME> ${CLASSIFICATIONS.join('|')} [--reason "<why>"]`);
-    }
-    const joined = joinedOrThrow();
-    requireLead(readProjectFile(joined.projectDir), deps);
-    const res = writeRecord(joined, 'ruling', [{ key: objectKey(type, name), classification, ...(opts.reason ? { reason: opts.reason } : {}) }], deps.identity(), { dir: path.join(joined.projectDir, 'rulings'), now: deps.now?.() });
-    if (!res.file)
-        throw new RegisterError(`${objectKey(type, name)} is not in this project's baseline.`);
-    deps.print(`✓ Ruled ${objectKey(type, name)} = ${classification}.`);
-    return 0;
-}

package/dist/tools/local-files.js

@@ -1,31 +0,0 @@
-// cspeach-cli/src/tools/local-files.ts
-/**
- * Startup wiring for the persisted `local_files` config toggle.
- *
- * When `cfg.local_files === true`, the otherwise flag-gated filesystem tools
- * (file_read/file_write/file_edit/glob/grep) are force-enabled via the
- * in-memory override in `_flag.ts`, BEFORE the first listTools()/turn. This is
- * what makes /abap-fiori-build runnable — it writes local app files.
- *
- * The toggle is PERSISTED (config.toml), not re-consented each session, so
- * `applyLocalFilesConfig` returns an announce line the entry point prints
- * whenever the tools are live — the user must always see that local file
- * access is on this session (trust-visibility requirement). The FS tools'
- * own cwd-sandbox (writes confined to the project root; .cspeach/.env/.git
- * denylisted) still applies regardless of this toggle.
- */
-import { enableToolFlags } from './_flag.js';
-/** The exact tool NAMEs the flag uses (file_read → CSPEACH_TOOL_FILE_READ). */
-export const LOCAL_FILE_TOOLS = ['file_read', 'file_write', 'file_edit', 'glob', 'grep'];
-/**
- * Apply the persisted `local_files` toggle. When on, force-enables the FS
- * tools and returns a one-line announce string (undefined when off, so the
- * caller prints nothing). `cwd` is surfaced so the user sees exactly which
- * directory tree read/write/edit operate under.
- */
-export function applyLocalFilesConfig(localFiles, cwd) {
-    if (localFiles !== true)
-        return undefined;
-    enableToolFlags([...LOCAL_FILE_TOOLS]);
-    return `local file tools enabled (read/write/edit under ${cwd}) — cspeach config set local_files off to disable`;
-}

package/dist/tools/subagent/schedule_create.js

@@ -1,131 +0,0 @@
-// cspeach-cli/src/tools/subagent/schedule_create.ts
-/**
- * schedule_create — Phase 3 / Chunk 3E.
- *
- * Persists a schedule envelope to ~/.cspeach/schedules/<uuid>.json.
- * Filename is ALWAYS crypto.randomUUID — never derived from user
- * input. Closes the path-injection class of attack on the schedules
- * directory.
- *
- * IMPORTANT: this tool persists schedules. It does NOT execute them.
- * A future chunk (Phase 4 or later) ships the actual runner. The
- * tool description and the response body both surface this caveat
- * so the agent doesn't assume the schedule will fire.
- *
- * Flag-gated: invisible to listTools() unless
- * CSPEACH_TOOL_SCHEDULE_CREATE=on. isMutating: true (writes filesystem).
- */
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { registerTool } from '../index.js';
-const NOT_EXECUTED_NOTE = 'Persisted only — the schedule runner has not shipped yet. ' +
-    'See Phase 4+ for execution.';
-// Test-overridable. Default to ~/.cspeach/schedules. Set null to reset.
-let schedulesDirOverride = null;
-/** Test-only: redirect the schedules dir so tests don't pollute the real home dir. */
-export function __setSchedulesDirForTests(dir) {
-    schedulesDirOverride = dir;
-}
-function getSchedulesDir() {
-    return schedulesDirOverride ?? path.join(os.homedir(), '.cspeach', 'schedules');
-}
-// Strict ISO-8601 UTC: YYYY-MM-DDTHH:MM:SS(.sss)?Z
-const ISO_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/;
-export async function scheduleCreateHandler(args, _ctx) {
-    if (args.kind !== 'oneoff' && args.kind !== 'cron') {
-        return { content: `error: kind must be 'oneoff' or 'cron' — got '${args.kind}'`, is_error: true };
-    }
-    if (!args.when || typeof args.when !== 'string' || args.when.trim().length === 0) {
-        return { content: 'error: when is required (non-empty string)', is_error: true };
-    }
-    if (!args.command || typeof args.command !== 'string' || args.command.trim().length === 0) {
-        return { content: 'error: command is required (non-empty string)', is_error: true };
-    }
-    if (args.kind === 'oneoff') {
-        if (!ISO_PATTERN.test(args.when)) {
-            return { content: `error: when must be an ISO-8601 UTC timestamp (e.g. 2099-06-01T10:00:00Z) — got '${args.when}'`, is_error: true };
-        }
-        const t = Date.parse(args.when);
-        if (Number.isNaN(t)) {
-            return { content: `error: when is not a parseable ISO timestamp: '${args.when}'`, is_error: true };
-        }
-        // Belt-and-braces against silent month/day rollover. Date.parse('2099-02-30T00:00:00Z')
-        // returns a valid timestamp that round-trips to March 2 — without this check, the
-        // envelope persists '2099-02-30' but the runner fires on March 2 (phantom job).
-        const roundTrip = new Date(t).toISOString();
-        // Normalise both sides: lowercase 'z', strip optional fractional seconds, compare.
-        const norm = (s) => s.replace(/\.\d+Z$/, 'Z').toUpperCase();
-        if (norm(roundTrip) !== norm(args.when)) {
-            return { content: `error: when is not a valid calendar date: '${args.when}' (rolls to ${roundTrip})`, is_error: true };
-        }
-        if (t <= Date.now()) {
-            return { content: `error: when is in the past — schedule must be in the future`, is_error: true };
-        }
-    }
-    else {
-        // cron: just check it has 5 whitespace-separated fields.
-        const fields = args.when.trim().split(/\s+/);
-        if (fields.length !== 5) {
-            return { content: `error: cron expression must have 5 fields (min hour dom mon dow) — got ${fields.length}`, is_error: true };
-        }
-    }
-    const dir = getSchedulesDir();
-    await fs.mkdir(dir, { recursive: true });
-    // Defence-in-depth: resolve the directory and verify it sits inside
-    // the cspeach home (or the test override). Refuses if a symlink
-    // points the dir at /etc/, /tmp/host-controlled/, etc.
-    const realDir = await fs.realpath(dir);
-    // In test mode the override dir IS the root (self-containment is trivial —
-    // mkdtemp gives us a unique dir that acts as both schedules-dir and its own
-    // root). In prod the schedules dir must sit UNDER ~/.cspeach/, so the root
-    // is the parent. Asymmetric on purpose.
-    const expectedRoot = schedulesDirOverride !== null
-        ? path.resolve(schedulesDirOverride)
-        : path.join(os.homedir(), '.cspeach');
-    const rel = path.relative(expectedRoot, realDir);
-    if (rel.startsWith('..') || path.isAbsolute(rel)) {
-        return { content: `error: schedules directory '${realDir}' resolves outside expected root`, is_error: true };
-    }
-    const id = randomUUID();
-    const envelope = {
-        id,
-        kind: args.kind,
-        when: args.when,
-        command: args.command,
-        createdAt: new Date().toISOString(),
-        note: NOT_EXECUTED_NOTE,
-    };
-    const target = path.join(realDir, `${id}.json`);
-    await fs.writeFile(target, JSON.stringify(envelope, null, 2), { encoding: 'utf-8', mode: 0o600 });
-    return {
-        content: `schedule persisted (NOT YET EXECUTED — runner ships in a later chunk).\n` +
-            `path: ${target}\n` +
-            `id: ${id}\n` +
-            `kind: ${args.kind}\n` +
-            `when: ${args.when}\n` +
-            `command: ${args.command}\n` +
-            `note: ${NOT_EXECUTED_NOTE}`,
-    };
-}
-registerTool({
-    name: 'schedule_create',
-    description: 'Persist a oneoff or cron schedule envelope to ~/.cspeach/schedules/<uuid>.json. ' +
-        'Filename is a fresh UUID — never derived from input. NOTE: this tool only PERSISTS the ' +
-        'schedule. No runner is shipped yet — the agent should not assume the command will fire ' +
-        'automatically. A future chunk will ship the runner.',
-    isMutating: true,
-    category: 'subagent',
-    flagGated: true,
-    input_schema: {
-        type: 'object',
-        properties: {
-            kind: { type: 'string', enum: ['oneoff', 'cron'], description: 'oneoff = single ISO timestamp; cron = 5-field expression' },
-            when: { type: 'string', description: 'ISO-8601 UTC timestamp for oneoff, or 5-field cron expression' },
-            command: { type: 'string', description: 'The command the runner WOULD execute (free-form string for now)' },
-        },
-        required: ['kind', 'when', 'command'],
-    },
-    handler: (args, ctx) => scheduleCreateHandler(args, ctx),
-});

package/dist/ui/error-emitter.js

@@ -1,21 +0,0 @@
-import { EventEmitter } from 'node:events';
-import { shouldUseInk } from '../renderer/tty.js';
-import chalk from 'chalk';
-export const errorEmitter = new EventEmitter();
-/**
- * Emit an error. In Ink mode, the main App subscribes and pushes the error
- * into its errorStack state for overlay rendering. In non-TTY / one-shot,
- * we fall back to chalk.red on stderr — never mount a second Ink root.
- */
-export function emitError(err) {
-    if (shouldUseInk()) {
-        errorEmitter.emit('error', err);
-    }
-    else {
-        console.error(chalk.red(`[${err.code}] ${err.title}`));
-        if (err.body)
-            console.error(chalk.red(`  ${err.body}`));
-        if (err.hint)
-            console.error(chalk.dim(`  ${err.hint}`));
-    }
-}

package/dist/ui/header.js

@@ -1,41 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { useSapState } from './sap-state-store.js';
-import { formatSpendSegment } from './status-line.js';
-import { CLI_VERSION } from '../lib/version.js';
-const PEACH = '#FFCBA4';
-/**
- * ⚠ SUPERSEDED (UX Wave 1, Task 4 — 2026-07) by ui/status-line.tsx, the
- * bottom-anchored borderless statusline mounted in App between TurnStatus
- * and Footer. This component is no longer rendered anywhere: Phase D6
- * removed the persistent top Header (inline mode can't pin the frame top),
- * and the statusline took over the SapStateStore display role. Kept for
- * reference, not deleted.
- *
- * Single-line rich header (Phase D3, 2026-05-16) — back to one line per
- * Laeeq's feedback that the two-line variant felt worse. Uses tighter
- * separators and shorter labels so it fits cleanly on typical terminals
- * (100+ cols). On a narrower terminal Ink will wrap rather than truncate,
- * accepted as a degradation case.
- *
- * Layout:
- *   🍑 CSPeach 0.6.5 │ S4H │ S.LAEEQ │ tr none │ 28k tok │ $0.54 │ approval-gated
- */
-export function Header({ writeMode } = {}) {
-    const s = useSapState();
-    const isAdvisory = writeMode === 'advisory-only';
-    const modeLabel = isAdvisory
-        ? 'ADVISORY'
-        : writeMode === 'approval-gated'
-            ? 'approval-gated'
-            : writeMode === 'auto'
-                ? 'auto'
-                : undefined;
-    const modeColor = isAdvisory ? 'yellow' : 'green';
-    const tokDisplay = s.tokenUsageToday >= 1000
-        ? `${(s.tokenUsageToday / 1000).toFixed(1)}k tok`
-        : `${s.tokenUsageToday} tok`;
-    // Shared with <StatusLine /> so the credits/dollar switch has one home.
-    const spendDisplay = formatSpendSegment(s);
-    return (_jsxs(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsxs(Text, { bold: true, color: PEACH, children: ["\uD83C\uDF51 CSPeach ", CLI_VERSION] }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "cyan", children: s.system || 'no system' }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "white", children: s.user || '—' }), _jsx(Text, { color: "gray", children: " \u2502 tr " }), _jsx(Text, { color: "yellow", children: s.transport ?? 'none' }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "green", children: tokDisplay }), _jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: "green", children: spendDisplay }), modeLabel && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: " \u2502 " }), _jsx(Text, { color: modeColor, bold: isAdvisory, children: modeLabel })] }))] }));
-}

package/dist/ui/ink-classifier-route.js

@@ -1,19 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useEffect } from 'react';
-import { Box, Text, useInput } from 'ink';
-/**
- * Medium-confidence banner rendered inside the Ink frame. Auto-settles to
- * the classifier's top pick after 800ms, unless the user presses Tab — in
- * which case we open the CommandPalette with alternates.
- */
-export function InkClassifierRoute({ skill, confidence, onSettle, onOpenPalette }) {
-    useEffect(() => {
-        const t = setTimeout(onSettle, 800);
-        return () => clearTimeout(t);
-    }, [onSettle]);
-    useInput((_input, key) => {
-        if (key.tab)
-            onOpenPalette();
-    });
-    return (_jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["\\u2504 Suggest /", skill, " (confidence ", Math.round(confidence * 100), "%) \\u2014 Tab to pick"] }) }));
-}

package/dist/ui/rich-error-box.js

@@ -1,9 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-function severityColor(s) {
-    return s === 'error' ? 'red' : s === 'warning' ? 'yellow' : 'blue';
-}
-export function RichErrorBox({ code, message, hint, severity = 'error' }) {
-    const color = severityColor(severity);
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: color, paddingX: 2, paddingY: 1, children: [_jsx(Text, { bold: true, color: color, children: code }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: message }) }), hint && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: hint }) }))] }));
-}

package/dist/ui/sidebar.js

@@ -1,12 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from 'ink';
-import { useSapState } from './sap-state-store.js';
-export function Sidebar() {
-    const s = useSapState();
-    // Phase A** (2026-05-16) — dropped the "/ of $100" pseudo-budget. We
-    // don't know the user's actual API spending limit; showing a fake
-    // cap trained the colour signal to be meaningless. Now just shows the
-    // raw spend. Colour signal removed alongside.
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, width: 30, children: [_jsx(Text, { bold: true, color: "cyan", children: s.system || 'no system' }), _jsxs(Text, { color: "gray", children: ["user: ", _jsx(Text, { color: "white", children: s.user || '—' })] }), _jsxs(Text, { color: "gray", children: ["transport: ", _jsx(Text, { color: "yellow", children: s.transport ?? 'none' })] }), _jsxs(Text, { color: "gray", children: ["locks: ", s.locksHeld.length === 0 ? _jsx(Text, { dimColor: true, children: "(none)" })
-                        : s.locksHeld.map((l, i) => _jsxs(Text, { color: "red", children: [l, " "] }, i))] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "green", children: [s.tokenUsageToday.toLocaleString(), " tok / $", s.dollarSpendToday.toFixed(2)] }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "\u2500 recent turns \u2500" }), s.recentTurns.slice(-5).reverse().map((t, i) => (_jsxs(Text, { dimColor: true, children: [t.time, " ", t.command.slice(0, 20)] }, i))), s.recentTurns.length === 0 && _jsx(Text, { dimColor: true, children: "(no turns yet)" })] })] }));
-}

package/dist/ui/status-emitter.js

@@ -1,19 +0,0 @@
-import { EventEmitter } from 'node:events';
-/**
- * Singleton channel from `runTurn` (producer) to `<App>` (consumer) for
- * status-row updates in Ink mode. Phase A #1 (2026-05-16) — the prior
- * version of the REPL claimed Ink rendered its own `<StatusRow>` but
- * never imported the component. As a result Ink users saw NO cost,
- * token, or session info ever. This emitter is the missing wire.
- *
- * Producer (repl.tsx, end-of-turn): emits an `update` event with the
- * latest StatusRowData. Consumer (App.tsx): subscribes in a useEffect,
- * stores in state, renders `<StatusRow data={...} />` above `<Footer>`.
- *
- * Why a separate emitter (not chunkEmitter): chunkEmitter pipes strings
- * into Body. StatusRow needs structured data (numbers + dollar amounts)
- * and lives in a fixed region — passing it through chunks would mean
- * sentinel parsing for what is naturally typed state. Matches the
- * approvalEmitter / errorEmitter / coachingPickerEmitter pattern.
- */
-export const statusEmitter = new EventEmitter();