peaks-loop 3.1.2 → 4.0.0-beta

package/dist/src/services/sediment/json-schema.d.ts

@@ -0,0 +1,247 @@
+import { z } from "zod";
+export declare const BeeManifestSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"peaks.bee/1">;
+    name: z.ZodString;
+    source: z.ZodEnum<["system", "user"]>;
+    promotion_status: z.ZodEnum<["candidate", "stable", "retired", "system-stable"]>;
+    description: z.ZodString;
+    segments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        inputs: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<["string", "number", "boolean", "json"]>;
+            required: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }, {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }>, "many">;
+        outputs: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<["string", "number", "boolean", "json"]>;
+            required: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }, {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }>, "many">;
+        sideEffects: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }, {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }>, "many">;
+    entrypoint: z.ZodObject<{
+        preamble: z.ZodString;
+        refs: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<["file", "dir", "script"]>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }, {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    }, {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    }>;
+    promotion: z.ZodObject<{
+        minCycles: z.ZodNumber;
+        requiresHumanApproval: z.ZodBoolean;
+        requiresSmokeTest: z.ZodBoolean;
+        retireOnMissesInRow: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    }, {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    }>;
+    createdBy: z.ZodEnum<["human", "llm"]>;
+    lastTouchedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    source: "user" | "system";
+    description: string;
+    schemaVersion: "peaks.bee/1";
+    promotion: {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    };
+    segments: {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }[];
+    promotion_status: "candidate" | "stable" | "retired" | "system-stable";
+    entrypoint: {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    };
+    createdBy: "llm" | "human";
+    lastTouchedAt: string;
+}, {
+    name: string;
+    source: "user" | "system";
+    description: string;
+    schemaVersion: "peaks.bee/1";
+    promotion: {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    };
+    segments: {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }[];
+    promotion_status: "candidate" | "stable" | "retired" | "system-stable";
+    entrypoint: {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    };
+    createdBy: "llm" | "human";
+    lastTouchedAt: string;
+}>, {
+    name: string;
+    source: "user" | "system";
+    description: string;
+    schemaVersion: "peaks.bee/1";
+    promotion: {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    };
+    segments: {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }[];
+    promotion_status: "candidate" | "stable" | "retired" | "system-stable";
+    entrypoint: {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    };
+    createdBy: "llm" | "human";
+    lastTouchedAt: string;
+}, {
+    name: string;
+    source: "user" | "system";
+    description: string;
+    schemaVersion: "peaks.bee/1";
+    promotion: {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    };
+    segments: {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }[];
+    promotion_status: "candidate" | "stable" | "retired" | "system-stable";
+    entrypoint: {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    };
+    createdBy: "llm" | "human";
+    lastTouchedAt: string;
+}>;

package/dist/src/services/sediment/json-schema.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export const BeeManifestSchema = z.object({
+    schemaVersion: z.literal("peaks.bee/1"),
+    name: z.string().regex(/^bee-[a-z0-9][a-z0-9-]*$|^peaks-[a-z0-9][a-z0-9-]*$/),
+    source: z.enum(["system", "user"]),
+    promotion_status: z.enum(["candidate", "stable", "retired", "system-stable"]),
+    description: z.string().min(1).max(200),
+    segments: z.array(z.object({
+        name: z.string(),
+        inputs: z.array(z.object({ name: z.string(), type: z.enum(["string", "number", "boolean", "json"]), required: z.boolean() })),
+        outputs: z.array(z.object({ name: z.string(), type: z.enum(["string", "number", "boolean", "json"]), required: z.boolean() })),
+        sideEffects: z.array(z.string()),
+    })),
+    entrypoint: z.object({
+        preamble: z.string(),
+        refs: z.array(z.object({ path: z.string(), kind: z.enum(["file", "dir", "script"]) })),
+    }),
+    promotion: z.object({
+        minCycles: z.number().int().nonnegative(),
+        requiresHumanApproval: z.boolean(),
+        requiresSmokeTest: z.boolean(),
+        retireOnMissesInRow: z.number().int().positive().optional(),
+    }),
+    createdBy: z.enum(["human", "llm"]),
+    lastTouchedAt: z.string().datetime(),
+}).refine((m) => !(m.source === "system" && m.promotion_status !== "system-stable"), { message: "source=system must have promotion_status=system-stable" });

package/dist/src/services/sediment/manifest-lint.d.ts

