@timurproko/a1 0.1.8-dev.290 → 0.1.8-dev.299

package/README.md

@@ -45,6 +45,15 @@ a1 pi                                   # vanilla Pi oracle: ~/.pi/agent
 Unsupported commands exit quietly without launching anything. The removed
 `update:<preview>` forms are not aliases; use `update --develop`.
 
+## Prompt history
+
+Bare A1 recalls recent unique prompts across sessions with Up/Down. History is
+stored in a separate profile-local SQLite database under A1's application-data
+root, not `~/.a1/agent` or disposable caches. `/settings` → History controls
+persistence and the 10-100-entry limit (default 100), effective on next start.
+History is unencrypted user text; images are not reattached. See
+[prompt history](docs/features/prompt-history.md) for privacy, storage, and removal.
+
 ## Extensions
 
 Pi extension packages install into A1's own profile (`~/.a1/agent`), so bare `a1`

package/dist/composition/owned-ui.js

@@ -1,5 +1,6 @@
+import { PromptHistoryService } from "../features/prompt-history/index.js";
 import { resolveProductPaths } from "../foundation/lifecycle/index.js";
-import { applyConfiguredPiTheme, getAvailablePiThemes } from "../integrations/pi/components/index.js";
+import { applyConfiguredPiTheme, getAvailablePiThemes, loadHistoryEditor } from "../integrations/pi/components/index.js";
 import { createPiEngineAdapter, } from "../integrations/pi/engine/index.js";
 import { OwnedUiSessionShell } from "../integrations/pi/session-ui/index.js";
 import { OwnedUiSettingsSession, OwnedUiSettingsStore } from "../ui/settings/index.js";
@@ -42,6 +43,15 @@ export async function composeOwnedUi(options = {}) {
         enabled: () => settings.value("promptSuggestions") !== false,
         onChange: (listener) => settings.onChange(() => listener(settings.value("promptSuggestions") !== false)),
     };
