peaks-loop 4.1.3 → 4.1.4

package/dist/cli/commands/hooks-status-command.js

@@ -0,0 +1,93 @@
+// src/cli/commands/hooks-status-command.ts
+//
+// `peaks hooks status` — report which peaks-managed hook entries are installed.
+// Split out of `hooks-commands.ts`; the verb name, its options, the
+// "read the ACTUAL on-disk entries, not the expected list" ruling and the
+// envelope shape are unchanged.
+import { existsSync } from 'node:fs';
+import { listSuperpowersDenyEntries, readHookStatus, readInstalledEntriesFromSettings } from '../../services/skills/hooks-settings-service.js';
+import { readJsonObjectFile } from '../../services/ide/shared/atomic-json.js';
+import { resolveIdeOptionHelp } from '../../services/ide/ide-registry.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { resolveIdeForCommand, resolveProjectRoot, resolveScope } from './hooks-command-shared.js';
+/**
+ * `permissions.deny` block from a settings.json object and return
+ * every peaks-managed entry currently present. Used by `hooks status`
+ * to surface Layer 3 governance state without forcing the caller to
+ * re-read the file. Tolerant of missing / malformed `permissions` —
+ * a missing field returns an empty array, never throws.
+ */
+function readOnDiskDenyEntries(settings) {
+    const permissions = settings.permissions;
+    if (!permissions || typeof permissions !== 'object' || Array.isArray(permissions))
+        return [];
+    const deny = permissions.deny;
+    if (!Array.isArray(deny))
+        return [];
+    return deny.filter((d) => typeof d === 'string');
+}
+function runHooksStatus(io, options) {
+    const scope = resolveScope(options);
+    const projectRoot = resolveProjectRoot(scope, options.project);
+    const ide = resolveIdeForCommand(options, projectRoot);
+    try {
+        const status = readHookStatus(scope, projectRoot, { ide });
+        // Slice #014: read the ACTUAL on-disk entries (post-install shape),
+        // not the IDE-EXPECTED list. Pre-#014 `listInstalledEntriesForIde`
+        // returned the expected list and reported `entries: [Bash, Task]`
+        // even when the file only had `Bash`. The new helper reads the
+        // file and reports whatever peaks-managed entries are present,
+        // including any legacy progress-start entry that a pre-#014
+        // install left behind.
+        const settingsPath = status.settingsPath;
+        const settings = existsSync(settingsPath) ? readJsonObjectFile(settingsPath) : {};
+        // The gate-enforce entry is materialized into the machine-local
+        // settings file (see `resolveHookTargets`), so the on-disk entry list
+        // must be read from both files or `status` would report it missing.
+        const localSettings = status.localSettingsPath !== undefined && existsSync(status.localSettingsPath)
+            ? readJsonObjectFile(status.localSettingsPath)
+            : {};
+        // entries actually on disk. We read the existing settings.json
+        // (above) and surface its `permissions.deny` block. Any entry
+        // that matches the current `SUPERPOWERS_DENIED_SKILLS` set is
+        // considered "peaks-managed"; user-written entries are passed
+        // through verbatim so the envelope reflects reality. The desired
+        // list is also included for parity with install / uninstall.
+        const onDiskDeny = readOnDiskDenyEntries(settings);
+        // `status` reports the state of the world; for an IDE that cannot host a
+        // hook the state of the world is "none, and none is possible". The exit
+        // code stays 0 (the query succeeded) and the payload carries the finding
+        // — `supportsHooks: false` on the data, plus a warning naming the IDE, so
+        // the negative fact is not confused with "supported IDE, nothing
+        // installed yet".
+        const warnings = status.supportsHooks
+            ? []
+            : [
+                `IDE '${ide}' cannot host peaks hooks (no HOOK_COMMAND_BY_IDE entry); nothing can be installed for it, which is why none is.`
+            ];
+        printResult(io, ok('hooks.status', {
+            ...status,
+            ide,
+            entries: [
+                ...readInstalledEntriesFromSettings(settings, ide),
+                ...readInstalledEntriesFromSettings(localSettings, ide)
+            ],
+            permissionsDenyEntries: listSuperpowersDenyEntries(),
+            permissionsDenyOnDisk: onDiskDeny
+        }, warnings), options.json);
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        printResult(io, fail('hooks.status', 'HOOKS_STATUS_FAILED', message, { scope, ide }, [message]), options.json);
+        process.exitCode = 1;
+    }
+}
+export function registerHooksStatusCommand(hooks, io) {
+    addJsonOption(hooks
+        .command('status')
+        .description('Report which peaks-managed hook entries are installed.')
+        .option('--global', 'inspect the user-level ~/.claude/settings.json instead of the project')
+        .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')
+        .option('--ide <id>', resolveIdeOptionHelp())).action((options) => runHooksStatus(io, options));
+}

