@oh-my-pi/pi-coding-agent 15.5.10 → 15.5.11

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [15.5.11] - 2026-05-29
+
+### Added
+
+- Added `SqlSessionStorage`, a `bun:sql`-backed implementation of `SessionStorage` that persists session JSONL into PostgreSQL, MySQL/MariaDB, or SQLite. Pass a connected `Bun.SQL` instance (the constructor accepts `postgres://`, `mysql://`, or `sqlite:` URLs) to `SqlSessionStorage.create({ client, table?, adapter?, createTable? })` and hand the returned storage to any `SessionManager` factory. The dialect is auto-detected from `client.options.adapter` and used to pick the correct DDL plus upsert-with-append syntax (`ON CONFLICT … DO UPDATE` for PG/SQLite, `ON DUPLICATE KEY UPDATE` for MySQL), so the agent's append-only persist pattern works in a single round-trip per line. Same in-memory mirror and `drain()` semantics as the Redis backend; blobs and tool artifacts still live on disk via `ArtifactManager`/`BlobStore`.
+- Added `RedisSessionStorage`, a `bun:redis`-backed implementation of the `SessionStorage` interface that lets API consumers route session JSONL through Redis instead of local disk. Pass a connected `Bun.RedisClient` (or any compatible adapter) to `RedisSessionStorage.create({ client, prefix? })` and hand the returned storage to `SessionManager.create(cwd, sessionDir, storage)` (or any other static factory that accepts a storage argument). An in-memory mirror is loaded on creation so the interface's synchronous methods (`existsSync`, `statSync`, `listFilesSync`, …) keep their contracts; `drain()` waits for queued background writes. Tool artifacts and image blobs still live on disk via `ArtifactManager`/`BlobStore` — Redis only owns the session JSONL keyspace under the configured prefix.
+- Exported the `SessionStorage` / `SessionStorageWriter` / `FileSessionStorage` / `MemorySessionStorage` symbols (already reachable via the `./session/session-storage` subpath) from the package root so SDK consumers can construct alternative storage backends without deep-importing.
+- Added a fresh `¶<relative-path>#TAG` snapshot header to the `write` tool's success text in hashline display mode, covering plain disk writes, ACP-bridge writes, and conflict resolutions (bulk resolutions emit a trailing `Snapshots:` block with one header per successfully written file). The header records a current snapshot in the file-snapshot store so the next `edit` can land without an extra `read` round-trip. Suppressed when the session is not in hashline mode and skipped for archive/SQLite writes and host-managed internal URL targets where hashline anchors do not apply.
+
+### Changed
+
+- The `edit` tool's stale-snapshot rejection message now distinguishes "file changed between read and edit" (the section's hash was recorded in this session but the file has since drifted — a prior in-session edit advanced it, or an external write changed it) from "hash #X is not from this session" (a fabricated or carried-over cross-session tag), the latter carrying explicit "never invent the tag" guidance. Both messages include the current file hash plus 2 lines of context around each anchor so the next attempt has everything it needs. Snapshot-based recovery still runs first; the sharper diagnostics only surface when recovery cannot reconcile the edit.
+
+### Fixed
+
+- Fixed Autonomous Memory phase 1/phase 2 failing with `Thinking effort low is not supported by <provider>/<model>` on models whose supported reasoning efforts exclude `low`/`medium` (e.g. `deepseek/deepseek-v4-pro`). Both stage1 (`Effort.Low`) and consolidation (`Effort.Medium`) call sites in `packages/coding-agent/src/memories/index.ts` now route through `clampThinkingLevelForModel`, lifting the requested effort to the model's lowest supported level instead of letting `requireSupportedEffort` throw ([#1480](https://github.com/can1357/oh-my-pi/issues/1480)).
+
 ## [15.5.10] - 2026-05-28
 
 ### Added
@@ -12,6 +29,10 @@
 
 - Fixed compaction surfacing raw HTTP 401/403 envelopes (e.g. `Compaction failed: 401 {"type":"error","error":{"type":"authentication_error",…}}`) instead of routing to an authenticated fallback model. The compaction layer now attaches the provider-reported HTTP status onto the thrown error, and `AgentSession`'s auth-failure detector branches on `error.status === 401 || 403` in addition to the existing `auth_unavailable` regex. When a fallback model role (e.g. `modelRoles.smol`) is configured, compaction retries it transparently; otherwise the user sees the actionable "Compaction requires usable credentials for …" hint instead of the raw provider envelope.
 
