peaks-loop 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/src/services/compact/decision-tables.d.ts

@@ -1,66 +0,0 @@
-/**
- * Strategic-compact decision tables (slice 2026-07-01-strategic-compact-cli).
- *
- * Pure data + lookup helpers. No I/O. The byte-for-byte text mirrors the
- * "Compaction Decision Guide" + "What Survives Compaction" tables in
- * ECC's strategic-compact SKILL.md (read-only reference at
- * C:\Users\smallMark\.claude\plugins\cache\ecc\ecc\2.0.0\skills\strategic-compact\SKILL.md).
- *
- * The `peaks compact recommend` + `peaks compact survival` + `peaks
- * compact dry-run` primitives read from these tables; any change to the
- * upstream skill table must be mirrored here and re-asserted by the
- * `tests/unit/cli/compact-command.test.ts` regression suite.
- */
-export type Phase = 'research' | 'planning' | 'implementation' | 'testing' | 'debugging';
-export declare const PHASES: readonly Phase[];
-export declare function isPhase(value: string): value is Phase;
-/** Severity for a phase transition: matches the SKILL.md "Compact?" column. */
-export type Severity = 'yes' | 'maybe' | 'no';
-export interface PhaseTransitionDecision {
-    readonly from: Phase;
-    readonly to: Phase;
-    readonly severity: Severity;
-    readonly rationale: string;
-}
-/**
- * Single source of truth for the strategic-compact "Compaction Decision
- * Guide" table. Each row is a recommended from→to transition. The
- * `rationale` field is the "Why" column verbatim from SKILL.md.
- *
- * The CLI accepts arbitrary from/to phase pairs; if the pair is not in
- * the table (e.g. testing→implementation) the recommend primitive
- * returns `severity: 'no'` with a `notInTable: true` flag and the
- * default rationale "No documented transition; preserve context".
- */
-export declare const PHASE_TRANSITIONS: readonly PhaseTransitionDecision[];
-/** Documented "no compact" rows from the SKILL.md table. */
-export declare const PHASE_NO_TRANSITIONS: readonly {
-    from: Phase;
-    to: Phase;
-    rationale: string;
-}[];
-/**
- * SKILL.md "What Survives Compaction" table — byte-for-byte.
- * The `peaks compact survival` primitive emits these lists verbatim.
- */
-export declare const SURVIVAL_TABLE: Readonly<{
-    persists: readonly string[];
-    lost: readonly string[];
-}>;
-/**
- * Resolve a (from, to) phase pair to a recommend() envelope.
- * Unknown pairs return `severity: 'no'` with `notInTable: true` so the
- * LLM can see "this transition isn't in the table" instead of silently
- * getting a default.
- */
-export declare function lookupPhaseTransition(from: Phase, to: Phase): {
-    severity: Severity;
-    rationale: string;
-    notInTable: boolean;
-};
-/**
- * LLM-ready `/compact Focus on ...` prompt string. The phrasing is
- * deliberately terse — the upstream ECC suggest-compact hook uses a
- * similar short imperative form.
- */
-export declare function buildSuggestedCompactMessage(from: Phase, to: Phase, severity: Severity): string;

package/dist/src/services/compact/decision-tables.js

