@fungi.computer/oyster 0.1.0 → 0.2.0

package/dist/agent-avatars.d.ts

@@ -0,0 +1,103 @@
+/**
+ * An Agent's avatar is host data on the Agent, beside its directory record:
+ * the one the owner chose, else Sprite's `seededAvatar(agentId)`. The seeded
+ * default is a pure function of identity, so it is computed, never stored,
+ * and an Agent created before any choice needs no stored row. Conversations
+ * carry no avatar of their own. Both hosts (the Hub's Team store and a
+ * standalone Oyster's Agent directory) keep the row in the same owner-local
+ * SQLite as the directory, so a choice commits and erases with its Agent.
+ */
+import type { WatchdogSqliteOwner } from "@fungi.computer/watchdog";
+import { type Avatar } from "@fungi.computer/sprite/avatar";
+import { z } from "zod";
+/** The catalog-valid avatar an owner may choose for an Agent. */
+export declare const agentAvatarSchema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    character: z.ZodEnum<{
+        mushroom: "mushroom";
+        cat: "cat";
+        burger: "burger";
+    }>;
+    appearance: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    expression: z.ZodString;
+    renderStyle: z.ZodEnum<{
+        plain: "plain";
+        pencil: "pencil";
+        manga: "manga";
+        riso: "riso";
+        halftone: "halftone";
+        blueprint: "blueprint";
+        crt: "crt";
+        watercolor: "watercolor";
+    }>;
+}, z.core.$strict>;
+/**
+ * The avatar as a closed record, for contracts that refuse open maps (Hub
+ * projections): each character's appearance names only its own controls,
+ * then the catalog refines it exactly as `agentAvatarSchema` does.
+ */
+export declare const agentAvatarProjectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    character: z.ZodLiteral<"mushroom">;
+    appearance: z.ZodObject<{
+        [x: string]: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>;
+    expression: z.ZodString;
+    renderStyle: z.ZodEnum<{
+        plain: "plain";
+        pencil: "pencil";
+        manga: "manga";
+        riso: "riso";
+        halftone: "halftone";
+        blueprint: "blueprint";
+        crt: "crt";
+        watercolor: "watercolor";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    character: z.ZodLiteral<"cat">;
+    appearance: z.ZodObject<{
+        [x: string]: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>;
+    expression: z.ZodString;
+    renderStyle: z.ZodEnum<{
+        plain: "plain";
+        pencil: "pencil";
+        manga: "manga";
+        riso: "riso";
+        halftone: "halftone";
+        blueprint: "blueprint";
+        crt: "crt";
+        watercolor: "watercolor";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    character: z.ZodLiteral<"burger">;
+    appearance: z.ZodObject<{
+        [x: string]: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    }, z.core.$strict>;
+    expression: z.ZodString;
+    renderStyle: z.ZodEnum<{
+        plain: "plain";
+        pencil: "pencil";
+        manga: "manga";
+        riso: "riso";
+        halftone: "halftone";
+        blueprint: "blueprint";
+        crt: "crt";
+        watercolor: "watercolor";
+    }>;
+}, z.core.$strict>], "character">;
+/** A projected avatar as the Avatar descriptor Sprite draws. */
+export declare function avatarFromProjection(projected: z.infer<typeof agentAvatarProjectionSchema>): Avatar;
+/** One owner-local store of chosen Agent avatars. */
+export type AgentAvatarStore = Readonly<{
+    /** The Agent's avatar: its chosen one, else its seeded default. */
+    read(agentId: string): Avatar;
+    /** Record the owner's choice; the caller owns the Agent's existence. */
+    write(agentId: string, avatar: Avatar): void;
+    /** Forget a removed Agent's choice in the caller's removal transaction. */
+    remove(agentId: string): void;
+}>;
+/** Open the chosen-avatar table in the Agent directory's own SQLite. */
+export declare function createAgentAvatarStore(sql: WatchdogSqliteOwner["sql"]): AgentAvatarStore;

package/dist/agent-avatars.js

@@ -0,0 +1,66 @@
+import { seededAvatar } from "@fungi.computer/sprite/avatar";
+import { avatarSchema } from "@fungi.computer/sprite-zdog/avatar";
+import { avatarCatalog } from "@fungi.computer/sprite-zdog/catalog";
+import { renderStyleSchema } from "@fungi.computer/sprite";
+import { z } from "zod";
+const storedAvatarRowSchema = z.strictObject({ avatar: z.string() });
+/** The catalog-valid avatar an owner may choose for an Agent. */
+export const agentAvatarSchema = avatarSchema;
+const appearanceValue = z.union([z.string(), z.number(), z.boolean()]);
+/** One character's avatar with its appearance closed to that character's controls. */
+function closedCharacterAvatar(character) {
+    return z.strictObject({
+        v: z.literal(1),
+        character: z.literal(character),
+        appearance: z.strictObject(Object.fromEntries(Object.keys(avatarCatalog[character].controls).map((control) => [
+            control,
+            appearanceValue.optional(),
+        ]))),
+        expression: z.string().min(1),
+        renderStyle: renderStyleSchema,
+    });
+}
+/**
+ * The avatar as a closed record, for contracts that refuse open maps (Hub
+ * projections): each character's appearance names only its own controls,
+ * then the catalog refines it exactly as `agentAvatarSchema` does.
+ */
+export const agentAvatarProjectionSchema = z
+    .discriminatedUnion("character", [
+    closedCharacterAvatar("mushroom"),
+    closedCharacterAvatar("cat"),
+    closedCharacterAvatar("burger"),
+])
+    .superRefine((avatar, context) => {
+    for (const issue of agentAvatarSchema.safeParse(avatar).error?.issues ?? [])
+        context.addIssue({
+            code: "custom",
+            path: issue.path,
+            message: issue.message,
+        });
+});
+/** A projected avatar as the Avatar descriptor Sprite draws. */
+export function avatarFromProjection(projected) {
+    return agentAvatarSchema.parse(projected);
+}
+/** Open the chosen-avatar table in the Agent directory's own SQLite. */
+export function createAgentAvatarStore(sql) {
+    sql.exec("CREATE TABLE IF NOT EXISTS agent_avatars (agent_id TEXT PRIMARY KEY, avatar TEXT NOT NULL) STRICT");
+    return {
+        read(agentId) {
+            const row = sql
+                .exec("SELECT avatar FROM agent_avatars WHERE agent_id = ?", agentId)
+                .toArray()[0];
+            if (row === undefined)
+                return seededAvatar(agentId);
+            const stored = storedAvatarRowSchema.parse(row);
+            return agentAvatarSchema.parse(JSON.parse(stored.avatar));
+        },
+        write(agentId, avatar) {
+            sql.exec("INSERT INTO agent_avatars(agent_id, avatar) VALUES(?, ?) ON CONFLICT(agent_id) DO UPDATE SET avatar = excluded.avatar", agentId, JSON.stringify(agentAvatarSchema.parse(avatar)));
+        },
+        remove(agentId) {
+            sql.exec("DELETE FROM agent_avatars WHERE agent_id = ?", agentId);
+        },
+    };
+}

package/dist/agents.d.ts

@@ -10,11 +10,14 @@ import type { AppToolPolicy } from "./apps/tools.js";
 import * as Schema from "effect/Schema";
 import { type OysterCapability, type OysterEnv, type OysterPrincipal } from "./host.js";
 import type { HostActor } from "@fungi.computer/puffball/app";
+import type { Avatar } from "@fungi.computer/sprite/avatar";
 import type { MemberInboxItem, MemberInboxSession } from "@fungi.computer/puffball/inbox";
 /** One agent as Apps see it, in Agar's `appAgentSchema` shape. */
 export type OysterAgent = Readonly<{
     agentId: string;
     name: string;
+    /** The Agent's own avatar: the owner's choice, else its seeded default. */
+    avatar: Avatar;
     sessionOperations: readonly ("agent.read" | "agent.send" | "agent.manage")[];
 }>;
 /** An Agent owner's Session facts before the member identity and visit are added. */
@@ -70,12 +73,19 @@ export type AgentToolPolicyStatus = Readonly<{
 export type OysterAgents = Readonly<{
     /** Every agent, oldest first. */
     list(): Promise<readonly OysterAgent[]>;
-    /** Create an agent; retrying with the same `requestId` returns the same one. */
-    create(name: string, requestId: string, principal: OysterPrincipal, actor: AgentPolicyActor): Promise<OysterAgent>;
+    /**
+     * Create an agent; retrying with the same `requestId` returns the same one.
+     * With no `avatar` it wears its seeded default until the owner picks one.
+     */
+    create(name: string, requestId: string, principal: OysterPrincipal, actor: AgentPolicyActor, avatar?: Avatar): Promise<OysterAgent>;
     /** Owner-only rename; refuses a name already held by another Agent. */
     rename(agentId: string, name: string, principal: OysterPrincipal): Promise<OysterAgent | Readonly<{
         error: "not_found" | "name_taken" | "not_granted";
     }>>;
+    /** Owner-only avatar change for an existing Agent. */
+    setAvatar(agentId: string, avatar: Avatar, principal: OysterPrincipal): Promise<OysterAgent | Readonly<{
+        error: "not_found" | "not_granted";
+    }>>;
     /** This Agent's App-tool policy status, or `null` for no such Agent. */
     policyStatus(agentId: string): Promise<AgentToolPolicyStatus | null>;
     /** Read this Agent's stored App-tool approval; absence requires re-approval. A key's App access is its own grants (Ear Tag), not this policy. */

package/dist/agents.js

@@ -7,8 +7,10 @@
  */
 import { Hono } from "hono";
 import * as Schema from "effect/Schema";
+import { z } from "zod";
 import { oysterPrincipalIsOwner, } from "./host.js";
-import { agentList, agentManage, agentRename, agentSessionRead, agentSessionWrite, agentToolPolicy, } from "@fungi.computer/agar/agents";
+import { agentAvatarSchema } from "./agent-avatars.js";
+import { agentAvatar, agentList, agentManage, agentRename, agentSessionRead, agentSessionWrite, agentToolPolicy, } from "@fungi.computer/agar/agents";
 /** At most this many MCP servers per Agent. */
 export const maxAgentMcpServers = 16;
 /** Owner input for one MCP server: a guest identifier, an `https:` endpoint and an optional bearer. */
@@ -30,10 +32,12 @@ export const agentMcpServerInputSchema = Schema.Struct({
 const createSchema = Schema.Struct({
     name: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256)),
     requestId: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_.:-]{1,256}$/u)),
+    avatar: Schema.optionalKey(Schema.Unknown),
 });
 const renameSchema = Schema.Struct({
     name: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(256)),
 });