package/dist/cli/commands/hooks-uninstall-command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerHooksUninstallCommand(hooks: Command, io: ProgramIO): void;

package/dist/cli/commands/hooks-uninstall-command.js

@@ -0,0 +1,43 @@
+// src/cli/commands/hooks-uninstall-command.ts
+//
+// `peaks hooks uninstall` — remove the peaks-managed gate-enforce hook entry
+// (and any legacy progress-start entry a pre-#014 install left behind). Split
+// out of `hooks-commands.ts`; the verb name, its options and the envelope shape
+// are unchanged.
+import { listSuperpowersDenyEntries, removeHookInstall } from '../../services/skills/hooks-settings-service.js';
+import { resolveIdeOptionHelp } from '../../services/ide/ide-registry.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { resolveIdeForCommand, resolveProjectRoot, resolveScope } from './hooks-command-shared.js';
+function runHooksUninstall(io, options) {
+    const scope = resolveScope(options);
+    const projectRoot = resolveProjectRoot(scope, options.project);
+    const ide = resolveIdeForCommand(options, projectRoot);
+    try {
+        const result = removeHookInstall(scope, projectRoot, { ide });
+        // bookkeeping. `permissionsDenyRemoved` mirrors `removed` (the
+        // service strips deny entries on the same atomic write that
+        // strips the hook entries; they share the same boolean).
+        printResult(io, ok('hooks.uninstall', {
+            ...result,
+            ide,
+            permissionsDenyRemoved: result.removed,
+            permissionsDenyEntries: listSuperpowersDenyEntries()
+        }), options.json);
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        printResult(io, fail('hooks.uninstall', 'HOOKS_UNINSTALL_FAILED', message, { scope, ide, removed: false }, [
+            message
+        ]), options.json);
+        process.exitCode = 1;
+    }
+}
+export function registerHooksUninstallCommand(hooks, io) {
+    addJsonOption(hooks
+        .command('uninstall')
+        .description('Remove the peaks-managed gate-enforce hook entry from the target settings.json. Any legacy progress-start entry that a pre-#014 install left behind is also removed (sentinel-based scan). Third-party hooks are preserved.')
+        .option('--global', 'remove from the user-level ~/.claude/settings.json instead of the project')
+        .option('--project <path>', 'project root path (auto-detected from cwd when omitted)')
+        .option('--ide <id>', resolveIdeOptionHelp())).action((options) => runHooksUninstall(io, options));
+}

package/dist/cli/commands/loop-command-shared.d.ts

@@ -0,0 +1,31 @@
+import type { Command } from 'commander';
+export type GoalComposeOptions = {
+    project: string;
+    goal: string;
+    json?: boolean;
+};
+export type LoopDistillOptions = {
+    project: string;
+    apply: boolean;
+    json?: boolean;
+};
+export type LoopPlaceholderOptions = {
+    project: string;
+    json?: boolean;
+};
+export type LoopExportOptions = {
+    loop: string;
+    out: string;
+    project?: string;
+    json?: boolean;
+};
+export type LoopImportOptions = {
+    in: string;
+    as?: string;
+    project?: string;
+    json?: boolean;
+};
+/** `--project`, else the nearest project root above cwd, else cwd. */
+export declare function resolveLoopProjectRoot(project: string | undefined): string;
+/** `--project` + `--json`, the option chain `loop export` and `loop import` share. */
+export declare const LOOP_EXPORT_IMPORT_OPTS: (cmd: Command) => Command;

package/dist/cli/commands/loop-command-shared.js