@@ -1,127 +0,0 @@
-/**
- * Strategic-compact decision tables (slice 2026-07-01-strategic-compact-cli).
- *
- * Pure data + lookup helpers. No I/O. The byte-for-byte text mirrors the
- * "Compaction Decision Guide" + "What Survives Compaction" tables in
- * ECC's strategic-compact SKILL.md (read-only reference at
- * C:\Users\smallMark\.claude\plugins\cache\ecc\ecc\2.0.0\skills\strategic-compact\SKILL.md).
- *
- * The `peaks compact recommend` + `peaks compact survival` + `peaks
- * compact dry-run` primitives read from these tables; any change to the
- * upstream skill table must be mirrored here and re-asserted by the
- * `tests/unit/cli/compact-command.test.ts` regression suite.
- */
-export const PHASES = [
-    'research',
-    'planning',
-    'implementation',
-    'testing',
-    'debugging'
-];
-export function isPhase(value) {
-    return PHASES.includes(value);
-}
-/**
- * Single source of truth for the strategic-compact "Compaction Decision
- * Guide" table. Each row is a recommended from→to transition. The
- * `rationale` field is the "Why" column verbatim from SKILL.md.
- *
- * The CLI accepts arbitrary from/to phase pairs; if the pair is not in
- * the table (e.g. testing→implementation) the recommend primitive
- * returns `severity: 'no'` with a `notInTable: true` flag and the
- * default rationale "No documented transition; preserve context".
- */
-export const PHASE_TRANSITIONS = [
-    {
-        from: 'research',
-        to: 'planning',
-        severity: 'yes',
-        rationale: 'Research context is bulky; plan is the distilled output'
-    },
-    {
-        from: 'planning',
-        to: 'implementation',
-        severity: 'yes',
-        rationale: 'Plan is in TodoWrite or a file; free up context for code'
-    },
-    {
-        from: 'implementation',
-        to: 'testing',
-        severity: 'maybe',
-        rationale: 'Keep if tests reference recent code; compact if switching focus'
-    },
-    {
-        from: 'debugging',
-        to: 'implementation',
-        severity: 'yes',
-        rationale: 'Debug traces pollute context for unrelated work'
-    }
-];
-/** Documented "no compact" rows from the SKILL.md table. */
-export const PHASE_NO_TRANSITIONS = [
-    {
-        from: 'implementation',
-        to: 'implementation',
-        rationale: 'Mid-implementation: losing variable names, file paths, and partial state is costly'
-    },
-    {
-        from: 'debugging',
-        to: 'debugging',
-        rationale: 'After a failed approach: keep context until you commit to a new direction'
-    }
-];
-/**
- * SKILL.md "What Survives Compaction" table — byte-for-byte.
- * The `peaks compact survival` primitive emits these lists verbatim.
- */
-export const SURVIVAL_TABLE = {
-    persists: [
-        'CLAUDE.md instructions',
-        'TodoWrite task list',
-        'Memory files (~/.claude/memory/)',
-        'Git state (commits, branches)',
-        'Files on disk'
-    ],
-    lost: [
-        'Intermediate reasoning and analysis',
-        'File contents you previously read',
-        'Multi-step conversation context',
-        'Tool call history and counts',
-        'Nuanced user preferences stated verbally'
-    ]
-};
-/**
- * Resolve a (from, to) phase pair to a recommend() envelope.
- * Unknown pairs return `severity: 'no'` with `notInTable: true` so the
- * LLM can see "this transition isn't in the table" instead of silently
- * getting a default.
- */
-export function lookupPhaseTransition(from, to) {
-    const direct = PHASE_TRANSITIONS.find((row) => row.from === from && row.to === to);
-    if (direct !== undefined) {
-        return { severity: direct.severity, rationale: direct.rationale, notInTable: false };
-    }
-    const noRow = PHASE_NO_TRANSITIONS.find((row) => row.from === from && row.to === to);
-    if (noRow !== undefined) {
-        return { severity: 'no', rationale: noRow.rationale, notInTable: false };
-    }
-    return {
-        severity: 'no',
-        rationale: 'No documented transition; preserve context',
-        notInTable: true
-    };
-}
-/**
- * LLM-ready `/compact Focus on ...` prompt string. The phrasing is
- * deliberately terse — the upstream ECC suggest-compact hook uses a
- * similar short imperative form.
- */
-export function buildSuggestedCompactMessage(from, to, severity) {
-    if (severity === 'no') {
-        return `/compact Preserve context for ongoing ${from} work; do not abandon in-flight state.`;
-    }
-    if (severity === 'maybe') {
-        return `/compact Focus on completing ${to} for the current thread; preserve recent code references.`;
-    }
-    return `/compact Focus on ${to}: ${from} context has been distilled into the plan / todo list.`;
-}

