toolroll 0.9.103 → 0.9.105

package/dist/latency-timeline.d.ts

@@ -1,46 +0,0 @@
-import type { CheckReport } from "./contracts/release-check.js";
-import { type Milestone, type Store } from "./store.js";
-/** A console request slower than this keeps its timeline. */
-export declare const SLOW_REQUEST_MS = 1000;
-/** One operation's milestones as they happen, bounded (the store bounds them again when kept). */
-export declare class Timeline {
-    readonly startedAt: Date;
-    private readonly t0;
-    readonly marks: Milestone[];
-    mark(name: string, detail?: string): void;
-    elapsed(): number;
-}
-/** Keep a finished console request's timeline when it was slow. Best effort: a failed write never touches the answer. */
-export declare function keepSlowRequest(store: Store, timeline: Timeline, route: string, status: number, now: Date): void;
-/** The check's own `took:` line (scripts/release-check.mjs): each part's duration, in ms, by label. */
-export declare function partDurations(stdout: string): Map<string, number>;
-/** A release check's parts as milestones: each part that started, and its end where its duration is known. */
-export declare function checkMilestones(report: CheckReport, stdout: string): {
-    startedAt: Date;
-    totalMs: number;
-    milestones: Milestone[];
-} | null;
-/** Keep a release check's timeline beside its run. Best effort: the check's outcome never depends on it. */
-export declare function keepCheckTimeline(store: Store, args: {
-    runId: number;
-    taskId: string;
-    report: CheckReport | null;
-    stdout: string;
-    now: Date;
-}): void;
-/** "Where the time went" on the task and run page: the run's check and the task's deploys, newest first. */
-export type TimingView = {
-    title: string;
-    total: string;
-    rows: {
-        label: string;
-        at: string;
-        detail: string | null;
-    }[];
-}[];
-/** 65 s → "1:05"; 3 723 s → "1:02:03". */
-export declare function clockWords(ms: number): string;
-/** A run's check timelines and its task's deploy timelines, for the page (null: none kept). */
-export declare function timingFor(store: Store, runId: number | null, taskId: string): TimingView | null;
-/** The approver's debug view beside /healthz (/health): the slowest recent console requests, one line each. */
-export declare function slowRequestLines(store: Store, limit?: number): string[];

package/dist/lead-about.d.ts

@@ -1,35 +0,0 @@
-/** What your lead knows about you (Settings → Lead): a short list of the owner's own lasting preferences, the same
- * across projects ("keep copy terse", "I test myself"). Stored beside the lead's name and persona; only lines the
- * owner confirmed (a remember about-you card) or wrote themselves are kept, never a guess. */
-import type { Store } from "./store.js";
-export declare const ABOUT_YOU_MAX_LINES = 20;
-/** Each line is under 200 characters. */
-export declare const ABOUT_YOU_LINE_MAX = 199;
-/** This person's confirmed lines; an older store reads as none. */
-export declare function aboutYouOf(store: Store, account: string | null | undefined): string[];
-/** One line as it is saved, or the problem with it. */
-export declare function checkAboutYouLine(value: unknown): {
-    ok: true;
-    line: string;
-} | {
-    ok: false;
-    message: string;
-};
-/** The Settings form's text, one line each: the saved list, or the problem with it. Blank lines and repeats go. */
-export declare function checkAboutYou(text: string): {
-    ok: true;
-    lines: string[];
-} | {
-    ok: false;
-    message: string;
-};
-/** Save the whole list for this person (already checked). Their lead's name and persona are left as they are. */
-export declare function saveAboutYou(store: Store, account: string, lines: readonly string[], now: Date): void;
-/** The list once a confirmed line is added, or once it replaces line `replaces` (1-based). */
-export declare function withAboutYouLine(lines: readonly string[], line: string, replaces: number): {
-    ok: true;
-    lines: string[];
-} | {
-    ok: false;
-    message: string;
-};

package/dist/lead-answer-eval.d.ts