+const avatarInputSchema = z.object({ avatar: agentAvatarSchema });
 const visitSchema = Schema.Struct({
     agentId: Schema.String,
     sessionId: Schema.String,
@@ -76,6 +80,19 @@ export function agentCapabilities(agents) {
                 rename: { kind: "json", method: "PUT", path: "agent-names/:agentId" },
             },
         },
+        {
+            ...shared,
+            id: "agent.avatar",
+            permission: "agent.avatar",
+            version: agentAvatar.version,
+            methods: {
+                setAvatar: {
+                    kind: "json",
+                    method: "PUT",
+                    path: "agent-avatars/:agentId",
+                },
+            },
+        },
         {
             ...shared,
             id: "agent.toolPolicy",
@@ -126,9 +143,14 @@ function createAgentRoutes(agents) {
         const body = Schema.decodeUnknownOption(createSchema)(await context.req.json());
         if (body._tag === "None")
             return refusal(400, "Name the agent");
+        const avatar = body.value.avatar === undefined
+            ? undefined
+            : agentAvatarSchema.safeParse(body.value.avatar);
+        if (avatar?.success === false)
+            return refusal(400, "Choose a valid avatar");
         // The owner's own authenticated request creates this Agent; its App tools
         // are approved the same way direct owner approval is, with no second path.
-        return Response.json(await agents.create(body.value.name, body.value.requestId, principal, "owner-direct"));
+        return Response.json(await agents.create(body.value.name, body.value.requestId, principal, "owner-direct", avatar?.data));
     });
     routes.put("/agent-names/:agentId", async (context) => {
         const { principal } = context.env;
@@ -149,6 +171,21 @@ function createAgentRoutes(agents) {
                     : 403, result.error);
         return Response.json(result);
     });
+    routes.put("/agent-avatars/:agentId", async (context) => {
+        const { principal } = context.env;
+        if (!oysterPrincipalIsOwner(principal))
+            return refusal(403, "Only the owner changes avatars");
+        const agentId = context.req.param("agentId");
+        if (!agentIdPattern.test(agentId))
+            return refusal(404, "No such agent");
+        const body = avatarInputSchema.safeParse(await context.req.json());
+        if (!body.success)
+            return refusal(400, "Choose a valid avatar");
+        const result = await agents.setAvatar(agentId, body.data.avatar, principal);
+        if ("error" in result)
+            return refusal(result.error === "not_found" ? 404 : 403, result.error);
+        return Response.json(result);
+    });
     routes.get("/agent-policies/:agentId", async (context) => {
         const agentId = context.req.param("agentId");
         if (!agentIdPattern.test(agentId))

package/dist/apps/gate.d.ts

@@ -10,7 +10,7 @@ export type HostPrincipal = Readonly<{
     role: "owner" | "member" | null;
 }>;
 /** Requests select existing SDK methods, opaque backend calls and derived operation identities. */
-export declare const gateRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const gateRequestSchema: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"method">;
     name: z.ZodString;
     input: z.ZodUnknown;
@@ -22,7 +22,7 @@ export declare const gateRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"capability-route">;
-    capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+    capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
     operation: z.ZodString;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"binding">;
@@ -32,7 +32,7 @@ export declare const gateRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"list-tools">;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"backend">;
-}, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">>;
 /** One decoded method, route, binding or catalog admission request. */
 export type GateRequest = z.output<typeof gateRequestSchema>;
 /** Immutable values the host already read; resource/grantor freshness remains host-owned. */
@@ -49,16 +49,16 @@ export type GateFacts = Readonly<{
     }>;
 }>;
 /** Binding grants have the exact S2 InvocationFacts shape and its maintained registry grammar. */
-export declare const invocationGrantsSchema: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+export declare const invocationGrantsSchema: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodObject<{
     binding: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"BACKGROUND" | "GIT" | "EVENTS" | "APPS" | "WORKFLOWS" | "APP_STORAGE" | "MEDIA" | "COMPUTER" | "INBOX" | "AGENTS", unknown>>;
     operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>>>;
+}, z.core.$strict>>>>;
 /** The explicit binding ceiling passed to an invocation frame. */
 export type InvocationGrants = z.output<typeof invocationGrantsSchema>;
 /** A declared method from the canonical Puffball API grammar. */
 export type AppMethodDeclaration = AppApi["methods"][string];
 /** Ordered, closed refusal vocabulary; external methods always require approval. */
-export declare const gateRefusalSchema: z.ZodObject<{
+export declare const gateRefusalSchema: z.ZodLazy<z.ZodObject<{
     kind: z.ZodLiteral<"refused">;
     code: z.ZodEnum<{
         unavailable: "unavailable";
@@ -71,7 +71,7 @@ export declare const gateRefusalSchema: z.ZodObject<{
         invalid_input: "invalid_input";
         visitor_read_only: "visitor_read_only";
     }>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 /** Either an admitted scoped ceiling or one closed refusal code. */
 export type GateDecision = Readonly<{
     kind: "admitted";

package/dist/apps/gate.js

@@ -8,7 +8,7 @@ import { appToolAccessSchema } from "./tools.js";
 import { ownerCodec, } from "./installation.js";
 const bindingNameSchema = ownerCodec(Schema.Literals(Object.values(appBackendBindingKinds).map((kind) => kind.name)));
 /** Requests select existing SDK methods, opaque backend calls and derived operation identities. */
-export const gateRequestSchema = z.discriminatedUnion("kind", [
+export const gateRequestSchema = z.lazy(() => z.discriminatedUnion("kind", [
     z.strictObject({
         kind: z.literal("method"),
         name: z.string(),
@@ -27,9 +27,9 @@ export const gateRequestSchema = z.discriminatedUnion("kind", [
     }),
     z.strictObject({ kind: z.literal("list-tools") }),
     z.strictObject({ kind: z.literal("backend") }),
-]);
+]));
 /** Binding grants have the exact S2 InvocationFacts shape and its maintained registry grammar. */
-export const invocationGrantsSchema = z
+export const invocationGrantsSchema = z.lazy(() => z
     .array(z.strictObject({
     binding: bindingNameSchema,
     operations: z.array(z.string().min(1)).readonly(),
@@ -38,9 +38,9 @@ export const invocationGrantsSchema = z
     name: grant.binding,
     operations: grant.operations,
 }))), "Invalid declared binding operations")
-    .readonly();
+    .readonly());
 /** Ordered, closed refusal vocabulary; external methods always require approval. */
-export const gateRefusalSchema = z.strictObject({
+export const gateRefusalSchema = z.lazy(() => z.strictObject({
     kind: z.literal("refused"),
     code: z.enum([
         "unavailable",
@@ -53,7 +53,7 @@ export const gateRefusalSchema = z.strictObject({
         "invalid_input",
         "visitor_read_only",
     ]),
-});
+}));
 /** Intersect stored approvals with the current verified Release without widening resource selectors. */
 export function grantsFor(installation, declaration, snapshot, capability) {
     if (installation.status !== "enabled" ||

package/dist/apps/installation.d.ts

@@ -6,7 +6,7 @@ import type { CapabilityDescriptor } from "../capability-descriptor.js";
 /** Reuse the owning Effect codec at a JSON/storage boundary. */
 export declare function ownerCodec<A, I>(schema: Schema.Codec<A, I>): z.ZodPipe<z.ZodUnknown, z.ZodTransform<Awaited<A>, unknown>>;
 /** Installation names cannot contain the tenant separator. */
-export declare const installationIdSchema: z.ZodString;
+export declare const installationIdSchema: z.ZodLazy<z.ZodString>;
 export type ResourceRef = Exclude<ApprovedGrant["resources"], "tenant-scope">[number];
 /**
  * Consent approves capabilities, with explicit operation and resource ceilings.
@@ -21,13 +21,13 @@ export type ResourceRef = Exclude<ApprovedGrant["resources"], "tenant-scope">[nu
  * Exact operation rows are enforced for capability routes and backend bindings.
  */
 export declare const approvedGrantSchema: z.ZodReadonly<z.ZodObject<{
-    capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+    capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
     capabilityApproved: z.ZodLiteral<true>;
-    operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+    operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
         kind: z.ZodString;
         id: z.ZodString;
-    }, z.core.$strict>>>>]>;
+    }, z.core.$strict>>>>>]>;
 }, z.core.$strict>>;
 export type ApprovedGrant = Readonly<z.output<typeof approvedGrantSchema>>;
 export type GrantRequest = Extract<InstallationCommand, {
@@ -35,7 +35,7 @@ export type GrantRequest = Extract<InstallationCommand, {
 }>["grants"];
 export type Approval = NonNullable<Installation["approval"]>;
 /** Immutable operation facts derived from descriptor methods and the binding registry. */
-export declare const declaredOperationsSchema: z.ZodObject<{
+export declare const declaredOperationsSchema: z.ZodLazy<z.ZodObject<{
     artifactDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     anonymousMethods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
@@ -43,10 +43,10 @@ export declare const declaredOperationsSchema: z.ZodObject<{
         digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     }, z.core.$strict>>>>;
     capabilities: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
-        operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+        operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
     }, z.core.$strict>>>>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 export type DeclaredOperations = Readonly<z.output<typeof declaredOperationsSchema>>;
 /** Use the existing adapter's permission and methods; hosts author no operation lists. */
 export type CapabilityOperationDescriptor = Pick<CapabilityDescriptor, "id" | "methods"> & Readonly<{
@@ -54,7 +54,7 @@ export type CapabilityOperationDescriptor = Pick<CapabilityDescriptor, "id" | "m
 }>;
 /** Resolved immutable Release plus host-owned installation and approval state. */
 export declare const installationSchema: z.ZodObject<{
-    installationId: z.ZodString;
+    installationId: z.ZodLazy<z.ZodString>;
     instanceId: z.ZodNullable<z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("../index.js").InstanceId, unknown>>>;
     appId: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").AppId, unknown>>;
     release: z.ZodPipe<z.ZodUnknown, z.ZodTransform<{
@@ -74,7 +74,7 @@ export declare const installationSchema: z.ZodObject<{
         pinned: "pinned";
         floating: "floating";
     }>;
-    authorityVersion: z.ZodNumber;
+    authorityVersion: z.ZodLazy<z.ZodNumber>;
     status: z.ZodEnum<{
         enabled: "enabled";
         disabled: "disabled";
@@ -85,16 +85,16 @@ export declare const installationSchema: z.ZodObject<{
         public: "public";
     }>;
     declaredOperationsDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
-    approvedGrants: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+    approvedGrants: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
         capabilityApproved: z.ZodLiteral<true>;
-        operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
             kind: z.ZodString;
             id: z.ZodString;
-        }, z.core.$strict>>>>]>;
-    }, z.core.$strict>>>>;
-    approval: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+        }, z.core.$strict>>>>>]>;
+    }, z.core.$strict>>>>>;
+    approval: z.ZodNullable<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
         by: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
             kind: import("zod/mini").ZodMiniLiteral<"member">;
             memberId: import("zod/mini").ZodMiniString<string>;
@@ -106,13 +106,13 @@ export declare const installationSchema: z.ZodObject<{
             keyId: import("zod/mini").ZodMiniString<string>;
         }, z.core.$strip>], "kind">;
         at: z.ZodNumber;
-        authorityVersion: z.ZodNumber;
-    }, z.core.$strict>>>;
+        authorityVersion: z.ZodLazy<z.ZodNumber>;
+    }, z.core.$strict>>>>;
     approvedAnonymousMethods: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
         name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
         digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     }, z.core.$strict>>>>;