package/dist/src/services/compact/request-transition-hook.d.ts

@@ -1,20 +0,0 @@
-export interface PreCompactHookInput {
-    readonly projectRoot: string;
-    readonly sessionId: string;
-    readonly transitionKey: string;
-}
-export interface PreCompactHookResult {
-    readonly triggered: boolean;
-    readonly checkpointPath: string | null;
-    readonly ratio: number;
-    readonly zone: 'none' | 'soft-warn' | 'pre-compact' | 'red-line';
-    readonly note: string;
-}
-/**
- * Check the pre-compact zone and, if active, write a checkpoint.
- * Returns a result envelope the caller can stitch into the
- * transition response. NEVER throws; returns a `triggered: false`
- * result on any error so the transition itself stays the contract
- * surface.
- */
-export declare function maybePreCompactCheckpoint(input: PreCompactHookInput): PreCompactHookResult;

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

@@ -1,110 +0,0 @@
-/**
- * Slice-boundary pre-compact hook (slice 2026-07-01-strategic-compact-cli).
- *
- * The RD → QA and QA → final-review slice-boundary transitions go
- * through `peaks request transition`. When the active session is in
- * the 0.85–0.95 pre-compact zone (per auto-compact-types.ts), this
- * hook:
- *
- *   1. Detects the zone via the latest `.peaks/_runtime/<sid>/usage.jsonl`
- *      row, OR falls back to `peaks compact suggest --json`.
- *   2. Writes a `context-fill` checkpoint BEFORE the transition so
- *      the post-compact LLM has a deterministic resume surface.
- *   3. Attaches `preCompactCheckpoint: true` to the transition
- *      envelope so the LLM can audit the side-effect.
- *
- * The hook is INVOKED from `src/cli/commands/request-commands.ts`
- * (RD→QA boundary) and from any future QA→final-review boundary. The
- * 0.95 red line is NOT changed: the existing auto-compact
- * orchestrator continues to refuse dispatch at ratio ≥ 0.95.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { writeCheckpoint } from '../session/session-checkpoint-service.js';
-import { AUTO_COMPACT_PRE_COMPACT_RATIO, AUTO_COMPACT_RED_LINE_RATIO } from '../context/auto-compact-types.js';
-const PRE_COMPACT_ZONE = {
-    preCompact: AUTO_COMPACT_PRE_COMPACT_RATIO,
-    redLine: AUTO_COMPACT_RED_LINE_RATIO
-};
-function readLatestUsageRow(projectRoot, sessionId) {
-    const path = join(projectRoot, '.peaks', '_runtime', sessionId, 'usage.jsonl');
-    if (!existsSync(path))
-        return null;
-    try {
-        const raw = readFileSync(path, 'utf8');
-        const lines = raw.split(/\r?\n/).filter((l) => l.length > 0);
-        if (lines.length === 0)
-            return null;
-        const last = lines[lines.length - 1];
-        if (last === undefined)
-            return null;
-        return JSON.parse(last);
-    }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-        return null;
-    }
-}
-/**
- * Compute the context-fill ratio from a usage row. Defaults to a
- * 200k window when the row is missing capacity. The auto-compact
- * types use a 256KB byte-based estimate; this hook uses a 200k
- * token-based window to match the strategic-compact SKILL.md.
- */
-function computeRatio(row) {
-    if (row === null)
-        return { ratio: 0, zone: 'none' };
-    const tokens = typeof row.tokens === 'number' && Number.isFinite(row.tokens) ? row.tokens : 0;
-    const capacity = typeof row.capacityTokens === 'number' && row.capacityTokens > 0 ? row.capacityTokens : 200_000;
-    const ratio = capacity > 0 ? tokens / capacity : 0;
-    if (ratio >= PRE_COMPACT_ZONE.redLine)
-        return { ratio, zone: 'red-line' };
-    if (ratio >= PRE_COMPACT_ZONE.preCompact)
-        return { ratio, zone: 'pre-compact' };
-    if (ratio >= 0.5)
-        return { ratio, zone: 'soft-warn' };
-    return { ratio, zone: 'none' };
-}
-/**
- * Check the pre-compact zone and, if active, write a checkpoint.
- * Returns a result envelope the caller can stitch into the
- * transition response. NEVER throws; returns a `triggered: false`
- * result on any error so the transition itself stays the contract
- * surface.
- */
-export function maybePreCompactCheckpoint(input) {
-    try {
-        const row = readLatestUsageRow(input.projectRoot, input.sessionId);
-        const { ratio, zone } = computeRatio(row);
-        if (zone !== 'pre-compact') {
-            return {
-                triggered: false,
-                checkpointPath: null,
-                ratio,
-                zone,
-                note: `ratio=${(ratio * 100).toFixed(1)}% (zone=${zone}); pre-compact hook is in 0.85–0.95 zone only`
-            };
-        }
-        const result = writeCheckpoint(input.projectRoot, {
-            sessionId: input.sessionId,
-            reason: 'context-fill',
-            gitStatus: `preCompactCheckpoint: ${input.transitionKey}`,
-            currentPlan: `Slice boundary transition: ${input.transitionKey}`
-        });
-        return {
-            triggered: true,
-            checkpointPath: result.path,
-            ratio,
-            zone,
-            note: `Pre-compact checkpoint written at ratio=${(ratio * 100).toFixed(1)}% (zone=pre-compact). The LLM is still the decision-maker; the transition will proceed.`
-        };
-    }
-    catch (error) {
-        return {
-            triggered: false,
-            checkpointPath: null,
-            ratio: 0,
-            zone: 'none',
-            note: `pre-compact hook failed: ${error.message ?? String(error)}`
-        };
-    }
-}

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

