@agentorg/cli 0.0.1 → 0.0.2

package/dist/src/home.d.ts

@@ -1,5 +1,5 @@
 /**
- * The agentorg home: the directory holding the core's database, the root's credential, the
+ * The agentorg home: the directory holding the core's database, the person's credential, the
  * credential store of the positions sessions fill, and which session fills which. It is
  * `AGENTORG_HOME`, or `~/.local/share/agentorg/`. Backing up means copying it.
  */
@@ -7,9 +7,9 @@ export declare function home(): string;
 /** The home directory, created readable by its owner only when it does not exist. */
 export declare function ensureHome(): string;
 export declare function databasePath(): string;
-/** The root's credential, which `agentorg-server` writes on first start, mode 600. */
+/** The person's credential, which `agentorg-server` writes on first start, mode 600. */
 export declare function rootCredentialPath(): string;
-/** The root's Actor identity, written beside its credential by `agentorg-server`. */
+/** The person's Actor identity, written beside its credential by `agentorg-server`. */
 export declare function rootActorPath(): string;
 /** A file's trimmed contents, refused when other users can read it. */
 export declare function readPrivate(path: string): string;
@@ -26,9 +26,9 @@ export declare const credentials: {
     read(actor: string): string | undefined;
     remove(actor: string): void;
 };
-/** An actor's credential: `AGENTORG_CREDENTIAL` when set, else the root's, from its file. */
+/** An actor's credential: `AGENTORG_CREDENTIAL` when set, else the person's, from its file. */
 export declare function readCredential(): string | undefined;