@@ -0,0 +1,13 @@
+import type { BeeManifest } from "./types.js";
+export type Finding = {
+    path: string;
+    message: string;
+};
+export type LintResult = {
+    ok: true;
+} | {
+    ok: false;
+    findings: Finding[];
+};
+export declare function lintManifest(m: unknown): LintResult;
+export declare function lintManifestStrict(m: unknown): BeeManifest;

package/dist/src/services/sediment/manifest-lint.js

@@ -0,0 +1,11 @@
+import { BeeManifestSchema } from "./json-schema.js";
+export function lintManifest(m) {
+    const r = BeeManifestSchema.safeParse(m);
+    if (r.success)
+        return { ok: true };
+    return { ok: false, findings: r.error.issues.map((i) => ({ path: i.path.join("."), message: i.message })) };
+}
+export function lintManifestStrict(m) {
+    const r = BeeManifestSchema.parse(m);
+    return r;
+}

package/dist/src/services/sediment/pool-paths.d.ts

@@ -0,0 +1,22 @@
+export declare class SYSTEM_PATH_FORBIDDEN extends Error {
+    constructor(p: string);
+}
+export interface Home {
+    home: string;
+}
+export declare const resolvePoolRoot: ({ home }: Home) => string;
+export declare const resolveSystemDir: ({ home }: Home) => string;
+export declare const resolveUserBeesDir: ({ home }: Home) => string;
+export declare const resolveUserBeeDir: ({ home }: Home, name: string) => string;
+export declare const resolveSegmentsDir: ({ home }: Home) => string;
+export declare const resolveSegmentDir: ({ home }: Home, name: string) => string;
+export declare const resolveStateDbPath: ({ home }: Home) => string;
+export declare const resolveBlobsDir: ({ home }: Home) => string;
+/**
+ * Normalize `..` segments via `path.resolve` before splitting, so a path like
+ * `/h/foo/../.system/evil` collapses to `/h/.system/evil` and its `.system`
+ * segment is correctly identified. Also defends against Windows-style
+ * traversal patterns such as `..\\.system\\evil`.
+ */
+export declare function isSystemPath(p: string): boolean;
+export declare function assertNotSystemPath(p: string): void;

package/dist/src/services/sediment/pool-paths.js

@@ -0,0 +1,25 @@
+import { join, resolve as pathResolve } from "node:path";
+export class SYSTEM_PATH_FORBIDDEN extends Error {
+    constructor(p) { super(`SYSTEM_PATH_FORBIDDEN: refusing to write ${p}`); }
+}
+export const resolvePoolRoot = ({ home }) => join(home, ".peaks", "skills");
+export const resolveSystemDir = ({ home }) => join(resolvePoolRoot({ home }), ".system");
+export const resolveUserBeesDir = ({ home }) => join(resolvePoolRoot({ home }), "bees");
+export const resolveUserBeeDir = ({ home }, name) => join(resolveUserBeesDir({ home }), name);
+export const resolveSegmentsDir = ({ home }) => join(resolvePoolRoot({ home }), "segments");
+export const resolveSegmentDir = ({ home }, name) => join(resolveSegmentsDir({ home }), name);
+export const resolveStateDbPath = ({ home }) => join(resolvePoolRoot({ home }), "state.db");
+export const resolveBlobsDir = ({ home }) => join(resolvePoolRoot({ home }), "blobs");
+/**
+ * Normalize `..` segments via `path.resolve` before splitting, so a path like
+ * `/h/foo/../.system/evil` collapses to `/h/.system/evil` and its `.system`
+ * segment is correctly identified. Also defends against Windows-style
+ * traversal patterns such as `..\\.system\\evil`.
+ */
+export function isSystemPath(p) {
+    return pathResolve(p).split(/[\\/]/).some((seg) => seg === ".system");
+}
+export function assertNotSystemPath(p) {
+    if (isSystemPath(p))
+        throw new SYSTEM_PATH_FORBIDDEN(p);
+}

package/dist/src/services/sediment/pool-read.d.ts

