@fungi.computer/oyster 0.4.0 → 0.5.0

package/dist/standalone/agent-mail.js

@@ -23,6 +23,7 @@ export function agentMail(options) {
         if (tick === undefined)
             throw new Error("Agent Post lane is not open");
         await tick();
+        await mail.stageUndeliverableReplies();
     };
     const mail = new AgentMail({ ...options, post: runtime, drain });
     const host = {
@@ -57,6 +58,8 @@ export function agentMail(options) {
     };
     return {
         host,
-        deliver: (value) => mail.send(value),
+        deliver: (value) => {
+            return mail.send(value);
+        },
     };
 }

package/dist/standalone/agent-model-choice.d.ts

@@ -20,7 +20,10 @@ export declare class AgentModelRefused extends Error {
 /** Read the maintained Pi catalog; never accept a model from a different egress. */
 export declare function selectAgentModel(choice: AgentModelChoice): Promise<Model<Api>>;
 /** The Agent DO is the only durable owner. Absence is a new-format default, not an old-env reader. */
-export declare function agentModelChoice(storage: Pick<DurableObjectStorage, "get" | "put">, admit: (choice: AgentModelChoice) => void): {
+export declare function agentModelChoice(storage: Readonly<{
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    put(key: string, value: AgentModelChoice): Promise<void>;
+}>, admit: (choice: AgentModelChoice) => void): {
     read(): Promise<AgentModelChoice>;
     set(input: AgentModelChoice): Promise<AgentModelChoice>;
 };

package/dist/standalone/agents.d.ts

@@ -1,5 +1,7 @@
 import { type StandaloneTenancyEnv } from "./tenancy.js";
 import type { PostEnvelope } from "@fungi.computer/carrier/post";
+import { type ChannelConversations } from "../channels/conversations.js";
+import type { ConversationBinding } from "../channels/binding.js";
 import { type StandaloneMachineLinkBindings, type StandaloneMachineJoinResult } from "./machine-link.js";
 import { type MachineAgentSettlementPrincipal, type MachineAgentHome, type MachineEnrollment, type MachineLinkCaller, type MachineLinkIdentity } from "../machine-link/index.js";
 /** Workers AI binding surface used by the standalone provider adapter. */
@@ -78,6 +80,12 @@ export declare abstract class StandaloneAgentBase<Env extends StandaloneAgentEnv
     #private;
     /** The deployable root's host for this Agent's pinned tenant. */
     protected abstract hostFor(scope: TenantScope): Promise<OysterHost>;
+    /**
+     * Compose Oyster's channel owner on this Agent's real store and Shiitake.
+     * A host must supply its own binding lookup after authenticating its edge;
+     * this does not install an inbound route or mint provider credentials.
+     */
+    protected channelConversations(binding: (bindingId: string) => ConversationBinding | null): ChannelConversations;
     private uiOwner;
     private machineClient;
     private computerSnapshot;

package/dist/standalone/agents.js

@@ -7,6 +7,8 @@ import { AgentCreateRefused, } from "@fungi.computer/shiitake/agent-control";
 import { AgentDelegation, AgentDisclosureRefused, machineAgentCodecs, } from "@fungi.computer/shiitake/delegation";
 import { FungiMessageMetaSchema } from "@fungi.computer/agar/agents";
 import { agentMail } from "./agent-mail.js";
+import { createChannelConversations, } from "../channels/conversations.js";
+import { channelSessionDoor } from "./channel-session-door.js";
 import { createStandaloneMachineEnrollment, standaloneMachineAgentHome, standaloneMachineLinkAuthority, } from "./machine-link.js";
 import { createMachineLinkFences, MachineEnrollmentRefused, MachineLinkRefused, createMachineAgentClient, } from "../machine-link/index.js";
 import { memberInboxItemSchema } from "@fungi.computer/puffball/inbox";
@@ -228,6 +230,22 @@ const instructions = [
 ].join("\n");
 /** One agent: Shiitake's Cloudflare host over this Durable Object; its root supplies `hostFor`. */
 export class StandaloneAgentBase extends ShiitakeDO {
+    /**
+     * Compose Oyster's channel owner on this Agent's real store and Shiitake.
+     * A host must supply its own binding lookup after authenticating its edge;
+     * this does not install an inbound route or mint provider credentials.
+     */
+    channelConversations(binding) {
+        return createChannelConversations({
+            sql: this.ctx.storage.sql,
+            transactionSync: (body) => this.ctx.storage.transactionSync(body),
+            binding,
+            door: channelSessionDoor(() => this.shiitake(), () => {
+                // Standalone Agents have no Hub Team grants to deliver.
+            }),
+            now: () => Date.now(),
+        });
+    }
     /** Each installed Release's verified catalog surface, built once per Release for this Agent's lifetime. */
     #appSurfaces;
     uiOwner;
@@ -479,10 +497,11 @@ export class StandaloneAgentBase extends ShiitakeDO {
                     throw new Error("Delegated reply identity is unavailable");
                 if (mail.reply.outcome === "undeliverable")
                     return undefined;
-                if (mail.from.sessionId === undefined)
-                    throw new Error("Delegated reply Session is unavailable");
+                if (mail.from.kind !== "agent")
+                    throw new Error("Delegated reply Agent identity is unavailable");
                 return (await this.machineClient()).settlement(mail.from.agentId, mail.from.sessionId, mail.reply.commandId, mail.to.agentId);
             },
+            onUndeliverable: (original) => this.delegation().localUndeliverable(original),
             wake: () => this.wakeRuntime(),
         }));
     }

