peaks-loop 4.0.0-beta → 4.0.0-beta.11

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

@@ -1,157 +0,0 @@
-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 { 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';
-import { fail, ok } from '../../shared/result.js';
-import { emitDecision, emitHint } from '../../services/hooks/output.js';
-/**
- * Read the hook payload. `PEAKS_HOOK_STDIN` is a test seam (same convention as
- * `gate-commands.ts`); production reads stdin. The TTY short-circuit means an
- * interactive shell invocation is treated as an empty payload (allow).
- */
-async function readStdin() {
-    const override = process.env.PEAKS_HOOK_STDIN;
-    if (override !== undefined) {
-        return override;
-    }
-    if (process.stdin.isTTY)
-        return '';
-    return new Promise((resolveStdin) => {
-        let data = '';
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (chunk) => { data += chunk; });
-        process.stdin.on('end', () => resolveStdin(data));
-        process.stdin.on('error', () => resolveStdin(data));
-    });
-}
-/**
- * `peaks hook handle` —— peaks 自有 hook 协议的单一入口。
- *
- * 该命令是 peaks-loop 拥有的 hook 处理总入口。它:
- *   1. 读 stdin
- *   2. auto-detect 来源 IDE(env / stdin shape / cwd)
- *   3. 归一化到 peaks canonical schema
- *   4. dispatch 到内部 peaks 逻辑(目前:gate enforce)
- *   5. 用 IDE 期望的格式发回决策
- *
- * Slice #1 阶段:peaks hook handle 与 peaks gate enforce
- * 并存(后者内部走 hook-translator)。Slice #2 把 IDE settings 改成调用
- * peaks hook handle 即可。Slice #3 删除旧命令。
- */
-export function registerHookHandleCommand(program, io) {
-    const hook = program.command('hook').description('Peaks 自有 hook 协议单一入口（slice #1 新增；后续 slice 将逐步替代 gate enforce）');
-    addJsonOption(hook
-        .command('handle')
-        .description('Read stdin hook payload, auto-detect IDE, dispatch to peaks gate-enforce logic, output IDE-formatted decision')
-        .option('--project <path>', 'project the gates evaluate against (default: current directory)', '.')).action(async (options) => {
-        try {
-            const raw = await readStdin();
-            let parsed = null;
-            if (raw.trim().length > 0) {
-                try {
-                    parsed = JSON.parse(raw);
-                }
-                catch {
-                    // Malformed JSON — treat as empty payload (fail-open)
-                    parsed = null;
-                }
-            }
-            const ide = detectIdeFromContext({ env: process.env, cwd: process.cwd(), parsedStdin: parsed });
-            const adapter = getAdapter(ide);
-            // Slice #3: per-adapter stdin parser dispatch. The detected IDE
-            // determines which parser runs; unknown IDEs fall back to the Claude
-            // shape (preserves slice #1's "fail-open to Claude" semantics).
-            const { toolName, command } = parseAdapterStdin(ide, parsed);
-            // Also try the Claude parser as a secondary fallback so a Trae user who
-            // accidentally pipes a Claude-shaped payload still gets the right fields.
-            const claudeShape = parseClaudeShapeStdin(parsed);
-            const fallbackToolName = toolName ?? claudeShape.toolName ?? pluckString(parsed, ['toolName']);
-            const fallbackCommand = command ?? claudeShape.command ?? pluckString(parsed, ['toolInput', 'command']);
-            const projectRoot = process.env[adapter.envVar] ?? options.project;
-            const hook = buildCanonicalHook({
-                toolName: fallbackToolName ?? '',
-                toolInput: pluckObject(parsed, ['tool_input']) ?? pluckObject(parsed, ['toolInput']) ?? {},
-                projectRoot,
-                rawIdeFormat: ide,
-                rawPayload: parsed
-            });
-            // 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
-                // 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);
-                        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' })));
-                        }
-                        return;
-                    }
-                }
-                // Lazy import to avoid circular: peaks gate enforce logic
-                const { enforceBashCommand } = await import('../../services/sop/gate-enforce-service.js');
-                const decision = await enforceBashCommand(projectRoot, fallbackCommand);
-                if (decision.decision === 'deny') {
-                    const formatted = formatDecisionResponse(ide, 'deny', decision.reason);
-                    emitDecision(io, formatted.stdout);
-                    if (options.json === true) {
-                        emitHint(io, JSON.stringify(ok('hook.handle', { ide, tool: hook.toolName, decision: 'deny', reason: decision.reason })));
-                    }
-                    return;
-                }
-            }
-            // L2.2 P1 #1: login-gate. After solo-code-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.
-            if (hook.toolName === 'Bash' && typeof fallbackCommand === 'string') {
-                const gate = checkLoginGate({ command: fallbackCommand });
-                if (gate.destructive) {
-                    emitHint(io, `warning: login-gate: destructive command detected (pattern: ${gate.matchedPattern}). Confirm with the user before proceeding.`);
-                }
-            }
-            // L2.1 P0 #2: no-root-pollution. Deny Write/Edit to files outside the
-            // root allowlist. file_path is read from toolInput.file_path (Claude
-            // and most IDEs use the same shape). When the field is missing or the
-            // path is not at depth 1, the enforcer allows (no-op).
-            if (hook.toolName === 'Write' || hook.toolName === 'Edit' || hook.toolName === 'MultiEdit' || hook.toolName === 'Create') {
-                const filePath = pluckString(parsed, ['tool_input', 'file_path'])
-                    ?? pluckString(parsed, ['toolInput', 'file_path'])
-                    ?? pluckString(parsed, ['tool_input', 'path'])
-                    ?? pluckString(parsed, ['toolInput', 'path']);
-                if (typeof filePath === 'string' && filePath.trim().length > 0) {
-                    const rootCheck = isRootWrite({ projectRoot, filePath });
-                    if (!rootCheck.allowed) {
-                        const formatted = formatDecisionResponse(ide, 'deny', rootCheck.denyReason);
-                        emitDecision(io, formatted.stdout);
-                        if (options.json === true) {
-                            emitHint(io, JSON.stringify(ok('hook.handle', { ide, tool: hook.toolName, decision: 'deny', reason: rootCheck.denyReason, enforcer: 'no-root-pollution' })));
-                        }
-                        return;
-                    }
-                }
-            }
-            const allow = formatDecisionResponse(ide, 'allow');
-            emitDecision(io, allow.stdout);
-            if (options.json === true) {
-                printResult(io, ok('hook.handle', { ide, tool: hook.toolName, decision: 'allow' }), true);
-            }
-        }
-        catch (error) {
-            // Fail-open: a bug in hook.handle must not brick Claude Code.
-            emitHint(io, `hook handle: internal error, allowing command (${error instanceof Error ? error.message : String(error)})`);
-            if (options.json === true) {
-                printResult(io, fail('hook.handle', 'HOOK_HANDLE_FAILED', error instanceof Error ? error.message : 'unknown', {}), true);
-            }
-        }
-    });
-}

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