+### Fixed
+
+- Fixed compiled-binary legacy plugin loading for `@earendil-works/*` imports of bundled package roots such as `@earendil-works/pi-coding-agent`; compat now rewrites all bundled pi package roots to bunfs entrypoints and resolves fallback peer dependencies through the canonical `@oh-my-pi/*` specifier.
+
 ## [15.5.8] - 2026-05-28
 
 ### Breaking Changes

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

@@ -0,0 +1,14 @@
+/**
+ * Compatibility shim for legacy extensions importing the package root of
+ * `@oh-my-pi/pi-coding-agent` (or one of its aliased scopes like
+ * `@earendil-works/pi-coding-agent` or `@mariozechner/pi-coding-agent`).
+ *
+ * The coding-agent package's own barrel (`./src/index.ts`) cannot be listed
+ * as a `bun --compile` extra entrypoint alongside the CLI entry without
+ * silently breaking the main binary's startup (see issue #1474 follow-up).
+ * Routing legacy plugin imports through this sibling shim sidesteps that
+ * conflict: bun bundles a distinct entry whose path differs from the CLI
+ * entry, while still re-exporting the canonical surface so plugins observe
+ * the same module identity as a direct `@oh-my-pi/pi-coding-agent` import.
+ */
+export * from "../index";

package/dist/types/extensibility/plugins/legacy-pi-compat.d.ts

@@ -1,2 +1,4 @@
 export declare function loadLegacyPiModule(resolvedPath: string): Promise<unknown>;
 export declare function installLegacyPiSpecifierShim(): void;
+/** Test seam: clears the memoized canonical specifier resolutions. */
+export declare function __resetLegacyPiResolutionCache(): void;

package/dist/types/index.d.ts

@@ -23,8 +23,11 @@ export * from "./sdk";
 export * from "./session/agent-session";
 export * from "./session/auth-storage";
 export * from "./session/messages";
+export * from "./session/redis-session-storage";
 export * from "./session/session-dump-format";
 export * from "./session/session-manager";
+export * from "./session/session-storage";
+export * from "./session/sql-session-storage";
 export * from "./task/executor";
 export type * from "./task/types";
 export * from "./tools";

package/dist/types/modes/components/custom-editor.d.ts

@@ -1,11 +1,14 @@
 import { Editor, type KeyId } from "@oh-my-pi/pi-tui";
 import type { AppKeybinding } from "../../config/keybindings";
