@agentorg/cli 0.0.1 → 0.0.2

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

@@ -193,10 +193,6 @@ export declare const Work: z.ZodObject<{
             note: z.ZodOptional<z.ZodString>;
             at: z.ZodISODateTime;
         }, z.core.$strict>>;
-        raises: z.ZodArray<z.ZodObject<{
-            actorID: z.ZodString;
-            at: z.ZodISODateTime;
-        }, z.core.$strict>>;
         resolution: z.ZodOptional<z.ZodObject<{
             text: z.ZodString;
             reason: z.ZodOptional<z.ZodEnum<{
@@ -213,7 +209,6 @@ export type WaitsOn = z.infer<typeof WaitsOn>;
 export type Work = z.infer<typeof Work>;
 export declare const WorkContracts: {
     work_create: {
-        level: "organization" | "report" | "team";
         description: string;
         input: z.ZodObject<{
             title: z.ZodString;
@@ -235,7 +230,6 @@ export declare const WorkContracts: {
         writes: boolean;
     };
     work_get: {
-        level: "organization" | "report" | "team";
         description: string;
         input: z.ZodObject<{
             ticketID: z.ZodOptional<z.ZodString>;
@@ -274,14 +268,11 @@ export declare const WorkContracts: {
         writes: boolean;
     };
     work_list: {
-        level: "organization" | "report" | "team";
         description: string;
         input: z.ZodObject<{
-            ownerID: z.ZodOptional<z.ZodString>;
+            ownerID: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
             requesterID: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
             waitsOnActorID: z.ZodOptional<z.ZodString>;
-            ownerWithin: z.ZodOptional<z.ZodString>;
-            requesterWithin: z.ZodOptional<z.ZodString>;
             status: z.ZodOptional<z.ZodArray<z.ZodEnum<{
                 accepted: "accepted";
                 active: "active";
@@ -299,7 +290,6 @@ export declare const WorkContracts: {
         writes: boolean;
     };
     work_update: {
-        level: "organization" | "report" | "team";
         description: string;
         input: z.ZodObject<{
             ticketID: z.ZodOptional<z.ZodString>;
@@ -357,7 +347,6 @@ export declare const WorkContracts: {
         writes: boolean;
     };
     work_submit: {
-        level: "organization" | "report" | "team";
         description: string;
         input: z.ZodObject<{
             ticketID: z.ZodString;
@@ -369,14 +358,12 @@ export declare const WorkContracts: {
         writes: boolean;
     };
     work_answer: {
-        level: "organization" | "report" | "team";
         description: string;
         input: z.ZodObject<{
             askID: z.ZodString;
             ticketID: z.ZodOptional<z.ZodString>;
-            answers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            answers: z.ZodRecord<z.ZodString, z.ZodString>;
             note: z.ZodOptional<z.ZodString>;
-            raise: z.ZodOptional<z.ZodLiteral<true>>;
         }, z.core.$strict>;
         output: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
         writes: boolean;

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

@@ -64,32 +64,30 @@ const ticketID = z.strictObject({ ticketID: ID });
 const mutation = ticketID.extend({ expectedRevision: Revision.optional() });
 /** Every supplied filter must match; the page limit applies after them. */
 const filter = z.strictObject({
-    ownerID: ID.optional(),
+    ownerID: OneOrMany.optional(),
     requesterID: OneOrMany.optional(),
     waitsOnActorID: ID.optional(),
-    ownerWithin: ID.optional(),
-    requesterWithin: ID.optional(),
     status: z.array(WorkStatus).min(1).optional(),
     updatedSince: z.iso.datetime().optional(),
     order: z.literal("recent").optional(),
 });
 export const WorkContracts = {
-    work_create: contract("report", "Create Work; the caller requests it and owns it unless ownerID names another Actor.", z.strictObject({
+    work_create: contract("Create Work; the caller requests it and owns it unless ownerID names another Actor.", z.strictObject({
         title: Title,
         goal: Text.optional(),
         ownerID: ID.optional(),
         links: Links.optional(),
         waitsOn: WaitsOn.optional(),
     }), Work, true),
-    work_get: contract("report", "Read Work with all its asks, by ticketID, or by askID: the Work an ask (or the current submission) is on, or an older ask with no Work alone. History only when asked, for the Work and each ask.", z
+    work_get: contract("Read Work with all its asks, by ticketID, or by askID: the Work an ask (or the current submission) is on, or an older ask with no Work alone. History only when asked, for the Work and each ask.", z
         .strictObject({
         ticketID: ID.optional(),
         askID: ID.optional(),
         history: z.boolean().default(false),
     })
         .refine((v) => (v.ticketID === undefined) !== (v.askID === undefined), { error: "name exactly one of ticketID or askID" }), z.union([Work, Form])),
-    work_list: contract("report", "List shared work matching every filter, by update order or most recent first; each item carries its open asks.", filter.extend({ after: Next.optional(), limit: Limit }), listOf(Work)),
-    work_update: contract("report", "One of three forms, each in a call of its own. Edits: the owner edits title, progress, open/active status, links and waitsOn (null clears it); the requester edits goal or owner, or cancels, with expectedRevision. Progress is a paragraph, then optionally a Markdown task list of steps: `- [x]` done, `- [ ]` not done. {ticketID, ask}: the owner asks on its Work and gets the ask back; mark approval when the answer can't be undone. {close}: the asker resolves or cancels its open ask, recording why.", z
+    work_list: contract("List shared work matching every filter, by update order or most recent first; each item carries its open asks.", filter.extend({ after: Next.optional(), limit: Limit }), listOf(Work)),
+    work_update: contract("One of three forms, each in a call of its own. Edits: the owner edits title, progress, open/active status, links and waitsOn (null clears it); the requester edits goal or owner, or cancels, with expectedRevision. Progress is a paragraph, then optionally a Markdown task list of steps: `- [x]` done, `- [ ]` not done. {ticketID, ask}: the owner asks on its Work and gets the ask back; mark approval when the answer can't be undone. {close}: the asker resolves or cancels its open ask, recording why.", z
         .strictObject({
         ticketID: ID.optional(),
         expectedRevision: Revision.optional(),
@@ -117,14 +115,11 @@ export const WorkContracts = {
     }, {
         error: "use one form per call: edits with ticketID; {ticketID, ask} and nothing else; or {close} and nothing else",
     }), z.union([Work, Form]), true),
-    work_submit: contract("report", "Owner submits the result; Work the owner requested itself completes, other Work waits for its requester's answer.", mutation.extend({ result: Text, evidence: z.array(Text).max(100).default([]) }), Work, true),
-    work_answer: contract("team", "Answer an ask by its askID: answers for its fields and an optional note. Any Actor answers; only the asker's managers answer an approval; the first answer resolves the ask unless it collects. raise: true, by the Actor the ask is routed to, passes it one manager up. Or answer the Work's current submission by its ID: answers {verdict: accepted or changes_requested}, the note as the comment, which requesting changes needs; only its requester answers, or its nearest open manager once it is closed.", z
-        .strictObject({
+    work_submit: contract("Owner submits the result; Work the owner requested itself completes, other Work waits for its requester's answer.", mutation.extend({ result: Text, evidence: z.array(Text).max(100).default([]) }), Work, true),
+    work_answer: contract("Answer an ask by its askID: answers for its fields and an optional note. Any Actor answers; the first answer resolves the ask unless it collects. An approval is answered only by the Actor it is routed to, never its asker: the Work's requester, or the person when the asker requested the Work itself or once the requester is closed. Or answer the Work's current submission by its ID: answers {verdict: accepted or changes_requested}, the note as the comment, which requesting changes needs; only its requester answers, or the person once it is closed.", z.strictObject({
         askID: ID,
         ticketID: ID.optional(),
-        answers: z.record(z.string(), z.string().max(20000)).optional(),
+        answers: z.record(z.string(), z.string().max(20000)),
         note: Text.optional(),
-        raise: z.literal(true).optional(),
-    })
-        .refine((v) => v.raise ? v.answers === undefined && v.note === undefined : v.answers !== undefined, { error: "give answers, or raise: true with no answers or note" }), z.union([Work, Form]), true),
+    }), z.union([Work, Form]), true),
 };

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

@@ -24,7 +24,7 @@ export function createMcpServer(clients, purpose) {
         work_submit: bind(WorkContracts.work_submit, (input) => work.submit(input)),
         work_answer: bind(WorkContracts.work_answer, (input) => work.answer(input)),
     };
-    const server = new Server({ name: `agentic-workspace-${purpose}`, version: "0.0.1" }, { capabilities: { tools: {} } });
+    const server = new Server({ name: `agentic-workspace-${purpose}`, version: "0.0.2" }, { capabilities: { tools: {} } });
     server.setRequestHandler(ListToolsRequestSchema, async () => {
         try {
             actors.get();

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

@@ -14,8 +14,6 @@ export interface RecordTable<T, C extends string = never> {
     get(id: string): Snapshot<T> | undefined;
     /** Current snapshots in cursor order whose every filtered column holds one of its values. */
     where(filter: Filter<C>): Snapshot<T>[];
-    /** The distinct values one indexed column holds among the rows a filter keeps. */
-    values(column: C, filter: Filter<C>): string[];
     history(id: string): HistoryEntry[];
     head(): number;
     /** Called inside transaction; expectedRevision is absent only for insertion. */
@@ -25,8 +23,7 @@ export interface WorkspaceStore {
     messages: RecordTable<MessageState, "sender" | "recipient">;
     /** A stored `blocked` status is indexed as `active`; submission is the current submission's ID. */
     work: RecordTable<WorkState, "owner" | "requester" | "status" | "submission">;
-    /** route is where an ask's route starts: its last raiser, else its asker. */
-    forms: RecordTable<FormState, "requester" | "status" | "work" | "route">;
+    forms: RecordTable<FormState, "requester" | "status" | "work">;
     /** Callback is synchronous; state checks and writes share one transaction. */
     transaction<T>(callback: () => T): T;
     close(): void;

package/node_modules/@uniac/agentic-workspace/dist/src/persistence/sqlite.js

@@ -45,8 +45,8 @@ const UPGRADES = [
         }
     },
     // Version 4: indexed columns for the fields lists select by. A stored `blocked` is indexed as
-    // `active`, the status Work reads it as, and an ask's route starts at its last raiser, else its
-    // asker.
+    // `active`, the status Work reads it as. Asks' `route` is unread; its (status, route) index serves
+    // status selects.
     // A party's index leads with the party and then status, so a party's Work or asks in some
     // statuses is one index range whatever the planner knows of the data.
     (db) => db.exec(`
@@ -128,11 +128,6 @@ export function openSqlite(path) {
                 throw new Error(`${name} has no indexed column ${column}`);
             return column;
         };
-        /** The index each column leads, so a column's distinct values come from its own index. */
-        const leading = new Map(db
-            .prepare("SELECT (SELECT name FROM pragma_index_info(l.name) WHERE seqno=0) AS lead, l.name FROM pragma_index_list(?) l")
-            .all(name)
-            .map((row) => [String(row.lead), String(row.name)]));
         const statements = new Map();
         const prepared = (sql) => {
             const statement = statements.get(sql) ?? db.prepare(sql);
@@ -174,14 +169,6 @@ export function openSqlite(path) {
                     .all(...values)
                     .map(decode);
             },
-            values(column, filter) {
-                const { sql, values } = matching(filter);
-                const selected = indexed(column);
-                const index = leading.get(selected);
-                return prepared(`SELECT DISTINCT m.${selected} AS value FROM ${name} m${index === undefined ? "" : ` INDEXED BY ${index}`} WHERE m.${selected} IS NOT NULL${sql}`)
-                    .all(...values)
-                    .map((row) => String(row.value));
-            },
             save(id, data, event, expectedRevision) {
                 const current = get(id);
                 requireThat(current ? current.revision === expectedRevision : expectedRevision === undefined, "conflict", "record revision changed");

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

@@ -27,13 +27,6 @@ export declare function traverse<T, C extends string>(actors: ActorsClient, tabl
     limit: number;
     order?: "recent" | undefined;
 }, scope: unknown, indexed: () => Filter<C>, visible: (row: Snapshot<T>) => boolean, mentions: (row: T) => (string | undefined)[]): List<Published<T>>;
-/**
- * A filter whose subtree criteria are resolved to the Actors each party column holds among the
- * rows the filter keeps: one membership read per Actor rather than per row.
- */
-export declare function subtrees<C extends string>(actors: ActorsClient, table: RecordTable<unknown, C>, filter: Filter<C>, within: {
-    [K in C]?: string | undefined;
-}): Filter<C>;
 /** Names of the Actors a page mentions; Actors the caller can't see are left out. */
 export declare function names(actors: ActorsClient, ids: Iterable<string | undefined>): {
     [k: string]: {

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

@@ -18,7 +18,6 @@ export function readThrough(table, read) {
             return row && read(row);
         },
         where: (filter) => table.where(filter).map(read),
-        values: (column, filter) => table.values(column, filter),
         history: (id) => table.history(id),
         head: () => table.head(),
         save: (id, data, event, expectedRevision) => table.save(id, data, event, expectedRevision),
@@ -71,19 +70,6 @@ export function traverse(actors, table, query, scope, indexed, visible, mentions
         actors: names(actors, items.flatMap(mentions)),
     };
 }
-/**
- * A filter whose subtree criteria are resolved to the Actors each party column holds among the
- * rows the filter keeps: one membership read per Actor rather than per row.
- */
-export function subtrees(actors, table, filter, within) {
-    const resolved = { ...filter };
-    for (const [column, anchor] of Object.entries(within))
-        if (anchor !== undefined)
-            resolved[column] = table
-                .values(column, filter)
-                .filter((actorID) => actors.within(actorID, anchor));
-    return resolved;
-}
 /** Names of the Actors a page mentions; Actors the caller can't see are left out. */
 export function names(actors, ids) {
     const found = [];

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

@@ -1,10 +1,11 @@
-import { type ActorsClient } from "../actors/index.js";
-import { type AskClose, type AskInput, type Field, type Form, type FormState, type Output } from "../contracts/index.js";
+import { type ActorsClient, standIn } from "../actors/index.js";
+import { type AskClose, type AskInput, type Field, type Form, type FormState, type Output, type WorkState } from "../contracts/index.js";
 import type { RecordTable, Snapshot } from "../persistence/index.js";
-type Asks = RecordTable<FormState, "requester" | "status" | "work" | "route">;
+type Asks = RecordTable<FormState, "requester" | "status" | "work">;
+type Requesters = Pick<RecordTable<WorkState>, "get">;
 /**
- * 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.
+ * Asks as this package reads them: a `cause` stored before asks lived on Work, and the `raises`
+ * earlier builds stored, are left unread.
  */
 export declare function asksAsRead(forms: Asks): Asks;
 export declare function checkFields(fields: Field[]): void;
@@ -54,10 +55,6 @@ export declare function asksOn(forms: Asks, ticketIDs: string[], options: {
         note?: string | undefined;
         at: string;
     }>;
-    raises: {
-        actorID: string;
-        at: string;
-    }[];
     resolution?: {
         text: string;
         reason?: "cancelled" | "reassigned" | "submitted" | undefined;
@@ -66,16 +63,20 @@ export declare function asksOn(forms: Asks, ticketIDs: string[], options: {
 }[]>;
 /** A new ask on a Work, by its owner, which the caller has checked may ask on it. */
 export declare function created(forms: Asks, caller: string, ticketID: string, input: Output<typeof AskInput>): Form;
-/** The asker, or its nearest open manager once it is closed, resolves or cancels its open ask. */
+/** The asker, or the person once the asker is closed, resolves or cancels its open ask. */
 export declare function closed(actors: ActorsClient, forms: Asks, request: Output<typeof AskClose>, caller: string): Form;
-/** A complete answer set by one responder; only the asker's strict managers answer an approval. */
-export declare function responded(actors: ActorsClient, forms: Asks, row: Snapshot<FormState>, caller: string, answers: Record<string, string>, note: string | undefined): Form;
-/** The Actor an open ask is routed to passes it one manager up; a raise never resolves it. */
-export declare function raised(actors: ActorsClient, forms: Asks, row: Snapshot<FormState>, caller: string): Form;
-/** The Actor an open ask is routed to, from its last raiser or else its asker; null for none. */
-export declare function routeOf(actors: ActorsClient, row: FormState): string | null;
-/** The route origins of open asks, among those the filter keeps, that route to an Actor. */
-export declare function routedTo(actors: ActorsClient, forms: Asks, actorID: string, requester: string[] | undefined): string[];
+/**
+ * A complete answer set by one responder; only the Actor an approval is routed to answers it, never
+ * its asker.
+ */
+export declare function responded(actors: ActorsClient, forms: Asks, work: Requesters, row: Snapshot<FormState>, caller: string, answers: Record<string, string>, note: string | undefined): Form;
+/**
+ * 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 declare function router(actors: ActorsClient, work: Requesters, through?: typeof standIn): (row: FormState) => string;
 declare const CANCELLED: {
     readonly submitted: "Cancelled with the Work's submission.";
     readonly cancelled: "Cancelled with the Work's cancellation.";
@@ -83,6 +84,6 @@ declare const CANCELLED: {
 };
 /** Cancels the open asks on a Work whose asker no longer moves it. */
 export declare function cancelOpen(forms: Asks, ticketID: string, actorID: string, at: string, reason: keyof typeof CANCELLED): void;
-/** The Actors an ask mentions: its asker, responders and raisers. */
+/** The Actors an ask mentions: its asker and responders. */
 export declare const mentioned: (row: FormState) => string[];
 export {};

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

@@ -1,19 +1,19 @@
 /**
- * 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.
+ * 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 { routedStandIn, standIn } from "../actors/index.js";
+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 is left unread, and
- * an ask stored then has no raises.
+ * 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, ...ask } = row;
-        return { ...ask, raises: ask.raises ?? [] };
+        const { cause: _cause, raises: _raises, ...ask } = row;
+        return ask;
     });
 }
 export function checkFields(fields) {
@@ -55,10 +55,9 @@ export function created(forms, caller, ticketID, input) {
         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. */
+/** 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");
@@ -66,10 +65,13 @@ export function closed(actors, forms, request, caller) {
     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) {
+/**
+ * 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 && actors.within(row.requesterID, caller)), "forbidden", "only the asker's managers answer an approval");
+    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) {
@@ -87,32 +89,32 @@ export function responded(actors, forms, row, caller, answers, note) {
         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.
+ * 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.
  */
-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;
+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;
+    };
 }
-/** 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);
+/** 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.",
@@ -126,9 +128,5 @@ export function cancelOpen(forms, ticketID, actorID, at, reason) {
         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),
-];
+/** 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.js

@@ -1,14 +1,14 @@
 /** 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 { activeActor, routedStandIn, 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";
+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 its nearest open manager once it is closed. */
+    /** 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) {
@@ -58,7 +58,6 @@ export function createWork(actors, store) {
     }
     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");
@@ -68,7 +67,6 @@ export function createWork(actors, store) {
     }
     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");
@@ -124,11 +122,11 @@ export function createWork(actors, store) {
             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],
+            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,
-            }, { owner: query.ownerWithin, requester: query.requesterWithin }), (row) => (query.waitsOnActorID === undefined || waitedOn(row) === query.waitsOnActorID) &&
+            }), (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) ?? [] }));
@@ -180,27 +178,23 @@ export function createWork(actors, store) {
                 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);
+                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;
-            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);
+            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);
         },
     };
 }