@@ -1,93 +0,0 @@
-import { type ChatConfig, type Store } from "./store.js";
-import { type VerifiedApprover } from "./principal.js";
-import { type ReplyVoice, type VoiceSummary } from "./reply-voice.js";
-import type { SubscriptionLeadRunner } from "./subscription-chat.js";
-export declare const LEAD_ANSWER_K = 3;
-type Seeded = {
-    id: string;
-    title: string;
-    state: "queued" | "running" | "done" | "failed" | "cancelled";
-};
-export declare const LEAD_ANSWER_TASKS: readonly Seeded[];
-/** A fact an answer must state: any one of its spellings (lower case). */
-type Fact = readonly string[];
-export type LeadAnswerQuestion = {
-    id: string;
-    text: string;
-    kind: "read" | "act";
-    mustName: readonly Fact[];
-    mustNot: readonly string[];
-    topic: string;
-};
-/** The 40 questions, each read question's oracle computed from LEAD_ANSWER_TASKS (the world's records). */
-export declare function leadAnswerQuestions(): LeadAnswerQuestion[];
-/** The seeded world: its store, its owner, the conversation config. */
-export declare function seedLeadAnswerWorld(now?: Date): {
-    store: Store;
-    who: VerifiedApprover;
-    config: ChatConfig;
-};
-/** How an answer did against its question's oracle. */
-export declare function gradeAnswer(question: LeadAnswerQuestion, answer: string): {
-    named: boolean;
-    falseClaims: number;
-};
-/**
- * The scripted stand-in model (CI): reads with list_tasks and list_decisions, then answers from those results alone; a
- * request without proposal tools (a quick step) asked to change something calls find_tools, as the contract tells a
- * model to search before saying something can't be done. Each step advances `clock` by the model's simulated latency.
- */
-export declare function scriptedLeadAnswerRunner(questions: readonly LeadAnswerQuestion[], clock: {
-    advance(ms: number): void;
-}, quickModel: string): SubscriptionLeadRunner;
-type Run = {
-    model: "main" | "quick";
-    route: string | null;
-    answer: string;
-    ms: number;
-    named: boolean;
-    falseClaims: number;
-    failed: string | null;
-    voice: ReplyVoice;
-};
-export type LeadAnswerReport = {
-    mode: "scripted" | "real";
-    k: number;
-    quickModel: string;
-    read: {
-        main: {
-            passK: number;
-            falseClaims: number;
-            medianMs: number;
-        };
-        quick: {
-            passK: number;
-            falseClaims: number;
-            medianMs: number;
-        };
-        questions: number;
-    };
-    act: {
-        kept: number;
-        total: number;
-        failures: string[];
-    };
-    /** How the read answers read, per model (docs/plans/lead-voice.md, V3). Reported; `pass` does not depend on it. */
-    voice: {
-        main: VoiceSummary;
-        quick: VoiceSummary;
-    };
-    speedup: number;
-    pass: boolean;
-    reasons: string[];
-    runs: ({
-        question: string;
-    } & Run)[];
-};
-/** Run the eval. `runner` absent: this computer's signed-in Claude (real mode). */
-export declare function runLeadAnswerEval(options: {
-    mode: "scripted" | "real";
-    k?: number;
-    onRun?: (line: string) => void;
-}): Promise<LeadAnswerReport>;
-export {};

package/dist/lead-capabilities.d.ts

@@ -1,57 +0,0 @@
-import type { Store } from "./store.js";
-import type { ChatControl } from "./chat-controls.js";
-import type { ProviderId } from "./provider.js";
-import { type AuthMode } from "./keys.js";
-import { type Integration } from "./integrations.js";
-/** One thing the lead may depend on: its state in a few words, what it lets the lead do, and when it can't, the next step. */
-export type Capability = {
-    name: string;
-    state: string;
-    ok: boolean;
-    lets: string;
-    next: string | null;
-    link: ChatControl | null;
-};
-export type ProjectCapabilities = {
-    repo: string;
-    agents: (Capability & {
-        provider: string;
-        model: string;
-        roles: string[];
-    })[];
-    agentsProblem: Capability | null;
-    tools: Capability[];
-    skills: Capability[];
-    checks: Capability & {
-        level: string;
-        quickCheck: boolean;
-        releaseCheck: boolean;
-    };
-};
-export type Capabilities = {
-    projects: ProjectCapabilities[];
-    workers: (Capability & {
-        online: boolean;
-        capacity: number;
-        running: string[];
-    })[];
-    integrations: (Capability & {
-        kind: string;
-        account: string | null;
-        usedBy: string[];
-        lastError: string | null;
-    })[];
-};
-/** The integrations exactly as get_integrations reads them, with what each lets the lead do and the next step. */
-export declare function integrationCapabilities(list: readonly Integration[]): Capabilities["integrations"];
-/** Every capability, for one project or every admitted one. Read-only and spends nothing. */
-export declare function capabilitiesOf(store: Store, input: {
-    repos: readonly string[];
-    admitted: readonly string[];
-    actor: string;
-    integrations: readonly Integration[];
-    authMode?: (provider: ProviderId) => AuthMode;
-    now: Date;
-}): Capabilities;
-export declare function needsCapabilities(name: string, args: Record<string, unknown>, channel: string | undefined): boolean;
-export declare const CAPABILITIES_UNREAD = "This depends on an agent, a worker or an integration. Read get_capabilities first, then propose or promise in a later step; if something it needs can't work, say so plainly with its next step and show_control link instead.";

