@pugi/cli 0.1.0-alpha.9 → 0.1.0-beta.10

package/dist/runtime/cli.js

@@ -16,14 +16,30 @@ 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 { buildRuntimeConfig, loadRuntimeConfig, pollDeviceFlow, pugiHandoffBundleSchema, pugiSyncDryRunPlanSchema, pugiSyncPrivacyModeSchema, pugiSyncRequestSchema, pugiSyncUploadPlanSchema, pugiTripleReviewRequestSchema, startDeviceFlow, submitSync, submitTripleReview, } from '@pugi/sdk';
+import { signatureForPlanReview } from '../core/repl/ask.js';
+import { buildRuntimeConfig, fetchPersonaRoster, loadRuntimeConfig, openPugiSession, pollDeviceFlow, pugiHandoffBundleSchema, pugiSyncDryRunPlanSchema, pugiSyncPrivacyModeSchema, pugiSyncRequestSchema, pugiSyncUploadPlanSchema, pugiTripleReviewRequestSchema, startDeviceFlow, submitDelegate, submitSync, submitTripleReview, } from '@pugi/sdk';
 import { PUGI_TAGLINE } from '@pugi/personas';
+import { resolveRoster, renderRosterTable } from './commands/roster.js';
+import { runDelegateCommand } from './commands/delegate.js';
 import { clearApiKey, DEFAULT_API_URL, listStoredCredentials, maskApiKey, normalizeApiUrl, purgeAllCredentials, readCredentialsFile, resolveActiveCredential, storeApiKey, switchActiveAccount, } from '../core/credentials.js';
+import { runDeployCommand } from '../commands/deploy.js';
 import { runJobsCommand } from '../commands/jobs.js';
 import { runConfigCommand } from './commands/config.js';
 import { runPrivacyCommand } from './commands/privacy.js';
 import { runUndoCommand } from './commands/undo.js';
 import { runBudgetCommand } from './commands/budget.js';
+import { runSkillsCommand } from './commands/skills.js';
+import { installDefaultSkills } from '../core/skills/defaults.js';
+import { runAgentsCommand } from './commands/agents.js';
+import { runLspCommand } from './commands/lsp.js';
+import { runPatchCommand } from './commands/patch.js';
+import { runWorktreeCommand } from './commands/worktree.js';
+import { resolveWorkspaceLabel } from '../core/repl/workspace-context.js';
+import { runReviewConsensus } from './commands/review-consensus.js';
+import { DECOMPOSE_PROMPT_SUFFIX, parseDecompositionFromText, writeDecomposition, } from './plan-decompose.js';
+import { FtsSyntaxError, SqliteSessionStore, resolveProjectStoreDir } from '../core/repl/store/index.js';
+import { slugForCwd } from '../core/repl/history.js';
+import { dispatchEdit, } from '../core/edits/index.js';
 /**
  * CLI version shown by `pugi version` and embedded in `pugi doctor --json`.
  *
@@ -35,13 +51,17 @@ import { runBudgetCommand } from './commands/budget.js';
  * packages/pugi-sdk/package.json); the publish workflow validates the
  * three are in lockstep.
  */
