@agentorg/cli 0.0.2 → 0.0.4

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

@@ -1,99 +0,0 @@
-/** Immutable direct messages, each in its pair's conversation and the one Message order; reads are open. */
-import { createHash, randomUUID } from "node:crypto";
-import { activeActor } from "../actors/index.js";
-import { MessageContracts, parse, requireThat, } from "../contracts/index.js";
-import { names, now, position, token } from "../records.js";
-/** One direct conversation per pair; the ID is opaque to clients. */
-const conversationOf = (a, b) => createHash("sha256")
-    .update(JSON.stringify(["direct", ...[a, b].sort()]))
-    .digest("base64url")
-    .slice(0, 22);
-const message = (row) => ({
-    messageID: row.messageID,
-    conversationID: conversationOf(row.senderID, row.recipientID),
-    senderID: row.senderID,
-    recipientID: row.recipientID,
-    text: row.text,
-    createdAt: row.createdAt,
-    seq: row.cursor,
-});
-export function createMessages(actors, store) {
-    const table = store.messages;
-    const page = (items, next, older) => ({
-        items: items.map(message),
-        next,
-        older,
-        actors: names(actors, items.flatMap((row) => [row.senderID, row.recipientID])),
-    });
-    /** An Actor's conversations, newest first, each as its latest message. */
-    function conversations(of, after, limit) {
-        const scope = ["messages", "of", of];
-        const head = table.head();
-        // Keyed by counterparty; a self message stored before self messages were refused is the
-        // Actor's conversation with itself.
-        const latest = new Map();
-        for (const row of [...table.where({ sender: [of] }), ...table.where({ recipient: [of] })]) {
-            const peer = row.senderID === of ? row.recipientID : row.senderID;
-            if (row.cursor <= head && row.cursor > (latest.get(peer)?.cursor ?? 0))
-                latest.set(peer, row);
-        }
-        const bound = after === undefined ? head + 1 : position(after, scope);
-        const rows = [...latest.values()]
-            .filter((row) => row.cursor < bound)
-            .sort((left, right) => right.cursor - left.cursor);
-        const items = rows.slice(0, limit);
-        const last = items.at(-1);
-        return page(items, last && rows.length > items.length ? token(scope, last.cursor) : null, null);
-    }
-    return {
-        send(input) {
-            const request = parse(MessageContracts.message_send.input, input);
-            const caller = actors.get().actorID;
-            requireThat(request.recipientID !== caller, "invalid_input", "an Actor doesn't message itself");
-            activeActor(actors, request.recipientID);
-            return store.transaction(() => {
-                const at = now();
-                const messageID = randomUUID();
-                return message(table.save(messageID, { messageID, senderID: caller, ...request, createdAt: at }, { actorID: caller, at, action: "sent", detail: request }));
-            });
-        },
-        get(input) {
-            const request = parse(MessageContracts.message_get.input, input);
-            actors.get();
-            const row = table.get(request.messageID);
-            requireThat(row, "not_found", "record not found");
-            return message(row);
-        },
-        list(input) {
-            const query = parse(MessageContracts.message_list.input, input);
-            const caller = actors.get().actorID;
-            const { before, after, limit } = query;
-            // The contract's refinements leave `of` with only a `next` position, and name one selector.
-            if (query.of !== undefined)
-                return conversations(query.of, after, limit);
-            const pair = (query.between ?? [caller, query.counterpartyID]).toSorted();
-            const scope = ["messages", "between", pair];
-            const head = table.head();
-            // The pair's parties also match either one's self messages stored before they were refused;
-            // only a self pair keeps them.
-            const rows = table
-                .where({ sender: pair, recipient: pair })
-                .filter((row) => row.cursor <= head && (pair[0] === pair[1] || row.senderID !== row.recipientID));
-            let items;
-            if (before !== undefined) {
-                const bound = before === "latest" ? head + 1 : position(before, scope, "before");
-                items = rows.filter((row) => row.cursor < bound).slice(-limit);
-            }
-            else {
-                const bound = after === undefined ? 0 : typeof after === "number" ? after : position(after, scope);
-                requireThat(bound <= head, "invalid_input", "position is beyond the module head");
-                items = rows.filter((row) => row.cursor > bound).slice(0, limit);
-            }
-            const first = items[0];
-            const last = items.at(-1);
-            return page(items, last && last.cursor < (rows.at(-1)?.cursor ?? 0) ? token(scope, last.cursor) : null, first && first.cursor > (rows[0]?.cursor ?? 0)
-                ? token(scope, first.cursor, "before")
-                : null);
-        },
-    };
-}

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

