peaks-loop 4.1.2 → 4.1.4

package/dist/cli/commands/core/session-command.js

@@ -1,10 +1,3 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { getSessionMeta, rotateSessionBinding, setSessionTitle, listSessionMetas } from '../../../services/session/session-manager.js';
-import { resolveCanonicalProjectRoot } from '../../../services/config/config-service.js';
-import { findProjectRoot } from '../../../services/config/config-safety.js';
-import { fail, ok } from 'peaks-loop-shared/result';
-import { addJsonOption, getErrorMessage, printResult } from '../../cli-helpers.js';
 // `peaks session checkpoint` and `peaks session resume` subcommands
 // EAGERLY so they appear in `peaks session --help` output. The
 // previous lazy import ran AFTER commander had already produced
@@ -22,174 +15,20 @@ import { registerSessionMigrateSkillNameCommand } from '../session-migrate-skill
 // appear in `peaks session --help` for LLM `<TAB>`-discovery.
 import { registerSession24hModeCommand } from '../session-24h-mode.js';
 import { registerSpillDemoCommand } from '../spill-demo-command.js';
+import { registerSessionInfoCommand } from './session-info-command.js';
+import { registerSessionListCommand, registerSessionRotateCommand, registerSessionTitleCommand } from './session-verb-commands.js';
 export function registerSessionCommand(program, io) {
     const session = program.command('session').description('Manage Peaks session directories');
-    addJsonOption(session.command('list').description('List all session directories with titles and metadata')).action((options) => {
-        const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
-        const metas = listSessionMetas(projectRoot);
-        printResult(io, ok('session.list', { sessions: metas, total: metas.length }), options.json);
-    });
-    addJsonOption(session
-        .command('info [sessionId]')
-        .description('Show full metadata for a session directory. Pass --active to resolve the canonical binding from .peaks/_runtime/session.json (the "one command a sub-agent runs to find the parent\'s sid" primitive). Slice 021: --active is the SOLE authoritative way to look up the active session id; the on-disk file path is internal and must NOT be `cat`-ed directly.')
-        .option('--active', 'resolve the canonical session id from .peaks/_runtime/session.json (ignores [sessionId] when set)')
-        .option('--project <path>', 'target project root (defaults to git root or cwd). Slice 021: lets sub-agents skip the cwd heuristic and look up the binding for a specific repo.')
-        // overrides the per-process PEAKS_CALLER_ID env var and the
-        // PLATFORM_FALLBACKS table (D4 priority). The resolved callerId is
-        // surfaced in the JSON envelope so callers can confirm what was
-        // resolved without re-deriving it.
-        .option('--caller-id <id>', 'Override the caller id for this invocation (D4 priority: flag beats env beats platform fallback). When set, the response envelope includes the resolved callerId.')).action(async (sessionId, options) => {
-        // (matches the pre-021 behaviour so the existing slice-020 / slice-007
-        // sub-agent flow keeps working unchanged).
-        const projectRoot = options.project !== undefined
-            ? resolveCanonicalProjectRoot(options.project)
-            : (findProjectRoot(process.cwd()) ?? process.cwd());
-        // We use `resolveCallerId` for D1/D5 validation; an invalid flag
-        // throws CallerIdError (D5 → exit 65). A missing flag and no env
-        // and no fallback also throws (D2 → exit 64). The resolved id is
-        // surfaced in the envelope so the caller can audit.
-        if (options.callerId !== undefined) {
-            const { resolveCallerId, CallerIdError } = await import('../../../services/session/resolve-caller-id.js');
-            let callerId;
-            try {
-                callerId = resolveCallerId({ flagValue: options.callerId });
-            }
-            catch (error) {
-                if (error instanceof CallerIdError) {
-                    const code = error.code === 'EX_USAGE' ? 64 : 65;
-                    printResult(io, fail('session.info', 'CALLER_ID_INVALID', error.message, { source: error.source }, [
-                        `Set --caller-id to a value matching ^[a-zA-Z0-9._-]{1,200}$`,
-                        'Or set PEAKS_CALLER_ID env var (or CLAUDE_CODE_SESSION_ID for Claude Code)'
-                    ]), options.json);
-                    process.exitCode = code;
-                    return;
-                }
-                throw error;
-            }
-            // Surface the resolved id in the envelope. When --active is also
-            // passed, look up the binding for this callerId; otherwise
-            // just emit the resolved id so the caller knows what was used.
-            if (options.active === true) {
-                const { getSessionIdCanonical } = await import('../../../services/session/session-manager.js');
-                const { getCallerBinding } = await import('../../../services/session/caller-binding-service.js');
-                const activeSid = getSessionIdCanonical(projectRoot);
-                const callerBinding = getCallerBinding(projectRoot, callerId);
-                // reports. Callers / migration tooling can detect pre-migration trees
-                // by inspecting `source === 'legacy'`.
-                const bindingSource = existsSync(join(projectRoot, '.peaks', '_runtime', 'session.json'))
-                    ? 'canonical'
-                    : 'legacy';
-                printResult(io, ok('session.info', {
-                    active: true,
-                    sessionId: activeSid,
-                    callerId,
-                    callerBindingPeakSessionId: callerBinding?.peakSessionId ?? null,
-                    source: bindingSource
-                }), options.json);
-                return;
-            }
-            printResult(io, ok('session.info', {
-                callerId,
-                note: '--caller-id resolved; pass --active to also look up the bound peak session'
-            }), options.json);
-            return;
-        }
-        // does not know the parent's sid reads it from the binding via
-        // SOLE authoritative discovery primitive: it composes on
-        // getSessionIdCanonical (canonicalize-on-read; handles the stored
-        // "projectRoot: '.'" vs caller-passed absolute realpath mismatch
-        // that the F22 fix addressed) AND falls through to getSessionId
-        // (strict-equality) for callers on the original contract. NEITHER
-        // path may call ensureSession() — that would side-effect-create a
-        // fresh binding on miss, erasing the "no active session" signal
-        // sub-agents rely on.
-        if (options.active === true) {
-            // Import lazily to avoid a cycle with workspace-commands.
-            const { getSessionIdCanonical, getSessionId } = await import('../../../services/session/session-manager.js');
-            // 1. Canonicalize-on-read first.
-            let activeSid = getSessionIdCanonical(projectRoot);
-            // 2. Fall through to the strict-equality reader if the canonical
-            //    miss is a projectRoot-form mismatch (e.g. the binding was
-            //    written with the absolute realpath but the caller's form
-            //    normalizes differently). The 2-read fan-out mirrors the
-            //    fallback ensureSession() uses.
-            if (activeSid === null) {
-                activeSid = getSessionId(projectRoot);
-            }
-            if (activeSid === null) {
-                // 3. No binding at all — fail loudly, NO crash, NO side-effect,
-                //    exit 1, message must point at `peaks workspace init`
-                //    (the canonical "first action" command, not the legacy
-                //    "or `peaks skill presence:set`" hedge that the pre-021
-                //    wording used — presence:set would also need a binding to
-                //    resolve the parent sid, so it's not actually a bootstrap
-                //    path).
-                printResult(io, fail('session.info', 'NO_ACTIVE_SESSION', 'No session bound. Run `peaks workspace init --project <repo> --json` to bind one.', { projectRoot }, [`peaks workspace init --project ${projectRoot} --json`]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            // 4. Determine the on-disk source so callers (and future
-            //    migration tooling) can detect pre-migration trees. The
-            //    contract).
-            const bindingSource = existsSync(join(projectRoot, '.peaks', '_runtime', 'session.json'))
-                ? 'canonical'
-                : 'legacy';
-            // surface a warning so callers (and humans tailing the JSON)
-            // see "this tree has not been reconciled to the canonical
-            // home yet". The warning is informational; the binding is
-            // contract). `warnings` is a top-level envelope field, not a
-            // data field, so it goes through ok()'s 3rd positional arg.
-            const legacyWarnings = bindingSource === 'legacy'
-                ? [
-                    'Read from legacy back-compat path .peaks/.session.json. Run `peaks workspace reconcile --apply` to migrate to the canonical home (.peaks/_runtime/session.json).'
-                ]
-                : [];
-            printResult(io, ok('session.info', {
-                active: true,
-                sessionId: activeSid,
-                bindingPath: bindingSource === 'canonical'
-                    ? join(projectRoot, '.peaks', '_runtime', 'session.json')
-                    : join(projectRoot, '.peaks', '.session.json'),
-                projectRoot,
-                source: bindingSource
-            }, legacyWarnings), options.json);
-            return;
-        }
-        if (sessionId === undefined) {
-            printResult(io, fail('session.info', 'SESSION_ID_REQUIRED', 'session.info requires a <sessionId> or --active', {}, ['Pass a <sessionId> argument, or use --active to resolve the canonical binding']), options.json);
-            process.exitCode = 1;
-            return;
-        }
-        const meta = getSessionMeta(projectRoot, sessionId);
-        if (meta === null) {
-            printResult(io, fail('session.info', 'SESSION_NOT_FOUND', `Session "${sessionId}" not found or has no metadata`, { sessionId }, ['Use `peaks session list` to see available sessions']), options.json);
-            process.exitCode = 1;
-            return;
-        }
-        printResult(io, ok('session.info', meta), options.json);
-    });
-    addJsonOption(session
-        .command('title <sessionId> <title>')
-        .description('Set a human-readable title for a session directory')).action((sessionId, title, options) => {
-        const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
-        try {
-            const meta = setSessionTitle(projectRoot, sessionId, title);
-            printResult(io, ok('session.title', meta), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('session.title', 'SESSION_TITLE_FAILED', getErrorMessage(error), { sessionId }, [
-                'Verify the sessionId exists under .peaks/'
-            ]), options.json);
-            process.exitCode = 1;
-        }
-    });
+    registerSessionListCommand(session, io);
+    registerSessionInfoCommand(session, io);
+    registerSessionTitleCommand(session, io);
     // Skill-level primitives — the LLM is the decision-maker; CLI is the muscle.
-    // via `void (async () => …)`) so commander walks the subcommand
-    // tree synchronously and `peaks session --help` includes both
-    // `checkpoint` and `resume`. The previous async-IIFE registered
-    // them on a microtask tick AFTER the program-level help builder
-    // had already serialised its output, so they were hidden from
-    // `<TAB>`-discovery and the LLM never saw them.
+    // Registered synchronously (rather than via `void (async () => …)`) so
+    // commander walks the subcommand tree synchronously and
+    // `peaks session --help` includes both `checkpoint` and `resume`. The
+    // previous async-IIFE registered them on a microtask tick AFTER the
+    // program-level help builder had already serialised its output, so they
+    // were hidden from `<TAB>`-discovery and the LLM never saw them.
     registerSessionCheckpointCommand(session, io);
     registerSessionResumeCommand(session, io);
     // Slice 2 of the peaks-code → peaks-code rename plan:
@@ -200,38 +39,5 @@ export function registerSessionCommand(program, io) {
     registerSessionMigrateSkillNameCommand(session);
     registerSession24hModeCommand(session, io);
     registerSpillDemoCommand(session, io);
-    addJsonOption(session
-        .command('rotate')
-        .description('Drop the project-level session binding so the next peaks call auto-generates a fresh session id. The on-disk session directory is left intact — only .peaks/.session.json is removed.')
-        .option('--project <path>', 'target project root (defaults to git root or cwd)')
-        .option('--reason <text>', 'human-readable reason for the rotation, recorded in the response data')).action((options) => {
-        try {
-            // Canonicalise the project root before touching the binding.
-            // `peaks workspace init` writes the binding with the
-            // realpath-resolved projectRoot; if the caller passes a path
-            // through a symlink (notably /tmp on macOS, which is a
-            // symlink to /private/tmp) without canonicalising here,
-            // readSessionFile's strict projectRoot equality check fails
-            // and the rotate call reports "no prior binding" even
-            // though one exists. The same fix as `workspace init`
-            // (b193714): promote the path to the git root, falling back
-            // to the heuristic, falling back to cwd verbatim.
-            const projectRoot = options.project !== undefined
-                ? options.project
-                : (findProjectRoot(process.cwd()) ?? process.cwd());
-            const canonical = resolveCanonicalProjectRoot(projectRoot);
-            const previousSessionId = rotateSessionBinding(canonical);
-            printResult(io, ok('session.rotate', {
-                previousSessionId,
-                ...(options.reason !== undefined ? { reason: options.reason } : {}),
-                note: previousSessionId === null
-                    ? 'No prior binding was present; the project is already unbound.'
-                    : 'Next ensureSession() call will auto-generate a fresh id. The previous session directory is still on disk at .peaks/_runtime/<previousSessionId>/.'
-            }), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('session.rotate', 'SESSION_ROTATE_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Verify the project path exists and is writable']), options.json);
-            process.exitCode = 1;
-        }
-    });
+    registerSessionRotateCommand(session, io);
 }

package/dist/cli/commands/core/session-info-command.d.ts

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

package/dist/cli/commands/core/session-info-command.js

@@ -0,0 +1,142 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { getSessionMeta } from '../../../services/session/session-manager.js';
+import { resolveCanonicalProjectRoot } from '../../../services/config/config-service.js';
+import { findProjectRoot } from '../../../services/config/config-safety.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { addJsonOption, printResult } from '../../cli-helpers.js';
+/** Exit codes for a rejected `--caller-id`, by the resolver's own errno. */
+const EXIT_USAGE = 64;
+const EXIT_DATAERR = 65;
+/** The advisory that rides every read off the pre-canonical binding dotfile. */
+const LEGACY_WARNING = 'Read from legacy back-compat path .peaks/.session.json. Run `peaks workspace reconcile --apply` to migrate to the canonical home (.peaks/_runtime/session.json).';
+/** `canonical` = `.peaks/_runtime/session.json`; `legacy` = `.peaks/.session.json`. */
+function bindingSourceOf(projectRoot) {
+    return existsSync(join(projectRoot, '.peaks', '_runtime', 'session.json'))
+        ? 'canonical'
+        : 'legacy';
+}
+function bindingPathOf(projectRoot, source) {
+    return source === 'canonical'
+        ? join(projectRoot, '.peaks', '_runtime', 'session.json')
+        : join(projectRoot, '.peaks', '.session.json');
+}
+/** A `--caller-id` the resolver rejected (D5 → exit 65; EX_USAGE → exit 64). */
+function emitCallerIdInvalid(io, options, error) {
+    printResult(io, fail('session.info', 'CALLER_ID_INVALID', error.message, { source: error.source }, [
+        `Set --caller-id to a value matching ^[a-zA-Z0-9._-]{1,200}$`,
+        'Or set PEAKS_CALLER_ID env var (or CLAUDE_CODE_SESSION_ID for Claude Code)'
+    ]), options.json);
+    process.exitCode = error.code === 'EX_USAGE' ? EXIT_USAGE : EXIT_DATAERR;
+}
+/**
+ * `--caller-id` together with `--active`: look up the binding this callerId
+ * holds, so the envelope carries both the resolved id and its peak session.
+ */
+async function emitCallerBinding(io, options, projectRoot, callerId) {
+    const { getSessionIdCanonical } = await import('../../../services/session/session-manager.js');
+    const { getCallerBinding } = await import('../../../services/session/caller-binding-service.js');
+    const callerBinding = getCallerBinding(projectRoot, callerId);
+    printResult(io, ok('session.info', {
+        active: true,
+        sessionId: getSessionIdCanonical(projectRoot),
+        callerId,
+        callerBindingPeakSessionId: callerBinding?.peakSessionId ?? null,
+        source: bindingSourceOf(projectRoot)
+    }), options.json);
+}
+/**
+ * Resolve `--caller-id` (D1/D5 validation) and report it. An invalid flag
+ * throws `CallerIdError`, which is surfaced as `CALLER_ID_INVALID`; anything
+ * else propagates.
+ */
+async function emitCallerIdPath(io, options, projectRoot, flagValue) {
+    const { resolveCallerId, CallerIdError } = await import('../../../services/session/resolve-caller-id.js');
+    let callerId;
+    try {
+        callerId = resolveCallerId({ flagValue });
+    }
+    catch (error) {
+        if (error instanceof CallerIdError) {
+            emitCallerIdInvalid(io, options, error);
+            return;
+        }
+        throw error;
+    }
+    if (options.active === true) {
+        await emitCallerBinding(io, options, projectRoot, callerId);
+        return;
+    }
+    printResult(io, ok('session.info', {
+        callerId,
+        note: '--caller-id resolved; pass --active to also look up the bound peak session'
+    }), options.json);
+}
+/**
+ * `--active` without `--caller-id`: the SOLE authoritative lookup of the
+ * active session id — composes on `getSessionIdCanonical`
+ * (canonicalize-on-read) and falls through to `getSessionId`
+ * (strict-equality) for callers on the original contract. NEITHER path calls
+ * `ensureSession()` — that would side-effect-create a fresh binding on miss,
+ * erasing the "no active session" signal sub-agents rely on.
+ */
+async function emitActiveBinding(io, options, projectRoot) {
+    const { getSessionIdCanonical, getSessionId } = await import('../../../services/session/session-manager.js');
+    let activeSid = getSessionIdCanonical(projectRoot);
+    if (activeSid === null)
+        activeSid = getSessionId(projectRoot);
+    if (activeSid === null) {
+        printResult(io, fail('session.info', 'NO_ACTIVE_SESSION', 'No session bound. Run `peaks workspace init --project <repo> --json` to bind one.', { projectRoot }, [`peaks workspace init --project ${projectRoot} --json`]), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    const source = bindingSourceOf(projectRoot);
+    printResult(io, ok('session.info', {
+        active: true,
+        sessionId: activeSid,
+        bindingPath: bindingPathOf(projectRoot, source),
+        projectRoot,
+        source
+    }, source === 'legacy' ? [LEGACY_WARNING] : []), options.json);
+}
+/** Explicit `<sessionId>`: read that session's metadata, or refuse. */
+function emitSessionById(io, sessionId, options, projectRoot) {
+    if (sessionId === undefined) {
+        printResult(io, fail('session.info', 'SESSION_ID_REQUIRED', 'session.info requires a <sessionId> or --active', {}, ['Pass a <sessionId> argument, or use --active to resolve the canonical binding']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    const meta = getSessionMeta(projectRoot, sessionId);
+    if (meta === null) {
+        printResult(io, fail('session.info', 'SESSION_NOT_FOUND', `Session "${sessionId}" not found or has no metadata`, { sessionId }, ['Use `peaks session list` to see available sessions']), options.json);
+        process.exitCode = 1;
+        return;
+    }
+    printResult(io, ok('session.info', meta), options.json);
+}
+async function runSessionInfo(io, sessionId, options) {
+    const projectRoot = options.project !== undefined
+        ? resolveCanonicalProjectRoot(options.project)
+        : (findProjectRoot(process.cwd()) ?? process.cwd());
+    if (options.callerId !== undefined) {
+        await emitCallerIdPath(io, options, projectRoot, options.callerId);
+        return;
+    }
+    if (options.active === true) {
+        await emitActiveBinding(io, options, projectRoot);
+        return;
+    }
+    emitSessionById(io, sessionId, options, projectRoot);
+}
+export function registerSessionInfoCommand(session, io) {
+    addJsonOption(session
+        .command('info [sessionId]')
+        .description('Show full metadata for a session directory. Pass --active to resolve the canonical binding from .peaks/_runtime/session.json (the "one command a sub-agent runs to find the parent\'s sid" primitive). Slice 021: --active is the SOLE authoritative way to look up the active session id; the on-disk file path is internal and must NOT be `cat`-ed directly.')
+        .option('--active', 'resolve the canonical session id from .peaks/_runtime/session.json (ignores [sessionId] when set)')
+        .option('--project <path>', 'target project root (defaults to git root or cwd). Slice 021: lets sub-agents skip the cwd heuristic and look up the binding for a specific repo.')
+        // overrides the per-process PEAKS_CALLER_ID env var and the
+        // PLATFORM_FALLBACKS table (D4 priority). The resolved callerId is
+        // surfaced in the JSON envelope so callers can confirm what was
+        // resolved without re-deriving it.
+        .option('--caller-id <id>', 'Override the caller id for this invocation (D4 priority: flag beats env beats platform fallback). When set, the response envelope includes the resolved callerId.')).action((sessionId, options) => runSessionInfo(io, sessionId, options));
+}

package/dist/cli/commands/core/session-verb-commands.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../../cli-helpers.js';
+export declare function registerSessionListCommand(session: Command, io: ProgramIO): void;
+export declare function registerSessionTitleCommand(session: Command, io: ProgramIO): void;
+export declare function registerSessionRotateCommand(session: Command, io: ProgramIO): void;

package/dist/cli/commands/core/session-verb-commands.js

@@ -0,0 +1,58 @@
+import { listSessionMetas, rotateSessionBinding, setSessionTitle } from '../../../services/session/session-manager.js';
+import { resolveCanonicalProjectRoot } from '../../../services/config/config-service.js';
+import { findProjectRoot } from '../../../services/config/config-safety.js';
+import { fail, ok } from 'peaks-loop-shared/result';
+import { addJsonOption, getErrorMessage, printResult } from '../../cli-helpers.js';
+export function registerSessionListCommand(session, io) {
+    addJsonOption(session.command('list').description('List all session directories with titles and metadata')).action((options) => {
+        const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+        const metas = listSessionMetas(projectRoot);
+        printResult(io, ok('session.list', { sessions: metas, total: metas.length }), options.json);
+    });
+}
+export function registerSessionTitleCommand(session, io) {
+    addJsonOption(session
+        .command('title <sessionId> <title>')
+        .description('Set a human-readable title for a session directory')).action((sessionId, title, options) => {
+        const projectRoot = findProjectRoot(process.cwd()) ?? process.cwd();
+        try {
+            const meta = setSessionTitle(projectRoot, sessionId, title);
+            printResult(io, ok('session.title', meta), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('session.title', 'SESSION_TITLE_FAILED', getErrorMessage(error), { sessionId }, [
+                'Verify the sessionId exists under .peaks/'
+            ]), options.json);
+            process.exitCode = 1;
+        }
+    });
+}
+export function registerSessionRotateCommand(session, io) {
+    addJsonOption(session
+        .command('rotate')
+        .description('Drop the project-level session binding so the next peaks call auto-generates a fresh session id. The on-disk session directory is left intact — only .peaks/.session.json is removed.')
+        .option('--project <path>', 'target project root (defaults to git root or cwd)')
+        .option('--reason <text>', 'human-readable reason for the rotation, recorded in the response data')).action((options) => {
+        try {
+            // Canonicalise the project root before touching the binding: `peaks
+            // workspace init` writes it realpath-resolved, and readSessionFile's
+            // strict projectRoot equality check would otherwise miss a path that
+            // came through a symlink (notably /tmp on macOS).
+            const projectRoot = options.project !== undefined
+                ? options.project
+                : (findProjectRoot(process.cwd()) ?? process.cwd());
+            const previousSessionId = rotateSessionBinding(resolveCanonicalProjectRoot(projectRoot));
+            printResult(io, ok('session.rotate', {
+                previousSessionId,
+                ...(options.reason !== undefined ? { reason: options.reason } : {}),
+                note: previousSessionId === null
+                    ? 'No prior binding was present; the project is already unbound.'
+                    : 'Next ensureSession() call will auto-generate a fresh id. The previous session directory is still on disk at .peaks/_runtime/<previousSessionId>/.'
+            }), options.json);
+        }
+        catch (error) {
+            printResult(io, fail('session.rotate', 'SESSION_ROTATE_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Verify the project path exists and is writable']), options.json);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/cli/commands/core/skill-command.d.ts

@@ -1,47 +1,4 @@
 import type { Command } from 'commander';
-import type { AutoCompactMode } from '../../../services/code/auto-compact-modes.js';
-/**
- * Canonicalize a user-supplied `--project <path>` value.
- *
- * Git Bash on Windows hands us forward-slash paths
- * (`C:/Users/.../peaks-loop`) while `peaks workspace init` writes the
- * backslash form, and either side may carry a trailing separator or
- * differing case. Resolving to the real path here means every
- * downstream consumer (`getSessionId`, `setSessionMeta`,
- * `setSkillPresence`) sees one stable form.
- *
- * Returns the input unchanged when it cannot be resolved (path does
- * not exist yet, or is not readable) so a bad `--project` still
- * reaches the existing error handling rather than throwing here.
- */
-/**
- * The loop-hygiene verdict attached to every ACTIVE `skill.presence` read.
- *
- * Why it lives here instead of only in a SKILL.md body: the zero-pause
- * contract ("auto-compact is the skill's own action, never the user's")
- * was already written into `peaks-code/SKILL.md`, including an explicit
- * ban on the exact phrasing "prompt the user to run `/compact`" — and it
- * was still violated. A SKILL.md body is loaded once and is then
- * compacted away, so the rule stops governing at precisely the moment
- * context pressure makes it matter. `skill.presence` is the one call
- * EVERY skill makes on EVERY turn, in EVERY consumer project and EVERY
- * mode, so a value carried here cannot be forgotten, and no skill has to
- * be edited for the obligation to reach the model.
- *
- * READ-ONLY by contract. It probes and reports; it never compacts.
- * Executing `peaks code auto-compact` stays the skill's own action — a
- * side effect here would fire on every single turn.
- *
- * Failure swallows to `null`: the hygiene verdict is advisory and must
- * never be able to break the presence read itself.
- */
-export declare function buildContextVerdict(ratio: number, mode: AutoCompactMode): {
-    context: {
-        ratioPct: string;
-        action: string;
-        mode: string;
-    };
-    nextActions: string[];
-};
 import { type ProgramIO } from '../../cli-helpers.js';
+export { buildContextVerdict } from './skill-context-verdict.js';
 export declare function registerSkillCommand(program: Command, io: ProgramIO): void;