@timurproko/a1 0.2.7-dev.746 → 0.2.7-dev.767

package/dist/foundation/release/dependency-certification.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
-import { chmod, lstat, mkdir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+import { chmod, lstat, mkdir, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
 import { immutablePlatformPolicy } from "./immutable-platform.js";
 export const DEPENDENCY_CERTIFICATIONS_DIRECTORY = "dependency-certifications";
@@ -194,7 +194,8 @@ async function releasePublicationLock(path, token) {
     while (true) {
         try {
             if (!retired) {
-                await assertPublicationLockOwner(path, token);
+                if (!await assertPublicationLockOwner(path, token))
+                    return;
                 await rename(path, released);
                 retired = true;
             }
@@ -218,24 +219,58 @@ async function releasePublicationLock(path, token) {
 }
 /** Ownership uncertainty is never authority to retire a missing, linked, or replaced generation. */
 async function assertPublicationLockOwner(path, token) {
-    try {
-        const metadata = await lstat(path);
-        if (!metadata.isDirectory() || metadata.isSymbolicLink() || await realpath(path) !== path)
-            throw new Error("invalid lock directory");
-        const ownerPath = resolve(path, "owner.json");
-        const ownerMetadata = await lstat(ownerPath);
-        if (!ownerMetadata.isFile() || ownerMetadata.isSymbolicLink() || await realpath(ownerPath) !== ownerPath)
-            throw new Error("invalid owner file");
-        const owner = JSON.parse(await readFile(ownerPath, "utf8"));
-        if (!owner || typeof owner !== "object" || !("pid" in owner) || !("token" in owner)
-            || owner.pid !== process.pid || owner.token !== token)
-            throw new Error("owner generation differs");
+    for (let attempt = 1;; attempt += 1) {
+        try {
+            const metadata = await lstat(path);
+            if (!metadata.isDirectory() || metadata.isSymbolicLink() || await realpath(path) !== path)
+                throw new Error("invalid lock directory");
+            const ownerPath = resolve(path, "owner.json");
+            const ownerMetadata = await lstat(ownerPath);
+            if (!ownerMetadata.isFile() || ownerMetadata.isSymbolicLink() || await realpath(ownerPath) !== ownerPath)
+                throw new Error("invalid owner file");
+            const owner = JSON.parse(await readFile(ownerPath, "utf8"));
+            if (!owner || typeof owner !== "object" || !("pid" in owner) || !("token" in owner)
+                || owner.pid !== process.pid || owner.token !== token)
+                throw new Error("owner generation differs");
+            return true;
+        }
+        catch (error) {
+            // Platform: Windows can briefly hide a directory immediately after a successful rename
+            // when independent publishers are contending. Re-read the complete identity; never treat
+            // absence as ownership and never retire a generation whose token differs.
+            if (hasCode(error, "ENOENT") && attempt < 3) {
+                await new Promise(resolvePromise => setTimeout(resolvePromise, 20 * attempt));
+                continue;
+            }
+            // Concurrency: a delayed abandoned-owner reclaimer can move a successor generation after
+            // reading the predecessor. If our exact token is now in a managed tombstone, no active
+            // generation belongs to this release call and returning without mutation is fail-safe.
+            if (hasCode(error, "ENOENT") && await publicationLockWasRetired(path, token))
+                return false;
+            if (isReleaseContention(error))
+                throw error;
+            throw new Error("publication lease release ownership could not be verified", { cause: error });
+        }
     }
-    catch (error) {
-        if (isReleaseContention(error))
-            throw error;
-        throw new Error("publication lease release ownership could not be verified", { cause: error });
+}
+async function publicationLockWasRetired(path, token) {
+    const directory = dirname(path);
+    const prefix = `${basename(path)}.`;
+    const entries = await readdir(directory, { withFileTypes: true });
+    if (entries.length > 256)
+        return false;
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.isSymbolicLink() || !entry.name.startsWith(prefix)
+            || (!entry.name.includes(".abandoned-") && !entry.name.includes(".released-")))
+            continue;
+        const ownerPath = resolve(directory, entry.name, "owner.json");
+        const owner = await readFile(ownerPath, "utf8")
+            .then(source => JSON.parse(source))
+            .catch(() => null);
+        if (owner?.pid === process.pid && owner.token === token)
+            return true;
     }
+    return false;
 }
 function isReleaseContention(error) {
     return ["EPERM", "EACCES", "EBUSY"].some(code => hasCode(error, code));

package/dist/foundation/release/progress-palette.generated.d.ts

@@ -1,5 +1,5 @@
 /**
- * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.1.0
- * (MIT), commit abe508e1b89912adde45528136c3221eb69acdd7. Do not edit directly.
+ * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.2.0
+ * (MIT), commit 06a466935536f8c9bcacb2d5efc0fc021be1bdff. Do not edit directly.
  */
 export declare const SHARED_PROGRESS_ACCENT_ANSI = "\u001B[38;2;167;152;215m";

package/dist/foundation/release/progress-palette.generated.js

@@ -1,5 +1,5 @@
 /**
- * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.1.0
- * (MIT), commit abe508e1b89912adde45528136c3221eb69acdd7. Do not edit directly.
+ * Generated by scripts/pi/sync-progress-palette.ts from @earendil-works/pi-coding-agent 1.2.0
+ * (MIT), commit 06a466935536f8c9bcacb2d5efc0fc021be1bdff. Do not edit directly.
  */
 export const SHARED_PROGRESS_ACCENT_ANSI = "\u001b[38;2;167;152;215m";

package/dist/foundation/resident-tabs/bridge-client.d.ts

@@ -1,4 +1,4 @@
-export type ResidentTabStatus = "starting" | "working" | "idle";
+export type ResidentTabStatus = "starting" | "working" | "idle" | "unresponsive" | "stalled" | "crashed" | "restarting" | "failed";
 export interface TabBridgeCredentials {
     readonly tabId: string;
     readonly token: string;
@@ -20,6 +20,9 @@ export interface TabBridgeOptions {
     readonly startIdentity?: string;
     readonly build?: string;
     readonly connect?: (endpoint: string) => BridgeTransport;
+    readonly heartbeatIntervalMs?: number;
+    readonly setInterval?: (callback: () => void, milliseconds: number) => unknown;
+    readonly clearInterval?: (timer: unknown) => void;
 }
 /** Metadata-only advisory bridge. Terminal input and transcript bytes have no API here. */
 export declare class TabBridgeClient {
@@ -28,9 +31,11 @@ export declare class TabBridgeClient {
     get available(): boolean;
     captureAttachment(): TabAttachment | null;
     start(timeoutMs?: number): Promise<boolean>;
-    status(state: ResidentTabStatus): void;
+    status(state: ResidentTabStatus, degraded?: boolean): void;
+    degraded(degraded: boolean): void;
     session(file: string | null, name: string | null): void;
     requestDetach(origin?: TabAttachment | null, timeoutMs?: number): Promise<boolean>;
+    requestRestart(origin?: TabAttachment | null, timeoutMs?: number): Promise<boolean>;
     close(): void;
 }
 export {};

package/dist/foundation/resident-tabs/bridge-client.js

@@ -6,6 +6,7 @@ export class TabBridgeClient {
     #transport = null;
     #connected = false;
     #available = true;
+    #features = new Set();
     #sequence = 0;
     #request = 0;
     #attachment = null;
@@ -13,6 +14,7 @@ export class TabBridgeClient {
     #retry = null;
     #latestStatus = null;
     #latestSession = null;
+    #heartbeat = null;
     #pending = new Map();
     #startWaiter = null;
     constructor(options) { this.#options = options; }
@@ -53,7 +55,8 @@ export class TabBridgeClient {
             this.#startWaiter = finish;
             transport.once("connect", () => {
                 this.#send("hello", {
-                    role: "bridge", generation: 1, build: this.#options.build ?? "a1", features: ["bridge-status", "bridge-detach"],
+                    role: "bridge", generation: 1, build: this.#options.build ?? "a1",
+                    features: ["bridge-status", "bridge-detach", "bridge-heartbeat", "bridge-restart", "recovery-journal"],
                     token: [...Buffer.from(this.#options.credentials.token, "base64")], tabId: this.#options.credentials.tabId,
                     pid: this.#options.pid ?? process.pid, startIdentity: this.#options.startIdentity ?? `${process.pid}:node`,
                 }, ++this.#request);
@@ -63,31 +66,36 @@ export class TabBridgeClient {
             timer.unref();
         });
     }
-    status(state) {
-        this.#latestStatus = state;
-        this.#send("bridge.status", { seq: ++this.#sequence, state });
+    status(state, degraded = false) {
+        this.#latestStatus = { state, degraded };
+        const recoveryState = state === "unresponsive" || state === "stalled" || state === "crashed" || state === "restarting" || state === "failed";
+        if (recoveryState && !this.#supports("recovery-status"))
+            return;
+        this.#send("bridge.status", {
+            seq: ++this.#sequence,
+            state,
+            ...(degraded && this.#supports("recovery-status") ? { degraded: true } : {}),
+        });
+    }
+    degraded(degraded) {
+        this.status(this.#latestStatus?.state ?? "idle", degraded);
     }
     session(file, name) {
         this.#latestSession = { file, name };
         this.#send("bridge.session", { file, name });
     }
-    async requestDetach(origin = this.captureAttachment(), timeoutMs = 1_000) {
-        if (!this.available || origin === null)
-            return false;
-        const requestId = ++this.#request;
-        const result = new Promise(resolvePromise => this.#pending.set(requestId, resolvePromise));
-        this.#send("bridge.request", { action: "detach", clientId: origin.clientId, controllerRevision: origin.controllerRevision }, requestId);
-        const timeout = new Promise(resolvePromise => {
-            const timer = setTimeout(() => { this.#pending.delete(requestId); resolvePromise(false); }, timeoutMs);
-            timer.unref();
-        });
-        return await Promise.race([result, timeout]);
+    requestDetach(origin = this.captureAttachment(), timeoutMs = 1_000) {
+        return this.#requestAction("detach", origin, timeoutMs);
+    }
+    requestRestart(origin = this.captureAttachment(), timeoutMs = 1_000) {
+        return this.#requestAction("restart", origin, timeoutMs);
     }
     close() {
         this.#closed = true;
         if (this.#retry !== null)
             clearTimeout(this.#retry);
         this.#retry = null;
+        this.#stopHeartbeat();
         const transport = this.#transport;
         this.#transport = null;
         transport?.destroy();
@@ -105,11 +113,15 @@ export class TabBridgeClient {
     }
     #receive(message) {
         if (message.type === "welcome" && message.body["generation"] === 1) {
+            const advertised = message.body["features"];
+            this.#features = new Set(Array.isArray(advertised) ? advertised.filter((feature) => typeof feature === "string") : []);
             this.#connected = true;
             this.#available = true;
             this.#startWaiter?.(true);
+            if (this.#supports("bridge-heartbeat"))
+                this.#startHeartbeat();
             if (this.#latestStatus !== null)
-                this.#send("bridge.status", { seq: ++this.#sequence, state: this.#latestStatus });
+                this.status(this.#latestStatus.state, this.#latestStatus.degraded);
             if (this.#latestSession !== null)
                 this.#send("bridge.session", this.#latestSession);
             return;
@@ -133,10 +145,40 @@ export class TabBridgeClient {
             }
         }
     }
+    async #requestAction(action, origin, timeoutMs) {
+        if (!this.available || origin === null || (action === "restart" && !this.#supports("bridge-restart")))
+            return false;
+        const requestId = ++this.#request;
+        const result = new Promise(resolvePromise => this.#pending.set(requestId, resolvePromise));
+        this.#send("bridge.request", { action, clientId: origin.clientId, controllerRevision: origin.controllerRevision }, requestId);
+        const timeout = new Promise(resolvePromise => {
+            const timer = setTimeout(() => { this.#pending.delete(requestId); resolvePromise(false); }, timeoutMs);
+            timer.unref();
+        });
+        return await Promise.race([result, timeout]);
+    }
+    #startHeartbeat() {
+        if (this.#heartbeat !== null)
+            return;
+        const schedule = this.#options.setInterval ?? ((callback, milliseconds) => setInterval(callback, milliseconds));
+        this.#heartbeat = schedule(() => this.#send("bridge.heartbeat", { seq: ++this.#sequence }), this.#options.heartbeatIntervalMs ?? 5_000);
+        this.#heartbeat.unref?.();
+    }
+    #stopHeartbeat() {
+        if (this.#heartbeat === null)
+            return;
+        (this.#options.clearInterval ?? (timer => clearInterval(timer)))(this.#heartbeat);
+        this.#heartbeat = null;
+    }
+    #supports(feature) {
+        return this.#features.has("crash-recovery") || this.#features.has(feature);
+    }
     #fail(retry = true) {
         const transport = this.#transport;
+        this.#stopHeartbeat();
         this.#available = false;
         this.#connected = false;
+        this.#features.clear();
         this.#attachment = null;
         this.#transport = null;
         transport?.destroy();

package/dist/foundation/resident-tabs/draft-checkpoint.d.ts

@@ -0,0 +1,27 @@
+import { ResidentTabFaultInjection } from "./fault-injection.js";
+export interface DraftCheckpointState {
+    readonly text: string;
+    readonly savedAt: string;
+}
+export interface DraftCheckpointOptions {
+    readonly intervalMs?: number;
+    readonly maximumDirtyMs?: number;
+    readonly faults?: ResidentTabFaultInjection;
+    readonly now?: () => number;
+    readonly onDegraded?: (degraded: boolean) => void;
+    readonly write?: (path: string, text: string) => Promise<void>;
+    readonly move?: (from: string, to: string) => Promise<void>;
+    readonly schedule?: (callback: () => void | Promise<void>, delayMs: number) => unknown;
+    readonly cancel?: (timer: unknown) => void;
+}
+/** Periodic rather than inactivity-debounced: continuous input still checkpoints every interval. */
+export declare class DraftCheckpointer {
+    #private;
+    readonly path: string;
+    constructor(path: string, options?: DraftCheckpointOptions);
+    get degraded(): boolean;
+    change(text: string): void;
+    restore(): Promise<DraftCheckpointState | null>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/foundation/resident-tabs/draft-checkpoint.js

@@ -0,0 +1,145 @@
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { ResidentTabFaultInjection } from "./fault-injection.js";
+/** Periodic rather than inactivity-debounced: continuous input still checkpoints every interval. */
+export class DraftCheckpointer {
+    path;
+    #intervalMs;
+    #maximumDirtyMs;
+    #faults;
+    #now;
+    #onDegraded;
+    #write;
+    #move;
+    #scheduleTimer;
+    #cancelTimer;
+    #text = "";
+    #dirtySince = null;
+    #timer = null;
+    #degradedTimer = null;
+    #writing = null;
+    #closed = false;
+    #degraded = false;
+    constructor(path, options = {}) {
+        this.path = path;
+        this.#intervalMs = options.intervalMs ?? 500;
+        this.#maximumDirtyMs = options.maximumDirtyMs ?? 1_000;
+        this.#faults = options.faults ?? new ResidentTabFaultInjection();
+        this.#now = options.now ?? Date.now;
+        this.#onDegraded = options.onDegraded ?? (() => { });
+        this.#write = options.write ?? (async (target, text) => writeFile(target, text, { encoding: "utf8", mode: 0o600, flag: "wx" }));
+        this.#move = options.move ?? rename;
+        this.#scheduleTimer = options.schedule ?? ((callback, delayMs) => setTimeout(callback, delayMs));
+        this.#cancelTimer = options.cancel ?? (timer => clearTimeout(timer));
+    }
+    get degraded() { return this.#degraded; }
+    change(text) {
+        if (this.#closed)
+            return;
+        this.#text = text;
+        this.#dirtySince ??= this.#now();
+        this.#schedule();
+        this.#armDegradedDeadline();
+    }
+    async restore() {
+        try {
+            const value = JSON.parse(await readFile(this.path, "utf8"));
+            if (typeof value !== "object" || value === null || typeof value.text !== "string"
+                || typeof value.savedAt !== "string")
+                return null;
+            return value;
+        }
+        catch (error) {
+            if (error.code === "ENOENT" || error instanceof SyntaxError)
+                return null;
+            throw error;
+        }
+    }
+    async flush() {
+        if (this.#timer !== null) {
+            this.#cancelTimer(this.#timer);
+            this.#timer = null;
+        }
+        await this.#writing;
+        if (this.#dirtySince !== null)
+            await this.#checkpoint();
+    }
+    async close() {
+        await this.flush();
+        this.#closed = true;
+    }
+    #armDegradedDeadline() {
+        if (this.#degradedTimer !== null || this.#dirtySince === null || this.#closed)
+            return;
+        const delay = Math.max(0, this.#maximumDirtyMs - (this.#now() - this.#dirtySince));
+        this.#degradedTimer = this.#scheduleTimer(() => {
+            this.#degradedTimer = null;
+            if (this.#dirtySince !== null && this.#now() - this.#dirtySince >= this.#maximumDirtyMs) {
+                this.#setDegraded(true);
+            }
+            else if (this.#dirtySince !== null) {
+                this.#armDegradedDeadline();
+            }
+        }, delay);
+    }
+    #clearDegradedDeadline() {
+        if (this.#degradedTimer !== null)
+            this.#cancelTimer(this.#degradedTimer);
+        this.#degradedTimer = null;
+    }
+    #schedule() {
+        if (this.#timer !== null || this.#writing !== null || this.#closed)
+            return;
+        const age = this.#dirtySince === null ? 0 : this.#now() - this.#dirtySince;
+        if (age > this.#maximumDirtyMs)
+            this.#setDegraded(true);
+        this.#timer = this.#scheduleTimer(async () => {
+            this.#timer = null;
+            this.#writing = this.#checkpoint().finally(() => {
+                this.#writing = null;
+                if (this.#dirtySince !== null)
+                    this.#schedule();
+            });
+            await this.#writing.catch(() => undefined);
+        }, this.#intervalMs);
+    }
+    async #checkpoint() {
+        if (this.#dirtySince === null)
+            return;
+        const snapshot = this.#text;
+        const temporary = `${this.path}.tmp-${process.pid}-${randomUUID()}`;
+        try {
+            await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+            if (process.platform !== "win32")
+                await chmod(dirname(this.path), 0o700);
+            this.#faults.at("draft-during-temp-write");
+            await this.#write(temporary, `${JSON.stringify({ text: snapshot, savedAt: new Date(this.#now()).toISOString() })}\n`);
+            this.#faults.at("draft-before-rename");
+            await this.#move(temporary, this.path);
+            this.#faults.at("draft-after-rename");
+            if (process.platform !== "win32")
+                await chmod(this.path, 0o600);
+            if (this.#text === snapshot)
+                this.#dirtySince = null;
+            else
+                this.#dirtySince = this.#now();
+            this.#clearDegradedDeadline();
+            if (this.#dirtySince !== null)
+                this.#armDegradedDeadline();
+            this.#setDegraded(false);
+        }
+        catch (error) {
+            await unlink(temporary).catch(() => undefined);
+            this.#clearDegradedDeadline();
+            this.#setDegraded(true);
+            throw error;
+        }
+    }
+    #setDegraded(value) {
+        if (this.#degraded === value)
+            return;
+        this.#degraded = value;
+        this.#onDegraded(value);
+    }
+}

package/dist/foundation/resident-tabs/ensure-terminal-host.d.ts

@@ -21,6 +21,8 @@ export interface EnsureTerminalHostOptions {
     readonly platform?: NodeJS.Platform;
     readonly architecture?: string;
     readonly timeoutMs?: number;
+    readonly maxConcurrentStarts?: number;
+    readonly unresponsiveRestartSeconds?: number;
     readonly run?: (executable: string, arguments_: readonly string[], environment: NodeJS.ProcessEnv, timeoutMs: number) => Promise<HostCommandResult>;
 }
 export declare function resolveTerminalHostPath(releaseRoot: string, environment?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, architecture?: string): string;

package/dist/foundation/resident-tabs/ensure-terminal-host.js

@@ -42,7 +42,13 @@ export async function ensureTerminalHost(options) {
             return { status: "fallback", reason: "incompatible generation" };
         if (existing?.outcome !== "not-running" && probe.code !== 3)
             return { status: "fallback", reason: classifiedReason(existing?.reason, "host probe failed") };
-        const start = await run(executable, ["server", "--detach", ...common], environment, timeoutMs);
+        const maximum = Math.max(1, Math.min(8, Math.trunc(options.maxConcurrentStarts ?? 2)));
+        const unresponsiveRestartSeconds = Math.max(30, Math.min(600, Math.trunc(options.unresponsiveRestartSeconds ?? 120)));
+        const start = await run(executable, [
+            "server", "--detach", ...common,
+            "--max-concurrent-starts", String(maximum),
+            "--unresponsive-restart-seconds", String(unresponsiveRestartSeconds),
+        ], environment, timeoutMs);
         const started = parseResult(start.stdout);
         if (start.code !== 0)
             return { status: "fallback", reason: classifiedReason(started?.reason, "launch not verified") };

package/dist/foundation/resident-tabs/fault-injection.d.ts

@@ -0,0 +1,8 @@
+export declare const RESIDENT_TAB_FAULT_ENVIRONMENT: readonly ["A1_TABS_FAULT_CRASH_POINT", "A1_TABS_HERMETIC_TEST"];
+export declare function residentTabFaultEnvironment(point: string, hermetic?: boolean): NodeJS.ProcessEnv;
+/** Test-only crash points are inert unless the caller explicitly marks a hermetic process. */
+export declare class ResidentTabFaultInjection {
+    #private;
+    constructor(environment?: NodeJS.ProcessEnv, crash?: (point: string) => never);
+    at(point: string): void;
+}

package/dist/foundation/resident-tabs/fault-injection.js

@@ -0,0 +1,26 @@
+const CRASH_POINT = "A1_TABS_FAULT_CRASH_POINT";
+const HERMETIC = "A1_TABS_HERMETIC_TEST";
+export const RESIDENT_TAB_FAULT_ENVIRONMENT = Object.freeze([CRASH_POINT, HERMETIC]);
+export function residentTabFaultEnvironment(point, hermetic = true) {
+    return Object.fromEntries(hermetic ? [[CRASH_POINT, point], [HERMETIC, "1"]] : [[CRASH_POINT, point]]);
+}
+/** Test-only crash points are inert unless the caller explicitly marks a hermetic process. */
+export class ResidentTabFaultInjection {
+    #point;
+    #crash;
+    constructor(environment = process.env, crash = point => {
+        process.stderr.write(`resident tab injected crash: ${point}\n`);
+        process.abort();
+    }) {
+        const point = environment[CRASH_POINT];
+        if (point !== undefined && environment[HERMETIC] !== "1") {
+            throw new Error(`${CRASH_POINT} is available only in a hermetic resident-tab test`);
+        }
+        this.#point = point;
+        this.#crash = crash;
+    }
+    at(point) {
+        if (this.#point === point)
+            this.#crash(point);
+    }
+}

package/dist/foundation/resident-tabs/index.d.ts

@@ -1,5 +1,6 @@
 export { ensureTerminalHost, resolveTerminalHostPath } from "./ensure-terminal-host.js";
 export type { EnsureTerminalHostOptions, EnsureTerminalHostResult, TerminalHostFallbackReason } from "./ensure-terminal-host.js";
-export { readResidentTabsSetting } from "./settings.js";
+export { readResidentTabLaunchSettings, readResidentTabsSetting } from "./settings.js";
+export type { ResidentTabLaunchSettings } from "./settings.js";
 export { selectResidentHost } from "./routing.js";
 export type { ResidentHostSelectionOptions } from "./routing.js";

package/dist/foundation/resident-tabs/index.js

@@ -1,3 +1,3 @@
 export { ensureTerminalHost, resolveTerminalHostPath } from "./ensure-terminal-host.js";
-export { readResidentTabsSetting } from "./settings.js";
+export { readResidentTabLaunchSettings, readResidentTabsSetting } from "./settings.js";
 export { selectResidentHost } from "./routing.js";

package/dist/foundation/resident-tabs/prompt-journal.d.ts

@@ -0,0 +1,65 @@
+import { ResidentTabFaultInjection } from "./fault-injection.js";
+export interface SubmittedPromptRecord {
+    readonly type: "submitted";
+    readonly id: string;
+    readonly sessionId: string;
+    readonly sessionFile: string | null;
+    readonly incarnation: number;
+    readonly fileExisted: boolean;
+    readonly kind: "prompt" | "steer" | "follow-up";
+    readonly text: string;
+    readonly images?: readonly unknown[];
+    readonly at: string;
+}
+export interface CorrelatedPromptRecord {
+    readonly type: "correlated";
+    readonly id: string;
+    readonly entryId: string;
+}
+export interface SettledPromptRecord {
+    readonly type: "settled";
+    readonly id: string;
+    readonly entryId: string;
+}
+export interface RetiredPromptRecord {
+    readonly type: "retired";
+    readonly id: string;
+}
+export type PromptJournalRecord = SubmittedPromptRecord | CorrelatedPromptRecord | SettledPromptRecord | RetiredPromptRecord;
+export interface PromptSubmission {
+    readonly sessionId: string;
+    readonly sessionFile: string | null;
+    readonly incarnation: number;
+    readonly fileExisted: boolean;
+    readonly kind: SubmittedPromptRecord["kind"];
+    readonly text: string;
+    readonly images?: readonly unknown[];
+}
+export interface SessionJournalEntry {
+    readonly entryId: string;
+    readonly text: string;
+    readonly settled: boolean;
+}
+export interface PendingPrompt {
+    readonly submitted: SubmittedPromptRecord;
+    readonly correlatedEntryId?: string;
+}
+export declare class PromptJournal {
+    #private;
+    readonly path: string;
+    constructor(path: string, options?: {
+        readonly faults?: ResidentTabFaultInjection;
+        readonly maximumBytes?: number;
+    });
+    initialize(): Promise<void>;
+    submit(submission: PromptSubmission): Promise<SubmittedPromptRecord>;
+    adopt(record: SubmittedPromptRecord): Promise<boolean>;
+    correlate(id: string, entryId: string): Promise<void>;
+    settle(id: string, entryId: string): Promise<void>;
+    retire(id: string): Promise<void>;
+    read(): Promise<readonly PromptJournalRecord[]>;
+    pending(sessionEntries?: readonly SessionJournalEntry[]): Promise<readonly PendingPrompt[]>;
+    compactIfRetired(): Promise<boolean>;
+}
+export declare function classifyMissingSession(record: SubmittedPromptRecord, sessionExists: boolean): "available" | "first-turn" | "missing-transcript";
+export declare function removeJournalTemporary(path: string): Promise<void>;