@@ -1,31 +0,0 @@
-/** Transactional snapshots and retained module history; SQLite is the v1 implementation. */
-import type { FormState, HistoryEntry, MessageState, WorkState } from "../contracts/index.js";
-/** updatedAt is the time of the event that wrote the current revision. */
-export type Snapshot<T> = T & {
-    revision: number;
-    cursor: number;
-    updatedAt: string;
-};
-/** Indexed columns, each kept to one of its listed values; an absent column keeps every row. */
-export type Filter<C extends string> = {
-    [K in C]?: readonly string[] | undefined;
-};
-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>[];
-    history(id: string): HistoryEntry[];
-    head(): number;
-    /** Called inside transaction; expectedRevision is absent only for insertion. */
-    save(id: string, data: T, event: Pick<HistoryEntry, "actorID" | "at" | "action" | "detail">, expectedRevision?: number): Snapshot<T>;
-}
-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">;
-    forms: RecordTable<FormState, "requester" | "status" | "work">;
-    /** Callback is synchronous; state checks and writes share one transaction. */
-    transaction<T>(callback: () => T): T;
-    close(): void;
-}
-export { openSqlite } from "./sqlite.js";

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

@@ -1 +0,0 @@
-export { openSqlite } from "./sqlite.js";

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

@@ -1,3 +0,0 @@
-import type { WorkspaceStore } from "./index.js";
-/** One SQLite database; module tables and their history are committed together. */
-export declare function openSqlite(path: string): WorkspaceStore;

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