-const PUGI_CLI_VERSION = '0.1.0-alpha.9';
+const PUGI_CLI_VERSION = "0.1.0-beta.10";
 const handlers = {
     accounts,
+    agents: dispatchAgents,
+    ask: dispatchAsk,
     build: runEngineTask('build_task'),
     budget: dispatchBudget,
     code: runEngineTask('code'),
     config: dispatchConfig,
+    delegate: dispatchDelegate,
+    deploy: dispatchDeploy,
     doctor,
     explain: runEngineTask('explain'),
     fix: runEngineTask('fix'),
@@ -52,17 +72,179 @@ const handlers = {
     jobs,
     login,
     logout,
+    lsp: dispatchLsp,
+    patch: dispatchPatch,
     plan: runEngineTask('plan'),
+    'plan-review': dispatchPlanReview,
     privacy: dispatchPrivacy,
     review,
     resume,
+    roster: dispatchRoster,
     sessions,
+    skills: dispatchSkills,
     sync,
     undo: dispatchUndo,
     version,
     web: dispatchWeb,
     whoami,
+    worktree: dispatchWorktree,
 };
+/**
+ * α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(),
@@ -76,6 +258,59 @@ async function dispatchPrivacy(args, flags, _session) {
         writeOutput: (payload, text) => writeOutput(flags, payload, text),
     });
 }
+/**
+ * `pugi roster` - α7.5 Phase 1.
+ *
+ * List the live Tier 1 personas with display name, role, and routing
+ * tag. Walks the remote /api/pugi/sessions/roster endpoint when a
+ * credential is available; falls back to the local @pugi/personas
+ * roster when offline so the operator can still see who is on the team.
+ */
+async function dispatchRoster(_args, flags, _session) {
+    const credential = resolveActiveCredential();
+    const config = credential
+        ? buildRuntimeConfig({ apiUrl: credential.apiUrl, apiKey: credential.apiKey })
+        : null;
+    const { rows, warning } = await resolveRoster(config);
+    const payload = {
+        ok: true,
+        personas: rows,
+        warning,
+    };
+    const text = (warning ? `# warning: ${warning}\n\n` : '') +
+        renderRosterTable(rows);
+    writeOutput(flags, payload, text);
+}
+/**
+ * `pugi delegate <slug> "<brief>"` - α7.5 Phase 1.
+ *
+ * Open a fresh REPL session and POST the brief to one Tier 1 persona,
+ * bypassing Mira's coordinator pass. Non-interactive: the CLI prints
+ * the dispatch id on success and exits; the operator (or a script) can
+ * subscribe to the session stream separately if they want the live
+ * lifecycle. Interactive operators use `/delegate` from inside the REPL
+ * instead so the dispatch lifecycle surfaces inline.
+ */
+async function dispatchDelegate(args, flags, _session) {
+    await runDelegateCommand(args, {
+        workspaceCwd: process.cwd(),
+        writeOutput: (payload, text) => writeOutput(flags, payload, text),
+        resolveConfig: () => {
+            const credential = resolveActiveCredential();
+            if (!credential)
+                return null;
+            return buildRuntimeConfig({ apiUrl: credential.apiUrl, apiKey: credential.apiKey });
+        },
+        fetchRoster: fetchPersonaRoster,
+        submitDelegate,
+        openSession: async (config, workspaceCwd) => {
+            const result = await openPugiSession(config, { workspaceCwd });
+            if (result.status === 'ok')
+                return { sessionId: result.response.sessionId };
+            return { error: `${result.status}: ${result.message}` };
+        },
+    });
+}
 async function dispatchUndo(args, flags, session) {
     await runUndoCommand(args, {
         workspaceRoot: process.cwd(),
@@ -89,6 +324,20 @@ async function dispatchBudget(args, flags, _session) {
         writeOutput: (payload, text) => writeOutput(flags, payload, text),
     });
 }
+async function dispatchSkills(args, flags, _session) {
+    await runSkillsCommand(args, {
+        workspaceRoot: process.cwd(),
+        json: flags.json,
+        writeOutput: (payload, text) => writeOutput(flags, payload, text),
+    });
+}
+async function dispatchAgents(args, flags, _session) {
+    await runAgentsCommand(args, {
+        workspaceRoot: process.cwd(),
+        json: flags.json,
+        writeOutput: (payload, text) => writeOutput(flags, payload, text),
+    });
+}
 /**
  * `pugi web <url>` — Sprint α6.15 Phase 1 quick-win subcommand.
  *
@@ -130,6 +379,59 @@ async function dispatchWeb(args, flags, _session) {
     }
     writeOutput(flags, result, `# ${result.title}\n# ${result.url}\n# fetched ${result.fetched_at}\n\n${result.content_md}`);
 }
+/**
+ * α7.7: `pugi lsp <op> <file> [args]` — direct LSP queries. Delegated
+ * to the standalone runner in `./commands/lsp.ts` so the giant cli.ts
+ * dispatch table stays narrow. The runner spawns + tears down the LSP
+ * server per invocation (no daemon yet — that ships in α7.7b).
+ */
+async function dispatchLsp(args, flags, _session) {
+    const result = await runLspCommand(args, { cwd: process.cwd(), json: flags.json });
+    console.log(result.text);
+    if (result.exitCode !== 0)
+        process.exitCode = result.exitCode;
+}
+/**
+ * α7.7: `pugi patch` — apply a unified-diff patch from stdin or a file.
+ * Routes through the same security gate as the Layer A/B/C applicators
+ * (see `src/core/edits/security-gate.ts`). Exit codes mirror the
+ * security taxonomy so CI loops can alert on hostile patches without
+ * confusing them with operator typos.
+ *
+ * R1 fix (2026-05-26, PR #413 r1): pass `flags.dryRun` through so the
+ * top-level parser's consumption of `--dry-run` does not silently
+ * disable dry-run mode on `pugi patch --dry-run < diff.patch`.
+ */
+async function dispatchPatch(args, flags, _session) {
+    const result = await runPatchCommand(args, {
+        cwd: process.cwd(),
+        json: flags.json,
+        dryRun: flags.dryRun,
+    });
+    console.log(result.text);
+    if (result.exitCode !== 0)
+        process.exitCode = result.exitCode;
+}
+/**
+ * α7.7: `pugi worktree <op>` — manual scratch worktree management.
+ * The `pugi build` and `pugi review --consensus` paths use the same
+ * primitives internally (`createWorktree` / `promoteWorktree`); this
+ * surface is the operator escape hatch for debug + experiment flows.
+ *
+ * R1 fix (2026-05-26, PR #413 r1): forward `flags.dryRun` so the
+ * top-level parser's consumption of `--dry-run` does not silently
+ * disable dry-run mode on `pugi worktree promote --dry-run <path>`.
+ */
+async function dispatchWorktree(args, flags, _session) {
+    const result = await runWorktreeCommand(args, {
+        cwd: process.cwd(),
+        json: flags.json,
+        dryRun: flags.dryRun,
+    });
+    console.log(result.text);
+    if (result.exitCode !== 0)
+        process.exitCode = result.exitCode;
+}
 export async function runCli(argv) {
     const { command, args, flags, isBareInvocation } = parseArgs(argv);
     // Bare `pugi` on a TTY enters the REPL-by-default agentic session
@@ -170,6 +472,7 @@ export async function runCli(argv) {
                 cliVersion: PUGI_CLI_VERSION,
                 updateBanner,
                 skipSplash: flags.noSplash,
+                hideToolStream: flags.noToolStream,
             });
             return;
         }
@@ -201,11 +504,26 @@ 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 to 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,
+        noDefaults: process.env.PUGI_INIT_NO_DEFAULTS === '1',
+        decompose: false,
     };
     const args = [];
     // Sprint 2E: `pugi --version` / `-v` are universal install-test conventions
