@oh-my-pi/pi-coding-agent 16.0.7 → 16.0.8

package/dist/types/utils/zip.d.ts

@@ -0,0 +1,119 @@
+/** A ZIP archive decoded to a `path → bytes` map of its file members. */
+export type Unzipped = Record<string, Uint8Array>;
+/** Read a single ZIP entry as UTF-8 text, or `undefined` when the entry is absent. */
+export declare function unzipText(entries: Unzipped, entryPath: string): string | undefined;
+/**
+ * Decode an in-memory ZIP archive into a `path → bytes` map of its file members
+ * (directory entries and `..`-escaping names are dropped). Shares the
+ * central-directory record parser with the lazy, file-backed reader.
+ */
+export declare function unzip(bytes: Uint8Array): Unzipped;
+export type ArchiveFormat = "zip" | "tar" | "tar.gz";
+/**
+ * Where to read an archive from: a filesystem path (format inferred from the
+ * extension; ZIP is read lazily via ranged central-directory access) or
+ * in-memory bytes with an explicit format.
+ */
+export type ArchiveSource = string | {
+    bytes: Uint8Array;
+    format: ArchiveFormat;
+};
+/** Content for a member when packing or extracting an archive. */
+export type ArchiveMemberContent = string | Uint8Array | Blob;
+export interface ArchivePathCandidate {
+    archivePath: string;
+    subPath: string;
+}
+export interface ArchiveNode {
+    path: string;
+    isDirectory: boolean;
+    size: number;
+    mtimeMs?: number;
+}
+export interface ArchiveDirectoryEntry extends ArchiveNode {
+    name: string;
+}
+export interface ExtractedArchiveFile extends ArchiveNode {
+    bytes: Uint8Array;
+}
+/** A byte window into an archive — file-backed (lazy) or in-memory. */
+interface ByteSource {
+    readonly size: number;
+    read(start: number, end: number): Promise<Uint8Array>;
+}
+interface TarStorage {
+    type: "tar";
+    file: File;
+}
+interface ZipStorage {
+    type: "zip";
+    source: ByteSource;
+    compressedSize: number;
+    compression: number;
+    flags: number;
+    localHeaderOffset: number;
+}
+type EntryStorage = TarStorage | ZipStorage;
+interface ArchiveIndexEntry extends ArchiveNode {
+    storage?: EntryStorage;
+}
+/** Infer an archive format from a filesystem path's extension. */
+export declare function archiveFormatFromPath(filePath: string): ArchiveFormat | undefined;
+export declare function formatArchiveEntryLines(entries: readonly ArchiveDirectoryEntry[]): string[];
+export declare function sniffArchiveFormat(bytes: Uint8Array): ArchiveFormat | undefined;
+/**
+ * Split an `archive.ext:inner/path` reference into every plausible
+ * `{ archivePath, subPath }` pair, longest archive prefix first. A path may
+ * contain more than one archive extension, so each candidate is a guess at
+ * where the archive ends and the member portion begins.
+ */
+export declare function parseArchivePathCandidates(filePath: string): ArchivePathCandidate[];
+/**
+ * An indexed, read-only view over a single archive. ZIP archives are indexed
+ * from the central directory and members are inflated on demand; tar archives
+ * are fully materialized by `Bun.Archive` up front.
+ */
+export declare class ArchiveReader {
+    #private;
+    readonly format: ArchiveFormat;
+    constructor(format: ArchiveFormat, entries: ArchiveIndexEntry[]);
+    getNode(subPath?: string): ArchiveNode | undefined;
+    listDirectory(subPath?: string): ArchiveDirectoryEntry[];
+    readFile(subPath: string): Promise<ExtractedArchiveFile>;
+}
+/**
+ * Open an archive for reading. ZIP archives opened from a path are indexed
+ * lazily via ranged central-directory reads (members inflate on demand); tar
+ * archives and in-memory ZIPs are read from a single buffer.
+ */
+export declare function openArchive(source: ArchiveSource): Promise<ArchiveReader>;
+/** Render the top-level entries of an in-memory archive as one line each. */
+export declare function listArchiveRoot(bytes: Uint8Array, format: ArchiveFormat, opts?: {
+    limit?: number;
+}): Promise<string>;
+/**
+ * Fully materialize every file member into a `path → content` map: ZIP members
+ * are inflated in memory, tar members are returned as lazy `File`s. Use this
+ * when you need every entry (rewrite, extract); for browsing or single-member
+ * reads prefer `openArchive`, which is lazy for ZIP.
+ */
+export declare function readArchiveEntries(source: ArchiveSource): Promise<Map<string, ArchiveMemberContent>>;
+/**
+ * Serialize `entries` into an archive of `format` and write it to `destPath`.
+ * ZIP is framed in memory, tar / tar.gz via `Bun.Archive` (gzip for tar.gz).
+ * String members are encoded as UTF-8.
+ */
+export declare function writeArchive(destPath: string, format: ArchiveFormat, entries: Iterable<readonly [string, ArchiveMemberContent]>): Promise<void>;
+/**
+ * Extract every file member to `destDir`, creating parent directories as
+ * needed. Entries that would escape `destDir` (via `..` or an absolute path)
+ * are rejected. Returns the number of files written.
+ */
+export declare function extractArchive(source: ArchiveSource, destDir: string): Promise<number>;
+/**
+ * Frame a `path → bytes` map into a ZIP archive in memory. Each member is raw
+ * DEFLATE unless that would not shrink it, in which case it is stored. ZIP64 is
+ * not emitted; archives beyond the 32-bit limits throw rather than corrupt.
+ */
+export declare function zip(entries: Unzipped): Uint8Array;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.0.7",
+	"version": "16.0.8",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -35,29 +35,30 @@
 		"check": "biome check . && bun run check:types",
 		"check:types": "tsgo -p tsconfig.json --noEmit",
 		"lint": "biome lint .",
