@agentorg/cli 0.0.2 → 0.0.4

package/dist/src/domain/model/workspace.js

@@ -1,23 +0,0 @@
-/** Package-owned contracts projected into explicit Hub feature definitions. */
-import { MessageContracts, WorkContracts, } from "@uniac/agentic-workspace/contracts";
-import { toolDefinition } from "./json-schema.js";
-// Package descriptors retain input types; exported DTOs supply their response types.
-const spec = () => (definition) => ({
-    request: definition.input,
-    response: definition.output,
-    description: definition.description,
-    writes: definition.writes,
-});
-export const MESSAGES = toolDefinition("messages", {
-    message_send: spec()(MessageContracts.message_send),
-    message_get: spec()(MessageContracts.message_get),
-    message_list: spec()(MessageContracts.message_list),
-});
-export const WORK = toolDefinition("work", {
-    work_create: spec()(WorkContracts.work_create),
-    work_get: spec()(WorkContracts.work_get),
-    work_list: spec()(WorkContracts.work_list),
-    work_update: spec()(WorkContracts.work_update),
-    work_submit: spec()(WorkContracts.work_submit),
-    work_answer: spec()(WorkContracts.work_answer),
-});

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

@@ -1,53 +0,0 @@
-/** The domain's protocol, connection and storage boundaries. */
-import type { WorkspaceStore } from "@uniac/agentic-workspace/persistence";
-import type { z } from "zod";
-import type { Actor, ActorRecord, Answer, AuditEntry, Claim, ToolDescriptor } from "./model/index.ts";
-export type ActorRow = z.output<typeof ActorRecord>;
-export type AuditRow = z.output<typeof AuditEntry>;
-export type ClaimRow = z.output<typeof Claim>;
-export interface Invocation {
-    /** Trusted immutable admission binding; never supplied by Tool input. */
-    connectionId?: string;
-    /** Tell the caller the call is still running. */
-    progress(message: string): Promise<void>;
-    /** Aborted when the caller goes away. */
-    signal: AbortSignal;
-}
-/** What an actor may do: its Tools and their interfaces, and calling one by its alias. */
-export interface Application {
-    available(actor: string, connectionId?: string): ToolDescriptor[];
-    invoke(actor: string, name: string, input: Record<string, unknown>, how: Invocation): Promise<Answer>;
-}
-/** The record reads and writes the domain needs, whatever keeps them. */
-export interface Store {
-    workspace: WorkspaceStore;
-    actors: {
-        insert(actor: ActorRow): void;
-        update(actor: ActorRow): void;
-        get(id: string): ActorRow | undefined;
-        /** The open actor with this credential hash. */
-        byCredentialHash(hash: string): ActorRow | undefined;
-        /** The first actor this store recorded. */
-        first(): ActorRow | undefined;
-        /** Every open actor, oldest first. */
-        open(): ActorRow[];
-    };
-    claims: {
-        get(resource: string): ClaimRow | undefined;
-        /** Hold the resource, replacing the claim it had. */
-        put(claim: ClaimRow): void;
-        remove(resource: string): void;
-    };
-    audit: {
-        append(entry: Omit<AuditRow, "id">): void;
-        /** The latest `limit` entries, or the earliest `limit` after `since`; oldest first. */
-        list(since: number | undefined, limit: number): AuditRow[];
-        /** The time of the actor's latest successful write. */
-        lastWrite(actor: string): string | undefined;
-        /** The ids of the actor's successful Work and ask writes on the target after entry `id`, in order. */
-        writesAfter(id: number, actor: string, target: string): number[];
-    };
-    /** Run `work` so that its writes land together or not at all. */
-    transaction<T>(work: () => T): T;
-}
-export type ActorView = z.output<typeof Actor>;

package/dist/src/domain/ports.js

@@ -1,2 +0,0 @@
-/** The domain's protocol, connection and storage boundaries. */
-export {};

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