@@ -0,0 +1,15 @@
+// src/cli/commands/loop-command-shared.ts
+//
+// What the `peaks loop` verbs share: the option types, the `--project` /
+// `--json` chain `export` and `import` both declare, and the project-root
+// resolution. Split out of `loop-commands.ts` so the bundle verbs can live in
+// their own modules without repeating the same eight-line construction.
+import { findProjectRoot } from '../../services/config/config-safety.js';
+/** `--project`, else the nearest project root above cwd, else cwd. */
+export function resolveLoopProjectRoot(project) {
+    return project ?? findProjectRoot(process.cwd()) ?? process.cwd();
+}
+/** `--project` + `--json`, the option chain `loop export` and `loop import` share. */
+export const LOOP_EXPORT_IMPORT_OPTS = (cmd) => cmd
+    .option('--project <path>', 'target project root (defaults to cwd)')
+    .option('--json', 'print machine-readable JSON envelope');

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

@@ -1,26 +1,21 @@
 /**
  * peaks loop * CLI (Slice #14 + M7 add).
  *
- * Slices:
  *   #14 sub-features (L4 Agent Loop integration): distill / preflight /
- *     detect-pattern / check-consistency / peaks goal compose.
+ *     detect-pattern / check-consistency, plus `peaks goal compose`.
  *
- *   M7 (2026-07-07 spec §7A.2):
- *     peaks loop export --loop <id> --out <path.tar.gz>
- *     peaks loop import --in <path.tar.gz> [--as <loop-id>]
+ *   M7 (2026-07-07 spec §7A.2): `peaks loop export --loop <id> --out <p.tar.gz>`
+ *     and `peaks loop import --in <p.tar.gz> [--as <loop-id>]`. `export` reads
+ *     the loop_release + relations + bees + evidence briefs and hard-blocks on
+ *     `shareable=false`; `import` validates `format_version_major=1` and lands
+ *     the release as `candidate` (spec §7A.2) — the receiver must run an
+ *     independent evaluation before promoting to `stable`. M7 only ADDs these
+ *     two verbs; the existing 14.x surface is not modified.
  *
- * `peaks loop export` reads the source loop_release + relations +
- * related bees + evidence briefs and emits a `peaks.bundle/1`
- * tar.gz. Hard-blocks when the source has `shareable=false`.
- *
- * `peaks loop import` extracts a bundle, validates
- * format_version_major=1, and lands the release as `candidate`
- * (mandatory landing status per spec §7A.2). The receiver must run
- * an independent evaluation before promoting to `stable`.
- *
- * The existing 14.x commands are kept under the same `loop` parent;
- * M7 only ADDs export / import — it does not modify the existing
- * surface.
+ * This module owns the `loop` parent, the registrar order, and `distill` — the
+ * one verb that spawns a child process, kept here so the `node:child_process`
+ * import stays on the module `tests/unit/spawn-windows-hide-guard.test.ts`
+ * pins it to. Every other verb lives beside this file, one module per verb.
  */
 import type { Command } from 'commander';
 import { type ProgramIO } from '../cli-helpers.js';

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

@@ -1,263 +1,81 @@
 /**
  * peaks loop * CLI (Slice #14 + M7 add).
  *
- * Slices:
  *   #14 sub-features (L4 Agent Loop integration): distill / preflight /
- *     detect-pattern / check-consistency / peaks goal compose.
+ *     detect-pattern / check-consistency, plus `peaks goal compose`.
  *
- *   M7 (2026-07-07 spec §7A.2):
- *     peaks loop export --loop <id> --out <path.tar.gz>
- *     peaks loop import --in <path.tar.gz> [--as <loop-id>]
+ *   M7 (2026-07-07 spec §7A.2): `peaks loop export --loop <id> --out <p.tar.gz>`
+ *     and `peaks loop import --in <p.tar.gz> [--as <loop-id>]`. `export` reads
+ *     the loop_release + relations + bees + evidence briefs and hard-blocks on
+ *     `shareable=false`; `import` validates `format_version_major=1` and lands
+ *     the release as `candidate` (spec §7A.2) — the receiver must run an
+ *     independent evaluation before promoting to `stable`. M7 only ADDs these
+ *     two verbs; the existing 14.x surface is not modified.
  *
- * `peaks loop export` reads the source loop_release + relations +
- * related bees + evidence briefs and emits a `peaks.bundle/1`
- * tar.gz. Hard-blocks when the source has `shareable=false`.
- *
- * `peaks loop import` extracts a bundle, validates
- * format_version_major=1, and lands the release as `candidate`
- * (mandatory landing status per spec §7A.2). The receiver must run
- * an independent evaluation before promoting to `stable`.
- *
- * The existing 14.x commands are kept under the same `loop` parent;
- * M7 only ADDs export / import — it does not modify the existing
- * surface.
+ * This module owns the `loop` parent, the registrar order, and `distill` — the
+ * one verb that spawns a child process, kept here so the `node:child_process`
+ * import stays on the module `tests/unit/spawn-windows-hide-guard.test.ts`
+ * pins it to. Every other verb lives beside this file, one module per verb.
  */
