@fungi.computer/oyster 0.1.0 → 0.3.0

package/dist/apps/gate.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod";
 import { type AppApi, type AppDeclaration, type HostActor } from "@fungi.computer/puffball/app";
 import { type AppToolAccess } from "./tools.js";
-import { type DeclaredOperations, type Installation, type ApprovedGrant } from "./installation.js";
+import { type ResourceRef, type DeclaredOperations, type Installation, type ApprovedGrant } from "./installation.js";
 /** Attested by the host, never authenticated by decoding request JSON. */
 export type HostPrincipal = Readonly<{
     actor: HostActor | Readonly<{
@@ -10,19 +10,31 @@ 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;
     via: z.ZodEnum<{
-        ui: "ui";
         agent: "agent";
         mcp: "mcp";
+        ui: "ui";
         workflow: "workflow";
     }>;
+    resource: z.ZodOptional<z.ZodLazy<z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"capability">;
+    capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "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.ZodOptional<z.ZodString>;
+    resource: z.ZodUnion<readonly [z.ZodLazy<z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>>, z.ZodLiteral<"any">]>;
 }, 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<"approvals" | "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,13 +44,15 @@ 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. */
 export type GateFacts = Readonly<{
     principal: HostPrincipal;
-    installation: Installation;
+    installation: Readonly<Pick<Installation, "status" | "visibility" | "instanceId" | "authority"> & {
+        artifactDigest: string;
+    }>;
     declaration: AppDeclaration;
     declaredOperations: DeclaredOperations;
     api: AppApi | null;
@@ -49,16 +63,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 +85,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";
@@ -79,10 +93,10 @@ export type GateDecision = Readonly<{
     method?: AppMethodDeclaration;
 }> | z.output<typeof gateRefusalSchema>;
 /** Intersect stored approvals with the current verified Release without widening resource selectors. */
-export declare function grantsFor(installation: Installation, declaration: AppDeclaration, snapshot: DeclaredOperations, capability: ApprovedGrant["capability"]): ApprovedGrant | null;
+export declare function grantsFor(installation: Pick<GateFacts["installation"], "status" | "authority" | "artifactDigest">, declaration: AppDeclaration, snapshot: DeclaredOperations, capability: ApprovedGrant["capability"], resource?: ResourceRef | "any"): ApprovedGrant | null;
 /** Approved binding operations from an already verified declaration. Hosts still pin
  * the selection/version/artifact and compare running frame grants as a subset. */
-export declare function approvedBindingGrants(installation: Installation, declaration: AppDeclaration): InvocationGrants;
+export declare function approvedBindingGrants(installation: Pick<GateFacts["installation"], "status" | "authority">, declaration: AppDeclaration): InvocationGrants;
 /** Narrow captured binding operations to the method's verified requirements and effect.
  * The captured set is the ceiling; this never adds an operation or resource authority. */
 export declare function scopedBindings(captured: InvocationGrants, method?: AppMethodDeclaration, ceiling?: "read" | "write"): InvocationGrants;

package/dist/apps/gate.js

@@ -5,15 +5,22 @@ import * as z from "zod";
 import * as Schema from "effect/Schema";
 import { appBackendBindingKinds, appBackendBindingOperation, scopeOperationToMethod, appApiMethodNameSchema, appBackendBindingsSchema, appCapabilityIdSchema, } from "@fungi.computer/puffball/app";
 import { appToolAccessSchema } from "./tools.js";
-import { ownerCodec, } from "./installation.js";
+import { ownerCodec, resourceRefSchema, } 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(),
         input: z.unknown(),
         via: z.enum(["ui", "agent", "mcp", "workflow"]),
+        resource: resourceRefSchema.optional(),
+    }),
+    z.strictObject({
+        kind: z.literal("capability"),
+        capability: ownerCodec(appCapabilityIdSchema),
+        operation: z.string().min(1).optional(),
+        resource: z.union([resourceRefSchema, z.literal("any")]),
     }),
     z.strictObject({
         kind: z.literal("capability-route"),
@@ -27,9 +34,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 +45,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,19 +60,22 @@ 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) {
+export function grantsFor(installation, declaration, snapshot, capability, resource = "any") {
     if (installation.status !== "enabled" ||
-        snapshot.digest !== installation.declaredOperationsDigest ||
-        snapshot.artifactDigest !== installation.release.artifact.artifactDigest ||
+        snapshot.digest !== installation.authority.declaredOperationsDigest ||
+        snapshot.artifactDigest !== installation.artifactDigest ||
         !declaration.capabilities.includes(capability))
         return null;
-    const approved = installation.approvedGrants.find((grant) => grant.capability === capability);
+    const approved = installation.authority.approvedGrants.find((grant) => grant.capability === capability);
     const declared = snapshot.capabilities.find((row) => row.capability === capability)
         ?.operations ?? [];
     if (!approved?.capabilityApproved ||
-        (approved.resources !== "tenant-scope" && approved.resources.length === 0))
+        (approved.resources !== "tenant-scope" &&
+            (resource === "any"
+                ? approved.resources.length === 0
+                : !approved.resources.some((ref) => ref.kind === resource.kind && ref.id === resource.id))))
         return null;
     const operations = approved.operations.filter((operation) => declared.includes(operation));
     return { ...approved, operations };
@@ -82,7 +92,7 @@ export function approvedBindingGrants(installation, declaration) {
             return (operation !== undefined &&
                 operation.requires.length > 0 &&
                 operation.requires.every((capability) => {
-                    const approved = installation.approvedGrants.find((grant) => grant.capability === capability);
+                    const approved = installation.authority.approvedGrants.find((grant) => grant.capability === capability);
                     return (declaration.capabilities.includes(capability) &&
                         approved?.capabilityApproved &&
                         (approved.resources === "tenant-scope" ||
@@ -128,13 +138,13 @@ function admissionRefusal(facts) {
     if (installation.status !== "enabled" ||
         (visitor && installation.visibility !== "public"))
         return refusal("unavailable");
-    if (facts.declaredOperations.digest !== installation.declaredOperationsDigest ||
-        facts.declaredOperations.artifactDigest !==
-            installation.release.artifact.artifactDigest ||
+    if (facts.declaredOperations.digest !==
+        installation.authority.declaredOperationsDigest ||
+        facts.declaredOperations.artifactDigest !== installation.artifactDigest ||
         (facts.pins !== undefined &&
-            (facts.pins.authorityVersion !== installation.authorityVersion ||
-                facts.pins.artifactDigest !==
-                    installation.release.artifact.artifactDigest)))
+            (facts.pins.authorityVersion !==
+                installation.authority.authorityVersion ||
+                facts.pins.artifactDigest !== installation.artifactDigest)))
         return refusal("stale_authority");
     if ((principal.actor.kind === "agent" || principal.actor.kind === "team-key") &&
         !Schema.is(appToolAccessSchema)(facts.access))
@@ -161,9 +171,9 @@ function methodMetadata(facts, name) {
         return refusal("level_too_low");
     return { kind: "admitted", method };
 }
-function methodGrantRefusal(facts, method) {
+function methodGrantRefusal(facts, method, resource = "any") {
     const { installation } = facts;
-    if (method.requires.some((capability) => grantsFor(installation, facts.declaration, facts.declaredOperations, capability) === null))
+    if (method.requires.some((capability) => grantsFor(installation, facts.declaration, facts.declaredOperations, capability, resource) === null))
         return refusal("requires_not_granted");
     return null;
 }
@@ -221,7 +231,7 @@ export function admits(facts, rawRequest) {
             catch {
                 return refusal("invalid_input");
             }
-            const grantDenied = methodGrantRefusal(facts, method);
+            const grantDenied = methodGrantRefusal(facts, method, request.resource);
             if (grantDenied !== null)
                 return grantDenied;
             return {
@@ -230,6 +240,22 @@ export function admits(facts, rawRequest) {
                 method,
             };
         }
+        case "capability": {
+            if (visitor)
+                return refusal("visitor_read_only");
+            if (!facts.declaration.capabilities.includes(request.capability) ||
+                (request.operation !== undefined &&
+                    facts.declaredOperations.capabilities
+                        .find((row) => row.capability === request.capability)
+                        ?.operations.includes(request.operation) !== true))
+                return refusal("not_declared");
+            const grant = grantsFor(installation, facts.declaration, facts.declaredOperations, request.capability, request.resource);
+            if (grant === null ||
+                (request.operation !== undefined &&
+                    !grant.operations.includes(request.operation)))
+                return refusal("not_approved");
+            return { kind: "admitted", grants: [] };
+        }
         case "capability-route": {
             if (visitor)
                 return refusal("visitor_read_only");

package/dist/apps/index.d.ts

@@ -1,5 +1,7 @@
 /** Installation records and pure admission rules; tenant state and commits stay host-owned. */
-export { applyInstallationCommand, approvedGrantSchema, declaredOperationsSchema, installationCommandSchema, installationIdSchema, installationRefusalSchema, installationSchema, type Approval, type ApprovedGrant, type CapabilityOperationDescriptor, type DeclaredOperations, type GrantRequest, type Installation, type InstallationCommand, type InstallationContext, type InstallationReader, type InstallationRefusal, type InstallationUpdate, type ResourceRef, } from "./installation.js";
+export { applyGrantCommand, appAuthoritySchema, grantCommandSchema, type AppAuthority, type GrantCommand, type GrantContext, type GrantRefusal, applyInstallationCommand, approvedGrantSchema, declaredOperationsSchema, installationCommandSchema, installationIdSchema, installationRefusalSchema, installationSchema, type Approval, type ApprovedGrant, type CapabilityOperationDescriptor, type DeclaredOperations, grantChangeSchema, type GrantChange, type Installation, type InstallationCommand, type InstallationContext, type InstallationReader, type InstallationRefusal, type InstallationUpdate, type ResourceRef, } from "./installation.js";
+export { permissionPinsSchema, permissionSaveSchema, type PermissionPins, appPermissionsWireSchema, appPermissionPageSchema, permissionScreen, draftOf, editPermissions, planGrantChange, rebaseDraft, type PermissionDraft, type PermissionEdit, type PermissionScreen, type AppPermissionsWire, grantRequestFor, pendingCapabilities, type GrantRequestDecision, type ResourceOption, } from "./permissions.js";
 export { admits, admitMethodMetadata, appInvocationCeiling, approvedBindingGrants, scopedBindings, grantsFor, gateRefusalSchema, gateRequestSchema, invocationGrantsSchema, type AppMethodDeclaration, type AppMethodMetadataDecision, type GateDecision, type GateFacts, type GateRequest, type HostPrincipal, type InvocationGrants, } from "./gate.js";
 export { deriveDeclaredOperations, appCallOperation } from "./operations.js";
 export { appToolPolicySchema, type AppToolAccess, type AppToolEntry, type AppToolPolicy, } from "./tools.js";
+export { permissionCatalog, type PermissionCatalogEntry } from "./catalog.js";

package/dist/apps/index.js

@@ -1,5 +1,7 @@
 /** Installation records and pure admission rules; tenant state and commits stay host-owned. */
-export { applyInstallationCommand, approvedGrantSchema, declaredOperationsSchema, installationCommandSchema, installationIdSchema, installationRefusalSchema, installationSchema, } from "./installation.js";
+export { applyGrantCommand, appAuthoritySchema, grantCommandSchema, applyInstallationCommand, approvedGrantSchema, declaredOperationsSchema, installationCommandSchema, installationIdSchema, installationRefusalSchema, installationSchema, grantChangeSchema, } from "./installation.js";
+export { permissionPinsSchema, permissionSaveSchema, appPermissionsWireSchema, appPermissionPageSchema, permissionScreen, draftOf, editPermissions, planGrantChange, rebaseDraft, grantRequestFor, pendingCapabilities, } from "./permissions.js";
 export { admits, admitMethodMetadata, appInvocationCeiling, approvedBindingGrants, scopedBindings, grantsFor, gateRefusalSchema, gateRequestSchema, invocationGrantsSchema, } from "./gate.js";
 export { deriveDeclaredOperations, appCallOperation } from "./operations.js";
 export { appToolPolicySchema, } from "./tools.js";
+export { permissionCatalog } from "./catalog.js";

package/dist/apps/installation.d.ts

@@ -2,11 +2,18 @@ import * as z from "zod";
 import * as Schema from "effect/Schema";
 import * as Result from "effect/Result";
 import { type AppDeclaration, type HostActor } from "@fungi.computer/puffball/app";
+import type { OwnerState } from "../index.js";
 import type { CapabilityDescriptor } from "../capability-descriptor.js";
+import type { HostPrincipal } from "./gate.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>;
+/** A resource identity minted and resolved by the host, never by this module. */
+export declare const resourceRefSchema: z.ZodLazy<z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strict>>>;
 export type ResourceRef = Exclude<ApprovedGrant["resources"], "tenant-scope">[number];
 /**
  * Consent approves capabilities, with explicit operation and resource ceilings.
@@ -14,28 +21,104 @@ export type ResourceRef = Exclude<ApprovedGrant["resources"], "tenant-scope">[nu
  * no new consent; a new capability does. Release selection intersects stored
  * operations instead of adding approvals. Each Worker call is still restricted
  * to that method's declared requires, never the App's complete capability set.
- * Only an approved install or set-grants command mints capabilityApproved.
+ * Only an approved install or change-grants command mints capabilityApproved.
  * Empty operation rows retain that consent; removing the capability revokes it.
  * route:app.methods rows record approval detail, not a method allowlist: narrowing
- * them in set-grants does not restrict methods using an approved capability.
+ * them in change-grants does not restrict methods using an approved capability.
  * 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<"approvals" | "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, {
-    kind: "install";
-}>["grants"];
-export type Approval = NonNullable<Installation["approval"]>;
+/** A bounded owner edit. Unnamed approvals are not part of the command. */
+export declare const grantChangeSchema: z.ZodReadonly<z.ZodObject<{
+    capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "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>>;
+    grant: z.ZodNullable<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 GrantChange = z.output<typeof grantChangeSchema>;
+/** The owner and version that approved a fixed operation snapshot. */
+export type Approval = Readonly<{
+    by: HostActor;
+    at: number;
+    authorityVersion: number;
+}>;
+/** The complete grant state. Hosts own storage and compare-and-set commits. */
+export declare const appAuthoritySchema: z.ZodObject<{
+    authorityVersion: z.ZodLazy<z.ZodNumber>;
+    declaredOperationsDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+    approvedGrants: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "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.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.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>;
+        }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
+            kind: import("zod/mini").ZodMiniLiteral<"agent">;
+            agentId: import("zod/mini").ZodMiniString<string>;
+        }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
+            kind: import("zod/mini").ZodMiniLiteral<"team-key">;
+            keyId: import("zod/mini").ZodMiniString<string>;
+        }, z.core.$strip>], "kind">;
+        at: z.ZodNumber;
+        authorityVersion: z.ZodLazy<z.ZodNumber>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
+export type AppAuthority = z.output<typeof appAuthoritySchema>;
+export declare const grantCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"install">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"change-grants">;
+    changes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "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>>;
+        grant: z.ZodNullable<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>>>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"select-release">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"delete">;
+}, z.core.$strict>], "kind">;
+export type GrantCommand = z.output<typeof grantCommandSchema>;
+export type GrantContext = Readonly<{
+    principal: HostPrincipal;
+    expectedVersion: number | null;
+    declaration: AppDeclaration;
+    declaredOperations: DeclaredOperations;
+    now: number;
+}>;
+export type GrantRefusal = Readonly<{
+    kind: "refused";
+    code: "stale_authority" | "not_owner" | "not_declared" | "invalid_command";
+}>;
+/** One host-independent approval policy; selection only intersects existing grants. */
+export declare function applyGrantCommand(current: AppAuthority | null, rawCommand: GrantCommand, context: GrantContext): Result.Result<AppAuthority, GrantRefusal>;
 /** 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 +126,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<"approvals" | "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,8 +137,8 @@ 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;
-    instanceId: z.ZodNullable<z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("../index.js").InstanceId, unknown>>>;
+    installationId: z.ZodLazy<z.ZodString>;
+    instanceId: z.ZodNullable<z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("../instance-id.js").InstanceId, unknown>>>;
     appId: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").AppId, unknown>>;
     release: z.ZodPipe<z.ZodUnknown, z.ZodTransform<{
         readonly releaseId: import("@fungi.computer/puffball").ReleaseId;
@@ -74,7 +157,33 @@ export declare const installationSchema: z.ZodObject<{
         pinned: "pinned";
         floating: "floating";
     }>;
-    authorityVersion: z.ZodNumber;
+    authority: z.ZodObject<{
+        authorityVersion: z.ZodLazy<z.ZodNumber>;
+        declaredOperationsDigest: z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("@fungi.computer/puffball").Sha256Digest, unknown>>;
+        approvedGrants: z.ZodLazy<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "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.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.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>;
+            }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
+                kind: import("zod/mini").ZodMiniLiteral<"agent">;
+                agentId: import("zod/mini").ZodMiniString<string>;
+            }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
+                kind: import("zod/mini").ZodMiniLiteral<"team-key">;
+                keyId: import("zod/mini").ZodMiniString<string>;
+            }, z.core.$strip>], "kind">;
+            at: z.ZodNumber;
+            authorityVersion: z.ZodLazy<z.ZodNumber>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>;
     status: z.ZodEnum<{
         enabled: "enabled";
         disabled: "disabled";
@@ -84,35 +193,11 @@ export declare const installationSchema: z.ZodObject<{
         private: "private";
         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>>;
-        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<{
-            kind: z.ZodString;
-            id: z.ZodString;
-        }, z.core.$strict>>>>]>;
-    }, z.core.$strict>>>>;
-    approval: z.ZodNullable<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>;
-        }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
-            kind: import("zod/mini").ZodMiniLiteral<"agent">;
-            agentId: import("zod/mini").ZodMiniString<string>;
-        }, z.core.$strip>, import("zod/mini").ZodMiniObject<{
-            kind: import("zod/mini").ZodMiniLiteral<"team-key">;
-            keyId: import("zod/mini").ZodMiniString<string>;
-        }, z.core.$strip>], "kind">;
-        at: z.ZodNumber;
-        authorityVersion: 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,20 +209,12 @@ 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<{
-    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<{
-            kind: z.ZodString;
-            id: z.ZodString;
-        }, z.core.$strict>>>>]>;
-    }, z.core.$strict>>>>]>;
+export declare const installationCommandSchema: z.ZodLazy<z.ZodDiscriminatedUnion<[z.ZodObject<{
     release: z.ZodPipe<z.ZodUnknown, z.ZodTransform<{
         readonly releaseId: import("@fungi.computer/puffball").ReleaseId;
         readonly appId: import("@fungi.computer/puffball").AppId;
@@ -189,22 +266,24 @@ export declare const installationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         public: "public";
     }>;
 }, 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<{
-            kind: z.ZodString;
-            id: z.ZodString;
-        }, z.core.$strict>>>>]>;
-    }, z.core.$strict>>>>]>;
+    kind: z.ZodLiteral<"change-grants">;
+    changes: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        capability: z.ZodPipe<z.ZodUnknown, z.ZodTransform<"approvals" | "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>>;
+        grant: z.ZodNullable<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>>>>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"approve-anonymous">;
     methods: 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>>>>;
-}, 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 +300,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 +310,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;
@@ -246,3 +325,5 @@ export type InstallationReader = Readonly<{
 }>;
 /** Pure transition; hosts retain transactions, receipts, epochs and delivery. */
 export declare function applyInstallationCommand(current: Installation | null, rawCommand: InstallationCommand, context: InstallationContext): Result.Result<InstallationUpdate, InstallationRefusal>;
+/** Only the committed installation may activate this exact owner selection. */
+export declare function isCommittedInstallation(current: Installation | null, state: OwnerState, release: Installation["release"]): boolean;