@agentorg/cli 0.0.1 → 0.0.2

package/README.md

@@ -1,11 +1,11 @@
 # agentorg
 
-AgentOrg connects Actors into an organization. Each Actor is a position with a responsibility and
-a manager; the user is at the root. Hub keeps organizational state and exposes explicit Tools.
+AgentOrg connects Actors into an organization. Each Actor is a responsibility, and every Actor sits
+on one flat level; the person is the user's own Actor. Hub keeps organizational state and exposes explicit Tools.
 Actors decide how to use those Tools independently of any native execution implementation.
 
 Actors exchange Messages in pair conversations, and track shared Work with the asks on it, through
-Hub Tools backed by `@uniac/agentic-workspace`. Hub supplies canonical Actor identity and hierarchy,
+Hub Tools backed by `@uniac/agentic-workspace`. Hub supplies canonical Actor identity, the person,
 actual connection presence and shared resource claims. An enrolled Provider can provision an
 implementation when requested at Actor creation. Human applications, agent sessions and programs share the same authority.
 

package/dist/src/bindings/mcp/encoding.js

@@ -1,6 +1,6 @@
 /** Semantic Hub Tools and operation results at the MCP boundary. */
 import { z } from "zod";
-import { Id, INTERFACE_NAME, Level, } from "../../domain/model/index.js";
+import { Id, INTERFACE_NAME } from "../../domain/model/index.js";
 const TOOL_META = "agentorg/tool";
 const ToolMetadata = z.strictObject({
     id: Id,
@@ -8,7 +8,6 @@ const ToolMetadata = z.strictObject({
     interface: z.string().regex(INTERFACE_NAME),
     one_way: z.boolean(),
     long_running: z.boolean(),
-    level: Level.optional(),
 });
 /** Flatten explicit Hub Tools for MCP while retaining their identity and local names. */
 export function offeredToolsOf(catalog) {
@@ -30,7 +29,6 @@ export function offeredToolsOf(catalog) {
                     interface: name,
                     one_way,
                     long_running,
-                    ...(offer.level === undefined ? {} : { level: offer.level }),
                 },
             },
         };
@@ -64,7 +62,6 @@ export function catalogOf(tools) {
                 long_running: meta.long_running,
             },
             ...(readOnly === undefined ? {} : { read_only: readOnly }),
-            ...(meta.level === undefined ? {} : { level: meta.level }),
         });
         catalog.set(meta.id, group);
         calls.add(tool.name);

package/dist/src/clients/cli/commands.js