-		"test": "bun test --parallel=4",
-		"fix": "biome check --write --unsafe . && bun run format-prompts && bun run generate-docs-index",
+		"test": "bun test --parallel=4 test src",
+		"fix": "biome check --write --unsafe . && bun run format-prompts",
 		"fmt": "biome format --write . && bun run format-prompts",
 		"format-prompts": "bun scripts/format-prompts.ts",
-		"generate-docs-index": "bun scripts/generate-docs-index.ts",
-		"prepack": "bun scripts/generate-docs-index.ts && bun --cwd=../collab-web run build:tool-views && bun scripts/bundle-dist.ts",
+		"generate-docs-index": "bun scripts/generate-docs-index.ts --generate",
+		"prepack": "bun scripts/generate-docs-index.ts --generate && bun --cwd=../collab-web run build:tool-views && bun scripts/bundle-dist.ts || ( bun scripts/generate-docs-index.ts --reset; exit 1 )",
+		"postpack": "bun scripts/generate-docs-index.ts --reset",
 		"bench:guard": "bun scripts/bench-guard.ts"
 	},
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.0.7",
-		"@oh-my-pi/omp-stats": "16.0.7",
-		"@oh-my-pi/pi-agent-core": "16.0.7",
-		"@oh-my-pi/pi-ai": "16.0.7",
-		"@oh-my-pi/pi-catalog": "16.0.7",
-		"@oh-my-pi/pi-mnemopi": "16.0.7",
-		"@oh-my-pi/pi-natives": "16.0.7",
-		"@oh-my-pi/pi-tui": "16.0.7",
-		"@oh-my-pi/pi-utils": "16.0.7",
-		"@oh-my-pi/pi-wire": "16.0.7",
-		"@oh-my-pi/snapcompact": "16.0.7",
+		"@oh-my-pi/hashline": "16.0.8",
+		"@oh-my-pi/omp-stats": "16.0.8",
+		"@oh-my-pi/pi-agent-core": "16.0.8",
+		"@oh-my-pi/pi-ai": "16.0.8",
+		"@oh-my-pi/pi-catalog": "16.0.8",
+		"@oh-my-pi/pi-mnemopi": "16.0.8",
+		"@oh-my-pi/pi-natives": "16.0.8",
+		"@oh-my-pi/pi-tui": "16.0.8",
+		"@oh-my-pi/pi-utils": "16.0.8",
+		"@oh-my-pi/pi-wire": "16.0.8",
+		"@oh-my-pi/snapcompact": "16.0.8",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",
@@ -70,11 +71,12 @@
 		"arktype": "^2.2.0",
 		"chalk": "^5.6.2",
 		"diff": "^9.0.0",
-		"fflate": "0.8.3",
+		"fast-xml-parser": "^5.9.0",
 		"handlebars": "^4.7.9",
 		"linkedom": "^0.18.12",
 		"lru-cache": "11.5.1",
