@primusclaw/personal-agent 0.0.0-stage → 0.1.1

package/dist/types/approvals/approval-view.d.ts

@@ -0,0 +1,70 @@
+import type { Lang } from "../locales/lang.js";
+export declare const TITLE_ID = "approval-title";
+export declare const DETAILS_ID = "approval-details";
+export declare const SUMMARY_MAX = 300;
+export declare const DESCRIPTION_MAX = 200;
+export declare const INTENT_MAX = 200;
+export declare const VALUE_MAX = 120;
+export declare const COMMAND_MAX = 300;
+export declare const COMMAND_EDGE = 140;
+export declare const NAME_MAX = 40;
+export declare const MAX_OTHER_ARGS = 5;
+export declare const RAW_MAX = 1500;
+/** One `name: value` line of the card. */
+export type ArgumentLine = readonly [name: string, value: string];
+export interface ArgumentLines {
+    /** The fields the call is about first (in the order the tool's name gives them), then up to MAX_OTHER_ARGS more. */
+    readonly lines: readonly ArgumentLine[];
+    /** The stated reason, shown apart. */
+    readonly reason: ArgumentLine | undefined;
+    /** How many other fields did not fit. */
+    readonly more: number;
+}
+/** `mcp__<server>__<tool>` -> `tool words (server)`; any other name with its separators turned into spaces. */
+export declare function humanizeTool(tool: string): string;
+/**
+ * (server, tool) of `mcp__<server>__<tool>` (Python's `re.fullmatch(r"mcp__(.+?)__(.+)", name)`: the shortest server, neither part
+ * empty, no line break), read in one pass; undefined for any other name.
+ */
+export declare function mcpParts(name: string): readonly [server: string, tool: string] | undefined;
+/**
+ * A shell command for the card: whole up to COMMAND_MAX, else its start and its end with the middle elided (a chained
+ * `git push` sits at the end, so a plain cut at the front would hide the part that is being approved).
+ */
+export declare function clipCommand(text: string): string;
+/** The call's key arguments, its reason and how many fields did not fit. A credential-named field shows as [hidden]. */
+export declare function argumentLines(tool: string, toolInput: unknown): ArgumentLines;
+/** The call as JSON for the collapsed section: credential-named fields and secret shapes already masked. */
+export declare function rawDetails(tool: string, toolInput: unknown): string;
+/** The semantic content of an approval card; the buttons are the caller's. */
+export interface ApprovalView {
+    readonly lang: Lang;
+    readonly group: boolean;
+    /** The model's one-sentence summary ('' when none): shown bold, with a note that the model wrote it. */
+    readonly summary: string;
+    /** What the agent said it was about to do, shown when there is no summary (1:1 only; '' when none). */
+    readonly intent: string;
+    /** The action's readable name ('' when the call names no tool: the view says "an action" in its language). */
+    readonly action: string;
+    /** The tool's own description, in a 1:1 chat only ('' when none). */
+    readonly description: string;
+    readonly args: readonly ArgumentLine[];
+    readonly reason: string | undefined;
+    /** The deployment's wording of the rule that held the call ('' when none). */
+    readonly ruleLabel: string;
+    readonly moreFields: number;
+    /** The raw call for the Details fold ('' when there is no input, and always in a group). */
+    readonly details: string;
+    /** Who alone can answer, in a group ('' for "the person who asked"). */
+    readonly owner: string;
+}
+export interface ApprovalRequest {
+    readonly tool: string;
+    readonly toolInput: unknown;
+    /** The permission event's optional fields: summary, tool_description, intent, approval_label. */
+    readonly event?: Readonly<Record<string, unknown>> | null | undefined;
+    readonly lang?: string | null | undefined;
+    readonly group: boolean;
+    readonly owner?: string | undefined;
+}
+export declare function approvalView(request: ApprovalRequest): ApprovalView;

package/dist/types/approvals/click.d.ts

@@ -0,0 +1,8 @@
+/** What a card press handler of this feature reads of the router's click (W4's `ClickRoute`). */
+import type { ClickRoute } from "../ports/routing.js";
+import type { OutMessage, View } from "../ports/surface.js";
+export type CardClick = Pick<ClickRoute, "sender" | "conversation" | "scope" | "lang" | "settle"> & {
+    readonly action: Pick<ClickRoute["action"], "data">;
+};
+/** A view as a message, with the line a client that cannot show it shows. */
+export declare function viewMessage(view: View, fallbackText?: string): OutMessage;