@@ -1,289 +0,0 @@
-// src/cli/commands/job-commands.ts
-import { join } from 'node:path';
-import { Command } from 'commander';
-import { fail, ok } from '../../shared/result.js';
-import { addJsonOption, printResult } from '../cli-helpers.js';
-import { JobStateStore } from '../../services/job/job-state-store.js';
-import { JobOrchestrator } from '../../services/job/job-orchestrator.js';
-import { writeJobProgress, readJobProgress, tryReadJobProgress } from '../../services/job/job-progress-store.js';
-import { JobRotation } from '../../services/job/job-rotation.js';
-import { SubAgentJobWrapper } from '../../services/job/subagent-job-wrapper.js';
-import { emitJobEvent } from '../../services/job/job-event-emitter.js';
-import { JobInitInputSchema, JobCheckpointInputSchema, JobBlockInputSchema, } from '../../services/job/job-types.js';
-import { getCurrentSessionId } from '../../services/skills/skill-presence-service.js';
-function projectRoot(opts) {
-    // Reuse the workspace root resolver from peaks CLI; for now, CWD as a safe placeholder.
-    return opts.project ?? process.cwd();
-}
-/**
- * Resolves the on-disk root for Job state files.
- *
- * Per spec §3.3 + §4.5 (2.7.1 single-scope-axis layout), Job state lives at:
- *   `<projectRoot>/.peaks/_runtime/<sessionId>/job/<jobId>/state.json`
- *
- * The `JobStateStore` itself only knows its `rootDir` + `jobId` and joins them. We
- * compute the canonical root here (per-call) so the store can stay layout-agnostic.
- *
- * Resolution order:
- * 1. `--session-id` flag (explicit override)
- * 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-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-code Step 0.8+)');
-    job
-        .command('init')
-        .requiredOption('--job-id <jid>')
-        .requiredOption('--slice-list <list>')
-        .option('--parallelism-hint <serial|llm-decides>', 'llm-decides')
-        .option('--exit-policy <strict|best-effort>', 'strict')
-        .option('--main-loop-strategy <single|rotating>', 'rotating')
-        .option('--rotate-every <n>', 'rotate every N slices (rotating mode)', '3')
-        .option('--session-id <sid>', 'session id (default: read from .peaks/_runtime/session.json; required to land in the 2.7.1 single-scope-axis layout)')
-        .option('--project <repo>')
-        .action(async (opts) => {
-        const project = projectRoot(opts);
-        // Resolve sessionId: explicit flag > canonical session binding > FAIL.
-        // Per spec §3.3, Job state lives at .peaks/_runtime/<sessionId>/job/<jobId>/state.json —
-        // 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-code session via peaks workspace init)', { project }, [
-                'Re-run with --session-id <sid>',
-                'Or run `peaks workspace init` to create a session first'
-            ]), opts);
-        }
-        const parsed = JobInitInputSchema.safeParse({
-            jobId: opts.jobId,
-            sessionId,
-            sliceList: opts.sliceList.split(',').map((s) => s.trim()).filter(Boolean),
-            parallelismHint: opts.parallelismHint,
-            exitPolicy: opts.exitPolicy,
-            mainLoopStrategy: opts.mainLoopStrategy,
-            rotateEvery: Number(opts.rotateEvery),
-            project,
-            json: opts.json,
-        });
-        if (!parsed.success)
-            return printResult(io, fail('init', 'INVALID_INIT', parsed.error.message, {}), opts);
-        const jobRoot = resolveJobStateRoot(opts);
-        const store = new JobStateStore(jobRoot.rootDir);
-        const orch = new JobOrchestrator(store);
-        const state = orch.init({
-            jobId: parsed.data.jobId,
-            sessionId: parsed.data.sessionId,
-            sliceList: parsed.data.sliceList,
-            parallelismHint: parsed.data.parallelismHint,
-            exitPolicy: parsed.data.exitPolicy,
-            mainLoopStrategy: parsed.data.mainLoopStrategy,
-            rotateEvery: parsed.data.rotateEvery,
-        });
-        try {
-            emitJobEvent({ kind: 'job-started', jobId: state.jobId, total: state.slices.length, strategy: state.mainLoopStrategy });
-        }
-        catch (e) {
-            // best-effort: event emission failures must not abort job init
-            void e;
-        }
-        printResult(io, ok('init', { jobId: state.jobId, sliceCount: state.slices.length, statePath: `${jobRoot.rootDir}/${state.jobId}/state.json` }), opts);
-    });
-    addJsonOption(job.commands.find(c => c.name() === 'init'));
-    job
-        .command('status')
-        .requiredOption('--job-id <jid>')
-        .option('--watch', 'poll every 3s')
-        .option('--show-cost', 'overlay cost from peaks budget')
-        .option('--project <repo>')
-        .action(async (opts) => {
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
-        const orch = new JobOrchestrator(store);
-        const s = orch.status(opts.jobId);
-        if (opts.watch) {
-            const draw = () => {
-                const bar = `[${'='.repeat(s.done)}${' '.repeat(s.total - s.done)}]`;
-                process.stdout.write(`\rjob ${opts.jobId}: ${bar} ${s.done}/${s.total}${s.currentSlice ? ` next=${s.currentSlice}` : ''}    `);
-            };
-            draw();
-            const iv = setInterval(() => { const u = orch.status(opts.jobId); Object.assign(s, u); draw(); if (u.done + u.failed + u.skipped + u.blocked >= u.total)
-                clearInterval(iv); }, 3000);
-            process.on('SIGINT', () => { clearInterval(iv); process.stdout.write('\n'); process.exit(0); });
-            return;
-        }
-        try {
-            emitJobEvent({ kind: 'job-progress', jobId: opts.jobId, done: s.done, total: s.total, ...(s.currentSlice ? { currentSlice: s.currentSlice } : {}) });
-        }
-        catch (e) {
-            // best-effort: event emission failures must not abort job status
-            void e;
-        }
-        printResult(io, ok('status', s), opts);
-    });
-    addJsonOption(job.commands.find(c => c.name() === 'status'));
-    // M4.2: wire rotate-now to JobRotation (session-rotate callbacks are stubs pending M6.5 batch-fix).
-    job.command('rotate-now')
-        .requiredOption('--job-id <jid>')
-        .option('--project <repo>')
-        .action(async (opts) => {
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
-        const rotation = new JobRotation(store, async (_jid) => { /* delegate to peaks session rotate — implementation wired in M6.5 batch-fix */ return { rotated: true }; }, async (jid) => ({ jobId: jid, cycle: 0 }));
-        const r = await rotation.rotateNow(opts.jobId);
-        printResult(io, ok('rotate-now', r), opts);
-    });
-    addJsonOption(job.commands.find(c => c.name() === 'rotate-now'));
-    job.command('subagent-cleanup')
-        .requiredOption('--job-id <jid>')
-        .requiredOption('--batch-id <bid>')
-        .option('--force')
-        .option('--project <repo>')
-        .action(async (opts) => {
-        const wrapper = new SubAgentJobWrapper(new JobStateStore(resolveJobStateRoot(opts).rootDir), async () => ({ batchId: opts.batchId }));
-        const r = await wrapper.cleanup({ jobId: opts.jobId, batchId: opts.batchId, force: !!opts.force });
-        printResult(io, ok('subagent-cleanup', r), opts);
-    });
-    addJsonOption(job.commands.find(c => c.name() === 'subagent-cleanup'));
-    // M3.2: wire the remaining 5 subcommand slots — block, checkpoint, continue, handoff, resume.
-    job
-        .command('checkpoint')
-        .requiredOption('--job-id <jid>')
-        .requiredOption('--slice-id <rid>')
-        .requiredOption('--state <done|failed|skipped>')
-        .option('--commit-sha <sha>')
-        .option('--reason <text>')
-        .option('--project <repo>')
-        .action(async (opts) => {
-        const parsed = JobCheckpointInputSchema.safeParse({
-            jobId: opts.jobId, sliceId: opts.sliceId, state: opts.state,
-            commitSha: opts.commitSha, reason: opts.reason,
-            project: projectRoot(opts), json: opts.json,
-        });
-        if (!parsed.success)
-            return printResult(io, fail('checkpoint', 'INVALID_CHECKPOINT', parsed.error.message, {}), opts);
-        const jobRoot = resolveJobStateRoot(opts);
-        const store = new JobStateStore(jobRoot.rootDir);
-        const orch = new JobOrchestrator(store);
-        if (parsed.data.state === 'done') {
-            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.
-            const project = projectRoot(opts);
-            const sessId = jobRoot.sessionId;
-            const state = orch.status(parsed.data.jobId);
-            writeJobProgress(project, sessId, {
-                jobId: parsed.data.jobId,
-                done: state.done,
-                total: state.total,
-                currentSlice: state.currentSlice ?? `slice-${state.done + 1}`,
-                lastCommitSha: parsed.data.commitSha ?? null,
-                updatedAt: new Date().toISOString()
-            });
-        }
-        else if (parsed.data.state === 'skipped') {
-            await orch.checkpointSkipped({ jobId: parsed.data.jobId, sliceId: parsed.data.sliceId, reason: parsed.data.reason });
-        }
-        else {
-            await orch.checkpointFailed({ jobId: parsed.data.jobId, sliceId: parsed.data.sliceId, reason: parsed.data.reason });
-        }
-        printResult(io, ok('checkpoint', { sliceId: parsed.data.sliceId, status: parsed.data.state }), opts);
-    });
-    addJsonOption(job.commands.find(c => c.name() === 'checkpoint'));
-    job
-        .command('block')
-        .requiredOption('--job-id <jid>')
-        .requiredOption('--slice-id <rid>')
-        .requiredOption('--reason <text>')
-        .option('--project <repo>')
-        .action(async (opts) => {
-        const parsed = JobBlockInputSchema.safeParse({
-            jobId: opts.jobId, sliceId: opts.sliceId, reason: opts.reason,
-            project: projectRoot(opts), json: opts.json,
-        });
-        if (!parsed.success)
-            return printResult(io, fail('block', 'INVALID_BLOCK', parsed.error.message, {}), opts);
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
-        const orch = new JobOrchestrator(store);
-        await orch.blockSlice(parsed.data);
-        printResult(io, ok('block', { blocked: parsed.data.sliceId, reason: parsed.data.reason }), opts);
-    });
-    addJsonOption(job.commands.find(c => c.name() === 'block'));
-    job
-        .command('continue')
-        .requiredOption('--job-id <jid>')
-        .option('--project <repo>')
-        .action(async (opts) => {
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
-        const orch = new JobOrchestrator(store);
-        const r = orch.continueNow(opts.jobId);
-        printResult(io, ok('continue', r), opts);
-    });
-    addJsonOption(job.commands.find(c => c.name() === 'continue'));
-    job
-        .command('resume')
-        .requiredOption('--job-id <jid>')
-        .option('--project <repo>')
-        .action(async (opts) => {
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
-        const orch = new JobOrchestrator(store);
-        const s = orch.status(opts.jobId);
-        printResult(io, ok('resume', { resumed: opts.jobId, ...s }), opts);
-    });
-    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-code Step 0.7 (resume) to surface `Next: slice #N of M
-    // (<currentSlice>)` without re-deriving from state.json.
-    job
-        .command('progress')
-        .description('v3.1.2: read the on-disk slice progress mirror (.peaks/_runtime/<sid>/job/<jid>/progress.json). ' +
-        'Returns { jobId, done, total, currentSlice, lastCommitSha, updatedAt }.')
-        .requiredOption('--job-id <jid>')
-        .option('--project <repo>')
-        .option('--allow-missing', 'return done=0/total=0 envelope instead of failing when progress.json is absent')
-        .action(async (opts) => {
-        try {
-            const jobRoot = resolveJobStateRoot(opts);
-            const sessId = jobRoot.sessionId;
-            const project = projectRoot(opts);
-            const progress = opts.allowMissing === true
-                ? tryReadJobProgress(project, sessId, opts.jobId)
-                : readJobProgress(project, sessId, opts.jobId);
-            if (progress === null) {
-                printResult(io, fail('progress', 'NO_PROGRESS', `No progress.json for job ${opts.jobId} at .peaks/_runtime/${sessId}/job/${opts.jobId}/progress.json`, { jobId: opts.jobId, sessionId: sessId }, [
-                    'Run `peaks job checkpoint --state done ...` at least once to seed progress.json.',
-                    'Or pass --allow-missing to return a zero-progress envelope.'
-                ]), opts.json);
-                process.exitCode = 1;
-                return;
-            }
-            printResult(io, ok('progress', progress, [], [
-                `Next: slice #${progress.done + 1} of ${progress.total} (${progress.currentSlice})`
-            ]), opts.json);
-        }
-        catch (err) {
-            printResult(io, fail('progress', 'PROGRESS_READ_FAILED', err instanceof Error ? err.message : String(err), { jobId: opts.jobId }, ['Verify the job id and try again']), opts.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(job.commands.find(c => c.name() === 'progress'));
-    job
-        .command('handoff')
-        .requiredOption('--job-id <jid>')
-        .option('--project <repo>')
-        .action(async (opts) => {
-        const store = new JobStateStore(resolveJobStateRoot(opts).rootDir);
-        const orch = new JobOrchestrator(store);
-        const s = orch.status(opts.jobId);
-        printResult(io, ok('handoff', { handoffFor: opts.jobId, ...s }), opts);
-    });
-    addJsonOption(job.commands.find(c => c.name() === 'handoff'));
-    program.addCommand(job);
-}

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

@@ -1,21 +0,0 @@
-/**
- * peaks loop * CLI (Slice #14) — L4 Agent Loop Integration.
- *
- * Per docs/superpowers/specs/2026-06-11-peaks-loop-l1-l2-l3-redesign.md §5.4
- * Slice #14, ships 5 sub-features:
- *
- *   14.1 peaks loop distill          — extract patterns from past sessions
- *                                       (delegates to peaks memory extract)
- *   14.2 peaks loop preflight        — pre-run sanity checks (placeholder)
- *   14.3 peaks loop detect-pattern   — find repeating patterns (placeholder)
- *   14.4 peaks loop check-consistency — verify state consistency (placeholder)
- *   14.5 peaks goal compose          — autonomous goal composition (placeholder;
- *                                       requires IDE adapter goalCommand capability
- *                                       per Slice #0.7)
- *
- * The 4 placeholders emit a clear nextActions list; the LLM-side UX
- * layer composes the actual runtime today.
- */
-import { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export declare function registerLoopCommands(program: Command, io: ProgramIO): void;

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

@@ -1,128 +0,0 @@
-/**
- * peaks loop * CLI (Slice #14) — L4 Agent Loop Integration.
- *
- * Per docs/superpowers/specs/2026-06-11-peaks-loop-l1-l2-l3-redesign.md §5.4
- * Slice #14, ships 5 sub-features:
- *
- *   14.1 peaks loop distill          — extract patterns from past sessions
- *                                       (delegates to peaks memory extract)
- *   14.2 peaks loop preflight        — pre-run sanity checks (placeholder)
- *   14.3 peaks loop detect-pattern   — find repeating patterns (placeholder)
- *   14.4 peaks loop check-consistency — verify state consistency (placeholder)
- *   14.5 peaks goal compose          — autonomous goal composition (placeholder;
- *                                       requires IDE adapter goalCommand capability
- *                                       per Slice #0.7)
- *
- * The 4 placeholders emit a clear nextActions list; the LLM-side UX
- * layer composes the actual runtime today.
- */
-import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-import { fail, ok } from '../../shared/result.js';
-export function registerLoopCommands(program, io) {
-    // 14.5 peaks goal compose — registered as a TOP-LEVEL command (not under
-    // `peaks loop`) because IDE adapters expose it as `goalCommand`.
-    // The sub-agent dispatch path consumes it; the slice 0.7 hermes +
-    // openclaw adapters will thread it through.
-    addJsonOption(program
-        .command('goal')
-        .description('14.5: compose an autonomous goal (returns the goal envelope that the LLM-side UX layer feeds to peaks sub-agent dispatch)')
-        .requiredOption('--project <path>', 'target project root')
-        .requiredOption('--goal <text>', 'the high-level goal to compose')).action(async (options) => {
-        try {
-            printResult(io, ok('goal.compose', {
-                project: options.project,
-                goal: options.goal,
-                status: 'placeholder',
-                nextSteps: [
-                    'The composed goal is consumed by peaks sub-agent dispatch.',
-                    'The hermes + openclaw IDE adapters (Slice #0.7) surface this as a goalCommand.',
-                ],
-            }, [], [
-                'goal.compose is a thin facade; the LLM-side UX layer decomposes the goal into sub-agent tasks.',
-            ]), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('goal.compose', 'GOAL_COMPOSE_FAILED', getErrorMessage(error), { project: options.project, goal: options.goal }, ['Verify the project path and --goal value']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // peaks loop *
-    const loop = program.command('loop').description('Slice #14: L4 Agent Loop sub-features (distill / preflight / detect-pattern / check-consistency)');
-    // 14.1 distill
-    addJsonOption(loop.command('distill')
-        .description('14.1: distill patterns from past sessions into .peaks/memory/ (delegates to peaks memory extract)')
-        .requiredOption('--project <path>', 'target project root')
-        .option('--apply', 'write extracted memories to .peaks/memory/ (default: dry-run preview)', false)).action(async (options) => {
-        try {
-            const apply = options.apply === true;
-            // Delegate to the existing peaks memory extract CLI via dynamic
-            // import (avoids circular); the LLM-side UX layer composes the
-            // two commands.
-            const { execFileSync } = await import('node:child_process');
-            const args = ['memory', 'extract', '--project', options.project];
-            if (apply)
-                args.push('--apply');
-            const stdout = execFileSync('node', ['bin/peaks.js', ...args], {
-                cwd: options.project,
-                stdio: ['ignore', 'pipe', 'ignore'],
-            }).toString('utf-8');
-            printResult(io, ok('loop.distill', {
-                project: options.project,
-                apply,
-                delegateStdout: stdout.slice(0, 200),
-            }, [], [
-                apply ? 'peaks memory extract --apply was invoked' : 'peaks memory extract dry-run was invoked',
-                'A future slice will inline the memory extract (not via execFileSync).',
-            ]), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('loop.distill', 'LOOP_DISTILL_FAILED', getErrorMessage(error), { project: options.project }, ['Verify the project path']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // 14.2 preflight
-    addJsonOption(loop.command('preflight')
-        .description('14.2: pre-run sanity checks (placeholder; future slice runs peaks doctor + peaks audit before each loop iter)')
-        .requiredOption('--project <path>', 'target project root')).action(async (options) => {
-        printResult(io, ok('loop.preflight', {
-            project: options.project,
-            status: 'placeholder',
-            nextSteps: [
-                'For each L4 loop iteration, call peaks doctor + peaks audit to surface regressions.',
-                'A future slice will inline the preflight checks (not just placeholder).',
-            ],
-        }, [], [
-            'loop.preflight is a thin facade; the LLM-side UX layer composes peaks doctor + peaks audit.',
-        ]), options.json);
-    });
-    // 14.3 detect-pattern
-    addJsonOption(loop.command('detect-pattern')
-        .description('14.3: detect repeating patterns across past sessions (placeholder; future slice uses peaks retrospective search)')
-        .requiredOption('--project <path>', 'target project root')).action(async (options) => {
-        printResult(io, ok('loop.detect-pattern', {
-            project: options.project,
-            status: 'placeholder',
-            nextSteps: [
-                'Run peaks retrospective search --limit 50 to surface high-frequency patterns.',
-                'A future slice will rank by frequency + LLM confidence.',
-            ],
-        }, [], [
-            'loop.detect-pattern is a thin facade; the LLM-side UX layer composes peaks retrospective search.',
-        ]), options.json);
-    });
-    // 14.4 check-consistency
-    addJsonOption(loop.command('check-consistency')
-        .description('14.4: verify state consistency (placeholder; future slice compares .peaks/_runtime across sessions)')
-        .requiredOption('--project <path>', 'target project root')).action(async (options) => {
-        printResult(io, ok('loop.check-consistency', {
-            project: options.project,
-            status: 'placeholder',
-            nextSteps: [
-                'Compare .peaks/_runtime/<sid>/session.json across recent sessions for drift.',
-                'A future slice will report drift with severity (warn / fail).',
-            ],
-        }, [], [
-            'loop.check-consistency is a thin facade; the LLM-side UX layer composes the drift scan.',
-        ]), options.json);
-    });
-}