package/dist/lead-cli-live.d.ts

@@ -1,56 +0,0 @@
-/**
- * The terminal's live reply for `toolroll chat` (docs/plans/responsive-chat.md §3.6): on a TTY only, one status line
- * shown at once and redrawn in place, then the answer as it is written, in a block of at most six rows wrapped to the
- * terminal's width by display width (wide and combining characters). Piped output and `--json` never get here.
- *
- * Only this renderer emits cursor controls. Every piece of model-derived text it draws (the partial reply, and the
- * status line, which can carry a tool's label) passes through `terminalText` first, on the whole accumulated text
- * every time, so an escape sequence split across stream chunks can never get past it.
- *
- * Views come from the shared live-reply core and are drawn through its serialized sender, so `finish()` resolves only
- * after the last draw: the block is erased and the caller prints the final answer (or the failure) strictly after.
- * The erase moves up within the block's known height; a terminal that scrolled meanwhile keeps what it showed.
- * Every draw first re-proves the caller's `standing`: once it fails, the block is erased and nothing more is drawn.
- */
-import type { LeadProgress } from "./lead-progress.js";
-import { type ShapeOptions } from "./reply-shape.js";
-/** Where the live block is drawn: the terminal, or a test's recording. */
-export type TerminalLiveOutput = {
-    write(chunk: string): void;
-    /** The terminal's width now, in columns; undefined when unknown. */
-    columns(): number | undefined;
-    /** Call the listener when the terminal is resized; returns the unsubscribe. */
-    onResize(listener: () => void): () => void;
-    /** Call the listener on Ctrl-C during a turn (the process then exits, as Ctrl-C always did); returns the unsubscribe. */
-    onInterrupt(listener: () => void): () => void;
-    /** Draw the status line dimmed (off under NO_COLOR). */
-    dim?: boolean;
-};
-/** At most this many rows of the reply show under the status line. */
-export declare const LIVE_TERMINAL_ROWS = 6;
-/** The columns one grapheme takes: 0 for a lone combining or format mark, 2 for wide and emoji, else 1. */
-export declare function graphemeWidth(cluster: string): number;
-/** The columns a line of text takes on a terminal. */
-export declare function displayWidth(text: string): number;
-/** Text wrapped to rows of at most `width` columns: at the last space where there is one, else mid-word. */
-export declare function wrapRows(text: string, width: number): string[];
-export type TerminalLive = {
-    /** Feed one engine event (the turn's `onProgress`). */
-    progress(event: LeadProgress): void;
-    /** The turn ended: wait for the last draw, then erase the block. The final answer or failure prints after this. */
-    finish(): Promise<void>;
-};
-/**
- * Start one turn's live block: the status line shows at once. `shape` is the final reply's shaping (the owner's
- * message and this app's origins), so a partial reads as the final will.
- */
-export declare function startTerminalLive(out: TerminalLiveOutput, shape?: ShapeOptions, options?: {
-    spacingMs?: number;
-    /** Re-proved immediately before every draw (the person, the conversation, its projects and the turn, once known,
-     * running under the generation it was admitted with). False: the block is erased and nothing more is drawn. */
-    standing?: (turn: number | null) => boolean;
-}): TerminalLive;
-/** The real terminal: stdout, its resize events, and Ctrl-C (which still ends the process, after the block is gone). */
-export declare function processTerminal(env?: Record<string, string | undefined>): TerminalLiveOutput;
-/** A live block only on a real terminal that can move its cursor, and never for an agent driving the CLI. */
-export declare function liveTerminalWanted(json: boolean, env: Record<string, string | undefined>, tty: boolean, agent: () => boolean): boolean;

package/dist/lead-cli.d.ts

