peaks-loop 4.1.3 → 4.1.4

package/dist/cli/commands/baseline-rollback-commands.js

@@ -0,0 +1,88 @@
+// src/cli/commands/baseline-rollback-commands.ts
+//
+// `peaks baseline rollback` and `peaks baseline reset` — the two destructive
+// baseline operations, both gated behind `--confirm`. Split out of
+// `baseline-commands.ts`; every refusal code, message and data field is
+// unchanged.
+import { copyFileSync, existsSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { readBaselineFile } from '../../services/capability-baseline/store.js';
+import { CURRENT_DIR, fail, HISTORY_DIR, ok } from './baseline-command-shared.js';
+function runRollback(io, opts) {
+    const projectRoot = opts.project ?? '.';
+    if (opts.confirm !== true) {
+        fail(io, 'HUMAN_NL_DECISION_REQUIRED', 'rollback requires the user to approve via AskUserQuestion. The LLM must surface a multi-choice prompt, then re-run with --confirm.');
+        return;
+    }
+    if (!opts.to) {
+        fail(io, 'MISSING_ARG', '--to is required');
+        return;
+    }
+    const source = HISTORY_DIR(projectRoot, opts.to);
+    const from = join(source, 'capability-baseline.json');
+    const fromLock = join(source, 'capability-baseline.lock');
+    if (!existsSync(from) || !existsSync(fromLock)) {
+        fail(io, 'BASELINE_HISTORY_GAP', `no frozen baseline recorded for version ${opts.to}`);
+        return;
+    }
+    const r = readBaselineFile(projectRoot);
+    if (!r.ok) {
+        fail(io, r.error.code, r.error.message);
+        return;
+    }
+    mkdirSync(CURRENT_DIR(projectRoot), { recursive: true });
+    copyFileSync(from, join(CURRENT_DIR(projectRoot), 'capability-baseline.json'));
+    copyFileSync(fromLock, join(CURRENT_DIR(projectRoot), 'capability-baseline.lock'));
+    // Re-read through the locked store so a tampered history entry cannot be
+    // installed: the copy is only reported successful if it verifies.
+    const after = readBaselineFile(projectRoot);
+    if (!after.ok) {
+        fail(io, after.error.code, after.error.message);
+        return;
+    }
+    ok(io, 'baseline.rollback', {
+        fromVersion: r.file.version,
+        toVersion: after.file.version,
+        historyPath: source
+    });
+}
+function runReset(io, opts) {
+    const projectRoot = opts.project ?? '.';
+    if (opts.confirm !== true) {
+        fail(io, 'HUMAN_NL_DECISION_REQUIRED', 'reset requires the user to approve via AskUserQuestion. The LLM must surface a multi-choice prompt, then re-run with --confirm.');
+        return;
+    }
+    const r = readBaselineFile(projectRoot);
+    // A missing baseline is already "wiped" — but an unreadable one (hash
+    // mismatch / unsigned lock) must not be silently discarded.
+    if (!r.ok && r.error.code !== 'BASELINE_NOT_FOUND') {
+        fail(io, r.error.code, r.error.message);
+        return;
+    }
+    const wipedVersion = r.ok ? r.file.version : null;
+    rmSync(join(CURRENT_DIR(projectRoot), 'capability-baseline.json'), { force: true });
+    rmSync(join(CURRENT_DIR(projectRoot), 'capability-baseline.lock'), { force: true });
+    ok(io, 'baseline.reset', {
+        wipedVersion,
+        nextAction: 're-freeze with `baseline freeze --from <path>`'
+    });
+}
+export function registerBaselineRollbackCommand(baseline, io) {
+    baseline
+        .command('rollback')
+        .description("Roll the baseline back to a historical version. --confirm records the user's approval.")
+        .option('--to <version>', 'Historical version to roll back to')
+        .option('--confirm', "Record the user's approval (collected via AskUserQuestion) for this rollback")
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action((opts) => runRollback(io, opts));
+}
+export function registerBaselineResetCommand(baseline, io) {
+    baseline
+        .command('reset')
+        .description("Wipe the current baseline and require a re-freeze. --confirm records the user's approval.")
+        .option('--confirm', "Record the user's approval (collected via AskUserQuestion) for the wipe")
+        .option('--project <path>', 'Project root', '.')
+        .option('--json', 'Emit JSON envelope')
+        .action((opts) => runReset(io, opts));
+}

package/dist/cli/commands/classify-downgrade-command.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export type ClassifyDowngradeOptions = {
+    project: string;
+    level: string;
+    reason: string;
+    json?: boolean;
+};
+export declare function registerClassifyDowngradeCommand(classify: Command, io: ProgramIO): void;

package/dist/cli/commands/classify-downgrade-command.js

@@ -0,0 +1,21 @@
+// src/cli/commands/classify-downgrade-command.ts
+//
+// `peaks classify downgrade` — REFUSED per spec §4: the CLI never downgrades a
+// classification unilaterally. Extracted from
+// `governance-classify-contract-commands.ts`; the registered name, description,
+// options, refusal code and exit code (2) are unchanged.
+import { fail } from 'peaks-loop-shared/result';
+import { printResult } from '../cli-helpers.js';
+export function registerClassifyDowngradeCommand(classify, io) {
+    classify
+        .command('downgrade')
+        .description('REFUSED per spec §4 — peaks-loop never downgrades a classification; ask the user to override explicitly')
+        .requiredOption('--level <level>', 'attempted level')
+        .requiredOption('--reason <text>', 'reason for the attempt (always rejected)')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--json', 'print machine-readable JSON envelope')
+        .action((options) => {
+        printResult(io, fail('classify.downgrade', 'DOWNGRADE_REFUSED', 'peaks classify downgrade is refused per spec §4. Use --override (with reason) on `classify run` to force a level; the CLI never downgrades a classification unilaterally.', { attemptedLevel: options.level, reason: options.reason }, ['Use `peaks classify run --override <level> --reason "<text>"` instead']), options.json);
+        process.exitCode = 2;
+    });
+}

package/dist/cli/commands/classify-run-command.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from 'commander';
+import { type ProgramIO } from '../cli-helpers.js';
+export type ClassifyRunOptions = {
+    project: string;
+    override?: string;
+    reason?: string;
+    json?: boolean;
+};
+export declare function registerClassifyRunCommand(classify: Command, io: ProgramIO): void;

package/dist/cli/commands/classify-run-command.js

@@ -0,0 +1,73 @@
+// src/cli/commands/classify-run-command.ts
+//
+// `peaks classify run` — classify the current diff (git diff HEAD) into one of
+// the 5 task levels, with an optional `--override` + `--reason`. Extracted from
+// `governance-classify-contract-commands.ts`; the registered name, description,
+// options, refusal codes, audit write and envelope are unchanged.
+//
+// `loadPreferences` is synchronous, so the action is too — the merged file said
+// `await loadPreferences(...)`, which `@typescript-eslint/await-thenable`
+// flagged as an await of a non-Promise. Dropping the keyword pair changes no
+// byte of the envelope (the equivalence harness re-measured it).
+import { fail, getErrorMessage, ok } from 'peaks-loop-shared/result';
+import { classifyTask } from '../../services/classify/classify-service.js';
+import { TASK_LEVELS } from '../../services/classify/classify-types.js';
+import { loadPreferences } from '../../services/preferences/preferences-service.js';
+import { addJsonOption, printResult } from '../cli-helpers.js';
+import { appendAuditEntry, CLASSIFY_AUDIT_FILE, getSignalsFromGitDiff, isTaskLevel } from './classify-signals.js';
+export function registerClassifyRunCommand(classify, io) {
+    addJsonOption(classify
+        .command('run')
+        .description('Classify the current diff (git diff HEAD) into one of 5 task levels')
+        .requiredOption('--project <path>', 'target project root')
+        .option('--override <level>', 'force a level (one of typo|bug|feature|refactor|migration); requires --reason')
+        .option('--reason <text>', 'reason for the override (mandatory when --override is set)')).action((options) => {
+        const envelope = classifyRunEnvelope(options);
+        printResult(io, envelope, options.json);
+        if (!envelope.ok)
+            process.exitCode = 1;
+    });
+}
+function classifyRunEnvelope(options) {
+    try {
+        const prefs = loadPreferences(options.project);
+        const signals = getSignalsFromGitDiff(options.project);
+        const override = readOverride(options);
+        if (override.envelope !== null)
+            return override.envelope;
+        const result = classifyTask(override.level === undefined
+            ? { signals, conservatism: prefs.classifyConservatism }
+            : {
+                signals,
+                conservatism: prefs.classifyConservatism,
+                override: { level: override.level, reason: override.reason }
+            }, prefs.classifyRules.feature_threshold_files, prefs.classifyRules.feature_threshold_lines);
+        appendAuditEntry(options.project, result.audit);
+        return ok('classify.run', result, [], [
+            `gate set for level "${result.level}": ${result.gateSet.stages.join(', ')}`,
+            `audit log: .peaks/_runtime/${CLASSIFY_AUDIT_FILE}`
+        ]);
+    }
+    catch (error) {
+        return fail('classify.run', 'CLASSIFY_RUN_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Run peaks classify --help for usage']);
+    }
+}
+/** The two refusals `--override` / `--reason` can earn, in the order they fire. */
+function readOverride(options) {
+    const empty = { level: undefined, reason: '', envelope: null };
+    if (options.override === undefined)
+        return empty;
+    if (!isTaskLevel(options.override)) {
+        return {
+            ...empty,
+            envelope: fail('classify.run', 'INVALID_LEVEL', `level must be one of: ${TASK_LEVELS.join(', ')}`, { provided: options.override }, ['Pass one of typo, bug, feature, refactor, migration'])
+        };
+    }
+    if (options.reason === undefined || options.reason.length === 0) {
+        return {
+            ...empty,
+            envelope: fail('classify.run', 'REASON_REQUIRED', '--reason is required when --override is set', {}, ['Provide a non-empty reason for the override'])
+        };
+    }
+    return { level: options.override, reason: options.reason, envelope: null };
+}

