@agentorg/cli 0.0.3 → 0.0.5

package/{node_modules → dist/node_modules}/@agentorg/hub/dist/src/storage.js

@@ -139,7 +139,8 @@ export class Storage {
      * Seed the store of (consumer, slot), all or none, if it holds nothing: `storage.admin@1`'s
      * `seed`. Each entry has kv@1's limits, and together they count toward the consumer's quota.
      */
-    seed(consumer, slot, entries) {
+    /** `named` is the consumer as a refusal names it: "Name (id)". */
+    seed(consumer, slot, entries, named = consumer) {
         const keys = new Set();
         const rows = entries.map(({ key, value }) => {
             checkKey(key);
@@ -159,7 +160,7 @@ export class Storage {
             if (this.#db
                 .prepare("SELECT 1 FROM store WHERE consumer = ? AND slot = ? LIMIT 1")
                 .get(consumer, slot))
-                throw new Refused("not_empty", `The store of ${consumer}.${slot} isn't empty.`);
+                throw new Refused("not_empty", `The store of ${named}'s ${slot} isn't empty.`);
             const used = this.#db.prepare("SELECT used FROM usage WHERE consumer = ?").get(consumer);
             if (Number(used?.used ?? 0) + total > this.#limits.maxPerConsumer)
                 throw new Refused("quota", `An Actor's stores hold at most ${this.#limits.maxPerConsumer} bytes.`);

package/{node_modules → dist/node_modules}/@agentorg/hub/package.json

@@ -23,9 +23,12 @@
   },
   "dependencies": {
     "@agentorg/interfaces": "0.0.0",
+    "@agentorg/kit": "0.0.0",
     "@agentorg/sdk": "0.0.0",
     "@agentorg/wire": "0.0.0",
     "ajv": "^8.20.0",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
     "ws": "^8.22.1",
     "zod": "^4.6.7"
   },

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/hub.d.ts

@@ -36,8 +36,8 @@ export declare const hubPackages: import("@agentorg/sdk").RpcInterface<"hub.pack
     /**
      * Build a package from its source, given as data (`package.json` and files under `src/`, up to
      * 768 KiB), and add it as `add` does. It's `agentorg build`'s build, reading no tsconfig; its
-     * files import only `@agentorg/sdk`, `@agentorg/interfaces` and `zod` by name, and nothing outside
-     * the package's folder, never by a pattern. A build that fails is
+     * files import only `@agentorg/sdk`, `@agentorg/interfaces`, `zod`, `react`, `react-dom` and
+     * `@agentorg/kit` by name, and nothing outside the package's folder, never by a pattern. A build that fails is
      * `Refused("build")` with the build's message, so the source can be fixed and built again.
      */
     build: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
@@ -75,6 +75,7 @@ export declare const Actor: z.ZodObject<{
         reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     views: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    installedFor: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /** One line of an Actor's log, from its `ctx.log` or its process's own output. */
 export declare const LogLine: z.ZodObject<{
@@ -93,11 +94,13 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
     /**
      * With a package, an Actor that runs it; without, an external one, whose credential is returned
      * once. `bindings` wire the new Actor's slots at once, with the caller's export-side authority
-     * (the creation is the slot side's yes), for example to its own `hub.grants@1`.
+     * (the creation is the slot side's yes), for example to its own `hub.grants@1`. `for` names
+     * the Actor it is made for, recorded as `installedFor`; only a manager may give it.
      */
     create: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         name: z.ZodString;
         package: z.ZodOptional<z.ZodString>;
+        for: z.ZodOptional<z.ZodString>;
         bindings: z.ZodOptional<z.ZodArray<z.ZodObject<{
             slot: z.ZodString;
             provider: z.ZodString;
@@ -130,6 +133,7 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
                 reason: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
             views: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            installedFor: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     get: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
@@ -156,6 +160,7 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
             reason: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
         views: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        installedFor: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
     start: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         actorId: z.ZodString;
@@ -167,6 +172,25 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
     close: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         actorId: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /**
+     * Run another package as the same package Actor: its id, its stores and every binding whose
+     * interfaces still match stay. A binding through a slot or export the new package drops, or
+     * declares as another interface, is dropped and listed in `dropped`; the new package's own
+     * wiring is made where its slot is unbound. A running Actor restarts on the new package.
+     * Only a manager may upgrade: the new package runs as the Actor and keeps what it was granted
+     * (its bindings and its store), which only a manager could grant anyway.
+     */
+    upgrade: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        actorId: z.ZodString;
+        package: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        dropped: z.ZodArray<z.ZodObject<{
+            consumer: z.ZodString;
+            slot: z.ZodString;
+            provider: z.ZodString;
+            export: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     /** Its newest log lines, oldest first. */
     logs: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         actorId: z.ZodString;
@@ -193,6 +217,8 @@ export declare const hubActors: import("@agentorg/sdk").RpcInterface<"hub.actors
         actor: z.ZodString;
     }, z.core.$strip>>;
 }, 1>;
+/** A slot made at run time: one segment, at most 48 characters, so tools named from it fit. */
+export declare const SlotName: z.ZodString;
 export declare const Binding: z.ZodObject<{
     consumer: z.ZodString;
     slot: z.ZodString;
@@ -201,6 +227,7 @@ export declare const Binding: z.ZodObject<{
     interface: z.ZodString;
     madeBy: z.ZodString;
     at: z.ZodString;
+    exposed: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strip>;
 export declare const BindingRequest: z.ZodObject<{
     consumer: z.ZodString;
@@ -215,6 +242,7 @@ export declare const BindingRequest: z.ZodObject<{
     reason: z.ZodString;
     requestedBy: z.ZodString;
     at: z.ZodString;
+    exposed: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strip>;
 /**
  * `hub.grants@1`: binding with the caller's own authority, so it is safe to give any Actor. A
@@ -241,6 +269,32 @@ export declare const hubGrants: import("@agentorg/sdk").RpcInterface<"hub.grants
         consumer: z.ZodString;
         slot: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+    /**
+     * Expose an `rpc` export to one Actor: a slot made on `to`, typed by the export's interface,
+     * named `as` (by default the provider's name camelCased, `_`, and the export's last part, made
+     * unique on `to`), and bound to the export, in one step. Its authority is a binding's: with
+     * both ends it is made; with one, it is a request to the other end's approvers, who approve it
+     * by calling `expose` with the request's fields. The same export already exposed to `to`
+     * gives that slot back.
+     */
+    expose: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        provider: z.ZodString;
+        export: z.ZodString;
+        to: z.ZodString;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodUnion<readonly [z.ZodObject<{
+        exposed: z.ZodLiteral<true>;
+        slot: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        exposed: z.ZodLiteral<false>;
+        slot: z.ZodString;
+        requestId: z.ZodString;
+    }, z.core.$strip>]>>;
+    /** Remove a slot made by `expose`, with its binding: as `unbind`, the consumer, the provider or a manager may. */
+    unexpose: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        to: z.ZodString;
+        slot: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
     request: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         consumer: z.ZodString;
         slot: z.ZodString;
@@ -265,6 +319,7 @@ export declare const hubGrants: import("@agentorg/sdk").RpcInterface<"hub.grants
             reason: z.ZodString;
             requestedBy: z.ZodString;
             at: z.ZodString;
+            exposed: z.ZodOptional<z.ZodLiteral<true>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     decline: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
@@ -290,6 +345,7 @@ export declare const hubGrants: import("@agentorg/sdk").RpcInterface<"hub.grants
             reason: z.ZodString;
             requestedBy: z.ZodString;
             at: z.ZodString;
+            exposed: z.ZodOptional<z.ZodLiteral<true>>;
             status: z.ZodEnum<{
                 approved: "approved";
                 closed: "closed";
@@ -313,6 +369,7 @@ export declare const hubGrants: import("@agentorg/sdk").RpcInterface<"hub.grants
         reason: z.ZodString;
         requestedBy: z.ZodString;
         at: z.ZodString;
+        exposed: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>>;
     /**
      * A request the subscriber could approve, or made, was approved (its binding made), declined,
@@ -332,6 +389,7 @@ export declare const hubGrants: import("@agentorg/sdk").RpcInterface<"hub.grants
             reason: z.ZodString;
             requestedBy: z.ZodString;
             at: z.ZodString;
+            exposed: z.ZodOptional<z.ZodLiteral<true>>;
         }, z.core.$strip>;
         status: z.ZodEnum<{
             approved: "approved";
@@ -357,6 +415,7 @@ export declare const hubBindings: import("@agentorg/sdk").RpcInterface<"hub.bind
             interface: z.ZodString;
             madeBy: z.ZodString;
             at: z.ZodString;
+            exposed: z.ZodOptional<z.ZodLiteral<true>>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
 }, {}, 1>;

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/hub.js

@@ -34,8 +34,8 @@ export const hubPackages = defineInterface({
         /**
          * Build a package from its source, given as data (`package.json` and files under `src/`, up to
          * 768 KiB), and add it as `add` does. It's `agentorg build`'s build, reading no tsconfig; its
-         * files import only `@agentorg/sdk`, `@agentorg/interfaces` and `zod` by name, and nothing outside
-         * the package's folder, never by a pattern. A build that fails is
+         * files import only `@agentorg/sdk`, `@agentorg/interfaces`, `zod`, `react`, `react-dom` and
+         * `@agentorg/kit` by name, and nothing outside the package's folder, never by a pattern. A build that fails is
          * `Refused("build")` with the build's message, so the source can be fixed and built again.
          */
         build: method({
@@ -75,6 +75,12 @@ export const Actor = z.object({
     host: z.object({ available: z.boolean(), reason: z.string().optional() }).optional(),
     /** For a package Actor: its view modules, which the person's shell can place. */
     views: z.array(z.string()).optional(),
+    /**
+     * The Actor it was created for, when a manager created it on another's behalf (the installer
+     * names its caller). Provenance only: the Hub grants nothing from it; only a rule the person
+     * turned on may act on it.
+     */
+    installedFor: Id.optional(),
 });
 /** One line of an Actor's log, from its `ctx.log` or its process's own output. */
 export const LogLine = z.object({
@@ -93,12 +99,14 @@ export const hubActors = defineInterface({
         /**
          * With a package, an Actor that runs it; without, an external one, whose credential is returned
          * once. `bindings` wire the new Actor's slots at once, with the caller's export-side authority
-         * (the creation is the slot side's yes), for example to its own `hub.grants@1`.
+         * (the creation is the slot side's yes), for example to its own `hub.grants@1`. `for` names
+         * the Actor it is made for, recorded as `installedFor`; only a manager may give it.
          */
         create: method({
             input: z.object({
                 name: z.string().min(1).max(128),
                 package: Hash.optional(),
+                for: Id.optional(),
                 bindings: z
                     .array(z.object({ slot: Name, provider: Id, export: Name }))
                     .max(64)
@@ -112,6 +120,20 @@ export const hubActors = defineInterface({
         stop: method({ input: z.object({ actorId: Id }), output: Empty }),
         /** Final: its bindings, both ways, are removed. */
         close: method({ input: z.object({ actorId: Id }), output: Empty }),
+        /**
+         * Run another package as the same package Actor: its id, its stores and every binding whose
+         * interfaces still match stay. A binding through a slot or export the new package drops, or
+         * declares as another interface, is dropped and listed in `dropped`; the new package's own
+         * wiring is made where its slot is unbound. A running Actor restarts on the new package.
+         * Only a manager may upgrade: the new package runs as the Actor and keeps what it was granted
+         * (its bindings and its store), which only a manager could grant anyway.
+         */
+        upgrade: method({
+            input: z.object({ actorId: Id, package: Hash }),
+            output: z.object({
+                dropped: z.array(z.object({ consumer: Id, slot: Name, provider: Id, export: Name })),
+            }),
+        }),
         /** Its newest log lines, oldest first. */
         logs: method({
             input: z.object({ actorId: Id, limit: z.number().int().min(1).max(1000).optional() }),
@@ -127,11 +149,18 @@ export const hubActors = defineInterface({
     },
 });
 const Wiring = { consumer: Id, slot: Name, provider: Id, export: Name };
+/** A slot made at run time: one segment, at most 48 characters, so tools named from it fit. */
+export const SlotName = z
+    .string()
+    .regex(/^[a-z][A-Za-z0-9_]*$/)
+    .max(48);
 export const Binding = z.object({
     ...Wiring,
     interface: z.string(),
     madeBy: Id,
     at: z.string(),
+    /** A slot made at run time by `hub.grants.expose`: it goes with this binding. */
+    exposed: z.literal(true).optional(),
 });
 export const BindingRequest = z.object({
     requestId: Id,
@@ -141,6 +170,11 @@ export const BindingRequest = z.object({
     reason: z.string(),
     requestedBy: Id,
     at: z.string(),
+    /**
+     * A request to expose: `slot` is the name the slot will have on `consumer`, made when it is
+     * approved. Approve it with `expose({provider, export, to: consumer, as: slot})`.
+     */
+    exposed: z.literal(true).optional(),
 });
 /**
  * `hub.grants@1`: binding with the caller's own authority, so it is safe to give any Actor. A
@@ -164,6 +198,23 @@ export const hubGrants = defineInterface({
         }),
         /** The consumer, the provider or a manager may unbind. */
         unbind: method({ input: z.object({ consumer: Id, slot: Name }), output: Empty }),
+        /**
+         * Expose an `rpc` export to one Actor: a slot made on `to`, typed by the export's interface,
+         * named `as` (by default the provider's name camelCased, `_`, and the export's last part, made
+         * unique on `to`), and bound to the export, in one step. Its authority is a binding's: with
+         * both ends it is made; with one, it is a request to the other end's approvers, who approve it
+         * by calling `expose` with the request's fields. The same export already exposed to `to`
+         * gives that slot back.
+         */
+        expose: method({
+            input: z.object({ provider: Id, export: Name, to: Id, as: SlotName.optional() }),
+            output: z.union([
+                z.object({ exposed: z.literal(true), slot: SlotName }),
+                z.object({ exposed: z.literal(false), slot: SlotName, requestId: Id }),
+            ]),
+        }),
+        /** Remove a slot made by `expose`, with its binding: as `unbind`, the consumer, the provider or a manager may. */
+        unexpose: method({ input: z.object({ to: Id, slot: SlotName }), output: Empty }),
         request: method({
             input: z.object({ ...Wiring, reason: z.string().min(1).max(1000) }),
             output: z.object({ requestId: Id }),

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/index.d.ts

@@ -6,6 +6,7 @@ export { Composition, installer } from "./installer.js";
 export { kv } from "./kv.js";
 export { layout, Placement } from "./layout.js";
 export { Item, llmSession, OutputItem, Tool } from "./llm-session.js";
+export { appRules, Rule } from "./rules.js";
 export { storageAdmin } from "./storage-admin.js";
 export { uiShell } from "./ui-shell.js";
 export { uiView } from "./ui-view.js";

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/index.js

@@ -6,6 +6,7 @@ export { Composition, installer } from "./installer.js";
 export { kv } from "./kv.js";
 export { layout, Placement } from "./layout.js";
 export { Item, llmSession, OutputItem, Tool } from "./llm-session.js";
+export { appRules, Rule } from "./rules.js";
 export { storageAdmin } from "./storage-admin.js";
 export { uiShell } from "./ui-shell.js";
 export { uiView } from "./ui-view.js";

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/installer.d.ts

@@ -39,6 +39,10 @@ export declare const installer: import("@agentorg/sdk").RpcInterface<"installer"
      */
     plan: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         package: z.ZodString;
+        expose: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            export: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         slots: z.ZodArray<z.ZodObject<{
             slot: z.ZodString;
@@ -49,6 +53,14 @@ export declare const installer: import("@agentorg/sdk").RpcInterface<"installer"
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         views: z.ZodArray<z.ZodString>;
+        exposes: z.ZodArray<z.ZodObject<{
+            export: z.ZodString;
+            to: z.ZodString;
+            settles: z.ZodEnum<{
+                granted: "granted";
+                request: "request";
+            }>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     /**
      * Create an Actor of the package named `name`, with exactly these connections, all or none.
@@ -58,6 +70,12 @@ export declare const installer: import("@agentorg/sdk").RpcInterface<"installer"
      * slot bound to `storage`'s `kv` gets the package's seed for it (an object of key to value);
      * a seed whose slot isn't is listed in `unseeded`. Then it is started if `start`. If a seed or
      * the start fails, the new Actor is closed. Slots left out stay unbound, listed in `unbound`.
+     * The Actor is recorded as made for the caller (`installedFor`), which grants nothing.
+     *
+     * `expose` lists the new Actor's exports to expose (`rpc` exports of its host modules), each to one Actor, all or none like the
+     * connections: a manager's are made now (`granted`, with the slot); one to the caller itself
+     * is left for the caller to file (`request`, with the exact `hub.grants.expose` call); any
+     * other is refused, and nothing is created. Nothing is exposed that isn't listed.
      */
     install: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
         package: z.ZodString;
@@ -67,10 +85,29 @@ export declare const installer: import("@agentorg/sdk").RpcInterface<"installer"
             export: z.ZodString;
         }, z.core.$strip>>;
         start: z.ZodOptional<z.ZodBoolean>;
+        expose: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            export: z.ZodString;
+            to: z.ZodString;
+        }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         actorId: z.ZodString;
         unbound: z.ZodArray<z.ZodString>;
         unseeded: z.ZodArray<z.ZodString>;
+        exposures: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            export: z.ZodString;
+            to: z.ZodString;
+            settles: z.ZodLiteral<"granted">;
+            slot: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            export: z.ZodString;
+            to: z.ZodString;
+            settles: z.ZodLiteral<"request">;
+            call: z.ZodObject<{
+                provider: z.ZodString;
+                export: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>]>>;
     }, z.core.$strip>>;
     /**
      * The system as it is, as a composition: every package Actor that isn't closed, the

package/{node_modules → dist/node_modules}/@agentorg/interfaces/dist/src/installer.js

@@ -1,9 +1,17 @@
 import { defineInterface, method } from "@agentorg/sdk";
 import { z } from "zod";
-import { Id, Name } from "./hub.js";
+import { Id, Name, SlotName } from "./hub.js";
 const Hash = z.string().regex(/^sha256-[0-9a-f]{64}$/);
 /** An export of a running Actor, by its id and the export's name. */
 const Target = z.object({ actor: Id, export: Name });
+/** One of the new Actor's `rpc` exports (`module.export`), to expose to the Actor `to`. */
+const Exposure = z.object({ export: Name, to: Id });
+/**
+ * How an exposure settles, by the caller's own authority: `granted`, made now (the caller holds
+ * both sides: it is a manager), or `request`, which the caller files itself with
+ * `hub.grants.expose` (it holds `to`'s side: it is `to`). Nothing else is exposed.
+ */
+const Settles = z.enum(["granted", "request"]);
 /** An Actor of a composition, by the name it has there. */
 const ActorName = z.string().min(1).max(128);
 /**
@@ -46,10 +54,15 @@ export const installer = defineInterface({
          * can place.
          */
         plan: method({
-            input: z.object({ package: Hash }),
+            input: z.object({ package: Hash, expose: z.array(Exposure).max(64).optional() }),
             output: z.object({
                 slots: z.array(z.object({ slot: Name, interface: z.string(), candidates: z.array(Target) })),
                 views: z.array(z.string()),
+                /**
+                 * Each `expose` entry given, with how `install` would settle it for this caller; an entry
+                 * `install` would refuse is refused here the same way.
+                 */
+                exposes: z.array(Exposure.extend({ settles: Settles })),
             }),
         }),
         /**
@@ -60,6 +73,12 @@ export const installer = defineInterface({
          * slot bound to `storage`'s `kv` gets the package's seed for it (an object of key to value);
          * a seed whose slot isn't is listed in `unseeded`. Then it is started if `start`. If a seed or
          * the start fails, the new Actor is closed. Slots left out stay unbound, listed in `unbound`.
+         * The Actor is recorded as made for the caller (`installedFor`), which grants nothing.
+         *
+         * `expose` lists the new Actor's exports to expose (`rpc` exports of its host modules), each to one Actor, all or none like the
+         * connections: a manager's are made now (`granted`, with the slot); one to the caller itself
+         * is left for the caller to file (`request`, with the exact `hub.grants.expose` call); any
+         * other is refused, and nothing is created. Nothing is exposed that isn't listed.
          */
         install: method({
             input: z.object({
@@ -67,8 +86,20 @@ export const installer = defineInterface({
                 name: z.string().min(1).max(128),
                 connections: z.record(Name, Target),
                 start: z.boolean().optional(),
+                expose: z.array(Exposure).max(64).optional(),
+            }),
+            output: z.object({
+                actorId: Id,
+                unbound: z.array(Name),
+                unseeded: z.array(Name),
+                exposures: z.array(z.union([
+                    Exposure.extend({ settles: z.literal("granted"), slot: SlotName }),
+                    Exposure.extend({
+                        settles: z.literal("request"),
+                        call: z.object({ provider: Id, export: Name, to: Id }),
+                    }),
+                ])),
             }),
-            output: z.object({ actorId: Id, unbound: z.array(Name), unseeded: z.array(Name) }),
         }),
         /**
          * The system as it is, as a composition: every package Actor that isn't closed, the

package/dist/node_modules/@agentorg/interfaces/dist/src/rules.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+/**
+ * One named rule: a convenience the person turns on, off unless they do. `says` is what it does,
+ * in the person's words.
+ */
+export declare const Rule: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    says: z.ZodString;
+    on: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * `app.rules@1`: the person's named rules. Each is held by the person's Actor (the app's gateway),
+ * which acts on a rule that is on as the person, a manager, and only within what the person could
+ * grant. A rule is the only thing that may act on provenance such as an Actor's `installedFor`.
+ */
+export declare const appRules: import("@agentorg/sdk").RpcInterface<"app.rules", {
+    /** Every rule the app knows, each with whether it is on. */
+    list: import("@agentorg/sdk").MethodSpec<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+        rules: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            says: z.ZodString;
+            on: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    /** Turn a rule on or off. Turning one on settles what already waits for it. */
+    set: import("@agentorg/sdk").MethodSpec<z.ZodObject<{
+        id: z.ZodString;
+        on: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{}, z.core.$strip>>;
+}, {
+    /** A rule was turned on or off; read them again with `list`. */
+    changed: import("@agentorg/sdk").EventSpec<z.ZodObject<{}, z.core.$strip>>;
+}, 1>;

package/dist/node_modules/@agentorg/interfaces/dist/src/rules.js

@@ -0,0 +1,37 @@
+import { defineInterface, event, method } from "@agentorg/sdk";
+import { z } from "zod";
+/** A named rule's id: lowercase words joined by hyphens. */
+const RuleId = z
+    .string()
+    .regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/)
+    .max(64);
+/**
+ * One named rule: a convenience the person turns on, off unless they do. `says` is what it does,
+ * in the person's words.
+ */
+export const Rule = z.object({
+    id: RuleId,
+    name: z.string().max(200),
+    says: z.string().max(1000),
+    on: z.boolean(),
+});
+/**
+ * `app.rules@1`: the person's named rules. Each is held by the person's Actor (the app's gateway),
+ * which acts on a rule that is on as the person, a manager, and only within what the person could
+ * grant. A rule is the only thing that may act on provenance such as an Actor's `installedFor`.
+ */
+export const appRules = defineInterface({
+    name: "app.rules",
+    major: 1,
+    kind: "rpc",
+    methods: {
+        /** Every rule the app knows, each with whether it is on. */
+        list: method({ input: z.object({}), output: z.object({ rules: z.array(Rule) }) }),
+        /** Turn a rule on or off. Turning one on settles what already waits for it. */
+        set: method({ input: z.object({ id: RuleId, on: z.boolean() }), output: z.object({}) }),
+    },
+    events: {
+        /** A rule was turned on or off; read them again with `list`. */
+        changed: event(z.object({})),
+    },
+});

package/dist/node_modules/@agentorg/kit/dist/src/chat.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode } from "react";
+/** One message of a chat, as `chat@1` carries it. A `tool` message may say which tool ran. */
+export interface ChatEntry {
+    id: string;
+    role: "user" | "assistant" | "tool";
+    text: string;
+    tool?: {
+        name: string;
+        state: "running" | "done" | "refused";
+        input?: string;
+        output?: string;
+    };
+}
+export interface ChatProps {
+    /** In order; a reply still streaming is an `assistant` entry like any other. */
+    messages: readonly ChatEntry[];
+    /** A turn is running: Send becomes Stop. */
+    running: boolean;
+    /** Send the person's text; when it rejects, the text goes back in the composer. */
+    onSend(text: string): Promise<void>;
+    onCancel(): void;
+    /** Run the last turn again: offered under the last reply. */
+    onRetry?(): void;
+    /** Older messages remain: "Earlier messages" loads them. */
+    hasEarlier?: boolean;
+    onEarlier?(): Promise<void>;
+    /** Above the composer: a notice the caller draws (a refusal and its action). */
+    notice?: ReactNode;
+    /** Beside the send button: the plan line, say. */
+    footer?: ReactNode;
+    /** The agent's name and avatar, over its replies; its name names the composer. */
+    name?: string;
+    avatar?: ReactNode;
+    /** The composer's accessible name; by default "Message". */
+    label?: string;
+}
+export declare function Chat(props: ChatProps): import("react").JSX.Element;