toolroll 0.9.103 → 0.9.105

package/dist/chat-decide.d.ts

@@ -1,269 +0,0 @@
-import { DECIDE_ACTS } from "./contracts/chat-callback-rows.js";
-import { chatApproveMode } from "./chat-approval.js";
-import { type VerifiedApprover } from "./principal.js";
-import type { Scope } from "./scope.js";
-import { type ReleaseCard } from "./release-card.js";
-import type { Store } from "./store.js";
-import { permissionPlainWords } from "./chat-terms.js";
-export { permissionPlainWords };
-/** The tokens live in chat_decide_action and the open "What should change?" in chat_decide_prompt (store.ts). */
-export type DecideAct = (typeof DECIDE_ACTS)[number];
-export type DecideTarget = {
-    kind: "result";
-    taskId: string;
-    run: number;
-} | {
-    kind: "failed";
-    taskId: string;
-} | {
-    kind: "plan";
-    taskId: string;
-} | {
-    kind: "merge";
-    taskId: string;
-    run: number;
-}
-/** The tasks one youiyoux pass filed (youiyoux-intake.ts), named by any one of them. */
- | {
-    kind: "requests";
-    taskId: string;
-};
-export type DecideChannel = "telegram" | "slack" | "discord" | "teams";
-/** Who is tapping, where: one paired person's binding on one channel, and the chat the card is in. */
-export type DecideSeat = {
-    channel: DecideChannel;
-    binding: number;
-    chat: string;
-    approver: string;
-    generation: number;
-};
-export type DecideLink = {
-    label: string;
-    path: string;
-};
-/** A button as a channel draws it: an act (its token) or a link to the console. */
-export type DecideButton = {
-    label: string;
-    token: string;
-} | {
-    label: string;
-    link: DecideLink;
-};
-/** The words, said once. */
-export declare const DECIDE_LABELS: {
-    readonly accept: "Accept";
-    readonly changes: "Send back";
-    readonly retry: "Retry";
-    readonly approve: "Approve & start";
-    readonly "not-now": "Not now";
-    readonly merge: "Merge";
-    readonly look: "Look first";
-    /** A result's one link (docs/plans/plain-toolroll.md P1.5). */
-    readonly open: "Open result";
-    /** A plan card's one button: it shows the full terms, and the Approve sits under them. Never an approval itself. */
-    readonly review: "Review plan";
-    readonly details: "Details";
-    readonly edit: "Edit";
-    readonly yes: "Yes";
-    readonly cancel: "Cancel";
-};
-export declare const WHAT_SHOULD_CHANGE = "What should change?";
-/** `taskId`: the task the button acts on, when it isn't the card's own (a youiyoux card's one-task Approve). */
-type ActSpec = {
-    act: DecideAct;
-    run: number | null;
-    digest: string;
-    label?: string;
-    taskId?: string;
-};
-/** What a card offers: an optional replacement text (the plan card) and rows of acts and links; a release card also
- * sends its full terms as a file with it (`file`), where the chat app can. */
-export type DecideOffer = {
-    text: string | null;
-    rows: Array<Array<ActSpec | DecideLink>>;
-    file?: {
-        name: string;
-        text: string;
-    };
-};
-export { chatApproveMode };
-/** A plan this person's chat may approve now: the term, the plan's exact bytes, and none of the reasons it must open
- * Toolroll instead. `digest` binds the scope and the plan document the card shows. */
-export declare function planInChat(store: Store, taskId: string, approver: string, now: Date, channel: DecideChannel, root?: string, 
-/** A youiyoux card asking (requestsOffer): its own words are checked there, every one shown. */
-from?: "requests"): {
-    ok: true;
-    modeDigest: string;
-    source: "setting" | "mode";
-    digest: string;
-    scope: Scope;
-    whole: boolean;
-} | {
-    ok: false;
-    why: string;
-};
-/** A ready pull request this person's chat may merge now, bound to the exact commit. */
-export declare function mergeInChat(store: Store, taskId: string, run: number, approver: string, now: Date, channel: DecideChannel): {
-    ok: true;
-    modeDigest: string;
-    source: "setting" | "mode";
-    head: string;
-} | {
-    ok: false;
-    why: string;
-};
-/** Whether a card's words arrive as one message that shows each of them as written: within Telegram's part, Slack's and
- * (after its escapes) Discord's limits, with room for the question a tap adds. Teams draws card text as Markdown, where
- * a link's label hides its address, and Slack turns `:name:` into an emoji: there such words never approve. */
-export declare function shownWhole(text: string, channel: DecideChannel): boolean;
-/** The plan card: title, goal in two lines, what changes, done when, and what the yes allows. On Telegram the yes's
- * terms come second, under the title, and the steps are fewer: the full plan is behind Edit. */
-export declare function planCardText(store: Store, taskId: string, scope: Scope, root?: string, channel?: DecideChannel): string;
-/** The acts a card about this target can take in chat right now, or null when none can (the card keeps its own
- * link). Reads only; nothing is minted. */
-export declare function decideOffer(store: Store, target: DecideTarget, who: VerifiedApprover, now: Date, channel: DecideChannel, root?: string): DecideOffer | null;
-/** One fingerprint of what the card offers, without its tokens: a repaint with the same offer keeps its buttons. */
-export declare function offerFingerprint(offer: DecideOffer): string;
-/** The card's buttons, minted now (message unknown until it is sent: `placeDecideTokens` puts them on it). */
-export declare function mintDecideButtons(store: Store, seat: DecideSeat, target: DecideTarget, offer: DecideOffer, now: Date, message?: string | null): {
-    rows: DecideButton[][];
-    tokens: string[];
-};
-/** Put freshly minted tokens on the message they ride: a tap on any other message proves itself stale. */
-export declare function placeDecideTokens(store: Store, tokens: readonly string[], message: string): void;
-/** Every live button on one message stops working: the card was repainted, or one of its acts was taken. */
-export declare function retireDecideTokens(store: Store, channel: DecideChannel, chat: string, message: string, now: Date): void;
-/** Buttons minted for a send or an edit that didn't land: they never act. */
-export declare function dropDecideTokens(store: Store, tokens: readonly string[], now: Date): void;
-/** Whether a message still carries a button that acts (an offer, or an armed Yes or Cancel): a card whose acts were
- * all spent, as by Not now, needs fresh ones. */
-export declare function hasLiveDecideTokens(store: Store, channel: DecideChannel, chat: string, message: string, now: Date): boolean;
-export declare function isDecideToken(store: Store, token: string): boolean;
-export type DecideTapOutcome = {
-    ack: string;
-    /** A release card's full terms, sent as a file before its Approve is offered (chat apps that limit a message). */
-    file?: {
-        name: string;
-        text: string;
-    };
-    /** The card repainted: its text and buttons now. */
-    edit?: {
-        text: string;
-        rows: DecideButton[][];
-        tokens: string[];
-    };
-    /** With `file`, where the chat app carries the terms only as a file: the card instead of `edit` when the file didn't
-     * arrive. No Approve, a fresh Continue to send it again; the channel drops whichever set it doesn't show. */
-    unsent?: {
-        text: string;
-        rows: DecideButton[][];
-        tokens: string[];
-    };
-    /** Ask "What should change?": the person's next message is the feedback. `id` names the prompt, so the channel can
-     * record the message it sent (a reply to anything else is not the feedback). */
-    prompt?: {
-        id: number;
-        text: string;
-    };
-    /** Merge after the transaction (GitHub is a network call); the card says "Merging…" until it lands, and
-     * `recordChatMerge` ledgers how it went. */
-    merge?: ChatMerge;
-    ignored?: boolean;
-};
-/** A merge approved in chat, waiting on GitHub: what its ledger line names once the answer is back. */
-export type ChatMerge = {
-    runId: number;
-    taskId: string;
-    by: string;
-    repo: string;
-    via: string;
-};
-/** Where a release card is tapped: the person's binding and the chat the tap came from. */
-export type ReleaseSeat = Pick<DecideSeat, "channel" | "binding" | "chat" | "approver">;
-/**
- * Whether a release card's tap comes from the person's own private chat with Toolroll (chat-management.md §0a.5), from
- * the binding's own record, failing closed: Telegram, a private chat (a positive id, which Telegram makes equal to the
- * user's own id) that is the binding's chat and its user's; Slack, a direct-message channel (D…) that is the binding's.
- * Any other chat app, a missing chat or binding, or another person's binding is not.
- */
-export declare function privateReleaseChat(store: Store, seat: ReleaseSeat): boolean;
-/**
- * A deploy gate this person may approve from this chat now, through its release card: every plain-plan rule
- * (planInChat: their Approve from chat setting and limits, no coordinator-, lead- or scout-written text, organisation
- * policy, protected work), never a nightly check, only in their private chat, and the card as the live records say
- * it now (chat-management.md §0a.5).
- */
-export declare function releaseInChat(store: Store, taskId: string, approver: string, now: Date, channel: DecideChannel, 
-/** The seat a tap came from, checked strictly; "offer" only where the card is drawn for the binding's own chat (no act). */
-seat: ReleaseSeat | "offer", root?: string): {
-    ok: true;
-    card: ReleaseCard;
-    modeDigest: string;
-    source: "setting" | "mode";
-    scope: Scope;
-} | {
-    ok: false;
-    why: string;
-};
-/** The links a card keeps once its acts are spent or stale: where to look, never a token. */
-export declare function linksFor(target: DecideTarget): DecideButton[][];
-/** Where a plan card's task is now, for a card whose buttons no longer act: the family's current version, named only
- * inside this person's projects, and linked only while it still waits on them. Never a live button. */
-export declare function planWhereNow(store: Store, taskId: string, who: VerifiedApprover, now: Date, root?: string): {
-    said: string;
-    rows: DecideButton[][];
-};
-/**
- * One tap on a decide button, inside the caller's transaction. Null: not this module's token. The seat must be the
- * token's own (person, chat, message); a spent, expired or foreign button acts on nothing.
- */
-export declare function applyDecideTap(store: Store, seat: DecideSeat, input: {
-    token: string;
-    message: string;
-    shown: string;
-    repos: readonly string[];
-    root?: string;
-    now: Date;
-}): DecideTapOutcome | null;
-/** A chat merge's second ledger line, after the GitHub call: merged, or failed and why (its approval is the first). */
-export declare function recordChatMerge(store: Store, merge: ChatMerge, result: {
-    ok: true;
-} | {
-    ok: false;
-    message: string;
-}, now: Date): void;
-/** What the card says once the merge came back. */
-export declare function mergedText(shown: string, result: {
-    ok: true;
-} | {
-    ok: false;
-    message: string;
-}): string;
-export type DecidePrompt = {
-    id: number;
-    taskId: string;
-    run: number;
-    digest: string;
-    message: string | null;
-};
-/** One open "What should change?" per person and chat: a newer one replaces it. */
-export declare function openDecidePrompt(store: Store, seat: DecideSeat, taskId: string, run: number, digest: string, now: Date): number;
-/** The message that asked "What should change?", once it was sent. */
-export declare function placeDecidePrompt(store: Store, id: number, message: string): void;
-export declare function openPromptFor(store: Store, seat: Pick<DecideSeat, "channel" | "binding" | "chat">, now: Date): DecidePrompt | null;
-/** Whether this message answers the prompt: the person's next message, unless it replies to some other message. */
-export declare function answersPrompt(prompt: DecidePrompt, replyTo: string | null): boolean;
-/** The person's message after "What should change?": a revision of the exact result, with these words as its
- * feedback, through the result page's own service. Says what was sent, once. */
-export declare function applyDecideFeedback(store: Store, seat: DecideSeat, prompt: DecidePrompt, text: string, repos: readonly string[], root: string | undefined, now: Date): {
-    said: string;
-    link: DecideLink | null;
-};
-/** The link a card keeps when it can't act in chat: a plan's is Review & start, where the password step lives. */
-export declare function decideFallbackLink(target: DecideTarget | null): DecideLink | null;
-/** Which card a pushed notification is, from its recorded kind and task — never from its words. */
-export declare function decideTargetOf(row: {
-    kind: string;
-    taskId: string | null;
-    run: number | null;
-}): DecideTarget | null;