@@ -1,11 +0,0 @@
-/** Preconfigured Provider identities and admission, independent of organizational Actor identities. */
-export interface ProviderIdentity {
-    providerId: string;
-    credentialHash: string;
-}
-export declare function providers(configured: readonly ProviderIdentity[]): {
-    ids: () => string[];
-    has: (providerId: string) => boolean;
-    admit(providerId: string, credential?: string): Promise<boolean>;
-};
-export type Providers = ReturnType<typeof providers>;

package/dist/src/domain/providers.js

@@ -1,24 +0,0 @@
-/** Preconfigured Provider identities and admission, independent of organizational Actor identities. */
-export function providers(configured) {
-    const identities = new Map();
-    for (const identity of configured) {
-        if (!identity.providerId || !/^[a-f\d]{64}$/i.test(identity.credentialHash)) {
-            throw new Error("a Provider needs an identity and SHA-256 credential hash");
-        }
-        if (identities.has(identity.providerId))
-            throw new Error("Provider identities must be unique");
-        identities.set(identity.providerId, identity.credentialHash.toLowerCase());
-    }
-    return {
-        ids: () => [...identities.keys()],
-        has: (providerId) => identities.has(providerId),
-        async admit(providerId, credential) {
-            const expected = identities.get(providerId);
-            if (expected === undefined || credential === undefined)
-                return false;
-            const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(credential));
-            const hash = Array.from(new Uint8Array(bytes), (byte) => byte.toString(16).padStart(2, "0")).join("");
-            return hash === expected;
-        },
-    };
-}

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

@@ -1,49 +0,0 @@
-/** Identity on one flat level and lifecycle transitions, with credentials hashed by Web Crypto. */
-import type { ActorRow, Store } from "./ports.ts";
-export type { ActorRow };
-export declare const newId: (prefix: string) => string;
-export declare function registry(actors: Store["actors"], now: () => string): {
-    root: () => {
-        id: string;
-        name: string;
-        purpose: string;
-        created_at: string;
-        closed_at: string | null;
-        credential_hash: string;
-    } | undefined;
-    createRoot: () => Promise<{
-        root: ActorRow;
-        credential: string;
-    }>;
-    create: (name: string, purpose: string) => Promise<{
-        actor: ActorRow;
-        credential: string;
-    }>;
-    rotateCredential: (id: string) => Promise<string>;
-    get: (id: string) => {
-        id: string;
-        name: string;
-        purpose: string;
-        created_at: string;
-        closed_at: string | null;
-        credential_hash: string;
-    } | undefined;
-    found: (id: string) => ActorRow;
-    byCredential: (credential: string) => Promise<ActorRow | undefined>;
-    identify: (credential: string) => Promise<string | undefined>;
-    open: () => {
-        id: string;
-        name: string;
-        purpose: string;
-        created_at: string;
-        closed_at: string | null;
-        credential_hash: string;
-    }[];
-    standIn: (actorID: string) => string | undefined;
-    close: (caller: ActorRow, id: string) => {
-        actor: ActorRow;
-        changed: boolean;
-    };
-    names: (ids: Iterable<string>) => Record<string, string>;
-};
-export type Registry = ReturnType<typeof registry>;

package/dist/src/domain/registry.js