@@ -1,74 +0,0 @@
-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;
-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;
-    to: Phase;
-    shouldCompact: boolean;
-    severity: Severity;
-    rationale: string;
-    suggestedMessage: string;
-};
-export { PHASE_TRANSITIONS, lookupPhaseTransition, buildSuggestedCompactMessage, PHASES, isPhase, SURVIVAL_TABLE } from './decision-tables.js';
-export type { Phase, Severity } from './decision-tables.js';

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

@@ -1,203 +0,0 @@
-/**
- * `peaks compact suggest` — strategic-compact service layer.
- *
- * Mirrors the ECC `suggest-compact.js` PreToolUse hook's two-signal
- * suggestion logic but as a deterministic, machine-enforced CLI
- * primitive. Two signals:
- *
- *   1. Context size (primary) — read latest usage row from
- *      `.peaks/_runtime/<sid>/usage.jsonl`. Suggest at
- *      COMPACT_CONTEXT_THRESHOLD (default 160k on 200k window, 250k
- *      on 1M window) and re-remind every COMPACT_CONTEXT_INTERVAL
- *      tokens (default 60k). A 1M window is detected when observed
- *      tokens exceed 200k AND the `modelKind: '1m'` marker is on
- *      the latest usage row, or when PEAKS_MODEL_KIND=1m is set.
- *
- *   2. Tool-call count (secondary) — read latest tool-call counter
- *      from the same usage.jsonl. Suggest at COMPACT_THRESHOLD
- *      (default 50) and re-remind every 25 calls.
- *
- * If usage.jsonl is absent (no peaks-loop session yet), fall back to
- * PEAKS_CONTEXT_TOKENS / PEAKS_TOOL_CALLS env vars. If neither signal
- * is available, the primitive returns `shouldSuggest: false` and a
- * `dataUnavailable: true` flag — never throws.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { lookupPhaseTransition, buildSuggestedCompactMessage, SURVIVAL_TABLE } from './decision-tables.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))
-        return null;
-    try {
-        const raw = readFileSync(path, 'utf8');
-        const lines = raw.split(/\r?\n/).filter((l) => l.length > 0);
-        if (lines.length === 0)
-            return null;
-        const last = lines[lines.length - 1];
-        if (last === undefined)
-            return null;
-        return JSON.parse(last);
-    }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-        return null;
-    }
-}
-function parseIntEnv(env, key, fallback) {
-    const raw = env[key];
-    if (typeof raw !== 'string' || raw.length === 0)
-        return fallback;
-    const parsed = Number.parseInt(raw, 10);
-    return Number.isFinite(parsed) ? parsed : fallback;
-}
-function detectWindowKind(env, observedTokens, rowModelKind) {
-    if (rowModelKind === '1m')
-        return '1m';
-    if (env['PEAKS_MODEL_KIND'] === '1m')
-        return '1m';
-    // Heuristic from SKILL.md: a `[1m]` model marker OR observed tokens
-    // already exceed the 200k window. We use observed as the second
-    // signal only.
-    if (observedTokens > DEFAULT_CONTEXT_THRESHOLD_200K)
-        return '1m';
-    return '200k';
-}
-export function suggestCompact(options) {
-    const env = options.env ?? process.env;
-    const contextThreshold = parseIntEnv(env, 'COMPACT_CONTEXT_THRESHOLD', 0);
-    const contextInterval = parseIntEnv(env, 'COMPACT_CONTEXT_INTERVAL', DEFAULT_CONTEXT_INTERVAL);
-    const toolCallThreshold = parseIntEnv(env, 'COMPACT_THRESHOLD', DEFAULT_TOOL_CALL_THRESHOLD);
-    let tokensUsed = 0;
-    let toolCalls = 0;
-    let modelKind;
-    let source = 'none';
-    if (options.sessionId !== null) {
-        const row = readLatestUsageRow(options.projectRoot, options.sessionId);
-        if (row !== null) {
-            if (typeof row.tokens === 'number' && Number.isFinite(row.tokens))
-                tokensUsed = row.tokens;
-            if (typeof row.toolCalls === 'number' && Number.isFinite(row.toolCalls))
-                toolCalls = row.toolCalls;
-            if (typeof row.modelKind === 'string')
-                modelKind = row.modelKind;
-            source = 'usage-jsonl';
-        }
-    }
-    if (source === 'none') {
-        const envTokens = env['PEAKS_CONTEXT_TOKENS'];
-        if (typeof envTokens === 'string' && envTokens.length > 0) {
-            const parsed = Number.parseInt(envTokens, 10);
-            if (Number.isFinite(parsed) && parsed >= 0) {
-                tokensUsed = parsed;
-                source = 'env-vars';
-            }
-        }
-        const envCalls = env['PEAKS_TOOL_CALLS'];
-        if (typeof envCalls === 'string' && envCalls.length > 0) {
-            const parsed = Number.parseInt(envCalls, 10);
-            if (Number.isFinite(parsed) && parsed >= 0) {
-                toolCalls = parsed;
-                source = 'env-vars';
-            }
-        }
-    }
-    const windowKind = detectWindowKind(env, tokensUsed, modelKind);
-    const windowCapacity = windowKind === '1m' ? 1_000_000 : 200_000;
-    const effectiveContextThreshold = contextThreshold > 0
-        ? contextThreshold
-        : (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
-    // gets a real "/compact" recommendation only when context-size OR
-    // tool-count crosses the threshold AND we have non-zero data.
-    let shouldSuggest = false;
-    let reason = 'below-threshold';
-    if (!dataUnavailable) {
-        if (contextThreshold !== 0 && tokensUsed >= effectiveContextThreshold) {
-            shouldSuggest = true;
-            const overBy = tokensUsed - effectiveContextThreshold;
-            reason = `context >= ${effectiveContextThreshold} on ${windowKind} window (over by ${overBy} tokens)`;
-        }
-        else if (toolCalls >= toolCallThreshold) {
-            shouldSuggest = true;
-            reason = `tool-calls >= ${toolCallThreshold} (count=${toolCalls})`;
-        }
-    }
-    return {
-        shouldSuggest,
-        reason,
-        ratio,
-        windowKind,
-        tokensUsed,
-        toolCalls,
-        thresholds: {
-            contextTokens: effectiveContextThreshold,
-            contextInterval,
-            toolCalls: toolCallThreshold
-        },
-        dataUnavailable,
-        source
-    };
-}
-export function dryRunCompact(options) {
-    const suggest = suggestCompact({
-        projectRoot: options.projectRoot,
-        sessionId: options.sessionId,
-        ...(options.env !== undefined ? { env: options.env } : {})
-    });
-    const hasPhase = options.from !== undefined && options.to !== undefined;
-    const recommend = hasPhase
-        ? buildRecommendEnvelope(options.from, options.to)
-        : {
-            from: null,
-            to: null,
-            shouldCompact: false,
-            severity: null,
-            rationale: null,
-            suggestedMessage: null
-        };
-    // Action threshold: either suggest-signal OR recommend=yes. The LLM
-    // is the final arbiter; the primitive just surfaces the composite
-    // signal.
-    const action = suggest.shouldSuggest || recommend.shouldCompact ? 'compact' : 'skip';
-    return {
-        action,
-        suggest,
-        recommend,
-        survival: { persists: SURVIVAL_TABLE_PERSISTS, lost: SURVIVAL_TABLE_LOST }
-    };
-}
-function buildRecommendEnvelope(from, to) {
-    const lookup = lookupPhaseTransition(from, to);
-    const shouldCompact = lookup.severity === 'yes' || lookup.severity === 'maybe';
-    return {
-        from,
-        to,
-        shouldCompact,
-        severity: lookup.severity,
-        rationale: lookup.rationale,
-        suggestedMessage: buildSuggestedCompactMessage(from, to, lookup.severity)
-    };
-}
-export function buildRecommendEnvelopePure(from, to) {
-    return buildRecommendEnvelope(from, to);
-}
-// Re-export phase primitives for callers that don't want to traverse
-// decision-tables. The CLI command file imports `isPhase` from here
-// 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';

package/dist/src/services/complexity/complexity-estimator.d.ts

@@ -1,34 +0,0 @@
-/**
- * v2.15.0 follow-up — G10: complexity estimator.
- *
- * 12 Gaps memory: the G2 complexity tier drives user-attended vs overnight
- * scheduling. This service estimates the complexity of a set of files
- * based on LOC + a few cheap heuristics.
- *
- * Tier thresholds (G2 12 Gaps memory):
- *   - trivial : ≤ 50 lines, no async, no IO
- *   - simple  : ≤ 200 lines, ≤ 3 exports
- *   - complex : > 200 lines, OR many exports, OR has async/await
- *
- * Pure function. CLI: `peaks complexity estimate --files <list>`.
- */
-export type ComplexityTier = 'trivial' | 'simple' | 'complex';
-export interface FileComplexity {
-    readonly file: string;
-    readonly lines: number;
-    readonly exports: number;
-    readonly hasAsync: boolean;
-    readonly tier: ComplexityTier;
-}
-export interface ComplexityEstimate {
-    readonly files: readonly FileComplexity[];
-    readonly overall: ComplexityTier;
-    readonly summary: {
-        trivial: number;
-        simple: number;
-        complex: number;
-    };
-}
-export declare function estimateFileComplexity(file: string): FileComplexity | null;
-export declare function aggregateTier(tiers: readonly ComplexityTier[]): ComplexityTier;
-export declare function estimateComplexity(projectRoot: string, files: readonly string[]): ComplexityEstimate;