peaks-loop 3.1.2 → 4.0.0-beta.2

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

@@ -10,7 +10,7 @@
  * never touches.
  *
  * Skill-first / CLI-auxiliary red line (PB-4 / AC-19/20): this command is
- * a primitive that the peaks-solo / peaks-rd / peaks-qa SKILL.md compose.
+ * a primitive that the peaks-code / peaks-rd / peaks-qa SKILL.md compose.
  * Users do NOT invoke it directly; the --help text and dispatch
  * envelope's `nextActions` reinforce the point.
  */
@@ -43,7 +43,7 @@ export function registerDispatchCommand(parent, io) {
         'Dry-run by design; the LLM executes the returned toolCall in its own ' +
         'environment. Flags: --write-artifact (G7), --use-headroom (G7.7), ' +
         '--force (G9 CLI 兜底). ' +
-        'See skills/peaks-solo/references/sub-agent-dispatch.md for the ' +
+        'See skills/peaks-code/references/sub-agent-dispatch.md for the ' +
         'orchestrator contract.')
         .argument('<role>', 'sub-agent role (e.g. rd | qa | ui | txt | qa-business | qa-business-api)')
         // 2.7.0 slice-dag-dispatcher MVP: --prompt is required ONLY when --from-dag is NOT

package/dist/src/cli/commands/dispatch-from-dag.js