+    const historyLimit = settings?.value("promptHistoryMaxItems");
+    const promptHistory = settings === null || !ownedSurfaces || settings.value("promptHistoryEnabled") === false ? null : {
+        limit: typeof historyLimit === "number" ? historyLimit : 100,
+        store: new PromptHistoryService({
+            dataDir: resolveProductPaths().dataDir,
+            profileRoot: adapter.agentDir,
+            limit: typeof historyLimit === "number" ? historyLimit : 100,
+        }),
+    };
     const shell = new OwnedUiSessionShell({
         backend: adapter,
         cwd: adapter.cwd,
@@ -50,6 +60,7 @@ export async function composeOwnedUi(options = {}) {
         ...(ownedSurfaces ? { sessionLayout: "custom-viewport" } : {}),
         ...(viewportSettings === null ? {} : { viewportSettings }),
         ...(promptSuggestions === null ? {} : { promptSuggestions }),
+        ...(promptHistory === null ? {} : { promptHistory: { ...promptHistory, editor: await loadHistoryEditor() } }),
     });
     const application = {
         get disposed() { return adapter.disposed; },

package/dist/contracts/owned-ui/index.d.ts

@@ -2,4 +2,5 @@ export * from "./extension-ui.js";
 export * from "./model.js";
 export * from "./image-attachments.js";
 export * from "./prompt-suggestions.js";
+export * from "./prompt-history.js";
 export * from "./validation.js";

package/dist/contracts/owned-ui/index.js

@@ -2,4 +2,5 @@ export * from "./extension-ui.js";
 export * from "./model.js";
 export * from "./image-attachments.js";
 export * from "./prompt-suggestions.js";
+export * from "./prompt-history.js";
 export * from "./validation.js";

package/dist/contracts/owned-ui/prompt-history.d.ts

@@ -0,0 +1,37 @@
+export declare const PROMPT_HISTORY_EDITOR_REPLACEMENT: Readonly<{
+    readonly id: "persistent-prompt-history";
+    readonly kind: "replacement";
+    readonly slot: "editor";
+    readonly replaces: readonly string[];
+}>;
+export type PromptHistoryKind = "prompt" | "steer" | "follow-up" | "bash" | "slash";
+export interface PromptHistorySubmission {
+    readonly id: string;
+    readonly text: string;
+    readonly timestamp: number;
+    readonly kind: PromptHistoryKind;
+    readonly cwd?: string;
+    readonly sessionId?: string;
+}
+export interface PromptHistorySnapshot {
+    readonly revision: number;
+    readonly limit: number;
+    readonly entries: readonly {
+        readonly text: string;
+        readonly submissionId: string;
+    }[];
+}
+export type PromptHistoryFailure = "unavailable" | "busy" | "capacity" | "oversized" | "schema" | "corrupt" | "shutdown";
+export type PromptHistoryResult = "committed" | "skipped";
+export interface PromptHistoryPort {
+    start(): void;
+    record(submission: PromptHistorySubmission): Promise<PromptHistoryResult>;
+    refresh(): void;
+    onSnapshot(listener: (snapshot: PromptHistorySnapshot) => void): () => void;
+    onFailure(listener: (code: PromptHistoryFailure) => void): () => void;
+    close(): Promise<void>;
+}
+export declare const PROMPT_HISTORY_MAX_ENTRY_BYTES: number;
+export declare const PROMPT_HISTORY_MAX_TEXT_BYTES: number;
+export declare const PROMPT_HISTORY_MAX_PENDING = 32;
+export declare function assertPromptHistorySubmission(value: unknown): asserts value is PromptHistorySubmission;

package/dist/contracts/owned-ui/prompt-history.js

@@ -0,0 +1,23 @@
+export const PROMPT_HISTORY_EDITOR_REPLACEMENT = Object.freeze({
+    id: "persistent-prompt-history",
+    kind: "replacement",
+    slot: "editor",
+    replaces: Object.freeze(["current-session-history-source", "adjacent-duplicate-policy", "recall-caret-placement", "history-border"]),
+});
+export const PROMPT_HISTORY_MAX_ENTRY_BYTES = 1024 * 1024;
+export const PROMPT_HISTORY_MAX_TEXT_BYTES = 8 * 1024 * 1024;
+export const PROMPT_HISTORY_MAX_PENDING = 32;
+export function assertPromptHistorySubmission(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new TypeError("Invalid history submission");
+    const item = value;
+    const allowed = new Set(["id", "text", "timestamp", "kind", "cwd", "sessionId"]);
+    if (Object.keys(item).some(key => !allowed.has(key))
+        || typeof item.id !== "string" || !/^[a-zA-Z0-9-]{1,128}$/.test(item.id)
+        || typeof item.text !== "string" || !item.text.trim() || item.text !== item.text.trim()
+        || typeof item.timestamp !== "number" || !Number.isSafeInteger(item.timestamp) || item.timestamp < 0
+        || typeof item.kind !== "string" || !["prompt", "steer", "follow-up", "bash", "slash"].includes(item.kind)
+        || item.cwd !== undefined && typeof item.cwd !== "string"
+        || item.sessionId !== undefined && typeof item.sessionId !== "string")
+        throw new TypeError("Invalid history submission");
+}

package/dist/features/prompt-history/index.d.ts

@@ -0,0 +1,2 @@
+export { PromptHistoryService } from "./service.js";
+export { resolvePromptHistoryPath } from "./paths.js";

package/dist/features/prompt-history/index.js

@@ -0,0 +1,2 @@
+export { PromptHistoryService } from "./service.js";
+export { resolvePromptHistoryPath } from "./paths.js";

package/dist/features/prompt-history/paths.d.ts

@@ -0,0 +1,4 @@
+export declare function resolvePromptHistoryPath(dataDir: string, profileRoot: string, platform?: NodeJS.Platform): {
+    path: string;
+    profileId: string;
+};

package/dist/features/prompt-history/paths.js

@@ -0,0 +1,16 @@
+import { createHash } from "node:crypto";
+import { posix, win32 } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+export function resolvePromptHistoryPath(dataDir, profileRoot, platform = process.platform) {
+    const paths = platform === "win32" ? win32 : posix;
+    if (!paths.isAbsolute(dataDir) || !paths.isAbsolute(profileRoot) || dataDir.includes("\0") || profileRoot.includes("\0"))
+        throw new TypeError("History requires absolute roots");
+    let normalized = paths.normalize(profileRoot);
+    if (normalized.length > paths.parse(normalized).root.length)
+        normalized = normalized.replace(/[\\/]+$/, "");
+    if (platform === "win32")
+        normalized = normalized.replaceAll("\\", "/").toLowerCase();
+    const digest = createHash("sha256").update(JSON.stringify([1, PRODUCT_IDENTITY.commandName, normalized])).digest("hex");
+    const profileId = `${PRODUCT_IDENTITY.filesystem.temporaryPrefix}${digest}`;
+    return { path: paths.join(dataDir, "history", `${profileId}.sqlite3`), profileId };
+}

package/dist/features/prompt-history/service.d.ts

@@ -0,0 +1,24 @@
+import type { Worker } from "node:worker_threads";
+import { type PromptHistoryFailure, type PromptHistoryPort, type PromptHistoryResult, type PromptHistorySnapshot, type PromptHistorySubmission } from "../../contracts/owned-ui/index.js";
+/** Owns a finite asynchronous history queue; storage faults never throw into prompt dispatch. */
+export declare class PromptHistoryService implements PromptHistoryPort {
+    #private;
+    readonly options: {
+        dataDir: string;
+        profileRoot: string;
+        limit: number;
+        createWorker?: () => Worker;
+    };
+    constructor(options: {
+        dataDir: string;
+        profileRoot: string;
+        limit: number;
+        createWorker?: () => Worker;
+    });
+    start(): void;
+    record(submission: PromptHistorySubmission): Promise<PromptHistoryResult>;
+    refresh(): void;
+    onSnapshot(listener: (snapshot: PromptHistorySnapshot) => void): () => void;
+    onFailure(listener: (code: PromptHistoryFailure) => void): () => void;
+    close(): Promise<void>;
+}

package/dist/features/prompt-history/service.js

@@ -0,0 +1,260 @@
+import { assertPromptHistorySubmission, PROMPT_HISTORY_MAX_ENTRY_BYTES, PROMPT_HISTORY_MAX_PENDING, PROMPT_HISTORY_MAX_TEXT_BYTES } from "../../contracts/owned-ui/index.js";
+import { resolvePromptHistoryPath } from "./paths.js";
+/** Owns a finite asynchronous history queue; storage faults never throw into prompt dispatch. */
+export class PromptHistoryService {
+    options;
+    #snapshots = new Set();
+    #failures = new Set();
+    #reported = new Set();
+    #queue = [];
+    #worker;
+    #active;
+    #timer;
+    #poll;
+    #sequence = 0;
+    #bytes = 0;
+    #writes = 0;
+    #started = false;
+    #ready = false;
+    #failed = false;
+    #closing = false;
+    #reading = false;
+    #refreshPending = false;
+    #lastRevision = -1;
+    #closePromise;
+    constructor(options) {
+        this.options = options;
+    }
+    start() {
+        if (this.#started || this.#closing)
+            return;
+        this.#started = true;
+        setImmediate(() => { void this.#open().catch(() => this.#fail("unavailable")); });
+    }
+    record(submission) {
+        if (this.#failed || this.#closing)
+            return Promise.resolve("skipped");
+        try {
+            assertPromptHistorySubmission(submission);
+        }
+        catch {
+            this.#report("unavailable");
+            return Promise.resolve("skipped");
+        }
+        const bytes = Buffer.byteLength(submission.text);
+        if (bytes > PROMPT_HISTORY_MAX_ENTRY_BYTES) {
+            this.#report("oversized");
+            return Promise.resolve("skipped");
+        }
+        if (this.#writes >= PROMPT_HISTORY_MAX_PENDING || this.#bytes + bytes > PROMPT_HISTORY_MAX_TEXT_BYTES) {
+            this.#report("capacity");
+            return Promise.resolve("skipped");
+        }
+        const candidate = {
+            id: submission.id, text: submission.text, timestamp: submission.timestamp, kind: submission.kind,
+            ...(submission.cwd !== undefined && Buffer.byteLength(submission.cwd) <= 8192 ? { cwd: submission.cwd } : {}),
+            ...(submission.sessionId !== undefined && Buffer.byteLength(submission.sessionId) <= 256 ? { sessionId: submission.sessionId } : {}),
+        };
+        this.start();
+        this.#writes++;
+        this.#bytes += bytes;
+        return new Promise(resolve => {
+            this.#queue.push({ request: { id: ++this.#sequence, kind: "record", submission: candidate }, done: (_value, ok) => {
+                    this.#writes--;
+                    this.#bytes -= bytes;
+                    resolve(ok ? "committed" : "skipped");
+                    if (ok)
+                        this.refresh();
+                } });
+            this.#drain();
+        });
+    }
+    refresh() {
+        if (this.#closing || this.#failed)
+            return;
+        this.start();
+        if (this.#reading) {
+            this.#refreshPending = true;
+            return;
+        }
+        this.#reading = true;
+        const observers = [...this.#snapshots];
+        this.#queue.push({ request: { id: ++this.#sequence, kind: "read" }, done: (value, ok) => {
+                this.#reading = false;
+                if (ok) {
+                    if (!isSnapshot(value)) {
+                        this.#fail("corrupt");
+                        return;
+                    }
+                    if (value.revision !== this.#lastRevision && observers.some(listener => this.#snapshots.has(listener))) {
+                        this.#lastRevision = value.revision;
+                        for (const listener of observers) {
+                            if (!this.#snapshots.has(listener))
+                                continue;
+                            try {
+                                listener(value);
+                            }
+                            catch { /* Security: observer errors must not escape the worker event handler. */ }
+                        }
+                    }
+                }
+                if (this.#refreshPending) {
+                    this.#refreshPending = false;
+                    this.refresh();
+                }
+            } });
+        this.#drain();
+    }
+    onSnapshot(listener) {
+        this.#snapshots.add(listener);
+        this.#lastRevision = -1;
+        return () => this.#snapshots.delete(listener);
+    }
+    onFailure(listener) {
+        this.#failures.add(listener);
+        return () => this.#failures.delete(listener);
+    }
+    close() {
+        if (this.#closePromise !== undefined)
+            return this.#closePromise;
+        this.#closing = true;
+        if (this.#poll !== undefined)
+            clearInterval(this.#poll);
+        this.#closePromise = new Promise(resolve => {
+            if (!this.#started || this.#failed) {
+                resolve();
+                return;
+            }
+            const deadline = setTimeout(() => { this.#report("shutdown"); this.#fail("shutdown"); resolve(); }, 2000);
+            this.#queue.push({ request: { id: ++this.#sequence, kind: "close" }, done: (_value, ok) => {
+                    if (!ok)
+                        this.#report("shutdown");
+                    const stopped = this.#worker?.terminate() ?? Promise.resolve();
+                    void stopped.catch(() => { }).finally(() => { clearTimeout(deadline); resolve(); });
+                } });
+            this.#drain();
+        });
+        return this.#closePromise;
+    }
+    async #open() {
+        if (this.#failed)
+            return;
+        const { Worker } = await import("node:worker_threads");
+        if (this.#failed)
+            return;
+        const location = resolvePromptHistoryPath(this.options.dataDir, this.options.profileRoot);
+        const source = import.meta.url.endsWith(".ts");
+        const entry = new URL(source ? "./worker.ts" : "./worker.js", import.meta.url);
+        const options = { workerData: { ...location, limit: this.options.limit }, stdout: true, stderr: true };
+        this.#worker = this.options.createWorker?.() ?? (source
+            ? new Worker(`import('tsx/esm/api').then(({ tsImport }) => tsImport(${JSON.stringify(entry.href)}, ${JSON.stringify(import.meta.url)}))`, { ...options, eval: true })
+            : new Worker(entry, options));
+        this.#worker.stdout.resume();
+        this.#worker.stderr.resume();
+        this.#timer = setTimeout(() => this.#fail("unavailable"), 5000);
+        this.#worker.on("message", (message) => {
+            if (this.#failed)
+                return;
+            clearTimeout(this.#timer);
+            if (message === null || typeof message !== "object" || !Number.isSafeInteger(message.id) || typeof message.ok !== "boolean") {
+                this.#fail("unavailable");
+                return;
+            }
+            if (!message.ok) {
+                this.#fail(failureCode(message.code));
+                return;
+            }
+            if (message.id === 0) {
+                this.#ready = true;
+                if (!this.#closing) {
+                    this.refresh();
+                    this.#poll = setInterval(() => this.refresh(), 1000);
+                    this.#poll.unref();
+                }
+            }
+            else {
+                const item = this.#active;
+                if (item?.request.id !== message.id) {
+                    this.#fail("unavailable");
+                    return;
+                }
+                this.#active = undefined;
+                item.done(message.value, true);
+            }
+            this.#drain();
+        });
+        this.#worker.on("error", () => this.#fail("unavailable"));
+        this.#worker.on("exit", () => { if (!this.#closing || this.#active !== undefined || this.#queue.length > 0)
+            this.#fail("unavailable"); });
+    }
+    #drain() {
+        if (!this.#ready || this.#failed || this.#active !== undefined)
+            return;
+        const next = this.#queue.shift();
+        if (next === undefined)
+            return;
+        this.#active = next;
+        this.#timer = setTimeout(() => this.#fail("busy"), 1500);
+        try {
+            this.#worker.postMessage(next.request);
+        }
+        catch {
+            this.#fail("unavailable");
+        }
+    }
+    #report(code) {
+        if (this.#reported.has(code))
+            return;
+        this.#reported.add(code);
+        for (const listener of this.#failures) {
+            try {
+                listener(code);
+            }
+            catch { /* Security: caller exceptions are not persistence diagnostics. */ }
+        }
+    }
+    #fail(code) {
+        if (this.#failed)
+            return;
+        this.#failed = true;
+        clearTimeout(this.#timer);
+        clearInterval(this.#poll);
+        this.#report(code);
+        const active = this.#active;
+        this.#active = undefined;
+        active?.done(undefined, false);
+        for (const item of this.#queue.splice(0))
+            item.done(undefined, false);
+        this.#worker?.unref();
+        void this.#worker?.terminate().catch(() => { });
+    }
+}
+function failureCode(value) {
+    switch (value) {
+        case "busy":
+        case "capacity":
+        case "oversized":
+        case "schema":
+        case "corrupt":
+        case "shutdown": return value;
+        default: return "unavailable";
+    }
+}
+function isSnapshot(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const candidate = value;
+    if (!Number.isSafeInteger(candidate.revision) || candidate.revision < 0 || !Number.isInteger(candidate.limit)
+        || candidate.limit < 10 || candidate.limit > 100 || candidate.limit % 10 !== 0
+        || !Array.isArray(candidate.entries) || candidate.entries.length > candidate.limit)
+        return false;
+    let bytes = 0;
+    return candidate.entries.every(item => {
+        if (typeof item?.text !== "string" || item.text !== item.text.trim()
+            || typeof item.submissionId !== "string" || item.submissionId.length > 128)
+            return false;
+        const size = Buffer.byteLength(item.text);
+        bytes += size;
+        return size > 0 && size <= PROMPT_HISTORY_MAX_ENTRY_BYTES && bytes <= PROMPT_HISTORY_MAX_TEXT_BYTES;
+    });
+}

package/dist/features/prompt-history/store.d.ts

@@ -0,0 +1,15 @@
+import { type PromptHistoryFailure, type PromptHistorySnapshot, type PromptHistorySubmission } from "../../contracts/owned-ui/index.js";
+export declare class HistoryStorageError extends Error {
+    readonly code: PromptHistoryFailure;
+    constructor(code: PromptHistoryFailure);
+}
+export declare class PromptHistoryStore {
+    #private;
+    readonly path: string;
+    readonly profileId: string;
+    constructor(path: string, profileId: string, limit: number);
+    record(input: PromptHistorySubmission): void;
+    snapshot(): PromptHistorySnapshot;
+    close(): void;
+}
+export declare function classifyHistoryError(error: unknown): PromptHistoryFailure;

package/dist/features/prompt-history/store.js

@@ -0,0 +1,166 @@
+import { DatabaseSync } from "node:sqlite";
+import { chmodSync, closeSync, lstatSync, mkdirSync, openSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { assertPromptHistorySubmission, PROMPT_HISTORY_MAX_ENTRY_BYTES, PROMPT_HISTORY_MAX_TEXT_BYTES } from "../../contracts/owned-ui/index.js";
+export class HistoryStorageError extends Error {
+    code;
+    constructor(code) {
+        super(`Prompt history ${code}`);
+        this.code = code;
+    }
+}
+const MAX_STORAGE_BYTES = 64 * 1024 * 1024;
+export class PromptHistoryStore {
+    path;
+    profileId;
+    #database;
+    constructor(path, profileId, limit) {
+        this.path = path;
+        this.profileId = profileId;
+        if (!Number.isInteger(limit) || limit < 10 || limit > 100 || limit % 10 !== 0)
+            throw new HistoryStorageError("schema");
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        if (lstatSync(dirname(path)).isSymbolicLink())
+            throw new HistoryStorageError("unavailable");
+        if (process.platform !== "win32")
+            chmodSync(dirname(path), 0o700);
+        try {
+            closeSync(openSync(path, "wx", 0o600));
+        }
+        catch (error) {
+            if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
+                throw error;
+        }
+        if (lstatSync(path).isSymbolicLink() || !lstatSync(path).isFile())
+            throw new HistoryStorageError("unavailable");
+        if (process.platform !== "win32")
+            chmodSync(path, 0o600);
+        this.#checkSize();
+        this.#database = new DatabaseSync(path);
+        try {
+            this.#database.exec("PRAGMA busy_timeout = 25");
+            this.#transaction(() => {
+                const version = Number(this.#database.prepare("PRAGMA user_version").get()?.user_version);
+                if (version === 0) {
+                    const tables = this.#database.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+                    if (tables.length !== 0)
+                        throw new HistoryStorageError("schema");
+                    this.#database.exec(`CREATE TABLE history_meta (id INTEGER PRIMARY KEY CHECK(id=1), schema TEXT NOT NULL, profile TEXT NOT NULL, revision INTEGER NOT NULL, limit_count INTEGER NOT NULL);
+            CREATE TABLE prompts (text TEXT PRIMARY KEY COLLATE BINARY, submission_id TEXT NOT NULL, sequence INTEGER NOT NULL UNIQUE, timestamp INTEGER NOT NULL, kind TEXT NOT NULL, cwd TEXT, session_id TEXT, bytes INTEGER NOT NULL CHECK(bytes>0 AND bytes<=1048576));
+            PRAGMA user_version=1;`);
+                    this.#database.prepare("INSERT INTO history_meta VALUES (1,?,?,0,?)").run(PRODUCT_IDENTITY.protocol.promptHistorySchema, profileId, limit);
+                }
+                else if (version !== 1)
+                    throw new HistoryStorageError("schema");
+                const meta = this.#database.prepare("SELECT schema,profile FROM history_meta WHERE id=1").get();
+                if (meta?.schema !== PRODUCT_IDENTITY.protocol.promptHistorySchema || meta?.profile !== profileId)
+                    throw new HistoryStorageError("schema");
+                this.#database.prepare("UPDATE history_meta SET limit_count=?,revision=revision+1 WHERE id=1").run(limit);
+                this.#prune(limit);
+            });
+            this.#database.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA wal_autocheckpoint=128; PRAGMA journal_size_limit=8388608; PRAGMA max_page_count=8192;");
+        }
+        catch (error) {
+            this.#database.close();
+            throw error;
+        }
+    }
+    record(input) {
+        assertPromptHistorySubmission(input);
+        const bytes = Buffer.byteLength(input.text);
+        if (bytes > PROMPT_HISTORY_MAX_ENTRY_BYTES)
+            throw new HistoryStorageError("oversized");
+        this.#checkSize(true);
+        this.#transaction(() => {
+            const duplicate = this.#database.prepare("SELECT submission_id FROM prompts WHERE text=?").get(input.text);
+            if (duplicate?.submission_id === input.id)
+                return;
+            this.#database.exec("UPDATE history_meta SET revision=revision+1 WHERE id=1");
+            const meta = this.#database.prepare("SELECT revision,limit_count FROM history_meta WHERE id=1").get();
+            this.#database.prepare(`INSERT INTO prompts VALUES (?,?,?,?,?,?,?,?) ON CONFLICT(text) DO UPDATE SET submission_id=excluded.submission_id,sequence=excluded.sequence,timestamp=excluded.timestamp,kind=excluded.kind,cwd=excluded.cwd,session_id=excluded.session_id,bytes=excluded.bytes`)
+                .run(input.text, input.id, meta.revision, input.timestamp, input.kind, bounded(input.cwd, 8192), bounded(input.sessionId, 256), bytes);
+            this.#prune(Number(meta.limit_count));
+        });
+    }
+    snapshot() {
+        this.#database.exec("BEGIN");
+        try {
+            const meta = this.#database.prepare("SELECT revision,limit_count FROM history_meta WHERE id=1").get();
+            const entries = this.#database.prepare("SELECT text,submission_id FROM prompts ORDER BY sequence DESC LIMIT 100").all();
+            let bytes = 0;
+            const result = entries.map(row => {
+                if (typeof row.text !== "string" || typeof row.submission_id !== "string")
+                    throw new HistoryStorageError("corrupt");
+                bytes += Buffer.byteLength(row.text);
+                if (bytes > PROMPT_HISTORY_MAX_TEXT_BYTES)
+                    throw new HistoryStorageError("corrupt");
+                return { text: row.text, submissionId: row.submission_id };
+            });
+            this.#database.exec("COMMIT");
+            return { revision: Number(meta.revision), limit: Number(meta.limit_count), entries: result };
+        }
+        catch (error) {
+            this.#database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    close() { this.#database.close(); }
+    #transaction(work) {
+        this.#database.exec("BEGIN IMMEDIATE");
+        try {
+            work();
+            this.#database.exec("COMMIT");
+        }
+        catch (error) {
+            this.#database.exec("ROLLBACK");
+            throw error;
+        }
+    }
+    #prune(limit) {
+        const rows = this.#database.prepare("SELECT sequence,bytes FROM prompts ORDER BY sequence DESC").all();
+        let bytes = 0;
+        for (const [index, row] of rows.entries()) {
+            bytes += Number(row.bytes);
+            if (index >= limit || bytes > PROMPT_HISTORY_MAX_TEXT_BYTES)
+                this.#database.prepare("DELETE FROM prompts WHERE sequence=?").run(row.sequence);
+        }
+    }
+    #checkSize(maintain = false) {
+        let size = 0;
+        for (const suffix of ["", "-wal", "-shm"]) {
+            try {
+                if (lstatSync(this.path + suffix).isSymbolicLink())
+                    throw new HistoryStorageError("unavailable");
+                size += statSync(this.path + suffix).size;
+            }
+            catch (error) {
+                if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
+                    throw error;
+            }
+        }
+        if (size > MAX_STORAGE_BYTES && maintain) {
+            this.#database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+            this.#checkSize();
+        }
+        else if (size > MAX_STORAGE_BYTES)
+            throw new HistoryStorageError("capacity");
+    }
+}
+function bounded(value, bytes) {
+    return value !== undefined && Buffer.byteLength(value) <= bytes ? value : null;
+}
+export function classifyHistoryError(error) {
+    if (error instanceof HistoryStorageError)
+        return error.code;
+    if (error instanceof Error && "errcode" in error) {
+        const code = Number(error.errcode) & 0xff;
+        if (code === 5 || code === 6)
+            return "busy";
+        if (code === 11 || code === 26)
+            return "corrupt";
+        if (code === 13)
+            return "capacity";
+    }
+    return "unavailable";
+}

package/dist/features/prompt-history/worker.d.ts

@@ -0,0 +1,9 @@
+import type { PromptHistorySubmission } from "../../contracts/owned-ui/index.js";
+export type HistoryWorkerRequest = {
+    id: number;
+    kind: "read" | "close";
+} | {
+    id: number;
+    kind: "record";
+    submission: PromptHistorySubmission;
+};