package/dist/chat-delivery-state.d.ts

@@ -1,132 +0,0 @@
-import { ChatCore, chatHash, type ChatBinding, type ChatProvider, type ChatRoom } from "./chat-core.js";
-import { ChatMessages } from "./chat-messages.js";
-import { savedChatPart, type ChatContent, type ChatEventBody } from "./contracts/chat-content.js";
-export { savedChatPart, chatHash, type ChatContent, type ChatEventBody, type ChatBinding, type ChatProvider, type ChatRoom };
-export type ChatIdentity = {
-    installation: string;
-    team?: string;
-    app: string;
-    bot: string;
-    workspace: string;
-};
-export type ChatEvent = {
-    id: string;
-    installation: string;
-    binding: number | null;
-    kind: "message" | "action" | "pair" | "notice";
-    channel: string;
-    member: string;
-    ts: string;
-    thread: string;
-    payload: string;
-    created: string;
-    session: number | null;
-    state: string;
-    next_at: string | null;
-};
-export type ChatPart = {
-    id: number;
-    event: string;
-    ordinal: number;
-    payload: string;
-    state: string;
-    message: string | null;
-    file: string | null;
-    uploaded: number;
-    attempts: number;
-    uncertain: number;
-    next_at: string | null;
-    created: string;
-};
-/** One app's chats on the shared core (the same object Telegram's run on): its events, planned parts and their buttons. */
-export declare class ChatState extends ChatMessages {
-    constructor(store: ChatCore["store"], provider: ChatProvider);
-    /** Pair-time half kept for the settings pages: mint a code for this installation and return it (only its hash is kept). */
-    pairing(installation: string, approver: string, generation: number, now?: Date): string;
-    /**
-     * Consume a code sent in a chat (the shared rules, chat-core.ts). The installation's notice cursor starts from now
-     * on its FIRST pairing; a later person joins the running cursor (their own history is fenced by their binding's
-     * creation time).
-     */
-    pair(identity: ChatIdentity, hash: string, member: string, channel: string, now: Date, event?: string | null): ChatBinding | null;
-    /** The 60-second lease the Slack, Discord and Teams workers renew. */
-    lease(installation: string, owner: string, now: Date): boolean;
-    /** Save a received event with its body (contracts/chat-content.ts), versioned. False: it was already here. */
-    enqueue(event: Omit<ChatEvent, "session" | "state" | "next_at" | "payload"> & {
-        payload: ChatEventBody;
-    }): boolean;
-    event(id: string): ChatEvent | null;
-    next(installation: string, now: Date): ChatEvent | null;
-    defer(event: string, problem: string, until: Date): void;
-    /**
-     * Mark an event handled: done (or dropped). For a message this runs when its reply is planned, before any part is
-     * sent; so on these apps done does not mean the person has the reply. Ask `unsent()` in chat-message-states.ts for
-     * that. Dropped is final: an event dropped while its handler was still working (the chat was disconnected) is
-     * never written back to done.
-     */
-    finish(event: string, dropped?: boolean): void;
-    /** Point an event at the binding its pairing made. */
-    setEventBinding(event: string, binding: number): void;
-    part(id: number): ChatPart | null;
-    /**
-     * The reply to an event, part by part, with each part's buttons minted with it; the event is then handled. Planned
-     * once. A dropped event gets no reply: nothing is saved, no button is minted, and the answer is false.
-     */
-    plan(event: string, parts: ChatContent[], now: Date): boolean;
-    /** A proposal card's buttons on its part: earlier ones on that part are spent. Yes and Cancel last ten minutes. */
-    tokens(part: number, proposal: number, phases: Array<"confirm" | "dismiss" | "yes" | "cancel">, now: Date): void;
-    /** A proposal card's live buttons on one part, in the order they were minted. */
-    partTokens(part: number, now: Date): {
-        token: string;
-        phase: string;
-    }[];
-    /** The next part to send for an installation: notices only while notifications may go out. */
-    nextPart(installation: string, notices: boolean, now: Date, order?: "id" | "created"): ChatPart | null;
-    /** A part that will not go: why, in words the saved chat shows. */
-    dropPart(id: number, problem: string): void;
-    /** Try again no earlier than then (a screenshot waiting for its result's message). */
-    holdPart(id: number, until: string): void;
-    /** The app's upload identity for a part's file, and whether its bytes are up. */
-    setPartFile(id: number, file: string | null, uploaded?: boolean, message?: string | null): void;
-    /**
-     * Sent: on the app's own message id when it gave one (an uploaded file may not). A card's decide buttons
-     * (chat-decide.ts) now ride that message, and any older ones on it stop working; a "What should change?" names it.
-     */
-    partSent(id: number, message: string | null, now: Date, attempt?: boolean): void;
-    /**
-     * Not sent this time: counted, named, and (when the answer was lost rather than refused) counted as uncertain. The
-     * part stays pending. A failed send never drops it on any app: it goes when the app says it can never be sent, or
-     * when the chat is disconnected.
-     */
-    partFailed(id: number, failure: {
-        problem: string;
-        until: string;
-        uncertain: boolean;
-    }): void;
-    /** One person's replies still waiting to send, and those that could not be delivered (settings show both). */
-    partCounts(binding: number): {
-        pending: number;
-        dropped: number;
-    };
-    /**
-     * Replace a part's content and send it again (a repaint after a tap). A dropped part stays dropped: it was given up
-     * on, or its chat disconnected, and new content doesn't bring it back. False then, so the caller can say it another way.
-     */
-    repaint(id: number, content: ChatContent): boolean;
-}
-/** A saved part's content. One that can't be read is a delivery problem that names the field, never a guess. */
-export declare function partContent(payload: string): ChatContent;
-/** The least time before a failed part is sent again, by how many times it has failed. The last step repeats. */
-export declare const CHAT_RETRY_STEPS_MS: readonly [5000, 15000, 60000, 300000];
-/**
- * When a part that failed to send is tried again: after the app's own wait or the step for its count of failures,
- * whichever is longer. One rule for Slack, Discord and Teams.
- */
-export declare function chatRetryAt(now: Date, retryMs: number, attempts: number): string;
-export declare class ChatDeliveryError extends Error {
-    readonly code: string;
-    readonly retryMs: number;
-    readonly uncertain: boolean;
-    readonly permanent: boolean;
-    constructor(code: string, retryMs?: number, uncertain?: boolean, permanent?: boolean);
-}