package/dist/types/approvals/decide.d.ts

@@ -0,0 +1,64 @@
+import type { ClawSessionsPort } from "../ports/claw/index.js";
+import type { Logger } from "../ports/logger.js";
+import type { StorePort } from "../ports/store/index.js";
+import type { TokenExchange } from "../plugins/token-exchange.js";
+import { type CardClick } from "./click.js";
+export type DecisionStore = Pick<StorePort, "approvals" | "sessions" | "prefs" | "reviewDelegation" | "now">;
+/** One approval's use of the person's allowance (guardrails): a refusal's text, or undefined when it may go on. */
+export interface ApprovalAllowance {
+    take(userId: string, ticket: object, details: ApprovalAuditIds): string | undefined;
+    giveBack(userId: string, ticket: object): void;
+}
+/** What the audit records name an approval by: only what the store has from Claw, never a card's text. */
+export interface ApprovalAuditIds {
+    readonly sessionId: string;
+    readonly toolUseId: string;
+    readonly approvalId: string | null;
+    readonly tool: string | null;
+}
+export interface ApprovalAudit extends ApprovalAuditIds {
+    readonly userId: string;
+    readonly decision: "approve" | "deny";
+    readonly outcome: "success" | "failure" | "expired";
+    readonly status: number | null;
+}
+export interface DecisionDeps {
+    readonly store: DecisionStore;
+    readonly claw: Pick<ClawSessionsPort, "decide" | "answer">;
+    readonly exchange: TokenExchange;
+    readonly allowance: ApprovalAllowance;
+    readonly audit: (record: ApprovalAudit) => void;
+    readonly logger: Logger;
+    /** Offers the person the card that connects their identity (1:1 only). */
+    readonly connectIdentity?: (click: CardClick) => Promise<void>;
+    /** An approval of the running turn was denied: its answer comes with the Report a problem button. */
+    readonly onDenied?: (userId: string, scope: string) => void;
+}
+export declare class ApprovalDecisions {
+    private readonly deps;
+    constructor(deps: DecisionDeps);
+    /**
+     * A press on an approval or question card in a group chat: answered ONLY by the person it was raised for (read from the stored
+     * request, never the card); anyone else, linked or not, is refused before any key is read, and the card is put back for the
+     * asker. `credential` reads the presser's linked key (null: none).
+     */
+    inGroup(click: CardClick, credential: () => Promise<string | null>): Promise<void>;
+    /** A press with the person's linked key (`key`; null when they have none). */
+    decide(click: CardClick, key: string | null): Promise<void>;
+    private read;
+    /** The press may be answered: the person's own, still pending and in time. Otherwise the card is settled and false. */
+    private valid;
+    private auditIds;
+    /**
+     * The exchanged token of the clicker for a session that acts as a person; undefined when it cannot be had (the card was put
+     * back and the allowance given back).
+     */
+    private actingToken;
+    private send;
+    private failed;
+    private record;
+    private settled;
+    /** It did not go through: the card comes back as it was, to be pressed again. */
+    private again;
+    private showExpired;
+}

package/dist/types/approvals/handler.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The buttons of approval and question cards, for the router (teams_agent/agent.py `_dispatch` and `_route_group` for these cards).
+ * A card of a session that acts as a person is answered before any key is read: it is never answered with one.
+ */
+import type { ClickHandler, ClickRoute } from "../ports/routing.js";
+import type { ApprovalDecisions } from "./decide.js";
+export declare class ApprovalClicks implements ClickHandler {
+    private readonly decisions;
+    /** Whether the session acts as a person (a review for a colleague): the store says so, never the card. */
+    private readonly actsAsPerson;
+    /** The presser's linked key, read only when needed (null: none). */
+    private readonly linkedKey;
+    readonly verbs: readonly ["decision", "answer"];
+    constructor(decisions: ApprovalDecisions, 
+    /** Whether the session acts as a person (a review for a colleague): the store says so, never the card. */
+    actsAsPerson: (sessionId: string) => boolean, 
+    /** The presser's linked key, read only when needed (null: none). */
+    linkedKey: (userId: string) => Promise<string | null>);
+    beforeCredential(click: ClickRoute): Promise<boolean>;
+    withCredential(click: ClickRoute, credential: string): Promise<void>;
+    inGroup(click: ClickRoute): Promise<boolean>;
+}

package/dist/types/approvals/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./approval-view.js";
+export * from "./click.js";
+export * from "./decide.js";
+export * from "./handler.js";
+export * from "./questions.js";
+export * from "./records.js";
+export * from "./sensitive.js";
+export * from "./turn-cards.js";
+export type * from "./views.js";