@@ -1,58 +0,0 @@
-import { type LeadProposal, type Store } from "./store.js";
-import { type ShapeOptions } from "./reply-shape.js";
-import type { SubscriptionLeadRunner } from "./subscription-chat.js";
-import { type TerminalLiveOutput } from "./lead-cli-live.js";
-export type LeadCliSeams = {
-    fetcher?: typeof fetch;
-    env?: Record<string, string | undefined>;
-    /** Lines the REPL reads instead of stdin (tests). */
-    lines?: AsyncIterable<string> | Iterable<string>;
-    clock?: () => Date;
-    /** Subscription harness seam; tests never consume a real membership turn. */
-    subscriptionRunner?: SubscriptionLeadRunner;
-};
-export type LeadCliInput = {
-    store: Store;
-    databaseFile: string;
-    write: (line: string) => void;
-    json: boolean;
-    credentials: {
-        name: string;
-        token: string;
-    };
-    /** The ceiling: explicit `--repo` paths, or the enrolled projects when none are named. */
-    repos: readonly string[];
-    say: string | undefined;
-    end: boolean;
-    follow?: boolean;
-    ceilingUsd: number | undefined;
-    seams?: LeadCliSeams;
-    /** Where evidence lives — a scout's report reads from here. */
-    evidenceRoot?: string;
-    /** The console's address(es): a reply's links there are named as its pages ("the task"), not by host. */
-    appOrigin?: ShapeOptions["appOrigin"];
-    /** A real terminal (never piped, never `--json`): each turn shows a live status line and the answer as it is written. */
-    liveTerminal?: TerminalLiveOutput;
-};
-export type LeadCliResult = {
-    code: number;
-    reason?: string;
-    message?: string;
-};
-export declare const LEAD_CLI_EXIT: {
-    readonly ok: 0;
-    readonly failed: 1;
-    readonly usage: 2;
-    readonly refused: 3;
-};
-/**
- * What a terminal must show before an answer is confirmed (v3 review,
- * finding 4): the question, every option with its consequence, which one
- * the builder recommends, which one is proposed — the card's content.
- */
-export declare function answerContextLines(store: Store, payload: Record<string, unknown>): string[];
-/** One line per proposal, numbered in thread order, for the operator to name. */
-export declare function proposalLines(proposals: readonly LeadProposal[], repos: readonly string[], ordinal?: (proposal: LeadProposal) => number): string[];
-/** The lines for one proposal, its answer context included when it is an answer. */
-export declare function proposalBlock(store: Store, proposal: LeadProposal, repos: readonly string[], number: number): string[];
-export declare function runLeadCli(input: LeadCliInput): Promise<LeadCliResult>;

package/dist/lead-commitments.d.ts

