peaks-loop 4.0.0-beta.8 → 4.0.1

package/dist/services/classify/classify-types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * L1a task classification — types and per-level gate sets.
+ *
+ * Spec: docs/superpowers/specs/2026-06-11-peaks-loop-l1-l2-l3-redesign.md §4
+ *
+ * Five task levels: typo / bug / feature / refactor / migration. Each
+ * level has a gate set (the "配套 gate set" — L1b) that the slice
+ * checker runs. Higher levels = more gates = slower but safer.
+ *
+ * The classification is a HYBRID mechanism:
+ *   1. Heuristic signal (file count, line count, keyword presence)
+ *   2. User override (`peaks classify override --level <level> --reason "<>"`)
+ *   3. Audit log of every classification (forensics)
+ *
+ * Conservatism modifier (per .peaks/preferences.json:classifyConservatism):
+ *   - 'default' — use the signal thresholds as-is
+ *   - 'strict'  — always upgrade to next level
+ *   - 'lax'     — always downgrade to previous level
+ */
+export type TaskLevel = 'typo' | 'bug' | 'feature' | 'refactor' | 'migration';
+export declare const TASK_LEVELS: readonly TaskLevel[];
+/** Numeric ordering for "next level" / "previous level" promotion. */
+export declare const TASK_LEVEL_ORDER: Readonly<Record<TaskLevel, number>>;
+export interface ClassifySignals {
+    /** Number of files changed in the diff. */
+    readonly filesChanged: number;
+    /** Number of lines added + removed in the diff. */
+    readonly linesChanged: number;
+    /** Whether the diff includes dependency files (package.json, etc.). */
+    readonly touchesDependencies: boolean;
+    /** Whether the diff includes migration scripts / codemods. */
+    readonly touchesMigrationScripts: boolean;
+    /** Whether the diff is mostly renames / formatting / comment changes. */
+    readonly isPureRefactor: boolean;
+    /** Keywords found in the change description or commit message. */
+    readonly keywords: readonly string[];
+}
+/** The gate set that runs for a given task level (L1b). */
+export interface TaskLevelGateSet {
+    readonly level: TaskLevel;
+    /** Human-readable description. */
+    readonly description: string;
+    /** Which slice-check stages run at this level. */
+    readonly stages: readonly string[];
+    /** Whether PRD is required at this level. */
+    readonly requiresPrd: boolean;
+    /** Whether a tech-doc is required at this level. */
+    readonly requiresTechDoc: boolean;
+    /** Whether a code review is required at this level. */
+    readonly requiresCodeReview: boolean;
+    /** Whether a security review is required at this level. */
+    readonly requiresSecurityReview: boolean;
+    /** Whether a perf baseline is required at this level. */
+    readonly requiresPerfBaseline: boolean;
+    /** Whether the slice must transition through QA handoff. */
+    readonly requiresQaHandoff: boolean;
+    /** Whether the user must explicitly confirm destructive paths. */
+    readonly requiresDestructiveConfirmation: boolean;
+}
+export declare const TASK_LEVEL_GATE_SETS: Readonly<Record<TaskLevel, TaskLevelGateSet>>;
+/** Result of a classification (deterministic given signals + conservatism). */
+export interface ClassifyResult {
+    readonly level: TaskLevel;
+    readonly signals: ClassifySignals;
+    /** Why this level was chosen (1-2 sentence explanation). */
+    readonly rationale: string;
+    /** The gate set that will run for this level. */
+    readonly gateSet: TaskLevelGateSet;
+    /** The audit log entry (every classification is logged). */
+    readonly audit: ClassifyAuditEntry;
+}
+export interface ClassifyAuditEntry {
+    readonly timestamp: string;
+    readonly inputs: ClassifySignals;
+    readonly output: TaskLevel;
+    readonly conservatism: 'default' | 'strict' | 'lax';
+    readonly overrideApplied: boolean;
+    readonly reason: string;
+}

package/dist/services/classify/classify-types.js

