@agentorg/cli 0.0.1 → 0.0.3

package/node_modules/@uniac/agentic-workspace/dist/src/work/asks.js

@@ -1,134 +0,0 @@
-/**
- * An ask's rules and writes: its fields, answers, raises, route and closing. Asks are stored in
- * their own rows of the forms table; callers run each write inside the store's transaction.
- */
-import { randomUUID } from "node:crypto";
-import { routedStandIn, standIn } from "../actors/index.js";
-import { requireThat, } from "../contracts/index.js";
-import { now, published, readThrough, recorded, stateOf } from "../records.js";
-/**
- * Asks as this package reads them: a `cause` stored before asks lived on Work is left unread, and
- * an ask stored then has no raises.
- */
-export function asksAsRead(forms) {
-    return readThrough(forms, (row) => {
-        const { cause: _cause, ...ask } = row;
-        return { ...ask, raises: ask.raises ?? [] };
-    });
-}
-export function checkFields(fields) {
-    requireThat(new Set(fields.map((field) => field.name)).size === fields.length, "invalid_input", "field names must be unique");
-    for (const field of fields) {
-        const values = field.options?.map((option) => option.value);
-        requireThat(values === undefined || new Set(values).size === values.length, "invalid_input", "field options must be unique");
-        requireThat(field.recommended === undefined || values?.includes(field.recommended), "invalid_input", "recommended must be one of the field's options");
-    }
-}
-/**
- * Each Work's asks, by its ID, in the order they were asked (asks in the same millisecond keep
- * update order); the open ones only when asked, and each with its history when asked.
- */
-export function asksOn(forms, ticketIDs, options) {
-    const asks = new Map(ticketIDs.map((id) => [id, []]));
-    const rows = forms
-        .where({ work: ticketIDs, status: options.open ? ["open"] : undefined })
-        .sort((left, right) => left.createdAt.localeCompare(right.createdAt));
-    for (const row of rows)
-        asks
-            .get(row.workID)
-            ?.push(options.history
-            ? { ...published(row), history: forms.history(row.formID) }
-            : published(row));
-    return asks;
-}
-/** A new ask on a Work, by its owner, which the caller has checked may ask on it. */
-export function created(forms, caller, ticketID, input) {
-    const at = now();
-    const formID = randomUUID();
-    const { links = [], ...asked } = input;
-    return published(forms.save(formID, {
-        formID,
-        requesterID: caller,
-        ...asked,
-        links,
-        workID: ticketID,
-        status: "open",
-        createdAt: at,
-        responses: {},
-        raises: [],
-    }, { actorID: caller, at, action: "created", detail: { ...input, workID: ticketID } }));
-}
-/** The asker, or its nearest open manager once it is closed, resolves or cancels its open ask. */
-export function closed(actors, forms, request, caller) {
-    const row = recorded(forms, request.askID);
-    requireThat(standIn(actors, row.requesterID) === caller, "forbidden", "only the asker closes its ask");
-    requireThat(row.status === "open", "conflict", "the ask is closed");
-    const resolution = { text: request.resolution, at: now() };
-    return published(forms.save(row.formID, { ...stateOf(row), status: request.status, resolution }, { actorID: caller, at: resolution.at, action: request.status, detail: resolution }, row.revision));
-}
-/** A complete answer set by one responder; only the asker's strict managers answer an approval. */
-export function responded(actors, forms, row, caller, answers, note) {
-    requireThat(row.status === "open", "conflict", "the ask is closed");
-    requireThat(!row.approval || (caller !== row.requesterID && actors.within(row.requesterID, caller)), "forbidden", "only the asker's managers answer an approval");
-    for (const name of Object.keys(answers))
-        requireThat(row.fields.some((field) => field.name === name), "invalid_input", "answer names an unknown field");
-    for (const field of row.fields) {
-        const answer = Object.hasOwn(answers, field.name) ? answers[field.name] : undefined;
-        requireThat(!field.required || (answer !== undefined && answer.trim().length > 0), "invalid_input", "required answer is missing");
-        requireThat(answer === undefined ||
-            field.options === undefined ||
-            field.options.some((option) => option.value === answer), "invalid_input", "answer is outside field options");
-    }
-    const at = now();
-    const answer = { answers, ...(note === undefined ? {} : { note }) };
-    return published(forms.save(row.formID, {
-        ...stateOf(published(row)),
-        status: row.collect ? "open" : "resolved",
-        responses: { ...row.responses, [caller]: { ...answer, at } },
-    }, { actorID: caller, at, action: "responded", detail: answer }, row.revision));
-}
-/** The Actor an open ask is routed to passes it one manager up; a raise never resolves it. */
-export function raised(actors, forms, row, caller) {
-    requireThat(row.status === "open", "conflict", "the ask is closed");
-    requireThat(routeOf(actors, row) === caller && above(actors, caller) !== null, "forbidden", "only the Actor the ask is routed to raises it, to an open manager above it");
-    const raise = { actorID: caller, at: now() };
-    return published(forms.save(row.formID, { ...stateOf(published(row)), raises: [...row.raises, raise] }, { actorID: caller, at: raise.at, action: "raised", detail: raise }, row.revision));
-}
-/**
- * Where an Actor's asks route: its manager, or that manager's nearest open manager. Raising walks it
- * strictly; only the routed read walks past Actors the caller can't see.
- */
-function above(actors, actorID, through = standIn) {
-    const manager = actors.manager(actorID);
-    return manager === null ? null : through(actors, manager);
-}
-/** The Actor an open ask is routed to, from its last raiser or else its asker; null for none. */
-export function routeOf(actors, row) {
-    return row.status === "open"
-        ? above(actors, row.raises.at(-1)?.actorID ?? row.requesterID)
-        : null;
-}
-/** The route origins of open asks, among those the filter keeps, that route to an Actor. */
-export function routedTo(actors, forms, actorID, requester) {
-    return forms
-        .values("route", { status: ["open"], requester })
-        .filter((origin) => above(actors, origin, routedStandIn) === actorID);
-}
-const CANCELLED = {
-    submitted: "Cancelled with the Work's submission.",
-    cancelled: "Cancelled with the Work's cancellation.",
-    reassigned: "Cancelled with the Work's reassignment.",
-};
-/** Cancels the open asks on a Work whose asker no longer moves it. */
-export function cancelOpen(forms, ticketID, actorID, at, reason) {
-    for (const row of forms.where({ work: [ticketID], status: ["open"] })) {
-        const resolution = { text: CANCELLED[reason], reason, at };
-        forms.save(row.formID, { ...stateOf(published(row)), status: "cancelled", resolution }, { actorID, at, action: "cancelled", detail: resolution }, row.revision);
-    }
-}
-/** The Actors an ask mentions: its asker, responders and raisers. */
-export const mentioned = (row) => [
-    row.requesterID,
-    ...Object.keys(row.responses),
-    ...row.raises.map((raise) => raise.actorID),
-];

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