@@ -1,116 +0,0 @@
-/** Identity on one flat level and lifecycle transitions, with credentials hashed by Web Crypto. */
-import { Conflict, Forbidden, Invalid, NotFound } from "./errors.js";
-const random = (length) => crypto.getRandomValues(new Uint8Array(length));
-const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-export const newId = (prefix) => `${prefix}_${hex(random(5))}`;
-/** A credential's SHA-256 hash, in hex: all the registry keeps of it. */
-async function digest(credential) {
-    const bytes = new TextEncoder().encode(credential);
-    return hex(new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)));
-}
-/** 32 random bytes, in base64url. */
-const mintCredential = () => btoa(String.fromCharCode(...random(32)))
-    .replaceAll("+", "-")
-    .replaceAll("/", "_")
-    .replace(/=+$/, "");
-export function registry(actors, now) {
-    /** The person: the first Actor this Hub made, the one place that says so. */
-    const root = () => actors.first();
-    const get = (id) => actors.get(id);
-    const open = () => actors.open();
-    /** The Actor while it is open; once it is closed, the person, who takes its part. */
-    function standIn(actorID) {
-        const actor = get(actorID);
-        return actor === undefined ? undefined : actor.closed_at === null ? actor.id : root()?.id;
-    }
-    /** Create the person, the user's Actor, and return its credential. */
-    async function createRoot() {
-        const { credential, hash } = await mint();
-        return {
-            root: insert("root", "The user: the person these Actors work for.", hash),
-            credential,
-        };
-    }
-    /** Create an Actor and return it with its credential. */
-    async function create(name, purpose) {
-        // Hashing waits, so it comes first: the check and the insert then run with nothing between.
-        const { credential, hash } = await mint();
-        if (open().some((actor) => actor.name === name)) {
-            throw new Conflict(`an open Actor is already named ${name}`);
-        }
-        return { actor: insert(name, purpose, hash), credential };
-    }
-    async function mint() {
-        const credential = mintCredential();
-        return { credential, hash: await digest(credential) };
-    }
-    function insert(name, purpose, hash) {
-        const actor = {
-            id: newId("act"),
-            name,
-            purpose,
-            credential_hash: hash,
-            created_at: now(),
-            closed_at: null,
-        };
-        actors.insert(actor);
-        return actor;
-    }
-    /** Replace an actor's credential, as when the person's file is lost, and return the new one. */
-    async function rotateCredential(id) {
-        const { credential, hash } = await mint();
-        actors.update({ ...found(id), credential_hash: hash });
-        return credential;
-    }
-    function found(id) {
-        const actor = get(id);
-        if (!actor)
-            throw new NotFound(`there is no actor ${id}`);
-        return actor;
-    }
-    /** The open actor whose credential this is. */
-    async function byCredential(credential) {
-        return actors.byCredentialHash(await digest(credential));
-    }
-    /** The id of the open actor whose credential this is: who a connection is. */
-    async function identify(credential) {
-        return (await byCredential(credential))?.id;
-    }
-    /** Close another Actor, never the person; repeat closure leaves its timestamp unchanged. */
-    function close(caller, id) {
-        const target = found(id);
-        if (target.id === root()?.id)
-            throw new Invalid("the person is never closed");
-        if (target.id === caller.id)
-            throw new Forbidden("an Actor closes others, not itself");
-        if (target.closed_at !== null)
-            return { actor: target, changed: false };
-        const actor = { ...target, closed_at: now() };
-        actors.update(actor);
-        return { actor, changed: true };
-    }
-    /** Each of these actors by id: its handle. */
-    function names(ids) {
-        const named = {};
-        for (const id of new Set(ids)) {
-            const actor = get(id);
-            if (actor)
-                named[id] = actor.name;
-        }
-        return named;
-    }
-    return {
-        root,
-        createRoot,
-        create,
-        rotateCredential,
-        get,
-        found,
-        byCredential,
-        identify,
-        open,
-        standIn,
-        close,
-        names,
-    };
-}

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

@@ -1,10 +0,0 @@
-/** Shared operational reads and single-socket detach under canonical Actor authority. */
-import type { Connections } from "./connections.ts";
-import type { Diagnostics } from "./diagnostics.ts";
-import type { Registry } from "./registry.ts";
-export interface SystemRuntime {
-    version: string;
-    nodeVersion: string;
-    providerIds: readonly string[];
-}
-export declare function system(registry: Registry, connections: Connections, diagnostics: Diagnostics, now: () => string, runtime: SystemRuntime): import("./tools.ts").FeatureTool;

package/dist/src/domain/system.js

