@fungi.computer/oyster 0.1.0 → 0.3.0

package/dist/release.d.ts

@@ -20,6 +20,14 @@ export type ArtifactHeads = Readonly<{
     /** Describe the object at `artifactRef`, or `null` when absent. */
     head: (artifactRef: ArtifactRef) => Promise<ArtifactHead | null>;
 }>;
+/** A store that can stream immutable object bytes without materializing them. */
+export type ArtifactStreams = Readonly<{
+    /**
+     * Open a one-shot byte stream, or return `null` when absent. The signal owns
+     * cancellation of both source opening where supported and subsequent reads.
+     */
+    stream: (artifactRef: ArtifactRef, signal?: AbortSignal) => Promise<ReadableStream<Uint8Array> | null>;
+}>;
 /** Why a Release could not be read; the host maps it to an HTTP refusal. */
 export declare class ReleaseError extends Error {
     readonly code: "artifact_missing" | "digest_mismatch" | "invalid_release" | "asset_missing";
@@ -55,14 +63,13 @@ export declare function readVerified(store: ArtifactStore, artifactRef: Artifact
 /** Decode an untrusted Release record, as an install request carries it. */
 export declare function parseRelease(value: unknown): Release;
 /**
- * Read a Release root and verify every artifact it names: the UI document or
- * asset build (and each asset object), and the backend descriptor.
+ * Read a Release root and verify its UI build and backend descriptor.
+ * `readAssets` verifies UI object bodies when true. When false, it reads the
+ * asset manifest needed to resolve references but does not read any UI object
+ * body, including standalone HTML.
  */
 export declare function verifyRelease(store: ArtifactStore, release: Release, policy?: AssetBuildPolicy, 
-/**
- * Read and check every UI asset now. Serving can skip this: each asset is
- * verified against its digest when it is read.
- */
+/** Read and check every UI object now. Serving verifies each on demand. */
 readAssets?: boolean): Promise<VerifiedRelease>;
 /**
  * Resolve a Release to its verified durable backend without reading its UI:

package/dist/release.js

@@ -49,14 +49,13 @@ export function parseRelease(value) {
     }
 }
 /**
- * Read a Release root and verify every artifact it names: the UI document or
- * asset build (and each asset object), and the backend descriptor.
+ * Read a Release root and verify its UI build and backend descriptor.
+ * `readAssets` verifies UI object bodies when true. When false, it reads the
+ * asset manifest needed to resolve references but does not read any UI object
+ * body, including standalone HTML.
  */
 export async function verifyRelease(store, release, policy = defaultAssetPolicy, 
-/**
- * Read and check every UI asset now. Serving can skip this: each asset is
- * verified against its digest when it is read.
- */
+/** Read and check every UI object now. Serving verifies each on demand. */
 readAssets = true) {
     const rootBytes = await readVerified(store, release.artifact.artifactRef, release.artifact.artifactDigest);
     let build;
@@ -70,8 +69,12 @@ readAssets = true) {
     }
     let ui = null;
     if ("ui" in build) {
-        const bytes = await readVerified(store, build.ui.artifactRef, build.ui.digest);
+        const bytes = readAssets || build.ui.mediaType === assetBuildMediaType
+            ? await readVerified(store, build.ui.artifactRef, build.ui.digest)
+            : null;
         if (build.ui.mediaType === assetBuildMediaType) {
+            if (bytes === null)
+                throw new ReleaseError("invalid_release", "Asset manifest is required to verify its object references");
             let assets;
             try {
                 assets = decodeAssetBuild(bytes, policy);

package/dist/root-data.d.ts

@@ -1,8 +1,17 @@
 import type { Release } from "@fungi.computer/puffball";
 import { createAppStorage } from "./app-storage.js";
 import type { InstallationStore, verifyRelease } from "./host.js";
-import { type AppDirectoryEntry } from "./shell/app-directory.js";
-import type { WorkbenchPlatformDestination } from "./shell/workbench-model.js";
+import { type AppDirectoryEntry } from "@fungi.computer/nacre/app-directory";
+/**
+ * A destination the host offers the dashboard. This is a structural twin of
+ * Nacre's `WorkbenchPlatformDestination`: importing that type would put
+ * Nacre's DOM-typed workbench declarations on every Worker entry that reaches
+ * root data.
+ */
+type PlatformDestination = Readonly<{
+    id: string;
+    label: string;
+}>;
 /** Role choices belong to the root owner, independently of Release declarations. */
 export type OysterRootRoles = Readonly<Record<string, Readonly<{
     surfaceId: string | null;
@@ -33,7 +42,7 @@ export declare function createOysterRootData(options: OysterRootDataOptions): {
         openInstallation(authorize: () => import("effect/Effect").Effect<import("./app-storage.js").AppStorageInstallationAdmission, Error>): {
             read: (key: string) => import("effect/Effect").Effect<{
                 readonly value: import("effect/Schema").Json;
-                readonly source: "team" | "member" | "none";
+                readonly source: "member" | "team" | "none";
                 readonly team: {
                     readonly value: import("effect/Schema").Json;
                     readonly revision: number;
@@ -54,7 +63,7 @@ export declare function createOysterRootData(options: OysterRootDataOptions): {
         open(authorize: () => import("effect/Effect").Effect<import("./app-storage.js").AppStorageAdmission, Error>): {
             read: (key: string) => import("effect/Effect").Effect<{
                 readonly value: import("effect/Schema").Json;
-                readonly source: "team" | "member" | "none";
+                readonly source: "member" | "team" | "none";
                 readonly team: {
                     readonly value: import("effect/Schema").Json;
                     readonly revision: number;
@@ -74,7 +83,7 @@ export declare function createOysterRootData(options: OysterRootDataOptions): {
             events: (key: string) => import("effect/Stream").Stream<{
                 readonly appId: string;
                 readonly key: string;
-                readonly scope: "team" | "member";
+                readonly scope: "member" | "team";
                 readonly revision: number;
             } | null, import("@fungi.computer/agar").AppStorageError, never>;
         };
@@ -82,5 +91,6 @@ export declare function createOysterRootData(options: OysterRootDataOptions): {
     /** Project the current installations without minting permissions or role choices. */
     directory(): Promise<OysterRootDirectory>;
     /** No standalone platform navigation destination is implemented yet. */
-    platformDestinations(): readonly WorkbenchPlatformDestination[];
+    platformDestinations(): readonly PlatformDestination[];
 };
+export {};

package/dist/root-data.js

@@ -1,6 +1,6 @@
 import { resolveAppRoles, } from "@fungi.computer/puffball/app";
 import { createAppStorage } from "./app-storage.js";
-import { addressKey, appDirectoryEntrySchema, } from "./shell/app-directory.js";
+import { addressKey, appDirectoryEntrySchema, } from "@fungi.computer/nacre/app-directory";
 /** Data adapters for a standalone workbench over the root's existing owners. */
 export function createOysterRootData(options) {
     const storage = createAppStorage(options);
@@ -31,7 +31,7 @@ export function createOysterRootData(options) {
                     displayName: declaration?.displayName,
                     icon: declaration?.icon ?? null,
                     releaseId: installation.release.releaseId,
-                    authorityVersion: installation.authorityVersion,
+                    authorityVersion: installation.authority.authorityVersion,
                     enforcement: null,
                     handlers: [...(declaration?.handlers ?? [])],
                     roles: [...(declaration?.roles ?? [])],

package/dist/source/index.d.ts

@@ -5,6 +5,6 @@
  * never import it: use `@fungi.computer/oyster/source/template-push`. */
 export { templateRepositoryForApp } from "./template-repository.js";
 export { seedReceiptInputSchema, sameReceipt, type PublisherTemplateSeedReceipt, type PublisherTemplateSeedReceipts, } from "./seed-receipt.js";
-export { readTeamAppSeedProvenance, privateTeamBuildSource, TeamAppSourceError, } from "./team-source.js";
+export { readTeamAppSeedProvenance, privateTeamBuildSource, TeamAppSourceError, type TeamAppSeedProvenance, } from "./team-source.js";
 export { parseTemplateSeedClaim, recordTemplateSeed, templateSeedClaimSchema, TEMPLATE_SEED_CLAIM_MAX_BYTES, type TemplateSeedClaim, } from "./template-seed.js";
 export { forkAppSource, type AppSourceForkResult } from "./fork.js";

package/dist/source/team-source.d.ts

@@ -4,12 +4,9 @@ export declare class TeamAppSourceError extends Error {
     readonly code: "denied" | "unavailable";
     constructor(code: "denied" | "unavailable");
 }
-export declare function readTeamAppSeedProvenance(options: {
-    appId: string;
-    teamId: string;
-    registry: TeamAppPublisherRegistry;
-    readSeedReceipt(appId: PublisherTemplateSeedReceipt["appId"], seedRevision: PublisherTemplateSeedReceipt["seedRevision"]): Promise<PublisherTemplateSeedReceipt | null>;
-}): Promise<Readonly<{
+/** What a Team build runs: the App's source repository and the seed receipt
+ * whose recipe builds it. */
+export type TeamAppSeedProvenance = Readonly<{
     appId: string;
     repository: string;
     templateSeed: Readonly<{
@@ -18,9 +15,24 @@ export declare function readTeamAppSeedProvenance(options: {
     }>;
     recipe: PublisherTemplateSeedReceipt["recipe"];
     buildRecipeDigest: PublisherTemplateSeedReceipt["buildRecipeDigest"];
+}>;
+/**
+ * Read the source revision a Team build runs and the seed receipt that builds
+ * it. A template App uses the receipt of the exact commit it builds, failing
+ * closed when that commit was never seeded; a fork uses its pinned seed.
+ */
+export declare function readTeamAppSeedProvenance(options: {
+    appId: string;
+    teamId: string;
+    registry: TeamAppPublisherRegistry;
+    readSeedReceipt(appId: PublisherTemplateSeedReceipt["appId"], seedRevision: PublisherTemplateSeedReceipt["seedRevision"]): Promise<PublisherTemplateSeedReceipt | null>;
+    readDefaultBranchHead(repository: string): Promise<string | null>;
+}): Promise<Readonly<{
+    source: TeamAppSeedProvenance;
+    sourceRevision: PublisherTemplateSeedReceipt["seedRevision"];
 }>>;
-/** A fork keeps the seed's exact builder; private UI assets use Vite's relative base. */
-export declare function privateTeamBuildSource(source: Awaited<ReturnType<typeof readTeamAppSeedProvenance>>): Readonly<{
+/** A Team build keeps the seed's exact builder; private UI assets use Vite's relative base. */
+export declare function privateTeamBuildSource(source: TeamAppSeedProvenance): Readonly<{
     appId: string;
     repository: string;
     templateSeed: Readonly<{

package/dist/source/team-source.js

@@ -1,4 +1,4 @@
-import { parseAppId } from "@fungi.computer/puffball";
+import { parseAppId, parseSourceRevision } from "@fungi.computer/puffball";
 import { digestPinnedRecipe } from "../build-contract.js";
 import { templateRepositoryForApp } from "./template-repository.js";
 export class TeamAppSourceError extends Error {
@@ -9,16 +9,42 @@ export class TeamAppSourceError extends Error {
         this.name = "TeamAppSourceError";
     }
 }
+/**
+ * A first-party template App builds its own template, so each seeded commit
+ * carries its own recipe. A fork builds its own repository with the recipe of
+ * the seed it was forked from.
+ */
+function seedKind(registration, templateSeed) {
+    return templateSeed.appId === registration.appId &&
+        registration.source.repository ===
+            templateRepositoryForApp(registration.appId)
+        ? "template"
+        : "fork";
+}
+/**
+ * Read the source revision a Team build runs and the seed receipt that builds
+ * it. A template App uses the receipt of the exact commit it builds, failing
+ * closed when that commit was never seeded; a fork uses its pinned seed.
+ */
 export async function readTeamAppSeedProvenance(options) {
     const appId = parseAppId(options.appId);
     const authorization = await options.registry.authorize(appId, options.teamId);
     if (authorization.kind !== "authorized")
         throw new TeamAppSourceError("denied");
     const registration = authorization.registration;
-    const templateSeed = registration.templateSeed;
-    if (registration.source.provider !== "artifacts" ||
-        templateSeed === undefined)
+    const pinned = registration.templateSeed;
+    if (registration.source.provider !== "artifacts" || pinned === undefined)
+        throw new TeamAppSourceError("unavailable");
+    const head = await options.readDefaultBranchHead(registration.source.repository);
+    if (head === null)
         throw new TeamAppSourceError("unavailable");
+    const sourceRevision = parseSourceRevision(`git:${head}`);
+    const templateSeed = {
+        appId: pinned.appId,
+        revision: seedKind(registration, pinned) === "template"
+            ? sourceRevision
+            : pinned.revision,
+    };
     const receipt = await options.readSeedReceipt(parseAppId(templateSeed.appId), templateSeed.revision);
     if (receipt?.appId !== templateSeed.appId ||
         receipt.seedRevision !== templateSeed.revision ||
@@ -26,14 +52,17 @@ export async function readTeamAppSeedProvenance(options) {
         digestPinnedRecipe(receipt.recipe) !== receipt.buildRecipeDigest)
         throw new TeamAppSourceError("unavailable");
     return Object.freeze({
-        appId,
-        repository: registration.source.repository,
-        templateSeed,
-        recipe: receipt.recipe,
-        buildRecipeDigest: receipt.buildRecipeDigest,
+        source: Object.freeze({
+            appId,
+            repository: registration.source.repository,
+            templateSeed: Object.freeze(templateSeed),
+            recipe: receipt.recipe,
+            buildRecipeDigest: receipt.buildRecipeDigest,
+        }),
+        sourceRevision,
     });
 }
-/** A fork keeps the seed's exact builder; private UI assets use Vite's relative base. */
+/** A Team build keeps the seed's exact builder; private UI assets use Vite's relative base. */
 export function privateTeamBuildSource(source) {
     if (source.recipe.format !== "assets")
         return source;

package/dist/source/template-seed.d.ts

@@ -51,7 +51,7 @@ export declare function parseTemplateSeedClaim(body: string): TemplateSeedClaim
  */
 export declare function recordTemplateSeed(receipts: PublisherTemplateSeedReceipts, artifacts: Pick<Artifacts, "readDefaultBranchHead">, rawAppId: string, claim: TemplateSeedClaim): Promise<{
     readonly kind: "conflict";
-    readonly receipt?: undefined;
+    receipt?: undefined;
 } | {
     readonly kind: "recorded" | "existing";
     readonly receipt: {
@@ -64,5 +64,5 @@ export declare function recordTemplateSeed(receipts: PublisherTemplateSeedReceip
     };
 } | {
     readonly kind: "unavailable";
-    readonly receipt?: undefined;
+    receipt?: undefined;
 }>;

package/dist/standalone/agent-mail.d.ts

@@ -0,0 +1,24 @@
+import { AgentMail, agentMailRoute } from "@fungi.computer/shiitake/delegation";
+/** Standalone borrows Shiitake's one Watchdog and Carrier's ordinary durable lane. */
+export declare function agentMail(options: Omit<ConstructorParameters<typeof AgentMail>[0], "post" | "drain"> & {
+    namespace: Parameters<typeof agentMailRoute>[0];
+}): {
+    host: Required<Pick<Readonly<{
+        meta?: import("@fungi.computer/shiitake").HostMetaOptions;
+        model: import("@fungi.computer/shiitake").ModelSource;
+        instructions: import("@fungi.computer/shiitake").InstructionSource;
+        tools?: readonly [] | import("@fungi.computer/shiitake/cloudflare").CloudflareShiitakeTools;
+        storagePressure?: import("@fungi.computer/shiitake").StoragePressureCheck;
+        compaction?: import("@fungi.computer/shiitake").CompactionOptions;
+        extensions: import("@fungi.computer/shiitake").ExtensionRosterV0;
+        initialize?: (agent: import("@fungi.computer/shiitake").ShiitakeOwnerAgent) => Promise<void>;
+        hostWork?: readonly import("@fungi.computer/shiitake/cloudflare").CloudflareHostWork[];
+        hostJobs?: import("@fungi.computer/shiitake/cloudflare").CloudflareHostJobs;
+        mailRoom?: import("@fungi.computer/bird-dog/effect").BirdDogEffect;
+        acp?: (agent: import("@fungi.computer/shiitake").ShiitakeOwnerAgent) => Promise<import("@fungi.computer/shiitake/cloudflare").CloudflareShiitakeAcpServer>;
+    }>, "mailRoom" | "hostJobs" | "hostWork">>;
+    deliver: (value: Parameters<AgentMail["send"]>[0]) => Promise<Readonly<{
+        status: "accepted";
+        commandId: string;
+    }>>;
+};

package/dist/standalone/agent-mail.js

@@ -0,0 +1,62 @@
+import { createPost } from "@fungi.computer/carrier/post";
+import { AgentMail, agentMailRoute } from "@fungi.computer/shiitake/delegation";
+/** Standalone borrows Shiitake's one Watchdog and Carrier's ordinary durable lane. */
+export function agentMail(options) {
+    const routes = {
+        agentMail: agentMailRoute(options.namespace, options.replySettlement),
+    };
+    let post;
+    let tick;
+    const runtime = () => {
+        if (post === undefined)
+            throw new Error("Agent Post is not open");
+        return post;
+    };
+    const recover = async () => {
+        let cursor;
+        do {
+            cursor = await runtime().enqueueDue(64, cursor);
+        } while (cursor !== undefined);
+    };
+    const drain = async () => {
+        await recover();
+        if (tick === undefined)
+            throw new Error("Agent Post lane is not open");
+        await tick();
+    };
+    const mail = new AgentMail({ ...options, post: runtime, drain });
+    const host = {
+        mailRoom: mail.mailRoom(),
+        hostJobs: {
+            lane: "post",
+            open: (owner) => {
+                post = createPost({
+                    routes,
+                    owner: options.storage,
+                    transactional: owner.transactional,
+                    readJob: owner.readJob,
+                    now: Date.now,
+                    scheduleWake: options.wake,
+                });
+                tick = owner.tickConcurrent;
+                return { execute: (job) => runtime().execute(job) };
+            },
+        },
+        hostWork: [
+            {
+                pending: () => {
+                    const nextWakeAt = runtime().nextWake();
+                    return {
+                        due: nextWakeAt !== null && nextWakeAt <= Date.now(),
+                        nextWakeAt,
+                    };
+                },
+                run: drain,
+            },
+        ],
+    };
+    return {
+        host,
+        deliver: (value) => mail.send(value),
+    };
+}

package/dist/standalone/agent-store.d.ts

@@ -0,0 +1,9 @@
+import type { ColdSessionPage, ColdSessionPageRequest } from "@fungi.computer/shiitake";
+import type { CloudflareShiitakeOptions } from "@fungi.computer/shiitake/cloudflare";
+import { type DurableObjectSizedStorage } from "@fungi.computer/zookeeper";
+/**
+ * An Oyster Agent's store keeping: Zookeeper's admission check and patrol over
+ * the one Durable Object budget. Shiitake's agent pack only; the Pi Durable
+ * pack keeps its own store.
+ */
+export declare function agentStoreKeeping(storage: DurableObjectSizedStorage, readColdSessions: (request: ColdSessionPageRequest) => Promise<ColdSessionPage>): Required<Pick<CloudflareShiitakeOptions, "hostWork" | "storagePressure">>;

package/dist/standalone/agent-store.js

@@ -0,0 +1,30 @@
+import { durableObjectStorageBudget, openPatrol, openStoragePressure, } from "@fungi.computer/zookeeper";
+/** Log what a Zookeeper patrol pass measured; a quiet store logs nothing. */
+function reportPatrol(report) {
+    if (report.status === "quiet")
+        return;
+    if (report.status === "unavailable") {
+        console.warn("agent zookeeper patrol unavailable", {
+            stage: report.source,
+            code: report.failure,
+        });
+        return;
+    }
+    console.info("agent zookeeper patrol measured", {
+        storeBytes: report.usedBytes,
+        sessionBytes: report.sessionBytes,
+        sessionCount: report.sessions,
+    });
+}
+/**
+ * An Oyster Agent's store keeping: Zookeeper's admission check and patrol over
+ * the one Durable Object budget. Shiitake's agent pack only; the Pi Durable
+ * pack keeps its own store.
+ */
+export function agentStoreKeeping(storage, readColdSessions) {
+    const budget = durableObjectStorageBudget(storage);
+    return {
+        hostWork: [openPatrol({ budget, readColdSessions, report: reportPatrol })],
+        storagePressure: openStoragePressure(budget),
+    };
+}

package/dist/standalone/agents.d.ts

@@ -1,4 +1,7 @@
 import { type StandaloneTenancyEnv } from "./tenancy.js";
+import type { PostEnvelope } from "@fungi.computer/carrier/post";
+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";
 import { DurableObject } from "cloudflare:workers";
 import type { StandaloneComputerEnv } from "./computer.js";
 import { ShiitakeDO } from "@fungi.computer/shiitake/cloudflare";
@@ -6,6 +9,7 @@ import type { CloudflareShiitakeOptions } from "@fungi.computer/shiitake/cloudfl
 import { type AiBinding } from "@earendil-works/pi-ai/api/cloudflare-ai-binding";
 import * as Schema from "effect/Schema";
 import { type FrameBindingProps } from "../cloudflare.js";
+import type { Avatar } from "@fungi.computer/sprite/avatar";
 import type { InvocationFrame } from "../invocation.js";
 import type { OysterJson } from "../host.js";
 import { type FleetMessage } from "@fungi.computer/shiitake/fleet";
@@ -19,10 +23,12 @@ import { type AgentMcpServer, type AgentMcpServerInput, type AgentMcpServerRefus
 import type { AgentPolicyActor, OysterAgents, OysterSessionRow } from "../agents.js";
 /** The model door an agent runs on; Shiitake's own contract. */
 export type StandaloneModelSource = CloudflareShiitakeOptions["model"];
-/** One directory entry: an agent's id and display name. */
+/** One directory entry: an agent's id, display name and own avatar. */
 export type AgentEntry = Readonly<{
     agentId: string;
+    createdBy: string | null;
     name: string;
+    avatar: Avatar;
 }>;
 /** Bindings the agent host reads. */
 export type StandaloneAgentsEnv = Readonly<{
@@ -49,7 +55,7 @@ export type StandaloneAgentsEnv = Readonly<{
     AGENT_DIRECTORY: DurableObjectNamespace<AgentDirectory>;
 }>;
 /** An agent host's whole env: its own bindings and the Oyster's. */
-export type StandaloneAgentEnv = StandaloneAgentsEnv & OysterWorkerEnv & StandaloneComputerEnv;
+export type StandaloneAgentEnv = StandaloneAgentsEnv & OysterWorkerEnv & StandaloneComputerEnv & StandaloneMachineLinkBindings;
 declare const policyDirectorySchema: Schema.Struct<{
     readonly directoryName: Schema.NonEmptyString;
     readonly tenantId: Schema.brand<Schema.String, "OysterTenantId">;
@@ -63,7 +69,24 @@ export type AgentInboxRows = Readonly<{
 export declare abstract class StandaloneAgentBase<Env extends StandaloneAgentEnv = StandaloneAgentEnv> extends ShiitakeDO<Env> {
     #private;
     /** The deployable root's host for this Agent's pinned tenant. */
-    protected abstract hostFor(scope: TenantScope): OysterHost;
+    protected abstract hostFor(scope: TenantScope): Promise<OysterHost>;
+    private uiOwner;
+    private machineClient;
+    private ui;
+    protected hostFetch(request: Request): Promise<Response> | undefined;
+    protected closeShiitake(): Promise<void>;
+    private controlDirectory;
+    private delegationOwner;
+    private delegation;
+    /** Host-only mail admission; an HTTP caller never receives this binding. */
+    deliver(envelope: PostEnvelope): Promise<import("@fungi.computer/carrier/post").PostDeliveryResult>;
+    private mailOwner;
+    private conversationAgentsOwner;
+    /** The Agents each of this Agent's conversations created or sent work to. */
+    private conversationAgents;
+    private mail;
+    /** Undefined is disclosure refusal; unavailable evidence fails before RPC. */
+    settlement(principal: MachineAgentSettlementPrincipal, sessionId: string, commandId: string): Promise<string | undefined>;
     /** The root host for this Agent's pinned policy directory; unpinned Agents have no App tools. */
     private appHost;
     /** Choose this agent's model door; override to plug in another. */
@@ -85,7 +108,7 @@ export declare abstract class StandaloneAgentBase<Env extends StandaloneAgentEnv
     addMcpServer(input: AgentMcpServerInput): Promise<AgentMcpServer | AgentMcpServerRefusal>;
     /** Host-only: disconnect one MCP server. */
     removeMcpServer(serverId: string): Promise<boolean>;
-    protected shiitakeOptions(): CloudflareShiitakeOptions;
+    protected shiitakeOptions(): Promise<CloudflareShiitakeOptions>;
     /** Send an installation-admitted message through fleet Session operations. */
     sendFromApp(installationId: string, sessionId: string, message: FleetMessage): Promise<{
         sessionId: string;
@@ -100,7 +123,45 @@ export declare abstract class StandaloneAgentBase<Env extends StandaloneAgentEnv
 /** Names this Oyster's agents and remembers which Sessions the member opened. */
 export declare class AgentDirectory extends DurableObject<StandaloneAgentEnv> {
     private readonly directory;
+    private readonly avatars;
     private composedTenancy;
+    private machineEnrollmentOwner;
+    private machineFencesOwner;
+    private machineScope;
+    private machineEnrollment;
+    /** Host-only join: consumption, enrollment and directory share one commit. */
+    enrollMachine(keyId: string, input: MachineEnrollment): Promise<StandaloneMachineJoinResult>;
+    machineDevice(id: MachineLinkIdentity): Promise<import("../machine-link/authority.js").MachineLinkDeviceFacts>;
+    machineFence(id: MachineLinkIdentity): Promise<Readonly<{
+        teamId: string;
+        deviceId: string;
+    } & {
+        live: boolean;
+        fenceEpoch: number;
+    }> | null>;
+    machineDirectory(id: MachineLinkIdentity): Promise<{
+        agentId: import("@fungi.computer/shiitake/fleet").AgentId;
+        name: string;
+    }[]>;
+    machineTarget(caller: MachineLinkCaller, agentId: string, requester: string | null): Promise<Readonly<{
+        teamId: string;
+        callerAgentId: string;
+        targetAgentId: string;
+        actorAgentId: string;
+        callerHome: MachineAgentHome;
+        targetHome: MachineAgentHome;
+    }>>;
+    machineKeyRetired(deviceId: string): boolean;
+    /** Catalog home only; no hosted DO is opened to discover a machine home. */
+    agentHome(agentId: string): Promise<MachineAgentHome | null>;
+    private machineFences;
+    private armMachineFenceAlarm;
+    /** Only the current canonical owner can retire a device, before fence push. */
+    revokeMachineDevice(memberId: string, deviceId: string): Promise<{
+        kind: "unconfirmed" | "confirmed";
+        fenceEpoch: number;
+    } | null>;
+    alarm(): Promise<void>;
     private grant;
     constructor(ctx: DurableObjectState, env: StandaloneAgentEnv);
     list(): readonly AgentEntry[];
@@ -111,7 +172,11 @@ export declare class AgentDirectory extends DurableObject<StandaloneAgentEnv> {
     rename(agentId: string, name: string, principal: OysterPrincipal): AgentEntry | Readonly<{
         error: "not_found" | "name_taken" | "not_granted";
     }>;
-    create(name: string, requestId: string, principal: OysterPrincipal, actor: AgentPolicyActor): AgentEntry & {
+    /** Owner-only avatar change; the Agent wears it in every App and list. */
+    setAvatar(agentId: string, avatar: Avatar, principal: OysterPrincipal): AgentEntry | Readonly<{
+        error: "not_found" | "not_granted";
+    }>;
+    create(name: string, requestId: string, principal: OysterPrincipal, actor: AgentPolicyActor, avatar?: Avatar, createdBy?: string | null): AgentEntry & {
         policyRevision: string | null;
     };
     private writePolicy;
@@ -153,10 +218,10 @@ export declare const agentFrameMethods: {
             decodeResult: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => {
                 readonly items: readonly ({
                     readonly agentId: string;
-                    readonly title: string;
-                    readonly state: "done" | "running" | "needs_you" | "errored";
-                    readonly createdAt: number;
                     readonly sessionId: string;
+                    readonly createdAt: number;
+                    readonly title: string;
+                    readonly state: "done" | "running" | "errored" | "needs_you";
                     readonly lastActivityAt: number;
                     readonly triggerId?: string | undefined;
                     readonly settledAt?: number | undefined;
@@ -166,21 +231,21 @@ export declare const agentFrameMethods: {
                     readonly sessionId: string;
                     readonly state: "unavailable";
                 } | {
-                    readonly kind: "workflow-review";
-                    readonly installationId: string;
                     readonly key: {
                         readonly runId: string;
                         readonly nodeId: string;
                         readonly iteration: string;
                     };
-                    readonly state: "pending" | "delivered" | "answered" | "timed_out" | "closed";
+                    readonly kind: "workflow-review";
+                    readonly installationId: string;
+                    readonly expiresAt: number;
                     readonly workflowId: string | null;
+                    readonly state: "pending" | "delivered" | "answered" | "timed_out" | "closed";
                     readonly workflowTitle: string;
                     readonly reviewTitle: string;
                     readonly reviewers: "runner" | "owners";
                     readonly show: readonly Schema.Json[];
                     readonly openedAt: number;
-                    readonly expiresAt: number;
                     readonly choices?: readonly string[] | undefined;
                 })[];
                 readonly next: null;
@@ -204,6 +269,7 @@ export declare const agentFrameMethods: {
             decodeArgs: (raw: readonly unknown[]) => [{
                 agentId: string;
                 sessionId: string;
+                requestId: string;
                 text: string;
                 delivery: "followUp";
             }];