pi-smart-compact 7.12.5 → 7.13.1

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [7.13.1] - 2026-05-26
+
+### Fixed
+- **Run-scoped service isolation** — Smart compaction runs now create isolated service containers for LLM calls, metrics, extraction-cache stats, token calibration, and provider prompt-cache session ids, reducing cross-run state pollution in concurrent Pi sessions.
+- **Phase timing accuracy** — Prune, extract, explore, and synthesize timings are now measured at their actual phase boundaries instead of adjacent marker calls that could report near-zero durations.
+- **Tool/noise accounting** — Tool character percentages now count only text blocks, avoiding accidental inclusion of provider tool-call fields with text-like payloads.
+- **File operation extraction coverage** — File-change detection now recognizes common patch/create/append/update/apply-style tool names in addition to write/edit/delete/read variants.
+
+### Tests
+- Added regression coverage for run-scoped LLM metrics isolation, text-only tool character accounting, and broader file-operation tool matching.
+
+## [7.13.0] - 2026-05-25
+
+### Added
+- **Interactive metrics dashboard TUI** — `/smart-compact dashboard` now opens an in-terminal dashboard with overview, latest-run details, current-session runs, recent runs, and an explicit HTML export action.
+- **Dashboard run detail formatting** — Added tested formatter helpers for legacy metrics, empty states, phase timings, compact run descriptions, and bounded percentage display.
+
+### Fixed
+- **Provider cache percentage accounting** — Provider prompt-cache hit rates now use an effective prompt-token denominator and are capped at 100%, preventing impossible values such as `572610%` when providers report cached tokens separately from new input tokens.
+- **Verification repair for malformed summaries** — Missing canonical sections are now reported as verification gaps and deterministic repair can create sections such as `## Goal`, `## Progress`, `## Critical Context`, and `## Files Modified` before injecting required facts.
+- **Dashboard comparison noise** — Legacy metrics entries without profile/provider metadata are omitted from profile/provider comparison groups instead of appearing as misleading `unknown` rows.
+
+### Changed
+- **Metrics readability** — Result overlays and notifications distinguish prompt, new, and cached input tokens when provider cache reads are present.
+- **Dashboard navigation** — The TUI supports keybinding-aware navigation plus page-up/page-down and home/end scrolling.
+
 ## [7.12.5] - 2026-05-23
 
 ### Fixed

package/README.md

@@ -1,8 +1,10 @@
 # pi-smart-compact
 