@@ -232,9 +550,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 so the existing
+            // performRemoteTripleReview path is never accidentally entered.
+            flags.consensus = true;
+        }
         else if (arg === '--offline') {
             flags.offline = true;
         }
@@ -250,6 +575,25 @@ 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 for α6.12 dev/testing — backend tool events not live yet,
+            // pane shows synthesized heuristic OR empty placeholder
+            flags.noToolStream = false;
+        }
+        else if (arg === '--no-defaults') {
+            // Init-only flag: skip the bundled default-skills install. Parsed
+            // at the global level for consistency with --no-splash / --no-tool-stream.
+            flags.noDefaults = true;
+        }
+        else if (arg === '--decompose') {
+            // α6.8 EXTEND PR1: plan-only flag. Other engine commands ignore
+            // it. Parsed globally for symmetry with the rest of the flag
+            // grammar; `runEngineTask('plan')` is the single consumer.
+            flags.decompose = true;
+        }
         else if (arg.startsWith('--privacy=')) {
             flags.privacy = parsePrivacyMode(arg.slice('--privacy='.length));
         }
@@ -265,8 +609,20 @@ function parseArgs(argv) {
         }
     }
     const isBareInvocation = args.length === 0;
+    const command = args.shift() ?? 'help';
+    // Sprint α6.X CEO dogfood 2026-05-26 (P0 hot-fix): trailing `--help`
+    // / `-h` on ANY sub-command must route to the help printer rather
+    // than dispatching the real engine. Before this guard `pugi build
+    // --help` burned 86k tokens running the actual build loop because
+    // the dispatcher saw `--help` as an opaque arg and forwarded it
+    // through to the engine. Re-routing here means `pugi <cmd> --help`
+    // becomes `pugi help <cmd>` deterministically across the entire
+    // command tree.
+    if (args.includes('--help') || args.includes('-h')) {
+        return { command: 'help', args: [command], flags, isBareInvocation: false };
+    }
     return {
-        command: args.shift() ?? 'help',
+        command,
         args,
         flags,
         isBareInvocation,
@@ -299,6 +655,39 @@ 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.',
+        '  pugi skills install <source> [--yes]        Fetch + trust + install a skill.',
+        '  pugi skills info <name>                     Metadata + body preview.',
+        '  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.',
+        '',
+        'Persona dispatch (α7.5):',
+        '  pugi roster                              List the live Tier 1 personas + roles.',
+        '  pugi delegate <slug> "<brief>"           Dispatch a brief to one specialist.',
+        '',
+        'Plan decomposition (α6.8):',
+        '  pugi plan --decompose <idea>   Split a high-level idea into 3-7 components.',
+        '                                 Writes .pugi/plan/<session-id>/splits/NN-<name>/spec.md',
+        '                                 plus manifest.md with the dependency DAG.',
+        '',
+        'Deploy:',
+        '  pugi deploy --target vercel <vercelProject> --project <id>',
+        '                          Trigger a Vercel deployment from the bound Git source.',
+        '                          Optional: --target-env production|preview, --ref <ref>,',
+        '                          --integration <id>.',
+        '  pugi deploy --target render <renderService> --project <id>',
+        '                          Trigger a Render deployment (Sprint 2 — stub today).',
+        '  pugi deploy --status <id>            Vendor-agnostic status snapshot.',
+        '  pugi deploy --logs <id> [--tail]     Build-log tail. --tail polls until terminal.',
         '',
         'Sync safety:',
         '  pugi sync --dry-run --privacy metadata',
@@ -310,6 +699,10 @@ 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.',
+        '  --no-defaults           Skip bundled default-skills install on',
+        '                          `pugi init`. Pairs with PUGI_INIT_NO_DEFAULTS=1.',
         '',
         PUGI_TAGLINE,
         'Execution defaults to local. Use --remote or --web to create a handoff bundle.',
@@ -379,6 +772,7 @@ async function init(_args, flags, _session) {
     ensureDir(pugiDir, created, skipped);
     ensureDir(resolve(pugiDir, 'artifacts'), created, skipped);
     ensureDir(resolve(pugiDir, 'sessions'), created, skipped);
+    ensureDir(resolve(pugiDir, 'skills'), created, skipped);
     writeJsonIfMissing(resolve(pugiDir, 'settings.json'), {
         schema: 1,
         workflow: {
@@ -448,17 +842,50 @@ async function init(_args, flags, _session) {
     // Ensure `.pugi/` is git-ignored so users do not accidentally commit
     // local audit logs, artifacts, or triple-review request payloads.
     ensurePugiGitIgnore(cwd, created, skipped);
+    // Bundled default skills (brand-voice, endpoint-probe, readme-sync).
+    // Skipped when --no-defaults is passed OR when PUGI_INIT_NO_DEFAULTS=1.
+    // Idempotent: a skill whose target directory already exists is left
+    // alone so re-running `pugi init` after the operator customised one of
+    // the defaults does not clobber their edits.
+    let defaultSkills = [];
+    if (!flags.noDefaults) {
+        try {
+            defaultSkills = await installDefaultSkills({
+                workspaceRoot: cwd,
+                log: (line) => process.stderr.write(line),
+            });
+        }
+        catch (error) {
+            // Default-skills install is a convenience layer. A failure here
+            // (bad sha256 hashing, permission error on .pugi/skills/) must not
+            // leave `pugi init` in a half-state where settings.json exists but
+            // the operator sees an unexplained crash. Log the error to stderr
+            // and continue — the operator can still install skills manually.
+            const message = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`[pugi init] default-skills install failed: ${message}\n`);
+        }
+    }
     const payload = {
         status: 'initialized',
         root: cwd,
         created,
         skipped,
+        defaultSkills,
     };
+    const defaultSkillLines = flags.noDefaults
+        ? ['Default skills: skipped (--no-defaults)']
+        : defaultSkills.length === 0
+            ? ['Default skills: none installed']
+            : [
+                'Default skills:',
+                ...defaultSkills.map((entry) => `  ${entry.name.padEnd(18)} ${entry.status}`),
+            ];
     writeOutput(flags, payload, [
         'Pugi initialized',
         `Root: ${cwd}`,
         created.length ? `Created:\n${created.map((path) => `  ${path}`).join('\n')}` : 'Created: none',
         skipped.length ? `Already present:\n${skipped.map((path) => `  ${path}`).join('\n')}` : 'Already present: none',
+        ...defaultSkillLines,
     ].join('\n'));
 }
 async function idea(args, flags, session) {
@@ -774,6 +1201,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;
@@ -1337,6 +1784,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');
@@ -1411,6 +1866,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`
@@ -1443,6 +1964,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);
@@ -1485,6 +2019,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:
@@ -1550,6 +2230,26 @@ function runEngineTask(kind) {
         const config = credential
             ? buildRuntimeConfig({ apiUrl: credential.apiUrl, apiKey: credential.apiKey })
             : envConfig;
+        // α6.8 EXTEND PR1 v2: `--decompose` gating runs BEFORE the offline
+        // fallback. Two reasons:
+        //   1. The flag is plan-only — surfacing the rejection for
+        //      `pugi build --decompose` before we drop into `offlineBuild`
+        //      means the operator gets a deterministic error instead of a
+        //      silent no-op stub.
+        //   2. The decompose post-processor depends on the engine's final
+        //      text. The offline plan stub does not invoke the engine, so
+        //      `pugi plan --decompose --offline` would silently skip the
+        //      decomposition step. Refusing the combination up front is the
+        //      cheapest way to keep the contract honest.
+        if (flags.decompose && kind !== 'plan') {
+            throw new Error(`--decompose is only valid for \`pugi plan\` (got \`pugi ${label}\`)`);
+        }
+        if (flags.decompose && flags.offline) {
+            throw new Error('--decompose requires the engine — drop --offline (decomposition needs the model to emit a fenced JSON block)');
+        }
+        if (flags.decompose && !config) {
+            throw new Error('--decompose requires the engine — run `pugi login` or set PUGI_API_KEY (decomposition needs the model to emit a fenced JSON block)');
+        }
         // Offline fallback: preserves the local-first invariant. `plan` /
         // `build` / `explain` drop back to their pre-Sprint-2 stub
         // behaviour so an operator without an API key (or with --offline)
@@ -1602,6 +2302,17 @@ function runEngineTask(kind) {
                 throw new Error(`pugi ${label} requires a prompt`);
             }
         }
+        // α6.8 EXTEND PR1: when `--decompose` is set, augment the user
+        // prompt with the decomposition-request suffix BEFORE the adapter
+        // run. The system prompt for `plan` already constrains the model
+        // to read-only tools + a plan deliverable; the suffix layers the
+        // JSON-emission contract on top so the post-run parser can lift
+        // the structured payload out of the final answer. The plan-only /
+        // engine-required gates fired before the offline fallback above,
+        // so by here we know we are on the engine path with a plan task.
+        if (flags.decompose && kind === 'plan') {
+            prompt = `${prompt}\n${DECOMPOSE_PROMPT_SUFFIX}`;
+        }
         // Narrow `config` for the type checker — the offline branches above
         // return whenever `config` is null, so by this point it must be set.
         if (!config) {
@@ -1659,6 +2370,45 @@ function runEngineTask(kind) {
                 risks: ['adapter terminated without emitting a result event'],
             };
         }
+        // α6.6 diff escalation — Layer A/B/C dispatcher.
+        //
+        // Some models emit file edits as inline SEARCH/REPLACE markers in
+        // the final response rather than through tool calls (especially
+        // Gemini and o1 family, which under-use tool schemas in long
+        // reasoning chains). We run the dispatcher against the model's
+        // final text so those markers still land on disk. Tool-call edits
+        // (Layer-A equivalent already handled by `edit`/`write` tools) are
+        // unaffected — the dispatcher only fires on prose blocks that
+        // happen to contain markers.
+        //
+        // Scope: code / fix / build / explain only. `plan` is read-only
+        // (the engine refuses write tools), so even a stray marker in plan
+        // output gets ignored to honour the plan-mode contract.
+        //
+        // Dry-run + read-only short-circuits: when the flags forbid writes
+        // we dispatch with `dryRun: true` so the operator still sees what
+        // WOULD have been written, but nothing touches disk.
+        let dispatchResults = [];
+        if (kind === 'code' || kind === 'fix' || kind === 'build_task') {
+            dispatchResults = await runMarkerDispatch({
+                root,
+                result: {
+                    status: result.status,
+                    summary: result.summary,
+                    eventRefs: result.eventRefs,
+                },
+                dryRun: flags.dryRun,
+            });
+            // Merge dispatcher-touched files into `result.filesChanged` so the
+            // operator-facing summary lists them alongside tool-driven edits.
+            for (const dr of dispatchResults) {
+                if (dr.ok && dr.absPath) {
+                    const rel = relative(root, dr.absPath);
+                    if (!result.filesChanged.includes(rel))
+                        result.filesChanged.push(rel);
+                }
+            }
+        }
         // For `plan` we always write a plan.md artifact, regardless of
         // outcome. A blocked plan (budget exhausted, tool refusal) still
         // produces a reviewable artifact — the reason is recorded inline.
@@ -1672,6 +2422,41 @@ function runEngineTask(kind) {
                 statusEvents,
             });
         }
