@oh-my-pi/pi-coding-agent 17.1.7 → 17.1.8

package/dist/types/advisor/advise-tool.d.ts

@@ -36,13 +36,6 @@ export declare function formatAdvisorBatchContent(notes: readonly AdvisorNote[])
  * and `blocker` interrupt; a plain `nit` queues.
  */
 export declare function isInterruptingSeverity(severity: AdvisorSeverity | undefined): boolean;
-/**
- * Append a staleness caveat to an advisor note when newer primary turns arrived
- * after the reviewed transcript window (i.e. `hasFreshBacklog` is true on the
- * advisor runtime at delivery time). Pure function — no session coupling — so it
- * can be unit-tested in isolation and called from `AgentSession#routeAdvice`.
- */
-export declare function annotateForStaleness(note: string, hasFreshBacklog: boolean): string;
 /** How an advisor note is routed to the primary. */
 export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
 /** Half-open turn-count fence for the post-interrupt cooldown. */

package/dist/types/advisor/runtime.d.ts

@@ -95,15 +95,6 @@ export declare class AdvisorRuntime {
     get failureNotified(): boolean;
     /** True after the runtime hard-stopped on repeated or permanent failures. */
     get halted(): boolean;
-    /**
-     * True when `#pending` is non-empty while the drain loop is busy — i.e., newer
-     * primary turns arrived after the current batch's transcript window was fixed
-     * but before the advisor model finished processing it. The delivery path uses
-     * this to annotate advice that was generated without seeing those newer turns.
-     * Can be true during `agent.prompt()`, a `maintainContext` await, or a retry
-     * sleep — any time `#drain` is busy and a concurrent `onTurnEnd` pushed.
-     */
-    get hasFreshBacklog(): boolean;
     /**
      * Called after each primary turn ends. Renders the incremental delta and
      * queues it for the advisor model.

package/dist/types/async/job-manager.d.ts

@@ -129,6 +129,17 @@ export declare class AsyncJobManager {
      * (used by `dispose()` to nuke the manager's state).
      */
     cancelAll(filter?: AsyncJobFilter): void;
+    /**
+     * Immediately evict completed and failed jobs matching the filter instead of
+     * waiting for retention expiry, dropping every queued delivery so a prior
+     * session's result can never be injected into a later transcript. Returns the
+     * number of jobs evicted.
+     *
+     * A delivery whose sink call is already in flight (or drained onto a caller's
+     * yield queue) is guarded by the owner's delivery generation, not the per-id
+     * suppression marker — that marker is cleared when the id is reused.
+     */
+    evictCompletedJobs(filter?: AsyncJobFilter): number;
     waitForAll(): Promise<void>;
     /**
      * Route completions for jobs owned by `ownerId` to `sink`. Sessions register

package/dist/types/cleanse/agent.d.ts

@@ -0,0 +1,19 @@
+import type { CleanseAgentOutcome, CleanseAssignment, CleanseDiagnosticReport, CleanseLoopResult } from "./types.js";
+/** Hooks used by the standalone command to render subagent lifecycle progress. */
+export interface CleanseAgentHooks {
+    onStart?(name: string, assignment: CleanseAssignment): void;
+    onFinish?(outcome: CleanseAgentOutcome, assignment: CleanseAssignment): void;
+}
+/** Persisted parent session that dispatches file-disjoint cleanse workers. */
+export interface CleanseAgentRuntime {
+    readonly model: string;
+    readonly sessionFile: string;
+    dispatch(assignments: CleanseAssignment[], wave: number, report: CleanseDiagnosticReport, signal?: AbortSignal): Promise<CleanseAgentOutcome[]>;
+    close(result?: CleanseLoopResult): Promise<void>;
+}
+/** Resolve the requested model and create a fresh persisted cleanse session. */
+export declare function createCleanseAgentRuntime(options: {
+    cwd?: string;
+    model: string;
+    hooks?: CleanseAgentHooks;
+}): Promise<CleanseAgentRuntime>;

package/dist/types/cleanse/balance.d.ts

@@ -0,0 +1,7 @@
+import type { CleanseAssignment, CleanseDiagnostic, CleanseFileIssues } from "./types.js";
+/** Estimate repair burden from severity and available location/fix evidence. */
+export declare function diagnosticWeight(diagnostic: CleanseDiagnostic): number;
+/** Group diagnostics by file while keeping project-level failures together. */
+export declare function groupDiagnosticsByFile(diagnostics: readonly CleanseDiagnostic[]): CleanseFileIssues[];
+/** Balance whole-file workloads with longest-processing-time bin packing. */
+export declare function balanceDiagnostics(diagnostics: readonly CleanseDiagnostic[], maxAgents: number): CleanseAssignment[];

package/dist/types/cleanse/checkers.d.ts

@@ -0,0 +1,13 @@
+import type { CleanseDiagnosticReport, SkippedCleanseCheck } from "./types.js";
+/** Optional checker families enabled for a cleanse run. */
+export interface CleanseDiagnosticSuiteOptions {
+    includeTests?: boolean;
+}
+/** Re-runnable checker set discovered from one project snapshot. */
+export interface CleanseDiagnosticSuite {
+    readonly checkCount: number;
+    readonly skipped: readonly SkippedCleanseCheck[];
+    run(signal?: AbortSignal): Promise<CleanseDiagnosticReport>;
+}
+/** Discover configured language checkers without installing missing tools. */
+export declare function discoverCleanseDiagnosticSuite(projectCwd: string, options?: CleanseDiagnosticSuiteOptions): Promise<CleanseDiagnosticSuite>;

package/dist/types/cleanse/index.d.ts

@@ -0,0 +1,16 @@
+import type { CleanseDiagnosticReport } from "./types.js";
+/** User-facing options for `omp cleanse`. */
+export interface CleanseCommandOptions {
+    maxAgents?: number;
+    model?: string;
+    includeTests?: boolean;
+}
+/** Observable completion state returned to the CLI adapter. */
+export interface CleanseCommandResult {
+    exitCode: number;
+    status: "clean" | "unresolved" | "unsupported" | "cancelled";
+    report: CleanseDiagnosticReport;
+    sessionFile?: string;
+}
+/** Detect project diagnostics, dispatch one bounded repair batch, and verify it. */
+export declare function runCleanseCommand(options?: CleanseCommandOptions): Promise<CleanseCommandResult>;

package/dist/types/cleanse/loop.d.ts

@@ -0,0 +1,16 @@
+import type { CleanseAgentOutcome, CleanseAssignment, CleanseDiagnosticReport, CleanseLoopResult } from "./types.js";
+/** Runtime seams for one bounded diagnose, dispatch, and verify pass. */
+export interface CleanseLoopDependencies {
+    collect(signal?: AbortSignal): Promise<CleanseDiagnosticReport>;
+    dispatch(assignments: CleanseAssignment[], wave: number, report: CleanseDiagnosticReport, signal?: AbortSignal): Promise<CleanseAgentOutcome[]>;
+    onWave?(wave: number, assignments: readonly CleanseAssignment[]): void;
+    onReport?(wave: number, report: CleanseDiagnosticReport): void;
+}
+/** Inputs controlling one complete cleanse loop. */
+export interface CleanseLoopOptions {
+    maxAgents: number;
+    initialReport: CleanseDiagnosticReport;
+    signal?: AbortSignal;
+}
+/** Dispatch at most `maxAgents` workers once, then verify their combined edits. */
+export declare function runCleanseLoop(options: CleanseLoopOptions, dependencies: CleanseLoopDependencies): Promise<CleanseLoopResult>;

package/dist/types/cleanse/parsers.d.ts

@@ -0,0 +1,13 @@
+import type { CleanseDiagnostic } from "./types.js";
+/** Machine and fallback output formats understood by cleanse. */
+export type CleanseParserKind = "rust" | "rust-test" | "go" | "go-test" | "ruff" | "pyright" | "eslint" | "biome" | "rubocop" | "phpstan" | "psalm" | "swiftlint" | "dart" | "credo" | "shellcheck" | "hlint" | "terraform" | "tflint" | "generic";
+/** Captured checker process output passed to a format parser. */
+export interface CleanseParserInput {
+    checker: string;
+    projectCwd: string;
+    checkerCwd: string;
+    stdout: string;
+    stderr: string;
+}
+/** Parse one checker invocation into normalized, project-relative diagnostics. */
+export declare function parseCleanseDiagnostics(kind: CleanseParserKind, input: CleanseParserInput): CleanseDiagnostic[];

package/dist/types/cleanse/progress.d.ts

@@ -0,0 +1,14 @@
+/** Minimal output contract used by the interactive cleanse progress reporter. */
+export interface CleanseProgressOutput {
+    isTTY?: boolean;
+    write(text: string): boolean;
+}
+/** Renders completed repair workers on one transient terminal line. */
+export interface CleanseProgressReporter {
+    readonly interactive: boolean;
+    start(total: number): void;
+    complete(): void;
+    finish(): void;
+}
+/** Create the TTY-only worker completion reporter used by `omp cleanse`. */
+export declare function createCleanseProgressReporter(output?: CleanseProgressOutput): CleanseProgressReporter;

package/dist/types/cleanse/types.d.ts

@@ -0,0 +1,64 @@
+/** Severity normalized across checker-specific output formats. */
+export type CleanseSeverity = "error" | "warning" | "info";
+/** One actionable problem reported by a project checker. */
+export interface CleanseDiagnostic {
+    checker: string;
+    file?: string;
+    line?: number;
+    column?: number;
+    endLine?: number;
+    endColumn?: number;
+    code?: string;
+    severity: CleanseSeverity;
+    message: string;
+    suggestion?: string;
+}
+/** Result metadata for one checker invocation. */
+export interface CleanseCheckResult {
+    id: string;
+    label: string;
+    language: string;
+    cwd: string;
+    command: string;
+    exitCode: number | null;
+    diagnostics: CleanseDiagnostic[];
+}
+/** Checker discovery result omitted because its required executable was unavailable. */
+export interface SkippedCleanseCheck {
+    label: string;
+    language: string;
+    reason: string;
+}
+/** Aggregate diagnostics from every checker selected for a project. */
+export interface CleanseDiagnosticReport {
+    checks: CleanseCheckResult[];
+    diagnostics: CleanseDiagnostic[];
+    skipped: SkippedCleanseCheck[];
+}
+/** All diagnostics attached to one file, which scheduling never splits across agents. */
+export interface CleanseFileIssues {
+    file?: string;
+    diagnostics: CleanseDiagnostic[];
+    weight: number;
+}
+/** One weighted, file-disjoint workload handed to a subagent. */
+export interface CleanseAssignment {
+    index: number;
+    groups: CleanseFileIssues[];
+    weight: number;
+}
+/** Settled result from one cleanse subagent. */
+export interface CleanseAgentOutcome {
+    name: string;
+    success: boolean;
+    output: string;
+    error?: string;
+    resolvedModel?: string;
+}
+/** Final state after one bounded repair wave and verification pass. */
+export interface CleanseLoopResult {
+    status: "clean" | "stalled" | "cancelled";
+    waves: number;
+    report: CleanseDiagnosticReport;
+    outcomes: CleanseAgentOutcome[];
+}

package/dist/types/commands/cleanse.d.ts

@@ -0,0 +1,23 @@
+import { Command } from "@oh-my-pi/pi-utils/cli";
+export default class Cleanse extends Command {
+    static description: string;
+    static flags: {
+        agents: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"integer"> & {
+            char: string;
+            description: string;
+            default: number;
+        };
+        model: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
+            char: string;
+            description: string;
+            default: string;
+        };
+        tests: import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
+            char: string;
+            description: string;
+            default: boolean;
+        };
+    };
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/types/export/html/index.d.ts

