peaks-loop 4.0.0-beta → 4.0.0-beta.3

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

@@ -1,23 +1,35 @@
 /**
- * peaks loop * CLI (Slice #14) — L4 Agent Loop Integration.
+ * peaks loop * CLI (Slice #14 + M7 add).
  *
- * Per docs/superpowers/specs/2026-06-11-peaks-loop-l1-l2-l3-redesign.md §5.4
- * Slice #14, ships 5 sub-features:
+ * Slices:
+ *   #14 sub-features (L4 Agent Loop integration): distill / preflight /
+ *     detect-pattern / check-consistency / peaks goal compose.
  *
- *   14.1 peaks loop distill          — extract patterns from past sessions
- *                                       (delegates to peaks memory extract)
- *   14.2 peaks loop preflight        — pre-run sanity checks (placeholder)
- *   14.3 peaks loop detect-pattern   — find repeating patterns (placeholder)
- *   14.4 peaks loop check-consistency — verify state consistency (placeholder)
- *   14.5 peaks goal compose          — autonomous goal composition (placeholder;
- *                                       requires IDE adapter goalCommand capability
- *                                       per Slice #0.7)
+ *   M7 (2026-07-07 spec §7A.2):
+ *     peaks loop export --loop <id> --out <path.tar.gz>
+ *     peaks loop import --in <path.tar.gz> [--as <loop-id>]
  *
- * The 4 placeholders emit a clear nextActions list; the LLM-side UX
- * layer composes the actual runtime today.
+ * `peaks loop export` reads the source loop_release + relations +
+ * related bees + evidence briefs and emits a `peaks.bundle/1`
+ * tar.gz. Hard-blocks when the source has `shareable=false`.
+ *
+ * `peaks loop import` extracts a bundle, validates
+ * format_version_major=1, and lands the release as `candidate`
+ * (mandatory landing status per spec §7A.2). The receiver must run
+ * an independent evaluation before promoting to `stable`.
+ *
+ * The existing 14.x commands are kept under the same `loop` parent;
+ * M7 only ADDs export / import — it does not modify the existing
+ * surface.
  */
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
 import { fail, ok } from '../../shared/result.js';
+import { findProjectRoot } from '../../services/config/config-safety.js';
+import { openStateDb } from '../../services/skillhub/sqlite-store.js';
+import { writeBundle, BundleNotShareableError, BundleAssetNotFoundError, } from '../../services/share/bundle-writer.js';
+import { readBundle, BundleMajorVersionMismatchError, BundleSchemaVersionsMismatchError, BundleImportToStableForbiddenError, BundleMalformedError, } from '../../services/share/bundle-reader.js';
 export function registerLoopCommands(program, io) {
     // 14.5 peaks goal compose — registered as a TOP-LEVEL command (not under
     // `peaks loop`) because IDE adapters expose it as `goalCommand`.
@@ -125,4 +137,126 @@ export function registerLoopCommands(program, io) {
             'loop.check-consistency is a thin facade; the LLM-side UX layer composes the drift scan.',
         ]), options.json);
     });
