peaks-loop 3.1.2 → 4.0.0-beta

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

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

package/dist/src/services/audit/enforcers/solo-code-ban.d.ts

@@ -2,7 +2,7 @@
  * Solo-code-ban enforcer — PreToolUse Bash guard.
  *
  * Per L2 redesign §5.4. Deny `git commit` or `git apply` invocations from
- * a peaks-* skill. The Solo Code-Change Red Line says peaks-solo / peaks-rd
+ * a peaks-* skill. The Solo Code-Change Red Line says peaks-code / peaks-rd
  * are orchestrators, not implementers; the actual `git commit` step must
  * go through `peaks request transition`, which itself enforces spec-locked
  * + tech-doc-presence.

package/dist/src/services/audit/enforcers/solo-code-ban.js

@@ -2,7 +2,7 @@
  * Solo-code-ban enforcer — PreToolUse Bash guard.
  *
  * Per L2 redesign §5.4. Deny `git commit` or `git apply` invocations from
- * a peaks-* skill. The Solo Code-Change Red Line says peaks-solo / peaks-rd
+ * a peaks-* skill. The Solo Code-Change Red Line says peaks-code / peaks-rd
  * are orchestrators, not implementers; the actual `git commit` step must
  * go through `peaks request transition`, which itself enforces spec-locked
  * + tech-doc-presence.
@@ -12,7 +12,7 @@
  * never bricked by a peaks bug.
  */
 const COMMIT_APPLY_PATTERN = /^\s*git\s+(commit|apply)\b/;