-/** Select an explicit Actor identity and its credential from the environment or local root files. */
+/** Select an explicit Actor identity and its credential from the environment or the person's files. */
 export declare function readIdentity(): {
     actorId: string;
     credential: string;

package/dist/src/home.js

@@ -1,5 +1,5 @@
 /**
- * The agentorg home: the directory holding the core's database, the root's credential, the
+ * The agentorg home: the directory holding the core's database, the person's credential, the
  * credential store of the positions sessions fill, and which session fills which. It is
  * `AGENTORG_HOME`, or `~/.local/share/agentorg/`. Backing up means copying it.
  */
@@ -18,11 +18,11 @@ export function ensureHome() {
 export function databasePath() {
     return join(home(), "core.db");
 }
-/** The root's credential, which `agentorg-server` writes on first start, mode 600. */
+/** The person's credential, which `agentorg-server` writes on first start, mode 600. */
 export function rootCredentialPath() {
     return join(home(), "root-credential");
 }
-/** The root's Actor identity, written beside its credential by `agentorg-server`. */
+/** The person's Actor identity, written beside its credential by `agentorg-server`. */
 export function rootActorPath() {
     return join(home(), "root-actor");
 }
@@ -65,13 +65,13 @@ export const credentials = {
         rmSync(credentials.path(actor), { force: true });
     },
 };
-/** An actor's credential: `AGENTORG_CREDENTIAL` when set, else the root's, from its file. */
+/** An actor's credential: `AGENTORG_CREDENTIAL` when set, else the person's, from its file. */
 export function readCredential() {
     if (process.env.AGENTORG_CREDENTIAL)
         return process.env.AGENTORG_CREDENTIAL;
     return existsSync(rootCredentialPath()) ? readPrivate(rootCredentialPath()) : undefined;
 }
-/** Select an explicit Actor identity and its credential from the environment or local root files. */
+/** Select an explicit Actor identity and its credential from the environment or the person's files. */
 export function readIdentity() {
     const actorId = process.env.AGENTORG_ACTOR_ID;
     const credential = process.env.AGENTORG_CREDENTIAL;
@@ -84,7 +84,7 @@ export function readIdentity() {
     if (!existsSync(rootCredentialPath()))
         return undefined;
     if (!existsSync(rootActorPath())) {
-        throw new Error(`no root actor id in ${rootActorPath()}; restart agentorg-server`);
+        throw new Error(`no Actor id for the person in ${rootActorPath()}; restart agentorg-server`);
     }
     return { actorId: readPrivate(rootActorPath()), credential: readPrivate(rootCredentialPath()) };
 }

package/dist/src/server/command.js

@@ -14,7 +14,7 @@ const HELP = `usage: agentorg-server [--port <n>]
        agentorg-server service install|uninstall
        agentorg-server status
 
-Run the organization's core on 127.0.0.1 at --port, else AGENTORG_PORT, else ${DEFAULT_CORE_PORT}. Its records and root credential are in AGENTORG_HOME, default ~/.local/share/agentorg. The first start creates the root. A missing root credential file is replaced on startup.
+Run the organization's core on 127.0.0.1 at --port, else AGENTORG_PORT, else ${DEFAULT_CORE_PORT}. Its records and the person's credential are in AGENTORG_HOME, default ~/.local/share/agentorg. The first start creates the person, the user's own Actor. A missing credential file for the person is replaced on startup.
 
 service manages only the core's user service. status reports its executable, launcher, service and availability.`;
 /** Suppress only Node 22's experimental SQLite notice while loading the store. */
@@ -57,7 +57,7 @@ export async function main(args) {
         onError: (actor, error) => process.stderr.write(`${PROGRAM}: the channel of ${actor} failed to start: ${error.message}\n`),
     });
     await rootCredential(core.organization.registry, rootCredentialPath());
-    process.stderr.write(`${PROGRAM}: core serving on ${core.url}; the root's credential is in ${rootCredentialPath()}\n`);
+    process.stderr.write(`${PROGRAM}: core serving on ${core.url}; the person's credential is in ${rootCredentialPath()}\n`);
     await Promise.race([once(process, "SIGINT"), once(process, "SIGTERM")]);
     await core.close();
     store.close();

package/dist/src/server/index.d.ts

@@ -38,7 +38,7 @@ export declare function startCore(store: Store, options: CoreOptions & {
     hostname?: string;
 }): Promise<RunningCore>;
 /**
- * The root's credential, kept in `file`: written with the root on the first start, and minted
+ * The person's credential, kept in `file`: written with the person on the first start, and minted
  * again when the file is gone, since only its hash is stored.
  */
 export declare function rootCredential(registry: Registry, file: string): Promise<string>;

package/dist/src/server/index.js

@@ -122,7 +122,7 @@ export async function startCore(store, options) {
     };
 }
 /**
- * The root's credential, kept in `file`: written with the root on the first start, and minted
+ * The person's credential, kept in `file`: written with the person on the first start, and minted
  * again when the file is gone, since only its hash is stored.
  */
 export async function rootCredential(registry, file) {
@@ -141,7 +141,7 @@ export async function rootCredential(registry, file) {
     }
     const credential = readPrivate(file);
     if ((await registry.byCredential(credential))?.id !== root.id) {
-        throw new Error(`${file} does not hold the root's credential; delete it and start the core again to mint a new one`);
+        throw new Error(`${file} does not hold the person's credential; delete it and start the core again to mint a new one`);
     }
     writePrivate(join(dirname(file), "root-actor"), root.id);
     return credential;

package/dist/src/storage/sqlite/database.d.ts

@@ -15,6 +15,11 @@ export declare class Database {
     private readonly kinds;
     constructor(path: string);
     private createSchema;
+    /**
+     * Schema 10: handles become unique among open Actors, not among siblings. A later open duplicate
+     * takes the first free `<handle>-<n>`, within the 40-character handle, from n = 2.
+     */
+    private uniqueOpenHandles;
     close(): void;
     /** Run `work` as one transaction, rolled back if it throws. */
     transaction<T>(work: () => T): T;

package/dist/src/storage/sqlite/database.js

@@ -52,8 +52,12 @@ export class Database {
           message_id TEXT PRIMARY KEY, source_hash TEXT NOT NULL,
           recipient_id TEXT NOT NULL REFERENCES actors(id), workspace_cursor INTEGER NOT NULL
         );
-        PRAGMA user_version = ${SCHEMA_VERSION};
+        PRAGMA user_version = 9;
       `));
+            version = 9;
+        }
+        if (version === 9) {
+            this.transaction(() => this.uniqueOpenHandles());
             return;
         }
         if (version !== 0) {
@@ -61,6 +65,33 @@ export class Database {
         }
         this.transaction(() => this.db.exec(`${SCHEMA}\nPRAGMA user_version = ${SCHEMA_VERSION};`));
     }
+    /**
+     * Schema 10: handles become unique among open Actors, not among siblings. A later open duplicate
+     * takes the first free `<handle>-<n>`, within the 40-character handle, from n = 2.
+     */
+    uniqueOpenHandles() {
+        const taken = new Set(this.all("SELECT name FROM actors").map((row) => String(row.name)));
+        const open = new Set();
+        for (const row of this.all("SELECT id, name FROM actors WHERE closed_at IS NULL ORDER BY rowid")) {
+            const handle = String(row.name);
+            let name = handle;
+            for (let n = 2; open.has(name); n += 1) {
+                const candidate = `${handle.slice(0, 39 - String(n).length)}-${n}`;
+                if (!taken.has(candidate))
+                    name = candidate;
+            }
+            if (name !== handle)
+                this.run("UPDATE actors SET name = ? WHERE id = ?", [name, String(row.id)]);
+            taken.add(name);
+            open.add(name);
+        }
+        this.db.exec(`
+      DROP INDEX one_root;
+      DROP INDEX handles_unique_among_siblings;
+      CREATE UNIQUE INDEX handles_unique_among_open ON actors (name) WHERE closed_at IS NULL;
+      PRAGMA user_version = 10;
+    `);
+    }
     close() {
         this.db.close();
     }

package/dist/src/storage/sqlite/index.js

@@ -52,8 +52,7 @@ export class SqliteStore {
         update: (actor) => this.database.update("actors", actor),
         get: (id) => this.database.get("actors", id),
         byCredentialHash: (hash) => this.database.select("actors", "credential_hash = ? AND closed_at IS NULL", [hash])[0],
-        root: () => this.database.select("actors", "manager IS NULL")[0],
-        reports: (manager) => this.database.select("actors", "manager = ? AND closed_at IS NULL", [manager]),
+        first: () => this.database.select("actors", "1", [], "rowid", 1)[0],
         open: () => this.database.select("actors", "closed_at IS NULL"),
     };
     claims = {

package/dist/src/storage/sqlite/schema.d.ts

@@ -1,17 +1,16 @@
 /** SQLite tables and their record schemas; times are ISO 8601 UTC and credentials are hashed. */
-export declare const SCHEMA_VERSION = 9;
+export declare const SCHEMA_VERSION = 10;
 export declare const AUDIT_INDEXES = "\nCREATE INDEX IF NOT EXISTS audit_writes ON audit (actor) WHERE outcome = 'ok';\nCREATE INDEX IF NOT EXISTS audit_targets ON audit (actor, target) WHERE outcome = 'ok';";
-export declare const SCHEMA = "\nCREATE TABLE actors (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL,\n  purpose TEXT NOT NULL,\n  manager TEXT REFERENCES actors (id),\n  credential_hash TEXT NOT NULL UNIQUE,\n  created_at TEXT NOT NULL,\n  closed_at TEXT\n);\nCREATE UNIQUE INDEX one_root ON actors ((manager IS NULL)) WHERE manager IS NULL;\nCREATE UNIQUE INDEX handles_unique_among_siblings ON actors (manager, name) WHERE closed_at IS NULL;\n\n-- Retired Actor-call history, retained privately; no operation reads it.\nCREATE TABLE calls (\n  id TEXT PRIMARY KEY,\n  \"from\" TEXT NOT NULL REFERENCES actors (id),\n  \"to\" TEXT NOT NULL REFERENCES actors (id),\n  interface TEXT NOT NULL,\n  input JSON NOT NULL,\n  state TEXT NOT NULL,\n  output JSON,\n  error TEXT,\n  cause TEXT REFERENCES calls (id),\n  run TEXT,\n  created_at TEXT NOT NULL,\n  delivered_at TEXT,\n  settled_at TEXT\n);\nCREATE TABLE claims (\n  resource TEXT PRIMARY KEY,\n  holder TEXT NOT NULL REFERENCES actors (id),\n  note TEXT NOT NULL,\n  until TEXT,\n  claimed_at TEXT NOT NULL\n);\nCREATE INDEX claims_holder ON claims (holder);\n\nCREATE TABLE workspace_imports (\n  message_id TEXT PRIMARY KEY,\n  source_hash TEXT NOT NULL,\n  recipient_id TEXT NOT NULL REFERENCES actors(id),\n  workspace_cursor INTEGER NOT NULL\n);\n\nCREATE TABLE audit (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  at TEXT NOT NULL,\n  actor TEXT,\n  operation TEXT NOT NULL,\n  target TEXT,\n  outcome TEXT NOT NULL\n);\n";
+export declare const SCHEMA = "\nCREATE TABLE actors (\n  id TEXT PRIMARY KEY,\n  name TEXT NOT NULL,\n  purpose TEXT NOT NULL,\n  manager TEXT REFERENCES actors (id),\n  credential_hash TEXT NOT NULL UNIQUE,\n  created_at TEXT NOT NULL,\n  closed_at TEXT\n);\nCREATE UNIQUE INDEX handles_unique_among_open ON actors (name) WHERE closed_at IS NULL;\n\n-- Retired Actor-call history, retained privately; no operation reads it.\nCREATE TABLE calls (\n  id TEXT PRIMARY KEY,\n  \"from\" TEXT NOT NULL REFERENCES actors (id),\n  \"to\" TEXT NOT NULL REFERENCES actors (id),\n  interface TEXT NOT NULL,\n  input JSON NOT NULL,\n  state TEXT NOT NULL,\n  output JSON,\n  error TEXT,\n  cause TEXT REFERENCES calls (id),\n  run TEXT,\n  created_at TEXT NOT NULL,\n  delivered_at TEXT,\n  settled_at TEXT\n);\nCREATE TABLE claims (\n  resource TEXT PRIMARY KEY,\n  holder TEXT NOT NULL REFERENCES actors (id),\n  note TEXT NOT NULL,\n  until TEXT,\n  claimed_at TEXT NOT NULL\n);\nCREATE INDEX claims_holder ON claims (holder);\n\nCREATE TABLE workspace_imports (\n  message_id TEXT PRIMARY KEY,\n  source_hash TEXT NOT NULL,\n  recipient_id TEXT NOT NULL REFERENCES actors(id),\n  workspace_cursor INTEGER NOT NULL\n);\n\nCREATE TABLE audit (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  at TEXT NOT NULL,\n  actor TEXT,\n  operation TEXT NOT NULL,\n  target TEXT,\n  outcome TEXT NOT NULL\n);\n";
 export declare const TABLES: {
     readonly actors: import("zod").ZodObject<{
         id: import("zod").ZodString;
         name: import("zod").ZodString;
         purpose: import("zod").ZodString;
-        manager: import("zod").ZodNullable<import("zod").ZodString>;
         created_at: import("zod").ZodISODateTime;
         closed_at: import("zod").ZodNullable<import("zod").ZodISODateTime>;
         credential_hash: import("zod").ZodString;
-    }, import("zod/v4/core").$strict>;
+    }, import("zod/v4/core").$strip>;
     readonly claims: import("zod").ZodObject<{
         resource: import("zod").ZodString;
         holder: import("zod").ZodString;

package/dist/src/storage/sqlite/schema.js

@@ -1,6 +1,6 @@
 /** SQLite tables and their record schemas; times are ISO 8601 UTC and credentials are hashed. */
 import { ActorRecord, AuditEntry, Claim } from "../../domain/model/index.js";
-export const SCHEMA_VERSION = 9;
+export const SCHEMA_VERSION = 10;
 // Made on every open, not in a schema step, so an earlier build still opens the home:
 // an Actor's last write, and its writes on one record, which attention counts.
 export const AUDIT_INDEXES = `
@@ -16,8 +16,7 @@ CREATE TABLE actors (
   created_at TEXT NOT NULL,
   closed_at TEXT
 );
-CREATE UNIQUE INDEX one_root ON actors ((manager IS NULL)) WHERE manager IS NULL;
-CREATE UNIQUE INDEX handles_unique_among_siblings ON actors (manager, name) WHERE closed_at IS NULL;
+CREATE UNIQUE INDEX handles_unique_among_open ON actors (name) WHERE closed_at IS NULL;
 
 -- Retired Actor-call history, retained privately; no operation reads it.
 CREATE TABLE calls (
@@ -61,7 +60,8 @@ CREATE TABLE audit (
 );
 `;
 export const TABLES = {
-    actors: ActorRecord,
+    // The unused manager column stays in the file; an Actor row neither reads nor writes it.
+    actors: ActorRecord.strip(),
     claims: Claim,
     audit: AuditEntry,
 };

package/node_modules/@uniac/agentic-workspace/README.md

@@ -2,7 +2,7 @@
 
 Durable pair conversations, Work and asks, shared within the organization by active admitted Actor clients. Three separate clients expose identity, Messages, and Work tracking with its asks. Execution and viewer MCP servers share their records and authority rules. Work and ask list filters select matching records before pagination; business write roles remain unchanged.
 
-This package composes with Hub's canonical Actor authority and trusted admission, including the synchronous canonical relationship predicate described in the [adapter checkpoint](docs/hub-integration.md). [Changes since the last version 3 build](docs/hub-integration.md#changes-since-the-last-version-3-build) lists what changes for hosts. The runnable example uses model-free fixture identities; it is not production admission.
+This package composes with Hub's canonical Actor authority and trusted admission, which names the person, as described in [Hub integration](docs/hub-integration.md). [Changes in 0.0.2](docs/hub-integration.md#changes-in-002) lists what changes for hosts. The runnable example uses model-free fixture identities; it is not production admission.
 
 ## Run
 
@@ -57,13 +57,13 @@ function workspace(authority: ActorAuthority, admittedActorID: string, databaseP
 }
 ```
 
-`ActorAuthority.get(callerID, actorID)` owns visibility and current canonical state. The required synchronous `.within(callerID, actorID, ancestorID): boolean` supplies inclusive retained ancestry, including closed members/anchors at every depth; unknown IDs return false. Bound `ActorsClient.within(actorID, ancestorID)` revalidates its actual active caller without resolving selected profiles or changing identity. The required `.manager(callerID, actorID): string | null` gives an Actor's retained manager: asks route through it, the root is the Actor with none, and a closed requester's or asker's rights pass to its nearest open manager. Hosts must implement both methods. The workspace stores no Actor rows, hierarchy or credentials. The optional root `bindWorkspace` factory performs the same explicit composition and returns three distinct clients. Contracts and errors are exported at `/contracts`; SDK server construction is exported at `/mcp`.
+`ActorAuthority.get(callerID, actorID)` owns visibility and current canonical state. The required synchronous `.person(): string` names the person, the Actor that stands for the host's user: asks on Work their asker requested itself, or on no Work, go to it, and a closed Actor's rights pass to it. Bound `ActorsClient.person()` revalidates its actual active caller first. Every Actor sits on one flat level, and the workspace stores no Actor rows, relationships or credentials. The optional top-level `bindWorkspace` factory performs the same explicit composition and returns three distinct clients. Contracts and errors are exported at `/contracts`; SDK server construction is exported at `/mcp`.
 
-Lists return `{items, next, actors}`: the page, an opaque position for the next page (null at the end) and the names of the Actors it mentions. Work lists filter by status lists, one or several requesters, `updatedSince` and canonical subtrees (`ownerWithin`, `requesterWithin`), and go newest first with `order: "recent"`. Records carry `updatedAt`; history comes only from a get with `history: true`. See [lists](docs/contracts.md#lists).
+Lists return `{items, next, actors}`: the page, an opaque position for the next page (null at the end) and the names of the Actors it mentions. Work lists filter by status lists, one or several owners or requesters and `updatedSince`, and go newest first with `order: "recent"`. Records carry `updatedAt`; history comes only from a get with `history: true`. See [lists](docs/contracts.md#lists).
 
-Work is the unit of progress: a title, progress, links and what it waits on, owned and requested by the caller unless it names another owner. Work an Actor requested itself completes when it submits; other Work waits for its requester's answer (`work_answer`). The requester may cancel open, active or changes-requested Work, and a closed requester's rights pass to its nearest open manager. See [Work](docs/contracts.md#work).
+Work is the unit of progress: a title, progress, links and what it waits on, owned and requested by the caller unless it names another owner. Work an Actor requested itself completes when it submits; other Work waits for its requester's answer (`work_answer`). The requester may cancel open, active or changes-requested Work, and a closed requester's rights pass to the person. See [Work](docs/contracts.md#work).
 
-An ask is part of the Work its asker owns: `work_update {ticketID, ask}` adds a title, context, links and fields with options and a recommended choice. Any Actor answers it with `work_answer`, and the first answer resolves it unless it collects answers; only the asker's managers answer an approval. The Actor it is routed to, its asker's manager, may raise it one manager up. `work_get` returns Work with its asks, and `work_list` items carry their open asks. See [asks](docs/contracts.md#asks).
+An ask is part of the Work its asker owns: `work_update {ticketID, ask}` adds a title, context, links and fields with options and a recommended choice. Any Actor answers it with `work_answer`, and the first answer resolves it unless it collects answers. An ask goes to its Work's requester, or to the person when its asker requested the Work itself or once the requester is closed, and only that Actor answers an approval, never its asker. `work_get` returns Work with its asks, and `work_list` items carry their open asks. See [asks](docs/contracts.md#asks).
 
 Each Message belongs to its pair's conversation (`conversationID`) and carries its place in the one Message order (`seq`). `messages.list({counterpartyID, before:"latest", limit:20})` returns the caller's conversation with that Actor, newest window ascending, with `older` for the page before it. `{between: [a, b]}` reads any pair's conversation the same way, and either form with `after` goes forward from a `next` position or the last `seq` a reader handled. `{of: actorID}` lists an Actor's conversations, newest first, each as its latest message. Every Actor reads every conversation. See [Messages](docs/contracts.md#messages).
 

package/node_modules/@uniac/agentic-workspace/dist/examples/authority.d.ts

@@ -8,5 +8,4 @@ export declare function fixtureAuthority(): {
         purpose: string;
         state: "active" | "closed";
     }>;
-    managers: Map<string, string | null>;
 };

package/node_modules/@uniac/agentic-workspace/dist/examples/authority.js

@@ -37,23 +37,10 @@ export function fixtureAuthority() {
             },
         ],
     ]);
-    const managers = new Map([
-        ["requester", null],
-        ["owner", "requester"],
-        ["respondent", "owner"],
-        ["outsider", "requester"],
-    ]);
+    // requester is the person, the Actor the host names as its user.
     const authority = {
         get: (_caller, id) => rows.get(id),
-        manager: (_caller, actorID) => managers.get(actorID) ?? null,
-        within: (_caller, actorID, ancestorID) => {
-            if (!rows.has(ancestorID))
-                return false;
-            for (let at = actorID; at != null && rows.has(at); at = managers.get(at))
-                if (at === ancestorID)
-                    return true;
-            return false;
-        },
+        person: () => "requester",
     };
-    return { authority, rows, managers };
+    return { authority, rows };
 }

package/node_modules/@uniac/agentic-workspace/dist/src/actors/index.d.ts

@@ -1,27 +1,27 @@
-/** Canonical identity and membership; the module stores no Actors or credentials. */
+/** Canonical identity and the person; the module stores no Actors or credentials. */
 import { Actor, ActorQuery, type Input } from "../contracts/index.js";
 export interface ActorAuthority {
     /** Canonical visibility, including access to the admitted caller itself. */
     get(callerID: string, actorID: string): Actor | undefined;
-    /** Inclusive retained ancestry, including closed members/anchors; unknown IDs return false. */
-    within(callerID: string, actorID: string, ancestorID: string): boolean;
-    /** The retained manager, closed or not; null for the root and for unknown IDs. */
-    manager(callerID: string, actorID: string): string | null;
+    /**
+     * The person's Actor ID: it stands in for closed Actors and receives the asks on Work their asker
+     * requested itself.
+     */
+    person(): string;
 }
 export interface ActorsClient {
     get(input?: Input<typeof ActorQuery>): Actor;
-    within(actorID: string, ancestorID: string): boolean;
-    manager(actorID: string): string | null;
+    person(): string;
 }
 export declare function createActors(authority: ActorAuthority, callerID: string): ActorsClient;
 export declare function activeActor(actors: ActorsClient, actorID: string): Actor;
 /**
- * The Actor itself while it is open; once it is closed, its nearest open manager, or null. This
- * decides who holds rights, so an Actor the caller can't see is refused (`not_found`), never passed.
+ * The Actor itself while it is open; once it is closed, the person. This decides who holds rights,
+ * so an Actor the caller can't see is refused (`not_found`), never passed.
  */
-export declare function standIn(actors: ActorsClient, actorID: string): string | null;
+export declare function standIn(actors: ActorsClient, actorID: string): string;
 /**
- * As standIn, for reads that route asks: an Actor the caller can't see counts as closed, so the walk
- * goes on past it. Never for authority.
+ * As standIn, for reads that route asks: an Actor the caller can't see counts as closed, so its asks
+ * go to the person. Never for authority.
  */
-export declare function routedStandIn(actors: ActorsClient, actorID: string): string | null;
+export declare function routedStandIn(actors: ActorsClient, actorID: string): string;

package/node_modules/@uniac/agentic-workspace/dist/src/actors/index.js

@@ -1,4 +1,4 @@
-/** Canonical identity and membership; the module stores no Actors or credentials. */
+/** Canonical identity and the person; the module stores no Actors or credentials. */
 import { Actor, ActorQuery, ID, parse, requireThat, WorkspaceError, } from "../contracts/index.js";
 export function createActors(authority, callerID) {
     function caller() {
@@ -16,16 +16,9 @@ export function createActors(authority, callerID) {
             requireThat(actor, "not_found", "Actor not found");
             return parse(Actor, actor);
         },
-        within(actorID, ancestorID) {
-            const member = parse(ID, actorID);
-            const ancestor = parse(ID, ancestorID);
+        person() {
             caller();
-            return authority.within(callerID, member, ancestor);
-        },
-        manager(actorID) {
-            const member = parse(ID, actorID);
-            caller();
-            return authority.manager(callerID, member);
+            return parse(ID, authority.person());
         },
     };
 }
@@ -35,27 +28,18 @@ export function activeActor(actors, actorID) {
     return actor;
 }
 /**
- * The Actor itself while it is open; once it is closed, its nearest open manager, or null. This
- * decides who holds rights, so an Actor the caller can't see is refused (`not_found`), never passed.
+ * The Actor itself while it is open; once it is closed, the person. This decides who holds rights,
+ * so an Actor the caller can't see is refused (`not_found`), never passed.
  */
 export function standIn(actors, actorID) {
-    return walk(actors, actorID, (at) => actors.get({ actorID: at }).state === "active");
+    return actors.get({ actorID }).state === "active" ? actorID : actors.person();
 }
 /**
- * As standIn, for reads that route asks: an Actor the caller can't see counts as closed, so the walk
- * goes on past it. Never for authority.
+ * As standIn, for reads that route asks: an Actor the caller can't see counts as closed, so its asks
+ * go to the person. Never for authority.
  */
 export function routedStandIn(actors, actorID) {
-    return walk(actors, actorID, (at) => visible(actors, at)?.state === "active");
-}
-function walk(actors, actorID, open) {
-    const seen = new Set();
-    for (let at = actorID; at !== null && !seen.has(at); at = actors.manager(at)) {
-        if (open(at))
-            return at;
-        seen.add(at);
-    }
-    return null;
+    return visible(actors, actorID)?.state === "active" ? actorID : actors.person();
 }
 function visible(actors, actorID) {
     try {

package/node_modules/@uniac/agentic-workspace/dist/src/contracts/common.d.ts

@@ -2,13 +2,6 @@ import { z } from "zod";
 export declare const ID: z.ZodString;
 export declare const Text: z.ZodString;
 export declare const Revision: z.ZodNumber;
-/** The smallest organization level that presents a contract; each level contains the one before. */
-export declare const Level: z.ZodEnum<{
-    organization: "organization";
-    report: "report";
-    team: "team";
-}>;
-export type Level = z.infer<typeof Level>;
 export declare const Limit: z.ZodDefault<z.ZodNumber>;
 /** An opaque list position; it continues only the read and filter that issued it. */
 export declare const Next: z.ZodString;
@@ -61,8 +54,7 @@ export declare class WorkspaceError extends Error {
 /** Refuses input outside the schema, naming each issue as the Hub does. */
 export declare function parse<S extends z.ZodType>(schema: S, input: unknown): z.output<S>;
 export declare function requireThat(condition: unknown, code: WorkspaceError["code"], message: string): asserts condition;
-export declare function contract<S extends z.ZodType>(level: Level, description: string, input: S, output: z.ZodType, writes?: boolean): {
-    level: "organization" | "report" | "team";
+export declare function contract<S extends z.ZodType>(description: string, input: S, output: z.ZodType, writes?: boolean): {
     description: string;
     input: S;
     output: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;

package/node_modules/@uniac/agentic-workspace/dist/src/contracts/common.js

@@ -2,8 +2,6 @@ import { z } from "zod";
 export const ID = z.string().trim().min(1).max(200);
 export const Text = z.string().trim().min(1).max(20000);
 export const Revision = z.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
-/** The smallest organization level that presents a contract; each level contains the one before. */
-export const Level = z.enum(["report", "team", "organization"]);
 export const Limit = z.number().int().min(1).max(100).default(50);
 /** An opaque list position; it continues only the read and filter that issued it. */
 export const Next = z.string().trim().min(1).max(1000);
@@ -49,8 +47,8 @@ export function requireThat(condition, code, message) {
     if (!condition)
         throw new WorkspaceError(code, message);
 }
-export function contract(level, description, input, output, writes = false) {
-    return { level, description, input, output, writes };
+export function contract(description, input, output, writes = false) {
+    return { description, input, output, writes };
 }
 export const listOf = (record) => z.strictObject({ items: z.array(record), next: Next.nullable(), actors: Actors });
 /** One ID or several, matching any of them. */

package/node_modules/@uniac/agentic-workspace/dist/src/contracts/forms.d.ts

@@ -20,11 +20,6 @@ export declare const Response: z.ZodObject<{
     note: z.ZodOptional<z.ZodString>;
     at: z.ZodISODateTime;
 }, z.core.$strict>;
-/** Who passed an ask up, and when; a raise names no destination. */
-export declare const Raise: z.ZodObject<{
-    actorID: z.ZodString;
-    at: z.ZodISODateTime;
-}, z.core.$strict>;
 export declare const AskStatus: z.ZodEnum<{
     cancelled: "cancelled";
     open: "open";
@@ -67,10 +62,6 @@ export declare const FormState: z.ZodObject<{
         note: z.ZodOptional<z.ZodString>;
         at: z.ZodISODateTime;
     }, z.core.$strict>>;
-    raises: z.ZodArray<z.ZodObject<{
-        actorID: z.ZodString;
-        at: z.ZodISODateTime;
-    }, z.core.$strict>>;
     resolution: z.ZodOptional<z.ZodObject<{
         text: z.ZodString;
         reason: z.ZodOptional<z.ZodEnum<{
@@ -124,10 +115,6 @@ export declare const Form: z.ZodObject<{
         note: z.ZodOptional<z.ZodString>;
         at: z.ZodISODateTime;
     }, z.core.$strict>>;
-    raises: z.ZodArray<z.ZodObject<{
-        actorID: z.ZodString;
-        at: z.ZodISODateTime;
-    }, z.core.$strict>>;
     resolution: z.ZodOptional<z.ZodObject<{
         text: z.ZodString;
         reason: z.ZodOptional<z.ZodEnum<{

package/node_modules/@uniac/agentic-workspace/dist/src/contracts/forms.js

@@ -14,8 +14,6 @@ export const Response = z.strictObject({
     note: Text.optional(),
     at: z.iso.datetime(),
 });
-/** Who passed an ask up, and when; a raise names no destination. */
-export const Raise = z.strictObject({ actorID: ID, at: z.iso.datetime() });
 export const AskStatus = z.enum(["open", "resolved", "cancelled"]);
 /**
  * An ask, part of the Work its asker owns: open to any responder except where approval limits it.
@@ -35,7 +33,6 @@ export const FormState = z.strictObject({
     status: AskStatus,
     createdAt: z.iso.datetime(),
     responses: z.record(ID, Response),
-    raises: z.array(Raise),
     resolution: z
         .strictObject({
         text: Text,

package/node_modules/@uniac/agentic-workspace/dist/src/contracts/messages.d.ts

@@ -22,7 +22,6 @@ export type Message = z.infer<typeof Message>;
 export type MessageState = z.infer<typeof MessageState>;
 export declare const MessageContracts: {
     message_send: {
-        level: "organization" | "report" | "team";
         description: string;
         input: z.ZodObject<{
             recipientID: z.ZodString;
@@ -32,7 +31,6 @@ export declare const MessageContracts: {
         writes: boolean;
     };
     message_get: {
-        level: "organization" | "report" | "team";
         description: string;
         input: z.ZodObject<{
             messageID: z.ZodString;
@@ -41,7 +39,6 @@ export declare const MessageContracts: {
         writes: boolean;
     };
     message_list: {
-        level: "organization" | "report" | "team";
         description: string;
         input: z.ZodObject<{
             between: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/node_modules/@uniac/agentic-workspace/dist/src/contracts/messages.js

@@ -21,9 +21,9 @@ export const Message = z.strictObject({
 });
 const messageID = z.strictObject({ messageID: ID });
 export const MessageContracts = {
-    message_send: contract("report", "Send a message to another Actor; it joins the pair's conversation.", z.strictObject({ recipientID: ID, text: Text }), Message, true),
-    message_get: contract("team", "Read a message.", messageID, Message),
-    message_list: contract("report", "Name exactly one of between, counterpartyID or of. between (two Actors) or counterpartyID (the caller and one Actor) reads one conversation ascending: forward after a position or seq, or the newest window before latest/older. of lists an Actor's conversations, newest first, each as its latest message, continuing only after next.", z
+    message_send: contract("Send a message to another Actor; it joins the pair's conversation.", z.strictObject({ recipientID: ID, text: Text }), Message, true),
+    message_get: contract("Read a message.", messageID, Message),
+    message_list: contract("Name exactly one of between, counterpartyID or of. between (two Actors) or counterpartyID (the caller and one Actor) reads one conversation ascending: forward after a position or seq, or the newest window before latest/older. of lists an Actor's conversations, newest first, each as its latest message, continuing only after next.", z
         .strictObject({
         between: z.array(ID).length(2).optional(),
         counterpartyID: ID.optional(),