@agentorg/cli 0.0.2 → 0.0.4

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

@@ -1,132 +0,0 @@
-/**
- * An ask's rules and writes: its fields, answers, 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 { 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, and the `raises`
- * earlier builds stored, are left unread.
- */
-export function asksAsRead(forms) {
-    return readThrough(forms, (row) => {
-        const { cause: _cause, raises: _raises, ...ask } = row;
-        return ask;
-    });
-}
-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: {},
-    }, { actorID: caller, at, action: "created", detail: { ...input, workID: ticketID } }));
-}
-/** The asker, or the person once the asker 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 Actor an approval is routed to answers it, never
- * its asker.
- */
-export function responded(actors, forms, work, row, caller, answers, note) {
-    requireThat(row.status === "open", "conflict", "the ask is closed");
-    requireThat(!row.approval || (caller !== row.requesterID && router(actors, work)(row) === caller), "forbidden", "only the Actor an approval is routed to answers it, never its asker");
-    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 each open ask is routed to: its Work's requester, or the person when the asker requested
- * the Work itself or the ask names no Work. A closed requester's asks go to the person. A router
- * reads each Work's requester, each stand-in and the person once. Rights use the strict stand-in;
- * only the hosts' routed read counts an Actor the caller can't see as closed.
- */
-export function router(actors, work, through = standIn) {
-    const requesterOf = remembered((workID) => work.get(workID)?.requesterID);
-    const standInOf = remembered((actorID) => through(actors, actorID));
-    let person;
-    return (row) => {
-        const requester = row.workID === undefined ? undefined : requesterOf(row.workID);
-        if (requester !== undefined && requester !== row.requesterID)
-            return standInOf(requester);
-        person ??= actors.person();
-        return person;
-    };
-}
-/** Reads each key once for the life of the returned function. */
-function remembered(read) {
-    const values = new Map();
-    return (key) => {
-        if (!values.has(key))
-            values.set(key, read(key));
-        return values.get(key);
-    };
-}
-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 and responders. */
-export const mentioned = (row) => [row.requesterID, ...Object.keys(row.responses)];

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,213 +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, routedStandIn, standIn } from "../actors/index.js";
-import { AskQuery, parse, requireThat, SubmissionAnswer, WorkContracts, } from "../contracts/index.js";
-import { names, now, published, readThrough, recorded, stateOf, traverse } from "../records.js";
-import { asksAsRead, asksOn, cancelOpen, checkFields, closed, created, mentioned, responded, router, } 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 the person 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);
-        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);
-        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], () => ({
-                owner: query.ownerID === undefined ? undefined : [query.ownerID].flat(),
-                requester: query.requesterID === undefined ? undefined : [query.requesterID].flat(),
-                status: query.status,
-            }), (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 responded(actors, forms, table, asked, caller, request.answers, request.note);
-            });
-        },
-        asks(input = {}) {
-            const query = parse(AskQuery, input);
-            actors.get();
-            const { after: _after, limit: _limit, ...filter } = query;
-            const routed = query.routedTo;
-            const route = router(actors, table, routedStandIn);
-            return traverse(actors, forms, query, ["asks", filter], () => ({
-                requester: query.requesterID === undefined ? undefined : [query.requesterID],
-                // Only an open ask has a route.
-                status: routed === undefined
-                    ? query.status
-                    : (query.status ?? ["open"]).filter((status) => status === "open"),
-            }), (row) => (query.answeredBy === undefined || Object.hasOwn(row.responses, query.answeredBy)) &&
-                (routed === undefined || route(row) === routed), 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,118 +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.
-
-| Tool         | Input                                                                                                                                         | Purpose                                                   |
-| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
-| message_send | `{recipientID,text}`                                                                                                                          | Send into the pair's conversation                         |
-| message_get  | `{messageID}`                                                                                                                                 | Read one message                                          |
-| message_list | `{between:[id,id]\|counterpartyID\|of,before?:latest\|older,after?:next\|seq,limit?}`                                                         | Read a conversation, or list an Actor's conversations     |
-| work_create  | `{title,goal?,ownerID?,links?,waitsOn?}`                                                                                                      | Create Work; caller requests it and owns it by default    |
-| work_get     | `{ticketID\|askID,history?}`                                                                                                                  | Read Work with all its asks, or an older ask with no Work |
-| work_list    | `{ownerID?:id\|id[],requesterID?:id\|id[],waitsOnActorID?,status?:[...],updatedSince?,order?:recent,after?,limit?}`                           | Read matching shared Work, each with its open asks        |
-| work_update  | `{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  | `{ticketID,expectedRevision?,result,evidence?}`                                                                                               | Submit; self-requested Work completes                     |
-| work_answer  | `{askID,ticketID?,answers:{field:value},note?}`                                                                                               | Answer an ask, or 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, the person 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, the person included. Any active Actor may answer an open ask, except an approval, which only the Actor it is routed to answers, never its asker. The asker closes its ask; once it is closed, the person does. Asking, answering 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 and Work filters select rows through indexed columns, and the adapter decodes only the snapshots they keep. The remaining filters then apply before the limit; `routedTo` reads each open ask the others keep, with its Work's requester. 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` 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 `ownerID` and `requesterID` each take one ID or a list, matching any of them, and the asks read's `requesterID` 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 derives each open ask's route and treats a requester the caller can't see as closed; unknown IDs yield empty matching sets. Omit filters to list all shared records. `ownerID` tests current Work ownership; `requesterID` tests the immutable record requester. Any active caller may query any Actor's records; a filter 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 the person, the Actor the host names for its user. The person edits goal and owner, cancels, and answers the submission. A requester the caller can't see refuses the write with `not_found`, so its rights never pass to the person.
-
-`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;
-- `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. 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 Actor it is routed to answers it, never the asker itself. An approval the person asks that routes back to the person, on Work it requested itself, on Work whose requester is closed, or on no Work, has no one to answer it: it stays open until the person closes it.
-
-**Routing.** An open ask is routed to its Work's requester. When its asker requested the Work itself, or it names no Work, it is routed to the person, so the person's own asks on Work it requested itself come back to it. A closed requester's asks go to the person. Nothing stores a destination: it is derived from the ask, its Work and the host's person. An approval's answer checks the route strictly, so a requester the caller can't see refuses the answer with `not_found`. Only the hosts' routed read (`asks {routedTo}`) counts such a requester as closed, routing its asks to the person.
-
-**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, the person 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`, and the `raises` earlier builds stored, stay stored and unread. Its next write stores it without them; history keeps them.
-
-**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), `resolved` (closed as resolved) and `cancelled` (closed as cancelled by its asker or the person, or when its Work moves on). An ask from an earlier build may also hold `raised`.
-- **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 the person"]
-    M["Messages<br/>Persistent pair conversations"]
-    T["Work tracking<br/>Work, owner, progress, result and its answer;<br/>its asks: fields, responses and resolution"]
-    M -->|"sender and recipient"| A
-    T -->|"owner, asker, an ask's route and the person"| 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/person`      | 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, 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 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 Work's requester and the host's person, 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.
-
-Every Actor sits on one flat level. The host names the person through the required synchronous `person()`, and the bound Actor client revalidates its active caller before asking. An approval's answer requires the responder to be the Actor the approval is routed to. Workspace stores no Actor relationship or new Actor field; the model-free fixture names its person 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 top-level 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` holds where an earlier build started an ask's route and is no longer read; its index, which leads with `status`, still serves status selects. An ask's destination is derived from its Work's requester when it is read.
-
-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`). 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.

package/node_modules/@uniac/agentic-workspace/docs/hub-integration.md

@@ -1,38 +0,0 @@
-# Hub integration
-
-Hub embeds this package under its canonical Actor authority. Hub owns identity, admission, which Actor is the person, and tool exposure; the package owns its records, contracts and SQLite schema.
-
-## Required host authority
-
-Bind the actual admitted Actor ID to a canonical synchronous `ActorAuthority` and one organization's `WorkspaceStore`. The authority has two methods, and every Actor sits on one flat level:
-
-- **`get(callerID, actorID): Actor | undefined`** returns the Actor the caller may see, open or closed, with its current state, and the caller itself; `undefined` for an unknown or hidden ID.
-- **`person(): string`** returns the person's Actor ID: the Actor that stands for the host's user, such as Hub's first Actor. The Workspace calls it only after revalidating an active caller. The person must be an Actor `get` returns, and Hub keeps it open, since rights that pass to a closed person pass to no one active.
-
-The Workspace uses the person in two ways. An ask on Work its asker requested itself, or on no Work, goes to the person. A closed Actor's requester rights, its asks' closing and the asks routed to it pass to the person. The Workspace stores no Actor rows, relationships or person.
-
-## Changes in 0.0.2
-
-0.0.2 changes the public contracts from 0.0.1 (commit 26fd0ee) and keeps storage version 4, so a 0.0.1 store opens unchanged and needs no upgrade.
-
-- **`ActorAuthority` is `{get, person}`.** `within` and `manager` are removed: an object literal typed `ActorAuthority` that still declares either no longer compiles, and on any other host object they are never called. `ActorsClient` drops `within` and `manager` and gains `person()`.
-- **Routing.** An ask goes to its Work's requester. When its asker requested the Work itself, or it names no Work, it goes to the person. A closed requester's asks go to the person. `WorkClient.asks({routedTo})` follows this, counting a requester the caller can't see as closed, and reads each open ask the other filters keep.
-- **Approvals.** Only the Actor an approval is routed to answers it, never its asker. An approval the person asks that routes back to the person, on Work it requested itself, on Work whose requester is closed, or on no Work, has no one to answer it: it stays open until the person closes it.
-- **Stand-ins.** A closed Actor's stand-in is the person: a closed requester's rights (goal, owner, cancel and the answer to its submission) and a closed asker's close pass to it. `standIn` in `/actors` returns an Actor's ID while it is open and the person's once it is closed, and throws `not_found` at an Actor the caller can't see; `routedStandIn` counts such an Actor as closed. Both return a string, never null.
-- **The person asks** on Work it owns, like any Actor.
-- **Raising is removed:** `work_answer`'s `raise`, the `Raise` schema and an ask's `raises`. `work_answer` requires `answers`. An ask stored with `raises` reads without them, its next write stores it without them, and history keeps every `raised` event.
-- **Filters.** `ownerWithin` and `requesterWithin` are removed and refused as unknown fields. `ownerID` takes one ID or a list, as `requesterID` does.
-- **Tool levels are removed.** Contracts carry no `level`, `contract` takes `(description, input, output, writes)`, and `Level` is no longer exported. Every tool is offered to every Actor. The execution server exposes 9 tools and the viewer 4, as before.
-- **Persistence.** `RecordTable.values` is removed, and the forms table's type no longer names `route`. The `route` column stays in the file, unread; its index, which leads with `status`, still serves status selects.
-
-Earlier changes are in [the 0.0.1 Hub integration](https://github.com/uniac-ai/AgenticWorkspace/blob/v0.0.1/docs/hub-integration.md).
-
-## Exposure
-
-Every active admitted Actor may read all organization Work, asks and Messages. Reading adds no business write role. Hub derives each tool's schema and declaration from the package contracts and uses the existing SDK protocol/transport and admitted principal.
-
-Human and Agent clients use those same offered Tools under ordinary admitted identity. HTTP projections may compose their results; they may not read Registry/DB/admin/Provider/native paths or synthesize an elevated caller. A list's `actors` map names the Actors it mentions under the caller's own Actor visibility. Message delivery positions and dedup remain client responsibilities; organization browsing grants no native execution authority.
-
-## Verification
-
-Node **>=22.13** remains the declared floor; CI and the packed-consumer check use **22.23.4** and **24.22.1**. Canonical host integration must prove active callers, the person's stand-in rights and routes, exact schemas and unchanged business writes. The model-free fixture names `requester` as the person only for package verification.