@@ -1,192 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-import { requireThat } from "../contracts/common.js";
-/** A version 3 database also holds the status and status_history tables, which stay unread. */
-const MODULES = ["messages", "work", "forms"];
-/**
- * Step N upgrades a database at user_version N to N + 1, and each step's comment names the version
- * it produces. 0 is a database from before storage versions, or a new one, where the data steps
- * find no rows. Snapshots change in place and history keeps every original event.
- */
-const UPGRADES = [
-    // Version 1: Messages link no Work.
-    (db) => db.exec("UPDATE messages SET data=json_remove(data,'$.workID')"),
-    // Version 2: Work has a title from its goal and links, and accepted Work was completed when its
-    // review accepted it.
-    (db) => {
-        const update = db.prepare("UPDATE work SET data=? WHERE id=?");
-        for (const { id, data } of db.prepare("SELECT id,data FROM work").all()) {
-            const work = JSON.parse(String(data));
-            const completedAt = work.status === "accepted" ? work.review?.at : undefined;
-            update.run(JSON.stringify({ ...work, title: headline(work.goal), links: [], completedAt }), String(id));
-        }
-    },
-    // Version 3: asks have a title from their first field's label, name no respondents and stay open
-    // until their asker closes them, as Forms did before; options carry detail, and each response the
-    // time of its last answer.
-    (db) => {
-        const events = db.prepare("SELECT event FROM forms_history WHERE id=? ORDER BY revision");
-        const update = db.prepare("UPDATE forms SET data=? WHERE id=?");
-        for (const { id, data } of db.prepare("SELECT id,data FROM forms").all()) {
-            const { respondentIDs: _respondents, ...form } = JSON.parse(String(data));
-            const answered = new Map();
-            for (const row of events.all(String(id))) {
-                const event = JSON.parse(String(row.event));
-                if (event.action === "responded")
-                    answered.set(event.actorID, event.at);
-            }
-            const fields = form.fields.map((field) => field.options ? { ...field, options: field.options.map((value) => ({ value })) } : field);
-            const responses = Object.fromEntries(Object.entries(form.responses).map(([actorID, answers]) => [
-                actorID,
-                { answers, at: answered.get(actorID) },
-            ]));
-            const title = headline(form.fields[0].label);
-            const ask = { ...form, title, links: [], approval: false, collect: true, fields, responses };
-            update.run(JSON.stringify(ask), String(id));
-        }
-    },
-    // Version 4: indexed columns for the fields lists select by. A stored `blocked` is indexed as
-    // `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(`
-      ALTER TABLE messages ADD COLUMN sender TEXT GENERATED ALWAYS AS (json_extract(data,'$.senderID')) VIRTUAL;
-      ALTER TABLE messages ADD COLUMN recipient TEXT GENERATED ALWAYS AS (json_extract(data,'$.recipientID')) VIRTUAL;
-      ALTER TABLE work ADD COLUMN owner TEXT GENERATED ALWAYS AS (json_extract(data,'$.ownerID')) VIRTUAL;
-      ALTER TABLE work ADD COLUMN requester TEXT GENERATED ALWAYS AS (json_extract(data,'$.requesterID')) VIRTUAL;
-      ALTER TABLE work ADD COLUMN status TEXT GENERATED ALWAYS AS (CASE json_extract(data,'$.status') WHEN 'blocked' THEN 'active' ELSE json_extract(data,'$.status') END) VIRTUAL;
-      ALTER TABLE work ADD COLUMN submission TEXT GENERATED ALWAYS AS (json_extract(data,'$.submission.submissionID')) VIRTUAL;
-      ALTER TABLE forms ADD COLUMN requester TEXT GENERATED ALWAYS AS (json_extract(data,'$.requesterID')) VIRTUAL;
-      ALTER TABLE forms ADD COLUMN status TEXT GENERATED ALWAYS AS (json_extract(data,'$.status')) VIRTUAL;
-      ALTER TABLE forms ADD COLUMN work TEXT GENERATED ALWAYS AS (json_extract(data,'$.workID')) VIRTUAL;
-      ALTER TABLE forms ADD COLUMN route TEXT GENERATED ALWAYS AS (COALESCE(json_extract(data,'$.raises[#-1].actorID'),json_extract(data,'$.requesterID'))) VIRTUAL;
-      CREATE INDEX messages_sender ON messages(sender);
-      CREATE INDEX messages_recipient ON messages(recipient);
-      CREATE INDEX work_owner ON work(owner,status);
-      CREATE INDEX work_requester ON work(requester,status);
-      CREATE INDEX work_status ON work(status);
-      CREATE INDEX work_submission ON work(submission);
-      CREATE INDEX forms_requester ON forms(requester,status);
-      CREATE INDEX forms_work ON forms(work,status);
-      CREATE INDEX forms_route ON forms(status,route);
-    `),
-];
-/** A title from existing text: its first line, cut at a word boundary to 120 characters. */
-function headline(text) {
-    const line = text.split(/\r?\n/, 1)[0]?.trim() ?? "";
-    if (line.length <= 120)
-        return line;
-    const space = line.slice(0, 120).search(/\s\S*$/);
-    return `${(space > 0 ? line.slice(0, space) : line.slice(0, 119)).trimEnd()}…`;
-}
-/** One SQLite database; module tables and their history are committed together. */
-export function openSqlite(path) {
-    const db = new DatabaseSync(path);
-    db.exec("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000;");
-    try {
-        transaction(() => {
-            const existing = db.prepare("SELECT 1 FROM sqlite_schema WHERE name='messages'").get();
-            const version = existing ? Number(db.prepare("PRAGMA user_version").get()?.user_version) : 0;
-            if (version > UPGRADES.length)
-                throw new Error(`workspace database version ${version} is newer than this package`);
-            for (const name of MODULES) {
-                db.exec(`
-          CREATE TABLE IF NOT EXISTS ${name} (id TEXT PRIMARY KEY, revision INTEGER NOT NULL, cursor INTEGER NOT NULL UNIQUE, data TEXT NOT NULL);
-          CREATE TABLE IF NOT EXISTS ${name}_history (id TEXT NOT NULL, revision INTEGER NOT NULL, cursor INTEGER NOT NULL UNIQUE, event TEXT NOT NULL, PRIMARY KEY (id, revision));
-        `);
-            }
-            for (const upgrade of UPGRADES.slice(version))
-                upgrade(db);
-            db.exec(`PRAGMA user_version=${UPGRADES.length}`);
-        });
-    }
-    catch (error) {
-        db.close();
-        throw error;
-    }
-    function transaction(callback) {
-        db.exec("BEGIN IMMEDIATE");
-        try {
-            const value = callback();
-            db.exec("COMMIT");
-            return value;
-        }
-        catch (error) {
-            db.exec("ROLLBACK");
-            throw error;
-        }
-    }
-    function table(name) {
-        const current = `SELECT m.data,m.revision,m.cursor,json_extract(h.event,'$.at') AS updated_at FROM ${name} m JOIN ${name}_history h ON h.id=m.id AND h.revision=m.revision`;
-        const select = db.prepare(`${current} WHERE m.id=?`);
-        const columns = new Set(db
-            .prepare("SELECT name FROM pragma_table_xinfo(?) WHERE hidden IN (2,3)")
-            .all(name)
-            .map((row) => String(row.name)));
-        const indexed = (column) => {
-            if (!columns.has(column))
-                throw new Error(`${name} has no indexed column ${column}`);
-            return column;
-        };
-        const statements = new Map();
-        const prepared = (sql) => {
-            const statement = statements.get(sql) ?? db.prepare(sql);
-            statements.set(sql, statement);
-            return statement;
-        };
-        /** Each filtered column's values are bound as one JSON array. */
-        const matching = (filter) => {
-            const entries = Object.entries(filter).filter((entry) => entry[1] !== undefined);
-            return {
-                sql: entries
-                    .map(([column]) => ` AND m.${indexed(column)} IN (SELECT value FROM json_each(?))`)
-                    .join(""),
-                values: entries.map(([, values]) => JSON.stringify(values)),
-            };
-        };
-        const events = db.prepare(`SELECT event FROM ${name}_history WHERE id=? ORDER BY revision ASC`);
-        const head = db.prepare(`SELECT COALESCE(MAX(cursor),0) AS head FROM ${name}_history`);
-        const put = db.prepare(`INSERT INTO ${name}(id,data,revision,cursor) VALUES(?,?,?,?) ON CONFLICT(id) DO UPDATE SET data=excluded.data,revision=excluded.revision,cursor=excluded.cursor`);
-        const append = db.prepare(`INSERT INTO ${name}_history(id,revision,cursor,event) VALUES(?,?,?,?)`);
-        const decode = (row) => ({
-            ...JSON.parse(String(row.data)),
-            revision: Number(row.revision),
-            cursor: Number(row.cursor),
-            updatedAt: String(row.updated_at),
-        });
-        const get = (id) => {
-            const row = select.get(id);
-            return row ? decode(row) : undefined;
-        };
-        const latest = () => Number(head.get()?.head ?? 0);
-        return {
-            get,
-            history: (id) => events.all(id).map((row) => JSON.parse(String(row.event))),
-            head: latest,
-            where(filter) {
-                const { sql, values } = matching(filter);
-                return prepared(`${current} WHERE 1${sql} ORDER BY m.cursor ASC`)
-                    .all(...values)
-                    .map(decode);
-            },
-            save(id, data, event, expectedRevision) {
-                const current = get(id);
-                requireThat(current ? current.revision === expectedRevision : expectedRevision === undefined, "conflict", "record revision changed");
-                const revision = (current?.revision ?? 0) + 1;
-                const cursor = latest() + 1;
-                requireThat(Number.isSafeInteger(cursor), "conflict", "cursor capacity reached");
-                const entry = { ...event, revision, cursor };
-                put.run(id, JSON.stringify(data), revision, cursor);
-                append.run(id, revision, cursor, JSON.stringify(entry));
-                return { ...data, revision, cursor, updatedAt: event.at };
-            },
-        };
-    }
-    return {
-        messages: table("messages"),
-        work: table("work"),
-        forms: table("forms"),
-        transaction,
-        close: () => db.close(),
-    };
-}

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

@@ -1,35 +0,0 @@
-import type { ActorsClient } from "./actors/index.js";
-import { type HistoryEntry, type List } from "./contracts/common.js";
-import type { Filter, RecordTable, Snapshot } from "./persistence/index.js";
-export declare const now: () => string;
-export type Published<T> = T & {
-    revision: number;
-    updatedAt: string;
-    history?: HistoryEntry[];
-};
-/** The public record: the cursor stays internal; lists and writes carry no history. */
-export declare function published<T>({ cursor: _cursor, ...record }: Snapshot<T>): Published<T>;
-export declare function recorded<T, C extends string>(table: RecordTable<T, C>, id: string, history?: boolean): Published<T>;
-/** A table whose reads pass each current snapshot through `read`, as the module reads it. */
-export declare function readThrough<T, C extends string>(table: RecordTable<T, C>, read: (row: Snapshot<T>) => Snapshot<T>): RecordTable<T, C>;
-/** The module state alone, for writing the next revision. */
-export declare function stateOf<T>(row: Published<T>): T;
-/** An opaque position naming its read, filter and direction. */
-export declare function token(scope: unknown, position: number, direction?: "after" | "before"): string;
-export declare function position(value: string, scope: unknown, direction?: "after" | "before"): number;
-/**
- * Current upserts in update order, or most recent first, after every filter. Rows are read up to
- * the module head captured first, and the indexed filter is selected after it, so a write
- * committed during the read waits for the next page.
- */
-export declare function traverse<T, C extends string>(actors: ActorsClient, table: RecordTable<T, C>, query: {
-    after?: string | undefined;
-    limit: number;
-    order?: "recent" | undefined;
-}, scope: unknown, indexed: () => Filter<C>, visible: (row: Snapshot<T>) => boolean, mentions: (row: T) => (string | undefined)[]): List<Published<T>>;
-/** 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]: {
-        name: string;
-    };
-};

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

@@ -1,88 +0,0 @@
-import { createHash } from "node:crypto";
-import { requireThat, WorkspaceError } from "./contracts/common.js";
-export const now = () => new Date().toISOString();
-/** The public record: the cursor stays internal; lists and writes carry no history. */
-export function published({ cursor: _cursor, ...record }) {
-    return record;
-}
-export function recorded(table, id, history = false) {
-    const item = table.get(id);
-    requireThat(item, "not_found", "record not found");
-    return history ? { ...published(item), history: table.history(id) } : published(item);
-}
-/** A table whose reads pass each current snapshot through `read`, as the module reads it. */
-export function readThrough(table, read) {
-    return {
-        get: (id) => {
-            const row = table.get(id);
-            return row && read(row);
-        },
-        where: (filter) => table.where(filter).map(read),
-        history: (id) => table.history(id),
-        head: () => table.head(),
-        save: (id, data, event, expectedRevision) => table.save(id, data, event, expectedRevision),
-    };
-}
-/** The module state alone, for writing the next revision. */
-export function stateOf(row) {
-    const { revision: _revision, updatedAt: _updatedAt, history: _history, ...state } = row;
-    return state;
-}
-const digest = (scope) => createHash("sha256").update(JSON.stringify(scope)).digest("base64url").slice(0, 16);
-/** An opaque position naming its read, filter and direction. */
-export function token(scope, position, direction = "after") {
-    return Buffer.from(JSON.stringify([digest(scope), direction, position])).toString("base64url");
-}
-export function position(value, scope, direction = "after") {
-    let decoded;
-    try {
-        decoded = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
-    }
-    catch {
-        decoded = undefined;
-    }
-    const [read, way, at] = Array.isArray(decoded) ? decoded : [];
-    requireThat(read === digest(scope) && way === direction && Number.isSafeInteger(at) && at >= 0, "invalid_input", "position does not continue this read");
-    return at;
-}
-/**
- * Current upserts in update order, or most recent first, after every filter. Rows are read up to
- * the module head captured first, and the indexed filter is selected after it, so a write
- * committed during the read waits for the next page.
- */
-export function traverse(actors, table, query, scope, indexed, visible, mentions) {
-    const recent = query.order === "recent";
-    const head = table.head();
-    const bound = query.after === undefined ? undefined : position(query.after, scope);
-    requireThat(bound === undefined || bound <= head, "invalid_input", "position is beyond the module head");
-    const rows = table
-        .where(indexed())
-        .filter((row) => row.cursor <= head &&
-        (bound === undefined || (recent ? row.cursor < bound : row.cursor > bound)) &&
-        visible(row));
-    if (recent)
-        rows.reverse();
-    const items = rows.slice(0, query.limit);
-    const last = items.at(-1);
-    return {
-        items: items.map(published),
-        next: last && rows.length > items.length ? token(scope, last.cursor) : null,
-        actors: names(actors, items.flatMap(mentions)),
-    };
-}
-/** Names of the Actors a page mentions; Actors the caller can't see are left out. */
-export function names(actors, ids) {
-    const found = [];
-    for (const actorID of new Set(ids)) {
-        if (actorID === undefined)
-            continue;
-        try {
-            found.push([actorID, { name: actors.get({ actorID }).name }]);
-        }
-        catch (error) {
-            if (!(error instanceof WorkspaceError && error.code === "not_found"))
-                throw error;
-        }
-    }
-    return Object.fromEntries(found);
-}

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

@@ -1,89 +0,0 @@
-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">;
-type Requesters = Pick<RecordTable<WorkState>, "get">;
-/**
- * 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;
-/**
- * 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 declare function asksOn(forms: Asks, ticketIDs: string[], options: {
-    open: boolean;
-    history: boolean;
-}): Map<string, {
-    revision: number;
-    updatedAt: string;
-    history?: {
-        revision: number;
-        cursor: number;
-        actorID: string;
-        at: string;
-        action: string;
-        detail: Record<string, unknown>;
-    }[] | undefined;
-    formID: string;
-    requesterID: string;
-    title: string;
-    context?: string | undefined;
-    links: {
-        label?: string | undefined;
-        url: string;
-    }[];
-    workID?: string | undefined;
-    approval: boolean;
-    collect: boolean;
-    fields: {
-        name: string;
-        label: string;
-        required: boolean;
-        options?: {
-            value: string;
-            detail?: string | undefined;
-        }[] | undefined;
-        recommended?: string | undefined;
-    }[];
-    status: "cancelled" | "open" | "resolved";
-    createdAt: string;
-    responses: Record<string, {
-        answers: Record<string, string>;
-        note?: string | undefined;
-        at: string;
-    }>;
-    resolution?: {
-        text: string;
-        reason?: "cancelled" | "reassigned" | "submitted" | undefined;
-        at: string;
-    } | undefined;
-}[]>;
-/** 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 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 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.";
-    readonly reassigned: "Cancelled with the Work's reassignment.";
-};
-/** 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 and responders. */
-export declare const mentioned: (row: FormState) => string[];
-export {};