@@ -0,0 +1,90 @@
+/**
+ * L1a task classification — types and per-level gate sets.
+ *
+ * Spec: docs/superpowers/specs/2026-06-11-peaks-loop-l1-l2-l3-redesign.md §4
+ *
+ * Five task levels: typo / bug / feature / refactor / migration. Each
+ * level has a gate set (the "配套 gate set" — L1b) that the slice
+ * checker runs. Higher levels = more gates = slower but safer.
+ *
+ * The classification is a HYBRID mechanism:
+ *   1. Heuristic signal (file count, line count, keyword presence)
+ *   2. User override (`peaks classify override --level <level> --reason "<>"`)
+ *   3. Audit log of every classification (forensics)
+ *
+ * Conservatism modifier (per .peaks/preferences.json:classifyConservatism):
+ *   - 'default' — use the signal thresholds as-is
+ *   - 'strict'  — always upgrade to next level
+ *   - 'lax'     — always downgrade to previous level
+ */
+export const TASK_LEVELS = ['typo', 'bug', 'feature', 'refactor', 'migration'];
+/** Numeric ordering for "next level" / "previous level" promotion. */
+export const TASK_LEVEL_ORDER = {
+    typo: 0,
+    bug: 1,
+    feature: 2,
+    refactor: 3,
+    migration: 4,
+};
+export const TASK_LEVEL_GATE_SETS = {
+    typo: {
+        level: 'typo',
+        description: 'Single-line fix: typo, comment, formatting. No new logic.',
+        stages: ['typecheck', 'lint'],
+        requiresPrd: false,
+        requiresTechDoc: false,
+        requiresCodeReview: false,
+        requiresSecurityReview: false,
+        requiresPerfBaseline: false,
+        requiresQaHandoff: false,
+        requiresDestructiveConfirmation: false,
+    },
+    bug: {
+        level: 'bug',
+        description: 'Bug fix: existing behavior wrong, patched in 1-3 files.',
+        stages: ['typecheck', 'unit-tests', 'lint'],
+        requiresPrd: false,
+        requiresTechDoc: false,
+        requiresCodeReview: true,
+        requiresSecurityReview: false,
+        requiresPerfBaseline: false,
+        requiresQaHandoff: false,
+        requiresDestructiveConfirmation: false,
+    },
+    feature: {
+        level: 'feature',
+        description: 'New feature: new behavior, new files, new tests.',
+        stages: ['typecheck', 'unit-tests', 'lint', 'review-fanout', 'gate-verify-pipeline'],
+        requiresPrd: true,
+        requiresTechDoc: true,
+        requiresCodeReview: true,
+        requiresSecurityReview: true,
+        requiresPerfBaseline: true,
+        requiresQaHandoff: true,
+        requiresDestructiveConfirmation: true,
+    },
+    refactor: {
+        level: 'refactor',
+        description: 'Refactor: behavior-preserving structural change.',
+        stages: ['typecheck', 'unit-tests', 'lint', 'review-fanout'],
+        requiresPrd: false,
+        requiresTechDoc: true,
+        requiresCodeReview: true,
+        requiresSecurityReview: true,
+        requiresPerfBaseline: false,
+        requiresQaHandoff: true,
+        requiresDestructiveConfirmation: false,
+    },
+    migration: {
+        level: 'migration',
+        description: 'Migration: codemod, schema change, data backfill, dependency upgrade.',
+        stages: ['typecheck', 'unit-tests', 'lint', 'review-fanout', 'gate-verify-pipeline', 'backward-compat'],
+        requiresPrd: true,
+        requiresTechDoc: true,
+        requiresCodeReview: true,
+        requiresSecurityReview: true,
+        requiresPerfBaseline: true,
+        requiresQaHandoff: true,
+        requiresDestructiveConfirmation: true,
+    },
+};

package/dist/services/code/auto-compact-modes.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Slice 2026-07-28 — auto-compact mode table for 24h long-run awareness.
+ *
+ * The default `'standard'` mode preserves the v2.13.0 zero-pause contract
+ * thresholds (preCompact=0.85, redLine=0.95). The `'partial'` mode fires
+ * earlier for 24h long-run scenarios where the user has explicitly
+ * opted into higher compaction cadence via `peaks session 24h-mode`.
+ *
+ * Slice 2026-07-29-context-evaluation-accuracy Part 22: a new
+ * `autoFire` tier is added between soft-warn and preCompact. peaks-loop
+ * preempts and runs `peaks compact auto --execute` itself when
+ * context crosses `autoFire`; the LLM is NOT asked to "decide"
+ * (the LLM-judged 0.85–0.95 zone was the source of false-positive
+ * "context too low" reports at 60%+ free — the LLM was guessing).
+ *
+ * The mode only changes the THRESHOLDS at which the orchestrator fires.
+ * The actual partial-compaction behaviour (dropping low-priority context
+ * layers) is a follow-up slice; for now `partial` mode is logged +
+ * decision-emitted, no separate compaction pathway.
+ */
+export type AutoCompactMode = 'standard' | 'partial';
+export declare const AUTO_COMPACT_THRESHOLDS: Readonly<Record<AutoCompactMode, {
+    readonly autoFire: number;
+    readonly preCompact: number;
+    readonly redLine: number;
+}>>;
+export declare function thresholdFor(mode: AutoCompactMode, kind: 'autoFire' | 'preCompact' | 'redLine'): number;
+export declare function isValidMode(value: string): value is AutoCompactMode;
+export declare function describeMode(mode: AutoCompactMode): string;
+export declare function isPartialModeEligible(contextPercent: number): boolean;