@@ -1,129 +0,0 @@
-import { Conflict, Forbidden, Invalid, NotFound } from "./errors.js";
-import { SYSTEM } from "./model/system.js";
-import { bindTool } from "./tools.js";
-export function system(registry, connections, diagnostics, now, runtime) {
-    const instanceId = crypto.randomUUID();
-    const startedAt = now();
-    function position(query, head) {
-        if ((query.instanceId !== undefined && query.instanceId !== instanceId) ||
-            (query.after > 0 && query.instanceId === undefined))
-            throw new Conflict("the continuation belongs to another Hub run");
-        if (query.after > head)
-            throw new Invalid("after: beyond this run's position");
-    }
-    function blocked(actor, entry, how) {
-        if (how.connectionId === undefined)
-            return "forbidden";
-        if (entry.connectionId === how.connectionId)
-            return "current_connection";
-        const root = registry.root()?.id === actor.id;
-        const allowed = "actorId" in entry.principal ? root || entry.principal.actorId === actor.id : root;
-        if (!allowed)
-            return "forbidden";
-        if (entry.state === "closing")
-            return "closing";
-        if (connections.busy(entry))
-            return "busy";
-        return undefined;
-    }
-    function view(actor, entry, how) {
-        const blockedBy = blocked(actor, entry, how);
-        return {
-            connectionId: entry.connectionId,
-            principal: { ...entry.principal },
-            admittedAt: entry.admittedAt,
-            state: entry.state,
-            activeInvocations: entry.activeInvocations,
-            canDisconnect: blockedBy === undefined,
-            ...(blockedBy === undefined ? {} : { blockedBy }),
-            ...("providerId" in entry.principal
-                ? {
-                    pendingFactoryRequests: entry.control.pendingFactoryRequests?.() ?? 0,
-                    activeCreations: entry.activeCreations,
-                    selectedForCreation: entry.control.selectedForCreation?.() ?? false,
-                }
-                : {}),
-        };
-    }
-    return bindTool(SYSTEM, {
-        system_status: (_actor, request) => {
-            const active = connections.entries().filter((entry) => entry.state === "admitted");
-            return {
-                instanceId,
-                observedAt: now(),
-                startedAt,
-                version: runtime.version,
-                nodeVersion: runtime.nodeVersion,
-                state: "serving",
-                actorConnections: active.filter((entry) => "actorId" in entry.principal).length,
-                providerConnections: active.filter((entry) => "providerId" in entry.principal).length,
-                configuredProviders: runtime.providerIds.length,
-                diagnostics: diagnostics.read(request.diagnosticLimit),
-            };
-        },
-        connection_list: (actor, request, how) => {
-            position(request, connections.head());
-            const matches = connections
-                .entries()
-                .filter((entry) => entry.ordinal > request.after &&
-                (request.connectionId === undefined || entry.connectionId === request.connectionId) &&
-                (request.actorId === undefined ||
-                    ("actorId" in entry.principal && entry.principal.actorId === request.actorId)) &&
-                (request.providerId === undefined ||
-                    ("providerId" in entry.principal &&
-                        entry.principal.providerId === request.providerId)));
-            const rows = matches.slice(0, request.limit);
-            return {
-                instanceId,
-                observedAt: now(),
-                items: rows.map((entry) => view(actor, entry, how)),
-                after: rows.at(-1)?.ordinal ?? request.after,
-                atEnd: matches.length <= request.limit,
-            };
-        },
-        provider_list: (_actor, request) => {
-            position(request, runtime.providerIds.length);
-            const entries = connections.entries();
-            const matches = runtime.providerIds
-                .map((providerId, index) => {
-                const sockets = entries.filter((entry) => entry.state === "admitted" &&
-                    "providerId" in entry.principal &&
-                    entry.principal.providerId === providerId);
-                return {
-                    ordinal: index + 1,
-                    providerId,
-                    admittedConnections: sockets.length,
-                    selectedConnectionId: sockets.find((entry) => entry.control.selectedForCreation?.())?.connectionId ?? null,
-                    activeCreations: sockets.reduce((sum, entry) => sum + entry.activeCreations, 0),
-                };
-            })
-                .filter((row) => row.ordinal > request.after &&
-                (request.providerId === undefined || row.providerId === request.providerId) &&
-                (request.connected === undefined || row.admittedConnections > 0 === request.connected));
-            const rows = matches.slice(0, request.limit);
-            return {
-                instanceId,
-                observedAt: now(),
-                items: rows.map(({ ordinal: _, ...row }) => row),
-                after: rows.at(-1)?.ordinal ?? request.after,
-                atEnd: matches.length <= request.limit,
-            };
-        },
-        connection_disconnect: (actor, request, how) => {
-            if (request.instanceId !== instanceId)
-                throw new Conflict("the connection belongs to another Hub run");
-            if (how.connectionId === undefined)
-                throw new Forbidden("an admitted calling connection is required");
-            const entry = connections.get(request.connectionId);
-            if (!entry)
-                throw new NotFound("the connection is not admitted");
-            const reason = blocked(actor, entry, how);
-            if (reason === "forbidden")
-                throw new Forbidden("the Actor does not control this connection");
-            if (reason !== undefined)
-                throw new Conflict(`connection disconnect refused: ${reason}`);
-            connections.detach(request.connectionId);
-            return { instanceId, connectionId: request.connectionId, closed: true };
-        },
-    });
-}

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

