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

package/README.md

@@ -45,6 +45,27 @@ 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 suggestions
+
+Bare A1's `/settings` → Agent → Prompt suggestions controls faint next-prompt
+predictions. It is enabled by default and uses one additional background request
+with the selected model for eligible turns. Disabling it takes effect immediately.
+Tab accepts a suggestion as editable text; Enter submits it afterward. The setting
+remains stored in A1's profile, and `a1 pi` is unchanged.
+
+## Prompt history
+
+Bare A1 recalls recent unique prompts across sessions with Up/Down. History is
+stored in a separate profile-local SQLite database at
+`~/.a1/data/history/<profile-id>.sqlite3`, or under `<A1_DATA_DIR>/history` when
+explicitly overridden. Other application data stays in its existing location.
+`/settings` → History controls persistence and the 10-100-entry limit (default
+100), effective on next start. The new default starts fresh: old platform history
+is neither imported nor automatically deleted. Ordinary upgrades and npm
+uninstall/reinstall preserve saved history. 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/bin/guardian.js

@@ -3,13 +3,14 @@
 const startup = await import("../dist/foundation/startup/index.js");
 startup.enableEnvironmentCompileCache(process.env);
 await startup.markStartupPhase(process.env, "guardian-start");
-const { fileURLToPath } = await import("node:url");
 const { resolve } = await import("node:path");
 const { parseSessionSelection } = await import("../dist/foundation/lifecycle/index.js");
 const { runLaunchGuardian } = await import("../dist/foundation/launch-guardian/index.js");
 