@@ -3,6 +3,8 @@ import type { SessionEntry, SessionHeader } from "../../session/session-entries.
 import { SessionManager } from "../../session/session-manager.js";
 import type { ExportThemeNames } from "./args.js";
 export { type ExportThemeNames, parseExportArgs } from "./args.js";
+/** Resolve a Bun file-loader value without parsing Windows drive letters as URL schemes. */
+export declare function resolveBundledHtmlAssetPath(assetPath: string, moduleDir?: string): string;
 /** Compose the standalone export template: minified CSS, tool renderers, and viewer JS inlined. */
 export declare function getTemplate(): string;
 export interface ExportOptions {

package/dist/types/extensibility/legacy-pi-ai-shim.d.ts

@@ -19,7 +19,7 @@
  * `types.ts` via the `export *` below — pi-ai still exports both as types,
  * only the runtime `Type` builder and `StringEnum()` helper were removed.
  */
-import type { Api, Model } from "@oh-my-pi/pi-ai";
+import type { Api, AssistantMessage, Model } from "@oh-my-pi/pi-ai";
 import type { Effort } from "@oh-my-pi/pi-catalog/effort";
 import { calculateCost, getBundledModel, getBundledModels, getBundledProviders, modelsAreEqual } from "@oh-my-pi/pi-catalog/models";
 import { type TSchema, Type } from "./typebox.js";
@@ -32,6 +32,15 @@ export interface StringEnumOptions<T extends string> {
 export declare function StringEnum<T extends string | number>(values: readonly T[] | Record<string, T>, options?: StringEnumOptions<any>): TSchema;
 /** Clamp a historical Pi thinking level against OMP's model metadata. */
 export declare function clampThinkingLevel<TApi extends Api>(model: Model<TApi>, level: Effort | "off"): Effort | "off";
+/**
+ * Compatibility implementation of historical pi-ai's `isRetryableAssistantError`.
+ *
+ * Classifies whether a failed assistant message looks like a transient provider
+ * or transport error so legacy extensions can decide if the last assistant turn
+ * should be restarted. Account/quota limits are treated as non-retryable. This
+ * does not implement any retry policy; callers own budget, backoff, and reporting.
+ */
+export declare function isRetryableAssistantError(message: AssistantMessage): boolean;
 export * from "@oh-my-pi/pi-ai";
 /**
  * Compatibility re-exports for catalog symbols that pi-ai historically exposed
@@ -45,3 +54,20 @@ export * from "@oh-my-pi/pi-ai";
 export { calculateCost, getBundledModel, getBundledModels, getBundledProviders, modelsAreEqual, Type };
 export declare const getModel: typeof getBundledModel;
 export declare const getModels: typeof getBundledModels;
+/**
+ * Compatibility re-exports for runtime helpers that upstream
+ * `@earendil-works/pi-ai` exposed from its package root but omp's
+ * `@oh-my-pi/pi-ai` barrel no longer forwards. Each symbol still exists in the
+ * host graph — only its root re-export was dropped — so bridging it here keeps
+ * legacy extensions importing it from the pi-ai root resolving through Bun's
+ * static named-export check (e.g. `omp plugin install pi-blackhole`).
+ *
+ * This is the full set derived from an audit of the upstream root surface: the
+ * error-classification predicate `isContextOverflow` (now under
+ * `@oh-my-pi/pi-ai/error`) and the JSON-repair helpers that omp relocated to
+ * `@oh-my-pi/pi-utils`. Upstream root symbols with no omp equivalent are
+ * intentionally not shimmed — the package has diverged and there is nothing to
+ * forward.
+ */
+export { isContextOverflow } from "@oh-my-pi/pi-ai/error";
+export { parseJsonWithRepair, parseStreamingJson, repairJson } from "@oh-my-pi/pi-utils";

package/dist/types/modes/interactive-mode.d.ts

@@ -257,9 +257,10 @@ export declare class InteractiveMode implements InteractiveModeContext {
     handlePlanModeCommand(initialPrompt?: string): Promise<void>;
     /**
      * `/vibe` toggle. Entering installs the ephemeral vibe tools, strips the
-     * active toolset down to `read` plus those tools, and injects the director
-     * context. Exiting unregisters them, restores the previous toolset, and kills
-     * every worker session so workers cannot outlive the mode that directs them.
+     * active toolset down to `read`, optional parent-owned `todo`, plus those
+     * tools, and injects the director context. Exiting unregisters them, restores
+     * the previous toolset, and kills every worker session so workers cannot
+     * outlive the mode that directs them.
      */
     handleVibeModeCommand(initialPrompt?: string): Promise<void>;
     handleGoalModeCommand(rest?: string): Promise<void>;

package/dist/types/session/async-job-delivery.d.ts

@@ -14,6 +14,14 @@ export interface AsyncResultEntry {
     result: string;
     job: AsyncJob | undefined;
     durationMs: number | undefined;
+    /**
+     * Owning session's async-delivery generation at enqueue time. A session
+     * transition (`/new`, switch, handoff) bumps the generation, so an entry
+     * whose generation no longer matches belongs to a replaced transcript and
+     * is dropped at flush — even after its job id has been reused, which clears
+     * the manager's per-id suppression marker.
+     */
+    epoch: number;
 }
 type AsyncResultJobDetails = {
     jobId: string;

package/dist/types/session/model-controls.d.ts

@@ -134,9 +134,9 @@ export declare class ModelControls {
     cycleThinkingLevel(): ConfiguredThinkingLevel | undefined;
     /**
      * Classify the current user turn and set the effective thinking level for it.
-     * Bounded by a timeout + abort; on any failure (no smol model, timeout, parse
-     * error) it falls back to the provisional concrete level and continues. Never
-     * throws into the turn, and never clears `#autoThinking` (auto stays active).
+     * Bounded by a timeout + abort; on failure it preserves the last classified
+     * level, or uses the provisional concrete level before the first resolution.
+     * Never throws into the turn, and never clears `#autoThinking`.
      */
     applyAutoThinkingLevel(promptText: string, generation: number): Promise<void>;
     /**

package/dist/types/task/isolation-ownership.d.ts

@@ -0,0 +1,34 @@
+/** Marker file written into a task-isolation base dir identifying its owner. */
+export declare const ISOLATION_OWNER_FILE = ".omp-isolation-owner.json";
+/** Recorded owner of a task-isolation sandbox. */
+export interface IsolationOwner {
+    /** PID of the omp process that created and owns the sandbox. */
+    pid: number;
+    /** Task id the sandbox was materialised for. */
+    id: string;
+    /**
+     * Process-instance start-time token for {@link pid}, when the OS can report
+     * it. Distinguishes the owning process from an unrelated process that later
+     * inherits a recycled pid, so a crashed sandbox is never pinned live.
+     */
+    startToken?: string;
+}
+/**
+ * Record the current process as owner of the sandbox rooted at `baseDir`.
+ *
+ * Written before the isolation backend materialises `m` so a concurrent
+ * `omp worktree clear` never sees an owner-less sandbox mid-creation.
+ */
+export declare function writeIsolationOwner(baseDir: string, id: string): Promise<void>;
+/**
+ * Whether a live omp process still owns the sandbox at `baseDir`.
+ *
+ * A missing or malformed marker means no verifiable owner — a crashed run or a
+ * sandbox from before markers existed, both safe to reclaim. `process.kill(pid,
+ * 0)` can fail with `EPERM` even when the process is alive, so only an explicit
+ * `ESRCH` ("no such process") counts as dead; any other error is treated as
+ * alive to avoid deleting a sandbox that is actually in use. When the marker
+ * carries a {@link IsolationOwner.startToken}, a live pid whose current token no
+ * longer matches is a recycled pid — a different process — and counts as dead.
+ */
+export declare function hasLiveIsolationOwner(baseDir: string): Promise<boolean>;

package/dist/types/tools/browser/cmux/cmux-tab.d.ts

@@ -8,7 +8,6 @@ import type { CmuxSocketClient } from "./socket-client.js";
 interface ScreenshotOptions {
     selector?: string;
     fullPage?: boolean;
-    save?: string;
     silent?: boolean;
     encoding?: "base64" | "binary";
 }
@@ -101,7 +100,7 @@ export declare class CmuxTab {
     scrollIntoView(selector: string): Promise<void>;
     select(selector: string, ...values: string[]): Promise<string[]>;
     extract(format?: ReadableFormat): Promise<string>;
-    screenshot(opts?: ScreenshotOptions): Promise<ScreenshotResult>;
+    screenshot(opts?: ScreenshotOptions): Promise<string>;
     waitForUrl(pattern: string | RegExp, opts?: {
         timeout?: number;
     }): Promise<string>;

package/dist/types/tools/browser/tab-worker.d.ts

@@ -1,5 +1,5 @@
 import type { HTMLElement } from "linkedom";
-import type { ElementHandle, ImageFormat } from "puppeteer-core";
+import type { ElementHandle } from "puppeteer-core";
 import type { Transport } from "./tab-protocol.js";
 declare module "puppeteer-core" {
     interface Frame {
@@ -41,7 +41,6 @@ export declare function resolveWaitTimeout(cellTimeoutMs: number, explicit?: num
 interface ScreenshotOptions {
     selector?: string;
     fullPage?: boolean;
-    save?: string;
     silent?: boolean;
 }
 export declare function normalizeSelector(selector: string): string;
@@ -67,8 +66,6 @@ export interface InflightOp {
 }
 /** Human-readable label for a screenshot op, used in op tracking + timeout errors. */
 export declare function describeScreenshot(opts?: ScreenshotOptions): string;
-/** Map an explicit save path's extension to a puppeteer capture format (default png). */
-export declare function imageFormatForPath(filePath: string): ImageFormat;
 /** Summarize still-running helpers (oldest first) so a cell timeout names what stalled. */
 export declare function describeInflight(inflight: Map<number, InflightOp>): string;
 export declare class WorkerCore {

package/dist/types/tui/output-block.d.ts

@@ -16,6 +16,7 @@ export interface OutputBlockOptions {
     width: number;
     applyBg?: boolean;
     contentPaddingLeft?: number;
+    contentPaddingRight?: number;
     /** Override the state-derived border color. Used for muted "legacy" tool
      * frames that should not visually compete with framed-output tools. */
     borderColor?: ThemeColor;
@@ -28,12 +29,11 @@ export declare function markFramedBlockComponent<T extends Component>(component:
 export declare function isFramedBlockComponent(component: Component): boolean;
 /**
  * Inner content width that {@link renderOutputBlock} wraps its body to, for a
- * given outer `width`: both vertical borders (1 cell each) plus the left
- * content padding. Renderers that size a tail window MUST budget visual rows
- * against this, not the outer width — otherwise the block re-wraps their lines
- * into more rows than they counted and the box overflows its intended height.
+ * given outer `width`: both vertical borders plus symmetric content padding.
+ * An explicit left padding of zero keeps legacy flush blocks flush on both
+ * sides unless a right padding is provided separately.
  */
-export declare function outputBlockContentWidth(width: number, contentPaddingLeft?: number): number;
+export declare function outputBlockContentWidth(width: number, contentPaddingLeft?: number, contentPaddingRight?: number): number;
 export declare function renderOutputBlock(options: OutputBlockOptions, theme: Theme): string[];
 /**
  * Cached wrapper around `renderOutputBlock`.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "17.1.7",
+	"version": "17.1.8",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -52,17 +52,17 @@
 		"@agentclientprotocol/sdk": "1.2.1",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "17.1.7",
-		"@oh-my-pi/omp-stats": "17.1.7",
-		"@oh-my-pi/pi-agent-core": "17.1.7",
-		"@oh-my-pi/pi-ai": "17.1.7",
-		"@oh-my-pi/pi-catalog": "17.1.7",
-		"@oh-my-pi/pi-mnemopi": "17.1.7",
-		"@oh-my-pi/pi-natives": "17.1.7",
-		"@oh-my-pi/pi-tui": "17.1.7",
-		"@oh-my-pi/pi-utils": "17.1.7",
-		"@oh-my-pi/pi-wire": "17.1.7",
-		"@oh-my-pi/snapcompact": "17.1.7",
+		"@oh-my-pi/hashline": "17.1.8",
+		"@oh-my-pi/omp-stats": "17.1.8",
+		"@oh-my-pi/pi-agent-core": "17.1.8",
+		"@oh-my-pi/pi-ai": "17.1.8",
+		"@oh-my-pi/pi-catalog": "17.1.8",
+		"@oh-my-pi/pi-mnemopi": "17.1.8",
+		"@oh-my-pi/pi-natives": "17.1.8",
+		"@oh-my-pi/pi-tui": "17.1.8",
+		"@oh-my-pi/pi-utils": "17.1.8",
+		"@oh-my-pi/pi-wire": "17.1.8",
+		"@oh-my-pi/snapcompact": "17.1.8",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/api-logs": "^0.220.0",
 		"@opentelemetry/context-async-hooks": "^2.9.0",
@@ -107,6 +107,10 @@
 		"dist/cli.js",
 		"dist/CHANGELOG-*.md",
 		"dist/*.node",
+		"dist/template-*.css",
+		"dist/template-*.html",
+		"dist/template-*.js",
+		"dist/tool-views.generated-*.js",
 		"scripts",
 		"examples",
 		"README.md",

package/scripts/bundle-dist.ts

@@ -9,6 +9,7 @@ const packageDir = path.join(import.meta.dir, "..");
 const outDir = path.join(packageDir, "dist");
 const cliPath = path.join(outDir, "cli.js");
 const shebang = "#!/usr/bin/env bun\n";
+const legacyHtmlExportAssetPattern = /^(?:template-[^.]+\.(?:css|html|js)|tool-views\.generated-[^.]+\.js)$/;
 
 // Native / optional / platform-specific deps are loaded from installed files.
 // `omp-legacy-pi-modules` exists only in compiled binaries via the build plugin;
@@ -80,7 +81,8 @@ async function cleanBundleOutputs(): Promise<void> {
 					entry === "cli.js" ||
 					entry.endsWith(".node") ||
 					entry.endsWith(".js.map") ||
-					(entry.startsWith("CHANGELOG-") && entry.endsWith(".md")),
+					(entry.startsWith("CHANGELOG-") && entry.endsWith(".md")) ||
+					legacyHtmlExportAssetPattern.test(entry),
 			)
 			.map(entry => fs.rm(path.join(outDir, entry), { force: true })),
 	);

package/src/advisor/advise-tool.ts

@@ -75,17 +75,6 @@ export function isInterruptingSeverity(severity: AdvisorSeverity | undefined): b
 	return severity === "concern" || severity === "blocker";
 }
 
-/**
- * Append a staleness caveat to an advisor note when newer primary turns arrived
- * after the reviewed transcript window (i.e. `hasFreshBacklog` is true on the
- * advisor runtime at delivery time). Pure function — no session coupling — so it
- * can be unit-tested in isolation and called from `AgentSession#routeAdvice`.
- */
-export function annotateForStaleness(note: string, hasFreshBacklog: boolean): string {
-	if (!hasFreshBacklog) return note;
-	return `${note}\n\n_(Note: newer primary turns arrived after this reviewed window — verify this still applies.)_`;
-}
-
 /** How an advisor note is routed to the primary. */
 export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
 /** Half-open turn-count fence for the post-interrupt cooldown. */

package/src/advisor/runtime.ts

@@ -340,18 +340,6 @@ export class AdvisorRuntime {
 		return this.#halted;
 	}
 
-	/**
-	 * True when `#pending` is non-empty while the drain loop is busy — i.e., newer
-	 * primary turns arrived after the current batch's transcript window was fixed
-	 * but before the advisor model finished processing it. The delivery path uses
-	 * this to annotate advice that was generated without seeing those newer turns.
-	 * Can be true during `agent.prompt()`, a `maintainContext` await, or a retry
-	 * sleep — any time `#drain` is busy and a concurrent `onTurnEnd` pushed.
-	 */
-	get hasFreshBacklog(): boolean {
-		return this.#pending.length > 0;
-	}
-
 	/**
 	 * Called after each primary turn ends. Renders the incremental delta and
 	 * queues it for the advisor model.

package/src/async/job-manager.ts

@@ -417,6 +417,26 @@ export class AsyncJobManager {
 		}
 	}
 
+	/**
+	 * Immediately evict completed and failed jobs matching the filter instead of
+	 * waiting for retention expiry, dropping every queued delivery so a prior
+	 * session's result can never be injected into a later transcript. Returns the
+	 * number of jobs evicted.
+	 *
+	 * A delivery whose sink call is already in flight (or drained onto a caller's
+	 * yield queue) is guarded by the owner's delivery generation, not the per-id
+	 * suppression marker — that marker is cleared when the id is reused.
+	 */
+	evictCompletedJobs(filter?: AsyncJobFilter): number {
+		let evicted = 0;
+		for (const job of this.#filterJobs(this.#jobs.values(), filter)) {
+			if (job.status !== "completed" && job.status !== "failed") continue;
+			this.acknowledgeDeliveries([job.id]);
+			if (this.#evictJob(job.id)) evicted += 1;
+		}
+		return evicted;
+	}
+
 	async waitForAll(): Promise<void> {
 		await Promise.all(Array.from(this.#jobs.values()).map(job => job.promise));
 	}
@@ -579,12 +599,18 @@ export class AsyncJobManager {
 		return candidate;
 	}
 
+	#evictJob(jobId: string): boolean {
+		clearTimeout(this.#evictionTimers.get(jobId));
+		this.#evictionTimers.delete(jobId);
+		this.#suppressedDeliveries.delete(jobId);
+		this.#watchedJobs.delete(jobId);
+		return this.#jobs.delete(jobId);
+	}
+
 	#scheduleEviction(jobId: string): void {
 		if (this.#disposed) return;
 		if (this.#retentionMs <= 0) {
-			this.#jobs.delete(jobId);
-			this.#suppressedDeliveries.delete(jobId);
-			this.#watchedJobs.delete(jobId);
+			this.#evictJob(jobId);
 			return;
 		}
 		const existing = this.#evictionTimers.get(jobId);
@@ -592,10 +618,7 @@ export class AsyncJobManager {
 			clearTimeout(existing);
 		}
 		const timer = setTimeout(() => {
-			this.#evictionTimers.delete(jobId);
-			this.#jobs.delete(jobId);
-			this.#suppressedDeliveries.delete(jobId);
-			this.#watchedJobs.delete(jobId);
+			this.#evictJob(jobId);
 		}, this.#retentionMs);
 		timer.unref();
 		this.#evictionTimers.set(jobId, timer);