package/dist/types/approvals/questions.d.ts

@@ -0,0 +1,36 @@
+/** The tool whose call waits for the answer to a question card. */
+export declare const QUESTION_TOOL = "ask_user_question";
+export declare const QUESTIONS_MAX = 5;
+export declare const OPTIONS_MAX = 10;
+export declare const QUESTION_MAX = 500;
+export declare const OPTION_MAX = 120;
+/** What one free-text answer takes. */
+export declare const ANSWER_MAX = 1000;
+export interface QuestionOption {
+    readonly id: string;
+    readonly label: string;
+}
+export interface CardQuestion {
+    readonly id: string;
+    readonly question: string;
+    readonly options: readonly QuestionOption[];
+    readonly allowMultiple: boolean;
+}
+/**
+ * The questions of a userQuestion event (or of a question card's own data), cut to what a card shows. A question without an id or
+ * text is left out; so is anything that is not an object.
+ */
+export declare function cardQuestions(raw: unknown): CardQuestion[];
+/** A question as a card's button carries it on the wire (the Python worker's dict, so a card it drew can be answered here). */
+export declare function questionWire(question: CardQuestion): Record<string, unknown>;
+export interface Answers {
+    /** {question id: answer}, in the order of the questions. */
+    readonly answers: ReadonlyMap<string, string>;
+    /** The ids of the questions left blank. */
+    readonly skipped: readonly string[];
+}
+/**
+ * What the person answered on a question card, as Claw takes it: an answer is the labels of the chosen options, then what was
+ * typed; a choice the card never offered is ignored.
+ */
+export declare function answersOf(data: Readonly<Record<string, unknown>>): Answers;

package/dist/types/approvals/records.d.ts

@@ -0,0 +1,43 @@
+/**
+ * One approval, one card (teams_agent/agent.py `on_approval`, `on_approval_sent`, `on_approval_unsent`; proactive.py `_send` for
+ * a pushed one): a card is recorded BEFORE it is shown, so its owner is known when it is pressed and the other way the same
+ * approval arrives (the running turn's stream, or Claw's `approval.requested` notification) finds it and shows nothing; and it is
+ * recorded WITH the card, so that a worker that dies before the send leaves it to the next (`resendUnsent`).
+ */
+import type { Conversation, Envelope, OutMessage } from "../ports/surface.js";
+import type { ApprovalRepository, StorePort } from "../ports/store/index.js";
+export type ApprovalRecordStore = Pick<StorePort, "now"> & {
+    readonly approvals: Pick<ApprovalRepository, "saveApproval" | "approvalSent" | "forgetApproval">;
+};
+export interface ApprovalCardRequest {
+    readonly userId: string;
+    readonly sessionId: string;
+    readonly toolUseId: string;
+    readonly tool: string;
+    /** When it runs out, epoch seconds. */
+    readonly expiresAt: number;
+}
+export declare class ApprovalCards {
+    private readonly store;
+    constructor(store: ApprovalRecordStore);
+    /**
+     * Show `card` for an approval in `conversation`, once: false when a card for it is in a chat already (nothing is sent). A card
+     * that could not be sent leaves no record (whatever else shows the approval then may show it), and the error goes on.
+     */
+    show(conversation: Conversation, request: ApprovalCardRequest, card: OutMessage): Promise<boolean>;
+    /** When an approval a turn shows runs out: as long as Brain waits for it (`expiresIn` seconds), else `fallbackSeconds` on. */
+    expiry(expiresIn: number | undefined, fallbackSeconds: number): number;
+}
+/** A turn's deadline: an approval a turn shows is answerable this long when Brain did not say how long it waits (turn.py). */
+export declare const TURN_DEADLINE_SECONDS: number;
+/**
+ * The turn engine's view of the records (W4's `TurnApprovals`, satisfied structurally): `record` is told whose approval it is,
+ * the person the turn is for (Python `store.save_approval(sender.aad_id, ...)`).
+ */
+export interface TurnApprovalRecords {
+    record(userId: string, sessionId: string, toolUseId: string, tool: string, expiresIn: number | undefined, envelope: Envelope): boolean;
+    sent(sessionId: string, toolUseId: string): void;
+    unsent(sessionId: string, toolUseId: string): void;
+}
+/** The records of the approvals a turn shows (the Python `on_approval`, `on_approval_sent`, `on_approval_unsent`). */
+export declare function turnApprovals(store: ApprovalRecordStore): TurnApprovalRecords;