package/dist/services/code/auto-compact-modes.js

@@ -0,0 +1,38 @@
+/**
+ * Slice 2026-07-28 — auto-compact mode table for 24h long-run awareness.
+ *
+ * The default `'standard'` mode preserves the v2.13.0 zero-pause contract
+ * thresholds (preCompact=0.85, redLine=0.95). The `'partial'` mode fires
+ * earlier for 24h long-run scenarios where the user has explicitly
+ * opted into higher compaction cadence via `peaks session 24h-mode`.
+ *
+ * Slice 2026-07-29-context-evaluation-accuracy Part 22: a new
+ * `autoFire` tier is added between soft-warn and preCompact. peaks-loop
+ * preempts and runs `peaks compact auto --execute` itself when
+ * context crosses `autoFire`; the LLM is NOT asked to "decide"
+ * (the LLM-judged 0.85–0.95 zone was the source of false-positive
+ * "context too low" reports at 60%+ free — the LLM was guessing).
+ *
+ * The mode only changes the THRESHOLDS at which the orchestrator fires.
+ * The actual partial-compaction behaviour (dropping low-priority context
+ * layers) is a follow-up slice; for now `partial` mode is logged +
+ * decision-emitted, no separate compaction pathway.
+ */
+export const AUTO_COMPACT_THRESHOLDS = {
+    standard: { autoFire: 0.80, preCompact: 0.85, redLine: 0.95 },
+    partial: { autoFire: 0.65, preCompact: 0.70, redLine: 0.85 }
+};
+export function thresholdFor(mode, kind) {
+    return AUTO_COMPACT_THRESHOLDS[mode][kind];
+}
+export function isValidMode(value) {
+    return value === 'standard' || value === 'partial';
+}
+export function describeMode(mode) {
+    return mode === 'standard'
+        ? 'standard (0.85/0.95 — v2.13.0 zero-pause contract)'
+        : 'partial (0.70/0.85 — 24h long-run mode)';
+}
+export function isPartialModeEligible(contextPercent) {
+    return contextPercent >= AUTO_COMPACT_THRESHOLDS.partial.preCompact;
+}

package/dist/services/code/auto-compact-orchestrator.d.ts