@@ -54,7 +54,7 @@ export async function runDispatchFromDag(role, options, asJson, io) {
     const [{ readFileSync }, sliceDagMod, dagOrchestratorMod, contractStoreMod] = await Promise.all([
         import('node:fs'),
         import('../../services/dispatch/slice-dag.js'),
-        import('../../services/solo/dag-orchestrator.js'),
+        import('../../services/code/dag-orchestrator.js'),
         import('../../services/dispatch/contract-store.js')
     ]);
     const { validateDag, topologicalLevels, isSliceComplexity } = sliceDagMod;

package/dist/src/cli/commands/hook-handle.js

@@ -2,7 +2,7 @@ import { addJsonOption, printResult } from '../cli-helpers.js';
 import { detectIdeFromContext, parseAdapterStdin, parseClaudeShapeStdin, pluckObject, pluckString } from '../../services/ide/hook-translator.js';
 import { buildCanonicalHook, formatDecisionResponse } from '../../services/ide/hook-protocol.js';
 import { getAdapter } from '../../services/ide/ide-registry.js';
-import { evaluateSoloCodeBan } from '../../services/audit/enforcers/solo-code-ban.js';
+import { evaluateCodeBan } from '../../services/audit/enforcers/code-ban.js';
 import { isRootWrite } from '../../services/audit/enforcers/no-root-pollution.js';
 import { checkLoginGate } from '../../services/audit/enforcers/login-gate.js';
 import { resolveActiveSkillForCaller } from '../../services/audit/enforcers/active-skill-resolver.js';
@@ -82,17 +82,17 @@ export function registerHookHandleCommand(program, io) {
             // Dispatch by toolName. For slice #1+, we only handle Bash. Task tool sub-agent dispatch goes through `peaks sub-agent dispatch` (slice #009) and does not need a hook entry.
             // Other tools: allow (no-op; future events will be added here).
             if (hook.toolName === 'Bash' && typeof fallbackCommand === 'string' && fallbackCommand.trim().length > 0) {
-                // L2.1 P0 #1: solo-code-ban. Deny `git commit` / `git apply` from peaks-* skills
+                // L2.1 P0 #1: code-commit-ban. Deny `git commit` / `git apply` from peaks-* skills
                 // BEFORE the SOP gate runs. The active skill is read from the per-caller
                 // active-skill file (see active-skill-resolver.ts).
                 const activeSkill = resolveActiveSkillForCaller(projectRoot);
                 if (activeSkill.skill !== null) {
-                    const soloDecision = evaluateSoloCodeBan({ skill: activeSkill.skill, command: fallbackCommand });
-                    if (soloDecision.denied) {
-                        const formatted = formatDecisionResponse(ide, 'deny', soloDecision.reason);
+                    const codeDecision = evaluateCodeBan({ skill: activeSkill.skill, command: fallbackCommand });
+                    if (codeDecision.denied) {
+                        const formatted = formatDecisionResponse(ide, 'deny', codeDecision.reason);
                         emitDecision(io, formatted.stdout);
                         if (options.json === true) {
-                            emitHint(io, JSON.stringify(ok('hook.handle', { ide, tool: hook.toolName, decision: 'deny', reason: soloDecision.reason, enforcer: 'solo-code-ban' })));
+                            emitHint(io, JSON.stringify(ok('hook.handle', { ide, tool: hook.toolName, decision: 'deny', reason: codeDecision.reason, enforcer: 'code-ban' })));
                         }
                         return;
                     }
@@ -109,7 +109,7 @@ export function registerHookHandleCommand(program, io) {
                     return;
                 }
             }
-            // L2.2 P1 #1: login-gate. After solo-code-ban + gate-enforce pass,
+            // L2.2 P1 #1: login-gate. After code-commit-ban + gate-enforce pass,
             // flag destructive patterns (uninstall, force-push, --force, --hard,
             // rm -rf) so the LLM gets a soft warning (still allow). The user
             // gets the warning via the warn channel; the command proceeds.

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

@@ -26,20 +26,20 @@ function projectRoot(opts) {
  *
  * Resolution order:
  * 1. `--session-id` flag (explicit override)
- * 2. `getCurrentSessionId(project)` — reads `.peaks/_runtime/session.json` per peaks-solo
+ * 2. `getCurrentSessionId(project)` — reads `.peaks/_runtime/session.json` per peaks-code
  * 3. Error (NO_ACTIVE_SESSION) — must never silently fall back to a random uuid
  */
 function resolveJobStateRoot(opts) {
     const project = projectRoot(opts);
     const sessionId = opts.sessionId ?? getCurrentSessionId(project);
     if (!sessionId) {
-        throw new Error('NO_ACTIVE_SESSION: peaks job requires --session-id or an active peaks-solo session via peaks workspace init');
+        throw new Error('NO_ACTIVE_SESSION: peaks job requires --session-id or an active peaks-code session via peaks workspace init');
     }
     const rootDir = join(project, '.peaks', '_runtime', sessionId, 'job');
     return { rootDir, sessionId, projectRoot: project };
 }
 export function registerJobCommands(program, io = { stdout: (t) => process.stdout.write(t), stderr: (t) => process.stderr.write(t) }) {
-    const job = new Command('job').description('Drive long multi-slice work as one Job (peaks-solo Step 0.8+)');
+    const job = new Command('job').description('Drive long multi-slice work as one Job (peaks-code Step 0.8+)');
     job
         .command('init')
         .requiredOption('--job-id <jid>')
@@ -57,7 +57,7 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
         // a random UUID would scatter state across dirs and break resume/auto-compact.
         let sessionId = opts.sessionId ?? getCurrentSessionId(project);
         if (!sessionId) {
-            return printResult(io, fail('init', 'NO_ACTIVE_SESSION', 'peaks job init requires --session-id (or an active peaks-solo session via peaks workspace init)', { project }, [
+            return printResult(io, fail('init', 'NO_ACTIVE_SESSION', 'peaks job init requires --session-id (or an active peaks-code session via peaks workspace init)', { project }, [
                 'Re-run with --session-id <sid>',
                 'Or run `peaks workspace init` to create a session first'
             ]), opts);
@@ -174,7 +174,7 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
             await orch.checkpointDone({ jobId: parsed.data.jobId, sliceId: parsed.data.sliceId, ...(parsed.data.commitSha ? { commitSha: parsed.data.commitSha } : {}) });
             // v3.1.2: after each --state done, mirror slice progress to
             // .peaks/_runtime/<sessionId>/job/<jid>/progress.json so the
-            // next LLM turn (or peaks solo gate-step-08 hook) can read it.
+            // next LLM turn (or peaks code gate-step-08 hook) can read it.
             const project = projectRoot(opts);
             const sessId = jobRoot.sessionId;
             const state = orch.status(parsed.data.jobId);
@@ -238,8 +238,8 @@ export function registerJobCommands(program, io = { stdout: (t) => process.stdou
     });
     addJsonOption(job.commands.find(c => c.name() === 'resume'));
     // v3.1.2: read the on-disk slice progress mirror written by `peaks
-    // job checkpoint --state done`. Used by peaks solo gate-step-08 and
-    // by peaks-solo Step 0.7 (resume) to surface `Next: slice #N of M
+    // job checkpoint --state done`. Used by peaks code gate-step-08 and
+    // by peaks-code Step 0.7 (resume) to surface `Next: slice #N of M
     // (<currentSlice>)` without re-deriving from state.json.
     job
         .command('progress')

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

@@ -184,7 +184,7 @@ export function registerObservabilityCommands(program, io) {
     });
     addJsonOption(observability
         .command('repair-cycles')
-        .description('RD → QA repair-cycle count per slice. Cap = 3 (peaks-solo repair-loop contract); capHit flag is set when any slice hits the cap.')
+        .description('RD → QA repair-cycle count per slice. Cap = 3 (peaks-code repair-loop contract); capHit flag is set when any slice hits the cap.')
         .option('--project <path>', 'target project root (defaults to git root or cwd)')
         .option('--session <sessionId>', 'scope to one session (defaults to the canonical session binding)')).action((options) => {
         runRepairCycles(io, options);

package/dist/src/cli/commands/perf-audit-commands.js

@@ -37,7 +37,7 @@ function readStdinSync() {
 export function registerPerfAuditCommands(program, io) {
     const perfAudit = program
         .command('perf-audit')
-        .description('Independent performance audit skill driver. Reads the immutable peaks-prd handoff (sha256-locked) + the project-level perf-template.md, then writes a structured perf-<rid>.md artifact. Decoupled from peaks-rd 5-way fan-out per slice v2.12.0 (Group A, Tier 3). See skills/peaks-perf-audit/SKILL.md for the full workflow.');
+        .description('Independent performance audit skill driver. Reads the immutable peaks-prd handoff (sha256-locked) + the project-level perf-template.md, then writes a structured perf-<rid>.md artifact. Decoupled from peaks-rd 5-way fan-out per slice v2.12.0 (Group A, Tier 3). See skills/bee/peaks-perf-audit/SKILL.md for the full workflow.');
     addJsonOption(perfAudit
         .command('detect')
         .description('Read-only probe: returns the 5-state perf-audit runtime as a JSON envelope (ready / handoff-missing / template-missing / dispatch-failed / envelope-malformed). The peaks-perf-audit skill calls this first to decide whether to invoke `run`. Mirrors `peaks security-audit detect` semantics.')
@@ -100,7 +100,7 @@ export function registerPerfAuditCommands(program, io) {
             if (!isPerfAuditEnvelope(envelopeValue)) {
                 printResult(io, fail('perf-audit.run', 'ENVELOPE_MALFORMED', 'envelope failed isPerfAuditEnvelope validation (expected { verdict, violations, summary })', { receivedType: typeof envelopeValue }, [
                     'Verify the peaks-perf-audit skill prompt matches the strict-shape contract.',
-                    'Re-emit the envelope; see skills/peaks-perf-audit/references/audit-protocol.md.'
+                    'Re-emit the envelope; see skills/bee/peaks-perf-audit/references/audit-protocol.md.'
                 ]), options.json);
                 process.exitCode = 1;
                 return;

package/dist/src/cli/commands/security-audit-commands.js

@@ -37,7 +37,7 @@ function readStdinSync() {
 export function registerSecurityAuditCommands(program, io) {
     const securityAudit = program
         .command('security-audit')
-        .description('Independent security audit skill driver. Reads the immutable peaks-prd handoff (sha256-locked) + the project-level security-template.md, then writes a structured security-<rid>.md artifact. Decoupled from peaks-rd 5-way fan-out per slice v2.12.0 (Group A, Tier 2). See skills/peaks-security-audit/SKILL.md for the full workflow.');
+        .description('Independent security audit skill driver. Reads the immutable peaks-prd handoff (sha256-locked) + the project-level security-template.md, then writes a structured security-<rid>.md artifact. Decoupled from peaks-rd 5-way fan-out per slice v2.12.0 (Group A, Tier 2). See skills/bee/peaks-security-audit/SKILL.md for the full workflow.');
     addJsonOption(securityAudit
         .command('detect')
         .description('Read-only probe: returns the 5-state security-audit runtime as a JSON envelope (ready / handoff-missing / template-missing / dispatch-failed / envelope-malformed). The peaks-security-audit skill calls this first to decide whether to invoke `run`. Mirrors `peaks code-review detect-ocr` semantics.')
@@ -100,7 +100,7 @@ export function registerSecurityAuditCommands(program, io) {
             if (!isSecurityAuditEnvelope(envelopeValue)) {
                 printResult(io, fail('security-audit.run', 'ENVELOPE_MALFORMED', 'envelope failed isSecurityAuditEnvelope validation (expected { verdict, violations, summary })', { receivedType: typeof envelopeValue }, [
                     'Verify the peaks-security-audit skill prompt matches the strict-shape contract.',
-                    'Re-emit the envelope; see skills/peaks-security-audit/references/audit-protocol.md.'
+                    'Re-emit the envelope; see skills/bee/peaks-security-audit/references/audit-protocol.md.'
                 ]), options.json);
                 process.exitCode = 1;
                 return;

package/dist/src/cli/commands/sediment-commands.d.ts

@@ -0,0 +1,80 @@
+import type { Command } from "commander";
+import type { ProgramIO } from "../cli-helpers.js";
+export interface CliResult {
+    ok: boolean;
+    error?: string;
+    data?: unknown;
+}
+/** Typed accessor over the flag map produced by `parseFlags`.
+ *
+ * `parseFlags` internally stores every flag with at least one value as a
+ * `string[]`. A flag with no following non-flag token (e.g. `--apply`,
+ * `--dry-run`) is recorded as `true`. This helper exposes three typed
+ * accessors so call-sites don't have to re-narrow `unknown` or
+ * `string | boolean | string[]` on every read:
+ *
+ *   - `flags.list(name)`     → `string[]` (always an array; a single
+ *                              occurrence is wrapped to a 1-element
+ *                              array at parse time)
+ *   - `flags.bool(name)`     → `boolean` (presence-of flag; missing
+ *                              flag is `false`)
+ *   - `flags.maybeString(name)` → `string | undefined` (first value,
+ *                              or `undefined` if the flag was given
+ *                              as a bare boolean with no value)
+ *
+ * The dispatch layer (runSediment) was previously peppered with
+ * `typeof flags.x === "string"` / `Array.isArray(flags.x)` narrowing.
+ * With this helper the call-sites collapse to one-line reads and the
+ * raw flag map stops leaking across the runSediment boundary.
+ */
+export declare class ParsedFlags {
+    private readonly raw;
+    constructor(raw: Record<string, string[] | true>);
+    /** Always returns an array. Missing flag → []. Single-occurrence
+     *  flag → a 1-element array (parseFlags normalizes this). */
+    list(name: string): string[];
+    /** Presence-of a bare boolean flag. Missing → false. */
+    bool(name: string): boolean;
+    /** First value of a flag, or `undefined` if the flag is absent or
+     *  was given as a bare boolean. */
+    maybeString(name: string): string | undefined;
+}
+/** Parse an argv tail into positional args + flag map.
+ *
+ * Supports:
+ *   --flag value    → flags[flag] = [value, ...] (advance i by 1)
+ *   --flag          → flags[flag] = true        (when next token starts with `--` or is undefined)
+ *   --flag v1 --flag v2   → repeated `--flag` values are accumulated
+ *
+ * Internally stores all values as `string[]` (or `true` for a bare
+ * boolean flag). Use the `ParsedFlags` helper to read typed accessors.
+ *
+ * Repeatable flag handling (Task 15b): when the same `--key` appears
+ * consecutively (e.g. `--segment a --segment b --segment c`), values
+ * are accumulated into a single `string[]`. A single occurrence is
+ * normalized to a 1-element array so callers can use `.list(name)`
+ * uniformly without shape-narrowing on the call-site.
+ */
+export declare function parseFlags(argv: string[]): {
+    positional: string[];
+    flags: ParsedFlags;
+};
+/** Dispatch a sediment verb argv to the matching implementation.
+ *
+ * Returns { ok: true, data? } on success and { ok: false, error }
+ * on validation failure or SYSTEM_PATH_FORBIDDEN. Unknown verbs
+ * return `{ ok: false, error: "UNKNOWN_VERB: <v>" }` so callers can
+ * distinguish "not yet implemented" from "zod rejected".
+ */
+export declare function runSediment(argv: string[], { home }: {
+    home: string;
+}): Promise<CliResult>;
+/** Register the `peaks skill sediment <verb>` subcommand group.
+ *
+ *  Task 15a wired 4 verbs; Task 15b adds 4 more (refine-bee / clone-bee /
+ *  promote / retire). The subcommand accepts variadic args so caller-side
+ *  code (peaks-cli action handler) can re-dispatch to `runSediment` for
+ *  the actual verb routing. Subsequent tasks (15c / 15d) will add the
+ *  remaining 10 verbs by extending the `runSediment` switch statement.
+ */
+export declare function registerSedimentCommands(program: Command, io: ProgramIO): void;