toolroll 0.9.54 → 0.9.56

package/dist/server/remote.d.ts

@@ -1,14 +1,13 @@
-import type { Registration } from './handler-registry.js';
 /** tasks handlers, moved without changing their route bodies. */
-import { type IncomingMessage, type ServerResponse } from "node:http";
+import { type IncomingMessage } from "node:http";
 import { CodingWorkspace } from '../coding-workspace.js';
 import { type Principal } from "../operate-remote.js";
 import { RequestBudget, SourceAdmission, type Admission } from "../request-budget.js";
 import { type Store } from "../store.js";
 import type { TeamResponse } from '../team-contract.js';
-import type { EdgeContext } from './handler-context.js';
 import { type RemoteHookContext } from "./remote-hooks.js";
-import { type ServeOptions, type Who } from "./shared.js";
+import { type ServeOptions } from "./http.js";
+import { type Who } from "./session.js";
 export interface RemoteRuntime {
     identify: (request: IncomingMessage, touch?: boolean, limited?: boolean, refusedToken?: {
         principal?: Principal;
@@ -32,7 +31,6 @@ export interface RemoteRuntime {
         name: string;
         generation: number;
     }, csrf: string) => TeamResponse;
-    teamStreams: Set<ServerResponse<IncomingMessage>>;
     requestBudget: RequestBudget;
     options: ServeOptions;
     coding: CodingWorkspace | null;
@@ -54,6 +52,5 @@ export interface RemoteRuntime {
     teamsTenantBudget: SourceAdmission;
 }
 export declare function createRemoteHandlers(runtime: RemoteRuntime): {
-    registrations: Registration[];
-    edge: (ctx: EdgeContext) => Promise<void>;
+    registrations: import("./handler-registry.js").Registration[];
 };

package/dist/server/remote.js

@@ -1,3 +1,4 @@
+import { handlersOf } from './handler-registry.js';
 /** tasks handlers, moved without changing their route bodies. */
 import {} from "node:http";
 import { handleCliHttp } from '../cli-http.js';
@@ -13,9 +14,10 @@ import {} from "../store.js";
 import { handleTeamHttp, TEAM_PASSWORD_REVERIFY_MS } from '../team-http.js';
 import { handleTeamsHttp } from "../teams.js";
 import { flowHook, telegramHook } from "./remote-hooks.js";
-import { respond } from "./shared.js";
+import { respond } from "./http.js";
+import {} from "./session.js";
 export function createRemoteHandlers(runtime) {
-    const { identify, store, admitPasswordSource, admitBearer, allowedHost, team, teamBrowserReply, teamStreams, requestBudget, options, coding, codingProjects, liveCeiling, clock, evidenceRoot, consoleOrigin, managedRepos, joinSourceOf, ssoSettings, SSO_FRESH_MS, oauthTokenBudget, hookContext, teamsSourceBudget, teamsTenantBudget } = runtime;
+    const { identify, store, admitPasswordSource, admitBearer, allowedHost, team, teamBrowserReply, requestBudget, options, coding, codingProjects, liveCeiling, clock, evidenceRoot, consoleOrigin, managedRepos, joinSourceOf, ssoSettings, SSO_FRESH_MS, oauthTokenBudget, hookContext, teamsSourceBudget, teamsTenantBudget } = runtime;
     /**
      * The full principal a live `so_` API token stands for: its person and their generation, the token's own read/act
      * scope, its project limit narrowed by the person's current access, and its id. Every route that accepts an API token
@@ -93,7 +95,7 @@ export function createRemoteHandlers(runtime) {
                 return reply;
             const who = identify(request, false);
             return who?.via === 'cookie' ? teamBrowserReply(reply, actor, who.session.csrf) : reply;
-        }, cursor: team.cursor, streams: teamStreams,
+        },
     });
     // Remote CLI: one live API token names the person; the shared command boundary decides everything else.
     const cliEndpoint = (request, response) => handleCliHttp(request, response, {
@@ -130,71 +132,38 @@ export function createRemoteHandlers(runtime) {
         projectsFor: account => store.knownRepos().filter(repo => store.accountCanAccess(account, repo)).sort(),
         admitToken: request => oauthTokenBudget.admit(joinSourceOf(request)),
     });
-    async function edge(ctx) {
-        const { request, response, url, route } = ctx;
-        switch (route.id) {
-            case 'edge.telegram-hook': return telegramHook(hookContext, request, response);
-            case 'edge.flow-hook':
-            case 'edge.flow-form':
-            case 'edge.flow-form-send': return flowHook(hookContext, request, response, url);
-            case 'edge.mcp': return mcpHttp(request, response);
-            case 'edge.oauth-discovery':
-            case 'edge.oauth-register':
-            case 'edge.oauth-token':
-            case 'edge.oauth-authorize':
-            case 'edge.oauth-consent':
-                await oauthHttp(request, response, url);
-                return;
-            case 'edge.sessions-list':
-            case 'edge.sessions-show':
-            case 'edge.sessions-changes':
-            case 'edge.sessions-start':
-            case 'edge.sessions-send':
-            case 'edge.sessions-stop':
-            case 'edge.sessions-resume':
-            case 'edge.sessions-recover':
-                await sessionEndpoint(request, response);
-                return;
-            case 'edge.team-read':
-            case 'edge.team-send':
-            case 'edge.team-events':
-                await teamEndpoint(request, response);
-                return;
-            case 'edge.cli':
-                await cliEndpoint(request, response);
-                return;
-            case 'edge.teams':
-                if (options.configDir !== undefined && await handleTeamsHttp(request, response, { store, dir: options.configDir, ...(options.teamsFetcher ? { fetcher: options.teamsFetcher } : {}), clock,
-                    admitSource: request => teamsSourceBudget.admit(joinSourceOf(request)), admitTenant: tenant => teamsTenantBudget.admit(tenant) }))
-                    return;
-                return respond(response, 404, 'text/plain; charset=utf-8', 'No such address.');
-        }
-        throw new Error('Unregistered remote route');
-    }
-    const registrations = [
-        { id: "edge.telegram-hook", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.flow-form", domain: "remote", stage: "edge", method: "GET,HEAD", handle: edge },
-        { id: "edge.flow-form-send", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.flow-hook", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.mcp", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.oauth-discovery", domain: "remote", stage: "edge", method: "GET,HEAD", handle: edge },
-        { id: "edge.oauth-register", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.oauth-token", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.oauth-authorize", domain: "remote", stage: "edge", method: "GET,HEAD", handle: edge },
-        { id: "edge.oauth-consent", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.sessions-list", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.sessions-show", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.sessions-changes", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.sessions-start", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.sessions-send", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.sessions-stop", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.sessions-resume", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.sessions-recover", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.team-read", domain: "remote", stage: "edge", method: "GET", handle: edge },
-        { id: "edge.team-send", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.team-events", domain: "remote", stage: "edge", method: "GET", handle: edge },
-        { id: "edge.cli", domain: "remote", stage: "edge", method: "POST", handle: edge },
-        { id: "edge.teams", domain: "remote", stage: "edge", method: "POST", handle: edge },
-    ];
-    return { registrations, edge };
+    const teams = async ({ request, response }) => {
+        if (options.configDir !== undefined && await handleTeamsHttp(request, response, { store, dir: options.configDir, ...(options.teamsFetcher ? { fetcher: options.teamsFetcher } : {}), clock,
+            admitSource: request => teamsSourceBudget.admit(joinSourceOf(request)), admitTenant: tenant => teamsTenantBudget.admit(tenant) }))
+            return;
+        return respond(response, 404, 'text/plain; charset=utf-8', 'No such address.');
+    };
+    // D5: native coding sessions and the central team service are deprecated (still served this release); each
+    // answer says so in a Deprecation header (RFC 9745).
+    // Each protocol adapter keeps its own operation boundary; every row still names its own entry.
+    const registrations = handlersOf("remote", {}, {
+        "edge.telegram-hook": async ({ request, response }) => { await telegramHook(hookContext, request, response); },
+        "edge.flow-form": async ({ request, response, url }) => { await flowHook(hookContext, request, response, url); },
+        "edge.flow-form-send": async ({ request, response, url }) => { await flowHook(hookContext, request, response, url); },
+        "edge.flow-hook": async ({ request, response, url }) => { await flowHook(hookContext, request, response, url); },
+        "edge.mcp": async ({ request, response }) => { await mcpHttp(request, response); },
+        "edge.oauth-discovery": async ({ request, response, url }) => { await oauthHttp(request, response, url); },
+        "edge.oauth-register": async ({ request, response, url }) => { await oauthHttp(request, response, url); },
+        "edge.oauth-token": async ({ request, response, url }) => { await oauthHttp(request, response, url); },
+        "edge.oauth-authorize": async ({ request, response, url }) => { await oauthHttp(request, response, url); },
+        "edge.oauth-consent": async ({ request, response, url }) => { await oauthHttp(request, response, url); },
+        "edge.sessions-list": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
+        "edge.sessions-show": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
+        "edge.sessions-changes": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
+        "edge.sessions-start": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
+        "edge.sessions-send": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
+        "edge.sessions-stop": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
+        "edge.sessions-resume": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
+        "edge.sessions-recover": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await sessionEndpoint(request, response); },
+        "edge.team-read": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await teamEndpoint(request, response); },
+        "edge.team-send": async ({ request, response }) => { response.setHeader('Deprecation', 'true'); await teamEndpoint(request, response); },
+        "edge.cli": async ({ request, response }) => { await cliEndpoint(request, response); },
+        "edge.teams": teams,
+    });
+    return { registrations };
 }

package/dist/server/render-chat.d.ts

@@ -0,0 +1,402 @@
+import { type AssignmentSnapshot } from "../assignment.js";
+import { type BrowserActionCard } from "../browser-workspace.js";
+import { type ChatDraft } from "../converse.js";
+import { type DispatchDiagnosis } from "../dispatch.js";
+import { type LeadLiveStep } from "../lead-progress.js";
+import { type FailureExplanation } from "../needs-you.js";
+import { type Scope } from "../scope.js";
+import { type ChatConfig, type ChatProviderId, type ChatSnapshot, type ChatTurn, type CheckProgress, type CoordinatorProposal, type Decision, type DirectChatProviderId, type LeadAsk, type LeadMessage, type LeadProposal, type LeadSession, type LeadTurn, type Publication, type RepairChainRow, type Store, type SubscriptionChatProviderId, type TaskFamily, type TaskState } from "../store.js";
+import { type TaskControlView } from "../task-control.js";
+import { type TeamChatProviderResolver } from "../team-chat-authorization.js";
+import { type TeamSnapshot } from "../team-contract.js";
+import { type DisplayStatus } from "../workspace-ui.js";
+import { type Html } from "../html.js";
+import { type Chrome, type Screen } from "./chrome.js";
+import { type ProjectPeek } from "./render-pages.js";
+import { type CompletionReceiptView } from "./render-results.js";
+import { type MilestoneProgressView, type PlanContractView, type PlanRevisionLedgerView, type RevisionView, type RouteView } from "./render-tasks.js";
+/** The installation fact that the lead was turned on by default, once (its value: the provider). */
+export declare const LEAD_BY_DEFAULT_FACT = "lead-on-by-default";
+/** The installation fact that the phone card was put away. */
+export declare const PHONE_CARD_FACT = "phone-card-dismissed";
+export type ChatProjectPulse = {
+    id: string;
+    label: string;
+    path: string;
+    peek: ProjectPeek | null;
+};
+/** A task attached by the server to one chat turn. The thread remains the
+ * unified conversation; this is a focused lens, not a second chat silo. */
+export type TaskChatFocus = {
+    executionId: string;
+    /** A failed task: what its latest attempt missed and what to change (the task page's own words). */
+    failure?: FailureExplanation | null;
+    /** Until this installation's first Ready result, the task shows where it stands on Plan → You approve → Build → Checks → Ready. */
+    guide?: boolean;
+    family: TaskFamily;
+    history: Html;
+    status: DisplayStatus;
+    assignment: AssignmentSnapshot | null;
+    id: string;
+    title: string;
+    state: TaskState;
+    project: string | null;
+    now: Date;
+    dispatch: DispatchDiagnosis | null;
+    scope: "none" | "needs approval" | "approved";
+    plan: "requested" | "drafted" | null;
+    /** Adaptive execution plans (v44): the identical ledger/progress
+     * projection the task page renders (c2). */
+    planRevisions: PlanRevisionLedgerView | null;
+    milestoneProgress: MilestoneProgressView[] | null;
+    claimed: boolean;
+    liveRun: {
+        id: number;
+        runner: string;
+        startedAt: string;
+        phase: string | null;
+    } | null;
+    checkProgress: CheckProgress | null;
+    /** v52: the exact-run control — the task page's own projection. */
+    control: TaskControlView;
+    /** The phase route (v47): the task page's exact projection, so chat and
+     * page can never disagree about which agent runs which phase. */
+    route: RouteView | null;
+    /** Approval uses the task page's exact nonce and joint digest. */
+    approval: {
+        scope: Scope;
+        nonce: string;
+        digest: string;
+        planDocument: string | null;
+        /** The drafted plan's contract record (contract handoff, task 1): the
+         * same panel the task page and /next show inside the ceremony. */
+        planContract: PlanContractView | null;
+        deliverable: "branch" | "report";
+        revision: RevisionView | null;
+        coordinator: {
+            label: string;
+            filedAgo: string | null;
+        } | null;
+        /** The repair chain row when this task is a machine-drafted repair. */
+        repairChain: RepairChainRow | null;
+    } | null;
+    decisions: (Decision & {
+        taskId: string;
+        repo: string | null;
+    })[];
+    publication: Publication | null;
+    /** The same compact, evidence-backed receipt shown on the task page.
+     * Chat is a lens over durable workflow state, never a second copy. */
+    result: CompletionReceiptView | null;
+};
+/** The task composer's modes (console v2), as the words the lead reads for that one turn. */
+export type TaskComposerMode = "build" | "plan" | "answer";
+export declare const TASK_COMPOSER_MODES: Record<TaskComposerMode, string>;
+export declare function taskChatContext(focus: TaskChatFocus): Html;
+export declare function taskChatApproval(focus: TaskChatFocus, csrf: string): Html;
+/** The chat's status sentence, worded as the task page words it: what a failed attempt missed, or which step a live
+ * build is on (and the step it is stuck on). Undefined keeps the shared status sentence. */
+export declare function chatStatusSentence(focus: TaskChatFocus): string | undefined;
+/** One live, server-derived journey from request to proof. The fragment is
+ * safe to refresh independently, so an in-progress message is never lost. */
+export declare function taskChatLiveRegion(focus: TaskChatFocus, csrf: string, fragment?: boolean, inert?: boolean, approvalHref?: string): Html;
+/** The first task's way to Ready, filled in as it moves (onboarding): the same stage every surface reads. */
+export declare function firstTaskJourneyHtml(focus: TaskChatFocus): Html;
+export declare function taskChatHeading(focus: TaskChatFocus): Html;
+export declare function chatWorkspace(content: Html, projects: readonly ChatProjectPulse[], inert: boolean, focus: TaskChatFocus | null, resultPanel?: Html | null): Html;
+/** The folded overview's one-line summary (UI polish 2026-09-13): the
+ * two counts a phone reader scans before deciding to open it. */
+export declare function chatOverviewSummaryHtml(projects: readonly ChatProjectPulse[], attention?: {
+    count: number;
+    saturated: boolean;
+}): Html;
+/** A live, server-derived portfolio card. It is deliberately independent
+ * of the model's prose: the numbers and links always reflect the current
+ * control plane, while chat remains the place to ask what they mean. */
+export type AssignmentChatSnapshot = ChatSnapshot & {
+    assignmentStates?: Record<string, {
+        state: AssignmentSnapshot['state'];
+        label: string;
+        detail: string;
+    }>;
+    attentionCount?: {
+        count: number;
+        saturated: boolean;
+    };
+};
+export declare function chatFleetOverview(snapshot: AssignmentChatSnapshot | null, projects: readonly ChatProjectPulse[], interactive: boolean): Html;
+/**
+ * The lead's project rail: one bounded pulse per admitted project, plus
+ * two roads that preserve the plane's contracts. "ask" sends the stable
+ * rN alias the model already sees; "board" uses the existing POST switch
+ * instead of smuggling a project change through a GET parameter.
+ */
+export declare function chatProjectRail(projects: readonly ChatProjectPulse[], inert: boolean): Html;
+/** Spend-authorized one-click questions: ordinary /chat posts, not a new door. */
+export declare function leadPromptStarters(focus?: TaskChatFocus | null): Html;
+export declare function chatHeading(copy: string, projectCount: number, showProjectToggle?: boolean): Html;
+/** A deliberately small rich-text grammar for model copy. The reply is shaped first (the lead's voice, enforced:
+ * no headers, at most three bold anchors, labelled links, no internal ids unless `asked` wanted them); input is
+ * escaped before tags are introduced: bullets, numbered steps, bold, inline code and labelled http(s) links are
+ * presentation only—never executable HTML. */
+export declare function renderChatText(raw: string, asked?: string): Html;
+export declare function chatActivity(activity: string | null): Html;
+export declare const CHAT_UI_SCRIPT: string;
+/** Provider, model, and limits under ONE disclosure (UI polish
+ * 2026-09-13): the facts stay one tap away on every chat surface, and a
+ * membership never shows a dollar figure as if it were a charge. */
+export declare function chatLimitsHtml(facts: {
+    provider: string;
+    model: string;
+    turnsToday: number;
+    dailyTurns: number;
+    subscription: boolean;
+    weekly: {
+        spent: number;
+        ceiling: number;
+    } | null;
+}): Html;
+export declare function chatPage(chrome: Chrome, data: {
+    enabled: ({
+        ok: true;
+    } & Record<string, unknown>) | {
+        ok: false;
+        why: string;
+    };
+    pending: ChatTurn | null;
+    latched: ChatTurn[];
+    chat: {
+        candidates: Map<string, {
+            key: string;
+            draft: ChatDraft;
+            repoPath: string;
+        }>;
+        lastTurn: {
+            id: number;
+            reply: string | null;
+            staticError: string | null;
+            proposalsDiscarded: boolean;
+        } | null;
+    } | null;
+    recent: ChatTurn[];
+    turnsToday: number;
+    weeklySpent: number;
+    projects: ChatProjectPulse[];
+    fleetSnapshot: AssignmentChatSnapshot | null;
+    catchUp?: Html;
+    /** Optional task lens into the same unified conversation. */
+    focusTask: TaskChatFocus | null;
+    canManage: boolean;
+    config: import("../store.js").ChatConfig | null;
+    /** Where each provider's key comes from — never the key itself. */
+    keyFacts: {
+        provider: string;
+        state: "environment" | "stored" | "none";
+        tail: string | null;
+    }[];
+    /** OpenRouter's live catalog when the key is present and reachable. */
+    openrouterModels: string[] | null;
+    /** Claude and Codex models from the saved live catalog, labelled with prices. */
+    liveModels?: {
+        value: string;
+        label: string;
+    }[];
+    csrf: string;
+    problem: string | null;
+    /** The card that mints a mate session (mate arc §5), approvers only. */
+    leadMint?: Html;
+    /** Pending coordinator proposals as cards (mate arc v3), approvers only. */
+    coordinatorProposals?: Html;
+    /** The task's result detail (package 3), when the URL opened one. */
+    resultPanel?: Html | null;
+    /** Opened from "Chat settings": show them expanded. */
+    settingsOpen?: boolean;
+    /** Chat's first run is on the page: it already says what to do while there is no lead. */
+    firstRunShown?: boolean;
+}): Screen;
+export declare function chatAckPage(chrome: Chrome, turn: ChatTurn, nonce: string): Screen;
+/** The card that starts a conversation: the one password ceremony (mate arc §1). */
+export declare function leadMintCard(enabled: {
+    billing: "metered" | "subscription";
+    config: {
+        provider: ChatProviderId;
+        weeklyCeilingMicrousd: number;
+    };
+}, returnTo?: string): Html;
+/** The decisions the cards on a page name, for the answer card's consequences and the builder's recommendation. */
+export declare function decisionsFor(store: Store, proposals: readonly {
+    kind: string;
+    payload: Record<string, unknown>;
+}[]): Map<number, Decision>;
+export type ProposalCardView = {
+    id: number;
+    kind: LeadProposal["kind"];
+    payload: Record<string, unknown>;
+    state: string;
+    outcome: Record<string, unknown> | null;
+    /** Who proposed: the mate, or a coordinator by name. */
+    by: {
+        mate: true;
+    } | {
+        mate: false;
+        name: string;
+        ago: string;
+    };
+    /** Where confirm/dismiss post: `/chat/proposal` for the lead's, `/proposals` for a coordinator's. */
+    actionBase: string;
+};
+/**
+ * A proposal card: what, then confirm/dismiss, or the door's answer. An
+ * `answer` card shows the question, every option WITH its consequence,
+ * the builder's recommendation beside the proposer's pick, and — for an
+ * irreversible option — the explicit confirmation field the decision
+ * page itself uses (ruling 12).
+ */
+export declare function proposalCard(view: ProposalCardView, inert: boolean, decision: Decision | null, returnTo?: string | null): Html;
+/** The card's HTML and, for the chat's confirm-in-place cards, the same
+ * card as data: the body is the HTML's own, the act is the same door. */
+export declare function proposalCardParts(view: ProposalCardView, inert: boolean, decision: Decision | null, returnTo?: string | null): {
+    html: Html;
+    card: BrowserActionCard;
+};
+export declare function leadProposalCard(proposal: LeadProposal, inert: boolean, decision: Decision | null, returnTo?: string | null): Html;
+export declare function leadProposalCardParts(proposal: LeadProposal, inert: boolean, decision: Decision | null, returnTo?: string | null): {
+    html: Html;
+    card: BrowserActionCard;
+};
+/** Review and inline team cards share the same server-decided controls and reasons. The team API renders these
+ * outside a console request, so the session's own `csrf` is given to the forms here. */
+export declare function teamProposalCardParts(store: Store, actor: {
+    name: string;
+    generation: number;
+}, proposal: LeadProposal, snapshot: TeamSnapshot, csrf: string, decision: Decision | null, now: Date, provider: TeamChatProviderResolver): {
+    html: Html;
+    card: BrowserActionCard;
+};
+export declare function coordinatorProposalCard(proposal: CoordinatorProposal, now: Date, decision: Decision | null, returnTo?: string | null): Html;
+/** The section shared by /chat (both modes) and the task page: pending coordinator proposals as cards. */
+export declare function coordinatorProposalsSection(proposals: readonly CoordinatorProposal[], decisions: Map<number, Decision>, now: Date, heading?: boolean, returnTo?: string | null): Html;
+/** The lead thread a change in reachable projects closed (mate arc ruling 9): its saved words and card outcomes, never continued. */
+export type ReplacedThread = {
+    messages: LeadMessage[];
+    proposals: LeadProposal[];
+    decisions: Map<number, Decision>;
+};
+export declare const REPLACED_THREAD_DIVIDER = "New conversation \u2014 the projects I can reach changed";
+/** The replaced thread as the React conversation renders it: words and card outcomes, no buttons. */
+export declare function replacedBrowserMessages(previous: ReplacedThread): import("../browser-workspace.js").BrowserMessage[];
+/** The replaced thread for the server-rendered page: read only, then the divider. */
+export declare function replacedThreadHtml(previous: ReplacedThread | null | undefined): Html;
+export type LeadThreadRows = {
+    /** The lead thread a change in reachable projects replaced; shown only. */
+    previous?: ReplacedThread | null;
+    messages: LeadMessage[];
+    proposals: LeadProposal[];
+    /** The decisions the answer cards name. */
+    decisions: Map<number, Decision>;
+    coordinatorProposals: CoordinatorProposal[];
+    pending: LeadTurn | null;
+    recent: LeadTurn[];
+    /** Optional task lens into the same unified thread. */
+    focusTask: TaskChatFocus | null;
+    /** The lead's open question to this reader, drawn as buttons under its reply. */
+    ask?: LeadAsk | null;
+    /** Every question the lead asked in these messages, by turn: answered ones show their words without buttons. */
+    asks?: Map<number, LeadAsk>;
+};
+/** The lead's question as buttons: each option sends itself as the next message (the same POST as a typed one);
+ * "Something else" moves to the composer. Nothing shows while a reply is running. */
+export declare function leadAskHtml(ask: LeadAsk, target: {
+    task: string | null;
+    project: string | null;
+}, composer: string, open?: boolean): Html;
+/** The thread's messages as the React conversation renders them, each
+ * with the proposal cards its turn produced; `back` is where a card's
+ * confirm or dismiss returns. */
+export declare function leadBrowserMessages(rows: Pick<LeadThreadRows, "messages" | "proposals" | "decisions" | "pending" | "ask" | "asks">, back: string | null, target?: {
+    task: string | null;
+    project: string | null;
+}): import("../browser-workspace.js").BrowserMessage[];
+/** The version of the DISPLAYED conversation (package 2): every fact a
+ * thread or task fragment renders — message identities, card states and
+ * outcomes, the live turn and its step count, the last turn's state, the
+ * decisions the cards name, and the task lens's own facts — and nothing
+ * that merely ticks: no relative age, no freshly minted nonce, no csrf.
+ * Equal versions mean equal fragments; the poll fetches nothing else. */
+export declare function leadChatVersion(rows: LeadThreadRows): string;
+/** The thread region — the one safe region the live refresh reconciles
+ * (package 2): coordinator cards, the operator/assistant messages with
+ * their cards, the reply-in-progress card, and the starters that follow a
+ * populated thread. Every child carries a stable `data-key` so the page
+ * keeps an unchanged node (its open disclosures, its focus) and replaces
+ * only what the server rendered differently. The composer is never here. */
+export declare function leadThreadHtml(data: LeadThreadRows & {
+    csrf: string;
+    now: Date;
+    problem: string | null;
+    chatProject?: string | null;
+}): Html;
+/** What follows the composer (package 2): the starters of an EMPTY thread
+ * sit under the box; once the first message lands they move above it. */
+export declare function leadAfterComposerHtml(data: {
+    messages: LeadMessage[];
+    pending: LeadTurn | null;
+    focusTask: TaskChatFocus | null;
+}): Html;
+export declare function leadPage(chrome: Chrome, data: LeadThreadRows & {
+    session: LeadSession;
+    /** A project's own thread (v77); null for the lead conversation or a task. */
+    chatProject?: string | null;
+    follow?: {
+        enabled: boolean;
+        detail: string;
+    };
+    resultRunId?: number | null;
+    latched: ChatTurn[];
+    config: import("../store.js").ChatConfig;
+    turnsToday: number;
+    weeklySpent: number;
+    projects: ChatProjectPulse[];
+    fleetSnapshot: AssignmentChatSnapshot | null;
+    catchUp?: Html;
+    csrf: string;
+    problem: string | null;
+    now: Date;
+    /** The task's result detail (package 3), when the URL opened one. */
+    resultPanel?: Html | null;
+}): Screen;
+/** Live replies (chat streaming): per thread, the turn being answered —
+ * each step's tools in plain words and its text as it is written. Memory
+ * only and display only; the saved turn stays the record. */
+export type LiveTurn = {
+    steps: LeadLiveStep[];
+    done: boolean;
+    ok: boolean;
+    listeners: Set<() => void>;
+    expiry?: NodeJS.Timeout;
+};
+export type ChatEnablement = {
+    ok: true;
+    billing: "metered";
+    config: ChatConfig & {
+        provider: DirectChatProviderId;
+    };
+    key: string;
+    keySource: "environment" | "stored";
+    price: import("../converse.js").ModelPrice;
+    credentialKey: string;
+} | {
+    ok: true;
+    billing: "subscription";
+    config: ChatConfig & {
+        provider: SubscriptionChatProviderId;
+    };
+    key: null;
+    keySource: null;
+    price: null;
+    credentialKey: string;
+} | {
+    ok: false;
+    code: "demo" | "unscoped" | "roots" | "unresolved" | "empty" | "unconfigured" | "unpriced" | "no-key";
+    why: string;
+};