@pugi/cli 0.1.0-alpha.10 → 0.1.0-alpha.16

package/dist/runtime/cli.js

@@ -16,6 +16,7 @@ import { globTool, grepTool, readTool } from '../tools/file-tools.js';
 import { toolRegistry, toolSchemaBundleHashInput } from '../tools/registry.js';
 import { webFetchTool } from '../tools/web-fetch.js';
 import { emptyIndex, rebuildIndex, readIndex, upsertArtifact, writeIndex, } from '../core/index-store.js';
+import { signatureForPlanReview } from '../core/repl/ask.js';
 import { buildRuntimeConfig, loadRuntimeConfig, pollDeviceFlow, pugiHandoffBundleSchema, pugiSyncDryRunPlanSchema, pugiSyncPrivacyModeSchema, pugiSyncRequestSchema, pugiSyncUploadPlanSchema, pugiTripleReviewRequestSchema, startDeviceFlow, submitSync, submitTripleReview, } from '@pugi/sdk';
 import { PUGI_TAGLINE } from '@pugi/personas';
 import { clearApiKey, DEFAULT_API_URL, listStoredCredentials, maskApiKey, normalizeApiUrl, purgeAllCredentials, readCredentialsFile, resolveActiveCredential, storeApiKey, switchActiveAccount, } from '../core/credentials.js';
@@ -26,6 +27,10 @@ import { runUndoCommand } from './commands/undo.js';
 import { runBudgetCommand } from './commands/budget.js';
 import { runSkillsCommand } from './commands/skills.js';
 import { runAgentsCommand } from './commands/agents.js';
+import { resolveWorkspaceLabel } from '../core/repl/workspace-context.js';
+import { runReviewConsensus } from './commands/review-consensus.js';
+import { FtsSyntaxError, SqliteSessionStore, resolveProjectStoreDir } from '../core/repl/store/index.js';
+import { slugForCwd } from '../core/repl/history.js';
 /**
  * CLI version shown by `pugi version` and embedded in `pugi doctor --json`.
  *
@@ -37,10 +42,11 @@ import { runAgentsCommand } from './commands/agents.js';
  * packages/pugi-sdk/package.json); the publish workflow validates the
  * three are in lockstep.
  */