+        // α6.8 EXTEND PR1: `--decompose` post-processing. We only attempt
+        // the parse on a `done` plan (a blocked/failed plan is already
+        // captured in plan.md with its reason; no JSON to extract). The
+        // model's final answer arrives via `result.summary` — on success
+        // the adapter prefix is empty so it is the raw final text. We
+        // strip any leading/trailing whitespace then run the parser
+        // against the contents. On parse failure we surface a non-fatal
+        // structured error in the payload — the operator still gets the
+        // plan.md artifact and can re-run.
+        //
+        // TODO(α7.x): `result.summary` is currently a string contract that
+        // doubles as both "human-readable headline" and "raw final model
+        // text". Split into `{ summary, finalText }` on the adapter so the
+        // parser does not have to assume the prefix is empty. Tracked in
+        // PR #423 v2 retro (P2.6, Claude review).
+        let decomposeArtifact = null;
+        let decomposeError = null;
+        if (flags.decompose && kind === 'plan' && result.status === 'done') {
+            const parsed = parseDecompositionFromText(result.summary);
+            if (parsed.ok) {
+                decomposeArtifact = writeDecomposition({
+                    root,
+                    sessionId: session.id,
+                    // Persist the OPERATOR's original prompt, not the prompt+suffix
+                    // we sent to the engine. The suffix is plumbing; the manifest
+                    // header reads naturally only with the operator text.
+                    prompt: args.join(' ').trim() || prompt,
+                    decomposition: parsed.decomposition,
+                    rationale: parsed.rationale,
+                });
+            }
+            else {
+                decomposeError = { reason: parsed.reason, detail: parsed.detail };
+            }
+        }
         // Pull the headline metrics out of `eventRefs` so the summary and
         // JSON envelope match without re-parsing strings in two places.
         const metrics = parseEventRefs(result.eventRefs);