-const releaseRoot = process.env.A1_RELEASE_ROOT ?? fileURLToPath(new URL("..", import.meta.url));
-const profileId = process.env.A1_LAUNCH_PROFILE ?? "a1";
+const { readLaunchContext } = await import("../dist/foundation/launch-context/index.js");
+const launchContext = readLaunchContext(process.env, "release");
+const releaseRoot = launchContext.releaseRoot;
+const profileId = readLaunchContext(process.env, "profile").launchProfile;
 
 Promise.resolve().then(() => runLaunchGuardian({
   sessionSelection: parseSessionSelection(process.argv.slice(2)),

package/bin/ui.js

@@ -2,14 +2,16 @@
 
 const startup = await import("../dist/foundation/startup/index.js");
 startup.enableEnvironmentCompileCache(process.env);
-const profile = process.env.A1_LAUNCH_PROFILE ?? "a1";
+const { readLaunchContext } = await import("../dist/foundation/launch-context/index.js");
+const launchContext = readLaunchContext(process.env, "profile");
+const profile = launchContext.launchProfile;
 const { installFatalExit } = await import("../dist/foundation/terminal-cleanup/index.js");
 const { resolveProductPaths } = await import("../dist/foundation/lifecycle/index.js");
 const { join } = await import("node:path");
 let runningApplication;
 const fatal = profile === "a1" ? installFatalExit({
   directory: join(resolveProductPaths().runtimeDir, "crashes"),
-  releaseId: process.env.A1_RELEASE_ID,
+  releaseId: launchContext.releaseId,
   dispose: () => runningApplication?.dispose(),
 }) : undefined;
 // Performance: begin the exact launch graph together while the trace write is pending.

package/bin/update-recovery.js

@@ -140,6 +140,7 @@ async function runRecoveredCommand(value, arguments_) {
 
 async function readCapsule(path) {
   const value = JSON.parse(await readFile(path, "utf8"));
+  if (value.launchContract !== "neutral-launch-v1") throw new Error("Unsupported private recovery contract; stop existing processes and install directly with npm. Preserve settings, sessions, and history.");
   if (value.schema !== SCHEMA || typeof value.transactionId !== "string" || typeof value.packageName !== "string"
     || typeof value.packageName !== "string" || !value.packageName.includes("/") || typeof value.targetVersion !== "string" || typeof value.packageRoot !== "string" || typeof value.globalRoot !== "string"
     || typeof value.launcherRoot !== "string" || !Array.isArray(value.launchers) || typeof value.priorReleaseId !== "string" || typeof value.priorReleaseRoot !== "string"
@@ -178,6 +179,7 @@ async function readCapsule(path) {
   assertDirectChild(releasesRoot, priorReleaseRoot);
   if (priorReleaseRoot.split(sep).at(-1) !== value.priorReleaseId) throw new Error("A1 update recovery prior release identity is invalid");
   const priorManifest = JSON.parse(await readFile(resolve(priorReleaseRoot, value.releaseManifestName), "utf8"));
+  if (priorManifest.launchContract !== "neutral-launch-v1") throw new Error("Unsupported prior private launch contract; manual cutover is required.");
   if (priorManifest.releaseId !== value.priorReleaseId || priorManifest.contentDigest !== value.priorContentDigest) {
     throw new Error("A1 update recovery prior release manifest is invalid");
   }
@@ -190,7 +192,7 @@ async function installedTargetEntry(value) {
   try {
     const manifest = JSON.parse(await readFile(resolve(value.packageRoot, "package.json"), "utf8"));
     const entry = resolve(value.packageRoot, "bin", "cli.js");
-    if (manifest.name !== value.packageName || manifest.version !== value.targetVersion || !(await lstat(entry)).isFile()) return null;
+    if (manifest.privateLaunchContract !== "neutral-launch-v1" || manifest.name !== value.packageName || manifest.version !== value.targetVersion || !(await lstat(entry)).isFile()) return null;
     return entry;
   } catch { return null; }
 }

package/dist/composition/owned-ui.js

@@ -1,5 +1,7 @@
+import { PromptHistoryService } from "../features/prompt-history/index.js";
+import { resolvePromptHistoryDataDir } from "../features/launch/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 +44,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: resolvePromptHistoryDataDir(),
+            profileRoot: adapter.agentDir,
+            limit: typeof historyLimit === "number" ? historyLimit : 100,
+        }),
+    };
     const shell = new OwnedUiSessionShell({
         backend: adapter,
         cwd: adapter.cwd,
@@ -50,6 +61,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/launch/profile-paths.d.ts

@@ -11,4 +11,6 @@ export interface LaunchProfilePathOptions {
     readonly platform?: NodeJS.Platform;
 }
 export declare function resolveLaunchProfilePaths(options?: LaunchProfilePathOptions): LaunchProfilePaths;
+/** Select history storage without relocating control state or probing former stores. */
+export declare function resolvePromptHistoryDataDir(options?: LaunchProfilePathOptions): string;
 export declare function configurationRootForProfile(profileId: LaunchProfileId, paths: LaunchProfilePaths): string | null;

package/dist/features/launch/profile-paths.js

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import { posix, win32 } from "node:path";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { resolveProductPaths } from "../../foundation/lifecycle/index.js";
 export function resolveLaunchProfilePaths(options = {}) {
     const environment = options.environment ?? process.env;
     const path = options.platform === "win32" || (options.platform === undefined && process.platform === "win32") ? win32 : posix;
@@ -13,6 +14,16 @@ export function resolveLaunchProfilePaths(options = {}) {
         agentProfile,
     });
 }
+/** Select history storage without relocating control state or probing former stores. */
+export function resolvePromptHistoryDataDir(options = {}) {
+    const environment = options.environment ?? process.env;
+    const platform = options.platform ?? process.platform;
+    if (environment[PRODUCT_IDENTITY.environment.dataDir] !== undefined) {
+        return resolveProductPaths(environment, platform).dataDir;
+    }
+    const path = platform === "win32" ? win32 : posix;
+    return path.join(resolveLaunchProfilePaths(options).managedStateRoot, "data");
+}
 export function configurationRootForProfile(profileId, paths) {
     return profileId === "a1" ? paths.agentProfile : null;
 }

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;