-const PUGI_CLI_VERSION = '0.1.0-alpha.10';
+const PUGI_CLI_VERSION = "0.1.0-alpha.16";
 const handlers = {
     accounts,
     agents: dispatchAgents,
+    ask: dispatchAsk,
     build: runEngineTask('build_task'),
     budget: dispatchBudget,
     code: runEngineTask('code'),
@@ -56,6 +62,7 @@ const handlers = {
     login,
     logout,
     plan: runEngineTask('plan'),
+    'plan-review': dispatchPlanReview,
     privacy: dispatchPrivacy,
     review,
     resume,
@@ -67,6 +74,162 @@ const handlers = {
     web: dispatchWeb,
     whoami,
 };
+/**
+ * α6.3 `pugi ask "<question>"` — surface the office-hours forcing-question
+ * modal manually. In an interactive TTY we mount a tiny Ink app, render
+ * the `<AskModal />`, and await the operator's verdict. In non-TTY
+ * (CI / pipes), we emit the structured ask JSON to stdout so scripted
+ * callers can pipe the response back without rendering a modal.
+ *
+ * The verdict is printed to stdout as either:
+ *   - the chosen option `value` (one of the yes/no defaults)
+ *   - `other:<text>` when the operator typed a custom answer
+ *   - `cancelled` when the operator pressed Esc
+ *
+ * This is a CLI-side helper. The REPL slash `/ask` is wired separately
+ * through `slash-commands.ts`.
+ */
+async function dispatchAsk(args, flags, _session) {
+    const question = args.join(' ').trim();
+    if (!question) {
+        writeOutput(flags, { ok: false, error: 'Usage: pugi ask "<question>"' }, 'Usage: pugi ask "<question>"');
+        process.exitCode = 2;
+        return;
+    }
+    const { synthesiseLocalAskTag } = await import('../core/repl/session.js');
+    const tag = synthesiseLocalAskTag(question);
+    if (!tag) {
+        writeOutput(flags, { ok: false, error: 'Question must be 1-80 chars.' }, 'pugi ask: question must be 1-80 chars.');
+        process.exitCode = 2;
+        return;
+    }
+    if (!isInteractive(flags)) {
+        // Non-TTY: emit the structured ask payload so scripted callers can
+        // forward it. The interactive modal is only meaningful with a real
+        // terminal, so the line-buffered fallback prints the question +
+        // options and exits 0 — callers parse the JSON.
+        const payload = {
+            ok: true,
+            ask: {
+                question: tag.question,
+                options: tag.options,
+                signature: tag.signature,
+            },
+        };
+        writeOutput(flags, payload, [
+            `Question: ${tag.question}`,
+            ...tag.options.map((o, i) => `  ${i + 1}. ${o.label}${o.desc ? ` - ${o.desc}` : ''}`),
+            `  ${tag.options.length + 1}. Other (custom)`,
+            '',
+            '(non-TTY: re-run in a real terminal to answer interactively, or pipe an answer to stdin)',
+        ].join('\n'));
+        return;
+    }
+    // Interactive: render the Ink modal and await resolution.
+    const { renderAskCli } = await import('../tui/ask-cli.js');
+    const verdict = await renderAskCli({ tag });
+    const encoded = verdict.cancelled
+        ? 'cancelled'
+        : verdict.value.length > 0
+            ? verdict.value
+            : `other:${verdict.customInput ?? ''}`;
+    writeOutput(flags, { ok: true, verdict: encoded }, encoded);
+}
+/**
+ * α6.3 `pugi plan-review <task>` — generate + present a plan WITHOUT
+ * executing. The legacy `pugi plan` surface (offline plan generator,
+ * see runEngineTask) stays intact; `plan-review` adds the office-hours
+ * Ink modal layer on top so the operator can approve/modify/cancel
+ * before the orchestrator dispatches Marcus.
+ *
+ * Phase 1 implementation: build a deterministic plan stub from the
+ * task description (the persona-driven planner ships in a follow-up
+ * sprint). The plan is presented through the standard
+ * `<pugi-plan-review>` modal in interactive mode; non-TTY emits the
+ * structured payload to stdout for scripted consumers.
+ *
+ * The exit code reflects the operator's verdict:
+ *   - 0 PASS    approved
+ *   - 1 MODIFY  modify (text printed)
+ *   - 2 CANCEL  cancel
+ */
+async function dispatchPlanReview(args, flags, _session) {
+    const task = args.join(' ').trim();
+    if (!task) {
+        writeOutput(flags, { ok: false, error: 'Usage: pugi plan <task description>' }, 'Usage: pugi plan <task description>');
+        process.exitCode = 2;
+        return;
+    }
+    const planTag = synthesiseLocalPlanReview(task);
+    if (!isInteractive(flags)) {
+        const payload = {
+            ok: true,
+            plan: {
+                steps: planTag.steps,
+                risk: planTag.risk,
+                signature: planTag.signature,
+            },
+        };
+        writeOutput(flags, payload, [
+            'Plan review (non-execution):',
+            ...planTag.steps.map((s, i) => `  ${i + 1}. ${s.text}`),
+            planTag.risk ? `Risk: ${planTag.risk}` : '',
+            '',
+            '(non-TTY: re-run in a real terminal to approve/modify/cancel interactively)',
+        ]
+            .filter(Boolean)
+            .join('\n'));
+        return;
+    }
+    const { renderPlanReviewCli } = await import('../tui/ask-cli.js');
+    const result = await renderPlanReviewCli({ tag: planTag });
+    switch (result.verdict) {
+        case 'approve':
+            writeOutput(flags, { ok: true, verdict: 'approve' }, 'approve');
+            return;
+        case 'modify':
+            writeOutput(flags, { ok: true, verdict: 'modify', modifyText: result.modifyText ?? '' }, `modify: ${result.modifyText ?? ''}`);
+            process.exitCode = 1;
+            return;
+        case 'cancel':
+            writeOutput(flags, { ok: true, verdict: 'cancel' }, 'cancel');
+            process.exitCode = 2;
+            return;
+    }
+}
+/**
+ * Local plan stub generator. Until the persona-side planner lands, we
+ * produce a deterministic 3-step skeleton anchored to the task text so
+ * the operator can dry-run the modal interaction. Real plan synthesis
+ * arrives in a follow-up sprint.
+ */
+function synthesiseLocalPlanReview(task) {
+    const truncated = task.length > 80 ? task.slice(0, 77) + '...' : task;
+    const steps = [
+        { text: `1. Understand the task: ${truncated}` },
+        { text: '2. Identify scope, files touched, side effects.' },
+        { text: '3. Execute with verification gates per Pugi defaults.' },
+    ];
+    const risk = task.length > 200
+        ? 'Long task description - consider splitting into smaller briefs.'
+        : undefined;
+    // Route through the single-source signature helper from ask.ts so a
+    // parser-extracted plan-review with identical content collides
+    // deterministically with this synthesised one. Inlining the formula
+    // here (as the original implementation did) silently drifted from
+    // signatureForPlanReview when the helper added `.trim()` to each
+    // step. Codex triple-review P2 (PR #375).
+    const signature = signatureForPlanReview(steps, risk ?? null);
+    const tag = {
+        steps,
+        signature,
+        start: 0,
+        end: 0,
+    };
+    if (risk)
+        tag.risk = risk;
+    return tag;
+}
 async function dispatchConfig(args, flags, _session) {
     await runConfigCommand(args, {
         workspaceRoot: process.cwd(),
@@ -188,6 +351,7 @@ export async function runCli(argv) {
                 cliVersion: PUGI_CLI_VERSION,
                 updateBanner,
                 skipSplash: flags.noSplash,
+                hideToolStream: flags.noToolStream,
             });
             return;
         }
@@ -219,11 +383,24 @@ function parseArgs(argv) {
         web: false,
         dryRun: false,
         triple: false,
+        consensus: false,
         offline: false,
         noTty: false,
         allowFetch: false,
         noUpdateCheck: false,
         noSplash: process.env.PUGI_SKIP_SPLASH === '1',
+        // Claude triple-review P1 PR #369: default tool-stream pane HIDDEN
+        // until backend ships `tool.start`/`tool.result` SSE events. Current
+        // client-side synthesiser parses persona prose for `Read(...)` /
+        // `Bash(...)` patterns — never fires in production (admin-api emits
+        // "Mira: ..." prose, never "Read(path)" prefix) OR fires falsely on
+        // accidental `Verb(noun)` shapes producing stuck `running` rows.
+        // Hide by default; opt-in via `--tool-stream` OR PUGI_TOOL_STREAM=1
+        // for development/testing. Will flip к default ON when backend
+        // emits real tool events (filed as α6.13.X follow-up).
+        noToolStream: process.env.PUGI_TOOL_STREAM === '1' || process.env.PUGI_HIDE_TOOL_STREAM === '1'
+            ? process.env.PUGI_HIDE_TOOL_STREAM === '1'
+            : true,
     };
     const args = [];
     // Sprint 2E: `pugi --version` / `-v` are universal install-test conventions
@@ -250,9 +427,16 @@ function parseArgs(argv) {
         else if (arg === '--dry-run') {
             flags.dryRun = true;
         }
-        else if (arg === '--triple' || arg === '--consensus') {
+        else if (arg === '--triple') {
             flags.triple = true;
         }
+        else if (arg === '--consensus') {
+            // α6.7: customer-facing 3-model consensus review. Routes through
+            // the SSE-based runtime gate rather than the legacy artifact
+            // writer. The triple flag stays unset так the existing
+            // performRemoteTripleReview path is never accidentally entered.
+            flags.consensus = true;
+        }
         else if (arg === '--offline') {
             flags.offline = true;
         }
@@ -268,6 +452,14 @@ function parseArgs(argv) {
         else if (arg === '--no-splash') {
             flags.noSplash = true;
         }
+        else if (arg === '--no-tool-stream') {
+            flags.noToolStream = true;
+        }
+        else if (arg === '--tool-stream') {
+            // Opt-in для α6.12 dev/testing — backend tool events not live yet,
+            // pane shows синтесайз heuristic OR empty placeholder
+            flags.noToolStream = false;
+        }
         else if (arg.startsWith('--privacy=')) {
             flags.privacy = parsePrivacyMode(arg.slice('--privacy='.length));
         }
@@ -317,6 +509,9 @@ async function help(_args, flags, _session) {
         '',
         'Review gate:',
         '  pugi review --triple    Prepare the Anvil-backed triple-review gate.',
+        '  pugi review --consensus 3-model consensus review (codex · claude · deepseek).',
+        '                          Optional: --commit <sha> | --pr <num> | --branch <name>.',
+        '                          Exits 0 PASS · 1 WARN · 2 BLOCK.',
         '',
         'Skills + agents marketplace:',
         '  pugi skills list                            All installed skills.',
@@ -325,6 +520,10 @@ async function help(_args, flags, _session) {
         '  pugi agents list                            All installed sub-agents.',
         '  pugi agents install <source> [--yes]        Fetch + trust + install an agent.',
         '',
+        'Office-hours forcing questions (α6.3):',
+        '  pugi ask "<question>"          Surface a yes/no question modal locally.',
+        '  pugi plan-review <task>        Generate + present a plan-review modal.',
+        '',
         'Sync safety:',
         '  pugi sync --dry-run --privacy metadata',
         '',
@@ -335,6 +534,8 @@ async function help(_args, flags, _session) {
         '                          with PUGI_SKIP_UPDATE_BANNER=1.',
         '  --no-splash             Skip the REPL boot splash. Pairs with',
         '                          PUGI_SKIP_SPLASH=1.',
+        '  --no-tool-stream        Hide the live tool stream pane (α6.12).',
+        '                          Pairs with PUGI_HIDE_TOOL_STREAM=1.',
         '',
         PUGI_TAGLINE,
         'Execution defaults to local. Use --remote or --web to create a handoff bundle.',
@@ -799,6 +1000,26 @@ async function review(args, flags, session) {
     const root = process.cwd();
     ensureInitialized(root);
     const prompt = args.join(' ').trim();
+    // α6.7: customer-facing consensus review routes here. Distinct from
+    // `--triple --remote` (legacy artifact-writer flow) so the new SSE
+    // streaming UX and rubric-driven exit codes don't disturb the existing
+    // pugi-cli surfaces that depend on the old shape.
+    if (flags.consensus) {
+        const exitCode = await runReviewConsensus(args, {
+            cwd: root,
+            config: resolveRuntimeConfig(),
+            json: flags.json,
+            emit: (line) => {
+                if (!flags.json)
+                    process.stdout.write(line);
+            },
+            writeOutput: (payload, text) => writeOutput(flags, payload, text),
+        });
+        // Caller owns `process.exitCode` so a REPL slash invocation
+        // ('/consensus') cannot inherit a stale exit code from a previous run.
+        process.exitCode = exitCode;
+        return;
+    }
     if (flags.triple && flags.remote) {
         await performRemoteTripleReview(root, session, flags, prompt);
         return;
@@ -1362,6 +1583,14 @@ async function handoff(args, flags, session) {
     writeOutput(flags, bundle, ['Pugi handoff bundle created', `Bundle: ${bundle.path}`].join('\n'));
 }
 async function sessions(args, flags, _session) {
+    // α6.4: `pugi sessions --local` / `--search "query"` route to the
+    // local SessionStore. The default surface stays artifact-based for
+    // backward compat — operators who relied on the index.json view get
+    // the same shape.
+    if (args.includes('--local') || args.includes('--search')) {
+        await sessionsLocal(args, flags);
+        return;
+    }
     const root = process.cwd();
     ensureInitialized(root);
     const rebuild = args.includes('--rebuild');
@@ -1436,6 +1665,72 @@ async function sessions(args, flags, _session) {
 function hasStubSession(index) {
     return index.sessions.some((session) => session.commandCount === 0 && session.commands.length === 0);
 }
+/**
+ * α6.4: `pugi sessions --local` / `--search "query"` against the
+ * SessionStore. The default `--local` mode lists the 10 most recent
+ * sessions for the current project; `--search "query"` runs FTS5
+ * against the title+body index.
+ */
+async function sessionsLocal(args, flags) {
+    const cwd = process.cwd();
+    const projectSlug = slugForCwd(cwd);
+    const projectDir = resolveProjectStoreDir(projectSlug);
+    if (!existsSync(resolve(projectDir, 'session.db'))) {
+        writeOutput(flags, { status: 'no-sessions', projectSlug, projectDir }, `No stored sessions for project '${projectSlug}' yet.`);
+        return;
+    }
+    // Parse `--search "query"` or `--search query`.
+    const searchIdx = args.indexOf('--search');
+    const query = searchIdx >= 0 ? (args[searchIdx + 1] ?? '').trim() : '';
+    if (query.length > 0) {
+        let rows;
+        try {
+            rows = await searchLocalSessions(projectSlug, query);
+        }
+        catch (error) {
+            // Surface FTS5 syntax errors as a clean one-line message + exit 2
+            // so a stray `"` in the operator's input does not dump a stack
+            // trace. Both the live-store path (FtsSyntaxError) and the
+            // read-only fallback (SQLite error with code starting `SQLITE_`)
+            // funnel here.
+            const code = error?.code;
+            if (error instanceof FtsSyntaxError
+                || (typeof code === 'string' && (code === 'EFTS5_SYNTAX' || code.startsWith('SQLITE_')))) {
+                writeOutput(flags, { status: 'error', error: 'invalid search query', query }, `Invalid search query: '${query}'. Try simpler text (no unbalanced quotes).`);
+                process.exitCode = 2;
+                return;
+            }
+            throw error;
+        }
+        writeOutput(flags, { projectSlug, query, sessions: rows }, rows.length === 0
+            ? `No local sessions matched '${query}' for project '${projectSlug}'.`
+            : `Search hits for '${query}' (${rows.length}):\n\n${rows
+                .map((row) => `  ${row.id.slice(0, 13)}  ${(row.title ?? '(untitled)').slice(0, 64)}`)
+                .join('\n')}`);
+        return;
+    }
+    const rows = await listLocalSessions(projectSlug);
+    writeOutput(flags, { projectSlug, sessions: rows }, renderLocalSessionList(rows, projectSlug));
+}
+/**
+ * Run an FTS5 search against the local SessionStore. Opens the SQLite
+ * file READ-ONLY via `SqliteSessionStore.openReadOnly` so the search
+ * never takes the lockfile and never inserts a stub session row. Works
+ * whether or not a live REPL holds the writer lock — SQLite supports
+ * concurrent readers + a single writer.
+ *
+ * FTS syntax errors surface as `FtsSyntaxError` (code `EFTS5_SYNTAX`);
+ * the dispatcher catches that + exits 2 with a clean message.
+ */
+async function searchLocalSessions(projectSlug, query) {
+    const view = await SqliteSessionStore.openReadOnly(resolveProjectStoreDir(projectSlug));
+    try {
+        return await view.search(query, { limit: 20 });
+    }
+    finally {
+        await view.close();
+    }
+}
 function registerArtifact(root, artifact) {
     // Hot path on every artifact-producing command. Avoid `rebuildIndex` here —
     // that walks the entire `.pugi/artifacts/` tree and re-parses `events.jsonl`
@@ -1468,6 +1763,19 @@ function registerArtifact(root, artifact) {
 }
 async function resume(args, flags, session) {
     const root = process.cwd();
+    // α6.4: `pugi resume [<local-session-id>]` and `pugi resume --list`
+    // operate on the LOCAL SessionStore under `~/.pugi/projects/<slug>/`
+    // before falling back to the legacy artifact-based resume. The
+    // local-session path requires no `.pugi/` directory in the cwd
+    // (the store lives under $HOME) so we run it BEFORE ensureInitialized.
+    const wantsList = args.includes('--list');
+    const arg0 = args[0] && !args[0].startsWith('--') ? args[0] : undefined;
+    const looksLikeSessionId = arg0 ? /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(arg0) : false;
+    const looksLikeSessionShortId = arg0 ? /^[0-9a-f]{8}-[0-9a-f]{4}$/i.test(arg0) : false;
+    if (wantsList || looksLikeSessionId || looksLikeSessionShortId) {
+        await resumeLocalSession({ flags, arg0, wantsList });
+        return;
+    }
     ensureInitialized(root);
     const target = args[0];
     const artifacts = listArtifactSets(root);
@@ -1510,6 +1818,152 @@ async function resume(args, flags, session) {
     recordToolResult(session, toolCallId, 'success', `Created resume ${relative(root, resumePath)}`);
     writeOutput(flags, { status: 'resumed', source: selected.path, resume: relative(root, resumePath) }, ['Pugi resume created', `Source: ${selected.path}`, `Resume: ${relative(root, resumePath)}`].join('\n'));
 }
+/**
+ * α6.4: resume a local SessionStore session. Two modes:
+ *
+ *   - `pugi resume --list`   → print the 10 most recent local sessions
+ *                              for the current project slug and exit.
+ *   - `pugi resume <id>`     → resolve the id (full or short prefix),
+ *                              check it exists, then mount the REPL
+ *                              with the localSessionId pre-bound so
+ *                              the bootstrap restores the transcript.
+ *
+ * The list path is non-interactive — operators pick by id and re-run
+ * with the chosen one. A future sprint can replace the print with an
+ * Ink select prompt; today's CLI surface is scripting-friendly.
+ */
+async function resumeLocalSession(input) {
+    const cwd = process.cwd();
+    const projectSlug = slugForCwd(cwd);
+    // Resolve the project directory WITHOUT opening the store — when we
+    // are only listing, taking the lock would block a live REPL.
+    const projectDir = resolveProjectStoreDir(projectSlug);
+    if (!existsSync(resolve(projectDir, 'session.db'))) {
+        writeOutput(input.flags, { status: 'no-sessions', projectSlug, projectDir }, `No stored sessions for project '${projectSlug}' yet.`);
+        return;
+    }
+    if (input.wantsList && !input.arg0) {
+        // Read-only list. Open + close without writing to keep it cheap.
+        const rows = await listLocalSessions(projectSlug);
+        writeOutput(input.flags, { projectSlug, sessions: rows }, renderLocalSessionList(rows, projectSlug));
+        return;
+    }
+    if (!input.arg0) {
+        writeOutput(input.flags, { status: 'error', error: 'usage: pugi resume <session-id> | pugi resume --list' }, 'Usage: pugi resume <session-id>  (run `pugi resume --list` to see ids).');
+        process.exitCode = 2;
+        return;
+    }
+    // Resolve the id. Accepts full uuid OR the 13-char prefix `pugi
+    // resume` prints (`xxxxxxxx-xxxx`). Match on prefix because the
+    // operator types from the human-friendly listing.
+    const candidate = input.arg0;
+    const target = await resolveLocalSessionId(projectSlug, candidate);
+    if (!target) {
+        writeOutput(input.flags, { status: 'not-found', id: candidate }, `No local session matches '${candidate}'. Run \`pugi resume --list\`.`);
+        process.exitCode = 1;
+        return;
+    }
+    // Hand off to the REPL bootstrap with the resolved id pre-bound so
+    // the SessionStore opens the existing log + the bootstrap calls
+    // restoreTranscript before the first user input.
+    const runtimeConfig = resolveRuntimeConfig();
+    if (!runtimeConfig) {
+        writeOutput(input.flags, { status: 'auth-missing', id: target.id }, 'No credentials configured. Run `pugi login` first, then `pugi resume <id>`.');
+        process.exitCode = ENGINE_EXIT_CODES.engine_unavailable;
+        return;
+    }
+    const { renderRepl } = await import('../tui/repl-render.js');
+    await renderRepl({
+        apiUrl: runtimeConfig.apiUrl,
+        apiKey: runtimeConfig.apiKey,
+        workspaceLabel: workspaceLabel(cwd),
+        cliVersion: PUGI_CLI_VERSION,
+        skipSplash: input.flags.noSplash,
+        hideToolStream: input.flags.noToolStream,
+        resumeLocalSessionId: target.id,
+    });
+}
+/**
+ * List the most recent local sessions for a project. Uses the
+ * READ-ONLY view (`SqliteSessionStore.openReadOnly`) so the call never
+ * takes the lockfile and never inserts a stub session row. Safe to
+ * call while a live REPL writes in the same project — SQLite supports
+ * concurrent readers + a single writer.
+ *
+ * Previously this opened the full SqliteSessionStore (lockfile +
+ * insert path), which polluted history with one empty session row per
+ * `pugi resume --list` or `pugi sessions --local` invocation. Fixed in
+ * the α6.4 review pass.
+ */
+async function listLocalSessions(projectSlug) {
+    const view = await SqliteSessionStore.openReadOnly(resolveProjectStoreDir(projectSlug));
+    try {
+        return await view.list({ limit: 10 });
+    }
+    finally {
+        await view.close();
+    }
+}
+/** Canonical UUID v7 surface form: 8-4-4-4-12 hex with '7' at the version nibble. */
+const FULL_UUID_V7_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/**
+ * Resolve a session id from a partial input. Accepts:
+ *   - full uuid v7 (canonical form xxxxxxxx-xxxx-7xxx-yxxx-xxxxxxxxxxxx)
+ *   - 13-char prefix `xxxxxxxx-xxxx` (the human-friendly form the
+ *     `/resume` list prints)
+ *   - short 8-char hex prefix `xxxxxxxx`
+ *
+ * For a FULL uuid we go direct-to-`get` so the lookup is not bounded
+ * by the most-recent-N listing (operators paste an id from days ago).
+ * For a prefix we fall back to scanning the first page; that matches
+ * the renderer's listing window.
+ *
+ * Returns the matching SessionRow or null when no row matches.
+ */
+async function resolveLocalSessionId(projectSlug, candidate) {
+    const normalised = candidate.trim().toLowerCase();
+    const view = await SqliteSessionStore.openReadOnly(resolveProjectStoreDir(projectSlug));
+    try {
+        if (FULL_UUID_V7_RE.test(normalised)) {
+            // Direct lookup — never bounded by the listing window.
+            const direct = await view.get(normalised);
+            if (direct)
+                return direct;
+            return null;
+        }
+        // Prefix path: scan the most-recent 10 rows so a typed short prefix
+        // resolves against what the renderer just printed.
+        const rows = await view.list({ limit: 10 });
+        const exact = rows.find((r) => r.id.toLowerCase() === normalised);
+        if (exact)
+            return exact;
+        const byPrefix = rows.find((r) => r.id.toLowerCase().startsWith(normalised));
+        return byPrefix ?? null;
+    }
+    finally {
+        await view.close();
+    }
+}
+function renderLocalSessionList(rows, projectSlug) {
+    if (rows.length === 0) {
+        return `No stored sessions for project '${projectSlug}' yet.`;
+    }
+    const lines = [
+        `Recent local sessions for '${projectSlug}' (${rows.length}):`,
+        '',
+    ];
+    for (let i = 0; i < rows.length; i += 1) {
+        const row = rows[i];
+        const title = (row.title ?? '(untitled)').slice(0, 64);
+        const idShort = row.id.slice(0, 13);
+        const branch = (row.branch ?? 'no-branch').padEnd(16);
+        const turns = `${row.turnCount}t`.padStart(4);
+        const events = `${row.eventCount}e`.padStart(5);
+        lines.push(`  ${idShort}  ${branch}  ${turns} ${events}  ${title}`);
+    }
+    lines.push('', 'Resume with: pugi resume <id>');
+    return lines.join('\n');
+}
 /**
  * Per-command exit code map. Surfaced to the operator so shell scripts
  * can branch on the engine outcome:
@@ -3083,13 +3537,18 @@ function ensurePugiGitIgnore(cwd, created, skipped) {
  * REPL header in sync with `pwd` lets the operator orient at a glance.
  * Empty / pathological cwd values (a worktree resolved to `/`) fall
  * back to `workspace` so the header never collapses.
+ *
+ * α6.14.2 wave 5: when the cwd has no project markers (no .git, no
+ * package.json, no PUGI.md), the resolver returns the explicit "not
+ * bound" warning instead of a stray parent-dir basename. CEO 2026-05-25
+ * dogfood surfaced the bug — launching `pugi` from `codeforge-io/`
+ * (the parent of all checkouts) leaked `codeforge-io` into the splash
+ * as if it were a real workspace. Mira/Pugi can NOT bind on that. The
+ * decision lives in `core/repl/workspace-context.ts` so the splash +
+ * status bar agree on a single label.
  */
 function workspaceLabel(cwd) {
-    const segments = cwd.split('/').filter((s) => s.length > 0);
-    const last = segments[segments.length - 1];
-    if (!last || last.length === 0)
-        return 'workspace';
-    return last;
+    return resolveWorkspaceLabel(cwd);
 }
 function ensureDir(path, created, skipped) {
     if (existsSync(path)) {
@@ -3311,22 +3770,41 @@ const PROTECTED_DIFF_EXCLUDES = [
     // Basename excludes apply at the repo root AND in any subdirectory
     // (e.g. `apps/foo/.env`) via the `**/<name>` glob form. Without the
     // `**/` prefix, git's literal pathspec syntax would only match the
-    // repo root and silently let a subdir `.env` ship in the diff —
+    // repo root and silently let a subdir `.env` ship in the diff -
     // common pitfall in pnpm/turbo monorepos.
+    //
+    // Keep this list in sync with `PROTECTED_PATHSPEC_EXCLUDES` in
+    // `apps/pugi-cli/src/core/consensus/diff-capture.ts`. Both surfaces
+    // (legacy triple-review + consensus fan-out) enforce the same egress
+    // contract; divergence creates an adversarial-PR leak window.
     ':(exclude,glob)**/.env',
     ':(exclude,glob)**/.env.*',
     ':(exclude,glob)**/.npmrc',
     ':(exclude,glob)**/.yarnrc',
     ':(exclude,glob)**/.pypirc',
     ':(exclude,glob)**/.gitconfig',
+    ':(exclude,glob)**/.netrc',
     ':(exclude,glob)**/id_rsa',
     ':(exclude,glob)**/id_ed25519',
+    ':(exclude,glob)**/id_ecdsa',
+    ':(exclude,glob)**/id_dsa',
     ':(exclude,glob)**/*.pem',
     ':(exclude,glob)**/*.key',
     ':(exclude,glob)**/*.crt',
+    ':(exclude,glob)**/*.cer',
+    ':(exclude,glob)**/*.der',
+    ':(exclude,glob)**/*.pfx',
     ':(exclude,glob)**/*.p12',
     ':(exclude,glob)**/*.dump',
     ':(exclude,glob)**/*.sql',
+    ':(exclude,glob)**/*.secret',
+    ':(exclude,glob)**/credentials',
+    ':(exclude,glob)**/credentials.json',
+    // Use `secrets/**` (not `secrets/*`) so nested credential paths
+    // recurse - with glob pathspec magic a single `*` does not cross path
+    // separators, so the non-recursive form would let `secrets/prod/x.key`
+    // ship in the diff payload.
+    ':(exclude,glob)**/secrets/**',
 ];
 function collectUntrackedSummary(root) {
     const raw = safeGit(root, ['ls-files', '--others', '--exclude-standard']);
@@ -3343,12 +3821,28 @@ function collectUntrackedSummary(root) {
     return { paths: visible.slice(0, 50), excludedProtected: excluded };
 }
 function isProtectedPath(path) {
+    // Keep in sync with PROTECTED_DIFF_EXCLUDES above. This filter
+    // applies to the untracked-files summary surfaced to operators; the
+    // pathspec excludes apply at the egress / diff capture layer.
     const base = path.split('/').pop() ?? path;
     if (base === '.env' || base.startsWith('.env.'))
         return true;
-    if (['.npmrc', '.yarnrc', '.pypirc', '.gitconfig', 'id_rsa', 'id_ed25519'].includes(base))
+    const exactNames = [
+        '.npmrc',
+        '.yarnrc',
+        '.pypirc',
+        '.gitconfig',
+        '.netrc',
+        'id_rsa',
+        'id_ed25519',
+        'id_ecdsa',
+        'id_dsa',
+        'credentials',
+        'credentials.json',
+    ];
+    if (exactNames.includes(base))
         return true;
-    return /\.(pem|key|crt|p12|dump|sql)$/i.test(base);
+    return /\.(pem|key|crt|cer|der|pfx|p12|dump|sql|secret)$/i.test(base);
 }
 function safeReadJson(path) {
     try {