@@ -1721,6 +2506,30 @@ function runEngineTask(kind) {
             sessionEventsMirror: metrics.mirror,
             risks: result.risks,
             plan: planArtifact ? { path: planArtifact.relPath } : undefined,
+            // α6.6 — per-edit dispatcher trace. Empty array when no inline
+            // markers were detected in the model's final response.
+            diffEdits: dispatchResults.map((dr) => ({
+                layer: dr.layer,
+                file: dr.file,
+                ok: dr.ok,
+                bytesWritten: dr.bytesWritten,
+                reason: dr.reason,
+                detail: dr.detail,
+            })),
+            // α6.8 EXTEND PR1: decompose artifacts (only present when
+            // `--decompose` was passed AND the model emitted a parseable
+            // JSON block). The `error` shape lands when the model returned
+            // unparseable output; the operator can re-run with a tighter
+            // prompt without losing the plain plan.md artifact.
+            decompose: decomposeArtifact !== null
+                ? {
+                    manifest: relative(root, decomposeArtifact.manifestPath),
+                    planDir: relative(root, decomposeArtifact.planDir),
+                    splits: decomposeArtifact.splitPaths,
+                }
+                : decomposeError !== null
+                    ? { error: decomposeError }
+                    : undefined,
             // The full event stream is useful for cabinet UI replay. We surface
             // it in JSON mode only — text mode operators want the summary, not
             // 30 turn-level lines.
@@ -1730,6 +2539,13 @@ function runEngineTask(kind) {
         if (kind === 'plan' && planArtifact) {
             textLines.push(`Pugi plan written to ${planArtifact.relPath}`);
         }
+        if (decomposeArtifact !== null) {
+            textLines.push(`Decomposition: ${decomposeArtifact.splitPaths.length} component spec${decomposeArtifact.splitPaths.length === 1 ? '' : 's'} under ${relative(root, decomposeArtifact.planDir)}`);
+            textLines.push(`Manifest: ${relative(root, decomposeArtifact.manifestPath)}`);
+        }
+        else if (decomposeError !== null) {
+            textLines.push(`Decomposition: skipped (${decomposeError.reason}) — plan.md still written`);
+        }
         textLines.push(`Pugi ${label}: ${result.status}`);
         textLines.push(`Summary: ${result.summary}`);
         if (result.filesChanged.length > 0) {
@@ -1741,6 +2557,19 @@ function runEngineTask(kind) {
             textLines.push('Files modified: none');
         }
         textLines.push(`Tool calls: ${metrics.toolCalls} · Turns: ${metrics.turns} · Tokens: ${metrics.tokens}`);
+        if (dispatchResults.length > 0) {
+            const okCount = dispatchResults.filter((d) => d.ok).length;
+            const failCount = dispatchResults.length - okCount;
+            textLines.push(`Diff dispatch: ${okCount} applied, ${failCount} rejected (${dispatchResults.length} marker block${dispatchResults.length === 1 ? '' : 's'})`);
+            for (const dr of dispatchResults) {
+                if (dr.ok) {
+                    textLines.push(`  + ${dr.layer} ${dr.file} (${dr.bytesWritten} bytes)`);
+                }
+                else {
+                    textLines.push(`  ! ${dr.layer} ${dr.file}: ${dr.reason ?? 'failure'} — ${dr.detail ?? ''}`);
+                }
+            }
+        }
         if (result.risks.length > 0) {
             textLines.push(`Risks: ${result.risks.join('; ')}`);
         }
@@ -1750,6 +2579,96 @@ function runEngineTask(kind) {
         writeOutput(flags, payload, textLines.join('\n'));
     };
 }
+// Exported for the α6.6.1 triple-review remediation spec
+// (`apps/pugi-cli/test/edits-dispatcher-gate.spec.ts`). The runtime
+// surface is not part of the public CLI API; this is a test seam.
+export async function runMarkerDispatch(input) {
+    const { root, result, dryRun } = input;
+    const dispatch = input.dispatchFn ?? dispatchEdit;
+    // Triple-review 2026-05-25 P2 (Codex): gate the dispatcher on the
+    // engine's terminal status. A `blocked` (budget_exhausted, plan-mode
+    // refusal) or `failed` result may still carry markers in the
+    // partial `summary` text — applying them would mutate files the
+    // CLI then exits non-zero on, leaving the workspace in an
+    // unexpected state with no operator signal that "blocked but with
+    // side effects" happened. Only `done` is allowed to write.
+    if (result.status !== 'done')
+        return [];
+    // Strip the engine's status prefixes (`[budget_exhausted] `, etc.)
+    // from the body before scanning. The prefixes start with `[`; the
+    // dispatcher tolerates leading prose but the cleaner the input the
+    // less chance of accidental marker matches.
+    const body = result.summary;
+    if (!hasAnyMarkerSignal(body))
+        return [];
+    const modelTag = extractModelTag(result.eventRefs);
+    try {
+        return await dispatch(body, {
+            modelTag,
+            cwd: root,
+            dryRun,
+        });
+    }
+    catch (error) {
+        // Triple-review 2026-05-25 P2 (Claude): the previous `catch {}`
+        // swallowed parser/applicator crashes silently — the operator
+        // saw a clean "0 applied" rather than the actual stack trace,
+        // and the bug only surfaced when someone manually `pugi resume`-d
+        // a session and noticed the missing edits. Surface the failure
+        // both to stderr (so live operators see it) and as a synthetic
+        // DispatchResult (so JSON consumers and the audit log record it).
+        //
+        // R2 triple-review 2026-05-25 P2 (Claude): the earlier remediation
+        // returned `detail: message` — i.e. the raw `Error.message`. That
+        // string is constructed by whatever code path threw (parser,
+        // applicator, fs layer, etc.) and may contain absolute paths,
+        // secret fragments echoed in `oldString` context, or other
+        // stack-bearing internals. The audit log and any JSON consumer
+        // that surfaces `detail` to the operator (or worse, to a remote
+        // monitoring pipe) would leak them. Stack already goes to stderr
+        // for live diagnosis; the returned result must carry a safe,
+        // static string so consumers can still detect "dispatcher
+        // crashed" without re-rendering the underlying exception.
+        const message = error instanceof Error ? error.message : String(error);
+        const stack = error instanceof Error && error.stack ? error.stack : message;
+        process.stderr.write(`pugi diff-dispatch: internal crash in dispatchEdit (${message}); see stack:\n${stack}\n`);
+        return [
+            {
+                layer: 'layer-a',
+                file: '',
+                ok: false,
+                bytesWritten: 0,
+                reason: 'dispatcher_crash',
+                detail: 'dispatcher crashed - see stderr for stack trace',
+            },
+        ];
+    }
+}
+/**
+ * Quick pre-filter: does the body contain ANY of the marker
+ * signatures the dispatcher knows about? Saves a full parse on every
+ * model response (most responses are pure prose and would otherwise
+ * round-trip through the parser pointlessly).
+ */
+function hasAnyMarkerSignal(body) {
+    return (body.includes('+++ NEW') ||
+        body.includes('<<<<<<< SEARCH') ||
+        body.includes('@@@ REWRITE') ||
+        body.includes('@@@ AST') ||
+        /^--- a\//m.test(body));
+}
+/**
+ * Extract `model=<tag>` from eventRefs if the adapter emitted it.
+ * Returns undefined when missing; dispatchEdit then auto-detects from
+ * the payload itself.
+ */
+function extractModelTag(refs) {
+    for (const ref of refs) {
+        if (ref.startsWith('model='))
+            return ref.slice('model='.length);
+    }
+    return undefined;
+}
 /**
  * Extract `key=value` metrics from `EngineResult.eventRefs`. The adapter
  * already emits the canonical strings (`tool_calls=N`, `turns=N`,
@@ -3023,6 +3942,33 @@ async function jobs(args, flags, session) {
         process.exitCode = exitCode;
     }
 }
+/**
+ * `pugi deploy` — Wave 3 P2 (Task #34, 2026-05-25). Thin shim into
+ * `src/commands/deploy.ts`. The shim adapts the global `CliFlags` shape
+ * to the deploy-specific flag set + exposes the credential store via
+ * `resolveRuntimeConfig` so the deploy module stays decoupled from the
+ * CLI's auth bootstrap.
+ */
+async function dispatchDeploy(args, flags, _session) {
+    // Triple-review #391 P2: the global `parseArgs` in this file consumes
+    // `--json` before the per-command args reach us, so `runDeployCommand`'s
+    // internal parser never sees it and the JSON envelope path is silently
+    // skipped. Re-inject the flag so downstream parsing surfaces the JSON
+    // output contract the operator asked for. Idempotent: if the user wrote
+    // `pugi deploy --json ...` the global parser stripped it; if they wrote
+    // `pugi --json deploy ...` ditto. Either way the global flag is the
+    // single source of truth and we forward it verbatim.
+    const forwardedArgs = flags.json && !args.includes('--json') ? [...args, '--json'] : args;
+    const exitCode = await runDeployCommand(forwardedArgs, {
+        write: (text) => process.stdout.write(text),
+        writeError: (text) => process.stderr.write(text.endsWith('\n') ? text : `${text}\n`),
+    }, {
+        resolveConfig: () => resolveRuntimeConfig(),
+    });
+    if (exitCode !== 0) {
+        process.exitCode = exitCode;
+    }
+}
 function notImplemented(command) {
     return async (_args, flags) => {
         const payload = {
@@ -3058,13 +4004,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)) {
@@ -3286,22 +4237,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']);
@@ -3318,12 +4288,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 {