package/dist/standalone/app-set.d.ts

@@ -60,6 +60,13 @@ export type InstalledStarterApp = Readonly<{
     release: Schema.Json;
     timings: StarterAppTimings;
 }>;
+export type StarterAppSetResult = Readonly<{
+    installed: readonly InstalledStarterApp[];
+    failed: readonly Readonly<{
+        installationId: string;
+        reason: string;
+    }>[];
+}>;
 /**
  * Builds the installer runs at once by default. A build's compiler may take a
  * 4 GB heap, so two fit the platform's 12 GiB Computer (standard-4) with room
@@ -91,4 +98,4 @@ export declare function installStandaloneAppSet(options: Readonly<{
     /** The idle wait between build status reads; the real timer by default. */
     idle?: (ms: number, signal: AbortSignal) => Promise<void>;
     waitMs?: number;
-}>): Promise<readonly InstalledStarterApp[]>;
+}>): Promise<StarterAppSetResult>;

package/dist/standalone/app-set.js

@@ -72,7 +72,13 @@ const publishedSchema = Schema.Struct({
 });
 const buildSchema = Schema.Struct({
     jobId: Schema.String,
-    status: Schema.Literals(["running", "succeeded", "failed", "revoked"]),
+    status: Schema.Literals([
+        "running",
+        "succeeded",
+        "failed",
+        "interrupted",
+        "revoked",
+    ]),
     detail: Schema.NullOr(Schema.String),
     /** Installed exactly as the host encoded it. */
     release: Schema.NullOr(Schema.Json),
@@ -271,10 +277,15 @@ export async function installStandaloneAppSet(options) {
         }
     };
     const installed = new Map();
-    /** Set by the first failure, so no further seed or build starts. */
-    const stop = { requested: false };
-    /** Every failure, in the order it happened; the first is the one thrown. */
-    const failures = [];
+    const failures = new Map();
+    const fail = (app, cause) => {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        failures.set(app.installationId, reason);
+        options.report(`Failed ${app.installationId}: ${reason}`);
+    };
+    const reportFailure = ({ app, cause, }) => {
+        fail(app, cause);
+    };
     const seededQueue = [];
     const waiting = [];
     const seeding = { finished: false };
@@ -318,21 +329,19 @@ export async function installStandaloneAppSet(options) {
     const seedAll = async () => {
         try {
             for (const app of standaloneAppSet) {
-                if (stop.requested)
-                    break;
-                const seeded = await seedApp(app);
-                const waiter = waiting.shift();
-                if (waiter === undefined)
-                    seededQueue.push(seeded);
-                else
-                    waiter(seeded);
+                try {
+                    const seeded = await seedApp(app);
+                    const waiter = waiting.shift();
+                    if (waiter === undefined)
+                        seededQueue.push(seeded);
+                    else
+                        waiter(seeded);
+                }
+                catch (cause) {
+                    reportFailure({ app, cause });
+                }
             }
         }
-        catch (cause) {
-            stop.requested = true;
-            failures.push(cause);
-            throw cause;
-        }
         finally {
             seeding.finished = true;
             for (const waiter of waiting.splice(0))
@@ -341,7 +350,7 @@ export async function installStandaloneAppSet(options) {
     };
     // `concurrency` builds at once, each installing as its build succeeds.
     const slot = async () => {
-        for (let next = await takeSeeded(); next !== undefined && !stop.requested; next = await takeSeeded()) {
+        for (let next = await takeSeeded(); next !== undefined; next = await takeSeeded()) {
             const name = next.app.installationId;
             try {
                 const buildStarted = performance.now();
@@ -416,22 +425,28 @@ export async function installStandaloneAppSet(options) {
                 });
             }
             catch (cause) {
-                stop.requested = true;
-                failures.push(cause);
-                throw cause;
+                reportFailure({ app: next.app, cause });
             }
         }
     };
-    // Wait for every seed and build to settle before reporting: nothing of this
-    // call may still run, or install, after it rejects.
-    await Promise.allSettled([
+    // Wait for every seed and build to settle before returning the full outcome.
+    const settled = await Promise.allSettled([
         seedAll(),
         ...Array.from({ length: concurrency }, slot),
     ]);
-    if (failures.length > 0)
-        throw failures[0];
-    return standaloneAppSet.flatMap((app) => {
-        const result = installed.get(app.installationId);
-        return result === undefined ? [] : [result];
-    });
+    for (const outcome of settled)
+        if (outcome.status === "rejected")
+            throw outcome.reason;
+    return {
+        installed: standaloneAppSet.flatMap((app) => {
+            const result = installed.get(app.installationId);
+            return result === undefined ? [] : [result];
+        }),
+        failed: standaloneAppSet.flatMap((app) => {
+            const reason = failures.get(app.installationId);
+            return reason === undefined
+                ? []
+                : [{ installationId: app.installationId, reason }];
+        }),
+    };
 }

package/dist/standalone/channel-session-door.d.ts

@@ -0,0 +1,4 @@
+import type { ShiitakeOwnerAgent } from "@fungi.computer/shiitake/cloudflare";
+import type { SessionDoor } from "../channels/conversations.js";
+/** Translate a standalone Agent's Shiitake owner into Oyster's channel Session port. */
+export declare function channelSessionDoor(open: () => Promise<ShiitakeOwnerAgent>, deliverGrants: (sessionId: string) => void): SessionDoor;

package/dist/standalone/channel-session-door.js

@@ -0,0 +1,42 @@
+import { authorMeta } from "@fungi.computer/agar/agents";
+import { ShiitakeError } from "@fungi.computer/shiitake";
+/** Translate a standalone Agent's Shiitake owner into Oyster's channel Session port. */
+export function channelSessionDoor(open, deliverGrants) {
+    return {
+        createSession: async (requestId) => (await open()).createSession(requestId),
+        deliverGrants,
+        withdraw: async (sessionId, requestId) => (await open()).session(sessionId).withdraw(requestId),
+        latestPending: async (sessionId, visitor) => (await open())
+            .withMeta(authorMeta(visitor))
+            .session(sessionId)
+            .latestPending(),
+        prompt: async (sessionId, { requestId, text, meta }) => {
+            // The conversation row exists now, so its channel admission is known;
+            // deliver Agent tools before the first run can call one.
+            deliverGrants(sessionId);
+            const agent = await open();
+            return await agent.withMeta(meta).session(sessionId).command({
+                type: "prompt",
+                requestId,
+                text,
+                delivery: "followUp",
+            });
+        },
+        line: async (sessionId, input) => {
+            const agent = await open();
+            const meta = input.author === "operator" ? authorMeta(input.identity) : input.meta;
+            await agent.withMeta(meta).session(sessionId).command({
+                type: "operator",
+                requestId: input.requestId,
+                author: input.author,
+                text: input.text,
+            });
+        },
+        errorKind: (error, requestId) => error instanceof ShiitakeError &&
+            error.boundary === "contract" &&
+            error.cause === "closed" &&
+            error.requestId === requestId
+            ? "closed_request"
+            : null,
+    };
+}

package/dist/standalone/install-apps-bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/standalone/install-apps-bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runInstallAppsCli } from "./install-apps-cli.js";
+await runInstallAppsCli();

package/dist/standalone/install-apps-cli.d.ts

@@ -1,2 +1,4 @@
 #!/usr/bin/env node
-export {};
+import { installStandaloneAppSet } from "./app-set.js";
+export declare function installApps(args: readonly string[], install?: typeof installStandaloneAppSet): Promise<void>;
+export declare function runInstallAppsCli(args?: readonly string[]): Promise<void>;

package/dist/standalone/install-apps-cli.js

@@ -76,7 +76,7 @@ function timingTable(results) {
     ];
     return [header, ...rows].map((row) => row.join("\t")).join("\n");
 }
-async function installApps(args) {
+export async function installApps(args, install = installStandaloneAppSet) {
     const { values } = parseArgs({
         args: [...args],
         options: {
@@ -121,7 +121,7 @@ async function installApps(args) {
             source = { kind: "checkout", directory, revision: `git:${revision}` };
         }
         const started = performance.now();
-        const results = await installStandaloneAppSet({
+        const { installed, failed } = await install({
             source,
             url,
             key,
@@ -131,33 +131,43 @@ async function installApps(args) {
             },
         });
         const elapsed = performance.now() - started;
-        process.stdout.write(`\n${timingTable(results)}\n`);
-        process.stdout.write(`\nInstalled ${String(results.length)} Apps in ${seconds(elapsed)}. Open ${url}/ to use Tourtois and the installed Apps.\n`);
+        process.stdout.write(`\n${timingTable(installed)}\n`);
+        process.stdout.write("\nApp\tResult\n");
+        for (const app of installed)
+            process.stdout.write(`${app.installationId}\tinstalled\n`);
+        for (const app of failed)
+            process.stdout.write(`${app.installationId}\tfailed: ${app.reason}\n`);
+        process.stdout.write(`\nInstalled ${String(installed.length)} Apps; failed ${String(failed.length)} in ${seconds(elapsed)}.${installed.length > 0 ? ` Open ${url}/ to use the installed Apps.` : ""}\n`);
         if (values.timings !== undefined)
             await writeFile(values.timings, JSON.stringify({
                 concurrency,
                 elapsedMs: elapsed,
-                apps: results.map(({ installationId, jobId, timings }) => ({
+                apps: installed.map(({ installationId, jobId, timings }) => ({
                     installationId,
                     jobId,
                     timings,
                 })),
+                failed,
             }, null, 2) + "\n");
+        if (failed.length > 0)
+            process.exitCode = 1;
     }
     finally {
         await rm(scratch, { recursive: true, force: true });
     }
 }
-const [command, ...rest] = process.argv.slice(2);
-if (command === "--help" || command === "-h") {
-    process.stdout.write(usage + "\n" + installReleaseUsage + "\n");
-}
-else if (command !== "install-apps" && command !== "install") {
-    process.stderr.write(`${usage}\n`);
-    process.exitCode = 2;
+export async function runInstallAppsCli(args = process.argv.slice(2)) {
+    const [command, ...rest] = args;
+    if (command === "--help" || command === "-h") {
+        process.stdout.write(usage + "\n" + installReleaseUsage + "\n");
+    }
+    else if (command !== "install-apps" && command !== "install") {
+        process.stderr.write(`${usage}\n`);
+        process.exitCode = 2;
+    }
+    else
+        await (command === "install" ? installReleaseCommand(rest) : installApps(rest)).catch((cause) => {
+            process.stderr.write(`${cause instanceof Error ? cause.message : String(cause)}\n`);
+            process.exitCode = 1;
+        });
 }
-else
-    await (command === "install" ? installReleaseCommand(rest) : installApps(rest)).catch((cause) => {
-        process.stderr.write(`${cause instanceof Error ? cause.message : String(cause)}\n`);
-        process.exitCode = 1;
-    });

package/dist/standalone/machine-link.d.ts

@@ -268,6 +268,8 @@ export declare class MachineLinkDO extends DurableObject<StandaloneMachineLinkEn
     alarm(): Promise<void>;
     fetch(request: Request): Promise<Response>;
     deliver(id: MachineLinkIdentity, caller: MachineLinkCaller, agentId: string, envelope: PostEnvelope): Promise<PostDeliveryResult>;
+    deliverRelayDisposition(id: MachineLinkIdentity, relay: MachineLinkIdentity, original: PostEnvelope, reply: PostEnvelope): Promise<PostDeliveryResult>;
+    hasStagedDisposition(id: MachineLinkIdentity, original: PostEnvelope, reply: PostEnvelope): Promise<boolean>;
     operation(id: MachineLinkIdentity, caller: MachineLinkCaller, agentId: string, operation: MachineAgentOperation): Promise<import("effect/Schema").Json>;
     applyFence(fact: MachineLinkFenceFact): Promise<MachineLinkFenceResult>;
     preflightErasure(teamId: string, deviceId: string): Promise<void>;

package/dist/standalone/machine-link.js

@@ -1,4 +1,4 @@
-import { machineAgentReservations } from "@fungi.computer/shiitake/delegation";
+import { machineAgentCodecs, machineAgentReservations, } from "@fungi.computer/shiitake/delegation";
 import { createMachineEnrollment, MachineEnrollmentRefused, MachineLinkRefused, } from "../machine-link/index.js";
 import { keyAllowsMachineEnroll, } from "../keys.js";
 import { agentIds, createAgentDirectory, } from "@fungi.computer/shiitake/fleet";
@@ -8,6 +8,7 @@ import { bodyLimit } from "hono/body-limit";
 import { validator } from "hono/validator";
 import { machineEnrollmentSchema, machineLinkName, } from "../machine-link/index.js";
 import { createMachineLink } from "../machine-link/workers.js";
+import { deliverUndeliverableMail } from "../machine-link/delivery.js";
 import { defaultTenant, tenantScope } from "../tenant.js";
 import { presentedGitKey } from "../git-auth.js";
 import { standaloneTenancy } from "./tenancy.js";
@@ -49,6 +50,7 @@ export function standaloneMachineLinkAuthority(env) {
             return directory().machineDevice(id);
         },
         currentFence: async (id) => id.teamId !== teamId ? null : directory().machineFence(id),
+        agentHome: async (id, agentId) => id.teamId !== teamId ? null : directory().agentHome(agentId),
         directory: async (id) => {
             if (!(await authority.admitDevice(id)).live)
                 throw new MachineLinkRefused("actor_not_allowed");
@@ -69,6 +71,31 @@ export function standaloneMachineLinkAuthority(env) {
                 throw new MachineLinkRefused("actor_not_allowed");
             return env.MACHINE_LINK.getByName(machineLinkName(next)).deliver(next, caller, facts.targetAgentId, envelope);
         },
+        deliverUndeliverable: async (id, original, reply) => {
+            if ((await authority.currentFence(id)) === null)
+                return "refused";
+            const mail = original.event;
+            if (mail.from.kind !== "agent")
+                return "refused";
+            const home = await authority.agentHome(id, mail.from.agentId);
+            if (home === null)
+                throw new MachineLinkRefused("unavailable");
+            return await deliverUndeliverableMail({
+                identity: id,
+                original,
+                reply,
+                senderHome: home,
+                hosted: env.AGENTS,
+                accepted: machineAgentCodecs.accepted,
+                machine: async (deviceId, envelope) => {
+                    const destination = { teamId, deviceId };
+                    return await env.MACHINE_LINK.getByName(machineLinkName(destination)).deliverRelayDisposition(destination, id, original, envelope);
+                },
+            });
+        },
+        verifyRelayDisposition: async (relay, original, reply) => {
+            return await env.MACHINE_LINK.getByName(machineLinkName(relay)).hasStagedDisposition(relay, original, reply);
+        },
         canErase: async (id) => {
             if (id.teamId !== teamId)
                 return false;
@@ -185,6 +212,12 @@ export class MachineLinkDO extends DurableObject {
     deliver(id, caller, agentId, envelope) {
         return this.link.deliver(id, caller, agentId, envelope);
     }
+    deliverRelayDisposition(id, relay, original, reply) {
+        return this.link.deliverRelayDisposition(id, relay, original, reply);
+    }
+    hasStagedDisposition(id, original, reply) {
+        return this.link.hasStagedDisposition(id, original, reply);
+    }
     operation(id, caller, agentId, operation) {
         return this.link.operation(id, caller, agentId, operation);
     }

package/dist/standalone/registry.d.ts

@@ -187,7 +187,7 @@ export declare abstract class StandaloneRegistry extends OysterRegistry implemen
         appId: string;
         releaseId: string;
         sourceRevision: string;
-        status: "running" | "succeeded" | "failed" | "revoked";
+        status: "running" | "succeeded" | "failed" | "interrupted" | "revoked";
         detail: string | null;
         release: Release | null;
         installation: import("../app-builds.js").OysterBuildInstallation | null;

package/dist/testing/capabilities.d.ts

@@ -1,6 +1,7 @@
 import { Hono } from "hono";
 import { type AppCapabilityId } from "@fungi.computer/puffball/app";
 import { type OysterAgents } from "../agents.js";
+import type { LiveOysterKey } from "../keys.js";
 import { type FileSource } from "../files.js";
 import { type OysterAuthResult, type OysterCapability } from "../host.js";
 /** How one capability fixture host admits its single installation. */
@@ -19,6 +20,7 @@ export type CapabilityFixtureOptions = Readonly<{
     visitor?: boolean;
     authenticate?: (request: Request) => Promise<OysterAuthResult>;
     agents?: OysterAgents;
+    liveKey?: (keyId: string) => Promise<LiveOysterKey | null>;
 }>;
 /** One Oyster host with a single installation whose capability grants the options shape. */
 export declare function capabilityFixture(options?: CapabilityFixtureOptions): Promise<{

package/dist/testing/capabilities.js

@@ -84,7 +84,7 @@ export async function capabilityFixture(options = {}) {
     if (options.visitor)
         installation = { ...installation, visibility: "public" };
     const readOnly = () => Promise.reject(new Error("Fixture installations are read-only"));
-    const base = {
+    let base = {
         bootUi: () => Promise.resolve({ kind: "passed" }),
         auth: {
             resolve: () => Promise.reject(new Error("Capability fixture resolves no actor")),
@@ -116,6 +116,8 @@ export async function capabilityFixture(options = {}) {
         },
         capabilities,
     };
+    if (options.liveKey !== undefined)
+        base = { ...base, keys: { live: options.liveKey } };
     const host = options.agents === undefined
         ? base
         : { ...base, ownerRoutes: agentApprovalRoutes(options.agents) };

package/dist/workers-git.js

@@ -1117,7 +1117,7 @@ export async function oysterGitWorkerHost(env, options, selected, request) {
     const base = oysterWorkerHost(env, auth, policyOptions);
     const capabilities = [
         ...(base.capabilities ?? []),
-        ...(agents === undefined ? [] : agentCapabilities(agents)),
+        ...(agents === undefined ? [] : agentCapabilities(agents, keysLive)),
         ...(options.capabilities?.(env, workspace, keysLive) ?? []),
     ];
     let gitOptions = { scope };

package/dist/workers.d.ts

@@ -138,6 +138,7 @@ export declare class OysterRegistry<Env extends OysterWorkerEnv = OysterWorkerEn
             };
             readonly reversibility: "reversible" | "irreversible-external";
             readonly requestedAt: number;
+            readonly denialNote?: string | undefined;
             readonly evidence?: readonly {
                 readonly kind: "artifact";
                 readonly ref: string;
@@ -155,6 +156,7 @@ export declare class OysterRegistry<Env extends OysterWorkerEnv = OysterWorkerEn
     }>, actor: HostActor, input: ApprovalAnswerInput): Promise<Readonly<{
         kind: "refused";
         reason: "pending" | "expired" | "not-found" | "not-eligible" | "already-answered" | "stale-revision" | "declined" | "fenced" | "not-granted" | "read-only" | "in-flight" | "outcome-unknown" | "identity-conflict";
+        denialNote?: string;
     }> | Readonly<{
         kind: "answered";
         view: import("@fungi.computer/approvals").ApprovalView;
@@ -166,6 +168,7 @@ export declare class OysterRegistry<Env extends OysterWorkerEnv = OysterWorkerEn
     }>, actor: HostActor, input: AutoApproveInput): Promise<Readonly<{
         kind: "refused";
         reason: "pending" | "expired" | "not-found" | "not-eligible" | "already-answered" | "stale-revision" | "declined" | "fenced" | "not-granted" | "read-only" | "in-flight" | "outcome-unknown" | "identity-conflict";
+        denialNote?: string;
     }> | Readonly<{
         kind: "updated";
         rule: AutoApproveInput;

package/dist/workers.js

@@ -48,6 +48,8 @@ import { createOysterRootData } from "./root-data.js";
 import { backendCache, resolveBackend } from "./release.js";
 import { ensureAppSourceTables, createOysterAppSourceReceipts, createOysterAppRegistrations, createOysterArtifactsRepositoryMetadataStore, } from "./app-sources.js";
 export { r2ArtifactStore, r2FileSource, ownerKeyAuth };
+/** Issuer-ahead clock allowance at issue only; resolution never adds skew. */
+const BOOT_ISSUER_SKEW_MS = 2_000;
 const recordRow = Schema.Struct({
     installation_id: Schema.String,
     record: Schema.String,
@@ -433,8 +435,14 @@ export class OysterRegistry extends DurableObject {
             const { lease, tokenDigest } = bootCapabilityGrantSchema.parse(input.grant);
             validateCapabilityAssetSet(lease);
             const now = Date.now();
+            // The issuer can be at most 2 s ahead of this registry. Apply that
+            // allowance only on issue: resolution still uses the stored absolute
+            // expiry, and revocation still removes the token after the page check.
+            // A lease can therefore live at most 14 s on this clock, not be renewed
+            // or replayed once expired.
             if (lease.expiresAt <= now ||
-                lease.expiresAt > now + BOOT_DEADLINE_MS + BOOT_TRANSPORT_GRACE_MS)
+                lease.expiresAt >
+                    now + BOOT_DEADLINE_MS + BOOT_TRANSPORT_GRACE_MS + BOOT_ISSUER_SKEW_MS)
                 throw new Error("Boot capability lease is outside its deadline");
             this.ctx.storage.sql.exec("DELETE FROM boot_capabilities WHERE expires_at <= ?", now);
             const count = this.ctx.storage.sql

package/docs/api/agents.md

@@ -358,16 +358,20 @@ optional bearer.
 ### agentCapabilities()
 
 ```ts
-function agentCapabilities(agents): readonly Readonly<object & object>[];
+function agentCapabilities(
+  agents,
+  liveKey,
+): readonly Readonly<object & object>[];
 ```
 
 Agent adapters admitted against each App's declared capabilities.
 
 #### Parameters
 
-| Parameter | Type                            |
-| --------- | ------------------------------- |
-| `agents`  | [`OysterAgents`](#oysteragents) |
+| Parameter | Type                                                                                                                                                                                                                                                                 |
+| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `agents`  | [`OysterAgents`](#oysteragents)                                                                                                                                                                                                                                      |
+| `liveKey` | (`keyId`) => `Promise`\< \| `Readonly`\<\{ `keyId`: `string`; `owner`: `string`; `grantVersion`: `number`; `grants`: readonly `Readonly`\<\{ `capability`: [`OysterKeyCapability`](keys.md#oysterkeycapability); `targets`: `GrantTargets`; \}\>[]; \}\> \| `null`\> |
 
 #### Returns