package/dist/chat-delivery.d.ts

@@ -1,71 +0,0 @@
-import { type WarmHooks } from "./chat-warmth.js";
-import { type ChatLiveTransport } from "./chat-live.js";
-import { ChatState, type ChatBinding, type ChatContent, type ChatEvent, type ChatIdentity } from "./chat-delivery-state.js";
-import { type Store } from "./store.js";
-import type { SubscriptionLeadRunner } from "./subscription-chat.js";
-import { type ChatMerge } from "./chat-decide.js";
-/**
- * The watch at a chat app's final fence (cockpit §3, R11), right before the network: a notice about an agent its
- * person has open now waits, as a held part, until the watch ends; then it is delivered as usual. The subject is the
- * part's own run, or its task's live build. Only a part planned with `watch` (never a security alert or the digest)
- * can be held. True: held, so nothing is sent now.
- */
-export declare function heldForWatch(state: ChatState, store: Store, part: number, event: {
-    kind: string;
-}, approver: string, content: ChatContent, now: Date): boolean;
-export declare const chatObject: (v: unknown) => Record<string, unknown>;
-export type ChatDeliveryOptions = {
-    store: Store;
-    state: ChatState;
-    label: string;
-    identity: ChatIdentity;
-    owner: string;
-    member: (member: string, channel: string) => Promise<boolean>;
-    readProjects: () => Promise<readonly string[]>;
-    evidenceRoot: string;
-    current: () => boolean;
-    origin: () => string | null;
-    subscriptionRunner?: SubscriptionLeadRunner;
-    canNotify?: () => boolean;
-    clock?: () => Date;
-    partSize?: number;
-    maxProposal?: number;
-    /** The app's warm touch while the lead works on one owner message (typing), where the app and the bot's permissions allow it. */
-    warm?: (event: ChatEvent, binding: ChatBinding) => WarmHooks;
-    /** Live replies (docs/plans/responsive-chat.md §3.2): the app's transport for the live message that answers the
-     * owner's own direct message; absent or null: the reply goes out whole at the end, as before. */
-    live?: (event: ChatEvent, binding: ChatBinding) => ChatLiveTransport | null;
-    /** Merges a pull request approved in chat (tests script it); otherwise the project's own merge. */
-    merge?: (input: {
-        runId: number;
-        by: string;
-    }) => Promise<{
-        ok: true;
-    } | {
-        ok: false;
-        message: string;
-    }>;
-};
-export declare const splitChatText: (text: string, size?: number) => string[];
-export declare function channelAccess(options: ChatDeliveryOptions, binding: ChatBinding, ceiling?: string): Promise<string[]>;
-/** A merge approved in chat, waiting on GitHub, and the card that says how it went. */
-type PendingMerge = {
-    merge: ChatMerge;
-    part: number;
-    shown: string;
-    content: ChatContent;
-};
-export declare function processChatEvent(options: ChatDeliveryOptions): Promise<boolean>;
-/** Bound to the paired member, exact channel/message, pending proposal and current ceiling. */
-export declare function applyChatAction(options: ChatDeliveryOptions, event: ChatEvent, binding: ChatBinding, repos: readonly string[]): PendingMerge | null;
-/**
- * Carry new conversation messages to every room that follows one: the
- * lead's replies, teammates' messages (never the room's own), and each
- * reply's pending cards, as ordinary parts sent to the room's channel. A
- * room is a grant from one exact pairing and is rechecked before each
- * message; a room nobody paired can carry waits.
- */
-export declare function planRoomMessages(options: ChatDeliveryOptions): Promise<void>;
-/** One progress card per exact result; separate urgent facts retain their own review link. */
-export declare function planChatNotifications(options: ChatDeliveryOptions): Promise<void>;
-export {};