-    anonymousApproval: z.ZodNullable<z.ZodReadonly<z.ZodObject<{
+    anonymousApproval: z.ZodNullable<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
         by: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
             kind: import("zod/mini").ZodMiniLiteral<"member">;
             memberId: import("zod/mini").ZodMiniString<string>;
@@ -124,19 +124,19 @@ export declare const installationSchema: z.ZodObject<{
             keyId: import("zod/mini").ZodMiniString<string>;
         }, z.core.$strip>], "kind">;
         at: z.ZodNumber;
-        authorityVersion: z.ZodNumber;
-    }, z.core.$strict>>>;
+        authorityVersion: z.ZodLazy<z.ZodNumber>;
+    }, z.core.$strict>>>>;
 }, z.core.$strict>;
 export type Installation = Readonly<z.output<typeof installationSchema>>;
 /** Host commands; floating targets have already been resolved to immutable Releases. */
-export declare const installationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const installationCommandSchema: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
     grants: z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"declared">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
-        operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+        operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
             kind: z.ZodString;
             id: z.ZodString;
-        }, z.core.$strict>>>>]>;
+        }, z.core.$strict>>>>>]>;
     }, z.core.$strict>>>>]>;
     release: z.ZodPipe<z.ZodUnknown, z.ZodTransform<{
         readonly releaseId: import("@fungi.computer/puffball").ReleaseId;
@@ -191,12 +191,12 @@ export declare const installationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodOb
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"set-grants">;
     grants: z.ZodUnion<readonly [z.ZodLiteral<"none">, z.ZodLiteral<"declared">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
-        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
-        operations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"agent.list" | "agent.manage" | "agent.rename" | "agent.avatar" | "agent.toolPolicy" | "agent.read" | "agent.send" | "computer.list" | "computer.readFile" | "computer.writeFile" | "computer.execute" | "llm.generation" | "media.generation" | "games:servers" | "git.repository" | "apps.open" | "apps.call" | "app.storage" | "app.events.emit" | "team.workbenchHost" | "marketplace.browse" | "marketplace.purchase" | "workflow.run" | "workflow.publish" | "workflow.arm" | "world" | "channels.read" | "channels.personal.manage", unknown>>;
+        operations: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        resources: z.ZodUnion<readonly [z.ZodLiteral<"tenant-scope">, z.ZodReadonly<z.ZodArray<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
             kind: z.ZodString;
             id: z.ZodString;
-        }, z.core.$strict>>>>]>;
+        }, z.core.$strict>>>>>]>;
     }, z.core.$strict>>>>]>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"approve-anonymous">;
@@ -204,7 +204,7 @@ export declare const installationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         name: z.ZodPipe<z.ZodUnknown, z.ZodTransform<string, unknown>>;
         digest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
     }, z.core.$strict>>>>;
-}, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">>;
 export type InstallationCommand = z.output<typeof installationCommandSchema>;
 /** Values captured by the host; identities and time are never generated by the reducer. */
 export type InstallationContext = Readonly<{
@@ -221,7 +221,7 @@ export type InstallationContext = Readonly<{
     }>;
 }>;
 /** Closed refusals: failed commands produce no installation update. */
-export declare const installationRefusalSchema: z.ZodObject<{
+export declare const installationRefusalSchema: z.ZodLazy<z.ZodObject<{
     kind: z.ZodLiteral<"refused">;
     code: z.ZodEnum<{
         unavailable: "unavailable";
@@ -231,7 +231,7 @@ export declare const installationRefusalSchema: z.ZodObject<{
         not_owner: "not_owner";
         invalid_command: "invalid_command";
     }>;
-}, z.core.$strict>;
+}, z.core.$strict>>;
 export type InstallationRefusal = z.output<typeof installationRefusalSchema>;
 export type InstallationUpdate = Readonly<{
     next: Installation;