+[![CI](https://github.com/alpertarhan/pi-smart-compact/actions/workflows/ci.yml/badge.svg)](https://github.com/alpertarhan/pi-smart-compact/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/pi-smart-compact.svg)](https://www.npmjs.com/package/pi-smart-compact)
+[![npm downloads](https://img.shields.io/npm/dm/pi-smart-compact.svg)](https://www.npmjs.com/package/pi-smart-compact)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
-[![GitHub](https://img.shields.io/badge/GitHub-alpertarhan%2Fpi--smart--compact-blue)](https://github.com/alpertarhan/pi-smart-compact)
+[![Pi extension](https://img.shields.io/badge/Pi-extension-6f42c1)](https://github.com/earendil-works/pi)
 
 <p align="center">
   <img src="./docs/assets/pi-smart-compact.png" alt="pi-smart-compact" width="760" />
@@ -16,6 +18,14 @@ It uses an **EESV** pipeline:
 
 **Extract → Explore → Synthesize → Verify**
 
+## Highlights
+
+- **Pi-native integration** — `/smart-compact`, `smart_compact`, and `session_before_compact` support.
+- **Verification-oriented output** — deterministic extraction and repair before trusting LLM synthesis.
+- **Adaptive cost profile** — skips unnecessary work on small sessions and uses chunking only when useful.
+- **Operational safety** — pending summaries expire, backups are available, and metrics make regressions visible.
+- **Companion-friendly** — designed to coexist with context hygiene tools such as `pi-toolkit`.
+
 Under the hood, the design is grounded in two core ideas:
 
 - **agentic compaction**: let the system inspect and reason about the session instead of collapsing everything into generic prose
@@ -37,6 +47,10 @@ The extension stages a short-lived pending summary in memory, then hands it back
 
 ---
 
+## Project status
+
+This is an actively maintained Pi extension. The public API is intentionally small, but the internals are still evolving as Pi's compaction lifecycle and extension APIs mature. Pin versions in production workflows if compaction behavior is mission-critical.
+
 ## Compatibility note
 
 `pi-smart-compact` sits close to Pi's compaction path: it registers `session_before_compact`, reads the active branch and session log, stages a pending summary, and may call Pi's native compaction flow from `/smart-compact`.
@@ -186,7 +200,7 @@ The tool prepares a pending smart summary and lets Pi consume it on the next nat
 - pending summaries are kept in memory for **5 minutes**
 - exploration is adaptive and may be skipped for simple sessions
 - use `/smart-compact metrics` for profile/provider comparisons
-- use `/smart-compact dashboard` to write a local HTML report at `.cache/smart-compact-report.html`
+- use `/smart-compact dashboard` to open the interactive TUI dashboard (overview, latest run, current session, recent runs, or write HTML)
 
 This keeps the extension helpful without forcing extra work when it is not needed.
 
@@ -308,17 +322,51 @@ At runtime, the extension writes to paths under `~/.pi/agent/`, including:
 ```text
 .
 ├── src/
-│   ├── index.ts
-│   ├── core.ts
-│   ├── phases/
-│   ├── ui/
-│   └── utils/
-├── test/
+│   ├── index.ts              # extension registration + command routing
+│   ├── constants.ts          # version, thresholds, prompts
+│   ├── types.ts              # shared types
+│   ├── app/                  # orchestration layer
+│   │   ├── run-smart-compact.ts   # pipeline orchestrator (was core.ts)
+│   │   ├── run-context.ts         # typed stage chain
+│   │   ├── explore-wrap.ts        # explore re-export shim
+│   │   └── steps/                 # 10 stage modules
+│   │       ├── prepare.ts   →   resolves config + auth
+│   │       ├── window.ts    →   picks compaction window
+│   │       ├── recover.ts   →   recovers truncated messages
+│   │       ├── tier.ts      →   chooses compaction tier
+│   │       ├── extract.ts   →   pruning + extraction + cache
+│   │       ├── synthesize.ts→   single-pass / EESV summarization
+│   │       ├── verify.ts    →   structural verify + repair
+│   │       ├── state.ts     →   state machine + open loops
+│   │       ├── persist.ts   →   apply compaction
+│   │       └── metrics.ts   →   success / failure metrics
+│   ├── domain/               # pure semantics (no I/O)
+│   │   ├── summary-schema.ts
+│   │   └── summary-parse.ts
+│   ├── phases/               # algorithms
+│   │   ├── explore.ts
+│   │   ├── synthesize.ts
+│   │   └── verify.ts
+│   ├── infra/                # external-world interaction
+│   │   ├── fs.ts                # atomic writes, advisory locks
+│   │   ├── paths.ts             # canonical paths
+│   │   ├── git.ts               # git-root discovery (cached)
+│   │   ├── clock.ts             # injectable clock
+│   │   ├── llm-client.ts        # LLM client seam
+│   │   ├── llm-retry.ts         # 429/5xx backoff
+│   │   └── services.ts          # per-run services container
+│   ├── ui/                   # TUI overlays + dashboard
+│   │   ├── overlays.ts
+│   │   └── dashboard-format.ts
+│   └── utils/                # 13 focused utility modules
+├── test/                     # 280+ tests across 28 files
 ├── docs/
 ├── dist/
 └── package.json
 ```
 
+See `ARCHITECTURE.md` for the full responsibility breakdown of each layer.
+
 ---
 
 ## Development
@@ -330,7 +378,7 @@ bun run build
 bun run typecheck
 ```
 
-Build output is published from `dist/`.
+Build output is published from `dist/`. Pull requests are expected to pass the same verification in GitHub Actions before merge.
 
 ---
 
@@ -339,6 +387,9 @@ Build output is published from `dist/`.
 - [`CHANGELOG.md`](./CHANGELOG.md) — release history
 - [`ARCHITECTURE.md`](./ARCHITECTURE.md) — system design and execution model
 - [`CONTRIBUTING.md`](./CONTRIBUTING.md) — contributor workflow and expectations
+- [`SECURITY.md`](./SECURITY.md) — vulnerability reporting and data-handling notes
+- [`SUPPORT.md`](./SUPPORT.md) — where to ask for help
+- [`docs/RELEASE.md`](./docs/RELEASE.md) — release checklist
 - [`ROADMAP.md`](./ROADMAP.md) — current priorities
 - [`DEVPLAN.md`](./DEVPLAN.md) — archived implementation plan
 

package/SECURITY.md

@@ -0,0 +1,28 @@
+# Security Policy
+
+## Supported versions
+
+Security fixes target the latest published version of `pi-smart-compact`.
+
+## Reporting a vulnerability
+
+Please do **not** open a public issue for vulnerabilities, leaked secrets, or private-session data exposure.
+
+Report privately through GitHub Security Advisories:
+
+<https://github.com/alpertarhan/pi-smart-compact/security/advisories/new>
+
+If advisories are unavailable, contact the maintainer listed in `package.json`.
+
+## Data handling notes
+
+`pi-smart-compact` processes Pi session content to produce compaction summaries. Depending on your session, this may include repository paths, command output, tool results, and user-provided context.
+
+Operational guidance:
+
+- Do not paste secrets into sessions you plan to compact.
+- Redact private logs before attaching them to issues.
+- Treat generated compaction summaries as potentially sensitive project context.
+- Review provider/model configuration before enabling auto-triggered compaction.
+
+Runtime artifacts are written under `~/.pi/agent/`; see `README.md` for the current list.

package/SUPPORT.md

@@ -0,0 +1,17 @@
+# Support
+
+For usage questions or bug reports specific to `pi-smart-compact`, open an issue in this repository:
+
+<https://github.com/alpertarhan/pi-smart-compact/issues>
+
+For Pi Coding Agent core behavior that reproduces without this extension, use the upstream Pi repository:
+
+<https://github.com/earendil-works/pi>
+
+When asking for help, include:
+
+- `pi-smart-compact` version
+- Pi Coding Agent version
+- the command or integration surface used (`/smart-compact`, `smart_compact`, or auto-trigger)
+- relevant non-secret `smartCompact` configuration
+- redacted error output or logs

package/dist/app/explore-wrap.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Thin re-export shim that lets `app/steps/synthesize.ts` reach the
+ * exploration phase without importing through a deep path. Keeping the
+ * indirection here means callers don't need to know whether the
+ * implementation lives under `phases/` or some future `app/explore`.
+ */
+export { exploreConversation, shouldExplore } from "../phases/explore.ts";
+//# sourceMappingURL=explore-wrap.d.ts.map

package/dist/app/explore-wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explore-wrap.d.ts","sourceRoot":"","sources":["../../src/app/explore-wrap.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/app/run-context.d.ts

@@ -0,0 +1,196 @@
+/**
+ * Per-run pipeline context as a typed state machine.
+ *
+ * The previous incarnation of `RunContext` was a single fat interface where
+ * every later-phase field was marked optional. That kept the type system
+ * quiet but had two real costs:
+ *
+ *   1. **Cast pollution.** `makeContext` initialized half the fields with
+ *      `undefined as unknown as RunContext["config"]` because the type
+ *      claimed they would be set. Every step then re-read them with `!`,
+ *      silently relying on call ordering. A future refactor that moved one
+ *      step would compile cleanly and crash at runtime.
+ *
+ *   2. **No phase guarantees.** `applyCompaction` reading `rc.details!` had
+ *      no compile-time proof that `buildState` had actually run.
+ *
+ * We replace that with a stage chain. Each step accepts the previous stage
+ * type and returns the next, so:
+ *
+ *   - `prepareRun(base)` → `PreparedRc`
+ *   - `resolveCompactionWindow(prepared)` → `WindowedRc | null`
+ *   - …
+ *   - `buildState(verified)` → `StatedRc`
+ *   - `applyCompaction(stated)` (cannot be invoked before `buildState`)
+ *
+ * Implementation note: mutation is preserved. Each step mutates the input
+ * object and returns it cast to the next stage. The `_brand` field on each
+ * extension is the only thing that distinguishes stages structurally — it is
+ * never read at runtime. This lets us avoid copying ~30 fields per step
+ * while still getting compile-time stage tracking.
+ *
+ * The final `RunContext = StatedRc` alias keeps backwards-compatible imports
+ * working for the `applyCompaction` / metrics paths that ran post-`buildState`.
+ */
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { Model, Api } from "@earendil-works/pi-ai";
+import type { CompressionProfile, PendingCompaction, LlmMessage, StructuredExtraction, ExplorationReport, ChunkSummary, SessionMessageEntry, PipelinePhaseTiming, CompactConfig, ProfileConfig, ProviderCapabilities, SmartCompactDetails, CompactionState, OpenLoop } from "../types.ts";
+import type { PruningResult } from "../utils/pruning.ts";
+import type { CompactionTier } from "../utils/helpers.ts";
+import type { SmartCompactServices } from "../infra/services.ts";
+export type Notifier = (msg: string, type?: "info" | "success" | "warning" | "error") => void;
+export interface CancellationToken {
+    controller: AbortController;
+    signal: AbortSignal;
+    /** Set when the auto-trigger hard timeout fires. */
+    timedOut: boolean;
+    /** Active setTimeout handle. Cleared in finally so we never leak timers. */
+    timeoutId: ReturnType<typeof setTimeout> | null;
+}
+export interface PendingRef {
+    value: PendingCompaction | null;
+    createdAt: number;
+}
+export interface RunFlags {
+    verbose: boolean;
+    dryRun: boolean;
+    autoTriggered: boolean;
+    skipCompact: boolean;
+    force: boolean;
+}
+export interface ResolvedAuth {
+    apiKey: string;
+    headers?: Record<string, string>;
+}
+export interface RcBase {
+    ctx: ExtensionCommandContext;
+    notify: Notifier;
+    vlog: (msg: string) => void;
+    services: SmartCompactServices;
+    cancellation: CancellationToken;
+    pendingRef: PendingRef;
+    isRunning: {
+        value: boolean;
+    };
+    flags: RunFlags;
+    userNote?: string;
+    timeoutMs: number;
+    phaseTimings: PipelinePhaseTiming[];
+    pipelineStart: number;
+    phaseStart: number;
+    summaryModel: Model<Api>;
+    segModel: Model<Api>;
+    modelLabel: string;
+    profile: CompressionProfile;
+}
+export interface PreparedExt {
+    /** Discriminator field; never read at runtime. */
+    readonly _prepared: true;
+    config: CompactConfig;
+    profileCfg: ProfileConfig;
+    providerCaps: ProviderCapabilities;
+    summaryAuth: ResolvedAuth;
+    segAuth: ResolvedAuth;
+}
+export type PreparedRc = RcBase & PreparedExt;
+export interface WindowedExt extends PreparedExt {
+    readonly _windowed: true;
+    sessionId: string;
+    branch: unknown[];
+    msgs: SessionMessageEntry[];
+    totalTokens: number;
+    contextPercent: number;
+    toolPercent: number;
+    keepFrom: number;
+    toCompact: SessionMessageEntry[];
+    firstKeptId: string;
+    accTokens: number;
+}
+export type WindowedRc = RcBase & WindowedExt;
+export interface RecoveredExt extends WindowedExt {
+    readonly _recovered: true;
+    llmMessages: LlmMessage[];
+}
+export type RecoveredRc = RcBase & RecoveredExt;
+export type ActiveTier = Exclude<CompactionTier, "none">;
+export interface TieredExt extends RecoveredExt {
+    readonly _tiered: true;
+    tier: ActiveTier;
+}
+export type TieredRc = RcBase & TieredExt;
+export interface ExtractedExt extends TieredExt {
+    readonly _extracted: true;
+    pruning: PruningResult;
+    currentEntryIds: string[];
+    currentKeptEntryIds: string[];
+    /**
+     * ToolCallIndex over the **pruned** message list. Built once in
+     * `extractWithCache` and reused by extraction. Keyed against pruned offsets,
+     * not the unpruned message list — do not confuse with `pruning.toolCallIndex`.
+     */
+    prunedToolCallIndex: import("../utils/extraction.ts").ToolCallIndex;
+    extraction: StructuredExtraction;
+    extractionCacheMissReason?: string;
+    prevContext: string;
+    projectCtx: string;
+    projectId: string;
+    /**
+     * Serialized pruned conversation text. Computed once in `extractWithCache`
+     * and reused by `summarizeConversation` so we don't `serializeConversation`
+     * the same 5000-message array twice on the hot path. `convTokens` is the
+     * cached `estimateTokens(convText)` value.
+     */
+    convText: string;
+    convTokens: number;
+    backupPath: string | null;
+}
+export type ExtractedRc = RcBase & ExtractedExt;
+export interface SynthesizedExt extends ExtractedExt {
+    readonly _synthesized: true;
+    finalSummary: string;
+    method: "eesv" | "single-pass" | "heuristic";
+    methodForMetrics: string;
+    llmCalls: number;
+    summaries: ChunkSummary[];
+    explorationReport: ExplorationReport | null;
+    explorationRounds: number;
+    chunkCount: number;
+}
+export type SynthesizedRc = RcBase & SynthesizedExt;
+export interface VerifiedExt extends SynthesizedExt {
+    readonly _verified: true;
+    verificationScore: number;
+    verificationGaps: string[];
+    verified: boolean;
+}
+export type VerifiedRc = RcBase & VerifiedExt;
+export interface StatedExt extends VerifiedExt {
+    readonly _stated: true;
+    openLoops: OpenLoop[];
+    compactionState: CompactionState;
+    details: SmartCompactDetails;
+    tokensSaved: number;
+}
+export type StatedRc = RcBase & StatedExt;
+/**
+ * Backwards-compatible alias.
+ *
+ * Modules that don't care about pipeline ordering (e.g. `applyCompaction` in
+ * `persist.ts`, which only runs after `buildState`) can still take a
+ * `RunContext`. New code should prefer the explicit stage types.
+ */
+export type RunContext = StatedRc;
+/** Record an already-measured phase and advance the phase boundary. */
+export declare function markMeasuredPhase(rc: RcBase, phase: PipelinePhaseTiming["phase"], startMs: number, endMs?: number): void;
+/** Mark the boundary between two pipeline phases for the metrics log. */
+export declare function markPhase(rc: RcBase, phase: PipelinePhaseTiming["phase"]): void;
+/**
+ * In-place stage advancement.
+ *
+ * Each step mutates its input then casts to the next stage. The cast is the
+ * only place we widen the type — the runtime object never copies. Centralizing
+ * it here means tests can spot the transition easily and IDE jumps to the
+ * factory rather than scattering `as` keywords through every step.
+ */
+export declare function advance<TIn extends RcBase, TOut extends TIn>(rc: TIn, _stage: keyof TOut): TOut;
+//# sourceMappingURL=run-context.d.ts.map

package/dist/app/run-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-context.d.ts","sourceRoot":"","sources":["../../src/app/run-context.ts"],"names":[],"mappings":"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"}

package/dist/app/run-smart-compact.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Orchestrator: thread the typed run context through every stage in order.
+ *
+ * Each step is now a typed transition (see `app/run-context.ts`): the input
+ * is the previous stage type, the output is the next. Skipping a step or
+ * reordering them is a TypeScript error rather than a runtime crash.
+ *
+ * Responsibilities owned by this file:
+ *
+ *  - The try/finally that maintains `isRunning`.
+ *  - The timeout `setTimeout` handle (set in prepare, cleared in finally).
+ *  - The decision to bail out without side effects when the auto-trigger
+ *    hard-timeout fires.
+ *  - The post-success result screen + apply-compaction trigger.
+ *
+ * The function intentionally has no clever control flow: every cross-step
+ * dependency is data on the stage type, every conditional is a boolean flag.
+ */
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import type { Model, Api } from "@earendil-works/pi-ai";
+import type { CompressionProfile } from "../types.ts";
+import type { PendingRef } from "./run-context.ts";
+/**
+ * Co-operative cancellation surface that the extension entry point can hand
+ * back to itself to drive an *external* hard timeout.
+ *
+ * Setting `timedOut = true` and calling `abort()` from outside the pipeline
+ * is the single source of truth for "give up on smart compaction and let Pi
+ * run its native compact". The orchestrator notices the flag and:
+ *
+ *   - skips all remaining side effects (state persist, ctx.compact apply),
+ *   - clears `pendingRef` in finally,
+ *   - records a timeout metric instead of a success metric.
+ */
+export interface ExternalCancellation {
+    timedOut: boolean;
+    abort: () => void;
+}
+/** Options for runSmartCompact — avoids 10-parameter positional calls. */
+export interface SmartCompactOptions {
+    ctx: ExtensionCommandContext;
+    summaryModel: Model<Api>;
+    segModel: Model<Api>;
+    profile: CompressionProfile;
+    verbose?: boolean;
+    dryRun?: boolean;
+    pendingRef: PendingRef;
+    isRunning: {
+        value: boolean;
+    };
+    autoTriggered?: boolean;
+    userNote?: string;
+    skipCompact?: boolean;
+    /** Explicit user command may bypass adaptive context-pressure tier gate. */
+    force?: boolean;
+    /** Optional hard budget for native auto-trigger only. Manual/tool runs do not time out by default. */
+    timeoutMs?: number;
+    /**
+     * If provided, populated with the run's cancellation handle before any
+     * async work begins. The session_before_compact hook uses this to enforce
+     * its own hard timeout in addition to the in-pipeline one (some providers
+     * ignore AbortSignal entirely).
+     */
+    cancellationOut?: {
+        value: ExternalCancellation | null;
+    };
+}
+export declare function runSmartCompact(opts: SmartCompactOptions): Promise<void>;
+//# sourceMappingURL=run-smart-compact.d.ts.map

package/dist/app/run-smart-compact.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-smart-compact.d.ts","sourceRoot":"","sources":["../../src/app/run-smart-compact.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAC/E,OAAO,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAItD,OAAO,KAAK,EACQ,UAAU,EAC7B,MAAM,kBAAkB,CAAC;AAc1B;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,0EAA0E;AAC1E,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,uBAAuB,CAAC;IAC7B,YAAY,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACzB,QAAQ,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;IACrB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4EAA4E;IAC5E,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,sGAAsG;IACtG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,eAAe,CAAC,EAAE;QAAE,KAAK,EAAE,oBAAoB,GAAG,IAAI,CAAA;KAAE,CAAC;CAC1D;AAwCD,wBAAsB,eAAe,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsK9E"}

package/dist/app/steps/extract.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Step 5: deterministic extraction with incremental cache.
+ *
+ * Stage: `TieredRc` → `ExtractedRc`.
+ *
+ * Pruning + extraction are paired here because:
+ *
+ *  1. The extraction indexes (topic ranges, error message offsets, decisions)
+ *     live in the pruned message domain. Caching the extraction is only safe
+ *     when the pruned *prefix* of the next run matches the previous one.
+ *  2. Without the prefix guard, an incremental delta could be merged on top
+ *     of a base whose pruning result drifted (e.g. a new duplicate read
+ *     evicted an old cached read), producing index offsets that point at the
+ *     wrong messages.
+ *
+ * `extractionCacheMissReason` captures *why* the cache could not be used so
+ * the metrics dashboard can show the hit-rate alongside the failure mode.
+ */
+import type { TieredRc, ExtractedRc } from "../run-context.ts";
+export declare function extractWithCache(rc: TieredRc): ExtractedRc;
+//# sourceMappingURL=extract.d.ts.map

package/dist/app/steps/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../../src/app/steps/extract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAiB/D,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,QAAQ,GAAG,WAAW,CA0J1D"}

package/dist/app/steps/metrics.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Step 10: record metrics for the run.
+ *
+ * Two paths:
+ *
+ *   - `recordSuccessMetrics(rc: StatedRc, status)` runs after a full pipeline
+ *     completion. Every field on the metric record is statically known.
+ *
+ *   - `recordFailureMetrics(rc, err, fields)` runs from the catch block in
+ *     the orchestrator and may execute before the pipeline ever populated
+ *     stage data. The `fields` bag carries whatever the orchestrator managed
+ *     to collect before the throw; missing values fall through to undefined.
+ *
+ * Metrics writes are intentionally append-only and idempotent — they target
+ * the JSONL log and never throw past the cache.ts boundary.
+ */
+import type { RcBase, StatedRc } from "../run-context.ts";
+export declare function recordSuccessMetrics(rc: StatedRc, status: "success" | "dry-run"): void;
+/**
+ * Partial summary that the orchestrator accumulates as steps complete. The
+ * failure path uses whatever is present at the moment of the throw.
+ */
+export interface FailureSummaryFields {
+    sessionId?: string;
+    tier?: string;
+    contextPercent?: number;
+    toolPercent?: number;
+    totalTokens?: number;
+    methodForMetrics?: string;
+    profile: string;
+}
+export declare function recordFailureMetrics(rc: RcBase | StatedRc, err: unknown, fields: FailureSummaryFields): void;
+//# sourceMappingURL=metrics.d.ts.map

package/dist/app/steps/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../../../src/app/steps/metrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAU1D,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,IAAI,CAwCtF;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,MAAM,GAAG,QAAQ,EACrB,GAAG,EAAE,OAAO,EACZ,MAAM,EAAE,oBAAoB,GAC3B,IAAI,CAgBN"}

package/dist/app/steps/persist.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Step 9: apply compaction and persist durable state.
+ *
+ * Lifecycle invariants:
+ *
+ *  - `pendingRef` is set immediately so `session_before_compact` can consume
+ *    it. We MUST clear it on failure (P1 #4 in the audit) — the previous
+ *    implementation left a stale summary alive for up to 5 minutes after a
+ *    `ctx.compact()` error.
+ *
+ *  - Project fingerprint and compaction state are persisted **after** the
+ *    native compact's `onComplete` confirms application. If we wrote state
+ *    eagerly and the compact failed, the next run would believe a successful
+ *    compaction had happened — corrupting damage detection and the
+ *    cross-compaction delta. This addresses P1 #5 in the audit.
+ *
+ *  - For manual / tool runs we run damage detection against the existing
+ *    branch's previous compaction as a best-effort signal.
+ */
+import type { RunContext } from "../run-context.ts";
+import type { PendingCompaction } from "../../types.ts";
+/**
+ * Persist project fingerprint + compaction state. Pulled into its own function
+ * so the post-compact onComplete callback in the orchestrator can invoke it
+ * exactly once after the native compact succeeds.
+ *
+ * `RunContext` is the final `StatedRc` stage, so both `extraction` and
+ * `compactionState` are statically known to be present here — no defensive
+ * `!` or runtime guards needed.
+ */
+export declare function persistDurableState(rc: RunContext): void;
+/** Run post-compaction damage detection. Best-effort — never throws. */
+export declare function runDamageDetection(rc: RunContext): void;
+/**
+ * Stash the prepared compaction in pendingRef and trigger the native compact
+ * if appropriate. Returns the pending summary so callers can decide whether
+ * the run should keep running side effects (it does until the timeout/cleanup
+ * step decides otherwise).
+ */
+export declare function stagePendingCompaction(rc: RunContext): PendingCompaction;
+/**
+ * Trigger Pi's native compact in non-auto/non-tool runs. The state-persist
+ * callback fires on success; failure clears the pendingRef so the next
+ * compact event cannot grab a stale summary (audit P1 #4).
+ */
+export declare function applyCompaction(rc: RunContext): void;
+//# sourceMappingURL=persist.d.ts.map

package/dist/app/steps/persist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persist.d.ts","sourceRoot":"","sources":["../../../src/app/steps/persist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAc,MAAM,gBAAgB,CAAC;AASpE;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI,CAGxD;AAED,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI,CA6BvD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,UAAU,GAAG,iBAAiB,CAcxE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,UAAU,GAAG,IAAI,CAoBpD"}

package/dist/app/steps/prepare.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Step 1: prepare a run — load config, resolve auth, wire cancellation.
+ *
+ * Stage transition: `RcBase` → `PreparedRc`.
+ *
+ * Returns `null` when authentication fails so the orchestrator can bail
+ * before any side effects. The null return is the explicit guard that lets
+ * TypeScript prove later steps never see a half-initialised context.
+ */
+import type { RcBase, PreparedRc } from "../run-context.ts";
+export declare function prepareRun(rc: RcBase): Promise<PreparedRc | null>;
+//# sourceMappingURL=prepare.d.ts.map

package/dist/app/steps/prepare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare.d.ts","sourceRoot":"","sources":["../../../src/app/steps/prepare.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAO5D,wBAAsB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA8CvE"}

package/dist/app/steps/recover.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Step 3: recover untruncated messages from the session log when needed.
+ *
+ * Stage: `WindowedRc` → `RecoveredRc`.
+ *
+ * pi-toolkit's context hook truncates tool results in-place on the branch.
+ * Where possible we read the original messages from the session log instead.
+ * If the log is unavailable we fall back to the (possibly truncated) branch
+ * messages — the summary still beats no summary at all.
+ */
+import type { WindowedRc, RecoveredRc } from "../run-context.ts";
+export declare function recoverSessionLog(rc: WindowedRc): RecoveredRc;
+//# sourceMappingURL=recover.d.ts.map

package/dist/app/steps/recover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recover.d.ts","sourceRoot":"","sources":["../../../src/app/steps/recover.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAMjE,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,UAAU,GAAG,WAAW,CAgB7D"}