-import { existsSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
 import { fail, ok } from 'peaks-loop-shared/result';
-import { findProjectRoot } from '../../services/config/config-safety.js';
-import { openStateDb } from '../../services/skillhub/sqlite-store.js';
-import { writeBundle, BundleNotShareableError, BundleAssetNotFoundError } from '../../services/share/bundle-writer.js';
-import { readBundle, BundleMajorVersionMismatchError, BundleSchemaVersionsMismatchError, BundleImportToStableForbiddenError, BundleMalformedError } from '../../services/share/bundle-reader.js';
+import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
+import { registerLoopExportCommand } from './loop-export-command.js';
+import { registerLoopGoalComposeCommand } from './loop-goal-compose-command.js';
+import { registerLoopImportCommand } from './loop-import-command.js';
+import { registerLoopPlaceholderCommands } from './loop-placeholder-commands.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((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 *
+    // 14.5 peaks goal compose — a TOP-LEVEL command (not under `peaks loop`),
+    // because IDE adapters expose it as `goalCommand`.
+    registerLoopGoalComposeCommand(program, io);
     const loop = program
         .command('loop')
         .description('Slice #14: L4 Agent Loop sub-features (distill / preflight / detect-pattern / check-consistency)');
-    // 14.1 distill
+    registerLoopDistillCommand(loop, io);
+    registerLoopPlaceholderCommands(loop, io);
+    registerLoopExportCommand(loop, io);
+    registerLoopImportCommand(loop, io);
+}
+/**
+ * 14.1 distill — delegate to `peaks memory extract` through a dynamic
+ * `node:child_process` import (no static import, so the command layer does not
+ * load `child_process` for verbs that never spawn). The LLM-side UX layer
+ * composes the two commands.
+ */
+function registerLoopDistillCommand(loop, io) {
     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'],
-                windowsHide: true
-            }).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);
+            printResult(io, ok('loop.distill', await extractMemoryViaDelegate(options), [], distillNextActions(options)), 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((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((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((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);
-    });
-    // ---------- M7: peaks loop export / import (spec §7A.2) ----------
-    const LOOP_EXPORT_IMPORT_OPTS = (cmd) => cmd
-        .option('--project <path>', 'target project root (defaults to cwd)')
-        .option('--json', 'print machine-readable JSON envelope');
-    LOOP_EXPORT_IMPORT_OPTS(loop
-        .command('export')
-        .description('M7: export a loop_release as a peaks.bundle/1 tarball (spec §7A.2 / §10 RL-9). Refuses to export when shareable=false.')
-        .requiredOption('--loop <id>', 'loop_release id (kebab-case)')
-        .requiredOption('--out <path>', 'output .tar.gz path')).action((options) => {
-        const asJson = options.json === true;
-        try {
-            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            if (!existsSync(join(projectRoot, '.peaks'))) {
-                mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
-            }
-            const db = openStateDb(join(projectRoot, '.peaks', 'state.db'));
-            try {
-                const result = writeBundle({
-                    db,
-                    blobsDir: join(projectRoot, '.peaks', 'blobs'),
-                    kind: 'loop',
-                    id: options.loop,
-                    outPath: options.out
-                });
-                printResult(io, ok('loop.export', {
-                    outPath: result.outPath,
-                    kind: result.kind,
-                    assetId: result.assetId,
-                    importedAs: 'candidate'
-                }, [], [
-                    `Receiver must run \`peaks loop import --in ${result.outPath}\` to land this bundle, then run an independent evolution_evaluation before any promote.`
-                ]), asJson);
-            }
-            finally {
-                db.close();
-            }
-        }
-        catch (error) {
-            if (error instanceof BundleNotShareableError) {
-                printResult(io, fail('loop.export', error.code, error.message, { ok: false, loop: options.loop }, ['Set shareable=true on the loop_release row, or share via desktop_visible=false.']), asJson);
-                process.exitCode = 1;
-                return;
-            }
-            if (error instanceof BundleAssetNotFoundError) {
-                printResult(io, fail('loop.export', error.code, error.message, { ok: false, loop: options.loop }, ['Verify the loop id with `peaks asset status --loop <id>`.']), asJson);
-                process.exitCode = 1;
-                return;
-            }
-            printResult(io, fail('loop.export', 'LOOP_EXPORT_FAILED', getErrorMessage(error), { ok: false, loop: options.loop }, ['Verify --loop id and --out path.']), asJson);
-            process.exitCode = 1;
-        }
-    });
-    LOOP_EXPORT_IMPORT_OPTS(loop
-        .command('import')
-        .description('M7: import a peaks.bundle/1 tarball. Lands as candidate only — promotion requires an evolution_evaluation row (spec §7A.2 / §10 RL-9 / AC-25 / AC-26).')
-        .requiredOption('--in <path>', 'input .tar.gz path')
-        .option('--as <id>', 'optional rename for the loop id when landing')).action((options) => {
-        const asJson = options.json === true;
-        try {
-            const projectRoot = options.project ?? findProjectRoot(process.cwd()) ?? process.cwd();
-            if (!existsSync(join(projectRoot, '.peaks'))) {
-                mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
-            }
-            const db = openStateDb(join(projectRoot, '.peaks', 'state.db'));
-            try {
-                const result = readBundle({
-                    db,
-                    blobsDir: join(projectRoot, '.peaks', 'blobs'),
-                    inPath: options.in,
-                    ...(options.as !== undefined ? { asName: options.as } : {})
-                });
-                printResult(io, ok('loop.import', {
-                    assetId: result.assetId,
-                    kind: result.kind,
-                    importedAs: result.importedAs,
-                    warnings: result.warnings,
-                    evidenceBriefCount: result.evidenceBriefCount
-                }, result.warnings, [
-                    `Run an independent evaluation against this release before promoting; peaks loop promote refuses without an evolution_evaluation row.`
-                ]), asJson);
-            }
-            finally {
-                db.close();
-            }
-        }
-        catch (error) {
-            if (error instanceof BundleMajorVersionMismatchError) {
-                printResult(io, fail('loop.import', error.code, error.message, { ok: false, receivedMajor: error.receivedMajor }, [
-                    'Use the matching peaks.bundle/<major> reader; this peaks build only supports major=1.'
-                ]), asJson);
-                process.exitCode = 1;
-                return;
-            }
-            if (error instanceof BundleSchemaVersionsMismatchError) {
-                printResult(io, fail('loop.import', error.code, error.message, { ok: false }, [
-                    'Source bundle did not declare the canonical schema versions; refuse the bundle.'
-                ]), asJson);
-                process.exitCode = 1;
-                return;
-            }
-            if (error instanceof BundleImportToStableForbiddenError) {
-                printResult(io, fail('loop.import', error.code, error.message, { ok: false }, [
-                    'Bundles always land as candidate; promotion to stable requires an evolution_evaluation row (AC-26).'
-                ]), asJson);
-                process.exitCode = 1;
-                return;
-            }
-            if (error instanceof BundleMalformedError) {
-                printResult(io, fail('loop.import', error.code, error.message, { ok: false, inPath: options.in }, ['Re-export from the source via `peaks loop export`.']), asJson);
-                process.exitCode = 1;
-                return;
-            }
-            printResult(io, fail('loop.import', 'LOOP_IMPORT_FAILED', getErrorMessage(error), { ok: false, inPath: options.in }, ['Verify the bundle path and integrity.']), asJson);
-            process.exitCode = 1;
-        }
-    });
+}
+/** Spawn `peaks memory extract` and report the first 200 bytes of its stdout. */
+async function extractMemoryViaDelegate(options) {
+    const apply = options.apply === true;
+    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'],
+        windowsHide: true
+    }).toString('utf-8');
+    return { project: options.project, apply, delegateStdout: stdout.slice(0, 200) };
+}
+/** The two sentences `loop.distill` tells the caller about what it just ran. */
+function distillNextActions(options) {
+    return [
+        options.apply === true
+            ? 'peaks memory extract --apply was invoked'
+            : 'peaks memory extract dry-run was invoked',
+        'A future slice will inline the memory extract (not via execFileSync).'
+    ];
 }

package/dist/cli/commands/loop-export-command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerLoopExportCommand(loop: Command, io: ProgramIO): void;

package/dist/cli/commands/loop-export-command.js

@@ -0,0 +1,73 @@
+// src/cli/commands/loop-export-command.ts
+//
+// `peaks loop export` (M7, spec §7A.2) — export a loop_release as a
+// `peaks.bundle/1` tarball, hard-blocked when the source has `shareable=false`.
+// Extracted from `loop-commands.ts`; the registered name, description, options,
+// refusal codes and envelope are unchanged.
+import { existsSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { fail, getErrorMessage, ok } from 'peaks-loop-shared/result';
+import { openStateDb } from '../../services/skillhub/sqlite-store.js';
+import { BundleAssetNotFoundError, BundleNotShareableError, writeBundle } from '../../services/share/bundle-writer.js';
+import { printResult } from '../cli-helpers.js';
+import { LOOP_EXPORT_IMPORT_OPTS, resolveLoopProjectRoot } from './loop-command-shared.js';
+export function registerLoopExportCommand(loop, io) {
+    LOOP_EXPORT_IMPORT_OPTS(loop
+        .command('export')
+        .description('M7: export a loop_release as a peaks.bundle/1 tarball (spec §7A.2 / §10 RL-9). Refuses to export when shareable=false.')
+        .requiredOption('--loop <id>', 'loop_release id (kebab-case)')
+        .requiredOption('--out <path>', 'output .tar.gz path')).action((options) => {
+        const asJson = options.json === true;
+        try {
+            const result = exportLoopBundle(options);
+            printResult(io, ok('loop.export', {
+                outPath: result.outPath,
+                kind: result.kind,
+                assetId: result.assetId,
+                importedAs: 'candidate'
+            }, [], [
+                `Receiver must run \`peaks loop import --in ${result.outPath}\` to land this bundle, then run an independent evolution_evaluation before any promote.`
+            ]), asJson);
+        }
+        catch (error) {
+            const refusal = exportRefusal(error, options.loop) ??
+                fail('loop.export', 'LOOP_EXPORT_FAILED', getErrorMessage(error), { ok: false, loop: options.loop }, ['Verify --loop id and --out path.']);
+            printResult(io, refusal, asJson);
+            process.exitCode = 1;
+        }
+    });
+}
+/** Open `<projectRoot>/.peaks/state.db` (creating `.peaks/`) and write the bundle. */
+function exportLoopBundle(options) {
+    const projectRoot = resolveLoopProjectRoot(options.project);
+    if (!existsSync(join(projectRoot, '.peaks'))) {
+        mkdirSync(join(projectRoot, '.peaks'), { recursive: true });
+    }
+    const db = openStateDb(join(projectRoot, '.peaks', 'state.db'));
+    try {
+        return writeBundle({
+            db,
+            blobsDir: join(projectRoot, '.peaks', 'blobs'),
+            kind: 'loop',
+            id: options.loop,
+            outPath: options.out
+        });
+    }
+    finally {
+        db.close();
+    }
+}
+/** The two named refusals `writeBundle` raises, or `null` for anything else. */
+function exportRefusal(error, loop) {
+    if (error instanceof BundleNotShareableError) {
+        return fail('loop.export', error.code, error.message, { ok: false, loop }, [
+            'Set shareable=true on the loop_release row, or share via desktop_visible=false.'
+        ]);
+    }
+    if (error instanceof BundleAssetNotFoundError) {
+        return fail('loop.export', error.code, error.message, { ok: false, loop }, [
+            'Verify the loop id with `peaks asset status --loop <id>`.'
+        ]);
+    }
+    return null;
+}

package/dist/cli/commands/loop-goal-compose-command.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export declare function registerLoopGoalComposeCommand(program: Command, io: ProgramIO): void;