@@ -0,0 +1,136 @@
+import { type CompactTrigger, type ConvergencePlan, type InFlightBatchProbe, type AutoCompactResult } from '../context/auto-compact-types.js';
+import type { CompactTarget } from '../context/auto-compact-dispatcher.js';
+import { type AutoCompactMode } from './auto-compact-modes.js';
+export interface AutoCompactInput {
+    /** Project root for context (default cwd). */
+    readonly projectRoot: string;
+    /** Caller-provided in-flight batch probe (default false). */
+    readonly inFlightBatch?: InFlightBatchProbe | undefined;
+    /**
+     * Force execute even when ratio < threshold (test seam). In
+     * production this is always `false` — peaks-loop drives compact
+     * autonomously at 0.85+ with zero human / zero LLM intervention.
+     */
+    readonly force?: boolean | undefined;
+    /** Skip the 95% red-line gate (test seam — never true in production). */
+    readonly bypassRedLine?: boolean | undefined;
+    /** Current session id (default = resolve via session-id-service). */
+    readonly sessionId?: string | undefined;
+    /** Injectable env for IDE detection (test seam). */
+    readonly env?: NodeJS.ProcessEnv | undefined;
+    /** Injectable clock for mtime checks (test seam). */
+    readonly now?: Date | undefined;
+    /**
+     * Slice 2026-06-28-code-mode-bypass-fix (defect #4): which session
+     * the compact should target. Default `'main'` — the orchestrator
+     * (peaks-code body) runs in the main-session Claude Code window and
+     * wants to compress *its* context. Sub-agent shells pass
+     * `'sub-agent'` to preserve the legacy shell-spawn behaviour.
+     */
+    readonly target?: CompactTarget | undefined;
+    /**
+     * Slice 2026-07-28 (rid-027): auto-compact mode. Default
+     * `'standard'` (v2.13.0 zero-pause contract, 0.85/0.95). `'partial'`
+     * fires earlier (0.70/0.85) for 24h long-run scenarios. CLI flag
+     * `--mode <mode>` overrides the 24h-mode auto-detection.
+     */
+    readonly mode?: AutoCompactMode | undefined;
+}
+/**
+ * Map a context ratio to a `CompactTrigger` action. Pure; the side
+ * effects (checkpoint + IDE dispatch) live in `runAutoCompact`. Two
+ * tiers (standard mode; partial mode shifts both thresholds):
+ *
+ *   - ratio < preCompact → 'none' or 'soft-warn'
+ *   - ratio ≥ preCompact → 'pre-compact' (async-friendly path)
+ *   - ratio ≥ redLine    → 'red-line' (synchronous gate)
+ *
+ * Slice 2026-07-28 (rid-027): `mode` selects the threshold table.
+ * Default `'standard'` (0.85/0.95). `'partial'` (0.70/0.85) is used
+ * when 24h long-run mode is active or `--mode partial` is passed.
+ */
+export declare function evaluateCompactTrigger(ratio: number, mode?: AutoCompactMode): CompactTrigger;
+/**
+ * Decide whether to run the auto-compact flow. Pure function for the
+ * decision; side effects (checkpoint + IDE dispatch) live in
+ * `runAutoCompact` below. Zero human / zero LLM intervention:
+ *
+ *   - ratio < 0.85           → skip (LLM keeps working; no action)
+ *   - 0.85 ≤ ratio < 0.95    → pre-compact; if in-flight batch
+ *                                present, defer (D6.e); else dispatch
+ *                                IDE compact asynchronously.
+ *   - ratio ≥ 0.95           → red-line; ALWAYS dispatch synchronously
+ *                                regardless of in-flight batch.
+ */
+export declare function evaluateAutoCompactDecision(input: {
+    ratio: number;
+    inFlightBatch?: InFlightBatchProbe | undefined;
+    force?: boolean | undefined;
+    bypassRedLine?: boolean | undefined;
+    mode?: AutoCompactMode | undefined;
+}): {
+    shouldCompact: boolean;
+    reason: 'below-threshold' | 'in-flight-batch' | 'pre-compact' | 'red-line';
+    trigger: CompactTrigger;
+};
+/**
+ * Build the convergence plan that D7's post-compact-detect will read
+ * back. Includes the current plan, open questions, recent decisions,
+ * todo state, and recent artifact paths — strictly more than what a
+ * raw `/compact` would preserve.
+ */
+export declare function buildConvergencePlan(input: {
+    readonly sessionId: string;
+    readonly projectRoot: string;
+    readonly ratio: number;
+    readonly checkpointPath: string;
+    readonly nextActions: readonly string[];
+    readonly redLine?: boolean;
+}): ConvergencePlan;
+/**
+ * Execute the auto-compact flow.
+ *
+ * Steps (orchestration):
+ *   1. Resolve session id.
+ *   2. Read current ratio via AC-1 (`readContextPercent`).
+ *   3. Evaluate trigger via `evaluateCompactTrigger`.
+ *   4. If trigger.kind === 'none' / 'soft-warn' → return skip.
+ *   5. If trigger.kind === 'pre-compact' AND in-flight batch → wait.
+ *   6. If trigger.kind === 'pre-compact' → async dispatch (write
+ *      checkpoint + IDE compact; orchestrator returns immediately).
+ *   7. If trigger.kind === 'red-line' → synchronous gate: refuse
+ *      sub-agent dispatch, dispatch IDE compact, mark `redLineGated`.
+ *
+ * The caller (CLI or skill body) handles the actual return — D7's
+ * post-compact-detect will pick up the checkpoint on the next turn.
+ * For red-line, the caller MUST block further tool calls until the
+ * post-compact probe confirms ratio < 0.85.
+ */
+export declare function runAutoCompact(input: AutoCompactInput): Promise<AutoCompactResult>;
+/** Re-export for callers that need to surface the trigger shape. */
+export type { CompactTrigger, ConvergencePlan, InFlightBatchProbe, AutoCompactResult };
+/**
+ * Slice 2026-07-30-compact-visibility: JSONL history of every
+ * auto-compact dispatch. Appended at the end of `executeAutoCompact`
+ * so the new 'peaks compact history' CLI + the
+ * 'peaks statusline compact' indicator have a record. One file
+ * per session (gitignored under `.peaks/_runtime/<sessionId>/`).
+ */
+export interface CompactHistoryEvent {
+    readonly schemaVersion: 1;
+    readonly ts: string;
+    readonly target: 'main' | 'sub-agent' | 'worker';
+    readonly mode: 'standard' | 'partial' | 'aggressive';
+    readonly ide: string;
+    readonly pathway: string;
+    readonly beforeRatio: number;
+    readonly redLine: boolean;
+    readonly ok: boolean;
+    readonly checkpointPath: string;
+    readonly dispatchMessage: string;
+}
+export declare function appendCompactHistoryEvent(input: {
+    readonly projectRoot: string;
+    readonly sessionId: string;
+    readonly event: CompactHistoryEvent;
+}): void;