@@ -1,84 +0,0 @@
-/** What the lead promised to follow up on. A commitment records the promise in the lead's words, the condition
- * that completes it, when to look next, where to report and when it lapses. The follow pass reads open ones
- * without a model and says one short line when the condition is met, on the channel the promise was made on;
- * nothing otherwise.
- * The table is additive (no schema version bump), so a build that predates it still opens the store. */
-import type { Notification, Store } from './store.js';
-import { type AssignmentSnapshot } from './assignment.js';
-/** The table: `LEAD_COMMITMENT_SCHEMA` in store.ts (additive, no version bump). */
-export declare const COMMITMENT_DAYS = 7;
-export type TaskState = AssignmentSnapshot['state'];
-export declare const TASK_STATES: readonly TaskState[];
-export declare const RUN_OUTCOMES: readonly ['finished', 'built', 'failed'];
-export declare const CHECK_RESULTS: readonly ['passed', 'failed', 'either'];
-/** Where a promise was made, and so where it is reported: `chat` is the console or terminal conversation; a phone
- * or team chat also gets the line as the lead's own message, on that chat only. */
-export declare const COMMITMENT_CHANNELS: readonly ['chat', 'telegram', 'slack', 'discord', 'teams'];
-export type CommitmentChannel = typeof COMMITMENT_CHANNELS[number];
-/** `afterRun`: only a result newer than the one there was when the promise was made counts. */
-export type CommitmentCondition = {
-    kind: 'task';
-    task: string;
-    states: TaskState[];
-} | {
-    kind: 'run';
-    run: number;
-    outcome: typeof RUN_OUTCOMES[number];
-} | {
-    kind: 'check';
-    task: string;
-    result: typeof CHECK_RESULTS[number];
-    afterRun: number;
-} | {
-    kind: 'check';
-    run: number;
-    result: typeof CHECK_RESULTS[number];
-} | {
-    kind: 'time';
-    at: string;
-};
-export type Commitment = {
-    id: number;
-    owner: string;
-    repo: string | null;
-    thread: number;
-    turn: number | null;
-    channel: string;
-    what: string;
-    condition: CommitmentCondition;
-    checkAt: string;
-    expiresAt: string;
-    state: 'open' | 'done' | 'cancelled' | 'expired';
-    createdAt: string;
-    checkedAt: string | null;
-    closedAt: string | null;
-    closedBy: string | null;
-    outcome: string | null;
-};
-/** The condition in a few words, for Settings and for the lead's own catch-up. */
-export declare function conditionWords(store: Store, condition: CommitmentCondition): string;
-export type CommitInput = {
-    owner: string;
-    repo: string | null;
-    thread: number;
-    turn: number | null;
-    channel?: string;
-    what: string;
-    condition: CommitmentCondition;
-    checkAt?: string | null;
-};
-/** Record a promise. The caller has already proved the task, attempt or project is within the owner's access. */
-export declare function recordCommitment(store: Store, input: CommitInput, now: Date): Commitment;
-export declare function getCommitment(store: Store, id: number): Commitment | null;
-/** The owner's open promises that they heard, oldest first. */
-export declare function openCommitments(store: Store, owner: string, limit?: number): Commitment[];
-/** The phone or team chat a lead message is for, when it is a met promise (`lead-promise:<channel>:<id>`); null for
- * every other notification, which goes wherever it always went. */
-export declare function promiseChannelOf(row: Pick<Notification, 'dedupeKey'>): string | null;
-/** Stop following up. Only the owner (from Settings or through their lead) cancels; a closed one stays as it was. */
-export declare function cancelCommitment(store: Store, owner: string, id: number, by: string, reason: string, now: Date): boolean;
-/** The newest result run for a task, for a check condition's baseline. */
-export declare function latestResultRun(store: Store, task: string, repos: readonly string[], now: Date): number;
-/** One deterministic pass over due promises (no model): expire, drop what can no longer be delivered or seen,
- * and report a met condition once — the state change and the message share one transaction. Returns how many reported. */
-export declare function checkLeadCommitments(store: Store, now: Date, root?: string): number;

package/dist/lead-context.d.ts

