peaks-loop 3.1.1 → 4.0.0-beta

package/dist/src/cli/commands/session-migrate-skill-name.js

@@ -0,0 +1,41 @@
+import { resolve } from 'node:path';
+import { migrateSkillName } from '../../services/migrate-skill-name/migrate.js';
+import { getErrorMessage } from '../cli-helpers.js';
+export function registerSessionMigrateSkillNameCommand(session) {
+    session
+        .command('migrate-skill-name')
+        .description('Rewrite skill-name strings under .peaks/_runtime/** (idempotent, dry-run by default). ' +
+        'Use --apply to write through. Skips .peaks/memory/** and .peaks/skills/.system/bees/.')
+        .requiredOption('--from <old>', 'old skill name (e.g. peaks-code)')
+        .requiredOption('--to <new>', 'new skill name (e.g. peaks-code)')
+        .option('--apply', 'write through (default is dry-run)', false)
+        .option('--project <path>', 'project root (defaults to current directory)', '.')
+        .option('--json', 'emit a JSON envelope to stdout', false)
+        .action((opts) => {
+        try {
+            const projectRoot = resolve(process.cwd(), opts.project ?? '.');
+            const result = migrateSkillName({
+                projectRoot,
+                from: opts.from,
+                to: opts.to,
+                apply: opts.apply === true,
+            });
+            if (opts.json === true) {
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                process.stdout.write(`Scanned: ${result.scannedFiles}\n` +
+                    `Modified: ${result.modifiedFiles}\n` +
+                    `Key-value replacements: ${result.keyValueReplacements}\n` +
+                    `String replacements: ${result.stringReplacements}\n` +
+                    `Skipped: ${result.skipped.length} path(s)\n` +
+                    `Errors: ${result.errors.length}\n`);
+            }
+            process.exitCode = result.ok ? 0 : 1;
+        }
+        catch (error) {
+            process.stderr.write(getErrorMessage(error) + '\n');
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/cli/commands/skill-visibility.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from 'commander';
+export interface SkillVisibility {
+    name: string;
+    userInvocable: boolean;
+    visibility: 'public' | 'internal';
+}
+export declare function listSkillsVisibility(repoRoot: string): SkillVisibility[];
+export declare function registerSkillVisibilityCommand(program: Command, repoRoot: string): void;

package/dist/src/cli/commands/skill-visibility.js

@@ -0,0 +1,63 @@
+/**
+ * `peaks skill:visibility` — Skill visibility CLI surface.
+ *
+ * Slice: Task 1 of peaks-code → peaks-code rename plan.
+ *
+ * Reads `.claude-plugin/marketplace.json`, resolves each skill entry's
+ * visibility (public / internal) from the optional `userInvocable`
+ * field, and emits either:
+ *   - a TSV list (`name \t visibility`) for human use
+ *   - a JSON envelope `{ ok, skills }` for programmatic use
+ *
+ * Schema contract:
+ *   - internal: `userInvocable: false`
+ *   - public (default): `userInvocable` omitted OR `true`
+ *
+ * The skill list lives at `plugins[0].skills` in marketplace.json;
+ * entries are objects of shape `{ name, path?, userInvocable?, description? }`.
+ * Older string-array shapes are auto-coerced (each string is treated as
+ * a public skill whose name is the basename of the path).
+ */
+import { readFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
+export function listSkillsVisibility(repoRoot) {
+    const marketplacePath = join(repoRoot, '.claude-plugin', 'marketplace.json');
+    const raw = readFileSync(marketplacePath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    const skills = parsed.plugins?.[0]?.skills ?? [];
+    return skills.map((entry) => {
+        if (typeof entry === 'string') {
+            return {
+                name: basename(entry),
+                userInvocable: true,
+                visibility: 'public',
+            };
+        }
+        const userInvocable = entry.userInvocable !== false;
+        return {
+            name: entry.name ?? '',
+            userInvocable,
+            visibility: userInvocable ? 'public' : 'internal',
+        };
+    });
+}
+export function registerSkillVisibilityCommand(program, repoRoot) {
+    const cmd = program
+        .command('skill:visibility')
+        .description('List skill visibility (public vs internal)')
+        .option('--list', 'List all skills')
+        .option('--name <name>', 'Query single skill')
+        .option('--json', 'JSON output');
+    cmd.action((opts) => {
+        const all = listSkillsVisibility(repoRoot);
+        const filtered = opts.name ? all.filter((s) => s.name === opts.name) : all;
+        if (opts.json) {
+            process.stdout.write(JSON.stringify({ ok: true, skills: filtered }, null, 2) + '\n');
+        }
+        else {
+            for (const s of filtered) {
+                process.stdout.write(`${s.name}\t${s.visibility}\n`);
+            }
+        }
+    });
+}

package/dist/src/cli/commands/slice-commands.js

@@ -26,8 +26,8 @@ export function registerSliceCommands(program, io) {
         .option('--project <path>', 'target project root', '.')
         .option('--rid <rid>', 'request id; defaults to the active current-change binding')
         .option('--refresh-fanout', 're-run the 3-way review fan-out (peaks-rd) even if the review files already exist', false)
-        .option('--run-tests', 'opt in to the FULL test suite at the boundary (default is the changed-only suite via `vitest run --changed`); use the peaks-solo-test skill to run the full suite standalone', false)
-        .option('--skip-tests', 'skip the unit-test stage entirely (e.g. docs-only slices); use the peaks-solo-test skill to run the full suite manually if you want a separate check', false)
+        .option('--run-tests', 'opt in to the FULL test suite at the boundary (default is the changed-only suite via `vitest run --changed`); use the peaks-test skill to run the full suite standalone', false)
+        .option('--skip-tests', 'skip the unit-test stage entirely (e.g. docs-only slices); use the peaks-test skill to run the full suite manually if you want a separate check', false)
         .option('--allow-pre-existing-failures', 'opt-in: if the unit-test stage fails, report it as `skipped` with a reason naming the failure count (useful when the repo has unrelated pre-existing failures; the long-term fix is to .skip or coverage.exclude those tests). Only meaningful with --run-tests or the default changed-only mode.', false)).action(async (options) => {
         try {
             const projectRoot = resolveCanonicalProjectRoot(options.project);

package/dist/src/cli/commands/solo-commands.d.ts

@@ -1,7 +1,7 @@
 /**
- * Slice 2 — `peaks solo [--fast] <change-id>` (peaks-solo fast mode).
+ * Slice 2 — `peaks solo [--fast] <change-id>` (peaks-code fast mode).
  *
- * The `peaks-solo` SKILL orchestrates an LLM-side workflow:
+ * The `peaks-code` SKILL orchestrates an LLM-side workflow:
  *   load-memory -> standards-preflight -> rd-cycle -> qa-cycle -> emit-txt
  *
  * The CLI surface here is intentionally narrow: it builds a SoloPlan and

package/dist/src/cli/commands/solo-commands.js

@@ -1,7 +1,7 @@
 /**
- * Slice 2 — `peaks solo [--fast] <change-id>` (peaks-solo fast mode).
+ * Slice 2 — `peaks solo [--fast] <change-id>` (peaks-code fast mode).
  *
- * The `peaks-solo` SKILL orchestrates an LLM-side workflow:
+ * The `peaks-code` SKILL orchestrates an LLM-side workflow:
  *   load-memory -> standards-preflight -> rd-cycle -> qa-cycle -> emit-txt
  *
  * The CLI surface here is intentionally narrow: it builds a SoloPlan and
@@ -26,6 +26,8 @@ import { getSkillPresence, checkStalePresence } from '../../services/skills/skil
 import { detectPostCompactResume, formatPostCompactResumeLogLine } from '../../services/solo/post-compact-detector.js';
 import { runAutoCompact } from '../../services/solo/auto-compact-orchestrator.js';
 import { readJobShapeDecision, writeJobShapeDecision, JobShapeDecisionError, JOB_SHAPE_NOT_DECIDED, JOB_SHAPE_ALREADY_DECIDED } from '../../services/solo/job-shape-decision.js';
+import { evaluateStep08, STEP_08_BACKUP_REGEX } from '../../services/solo/step-08-gate.js';
+import { evaluateEmitHandoff, JOB_NOT_INITIALIZED, JOB_REMAINING_BLOCKED } from '../../services/solo/emit-handoff.js';
 const STEP_ORDER = [
     'load-memory',
     'standards-preflight',
@@ -107,7 +109,7 @@ export async function runSoloFast(opts) {
 export function registerSoloCommands(program, io) {
     const solo = program
         .command('solo')
-        .description('peaks-solo LLM-side workflow planner (slice 2 fast mode)');
+        .description('peaks-code LLM-side workflow planner (slice 2 fast mode)');
     solo
         .command('plan')
         .description('Build and print a SoloPlan without executing it')
@@ -236,7 +238,7 @@ export function registerSoloCommands(program, io) {
                     }
                 }, [], [
                     `Recorded outer session id "${stalePresence.recordedOuterSessionId ?? '?'}" does not match current outer session id "${stalePresence.currentOuterSessionId ?? '?'}".`,
-                    `peaks-solo Step 1 must AskUserQuestion to confirm the mode for THIS session (slice 002 AC-2).`
+                    `peaks-code Step 1 must AskUserQuestion to confirm the mode for THIS session (slice 002 AC-2).`
                 ]), opts.json);
                 return;
             }
@@ -304,14 +306,14 @@ export function registerSoloCommands(program, io) {
         .command('post-compact-detect')
         .description('v2.11.0 D7: detect whether the current invocation is a same-day post-compact resume. ' +
         'Auto-resumes (no AskUserQuestion) when the most-recent checkpoint is from today, has a mode field, ' +
-        'and the active skill is peaks-solo. Falls through to the normal Step 0.7 flow otherwise.')
+        'and the active skill is peaks-code. Falls through to the normal Step 0.7 flow otherwise.')
         .requiredOption('--project <path>', 'target project root')
         .option('--session-id <sid>', 'override session id (default: read from active presence)')
         .option('--active-skill <skill>', 'override active skill (test seam; default: read from presence)')).action(async (opts) => {
         try {
             const sessionId = opts.sessionId ?? readActiveSid(opts.project);
             if (sessionId === null) {
-                printResult(io, fail('solo.post-compact-detect', 'NO_ACTIVE_SESSION', 'no active session id; pass --session-id or set presence via `peaks skill presence:set peaks-solo`', null, ['Re-run with --session-id <sid>']), opts.json);
+                printResult(io, fail('solo.post-compact-detect', 'NO_ACTIVE_SESSION', 'no active session id; pass --session-id or set presence via `peaks skill presence:set peaks-code`', null, ['Re-run with --session-id <sid>']), opts.json);
                 process.exitCode = 1;
                 return;
             }
@@ -383,38 +385,88 @@ export function registerSoloCommands(program, io) {
         'without requiring the LLM to pass --prompt-size <bytes> manually. ' +
         'Adapter-driven (no hard-coded IDE names): Claude Code is the MVP ' +
         'implementation; trae / codex / cursor / qoder / tongyi-lingma / ' +
-        'hermes / openclaw register their own env-var via IdeAdapter.compact.')
+        'hermes / openclaw register their own env-var via IdeAdapter.compact. ' +
+        'v3.1.2: when --enforce-job-mode is set OR job-shape.json says isJob=true, ' +
+        '≥0.85 emits action=auto-compact-now (MANDATORY, not advisory) and ' +
+        '≥0.95 emits action=red-line (forced hook fires next turn).')
         .requiredOption('--project <path>', 'target project root')
-        .option('--session-id <sid>', 'override session id (default: read from active presence)')).action(async (opts) => {
+        .option('--session-id <sid>', 'override session id (default: read from active presence)')
+        .option('--enforce-job-mode', 'v3.1.2: treat ≥0.85 as MANDATORY auto-compact (not advisory). Auto-enabled when job-shape.json says isJob=true.')).action(async (opts) => {
         try {
             const { readContextPercent } = await import('../../services/context/auto-compact-reader.js');
+            // v3.1.2: detect Job mode from job-shape.json when --enforce-job-mode
+            // is not explicitly passed. The LLM is the source of truth for
+            // whether the request is Job-shaped; the recorded decision is.
+            let isJobMode = opts.enforceJobMode === true;
+            if (!isJobMode) {
+                try {
+                    const sessionIdForDecision = opts.sessionId ?? readActiveSid(opts.project);
+                    if (sessionIdForDecision !== null) {
+                        const record = readJobShapeDecision(opts.project, sessionIdForDecision);
+                        if (record.decision.isJob)
+                            isJobMode = true;
+                    }
+                }
+                catch (err) {
+                    if (!(err instanceof JobShapeDecisionError))
+                        throw err;
+                    // missing/malformed decision file is fine — fall back to advisory.
+                }
+            }
             const probe = readContextPercent({
                 projectRoot: opts.project,
                 sessionId: opts.sessionId ?? readActiveSid(opts.project) ?? 'unknown',
                 env: process.env
             });
             const ratioPct = (probe.ratio * 100).toFixed(1);
-            const verdict = probe.ratio >= 0.95 ? 'red-line'
-                : probe.ratio >= 0.85 ? 'pre-compact'
-                    : probe.ratio >= 0.5 ? 'soft-warn'
+            let action = 'ok';
+            let next = null;
+            if (probe.ratio >= 0.95) {
+                action = isJobMode ? 'red-line' : 'red-line';
+                next = 'peaks session auto-compact-hook';
+            }
+            else if (probe.ratio >= 0.85) {
+                if (isJobMode) {
+                    action = 'auto-compact-now';
+                    next = 'peaks session auto-compact --execute';
+                }
+                else {
+                    action = 'soft-warn';
+                }
+            }
+            else if (probe.ratio >= 0.5) {
+                action = 'soft-warn';
+            }
+            const verdict = action === 'red-line' ? 'red-line'
+                : action === 'auto-compact-now' ? 'pre-compact'
+                    : action === 'soft-warn' ? 'soft-warn'
                         : 'ok';
+            const jobModeNotice = isJobMode
+                ? 'Job mode enforced: ≥0.85 is MANDATORY auto-compact (v3.1.2).'
+                : 'Advisory mode (single-rid): ≥0.85 is recommended, not mandatory.';
             printResult(io, ok('solo.context-now', {
                 ratio: probe.ratio,
                 ratioPct: `${ratioPct}%`,
                 verdict,
+                action,
+                next,
+                jobMode: isJobMode,
                 source: probe.source,
                 ide: probe.ide,
                 capacityBytes: probe.capacityBytes,
                 rawBytes: probe.rawBytes ?? null,
                 capturedAt: probe.capturedAt
             }, [], [
-                verdict === 'red-line'
-                    ? `RED LINE: ≥ 95%. Run \`peaks solo auto-compact\` immediately (next sub-agent dispatch will be blocked).`
-                    : verdict === 'pre-compact'
-                        ? `Pre-compact zone (85–95%). Run \`peaks solo auto-compact\` to converge now.`
-                        : verdict === 'soft-warn'
-                            ? `Soft warn (50–85%). Continue working; the next \`peaks context now\` will re-check.`
-                            : `Below 50%. No action required.`
+                action === 'red-line'
+                    ? `RED LINE: ≥ 95%. Next: \`${next}\` (PreToolUse hook fires next turn).`
+                    : action === 'auto-compact-now'
+                        ? `Job-mode MANDATORY auto-compact. Solo MUST call \`${next}\` WITHOUT confirmation.`
+                        : action === 'soft-warn'
+                            ? isJobMode
+                                ? `Job mode soft-warn (50–85%). Continue working; the next \`peaks context now\` will re-check.`
+                                : `Soft warn (50–85%). Continue working; the next \`peaks context now\` will re-check.`
+                            : `Below 50%. No action required.`,
+                jobModeNotice
             ]), true);
         }
         catch (err) {
@@ -468,7 +520,7 @@ export function registerSoloCommands(program, io) {
             const projectRoot = opts.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
             const sessionId = opts.sessionId ?? readActiveSid(projectRoot);
             if (sessionId === null) {
-                printResult(io, fail('solo.detect-job', 'NO_ACTIVE_SESSION', 'no active session id; pass --session-id or set presence via `peaks skill presence:set peaks-solo`', null, ['Re-run with --session-id <sid>']), opts.json);
+                printResult(io, fail('solo.detect-job', 'NO_ACTIVE_SESSION', 'no active session id; pass --session-id or set presence via `peaks skill presence:set peaks-code`', null, ['Re-run with --session-id <sid>']), opts.json);
                 process.exitCode = 1;
                 return;
             }
@@ -530,7 +582,7 @@ export function registerSoloCommands(program, io) {
             const projectRoot = opts.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
             const sessionId = opts.sessionId ?? readActiveSid(projectRoot);
             if (sessionId === null) {
-                printResult(io, fail('solo.read-job-shape', 'NO_ACTIVE_SESSION', 'no active session id; pass --session-id or set presence via `peaks skill presence:set peaks-solo`', null, ['Re-run with --session-id <sid>']), opts.json);
+                printResult(io, fail('solo.read-job-shape', 'NO_ACTIVE_SESSION', 'no active session id; pass --session-id or set presence via `peaks skill presence:set peaks-code`', null, ['Re-run with --session-id <sid>']), opts.json);
                 process.exitCode = 1;
                 return;
             }
@@ -558,6 +610,180 @@ export function registerSoloCommands(program, io) {
             process.exitCode = 1;
         }
     });
+    // v3.1.2 Step 0.8 — Mechanical PreToolUse gate.
+    // Wire-installed by `peaks workspace init` (extends the existing hook
+    // installer). Exit code is the load-bearing contract:
+    //   exit 0 → allow (with structured stdout describing the decision)
+    //   exit 2 → block (stderr contains the BLOCKED: ... reason)
+    addJsonOption(solo
+        .command('gate-step-08')
+        .description('v3.1.2: PreToolUse gate for Step 0.8 — allow when job-shape.json exists; ' +
+        'fail-closed backup regex when missing. Exit 0 = allow, exit 2 = block. ' +
+        'When the decision says isJob=true AND progress.json exists, the stdout ' +
+        'also carries `Next: slice #N+1 of M (<currentSlice>)` so the LLM cannot ' +
+        'wake up cold.')
+        .requiredOption('--project <path>', 'target project root (the hook passes "." so resolveCanonicalProjectRoot promotes it to the git root)')
+        .option('--session-id <sid>', 'override session id (default: read from active presence)')
+        .option('--prompt <text>', 'explicit prompt text (default: read last-prompt.txt; stdin ignored)')).action((opts) => {
+        try {
+            const sessionId = opts.sessionId ?? readActiveSid(opts.project);
+            if (sessionId === null) {
+                // No session binding — treat as allow (single-rid mode). The
+                // LLM has not yet anchored; we have nothing to gate against.
+                const envelope = ok('solo.gate-step-08', {
+                    allow: true,
+                    mode: 'no-session',
+                    decision: null,
+                    nextSlice: null
+                }, [], [
+                    'No active session id; gate passes through (single-rid mode).'
+                ]);
+                printResult(io, envelope, opts.json);
+                return;
+            }
+            const evalInput = {
+                projectRoot: opts.project,
+                sessionId
+            };
+            if (opts.prompt !== undefined)
+                evalInput.prompt = opts.prompt;
+            const result = evaluateStep08(evalInput);
+            const verdict = result.verdict;
+            if (verdict.kind === 'allow-job') {
+                const envelope = ok('solo.gate-step-08', {
+                    allow: true,
+                    mode: 'job',
+                    decision: verdict.decision,
+                    progress: verdict.progress,
+                    nextSlice: result.nextSliceLine
+                }, [], result.nextSliceLine !== null ? [result.nextSliceLine] : []);
+                printResult(io, envelope, opts.json);
+                return;
+            }
+            if (verdict.kind === 'allow-single') {
+                const envelope = ok('solo.gate-step-08', {
+                    allow: true,
+                    mode: 'single',
+                    decision: null,
+                    nextSlice: null
+                }, [], [
+                    'job-shape.json says isJob=false; single-rid mode (gate allows).'
+                ]);
+                printResult(io, envelope, opts.json);
+                return;
+            }
+            // block-missing-decision
+            if (verdict.promptHit) {
+                // Block: backup regex hit. Exit code 2 is the load-bearing
+                // signal for the PreToolUse hook.
+                const blockMessage = 'BLOCKED: prompt looks Job-shaped but peaks solo detect-job has not been called. Run `peaks solo detect-job --is-job true ...` to record your Job-shape verdict, then retry.';
+                const envelope = fail('solo.gate-step-08', 'STEP_08_BLOCKED', blockMessage, {
+                    promptSource: verdict.promptSource,
+                    backupRegex: STEP_08_BACKUP_REGEX.toString()
+                }, [
+                    'Run `peaks solo detect-job --is-job true --rationale <text> --suggested-job-id <slug>` to record the Job-shape verdict.',
+                    'Then re-run the Bash tool call.'
+                ]);
+                io.stderr(`${blockMessage}\n`);
+                printResult(io, envelope, opts.json);
+                process.exitCode = 2;
+                return;
+            }
+            // No decision + no regex hit → allow.
+            const envelope = ok('solo.gate-step-08', {
+                allow: true,
+                mode: 'undecided-no-regex-hit',
+                decision: null,
+                nextSlice: null,
+                promptSource: verdict.promptSource
+            }, [], [
+                'No job-shape.json AND no backup-regex match on prompt → allow (most prompts are not Job-shaped).'
+            ]);
+            printResult(io, envelope, opts.json);
+            return;
+        }
+        catch (err) {
+            printResult(io, fail('solo.gate-step-08', 'GATE_STEP_08_FAILED', getErrorMessage(err), null, [
+                'Verify the project path and try again'
+            ]), opts.json);
+            process.exitCode = 1;
+        }
+    });
+    // v3.1.2 Step 11 / final handoff — Size-fear ban.
+    // Refuses to emit a final handoff while a Job has remaining slices.
+    addJsonOption(solo
+        .command('emit-handoff')
+        .description('v3.1.2 Step 11 size-fear ban: under Job mode, refuse to emit a final ' +
+        'handoff while remaining > 0. Exit 0 = allow, exit 1 = block. Pass ' +
+        '--force-under-job to override (requires explicit user approval).')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--session-id <sid>', 'override session id (default: read from active presence)')
+        .option('--job-id <jid>', 'override job id (default: read from job-shape.json decision.suggestedJobId)')
+        .option('--force-under-job', 'override the remaining>0 block (explicit user approval required)')).action((opts) => {
+        try {
+            const sessionId = opts.sessionId ?? readActiveSid(opts.project);
+            if (sessionId === null) {
+                const envelope = ok('solo.emit-handoff', { allow: true, mode: 'no-session' }, [], [
+                    'No active session id; gate passes through (single-rid mode).'
+                ]);
+                printResult(io, envelope, opts.json);
+                return;
+            }
+            const evalInput = {
+                projectRoot: opts.project,
+                sessionId
+            };
+            if (opts.jobId !== undefined)
+                evalInput.jobId = opts.jobId;
+            if (opts.forceUnderJob === true)
+                evalInput.forceUnderJob = true;
+            const verdict = evaluateEmitHandoff(evalInput);
+            if (verdict.kind === 'allow-not-job') {
+                const envelope = ok('solo.emit-handoff', { allow: true, mode: 'single' }, [], [
+                    'job-shape.json says isJob=false (or absent); normal handoff allowed.'
+                ]);
+                printResult(io, envelope, opts.json);
+                return;
+            }
+            if (verdict.kind === 'allow-done') {
+                const envelope = ok('solo.emit-handoff', { allow: true, mode: 'job-done', remaining: verdict.remaining }, [], [
+                    `Job is complete (remaining=0); handoff allowed.`
+                ]);
+                printResult(io, envelope, opts.json);
+                return;
+            }
+            if (verdict.kind === 'allow-force-override') {
+                const envelope = ok('solo.emit-handoff', { allow: true, mode: 'job-force-override', remaining: verdict.remaining }, [], [
+                    `Job has ${verdict.remaining} remaining slices; --force-under-job override applied. Handoff allowed (explicit user approval).`
+                ]);
+                printResult(io, envelope, opts.json);
+                return;
+            }
+            if (verdict.kind === 'block-not-initialized') {
+                const envelope = fail('solo.emit-handoff', JOB_NOT_INITIALIZED, `Job ${verdict.jobId} has no state.json; peaks job init was skipped.`, { jobId: verdict.jobId }, [`Run \`peaks job init --job-id ${verdict.jobId} --slice-list <...>\` before emitting handoff.`]);
+                printResult(io, envelope, opts.json);
+                process.exitCode = 1;
+                return;
+            }
+            // block-remaining
+            const blockMessage = `BLOCKED: Job ${verdict.jobId} has ${verdict.remaining} remaining slices. Run \`peaks job status\`. Use --force-under-job only with explicit user approval.`;
+            const envelope = fail('solo.emit-handoff', JOB_REMAINING_BLOCKED, blockMessage, { jobId: verdict.jobId, remaining: verdict.remaining }, [
+                `Run \`peaks job status --job-id ${verdict.jobId}\` to see remaining slices.`,
+                'Resume Step 0.81 (per-slice checkpoint loop) and continue until remaining === 0.',
+                'Use --force-under-job only with explicit user approval (size-fear ban override).'
+            ]);
+            io.stderr(`${blockMessage}\n`);
+            printResult(io, envelope, opts.json);
+            process.exitCode = 1;
+            return;
+        }
+        catch (err) {
+            printResult(io, fail('solo.emit-handoff', 'EMIT_HANDOFF_FAILED', getErrorMessage(err), null, [
+                'Verify the project path and try again'
+            ]), opts.json);
+            process.exitCode = 1;
+        }
+    });
 }
 function readActiveSid(projectRoot) {
     try {

package/dist/src/cli/commands/sub-agent-commands.d.ts

@@ -13,7 +13,7 @@
  *   - `sub-agent-shared.ts`   — shared types, constants, helpers
  *
  * Skill-first / CLI-auxiliary red line (PB-4 / AC-19/20):
- *   These commands are primitives that the peaks-solo / peaks-rd /
+ *   These commands are primitives that the peaks-code / peaks-rd /
  *   peaks-qa SKILL.md compose. Users do NOT invoke them directly.
  */
 import type { Command } from 'commander';

package/dist/src/cli/commands/sub-agent-commands.js

@@ -9,7 +9,7 @@ export function registerSubAgentCommands(program, io) {
     const subAgent = program
         .command('sub-agent')
         .description('Sub-agent dispatch primitive (skill-first / CLI-auxiliary). ' +
-        'These commands are the primitives that peaks-solo / peaks-rd / ' +
+        'These commands are the primitives that peaks-code / peaks-rd / ' +
         'peaks-qa SKILL.md compose. Users do not invoke this directly.');
     registerDispatchCommand(subAgent, io);
     registerHeartbeatCommand(subAgent, io);

package/dist/src/cli/commands/understand-commands.js

@@ -77,7 +77,7 @@ export function registerUnderstandCommands(program, io) {
         }
     });
     // L3.1: opt-in UX subcommand. Returns the AskUserQuestion payload that
-    // the LLM-side UX layer (peaks-solo / peaks-ide) should surface when
+    // the LLM-side UX layer (peaks-code / peaks-ide) should surface when
     // uaPrompt === 'unset' and UA is absent. When uaPrompt is skip-this-session
     // or skip-forever, returns a no-op envelope (caller does not prompt).
     addJsonOption(understand

package/dist/src/cli/commands/upgrade-commands.d.ts

@@ -13,7 +13,7 @@
  * hooks-install / skill-sync / audit-verify + write-upgrade-record.
  *
  * The `--detect-1x` flag (added in slice 3) is a read-only
- * probe that the peaks-solo skill calls to gate the
+ * probe that the peaks-code skill calls to gate the
  * AskUserQuestion that prompts the 1.x → 2.0 upgrade. The
  * probe returns the JSON envelope from the
  * 1x-detector-service; it does NOT modify any files.

package/dist/src/cli/commands/upgrade-commands.js

@@ -8,11 +8,11 @@ import { fail, ok } from '../../shared/result.js';
 export function registerUpgradeCommands(program, io) {
     addJsonOption(program
         .command('upgrade')
-        .description('Upgrade a peaks-loop 1.x project to 2.0. Umbrella that orquestrates 7 sub-commands: config-migrate / standards-migrate / memory-extract / hooks-install / skill-sync / audit-verify + write-upgrade-record. Per the "one-key completion" tenet, prefer letting `npm i -g peaks-loop@2.0` postinstall run this for you. Use `--detect-1x` for a read-only probe (no file writes) that the peaks-solo skill uses to gate the 1.x → 2.0 AskUserQuestion.')
+        .description('Upgrade a peaks-loop 1.x project to 2.0. Umbrella that orquestrates 7 sub-commands: config-migrate / standards-migrate / memory-extract / hooks-install / skill-sync / audit-verify + write-upgrade-record. Per the "one-key completion" tenet, prefer letting `npm i -g peaks-loop@2.0` postinstall run this for you. Use `--detect-1x` for a read-only probe (no file writes) that the peaks-code skill uses to gate the 1.x → 2.0 AskUserQuestion.')
         .option('--to <version>', 'target version (only "2.0" supported)', '2.0')
         .option('--project <path>', 'project root to upgrade (default: cwd)')
         .option('--auto', 'non-interactive: accept soft-fail on any sub-step (used by the postinstall hook)')
-        .option('--detect-1x', 'read-only probe: returns the 1.x state as JSON (no file writes); consumed by peaks-solo Step 0.55 to gate the AskUserQuestion')
+        .option('--detect-1x', 'read-only probe: returns the 1.x state as JSON (no file writes); consumed by peaks-code Step 0.55 to gate the AskUserQuestion')
         .option('--apply-init', 'slice 4 (slice 2026-06-13-selfheal-claude-settings-template): run initWorkspace so the drift-driven self-heal fires on the consumer-project .claude/settings.local.json and the offline .peaks/.claude-settings-template.json. Idempotent. Use after a peaks-loop version bump if you do not otherwise re-run init. Mutually exclusive with --detect-1x.')).action(async (options) => {
         const projectRoot = options.project ?? process.cwd();
         // Branch 1: --detect-1x (read-only probe)
@@ -21,7 +21,7 @@ export function registerUpgradeCommands(program, io) {
                 const state = detect1xProjectState(projectRoot);
                 const nextActions = [];
                 if (state.isOneX) {
-                    nextActions.push(`Detected 1.x state. peaks-solo Step 0.55 should present an AskUserQuestion to invoke \`peaks upgrade --to 2.0 --auto --project ${state.projectRoot ?? projectRoot}\`.`);
+                    nextActions.push(`Detected 1.x state. peaks-code Step 0.55 should present an AskUserQuestion to invoke \`peaks upgrade --to 2.0 --auto --project ${state.projectRoot ?? projectRoot}\`.`);
                 }
                 else {
                     nextActions.push('No 1.x state detected. Proceed with the standing 2.0 layout.');

package/dist/src/cli/commands/user-touchpoint-commands.js

@@ -23,7 +23,7 @@ export function registerUserTouchpointCommands(program, io) {
     // user-touchpoints / commit-boundary-actions.
     //
     // We do NOT create a new `peaks solo` CLI command here because that
-    // would conflict with the peaks-solo skill presence tracking (see
+    // would conflict with the peaks-code skill presence tracking (see
     // `src/services/skills/skill-presence-service.ts`).
     addJsonOption(program
         .command('gate-classify')

package/dist/src/cli/commands/verdict-aggregate-command.d.ts

@@ -3,7 +3,7 @@
  *
  * Reads the 5 envelope sources under `.peaks/_runtime/<sid>/` for a
  * given rid, runs `aggregateVerdict()`, and prints the verdict +
- * reasons JSON envelope. Used by peaks-solo / peaks-final-review to
+ * reasons JSON envelope. Used by peaks-code / peaks-final-review to
  * cross-check the slice-level verdict without booting the full
  * 5-skill fanout.
  *

package/dist/src/cli/commands/verdict-aggregate-command.js

@@ -10,10 +10,10 @@ const KARPATHY_REL = 'rd/karpathy-review.md';
 const MUT_REL = 'mut/mut-report.json';
 const QA_REL = 'qa/test-reports';
 export function registerVerdictAggregateCommands(program, io) {
-    const verdict = program.command('verdict').description('Aggregate the 5 envelope sources feeding peaks-solo verdict logic');
+    const verdict = program.command('verdict').description('Aggregate the 5 envelope sources feeding peaks-code verdict logic');
     addJsonOption(verdict
         .command('aggregate')
-        .description('Aggregate 5 envelope sources (security / perf / karpathy / mut / qa) and print the verdict + reasons JSON envelope. Used by peaks-solo and peaks-final-review.')
+        .description('Aggregate 5 envelope sources (security / perf / karpathy / mut / qa) and print the verdict + reasons JSON envelope. Used by peaks-code and peaks-final-review.')
         .requiredOption('--from-rid <rid>', 'request id, e.g. 2026-06-27-...')
         .option('--sid <sid>', 'session id, e.g. 2026-06-27-session-...; default: project default')
         .option('--project <path>', 'project root (default: cwd)')).action(async (options) => {

package/dist/src/cli/commands/workflow-commands.js

@@ -330,7 +330,7 @@ function addAutonomousResumeInitOptions(command) {
 export function registerWorkflowCommands(program, io) {
     const refactor = program.command('refactor').description('Plan a Peaks refactor run without modifying code');
     addJsonOption(refactor
-        .option('--solo', 'use peaks-solo orchestration mode')
+        .option('--solo', 'use peaks-code orchestration mode')
         .option('--rd', 'use peaks-rd direct mode')
         .option('--dry-run', 'print gates and required artifacts', true)
         .option('--no-dry-run', 'unsupported: do not modify code from this command')).action((options) => {
@@ -410,7 +410,7 @@ export function registerWorkflowCommands(program, io) {
             // because we read, not write, the binding.
             const sessionId = getSessionId(options.project);
             if (sessionId === null) {
-                printResult(io, fail('workflow.skip', 'NO_ACTIVE_SESSION', `project "${options.project}" has no peaks-solo session binding; run \`peaks workspace init --project ${options.project} --json\` first`, { applied: false }, [`peaks workspace init --project ${options.project} --json`]), options.json);
+                printResult(io, fail('workflow.skip', 'NO_ACTIVE_SESSION', `project "${options.project}" has no peaks-code session binding; run \`peaks workspace init --project ${options.project} --json\` first`, { applied: false }, [`peaks workspace init --project ${options.project} --json`]), options.json);
                 process.exitCode = 1;
                 return;
             }

package/dist/src/cli/commands/workspace/init-command.d.ts

@@ -1,5 +1,5 @@
 /**
- * `peaks workspace init` — slice 006 + 007 + 014 + 018 + 2026-06-16-peaks-solo-auto-scaffold.
+ * `peaks workspace init` — slice 006 + 007 + 014 + 018 + 2026-06-16-peaks-code-auto-scaffold.
  *
  * Extracted from `src/cli/commands/workspace-commands.ts` (slice
  * 2026-06-16-workspace-commands-split) to keep that entry file under the
@@ -45,11 +45,11 @@ export type WorkspaceInitOptions = {
      * (commander `--no-` prefix) is `true`; pass `--no-claude-hooks` to
      * set this to `false`. The wrapper reads this as `=== false` to
      * skip the materialization. The bypass is documented in
-     * `peaks-solo/references/anchoring-and-session-info.md`.
+     * `peaks-code/references/anchoring-and-session-info.md`.
      */
     claudeHooks?: boolean;
     /**
-     * Slice 2026-06-16-peaks-solo-auto-scaffold (RD#7): opt-in flag to
+     * Slice 2026-06-16-peaks-code-auto-scaffold (RD#7): opt-in flag to
      * auto-scaffold `.claude/rules/{common,<language>}/` when missing.
      * Default `false` — the diagnostic fires but no write happens.
      * Set to `true` (via `--init-standards`) to also run