@@ -1,14 +0,0 @@
-import { type ActorsClient } from "../actors/index.js";
-import { AskQuery, type Form, type Input, type List, type Work, WorkContracts } from "../contracts/index.js";
-import type { WorkspaceStore } from "../persistence/index.js";
-export interface WorkClient {
-    create(input: Input<typeof WorkContracts.work_create.input>): Work;
-    get(input: Input<typeof WorkContracts.work_get.input>): Work | Form;
-    list(input?: Input<typeof WorkContracts.work_list.input>): List<Work>;
-    update(input: Input<typeof WorkContracts.work_update.input>): Work | Form;
-    submit(input: Input<typeof WorkContracts.work_submit.input>): Work;
-    answer(input: Input<typeof WorkContracts.work_answer.input>): Work | Form;
-    /** For hosts, not a tool: asks by asker, by route or by responder, wherever they are. */
-    asks(input?: Input<typeof AskQuery>): List<Form>;
-}
-export declare function createWork(actors: ActorsClient, store: Pick<WorkspaceStore, "work" | "forms" | "transaction">): WorkClient;

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

@@ -1,219 +0,0 @@
-/** Work, the unit of progress, and its asks: completed on submit or by its requester's answer. */
-import { randomUUID } from "node:crypto";
-import { activeActor, standIn } from "../actors/index.js";
-import { AskQuery, parse, requireThat, SubmissionAnswer, WorkContracts, } from "../contracts/index.js";
-import { names, now, published, readThrough, recorded, stateOf, subtrees, traverse, } from "../records.js";
-import { asksAsRead, asksOn, cancelOpen, checkFields, closed, created, mentioned, raised, responded, routedTo, } from "./asks.js";
-export function createWork(actors, store) {
-    const table = readThrough(store.work, (row) => row.status === "blocked" ? { ...row, status: "active" } : row);
-    const forms = asksAsRead(store.forms);
-    const editable = (row) => requireThat(row.status === "open" || row.status === "active" || row.status === "changes_requested", "conflict", "work is frozen for review, accepted or cancelled");
-    /** The requester's rights, which pass to its nearest open manager once it is closed. */
-    const requester = (row, caller) => standIn(actors, row.requesterID) === caller;
-    /** What Work waits on must exist; text needs no check. */
-    function waitable(waitsOn) {
-        if (waitsOn && "actorID" in waitsOn)
-            actors.get({ actorID: waitsOn.actorID });
-        if (waitsOn && "ticketID" in waitsOn)
-            recorded(table, waitsOn.ticketID);
-    }
-    const withAsks = (ticketID, history) => ({
-        ...recorded(table, ticketID, history),
-        asks: asksOn(forms, [ticketID], { open: false, history }).get(ticketID) ?? [],
-    });
-    function edit(request, caller) {
-        const { ticketID, expectedRevision, goal, ownerID, status, ask: _ask, close: _close, ...own } = request;
-        const cancel = status === "cancelled";
-        const requested = { goal, ownerID, status: cancel ? status : undefined };
-        const owned = { ...own, status: cancel ? undefined : status };
-        const requesterEdit = Object.values(requested).some((value) => value !== undefined);
-        requireThat(!requesterEdit || expectedRevision !== undefined, "invalid_input", "goal, owner or cancel edits need expectedRevision");
-        if (ownerID !== undefined)
-            activeActor(actors, ownerID);
-        waitable(own.waitsOn);
-        return store.transaction(() => {
-            const row = recorded(table, ticketID);
-            editable(row);
-            requireThat(!requesterEdit || requester(row, caller), "forbidden", "only requester edits goal or owner, or cancels");
-            requireThat(Object.values(owned).every((value) => value === undefined) || row.ownerID === caller, "forbidden", "only owner edits title, progress, status, links or waitsOn");
-            // A stored blocked reads as active; the write that first stores active says so.
-            const unblocked = status === undefined && String(store.work.get(row.ticketID)?.status) === "blocked";
-            const detail = Object.fromEntries([
-                ...Object.entries(requested),
-                ...Object.entries(owned),
-                ...(unblocked ? [["status", "active"]] : []),
-            ].filter(([, value]) => value !== undefined));
-            const data = { ...stateOf(row), ...detail };
-            if (data.waitsOn === null)
-                delete data.waitsOn;
-            const at = now();
-            const saved = table.save(row.ticketID, data, { actorID: caller, at, action: "updated", detail }, expectedRevision ?? row.revision);
-            // Once the owner no longer moves the Work, its open asks wait on nobody.
-            if (cancel)
-                cancelOpen(forms, row.ticketID, caller, at, "cancelled");
-            else if (ownerID !== undefined && ownerID !== row.ownerID)
-                cancelOpen(forms, row.ticketID, caller, at, "reassigned");
-            return published(saved);
-        });
-    }
-    function ask(ticketID, input, caller) {
-        checkFields(input.fields);
-        requireThat(actors.manager(caller) !== null, "forbidden", "the root doesn't ask");
-        return store.transaction(() => {
-            const work = recorded(table, ticketID);
-            requireThat(work.ownerID === caller, "forbidden", "only the Work's owner asks on it");
-            editable(work);
-            return created(forms, caller, ticketID, input);
-        });
-    }
-    function answerSubmission(request, caller) {
-        const row = submitted(table, request.askID, request.ticketID);
-        requireThat(!request.raise, "invalid_input", "a submission can't be raised");
-        const { verdict } = parse(SubmissionAnswer, request).answers;
-        requireThat(verdict === "accepted" || request.note !== undefined, "invalid_input", "requesting changes needs a note");
-        requireThat(requester(row, caller), "forbidden", "only requester answers its submission");
-        requireThat(row.status === "submitted" && row.submission?.submissionID === request.askID, "conflict", "the submission is not current");
-        const at = now();
-        const review = {
-            submissionID: request.askID,
-            reviewerID: caller,
-            verdict,
-            ...(request.note === undefined ? {} : { comment: request.note }),
-            at,
-        };
-        const data = { ...stateOf(row), status: verdict, review };
-        return published(table.save(row.ticketID, verdict === "accepted" ? { ...data, completedAt: at } : data, { actorID: caller, at, action: "reviewed", detail: review }, row.revision));
-    }
-    return {
-        create(input) {
-            const request = parse(WorkContracts.work_create.input, input);
-            const caller = actors.get().actorID;
-            const { ownerID = caller, links = [], ...fields } = request;
-            activeActor(actors, ownerID);
-            waitable(request.waitsOn);
-            return store.transaction(() => {
-                const at = now();
-                const ticketID = randomUUID();
-                const saved = table.save(ticketID, {
-                    ticketID,
-                    requesterID: caller,
-                    ownerID,
-                    ...fields,
-                    status: "open",
-                    links,
-                    createdAt: at,
-                }, { actorID: caller, at, action: "created", detail: request });
-                return published(saved);
-            });
-        },
-        get(input) {
-            const request = parse(WorkContracts.work_get.input, input);
-            actors.get();
-            if (request.ticketID !== undefined)
-                return withAsks(request.ticketID, request.history);
-            const { askID } = request;
-            const asked = forms.get(askID);
-            if (asked === undefined)
-                return withAsks(submitted(table, askID, undefined).ticketID, request.history);
-            return asked.workID === undefined
-                ? recorded(forms, askID, request.history)
-                : withAsks(asked.workID, request.history);
-        },
-        list(input = {}) {
-            const query = parse(WorkContracts.work_list.input, input);
-            actors.get();
-            const { after: _after, limit: _limit, ...filter } = query;
-            const waitedOn = (row) => row.waitsOn && "actorID" in row.waitsOn ? row.waitsOn.actorID : undefined;
-            const page = traverse(actors, table, query, ["work", filter], () => subtrees(actors, table, {
-                owner: query.ownerID === undefined ? undefined : [query.ownerID],
-                requester: query.requesterID === undefined ? undefined : [query.requesterID].flat(),
-                status: query.status,
-            }, { owner: query.ownerWithin, requester: query.requesterWithin }), (row) => (query.waitsOnActorID === undefined || waitedOn(row) === query.waitsOnActorID) &&
-                (query.updatedSince === undefined || row.updatedAt >= query.updatedSince), (row) => [row.requesterID, row.ownerID, row.review?.reviewerID, waitedOn(row)]);
-            const asks = asksOn(forms, page.items.map((item) => item.ticketID), { open: true, history: false });
-            const items = page.items.map((item) => ({ ...item, asks: asks.get(item.ticketID) ?? [] }));
-            const unnamed = items
-                .flatMap((item) => item.asks.flatMap(mentioned))
-                .filter((actorID) => !Object.hasOwn(page.actors, actorID));
-            return { ...page, items, actors: { ...page.actors, ...names(actors, unnamed) } };
-        },
-        update(input) {
-            const request = parse(WorkContracts.work_update.input, input);
-            const caller = actors.get().actorID;
-            // The contract keeps each form in a call of its own, and `ask` names its Work.
-            const { close } = request;
-            if (close !== undefined)
-                return store.transaction(() => closed(actors, forms, close, caller));
-            if (request.ask !== undefined)
-                return ask(request.ticketID, request.ask, caller);
-            return edit(request, caller);
-        },
-        submit(input) {
-            const request = parse(WorkContracts.work_submit.input, input);
-            const caller = actors.get().actorID;
-            return store.transaction(() => {
-                const row = recorded(table, request.ticketID);
-                editable(row);
-                requireThat(row.ownerID === caller, "forbidden", "only owner submits work");
-                const at = now();
-                const submission = {
-                    submissionID: randomUUID(),
-                    ownerID: caller,
-                    result: request.result,
-                    evidence: request.evidence,
-                    at,
-                };
-                const { review: _review, ...data } = stateOf(row);
-                const completed = row.requesterID === caller;
-                const saved = table.save(row.ticketID, completed
-                    ? { ...data, status: "accepted", completedAt: at, submission }
-                    : { ...data, status: "submitted", submission }, { actorID: caller, at, action: "submitted", detail: submission }, request.expectedRevision ?? row.revision);
-                cancelOpen(forms, row.ticketID, caller, at, "submitted");
-                return published(saved);
-            });
-        },
-        answer(input) {
-            const request = parse(WorkContracts.work_answer.input, input);
-            const caller = actors.get().actorID;
-            return store.transaction(() => {
-                const asked = forms.get(request.askID);
-                if (asked === undefined)
-                    return answerSubmission(request, caller);
-                requireThat(request.ticketID === undefined || asked.workID === request.ticketID, "not_found", "record not found");
-                return request.raise
-                    ? raised(actors, forms, asked, caller)
-                    : responded(actors, forms, asked, caller, request.answers ?? {}, request.note);
-            });
-        },
-        asks(input = {}) {
-            const query = parse(AskQuery, input);
-            actors.get();
-            const { after: _after, limit: _limit, ...filter } = query;
-            return traverse(actors, forms, query, ["asks", filter], () => {
-                const requester = query.requesterID === undefined ? undefined : [query.requesterID];
-                const routed = query.routedTo;
-                return {
-                    requester,
-                    // Only an open ask has a route.
-                    status: routed === undefined
-                        ? query.status
-                        : (query.status ?? ["open"]).filter((status) => status === "open"),
-                    route: routed === undefined ? undefined : routedTo(actors, forms, routed, requester),
-                };
-            }, (row) => query.answeredBy === undefined || Object.hasOwn(row.responses, query.answeredBy), mentioned);
-        },
-    };
-}
-/**
- * The Work a submission is on: by its ID alone, the Work whose current submission it is; with a
- * ticketID, that Work, if the submission is one of its own.
- */
-function submitted(table, submissionID, ticketID) {
-    const [row] = ticketID === undefined ? table.where({ submission: [submissionID] }) : [table.get(ticketID)];
-    requireThat(row &&
-        (row.submission?.submissionID === submissionID ||
-            table
-                .history(row.ticketID)
-                .some((event) => event.action === "submitted" && event.detail.submissionID === submissionID)), "not_found", "record not found");
-    return row;
-}