@@ -1,45 +0,0 @@
-/** Bounded DB memory shared by browser and terminal lead turns. No provider,
- * repository scan, mutation, or hidden approval happens while catching up.
- *
- * The bundle is ordered by importance and built fresh each turn: who the lead
- * is (name, persona), who it is talking to (first name, time zone, today), what
- * it knows about them (their confirmed lines), the people, subagents and team
- * chats it works with (one line each), the channel, what needs them now,
- * projects by name with their active decisions, then the rest. Over 8 KB, the
- * least important goes first: the rest, then people, then decisions. */
-import { type Html } from './html.js';
-import type { Store } from './store.js';
-import { type LeadChannel } from './contracts/lead-context.js';
-import { type AssignmentCatchUp } from './assignment-brief.js';
-/** The whole bundle's size, in UTF-8 bytes (TEXT_LIMITS.leadContextBytes). */
-export declare const LEAD_CONTEXT_MAX_BYTES: 8000;
-/** Where this turn's conversation happens. */
-export type { LeadChannel };
-/** One message on the channel, in characters: the lead writes a reply within it (it is told before it writes and asked
- * once to shorten one over it); a longer reply is split across messages, never cut. Null: no platform limit. */
-export declare const LEAD_REPLY_LIMITS: Record<LeadChannel, number | null>;
-export type LeadContextOptions = {
-    evidenceRoot?: string;
-    /** The person this turn talks to (their account name). */
-    owner?: string;
-    channel?: LeadChannel;
-    /** A shared team conversation's own lead, in place of the person's own name for it. */
-    leadName?: string;
-    /** This conversation: its open promises and the corrections confirmed since the lead's last reply. */
-    thread?: number;
-    /** Their time zone; this computer's when absent. */
-    timeZone?: string;
-    /** Scrubs every string in the bundle (paths, digests, account names); the person's first name and the project
-     * labels are put back afterwards, on purpose. */
-    redact?: (text: string) => string;
-    /** A project's display name, already safe to show; the bundle never carries paths. */
-    projectName?: (path: string, index: number) => string;
-};
-/** "alex.pelletier@example.com" → "Alex". */
-export declare function firstNameOf(account: string): string;
-/** The channel a chat surface's label names; an unknown label names none rather than a guess. */
-export declare function leadChannelOf(label: string): LeadChannel | undefined;
-export declare function leadContext(store: Store, repos: readonly string[], now: Date, options?: LeadContextOptions): string;
-/** The same saved brief is useful before chat spending is authorized. */
-export declare function leadBriefHtml(brief: AssignmentCatchUp): Html;
-export declare const LEAD_CONTEXT_CSS = ".lead-subagent-list{list-style:none;margin:0 0 .5rem;padding:0}.lead-subagent-list li{display:grid;grid-template-columns:minmax(0,1fr) auto;column-gap:.75rem;align-items:center;border-bottom:1px solid var(--border);min-width:0}.lead-subagent-list li:last-child{border-bottom:0}.lead-subagent-list a{display:flex;min-height:44px;align-items:center;font-weight:500;overflow-wrap:anywhere;min-width:0}.lead-subagent-list .meta{text-align:right;overflow-wrap:anywhere}@media(max-width:600px){.lead-subagent-list li{grid-template-columns:minmax(0,1fr)}.lead-subagent-list .meta{text-align:left;padding-bottom:.4rem}}.lead-subagents .button-link{min-height:44px;display:inline-flex;align-items:center}.lead-promise-list{list-style:none;margin:0;padding:0}.lead-promise-list li{display:grid;grid-template-columns:minmax(0,1fr) auto;column-gap:.75rem;align-items:center;padding:.5rem 0;border-bottom:1px solid var(--border);min-width:0}.lead-promise-list li:last-child{border-bottom:0}.lead-promise-list p{margin:0;overflow-wrap:anywhere}.lead-promise-list form{grid-column:2;grid-row:1/span 2;margin:0}.lead-promise-list button{min-height:44px;width:auto;white-space:nowrap}.lead-promise-list .nowrap{white-space:nowrap}.lead-brief{margin:1rem 0;min-width:0}.lead-brief h2{font-size:1.1rem;margin:0 0 .8rem}.repository-context input[name=q]{display:block;box-sizing:border-box;min-height:44px;width:100%;margin:.4rem 0 .75rem;padding:.6rem .75rem;border:1px solid var(--border);border-radius:8px;background:var(--surface);color:inherit;font:inherit}.repository-context form{margin:.5rem 0 1rem}.repository-context summary{min-height:44px;padding:.75rem 0;overflow-wrap:anywhere}.lead-brief h3{font-size:.85rem;margin:1rem 0 .4rem;color:var(--muted-foreground)}.lead-brief ul{list-style:none;margin:0;padding:0}.lead-brief li{display:grid;grid-template-columns:minmax(0,1fr) auto;column-gap:.75rem;align-items:center;padding:.35rem 0;border-bottom:1px solid var(--border);min-width:0}.lead-brief li a{display:flex;min-height:44px;align-items:center;font-weight:500;overflow-wrap:anywhere;text-decoration:none}.lead-brief li a:hover{text-decoration:underline}.lead-brief-state{font-size:.75rem;font-weight:600;padding:.15rem .5rem;border-radius:.375rem;background:var(--so-neutral-soft);color:var(--so-neutral-ink);white-space:nowrap}.lead-brief-state--needs-decision,.lead-brief-state--ready-to-check{background:var(--so-attention-soft);color:var(--so-attention)}.lead-brief-state--working,.lead-brief-state--checking{background:var(--so-info-soft);color:var(--so-info)}.lead-brief-state--complete{background:var(--so-success-soft);color:var(--so-success)}.lead-brief li a.lead-brief-act{grid-column:1/-1;justify-self:start;display:inline-flex;min-height:40px;margin:.15rem 0 .4rem;font-weight:600}@media(max-width:760px){.lead-brief li a.lead-brief-act{justify-self:stretch;justify-content:center;min-height:44px}}.lead-brief-detail{grid-column:1/-1;font-size:.85rem;color:var(--muted-foreground);overflow-wrap:anywhere;padding-bottom:.35rem}@media(max-width:760px){.lead-brief{margin:.5rem 0}.lead-brief h2{margin:0 0 .25rem}.lead-brief h3{margin:.5rem 0 0}.lead-brief li{padding:0 0 .375rem}.lead-brief-detail{margin-top:-.375rem;padding-bottom:0;line-height:1.35;pointer-events:none}}";

package/dist/lead-contract.d.ts