@@ -7,7 +7,7 @@ const note = (text) => process.stderr.write(`agentorg: ${text}\n`);
 async function asActor(run) {
     const identity = readIdentity();
     if (!identity) {
-        throw new Error(`no identity: set AGENTORG_ACTOR_ID and AGENTORG_CREDENTIAL, or run \`agentorg-server\`, which writes the root's credential to ${rootCredentialPath()}`);
+        throw new Error(`no identity: set AGENTORG_ACTOR_ID and AGENTORG_CREDENTIAL, or run \`agentorg-server\`, which writes the person's credential to ${rootCredentialPath()}`);
     }
     const url = coreUrl();
     const client = await connectClient({ url, ...identity, name: "agentorg-cli" }).catch((error) => {

package/dist/src/clients/cli/index.js

@@ -14,7 +14,7 @@ const usage = () => [
     "  call <name> --json <json> Invoke any permitted interface; print its complete answer.",
     ...builtinLines(),
     "",
-    "Set AGENTORG_ACTOR_ID with AGENTORG_CREDENTIAL, else use the root's local identity.",
+    "Set AGENTORG_ACTOR_ID with AGENTORG_CREDENTIAL, else use the person's local identity.",
     "agentorg <operation> --help shows its flags.",
 ].join("\n");
 export async function main(argv) {

package/dist/src/clients/mcp/agent.d.ts

@@ -5,22 +5,20 @@
  * never the credential. Workspace record authority remains with the Hub and package clients.
  */
 import { type PresentationOptions, type Presented } from "../../actor/index.ts";
-import { type Answer, type InterfaceDescriptor, type Level, type ToolDescriptor } from "../../domain/model/index.ts";
+import { type Answer, type InterfaceDescriptor, type ToolDescriptor } from "../../domain/model/index.ts";
 export declare const ATTACH: InterfaceDescriptor;
 /** What the session's client may show its model about the agent actor's tools as a whole. */
-export declare const INSTRUCTIONS = "These tools make this session a position in an AgentOrg organization: a responsibility with a manager, under the user. Attach before any other action, with the actor id the brief names, or with a name and purpose when the user started the session with no position named. Then use interfaces to list the Hub interfaces this session presents, interfaces {name} to read one's schemas, and call with {name, input} to invoke one. Logical names such as work_update and attention are operations through call. How to work in a position is the agentorg skill; without it, read https://github.com/uniac-ai/AgentOrg/blob/main/skills/agentorg/SKILL.md.";
+export declare const INSTRUCTIONS = "These tools make this session an Actor in an AgentOrg organization: a responsibility on its one flat level, working for the user. Attach before any other action, with the actor id the brief names, or with a name and purpose when the user started the session with no position named. Then use interfaces to list the Hub's interfaces, interfaces {name} to read one's schemas, and call with {name, input} to invoke one. Logical names such as work_update and attention are operations through call. How to work as an Actor is the agentorg skill; without it, read https://github.com/uniac-ai/AgentOrg/blob/main/skills/agentorg/SKILL.md.";
 export interface AgentOptions {
     coreUrl: string;
     /** The client session this agent serves, when the client names one; it remembers the position. */
     session: string | undefined;
     /** A client that identifies its session on each call instead of at process startup. */
     client?: string;
-    /** The organization level whose interfaces `interfaces` presents; without one, all of them. */
-    level?: Level;
 }
 export declare class Agent implements Presented {
     #private;
-    readonly instructions = "These tools make this session a position in an AgentOrg organization: a responsibility with a manager, under the user. Attach before any other action, with the actor id the brief names, or with a name and purpose when the user started the session with no position named. Then use interfaces to list the Hub interfaces this session presents, interfaces {name} to read one's schemas, and call with {name, input} to invoke one. Logical names such as work_update and attention are operations through call. How to work in a position is the agentorg skill; without it, read https://github.com/uniac-ai/AgentOrg/blob/main/skills/agentorg/SKILL.md.";
+    readonly instructions = "These tools make this session an Actor in an AgentOrg organization: a responsibility on its one flat level, working for the user. Attach before any other action, with the actor id the brief names, or with a name and purpose when the user started the session with no position named. Then use interfaces to list the Hub's interfaces, interfaces {name} to read one's schemas, and call with {name, input} to invoke one. Logical names such as work_update and attention are operations through call. How to work as an Actor is the agentorg skill; without it, read https://github.com/uniac-ai/AgentOrg/blob/main/skills/agentorg/SKILL.md.";
     constructor(options: AgentOptions);
     /** Connect the position this session filled before, if it did; retried until the core answers. */
     resume(): Promise<void>;

package/dist/src/clients/mcp/agent.js

@@ -9,22 +9,21 @@ import { z } from "zod";
 import { connectClient, } from "../../actor/index.js";
 import { Handle, Id, objectSchema, Text, } from "../../domain/model/index.js";
 import { credentials, readPrivate, rootActorPath, rootCredentialPath } from "../../home.js";
-import { presented } from "./levels.js";
 import { sessionName, sessions } from "./sessions.js";
 const AttachRequest = z.strictObject({
     actor: Id.optional().describe("The id of the position your brief names."),
-    name: Handle.optional().describe("Only when the user appointed you directly, with no position named: your handle under the user."),
+    name: Handle.optional().describe("Only when the user appointed you directly, with no position named: your handle."),
     purpose: Text.optional().describe("With name: what your position is for."),
 });
 const Attached = z.strictObject({
     actor: Id.describe("The position you now fill."),
-    created: z.boolean().describe("True when attaching created it, under the user."),
+    created: z.boolean().describe("True when attaching created it."),
 });
 export const ATTACH = {
     name: "attach",
     description: `Fill your position in the organization before listing or calling Hub Tools. A resumed session can acknowledge its same actor; an attached session cannot change actors.
 
-Give actor, the id your brief names. A session the user started with an appointment, naming no position, gives name and purpose instead, once: that creates its position directly under the user. Then team shows your position, your manager and your reports.`,
+Give actor, the id your brief names. A session the user started with an appointment, naming no position, gives name and purpose instead, once: that creates its Actor, beside every other. Then team shows every open Actor, you among them.`,
     input: objectSchema(AttachRequest, "input"),
     output: objectSchema(Attached, "output"),
     one_way: false,
@@ -39,7 +38,7 @@ const InterfacesRequest = z.strictObject({
 });
 const INTERFACES = {
     name: "interfaces",
-    description: "List the Hub interfaces this session presents, each with its call alias and a one-line summary. Give name to read one interface's description and input/output schemas before calling an operation whose contract you have not read.",
+    description: "List the Hub's interfaces, each with its call alias and a one-line summary. Give name to read one interface's description and input/output schemas before calling an operation whose contract you have not read.",
     input: objectSchema(InterfacesRequest, "input"),
     one_way: false,
     long_running: false,
@@ -52,7 +51,7 @@ const CALL = {
     long_running: false,
 };
 /** What the session's client may show its model about the agent actor's tools as a whole. */
-export const INSTRUCTIONS = `These tools make this session a position in an AgentOrg organization: a responsibility with a manager, under the user. Attach before any other action, with the actor id the brief names, or with a name and purpose when the user started the session with no position named. Then use interfaces to list the Hub interfaces this session presents, interfaces {name} to read one's schemas, and call with {name, input} to invoke one. Logical names such as work_update and attention are operations through call. How to work in a position is the agentorg skill; without it, read https://github.com/uniac-ai/AgentOrg/blob/main/skills/agentorg/SKILL.md.`;
+export const INSTRUCTIONS = `These tools make this session an Actor in an AgentOrg organization: a responsibility on its one flat level, working for the user. Attach before any other action, with the actor id the brief names, or with a name and purpose when the user started the session with no position named. Then use interfaces to list the Hub's interfaces, interfaces {name} to read one's schemas, and call with {name, input} to invoke one. Logical names such as work_update and attention are operations through call. How to work as an Actor is the agentorg skill; without it, read https://github.com/uniac-ai/AgentOrg/blob/main/skills/agentorg/SKILL.md.`;
 const refused = (code, message) => ({ state: "refused", code, message });
 export class Agent {
     instructions = INSTRUCTIONS;
@@ -67,12 +66,6 @@ export class Agent {
         this.#session = options.session;
         if (this.#session !== undefined)
             this.#filled = sessions.position(this.#session);
-        this.#present();
-    }
-    /** Record the level this server presents beside a filled position, for the session's waiter. */
-    #present() {
-        if (this.#session !== undefined && this.#filled !== undefined)
-            sessions.present(this.#session, this.#options.level);
     }
     /** Connect the position this session filled before, if it did; retried until the core answers. */
     async resume() {
@@ -168,14 +161,12 @@ export class Agent {
         catch {
             return refused("unavailable", "the Hub did not list available Tools");
         }
-        const level = this.#options.level;
-        const offers = presented(tools, level);
+        const offers = tools.flatMap((tool) => tool.interfaces);
         if (name === undefined) {
             const summaryOf = (description = "") => description.split("\n\n")[0] ?? "";
             return {
                 state: "done",
                 value: {
-                    ...(level === undefined ? {} : { level }),
                     interfaces: offers.map((offer) => ({
                         name: offer.call,
                         summary: summaryOf(offer.interface.description),
@@ -185,9 +176,7 @@ export class Agent {
         }
         const offer = offers.find((each) => each.call === name);
         if (offer === undefined)
-            return refused("not_found", presented(tools, undefined).some((each) => each.call === name)
-                ? `${name} is not presented at the ${level} level`
-                : `there is no Hub interface ${name}`);
+            return refused("not_found", `there is no Hub interface ${name}`);
         const { description, input, output } = offer.interface;
         return {
             state: "done",
@@ -216,7 +205,6 @@ export class Agent {
         }
         this.#session = session;
         this.#filled = sessions.position(session);
-        this.#present();
         const actor = this.#filled;
         const credential = actor === undefined ? undefined : credentials.read(actor);
         if (actor !== undefined && credential !== undefined) {
@@ -238,7 +226,7 @@ export class Agent {
         }
         let actor = request.actor;
         if (actor === undefined) {
-            const created = await this.#createUnderRoot(request.name, request.purpose);
+            const created = await this.#createWithPerson(request.name, request.purpose);
             if (created.state !== "done")
                 return created;
             actor = created.value;
@@ -257,7 +245,6 @@ export class Agent {
         this.#filled = actor;
         if (this.#session !== undefined) {
             sessions.fill(this.#session, actor);
-            this.#present();
             // Delivery starts from now: what happened before the session attached is not its input.
             // Without it, the waiter starts from whenever it first reads.
             const now = await this.#position?.call("attention", {}).catch(() => undefined);
@@ -267,9 +254,9 @@ export class Agent {
         return { state: "done", value: { actor, created: request.actor === undefined } };
     }
     /**
-     * Create the session's position under the root with the root's credential, used for that only.
+     * Create the session's Actor with the person's credential, used for that only.
      */
-    async #createUnderRoot(name, purpose) {
+    async #createWithPerson(name, purpose) {
         const file = rootCredentialPath();
         if (!existsSync(file))
             return refused("not_found", `no root credential in ${file}`);

package/dist/src/clients/mcp/command.d.ts

@@ -8,5 +8,5 @@
 export declare function claudeTakesInput(line: string): boolean;
 /** What a session that fills no position reads before its first turn. */
 export declare const ATTACH_FIRST = "agentorg: This session can fill a position in an AgentOrg organization. Load the agentorg skill, then attach with `attach` before any other action.";
-export declare const MCP_HELP: string;
+export declare const MCP_HELP = "usage: agentorg-mcp [--client claude-code|codex]\n       agentorg-mcp context|wait [--client claude-code|codex]\n       agentorg-mcp connect <claude-code|codex> [--project <dir>]\n       agentorg-mcp disconnect <claude-code|codex> [--project <dir>]\n       agentorg-mcp status [--project <dir>]\n\nPresent attach, interfaces and call over stdio, connected to AGENTORG_URL. Listing and invocation require attachment. interfaces lists the Hub interfaces with one-line summaries, and interfaces {name} returns one's schemas; call invokes an interface by its call alias.\nClient hooks: context emits an attachment hint; wait delivers what concerns the attached Actor, read with attention, on stderr with the client's wake status.";
 export declare function mcpCommand(args: string[]): Promise<number>;

package/dist/src/clients/mcp/command.js

@@ -3,7 +3,6 @@ import { execFileSync } from "node:child_process";
 import { once } from "node:events";
 import { parseArgs } from "node:util";
 import { presentOverStdio } from "../../actor/index.js";
-import { Level } from "../../domain/model/index.js";
 import { coreUrl } from "../../network/index.js";
 import { help } from "../../runtime/command.js";
 import { Agent } from "./agent.js";
@@ -75,7 +74,6 @@ function client(args) {
         args,
         options: {
             client: { type: "string", default: "claude-code" },
-            level: { type: "string" },
         },
         allowPositionals: true,
         strict: true,
@@ -85,10 +83,7 @@ function client(args) {
     if (found === undefined) {
         throw new Error(`unknown client ${name}; known: ${Object.keys(CLIENTS).join(", ")}`);
     }
-    const level = values.level === undefined ? undefined : Level.safeParse(values.level);
-    if (level?.success === false)
-        throw new Error(`unknown level ${values.level}; known: ${Level.options.join(", ")}`);
-    return { name, client: found, level: level?.data, rest: positionals };
+    return { name, client: found, rest: positionals };
 }
 async function text(stream) {
     let read = "";
@@ -99,13 +94,13 @@ async function text(stream) {
 const sessionOf = (name, client, input) => sessionName(name, client.session(input));
 /** What a session that fills no position reads before its first turn. */
 export const ATTACH_FIRST = "agentorg: This session can fill a position in an AgentOrg organization. Load the agentorg skill, then attach with `attach` before any other action.";
-export const MCP_HELP = `usage: agentorg-mcp [--client claude-code|codex] [--level ${Level.options.join("|")}]
+export const MCP_HELP = `usage: agentorg-mcp [--client claude-code|codex]
        agentorg-mcp context|wait [--client claude-code|codex]
-       agentorg-mcp connect <claude-code|codex> [--project <dir>] [--level <level>]
+       agentorg-mcp connect <claude-code|codex> [--project <dir>]
        agentorg-mcp disconnect <claude-code|codex> [--project <dir>]
        agentorg-mcp status [--project <dir>]
 
-Present attach, interfaces and call over stdio, connected to AGENTORG_URL. Listing and invocation require attachment. interfaces lists the Hub interfaces of the chosen level (without one, the whole catalog) with one-line summaries, and interfaces {name} returns one's schemas; call invokes an interface by its call alias.
+Present attach, interfaces and call over stdio, connected to AGENTORG_URL. Listing and invocation require attachment. interfaces lists the Hub interfaces with one-line summaries, and interfaces {name} returns one's schemas; call invokes an interface by its call alias.
 Client hooks: context emits an attachment hint; wait delivers what concerns the attached Actor, read with attention, on stderr with the client's wake status.`;
 export async function mcpCommand(args) {
     const command = args[0];
@@ -117,7 +112,7 @@ export async function mcpCommand(args) {
     }
     if (asked)
         return help(MCP_HELP);
-    const { name, client: chosen, level, rest } = client(args);
+    const { name, client: chosen, rest } = client(args);
     const input = name === "codex" && ["context", "wait"].includes(rest[0] ?? "")
         ? await text(process.stdin)
         : undefined;
@@ -145,7 +140,6 @@ export async function mcpCommand(args) {
     const agent = new Agent({
         coreUrl: coreUrl(),
         session,
-        ...(level === undefined ? {} : { level }),
         ...(name === "codex" ? { client: name } : {}),
     });
     const server = await presentOverStdio(agent);

package/dist/src/clients/mcp/projects.d.ts

@@ -4,10 +4,9 @@
  * installed command whatever the client's `PATH`. `connect` writes only entries it can find again:
  * connecting again replaces them, and `disconnect` removes them and nothing of the user's.
  */
-import type { Level } from "../../domain/model/index.ts";
 export interface Client {
     /** Write the client's configuration and the skill link; return the paths written. */
-    connect(project: string, launcher: string, level?: Level): string[];
+    connect(project: string, launcher: string): string[];
     /** Remove them; return the paths changed. */
     disconnect(project: string): string[];
     /** Undefined when the project isn't connected, else what is wrong with its connection. */

package/dist/src/clients/mcp/projects.js

@@ -72,11 +72,7 @@ function skillProblems(folder) {
     return [];
 }
 const shellWord = (text) => `'${text.replaceAll("'", `'\\''`)}'`;
-const agentArgs = (client, level) => [
-    "--client",
-    client,
-    ...(level === undefined ? [] : ["--level", level]),
-];
+const agentArgs = (client) => ["--client", client];
 // Claude Code: the server in `.mcp.json`, approved and hooked in `.claude/settings.local.json`, the
 // user's own settings for the project, and the skill in `.claude/skills/`.
 const HOOK_COMMAND = /\/agentorg-mcp' (context|prompt|wait) --client (claude-code|codex)$/;
@@ -168,14 +164,14 @@ function claudeServer(path) {
     return org;
 }
 const claudeCode = {
-    connect(project, launcher, level) {
+    connect(project, launcher) {
         const files = claudeFiles(project);
         claudeServer(files.servers);
         const config = readJson(files.servers);
         const servers = isObject(config.mcpServers) ? config.mcpServers : {};
         config.mcpServers = {
             ...servers,
-            org: { command: launcher, args: agentArgs("claude-code", level) },
+            org: { command: launcher, args: agentArgs("claude-code") },
         };
         writeJson(files.servers, config);
         const settings = readJson(files.settings);
@@ -278,14 +274,14 @@ const codexFiles = (project) => ({
     skills: join(project, ".agents", "skills"),
 });
 const codex = {
-    connect(project, launcher, level) {
+    connect(project, launcher) {
         const files = codexFiles(project);
         const config = codexConfig(files.config);
         const hooks = readJson(files.hooks);
         withOurHooks(hooks, "codex", launcher);
         const settings = {
             command: JSON.stringify(launcher),
-            args: JSON.stringify(agentArgs("codex", level)),
+            args: JSON.stringify(agentArgs("codex")),
         };
         let text;
         if (config.table === undefined) {

package/dist/src/clients/mcp/sessions.d.ts

@@ -1,7 +1,6 @@
 /**
  * Which client session fills which position, kept in the home's `sessions/<session>/` so that a
- * resumed session fills it again. `position` holds the Actor ID, `level` the level its server
- * presents, `waiter` the current waiter PID, and `inbox` the `attention` position the session has
+ * resumed session fills it again. `position` holds the Actor ID, `waiter` the current waiter PID, and `inbox` the `attention` position the session has
  * been given everything before. This private bookkeeping establishes neither public
  * acknowledgements nor user input.
  */
@@ -10,9 +9,6 @@ export declare function sessionName(client: string, id: string | undefined): str
 export declare const sessions: {
     position: (session: string) => string | undefined;
     fill: (session: string, actor: string) => void;
-    /** The level the session's server presents, which the waiter frames for; none is every tool. */
-    level: (session: string) => string | undefined;
-    present(session: string, level: string | undefined): void;
     /** Forget the session, as when its position closed. */
     forget: (session: string) => void;
     waiter: (session: string) => number;

package/dist/src/clients/mcp/sessions.js

@@ -1,7 +1,6 @@
 /**
  * Which client session fills which position, kept in the home's `sessions/<session>/` so that a
- * resumed session fills it again. `position` holds the Actor ID, `level` the level its server
- * presents, `waiter` the current waiter PID, and `inbox` the `attention` position the session has
+ * resumed session fills it again. `position` holds the Actor ID, `waiter` the current waiter PID, and `inbox` the `attention` position the session has
  * been given everything before. This private bookkeeping establishes neither public
  * acknowledgements nor user input.
  */
@@ -44,14 +43,6 @@ function replace(session, entry, value) {
 export const sessions = {
     position: (session) => read(session, "position"),
     fill: (session, actor) => write(session, "position", actor),
-    /** The level the session's server presents, which the waiter frames for; none is every tool. */
-    level: (session) => read(session, "level"),
-    present(session, level) {
-        if (level !== undefined)
-            replace(session, "level", level);
-        else
-            rmSync(join(directory(session), "level"), { force: true });
-    },
     /** Forget the session, as when its position closed. */
     forget: (session) => rmSync(directory(session), { recursive: true, force: true }),
     waiter: (session) => Number(read(session, "waiter") ?? 0),

package/dist/src/clients/mcp/setup.js

@@ -4,17 +4,16 @@ import { statSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { parseArgs } from "node:util";
-import { Level } from "../../domain/model/index.js";
 import { coreUrl } from "../../network/index.js";
 import { launcherPath, writeLauncher } from "../../runtime/launcher.js";
 import { answers, launcherStatus, printReport } from "../../runtime/status.js";
 import { CLIENTS, clientOf } from "./projects.js";
 const PROGRAM = "agentorg-mcp";
 const NAMES = Object.keys(CLIENTS).join("|");
-export const CONNECT_HELP = `usage: agentorg-mcp connect <${NAMES}> [--project <dir>] [--level ${Level.options.join("|")}]
+export const CONNECT_HELP = `usage: agentorg-mcp connect <${NAMES}> [--project <dir>]
        agentorg-mcp disconnect <${NAMES}> [--project <dir>]
 
-connect pins this MCP adapter and Node in <home>/bin/agentorg-mcp, configures the project's org MCP server and hooks, and links the package's agentorg skill. --level chooses the interfaces the server presents; without it, the whole catalog. Claude Code also gets its MCP approval. The project's other entries stay as they are. Codex requires project trust, enabled hooks (features.hooks), and review and trust of the hook definitions through /hooks.
+connect pins this MCP adapter and Node in <home>/bin/agentorg-mcp, configures the project's org MCP server and hooks, and links the package's agentorg skill. Claude Code also gets its MCP approval. The project's other entries stay as they are. Codex requires project trust, enabled hooks (features.hooks), and review and trust of the hook definitions through /hooks.
 
 connect checks through the launcher with a bare PATH. disconnect removes only this adapter's entries.`;
 export const STATUS_HELP = `usage: agentorg-mcp status [--project <dir>]
@@ -29,7 +28,7 @@ const projectOf = (path) => {
 export async function setupCommand(command, args) {
     const { values, positionals } = parseArgs({
         args,
-        options: { project: { type: "string" }, level: { type: "string" } },
+        options: { project: { type: "string" } },
         allowPositionals: true,
         strict: true,
     });
@@ -63,11 +62,8 @@ export async function setupCommand(command, args) {
             : `${name} was not connected\n`);
         return 0;
     }
-    const level = values.level === undefined ? undefined : Level.safeParse(values.level);
-    if (level?.success === false)
-        throw new Error(`unknown level ${values.level}; known: ${Level.options.join(", ")}`);
     const launcher = writeLauncher(PROGRAM);
-    const written = client.connect(project, launcher, level?.data);
+    const written = client.connect(project, launcher);
     process.stdout.write(`connected ${name} in ${project}:\n${written.map((path) => `  wrote ${path}`).join("\n")}\nchecking through the launcher, with only /usr/bin and /bin on PATH:\n`);
     if (name === "codex") {
         process.stdout.write("Codex: trust this project's configuration, enable features.hooks, and review and trust AgentOrg's definitions through /hooks. These hooks do not wake an idle turn.\n");

package/dist/src/clients/mcp/waiter.d.ts

@@ -25,8 +25,6 @@ export type Delivery = Item & {
 };
 interface Here {
     self: z.output<typeof Position>;
-    /** The call aliases the session's server presents; a frame names work_answer only if presented. */
-    presented: ReadonlySet<string>;
 }
 export declare function waitForNews(options: WaitOptions): Promise<boolean>;
 export declare function describe(items: Delivery[], here: Here): string;

package/dist/src/clients/mcp/waiter.js

@@ -1,7 +1,6 @@
 import { connectClient } from "../../actor/index.js";
-import { Level, MAX_WAIT_SECONDS } from "../../domain/model/index.js";
+import { MAX_WAIT_SECONDS } from "../../domain/model/index.js";
 import { credentials } from "../../home.js";
-import { presented } from "./levels.js";
 import { sessions } from "./sessions.js";
 const value = (answer) => {
     if (answer.state === "done")
@@ -83,8 +82,8 @@ export async function waitForNews(options) {
                 void connected.close().catch(() => { });
             }, 100);
             watch.unref();
-            const team = await call(client, "team", { depth: 0 });
-            const self = team.positions[0];
+            const team = await call(client, "team", {});
+            const self = team.positions.find((position) => position.id === actorID);
             if (!self)
                 throw new Error("the Hub named no position");
             while (current()) {
@@ -102,11 +101,7 @@ export async function waitForNews(options) {
                             items.push(await delivery(client, actorID, item));
                     if (!current())
                         return false;
-                    const level = Level.safeParse(sessions.level(options.session)).data;
-                    const offers = presented(await client.available(), level);
-                    if (!current())
-                        return false;
-                    options.write(describe(items, { self, presented: new Set(offers.map((o) => o.call)) }));
+                    options.write(describe(items, { self }));
                     sessions.advanceInbox(options.session, read.next);
                     return true;
                 }
@@ -126,11 +121,9 @@ export async function waitForNews(options) {
     return false;
 }
 const quoted = (text) => `"${text}"`;
-/** What one item says to the session, with what to do about it, in tools its level presents. */
+/** What one item says to the session, with what to do about it. */
 function frame(item, here) {
-    const from = `${item.from.name}${item.from.actorID === here.self.manager ? ", your manager," : ""}`;
-    // Answering and raising name work_answer, which the session's level may not present.
-    const answering = here.presented.has("work_answer");
+    const from = item.from.name;
     switch (item.kind) {
         case "answer": {
             const response = item.ask?.responses[item.from.actorID];
@@ -146,9 +139,7 @@ function frame(item, here) {
             return `${from} answered your ask ${quoted(item.title)} (${item.recordID}): ${answers}.${note} Apply it${work}. The ask records the answer; ${item.ask?.status === "open" ? "it collects more until you close it" : "it is resolved"}.`;
         }
         case "ask":
-            return `${from} routes you the ask ${quoted(item.title)} (${item.recordID}). Read it with work_get {askID: "${item.recordID}"}${answering ? ", then answer it with work_answer {askID, answers, note?}, or raise it one manager up with work_answer {askID, raise: true}" : ""}.`;
-        case "raised":
-            return `${from} raised your ask ${quoted(item.title)} (${item.recordID}) to its manager; it stays open until someone answers it. Keep working on what doesn't depend on it.`;
+            return `${from} routes you the ask ${quoted(item.title)} (${item.recordID}). Read it with work_get {askID: "${item.recordID}"}, then answer it with work_answer {askID, answers, note?}.`;
         case "updated":
             return item.work?.status === "cancelled"
                 ? `${from} cancelled your Work ${quoted(item.title)} (${item.recordID}); its open asks are cancelled. Stop working on it.`
@@ -157,9 +148,7 @@ function frame(item, here) {
             return `${from} gave you Work ${quoted(item.title)} (${item.recordID}). Read it with work_get; set it active with work_update when you start.`;
         case "review_due": {
             const submission = item.work?.submission;
-            const answer = answering
-                ? `, then answer it with work_answer {askID: ${submission ? `"${submission.submissionID}"` : "<its submissionID>"}, answers: {verdict: "accepted" or "changes_requested"}, note?}; requesting changes needs the note`
-                : "";
+            const answer = `, then answer it with work_answer {askID: ${submission ? `"${submission.submissionID}"` : "<its submissionID>"}, answers: {verdict: "accepted" or "changes_requested"}, note?}; requesting changes needs the note`;
             // A submission a close re-routes comes from the Actor that closed, not from its submitter.
             return submission && submission.ownerID !== item.from.actorID
                 ? `${from} closed the Actor the submission of ${quoted(item.title)} (${item.recordID}) waited on; it now waits for your answer. Read the submission with work_get${answer}.`
@@ -175,7 +164,7 @@ function frame(item, here) {
 }
 export function describe(items, here) {
     return [
-        `AgentOrg, for ${here.self.path || here.self.name} (${here.self.id}). These come through the Hub from other Actors, not from the user typing in this session. An answer is an ordinary Actor record; a native approval requires its client's validated binding.`,
+        `AgentOrg, for ${here.self.name} (${here.self.id}). These come through the Hub from other Actors, not from the user typing in this session. An answer is an ordinary Actor record; a native approval requires its client's validated binding.`,
         ...items.map((item) => frame(item, here)),
     ].join("\n\n");
 }

package/dist/src/domain/actors.js

@@ -5,17 +5,13 @@ export { ACTORS as definition } from "./model/index.js";
 export function actors(registry, connections, execution) {
     function view(actor) {
         const { credential_hash: _, ...identity } = actor;
-        return {
-            ...identity,
-            path: registry.path(actor),
-            online: connections.connected(actor.id),
-        };
+        return { ...identity, online: connections.connected(actor.id) };
     }
     return {
         view,
         tool: bindTool(ACTORS, {
-            actor_create: async (actor, request) => {
-                const { actor: created, credential } = await registry.create(actor.id, request.name, request.purpose);
+            actor_create: async (_actor, request) => {
+                const { actor: created, credential } = await registry.create(request.name, request.purpose);
                 const outcome = request.execution === undefined
                     ? undefined
                     : await execution.create({

package/dist/src/domain/attention.d.ts

@@ -1,12 +1,13 @@
 /**
  * What concerns an Actor, read from the audited writes after its position, by the next mover.
- * On its records: Work given to it or changed by its requester, an answer to its
- * submission, an answer to its ask or the ask's raise, and a message to it. Routed to it, or to a
- * closed Actor it stands in for: an ask from a report or raised to it while the ask is open and
- * with it, and a submission of Work it requested while the submission waits. Closing an Actor gives
- * its stand-in an ask for each open ask the close re-routes and a review_due for each waiting
- * submission, from the Actor that closed it; a stand-in that closed it gets none, as its own
- * write. A read that finds nothing waits for the next audited write, up to `wait` seconds.
+ * On its records: Work given to it or changed by its requester, an answer to its submission, an
+ * answer to its ask, and a message to it. Routed to it: an ask on Work it requested while the ask
+ * is open and still routed to it, and a submission of Work it requested while the submission
+ * waits. The person also gets the asks on Work their asker requested itself or on no Work, and
+ * stands in for closed Actors: closing one gives it an ask for each open ask the close re-routes
+ * and a review_due for each waiting submission, from the Actor that closed it, or none when the
+ * person closed it, as its own write. A read that finds nothing waits for the next audited write,
+ * up to `wait` seconds.
  */
 import type { Audit } from "./audit.ts";
 import type { Registry } from "./registry.ts";