@@ -0,0 +1,20 @@
+import type { IndexFile } from "./types.js";
+export declare class POOL_READ_ERROR extends Error {
+}
+/** Pure read of the in-memory pool index (Critical #2 fix).
+ *
+ *  CONTRACT: this function is a READ-ONLY computation. It MUST NOT
+ *  write `index.json` (or any other file) as a side-effect. The
+ *  "self-heal" property of rewriting index.json when it goes stale
+ *  belongs to `rebuildIndexFromFs`, not here. List / search / recent /
+ *  add-* verbs that need to mutate the on-disk cache should call
+ *  `rebuildIndexFromFs` explicitly.
+ *
+ *  Edge case: if the pool root does not yet exist, this returns an
+ *  empty index WITHOUT creating the directory. Callers that need a
+ *  materialized root should use `rebuildIndexFromFs` or `mkdirSync`
+ *  themselves.
+ */
+export declare function readPool({ home }: {
+    home: string;
+}): IndexFile;

package/dist/src/services/sediment/pool-read.js

@@ -0,0 +1,73 @@
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveUserBeesDir, resolveSegmentsDir } from "./pool-paths.js";
+import { lintManifest } from "./manifest-lint.js";
+export class POOL_READ_ERROR extends Error {
+}
+function readJsonIfExists(p) {
+    if (!existsSync(p))
+        return null;
+    return JSON.parse(readFileSync(p, "utf-8"));
+}
+function readBeeDir(home, name) {
+    const dir = join(resolveUserBeesDir({ home }), name);
+    const manifestPath = join(dir, "manifest.json");
+    const m = readJsonIfExists(manifestPath);
+    if (!m)
+        return null;
+    const r = lintManifest(m);
+    if (!r.ok)
+        return null;
+    return {
+        name: m.name,
+        kind: "bee",
+        path: `bees/${name}`,
+        source: m.source,
+        promotion_status: m.promotion_status,
+        segments: m.segments.map((s) => s.name),
+    };
+}
+function readSegmentDir(home, name) {
+    const dir = join(resolveSegmentsDir({ home }), name);
+    if (!existsSync(dir))
+        return null;
+    return {
+        name, kind: "segment", path: `segments/${name}`, source: "user", promotion_status: "stable",
+    };
+}
+/** Pure read of the in-memory pool index (Critical #2 fix).
+ *
+ *  CONTRACT: this function is a READ-ONLY computation. It MUST NOT
+ *  write `index.json` (or any other file) as a side-effect. The
+ *  "self-heal" property of rewriting index.json when it goes stale
+ *  belongs to `rebuildIndexFromFs`, not here. List / search / recent /
+ *  add-* verbs that need to mutate the on-disk cache should call
+ *  `rebuildIndexFromFs` explicitly.
+ *
+ *  Edge case: if the pool root does not yet exist, this returns an
+ *  empty index WITHOUT creating the directory. Callers that need a
+ *  materialized root should use `rebuildIndexFromFs` or `mkdirSync`
+ *  themselves.
+ */
+export function readPool({ home }) {
+    const entries = [];
+    const beesDir = resolveUserBeesDir({ home });
+    if (existsSync(beesDir)) {
+        for (const ent of readdirSync(beesDir, { withFileTypes: true })) {
+            if (!ent.isDirectory())
+                continue;
+            entries.push(...[readBeeDir(home, ent.name)].filter((e) => e !== null));
+        }
+    }
+    const segsDir = resolveSegmentsDir({ home });
+    if (existsSync(segsDir)) {
+        for (const ent of readdirSync(segsDir, { withFileTypes: true })) {
+            if (!ent.isDirectory())
+                continue;
+            entries.push(...[readSegmentDir(home, ent.name)].filter((e) => e !== null));
+        }
+    }
+    const idx = { schemaVersion: "peaks.pool/1", generatedAt: new Date().toISOString(), entries };
+    // Note: NO writeFileSync here. See Critical #2 fix.
+    return idx;
+}

package/dist/src/services/sediment/pool-rebuild-index.d.ts

@@ -0,0 +1,15 @@
+import type { IndexFile } from "./types.js";
+/**
+ * Rebuilds index.json from on-disk manifests/segments and writes the result.
+ *
+ * After the Critical #2 fix, `readPool` is a pure read (no filesystem
+ * side-effects). `rebuildIndexFromFs` is the single writer of
+ * `index.json`: it materializes the pool root if needed, walks the
+ * filesystem to build the in-memory index via `readPool`, and persists
+ * the result. Callers that need the on-disk cache up-to-date should
+ * call this function (or one of the add-* / rebuild-index CLI verbs
+ * which call it internally).
+ */
+export declare function rebuildIndexFromFs({ home }: {
+    home: string;
+}): IndexFile;

package/dist/src/services/sediment/pool-rebuild-index.js

