@agentorg/cli 0.0.3 → 0.0.5

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

@@ -24,6 +24,7 @@
   },
   "devDependencies": {
     "@agentorg/interfaces": "0.0.0",
+    "@agentorg/kit": "0.0.0",
     "@agentorg/sdk": "0.0.0",
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",

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

@@ -1,4 +1,4 @@
 export { encodeFrame, FrameError, FrameReader, MAX_FRAME } from "./frames.js";
-export { type Body, eventBody, type Header, HeaderError, input, parseBody, parseHeader, result, type WireError, type WireErrorName, wireError, } from "./ops.js";
+export { type Body, type Exposure, eventBody, type Header, HeaderError, input, parseBody, parseHeader, result, type WireError, type WireErrorName, wireError, } from "./ops.js";
 export { MAX_UNREAD, memoryPair, type WebSocketLike, webSocketChannel } from "./transports.js";
 export { type Duplex, GO_AWAY, Session, type SessionOptions, YamuxError, type YamuxStream, } from "./yamux.js";

package/{node_modules → dist/node_modules}/@agentorg/wire/dist/src/ops.d.ts

@@ -69,11 +69,16 @@ export type Header =
     op: "withdraw";
     name: string;
 }
-/** From the Hub to an Actor: one of its slots was bound or unbound. */
+/**
+ * From the Hub to an Actor: one of its slots was bound or unbound. A slot made at run time (an
+ * export exposed to this Actor) carries `exposed` while bound: the export's described interface
+ * and which Actor's export it is. Unbound, it is gone.
+ */
  | {
     op: "slot";
     name: string;
     bound: boolean;
+    exposed?: Exposure;
 }
 /**
  * From the Hub to a provider: the same four, naming its export, who is calling, and through which
@@ -89,6 +94,14 @@ export type Header =
     event?: string;
     params?: unknown;
 };
+/** A slot made at run time, as the Hub describes it: the export's interface, and whose it is. */
+export interface Exposure {
+    interface: unknown;
+    provider: {
+        actor: string;
+        export: string;
+    };
+}
 export type WireErrorName = "NotConnected" | "Refused" | "OutcomeUnknown";
 /** How a refusal crosses the wire; the SDK maps it to its error classes. */
 export interface WireError {

package/{node_modules → dist/node_modules}/@agentorg/wire/dist/src/ops.js

@@ -37,10 +37,30 @@ export function parseHeader(value) {
             return { op: "offer", name: text(value, "name"), interface: value.interface };
         case "withdraw":
             return { op: "withdraw", name: text(value, "name") };
-        case "slot":
+        case "slot": {
             if (typeof value.bound !== "boolean")
                 throw new HeaderError("A slot header needs bound.");
-            return { op: "slot", name: text(value, "name"), bound: value.bound };
+            if (!("exposed" in value))
+                return { op: "slot", name: text(value, "name"), bound: value.bound };
+            const exposed = value.exposed;
+            if (!value.bound ||
+                !isRecord(exposed) ||
+                !isRecord(exposed.interface) ||
+                !isRecord(exposed.provider))
+                throw new HeaderError("A slot header's exposed is a bound slot's {interface, provider}.");
+            return {
+                op: "slot",
+                name: text(value, "name"),
+                bound: true,
+                exposed: {
+                    interface: exposed.interface,
+                    provider: {
+                        actor: text(exposed.provider, "actor"),
+                        export: text(exposed.provider, "export"),
+                    },
+                },
+            };
+        }
         case "serve": {
             const kind = value.kind;
             if (kind !== "call" && kind !== "subscribe" && kind !== "open" && kind !== "http")

package/dist/src/cli.js

@@ -6,6 +6,7 @@ import { parseArgs } from "node:util";
 import { hubHome, personCall, UsageError } from "@agentorg/sdk/person-commands";
 import WebSocket from "ws";
 const USAGE = `Usage: agentorg [command] [--home DIR]
+       agentorg --version
 
   (no command) [--port N] [--no-open]       run AgentOrg: the Hub, your gateway and the shell
   open                                      sign a browser in to the running app
@@ -37,11 +38,33 @@ const { values, positionals } = parseArgs({
         port: { type: "string" },
         "no-open": { type: "boolean" },
         help: { type: "boolean", short: "h" },
+        version: { type: "boolean" },
     },
     allowPositionals: true,
     strict: false,
 });
 const [command, ...rest] = positionals;
+// `build` and `hub` are the SDK's, which reads their options itself, strictly. Everything else is
+// this command's: an option it doesn't know is a mistake, never a reason to start the app.
+if (command !== "build" && command !== "hub") {
+    const unknown = Object.keys(values).find((name) => !["home", "port", "no-open", "help", "version"].includes(name));
+    if (unknown !== undefined)
+        usage(`Unknown option ${unknown.length === 1 ? "-" : "--"}${unknown}. An argument that starts with - goes after --.`);
+    // A value is a word of its own: an option in its place means the value is missing.
+    for (const [name, what] of [
+        ["home", "a directory"],
+        ["port", "a port number"],
+    ]) {
+        const value = values[name];
+        if (typeof value === "boolean" || value?.startsWith("-"))
+            usage(`--${name} takes ${what}.`);
+    }
+}
+if (values.version && command === undefined) {
+    const own = new URL("../../package.json", import.meta.url);
+    write(process.stdout, JSON.parse(readFileSync(own, "utf8")).version);
+    process.exit(0);
+}
 if (values.help && command === undefined) {
     process.stdout.write(USAGE);
     process.exit(0);

package/dist/src/gateway.js

@@ -4,7 +4,7 @@ import { createRequire } from "node:module";
 import { dirname, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Hub, listen, PERSON, STORAGE } from "@agentorg/hub";
-import { accountLogin, hubActors, hubAudit, hubBindings, hubExports, hubGrants, hubPackages, installer, kv, layout, } from "@agentorg/interfaces";
+import { accountLogin, appRules, hubActors, hubAudit, hubBindings, hubExports, hubGrants, hubPackages, installer, kv, layout, } from "@agentorg/interfaces";
 import { Refused } from "@agentorg/sdk";
 import { connect } from "@agentorg/sdk/client";
 import { WebSocketServer } from "ws";
@@ -12,6 +12,7 @@ import { serveSocket } from "./api.js";
 import { serveFrame } from "./frames.js";
 import { Layout } from "./layout.js";
 import { firstRun, oauthRoute } from "./model.js";
+import { Rules } from "./rules.js";
 import { SignIn } from "./signin.js";
 import { MAX_TRANSFER, packageArchive, pinnedHashes, readSystem, withTemporaryFile, writeSystem, } from "./transfer.js";
 /**
@@ -64,6 +65,8 @@ export async function startApp(options) {
     writePrivate(join(home, "url"), `${listener.url}\n`);
     const signIn = new SignIn();
     const changes = new Set();
+    /** Who hears that a rule was turned on or off. */
+    const ruleChanges = new Set();
     let emitChanged = () => { };
     const isView = (actorId, module) => {
         try {
@@ -128,6 +131,24 @@ export async function startApp(options) {
     /** The person's side of `/api`: its slots, and `layout`, its own export, served here. */
     const personSide = {
         async call(slot, method, input) {
+            if (slot === "rules") {
+                // The person's named rules, the gateway's own, checked as a call through the Hub would be.
+                const spec = Object.hasOwn(appRules.methods, method)
+                    ? appRules.methods[method]
+                    : undefined;
+                if (!spec)
+                    throw new Refused("invalid", `rules has no method ${method}.`);
+                const parsed = spec.input.safeParse(input);
+                if (!parsed.success)
+                    throw new Refused("invalid", `rules.${method}: ${parsed.error.message}`);
+                const result = method === "set"
+                    ? await rules.set(parsed.data)
+                    : await rules.list();
+                const checked = spec.output.safeParse(result);
+                if (!checked.success)
+                    throw new Refused("bad_output", `rules.${method}: ${checked.error.message}`);
+                return checked.data;
+            }
             if (slot === "layout") {
                 const spec = Object.hasOwn(layout.methods, method)
                     ? layout.methods[method]
@@ -154,6 +175,13 @@ export async function startApp(options) {
             return call(input);
         },
         subscribe(slot, event, send) {
+            if (slot === "rules") {
+                if (event !== "changed")
+                    throw new Refused("invalid", "rules has one event, changed.");
+                const tell = () => send({});
+                ruleChanges.add(tell);
+                return () => void ruleChanges.delete(tell);
+            }
             if (slot === "layout") {
                 if (event !== "changed")
                     throw new Refused("invalid", "layout has one event, changed.");
@@ -194,6 +222,18 @@ export async function startApp(options) {
             process.stderr.write(`First run didn't work: ${error instanceof Error ? error.message : String(error)}\n`);
             return undefined;
         });
+    // The person's named rules: off until turned on; their engine starts once the first run is done.
+    const rules = new Rules({
+        person: personSide,
+        log: (message) => process.stderr.write(`${message}\n`),
+        changed: () => {
+            for (const tell of [...ruleChanges])
+                tell();
+        },
+    });
+    void Promise.resolve(ran)
+        .then(() => rules.start())
+        .catch((error) => process.stderr.write(`The rules didn't start: ${error instanceof Error ? error.message : String(error)}\n`));
     /** The app's own pages: scripts and styles from here only, framed by nothing. */
     const appCsp = [
         "default-src 'self'",
@@ -461,6 +501,7 @@ export async function startApp(options) {
         closing ??= (async () => {
             // A first run still going finishes first, so it isn't cut off half way.
             await ran;
+            rules.close();
             const ours = (file, text) => {
                 if (file === "cli-token")
                     return text.trim() === signIn.cliToken;

package/dist/src/model.d.ts

@@ -35,10 +35,13 @@ export interface FirstRun {
  * The first run, at every start after the person's store is bound: add the bundled packages,
  * ensure the installer (made by the person, with its bindings, started), bind the person's
  * `installer` to it, ensure the model Actor installed through it (`web` to `egress`, `store` to
- * storage's `kv`, started), and bind the person's `login` to the model's. What is there already is
- * kept: an installer or model Actor an earlier run made (recorded in the person's store) stays,
- * of whatever build. A step that fails is logged and the rest still runs where it can; the next
- * start tries again.
+ * storage's `kv`, started), and bind the person's `login` to the model's. What earlier runs made
+ * (recorded in the person's store) is kept and brought to this build: an installer or model Actor
+ * on another package is upgraded in place, with its id, its store and its bindings; so is an agent
+ * on an assistant build an earlier run bundled (by the hashes recorded, never by a package's
+ * name). A binding an upgrade drops, its interface having changed, is made again where its ends
+ * match now. A step that fails is logged and the rest still runs where it can; the next start
+ * tries again.
  */
 export declare function firstRun(person: PersonCalls, options?: FirstRunOptions): Promise<FirstRun>;
 /**

package/dist/src/model.js

@@ -35,10 +35,13 @@ const INSTALLER_BINDINGS = [
  * The first run, at every start after the person's store is bound: add the bundled packages,
  * ensure the installer (made by the person, with its bindings, started), bind the person's
  * `installer` to it, ensure the model Actor installed through it (`web` to `egress`, `store` to
- * storage's `kv`, started), and bind the person's `login` to the model's. What is there already is
- * kept: an installer or model Actor an earlier run made (recorded in the person's store) stays,
- * of whatever build. A step that fails is logged and the rest still runs where it can; the next
- * start tries again.
+ * storage's `kv`, started), and bind the person's `login` to the model's. What earlier runs made
+ * (recorded in the person's store) is kept and brought to this build: an installer or model Actor
+ * on another package is upgraded in place, with its id, its store and its bindings; so is an agent
+ * on an assistant build an earlier run bundled (by the hashes recorded, never by a package's
+ * name). A binding an upgrade drops, its interface having changed, is made again where its ends
+ * match now. A step that fails is logged and the rest still runs where it can; the next start
+ * tries again.
  */
 export async function firstRun(person, options = {}) {
     const log = options.log ?? (() => { });
@@ -63,17 +66,48 @@ export async function firstRun(person, options = {}) {
     // What earlier runs made, by role, kept while it isn't closed. Unread, nothing is made: a run that
     // couldn't see its record would make a second installer.
     const read = (await call("store", "get", { key: RECORD })).value;
-    const record = Object.fromEntries(Object.entries((read ?? {})).filter(([role, id]) => (role === "installer" || role === "chatgpt") && typeof id === "string"));
+    const kept = (read ?? {});
+    // Every assistant build a run has bundled, by hash: an agent on one of them is this app's to
+    // bring to this build. Never a package by its name, which an agent's own package could take.
+    const earlier = [
+        ...(Array.isArray(kept.assistants) ? kept.assistants : []),
+        kept.assistant,
+    ].filter((hash) => typeof hash === "string");
+    const isWiring = (wiring) => typeof wiring === "object" &&
+        wiring !== null &&
+        ["consumer", "slot", "provider", "export"].every((key) => typeof wiring[key] === "string");
+    const record = {
+        ...Object.fromEntries(Object.entries(kept).filter(([role, id]) => (role === "installer" || role === "chatgpt" || role === "assistant") &&
+            typeof id === "string")),
+        ...(earlier.length ? { assistants: [...new Set(earlier)] } : {}),
+        ...(Array.isArray(kept.rebind) && kept.rebind.some(isWiring)
+            ? { rebind: kept.rebind.filter(isWiring) }
+            : {}),
+    };
+    const save = () => call("store", "set", { key: RECORD, value: { ...record } });
     const remember = (role, actorId) => {
         record[role] = actorId;
-        return call("store", "set", { key: RECORD, value: { ...record } });
+        return save();
     };
-    // The assistant New agent installs is this build's, by hash: never a package by its name, which
-    // an agent's own package could take.
+    // The assistant New agent installs is this build's, by hash.
     if (packages.assistant) {
         record.assistant = packages.assistant;
-        await attempt("recording the assistant", () => call("store", "set", { key: RECORD, value: { ...record } }));
+        record.assistants = [...new Set([...earlier, packages.assistant])];
+        await attempt("recording the assistant", save);
     }
+    /** Run this build's package as an Actor an earlier run made, keeping its id and its store. */
+    const upgrade = async (actor, hash, what) => {
+        const { dropped: lost } = await call("actors", "upgrade", {
+            actorId: actor.actorId,
+            package: hash,
+        });
+        if (lost.length) {
+            record.rebind = [...(record.rebind ?? []), ...lost];
+            await attempt("recording the bindings to make again", save);
+        }
+        log(`First run: upgraded ${what} (${actor.actorId}) to this build${lost.length ? `; ${lost.length} of its bindings to make again` : ""}.`);
+        return { ...actor, package: hash };
+    };
     /** The Actor an earlier run made for `role`, unless it is gone or closed. */
     const madeBefore = async (role) => {
         const id = record[role];
@@ -129,9 +163,12 @@ export async function firstRun(person, options = {}) {
             actor = { actorId, name: "Installer", package: hash, state: "created" };
         }
         else {
+            const hash = packages[INSTALLER];
+            const before = actor;
+            if (hash && actor.package !== hash)
+                actor =
+                    (await attempt("upgrading the installer", () => upgrade(before, hash, "the installer"))) ?? actor;
             await rebind(actor, INSTALLER_BINDINGS);
-            if (actor.package !== packages[INSTALLER])
-                log("First run: kept the installer; the bundled build is added, not used.");
         }
         await personSlot("installer", { actor: actor.actorId, export: "installer.installer" });
         await running(actor);
@@ -143,11 +180,14 @@ export async function firstRun(person, options = {}) {
         { slot: "model.store", provider: "storage", export: "kv" },
     ];
     const chatgpt = await attempt("ChatGPT", async () => {
-        const actor = await madeBefore("chatgpt");
+        let actor = await madeBefore("chatgpt");
         if (actor) {
+            const hash = packages[CHATGPT];
+            const before = actor;
+            if (hash && actor.package !== hash)
+                actor =
+                    (await attempt("upgrading ChatGPT", () => upgrade(before, hash, "ChatGPT"))) ?? actor;
             await rebind(actor, chatgptBindings);
-            if (actor.package !== packages[CHATGPT])
-                log("First run: kept ChatGPT; the bundled build is added, not used.");
             await running(actor);
             return actor.actorId;
         }
@@ -176,6 +216,35 @@ export async function firstRun(person, options = {}) {
     });
     if (chatgpt)
         await attempt("binding the login", () => personSlot("login", { actor: chatgpt, export: "model.login" }));
+    // Agents on an assistant build an earlier run bundled: brought to this build's assistant.
+    const assistant = packages.assistant;
+    if (assistant) {
+        const agents = await attempt("finding agents on earlier builds", async () => (await call("actors", "list")).actors.filter((a) => a.state !== "closed" && a.package !== assistant && earlier.includes(a.package)));
+        for (const agent of agents ?? [])
+            await attempt(`upgrading ${agent.name}`, () => upgrade(agent, assistant, `the agent ${agent.name}`));
+    }
+    // What upgrades dropped, this run or one that stopped before this, made again where its slot is
+    // still unbound: the ends now match, both on this build. One that can't be yet (an upgrade
+    // failed, or its ends still differ) is logged and kept for the next start.
+    if (record.rebind) {
+        const left = [];
+        for (const wiring of record.rebind) {
+            const made = await attempt(`binding ${wiring.slot} again`, async () => {
+                if ((await bindingsOf(wiring.consumer)).some((b) => b.slot === wiring.slot))
+                    return true;
+                await call("grants", "bind", wiring);
+                log(`First run: bound ${wiring.consumer}'s ${wiring.slot} again.`);
+                return true;
+            });
+            if (!made)
+                left.push(wiring);
+        }
+        if (left.length)
+            record.rebind = left;
+        else
+            delete record.rebind;
+        await attempt("recording the bindings made again", save);
+    }
     return {
         packages,
         ...(installer ? { installer } : {}),

package/dist/src/rules.d.ts

@@ -0,0 +1,71 @@
+import type { PersonSide } from "./api.js";
+/** Where the rules that are on are kept, in the person's store: `{<id>: {on}}`. */
+export declare const RULES_KEY = "app/rules";
+/** An exposure a request asks for: `provider`'s `export`, as a slot on `to`. */
+export interface Exposure {
+    provider: string;
+    export: string;
+    to: string;
+    as?: string;
+}
+/** An exposure as a request asks for it: by whom, and which side it lacks. */
+export interface Asked extends Exposure {
+    requestedBy?: string;
+    /** The side the requester lacks: `export` when it holds the slot side, as `to` does. */
+    needs?: string;
+}
+/** An open request, as `hub.grants` tells it. */
+export interface Request {
+    requestId: string;
+    [field: string]: unknown;
+}
+/**
+ * The exposure an open request asks for, if it asks for one. The one place that reads the Hub's
+ * request shape for exposures.
+ */
+export declare function exposureOf(request: Request): Asked | undefined;
+interface Definition {
+    id: string;
+    name: string;
+    says: string;
+    /** Whether this rule approves the exposure, read from the Hub as the person. */
+    approves(asked: Asked, person: PersonSide): Promise<boolean>;
+}
+/** The rules the app knows, in the order Settings lists them. */
+export declare const DEFINITIONS: readonly Definition[];
+export interface RulesOptions {
+    person: PersonSide;
+    /** Where the rules say what they approved, and what they couldn't. */
+    log?: (message: string) => void;
+    /** Told after a rule is turned on or off. */
+    changed?: () => void;
+}
+/**
+ * The rules, for `app.rules@1`, and their engine: it hears each request the person could approve,
+ * and goes through the open ones at start and whenever a rule is turned on. It approves a request a
+ * rule that is on matches, as an approver does, with the call the request asked for; the Hub checks
+ * that the person could grant it. It never declines: anything no rule matches stays for the person.
+ */
+export declare class Rules {
+    #private;
+    constructor(options: RulesOptions);
+    list(): Promise<{
+        rules: {
+            id: string;
+            name: string;
+            says: string;
+            on: boolean;
+        }[];
+    }>;
+    set({ id, on }: {
+        id: string;
+        on: boolean;
+    }): Promise<Record<string, never>>;
+    /** Hear each new request, and settle the open ones. */
+    start(): Promise<void>;
+    /** Stop: nothing more is heard, and a sweep under way approves nothing more. */
+    close(): void;
+    /** Go through every open request the person could approve. */
+    sweep(): Promise<void>;
+}
+export {};

package/dist/src/rules.js

@@ -0,0 +1,157 @@
+// The person's named rules: conveniences the person turns on, held by the gateway, which acts on a
+// rule that is on as the person (a manager) and only within what the person could grant. Each rule
+// is named and visible, and off until the person turns it on; nothing else acts on provenance.
+import { Refused } from "@agentorg/sdk";
+/** Where the rules that are on are kept, in the person's store: `{<id>: {on}}`. */
+export const RULES_KEY = "app/rules";
+/**
+ * The exposure an open request asks for, if it asks for one. The one place that reads the Hub's
+ * request shape for exposures.
+ */
+export function exposureOf(request) {
+    const { exposed, provider, export: name, consumer, slot, requestedBy, needs, } = request;
+    if (exposed !== true)
+        return undefined;
+    if (typeof provider !== "string" || typeof name !== "string" || typeof consumer !== "string")
+        return undefined;
+    return {
+        provider,
+        export: name,
+        to: consumer,
+        ...(typeof slot === "string" ? { as: slot } : {}),
+        ...(typeof requestedBy === "string" ? { requestedBy } : {}),
+        ...(typeof needs === "string" ? { needs } : {}),
+    };
+}
+/** The rules the app knows, in the order Settings lists them. */
+export const DEFINITIONS = [
+    {
+        id: "agents-use-what-they-install",
+        name: "Let an agent use what it installs",
+        says: "When an agent asks to use an Actor it installed, approve it.",
+        async approves(asked, person) {
+            // The agent asked for itself: it holds its slot side and lacks the export side.
+            if (asked.requestedBy !== asked.to || asked.needs !== "export")
+                return false;
+            // Provenance only: who the installer installed it for. The Hub grants nothing from it.
+            const actor = (await person.call("actors", "get", { actorId: asked.provider }));
+            return actor.state !== "closed" && actor.installedFor === asked.to;
+        },
+    },
+];
+/**
+ * The rules, for `app.rules@1`, and their engine: it hears each request the person could approve,
+ * and goes through the open ones at start and whenever a rule is turned on. It approves a request a
+ * rule that is on matches, as an approver does, with the call the request asked for; the Hub checks
+ * that the person could grant it. It never declines: anything no rule matches stays for the person.
+ */
+export class Rules {
+    #person;
+    #log;
+    #changed;
+    /** Requests being settled, so an event and a sweep don't settle one twice. */
+    #settling = new Set();
+    #stop;
+    #closed = false;
+    /** Turning rules on and off, one at a time, so none is lost. */
+    #setting = Promise.resolve();
+    constructor(options) {
+        this.#person = options.person;
+        this.#log = options.log ?? (() => { });
+        this.#changed = options.changed ?? (() => { });
+    }
+    /** The ids of the rules that are on. */
+    async #on() {
+        const { value } = (await this.#person.call("store", "get", { key: RULES_KEY }));
+        const held = typeof value === "object" && value !== null ? value : {};
+        return new Set(DEFINITIONS.filter((rule) => held[rule.id]?.on === true).map((rule) => rule.id));
+    }
+    async list() {
+        const on = await this.#on();
+        return {
+            rules: DEFINITIONS.map(({ id, name, says }) => ({ id, name, says, on: on.has(id) })),
+        };
+    }
+    set({ id, on }) {
+        if (!DEFINITIONS.some((rule) => rule.id === id))
+            return Promise.reject(new Refused("unknown", `There is no rule ${id}.`));
+        const done = this.#setting.then(async () => {
+            const now = await this.#on();
+            if (on)
+                now.add(id);
+            else
+                now.delete(id);
+            await this.#person.call("store", "set", {
+                key: RULES_KEY,
+                value: Object.fromEntries([...now].map((ruleId) => [ruleId, { on: true }])),
+            });
+            this.#changed();
+            // Turned on, it settles what already waits for it; a sweep that fails is logged, as the
+            // rule is on either way.
+            if (on)
+                await this.sweep().catch((error) => this.#log(`The rules couldn't go through what waits: ${messageOf(error)}`));
+            return {};
+        });
+        this.#setting = done.catch(() => { });
+        return done;
+    }
+    /** Hear each new request, and settle the open ones. */
+    async start() {
+        await this.sweep();
+    }
+    /** Hear each new request, once; heard again after a subscription that ended. */
+    #listen() {
+        if (this.#closed)
+            return;
+        this.#stop ??= this.#person.subscribe("grants", "requested", (request) => void this.#settle(request), () => {
+            this.#stop = undefined;
+        });
+    }
+    /** Stop: nothing more is heard, and a sweep under way approves nothing more. */
+    close() {
+        this.#closed = true;
+        this.#stop?.();
+        this.#stop = undefined;
+    }
+    /** Go through every open request the person could approve. */
+    async sweep() {
+        this.#listen();
+        for (const request of await this.#open())
+            await this.#settle(request);
+    }
+    async #open() {
+        if (this.#closed)
+            return [];
+        return (await this.#person.call("grants", "requests", {}))
+            .requests;
+    }
+    async #settle(request) {
+        const asked = exposureOf(request);
+        if (!asked || this.#closed || this.#settling.has(request.requestId))
+            return;
+        this.#settling.add(request.requestId);
+        try {
+            const on = await this.#on();
+            for (const rule of DEFINITIONS) {
+                if (!on.has(rule.id) || !(await rule.approves(asked, this.#person)))
+                    continue;
+                // Still open just before: one the person declined, or that was settled meanwhile, is left.
+                if (!(await this.#open()).some((open) => open.requestId === request.requestId))
+                    return;
+                const { provider, export: name, to, as } = asked;
+                const exposure = { provider, export: name, to, ...(as ? { as } : {}) };
+                // As an approver approves: the call the request asked for, checked by the Hub.
+                await this.#person.call("grants", "expose", exposure);
+                this.#log(`Rule "${rule.name}" approved ${exposure.provider}'s ${exposure.export} for ${exposure.to}.`);
+                return;
+            }
+        }
+        catch (error) {
+            this.#log(`A rule couldn't settle request ${request.requestId}: ${messageOf(error)}`);
+        }
+        finally {
+            this.#settling.delete(request.requestId);
+        }
+    }
+}
+const messageOf = (error) => (error instanceof Error ? error.message : String(error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentorg/cli",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "AgentOrg as one app: the Hub, the person's gateway and the shell, on loopback.",
   "license": "MIT",
   "repository": {
@@ -24,27 +24,24 @@
   "files": [
     "dist/src",
     "dist/bundled",
-    "static"
+    "static",
+    "dist/node_modules"
   ],
   "dependencies": {
-    "@agentorg/hub": "0.0.0",
-    "@agentorg/interfaces": "0.0.0",
-    "@agentorg/sdk": "0.0.0",
-    "@agentorg/shell": "0.0.0",
+    "@assistant-ui/react": "^0.15.32",
     "ajv": "^8.20.0",
     "esbuild": "0.28.2",
+    "radix-ui": "^1.8.1",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
+    "react-markdown": "^10.1.0",
+    "react-resizable-panels": "^4.19.1",
+    "remark-gfm": "^4.0.1",
+    "remend": "^1.4.0",
     "ws": "^8.22.1",
-    "zod": "^4.6.7",
-    "@agentorg/wire": "0.0.0"
+    "zod": "^4.6.7"
   },
   "publishConfig": {
     "access": "public"
-  },
-  "bundleDependencies": [
-    "@agentorg/wire",
-    "@agentorg/sdk",
-    "@agentorg/interfaces",
-    "@agentorg/hub",
-    "@agentorg/shell"
-  ]
+  }
 }