@@ -1,10 +0,0 @@
-/**
- * The contract the lead reads (mate arc §4): plain words, versioned. It
- * tells the model what the plane is, that every act is a proposal the
- * operator confirms, the honesty and copy rules, when to ask instead of
- * propose, and the shape of a good recap. Paths, consequences, and
- * recommendations never reach the model — the tools already hide them —
- * so the contract need not forbid repeating what it cannot see.
- */
-export declare const LEAD_CONTRACT_VERSION = 53;
-export declare const LEAD_CONTRACT: string;

package/dist/lead-doors.d.ts

@@ -1,122 +0,0 @@
-import { type SharedActionOptions } from './chat-actions.js';
-import { type LeadProposal, type Store } from "./store.js";
-import type { VerifiedApprover } from "./principal.js";
-import { type TeamChatProviderResolver } from './team-chat-authorization.js';
-import { type Authority } from "./local-owner.js";
-export type ProposalKind = LeadProposal["kind"];
-export type DoorOutcome = {
-    ok: true;
-    kind: ProposalKind;
-    said: string;
-    taskId: string | null;
-    href?: string;
-    awaiting?: true;
-    already?: true;
-} | {
-    ok: false;
-    kind: ProposalKind | null;
-    reason: DoorRefusal;
-    said: string;
-};
-export type DoorRefusal = "standing" | "not-yours" | "ceiling-changed" | "not-pending" | "session-ended" | "turn-not-answered" | "turn-running" | "not-confirmable" | "needs-confirm" | "stale" | "claimed" | "not-queued" | "unknown-task" | "unknown-decision" | "already-answered" | "expired" | "outside-ceiling" | "refused";
-export type DoorOptions = {
-    /**
-     * Easy-start C1: whose authority confirms — a full session (or the CLI, a paired phone, a chat relay), or a laptop's
-     * local owner. Named by every caller; the door also reads the local owner its chain acts as, and the stricter wins.
-     */
-    authority: Authority;
-    /** Resolved inside the transaction. Without it, only current subscription terms are available. */
-    chatProvider?: TeamChatProviderResolver;
-    evidenceRoot?: string;
-    /** Only the secure human review endpoint supplies this; never saved or model-authored. */
-    actionReview?: SharedActionOptions["review"];
-    /** The existing ceremony for an irreversible decision option: `confirm=yes`, typed explicitly (ruling 12). */
-    confirm?: boolean;
-    /** The web door only: a person's signed-in browser session, never a token. An approval from the web needs it. */
-    person?: boolean;
-    /** A linked chat's own binding: which chat the yes came from, for the ledger. */
-    binding?: number;
-    /** A typed yes to a Start card on Telegram (one-step-chat.md C5), set only by confirmTypedStart: the one new way past
-     * the "confirm this" gate, for `task_start` alone. It is not `confirm`, mints no review and changes no `via`. */
-    typedStart?: {
-        provider: string;
-        event: string;
-    };
-    /** Which surface answered — recorded on the decision, the stop and the
-     * proposal's outcome. Named by the caller, never defaulted (v3 review,
-     * finding 1); `telegram` is the paired phone, never relabelled as the CLI. */
-    via: "web" | "cli" | "telegram" | "slack" | "discord" | "teams";
-    /**
-     * A composing caller already inside a transaction (the Telegram bridge
-     * applies a tap in the update's own transaction) hands the door its
-     * commit hook: the stop's process signal then fires after THAT commit,
-     * never before it, exactly as the door's own transaction would order it.
-     */
-    deferSignal?: ((signal: () => void) => void) | undefined;
-};
-/** A coordinator proposal lives seven days (§9); the door refuses an older one whatever the sweep did (v3 review, finding 3). */
-export declare const COORDINATOR_PROPOSAL_TTL_MS: number;
-/** The plain reasons a card shows instead of its controls; the door refuses with the same words. */
-export declare const PROPOSAL_CONTRIBUTOR_REASON = "An authorized contributor can act on this proposal.";
-export declare const PROPOSAL_CHAT_REASON = "Enable chat in this conversation before acting on a proposal.";
-export declare const PROPOSAL_WAIT_REASON = "Available when the current reply finishes.";
-/** Unbound claims get the same wall-clock allowance as a provider turn. */
-export declare const TEAM_UNBOUND_CLAIM_MS = 120000;
-export type ProposalGate = {
-    ok: true;
-} | {
-    ok: false;
-    reason: Extract<DoorRefusal, "not-yours" | "session-ended" | "turn-running">;
-    said: string;
-};
-/**
- * Whether `who` may act on a card in `thread` right now: the one gate the
- * cards and the confirm door share. Re-proved from saved state and live provider facts, so
- * every caller (console, CLI, Telegram) reaches the same answer: the thread
- * is theirs (or they contribute to its team conversation), chat is enabled
- * for it under their current generation, and no turn in that thread is
- * live. A team message still marked running after its turn finished is not
- * live; the delivery sweep settles it.
- */
-export declare function proposalActGate(store: Store, who: {
-    name: string;
-    generation: number;
-}, thread: number, now: Date, provider?: TeamChatProviderResolver): ProposalGate;
-export declare function confirmLeadProposal(store: Store, who: VerifiedApprover, proposalId: number, now: Date, options: DoorOptions): DoorOutcome;
-/** The operator declines the lead's card: `pending → dismissed`. */
-export declare function dismissLeadProposal(store: Store, who: VerifiedApprover, proposalId: number, now: Date): boolean;
-/**
- * Confirm a coordinator's proposal (v3 §9) as `who`: any approver whose
- * ceiling admits the row's repo. One transaction: standing re-proved
- * inside; the repo inside this ceiling; `pending → confirming`; the shared
- * executor; `confirming → confirmed | refused`. No lead session is
- * involved — nothing here spends.
- */
-export declare function confirmCoordinatorProposal(store: Store, who: VerifiedApprover, proposalId: number, now: Date, options: DoorOptions): DoorOutcome;
-export declare function dismissCoordinatorProposal(store: Store, who: VerifiedApprover, proposalId: number, now: Date): boolean;
-export type TypedStartOutcome = {
-    ok: true;
-    taskId: string;
-    said: string;
-} | {
-    ok: false;
-    said: string;
-};
-/** What a typed yes that started the work says (the tap's own words). */
-export declare const TYPED_START_STARTED = "Started. It's building now.";
-/**
- * Act on a typed yes recorded at ingress, as the Telegram worker takes its message (no lead turn runs for it). ONE
- * transaction: a settled record returns its saved outcome (a redelivery, or a crash after the write); otherwise the
- * approver and the pairing are re-proved, the card is found again from the tables by the same ids (the last sent part,
- * the reply or the very next message, the one pending proposal from an answered turn in the person's own thread), its
- * stamp must still be the one recorded and its preview unexpired and unused, and then it confirms through the door with
- * `typedStart`: everything after that gate is the tap's road (the single-use step, the person's own chat setting and
- * limits, fastStartBuild, approve()). Any failed check settles the record as not counted, and nothing starts.
- */
-export declare function confirmTypedStart(store: Store, who: VerifiedApprover | null, typed: {
-    provider: "telegram";
-    event: string;
-}, now: Date, options: {
-    binding: number;
-    evidenceRoot?: string;
-}): TypedStartOutcome;