package/node_modules/@uniac/agentic-workspace/docs/contracts.md

@@ -1,124 +0,0 @@
-# Operations, roles and transitions
-
-Runtime request/record schemas and derived TypeScript types are maintained in [src/contracts](../src/contracts/index.ts). Requests are strict objects: extra fields, including caller identity fields, are rejected. IDs/text are trimmed and bounded. The admitted caller comes from trusted client construction. All clients require an active caller on every operation, including reads. Visibility is owned by canonical Actor authority. Work, its asks and Messages are shared within the admitted Hub organization. Record roles determine write permissions.
-
-## Tool inventory
-
-Every successful write returns the resulting record: its stable ID, `revision` and `updatedAt`, the time of the write that produced the current revision. History comes only from `work_get` with `history: true`, for the Work and each of its asks. Execution MCP exposes every row below. Viewer MCP exposes only reads. Actor lifecycle administration is outside this inventory.
-
-Each contract carries `level`, the smallest organization level that presents it. Report is one agent and its person; Team adds working with other Actors; Organization adds the lifecycle and the system, none of which is in this package. Each level contains the one before it. The tag selects what a client presents; it grants and refuses nothing.
-
-| Tool         | Level  | Input                                                                                                                                         | Purpose                                                   |
-| ------------ | ------ | --------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
-| message_send | Report | `{recipientID,text}`                                                                                                                          | Send into the pair's conversation                         |
-| message_get  | Team   | `{messageID}`                                                                                                                                 | Read one message                                          |
-| message_list | Report | `{between:[id,id]\|counterpartyID\|of,before?:latest\|older,after?:next\|seq,limit?}`                                                         | Read a conversation, or list an Actor's conversations     |
-| work_create  | Report | `{title,goal?,ownerID?,links?,waitsOn?}`                                                                                                      | Create Work; caller requests it and owns it by default    |
-| work_get     | Report | `{ticketID\|askID,history?}`                                                                                                                  | Read Work with all its asks, or an older ask with no Work |
-| work_list    | Report | `{ownerID?,requesterID?:id\|id[],waitsOnActorID?,ownerWithin?,requesterWithin?,status?:[...],updatedSince?,order?:recent,after?,limit?}`      | Read matching shared Work, each with its open asks        |
-| work_update  | Report | `{ticketID,expectedRevision?,title?,goal?,ownerID?,progress?,status?:open\|active\|cancelled,links?,waitsOn?}`, `{ticketID,ask}` or `{close}` | Edit or cancel Work; ask on it; close an ask              |
-| work_submit  | Report | `{ticketID,expectedRevision?,result,evidence?}`                                                                                               | Submit; self-requested Work completes                     |
-| work_answer  | Team   | `{askID,ticketID?,answers?:{field:value},note?,raise?:true}`                                                                                  | Answer or raise an ask, or answer the current submission  |
-
-`work_get`, `work_update` and `work_answer` return the record the call reads or writes: Work, or an ask. An ask has `formID` and Work has `ticketID`, and each result schema is their union.
-
-## Authority
-
-- Every active admitted Actor may read every message and every conversation. An Actor sends to any other active Actor, never to itself. A reply is another message in the same conversation. Messages have no read, delivery or handling state, and reading changes nothing.
-- Every active admitted Actor may get/list all organization Work, including history and accepted tickets. The requester edits goal and owner, cancels and answers the submission; once it is closed, its nearest open manager does. The current owner edits title, progress, status, links and waitsOn, and submits. Reassignment changes write roles and filter membership; it does not remove shared read access. New owner must be active.
-- Every active admitted Actor may read every ask and its history, with its Work. The Work's owner asks on it, except the root. Any active Actor may answer an open ask, except an approval, which only the asker's managers answer. The Actor an ask is routed to may raise it, except the root. The asker closes its ask; once it is closed, its nearest open manager does. Asking, answering, raising and closing never change the Work row. Active callers retain shared history reads when counterparties close.
-
-The host composes canonical Actor authority and a WorkspaceStore for one Hub organization. Public read does not construct an elevated identity or alter Actor visibility. List criteria do not select the caller or grant write authority.
-
-## Lists
-
-`work_list`, `message_list` and the hosts' `WorkClient.asks` return `{items, next, actors}`. `actors` maps every Actor ID the page mentions to `{name}`, leaving out Actors the caller can't see. `next` is an opaque position, or null when the read observed no further matching rows. Pass it back as `after` with the same filters to continue; a position from another read, filter or order is refused with `invalid_input`. Work and ask records carry no position of their own.
-
-Work and ask lists go in update order by default: a record moves to the end of that order whenever it changes. `work_list`'s `order: "recent"` goes newest first, and its `updatedSince` keeps records whose `updatedAt` is at or after the given time, which is how a reader picks up changes since it last looked. Lists are current upserts, not snapshots: a record updated during a traversal can appear again later in update order, and a record that stops matching leaves no tombstone. Paging `order: "recent"` can skip a record that is updated between page reads, because the update moves it to the front, ahead of the pages already read. That suits a view that refetches its first page when records change; it is not a way to read every record. A reader that needs a complete current view pages in update order or lists again from the start, and reconciles IDs.
-
-The page `limit` defaults to 50 and is at most 100. It bounds the returned rows, not the scan. Owner, requester, status, Work and route filters select rows through indexed columns, and the adapter decodes only the snapshots they keep. A subtree filter reads membership once for each Actor the column holds among the rows the other indexed filters keep, not once per row. The remaining filters then apply before the limit. A list reads the rows committed before it starts; a row committed during the read waits for the next one. The open asks a `work_list` page carries are read after the page.
-
-### Filters
-
-Work accepts `ownerID`, `requesterID`, `waitsOnActorID`, `status`, `ownerWithin`, `requesterWithin` and `updatedSince`. The hosts' `WorkClient.asks` accepts `requesterID`, `routedTo` (open asks routed to that Actor), `answeredBy` (asks with a response by that Actor) and `status`. All supplied filters intersect. `work_list`'s `requesterID` takes one ID or a list, matching any of them, and the asks read's takes one ID; `status` takes a list of the module's status values, matching any of them. ID filters use exact equality; `waitsOnActorID` matches Work waiting on that Actor. Filter IDs do not trigger Actor lookup, except `routedTo`, which walks each open ask's route through the host's `manager` and treats an Actor the caller can't see as closed; unknown IDs yield empty matching sets. Omit filters to list all shared records.
-
-Subtree criteria use the required host `ActorAuthority.within(callerID, actorID, ancestorID)`, which tests the named canonical position and every descendant through retained relationships, including closed Actors and closed anchors without a depth limit. Unknown members or anchors return false. Bound `ActorsClient.within(actorID, ancestorID)` revalidates the admitted caller and delegates membership without selected-profile lookup or caller substitution.
-
-`ownerWithin` tests current Work ownership; `requesterWithin` tests immutable record requester, the scope from which it originated. Neither implies causal ticket lineage. Any active caller may query any branch; membership grants no write role.
-
-## Messages
-
-A Message is `{messageID, conversationID, senderID, recipientID, text, createdAt, seq}` and never changes after it is sent.
-
-- **`conversationID`** names the one ordered series the message belongs to. In this version it is derived from the pair, so each pair has one direct conversation, both directions included. A message to oneself, which earlier builds accepted and this one refuses, has its own. It is opaque: clients compare it and key their own positions by it.
-- **`seq`** is the message's place in the one Message order, which spans every conversation and follows commit order. Clients compare it with their own positions, such as a seen-through or delivered-through `seq`.
-
-`message_list` takes exactly one of three selectors and returns `{items, next, older, actors}`. No read mixes several conversations into one list.
-
-- **`between: [a, b]`** reads that pair's conversation, in either order. `[a, a]` reads a self conversation stored before self messages were refused.
-- **`counterpartyID`** reads the caller's conversation with that Actor, the same as `between: [caller, counterpartyID]`. A position from one form continues the other.
-- **`of`** lists that Actor's conversations, newest first. Each item is its conversation's latest message, and the counterparty is its party other than `of`; a self conversation stored before self messages were refused is listed too, with `of` as both parties. `next` continues to older conversations, and `older` is null. `of` takes no `before`, and its `after` is a `next` position. A conversation that gets a message between page reads moves to the front, as with `order: "recent"`.
-
-A conversation reads one of two ways, with items ascending.
-
-- **Forward:** omit `before`. Rows after `after` (a `next` token or a `seq`; default from the start) come in order up to `limit`.
-- **Newest window:** `before: "latest"` selects the last `limit` rows; `before: older` continues toward the start. `before` and `after` are exclusive.
-
-`next` continues forward from the last returned row and is null when nothing newer matched; `older` continues back from the first returned row and is null at the start. A client may keep a `seq` instead of `next`, since `after` accepts either: a forward read that reached the end resumes from the last `seq` it handled. A newest window captures the Message head once, so messages sent during the read wait for the next read. Listing does not resolve the named Actors or require them to be active, so a closed Actor's conversations stay readable.
-
-## Work
-
-Work is the unit of progress. A Work record holds:
-- `title` (at most 120 characters) and an optional `goal`;
-- `progress`: a paragraph, then optionally a Markdown task list of steps, where `- [x]` marks a step done and `- [ ]` one not done. Readers take the first step not done as the current one and render a plain list as numbered steps. The Workspace stores the text as written and parses none of it;
-- `status`: `open`, `active`, `submitted`, `changes_requested`, `accepted` or `cancelled`;
-- `links`, each `{label?, url}` with an http or https URL;
-- an optional `waitsOn`: an Actor (`{actorID}`), other Work (`{ticketID}`) or a short description (`{text}`);
-- `submission` and `review`, and `completedAt` once accepted.
-
-`work_create` makes the caller the requester and, unless `ownerID` names another active Actor, the owner. A waited-on Actor or Work must exist. `work_update` sets `waitsOn: null` to clear it and `links: []` to empty them.
-
-New Work is `open`. In `open`, `active` or `changes_requested`, the owner may edit its fields and set `open` or `active`, and the requester may edit goal and owner, or set `cancelled`. Cancelled Work is terminal and frozen. Work that can't move without someone asks; Work held up outside the organization, or by other Work, stays `active` and says what it waits on. So `blocked` is refused, with a message that says so. A Work row stored as `blocked`, before `blocked` was refused, reads as `active` in every read, filter and rule; its next write stores `active`, and its history keeps the `blocked` write.
-
-`work_submit` records a new submission. On Work its owner requested itself it completes at once: `accepted`, with `completedAt` and no review. Other Work enters `submitted` and is frozen until its requester answers the current submission with `work_answer`. The answer names the submission by its ID (`askID`, with an optional `ticketID` that must be the Work it is on) and gives `answers: {verdict}`; its `note` is the comment. It is stored as `review`. Accepting needs no note, sets `completedAt` and is terminal; requesting changes needs a note and returns the Work to its owner. Follow-up work gets a new ticket.
-
-Once the requester is closed, its rights pass to its nearest open manager: the first open Actor up its retained managers. That Actor edits goal and owner, cancels, and answers the submission. Rights never pass past an Actor the caller can't see: the write is refused with `not_found`.
-
-`expectedRevision` is optional on the owner's writes (edits and submit), which no one else makes. Goal, owner and cancel edits require it. An answer takes none: its submission ID pins it. The state, role and revision checks and the snapshot/history writes share one SQLite transaction; a stale revision conflicts. By its ID alone a submission is found only while it is current; named with its `ticketID`, an earlier submission of that Work conflicts, and an ID that was never one of its submissions is `not_found`. Resubmission retains prior evidence and reviews in history.
-
-## Asks
-
-An ask is part of the Work its asker owns: `work_update {ticketID, ask}` asks on it, and returns the new ask. The ask names no one to answer it. It holds:
-- `title` (at most 120 characters), optional `context` and `links`;
-- `fields`: each has a `name`, a `label` and `required`, and may have `options`, each `{value, detail?}`, and the asker's `recommended` value among them. A one-field ask with options is a decision; without options, a question;
-- `workID`, the Work it is on;
-- `approval` and `collect`, both false by default;
-- `responses`, one per responder, and `raises`, `{actorID, at}` for each Actor that passed it up, in order;
-- `status` (`open`, `resolved` or `cancelled`), and a `resolution` once closed.
-
-The record keeps its Form field names (`formID`, `requesterID` for the asker) until the wire takes the model's words; arguments name it `askID`. Only the Work's owner asks, on Work that is open, active or changes requested, and the root doesn't ask. An ask is stored in its own row, so asking, answering and closing never move the Work's revision.
-
-**Reads.** `work_get {ticketID}` returns the Work with `asks`: all of them, open and closed, in the order they were asked (asks made in the same millisecond keep update order). `work_get {askID}` returns the Work an ask is on, the same way, and the current submission's ID returns its Work. An older ask that names no Work is returned alone. `work_list` items carry their open asks. Write results carry no `asks`.
-
-**Answering.** Any active Actor answers an open ask with `work_answer {askID, answers, note?}`: a complete answer set, where required fields are nonblank, every named field exists and a choice matches an option. The response is recorded under its responder with the time it was given. A responder that answers again replaces its own response, and history keeps every earlier one. The first answer resolves the ask; an ask with `collect` stays open for more answers until its asker closes it. An answer to a closed ask conflicts.
-
-An `approval` ask authorizes something that can't be undone, so only the asker's strict ancestors answer it: its managers up to the root, never the asker itself. The Workspace tests this with the host's `within` relation, so it needs no root identity.
-
-**Routing and raising.** An open ask is routed to its asker's manager; once raised, to its last raiser's manager. A closed manager is skipped for its nearest open one. Raising walks the route strictly, so a manager the caller can't see refuses the raise with `not_found`. Only the hosts' routed read (`asks {routedTo}`) counts such a manager as closed and walks on past it. Nothing stores a destination: it is derived from the asker, the raises and the tree. The Actor an ask is routed to may raise it with `work_answer {askID, raise: true}`, except the root, which has no manager. A raise adds `{actorID, at}` to `raises`, keeps the ask open and routes it one manager up. It never resolves the ask, and a later answer by the raiser doesn't remove it.
-
-**Closing.** The asker closes its open ask with `work_update {close: {askID, status, resolution}}`, as `resolved` with a `resolution` (ending a collection, or recording an answer given elsewhere) or `cancelled`. Once the asker is closed, its nearest open manager closes it. It takes no `expectedRevision`, and a closed ask refuses a second close. Answering and closing work on frozen Work too.
-
-**When Work moves on.** Submitting, cancelling or reassigning Work cancels its open asks, since their asker no longer moves it. Each gets `status: cancelled` and a `resolution` with a fixed `text` and a `reason`: `submitted`, `cancelled` or `reassigned`. Its history entry is by the Actor who moved the Work, at the same time. A new ask on submitted, accepted or cancelled Work is refused.
-
-**Asks stored before asks lived on Work.** They read as stored: an ask with no Work is read, answered and closed by its ID, an ask by another Actor shows under the Work it names, and an ask left open on submitted Work is still answered and closed. Such an ask's `cause` stays stored and unread, and it reads with `raises: []`. Its next write stores it without `cause`; history keeps it.
-
-**Hosts' reads.** `WorkClient.asks({requesterID?, routedTo?, answeredBy?, status?, after?, limit?})` is not a tool. It lists asks wherever they are: an asker's own, those routed to an Actor, and those an Actor answered. Older asks with no Work are included.
-
-**History.** These action names are part of the contract, since hosts label what changed by them.
-- **An ask's history:** `created` (asked), `responded` (answered), `raised`, `resolved` (closed as resolved) and `cancelled` (closed as cancelled by its asker or stand-in, or when its Work moves on).
-- **Cancellations when Work moves on:** only these carry `resolution.reason`.
-- **A Work's history:** `created`, `updated` (every edit, a cancel included), `submitted` and `reviewed` (the answer to a submission).
-
-## Errors and protocol
-
-Domain clients throw `WorkspaceError` with `invalid_input`, `not_found`, `forbidden` or `conflict`. An `invalid_input` from a contract names each schema issue as `path: message`. Reads of inaccessible IDs use `not_found`. MCP successes include record/page `structuredContent` plus equivalent JSON text and an advertised output schema. MCP tool errors set `isError:true` and carry JSON text `{code,message}`; they omit structured content to avoid success-schema validation. Unexpected failures become generic `internal_error` without raw exception text. Discovery uses SDK protocol errors: domain refusals return invalid-request errors with public text; unexpected failures return internal errors with the same generic public message. Viewer calls to a mutation are refused even when sent directly without discovery.