@@ -0,0 +1,28 @@
+import { writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolvePoolRoot } from "./pool-paths.js";
+import { readPool } from "./pool-read.js";
+/**
+ * Rebuilds index.json from on-disk manifests/segments and writes the result.
+ *
+ * After the Critical #2 fix, `readPool` is a pure read (no filesystem
+ * side-effects). `rebuildIndexFromFs` is the single writer of
+ * `index.json`: it materializes the pool root if needed, walks the
+ * filesystem to build the in-memory index via `readPool`, and persists
+ * the result. Callers that need the on-disk cache up-to-date should
+ * call this function (or one of the add-* / rebuild-index CLI verbs
+ * which call it internally).
+ */
+export function rebuildIndexFromFs({ home }) {
+    const root = resolvePoolRoot({ home });
+    if (!existsSync(root))
+        mkdirSync(root, { recursive: true });
+    const idx = readPool({ home });
+    // Trailing newline: POSIX-friendly (`cat`, `git diff`, log tailers all
+    // expect a final \n). The Minor #14 review confirmed we keep the current
+    // behavior rather than drop it — both are JSON-valid but the trailing
+    // newline matches the convention used by every other peaks-*.json file
+    // in the project (manifest.json, segment.json, etc.).
+    writeFileSync(join(root, "index.json"), JSON.stringify(idx, null, 2) + "\n");
+    return idx;
+}

package/dist/src/services/sediment/pool-write.d.ts

@@ -0,0 +1,14 @@
+import type { BeeManifest } from "./types.js";
+/**
+ * Atomically writes a BeeManifest to <home>/.peaks/skills/bees/<name>/manifest.json.
+ *
+ * Defense in depth:
+ *  - re-validates the manifest via lintManifestStrict (zod) before any FS work
+ *  - refuses to write under any path segment equal to ".system" (soft-protection)
+ *
+ * Atomicity is achieved via write-to-tmp + renameSync so readers either see the
+ * old file or the fully-written new file, never a half-written one.
+ */
+export declare function writeBeeManifest({ home }: {
+    home: string;
+}, m: BeeManifest): void;

package/dist/src/services/sediment/pool-write.js

@@ -0,0 +1,25 @@
+import { writeFileSync, mkdirSync, renameSync } from "node:fs";
+import { join } from "node:path";
+import { assertNotSystemPath, resolveUserBeeDir } from "./pool-paths.js";
+import { lintManifestStrict } from "./manifest-lint.js";
+/**
+ * Atomically writes a BeeManifest to <home>/.peaks/skills/bees/<name>/manifest.json.
+ *
+ * Defense in depth:
+ *  - re-validates the manifest via lintManifestStrict (zod) before any FS work
+ *  - refuses to write under any path segment equal to ".system" (soft-protection)
+ *
+ * Atomicity is achieved via write-to-tmp + renameSync so readers either see the
+ * old file or the fully-written new file, never a half-written one.
+ */
+export function writeBeeManifest({ home }, m) {
+    const validated = lintManifestStrict(m);
+    const dir = resolveUserBeeDir({ home }, validated.name);
+    assertNotSystemPath(dir);
+    mkdirSync(dir, { recursive: true });
+    const file = join(dir, "manifest.json");
+    assertNotSystemPath(file);
+    const tmp = file + ".tmp";
+    writeFileSync(tmp, JSON.stringify(validated, null, 2) + "\n");
+    renameSync(tmp, file);
+}

package/dist/src/services/sediment/promotion-gate.d.ts

@@ -0,0 +1,12 @@
+import type { BeeManifest } from "./types.js";
+export interface GateInputs {
+    humanApproved: boolean;
+    smokeTestPresent: boolean;
+}
+export interface GateResult {
+    ok: boolean;
+    failedSubconditions: string[];
+}
+export declare function evaluateGate({ home }: {
+    home: string;
+}, m: BeeManifest, inputs: GateInputs): GateResult;

package/dist/src/services/sediment/promotion-gate.js

