@fungi.computer/truffle 0.4.0 → 0.5.0

package/dist/local-extensions.js

@@ -37,6 +37,11 @@ const manifestSchema = z.strictObject({
         id: identifier.max(64),
         name: z.string().trim().min(1).max(64),
         description: z.string().max(200).default(""),
+        /** A shell key that opens this program beside the focused pane. */
+        binding: z
+            .string()
+            .regex(/^<leader>[a-z]$/u)
+            .optional(),
         /** Package-relative executable and its arguments. */
         command: z
             .array(z.string().min(1).max(1_024))
@@ -60,6 +65,7 @@ const terminalRecord = z.strictObject({
     id: z.string(),
     name: z.string(),
     description: z.string(),
+    binding: z.string().optional(),
     command: z.array(z.string()),
 });
 const revisionRecord = z.strictObject({
@@ -614,8 +620,8 @@ export function localExtensions(options) {
                 if (record.client !== null)
                     clients.push(record.client);
                 const runtime = await runtimeDirectory(project, id);
-                for (const terminal of record.terminals)
-                    terminals.push({
+                for (const terminal of record.terminals) {
+                    const launcher = {
                         extensionId: id,
                         terminalId: terminal.id,
                         name: terminal.name,
@@ -630,7 +636,11 @@ export function localExtensions(options) {
                             FUNGI_PROJECT_ROOT: project,
                             FUNGI_EXTENSION_RUNTIME_DIR: runtime,
                         },
-                    });
+                    };
+                    terminals.push(terminal.binding === undefined
+                        ? launcher
+                        : { ...launcher, binding: terminal.binding });
+                }
             }
             return { clients, terminals, diagnostics };
         },

package/dist/local-login.js

@@ -1,3 +1,4 @@
+import { interactionTitleLimit } from "@fungi.computer/whistle/wire";
 /** Display order for popular model providers; labels remain owned by Pi. */
 export const localPopularProviderIds = Object.freeze([
     "fungi",
@@ -54,13 +55,32 @@ function notice(event) {
             return { type: "progress", message: event.message };
     }
 }
+/**
+ * Pi's prompt text is provider wording, not a modal title: Whistle titles are
+ * at most `interactionTitleLimit` characters, and Pi 1.3's Anthropic paste
+ * prompt is longer. A message that fits stays the title; a longer one keeps
+ * every word as the summary under Fungi's fixed title for that prompt kind,
+ * so a provider sentence can never make the dialog refuse to open.
+ */
+function modalText(message, fallbackTitle, hint) {
+    const fits = message.trim() !== "" && message.length <= interactionTitleLimit;
+    const lines = [
+        ...(fits ? [] : [message]),
+        ...(hint === undefined ? [] : [hint]),
+    ];
+    const title = fits ? message : fallbackTitle;
+    return lines.length === 0
+        ? { message: title }
+        : { message: title, summary: lines.join(" ") };
+}
+const placeholderOf = (placeholder) => placeholder === undefined ? {} : { placeholder };
 async function ask(interaction, prompt) {
     const options = prompt.signal === undefined ? {} : { signal: prompt.signal };
     switch (prompt.type) {
         case "select":
             return interaction.prompt({
                 type: "choice",
-                message: prompt.message,
+                ...modalText(prompt.message, "Choose a sign-in option"),
                 options: prompt.options.map((option) => option.description === undefined
                     ? { value: option.id, label: option.label }
                     : {
@@ -69,36 +89,24 @@ async function ask(interaction, prompt) {
                         description: option.description,
                     }),
             }, options);
-        case "manual_code": {
+        case "manual_code":
             // Generic across every provider that falls back to a pasted code or
             // redirect URL (OpenAI, Anthropic): the provider's own
             // message explains what to paste; this adds the SSH hint once, here,
             // instead of baking it into one provider's registry label.
-            const summary = "Connecting over SSH? Paste the URL here instead of opening a browser.";
-            const { message } = prompt;
-            return interaction.prompt(prompt.placeholder === undefined
-                ? { type: "text", message, summary }
-                : {
-                    type: "text",
-                    message,
-                    summary,
-                    placeholder: prompt.placeholder,
-                }, options);
-        }
+            return interaction.prompt({
+                type: "text",
+                ...modalText(prompt.message, "Paste the sign-in code or redirect URL", "Connecting over SSH? Paste the URL here instead of opening a browser."),
+                ...placeholderOf(prompt.placeholder),
+            }, options);
         case "secret":
         case "text":
-            return interaction.prompt(prompt.placeholder === undefined
-                ? {
-                    type: "text",
-                    message: prompt.message,
-                    secret: prompt.type === "secret",
-                }
-                : {
-                    type: "text",
-                    message: prompt.message,
-                    placeholder: prompt.placeholder,
-                    secret: prompt.type === "secret",
-                }, options);
+            return interaction.prompt({
+                type: "text",
+                ...modalText(prompt.message, prompt.type === "secret" ? "Enter your key" : "Enter a value"),
+                ...placeholderOf(prompt.placeholder),
+                secret: prompt.type === "secret",
+            }, options);
     }
 }
 const methodNotOffered = "The provider did not offer that sign-in method";

package/dist/private-local-agent-control.d.ts

@@ -36,11 +36,13 @@ export type LocalArchiveRequest = Readonly<{
  * creating Agent, so the directory owner can hold the created Agent to what
  * the creator holds; its archive names who archives.
  */
-export type LocalAgentControlDirectory = Omit<AgentControlDirectory, "create" | "list" | "archive" | "unarchive"> & Readonly<{
+export type LocalAgentControlDirectory = Omit<AgentControlDirectory, "create" | "list" | "archive" | "unarchive" | "answer" | "escalate"> & Readonly<{
     list: (signal: AbortSignal, options?: Readonly<{
         archived?: boolean;
     }>) => Promise<readonly LocalAgentControlAgent[]>;
     create: (input: LocalCreateRequest, signal: AbortSignal) => Promise<AgentControlAgent>;
+    answer: (input: Parameters<NonNullable<AgentControlDirectory["answer"]>>[0], senderAgentId: string, senderSessionId: string, signal: AbortSignal) => ReturnType<NonNullable<AgentControlDirectory["answer"]>>;
+    escalate: (input: Parameters<NonNullable<AgentControlDirectory["escalate"]>>[0], senderAgentId: string, senderSessionId: string, signal: AbortSignal) => ReturnType<NonNullable<AgentControlDirectory["escalate"]>>;
     archive: (input: LocalArchiveRequest, signal: AbortSignal) => Promise<void>;
     unarchive: (input: LocalArchiveRequest, signal: AbortSignal) => Promise<void>;
 }>;
@@ -75,6 +77,8 @@ export declare function createPrivateLocalAgentControl(input: Readonly<{
         }>) => Promise<readonly AgentControlAgent[]>;
         send?: (input: import("@fungi.computer/shiitake/agent-control").AgentDelegationInput, sourceSessionId: string, signal: AbortSignal, invocation?: import("@fungi.computer/shiitake/agent-control").AgentDelegationInvocation) => Promise<import("@fungi.computer/shiitake").Accepted | import("@fungi.computer/shiitake").Held>;
         recall?: (input: import("@fungi.computer/shiitake/agent-control").AgentRecallInput, sourceSessionId: string, signal: AbortSignal) => Promise<import("@fungi.computer/shiitake").CancelResult>;
+        answer?: (input: import("@fungi.computer/shiitake/agent-control").AgentControlAnswerInput, senderSessionId: string, signal: AbortSignal) => Promise<import("@fungi.computer/shiitake/agent-control").AgentControlAnswerOutput>;
+        escalate?: (input: import("@fungi.computer/shiitake/agent-control").AgentControlEscalateInput, senderSessionId: string, signal: AbortSignal) => Promise<import("@fungi.computer/shiitake/agent-control").AgentControlEscalateOutput>;
         create?: (input: Readonly<{
             requestId: string;
             name?: string;

package/dist/private-local-agent-control.js

@@ -8,7 +8,7 @@ import { createConversationAgents } from "@fungi.computer/shiitake-extensions/ro
 export function createPrivateLocalAgentControl(input) {
     const conversations = createConversationAgents(input.storage);
     function bound(parentSessionId) {
-        const { create, archive, unarchive } = input.directory;
+        const { create, archive, unarchive, answer, escalate } = input.directory;
         const by = { kind: "agent", agentId: input.agentId };
         return {
             ...input.directory,
@@ -23,6 +23,16 @@ export function createPrivateLocalAgentControl(input) {
                     createdBySessionId: parentSessionId,
                 }, signal);
             },
+            answer: (request, sourceSessionId, signal) => parentSessionId === undefined
+                ? Promise.resolve({ status: "refused", reason: "no_provenance" })
+                : sourceSessionId !== parentSessionId
+                    ? Promise.resolve({ status: "refused", reason: "not_sender" })
+                    : answer(request, input.agentId, parentSessionId, signal),
+            escalate: (request, sourceSessionId, signal) => parentSessionId === undefined
+                ? Promise.resolve({ status: "refused", reason: "no_provenance" })
+                : sourceSessionId !== parentSessionId
+                    ? Promise.resolve({ status: "refused", reason: "not_sender" })
+                    : escalate(request, input.agentId, parentSessionId, signal),
         };
     }
     const control = conversations.control(bound);

package/dist/private-local-auth-rpc.d.ts

@@ -87,8 +87,13 @@ declare const wireResultSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.
         category: z.ZodLiteral<"cancelled">;
     }, z.core.$strict>, z.ZodObject<{
         category: z.ZodLiteral<"no-key-entered">;
+    }, z.core.$strict>, z.ZodObject<{
+        category: z.ZodLiteral<"prompt-failed">;
+    }, z.core.$strict>, z.ZodObject<{
+        category: z.ZodLiteral<"missing-authorization-code">;
     }, z.core.$strict>, z.ZodObject<{
         category: z.ZodLiteral<"unknown">;
+        errorName: z.ZodString;
     }, z.core.$strict>], "category">;
 }, z.core.$strict>]>;
 declare class AuthPromptTarget extends RpcTarget {

package/dist/private-local-auth-rpc.js

@@ -80,6 +80,24 @@ const eventSchema = z.discriminatedUnion("type", [
     }),
 ]);
 const answerSchema = z.string().max(localAuthInputLimit);
+const errorNameSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/u);
+/** A class name only: anything else (or a non-Error) is named generically. */
+function errorNameOf(cause) {
+    if (!(cause instanceof Error))
+        return "NonError";
+    const name = errorNameSchema.safeParse(cause.name);
+    return name.success ? name.data : "Error";
+}
+/**
+ * The person's own dialog could not show or answer a provider question (for
+ * example the prompt failed the renderer's contract). Fixed text, no cause.
+ */
+class LocalAuthPromptFailed extends Error {
+    constructor() {
+        super("Authentication prompt failed");
+        this.name = "LocalAuthPromptFailed";
+    }
+}
 /**
  * The closed set of failures that cross the service. Provider errors can
  * contain credential material, so no free text, cause or provider message
@@ -98,7 +116,13 @@ const localAuthFailureSchema = z.discriminatedUnion("category", [
     }),
     z.strictObject({ category: z.literal("cancelled") }),
     z.strictObject({ category: z.literal("no-key-entered") }),
-    z.strictObject({ category: z.literal("unknown") }),
+    z.strictObject({ category: z.literal("prompt-failed") }),
+    z.strictObject({ category: z.literal("missing-authorization-code") }),
+    z.strictObject({
+        category: z.literal("unknown"),
+        /** The thrown value's class name only, e.g. `TypeError`; never its message. */
+        errorName: errorNameSchema,
+    }),
 ]);
 const wireResultSchema = z.union([
     authResultSchema,
@@ -110,6 +134,7 @@ const wireResultSchema = z.union([
 /** Pi 1.3.0's fixed error prefixes; never retain a provider body suffix. */
 const callbackPortInUse = /^Port \d+ is in use\b/u;
 const oauthStateMismatch = "OAuth state mismatch";
+const missingAuthorizationCode = "Missing authorization code";
 const openAITokenRequestFailed = /^OpenAI OAuth token request failed \(([1-5]\d{2})\)/u;
 function classifyFailure(cause, aborted) {
     if (aborted)
@@ -133,7 +158,14 @@ function classifyFailure(cause, aborted) {
         return { category: "callback-port-in-use" };
     if (cause instanceof Error && cause.message === oauthStateMismatch)
         return { category: "oauth-state-mismatch" };
-    return { category: "unknown" };
+    if (cause instanceof LocalAuthPromptFailed)
+        return { category: "prompt-failed" };
+    if (cause instanceof Error && cause.message === missingAuthorizationCode)
+        return { category: "missing-authorization-code" };
+    return {
+        category: "unknown",
+        errorName: errorNameOf(cause),
+    };
 }
 /** Fixed wording per category; the dialog shows exactly this. */
 function failureText(failure) {
@@ -164,8 +196,12 @@ function failureText(failure) {
             return "Authentication cancelled";
         case "no-key-entered":
             return new LocalAuthRefusal().message;
+        case "prompt-failed":
+            return "The sign-in dialog could not show the provider's question (prompt-failed). Nothing was saved.";
+        case "missing-authorization-code":
+            return "No authorization code was found in what was pasted. Paste the code or the full redirect URL.";
         case "unknown":
-            return "Local authentication failed";
+            return `Local authentication failed (unknown: ${failure.errorName}). Nothing was saved.`;
     }
 }
 /** The client-side error for one typed failure; its message is fixed text. */
@@ -333,7 +369,13 @@ export class PrivateLocalAuthTarget extends RpcTarget {
                         try {
                             if (promptSignal.aborted)
                                 cancel();
-                            return answerSchema.parse(await pending.result());
+                            const answer = await pending.result().then((value) => ({ value }), (cause) => ({ cause }));
+                            if ("cause" in answer) {
+                                promptSignal.throwIfAborted();
+                                // The presenter's error text is not trusted to be secret-free.
+                                throw new LocalAuthPromptFailed();
+                            }
+                            return answerSchema.parse(answer.value);
                         }
                         finally {
                             promptSignal.removeEventListener("abort", cancel);

package/dist/private-local-client-version.js

@@ -5,7 +5,9 @@ import { basename, dirname, join } from "node:path";
 import { promisify } from "node:util";
 import { z } from "zod";
 const execute = promisify(execFile);
-const queryOptions = { timeout: 2_000, maxBuffer: 4_096 };
+// A compiled launcher cold-starts a Bun process; 2s sat at twice its quiet-box
+// time and killed the query on a loaded box.
+const queryOptions = { timeout: 10_000, maxBuffer: 4_096 };
 const buildId = z.string().regex(/^[a-f0-9]{64}$/u);
 function installedLauncherOnPath() {
     return new Promise((resolve, reject) => {

package/dist/private-local-delegation.d.ts

@@ -28,9 +28,27 @@ export declare function createPrivateLocalDelegation(input: Readonly<{
         name: string;
     }[] | undefined>) | undefined;
     accept: (mail: BirdDogMail, meta?: BirdDogMail["meta"], reply?: VerifiedAgentReply) => Promise<Accepted>;
+    /**
+     * What happens to items a child left waiting on this Agent when the work
+     * that was told about them ends. Without it a host leaves them to expire.
+     */
+    unattended?: Readonly<{
+        /** Exact settled facts of one command of this Agent's own Sessions. */
+        readSettlement: (sessionId: string, commandId: string) => Promise<CommandSettlement | undefined>;
+        /**
+         * Pass one child item on to a person, as this Agent's Session that was
+         * told about it. A child that already moved on answers that and nothing changes.
+         */
+        escalate: (item: Readonly<{
+            agentId: string;
+            sessionId: string;
+            itemId: string;
+        }>, receiverSessionId: string) => Promise<void>;
+    }>;
 }>): {
     send: (task: AgentDelegationInput, sourceSessionId: string, signal: AbortSignal, invocation?: AgentDelegationInvocation) => Promise<DelegationReceipt>;
     recall: (task: AgentRecallInput, sourceSessionId: string, signal: AbortSignal) => Promise<CancelResult>;
     receive: (mail: BirdDogMail) => Promise<Accepted>;
+    close: () => Promise<void>;
     outstanding: () => Promise<import("@fungi.computer/shiitake/fleet").OutstandingDelegation | undefined>;
 };

package/dist/private-local-delegation.js

@@ -1,3 +1,4 @@
+import * as Effect from "effect/Effect";
 import { AgentArchiveRefused } from "@fungi.computer/shiitake/agent-control";
 import { agentDelegationRequestKey, createFleetDelegation, delegationProvenance, delegationReplyMeta, delegationSendMeta, } from "@fungi.computer/shiitake/fleet";
 /** How long one Local delegation grant stays valid while it is admitted. */
@@ -31,7 +32,67 @@ export function createPrivateLocalDelegation(input) {
         }
         return agents;
     }
-    /** Send with one caller-owned identity; follow-up replies return here. */
+    /**
+     * Items a child left waiting on this Agent, by the reply command that told
+     * it. When the work that carried the reply ends, whatever the Agent neither
+     * answered nor escalated goes to a person, so no waiting item is silent.
+     */
+    const unattended = new Map();
+    let poll;
+    /** Escalate the items of every reply whose carrying work has settled. */
+    async function settleUnattended() {
+        const handling = input.unattended;
+        if (handling === undefined)
+            return;
+        for (const [commandId, entry] of unattended) {
+            const settlement = await handling
+                .readSettlement(entry.sessionId, commandId)
+                .catch((cause) => {
+                // Not settled as far as anyone can tell; try again on the next poll.
+                Effect.runFork(Effect.logWarning("delegation.settlement", cause));
+                return undefined;
+            });
+            if (settlement === undefined)
+                continue;
+            unattended.delete(commandId);
+            for (const itemId of entry.items)
+                await handling
+                    .escalate({ ...entry.child, itemId }, entry.sessionId)
+                    .catch((cause) => {
+                    Effect.runFork(Effect.logWarning("delegation.escalate", cause));
+                });
+        }
+        if (unattended.size === 0 && poll !== undefined) {
+            clearInterval(poll);
+            poll = undefined;
+        }
+    }
+    function watchUnattended(accepted, receiverSessionId, reply) {
+        if (input.unattended === undefined ||
+            reply.outcome === "undeliverable" ||
+            reply.waitingOnYou === undefined)
+            return;
+        if (receiverSessionId === undefined)
+            return;
+        unattended.set(accepted.commandId, {
+            sessionId: receiverSessionId,
+            child: { agentId: reply.agentId, sessionId: reply.sessionId },
+            items: reply.waitingOnYou.map(({ itemId }) => itemId),
+        });
+        poll ??= setInterval(() => {
+            void settleUnattended();
+        }, 1_000);
+        poll.unref();
+    }
+    /** Escalate what is owed now and stop watching; the Agent is closing. */
+    async function close() {
+        await settleUnattended();
+        unattended.clear();
+        if (poll !== undefined)
+            clearInterval(poll);
+        poll = undefined;
+    }
+    /** Send with one caller-owned identity; follow-up and steer replies return here. */
     async function send(task, sourceSessionId, signal, invocation) {
         if (invocation === undefined)
             throw new Error("Delegation requires a tool invocation");
@@ -43,19 +104,9 @@ export function createPrivateLocalDelegation(input) {
             requestId: task.requestId,
         });
         signal.throwIfAborted();
-        if (task.delivery === "steer") {
-            const opened = await input.directory.open(task.agentId, signal);
-            try {
-                return await opened.agent.session(task.sessionId).send(task.text, {
-                    requestId,
-                    delivery: "steer",
-                });
-            }
-            finally {
-                await opened.release();
-            }
-        }
-        const meta = delegationSendMeta({ id: input.agentId, name: input.agentId }, invocation.meta);
+        // A person reads this name where work waits on its sender.
+        const sender = agents.find(({ agentId }) => agentId === input.agentId);
+        const meta = delegationSendMeta({ id: input.agentId, name: sender?.name ?? input.agentId }, invocation.meta);
         // The caller's request key owns replay, not the current model program's bytes.
         const provenance = await delegationProvenance({
             agentId: input.agentId,
@@ -71,6 +122,7 @@ export function createPrivateLocalDelegation(input) {
         }, {
             agentId: task.agentId,
             sessionId: task.sessionId,
+            delivery: task.delivery,
             text: task.text,
             requestId,
         });
@@ -147,7 +199,9 @@ export function createPrivateLocalDelegation(input) {
         if (replier === undefined && !authenticatedUndeliverable)
             throw new Error("Local reply sender is outside this project");
         const meta = delegationReplyMeta(delegation, replier?.name ?? delegation.reply.agentId);
-        return input.accept({ ...mail, meta }, meta, delegation.reply);
+        const accepted = await input.accept({ ...mail, meta }, meta, delegation.reply);
+        watchUnattended(accepted, mail.to.sessionId, delegation.reply);
+        return accepted;
     }
-    return { send, recall, receive, outstanding: fleet.outstanding };
+    return { send, recall, receive, close, outstanding: fleet.outstanding };
 }

package/dist/private-local-runtime-host.js

@@ -46,7 +46,7 @@ import { createPrivateInvocationFilesPort, } from "./private-invocation-files.js
 import { createLocalSkillSource } from "./local-skill-source.js";
 import { createPrivateWorkerdSandbox } from "./private-workerd-sandbox.js";
 import { createPrivateFungiMcpConnection, } from "./private-fungi-mcp-connection.js";
-import { createPrivateSqliteOwner, openPrivateWritableSqliteDatabase, } from "./private-sqlite-owner.js";
+import { createPrivateSqliteOwner, openPrivateWritableSqliteDatabase, storeWriteBusyTimeoutMs, } from "./private-sqlite-owner.js";
 import { createPrivateLocalMailRoom, hasPrivateLocalPendingMail, } from "./private-local-mail.js";
 import { createPrivateLocalDelegation, } from "./private-local-delegation.js";
 import { createPrivateLocalAgentControl, } from "./private-local-agent-control.js";
@@ -207,6 +207,30 @@ async function assertPrivateLocalReceiptFile(path, kind) {
         throw cause;
     }
 }
+function ensureReceiptTable(database) {
+    database.exec(`
+    CREATE TABLE IF NOT EXISTS ${localCreateReceiptTable} (
+      request_id TEXT PRIMARY KEY NOT NULL,
+      agent_id TEXT NOT NULL UNIQUE,
+      name TEXT,
+      created_by_agent_id TEXT,
+      created_by_session_id TEXT
+    ) WITHOUT ROWID
+  `);
+    const receiptColumns = database
+        .prepare(`PRAGMA table_info(${localCreateReceiptTable})`)
+        .all()
+        .map((column) => column.name);
+    if (!receiptColumns.includes("created_by_agent_id"))
+        database.exec(`ALTER TABLE ${localCreateReceiptTable} ADD COLUMN created_by_agent_id TEXT`);
+    if (!receiptColumns.includes("created_by_session_id"))
+        database.exec(`ALTER TABLE ${localCreateReceiptTable} ADD COLUMN created_by_session_id TEXT`);
+}
+function readReceiptRow(database, requestId) {
+    return database
+        .prepare(`SELECT agent_id, created_by_agent_id, created_by_session_id FROM ${localCreateReceiptTable} WHERE request_id = ?`)
+        .get(requestId);
+}
 /** Resolve an Agent create request through its durable Local receipt. */
 export async function resolvePrivateLocalCreateStore(root, requestId, creator) {
     if (requestId.length === 0 || requestId.length > 256)
@@ -229,27 +253,13 @@ export async function resolvePrivateLocalCreateStore(root, requestId, creator) {
     try {
         database.exec(`PRAGMA busy_timeout = ${String(receiptBusyTimeoutMs)}`);
         database.exec("BEGIN IMMEDIATE");
-        database.exec(`
-      CREATE TABLE IF NOT EXISTS ${localCreateReceiptTable} (
-        request_id TEXT PRIMARY KEY NOT NULL,
-        agent_id TEXT NOT NULL UNIQUE,
-        name TEXT,
-        created_by_agent_id TEXT,
-        created_by_session_id TEXT
-      ) WITHOUT ROWID
-    `);
-        const receiptColumns = database
-            .prepare(`PRAGMA table_info(${localCreateReceiptTable})`)
-            .all()
-            .map((column) => column.name);
-        if (!receiptColumns.includes("created_by_agent_id"))
-            database.exec(`ALTER TABLE ${localCreateReceiptTable} ADD COLUMN created_by_agent_id TEXT`);
-        if (!receiptColumns.includes("created_by_session_id"))
-            database.exec(`ALTER TABLE ${localCreateReceiptTable} ADD COLUMN created_by_session_id TEXT`);
-        const existing = database
-            .prepare(`SELECT agent_id, created_by_agent_id, created_by_session_id FROM ${localCreateReceiptTable} WHERE request_id = ?`)
-            .get(requestId);
+        ensureReceiptTable(database);
+        const existing = readReceiptRow(database, requestId);
         if (existing !== undefined) {
+            if (creatorAgentId !== undefined &&
+                (existing.created_by_agent_id === null ||
+                    existing.created_by_agent_id === undefined))
+                throw new AgentCreateRefused("request_conflict", "the Local Agent create receipt is unbound; use a fresh requestId");
             if (creatorAgentId !== undefined &&
                 (existing.created_by_agent_id !== creatorAgentId ||
                     existing.created_by_session_id !== creatorSessionId))
@@ -616,6 +626,13 @@ export function createPrivateLocalModelSource(models, providerId, modelId, provi
                     message.stopReason === "error" &&
                     modelFailure?.message === message &&
                     modelFailure.retryable,
+                retryAfterMs: (message) => modelFailure?.message === message &&
+                    modelFailure.rejection?.code === "rate-limit"
+                    ? modelFailure.rejection.retryAfterMs
+                    : undefined,
+                rejection: (message) => modelFailure?.message === message
+                    ? modelFailure.rejection
+                    : undefined,
                 failureReason: (message) => modelFailure?.message === message ? modelFailure.reason : undefined,
                 providerError: (message) => modelFailure?.message === message
                     ? modelFailure.providerError
@@ -637,7 +654,7 @@ export function createPrivateLocalModelSource(models, providerId, modelId, provi
                         const evidence = {
                             refusal: turn.refusal(),
                             upstream: upstream ?? partial,
-                            rejection: provider.rejection(),
+                            rejection: provider.rejection(upstream),
                         };
                         const message = cause === undefined
                             ? modelFailureMessage(selected.provider, evidence)
@@ -674,6 +691,8 @@ export function createPrivateLocalModelSource(models, providerId, modelId, provi
                                 reason: message,
                                 retryable: modelFailureRetryable(evidence),
                             };
+                            if (evidence.rejection !== undefined)
+                                modelFailure.rejection = evidence.rejection;
                             if (upstream?.errorMessage !== undefined)
                                 modelFailure.providerError = upstream.errorMessage;
                         }
@@ -1044,7 +1063,7 @@ export async function openPrivateLocalRuntimeHost(input, suppliedModels) {
         providerCacheKey = createHash("sha256")
             .update(JSON.stringify(["fungi-local", paths.databasePath, initialSessionId]))
             .digest("hex");
-        database = openPrivateWritableSqliteDatabase(paths.databasePath, 0);
+        database = openPrivateWritableSqliteDatabase(paths.databasePath, storeWriteBusyTimeoutMs);
         database.exec("PRAGMA foreign_keys = ON");
         const agentId = ensureLocalAgentId({
             database,
@@ -1119,6 +1138,14 @@ export async function openPrivateLocalRuntimeHost(input, suppliedModels) {
                         return Promise.reject(new Error("Local mail ingress is unavailable"));
                     return acceptMail(mail, meta, reply);
                 },
+                unattended: {
+                    readSettlement: (sessionId, commandId) => readSettlement === undefined
+                        ? Promise.reject(new Error("Local settlement reads are unavailable"))
+                        : readSettlement(sessionId, commandId),
+                    escalate: async (item, receiverSessionId) => {
+                        await input.agentControl?.escalate(item, agentId, receiverSessionId, new AbortController().signal);
+                    },
+                },
             });
         let projectDirectory;
         if (input.agentControl !== undefined) {
@@ -1531,7 +1558,7 @@ export async function openPrivateLocalRuntimeHost(input, suppliedModels) {
                 };
             },
             close: () => {
-                closing ??= closePrivateLocalResources({
+                closing ??= (delegation?.close() ?? Promise.resolve()).then(() => closePrivateLocalResources({
                     agent,
                     processes,
                     sandbox,
@@ -1539,7 +1566,7 @@ export async function openPrivateLocalRuntimeHost(input, suppliedModels) {
                     database,
                     lease,
                     providerCacheKey,
-                });
+                }));
                 return closing;
             },
         });

package/dist/private-local-service-contract.d.ts

@@ -102,6 +102,7 @@ export type PrivateLocalServiceRebind = Readonly<{
     service: PrivateLocalServiceStatus;
 }> | Readonly<{
     kind: "unavailable";
+    alive: boolean;
 }>;
 export type PrivateLocalSessionChoice = Readonly<{
     databasePath: string;