+import { highlightUltrathink } from "../ultrathink";
 type ConfigurableEditorAction = Extract<AppKeybinding, "app.interrupt" | "app.clear" | "app.exit" | "app.suspend" | "app.thinking.cycle" | "app.model.cycleForward" | "app.model.cycleBackward" | "app.model.select" | "app.model.selectTemporary" | "app.tools.expand" | "app.thinking.toggle" | "app.editor.external" | "app.history.search" | "app.message.dequeue" | "app.clipboard.pasteImage" | "app.clipboard.copyPrompt">;
 /**
  * Custom editor that handles configurable app-level shortcuts for coding-agent.
  */
 export declare class CustomEditor extends Editor {
     #private;
+    /** Rainbow-highlight the "ultrathink" keyword as the user types it. */
+    decorateText: typeof highlightUltrathink;
     onEscape?: () => void;
     shouldBypassAutocompleteOnEscape?: () => boolean;
     onClear?: () => void;

package/dist/types/modes/ultrathink.d.ts

@@ -0,0 +1,10 @@
+/** Hidden system notice appended after a user message that mentions "ultrathink". */
+export declare const ULTRATHINK_NOTICE: string;
+/** Whether `text` contains the standalone keyword "ultrathink" (any case). */
+export declare function containsUltrathink(text: string): boolean;
+/**
+ * Rainbow-highlight every standalone "ultrathink" in `text` for editor display.
+ * Adds only zero-width SGR escapes — the visible width is unchanged — and returns
+ * the input untouched when the keyword is absent.
+ */
+export declare function highlightUltrathink(text: string): string;

package/dist/types/session/redis-session-storage.d.ts

@@ -0,0 +1,124 @@
+import type { SessionStorage, SessionStorageStat, SessionStorageWriter } from "./session-storage";
+/**
+ * Minimal subset of the `bun:redis` `RedisClient` surface used by
+ * {@link RedisSessionStorage}. Keeping the contract narrow (and accepting any
+ * client that conforms) lets callers swap in test doubles or shared clients
+ * without dragging the entire Bun typings into this module.
+ */
+export interface RedisSessionStorageClient {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<unknown>;
+    append(key: string, value: string): Promise<number>;
+    del(...keys: string[]): Promise<number>;
+    rename(src: string, dst: string): Promise<unknown>;
+    scan(cursor: string, ...args: string[]): Promise<[string, string[]]>;
+    hset(key: string, field: string, value: string): Promise<unknown>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    hdel(key: string, ...fields: string[]): Promise<unknown>;
+}
+export interface RedisSessionStorageOptions {
+    /** A connected `bun:redis` RedisClient (or any compatible adapter). */
+    client: RedisSessionStorageClient;
+    /**
+     * Key prefix applied to every Redis key this storage owns. Default `omp:sessions:`.
+     * Trailing colon is preserved verbatim — set to a project-scoped prefix to share
+     * one Redis instance between multiple agents.
+     */
+    prefix?: string;
+    /**
+     * Maximum number of keys returned per SCAN batch when warming the mirror.
+     * Default 500.
+     */
+    scanCount?: number;
+}
+/**
+ * Redis-backed implementation of {@link SessionStorage}. Each session JSONL
+ * file maps to a Redis STRING key, with per-key metadata (mtime) tracked in a
+ * single sibling HASH. An in-memory mirror is loaded on construction so the
+ * interface's synchronous methods (`existsSync`, `statSync`, `listFilesSync`,
+ * `readTextSync`, `writeTextSync`) keep their contracts — Bun's Redis client
+ * is async only, and the persist hot path (`writer.writeLineSync`) cannot
+ * wait on a network round-trip.
+ *
+ * Trade-offs vs `FileSessionStorage`:
+ * - Mirror state is process-local. Two processes writing the same session key
+ *   will diverge until one of them reloads via {@link refresh}. This matches
+ *   `FileSessionStorage`'s existing single-writer assumption.
+ * - `writeLineSync` updates the mirror synchronously and queues an async
+ *   `APPEND`. The promise is awaited by `flush()` / `close()` / {@link drain}.
+ *   A SIGKILL landing between the sync mirror update and the network round
+ *   trip loses the last line; the file-backed implementation survives that
+ *   window because bytes are handed to the kernel page cache before
+ *   returning.
+ * - Blobs (image data) and tool artifact files still live on disk via
+ *   `BlobStore` / `ArtifactManager`. Those are out of scope for this storage.
+ */
+export declare class RedisSessionStorage implements SessionStorage {
+    #private;
+    private constructor();
+    /**
+     * Warm the in-memory mirror with every existing session key under the
+     * configured prefix and return the ready-to-use storage. Must be awaited
+     * before passing the storage into `SessionManager.create()` so synchronous
+     * lookups (session resume, recent sessions, EPERM-backup recovery) see
+     * the existing keyspace.
+     */
+    static create(options: RedisSessionStorageOptions): Promise<RedisSessionStorage>;
+    /**
+     * Re-scan Redis and replace the mirror's contents. Call this from a
+     * different process that took over a session keyspace, or after an
+     * out-of-band write made by another agent.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Resolve once every pending background write (issued via `writeTextSync`
+     * or `writer.writeLineSync`) has been acknowledged by Redis. Throws if any
+     * background write failed since the last drain.
+     *
+     * Call this on graceful shutdown to avoid losing the last unflushed line.
+     * The session-manager's own `flush()` / `close()` already drain through
+     * the writer chain — this method exists for callers (test harnesses,
+     * subprocess-style consumers) that bypass the writer.
+     */
+    drain(): Promise<void>;
+    ensureDirSync(_dir: string): void;
+    existsSync(path: string): boolean;
+    writeTextSync(path: string, content: string): void;
+    readTextSync(path: string): string;
+    statSync(path: string): SessionStorageStat;
+    listFilesSync(dir: string, pattern: string): string[];
+    exists(path: string): Promise<boolean>;
+    readText(path: string): Promise<string>;
+    readTextPrefix(path: string, maxBytes: number): Promise<string>;
+    writeText(path: string, content: string): Promise<void>;
+    rename(src: string, dst: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
+    openWriter(path: string, options?: {
+        flags?: "a" | "w";
+        onError?: (err: Error) => void;
+    }): SessionStorageWriter;
+    _writerClosed(writer: RedisSessionStorageWriter): void;
+    /** Mirror-only mutation, no Redis call. Used by writers to update local state synchronously. */
+    _mirrorAppend(path: string, line: string): void;
+    /** Mirror-only mutation, no Redis call. Used by writers opened with `flags: "w"` to truncate. */
+    _mirrorTruncate(path: string): void;
+    _remoteTruncate(path: string): Promise<void>;
+    _remoteAppend(path: string, line: string): Promise<void>;
+    /** Record a writer's pending promise on the storage-level tail so `drain()` waits for it. */
+    _attachPending(promise: Promise<void>): void;
+}
+declare class RedisSessionStorageWriter implements SessionStorageWriter {
+    #private;
+    constructor(storage: RedisSessionStorage, path: string, options?: {
+        flags?: "a" | "w";
+        onError?: (err: Error) => void;
+    });
+    writeLineSync(line: string): void;
+    writeLine(line: string): Promise<void>;
+    flush(): Promise<void>;
+    fsync(): Promise<void>;
+    close(): Promise<void>;
+    getError(): Error | undefined;
+}
+export {};

package/dist/types/session/sql-session-storage.d.ts

@@ -0,0 +1,141 @@
+import type { SessionStorage, SessionStorageStat, SessionStorageWriter } from "./session-storage";
+/**
+ * Supported `bun:sql` adapter dialects. `Bun.SQL` reports this string on
+ * `client.options.adapter`; we detect it once at construction and pick the
+ * correct DDL / upsert / concat syntax for the underlying engine.
+ */
+export type SqlSessionStorageAdapter = "postgres" | "mysql" | "sqlite";
+/**
+ * Minimal subset of the `Bun.SQL` instance surface used by
+ * {@link SqlSessionStorage}. The real client exposes a callable
+ * tagged-template too; we only ever call `unsafe()` so the contract here is
+ * narrow — making it trivial to swap in a test double or wrap a pooled
+ * client.
+ */
+export interface SqlSessionStorageClient {
+    unsafe(query: string, values?: unknown[]): Promise<unknown[]>;
+    /**
+     * `Bun.SQL` exposes the parsed connection options here. We only consult
+     * `adapter` to pick the dialect; the field is typed as
+     * `string | undefined` so the real `Bun.SQL` instance type slots in
+     * without casting (it reports `string | undefined` across adapters).
+     */
+    options: {
+        adapter?: string;
+        [key: string]: unknown;
+    };
+    end?(): Promise<void>;
+}
+export interface SqlSessionStorageOptions {
+    /** Connected `Bun.SQL` instance (PostgreSQL, MySQL, or SQLite). */
+    client: SqlSessionStorageClient;
+    /**
+     * Override the auto-detected adapter. Useful when the client is wrapped
+     * (e.g. by a pool) and `client.options.adapter` is unreliable.
+     */
+    adapter?: SqlSessionStorageAdapter;
+    /**
+     * Table name to use. Default: `omp_session_files`. Must match
+     * `[A-Za-z_][A-Za-z0-9_]{0,62}` — inlined into prepared statements at
+     * startup, so we accept identifier-safe inputs only (no quoted/dotted
+     * names).
+     */
+    table?: string;
+    /**
+     * If true, run `CREATE TABLE IF NOT EXISTS` during `create()`.
+     * Default: true. Disable when the table is owned by an external
+     * migration.
+     */
+    createTable?: boolean;
+}
+/**
+ * SQL-backed implementation of {@link SessionStorage} using `bun:sql`. Each
+ * session JSONL file maps to a row keyed by `path`; one table stores
+ * everything.
+ *
+ * Works against PostgreSQL, MySQL/MariaDB, and SQLite by selecting the
+ * dialect-correct DDL, upsert, and string-concat syntax at construction.
+ *
+ * Trade-offs vs `FileSessionStorage`:
+ * - An in-memory mirror is loaded on construction so the interface's
+ *   synchronous methods (`existsSync`, `statSync`, `listFilesSync`, …) keep
+ *   their contracts; `bun:sql` is async only. Mirror state is process-local,
+ *   matching `FileSessionStorage`'s existing single-writer assumption — peer
+ *   processes need {@link refresh} to pick up out-of-band writes.
+ * - `writeLineSync` updates the mirror synchronously and queues an async
+ *   upsert that appends the line to the existing row (or inserts it as the
+ *   first chunk). The promise is awaited by `flush()` / `close()` /
+ *   {@link drain}. A SIGKILL between the sync mirror update and the network
+ *   round-trip loses the last line.
+ * - Blobs (image data) and tool artifact files still live on disk via
+ *   `BlobStore` / `ArtifactManager`. Those are out of scope for this storage.
+ */
+export declare class SqlSessionStorage implements SessionStorage {
+    #private;
+    private constructor();
+    /**
+     * Apply the dialect-correct DDL (unless `createTable: false` is set) and
+     * warm the in-memory mirror with every existing row. Must be awaited
+     * before passing the storage into `SessionManager.create()`.
+     */
+    static create(options: SqlSessionStorageOptions): Promise<SqlSessionStorage>;
+    get adapter(): SqlSessionStorageAdapter;
+    get table(): string;
+    /**
+     * Re-load the mirror from the database. Call this from a different
+     * process that took over the table, or after an out-of-band write made
+     * by another agent.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Resolve once every pending background write (issued via `writeTextSync`
+     * or `writer.writeLineSync`) has been acknowledged by the database.
+     * Throws if any background write failed since the last drain. Call on
+     * graceful shutdown to avoid losing the last unflushed line.
+     */
+    drain(): Promise<void>;
+    ensureDirSync(_dir: string): void;
+    existsSync(path: string): boolean;
+    writeTextSync(path: string, content: string): void;
+    readTextSync(path: string): string;
+    statSync(path: string): SessionStorageStat;
+    listFilesSync(dir: string, pattern: string): string[];
+    exists(path: string): Promise<boolean>;
+    readText(path: string): Promise<string>;
+    readTextPrefix(path: string, maxBytes: number): Promise<string>;
+    writeText(path: string, content: string): Promise<void>;
+    rename(src: string, dst: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    deleteSessionWithArtifacts(sessionPath: string): Promise<void>;
+    openWriter(path: string, options?: {
+        flags?: "a" | "w";
+        onError?: (err: Error) => void;
+    }): SessionStorageWriter;
+    _writerClosed(writer: SqlSessionStorageWriter): void;
+    _mirrorAppend(path: string, line: string): {
+        content: string;
+        mtimeMs: number;
+    };
+    _mirrorTruncate(path: string): void;
+    _remoteTruncate(path: string): Promise<void>;
+    /**
+     * Append a chunk to the row at `path`, inserting if the row doesn't
+     * exist yet. Single round-trip via the dialect-specific `upsertAppend`.
+     */
+    _remoteAppend(path: string, line: string, mtimeMs: number): Promise<void>;
+    _attachPending(promise: Promise<void>): void;
+}
+declare class SqlSessionStorageWriter implements SessionStorageWriter {
+    #private;
+    constructor(storage: SqlSessionStorage, path: string, options?: {
+        flags?: "a" | "w";
+        onError?: (err: Error) => void;
+    });
+    writeLineSync(line: string): void;
+    writeLine(line: string): Promise<void>;
+    flush(): Promise<void>;
+    fsync(): Promise<void>;
+    close(): Promise<void>;
+    getError(): Error | undefined;
+}
+export {};

package/examples/sdk/12-redis-sessions.ts

@@ -0,0 +1,54 @@
+/**
+ * Redis-Backed Sessions
+ *
+ * Store session JSONL in Redis (or Valkey) instead of the local filesystem.
+ * Useful when the agent runs in an ephemeral container, behind a load
+ * balancer, or anywhere a shared session store beats per-host disk state.
+ *
+ * The storage substrate is the only thing that changes — every other SDK
+ * surface (extensions, hooks, custom tools, slash commands, branching,
+ * `SessionManager.list`, …) continues to work unmodified.
+ *
+ * Tool artifacts and image blobs are out of scope: `ArtifactManager` /
+ * `BlobStore` keep writing to `~/.omp/agent/...`. Reach for an object store
+ * (S3, R2, GCS) if you need those off-host too.
+ */
+
+import { createAgentSession, RedisSessionStorage, SessionManager } from "@oh-my-pi/pi-coding-agent";
+import { RedisClient } from "bun";
+
+// `bun:redis` picks up `REDIS_URL` / `VALKEY_URL` from the environment, or
+// you can pass an explicit `redis://`/`rediss://` URL.
+const redis = new RedisClient();
+await redis.ping();
+
+// `create()` warms an in-memory mirror with every existing key under the
+// prefix so SessionManager's synchronous lookups (resume, recent sessions,
+// list) work without per-call network round-trips.
+const storage = await RedisSessionStorage.create({
+	client: redis,
+	prefix: "omp:sessions:", // optional, this is the default
+});
+
+const sessionDir = "/sessions/my-project";
+
+// 1) Fresh persistent session, JSONL backed by Redis.
+const { session } = await createAgentSession({
+	sessionManager: SessionManager.create(process.cwd(), sessionDir, storage),
+});
+console.log("New Redis session:", session.sessionFile);
+
+// 2) Continue the most recent session for this `sessionDir`.
+const { session: continued } = await createAgentSession({
+	sessionManager: await SessionManager.continueRecent(process.cwd(), sessionDir, storage),
+});
+console.log("Resumed:", continued.sessionFile);
+
+// 3) List every Redis-backed session under this directory key prefix.
+const sessions = await SessionManager.list(process.cwd(), sessionDir, storage);
+console.log(`Found ${sessions.length} sessions under ${sessionDir}`);
+
+// On graceful shutdown, drain any background writes the writer queued and
+// close the Redis connection so containerized hosts can exit cleanly.
+await storage.drain();
+redis.close();

package/examples/sdk/13-sql-sessions.ts

@@ -0,0 +1,61 @@
+/**
+ * SQL-Backed Sessions (PostgreSQL / MySQL / SQLite)
+ *
+ * Store session JSONL in a SQL database via `bun:sql`. One table, one row
+ * per session file — works against PostgreSQL, MySQL/MariaDB, and SQLite
+ * with the dialect picked automatically from the connection URL.
+ *
+ * Useful when:
+ * - sessions need to be queryable from existing analytics infra (just JOIN
+ *   against the rest of your warehouse);
+ * - a managed Postgres/MySQL instance is already in place and adding Redis
+ *   isn't worth the operational surface;
+ * - you want a single durable file at rest (SQLite) without coding directly
+ *   against `bun:sqlite`.
+ *
+ * Tool artifacts and image blobs are out of scope: `ArtifactManager` /
+ * `BlobStore` keep writing to `~/.omp/agent/...`. Reach for object storage
+ * if you need those off-host too.
+ */
+
+import { createAgentSession, SessionManager, SqlSessionStorage } from "@oh-my-pi/pi-coding-agent";
+import { SQL } from "bun";
+
+// Pick one — Bun.SQL auto-detects the dialect from the URL scheme.
+//
+//   postgres://user:pass@host:5432/db
+//   mysql://user:pass@host:3306/db
+//   sqlite:/absolute/path/to/sessions.sqlite
+//   sqlite::memory:                                // ephemeral
+const client = new SQL(process.env.SESSIONS_DB_URL ?? "sqlite::memory:");
+
+// `create()` runs `CREATE TABLE IF NOT EXISTS` (with the right DDL for the
+// dialect) and warms the in-memory mirror with every existing row.
+const storage = await SqlSessionStorage.create({
+	client,
+	table: "omp_session_files", // optional, this is the default
+	// createTable: false,       // set if migrations are owned elsewhere
+});
+
+const sessionDir = "/sessions/my-project";
+
+// 1) Fresh persistent session, JSONL backed by SQL.
+const { session } = await createAgentSession({
+	sessionManager: SessionManager.create(process.cwd(), sessionDir, storage),
+});
+console.log(`New SQL session (${storage.adapter}):`, session.sessionFile);
+
+// 2) Continue the most recent session for this `sessionDir`.
+const { session: continued } = await createAgentSession({
+	sessionManager: await SessionManager.continueRecent(process.cwd(), sessionDir, storage),
+});
+console.log("Resumed:", continued.sessionFile);
+
+// 3) Enumerate every session row under this directory prefix.
+const sessions = await SessionManager.list(process.cwd(), sessionDir, storage);
+console.log(`Found ${sessions.length} sessions under ${sessionDir}`);
+
+// On graceful shutdown, drain any background writes the writer queued and
+// close the connection.
+await storage.drain();
+await client.end?.();

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "15.5.10",
+	"version": "15.5.11",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,13 +47,13 @@
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@babel/parser": "^7.29.3",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "15.5.10",
-		"@oh-my-pi/omp-stats": "15.5.10",
-		"@oh-my-pi/pi-agent-core": "15.5.10",
-		"@oh-my-pi/pi-ai": "15.5.10",
-		"@oh-my-pi/pi-natives": "15.5.10",
-		"@oh-my-pi/pi-tui": "15.5.10",
-		"@oh-my-pi/pi-utils": "15.5.10",
+		"@oh-my-pi/hashline": "15.5.11",
+		"@oh-my-pi/omp-stats": "15.5.11",
+		"@oh-my-pi/pi-agent-core": "15.5.11",
+		"@oh-my-pi/pi-ai": "15.5.11",
+		"@oh-my-pi/pi-natives": "15.5.11",
+		"@oh-my-pi/pi-tui": "15.5.11",
+		"@oh-my-pi/pi-utils": "15.5.11",
 		"@puppeteer/browsers": "^2.13.0",
 		"@types/turndown": "5.0.6",
 		"@xterm/headless": "^6.0.0",

package/scripts/build-binary.ts

@@ -56,17 +56,22 @@ async function main(): Promise<void> {
 					"../stats/src/sync-worker.ts",
 					"./src/tools/browser/tab-worker-entry.ts",
 					"./src/eval/js/worker-entry.ts",
-					// Legacy pi-* extension compat shims served by `legacy-pi-compat.ts`.
-					// Both are reached only via the computed `TYPEBOX_SHIM_PATH` /
-					// `LEGACY_PI_AI_SHIM_PATH` constants (which `--compile`'s static
-					// analyzer cannot trace), so each shim must be listed here to land
-					// in bunfs alongside the workers above. The bunfs entry path is
-					// `--root`-relative with a `.js` extension, e.g.
-					// `/$bunfs/root/packages/coding-agent/src/extensibility/typebox.js`,
-					// which is what the `isCompiledBinary()` branch in
-					// `legacy-pi-compat.ts` resolves to at runtime.
+					// Legacy pi-* extension compat entrypoints served by
+					// `legacy-pi-compat.ts`. These are reached via computed bunfs paths
+					// (which `--compile`'s static analyzer cannot trace), so each must be
+					// listed here to land in bunfs at
+					// `/$bunfs/root/packages/<pkg>/<entry>.js`. The coding-agent's own
+					// `./src/index.ts` is intentionally NOT listed: bun --compile silently
+					// breaks the CLI entry when the same package's barrel appears as an
+					// extra entrypoint (issue #1474), so legacy `pi-coding-agent` imports
+					// resolve through `legacy-pi-coding-agent-shim.ts` instead.
+					"../agent/src/index.ts",
+					"../natives/native/index.js",
+					"../tui/src/index.ts",
+					"../utils/src/index.ts",
 					"./src/extensibility/typebox.ts",
 					"./src/extensibility/legacy-pi-ai-shim.ts",
+					"./src/extensibility/legacy-pi-coding-agent-shim.ts",
 					"--outfile",
 					"dist/omp",
 				],

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -0,0 +1,15 @@
+/**
+ * Compatibility shim for legacy extensions importing the package root of
+ * `@oh-my-pi/pi-coding-agent` (or one of its aliased scopes like
+ * `@earendil-works/pi-coding-agent` or `@mariozechner/pi-coding-agent`).
+ *
+ * The coding-agent package's own barrel (`./src/index.ts`) cannot be listed
+ * as a `bun --compile` extra entrypoint alongside the CLI entry without
+ * silently breaking the main binary's startup (see issue #1474 follow-up).
+ * Routing legacy plugin imports through this sibling shim sidesteps that
+ * conflict: bun bundles a distinct entry whose path differs from the CLI
+ * entry, while still re-exporting the canonical surface so plugins observe
+ * the same module identity as a direct `@oh-my-pi/pi-coding-agent` import.
+ */
+
+export * from "../index";