peaks-loop 4.0.54 → 4.1.0

package/dist/services/codegraph/codegraph-autorefresh.js

@@ -55,7 +55,7 @@
 // build), not `init`.
 import { existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { CODEGRAPH_DIR_NAME, CODEGRAPH_MARKER_NAME, createCodegraphInvocation, executeCodegraphInvocation, isCodegraphInitialized, } from './codegraph-service.js';
+import { CODEGRAPH_DIR_NAME, CODEGRAPH_MARKER_NAME, createCodegraphInvocation, executeCodegraphInvocation, isCodegraphInitialized } from './codegraph-service.js';
 import { repairCodegraphExcludeFromProject } from './codegraph-exclude-repair.js';
 /**
  * The operator-facing line for a refresh that did not happen, or `null` when
@@ -115,6 +115,50 @@ function firstMeaningfulLine(text) {
     const first = trimmed.split(/\r?\n/)[0];
     return first !== undefined ? first.slice(0, 200) : 'no upstream output';
 }
+/**
+ * Self-heal a `.codegraph/` dir that exists without a `codegraph.db`
+ * (extracted verbatim from `refreshCodegraphAfterSlice` to clear the
+ * `max-lines-per-function` arm; behavior unchanged). Returns a terminal
+ * result when the refresh must stop, `null` when the caller may proceed
+ * to the index step.
+ */
+async function selfHealUninitializedCodegraph(projectRoot, runner) {
+    // A `.codegraph/` dir without a `codegraph.db` is uninitialized:
+    //   - NOT peaks-loop-managed → foreign schema, never touch it.
+    //   - peaks-loop-managed → the dangling state left by the pre-fix
+    //     rid-CG-001 auto-stake (marker stamped, no upstream init). Run
+    //     init (fast, offline-safe — no full index) so the subsequent
+    //     index has a schema to write into.
+    if (!isCodegraphInitialized(projectRoot)) {
+        if (!isCodegraphPeaksLoopManaged(projectRoot)) {
+            return {
+                refreshed: false,
+                reason: 'no-codegraph-dir',
+                note: `auto codegraph refresh skipped: ${CODEGRAPH_DIR_NAME}/ exists without a codegraph.db and is not peaks-loop-managed. Run \`peaks codegraph init\` once to enable post-slice auto-refresh.`
+            };
+        }
+        const initResult = await executeCodegraphInvocation(createCodegraphInvocation({ subcommand: 'init', project: projectRoot }), runner);
+        if (initResult.exitCode !== 0) {
+            return {
+                refreshed: false,
+                reason: 'index-failed',
+                note: `auto codegraph refresh self-heal init failed (exit ${String(initResult.exitCode)}): ${firstMeaningfulLine(initResult.stderr || initResult.stdout)}. ${REFRESH_REMEDY}`
+            };
+        }
+        // That init just wrote upstream's 99-rule default `exclude`
+        // template, some of which block tracked source files — the same
+        // self-heal the CLI's `peaks codegraph init` performs, via the
+        // same shared helper. Skipped, this path would stamp the
+        // peaks-loop marker over an incomplete index that no later
+        // `init` (it would no-op) could ever repair.
+        //
+        // Never throws (the helper catches everything), and
+        // `reindex: false` because the index call below covers the
+        // recovered files.
+        await repairCodegraphExcludeFromProject(projectRoot, runner, { reindex: false });
+    }
+    return null;
+}
 /**
  * Run a best-effort `codegraph index` refresh for `projectRoot` after a
  * slice-complete boundary. NEVER throws — every failure path returns a
@@ -128,51 +172,24 @@ export async function refreshCodegraphAfterSlice(projectRoot, runner) {
         return {
             refreshed: false,
             reason: 'no-codegraph-dir',
-            note: `auto codegraph refresh skipped: no ${CODEGRAPH_DIR_NAME} directory at ${join(projectRoot, CODEGRAPH_DIR_NAME)}. Run \`peaks codegraph init\` once to enable post-slice auto-refresh.`,
+            note: `auto codegraph refresh skipped: no ${CODEGRAPH_DIR_NAME} directory at ${join(projectRoot, CODEGRAPH_DIR_NAME)}. Run \`peaks codegraph init\` once to enable post-slice auto-refresh.`
         };
     }
     try {
-        // A `.codegraph/` dir without a `codegraph.db` is uninitialized:
-        //   - NOT peaks-loop-managed → foreign schema, never touch it.
-        //   - peaks-loop-managed → the dangling state left by the pre-fix
-        //     rid-CG-001 auto-stake (marker stamped, no upstream init). Run
-        //     init (fast, offline-safe — no full index) so the subsequent
-        //     index has a schema to write into.
-        if (!isCodegraphInitialized(projectRoot)) {
-            if (!isCodegraphPeaksLoopManaged(projectRoot)) {
-                return {
-                    refreshed: false,
-                    reason: 'no-codegraph-dir',
-                    note: `auto codegraph refresh skipped: ${CODEGRAPH_DIR_NAME}/ exists without a codegraph.db and is not peaks-loop-managed. Run \`peaks codegraph init\` once to enable post-slice auto-refresh.`,
-                };
-            }
-            const initResult = await executeCodegraphInvocation(createCodegraphInvocation({ subcommand: 'init', project: projectRoot }), runner);
-            if (initResult.exitCode !== 0) {
-                return {
-                    refreshed: false,
-                    reason: 'index-failed',
-                    note: `auto codegraph refresh self-heal init failed (exit ${String(initResult.exitCode)}): ${firstMeaningfulLine(initResult.stderr || initResult.stdout)}. ${REFRESH_REMEDY}`,
-                };
-            }
-            // That init just wrote upstream's 99-rule default `exclude`
-            // template, some of which block tracked source files — the same
-            // self-heal the CLI's `peaks codegraph init` performs, via the
-            // same shared helper. Skipped, this path would stamp the
-            // peaks-loop marker over an incomplete index that no later
-            // `init` (it would no-op) could ever repair.
-            //
-            // Never throws (the helper catches everything), and
-            // `reindex: false` because the index call below covers the
-            // recovered files.
-            await repairCodegraphExcludeFromProject(projectRoot, runner, { reindex: false });
-        }
-        const invocation = createCodegraphInvocation({ subcommand: 'index', project: projectRoot, quiet: true });
+        const selfHeal = await selfHealUninitializedCodegraph(projectRoot, runner);
+        if (selfHeal !== null)
+            return selfHeal;
+        const invocation = createCodegraphInvocation({
+            subcommand: 'index',
+            project: projectRoot,
+            quiet: true
+        });
         const result = await executeCodegraphInvocation(invocation, runner);
         if (result.exitCode !== 0) {
             return {
                 refreshed: false,
                 reason: 'index-failed',
-                note: `auto codegraph refresh failed (exit ${String(result.exitCode)}): ${firstMeaningfulLine(result.stderr || result.stdout)}. ${REFRESH_REMEDY}`,
+                note: `auto codegraph refresh failed (exit ${String(result.exitCode)}): ${firstMeaningfulLine(result.stderr || result.stdout)}. ${REFRESH_REMEDY}`
             };
         }
         return { refreshed: true };
@@ -181,7 +198,7 @@ export async function refreshCodegraphAfterSlice(projectRoot, runner) {
         return {
             refreshed: false,
             reason: 'unavailable',
-            note: `auto codegraph refresh unavailable: ${errorMessage(error)}. ${REFRESH_REMEDY}`,
+            note: `auto codegraph refresh unavailable: ${errorMessage(error)}. ${REFRESH_REMEDY}`
         };
     }
 }

package/dist/services/codegraph/codegraph-config-repair-writer.js

@@ -314,7 +314,10 @@ export function applyCodegraphConfigRepair(projectRoot, repair) {
     // is how a wrong `include` would survive a repair that reported success.
     const include = record.include === undefined ? [] : assertStringArray(record.include, 'include', configPath);
     const excludePlan = repairCodegraphExclude({ exclude, rulesToRemove: repair.rulesToRemove });
-    const includePlan = repairCodegraphInclude({ include, patternsToAdd: repair.includePatternsToAdd });
+    const includePlan = repairCodegraphInclude({
+        include,
+        patternsToAdd: repair.includePatternsToAdd
+    });
     if (!excludePlan.changed && !includePlan.changed) {
         return {
             applied: false,

package/dist/services/codegraph/codegraph-exclude-integrity.js

@@ -84,7 +84,10 @@ export function inspectCodegraphExcludeIntegrity(projectRoot, inputs = {}) {
         excludedTrackedCount: result.excludedTrackedCount,
         violations: result.violations,
         rulesToRemove: result.rulesToRemove,
-        ruleImpacts: result.rulesToRemove.map((rule) => ({ rule, blockedCount: blockedCounts.get(rule) ?? 0 }))
+        ruleImpacts: result.rulesToRemove.map((rule) => ({
+            rule,
+            blockedCount: blockedCounts.get(rule) ?? 0
+        }))
     };
 }
 /**

package/dist/services/codegraph/codegraph-exclude-repair.js

@@ -210,8 +210,7 @@ export async function repairCodegraphExcludeFromProject(projectRoot, runner, opt
     // pass runs only on the one run per project that actually widens
     // `include`, where a repair is about to spend seconds rebuilding an index.
     const includeFilesRecovered = includePlan.changed
-        ? includeAdmittedAfter -
-            filterAdmittedTrackedFiles(trackedFiles, config.include).length
+        ? includeAdmittedAfter - filterAdmittedTrackedFiles(trackedFiles, config.include).length
         : 0;
     const nothingToRepair = includePlan.addedPatterns.length === 0 && reconcile.rulesToRemove.length === 0;
     const unchanged = {

package/dist/services/codegraph/codegraph-index-integrity.js

@@ -135,7 +135,7 @@ export const CODEGRAPH_REPAIR_INDEX_COMMAND = 'peaks codegraph repair-index --pr
 export const CODEGRAPH_INDEX_STRICT_ENV_VAR = 'PEAKS_CODEGRAPH_INDEX_STRICT';
 /** True when the project opted in to blocking index-gap verdicts. */
 export function isCodegraphIndexStrictMode(env = process.env) {
-    return env[CODEGRAPH_INDEX_STRICT_ENV_VAR] === '1' || env[CODEGRAPH_INDEX_STRICT_ENV_VAR] === 'true';
+    return (env[CODEGRAPH_INDEX_STRICT_ENV_VAR] === '1' || env[CODEGRAPH_INDEX_STRICT_ENV_VAR] === 'true');
 }
 /**
  * Fold the inspected report (null when there is no index to inspect) and

package/dist/services/codegraph/codegraph-preflight-service.d.ts

@@ -1,30 +1,7 @@
 import { type CodegraphProcessRunner } from './codegraph-service.js';
-export type CodegraphPreflightResult = {
-    available: true;
-    block: string;
-    fileCount: number;
-    truncated: boolean;
-} | {
-    available: false;
-    note: string;
-};
-/** Cap for the directory histogram in the rendered structure block. */
-export declare const CODEGRAPH_STRUCTURE_MAX_DIRS = 40;
-/** Cap for bare root files listed in the rendered structure block. */
-export declare const CODEGRAPH_STRUCTURE_MAX_ROOT_FILES = 12;
-export interface CodegraphStructureFileEntry {
-    readonly path: string;
-}
-export interface CodegraphStructureRenderOptions {
-    readonly maxDirs?: number;
-    readonly maxRootFiles?: number;
-}
-export interface CodegraphStructureSummary {
-    /** Full `## Codegraph structure` markdown block, ending on its own paragraph. */
-    block: string;
-    total: number;
-    truncated: boolean;
-}
+import { type CodegraphPreflightResult, type CodegraphStructureFileEntry, type CodegraphStructureRenderOptions, type CodegraphStructureSummary } from './codegraph-preflight-structure.js';
+export { CODEGRAPH_STRUCTURE_MAX_DIRS, CODEGRAPH_STRUCTURE_MAX_ROOT_FILES } from './codegraph-preflight-structure.js';
+export type { CodegraphPreflightResult, CodegraphStructureFileEntry, CodegraphStructureRenderOptions, CodegraphStructureSummary } from './codegraph-preflight-structure.js';
 /**
  * Pure renderer: turn the codegraph `files --json` payload into a bounded
  * `## Codegraph structure` block. Files are aggregated into a directory

package/dist/services/codegraph/codegraph-preflight-service.js

@@ -31,17 +31,11 @@
 //   - CODEGRAPH_STRUCTURE_MAX_DIRS        = 40  directory rows
 //   - CODEGRAPH_STRUCTURE_MAX_ROOT_FILES  = 12  bare root files
 import { mkdirSync } from 'node:fs';
-import { CODEGRAPH_DIR_NAME, createCodegraphInvocation, defaultCodegraphInitGuard, executeCodegraphInvocation, isCodegraphInitialized, writeCodegraphMarker, } from './codegraph-service.js';
+import { CODEGRAPH_DIR_NAME, createCodegraphInvocation, defaultCodegraphInitGuard, executeCodegraphInvocation, isCodegraphInitialized, writeCodegraphMarker } from './codegraph-service.js';
 import { defaultCodegraphProcessRunner } from './codegraph-process-runner.js';
 import { repairCodegraphExcludeFromProject } from './codegraph-exclude-repair.js';
-/** Cap for the directory histogram in the rendered structure block. */
-export const CODEGRAPH_STRUCTURE_MAX_DIRS = 40;
-/** Cap for bare root files listed in the rendered structure block. */
-export const CODEGRAPH_STRUCTURE_MAX_ROOT_FILES = 12;
-/** Strip a leading `./` (upstream codegraph paths may carry it). */
-function normalizeCodegraphPath(path) {
-    return path.startsWith('./') ? path.slice(2) : path;
-}
+import { CODEGRAPH_STRUCTURE_MAX_DIRS, CODEGRAPH_STRUCTURE_MAX_ROOT_FILES, normalizeCodegraphPath, parseFilesPayload } from './codegraph-preflight-structure.js';
+export { CODEGRAPH_STRUCTURE_MAX_DIRS, CODEGRAPH_STRUCTURE_MAX_ROOT_FILES } from './codegraph-preflight-structure.js';
 /**
  * Pure renderer: turn the codegraph `files --json` payload into a bounded
  * `## Codegraph structure` block. Files are aggregated into a directory
@@ -69,8 +63,7 @@ export function renderCodegraphStructureBlock(files, options = {}) {
         const dir = raw.slice(0, slash);
         dirCounts.set(dir, (dirCounts.get(dir) ?? 0) + 1);
     }
-    const sortedDirs = [...dirCounts.entries()]
-        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+    const sortedDirs = [...dirCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
     const shownDirs = sortedDirs.slice(0, maxDirs);
     const truncatedDirs = sortedDirs.length > maxDirs;
     const sortedRoot = [...rootFiles].sort((a, b) => a.localeCompare(b));
@@ -102,28 +95,14 @@ function firstMeaningfulLine(text) {
     const first = trimmed.split(/\r?\n/)[0];
     return first !== undefined ? first.slice(0, 200) : 'no upstream output';
 }
-function parseFilesPayload(stdout) {
-    try {
-        const parsed = JSON.parse(stdout);
-        if (Array.isArray(parsed)) {
-            const entries = parsed
-                .filter((entry) => typeof entry === 'object' && entry !== null && 'path' in entry)
-                .map((entry) => ({ path: typeof entry.path === 'string' ? entry.path : '' }))
-                .filter((entry) => entry.path.length > 0);
-            return { ok: true, entries };
-        }
-        // JSON but not an array — not the shape we expect.
-        return { ok: false, entries: [] };
-    }
-    catch {
-        // Not JSON at all — e.g. the upstream text path ("No files indexed…").
-        return { ok: false, entries: [] };
-    }
-}
 async function readStructure(projectRoot, runner) {
     let result;
     try {
-        const invocation = createCodegraphInvocation({ subcommand: 'files', project: projectRoot, json: true });
+        const invocation = createCodegraphInvocation({
+            subcommand: 'files',
+            project: projectRoot,
+            json: true
+        });
         result = await executeCodegraphInvocation(invocation, runner);
     }
     catch (error) {
@@ -132,20 +111,20 @@ async function readStructure(projectRoot, runner) {
     if (result.exitCode !== 0) {
         return {
             available: false,
-            note: `codegraph files failed (exit ${String(result.exitCode)}): ${firstMeaningfulLine(result.stderr || result.stdout)}`,
+            note: `codegraph files failed (exit ${String(result.exitCode)}): ${firstMeaningfulLine(result.stderr || result.stdout)}`
         };
     }
     const { ok, entries } = parseFilesPayload(result.stdout);
     if (!ok) {
         return {
             available: false,
-            note: 'codegraph files returned no parseable structure — run `peaks codegraph index` before dispatch for symbol-accurate structure.',
+            note: 'codegraph files returned no parseable structure — run `peaks codegraph index` before dispatch for symbol-accurate structure.'
         };
     }
     if (entries.length === 0) {
         return {
             available: false,
-            note: 'codegraph index has no files — run `peaks codegraph index` before dispatch for symbol-accurate structure.',
+            note: 'codegraph index has no files — run `peaks codegraph index` before dispatch for symbol-accurate structure.'
         };
     }
     const summary = renderCodegraphStructureBlock(entries);
@@ -153,7 +132,7 @@ async function readStructure(projectRoot, runner) {
         available: true,
         block: summary.block,
         fileCount: summary.total,
-        truncated: summary.truncated,
+        truncated: summary.truncated
     };
 }
 /**
@@ -181,7 +160,7 @@ export async function buildCodegraphPreflightBlock(projectRoot, runner) {
     if (guard.status === 'conflict-foreign-schema') {
         return {
             available: false,
-            note: `codegraph unavailable: ${CODEGRAPH_DIR_NAME}/ exists with a non-peaks-loop schema and was not touched. Move or rename the foreign directory, then re-run \`peaks codegraph init\` to enable pre-dispatch structure reads.`,
+            note: `codegraph unavailable: ${CODEGRAPH_DIR_NAME}/ exists with a non-peaks-loop schema and was not touched. Move or rename the foreign directory, then re-run \`peaks codegraph init\` to enable pre-dispatch structure reads.`
         };
     }
     // 'fresh' (no dir) OR a dangling peaks-loop dir (marker present, no
@@ -196,7 +175,7 @@ export async function buildCodegraphPreflightBlock(projectRoot, runner) {
             if (initResult.exitCode !== 0) {
                 return {
                     available: false,
-                    note: `codegraph init failed (exit ${String(initResult.exitCode)}): ${firstMeaningfulLine(initResult.stderr || initResult.stdout)}`,
+                    note: `codegraph init failed (exit ${String(initResult.exitCode)}): ${firstMeaningfulLine(initResult.stderr || initResult.stdout)}`
                 };
             }
             try {
@@ -230,7 +209,7 @@ export async function buildCodegraphPreflightBlock(projectRoot, runner) {
             if (indexResult.exitCode !== 0) {
                 return {
                     available: false,
-                    note: `codegraph index failed (exit ${String(indexResult.exitCode)}): ${firstMeaningfulLine(indexResult.stderr || indexResult.stdout)}`,
+                    note: `codegraph index failed (exit ${String(indexResult.exitCode)}): ${firstMeaningfulLine(indexResult.stderr || indexResult.stdout)}`
                 };
             }
         }

package/dist/services/codegraph/codegraph-preflight-structure.d.ts

@@ -0,0 +1,32 @@
+export type CodegraphPreflightResult = {
+    available: true;
+    block: string;
+    fileCount: number;
+    truncated: boolean;
+} | {
+    available: false;
+    note: string;
+};
+/** Cap for the directory histogram in the rendered structure block. */
+export declare const CODEGRAPH_STRUCTURE_MAX_DIRS = 40;
+/** Cap for bare root files listed in the rendered structure block. */
+export declare const CODEGRAPH_STRUCTURE_MAX_ROOT_FILES = 12;
+export interface CodegraphStructureFileEntry {
+    readonly path: string;
+}
+export interface CodegraphStructureRenderOptions {
+    readonly maxDirs?: number;
+    readonly maxRootFiles?: number;
+}
+export interface CodegraphStructureSummary {
+    /** Full `## Codegraph structure` markdown block, ending on its own paragraph. */
+    block: string;
+    total: number;
+    truncated: boolean;
+}
+/** Strip a leading `./` (upstream codegraph paths may carry it). */
+export declare function normalizeCodegraphPath(path: string): string;
+export declare function parseFilesPayload(stdout: string): {
+    ok: boolean;
+    entries: CodegraphStructureFileEntry[];
+};

package/dist/services/codegraph/codegraph-preflight-structure.js

@@ -0,0 +1,33 @@
+// src/services/codegraph/codegraph-preflight-structure.ts
+//
+// The declaration + payload-parsing surface of the pre-dispatch codegraph
+// preflight (`codegraph-preflight-service.ts`), extracted so the service
+// module stays under the repo file-size cap. `codegraph-preflight-service.ts`
+// imports these and re-exports the public ones, so importers keep resolving
+// every name from the original path.
+/** Cap for the directory histogram in the rendered structure block. */
+export const CODEGRAPH_STRUCTURE_MAX_DIRS = 40;
+/** Cap for bare root files listed in the rendered structure block. */
+export const CODEGRAPH_STRUCTURE_MAX_ROOT_FILES = 12;
+/** Strip a leading `./` (upstream codegraph paths may carry it). */
+export function normalizeCodegraphPath(path) {
+    return path.startsWith('./') ? path.slice(2) : path;
+}
+export function parseFilesPayload(stdout) {
+    try {
+        const parsed = JSON.parse(stdout);
+        if (Array.isArray(parsed)) {
+            const entries = parsed
+                .filter((entry) => typeof entry === 'object' && entry !== null && 'path' in entry)
+                .map((entry) => ({ path: typeof entry.path === 'string' ? entry.path : '' }))
+                .filter((entry) => entry.path.length > 0);
+            return { ok: true, entries };
+        }
+        // JSON but not an array — not the shape we expect.
+        return { ok: false, entries: [] };
+    }
+    catch {
+        // Not JSON at all — e.g. the upstream text path ("No files indexed…").
+        return { ok: false, entries: [] };
+    }
+}

package/dist/services/codegraph/codegraph-process-runner.js

@@ -3,7 +3,18 @@ import { join } from 'node:path';
 const CODEGRAPH_PROCESS_TIMEOUT_MS = 600_000;
 const CODEGRAPH_OUTPUT_LIMIT_BYTES = 10 * 1024 * 1024;
 function createCodegraphEnvironment(sourceEnv = process.env) {
-    const preservedKeys = ['PATH', 'Path', 'HOME', 'USERPROFILE', 'APPDATA', 'LOCALAPPDATA', 'TEMP', 'TMP', 'SystemRoot', 'WINDIR'];
+    const preservedKeys = [
+        'PATH',
+        'Path',
+        'HOME',
+        'USERPROFILE',
+        'APPDATA',
+        'LOCALAPPDATA',
+        'TEMP',
+        'TMP',
+        'SystemRoot',
+        'WINDIR'
+    ];
     const environment = {};
     for (const key of preservedKeys) {
         const value = sourceEnv[key];

package/dist/services/codegraph/codegraph-service.js

@@ -9,7 +9,15 @@ const CODEGRAPH_PACKAGE_VERSION = '0.7.10';
 const CODEGRAPH_EXECUTABLE = process.execPath;
 const CODEGRAPH_BINARY_PATH = resolveCodegraphBinaryPath();
 const POSITIONAL_ARGUMENT_PREFIX = '-';
-const ALLOWED_SUBCOMMANDS = ['status', 'init', 'index', 'query', 'files', 'context', 'affected'];
+const ALLOWED_SUBCOMMANDS = [
+    'status',
+    'init',
+    'index',
+    'query',
+    'files',
+    'context',
+    'affected'
+];
 const NUMERIC_FLAG_NAMES = ['limit', 'maxDepth'];
 const COMMON_OPTION_KEYS = ['subcommand', 'project'];
 const ALLOWED_OPTIONS_BY_SUBCOMMAND = {

package/dist/services/compact/request-transition-hook.js

@@ -43,7 +43,8 @@ function readLatestUsageRow(projectRoot, sessionId) {
             return null;
         return JSON.parse(last);
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }

package/dist/services/compact/suggest-service.d.ts

@@ -1,66 +1,6 @@
 import { type Phase, type Severity } from './decision-tables.js';
-/** Token window sizes supported by the suggest service. */
-export type WindowKind = '200k' | '1m';
-export interface SuggestOptions {
-    readonly projectRoot: string;
-    readonly sessionId: string | null;
-    readonly env?: NodeJS.ProcessEnv;
-}
-export interface SuggestResult {
-    readonly shouldSuggest: boolean;
-    readonly reason: string;
-    readonly ratio: number;
-    readonly windowKind: WindowKind;
-    readonly tokensUsed: number;
-    readonly toolCalls: number;
-    readonly thresholds: {
-        readonly contextTokens: number;
-        readonly contextInterval: number;
-        readonly toolCalls: number;
-    };
-    readonly dataUnavailable: boolean;
-    readonly source: 'usage-jsonl' | 'env-vars' | 'none';
-}
-/** Default tool-call threshold before first suggestion. */
-export declare const DEFAULT_TOOL_CALL_THRESHOLD = 50;
-/** Default additional tool calls before the suggestion repeats. */
-export declare const TOOL_CALL_REMIND_STEP = 25;
-/** Default context-size threshold on a 200k window. */
-export declare const DEFAULT_CONTEXT_THRESHOLD_200K = 160000;
-/** Default context-size threshold on a 1M window. */
-export declare const DEFAULT_CONTEXT_THRESHOLD_1M = 250000;
-/** Default re-remind interval for context size. */
-export declare const DEFAULT_CONTEXT_INTERVAL = 60000;
+import { type SuggestOptions, type SuggestResult, type DryRunOptions, type DryRunResult } from './suggest-types.js';
 export declare function suggestCompact(options: SuggestOptions): SuggestResult;
-/**
- * `peaks compact dry-run` envelope — composed of (a) suggest, (b)
- * recommend, (c) survival. Pure composition over the helpers; no
- * additional I/O. The CLI emits this so the LLM can decide in one
- * tool-call whether to act.
- */
-export interface DryRunOptions {
-    readonly projectRoot: string;
-    readonly sessionId: string | null;
-    readonly from?: Phase;
-    readonly to?: Phase;
-    readonly env?: NodeJS.ProcessEnv;
-}
-export interface DryRunResult {
-    readonly action: 'compact' | 'skip';
-    readonly suggest: SuggestResult;
-    readonly recommend: {
-        readonly from: Phase | null;
-        readonly to: Phase | null;
-        readonly shouldCompact: boolean;
-        readonly severity: Severity | null;
-        readonly rationale: string | null;
-        readonly suggestedMessage: string | null;
-    };
-    readonly survival: {
-        readonly persists: readonly string[];
-        readonly lost: readonly string[];
-    };
-}
 export declare function dryRunCompact(options: DryRunOptions): DryRunResult;
 export declare function buildRecommendEnvelopePure(from: Phase, to: Phase): {
     from: Phase;
@@ -72,3 +12,5 @@ export declare function buildRecommendEnvelopePure(from: Phase, to: Phase): {
 };
 export { PHASE_TRANSITIONS, lookupPhaseTransition, buildSuggestedCompactMessage, PHASES, isPhase, SURVIVAL_TABLE } from './decision-tables.js';
 export type { Phase, Severity } from './decision-tables.js';
+export { DEFAULT_TOOL_CALL_THRESHOLD, TOOL_CALL_REMIND_STEP, DEFAULT_CONTEXT_THRESHOLD_200K, DEFAULT_CONTEXT_THRESHOLD_1M, DEFAULT_CONTEXT_INTERVAL } from './suggest-types.js';
+export type { WindowKind, SuggestOptions, SuggestResult, DryRunOptions, DryRunResult } from './suggest-types.js';

package/dist/services/compact/suggest-service.js

@@ -25,19 +25,10 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { lookupPhaseTransition, buildSuggestedCompactMessage, SURVIVAL_TABLE } from './decision-tables.js';
+import { DEFAULT_TOOL_CALL_THRESHOLD, DEFAULT_CONTEXT_THRESHOLD_200K, DEFAULT_CONTEXT_THRESHOLD_1M, DEFAULT_CONTEXT_INTERVAL } from './suggest-types.js';
 /** Snapshot of the survival table for the dry-run envelope. */
 const SURVIVAL_TABLE_PERSISTS = SURVIVAL_TABLE.persists;
 const SURVIVAL_TABLE_LOST = SURVIVAL_TABLE.lost;
-/** Default tool-call threshold before first suggestion. */
-export const DEFAULT_TOOL_CALL_THRESHOLD = 50;
-/** Default additional tool calls before the suggestion repeats. */
-export const TOOL_CALL_REMIND_STEP = 25;
-/** Default context-size threshold on a 200k window. */
-export const DEFAULT_CONTEXT_THRESHOLD_200K = 160_000;
-/** Default context-size threshold on a 1M window. */
-export const DEFAULT_CONTEXT_THRESHOLD_1M = 250_000;
-/** Default re-remind interval for context size. */
-export const DEFAULT_CONTEXT_INTERVAL = 60_000;
 function readLatestUsageRow(projectRoot, sessionId) {
     const path = join(projectRoot, '.peaks', '_runtime', sessionId, 'usage.jsonl');
     if (!existsSync(path))
@@ -52,7 +43,8 @@ function readLatestUsageRow(projectRoot, sessionId) {
             return null;
         return JSON.parse(last);
     }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+    catch {
+        // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
         return null;
     }
 }
@@ -118,7 +110,9 @@ export function suggestCompact(options) {
     const windowCapacity = windowKind === '1m' ? 1_000_000 : 200_000;
     const effectiveContextThreshold = contextThreshold > 0
         ? contextThreshold
-        : (windowKind === '1m' ? DEFAULT_CONTEXT_THRESHOLD_1M : DEFAULT_CONTEXT_THRESHOLD_200K);
+        : windowKind === '1m'
+            ? DEFAULT_CONTEXT_THRESHOLD_1M
+            : DEFAULT_CONTEXT_THRESHOLD_200K;
     const ratio = windowCapacity > 0 ? tokensUsed / windowCapacity : 0;
     const dataUnavailable = tokensUsed === 0 && toolCalls === 0;
     // Two-signal suggestion. The context signal is primary: the LLM
@@ -201,3 +195,6 @@ export function buildRecommendEnvelopePure(from, to) {
 // to keep the validation path co-located with the recommend envelope
 // builder.
 export { PHASE_TRANSITIONS, lookupPhaseTransition, buildSuggestedCompactMessage, PHASES, isPhase, SURVIVAL_TABLE } from './decision-tables.js';
+// The public types and default thresholds live in suggest-types.ts; they are
+// re-exported here so importers keep using this same path.
+export { DEFAULT_TOOL_CALL_THRESHOLD, TOOL_CALL_REMIND_STEP, DEFAULT_CONTEXT_THRESHOLD_200K, DEFAULT_CONTEXT_THRESHOLD_1M, DEFAULT_CONTEXT_INTERVAL } from './suggest-types.js';

package/dist/services/compact/suggest-types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * `src/services/compact/suggest-types.ts`
+ *
+ * Type declarations and default-threshold constants extracted verbatim
+ * from `suggest-service.ts` (wave 2, file-size cap campaign) so the
+ * service stays under the 300 raw-line cap. Mechanical move only —
+ * `suggest-service.ts` re-exports every public name from this module.
+ */
+import type { Phase, Severity } from './decision-tables.js';
+/** Token window sizes supported by the suggest service. */
+export type WindowKind = '200k' | '1m';
+export interface SuggestOptions {
+    readonly projectRoot: string;
+    readonly sessionId: string | null;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export interface SuggestResult {
+    readonly shouldSuggest: boolean;
+    readonly reason: string;
+    readonly ratio: number;
+    readonly windowKind: WindowKind;
+    readonly tokensUsed: number;
+    readonly toolCalls: number;
+    readonly thresholds: {
+        readonly contextTokens: number;
+        readonly contextInterval: number;
+        readonly toolCalls: number;
+    };
+    readonly dataUnavailable: boolean;
+    readonly source: 'usage-jsonl' | 'env-vars' | 'none';
+}
+/** Default tool-call threshold before first suggestion. */
+export declare const DEFAULT_TOOL_CALL_THRESHOLD = 50;
+/** Default additional tool calls before the suggestion repeats. */
+export declare const TOOL_CALL_REMIND_STEP = 25;
+/** Default context-size threshold on a 200k window. */
+export declare const DEFAULT_CONTEXT_THRESHOLD_200K = 160000;
+/** Default context-size threshold on a 1M window. */
+export declare const DEFAULT_CONTEXT_THRESHOLD_1M = 250000;
+/** Default re-remind interval for context size. */
+export declare const DEFAULT_CONTEXT_INTERVAL = 60000;
+export interface UsageRow {
+    ts?: string;
+    tokens?: number;
+    toolCalls?: number;
+    modelKind?: '200k' | '1m';
+}
+/**
+ * `peaks compact dry-run` envelope — composed of (a) suggest, (b)
+ * recommend, (c) survival. Pure composition over the helpers; no
+ * additional I/O. The CLI emits this so the LLM can decide in one
+ * tool-call whether to act.
+ */
+export interface DryRunOptions {
+    readonly projectRoot: string;
+    readonly sessionId: string | null;
+    readonly from?: Phase;
+    readonly to?: Phase;
+    readonly env?: NodeJS.ProcessEnv;
+}
+export interface DryRunResult {
+    readonly action: 'compact' | 'skip';
+    readonly suggest: SuggestResult;
+    readonly recommend: {
+        readonly from: Phase | null;
+        readonly to: Phase | null;
+        readonly shouldCompact: boolean;
+        readonly severity: Severity | null;
+        readonly rationale: string | null;
+        readonly suggestedMessage: string | null;
+    };
+    readonly survival: {
+        readonly persists: readonly string[];
+        readonly lost: readonly string[];
+    };
+}