package/dist/chat-display.d.ts

@@ -1 +0,0 @@
-export declare function publicChatText(value: string, cap: number): string;

package/dist/chat-evidence.d.ts

@@ -1,123 +0,0 @@
-import type { Artifact, Run, Store } from "./store.js";
-import type { VerifiedApprover } from "./principal.js";
-/** How many images one turn may select for delivery; more is a flood, not an answer. The rest are one more ask away, by offset or by id. */
-export declare const RESULT_IMAGES_PER_TURN_CAP = 8;
-/** Which of a result's images one ask selects: a page from an offset, or exact image ids from an earlier listing. Absent: the first page. */
-export type ResultImagePick = {
-    offset?: number;
-    images?: readonly number[];
-};
-export type ResultImage = {
-    artifact: number;
-    sha256: string;
-    format: "png" | "jpeg";
-    bytes: number;
-    /** 1-based position among the result's deliverable images, and their count. */
-    ordinal: number;
-    total: number;
-    /** The short caption a channel sends with the file: task, result, position. No title, path or prose. */
-    caption: string;
-    /** The file name a channel uploads under: task and result identity, never a path. */
-    fileName: string;
-};
-export type ResultImageSelection = {
-    task: string;
-    /** The task as a caption or file name shows it: the id when it is plain, a stable opaque label when it is credential-shaped. */
-    label: string;
-    root: string;
-    currentExecution: string;
-    run: number;
-    role: Run["role"];
-    title: string;
-    /** Every deliverable image of the result, in evidence order, each with its position. */
-    images: ResultImage[];
-    /** The images THIS ask selects for delivery: at most the per-turn cap, in evidence order. */
-    selected: ResultImage[];
-    /** Where the next page starts when the selection stopped short of the last image; null when nothing remains after it. */
-    nextOffset: number | null;
-    /** Screenshot records that exist but cannot be delivered, each with its plain reason. */
-    unavailable: {
-        artifact: number;
-        problem: string;
-    }[];
-    /** The run delivered a report (a scout): images are not the point of this result. */
-    report: boolean;
-};
-type Problem = {
-    ok: false;
-    message: string;
-};
-/** The plain words for a screenshot record that must not travel. Null means the record itself is fine. */
-export declare function screenshotRecordProblem(artifact: Artifact): string | null;
-/** Telegram's own caption ceiling for a document (Bot API sendDocument, checked 2026-09-16). Ours are far shorter by construction. */
-export declare const RESULT_IMAGE_CAPTION_MAX_CHARS = 1024;
-/**
- * Is this text safe to show a third-party transport as identity? Nothing
- * credential-shaped, nothing that steers a terminal or a renderer, nothing
- * longer than an id may be. A caption or file name shows only what passes.
- */
-export declare function displayIdentityProblem(text: string): string | null;
-/**
- * The task as a caption or file name may show it. A plain id is itself,
- * with any character a file name cannot hold replaced. A credential-shaped
- * id (a task filed under a token-like name, on purpose or by accident) is
- * never repeated to Telegram: it shows as a stable opaque label instead,
- * while the exact id stays in the typed part, the bindings and the link.
- */
-export declare function resultTaskLabel(taskId: string): string;
-/** The caption: the task's display label, the exact result and the position — identity a person can read, nothing a person or a model typed. */
-export declare function resultImageCaption(task: string, run: number, ordinal: number, total: number, current: boolean): string;
-/** The upload name: task label, result and artifact identity — derivable from the typed part alone, never a path. */
-export declare function resultImageFileName(task: string, run: number, artifact: number, format: "png" | "jpeg"): string;
-/**
- * A persisted caption, checked again at send and retry time: a row planned
- * before this rule, or one edited by hand, may carry the raw task id. A
- * caption that would show a credential, a control character or more than
- * Telegram's ceiling is rebuilt from the part's typed identity instead —
- * the exact task and run stay bound; only the words on the wire change.
- */
-export declare function safeResultImageCaption(text: string, taskId: string, run: number): string;
-/** The page or the exact ids one ask selects from a result's images; a refusal names what to choose instead. */
-export declare function pickResultImages(images: readonly ResultImage[], pick: ResultImagePick | undefined, cap: number): {
-    ok: true;
-    selected: ResultImage[];
-    nextOffset: number | null;
-} | Problem;
-/**
- * Select the images of precisely the result named. With no run, the latest
- * finished result of THAT execution — and only while it is the current
- * version: a newer revision is said, never switched to. A run must belong
- * to the task and have finished; a role that delivers no images (a
- * reviewer, a planner) is not a result at all. Every deliverable image is
- * listed with its position; `selected` is the page (or the exact ids) this
- * ask delivers, at most the per-turn cap, and `nextOffset` says where the
- * rest begins so the remaining images are one more ask away, never lost.
- */
-export declare function selectResultImages(store: Store, who: VerifiedApprover, evidenceRoot: string | undefined, task: string, run?: number, pick?: ResultImagePick): {
-    ok: true;
-    selection: ResultImageSelection;
-} | Problem;
-/**
- * The send-time proof, run immediately before EVERY upload including
- * retries: the task is still in the projects this channel may reach now,
- * the run still belongs to it and finished, the artifact row is still the
- * one the part was planned from (same run, same recorded hash — a changed
- * record is a changed provenance, refused), and the bytes read now still
- * verify and are still a bounded PNG or JPEG. Returns the original bytes;
- * nothing is transformed.
- */
-export declare function verifyResultImage(store: Store, evidenceRoot: string, repos: readonly string[], part: {
-    taskId: string;
-    run: number;
-    artifact: number;
-    sha256: string;
-}): {
-    ok: true;
-    bytes: Buffer;
-    format: "png" | "jpeg";
-    artifact: Artifact;
-} | {
-    ok: false;
-    problem: string;
-};
-export {};

