@agentorg/cli 0.0.6 → 0.0.7

package/dist/node_modules/@agentorg/manager/dist/src/manager.js

@@ -1,27 +1,28 @@
 import { chmodSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { agentProvider, agentSettings, agents, ConnectionOrigin, connections, hubActors, hubBindings, hubGrants, mcpProvider, skills, } from "@agentorg/interfaces";
+import { agentProvider, agentSettings, agents, chat, connections, hubActors, hubBindings, hubGrants, skills, tools, unitProvider, } from "@agentorg/interfaces";
 import { describeInterface, Refused } from "@agentorg/sdk";
 import { connect } from "@agentorg/sdk/client";
-import { z } from "zod";
+import { createActivity } from "./activity.js";
+import { createControl } from "./control.js";
+import { schemaOf, secretsSchemaOf, settle } from "./form.js";
 import { createSkills, readSkillFolder } from "./skills.js";
-/** What only management knows of an agent: where it came from, what it is told, and its skills. */
-const AgentRecord = z.object({
-    provider: z.string(),
-    creatable: z.string(),
-    instructions: z.string(),
-    skills: z.array(z.string()),
-});
-const Records = z.object({
-    agents: z.record(z.string(), AgentRecord),
-    connections: z.record(z.string(), ConnectionOrigin),
-});
+import { createStacks, Records, slotFieldOf } from "./stack.js";
 const FILE = "manager.json";
-const PERSON = "person";
-const TOOLS = "tools@1";
+const ACTIVITY = "activity.jsonl";
+/** Who a control call is made as, when it isn't on an agent's own behalf. */
+const PERSON_CALLER = "person";
+const CHAT_WAIT_MS = 2000;
+const CHAT = "chat@1";
+/** What one agent may add of its own, at most. */
+const AGENT_CONNECTIONS = 16;
+const AGENT_SKILLS = 32;
+const AGENT_SKILL_BYTES = 1024 * 1024;
 const TOOLS_EXPORT = "tools";
 const quiet = { info() { }, warn() { }, error() { } };
 const messageOf = (error) => (error instanceof Error ? error.message : String(error));
+/** The slot a connection is made for by the person: no agent has it yet, so it names nothing. */
+const PERSON_SLOT = "tools";
 const alreadyGone = (error) => error instanceof Refused && error.code === "unknown";
 /**
  * Run management as an Actor exporting `agents@1`, `connections@1`, `skills@1` and, as `settings`,
@@ -36,7 +37,13 @@ export async function startManager(options) {
     chmodSync(dir, 0o700);
     const path = join(dir, FILE);
     const read = () => {
-        const empty = { agents: {}, connections: {} };
+        const empty = {
+            agents: {},
+            connections: {},
+            templates: {},
+            instances: {},
+            authors: { skills: {}, templates: {} },
+        };
         let raw;
         try {
             raw = readFileSync(path, "utf8");
@@ -61,6 +68,7 @@ export async function startManager(options) {
         renameSync(`${path}.tmp`, path);
     };
     const library = createSkills(join(dir, "skills"));
+    const activity = createActivity(join(dir, ACTIVITY));
     /** Agents being made: they can read their settings, and nothing else can see them yet. */
     const creating = new Map();
     const client = await connect({
@@ -68,7 +76,7 @@ export async function startManager(options) {
         actorId: options.actorId,
         credential: options.credential,
         slots: { actors: hubActors, grants: hubGrants, bindings: hubBindings },
-        exports: { agents, connections, skills, settings: agentSettings },
+        exports: { agents, connections, skills, settings: agentSettings, tools },
         log,
         start(ctx) {
             const hub = {
@@ -85,7 +93,7 @@ export async function startManager(options) {
                     .map(({ provider, call }) => ({ actor: provider.actor, call: call }));
             };
             const agentProviders = () => exposed(agentProvider);
-            const mcpProviders = () => exposed(mcpProvider);
+            const unitProviders = () => exposed(unitProvider);
             const named = (list, actor, what) => {
                 const found = list.find((one) => one.actor === actor);
                 if (!found)
@@ -110,6 +118,30 @@ export async function startManager(options) {
                     throw new Refused("unknown", `Management has no agent ${agent}.`);
                 return record;
             };
+            /** The caller when it's an agent, which reaches these only through its control unit. */
+            const agentOf = (caller) => records.agents[caller] || creating.has(caller) ? caller : undefined;
+            /** A skill an agent added is seen by it and the agents below it, until the person shares it. */
+            const seesSkill = (caller, name) => {
+                const author = records.authors.skills[name];
+                if (!author || !agentOf(caller))
+                    return true;
+                const seen = new Set();
+                for (let at = caller; at && !seen.has(at);) {
+                    if (at === author)
+                        return true;
+                    seen.add(at);
+                    at = records.agents[at]?.parent?.agent;
+                }
+                return false;
+            };
+            const parentOf = ({ parent }) => parent
+                ? {
+                    parent: {
+                        ...parent,
+                        ...(records.agents[parent.agent] ? {} : { gone: true }),
+                    },
+                }
+                : {};
             const settingsOf = (agent) => creating.get(agent) ?? recordOf(agent);
             const originOf = (connection) => {
                 const origin = records.connections[connection];
@@ -125,32 +157,22 @@ export async function startManager(options) {
                     return { state: "down", detail: "Its provider can't be reached." };
                 }
             };
+            const instanceOf = (connection) => records.instances[connection] ?? connection;
+            const forget = (connection) => {
+                delete records.connections[connection];
+                delete records.instances[connection];
+            };
             const connectionStatus = async (connection) => {
+                const unit = stacks.unitMaking(connection);
+                if (unit)
+                    return stacks.connectionStatus(unit, connection);
                 const origin = records.connections[connection];
                 if (!origin) {
                     // Exposed by hand, so no provider is known: the Hub says whether it is there.
                     const { connected } = await hub.actors.get({ actorId: connection });
                     return { state: connected ? "connected" : "down", tools: [] };
                 }
-                try {
-                    const mcp = named(mcpProviders(), origin.provider, "MCP provider");
-                    return await mcp.call.status({ connection });
-                }
-                catch {
-                    return { state: "down", detail: "Its provider can't be reached.", tools: [] };
-                }
-            };
-            const offering = async (kind) => {
-                const providers = mcpProviders();
-                const answers = await fromEach(providers, async ({ actor, call }) => ({
-                    actor,
-                    call,
-                    kinds: (await call.kinds({})).kinds,
-                }));
-                const found = answers.find((one) => one.kinds.some((k) => k.kind === kind));
-                if (!found)
-                    throw new Refused("unknown", `No connected MCP provider offers ${kind}.`);
-                return found;
+                return stacks.connectionStatus({ provider: origin.provider, providerInstance: instanceOf(connection) }, connection);
             };
             const exposeConnection = async (agent, connection, as) => {
                 const { slot } = await hub.grants.expose({
@@ -163,10 +185,10 @@ export async function startManager(options) {
             };
             /** Remove a connection through its provider; one that has lost it leaves only the Actor. */
             const removeConnection = async (connection, provider) => {
-                const mcp = mcpProviders().find((one) => one.actor === provider);
+                const maker = unitProviders().find((one) => one.actor === provider);
                 try {
-                    if (mcp)
-                        return void (await mcp.call.remove({ connection }));
+                    if (maker)
+                        return void (await maker.call.remove({ instance: instanceOf(connection) }));
                 }
                 catch (error) {
                     if (!alreadyGone(error))
@@ -197,14 +219,154 @@ export async function startManager(options) {
                 for (const [agent, record] of Object.entries(records.agents))
                     if (record.skills.includes(name)) {
                         record.skills = record.skills.filter((skill) => skill !== name);
+                        for (const unit of record.units)
+                            unit.skills = unit.skills.filter((skill) => skill !== name);
                         changed(agent);
                     }
             };
+            const stacks = createStacks({
+                self: options.actorId,
+                hub,
+                records,
+                save,
+                library,
+                creating,
+                log,
+                shipped: options.templates ?? [],
+                agentProviders,
+                unitProviders,
+                recordOf,
+                openActors: open,
+                nameOf,
+                changed,
+                fromEach,
+                exposeConnection,
+                closing,
+                removeAgent,
+            });
+            /** An agent's own provider, which runs it and keeps its model. */
+            const makerOf = (agent) => named(agentProviders(), recordOf(agent).provider, "agent provider").call;
+            const startAgent = async (agent) => makerOf(agent).start({ agent });
+            const stopAgent = async (agent) => makerOf(agent).stop({ agent });
+            /** Its units and connections go first: if one can't, the agent is here to be tried again. */
+            const removeWhole = (agent) => stacks.serial(agent, async () => {
+                const record = recordOf(agent);
+                await stacks.removeAll(agent, record);
+                for (const [connection, origin] of Object.entries(records.connections)) {
+                    if (origin.madeFor !== agent)
+                        continue;
+                    await removeConnection(connection, origin.provider);
+                    forget(connection);
+                    save();
+                }
+                await removeAgent(agent, record.provider);
+                delete records.agents[agent];
+                // What it wrote or saved is the person's now.
+                for (const kept of [records.authors.skills, records.authors.templates])
+                    for (const [name, author] of Object.entries(kept))
+                        if (author === agent)
+                            delete kept[name];
+                save();
+                return {};
+            });
+            /** A child's chat: exposed to management when it is made, which takes a moment to arrive. */
+            const chatOf = async (agent) => {
+                const exposedChat = () => exposed(chat).find((one) => one.actor === agent);
+                if (!exposedChat()) {
+                    // One the person made: its chat is reached as the person reaches it.
+                    const { bindings } = await hub.bindings.list({ actor: PERSON_CALLER });
+                    const theirs = bindings.find((one) => one.provider === agent && one.interface === CHAT && one.consumer === PERSON_CALLER);
+                    if (theirs)
+                        await hub.grants
+                            .expose({ provider: agent, export: theirs.export, to: options.actorId })
+                            .catch((error) => log.warn(`Reaching a chat: ${messageOf(error)}`));
+                }
+                for (let waited = 0; waited < CHAT_WAIT_MS; waited += 20) {
+                    const found = exposed(chat).find((one) => one.actor === agent);
+                    if (found)
+                        return found.call;
+                    await new Promise((resolve) => setTimeout(resolve, 20));
+                }
+                throw new Refused("not_connected", "That agent's chat can't be reached now.");
+            };
+            /**
+             * An agent's chats reach the person, and management too for an agent another agent made. The
+             * Hub drops both when the agent comes back offering its chats in another shape, as after an
+             * upgrade, so they are made again each time it connects: nothing changes when they are there.
+             */
+            const reachChats = async (agent) => {
+                const record = records.agents[agent];
+                if (!record || !(await hub.actors.get({ actorId: agent })).connected)
+                    return;
+                for (const to of [PERSON_CALLER, ...(record.parent ? [options.actorId] : [])])
+                    await hub.grants.expose({ provider: agent, export: record.chat, to });
+            };
+            const reaching = (agent) => void reachChats(agent).catch((error) => log.warn(`Reaching a chat: ${messageOf(error)}`));
+            ctx.slots.actors.on("changed", ({ actor }) => reaching(actor));
+            // And for those that connected while management was away, once it can ask.
+            ctx.slots.actors.onBind(() => {
+                for (const agent of Object.keys(records.agents))
+                    reaching(agent);
+            });
+            /** The person's own handlers, which an agent's control tools call after their checks. */
+            const personHandlers = {};
+            const control = createControl({
+                self: options.actorId,
+                records,
+                creatingCount: () => creating.size,
+                catalog: stacks.catalog,
+                boundTo: async (agent) => new Set((await hub.bindings.list({ actor: agent })).bindings
+                    .filter((binding) => binding.consumer === agent)
+                    .map((binding) => `${binding.slot} ${binding.provider}`)),
+                templates: stacks.allTemplates,
+                baseProviderNamed: stacks.baseProviderNamed,
+                serial: stacks.serial,
+                create: (input, caller, child) => stacks.create(input, caller, child),
+                nameOf,
+                chatOf,
+                statusOf: agentStatus,
+                start: startAgent,
+                stop: stopAgent,
+                remove: removeWhole,
+                // Held to the interface's own input, as the person's calls are by the Hub.
+                person: async (iface, method, input, caller = PERSON_CALLER) => {
+                    const handler = personHandlers[iface]?.[method];
+                    const spec = { agents, connections, skills }[iface].methods[method];
+                    if (!handler || !spec)
+                        throw new Refused("unimplemented", `${iface} has no ${method}.`);
+                    return handler(spec.input.parse(input), { caller });
+                },
+                hasSkill: (name, caller) => library.has(name) && seesSkill(caller, name),
+                templateAuthor: (id) => records.authors.templates[id],
+                madeBy: (connection) => records.connections[connection]?.madeBy,
+                log: (entry) => activity.add(entry),
+            });
+            /** Those who call management: the person. An agent comes through its control unit instead. */
+            const personOnly = (exported, name) => ({
+                implement(handlers) {
+                    const held = handlers;
+                    personHandlers[name] = held;
+                    exported.implement(Object.fromEntries(Object.entries(held).map(([method, handler]) => [
+                        method,
+                        (input, context) => {
+                            if (records.agents[context.caller] || creating.has(context.caller))
+                                throw new Refused("forbidden", "An agent reaches this through its control unit.");
+                            return handler(input, context);
+                        },
+                    ])));
+                },
+            });
+            ctx.exports.tools.implement({
+                list: async (_, { caller }) => ({ tools: await control.list(caller) }),
+                call: ({ name, arguments: input }, { caller }) => control.call(caller, name, input),
+            });
             ctx.exports.settings.implement({
                 get: (_, { caller }) => {
-                    const { instructions, skills: names } = settingsOf(caller);
+                    const { instructions, purpose, skills: names } = settingsOf(caller);
                     return {
-                        instructions,
+                        instructions: purpose
+                            ? `${instructions}\n\nWhat you are for: ${purpose}`
+                            : instructions,
                         skills: names.flatMap((name) => library.entry(name) ?? []),
                     };
                 },
@@ -217,7 +379,7 @@ export async function startManager(options) {
                     return { text };
                 },
             });
-            ctx.exports.agents.implement({
+            personOnly(ctx.exports.agents, "agents").implement({
                 creatable: async () => ({
                     creatables: (await fromEach(agentProviders(), async ({ actor, call }) => (await call.creatable({})).creatables.map((one) => ({ ...one, provider: actor })))).flat(),
                 }),
@@ -227,99 +389,23 @@ export async function startManager(options) {
                         name: await nameOf(actor),
                     }))),
                 }),
-                async create(input, { caller }) {
-                    const { creatable: id, name, answers, connections: picked = {} } = input;
-                    const provider = named(agentProviders(), input.provider, "agent provider");
-                    const creatable = (await provider.call.creatable({})).creatables.find((c) => c.id === id);
-                    if (!creatable)
-                        throw new Refused("unknown", `${input.provider} offers no ${id}.`);
-                    for (const need of creatable.mcp)
-                        if (need.how === "pick" && !picked[need.slot])
-                            throw new Refused("invalid", `Pick a connection for ${need.slot}.`);
-                    /** What this creation has made so far, undone last first if a step fails. */
-                    const undo = [];
-                    try {
-                        const made = await provider.call.create({ creatable: id, name, answers });
-                        const { agent } = made;
-                        undo.push(() => closing(agent, () => removeAgent(agent, input.provider)));
-                        const record = {
-                            provider: input.provider,
-                            creatable: id,
-                            instructions: creatable.instructions,
-                            skills: [],
-                        };
-                        creating.set(agent, record);
-                        undo.push(() => creating.delete(agent));
-                        const origins = {};
-                        await hub.grants.bind({
-                            consumer: agent,
-                            slot: made.settings,
-                            provider: options.actorId,
-                            export: "settings",
-                        });
-                        for (const skill of creatable.skills) {
-                            if (!library.has(skill.name)) {
-                                const files = {};
-                                for (const file of skill.files)
-                                    files[file] = (await provider.call.skill({ creatable: id, name: skill.name, path: file })).text;
-                                library.add(files, skill.name);
-                                // Another agent may have been given it meanwhile, and then it stays.
-                                undo.push(() => {
-                                    if (!Object.values(records.agents).some((r) => r.skills.includes(skill.name)))
-                                        library.remove(skill.name);
-                                });
-                            }
-                            record.skills.push(skill.name);
-                        }
-                        for (const need of creatable.mcp) {
-                            let connection = picked[need.slot];
-                            if (need.how === "create") {
-                                const mcp = await offering(need.kind);
-                                const params = { ...need.params };
-                                for (const [param, ask] of Object.entries(need.fromAnswers ?? {}))
-                                    if (answers[ask] !== undefined)
-                                        params[param] = answers[ask];
-                                const { connection: id2, target } = await mcp.call.create({
-                                    kind: need.kind,
-                                    params,
-                                    name: `${name}: ${need.title}`.slice(0, 128),
-                                });
-                                connection = id2;
-                                undo.push(() => closing(id2, () => removeConnection(id2, mcp.actor)));
-                                origins[id2] = {
-                                    provider: mcp.actor,
-                                    kind: need.kind,
-                                    target,
-                                    madeBy: caller,
-                                    madeFor: agent,
-                                    at: new Date().toISOString(),
-                                };
-                            }
-                            await exposeConnection(agent, connection, need.slot);
-                        }
-                        await hub.grants.expose({
-                            provider: agent,
-                            export: made.chat,
-                            to: PERSON,
-                        });
-                        records.agents[agent] = record;
-                        Object.assign(records.connections, origins);
-                        undo.push(() => {
-                            delete records.agents[agent];
-                            for (const connection of Object.keys(origins))
-                                delete records.connections[connection];
-                        });
-                        save();
-                        creating.delete(agent);
-                        return { agent };
-                    }
-                    catch (error) {
-                        for (const step of undo.reverse())
-                            await Promise.resolve()
-                                .then(step)
-                                .catch((failed) => log.error(`Undoing a creation: ${messageOf(failed)}`));
-                        throw error;
-                    }
+                units: () => stacks.units(),
+                templates: () => stacks.templates(),
+                saveTemplate: (template, { caller }) => stacks.saveTemplate(template, agentOf(caller)),
+                removeTemplate: (input, { caller }) => stacks.removeTemplate(input, agentOf(caller)),
+                check: (input) => stacks.check(input),
+                create: (input, { caller }) => stacks.create(input, caller),
+                addUnit: (input, { caller }) => stacks.serial(input.agent, () => stacks.addUnit(input, caller)),
+                removeUnit: (input) => stacks.serial(input.agent, () => stacks.removeUnit(input)),
+                activity: (input) => activity.read(input),
+                async live({ agent, instance, surface, mode }) {
+                    const unit = recordOf(agent).units.find((one) => one.instance === instance);
+                    if (!unit || unit.provider === options.actorId)
+                        throw new Refused("unknown", `${agent} has nothing like that to open live.`);
+                    const provider = unitProviders().find((one) => one.actor === unit.provider);
+                    if (!provider)
+                        throw new Refused("not_connected", "Its provider can't be reached now.");
+                    return provider.call.live({ instance: unit.providerInstance, surface, mode });
                 },
                 async list() {
                     const actors = await open();
@@ -334,6 +420,9 @@ export async function startManager(options) {
                                         status,
                                         provider: record.provider,
                                         creatable: record.creatable,
+                                        ...(record.purpose ? { purpose: record.purpose } : {}),
+                                        ...(record.template ? { template: record.template } : {}),
+                                        ...parentOf(record),
                                     })),
                                 ]
                                 : [];
@@ -342,19 +431,18 @@ export async function startManager(options) {
                 },
                 async get({ agent }) {
                     const record = recordOf(agent);
-                    const { bindings } = await hub.bindings.list({ actor: agent });
+                    const { units, tools, instanceOfSkill, instanceOfSlot } = await stacks.read(agent, record, connectionStatus);
                     const [name, status, mcp] = await Promise.all([
                         nameOf(agent),
                         agentStatus(agent, record.provider),
-                        Promise.all(bindings
-                            .filter((b) => b.consumer === agent && b.interface === TOOLS)
-                            .map(async (b) => ({
+                        Promise.all(tools.map(async (b) => ({
                             slot: b.slot,
                             connection: b.provider,
                             ...(records.connections[b.provider]
                                 ? { origin: records.connections[b.provider] }
                                 : {}),
                             status: await connectionStatus(b.provider),
+                            instance: instanceOfSlot(b.slot),
                         }))),
                     ]);
                     return {
@@ -363,34 +451,42 @@ export async function startManager(options) {
                         status,
                         provider: record.provider,
                         creatable: record.creatable,
+                        ...(record.purpose ? { purpose: record.purpose } : {}),
+                        ...(record.template ? { template: record.template } : {}),
+                        ...parentOf(record),
                         instructions: record.instructions,
-                        skills: record.skills.flatMap((skill) => library.entry(skill) ?? []),
+                        skills: record.skills.flatMap((skill) => {
+                            const entry = library.entry(skill);
+                            return entry ? [{ ...entry, instance: instanceOfSkill(skill) }] : [];
+                        }),
                         mcp,
+                        units,
                     };
                 },
-                async start({ agent }) {
-                    const { provider } = recordOf(agent);
-                    return named(agentProviders(), provider, "agent provider").call.start({ agent });
-                },
-                async stop({ agent }) {
-                    const { provider } = recordOf(agent);
-                    return named(agentProviders(), provider, "agent provider").call.stop({ agent });
-                },
-                async expose(input) {
+                start: ({ agent }) => startAgent(agent),
+                stop: ({ agent }) => stopAgent(agent),
+                models: ({ agent }) => makerOf(agent).models({ agent }),
+                setModel: (input) => makerOf(input.agent).setModel(input),
+                expose: (input, { caller }) => stacks.serial(input.agent, async () => {
                     const record = recordOf(input.agent);
                     if ("connection" in input)
                         return { slot: await exposeConnection(input.agent, input.connection, input.as) };
-                    if (!library.has(input.skill))
+                    if (!library.has(input.skill) || !seesSkill(caller, input.skill))
                         throw new Refused("unknown", `Management has no skill ${input.skill}.`);
+                    // The person giving an agent's skill to anyone shares it: it's the person's now.
+                    if (!agentOf(caller))
+                        delete records.authors.skills[input.skill];
                     if (!record.skills.includes(input.skill)) {
                         record.skills.push(input.skill);
                         save();
                         changed(input.agent);
                     }
                     return {};
-                },
-                async unexpose(input) {
+                }),
+                unexpose: (input) => stacks.serial(input.agent, async () => {
                     const record = recordOf(input.agent);
+                    if (stacks.fromUnit(record, input))
+                        throw new Refused("state", "This came with a unit: remove the unit.");
                     if ("slot" in input) {
                         await hub.grants.unexpose({ to: input.agent, slot: input.slot });
                         return {};
@@ -401,53 +497,80 @@ export async function startManager(options) {
                         changed(input.agent);
                     }
                     return {};
-                },
-                /** The connections go first: if one can't, the agent is still here to be tried again. */
-                async remove({ agent }) {
-                    const record = recordOf(agent);
-                    for (const [connection, origin] of Object.entries(records.connections)) {
-                        if (origin.madeFor !== agent)
-                            continue;
-                        await removeConnection(connection, origin.provider);
-                        delete records.connections[connection];
-                        save();
-                    }
-                    await removeAgent(agent, record.provider);
-                    delete records.agents[agent];
-                    save();
-                    return {};
-                },
+                }),
+                /** Units and connections go first: if one can't, the agent is still here to be tried again. */
+                remove: ({ agent }) => removeWhole(agent),
             });
-            ctx.exports.connections.implement({
+            personOnly(ctx.exports.connections, "connections").implement({
                 providers: async () => ({
-                    providers: await fromEach(mcpProviders(), async ({ actor, call }) => ({
+                    providers: (await fromEach(unitProviders(), async ({ actor, call }) => ({
                         provider: actor,
                         name: await nameOf(actor),
-                        kinds: (await call.kinds({})).kinds,
-                    })),
+                        kinds: (await call.units({})).units.flatMap((unit) => {
+                            const slot = slotFieldOf(unit);
+                            if (!slot)
+                                return [];
+                            const fields = unit.form.filter((field) => field.id !== slot);
+                            return [
+                                {
+                                    kind: unit.id,
+                                    title: unit.title,
+                                    params: JSON.parse(JSON.stringify(schemaOf(fields))),
+                                    secrets: JSON.parse(JSON.stringify(secretsSchemaOf(fields))),
+                                },
+                            ];
+                        }),
+                    }))).filter(({ kinds }) => kinds.length > 0),
                 }),
                 // `secrets` go straight to the provider: nothing here keeps or logs them.
-                async create({ provider, kind, params, secrets, name }, { caller }) {
-                    const mcp = named(mcpProviders(), provider, "MCP provider");
-                    const { connection, target } = await mcp.call.create({
-                        kind,
-                        params,
+                async create({ provider, kind, params, secrets = {}, name }, { caller }) {
+                    const agent = agentOf(caller);
+                    if (agent &&
+                        Object.values(records.connections).filter((one) => one.madeBy === agent).length >=
+                            AGENT_CONNECTIONS)
+                        throw new Refused("limit", `An agent can add at most ${AGENT_CONNECTIONS} connections.`);
+                    const { call } = named(unitProviders(), provider, "connection provider");
+                    const unit = (await call.units({})).units.find((one) => one.id === kind);
+                    const slot = unit && slotFieldOf(unit);
+                    if (!unit || !slot)
+                        throw new Refused("invalid", `${provider} offers no ${kind}.`);
+                    const declared = Object.keys(secrets).filter((id) => unit.form.some((field) => field.id === id && field.value === "secret"));
+                    const settled = settle(unit.form, { ...params, [slot]: PERSON_SLOT }, declared);
+                    if (settled.problems.length)
+                        throw new Refused("invalid", settled.problems.map((one) => one.message).join(" "));
+                    const applied = await call.apply({
+                        unit: kind,
+                        values: settled.values,
+                        secrets,
+                        needs: {},
+                        agent: "person",
                         name,
-                        ...(secrets ? { secrets } : {}),
                     });
+                    const [made] = applied.connections;
+                    if (!made || applied.connections.length !== 1) {
+                        await call.remove({ instance: applied.instance }).catch(async () => {
+                            for (const one of applied.connections)
+                                await hub.actors.close({ actorId: one.connection });
+                        });
+                        throw new Refused("failed", `${kind} didn't make one connection.`);
+                    }
+                    const { connection, target } = made;
                     try {
                         records.connections[connection] = {
                             provider,
                             kind,
                             target,
                             madeBy: caller,
+                            // One an agent made goes with it.
+                            ...(agent ? { madeFor: agent } : {}),
                             at: new Date().toISOString(),
                         };
+                        records.instances[connection] = applied.instance;
                         save();
                     }
                     catch (error) {
-                        delete records.connections[connection];
                         await closing(connection, () => removeConnection(connection, provider));
+                        forget(connection);
                         throw error;
                     }
                     return { connection };
@@ -479,25 +602,52 @@ export async function startManager(options) {
                         status: await connectionStatus(connection),
                     };
                 },
-                async remove({ connection }) {
+                async remove({ connection }, { caller }) {
                     const origin = originOf(connection);
+                    if (agentOf(caller) && origin.madeBy !== caller)
+                        throw new Refused("unknown", `You have no connection ${connection}.`);
+                    if (stacks.unitMaking(connection))
+                        throw new Refused("state", "This connection came with a unit: remove the unit.");
                     await removeConnection(connection, origin.provider);
-                    delete records.connections[connection];
+                    forget(connection);
                     save();
                     return {};
                 },
             });
-            ctx.exports.skills.implement({
-                add: (input) => {
+            personOnly(ctx.exports.skills, "skills").implement({
+                add: (input, { caller }) => {
+                    const agent = agentOf(caller);
+                    if (agent) {
+                        // An agent writes a skill of its own: it can't read a folder, or replace one there is.
+                        if ("path" in input)
+                            throw new Refused("forbidden", "An agent gives a skill as files.");
+                        const named = library.nameOf(input.files);
+                        if (library.has(named))
+                            throw new Refused("state", `There is a skill ${named} already.`);
+                        if (Object.values(records.authors.skills).filter((one) => one === agent).length >=
+                            AGENT_SKILLS)
+                            throw new Refused("limit", `An agent can write at most ${AGENT_SKILLS} skills.`);
+                        const bytes = Object.values(input.files).reduce((sum, text) => sum + Buffer.byteLength(text), 0);
+                        if (bytes > AGENT_SKILL_BYTES)
+                            throw new Refused("limit", "An agent's skill can be at most 1 MB.");
+                        const added = library.add(input.files, named);
+                        records.authors.skills[added.name] = agent;
+                        save();
+                        return added;
+                    }
                     const added = library.add("path" in input ? readSkillFolder(input.path) : input.files);
+                    // Replaced by the person, it's the person's.
+                    delete records.authors.skills[added.name];
                     for (const [agent, record] of Object.entries(records.agents))
                         if (record.skills.includes(added.name))
                             changed(agent);
                     return added;
                 },
-                list: () => ({ skills: library.list() }),
-                get: ({ name }) => {
-                    const entry = library.entry(name);
+                list: (_, { caller }) => ({
+                    skills: library.list().filter((one) => seesSkill(caller, one.name)),
+                }),
+                get: ({ name }, { caller }) => {
+                    const entry = seesSkill(caller, name) ? library.entry(name) : undefined;
                     if (!entry)
                         throw new Refused("unknown", `Management has no skill ${name}.`);
                     return {
@@ -509,10 +659,12 @@ export async function startManager(options) {
                             .map(([agent]) => agent),
                     };
                 },
-                remove: ({ name }) => {
-                    if (!library.has(name))
+                remove: ({ name }, { caller }) => {
+                    const agent = agentOf(caller);
+                    if (!library.has(name) || (agent && records.authors.skills[name] !== agent))
                         throw new Refused("unknown", `Management has no skill ${name}.`);
                     dropSkill(name);
+                    delete records.authors.skills[name];
                     save();
                     return {};
                 },