peaks-loop 3.1.1 → 4.0.0-beta

package/dist/src/services/skillhub/release-retain.js

@@ -0,0 +1,89 @@
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join, relative } from "node:path";
+/** Compute the sha256 hash and byte length of a single file. */
+export function sha256OfFile(p) {
+    const buf = readFileSync(p);
+    return { sha: createHash("sha256").update(buf).digest("hex"), bytes: buf.length };
+}
+/** Copy a file into the content-addressed blob store under `blobsDir/<aa>/<sha>`
+ *  if not already present, and return the relative blob_path used by `bee_file`. */
+export function ensureBlob(blobsDir, sha, srcPath) {
+    const dir = join(blobsDir, sha.slice(0, 2));
+    const dest = join(dir, sha);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    if (!existsSync(dest))
+        writeFileSync(dest, readFileSync(srcPath));
+    return `blobs/${sha.slice(0, 2)}/${sha}`;
+}
+export function* walk(root, base = root) {
+    for (const ent of readdirSync(base, { withFileTypes: true })) {
+        const abs = join(base, ent.name);
+        if (ent.isDirectory())
+            yield* walk(root, abs);
+        else {
+            const relPosix = relative(root, abs).split(/[\\/]/).join("/");
+            yield { abs, rel: relPosix };
+        }
+    }
+}
+function warnOverflow(column, length) {
+    // Soft warning, no truncation: the spec does not mandate truncation,
+    // but a stale over-16KB row would silently break downstream readers
+    // that assume <16KB. Surface it for ops review.
+    // eslint-disable-next-line no-console
+    console.warn(`[release-retain] WARN: column ${column} overflowed 16KB guard (${length} bytes) — review and consider truncation`);
+}
+/**
+ * Defensive 16KB check: if the value would exceed SQLite's
+ * recommended 16KB single-column limit, log a warning. Not a hard
+ * error — we let SQLite handle overflow. The columns covered are the
+ * four TEXT columns previously unchecked: bee_manifest.segments_json,
+ * bee_segment_ref.inputs_json, bee_segment_ref.outputs_json,
+ * bee_segment_ref.side_effects.
+ */
+function checkOverflow({ table, col }, value) {
+    const len = Buffer.byteLength(value, "utf-8");
+    if (len > 16 * 1024)
+        warnOverflow(`${table}.${col}`, len);
+}
+export function retainRelease({ db, blobsDir, scratchDir, manifest, version: explicitVersion, parentVersion, changelog, }) {
+    const version = explicitVersion ?? "0.1.0";
+    const tx = db.transaction(() => {
+        const ins = db.prepare(`INSERT INTO bee_release (bee_name, version, source, archived_at, archived_by, user_intent_raw, description, parent_version, changelog) VALUES (?, ?, 'user', ?, ?, ?, ?, ?, ?)`);
+        const info = ins.run(manifest.name, version, new Date().toISOString(), "llm", null, manifest.description, parentVersion ?? null, changelog ?? null);
+        const id = info.lastInsertRowid;
+        db.prepare(`INSERT OR REPLACE INTO bee_release_pointer (bee_name, latest_version, released_at) VALUES (?, ?, ?)`).run(manifest.name, version, new Date().toISOString());
+        for (const s of manifest.segments) {
+            const inputsJson = JSON.stringify(s.inputs);
+            const outputsJson = JSON.stringify(s.outputs);
+            const sideEffectsStr = s.sideEffects.join(",");
+            checkOverflow({ table: "bee_segment_ref", col: "inputs_json" }, inputsJson);
+            checkOverflow({ table: "bee_segment_ref", col: "outputs_json" }, outputsJson);
+            checkOverflow({ table: "bee_segment_ref", col: "side_effects" }, sideEffectsStr);
+            db.prepare(`INSERT INTO bee_segment_ref (release_id, segment_name, inputs_json, outputs_json, side_effects) VALUES (?, ?, ?, ?, ?)`).run(id, s.name, inputsJson, outputsJson, sideEffectsStr);
+        }
+        // Also guard the manifest-level JSON column that holds the segment
+        // name list (can exceed 16KB if a bee advertises thousands of
+        // segments).
+        const segmentsJson = JSON.stringify(manifest.segments.map((s) => s.name));
+        checkOverflow({ table: "bee_manifest", col: "segments_json" }, segmentsJson);
+        db.prepare(`INSERT INTO bee_manifest (release_id, schema_version, description, segments_json, entrypoint_preamble, promotion, min_cycles, requires_human, requires_smoke, retire_on_misses) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, manifest.schemaVersion, manifest.description, segmentsJson, manifest.entrypoint.preamble, manifest.promotion_status, manifest.promotion.minCycles, manifest.promotion.requiresHumanApproval ? 1 : 0, manifest.promotion.requiresSmokeTest ? 1 : 0, manifest.promotion.retireOnMissesInRow ?? null);
+        const insFile = db.prepare(`INSERT INTO bee_file (release_id, owner_kind, owner_name, path, kind, size_bytes, sha256, blob_path) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+        for (const f of walk(scratchDir)) {
+            const { sha, bytes } = sha256OfFile(f.abs);
+            const blobPath = ensureBlob(blobsDir, sha, f.abs);
+            const kind = f.rel.endsWith(".md")
+                ? "markdown"
+                : f.rel.startsWith("scripts/")
+                    ? "script"
+                    : f.rel.startsWith("references/")
+                        ? "reference"
+                        : "other";
+            insFile.run(id, "bee", manifest.name, f.rel, kind, bytes, sha, blobPath);
+        }
+        return id;
+    });
+    return tx();
+}

package/dist/src/services/skillhub/sqlite-store.d.ts

@@ -0,0 +1,22 @@
+import Database from "better-sqlite3";
+/**
+ * Open (or create) a SkillHub state database at the given path.
+ *
+ * Behavior:
+ *   - Creates the parent directory if it does not exist.
+ *   - Enables WAL journal mode and foreign-key enforcement.
+ *   - Applies every `migrations/*.sql` file in lexicographic order.
+ *     Migrations must be idempotent (CREATE TABLE IF NOT EXISTS, etc.).
+ *
+ * The migrations directory lives next to this source file at build time;
+ * we resolve it via `import.meta.url` so the lookup survives vitest ESM
+ * (where `__dirname` is undefined). Migration files are discovered by
+ * globbing (`*.sql`) and sorted lexicographically so future
+ * `002-…`, `003-…` additions are picked up automatically.
+ */
+export declare function openStateDb(path: string): Database.Database;
+/**
+ * Return the user-defined table names present in `db` (excluding SQLite
+ * system tables such as `sqlite_sequence`).
+ */
+export declare function listTables(db: Database.Database): string[];

package/dist/src/services/skillhub/sqlite-store.js

@@ -0,0 +1,47 @@
+import Database from "better-sqlite3";
+import { readFileSync, readdirSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Open (or create) a SkillHub state database at the given path.
+ *
+ * Behavior:
+ *   - Creates the parent directory if it does not exist.
+ *   - Enables WAL journal mode and foreign-key enforcement.
+ *   - Applies every `migrations/*.sql` file in lexicographic order.
+ *     Migrations must be idempotent (CREATE TABLE IF NOT EXISTS, etc.).
+ *
+ * The migrations directory lives next to this source file at build time;
+ * we resolve it via `import.meta.url` so the lookup survives vitest ESM
+ * (where `__dirname` is undefined). Migration files are discovered by
+ * globbing (`*.sql`) and sorted lexicographically so future
+ * `002-…`, `003-…` additions are picked up automatically.
+ */
+export function openStateDb(path) {
+    const parent = dirname(path);
+    if (!existsSync(parent))
+        mkdirSync(parent, { recursive: true });
+    const db = new Database(path);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    const here = dirname(fileURLToPath(import.meta.url));
+    const migrationsDir = join(here, "migrations");
+    if (existsSync(migrationsDir)) {
+        const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
+        for (const f of files) {
+            const sql = readFileSync(join(migrationsDir, f), "utf-8");
+            db.exec(sql);
+        }
+    }
+    return db;
+}
+/**
+ * Return the user-defined table names present in `db` (excluding SQLite
+ * system tables such as `sqlite_sequence`).
+ */
+export function listTables(db) {
+    const rows = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+        .all();
+    return rows.map((r) => r.name);
+}

package/dist/src/services/skillhub/tar-runtime.d.ts

@@ -0,0 +1,21 @@
+/** Thrown when no usable tar binary can be located. */
+export declare class TAR_NOT_FOUND extends Error {
+    constructor(msg: string);
+}
+/**
+ * Run `tar <args...>` in a cross-platform way.
+ *
+ * Args MUST be `["-czf", outPath, "-C", stageDir, "."]` style (no
+ * shell quoting needed because we use execFileSync, not execSync).
+ *
+ * After the Critical #3 fix:
+ *   - Honors PEAKS_TAR_BIN / TAR env vars.
+ *   - On Windows, tries C:\Windows\System32\tar.exe first; falls back
+ *     to PATH lookup if it's missing.
+ *   - Accumulates tar's stderr and re-throws it on non-zero exit so
+ *     operators can see WHY tar failed (path typo, permission, corrupt
+ *     stage dir, etc.) instead of swallowing it.
+ *
+ * Throws `TAR_NOT_FOUND` when the binary cannot be located.
+ */
+export declare function runTar(args: string[]): void;

package/dist/src/services/skillhub/tar-runtime.js

@@ -0,0 +1,91 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+/** Thrown when no usable tar binary can be located. */
+export class TAR_NOT_FOUND extends Error {
+    constructor(msg) {
+        super(`TAR_NOT_FOUND: ${msg}`);
+        this.name = "TAR_NOT_FOUND";
+    }
+}
+/**
+ * Resolve a tar binary path, in priority order:
+ *   1. process.env.PEAKS_TAR_BIN  (explicit override; honored unconditionally)
+ *   2. process.env.TAR            (POSIX convention, honored if set)
+ *   3. On Windows: C:\Windows\System32\tar.exe (bsdtar — accepts
+ *      Windows-style paths verbatim, unlike git-bash GNU tar)
+ *   4. PATH lookup: "tar" (delegates to the platform default)
+ *
+ * Throws `TAR_NOT_FOUND` when none of the candidates exist (Windows
+ * file-system check) or no override is set (POSIX). On POSIX we
+ * always trust PATH; tar is in base images 99.9% of the time. On
+ * Windows we explicitly stat each candidate so a missing
+ * C:\Windows\System32\tar.exe falls through to PATH instead of
+ * throwing an opaque spawn-ENOENT.
+ */
+function resolveTarBin() {
+    const envOverride = process.env.PEAKS_TAR_BIN;
+    if (envOverride && envOverride.length > 0)
+        return envOverride;
+    const envTar = process.env.TAR;
+    if (envTar && envTar.length > 0)
+        return envTar;
+    if (process.platform === "win32") {
+        const systemTar = "C:\\Windows\\System32\\tar.exe";
+        if (existsSync(systemTar))
+            return systemTar;
+        // Fall through to PATH lookup below — many dev setups install tar
+        // under Git for Windows or WindowsApps rather than System32.
+    }
+    // PATH lookup. We can't stat `tar` directly (it's a name, not a path),
+    // so we trust the resolution to execFileSync and surface a clean
+    // TAR_NOT_FOUND error from the caller if it fails.
+    return "tar";
+}
+/**
+ * Run `tar <args...>` in a cross-platform way.
+ *
+ * Args MUST be `["-czf", outPath, "-C", stageDir, "."]` style (no
+ * shell quoting needed because we use execFileSync, not execSync).
+ *
+ * After the Critical #3 fix:
+ *   - Honors PEAKS_TAR_BIN / TAR env vars.
+ *   - On Windows, tries C:\Windows\System32\tar.exe first; falls back
+ *     to PATH lookup if it's missing.
+ *   - Accumulates tar's stderr and re-throws it on non-zero exit so
+ *     operators can see WHY tar failed (path typo, permission, corrupt
+ *     stage dir, etc.) instead of swallowing it.
+ *
+ * Throws `TAR_NOT_FOUND` when the binary cannot be located.
+ */
+export function runTar(args) {
+    const cmd = resolveTarBin();
+    try {
+        execFileSync(cmd, args, {
+            stdio: ["ignore", "ignore", "pipe"],
+            // Surface stderr text rather than dumping a Buffer at the caller.
+            // execFileSync with stdio: ["ignore","ignore","pipe"] captures the
+            // stderr stream into the Error's `.stderr` Buffer when the child
+            // exits non-zero.
+        });
+    }
+    catch (e) {
+        // Distinguish "binary not found" from "binary ran but failed".
+        if (e && typeof e === "object" && "code" in e) {
+            const code = e.code;
+            if (code === "ENOENT") {
+                throw new TAR_NOT_FOUND(`tar binary not found (cmd="${cmd}"). Set PEAKS_TAR_BIN to override, or install tar (Windows: bsdtar is bundled with Windows 10+).`);
+            }
+        }
+        // Non-zero exit from tar itself — re-throw with stderr text.
+        const stderr = e?.stderr;
+        const stderrText = stderr instanceof Buffer
+            ? stderr.toString("utf-8")
+            : typeof stderr === "string"
+                ? stderr
+                : "";
+        const baseMsg = e instanceof Error ? e.message : typeof e === "string" ? e : String(e);
+        const wrapped = new Error(`tar exited non-zero (cmd="${cmd}"): ${baseMsg}${stderrText ? `\ntar stderr:\n${stderrText.trimEnd()}` : ""}`);
+        wrapped.cause = e;
+        throw wrapped;
+    }
+}

package/dist/src/services/skillhub/types.d.ts

@@ -0,0 +1,105 @@
+export interface BeeReleaseRow {
+    id: number;
+    bee_name: string;
+    version: string;
+    source: "user";
+    archived_at: string;
+    archived_by: "user" | "llm";
+    user_intent_raw: string | null;
+    description: string | null;
+    parent_version: string | null;
+    changelog: string | null;
+}
+export interface BeeReleasePointerRow {
+    bee_name: string;
+    latest_version: string;
+    released_at: string;
+}
+export interface BeeManifestRow {
+    release_id: number;
+    schema_version: string;
+    description: string;
+    segments_json: string;
+    entrypoint_preamble: string | null;
+    promotion: string;
+    min_cycles: number | null;
+    requires_human: number;
+    requires_smoke: number;
+    retire_on_misses: number | null;
+}
+export interface BeeSegmentRefRow {
+    id: number;
+    release_id: number;
+    segment_name: string;
+    inputs_json: string | null;
+    outputs_json: string | null;
+    side_effects: string | null;
+}
+export interface BeeFileRow {
+    id: number;
+    release_id: number;
+    owner_kind: "bee" | "segment";
+    owner_name: string;
+    path: string;
+    kind: "markdown" | "script" | "reference" | "binary" | "other";
+    size_bytes: number;
+    sha256: string;
+    blob_path: string;
+}
+export interface BeeChangeRow {
+    id: number;
+    release_id: number;
+    change_kind: string;
+    target_kind: string;
+    target_name: string;
+    detail: string | null;
+}
+/**
+ * Shape of `manifest.json` inside a release export tarball.
+ *
+ * Producer: `src/services/skillhub/release-export.ts` writes this file via
+ *   `JSON.stringify({ bee_name, version, manifestRows, segRows, fileRows, changeRows })`.
+ * Consumer: `src/services/skillhub/release-import.ts` parses it back with
+ *   `JSON.parse(readFileSync(join(stageDir, "manifest.json"), "utf-8"))`.
+ *
+ * Defining it once here (rather than as an inline anonymous type at the
+ * call-site) lets both sides share a structural contract. If a future
+ * field is added — e.g. an exported schema-version stamp — it lands in
+ * one place and TypeScript flags every consumer that needs updating.
+ */
+export interface ExportPayload {
+    bee_name: string;
+    version: string;
+    manifestRows: Array<{
+        schema_version: string;
+        description: string;
+        segments_json: string;
+        entrypoint_preamble: string | null;
+        promotion: string;
+        min_cycles: number | null;
+        requires_human: number;
+        requires_smoke: number;
+        retire_on_misses: number | null;
+    }>;
+    segRows: Array<{
+        segment_name: string;
+        inputs_json: string | null;
+        outputs_json: string | null;
+        side_effects: string | null;
+    }>;
+    fileRows: Array<{
+        owner_kind: string;
+        owner_name: string;
+        path: string;
+        kind: string;
+        size_bytes: number;
+        sha256: string;
+        blob_path: string;
+    }>;
+    changeRows: Array<{
+        change_kind: string;
+        target_kind: string;
+        target_name: string;
+        detail: string | null;
+    }>;
+}

package/dist/src/services/skillhub/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/services/skills/skill-conformance-service.js

@@ -28,10 +28,10 @@ const SKILL_NAMES = [
     'peaks-rd',
     'peaks-qa',
     'peaks-sc',
-    'peaks-solo',
-    'peaks-solo-resume',
-    'peaks-solo-status',
-    'peaks-solo-test',
+    'peaks-code',
+    'peaks-resume',
+    'peaks-status',
+    'peaks-test',
     'peaks-sop',
     'peaks-txt',
     'peaks-doctor'
@@ -85,7 +85,10 @@ export function auditSkillConformance(input) {
     const skillsDir = join(input.projectRoot, 'skills');
     const checks = [];
     for (const skillName of SKILL_NAMES) {
-        const skillPath = join(skillsDir, skillName, 'SKILL.md');
+        // LLM-internal skills live under `skills/bee/<name>/` per spec 2026-07-05.
+        const topPath = join(skillsDir, skillName, 'SKILL.md');
+        const beePath = join(skillsDir, 'bee', skillName, 'SKILL.md');
+        const skillPath = existsSync(topPath) ? topPath : beePath;
         const fm = readSkillFrontmatter(skillPath);
         // 1. task-level frontmatter
         if (fm === null) {

package/dist/src/services/skills/skill-presence-service.d.ts

@@ -28,7 +28,7 @@ export type SkillPresence = {
      * observability consumer that an outer-session swap was observed
      * on the previous heartbeat. The actual binding rotation is
      * performed by `ensureSessionWithRotation` (slice 018), not by
-     * `setSkillPresence`. `peaks-solo`'s Step 0 used to read this
+     * `setSkillPresence`. `peaks-code`'s Step 0 used to read this
      * field and turn it into an AskUserQuestion; that ask is no
      * longer needed because the rotation already happened by the time
      * the skill is invoked.
@@ -81,11 +81,11 @@ export declare function getSkillPresence(projectRootOverride?: string): SkillPre
  *     different outer (Claude / harness) session than the one that
  *     is now driving peaks. Most common cause: the LLM closed the
  *     previous Claude session, the next session boots and finds a
- *     presence leftover from the old one. peaks-solo Step 1 must
+ *     presence leftover from the old one. peaks-code Step 1 must
  *     AskUserQuestion to confirm the user wants the old mode.
  *
  *   - `'no-presence'`            — there is no presence file on disk.
- *     Not strictly "stale", but callers (peaks-solo Step 1, `peaks
+ *     Not strictly "stale", but callers (peaks-code Step 1, `peaks
  *     solo should-pause --step step-1-mode-select`) want to treat
  *     this case as "no opinion yet — must ask". Surfaced as
  *     `stale: true` with reason `'no-presence'` so the ask path is
@@ -130,7 +130,7 @@ export declare function checkStalePresence(opts?: {
  * Called from `peaks workspace init` immediately after a successful
  * `outer-session-mismatch` rotation. When the previous session's
  * presence is still on disk under the OLD outer session id,
- * clearing it prevents peaks-solo Step 1 from picking up a stale
+ * clearing it prevents peaks-code Step 1 from picking up a stale
  * `mode` field that the user never explicitly chose.
  *
  * Only clears when:

package/dist/src/services/skills/skill-presence-service.js

@@ -143,7 +143,7 @@ function getBoundOuterSessionId(projectRootOverride) {
  * the presence envelope (useful for the statusline to render a stale
  * marker and for the QA / log consumers to know an outer-session swap
  * happened), but it no longer carries the implicit "ask the user"
- * promise — `peaks-solo`'s Step 0 no longer needs to surface an
+ * promise — `peaks-code`'s Step 0 no longer needs to surface an
  * AskUserQuestion, because the rotation already fired by the time the
  * skill is invoked.
  *
@@ -377,7 +377,7 @@ export function checkStalePresence(opts) {
  * Called from `peaks workspace init` immediately after a successful
  * `outer-session-mismatch` rotation. When the previous session's
  * presence is still on disk under the OLD outer session id,
- * clearing it prevents peaks-solo Step 1 from picking up a stale
+ * clearing it prevents peaks-code Step 1 from picking up a stale
  * `mode` field that the user never explicitly chose.
  *
  * Only clears when:

package/dist/src/services/skills/skill-registry.js

@@ -13,6 +13,33 @@ export async function loadSkillRegistry(baseDir = skillsDir) {
     const skills = [];
     const failures = [];
     for (const directory of directories) {
+        // LLM-internal skills (bees) live under `bee/` per spec 2026-07-05.
+        // Recurse one level into `bee/`; treat each child as a separate skill.
+        if (directory === 'bee') {
+            const subEntries = await listDirectories(join(baseDir, 'bee'));
+            for (const subDir of subEntries) {
+                const skillPath = join(baseDir, 'bee', subDir, 'SKILL.md');
+                if (!(await pathExists(skillPath))) {
+                    continue;
+                }
+                try {
+                    const frontmatter = parseFrontmatter(await readText(skillPath));
+                    // `directory` is the on-disk skill folder name; for bees that is the
+                    // basename of the bee child, NOT `bee/<name>` (keeps the
+                    // doctor skill-name-matches-directory invariant working).
+                    skills.push({
+                        name: frontmatter.name,
+                        description: frontmatter.description,
+                        directory: subDir,
+                        skillPath
+                    });
+                }
+                catch (error) {
+                    failures.push({ directory: subDir, skillPath, message: getLoadFailureMessage(error) });
+                }
+            }
+            continue;
+        }
         const skillPath = join(baseDir, directory, 'SKILL.md');
         if (!(await pathExists(skillPath))) {
             continue;

package/dist/src/services/skills/skill-runbook-service.js

@@ -36,7 +36,7 @@ function extractRunbookSection(body) {
 /**
  * Load the runbook section, falling back to `references/runbook.md` if the
  * SKILL.md only has a pointer section. This supports skills (notably
- * `peaks-solo`) that extracted their 150-line bash runbook to a sibling
+ * `peaks-code`) that extracted their 150-line bash runbook to a sibling
  * reference to keep SKILL.md under the 800-line cap. The CLI
  * `peaks skill runbook` command uses the same fallback so a human
  * reviewer sees the full runbook regardless of where it lives.
@@ -52,7 +52,7 @@ async function loadRunbookSection(skillPath, body) {
     const inline = extractRunbookSection(body);
     const skillDir = dirname(skillPath);
     // Try multiple reference filenames. Convention: each skill may name its
-    // runbook file `runbook.md` (the generic name, used by peaks-solo), or
+    // runbook file `runbook.md` (the generic name, used by peaks-code), or
     // `<role>-runbook.md` (the role-suffixed name, used by peaks-rd → rd-runbook.md,
     // peaks-qa → qa-runbook.md, etc.). Prefer the longest extracted section.
     const refCandidates = [

package/dist/src/services/slice/slice-check-service.js

@@ -297,7 +297,7 @@ export async function sliceCheck(options) {
             description: 'vitest run (skipped per --skip-tests)',
             status: 'skipped',
             durationMs: 0,
-            detail: 'Skipped: --skip-tests was set. Use the peaks-solo-test skill to run the full suite manually.'
+            detail: 'Skipped: --skip-tests was set. Use the peaks-test skill to run the full suite manually.'
         });
         unitTestsRunMode = 'skipped';
     }

package/dist/src/services/slice/slice-check-types.d.ts

@@ -2,7 +2,7 @@
  * Type envelope for the `peaks slice check` CLI command.
  *
  * `peaks slice check` is the boundary check for the RD micro-cycle
- * (see `skills/peaks-solo/references/micro-cycle.md`). It bundles the
+ * (see `skills/peaks-code/references/micro-cycle.md`). It bundles the
  * 4 self-checks that must pass at slice end before the slice is handed
  * off to peaks-qa:
  *

package/dist/src/services/slice/slice-check-types.js

@@ -2,7 +2,7 @@
  * Type envelope for the `peaks slice check` CLI command.
  *
  * `peaks slice check` is the boundary check for the RD micro-cycle
- * (see `skills/peaks-solo/references/micro-cycle.md`). It bundles the
+ * (see `skills/peaks-code/references/micro-cycle.md`). It bundles the
  * 4 self-checks that must pass at slice end before the slice is handed
  * off to peaks-qa:
  *

package/dist/src/services/slice/slice-decompose-types.d.ts

@@ -2,7 +2,7 @@
  * Type envelope for `peaks slice decompose` and its outputs.
  *
  * The slice-decomposition algorithm is a 6-stage deterministic function
- * (see `peaks-solo/references/slice-algorithm.md` for the full spec):
+ * (see `peaks-code/references/slice-algorithm.md` for the full spec):
  *
  *   1. workUnitResolution  -- codegraph.query + knowledge_graph.grep
  *   2. buildDependencyDAG  -- real import edges + codegraph.affected fallback

package/dist/src/services/slice/slice-decompose-types.js

@@ -2,7 +2,7 @@
  * Type envelope for `peaks slice decompose` and its outputs.
  *
  * The slice-decomposition algorithm is a 6-stage deterministic function
- * (see `peaks-solo/references/slice-algorithm.md` for the full spec):
+ * (see `peaks-code/references/slice-algorithm.md` for the full spec):
  *
  *   1. workUnitResolution  -- codegraph.query + knowledge_graph.grep
  *   2. buildDependencyDAG  -- real import edges + codegraph.affected fallback

package/dist/src/services/solo/auto-compact-orchestrator.d.ts

@@ -22,7 +22,7 @@ export interface AutoCompactInput {
     /**
      * 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. Sub-agent shells pass
      * `'sub-agent'` to preserve the legacy shell-spawn behaviour.
      */

package/dist/src/services/solo/auto-compact-orchestrator.js

@@ -139,7 +139,7 @@ function appendAutoDecisionLog(input) {
         ''
     ].join('\n');
     if (!existsSync(logPath)) {
-        writeFileSync(logPath, `# peaks-solo auto-decisions log\n${row}`, 'utf8');
+        writeFileSync(logPath, `# peaks-code auto-decisions log\n${row}`, 'utf8');
         return;
     }
     const existing = readFileSync(logPath, 'utf8');
@@ -200,7 +200,7 @@ function writePreCompactCheckpoint(input) {
         recentDecisions: [],
         recentArtifactPaths: [],
         gitStatus: '',
-        skillsActive: ['peaks-solo'],
+        skillsActive: ['peaks-code'],
         todoState: []
     };
     writeFileSync(path, JSON.stringify(content, null, 2), 'utf8');

package/dist/src/services/solo/dag-orchestrator.d.ts

@@ -8,7 +8,7 @@
  * Design:
  *  - **Pure dispatcher contract**: the orchestrator never calls an LLM
  *    directly; it returns `DispatchSpec[]` per topological level and lets
- *    the caller (the CLI / peaks-solo LLM) execute the per-IDE tool calls.
+ *    the caller (the CLI / peaks-code LLM) execute the per-IDE tool calls.
  *    This keeps the orchestrator testable end-to-end with mock sub-agents.
  *  - **Join barrier**: between levels, the orchestrator awaits the
  *    results of all dispatched leaves and refuses to advance if any
@@ -21,7 +21,7 @@
  *    and the next dispatch's prompt is built with `formatContractInjection`.
  *
  * Why this lives in `services/solo/`:
- *  `peaks-solo` is the natural caller. The CLI surface (`peaks sub-agent
+ *  `peaks-code` is the natural caller. The CLI surface (`peaks sub-agent
  *  dispatch --from-dag`) consumes the planner's output but the planner
  *  itself is a library.
  */
@@ -123,6 +123,6 @@ export declare function runDag(dag: SliceDag, opts: RunDagOptions): Promise<DagR
  *      cancels in-flight siblings and breaks the loop.
  *
  * Pure planner; same I/O contract as `runDag`. The caller (CLI /
- * peaks-solo LLM) executes the per-IDE tool calls.
+ * peaks-code LLM) executes the per-IDE tool calls.
  */
 export declare function runLayeredDag(dag: SliceDag, opts: RunDagOptions): Promise<DagRunResult>;

package/dist/src/services/solo/dag-orchestrator.js

@@ -8,7 +8,7 @@
  * Design:
  *  - **Pure dispatcher contract**: the orchestrator never calls an LLM
  *    directly; it returns `DispatchSpec[]` per topological level and lets
- *    the caller (the CLI / peaks-solo LLM) execute the per-IDE tool calls.
+ *    the caller (the CLI / peaks-code LLM) execute the per-IDE tool calls.
  *    This keeps the orchestrator testable end-to-end with mock sub-agents.
  *  - **Join barrier**: between levels, the orchestrator awaits the
  *    results of all dispatched leaves and refuses to advance if any
@@ -21,7 +21,7 @@
  *    and the next dispatch's prompt is built with `formatContractInjection`.
  *
  * Why this lives in `services/solo/`:
- *  `peaks-solo` is the natural caller. The CLI surface (`peaks sub-agent
+ *  `peaks-code` is the natural caller. The CLI surface (`peaks sub-agent
  *  dispatch --from-dag`) consumes the planner's output but the planner
  *  itself is a library.
  */
@@ -110,7 +110,7 @@ export function buildDispatchSpec(dag, sliceId, contracts, defaultPrompt) {
         'Handoff protocol (REQUIRED — orchestrator depends on this):',
         '  1. Execute the slice to completion.',
         `  2. Write your public contract via \`peaks contract write --project <root> --session-id <sid> --slice-id ${sliceId} --exports <...> --types <...> --signatures <...>\`. The orchestrator will pick it up on the next dispatch run.`,
-        '  3. Do NOT re-invoke `peaks sub-agent dispatch --from-dag` yourself — the parent orchestrator (peaks-solo) drives level advancement.',
+        '  3. Do NOT re-invoke `peaks sub-agent dispatch --from-dag` yourself — the parent orchestrator (peaks-code) drives level advancement.',
         '',
         `After your contract is on disk, the orchestrator will auto-advance to the next topological level (if any) by re-invoking \`peaks sub-agent dispatch --from-dag\` with the same batch-id. Your slice will appear in its ancestors via \`formatContractInjection\`.${ancestorFragment}`
     ].join('\n');
@@ -214,7 +214,7 @@ export async function runDag(dag, opts) {
  *      cancels in-flight siblings and breaks the loop.
  *
  * Pure planner; same I/O contract as `runDag`. The caller (CLI /
- * peaks-solo LLM) executes the per-IDE tool calls.
+ * peaks-code LLM) executes the per-IDE tool calls.
  */
 export async function runLayeredDag(dag, opts) {
     try {