package/dist/types/approvals/sensitive.d.ts

@@ -0,0 +1,13 @@
+/** The words of an argument name, as the credential rule reads them (camelCase and ALLCaps split, lower case). */
+export declare function nameWords(name: string): string[];
+/** Whether a value stored under this argument name must not be shown. */
+export declare function isSensitiveName(name: unknown): boolean;
+/** Every string (or number) under a credential-named argument, at any depth: the values no text about the call may repeat. */
+export declare function credentialValues(value: unknown, underSecret?: boolean, depth?: number): string[];
+/** `text` with every occurrence of each secret replaced; longest first, so one inside another goes whole. */
+export declare function scrub(text: string, secrets: readonly string[]): string;
+/**
+ * A copy of a JSON value with credential-named fields replaced whole and strings masked by shape; `secrets` (the values typed
+ * under credential-named arguments) are replaced wherever else they repeat.
+ */
+export declare function maskValue(value: unknown, secrets?: readonly string[], depth?: number): unknown;

package/dist/types/approvals/turn-cards.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The approvals feature's half of the turn's `TurnCards`: the card of a held tool call (Python render.py `permission_card`) and
+ * of an agent's question (turn.py `question_card(card_questions(questions), ...)`, the questions read here). The feedback
+ * feature brings `thumbs`; whoever assembles the worker joins the two.
+ */
+import type { TurnCards } from "../ports/turn-cards.js";
+export declare const approvalTurnCards: Pick<TurnCards, "approval" | "question">;

