peaks-loop 3.1.2 → 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
@@ -109,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')
@@ -238,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;
             }
@@ -306,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;
             }
@@ -520,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;
             }
@@ -582,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;
             }

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

package/dist/src/cli/commands/workspace/init-command.js

@@ -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
@@ -44,7 +44,7 @@ export function registerWorkspaceInitCommand(workspace, io) {
         return value;
     })
         .option('--no-claude-hooks', 'do NOT materialize .claude/settings.local.json (slice 2.0.1-bug3 fact-forcing bypass). Default: hooks installed so tool calls inside .peaks/** are not blocked by the [Fact-Forcing Gate].')
-        .option('--init-standards', 'slice 2026-06-16-peaks-solo-auto-scaffold: when the consumer project\'s .claude/rules/ is missing or empty, auto-apply `peaks standards init --project <path> --apply` after emitting the diagnostic. Default: diagnostic only (no write).')).action(async (options) => {
+        .option('--init-standards', 'slice 2026-06-16-peaks-code-auto-scaffold: when the consumer project\'s .claude/rules/ is missing or empty, auto-apply `peaks standards init --project <path> --apply` after emitting the diagnostic. Default: diagnostic only (no write).')).action(async (options) => {
         try {
             // Resolve the session id. Two paths:
             //   - explicit --session-id: use it as the requested binding target
@@ -110,7 +110,7 @@ export function registerWorkspaceInitCommand(workspace, io) {
                 // `false`, so the default is "install hooks" (the bypass is
                 // on). Pass `--no-claude-hooks` to opt out.
                 noClaudeHooks: options.claudeHooks === false,
-                // Slice 2026-06-16-peaks-solo-auto-scaffold (RD#7): opt-in
+                // Slice 2026-06-16-peaks-code-auto-scaffold (RD#7): opt-in
                 // auto-apply for the missing-standards scaffold. Default false
                 // — only the diagnostic is emitted. Pass --init-standards to
                 // also run `executeProjectStandardsInit({ apply: true })`.
@@ -129,7 +129,7 @@ export function registerWorkspaceInitCommand(workspace, io) {
                     `Re-run with --no-rotate-on-outer-mismatch to suppress this rotation.`);
                 // Slice 002 (v2.15.0) AC-1: a presence marker stamped by the
                 // OLD outer session is now stale (defect A from the PRD).
-                // peaks-solo Step 1 would otherwise pick up the old `mode`
+                // peaks-code Step 1 would otherwise pick up the old `mode`
                 // field and silently lock the new session into a mode the
                 // user never explicitly chose. Clear it here so Step 1's
                 // presence:check-stale reports `reason: 'no-presence'` and
@@ -142,7 +142,7 @@ export function registerWorkspaceInitCommand(workspace, io) {
                 });
                 if (presenceClearOutcome.cleared) {
                     nextActions.push(`Auto-cleared stale skill presence (recorded outer id "${presenceClearOutcome.recordedOuter ?? '?'}" did not match the new outer session). ` +
-                        'peaks-solo Step 1 will now AskUserQuestion to confirm the mode.');
+                        'peaks-code Step 1 will now AskUserQuestion to confirm the mode.');
                 }
                 else if (presenceClearOutcome.reason === 'recorded-by-different-outer') {
                     nextActions.push(`Kept skill presence: it was recorded by a different live outer session (id "${presenceClearOutcome.recordedOuter ?? '?'}"). ` +
@@ -227,7 +227,7 @@ export function registerWorkspaceInitCommand(workspace, io) {
             else if (hooksOutcome.action === 'first-decision' && hooksOutcome.decision === 'skipped') {
                 nextActions.push('Skipped peaks-managed hook install for this project. Re-run with --install-hooks=auto (or peaks hooks install) to install later.');
             }
-            // Slice 2026-06-16-peaks-solo-auto-scaffold (RD#7):
+            // Slice 2026-06-16-peaks-code-auto-scaffold (RD#7):
             //   - When the consumer project's `.claude/rules/` is missing or
             //     empty, emit the copy-pasteable diagnostic to stderr (via
             //     the JSON envelope `warnings` array) AND surface the
@@ -246,7 +246,7 @@ export function registerWorkspaceInitCommand(workspace, io) {
                 nextActions.push(`Run \`peaks workspace init --init-standards --project ${projectRoot}\` to auto-apply the scaffold, or \`peaks standards init --project ${projectRoot} --apply\` manually.`);
             }
             if (report.standardsApplied !== undefined) {
-                nextActions.push(`Auto-applied .claude/rules/${report.standardsApplied.language}/ scaffold (slice 2026-06-16-peaks-solo-auto-scaffold): ` +
+                nextActions.push(`Auto-applied .claude/rules/${report.standardsApplied.language}/ scaffold (slice 2026-06-16-peaks-code-auto-scaffold): ` +
                     `wrote ${report.standardsApplied.writtenFiles.length} file(s), ` +
                     `kept ${report.standardsApplied.skippedFiles.length} existing file(s).`);
             }

package/dist/src/cli/program.js

@@ -1,7 +1,7 @@
 import { readdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { Command } from 'commander';
-import { skillsDir } from '../shared/paths.js';
+import { skillsDir, repoRoot } from '../shared/paths.js';
 import { CLI_VERSION } from '../shared/version.js';
 import { registerCoreAndArtifactCommands } from './commands/core-artifact-commands.js';
 import { registerWorkflowCommands } from './commands/workflow-commands.js';
@@ -76,6 +76,12 @@ import { registerObservabilityCommands } from './commands/observability-commands
 import { registerCompactCommands } from './commands/compact-command.js';
 // Slice 2026-07-01-job-m3.1: `peaks job init|status|...` — Job orchestration CLI surface.
 import { registerJobCommands } from './commands/job-commands.js';
+// Slice 2026-07-04-cli-15a: `peaks skill sediment <verb>` + `peaks skill adapter <verb>`
+// — Task 15a 4-verb subset (add-segment / add-bee / list / rebuild-index).
+// 15b / 15c / 15d will extend sediment-commands.ts with the remaining 14 verbs.
+import { registerSedimentCommands } from './commands/sediment-commands.js';
+import { registerAdapterCommands } from './commands/adapter-commands.js';
+import { registerSkillVisibilityCommand } from './commands/skill-visibility.js';
 import { applyRetention } from '../services/log/retention.js';
 import { writeLogEntry, maybeWriteStderr } from '../services/log/logger.js';
 export { printResult } from './cli-helpers.js';
@@ -315,7 +321,7 @@ Run peaks (no arguments) for a quickstart. You likely want one of:
     // Slice 2026-06-17-2.5.0-sub-fix-C: `peaks playwright start|ls|stop`
     // (multi-terminal Playwright MCP lifecycle).
     registerPlaywrightCommands(program, io);
-    // Slice 2 (peaks-solo fast mode): `peaks solo plan [--fast] <change-id>`
+    // Slice 2 (peaks-code fast mode): `peaks solo plan [--fast] <change-id>`
     // v2.11.0 Group F (D5 + D7): also registers `peaks solo should-pause` and
     // `peaks solo post-compact-detect` for runtime-friction probes.
     registerSoloCommands(program, io);
@@ -347,5 +353,16 @@ Run peaks (no arguments) for a quickstart. You likely want one of:
     // orchestration CLI surface. M3.1 wires init + status + 2 stubs;
     // the remaining 5 subcommands land in M3.2.
     registerJobCommands(program, io);
+    // Slice 2026-07-04-cli-15a: `peaks skill sediment <verb>` — Task 15a
+    // 4-verb subset. Dispatches to runSediment; remaining verbs land in 15b/15c/15d.
+    registerSedimentCommands(program, io);
+    // Slice 2026-07-04-cli-15a: `peaks skill adapter <verb>` — adapter list / set-active.
+    registerAdapterCommands(program, io);
+    // Slice 2026-07-05-peaks-code-to-peaks-code (Task 1): `peaks skill:visibility --list --json`
+    // — read .claude-plugin/marketplace.json and report each skill's
+    // visibility (public vs internal). Used to surface which skills are
+    // user-invocable vs LLM-only internal role skills. See
+    // src/cli/commands/skill-visibility.ts.
+    registerSkillVisibilityCommand(program, repoRoot);
     return program;
 }

package/dist/src/services/adapter/adapter.d.ts

@@ -0,0 +1,27 @@
+export interface AdapterSegment {
+    name: string;
+    skillMd: string;
+    scripts: {
+        name: string;
+        content: string;
+    }[];
+}
+export interface AdapterEnvelope {
+    preamble: string;
+    refs: {
+        path: string;
+        kind: "file" | "dir" | "script";
+    }[];
+}
+export interface Adapter {
+    readonly name: "claude" | "codex" | "copilot" | "auto";
+    resolveScratchDir(beeName: string): Promise<string>;
+    materialize(beeName: string, env: AdapterEnvelope, segments: AdapterSegment[]): Promise<string>;
+    publish(scratchDir: string): Promise<string>;
+    activate(scratchDir: string): Promise<void>;
+    cleanup(scratchDir: string): Promise<void>;
+    detect(): Promise<boolean>;
+}
+export declare class ADAPTER_NOT_IMPLEMENTED extends Error {
+    constructor(adapter: string, method: string);
+}

package/dist/src/services/adapter/adapter.js

@@ -0,0 +1,5 @@
+export class ADAPTER_NOT_IMPLEMENTED extends Error {
+    constructor(adapter, method) {
+        super(`ADAPTER_NOT_IMPLEMENTED: ${adapter}.${method} — stub until later slice`);
+    }
+}

package/dist/src/services/adapter/auto-adapter.d.ts

@@ -0,0 +1,11 @@
+import { Adapter } from "./adapter.js";
+type Detectable = Pick<Adapter, "name" | "detect">;
+export declare class AutoAdapter {
+    private readonly _o;
+    private readonly _adapters;
+    constructor(_o: {
+        home: string;
+    }, _adapters: Detectable[]);
+    detectAndPick(): Promise<Detectable>;
+}
+export {};

package/dist/src/services/adapter/auto-adapter.js

@@ -0,0 +1,15 @@
+export class AutoAdapter {
+    _o;
+    _adapters;
+    constructor(_o, _adapters) {
+        this._o = _o;
+        this._adapters = _adapters;
+    }
+    async detectAndPick() {
+        for (const a of this._adapters) {
+            if (await a.detect())
+                return a;
+        }
+        throw new Error("No adapter detected. Use `peaks skill adapter set-active <name>` to force one.");
+    }
+}

package/dist/src/services/adapter/claude-adapter.d.ts

@@ -0,0 +1,14 @@
+import { Adapter, AdapterEnvelope, AdapterSegment } from "./adapter.js";
+export declare class ClaudeAdapter implements Adapter {
+    private readonly opts;
+    readonly name: "claude";
+    constructor(opts: {
+        home: string;
+    });
+    detect(): Promise<boolean>;
+    resolveScratchDir(beeName: string): Promise<string>;
+    materialize(beeName: string, env: AdapterEnvelope, segments: AdapterSegment[]): Promise<string>;
+    publish(scratchDir: string): Promise<string>;
+    activate(_scratchDir: string): Promise<void>;
+    cleanup(scratchDir: string): Promise<void>;
+}

package/dist/src/services/adapter/claude-adapter.js

@@ -0,0 +1,40 @@
+import { writeFileSync, mkdirSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+export class ClaudeAdapter {
+    opts;
+    name = "claude";
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async detect() {
+        return true; /* Claude is the default; ship this slice first */
+    }
+    async resolveScratchDir(beeName) {
+        return join(this.opts.home, ".claude", "skills", `peaks-bee-${beeName}.peaks-generated`);
+    }
+    async materialize(beeName, env, segments) {
+        const dir = await this.resolveScratchDir(beeName);
+        if (existsSync(dir))
+            rmSync(dir, { recursive: true, force: true });
+        mkdirSync(dir, { recursive: true });
+        const frontmatter = `---\nname: peaks-bee-${beeName}\ndescription: peaks-loop generated bee ${beeName} — see local SkillHub for source\n---\n\n`;
+        const body = `${env.preamble}\n\n` + segments.map((s) => s.skillMd).join("\n\n");
+        writeFileSync(join(dir, "SKILL.md"), frontmatter + body);
+        mkdirSync(join(dir, "scripts"), { recursive: true });
+        for (const s of segments) {
+            for (const sc of s.scripts)
+                writeFileSync(join(dir, "scripts", sc.name), sc.content);
+        }
+        return dir;
+    }
+    async publish(scratchDir) {
+        return scratchDir;
+    }
+    async activate(_scratchDir) {
+        /* no-op; runtime picks up by convention */
+    }
+    async cleanup(scratchDir) {
+        if (existsSync(scratchDir))
+            rmSync(scratchDir, { recursive: true, force: true });
+    }
+}

package/dist/src/services/adapter/codex-adapter.d.ts

@@ -0,0 +1,14 @@
+import { Adapter } from "./adapter.js";
+export declare class CodexAdapter implements Pick<Adapter, "name"> {
+    private readonly _o;
+    readonly name: "codex";
+    constructor(_o: {
+        home: string;
+    });
+    detect(): Promise<boolean>;
+    resolveScratchDir(): Promise<void>;
+    materialize(): Promise<void>;
+    publish(): Promise<void>;
+    activate(): Promise<void>;
+    cleanup(): Promise<void>;
+}

package/dist/src/services/adapter/codex-adapter.js

@@ -0,0 +1,14 @@
+import { ADAPTER_NOT_IMPLEMENTED } from "./adapter.js";
+export class CodexAdapter {
+    _o;
+    name = "codex";
+    constructor(_o) {
+        this._o = _o;
+    }
+    async detect() { return false; }
+    async resolveScratchDir() { throw new ADAPTER_NOT_IMPLEMENTED("codex", "resolveScratchDir"); }
+    async materialize() { throw new ADAPTER_NOT_IMPLEMENTED("codex", "materialize"); }
+    async publish() { throw new ADAPTER_NOT_IMPLEMENTED("codex", "publish"); }
+    async activate() { throw new ADAPTER_NOT_IMPLEMENTED("codex", "activate"); }
+    async cleanup() { throw new ADAPTER_NOT_IMPLEMENTED("codex", "cleanup"); }
+}

package/dist/src/services/adapter/copilot-adapter.d.ts

@@ -0,0 +1,14 @@
+import { Adapter } from "./adapter.js";
+export declare class CopilotAdapter implements Pick<Adapter, "name"> {
+    private readonly _o;
+    readonly name: "copilot";
+    constructor(_o: {
+        home: string;
+    });
+    detect(): Promise<boolean>;
+    resolveScratchDir(): Promise<void>;
+    materialize(): Promise<void>;
+    publish(): Promise<void>;
+    activate(): Promise<void>;
+    cleanup(): Promise<void>;
+}