package/dist/lead-follow.d.ts

@@ -1,26 +0,0 @@
-import { type Store, type LeadSession, type LeadThread, type ChatConfig } from './store.js';
-import { type VerifiedApprover } from './principal.js';
-import { type LeadTurnInput, type LeadTurnOutcome } from './lead.js';
-export declare function configureLeadFollow(store: Store, who: VerifiedApprover, session: LeadSession, thread: LeadThread, enabled: boolean, now: Date): boolean;
-export declare function leadFollowStatus(store: Store, actor: string): {
-    enabled: boolean;
-    detail: string;
-};
-/** A follow pass that failed outright says so where each enabled conversation reads its follow status. */
-export declare function recordLeadFollowFailure(store: Store, error: unknown, now: Date): void;
-export type LeadFollowInput = {
-    store: Store;
-    repos: () => readonly string[];
-    evidenceRoot: string;
-    clock?: () => Date;
-    provider: () => {
-        config: ChatConfig;
-        key: string | null;
-    } | null;
-    runTurn?: (input: LeadTurnInput) => Promise<LeadTurnOutcome>;
-    subscriptionRunner?: LeadTurnInput['subscriptionRunner'];
-    fetcher?: typeof fetch;
-};
-export declare function runLeadFollowPass(input: LeadFollowInput): Promise<void>;
-/** How long a burst of one sweep's updates is held so it lands on one page (docs/plans/lead-fan-out.md). */
-export declare const SWEEP_SETTLE_MS: number;