package/dist/types/approvals/views.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The approval and question views any feature may show (a turn's permission request, a remote agent's, a work item's). The
+ * channel adapter renders them; `approvalView` (approval-view.ts) is what an approval card says.
+ */
+import type { JsonObject } from "../json.js";
+import type { CardQuestion } from "./questions.js";
+/** An approval card: the arguments of the Python worker's `render.permission_card`, one for one. */
+export interface ApprovalCardModel {
+    readonly tool: string;
+    readonly input: unknown;
+    readonly sessionId: string;
+    readonly toolUseId: string;
+    readonly group: boolean;
+    /** Who alone can answer it in a group ("" for "the person who asked"). */
+    readonly ownerName: string;
+    /** Brain's permissionRequest (summary, tool_description, intent, approval_label); null when there is none. */
+    readonly event: JsonObject | null;
+    /** "zh" or "en"; null to follow the summary's language. */
+    readonly lang: string | null;
+}
+/** A question card: the arguments of `render.question_card`. */
+export interface QuestionCardModel {
+    readonly questions: readonly CardQuestion[];
+    readonly sessionId: string;
+    readonly toolUseId: string;
+    readonly group: boolean;
+    readonly ownerName: string;
+    /** A line under the header: which task asks, or what happened when the card comes back after a click ("" when none). */
+    readonly note: string;
+}
+/** What replaces an approval card once it was answered (render.decided_card). */
+export interface ApprovalDecidedModel {
+    readonly tool: string;
+    /** "allow" or "deny". */
+    readonly action: string;
+    /** When it was answered, epoch seconds, shown as HH:MM in `zone`. */
+    readonly when: number;
+    readonly zone: string;
+}
+/** An approval or a question that ran out (render.expired_card). */
+export interface ApprovalExpiredModel {
+    readonly tool: string;
+}
+/** What replaces a question card once it was answered (render.answered_card). */
+export interface QuestionAnsweredModel {
+    /** (question id, answer), in the order of the questions. */
+    readonly answers: readonly (readonly [string, string])[];
+    readonly when: number;
+    readonly zone: string;
+}
+/** An approval card put back after a press that did not go through: the note, then Approve and Deny again. */
+export interface ApprovalAgainModel {
+    readonly text: string;
+    readonly tool: string;
+    readonly sessionId: string;
+    readonly toolUseId: string;
+}
+declare module "../ports/surface.js" {
+    interface ViewMap {
+        approval: ApprovalCardModel;
+        approvalAgain: ApprovalAgainModel;
+        approvalDecided: ApprovalDecidedModel;
+        approvalExpired: ApprovalExpiredModel;
+        question: QuestionCardModel;
+        questionAnswered: QuestionAnsweredModel;
+    }
+}

package/dist/types/assistant/action-handler.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The buttons of the cards the assistant puts to the person, for the router (teams_agent/agent.py `_dispatch`: `_action_click` and
+ * `_confirm_click`, after the person's key is read; a group chat answers neither). Run or Cancel under a command
+ * (`assistant_action`), Allow or Deny on a write Claw holds (`assistant_confirm`).
+ */
+import type { ClickHandler, ClickRoute } from "../ports/routing.js";
+import type { AssistantActions } from "./actions.js";
+export declare class AssistantActionClicks implements ClickHandler {
+    private readonly actions;
+    readonly verbs: readonly ["assistant_action", "assistant_confirm"];
+    constructor(actions: Pick<AssistantActions, "actionClick" | "confirmClick">);
+    withCredential(click: ClickRoute, credential: string): Promise<void>;
+}

package/dist/types/assistant/actions.d.ts

@@ -0,0 +1,63 @@
+/**
+ * What the assistant asks this chat to do, and the buttons it puts to the person for that (teams_agent/agent.py `run_action`,
+ * `_action_click`, `_confirm_click`). A command is carried out only for a message this worker sent for the person (by its id),
+ * only for an action that message declared, once, and exactly as if the person had typed it. Cards are not trusted: a button
+ * carries the id of the card this worker recorded, what it means is read from the record, and of two presses exactly one goes on.
+ * A held write is answered as the person, with the token the identity service exchanges for them, never their linked key.
+ */
+import { type CardClick } from "../approvals/click.js";
+import type { ClawAssistantPort } from "../ports/claw/assistant.js";
+import type { Logger } from "../ports/logger.js";
+import type { StorePort } from "../ports/store/index.js";
+import type { TokenExchange } from "../plugins/token-exchange.js";
+/** The handoff a message declares for a review asked of someone else: started by the review line (W7), not here. */
+export declare const REVIEW_HANDOFF = "review_for_other";
+export type AssistantActionStore = Pick<StorePort, "assistantButtons" | "assistantMessages" | "idempotency">;
+export interface AssistantActionDeps {
+    readonly store: AssistantActionStore;
+    readonly claw: Pick<ClawAssistantPort, "decideConfirmation">;
+    readonly exchange: TokenExchange;
+    /** Carries out `text` exactly as if the presser had typed it, with their linked `key`; false when it was not done. */
+    readonly runCommand: (text: string, click: CardClick, key: string) => Promise<boolean>;
+    /** The router's test of a command typed whole. */
+    readonly exactCommand: (text: string) => boolean;
+    /** The arguments of an `agent` action are one the assistant may ask for. */
+    readonly agentActionAllowed: (args: string) => boolean;
+    /** The assistant understands the person's messages. */
+    readonly understands: (userId: string) => boolean;
+    /** The person's assistant can answer them. */
+    readonly reachable: (userId: string) => boolean;
+    readonly logger: Logger;
+    /** Takes a review handed back to this chat (the review service's `ReviewHandoffAction.take`); dropped without it. */
+    readonly reviewHandoff?: (userId: string, event: Readonly<Record<string, unknown>>) => "delivered" | "dropped";
+}
+type Event = Readonly<Record<string, unknown>>;
+export declare class AssistantActions {
+    private readonly deps;
+    constructor(deps: AssistantActionDeps);
+    /** A message this worker sent for `userId` declared `name`, and `/{name} {args}` is a command it may carry out. */
+    private declared;
+    /**
+     * An `assistant.action` event for `userId`: carried out by `run` (the command exactly as typed, as the person) only for a message
+     * this worker sent for them that declared it, and once per event id. A review handoff goes to the review service.
+     */
+    runAction(userId: string, event: Event, run: (text: string) => Promise<boolean>): Promise<"delivered" | "dropped">;
+    /**
+     * Run or Cancel (`op`) under a command the assistant put to the person. The card must be the presser's and not yet used; the
+     * command is the recorded one, for a message this worker sent for them that declared it. Run carries it out as typed.
+     */
+    actionClick(click: CardClick, key: string): Promise<void>;
+    private run;
+    /**
+     * Allow or Deny (`op`) on a write Claw holds until the person answers. The card must be the presser's and not yet used; what it
+     * answers is the recorded confirmation, as the person with their exchanged token. Of two presses exactly one is sent.
+     */
+    confirmClick(click: CardClick): Promise<void>;
+    /** The presser's exchanged token; undefined when it cannot be had (the card was answered with why, as it was). */
+    private token;
+    /** Claw did not answer, or refused: a 403 or 404 ends the card (pressing again cannot help); anything else gives it back. */
+    private notAnswered;
+    /** Nothing was answered: the card comes back with `note`, and pressing it again can help. */
+    private again;
+}
+export {};

package/dist/types/assistant/auto-reply.d.ts

@@ -0,0 +1,14 @@
+import type { ClawWorkItemsPort } from "../ports/claw/index.js";
+import type { Logger } from "../ports/logger.js";
+import type { AssistantCardRepository } from "../ports/store/index.js";
+/** A watch Claw lists that still answers new comments unasked. */
+export declare function answersUnasked(watch: Readonly<Record<string, unknown>>): boolean;
+export declare function refreshAutoReply(deps: {
+    readonly cards: Pick<AssistantCardRepository, "autoReply" | "clearAutoReply">;
+    readonly claw: Pick<ClawWorkItemsPort, "watches"> | undefined;
+    readonly logger: Logger;
+}, call: {
+    readonly userId: string;
+    readonly itemId: string;
+    readonly key: string | null;
+}): Promise<void>;

package/dist/types/assistant/board.d.ts

@@ -0,0 +1,68 @@
+/**
+ * `/board` (teams_agent/assistant.py `board`, `_board_card`, `_remote_ask_card`): the person's work items in three sections, the
+ * reviews they asked of others beside them, and a card for each item that waits for them (at most BOARD_CARDS). The board's own
+ * buttons (Accept all, Retry) carry only card ids recorded first, so a press means what the board showed.
+ */
+import type { ReviewAskedOfOther, WorkItem } from "../claw/model.js";
+import type { ClawWorkItemsPort } from "../ports/claw/index.js";
+import type { Logger } from "../ports/logger.js";
+import type { StorePort } from "../ports/store/index.js";
+import type { Conversation, OutMessage } from "../ports/surface.js";
+/** Results one Accept all takes (the board button counts the same ones it carries). */
+export declare const ACCEPT_ALL_MAX = 50;
+/** After a Claw without retry said so, the board offers no Retry for this long. */
+export declare const NO_RETRY_SECONDS: number;
+export type BoardStore = Pick<StorePort, "now" | "prefs" | "assistantCards" | "remotePermissions">;
+/** The approval card of a request an agent on the person's machine waits on, as the board shows it (W6b's card). */
+export type BoardRemoteAsk = (request: {
+    readonly ask: Readonly<Record<string, unknown>>;
+    readonly options: readonly unknown[];
+    readonly sessionId: string;
+    readonly machine: string;
+    readonly agent: string;
+    readonly about: string;
+    readonly expiresAt: number;
+    readonly zone: string;
+    readonly lang: string;
+}) => OutMessage;
+export interface BoardDeps {
+    readonly store: BoardStore;
+    readonly claw: Pick<ClawWorkItemsPort, "list" | "askedOfOthers" | "watches">;
+    readonly logger: Logger;
+    /** The chat talks to the assistant (`AssistantChat.on`). */
+    readonly on: (userId: string) => boolean;
+    readonly remoteAsk: BoardRemoteAsk;
+    /** The locale of the client the message being handled came from ("" none): the language before the person said one. */
+    readonly clientLocale?: () => string;
+}
+export declare class Board {
+    private readonly deps;
+    /** Claw answered Retry with a route it does not have (a Claw before retry): no Retry on the board until then. */
+    noRetryUntil: number;
+    constructor(deps: BoardDeps);
+    private locale;
+    /** `/board`: the person's work items, and a card for each one that waits for them. */
+    show(userId: string, key: string, conversation: Conversation): Promise<void>;
+    /** The reviews the person asked of others; best effort: the board is shown whatever this answers. */
+    private askedOfOthers;
+    private waitingCards;
+    /**
+     * For a development environment item that waits on the person: the approval card of the first of its requests this chat was
+     * shown and that is still open, so the board's "needs you" is answered where it is listed. Undefined: the item's own card.
+     */
+    private remoteAskCard;
+    /** The board with its own buttons, each button's card recorded first; in the person's language. */
+    model(userId: string, items: readonly WorkItem[], asked: readonly ReviewAskedOfOther[]): {
+        items: readonly WorkItem[];
+        asked: readonly ReviewAskedOfOther[];
+        now: number;
+        accept: string[];
+        retry: {
+            cardId: string;
+            item: WorkItem;
+        }[];
+        lang: "en" | "zh";
+    };
+    /** The board as it is now, to replace the board a press was made on; undefined when it cannot be read. */
+    now(userId: string, key: string): Promise<OutMessage | undefined>;
+}