package/dist/chat-flow.d.ts

@@ -1,70 +0,0 @@
-import type { ChatProvider } from "./contracts/chat-tables.js";
-import { type ChatBinding, type ChatContent, type ChatEvent, type ChatState } from "./chat-delivery-state.js";
-import type { Store } from "./store.js";
-export type ChatFlowAction = "approve" | "edit" | "send-back";
-export declare const CHAT_FLOW_LABELS: Record<ChatFlowAction, string>;
-/** Words kept as written, line breaks and all; only control characters go. */
-export declare function chatFlowText(text: string): string;
-type ChatApp = ChatProvider;
-/** A "Send to me" notice as chat parts: what was done, then its links; null when it isn't one. */
-export declare function flowSendParts(store: Store, notification: {
-    dedupeKey: string;
-    subject: string;
-    body: string;
-}, app?: ChatApp): ChatContent[] | null;
-/**
- * A "flow-decision" notice as chat parts, or null when it isn't one (or the
- * card has already moved on, and there is nothing left to decide).
- */
-export declare function flowDecisionParts(store: Store, notification: {
-    dedupeKey: string;
-    subject: string;
-    body: string;
-    link: string | null;
-}, app?: ChatApp): ChatContent[] | null;
-/** The live buttons on one part, in the order they were minted: a decision's, a choice's options in their order, or
- * "Use this as your note?" Yes / No. `key` is unique on the part (Slack names each button by it). */
-export declare function chatFlowButtons(state: ChatState, part: number, now: Date): Array<{
-    token: string;
-    action: ChatFlowAction | "choose" | "note";
-    label: string;
-    key: string;
-}>;
-/**
- * A tapped flow button, inside the action's transaction. false when the
- * token isn't a flow button (the caller looks for a proposal's); otherwise
- * the event is finished and anything to say is planned on it.
- */
-export declare function applyChatFlowTap(options: {
-    store: Store;
-    state: ChatState;
-    label: string;
-}, event: ChatEvent, binding: ChatBinding, token: string, repos: readonly string[], now: Date): boolean;
-/**
- * A message in the person's own chat while one of their choices waits. Only a reply in the Choose notice's thread (Slack,
- * Discord) is the note. Any other message there is the lead's, except the first one after a choice that takes replies:
- * that one is asked about, once — "Use this as your note?" — and only Yes makes it the note (No passes it on to the lead).
- * false when the message isn't about a choice at all.
- */
-export declare function answerChoiceMessage(options: {
-    store: Store;
-    state: ChatState;
-    label: string;
-}, event: ChatEvent, binding: ChatBinding, input: {
-    text: string;
-    originalLength?: number;
-    lead?: boolean;
-}, now: Date, repos: readonly string[]): boolean;
-/**
- * A message from the person while a prompt is open: the new draft or the
- * note. false when no prompt is open (the message goes on as usual).
- */
-export declare function answerChatFlowPrompt(options: {
-    store: Store;
-    state: ChatState;
-    label: string;
-}, event: ChatEvent, binding: ChatBinding, input: {
-    text: string;
-    originalLength?: number;
-}, repos: readonly string[], now: Date): boolean;
-export {};