@@ -1,10 +0,0 @@
-/** Every open Actor, actual admitted connection presence and each Actor's report. */
-import type { Actors } from "./actors.ts";
-import type { Audit } from "./audit.ts";
-import type { Registry } from "./registry.ts";
-import type { Workspace } from "./workspace.ts";
-export { TEAM as definition } from "./model/index.ts";
-export declare function team(registry: Registry, actors: Pick<Actors, "view">, audit: Pick<Audit, "lastWrite">, workspace: Workspace): {
-    tool: import("./tools.ts").FeatureTool;
-};
-export type Team = ReturnType<typeof team>;

package/dist/src/domain/team.js

@@ -1,234 +0,0 @@
-/** Every open Actor, actual admitted connection presence and each Actor's report. */
-import { WorkspaceError, } from "@uniac/agentic-workspace/contracts";
-import { TEAM } from "./model/index.js";
-import { bindTool } from "./tools.js";
-export { TEAM as definition } from "./model/index.js";
-/** Up to this many positions, each reads its own Work rather than the organization's. */
-const FEW = 20;
-/** Work that isn't finished, not started included. */
-const UNFINISHED = ["open", "active", "submitted", "changes_requested"];
-const oldestFirst = (items) => items.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
-/** Every page of a list, each read continuing from the last. */
-function all(read) {
-    const items = [];
-    for (let after;;) {
-        const page = read(after);
-        items.push(...page.items);
-        if (page.next === null)
-            return items;
-        after = page.next;
-    }
-}
-/**
- * A Work's state from its status and its owner's open ask on it: submitted Work is in review even
- * with an ask.
- */
-function workState(work, ask) {
-    if (work.status === "accepted")
-        return "done";
-    if (work.status === "submitted")
-        return "review";
-    if (ask !== undefined)
-        return "waiting";
-    return work.status === "open" ? "open" : "active";
-}
-/** Its owner's oldest open ask on it, which makes it waiting. */
-const ownerAsk = (work) => work.asks?.find((ask) => ask.requesterID === work.ownerID);
-/** Changes were requested on its current submission; it stays so after the owner resumes. */
-const changesRequested = (work) => work.review?.verdict === "changes_requested" &&
-    work.review.submissionID === work.submission?.submissionID;
-/** How urgent Work is for a headline: waiting, review, changes requested, then active. */
-const urgency = (state, work) => state === "waiting" ? 0 : state === "review" ? 1 : changesRequested(work) ? 2 : 3;
-/** A list item, `-`, `*`, `+`, `1.` or `1)`, with an optional box: `[ ]`, `[x]` or `[X]`. */
-const ITEM = /^\s*(?:[-*+]|\d+[.)])\s+(?:\[([ xX])\]\s+)?(.*\S)\s*$/;
-/** A text's first sentence, on one line. */
-function sentence(text) {
-    const line = text.replace(/\s+/g, " ").trim();
-    return line ? (/^.*?[.!?](?=\s|$)/.exec(line)?.[0] ?? line) : undefined;
-}
-/**
- * Its current step, else the first sentence of its progress. Progress is a paragraph, then a
- * list; once any item has a box, the first item not checked `- [x]` is current.
- */
-function step(progress) {
-    if (!progress)
-        return undefined;
-    const lines = progress.split("\n");
-    const start = lines.findIndex((line) => ITEM.test(line));
-    const items = (start < 0 ? [] : lines.slice(start)).flatMap((line) => {
-        const found = ITEM.exec(line);
-        return found ? [{ box: found[1], text: found[2] }] : [];
-    });
-    const current = items.some((item) => item.box !== undefined)
-        ? items.find((item) => item.box?.toLowerCase() !== "x")
-        : undefined;
-    return current?.text ?? sentence(lines.slice(0, start < 0 ? undefined : start).join("\n"));
-}
-export function team(registry, actors, audit, workspace) {
-    /**
-     * An Actor's state and headline from the Work on it: its most urgent Work that is
-     * waiting, in review or active is the subject, with the clause that applies; with none, its
-     * Work not started and the last it finished. `known` is Work already read, which names Work
-     * waited on without a read of its own.
-     */
-    function standing(caller, work, owned, known, last) {
-        const named = (actorID) => actorID === caller.id ? "you" : (registry.get(actorID)?.name ?? actorID);
-        const titled = (ticketID) => {
-            const found = known.find((item) => item.ticketID === ticketID);
-            if (found)
-                return found.title;
-            try {
-                return work.get({ ticketID }).title;
-            }
-            catch (error) {
-                if (error instanceof WorkspaceError && error.code === "not_found")
-                    return "other Work";
-                throw error;
-            }
-        };
-        const clause = (item, state, ask) => {
-            if (ask)
-                return { kind: ask.approval ? "approval" : "ask", text: ask.title };
-            if (state === "review")
-                return {
-                    kind: "review",
-                    // A closed requester's part passes to the person.
-                    text: `with ${named(registry.standIn(item.requesterID) ?? item.requesterID)} for review`,
-                };
-            const on = item.waitsOn;
-            if (on)
-                return {
-                    kind: "waits",
-                    text: "text" in on ? on.text : "actorID" in on ? named(on.actorID) : titled(on.ticketID),
-                };
-            const text = step(item.progress);
-            return text === undefined ? null : { kind: "step", text };
-        };
-        const items = owned.map((item) => {
-            const ask = ownerAsk(item);
-            return { item, ask, state: workState(item, ask) };
-        });
-        const ranked = items
-            .flatMap(({ item, ask, state }) => state === "done" || state === "open"
-            ? []
-            : [{ item, ask, state, rank: urgency(state, item) }])
-            .sort((left, right) => left.rank - right.rank || right.item.updatedAt.localeCompare(left.item.updatedAt));
-        const [subject] = ranked;
-        return {
-            state: subject?.state ?? "idle",
-            headline: {
-                subject: subject
-                    ? { ticketID: subject.item.ticketID, title: subject.item.title, state: subject.state }
-                    : null,
-                clause: subject ? clause(subject.item, subject.state, subject.ask) : null,
-                more: Math.max(ranked.length - 1, 0),
-                notStarted: items.filter((each) => each.state === "open").length,
-                finished: last
-                    ? { ticketID: last.ticketID, title: last.title, at: last.completedAt ?? last.updatedAt }
-                    : null,
-            },
-        };
-    }
-    /**
-     * Every open Actor, oldest first, each with its state, headline and open asks. Up to `FEW`
-     * Actors read their own Work, more read the organization's once, and open asks are one pass.
-     */
-    function readTeam(caller) {
-        const rows = registry.open();
-        const few = rows.length <= FEW;
-        const positions = workspace.run(caller, ({ work }) => {
-            const list = (filter) => all((after) => work.list({ ...filter, limit: 100, after }));
-            const live = few
-                ? rows.flatMap((row) => list({ ownerID: row.id, status: [...UNFINISHED] }))
-                : list({ status: [...UNFINISHED] });
-            const open = oldestFirst(all((after) => work.asks({ status: ["open"], limit: 100, after })));
-            const latest = (actorID) => work.list({ ownerID: actorID, status: ["accepted"], order: "recent", limit: 1 }).items[0];
-            const recent = few
-                ? undefined
-                : work.list({ status: ["accepted"], order: "recent", limit: 100 });
-            /** The last Work it finished; past the most recent page, its own latest. */
-            const finished = (actorID) => recent === undefined
-                ? latest(actorID)
-                : (recent.items.find((item) => item.ownerID === actorID) ??
-                    (recent.next === null ? undefined : latest(actorID)));
-            return rows.map((row) => ({
-                ...actors.view(row),
-                ...standing(caller, work, live.filter((item) => item.ownerID === row.id), live, finished(row.id)),
-                asks: open.filter((ask) => ask.requesterID === row.id).length,
-                lastActiveAt: audit.lastWrite(row.id) ?? null,
-            }));
-        });
-        return { positions };
-    }
-    /**
-     * An Actor's report: its state and headline as `team` gives them, from the same Work, the Work
-     * on it, its own open asks wherever they are, and what needs it: the asks routed to it, the
-     * submissions it answers and the Work it must take up or hand on. Each list is every page of
-     * its read.
-     */
-    function view(caller, request) {
-        const viewed = request.actorID === undefined ? caller : registry.found(request.actorID);
-        const id = viewed.id;
-        return workspace.run(caller, ({ work }) => {
-            const names = {};
-            const named = (page) => {
-                Object.assign(names, page.actors);
-                return page;
-            };
-            const works = (query) => oldestFirst(all((after) => named(work.list({ ...query, limit: 100, after }))));
-            const asks = (query) => oldestFirst(all((after) => named(work.asks({ ...query, limit: 100, after }))));
-            const mine = works({ ownerID: id, status: [...UNFINISHED] });
-            const last = work.list({ ownerID: id, status: ["accepted"], order: "recent", limit: 1 })
-                .items[0];
-            // Work routed to it as requester: its own, and for the person a closed requester's too.
-            const requesterID = registry.root()?.id === id ? {} : { requesterID: id };
-            const requested = oldestFirst(all((after) => work.list({ ...requesterID, status: [...UNFINISHED], limit: 100, after }))).filter((item) => registry.standIn(item.requesterID) === id);
-            const reviews = requested.filter((item) => item.status === "submitted");
-            const ownerClosed = requested.filter((item) => item.status !== "submitted" && registry.found(item.ownerID).closed_at !== null);
-            names[id] = { name: viewed.name };
-            for (const item of [...reviews, ...ownerClosed])
-                for (const party of [item.ownerID, item.requesterID])
-                    names[party] = { name: registry.found(party).name };
-            const { online } = actors.view(viewed);
-            return {
-                actor: {
-                    actorID: id,
-                    name: viewed.name,
-                    purpose: viewed.purpose,
-                    online,
-                    lastActiveAt: audit.lastWrite(id) ?? null,
-                    closed_at: viewed.closed_at,
-                },
-                ...standing(caller, work, mine, mine, last),
-                workstreams: mine
-                    .filter((item) => workState(item, ownerAsk(item)) !== "open")
-                    .map((item) => ({ ...item, asks: item.asks ?? [] })),
-                asks: asks({ requesterID: id, status: ["open"] }),
-                needs: asks({ routedTo: id }),
-                reviews,
-                assigned: mine.filter((item) => item.requesterID !== id &&
-                    (item.status === "open" || item.status === "changes_requested")),
-                ownerClosed,
-                ...(request.answeredBy === undefined
-                    ? {}
-                    : { answered: asks({ requesterID: id, answeredBy: request.answeredBy }) }),
-                followUps: mine.filter((item) => item.status === "open" && item.requesterID === id),
-                completed: request.completed === 0
-                    ? []
-                    : named(work.list({
-                        ownerID: id,
-                        status: ["accepted"],
-                        order: "recent",
-                        limit: request.completed,
-                    })).items,
-                actors: names,
-            };
-        });
-    }
-    return {
-        tool: bindTool(TEAM, {
-            team: (actor) => readTeam(actor),
-            actor_view: (actor, request) => view(actor, request),
-        }),
-    };
-}