package/dist/cli/commands/classify-signals.d.ts

@@ -0,0 +1,5 @@
+import { type ClassifySignals, type TaskLevel } from '../../services/classify/classify-types.js';
+export declare const CLASSIFY_AUDIT_FILE = "classify-audit.jsonl";
+export declare function getSignalsFromGitDiff(projectRoot: string): ClassifySignals;
+export declare function appendAuditEntry(projectRoot: string, entry: unknown): void;
+export declare function isTaskLevel(value: string): value is TaskLevel;

package/dist/cli/commands/classify-signals.js

@@ -0,0 +1,104 @@
+// src/cli/commands/classify-signals.ts
+//
+// What `peaks classify` reads and writes outside its own envelope: the diff
+// signals the heuristic classifies, the audit-log append, and the task-level
+// guard. Extracted from `governance-classify-contract-commands.ts` (which had
+// merged `classify-classify-commands.ts` verbatim); the parsing, the audit file
+// name and the level guard are unchanged.
+//
+// `child_process` is a static import here rather than the CJS `require` the
+// merged file used inside `getSignalsFromGitDiff`: the module specifier is a
+// Node builtin, so a top-level import cannot fail where the `require` could, and
+// the call itself — arguments, `windowsHide`, and the zeros fallback when git is
+// unavailable — is byte-for-byte the same.
+import { execFileSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { TASK_LEVELS } from '../../services/classify/classify-types.js';
+export const CLASSIFY_AUDIT_FILE = 'classify-audit.jsonl';
+export function getSignalsFromGitDiff(projectRoot) {
+    // Use git diff --stat to extract file count + line count. Fall back to
+    // zeros if git is unavailable (e.g. fresh repo with no commits).
+    let stdout;
+    try {
+        stdout = execFileSync('git', ['diff', '--shortstat', 'HEAD'], {
+            cwd: projectRoot,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: 32 * 1024 * 1024,
+            windowsHide: true
+        }).toString('utf8');
+    }
+    catch {
+        return {
+            filesChanged: 0,
+            linesChanged: 0,
+            touchesDependencies: false,
+            touchesMigrationScripts: false,
+            isPureRefactor: true,
+            keywords: []
+        };
+    }
+    const lines = stdout.split('\n').filter((l) => l.trim().length > 0);
+    const filesChanged = lines.length;
+    let added = 0;
+    let removed = 0;
+    let touchesDependencies = false;
+    let touchesMigrationScripts = false;
+    for (const line of lines) {
+        const match = /(\d+)\s+insertion.*?(\d+)\s+deletion/.exec(line);
+        if (match) {
+            added += Number(match[1]);
+            removed += Number(match[2]);
+        }
+        if (/(package\.json|pnpm-lock\.yaml|yarn\.lock|requirements\.txt|go\.mod)/.test(line)) {
+            touchesDependencies = true;
+        }
+        if (/(migrate|codemod|backfill|schema)/.test(line)) {
+            touchesMigrationScripts = true;
+        }
+    }
+    // isPureRefactor: heuristic — if added lines / removed lines < 0.1 OR
+    // no new exports were added, treat as refactor. For L2.2 the signal is
+    // binary (true/false). Default: true (no behavior change is the safe
+    // assumption; flip to false when keyword 'add' / 'new' / 'feature' present).
+    const isPureRefactor = true;
+    return {
+        filesChanged,
+        linesChanged: added + removed,
+        touchesDependencies,
+        touchesMigrationScripts,
+        isPureRefactor,
+        keywords: []
+    };
+}
+export function appendAuditEntry(projectRoot, entry) {
+    const auditDir = join(projectRoot, '.peaks/_runtime');
+    if (!existsSync(auditDir)) {
+        try {
+            mkdirSync(auditDir, { recursive: true });
+        }
+        catch {
+            /* ignore */
+        } // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    }
+    const auditPath = join(auditDir, CLASSIFY_AUDIT_FILE);
+    let body = '';
+    try {
+        if (existsSync(auditPath)) {
+            body = readFileSync(auditPath, 'utf8');
+        }
+    }
+    catch {
+        /* ignore */
+    } // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    body += JSON.stringify(entry) + '\n';
+    try {
+        writeFileSync(auditPath, body);
+    }
+    catch {
+        /* best-effort */
+    } // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+}
+export function isTaskLevel(value) {
+    return TASK_LEVELS.includes(value);
+}

package/dist/cli/commands/code-emit-handoff-command.js

@@ -1,6 +1,6 @@
 import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
 import { fail, ok } from 'peaks-loop-shared/result';
-import { evaluateEmitHandoff, JOB_NOT_INITIALIZED, JOB_REMAINING_BLOCKED } from '../../services/code/emit-handoff.js';
+import { evaluateEmitHandoff, JOB_COMPLETED_NO_SEDIMENT, JOB_NOT_INITIALIZED, JOB_REMAINING_BLOCKED } from '../../services/code/emit-handoff.js';
 import { readActiveSid } from './code-runtime-session.js';
 export function registerCodeEmitHandoffCommand(code, io) {
     // v3.1.2 Step 11 / final handoff — Size-fear ban.
@@ -13,7 +13,9 @@ export function registerCodeEmitHandoffCommand(code, io) {
         .requiredOption('--project <path>', 'target project root')
         .option('--session-id <sid>', 'override session id (default: read from active presence)')
         .option('--job-id <jid>', 'override job id (default: read from job-shape.json decision.suggestedJobId)')
-        .option('--force-under-job', 'override the remaining>0 block (explicit user approval required)')).action((opts) => runEmitHandoff(opts, io));
+        .option('--force-under-job', 'override the remaining>0 block (explicit user approval required)')
+        .option('--force-no-sediment <reason>', 'override the no-sediment block on a COMPLETED Job: supply the reason the ' +
+        'user approved a no-sediment outcome. A blank reason does not override.')).action((opts) => runEmitHandoff(opts, io));
 }
 function runEmitHandoff(opts, io) {
     try {
@@ -30,6 +32,8 @@ function runEmitHandoff(opts, io) {
             evalInput.jobId = opts.jobId;
         if (opts.forceUnderJob === true)
             evalInput.forceUnderJob = true;
+        if (opts.forceNoSediment !== undefined)
+            evalInput.forceNoSedimentReason = opts.forceNoSediment;
         const verdict = evaluateEmitHandoff(evalInput);
         reportEmitHandoffVerdict(verdict, io, opts.json);
     }
@@ -54,7 +58,15 @@ function reportEmitHandoffVerdict(verdict, io, json) {
         printEmitHandoffBlockNotInitialized(verdict, io, json);
         return;
     }
-    printEmitHandoffBlockRemaining(verdict, io, json);
+    if (verdict.kind === 'block-remaining') {
+        printEmitHandoffBlockRemaining(verdict, io, json);
+        return;
+    }
+    if (verdict.kind === 'allow-forced-no-sediment') {
+        printEmitHandoffAllowForcedNoSediment(verdict, io, json);
+        return;
+    }
+    printEmitHandoffBlockNoSediment(verdict, io, json);
 }
 function printEmitHandoffNoSession(io, json) {
     const envelope = ok('code.emit-handoff', { allow: true, mode: 'no-session' }, [], ['No active session id; gate passes through (single-rid mode).']);
@@ -91,6 +103,31 @@ function printEmitHandoffBlockRemaining(verdict, io, json) {
     printResult(io, envelope, json);
     process.exitCode = 1;
 }
+function printEmitHandoffAllowForcedNoSediment(verdict, io, json) {
+    const envelope = ok('code.emit-handoff', {
+        allow: true,
+        mode: 'job-forced-no-sediment',
+        remaining: verdict.remaining,
+        sedimentState: verdict.sedimentState,
+        approvedNoSedimentReason: verdict.reason
+    }, [], [
+        `Job is complete (remaining=0) and the session sedimented no memory (${verdict.sedimentState}); the user explicitly approved a no-sediment outcome — "${verdict.reason}". Handoff allowed.`
+    ]);
+    printResult(io, envelope, json);
+}
+function printEmitHandoffBlockNoSediment(verdict, io, json) {
+    const why = verdict.sedimentState === 'none'
+        ? 'the session sedimented no memory'
+        : 'the memory index could not be read, so it cannot be shown that the session sedimented any memory';
+    const blockMessage = `BLOCKED: Job ${verdict.jobId} is complete (remaining=0) but ${why}. Step 11 requires at least one memory in the project memory store, or an explicit user-approved no-sediment outcome. Run \`peaks memory extract --apply\` (or record a non-handoff memory with the user's help), then re-run.`;
+    const envelope = fail('code.emit-handoff', JOB_COMPLETED_NO_SEDIMENT, blockMessage, { jobId: verdict.jobId, sedimentState: verdict.sedimentState }, [
+        'Sediment the session: run `peaks memory extract --project <root> --artifact .peaks/_runtime/<sessionId>/txt/handoff.md --apply --json`, then `peaks memory reindex --project <root> --apply --json`.',
+        'Ask the user whether a no-sediment outcome is acceptable; only then re-run with `--force-no-sediment "<the reason the user gave>"`.'
+    ]);
+    io.stderr(`${blockMessage}\n`);
+    printResult(io, envelope, json);
+    process.exitCode = 1;
+}
 function reportEmitHandoffFailure(io, err, json) {
     printResult(io, fail('code.emit-handoff', 'EMIT_HANDOFF_FAILED', getErrorMessage(err), null, [
         'Verify the project path and try again'

package/dist/cli/commands/code-gate-step-08-command.js

@@ -41,14 +41,19 @@ function runGateStep08(opts, io) {
             printGateStep08AllowSingle(context, io, opts.json);
             return;
         }
-        // block-missing-decision
-        if (verdict.promptHit) {
-            // Block: backup regex hit. Exit code 2 is the load-bearing
-            // signal for the PreToolUse hook.
+        if (verdict.kind === 'block-missing-decision') {
+            // Block: the prompt matched the backup regex, so the LLM is treated as
+            // having skipped `peaks code detect-job` on a Job-shaped request.
+            // Exit code 2 is the load-bearing signal for the PreToolUse hook.
             printGateStep08Blocked(verdict, context, io, opts.json);
             return;
         }
-        // No decision + no regex hit → allow.
+        if (verdict.kind === 'block-no-decision-with-ledger') {
+            printGateStep08BlockedWithLedger(verdict, context, io, opts.json);
+            return;
+        }
+        // allow-no-decision-recorded — no decision and no ledger. This is a
+        // normal non-Job session and the gate must let it through.
         printGateStep08Undecided(verdict, context, io, opts.json);
     }
     catch (err) {
@@ -118,6 +123,20 @@ function printGateStep08Blocked(verdict, context, io, json) {
     printResult(io, envelope, json);
     process.exitCode = 2;
 }
+function printGateStep08BlockedWithLedger(verdict, context, io, json) {
+    const blockMessage = `BLOCKED: ${verdict.reason}`;
+    const envelope = fail('code.gate-step-08', 'STEP_08_BLOCKED_WITH_LEDGER', blockMessage, {
+        ledgerJobIds: verdict.ledgerJobIds,
+        backupRegex: STEP_08_BACKUP_REGEX.toString()
+    }, [
+        'Run `peaks code detect-job --is-job true --rationale <text> --suggested-job-id <slug>` (or `--is-job false`) to record the Job-shape verdict the Job ledger presumes.',
+        'Then re-run the Bash tool call.',
+        ...context.hintActions
+    ]);
+    io.stderr(`${blockMessage}\n`);
+    printResult(io, envelope, json);
+    process.exitCode = 2;
+}
 function printGateStep08Undecided(verdict, context, io, json) {
     const envelope = ok('code.gate-step-08', {
         allow: true,
@@ -125,10 +144,7 @@ function printGateStep08Undecided(verdict, context, io, json) {
         decision: null,
         nextSlice: null,
         promptSource: verdict.promptSource
-    }, [], [
-        'No job-shape.json AND no backup-regex match on prompt → allow (most prompts are not Job-shaped).',
-        ...context.hintActions
-    ]);
+    }, [], [verdict.reason, ...context.hintActions]);
     printResult(io, envelope, json);
 }
 function reportGateStep08Failure(io, err, json) {

package/dist/cli/commands/codegraph-command-options.d.ts

@@ -0,0 +1,22 @@
+import { type Command } from 'commander';
+import type { CommonCodegraphOptions } from './codegraph-command-runtime.js';
+export interface CodegraphIndexOptions extends CommonCodegraphOptions {
+    force?: boolean;
+    quiet?: boolean;
+}
+export interface CodegraphQueryOptions extends CommonCodegraphOptions {
+    json?: boolean;
+    limit?: number;
+}
+export interface CodegraphFilesOptions extends CommonCodegraphOptions {
+    json?: boolean;
+    maxDepth?: number;
+}
+export interface CodegraphAffectedOptions extends CommonCodegraphOptions {
+    json?: boolean;
+    rid?: string;
+    writeEnvelope?: boolean;
+}
+export declare function addPeaksJsonOption(command: Command): Command;
+export declare function addProjectOption(command: Command): Command;
+export declare function parsePositiveInteger(value: string): number;

package/dist/cli/commands/codegraph-command-options.js

@@ -0,0 +1,22 @@
+// src/cli/commands/codegraph-command-options.ts
+//
+// The option shapes every `peaks codegraph <verb>` shares, plus the three
+// option-attaching helpers. Split out of `codegraph-commands.ts` so each verb
+// group can live in its own module without re-declaring them.
+import { InvalidArgumentError } from 'commander';
+export function addPeaksJsonOption(command) {
+    return command.option('--peaks-json', 'print Peaks error envelope as machine-readable JSON');
+}
+export function addProjectOption(command) {
+    return addPeaksJsonOption(command.requiredOption('--project <path>', 'target project root'));
+}
+export function parsePositiveInteger(value) {
+    if (!/^\d+$/.test(value)) {
+        throw new InvalidArgumentError('must be a positive integer');
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed) || parsed < 1) {
+        throw new InvalidArgumentError('must be a positive integer');
+    }
+    return parsed;
+}

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

@@ -1,5 +1,5 @@
-import { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
+import type { Command } from 'commander';
+import type { ProgramIO } from '../cli-helpers.js';
 export { rewriteBareCodegraphHints } from './codegraph-command-runtime.js';
 export { attributeUpstreamUpToDateLine } from './codegraph-status-command.js';
 export declare function registerCodegraphCommands(program: Command, io: ProgramIO): void;