toolroll 0.5.0

package/dist/chat-channel.d.ts

@@ -0,0 +1,109 @@
+import type { DoorOutcome } from "./mate-doors.js";
+import { type VerifiedApprover } from "./principal.js";
+import type { ChatConfig, MateProposal, MateSession, MateThread, Store, SubscriptionChatProviderId } from "./store.js";
+export declare function channelRepos(store: Store, approver: string, registry: readonly string[]): string[];
+export type ResolvedMate = {
+    ok: true;
+    who: VerifiedApprover;
+    session: MateSession;
+    thread: MateThread;
+    config: ChatConfig & {
+        provider: SubscriptionChatProviderId;
+    };
+} | {
+    ok: false;
+    reason: "unpaired" | "unconfigured" | "direct-api" | "no-projects" | "session-mismatch" | "thread-mismatch";
+    said: string | null;
+};
+/**
+ * The session and thread a paired phone speaks in: the approver's live
+ * session when it is compatible (same generation, same membership
+ * credential, same ceiling), else one minted under the very terms the
+ * console and CLI state for membership chat (no dollar ceiling, this
+ * ceiling digest) — and only when NO session is live, because minting
+ * ends the previous one and an unrelated console conversation is not
+ * this phone's to end. The same rule for the thread: reused when its
+ * ceiling matches, never closed from here.
+ */
+export declare function resolveChannelMate(store: Store, binding: {
+    approver: string;
+    approverGeneration: number;
+}, repos: readonly string[], now: Date): ResolvedMate;
+/** A phone exchange about one task (a reply to that task's or result's
+ * message) stays in the lead conversation, and is kept in the task's own
+ * chat as well, so the task shows everything asked of it wherever it was
+ * asked. Best effort: the phone conversation never depends on it. */
+export declare function mirrorToTaskChat(store: Store, who: VerifiedApprover, taskId: string, surface: string, message: string, reply: string, now: Date): void;
+export declare function tooLongText(length: number): string;
+/** A reply to a message about several tasks is never guessed: it names them and says how to choose. */
+export declare function whichTaskText(titles: readonly string[]): string;
+/** The server-authored context a reply to a result message carries into the turn — the exact execution and run, never a guess. */
+export declare function replyContextFor(taskId: string, run: number | null): string;
+/** The context a chosen task (/tasks, /task <name>) carries into each turn from that chat. */
+export declare function focusContextFor(taskId: string): string;
+/** No trusted https origin is configured: one honest line, no localhost, no promise. */
+export declare const NO_PHONE_LINK = "Phone access isn't configured. Open Toolroll on your computer.";
+/** An origin exists but the card's task is not one this phone may reach now: said as that, never as missing setup. */
+export declare const NO_TASK_LINK = "No phone link: this task is outside your connected projects now, so open Toolroll on the computer.";
+/** A fixed console destination beside its button label. The path is one of chat-controls' own; the origin joins it only at send time. */
+export type PhoneLink = {
+    label: string;
+    path: string;
+};
+/** Is this task one the phone's ceiling admits right now? A link names a stored identity, never a model's word alone. */
+export declare function taskInCeiling(store: Store, taskId: string, repos: readonly string[]): boolean;
+/**
+ * The link a PENDING card carries: only the handoff kinds (cancel, a console
+ * control), whose whole point is where to go. Confirmable cards keep their
+ * Confirm/Dismiss buttons alone — a second button on a card that acts is a
+ * choice the operator did not need.
+ */
+/** A chat transport that renders cards and confirms them in place. The
+ * console ("web") and the terminal are not chat channels. */
+export type ChatChannelName = "telegram" | "slack" | "discord" | "teams";
+/** The card text once its challenge is armed: an irreversible answer or a
+ * challenge action, in the same words on every channel. */
+export declare function armedCardText(proposal: MateProposal, previewText: string): string;
+/** The "yes" button's label for an armed card. */
+export declare function armedYesLabel(proposal: MateProposal): string;
+export declare function proposalLink(store: Store, proposal: MateProposal, repos: readonly string[], channel?: ChatChannelName | null): PhoneLink | null;
+/**
+ * The link a CONFIRMED card carries: the exact recorded task the outcome
+ * names, where its remaining step lives — the approval control while the
+ * scope waits for one (a manual approval), the task otherwise (an
+ * automatic approval, a staged resume). Kinds whose outcome is complete
+ * carry none.
+ */
+export declare function confirmedLink(store: Store, outcome: DoorOutcome, proposal: MateProposal, repos: readonly string[]): PhoneLink | null;
+/** The card: plain words for what confirming does, the exact terms it binds to, and whether a button belongs on it. */
+export declare function proposalPreview(store: Store, proposal: MateProposal, repos: readonly string[], channel?: ChatChannelName | null): {
+    text: string;
+    buttons: boolean;
+};
+/** The card after it resolves, from the recorded outcome — the same words every surface shows. */
+export declare function proposalOutcomeText(proposal: MateProposal): string;
+export type ParitySupport = "direct" | "handoff" | "missing";
+/**
+ * One row per mate tool: how the paired phone reaches it. `direct` means
+ * the same engine tool or the same confirm door runs from Telegram;
+ * `handoff` means the phone shows where the existing authenticated
+ * control lives and does nothing itself; `missing` means no phone path
+ * yet. The test suite refuses a tool this table does not name, and the
+ * committed matrix document must agree with it line for line.
+ */
+export declare const CHAT_ACTION_PARITY: Record<string, {
+    support: ParitySupport;
+    how: string;
+    gap: string | null;
+}>;
+/** Every tool the model can call, mapped; a new tool must name its phone road. */
+export declare function parityGaps(): string[];
+export declare function handoffCardText(text: string, note: string | null): string;
+/**
+ * The resolved card, from what is RECORDED about the task the outcome
+ * names — never from a word search over the door's sentence. A scope that
+ * still waits for approval has one next action: approve it (the button, or
+ * the console on the computer when no link exists). A scope approved under
+ * a signed mode asks for nothing more. A staged resume says what remains.
+ */
+export declare function confirmedCardText(store: Store, outcome: DoorOutcome, proposal: MateProposal, note: string | null): string;