-		"markit-ai": "0.5.3",
+		"mammoth": "^1.12.0",
+		"mupdf": "^1.27.0",
 		"puppeteer-core": "^25.1.0",
 		"turndown": "7.2.4",
 		"turndown-plugin-gfm": "1.0.2",

package/scripts/build-binary.ts

@@ -38,9 +38,13 @@ async function runCommand(
 }
 
 async function main(): Promise<void> {
-	await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
+	// Generate inside the try so the finally always restores the empty checked-in
+	// placeholders (stats client archive, docs index) even on failure.
 	try {
+		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--generate"]);
+		await runCommand(["bun", "scripts/generate-docs-index.ts", "--generate"]);
 		await runCommand(["bun", "--cwd=../natives", "run", "embed:native"]);
+		await runCommand(["bun", "scripts/embed-mupdf-wasm.ts", "--generate"]);
 		try {
 			const buildEnv = shouldAdhocSignDarwinBinary() ? { ...Bun.env, BUN_NO_CODESIGN_MACHO_BINARY: "1" } : Bun.env;
 			await runCommand(
@@ -58,8 +62,6 @@ async function main(): Promise<void> {
 					"--define",
 					`process.env.PI_TINY_TRANSFORMERS_VERSION=${JSON.stringify(transformersVersion)}`,
 					"--external",
-					"mupdf",
-					"--external",
 					"fastembed",
 					"--external",
 					"onnxruntime-node",
@@ -94,10 +96,12 @@ async function main(): Promise<void> {
 				await runCommand(["codesign", "--force", "--sign", "-", outputPath]);
 			}
 		} finally {
+			await runCommand(["bun", "scripts/embed-mupdf-wasm.ts", "--reset"]);
 			await runCommand(["bun", "--cwd=../natives", "run", "embed:native", "--reset"]);
 		}
 	} finally {
 		await runCommand(["bun", "--cwd=../stats", "scripts/generate-client-bundle.ts", "--reset"]);
+		await runCommand(["bun", "scripts/generate-docs-index.ts", "--reset"]);
 	}
 }
 

package/scripts/bundle-dist.ts

@@ -9,6 +9,30 @@ const outDir = path.join(packageDir, "dist");
 const cliPath = path.join(outDir, "cli.js");
 const shebang = "#!/usr/bin/env bun\n";
 
+// Native / optional / platform-specific deps that are never bundled — installed on
+// demand (transformers/fastembed/onnxruntime) or shipped as their own artifact
+// (native addon, mupdf).
+const ALWAYS_EXTERNAL = ["mupdf", "@oh-my-pi/pi-natives", "@huggingface/transformers", "fastembed", "onnxruntime-node"];
+
+// Heavy, lazily-used third-party leaf deps. Each is a declared `dependency`, so the
+// published package resolves it from node_modules at runtime; bundling only embeds a
+// redundant copy that bloats dist/cli.js. NEVER add a patched dependency here — the
+// bundle is where a root `patchedDependencies` patch is baked in, so an externalized
+// import would load the unpatched npm package in users' installs (currently
+// @ark/schema is patched, so it — and arktype, which pulls @ark/schema — stay
+// bundled).
+const RUNTIME_EXTERNAL = [
+	"puppeteer-core",
+	"@puppeteer/browsers",
+	"@babel/parser",
+	"@xterm/headless",
+	"turndown",
+	"turndown-plugin-gfm",
+	"@mozilla/readability",
+	"linkedom",
+	"@agentclientprotocol/sdk",
+];
+
 async function runCommand(command: string[]): Promise<void> {
 	const proc = Bun.spawn(command, {
 		cwd: packageDir,
@@ -63,19 +87,11 @@ async function main(): Promise<void> {
 			"--target=bun",
 			"--outdir",
 			"dist",
-			"--minify-whitespace",
-			"--minify-syntax",
+			// Full minify (whitespace + syntax + identifiers); --keep-names retains
+			// fn/class .name where code depends on it.
+			"--minify",
 			"--keep-names",
-			"--external",
-			"mupdf",
-			"--external",
-			"@oh-my-pi/pi-natives",
-			"--external",
-			"@huggingface/transformers",
-			"--external",
-			"fastembed",
-			"--external",
-			"onnxruntime-node",
+			...[...ALWAYS_EXTERNAL, ...RUNTIME_EXTERNAL].flatMap(dep => ["--external", dep]),
 			"--define",
 			'process.env.PI_BUNDLED="true"',
 			"./src/cli.ts",

package/scripts/embed-mupdf-wasm.ts

@@ -0,0 +1,67 @@
+#!/usr/bin/env bun
+
+// Embeds mupdf's `mupdf-wasm.wasm` into the compiled single-file binary.
+//
+// mupdf loads its wasm by reading the `mupdf-wasm.wasm` sibling of its own
+// module via `new URL(..., import.meta.url)` + `readFileSync`. A `bun --compile`
+// binary has no node_modules, so that read fails (`ENOENT .../mupdf-wasm.wasm`),
+// and marking mupdf `--external` instead makes `bun --compile` eagerly fail to
+// resolve the package at startup (the static `import * as mupdf` lives in a lazy
+// chunk but is hoisted). So the binary build bundles mupdf and embeds the wasm
+// bytes here, handing them to the WASM module as `$libmupdf_wasm_Module.wasmBinary`
+// (see src/utils/markit.ts).
+//
+// `--generate` copies the wasm next to src/utils/mupdf-wasm-embed.ts and rewrites
+// that module to import it via `with { type: "file" }`; `--reset` restores the
+// checked-in placeholder and removes the copy. The npm `dist/cli.js` bundle never
+// runs this — it keeps mupdf external and loads the wasm from node_modules.
+
+import * as fs from "node:fs/promises";
+import { createRequire } from "node:module";
+import * as path from "node:path";
+
+const utilsDir = path.join(import.meta.dir, "..", "src", "utils");
+const helperPath = path.join(utilsDir, "mupdf-wasm-embed.ts");
+const wasmCopyPath = path.join(utilsDir, "mupdf-wasm.wasm");
+
+const placeholder = `// AUTOGENERATED -- managed by scripts/embed-mupdf-wasm.ts. Do not edit by hand.
+//
+// Compiled single-file binaries cannot let mupdf resolve its \`mupdf-wasm.wasm\`
+// sibling from the read-only bunfs, so the binary build (scripts/build-binary.ts
+// and scripts/ci-release-build-binaries.ts) regenerates this module to embed the
+// wasm bytes via \`with { type: "file" }\` and copies the wasm next to it. Source
+// checkouts, \`bun test\`, and the npm \`dist/cli.js\` bundle keep mupdf external and
+// load the wasm from node_modules, so this placeholder returns undefined and the
+// build resets back to it afterward.
+export function loadEmbeddedMupdfWasm(): Uint8Array | undefined {
+\treturn undefined;
+}
+`;
+
+const generated = `// AUTOGENERATED -- managed by scripts/embed-mupdf-wasm.ts. Do not edit or commit.
+import { readFileSync } from "node:fs";
+import wasmPath from "./mupdf-wasm.wasm" with { type: "file" };
+
+export function loadEmbeddedMupdfWasm(): Uint8Array | undefined {
+\treturn readFileSync(wasmPath);
+}
+`;
+
+if (process.argv.includes("--reset")) {
+	await Bun.write(helperPath, placeholder);
+	try {
+		await fs.unlink(wasmCopyPath);
+	} catch (err) {
+		if ((err as NodeJS.ErrnoException).code !== "ENOENT") throw err;
+	}
+	process.exit(0);
+}
+
+const wasmSource = path.join(path.dirname(createRequire(import.meta.url).resolve("mupdf")), "mupdf-wasm.wasm");
+const wasmFile = Bun.file(wasmSource);
+if (!(await wasmFile.exists())) {
+	throw new Error(`mupdf wasm not found at ${wasmSource}; run \`bun install\` first.`);
+}
+await Bun.write(wasmCopyPath, wasmFile);
+await Bun.write(helperPath, generated);
+console.log(`Embedded mupdf wasm (${wasmFile.size} bytes) into ${path.relative(process.cwd(), wasmCopyPath)}`);

package/scripts/generate-docs-index.ts

@@ -1,40 +1,56 @@
 #!/usr/bin/env bun
 
+/**
+ * Populate (or reset) the embedded harness documentation index for `omp://`.
+ *
+ * `--generate` writes `src/internal-urls/docs-index.generated.txt` as two lines:
+ * a plain JSON array of the sorted `docs/**\/*.md` file names, then a base64
+ * gzip blob of the index-aligned doc bodies (`string[]`). Keeping the filename
+ * list out of the blob lets the loader list docs without inflating it.
+ * Compiled binaries and the prepacked npm bundle inline this (~0.5MB) instead of
+ * the ~1.6MB raw map; `--reset` restores the checked-in empty placeholder so the
+ * dev tree reads `docs/` from disk. Mirrors the stats / model-catalog embeds.
+ */
+
 import * as path from "node:path";
+import { gzipSync } from "node:zlib";
 import { Glob } from "bun";
 
 const docsDir = path.resolve(import.meta.dir, "../../../docs");
-const outputPath = path.resolve(import.meta.dir, "../src/internal-urls/docs-index.generated.ts");
+const outputPath = path.resolve(import.meta.dir, "../src/internal-urls/docs-index.generated.txt");
+const GENERATE_FLAG = "--generate";
+const RESET_FLAG = "--reset";
+
+async function main(): Promise<void> {
+	const rel = path.relative(process.cwd(), outputPath);
+
+	if (process.argv.includes(RESET_FLAG)) {
+		await Bun.write(outputPath, "");
+		console.log(`Reset ${rel}`);
+		return;
+	}
+
+	if (!process.argv.includes(GENERATE_FLAG)) {
+		console.log(`Skipping ${rel}; pass ${GENERATE_FLAG} to embed docs (the dev tree reads docs/ from disk)`);
+		return;
+	}
 
-const glob = new Glob("**/*.md");
-const entries: string[] = [];
-for await (const relativePath of glob.scan(docsDir)) {
-	entries.push(relativePath.split(path.sep).join("/"));
+	const glob = new Glob("**/*.md");
+	const files: string[] = [];
+	for await (const relativePath of glob.scan(docsDir)) {
+		files.push(relativePath.split(path.sep).join("/"));
+	}
+	files.sort();
+
+	// Index-aligned bodies (Promise.all preserves order), kept separate from the
+	// filename list so the loader can list docs without inflating the blob.
+	const bodies = await Promise.all(files.map(file => Bun.file(path.join(docsDir, file)).text()));
+
+	const bodiesB64 = Buffer.from(gzipSync(Buffer.from(JSON.stringify(bodies)), { level: 9 })).toString("base64");
+	// Two lines: plain filename array, then the base64 gzip blob.
+	const payload = `${JSON.stringify(files)}\n${bodiesB64}`;
+	await Bun.write(outputPath, payload);
+	console.log(`Generated ${rel} (${files.length} docs, ${payload.length} bytes)`);
 }
-entries.sort();
-
-const docsWithContent = await Promise.all(
-	entries.map(async relativePath => ({
-		relativePath,
-		content: await Bun.file(path.join(docsDir, relativePath)).text(),
-	})),
-);
-
-const filenamesLiteral = JSON.stringify(entries);
-
-const mapEntries = docsWithContent
-	.map(({ relativePath, content }) => `\t${JSON.stringify(relativePath)}: ${JSON.stringify(content)},`)
-	.join("\n");
-const output = [
-	"// Auto-generated by scripts/generate-docs-index.ts - DO NOT EDIT",
-	"",
-	`export const EMBEDDED_DOC_FILENAMES: readonly string[] = ${filenamesLiteral};`,
-	"",
-	`export const EMBEDDED_DOCS: Readonly<Record<string, string>> = {`,
-	`${mapEntries}`,
-	`};`,
-	"",
-].join("\n");
-
-await Bun.write(outputPath, output);
-console.log(`Generated ${path.relative(process.cwd(), outputPath)} (${entries.length} docs)`);
+
+await main();

package/scripts/omp

@@ -1,5 +1,5 @@
 #!/bin/sh
-# Dev launcher for the omp CLI.
+# Dev launcher for the omp CLI, installed by `bun run setup`.
 #
 # Problem it solves: Bun reads `bunfig.toml` from the *current working
 # directory* at startup and evaluates its `preload` entries before running the

package/src/advisor/__tests__/advisor.test.ts

@@ -106,6 +106,32 @@ describe("advisor", () => {
 			yq.enqueue("normal", { note: "b" });
 			expect(scheduled).toBe(1);
 		});
+
+		it("clear(kind) drops only that kind's queued entries", () => {
+			const yq = new YieldQueue({
+				isStreaming: () => false,
+				injectIdle: async () => {},
+				scheduleIdleFlush: () => {},
+			});
+			yq.register<{ note: string }>("advisor", {
+				build: entries => (entries.length === 0 ? null : ({ role: "custom", content: "x" } as AgentMessage)),
+				skipIdleFlush: true,
+			});
+			yq.register<{ note: string }>("normal", {
+				build: entries => (entries.length === 0 ? null : ({ role: "custom", content: "y" } as AgentMessage)),
+			});
+
+			yq.enqueue("advisor", { note: "stale advice" });
+			yq.enqueue("normal", { note: "keep me" });
+			expect(yq.has("advisor")).toBe(true);
+			expect(yq.has("normal")).toBe(true);
+
+			// Conversation-boundary cleanup must drop advisor deliveries without
+			// touching other kinds (IRC asides, async-job/diagnostic deliveries).
+			yq.clear("advisor");
+			expect(yq.has("advisor")).toBe(false);
+			expect(yq.has("normal")).toBe(true);
+		});
 	});
 
 	describe("AdviseTool", () => {
@@ -659,6 +685,63 @@ describe("advisor", () => {
 			expect(promptInputs).toHaveLength(3);
 			expect(runtime.backlog).toBe(0);
 		});
+
+		it("drops the in-flight batch when a reset aborts the advisor prompt", async () => {
+			const promptInputs: string[] = [];
+			const { promise: firstPromptStarted, resolve: startFirstPrompt } = Promise.withResolvers<void>();
+			let rejectInFlight: ((err: unknown) => void) | undefined;
+			let promptCalls = 0;
+			const agent: AdvisorAgent = {
+				prompt: input => {
+					promptInputs.push(input);
+					promptCalls++;
+					if (promptCalls === 1) {
+						const { promise, reject } = Promise.withResolvers<void>();
+						rejectInFlight = reject;
+						startFirstPrompt();
+						return promise;
+					}
+					return Promise.resolve();
+				},
+				// AdvisorRuntime.reset() calls agent.reset() then agent.abort(); the real
+				// Agent.abort rejects the awaited prompt, so model that rejection here.
+				abort: () => rejectInFlight?.(new Error("advisor reset")),
+				reset: () => {},
+				state: { messages: [] },
+			};
+			const messages: AgentMessage[] = [{ role: "user", content: "old-conversation", timestamp: 1 } as AgentMessage];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+			};
+			const runtime = new AdvisorRuntime(agent, host, 0);
+
+			runtime.onTurnEnd(messages);
+			await firstPromptStarted;
+			expect(promptInputs).toHaveLength(1);
+			expect(promptInputs[0]).toContain("old-conversation");
+
+			// Conversation boundary (/new): transcript replaced and the runtime reset
+			// while the advisor prompt is still in flight. The abort that rejects the
+			// prompt is the reset itself — it must NOT be treated as a transient
+			// failure that requeues and re-sends the stale pre-reset batch.
+			messages.length = 0;
+			messages.push({ role: "user", content: "new-conversation", timestamp: 2 } as AgentMessage);
+			runtime.reset();
+			await Bun.sleep(0);
+			await Bun.sleep(0);
+
+			expect(promptInputs).toHaveLength(1);
+			expect(runtime.backlog).toBe(0);
+
+			// The runtime still works afterward: the next turn replays the new
+			// transcript only, never the dropped pre-reset content.
+			runtime.onTurnEnd(messages);
+			await Bun.sleep(0);
+			expect(promptInputs).toHaveLength(2);
+			expect(promptInputs[1]).toContain("new-conversation");
+			expect(promptInputs[1]).not.toContain("old-conversation");
+		});
 	});
 
 	describe("read-only tool allowlist", () => {

package/src/advisor/runtime.ts

@@ -48,6 +48,11 @@ export class AdvisorRuntime {
 	#consecutiveFailures = 0;
 	#latestMessages?: AgentMessage[];
 	#waiters: CatchupWaiter[] = [];
+	/** Bumped by every external {@link reset}/{@link dispose}. A drain iteration
+	 *  captures it before its awaits; a mismatch on resume means a reset aborted
+	 *  the in-flight advisor prompt, so the stale batch is dropped instead of
+	 *  being retried/requeued into the post-reset conversation. */
+	#epoch = 0;
 	disposed = false;
 
 	constructor(
@@ -95,6 +100,7 @@ export class AdvisorRuntime {
 
 	dispose(): void {
 		this.disposed = true;
+		this.#epoch++;
 		this.#pending = [];
 		this.#backlog = 0;
 		this.#consecutiveFailures = 0;
@@ -130,6 +136,7 @@ export class AdvisorRuntime {
 	 * leaving it blind to everything before the rewrite.
 	 */
 	reset(): void {
+		this.#epoch++;
 		this.#resetAdvisorContext(true, true);
 	}
 
@@ -187,6 +194,7 @@ export class AdvisorRuntime {
 		try {
 			while (!this.disposed && this.#pending.length) {
 				const popped = this.#pending.splice(0);
+				const epoch = this.#epoch;
 				// Each delta already opens with a `### Session update` heading, so
 				// join with a blank line rather than a `---` rule.
 				const candidateBatch = popped.map(b => b.text).join("\n\n");
@@ -205,6 +213,8 @@ export class AdvisorRuntime {
 						logger.debug("advisor context maintenance failed", { err: String(err) });
 					}
 				}
+				// A reset/dispose during context maintenance invalidates this batch.
+				if (this.#epoch !== epoch) continue;
 
 				let batch: string | null;
 				let finalTurns: number;
@@ -231,6 +241,11 @@ export class AdvisorRuntime {
 					success = true;
 					this.#consecutiveFailures = 0;
 				} catch (err) {
+					// reset()/dispose() aborts the in-flight prompt; the rejection is the
+					// reset itself, not a transient advisor failure. Drop the stale batch
+					// (reset already cleared #pending and rewound the cursor) instead of
+					// requeuing it into the post-reset conversation.
+					if (this.#epoch !== epoch) continue;
 					logger.debug("advisor turn failed", { err: String(err) });
 					this.#consecutiveFailures++;
 					if (this.#consecutiveFailures >= 3) {
@@ -243,7 +258,7 @@ export class AdvisorRuntime {
 					}
 				}
 
-				if (success) {
+				if (success && this.#epoch === epoch) {
 					this.#backlog = Math.max(0, this.#backlog - finalTurns);
 					this.#notifyWaiters();
 				}

package/src/cli/auth-broker-cli.ts

@@ -19,11 +19,9 @@ import * as os from "node:os";
 import * as path from "node:path";
 import * as readline from "node:readline";
 import {
-	AuthBrokerClient,
 	type AuthCredential,
 	AuthStorage,
 	type CredentialDisabledEvent,
-	DEFAULT_AUTH_BROKER_BIND,
 	getEnvApiKey,
 	getOAuthProviders,
 	listProvidersWithEnvKey,
@@ -32,8 +30,8 @@ import {
 	type OAuthProviderInfo,
 	PROVIDER_REGISTRY,
 	SqliteAuthCredentialStore,
-	startAuthBroker,
 } from "@oh-my-pi/pi-ai";
+import { AuthBrokerClient, DEFAULT_AUTH_BROKER_BIND, startAuthBroker } from "@oh-my-pi/pi-ai/auth-broker";
 import { $which, APP_NAME, getAgentDbPath, getConfigRootDir, isEnoent, logger, VERSION } from "@oh-my-pi/pi-utils";
 import { setTransports as setLoggerTransports } from "@oh-my-pi/pi-utils/logger";
 import { $ } from "bun";

package/src/cli/auth-gateway-cli.ts

@@ -17,18 +17,15 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import {
 	type Api,
-	AuthBrokerClient,
 	AuthStorage,
 	type CompletionProbe,
 	type CompletionProbeInput,
 	type CredentialCompletionResult,
 	completeSimple,
-	DEFAULT_AUTH_GATEWAY_BIND,
 	type Model,
-	RemoteAuthCredentialStore,
-	type SnapshotResponse,
-	startAuthGateway,
 } from "@oh-my-pi/pi-ai";
+import { AuthBrokerClient, RemoteAuthCredentialStore, type SnapshotResponse } from "@oh-my-pi/pi-ai/auth-broker";
+import { DEFAULT_AUTH_GATEWAY_BIND, startAuthGateway } from "@oh-my-pi/pi-ai/auth-gateway";
 import { type GeneratedProvider, getBundledModels, getBundledProviders } from "@oh-my-pi/pi-catalog/models";
 import { getConfigRootDir, isEnoent, VERSION } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";