+    // ---------- M7: peaks loop export / import (spec §7A.2) ----------
+    const LOOP_EXPORT_IMPORT_OPTS = (cmd) => cmd
+        .option('--project <path>', 'target project root (defaults to cwd)')
+        .option('--json', 'print machine-readable JSON envelope');
+    LOOP_EXPORT_IMPORT_OPTS(loop
+        .command('export')
+        .description("M7: export a loop_release as a peaks.bundle/1 tarball (spec §7A.2 / §10 RL-9). Refuses to export when shareable=false.")
+        .requiredOption('--loop <id>', 'loop_release id (kebab-case)')
+        .requiredOption('--out <path>', 'output .tar.gz path')).action((options) => {
+        const asJson = options.json === true;
+        try {
+            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+            if (!existsSync(join(projectRoot, '.peaks'))) {
+                mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
+            }
+            const db = openStateDb(join(projectRoot, '.peaks', 'state.db'));
+            try {
+                const result = writeBundle({
+                    db,
+                    blobsDir: join(projectRoot, '.peaks', 'blobs'),
+                    kind: 'loop',
+                    id: options.loop,
+                    outPath: options.out,
+                });
+                printResult(io, ok('loop.export', {
+                    outPath: result.outPath,
+                    kind: result.kind,
+                    assetId: result.assetId,
+                    importedAs: 'candidate',
+                }, [], [
+                    `Receiver must run \`peaks loop import --in ${result.outPath}\` to land this bundle, then run an independent evolution_evaluation before any promote.`,
+                ]), asJson);
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch (error) {
+            if (error instanceof BundleNotShareableError) {
+                printResult(io, fail('loop.export', error.code, error.message, { ok: false, loop: options.loop }, [
+                    'Set shareable=true on the loop_release row, or share via desktop_visible=false.',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof BundleAssetNotFoundError) {
+                printResult(io, fail('loop.export', error.code, error.message, { ok: false, loop: options.loop }, [
+                    'Verify the loop id with `peaks asset status --loop <id>`.',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            printResult(io, fail('loop.export', 'LOOP_EXPORT_FAILED', getErrorMessage(error), { ok: false, loop: options.loop }, ['Verify --loop id and --out path.']), asJson);
+            process.exitCode = 1;
+        }
+    });
+    LOOP_EXPORT_IMPORT_OPTS(loop
+        .command('import')
+        .description("M7: import a peaks.bundle/1 tarball. Lands as candidate only — promotion requires an evolution_evaluation row (spec §7A.2 / §10 RL-9 / AC-25 / AC-26).")
+        .requiredOption('--in <path>', 'input .tar.gz path')
+        .option('--as <id>', 'optional rename for the loop id when landing')).action((options) => {
+        const asJson = options.json === true;
+        try {
+            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+            if (!existsSync(join(projectRoot, '.peaks'))) {
+                mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
+            }
+            const db = openStateDb(join(projectRoot, '.peaks', 'state.db'));
+            try {
+                const result = readBundle({
+                    db,
+                    blobsDir: join(projectRoot, '.peaks', 'blobs'),
+                    inPath: options.in,
+                    ...(options.as !== undefined ? { asName: options.as } : {}),
+                });
+                printResult(io, ok('loop.import', {
+                    assetId: result.assetId,
+                    kind: result.kind,
+                    importedAs: result.importedAs,
+                    warnings: result.warnings,
+                    evidenceBriefCount: result.evidenceBriefCount,
+                }, result.warnings, [
+                    `Run an independent evaluation against this release before promoting; peaks loop promote refuses without an evolution_evaluation row.`,
+                ]), asJson);
+            }
+            finally {
+                db.close();
+            }
+        }
+        catch (error) {
+            if (error instanceof BundleMajorVersionMismatchError) {
+                printResult(io, fail('loop.import', error.code, error.message, { ok: false, receivedMajor: error.receivedMajor }, [
+                    'Use the matching peaks.bundle/<major> reader; this peaks build only supports major=1.',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof BundleSchemaVersionsMismatchError) {
+                printResult(io, fail('loop.import', error.code, error.message, { ok: false }, [
+                    'Source bundle did not declare the canonical schema versions; refuse the bundle.',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof BundleImportToStableForbiddenError) {
+                printResult(io, fail('loop.import', error.code, error.message, { ok: false }, [
+                    'Bundles always land as candidate; promotion to stable requires an evolution_evaluation row (AC-26).',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            if (error instanceof BundleMalformedError) {
+                printResult(io, fail('loop.import', error.code, error.message, { ok: false, inPath: options.in }, [
+                    'Re-export from the source via `peaks loop export`.',
+                ]), asJson);
+                process.exitCode = 1;
+                return;
+            }
+            printResult(io, fail('loop.import', 'LOOP_IMPORT_FAILED', getErrorMessage(error), { ok: false, inPath: options.in }, ['Verify the bundle path and integrity.']), asJson);
+            process.exitCode = 1;
+        }
+    });
 }

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

@@ -450,6 +450,11 @@ export async function runSediment(argv, { home }) {
                 finally {
                     db.close();
                 }
+                // M7 (spec §7A.2 / §10 RL-9): `peaks skill sediment export` is
+                // an ALIAS of `peaks loop export` for one release cycle. Emit
+                // the deprecation warning to stderr so downstream tooling can
+                // upgrade. Future slice removes the alias.
+                process.stderr.write("warning: 'peaks skill sediment export' is deprecated; use 'peaks loop export' or 'peaks bee export' (peaks.bundle/1, spec §7A.2)\n");
                 return { ok: true, data: { outPath } };
             }
             case "import": {
@@ -479,6 +484,10 @@ export async function runSediment(argv, { home }) {
                 finally {
                     db.close();
                 }
+                // M7 (spec §7A.2): `peaks skill sediment import` is an ALIAS of
+                // `peaks loop import` for one release cycle. Emit the
+                // deprecation warning so downstream tooling can upgrade.
+                process.stderr.write("warning: 'peaks skill sediment import' is deprecated; use 'peaks loop import' or 'peaks bee import' (peaks.bundle/1, spec §7A.2)\n");
                 return { ok: true, data: { asName: asName ?? basename(bundlePath) } };
             }
             case "gc-blobs": {

package/dist/src/cli/commands/session-auto-compact-hook-command.js

@@ -86,7 +86,7 @@ export function registerSessionAutoCompactHookCommand(session) {
         if (probe.ratio < RED_LINE_RATIO) {
             // Below red line → exit 0 silent. The orchestrator's
             // pre-compact zone (0.85–0.95) is handled out-of-band by
-            // the LLM firing `peaks solo auto-compact --execute`; the
+            // the LLM firing `peaks code auto-compact --execute`; the
             // hook only fires on the synchronous red-line path.
             return;
         }
@@ -102,7 +102,7 @@ export function registerSessionAutoCompactHookCommand(session) {
         // binary), `spawn` raises ENOENT. Catching this MUST NOT crash
         // the runner's tool call — the hook must exit 0 silently with
         // a one-line stderr hint so the runner keeps working. The user
-        // can then run `/compact` manually (or `peaks solo auto-compact`
+        // can then run `/compact` manually (or `peaks code auto-compact`
         // from another terminal).
         try {
             const child = spawn('claude', ['--compact'], {

package/dist/src/cli/commands/skill-loop-engineering-readiness-commands.d.ts

@@ -0,0 +1,67 @@
+/**
+ * `peaks skill lint --category loop-engineering-readiness` — M6 / spec §7.5 + §8.4
+ *
+ * Loop Engineering readiness gate for any new peaks-* skill that
+ * participates in Loop Engineering (crystallization or evolution).
+ *
+ * Usage:
+ *   peaks skill lint --category loop-engineering-readiness --path <skill-dir>
+ *   peaks skill lint --category loop-engineering-readiness --path <skill-dir> --json
+ *
+ * The command:
+ *   1. Resolves <skill-dir>/SKILL.md (default if the path is a file).
+ *   2. Calls lintSkillLoopEngineeringReadiness() with the file contents.
+ *   3. Prints a structured JSON envelope via printResult (or a
+ *      human-readable summary when --json is omitted).
+ *   4. Sets process.exitCode = 1 on a non-ok result, so the LLM
+ *      gate can short-circuit a future peaks-* skill that fails the
+ *      lint.
+ *
+ * The lint asserts three structural properties:
+ *   1. the SKILL.md references
+ *      `.peaks/standards/loop-engineering-guidelines.md`;
+ *   2. the SKILL.md does not introduce a CLI verb the user is meant
+ *      to type (only LLM-coordinated verbs from the sediment /
+ *      asset / evolution surface are allowed; RL-1);
+ *   3. the SKILL.md does not introduce a JSON / manifest
+ *      hand-authoring surface (RL-1).
+ *
+ * The user never types `peaks skill lint …` — the LLM runs it on
+ * the user's behalf. This command is also reachable as
+ * `peaks skill ready --category loop-engineering-readiness
+ *   --path <skill-dir>`
+ * via a small alias added at the bottom of this file.
+ */
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare const LOOP_ENGINEERING_READINESS_CATEGORY = "loop-engineering-readiness";
+/**
+ * Resolve the SKILL.md file path from a `--path <skill-dir>` value.
+ *
+ * Accepts either:
+ *   - a directory containing a SKILL.md (the common case for a
+ *     peaks-* skill: `src/skills/<id>/`, `skills/<id>/`, etc.);
+ *   - a direct file path to a SKILL.md.
+ *
+ * Returns the absolute path to the SKILL.md, or null if no SKILL.md
+ * is found.
+ */
+export declare function resolveSkillMdPath(rawPath: string): string | null;
+/**
+ * Pure helper: run the readiness lint against the SKILL.md text and
+ * return a CLI-shaped envelope. Kept separate from the Commander
+ * action so unit + integration tests can drive it without spawning
+ * a child process.
+ */
+export declare function runReadinessLint(rawPath: string): {
+    ok: boolean;
+    code: string;
+    message: string;
+    data: {
+        path: string;
+        category: string;
+        findings: string[];
+    };
+    nextActions: string[];
+};
+export declare function registerSkillLoopEngineeringReadinessCommands(program: Command, io: ProgramIO): void;

package/dist/src/cli/commands/skill-loop-engineering-readiness-commands.js

@@ -0,0 +1,173 @@
+/**
+ * `peaks skill lint --category loop-engineering-readiness` — M6 / spec §7.5 + §8.4
+ *
+ * Loop Engineering readiness gate for any new peaks-* skill that
+ * participates in Loop Engineering (crystallization or evolution).
+ *
+ * Usage:
+ *   peaks skill lint --category loop-engineering-readiness --path <skill-dir>
+ *   peaks skill lint --category loop-engineering-readiness --path <skill-dir> --json
+ *
+ * The command:
+ *   1. Resolves <skill-dir>/SKILL.md (default if the path is a file).
+ *   2. Calls lintSkillLoopEngineeringReadiness() with the file contents.
+ *   3. Prints a structured JSON envelope via printResult (or a
+ *      human-readable summary when --json is omitted).
+ *   4. Sets process.exitCode = 1 on a non-ok result, so the LLM
+ *      gate can short-circuit a future peaks-* skill that fails the
+ *      lint.
+ *
+ * The lint asserts three structural properties:
+ *   1. the SKILL.md references
+ *      `.peaks/standards/loop-engineering-guidelines.md`;
+ *   2. the SKILL.md does not introduce a CLI verb the user is meant
+ *      to type (only LLM-coordinated verbs from the sediment /
+ *      asset / evolution surface are allowed; RL-1);
+ *   3. the SKILL.md does not introduce a JSON / manifest
+ *      hand-authoring surface (RL-1).
+ *
+ * The user never types `peaks skill lint …` — the LLM runs it on
+ * the user's behalf. This command is also reachable as
+ * `peaks skill ready --category loop-engineering-readiness
+ *   --path <skill-dir>`
+ * via a small alias added at the bottom of this file.
+ */
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { lintSkillLoopEngineeringReadiness, } from '../../services/standards/loop-engineering-readiness-lint.js';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { fail, ok } from '../../shared/result.js';
+export const LOOP_ENGINEERING_READINESS_CATEGORY = 'loop-engineering-readiness';
+/**
+ * Resolve the SKILL.md file path from a `--path <skill-dir>` value.
+ *
+ * Accepts either:
+ *   - a directory containing a SKILL.md (the common case for a
+ *     peaks-* skill: `src/skills/<id>/`, `skills/<id>/`, etc.);
+ *   - a direct file path to a SKILL.md.
+ *
+ * Returns the absolute path to the SKILL.md, or null if no SKILL.md
+ * is found.
+ */
+export function resolveSkillMdPath(rawPath) {
+    const abs = resolve(rawPath);
+    if (!existsSync(abs))
+        return null;
+    const st = statSync(abs);
+    if (st.isFile()) {
+        return abs.toLowerCase().endsWith('skill.md') ? abs : null;
+    }
+    if (st.isDirectory()) {
+        const candidate = join(abs, 'SKILL.md');
+        return existsSync(candidate) ? candidate : null;
+    }
+    return null;
+}
+/**
+ * Pure helper: run the readiness lint against the SKILL.md text and
+ * return a CLI-shaped envelope. Kept separate from the Commander
+ * action so unit + integration tests can drive it without spawning
+ * a child process.
+ */
+export function runReadinessLint(rawPath) {
+    const skillMdPath = resolveSkillMdPath(rawPath);
+    if (!skillMdPath) {
+        return {
+            ok: false,
+            code: 'SKILL_FILE_NOT_FOUND',
+            message: `could not resolve SKILL.md from --path ${rawPath}`,
+            data: { path: rawPath, category: LOOP_ENGINEERING_READINESS_CATEGORY, findings: [] },
+            nextActions: [
+                'Pass a directory containing SKILL.md or a direct path to a SKILL.md file.',
+            ],
+        };
+    }
+    const text = readFileSync(skillMdPath, 'utf-8');
+    const result = lintSkillLoopEngineeringReadiness(text);
+    if (result.ok) {
+        return {
+            ok: true,
+            code: 'SKILL_READINESS_OK',
+            message: 'SKILL.md passes the Loop Engineering readiness lint',
+            data: {
+                path: skillMdPath,
+                category: LOOP_ENGINEERING_READINESS_CATEGORY,
+                findings: [],
+            },
+            nextActions: [
+                'The skill is allowed to participate in Loop Engineering (crystallization / evolution).',
+            ],
+        };
+    }
+    return {
+        ok: false,
+        code: 'SKILL_READINESS_FAILED',
+        message: `SKILL.md failed the Loop Engineering readiness lint (${result.findings.length} finding(s))`,
+        data: {
+            path: skillMdPath,
+            category: LOOP_ENGINEERING_READINESS_CATEGORY,
+            findings: result.findings,
+        },
+        nextActions: [
+            'Address every finding listed in data.findings, then re-run the lint.',
+            'See src/services/standards/loop-engineering-readiness-lint.ts for the rule definitions.',
+            'See .peaks/standards/loop-engineering-guidelines.md for the red lines the lint enforces.',
+        ],
+    };
+}
+function lintAction(options, io) {
+    if (options.category !== LOOP_ENGINEERING_READINESS_CATEGORY) {
+        printResult(io, fail('skill.lint', 'UNKNOWN_LINT_CATEGORY', `only --category ${LOOP_ENGINEERING_READINESS_CATEGORY} is implemented in M6`, { category: options.category ?? null }, [
+            `Pass --category ${LOOP_ENGINEERING_READINESS_CATEGORY}.`,
+        ]), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    if (!options.path) {
+        printResult(io, fail('skill.lint', 'MISSING_PATH', '--path <skill-dir> is required', { category: options.category }, ['Pass --path pointing at a peaks-* skill directory containing SKILL.md.']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const envelope = runReadinessLint(options.path);
+        if (envelope.ok) {
+            printResult(io, ok('skill.lint', envelope.data, [], envelope.nextActions), options.json);
+            return;
+        }
+        printResult(io, fail('skill.lint', envelope.code, envelope.message, envelope.data, envelope.nextActions), options.json);
+        process.exitCode = 1;
+    }
+    catch (error) {
+        printResult(io, fail('skill.lint', 'SKILL_READINESS_ERROR', getErrorMessage(error), { path: options.path }, ['Verify the path is readable.']), options.json);
+        process.exitCode = 1;
+    }
+}
+export function registerSkillLoopEngineeringReadinessCommands(program, io) {
+    // `peaks skill lint --category loop-engineering-readiness --path <skill-dir>`
+    // — primary surface, named to match the spec §7.5 / §8.4 wording.
+    // We reuse the existing `skill` parent if one is registered; per
+    // the add-a-new-subcommand-check-for-existing-top-level-first rule,
+    // we never re-create `skill` when it's already there.
+    const existingSkill = program.commands.find((c) => c.name() === 'skill');
+    const skill = existingSkill ?? program
+        .command('skill')
+        .description('skill operations (M6: lint --category loop-engineering-readiness)');
+    addJsonOption(skill
+        .command('lint')
+        .description(`M6: lint a peaks-* SKILL.md against a category. Currently supports --category ${LOOP_ENGINEERING_READINESS_CATEGORY} (spec §7.5 / §8.4 / RL-8).`)
+        .option('--category <name>', `lint category; the M6 implementation only supports ${LOOP_ENGINEERING_READINESS_CATEGORY}`, LOOP_ENGINEERING_READINESS_CATEGORY)
+        .requiredOption('--path <skill-dir>', 'path to a peaks-* skill directory (containing SKILL.md) or directly to a SKILL.md file')).action((options) => lintAction(options, io));
+    // `peaks skill ready --category loop-engineering-readiness --path <skill-dir>`
+    // — alias verb chosen by M6 for human-facing callouts. It points at
+    // the same handler; both verbs are first-class so users (LLM
+    // proxies) can pick whichever phrasing fits the conversation.
+    // Per the spec, the user never types either verb; the LLM runs the
+    // CLI on the user's behalf.
+    skill
+        .command('ready')
+        .description(`M6 alias for \`peaks skill lint --category ${LOOP_ENGINEERING_READINESS_CATEGORY}\`; same flags, same exit codes.`)
+        .option('--category <name>', `lint category; the M6 implementation only supports ${LOOP_ENGINEERING_READINESS_CATEGORY}`, LOOP_ENGINEERING_READINESS_CATEGORY)
+        .requiredOption('--path <skill-dir>', 'path to a peaks-* skill directory or SKILL.md file')
+        .option('--json', 'print machine-readable JSON envelope')
+        .action((options) => lintAction(options, io));
+}

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

@@ -71,7 +71,7 @@ export type AwaitOptions = {
  * to keep the warm-path dispatch CLI cold-start fast (slice 9).
  */
 export type SliceDagModule = typeof import('../../services/dispatch/slice-dag.js');
-export type DagOrchestratorModule = typeof import('../../services/solo/dag-orchestrator.js');
+export type DagOrchestratorModule = typeof import('../../services/code/dag-orchestrator.js');
 export type ContractStoreModule = typeof import('../../services/dispatch/contract-store.js');
 /**
  * Validate a role string. Returns `null` when valid, otherwise the

package/dist/src/cli/commands/user-touchpoint-commands.d.ts

@@ -1,12 +1,12 @@
 /**
  * v2.15.0 follow-up — G4: user touchpoint CLI.
  *
- *   - `peaks solo gate-classify --step <step-id>` — classify a single
- *     Solo gate (business / tech / mode-selection / commit-boundary /
+ *   - `peaks code gate-classify --step <step-id>` — classify a single
+ *     Code gate (business / tech / mode-selection / commit-boundary /
  *     commit-floor)
- *   - `peaks solo user-touchpoints`                — list all gates the
+ *   - `peaks code user-touchpoints`                — list all gates the
  *     user must review (vs AI auto-decides in full-auto)
- *   - `peaks solo commit-boundary-actions`         — list the 5
+ *   - `peaks code commit-boundary-actions`         — list the 5
  *     hard-floor commit actions (push / tag / publish / global
  *     install)
  *

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

@@ -1,45 +1,45 @@
 /**
  * v2.15.0 follow-up — G4: user touchpoint CLI.
  *
- *   - `peaks solo gate-classify --step <step-id>` — classify a single
- *     Solo gate (business / tech / mode-selection / commit-boundary /
+ *   - `peaks code gate-classify --step <step-id>` — classify a single
+ *     Code gate (business / tech / mode-selection / commit-boundary /
  *     commit-floor)
- *   - `peaks solo user-touchpoints`                — list all gates the
+ *   - `peaks code user-touchpoints`                — list all gates the
  *     user must review (vs AI auto-decides in full-auto)
- *   - `peaks solo commit-boundary-actions`         — list the 5
+ *   - `peaks code commit-boundary-actions`         — list the 5
  *     hard-floor commit actions (push / tag / publish / global
  *     install)
  *
  * Surfaces the 12 Gaps positioning memory rule:
  *   "user 在循环里 = 业务/产品审阅者,不参与技术决策"
  */
-import { aiAutoDecidesGates, classifyGate, COMMIT_BOUNDARY_ACTIONS_LIST, userMustReviewGates } from '../../services/solo/user-touchpoint-classifier.js';
+import { aiAutoDecidesGates, classifyGate, COMMIT_BOUNDARY_ACTIONS_LIST, userMustReviewGates } from '../../services/code/user-touchpoint-classifier.js';
 import { fail, ok } from '../../shared/result.js';
 import { addJsonOption, printResult } from '../cli-helpers.js';
 export function registerUserTouchpointCommands(program, io) {
     // G4 commands are registered as TOP-LEVEL commands (not sub-commands
-    // of `peaks solo`) because `peaks solo` is a SKILL (consumed by the
+    // of `peaks code`) because `peaks code` is a SKILL (consumed by the
     // LLM in SKILL.md), not a CLI command. Top-level names: gate-classify /
     // user-touchpoints / commit-boundary-actions.
     //
-    // We do NOT create a new `peaks solo` CLI command here because that
+    // We do NOT create a new `peaks code` CLI command here because that
     // would conflict with the peaks-code skill presence tracking (see
     // `src/services/skills/skill-presence-service.ts`).
     addJsonOption(program
         .command('gate-classify')
-        .description('v2.15.0 follow-up G4: classify a single Solo gate by its decision kind: ' +
+        .description('v2.15.0 follow-up G4: classify a single Code gate by its decision kind: ' +
         'business / tech / mode-selection / commit-boundary / commit-floor. ' +
         'Returns null when the step is unknown.')
         .requiredOption('--step <step-id>', 'step id (e.g. step-1-mode-select, phase-2-prd-confirm)')).action((opts) => {
         const c = classifyGate(opts.step);
         if (c === null) {
-            printResult(io, fail('solo.gate-classify', 'UNKNOWN_STEP', `unknown step "${opts.step}"`, {}, [
-                'Run `peaks solo user-touchpoints` to list all known steps.'
+            printResult(io, fail('code.gate-classify', 'UNKNOWN_STEP', `unknown step "${opts.step}"`, {}, [
+                'Run `peaks code user-touchpoints` to list all known steps.'
             ]), opts.json ?? false);
             process.exitCode = 1;
             return;
         }
-        printResult(io, ok('solo.gate-classify', { classification: c }, [], [
+        printResult(io, ok('code.gate-classify', { classification: c }, [], [
             c.userShouldReview === 'always'
                 ? 'User must review this gate in all modes.'
                 : c.userShouldReview === 'business-only'
@@ -49,12 +49,12 @@ export function registerUserTouchpointCommands(program, io) {
     });
     addJsonOption(program
         .command('user-touchpoints')
-        .description('List all Solo gates the user must review. The 12 Gaps positioning ' +
+        .description('List all Code gates the user must review. The 12 Gaps positioning ' +
         'memory: user 在循环里 = 业务/产品审阅者,不参与技术决策。 ' +
         'These are the only gates where the user is asked to decide.')).action((opts) => {
         const must = userMustReviewGates();
         const auto = aiAutoDecidesGates();
-        printResult(io, ok('solo.user-touchpoints', {
+        printResult(io, ok('code.user-touchpoints', {
             userMustReview: must,
             aiAutoDecides: auto,
             counts: {
@@ -71,7 +71,7 @@ export function registerUserTouchpointCommands(program, io) {
         .description('List the 5 commit-boundary hard-floor actions. These are the ' +
         'actions that PAUSE even in full-auto (v2.15.0 slice 002 AC-4 rule: ' +
         '"full-auto 只做到 commit"). The user is always asked to confirm.')).action((opts) => {
-        printResult(io, ok('solo.commit-boundary-actions', { actions: COMMIT_BOUNDARY_ACTIONS_LIST }, [], [
+        printResult(io, ok('code.commit-boundary-actions', { actions: COMMIT_BOUNDARY_ACTIONS_LIST }, [], [
             'Even in full-auto, the user must explicitly confirm these actions.'
         ]), opts.json ?? false);
     });