@@ -0,0 +1,20 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveUserBeeDir } from "./pool-paths.js";
+export function evaluateGate({ home }, m, inputs) {
+    if (m.source === "system") {
+        return { ok: true, failedSubconditions: [] };
+    }
+    const failed = [];
+    const rsPath = join(resolveUserBeeDir({ home }, m.name), "run-state.json");
+    const cycles = existsSync(rsPath)
+        ? JSON.parse(readFileSync(rsPath, "utf-8")).cycles
+        : 0;
+    if (cycles < m.promotion.minCycles)
+        failed.push("minCycles");
+    if (inputs.smokeTestPresent !== m.promotion.requiresSmokeTest)
+        failed.push("smokeTest");
+    if (m.promotion.requiresHumanApproval && !inputs.humanApproved)
+        failed.push("humanApproval");
+    return { ok: failed.length === 0, failedSubconditions: failed };
+}

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

@@ -0,0 +1,52 @@
+export type Source = "system" | "user";
+export type PromotionStatus = "candidate" | "stable" | "retired" | "system-stable";
+export interface Param {
+    name: string;
+    type: "string" | "number" | "boolean" | "json";
+    required: boolean;
+}
+export interface SegmentRef {
+    name: string;
+    inputs: Param[];
+    outputs: Param[];
+    sideEffects: string[];
+}
+export interface SkillEnvelopeRef {
+    path: string;
+    kind: "file" | "dir" | "script";
+}
+export interface SkillEnvelope {
+    preamble: string;
+    refs: SkillEnvelopeRef[];
+}
+export interface PromotionGate {
+    minCycles: number;
+    requiresHumanApproval: boolean;
+    requiresSmokeTest: boolean;
+    retireOnMissesInRow?: number;
+}
+export interface BeeManifest {
+    schemaVersion: "peaks.bee/1";
+    name: string;
+    source: Source;
+    promotion_status: PromotionStatus;
+    description: string;
+    segments: SegmentRef[];
+    entrypoint: SkillEnvelope;
+    promotion: PromotionGate;
+    createdBy: "human" | "llm";
+    lastTouchedAt: string;
+}
+export interface IndexEntry {
+    name: string;
+    kind: "bee" | "segment";
+    path: string;
+    source: Source;
+    promotion_status: PromotionStatus;
+    segments?: string[];
+}
+export interface IndexFile {
+    schemaVersion: "peaks.pool/1";
+    generatedAt: string;
+    entries: IndexEntry[];
+}

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

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

package/dist/src/services/session/binding-store.d.ts

@@ -107,7 +107,7 @@ export declare function writeBinding(projectRoot: string, binding: Binding): voi
  * This is the D2 Claude-instance-level binding primitive — a single
  * Claude instance keeps one sid across multiple peaks-* skill
  * activations; binding.instances[<sid>].roles accumulates the skill
- * names (peaks-solo → peaks-rd → peaks-qa in the same Claude run).
+ * names (peaks-code → peaks-rd → peaks-qa in the same Claude run).
  *
  * The caller is responsible for actually creating the session dir via
  * `initWorkspace` and storing per-session meta via `setSessionMeta`.

package/dist/src/services/session/binding-store.js

@@ -192,7 +192,7 @@ export function writeBinding(projectRoot, binding) {
  * This is the D2 Claude-instance-level binding primitive — a single
  * Claude instance keeps one sid across multiple peaks-* skill
  * activations; binding.instances[<sid>].roles accumulates the skill
- * names (peaks-solo → peaks-rd → peaks-qa in the same Claude run).
+ * names (peaks-code → peaks-rd → peaks-qa in the same Claude run).
  *
  * The caller is responsible for actually creating the session dir via
  * `initWorkspace` and storing per-session meta via `setSessionMeta`.

package/dist/src/services/session/caller-id-types.d.ts

@@ -28,7 +28,7 @@ export interface CallerBinding {
     createdAt: string;
     /** ISO 8601 timestamp; bumped on every `peaks <cmd>` that touches the binding. */
     lastActivityAt: string;
-    /** Last skill that touched this binding, e.g. "peaks-solo". */
+    /** Last skill that touched this binding, e.g. "peaks-code". */
     skill: string;
     /** Last mode, e.g. "full-auto". */
     mode: string;

package/dist/src/services/session/session-manager.d.ts

@@ -120,7 +120,7 @@ export declare function getSessionId(projectRoot: string): string | null;
  * caller is operating on a user-supplied `--project` flag
  * and the binding may have been written by a CLI invocation
  * that was running from inside the project dir (the common
- * peaks-solo / peaks-sop scenario). Other modules depend
+ * peaks-code / peaks-sop scenario). Other modules depend
  * on the strict-equality semantics of `getSessionId` (the
  * "no binding" fallback path is part of their contract),
  * so this variant is opt-in.