-const DENY_REASON = 'Solo Code-Change Red Line: peaks-* skills must go through peaks-solo / peaks-rd. ' +
+const DENY_REASON = 'Solo Code-Change Red Line: peaks-* skills must go through peaks-code / peaks-rd. ' +
     'Use `peaks request transition` instead of `git commit` / `git apply` directly.';
 export function isSoloCodeCommit(skill, command) {
     if (!skill.startsWith('peaks-'))

package/dist/src/services/audit/red-line-catalog.js

@@ -13,7 +13,7 @@ export const RED_LINE_CATALOG = [
         rule: 'Solo Code-Change Red Line',
         markers: ['BLOCKING', 'MANDATORY'],
         phrases: [
-            'peaks-solo',
+            'peaks-code',
             'orchestrator, NOT an implementer',
             'solo',
         ],

package/dist/src/services/audit/scanners/skills-tree-scanner.js

@@ -39,6 +39,28 @@ export function scanSkillsTree(input) {
     for (const entry of entries) {
         if (!entry.isDirectory() || entry.name.startsWith('.'))
             continue;
+        // LLM-internal skills live under `skills/bee/<name>/` per spec 2026-07-05.
+        // Recurse one level into `bee/` to cover all 9 demoted role/audit skills.
+        if (entry.name === 'bee') {
+            let subEntries;
+            try {
+                subEntries = readdirSync(join(skillsRoot, 'bee'), { withFileTypes: true });
+            }
+            catch (error) {
+                warnings.push({
+                    file: 'skills/bee',
+                    message: `readdir failed: ${error instanceof Error ? error.message : String(error)}`,
+                });
+                continue;
+            }
+            for (const subEntry of subEntries) {
+                if (!subEntry.isDirectory() || subEntry.name.startsWith('.'))
+                    continue;
+                const skillMd = readSkillFile(input.projectRoot, join('bee', subEntry.name), 'SKILL.md');
+                lines.push(...skillMd);
+            }
+            continue;
+        }
         const skillMd = readSkillFile(input.projectRoot, entry.name, 'SKILL.md');
         lines.push(...skillMd);
     }

package/dist/src/services/context/auto-compact-dispatcher.d.ts

@@ -9,7 +9,7 @@ export interface DispatchIdeCompactInput {
     /**
      * Slice 2026-06-28-solo-mode-bypass-fix (defect #4): which session
      * the compact should target. Default `'main'` — the orchestrator
-     * (peaks-solo body) runs in the main-session Claude Code window and
+     * (peaks-code body) runs in the main-session Claude Code window and
      * wants to compress *its* context, not a sub-agent's. Sub-agent
      * shells that spawn their own `peaks solo auto-compact` flow pass
      * `'sub-agent'` to preserve the legacy shell-spawn behaviour.

package/dist/src/services/dispatch/batch-counter.js

@@ -3,7 +3,7 @@
  *
  * Empirical upper bound for one Dispatcher × one batch: 6 sub-agents.
  * Above 6, the LLM / human is encouraged to split into multiple
- * batches with an explicit reducer step in between. peaks-solo's
+ * batches with an explicit reducer step in between. peaks-code's
  * swarm phase dispatches 3; peaks-rd's 4-way fan-out dispatches 4;
  * peaks-qa's 3-way fan-out dispatches 3. The 6 limit leaves headroom
  * for "qa-business-api" / "qa-business-frontend" / "qa-business-regression"

package/dist/src/services/dispatch/leak-detector.js

@@ -1,7 +1,7 @@
 /**
  * Slice #009 / G5 RL-7 — dispatch record leak detector.
  *
- * After peaks-solo's reducer consumes a batch, any dispatch record that
+ * After peaks-code's reducer consumes a batch, any dispatch record that
  * is still `disposed === false` AND was created more than `thresholdMs`
  * ago is a **leak**. This helper scans the on-disk records under
  * `.peaks/_sub_agents/<sid>/` and returns the leaked ones. The CLI or

package/dist/src/services/doctor/doctor-service.js

@@ -538,7 +538,7 @@ export async function runDoctor(options = {}) {
             }
         }
     }
-    // Workspace guard: an active workflow presence (peaks-solo) with no workspace
+    // Workspace guard: an active workflow presence (peaks-code) with no workspace
     // session means the skill was anchored but `peaks workspace init` never ran —
     // the #1 reported failure where .peaks/ artifacts are never created. This
     // turns the SKILL.md "MUST create the workspace" prose into an executable check.
@@ -554,7 +554,7 @@ export async function runDoctor(options = {}) {
         checks.push({
             id: 'skill-presence:workspace',
             ok: false,
-            message: `Skill ${presence.skill} is active but no workspace session exists (.peaks/_runtime/session.json missing); run \`peaks workspace init --project <repo>\` — peaks-solo Step 0 must anchor the workspace before any work`
+            message: `Skill ${presence.skill} is active but no workspace session exists (.peaks/_runtime/session.json missing); run \`peaks workspace init --project <repo>\` — peaks-code Step 0 must anchor the workspace before any work`
         });
     }
     else {

package/dist/src/services/job/job-resource-snapshot.js

@@ -26,10 +26,37 @@ export function collectResourceSnapshot(jobDir) {
         contextRatio,
     };
 }
-function dirSizeMb(dir) {
+// Non-enumerable internal attachment for test-time access via
+// `collectResourceSnapshot.dirSizeMb`. NOT a public export — keeps
+// the prod module surface clean per PRD while still allowing
+// targeted AC-1/AC-2/AC-3 unit tests to drive `dirSizeMb` directly.
+Object.defineProperty(collectResourceSnapshot, 'dirSizeMb', {
+    value: dirSizeMb,
+    enumerable: false,
+    writable: false,
+    configurable: false,
+});
+/**
+ * Best-effort, non-recursive size of one directory level, in rounded megabytes.
+ *
+ * - Missing directory → 0.
+ * - Per-entry stat failures (race with deletion, EBUSY on Windows) → silently skipped.
+ * - When `opts.maxEntries` > 0 and the directory has more entries than the cap,
+ *   the returned value is a partial sum (a lower bound), and no further `stat`
+ *   calls are issued past the cap. Callers must treat the value as a lower bound.
+ * - `opts.maxEntries` defaults to 0 (unbounded, legacy behaviour).
+ *
+ * NOTE: when maxEntries > 0 and the directory contains more entries than the
+ * cap, this is a partial sum. Callers must treat the value as a lower bound.
+ */
+function dirSizeMb(dir, opts) {
+    const cap = opts?.maxEntries ?? 0;
     let total = 0;
+    let index = 0;
     try {
         for (const name of readdirSync(dir)) {
+            if (cap > 0 && index >= cap)
+                break;
             try {
                 total += statSync(join(dir, name)).size;
             }
@@ -37,6 +64,7 @@ function dirSizeMb(dir) {
                 // best-effort: missing entries (race with deletion) are silently skipped
                 void e;
             }
+            index++;
         }
     }
     catch (e) {

package/dist/src/services/memory/project-memory-service.js

@@ -600,7 +600,7 @@ export function executeProjectMemoryExtract(options) {
         const safeMemoryDir = assertSafeProjectMemoryDir(plan.projectRoot);
         // Idempotency: skip writes for memories whose slug already lives in
         // .peaks/memory/. Re-running `peaks memory extract --apply` on the
-        // same handoff is a normal peaks-solo / peaks-txt retry pattern (the
+        // same handoff is a normal peaks-code / peaks-txt retry pattern (the
         // skill prompt may invoke extract more than once when a handoff is
         // edited and re-extracted). Without this, writeNewFile's O_EXCL
         // throws EEXIST and aborts the whole batch. Symmetric with

package/dist/src/services/migrate-skill-name/migrate.d.ts

@@ -0,0 +1,17 @@
+import type { MigrateResult } from './schema.js';
+export interface MigrateOpts {
+    projectRoot: string;
+    from: string;
+    to: string;
+    /** false = dry-run (default); true = write through. */
+    apply: boolean;
+}
+/** True iff `absPath` falls under any skip-path (substring match). */
+export declare function shouldSkip(projectRoot: string, absPath: string): boolean;
+/**
+ * Recursively walk a directory and return every `.json` / `.md`
+ * path. Missing root → empty list (the CLI reports scannedFiles:0,
+ * which is the truthful "nothing to look at" signal).
+ */
+export declare function walkRuntimeFiles(root: string): string[];
+export declare function migrateSkillName(opts: MigrateOpts): MigrateResult;

package/dist/src/services/migrate-skill-name/migrate.js

@@ -0,0 +1,152 @@
+/**
+ * `peaks session migrate-skill-name` core service (slice 2 of the
+ * peaks-code → peaks-code rename plan).
+ *
+ * Walks `.peaks/_runtime/**` and rewrites two patterns:
+ *   1. Key-value:   `"skill": "<old>"`  →  `"skill": "<new>"`
+ *   2. Slash-trig:  `/<old>`            →  `/<new>`
+ *
+ * Files under known skip-paths (`.peaks/memory/**`,
+ * `.peaks/skills/.system/bees/<old>/manifest.json`) are recorded in
+ * `skipped` but never opened. The operation is idempotent: re-running
+ * with the same `--from` on a tree already migrated reports 0
+ * modifications.
+ *
+ * Dry-run (`apply: false`) counts what WOULD change without writing;
+ * apply (`apply: true`) validates each `.json` payload with
+ * `JSON.parse` before writing so a broken mid-edit never lands on
+ * disk. Errors are pushed into `result.errors` (never swallowed).
+ */
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+/**
+ * Skip-paths are matched against the path relative to `projectRoot`,
+ * forward-slashed (Windows-friendly). Each entry is a SUBSTRING —
+ * the brief pins two specific exclusions: the memory dir, and the
+ * .system bee manifest for the old skill (which the renamer must
+ * leave alone until the bee itself is moved in a later slice).
+ */
+const SKIP_DIRS = ['.peaks/memory', '.peaks/skills/.system/bees'];
+const TARGET_ROOT = '.peaks/_runtime';
+const KEY_VALUE_PATTERN = (from, to) => new RegExp(`"skill"\\s*:\\s*"${escapeRe(from)}"`, 'g');
+const STRING_PATTERN = (from, to) => new RegExp(`/${escapeRe(from)}`, 'g');
+/**
+ * Escape regex metachars so an aggressive `--from` value (e.g.
+ * `peaks.code`) doesn't blow up the regex compiler. The two regexes
+ * above use `from` inside both body and character-class territory,
+ * so escaping is the safe path regardless of input.
+ */
+function escapeRe(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** True iff `absPath` falls under any skip-path (substring match). */
+export function shouldSkip(projectRoot, absPath) {
+    const rel = relative(projectRoot, absPath).replace(/\\/g, '/');
+    return SKIP_DIRS.some((skip) => rel.includes(skip));
+}
+/**
+ * Recursively walk a directory and return every `.json` / `.md`
+ * path. Missing root → empty list (the CLI reports scannedFiles:0,
+ * which is the truthful "nothing to look at" signal).
+ */
+export function walkRuntimeFiles(root) {
+    const out = [];
+    if (!existsSync(root))
+        return out;
+    const visit = (dir) => {
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                visit(full);
+            }
+            else if (entry.endsWith('.json') || entry.endsWith('.md')) {
+                out.push(full);
+            }
+        }
+    };
+    visit(root);
+    return out;
+}
+export function migrateSkillName(opts) {
+    const runtimeRoot = join(opts.projectRoot, TARGET_ROOT);
+    const files = walkRuntimeFiles(runtimeRoot);
+    const result = {
+        ok: true,
+        scannedFiles: files.length,
+        modifiedFiles: 0,
+        keyValueReplacements: 0,
+        stringReplacements: 0,
+        skipped: [...SKIP_DIRS],
+        errors: [],
+    };
+    for (const file of files) {
+        if (shouldSkip(opts.projectRoot, file))
+            continue;
+        let original;
+        try {
+            original = readFileSync(file, 'utf-8');
+        }
+        catch (e) {
+            // Unreadable file: surface the error and keep going (other
+            // files may be fine). `ok` flips to false; reporting stops
+            // hiding the failure from the operator.
+            result.errors.push(`${file}: read failed: ${e.message}`);
+            result.ok = false;
+            continue;
+        }
+        // Pin the broken-JSON test: any .json runtime file that fails
+        // to parse MUST be surfaced as an error, EVEN when it does not
+        // contain the from-name (the operator still needs to know the
+        // file is unparseable so they can fix it before re-running).
+        // Per Karpathy §4 honesty, silent skip is the worst kind of
+        // fake-green.
+        if (file.endsWith('.json')) {
+            try {
+                JSON.parse(original);
+            }
+            catch (e) {
+                result.errors.push(`${file}: invalid JSON: ${e.message}`);
+                result.ok = false;
+                continue;
+            }
+        }
+        let mutated = original;
+        const kvPattern = KEY_VALUE_PATTERN(opts.from, opts.to);
+        const kvMatches = mutated.match(kvPattern);
+        if (kvMatches) {
+            mutated = mutated.replace(kvPattern, `"skill": "${opts.to}"`);
+            result.keyValueReplacements += kvMatches.length;
+        }
+        const strPattern = STRING_PATTERN(opts.from, opts.to);
+        const strMatches = mutated.match(strPattern);
+        if (strMatches) {
+            mutated = mutated.replace(strPattern, `/${opts.to}`);
+            result.stringReplacements += strMatches.length;
+        }
+        if (mutated === original)
+            continue;
+        if (opts.apply) {
+            try {
+                if (file.endsWith('.json')) {
+                    // Validate the post-edit JSON before touching the disk —
+                    // catches accidents (e.g., stray quotes in the renamed
+                    // from/to values) without leaving a corrupted runtime file
+                    // behind.
+                    JSON.parse(mutated);
+                }
+                writeFileSync(file, mutated, 'utf-8');
+                result.modifiedFiles += 1;
+            }
+            catch (e) {
+                result.errors.push(`${file}: ${e.message}`);
+                result.ok = false;
+            }
+        }
+        // Dry-run path intentionally does not bump `modifiedFiles` —
+        // pin: `expect(result.modifiedFiles).toBe(0)` in the dry-run
+        // test. The would-be count lives implicitly in the *Replacement
+        // counters, which both dry-run and apply share.
+    }
+    return result;
+}

package/dist/src/services/migrate-skill-name/schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+/**
+ * Result shape for `peaks session migrate-skill-name`.
+ *
+ * Counters:
+ *   - `scannedFiles` — every .json / .md under `.peaks/_runtime/**` (excluding
+ *     skip dirs below).
+ *   - `modifiedFiles` — files whose contents would change (dry-run reports
+ *     the predicted count; --apply reports the actually-written count).
+ *   - `keyValueReplacements` — `"skill": "<old>"` → `"skill": "<new>"`.
+ *   - `stringReplacements` — `/<old>` → `/<new>` slash-trigger mentions.
+ *
+ * Errors are surfaced per-file with `errors: [ "<absPath>: <message>", … ]`;
+ * the tool never silently skips a broken JSON file (Karpathy §4 honesty:
+ * silence on bad data is the worst kind of fake-green).
+ */
+export declare const MigrateResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    scannedFiles: z.ZodNumber;
+    modifiedFiles: z.ZodNumber;
+    keyValueReplacements: z.ZodNumber;
+    stringReplacements: z.ZodNumber;
+    skipped: z.ZodArray<z.ZodString, "many">;
+    errors: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    skipped: string[];
+    scannedFiles: number;
+    modifiedFiles: number;
+    keyValueReplacements: number;
+    stringReplacements: number;
+    errors: string[];
+}, {
+    ok: boolean;
+    skipped: string[];
+    scannedFiles: number;
+    modifiedFiles: number;
+    keyValueReplacements: number;
+    stringReplacements: number;
+    errors: string[];
+}>;
+export type MigrateResult = z.infer<typeof MigrateResultSchema>;

package/dist/src/services/migrate-skill-name/schema.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/**
+ * Result shape for `peaks session migrate-skill-name`.
+ *
+ * Counters:
+ *   - `scannedFiles` — every .json / .md under `.peaks/_runtime/**` (excluding
+ *     skip dirs below).
+ *   - `modifiedFiles` — files whose contents would change (dry-run reports
+ *     the predicted count; --apply reports the actually-written count).
+ *   - `keyValueReplacements` — `"skill": "<old>"` → `"skill": "<new>"`.
+ *   - `stringReplacements` — `/<old>` → `/<new>` slash-trigger mentions.
+ *
+ * Errors are surfaced per-file with `errors: [ "<absPath>: <message>", … ]`;
+ * the tool never silently skips a broken JSON file (Karpathy §4 honesty:
+ * silence on bad data is the worst kind of fake-green).
+ */
+export const MigrateResultSchema = z.object({
+    ok: z.boolean(),
+    scannedFiles: z.number().int().nonnegative(),
+    modifiedFiles: z.number().int().nonnegative(),
+    keyValueReplacements: z.number().int().nonnegative(),
+    stringReplacements: z.number().int().nonnegative(),
+    skipped: z.array(z.string()),
+    errors: z.array(z.string()),
+});

package/dist/src/services/observability/aggregation.d.ts

@@ -51,7 +51,7 @@ export type RepairCycleReport = {
         cycleCount: number;
     }>;
 };
-/** RD/QA repair-loop cap (matches the peaks-solo repair-loop contract). */
+/** RD/QA repair-loop cap (matches the peaks-code repair-loop contract). */
 export declare const REPAIR_CYCLE_CAP = 3;
 export declare function aggregateStatus(events: readonly ObservabilityEvent[]): StatusAggregate;
 export declare function aggregateSlices(events: readonly ObservabilityEvent[]): SliceRollup[];

package/dist/src/services/observability/aggregation.js

@@ -28,7 +28,7 @@ const TERMINAL_HAPPY_STATES = new Set([
     'boundary-recorded'
 ]);
 const TERMINAL_FAIL_STATES = new Set(['blocked']);
-/** RD/QA repair-loop cap (matches the peaks-solo repair-loop contract). */
+/** RD/QA repair-loop cap (matches the peaks-code repair-loop contract). */
 export const REPAIR_CYCLE_CAP = 3;
 // v2.12.0 fan-out collapse: see OBSERVABILITY_SUBAGENT_ROLES for the
 // rationale on why `security-reviewer` was dropped and `peaks-security-audit`

package/dist/src/services/perf/perf-baseline-service.d.ts

@@ -1,7 +1,7 @@
 /**
  * Performance baseline scaffolding for the RD stage.
  *
- * peaks-solo's RD stage runs before the QA stage. The user-facing pain is
+ * peaks-code's RD stage runs before the QA stage. The user-facing pain is
  * that performance tests (lighthouse / k6 / project-local benches / etc.)
  * have historically only been run at QA Gate A4 — too late in the loop,
  * because a slow regression discovered at QA triggers a return-to-rd

package/dist/src/services/perf/perf-baseline-service.js

@@ -1,7 +1,7 @@
 /**
  * Performance baseline scaffolding for the RD stage.
  *
- * peaks-solo's RD stage runs before the QA stage. The user-facing pain is
+ * peaks-code's RD stage runs before the QA stage. The user-facing pain is
  * that performance tests (lighthouse / k6 / project-local benches / etc.)
  * have historically only been run at QA Gate A4 — too late in the loop,
  * because a slow regression discovered at QA triggers a return-to-rd

package/dist/src/services/prd/handoff-types.d.ts

@@ -4,7 +4,7 @@
  * The handoff is the **immutable** single source of truth that all
  * downstream consumers (peaks-rd main loop + 4 audit sub-agents +
  * peaks-qa) read. It is written by peaks-prd AFTER user confirmation
- * (per `skills/peaks-prd/SKILL.md` Step 5.5) and replaces the legacy
+ * (per `skills/bee/peaks-prd/SKILL.md` Step 5.5) and replaces the legacy
  * peaks-rd tech-doc handoff (v2.10.0 and earlier).
  *
  * Frontmatter invariant: `handoffHash` MUST equal the lowercase hex

package/dist/src/services/prd/handoff-types.js

@@ -4,7 +4,7 @@
  * The handoff is the **immutable** single source of truth that all
  * downstream consumers (peaks-rd main loop + 4 audit sub-agents +
  * peaks-qa) read. It is written by peaks-prd AFTER user confirmation
- * (per `skills/peaks-prd/SKILL.md` Step 5.5) and replaces the legacy
+ * (per `skills/bee/peaks-prd/SKILL.md` Step 5.5) and replaces the legacy
  * peaks-rd tech-doc handoff (v2.10.0 and earlier).
  *
  * Frontmatter invariant: `handoffHash` MUST equal the lowercase hex

package/dist/src/services/progress/progress-service.d.ts

@@ -1,5 +1,5 @@
 /**
- * Sub-agent progress file for the RD/QA sub-agents in `peaks-solo`'s
+ * Sub-agent progress file for the RD/QA sub-agents in `peaks-code`'s
  * Swarm phase. A sub-agent (or the LLM via the `peaks progress step`
  * CLI) writes a stable JSON file at
  * `.peaks/_sub_agents/<sid>/subagent-progress.json`. The dispatch +

package/dist/src/services/progress/progress-service.js

@@ -1,5 +1,5 @@
 /**
- * Sub-agent progress file for the RD/QA sub-agents in `peaks-solo`'s
+ * Sub-agent progress file for the RD/QA sub-agents in `peaks-code`'s
  * Swarm phase. A sub-agent (or the LLM via the `peaks progress step`
  * CLI) writes a stable JSON file at
  * `.peaks/_sub_agents/<sid>/subagent-progress.json`. The dispatch +

package/dist/src/services/rd/standards-diagnostic.js

@@ -2,7 +2,7 @@
  * Slice 2026-06-16-peaks-rd-no-gates — missing-project-standards diagnostic
  * + JSON gate list shape for the RD bootstrap path.
  *
- * Background: when `peaks-rd` (or `peaks-qa` / `peaks-solo`) starts in a
+ * Background: when `peaks-rd` (or `peaks-qa` / `peaks-code`) starts in a
  * project whose `.claude/rules/{common,typescript}/` is missing or empty,
  * the existing code-review / security / performance gates were silently
  * dropped. This module makes the missing-standards condition observable:

package/dist/src/services/recommendations/capability-seed-mappings.js

@@ -6,7 +6,7 @@ export const seedCapabilityLandingMappings = [
     mapping({ capabilityId: 'codegraph.impact-analysis', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-rd', skillName: 'peaks-rd', guidance: 'Dry-run reference only: peaks-rd may use peaks codegraph affected --project <path> <files...> --json to inspect likely impact before slice planning and red-line checks when execution is approved.' }),
     mapping({ capabilityId: 'codegraph.impact-analysis', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-qa', skillName: 'peaks-qa', guidance: 'Use affected output as regression-surface evidence only; QA validation and test evidence remain authoritative.' }),
     mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-rd', skillName: 'peaks-rd', guidance: 'Dry-run reference only: peaks-rd may use peaks codegraph context --project <path> <task> to gather local evidence for RD analysis when execution is approved, without replacing standards dry-runs.' }),
-    mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-solo', skillName: 'peaks-solo', guidance: 'Solo may attach local context packs or affected summaries before role handoff so RD, QA, and TXT share the same project evidence.' }),
+    mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-code', skillName: 'peaks-code', guidance: 'Solo may attach local context packs or affected summaries before role handoff so RD, QA, and TXT share the same project evidence.' }),
     mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-txt', skillName: 'peaks-txt', guidance: 'TXT may summarize recorded codegraph context packs into handoffs while treating them as supporting evidence only.' }),
     mapping({ capabilityId: 'playwright-mcp.browser-validation', sourceId: 'playwright-mcp', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-qa', skillName: 'peaks-qa', guidance: 'Use for browser and E2E validation after user-approved app targets are available.' }),
     mapping({ capabilityId: 'chrome-devtools-mcp.browser-debug', sourceId: 'chrome-devtools-mcp', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-ui', skillName: 'peaks-ui', guidance: 'Use for runtime UI, console, network, and performance inspection.' }),

package/dist/src/services/sc/sc-service.js

@@ -473,7 +473,7 @@ export function validateArtifactRetention(sliceId) {
     };
     if (!workspace) {
         // No workspace: validate against the resolved session dir directly
-        // (this is the common peaks-solo / peaks-rd invocation: the slice
+        // (this is the common peaks-code / peaks-rd invocation: the slice
         // lives under the project-root `.peaks/_runtime/<sessionId>/`, and the
         // workspace artifact path is irrelevant). When the resolution also
         // fails, fall back to the legacy "No workspace configured" failure

package/dist/src/services/sediment/dispose-confirm.d.ts

@@ -0,0 +1,9 @@
+import type { BeeManifest } from "./types.js";
+export type DisposePlan = {
+    decision: "destroy";
+    auto: true;
+} | {
+    decision: null;
+    requiresUserPrompt: true;
+};
+export declare function planDispose(m: BeeManifest): DisposePlan;

package/dist/src/services/sediment/dispose-confirm.js

@@ -0,0 +1,5 @@
+export function planDispose(m) {
+    if (m.source === "system")
+        return { decision: "destroy", auto: true };
+    return { decision: null, requiresUserPrompt: true };
+}