package/node_modules/@uniac/agentic-workspace/docs/design.md

@@ -1,67 +0,0 @@
-# Design and boundaries
-
-The graphs below are the component and exposure graphs; [contracts.md](contracts.md) holds the exact contracts and local policies.
-
-## Component dependencies
-
-Arrows point toward a dependency. An ask is part of the Work its asker owns, so the Work module owns asks too; Messages link no Work.
-
-```mermaid
-flowchart BT
-    A["Actors<br/>Identity and canonical membership"]
-    M["Messages<br/>Persistent pair conversations"]
-    T["Work tracking<br/>Work, owner, progress, result and its answer;<br/>its asks: fields, responses, raises and resolution"]
-    M -->|"sender and recipient"| A
-    T -->|"owner, asker, an approval's managers and an ask's route"| A
-```
-
-## Exposure and authority
-
-```mermaid
-flowchart TB
-    E["Execution-use MCP"] -->|"uses"| D["Shared workspace records<br/>Actors · Messages · Work and its asks"]
-    V["Viewer-use MCP"] -->|"reads"| D
-    H["AgentOrg Hub<br/>Canonical Actor identity, admission<br/>and Tool exposure"] -.->|"authority binding when integrated"| D
-```
-
-Both MCP exposures use the same Actor identity and role rules. The execution server exposes all 9 operations. The viewer server exposes four reads and refuses writes, using the same underlying clients and authority checks. The SDK owns protocol initialization, transports, request dispatch, and shutdown. The package constructs an SDK server; the host connects it to an SDK transport and closes it.
-
-## Module contracts
-
-| Module        | Consumes                                         | Exposes                           | Owns                                                                                                                                                                                                           |
-| ------------- | ------------------------------------------------ | --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Actors        | Injected canonical authority and admitted caller | `ActorsClient.get/within/manager` | No persisted state; no lifecycle administration                                                                                                                                                                |
-| Messages      | Actors; Messages persistence                     | `MessagesClient.send/get/list`    | Content, parties, conversation and order                                                                                                                                                                       |
-| Work tracking | Actors; Work and Forms persistence               | `WorkClient`                      | Work: requester, owner, title, goal, progress, status, links, waits-on, submission, review, completion, history; and its asks: fields and options, approval, collection, responses with notes, raises, closure |
-
-Work does not import Messages. Messages link no Work; a reply is another message in the pair's conversation. An ask is stored in its own row of the forms table, beside its Work, so asking, answering, raising and closing never move the Work's revision. Submitting, cancelling or reassigning Work cancels its open asks in the same transaction. An ask's route is derived when read, from its asker, its raises and the host's `manager` relation, and nothing stores a destination. Messages have no public read/handling state or dependent acknowledgement step. Work and its asks, with their history, and Messages are public within the admitted organization. Work progress may contain stable record references as text.
-
-The host binds one organization's canonical authority and persistence into the composition. Shared reads authenticate the existing caller; they do not construct a privileged Actor. Work and ask filters intersect before pagination, using the same traversal and record schemas. Business write roles remain separate from shared visibility.
-
-The required synchronous canonical `within(callerID, actorID, ancestorID)` relationship read supplies inclusive retained ancestry, including closed positions and descendants beyond any Team depth limit. The bound Actor client revalidates its active caller; Work predicates apply the subtree criteria before traversal limits, and an approval's answer requires the responder to be a strict ancestor of the asker. Workspace stores no hierarchy or new Actor field. The model-free fixture alone holds a manager map for its example truth. Requester scope is immutable record origin, not causal ticket lineage. Independent lane cursors and bounded from-zero refresh/reconciliation preserve the current-upsert limitations described in the contract.
-
-The root composition factory wires distinct clients; it is not another multi-domain operation client. Consumers can construct and use any module independently through its own export. Contracts depend only on Zod. Domain modules import persistence types; native SQLite is loaded only through the persistence implementation export.
-
-A Message's `conversationID` is derived from its pair when read and its `seq` is its module cursor, so neither is stored and there is no conversation registry. A later kind of conversation, such as a group or a Work thread, would store its own ID beside these without migrating them. Lists issue opaque positions that encode the read's filter and a cursor, so a position continues only its own read (a `between` read and a `counterpartyID` read of one pair are the same read); the records themselves carry no cursor, except a Message's `seq`. Each list resolves the Actor names it mentions through the Actor authority, so a reader needs no lookup per ID.
-
-## Persistence and state changes
-
-SQLite has separate current-snapshot and history tables for Messages, Work and asks (the `forms` table); a version 3 database also holds the `status` and `status_history` tables, which this package leaves in place, unread. There is no Actor table. Each mutation writes the current snapshot and one module-owned history entry together inside `BEGIN IMMEDIATE`/commit, or rolls back both. History includes actor, time, action, revision, cursor and changed details. A record's `updatedAt` is the time of the history entry for its current revision. Old submissions, reviews and responses remain in history after newer ones replace their current fields; reads return history only when asked. IDs are UUIDs; the Work primary ID is named `ticketID`, and other records carry the same value as `workID`.
-
-The database records its schema in `PRAGMA user_version`. Opening a database runs, in one transaction, every upgrade step after its version: 0 is a database from before storage versions, or a new one, where the data steps find no rows. Steps change current snapshots in place and never rewrite history, so an original value a step removes stays in the event that recorded it. A database newer than the package is refused and left unchanged. A title a step derives is the first line of the source text, cut at a word boundary to 120 characters with "…"; the source text is unchanged.
-
-- Version 1 removes `workID` from Message snapshots.
-- Version 2 gives Work a `title` from its goal and empty `links`, and gives accepted Work the `completedAt` of the review that accepted it.
-- Version 3 turns Forms into asks. Each ask gets a `title` from its first field's label, empty `links`, `approval: false` and `collect: true`, because a Form before version 3 stayed open until its requester closed it and keeps doing so. `respondentIDs` is removed, each option string becomes `{value}`, and each response becomes `{answers, at}`, with the time of that responder's last answer.
-- Version 4 adds indexed, generated columns and rewrites no record:
-  - Messages' `sender` and `recipient`;
-  - Work's `owner`, `requester`, `status` and `submission` (the current submission's ID). The `status` column holds a stored `blocked` as `active`. The owner and requester indexes are on (party, status);
-  - asks' `requester`, `status`, `work` and `route`, indexed on (requester, status), (work, status) and (status, route). `route` is where an ask's route starts: its last raiser, else its asker. The destination comes from the Actor tree when it is read, so it is never stored.
-
-Each module advances a persisted cursor on every mutation. Current snapshots are traversed by cursor; histories are read with their owning record. [List semantics](contracts.md#lists) describe the positions and limits. No event replay framework, scheduler, notification dispatcher, model executor or native session controller is part of this package. Record-changing communication happens only through these clients/tools; ordinary prose has no effect.
-
-The persistence adapter selects current snapshots through those indexed columns (`RecordTable.where`), and reads a column's distinct values (`values`) so that a subtree filter tests each Actor once. A party's index leads with the party and then status, so a party's records in some statuses are one index range, whatever statistics the planner has. Other filters apply to the decoded rows. It returns full history for a record when asked. It makes no bounded-history or large-workspace guarantee: a list decodes every row its indexed filters keep before paging, and a list with no indexed filter decodes every row of its table. An Actor's conversations read every message it sent or received. Database files belong to the host: use trusted local paths, appropriate filesystem access, and close owned connections before deleting test data. The fixture entry point has no production credential or network admission surface.
-
-## Repository map
-
-`src/contracts` owns runtime schemas and exported types. Each of `src/actors`, `src/messages` and `src/work` exposes its client; `src/work/asks.ts` holds an ask's rules. `src/persistence` owns the storage boundary and SQLite implementation. `src/mcp` adapts those clients to SDK servers. `src/index.ts` composes clients. Model-free authorities and stdio use live only in `examples`; they are not exported as production identity services. Tests include a packed-package consumer installed outside this repository.