toolroll 0.9.14 → 0.9.16

package/dist/chat-voice.d.ts

@@ -1,8 +1,3 @@
-/** How chat sounds: a teammate talking. One or two short sentences, outcome
- * first, plain words, one action at most. Every chat (Telegram, Slack,
- * Discord, Teams) takes its titles and its finished-work lines from here, so a
- * task id, a "— revision" suffix or a person's own act never reaches a chat.
- * The console keeps every exact name and fact. */
 import type { TelegramTransport } from "./telegram.js";
 import type { Store } from "./store.js";
 /** The bot's display name in every chat app. */
@@ -24,7 +19,7 @@ export type FinishedFact = {
     checks: "passed" | "failed" | "not-run" | "off" | null;
     report: boolean;
     completedBy: string | null;
-    /** An open pull request carries this result: the ask is "Merge it?" rather than "Mark it complete?". */
+    /** An open pull request carries this result: the ask is "Merge it?" rather than "Accept and finish it?". */
     pullRequest?: boolean;
     /** The lead did this (built it, or marked it complete), so the lead says "I". */
     lead?: boolean;
@@ -34,16 +29,18 @@ export type FinishedFact = {
         words: string;
         phrase: string;
     } | null;
-    /** The person's lead took it on (lead-voice.ts): "Your lead is on it", never "It waits for you". */
+    /** The person's lead took it on (lead-voice.ts): "<name> is on it", never "It waits for you". */
     leadOnIt?: boolean;
+    /** What the person calls their lead (Settings → Lead); "Lead" when unnamed. */
+    leadName?: string;
 };
 /** The two buttons under a result ready for a person: the real next step, then a look first. */
 export declare const READY_ACTIONS: {
     readonly merge: "Merge";
-    readonly complete: "Mark complete";
+    readonly complete: "Accept and finish";
     readonly look: "Look first";
 };
-/** Whether this line asks for the result's next step, so it carries [Merge] or [Mark complete] and [Look first]. */
+/** Whether this line asks for the result's next step, so it carries [Merge] or [Accept and finish] and [Look first]. */
 export declare function asksToFinish(fact: FinishedFact): boolean;
 /** One update, said plainly: what happened, then what happens next. The lead says "I" for what it did. */
 export declare function finishedLine(fact: FinishedFact): string;

package/dist/chat-voice.js

@@ -1,3 +1,9 @@
+/** How chat sounds: a teammate talking. One or two short sentences, outcome
+ * first, plain words, one action at most. Every chat (Telegram, Slack,
+ * Discord, Teams) takes its titles and its finished-work lines from here, so a
+ * task id, a "— revision" suffix or a person's own act never reaches a chat.
+ * The console keeps every exact name and fact. */
+import { leadOnIt } from "./task-status.js";
 import { phoneText } from "./telegram-status.js";
 /** The bot's display name in every chat app. */
 export const BOT_NAME = "Toolroll";
@@ -42,8 +48,8 @@ export function inSentence(summary) {
     return /^\p{Lu}\p{Ll}/u.test(summary) ? summary[0].toLowerCase() + summary.slice(1) : summary;
 }
 /** The two buttons under a result ready for a person: the real next step, then a look first. */
-export const READY_ACTIONS = { merge: "Merge", complete: "Mark complete", look: "Look first" };
-/** Whether this line asks for the result's next step, so it carries [Merge] or [Mark complete] and [Look first]. */
+export const READY_ACTIONS = { merge: "Merge", complete: "Accept and finish", look: "Look first" };
+/** Whether this line asks for the result's next step, so it carries [Merge] or [Accept and finish] and [Look first]. */
 export function asksToFinish(fact) {
     return fact.update == null && fact.headline === "Ready for review" && !fact.report;
 }
@@ -55,19 +61,19 @@ export function finishedLine(fact) {
     const ready = fact.lead === true ? `I finished ${lower}` : `${name} is ready`;
     // What waited on the person and the lead has taken on (Needs you reads Waiting then).
     if (fact.leadOnIt === true && (fact.headline === "Needs you" || fact.headline === "Waiting" || fact.headline === "Stopped"))
-        return `${name}: your lead is on it.`;
+        return `${name}: ${leadOnIt(fact.leadName)}`;
     switch (fact.headline) {
         case "Ready for review":
             if (fact.report)
                 return fact.lead === true ? `I wrote up ${lower}. The report is ready to read.` : `${name}: the report is ready to read.`;
             if (fact.checks === "passed")
-                return `${ready}. Your tests passed. ${fact.pullRequest === true ? "Merge it?" : "Mark it complete?"}`;
+                return `${ready}. Your tests passed. ${fact.pullRequest === true ? "Merge it?" : "Accept and finish it?"}`;
             if (fact.checks === "off")
                 return `${ready}. Checks are off for this project, so look it over first.`;
             return `${ready}, but no tests ran. Look it over first.`;
         case "Failed":
             if (fact.leadOnIt === true)
-                return fact.checks === "failed" ? `${name} is built, but its tests failed. Your lead is on it.` : `${name} stopped before it finished. Your lead is on it.`;
+                return fact.checks === "failed" ? `${name} is built, but its tests failed. ${leadOnIt(fact.leadName)}` : `${name} stopped before it finished. ${leadOnIt(fact.leadName)}`;
             if (fact.checks === "failed")
                 return fact.lead === true
                     ? `I built ${lower}, but its tests failed. It waits for you: retry or ask for changes.`

package/dist/demo.js

@@ -97,6 +97,57 @@ const DEMO_HANDOFF = {
     followUps: [],
     decisionsIncorporated: [],
 };
+/** The failed demo build: it took the flag out of settlement and config, but
+ * not out of the admin override, and its own report says so. */
+const DEMO_FAILED_PATCH = `diff --git a/src/payout.ts b/src/payout.ts
+index 7c1d2e3..5a1f0c7 100644
+--- a/src/payout.ts
++++ b/src/payout.ts
+@@ -18,9 +18,5 @@ export function settleAll(rows: PayoutRow[]): number {
+-  if (config.LEGACY_PAYOUT) {
+-    return rows.reduce((sum, row) => sum + legacySettle(row), 0);
+-  }
+-
+-  return rows.reduce((sum, row) => sum + settle(row.cents, row.rate), 0);
++  return rows.reduce((sum, row) => sum + settle(row.cents, row.rate), 0);
+ }
+diff --git a/src/config.ts b/src/config.ts
+index 2b3c4d5..8e9f0a1 100644
+--- a/src/config.ts
++++ b/src/config.ts
+@@ -4,8 +4,6 @@ export const config = {
+   PAYOUT_BATCH_SIZE: 500,
+-  // Retired once every merchant is on the new settlement path.
+-  LEGACY_PAYOUT: process.env.LEGACY_PAYOUT === "1",
+   PAYOUT_CURRENCY: "USD",
+ };
+`;
+const DEMO_FAILED_HANDOFF = {
+    schema: 1,
+    outcome: "built",
+    committed: true,
+    conclusion: "Removed LEGACY_PAYOUT from settlement and config. The admin override still reads it, so one reference remains.",
+    changes: ["Dropped the legacy settlement branch in src/payout.ts.", "Removed the LEGACY_PAYOUT flag from src/config.ts."],
+    verification: ["Searched the codebase for LEGACY_PAYOUT after the change."],
+    followUps: [],
+    decisionsIncorporated: [],
+};
+const DEMO_FAILED_PROOF = {
+    version: 1,
+    criteria: [
+        {
+            id: "c1",
+            statement: "No reference to LEGACY_PAYOUT remains in the codebase.",
+            verdict: "met",
+            how: "Removed the flag and the settlement branch behind it.",
+            evidence: [{ kind: "changed-path", ref: "src/payout.ts" }, { kind: "changed-path", ref: "src/config.ts" }],
+        },
+    ],
+    checks: [],
+    changed: ["src/payout.ts", "src/config.ts"],
+    caveats: ["c1: src/admin/overrides.ts still reads LEGACY_PAYOUT for the per-merchant override toggle, so one reference remains."],
+    screenshots: [],
+};
 /** The evidence bundle's own manifest (Acceptance Contract v2 demo): the
  * seeded sandbox answers its OWN signed rubric by exact id, with typed
  * evidence references — the same shape a real builder writes — so a
@@ -472,14 +523,15 @@ export function seedDemo(store, repos, evidenceRoot, now) {
     store.finishRun(buildingPriorRun, { outcome: "refused", reason: "plan-revised", now: hoursAgo(1.6) });
     // The board's "building" lane keys off a live claim — take one through
     // the real claim machinery so the card wears worker and lease honestly.
-    acquire(store, buildingRef, "night-shift-1", {
+    const liveClaim = acquire(store, buildingRef, "night-shift-1", {
         now: hoursAgo(0.4),
         token: nightShift.token,
         ttlMs: 4 * 3_600_000,
     });
     const liveRun = store.startRun({
         taskRef: buildingRef,
-        leaseId: "demo-lease-live",
+        // The claim's own lease, so the build reads as live: the run the task's current claim owns.
+        leaseId: liveClaim.ok ? liveClaim.claim.leaseId : "demo-lease-live",
         runner: "night-shift-1",
         branch: `toolroll/${building}`,
         worktree: join(repos.api, ".demo-worktree-2"),
@@ -603,6 +655,34 @@ export function seedDemo(store, repos, evidenceRoot, now) {
         now: hoursAgo(6),
         ...presentedRoute(store, store.refFor("built-in", failed).id, "builder"),
     });
+    // What the failed build left: its saved changes, its report and the
+    // machine's reading of them. It removed the flag from settlement but left
+    // the admin override reading it, and said so in its own note — so the
+    // signed requirement is missed, and the task card can name it.
+    store.stampRun(failedRun, { baseRevision: "4b825dc642cb6eb9a060e54bf8d69288fbee4904", scopeDigest: failedProposed.digest });
+    store.recordOutcomeFacts(failedRun, { headRevision: "5a1f0c7e2b9d4e6f8a0b1c2d3e4f5a6b7c8d9e0f" });
+    storeEvidence(store, evidenceRoot, failedRun, "terminal-diff", "terminal-diff.patch", Buffer.from(DEMO_FAILED_PATCH, "utf8"), "git diff --no-ext-diff --no-textconv --no-color 4b825dc6..HEAD (exit 0) [demo: synthetic]", hoursAgo(5.6));
+    const failedStat = {
+        schema: 1, base: "4b825dc642cb6eb9a060e54bf8d69288fbee4904", head: "5a1f0c7e2b9d4e6f8a0b1c2d3e4f5a6b7c8d9e0f",
+        fileCount: 2, additions: 1, deletions: 7, binaryCount: 0,
+        files: [{ path: "src/payout.ts", additions: 1, deletions: 5 }, { path: "src/config.ts", additions: 0, deletions: 2 }],
+        filesTruncated: false,
+    };
+    storeEvidence(store, evidenceRoot, failedRun, "diff-stat", "diff-stat.json", budgetedStatJson(failedStat), "parsed from git diff --numstat -z [demo: synthetic]", hoursAgo(5.6));
+    storeEvidence(store, evidenceRoot, failedRun, "handoff", "handoff.json", Buffer.from(JSON.stringify(DEMO_FAILED_HANDOFF, null, 2), "utf8"), "composed at completion [demo: synthetic]", hoursAgo(5.6));
+    storeEvidence(store, evidenceRoot, failedRun, "proof", "proof.json", Buffer.from(JSON.stringify(DEMO_FAILED_PROOF, null, 2), "utf8"), "agent-authored proof (validated, re-serialized) [demo: synthetic]", hoursAgo(5.6));
+    const failedAdjudicated = adjudicate({
+        proofArtifactPresent: true,
+        proofParse: parseProof(JSON.stringify(DEMO_FAILED_PROOF)),
+        handoffPresent: true,
+        terminalDiffPresent: true,
+        terminalDiffCaptureStatus: "ok",
+        diffStat: { captured: true, truncated: false, paths: new Set(failedStat.files.map(one => one.path)) },
+        verifyCommand: { configured: false },
+        screenshots: [],
+        approvedCriteria: failedProposed.acceptance,
+    });
+    store.saveProofVerdict(failedRun, failedAdjudicated.verdict, failedAdjudicated.reasons, hoursAgo(5.5), failedAdjudicated.matrix);
     store.finishRun(failedRun, {
         outcome: "failed",
         reason: "acceptance",

package/dist/disclosure.d.ts

@@ -0,0 +1,6 @@
+/** One disclosure glyph everywhere: the chevron. It points right while a fold is shut and turns down when it opens,
+ * on the server pages, the enhanced folds (workspace-motion.ts) and the React views (lucide's ChevronRight). Every
+ * other marker (the native triangle, ▸/▾, +/−, ⌄ and the old arrows) is turned off here, last, so no page can bring
+ * a second glyph back. A summary that carries its own icon keeps it. Drawn with two borders: the page's content
+ * policy allows no image, not even a data: one. */
+export declare const DISCLOSURE_CSS: string;

package/dist/disclosure.js

@@ -0,0 +1,13 @@
+/** One disclosure glyph everywhere: the chevron. It points right while a fold is shut and turns down when it opens,
+ * on the server pages, the enhanced folds (workspace-motion.ts) and the React views (lucide's ChevronRight). Every
+ * other marker (the native triangle, ▸/▾, +/−, ⌄ and the old arrows) is turned off here, last, so no page can bring
+ * a second glyph back. A summary that carries its own icon keeps it. Drawn with two borders: the page's content
+ * policy allows no image, not even a data: one. */
+export const DISCLOSURE_CSS = `details>summary{list-style:none}details>summary::-webkit-details-marker{display:none}` +
+    `details>summary::after{content:none!important}` +
+    `details>summary:not(:has(>svg))::before{content:""!important;display:inline-block;flex:none;box-sizing:border-box;width:7px!important;height:7px!important;` +
+    `margin:0 .55rem 0 .2rem!important;padding:0!important;position:static!important;vertical-align:.1em;font-size:0;background:none!important;` +
+    `border:0 solid currentColor!important;border-right-width:1.5px!important;border-bottom-width:1.5px!important;opacity:.65;` +
+    `transform:rotate(-45deg)!important;transition:transform .15s ease}` +
+    `details[open]>summary:not(:has(>svg))::before{transform:rotate(45deg)!important}` +
+    `@media (prefers-reduced-motion:reduce){details>summary::before{transition:none!important}}`;

package/dist/discord-chat.js

@@ -1,5 +1,6 @@
 /** Discord messages and buttons transport the shared assistant's saved actions. */
 import { chatQuestionButtons } from "./teammate-question.js";
+import { chatAskButtons } from "./chat-ask.js";
 import { chatFlowButtons } from "./chat-flow.js";
 import { channelInbox } from "./chat-inbox.js";
 import { roomCommand } from "./chat-rooms.js";
@@ -272,6 +273,15 @@ export async function deliverDiscordPart(options) {
                         custom_id: `so_${one.token}`,
                     }))
                     : []),
+                // The lead's question to its owner: its options, then "Something else".
+                ...(content.ask
+                    ? chatAskButtons(state, row.id, now).map((one) => ({
+                        type: 2,
+                        style: one.words ? 2 : 1,
+                        label: one.label.slice(0, 80),
+                        custom_id: `so_${one.token}`,
+                    }))
+                    : []),
                 ...link(options.origin(), content.link),
                 ...(content.also ?? []).flatMap(one => link(options.origin(), one)),
             ];

package/dist/lead-commitments.d.ts

@@ -0,0 +1,84 @@
+/** 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-commitments.js

@@ -0,0 +1,208 @@
+import { assignmentOf } from './assignment.js';
+import { LEAD_SAY_KIND } from './lead-voice.js';
+import { leadNameOf } from './lead-identity.js';
+/** The table: `LEAD_COMMITMENT_SCHEMA` in store.ts (additive, no version bump). */
+export const COMMITMENT_DAYS = 7;
+const DAY_MS = 86_400_000;
+/** How long an unmet condition waits before it is looked at again. */
+const RECHECK_MS = 30_000;
+const PASS_LIMIT = 50;
+export const TASK_STATES = ['working', 'checking', 'needs-decision', 'ready-to-check', 'complete', 'cancelled'];
+export const RUN_OUTCOMES = ['finished', 'built', 'failed'];
+export const CHECK_RESULTS = ['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 const COMMITMENT_CHANNELS = ['chat', 'telegram', 'slack', 'discord', 'teams'];
+const PROMISE_KEY = 'lead-promise:';
+const STATE_WORDS = { working: 'being worked on', checking: 'being checked', 'needs-decision': 'waiting for you',
+    'ready-to-check': 'ready for you to check', complete: 'complete', cancelled: 'cancelled' };
+const STAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?Z$/;
+function readCondition(text) {
+    try {
+        const value = JSON.parse(text);
+        if (value?.kind === 'task' && typeof value.task === 'string' && Array.isArray(value.states) && value.states.every((one) => TASK_STATES.includes(one)))
+            return value;
+        if (value?.kind === 'run' && Number.isSafeInteger(value.run) && RUN_OUTCOMES.includes(value.outcome))
+            return value;
+        if (value?.kind === 'check' && CHECK_RESULTS.includes(value.result) && (typeof value.task === 'string' && Number.isSafeInteger(value.afterRun) || Number.isSafeInteger(value.run)))
+            return value;
+        if (value?.kind === 'time' && typeof value.at === 'string' && STAMP.test(value.at))
+            return value;
+    }
+    catch { /* unreadable: the row stays visible and is never acted on */ }
+    return null;
+}
+function readCommitment(row) {
+    const condition = readCondition(String(row['condition_json']));
+    if (condition === null)
+        return null;
+    const text = (key) => row[key] == null ? null : String(row[key]);
+    return { id: Number(row['id']), owner: String(row['owner']), repo: text('repo'), thread: Number(row['thread']), turn: row['turn'] == null ? null : Number(row['turn']),
+        channel: String(row['channel']), what: String(row['what']), condition, checkAt: String(row['check_at']), expiresAt: String(row['expires_at']),
+        state: String(row['state']), createdAt: String(row['created_at']), checkedAt: text('checked_at'),
+        closedAt: text('closed_at'), closedBy: text('closed_by'), outcome: text('outcome') };
+}
+/** The condition in a few words, for Settings and for the lead's own catch-up. */
+export function conditionWords(store, condition) {
+    const title = (task) => `“${store.getTask(task)?.title ?? task}”`;
+    if (condition.kind === 'task')
+        return `when ${title(condition.task)} is ${condition.states.map(one => STATE_WORDS[one]).join(' or ')}`;
+    if (condition.kind === 'run')
+        return `when the attempt on ${attemptOf(store, condition.run)} ${condition.outcome === 'finished' ? 'finishes' : condition.outcome === 'built' ? 'finishes with a result' : 'fails'}`;
+    if (condition.kind === 'check') {
+        const on = `the checks on ${'task' in condition ? title(condition.task) : attemptOf(store, condition.run)}`;
+        return `when ${on} ${condition.result === 'either' ? 'finish' : condition.result === 'passed' ? 'pass' : 'fail'}`;
+    }
+    return `at ${condition.at.slice(0, 16).replace('T', ' ')} UTC`;
+}
+/** The task an attempt belongs to, by title. */
+function attemptOf(store, run) {
+    const task = store.refById(store.getRun(run)?.taskRef ?? -1)?.externalId;
+    return task === undefined ? 'that attempt' : `“${store.getTask(task)?.title ?? task}”`;
+}
+/** Record a promise. The caller has already proved the task, attempt or project is within the owner's access. */
+export function recordCommitment(store, input, now) {
+    const what = input.what.trim().replace(/\s+/g, ' ');
+    if (what.length < 3 || what.length > 240)
+        throw Error('Say what you promised in one short sentence.');
+    const channel = input.channel ?? 'chat';
+    if (!COMMITMENT_CHANNELS.includes(channel))
+        throw Error('Report on a chat this conversation uses.');
+    if (readCondition(JSON.stringify(input.condition)) === null)
+        throw Error('Choose a task, attempt, check or time to wait for.');
+    const expiresAt = new Date(now.getTime() + COMMITMENT_DAYS * DAY_MS).toISOString();
+    let checkAt = input.checkAt ?? now.toISOString();
+    if (input.condition.kind === 'time') {
+        if (input.condition.at > expiresAt)
+            throw Error(`A promise lasts ${COMMITMENT_DAYS} days; choose a time before then.`);
+        checkAt = input.condition.at > checkAt ? input.condition.at : checkAt;
+    }
+    if (!STAMP.test(checkAt) || checkAt > expiresAt)
+        throw Error(`Check within the next ${COMMITMENT_DAYS} days.`);
+    const id = Number(store.handle.prepare(`INSERT INTO lead_commitment (owner, repo, thread, turn, channel, what, condition_json, check_at, expires_at, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.owner, input.repo, input.thread, input.turn, channel, what, JSON.stringify(input.condition), checkAt, expiresAt, now.toISOString()).lastInsertRowid);
+    return getCommitment(store, id);
+}
+export function getCommitment(store, id) {
+    const row = store.handle.prepare('SELECT * FROM lead_commitment WHERE id = ?').get(id);
+    return row === undefined ? null : readCommitment(row);
+}
+/** A promise only counts once the reply that made it was answered: one from a reply still being written, or one
+ * that never finished, was never heard. */
+const HEARD = "(c.turn IS NULL OR EXISTS (SELECT 1 FROM mate_turn t WHERE t.id = c.turn AND t.state = 'answered'))";
+/** The owner's open promises that they heard, oldest first. */
+export function openCommitments(store, owner, limit = 20) {
+    return store.handle.prepare(`SELECT c.* FROM lead_commitment c WHERE c.owner = ? AND c.state = 'open' AND ${HEARD} ORDER BY c.id LIMIT ?`).all(owner, limit)
+        .map(readCommitment).filter((one) => one !== null);
+}
+/** 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 function promiseChannelOf(row) {
+    return row.dedupeKey.startsWith(PROMISE_KEY) ? row.dedupeKey.slice(PROMISE_KEY.length).split(':')[0] ?? null : null;
+}
+/** Stop following up. Only the owner (from Settings or through their lead) cancels; a closed one stays as it was. */
+export function cancelCommitment(store, owner, id, by, reason, now) {
+    const changed = store.handle.prepare("UPDATE lead_commitment SET state = 'cancelled', closed_at = ?, closed_by = ?, outcome = ? WHERE id = ? AND owner = ? AND state = 'open'")
+        .run(now.toISOString(), by, reason.trim().slice(0, 240) || 'Cancelled.', id, owner);
+    return Number(changed.changes) === 1;
+}
+/** The newest result run for a task, for a check condition's baseline. */
+export function latestResultRun(store, task, repos, now) {
+    return assignmentOf(store, task, now, { principal: 'operator', repos })?.receipt?.runId ?? 0;
+}
+/** What was observed when the condition is met, in one sentence; null while it is not. */
+function observe(store, one, now, root) {
+    const c = one.condition, repos = one.repo === null ? [] : [one.repo];
+    const title = (task) => `“${store.getTask(task)?.title ?? task}”`;
+    if (c.kind === 'time')
+        return now.toISOString() >= c.at ? 'It is time.' : null;
+    if (c.kind === 'task') {
+        const a = assignmentOf(store, c.task, now, { principal: 'operator', repos }, root);
+        return a !== null && c.states.includes(a.state) ? `${title(a.rootId)} is ${STATE_WORDS[a.state]}.` : null;
+    }
+    if (c.kind === 'run') {
+        const run = store.getRun(c.run);
+        if (run === null || run.outcome === null)
+            return null;
+        const ended = run.outcome === 'built' ? 'finished with a result' : run.outcome === 'failed' ? 'failed' : `ended (${run.outcome})`;
+        if (c.outcome === 'built' && run.outcome !== 'built' || c.outcome === 'failed' && run.outcome !== 'failed')
+            return null;
+        return `The attempt on ${attemptOf(store, run.id)} ${ended}.`;
+    }
+    const matches = (status) => (status === 'passed' || status === 'failed') && (c.result === 'either' || c.result === status);
+    if ('task' in c) {
+        const a = assignmentOf(store, c.task, now, { principal: 'operator', repos }, root);
+        const receipt = a?.receipt;
+        if (!a || !receipt || receipt.runId <= c.afterRun || !matches(receipt.checks.status))
+            return null;
+        return `The checks on ${title(a.rootId)} ${receipt.checks.status}.`;
+    }
+    const check = store.runCheckFor(c.run);
+    if (check === null || !matches(check.status))
+        return null;
+    return `The checks on ${attemptOf(store, c.run)} ${check.status}.`;
+}
+/** The promise as the end of "I said I would …": "I'll tell you when…" and "Tell you when…" both read "tell you when…". */
+function promised(what) {
+    const bare = what.replace(/^I(?:'ll| will)\s+/i, '').replace(/[.!]+$/, '');
+    return /^[A-Z][a-z]/.test(bare) ? bare.charAt(0).toLowerCase() + bare.slice(1) : bare;
+}
+/** 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 function checkLeadCommitments(store, now, root) {
+    const at = now.toISOString();
+    let reported = 0;
+    store.handle.prepare("UPDATE lead_commitment SET state = 'expired', closed_at = ?, outcome = 'Expired after 7 days without the condition being met.' WHERE state = 'open' AND expires_at <= ?").run(at, at);
+    // A promise made in a reply that was not delivered (it failed, or its turn is gone) was never heard: drop it now,
+    // whenever it was next due, so nothing waits on it.
+    store.handle.prepare(`UPDATE lead_commitment SET state = 'cancelled', closed_at = ?, closed_by = 'lead', outcome = 'The reply that made this promise was not delivered.'
+    WHERE state = 'open' AND turn IS NOT NULL AND NOT EXISTS (SELECT 1 FROM mate_turn t WHERE t.id = lead_commitment.turn AND t.state IN ('queued', 'running', 'answered'))`).run(at);
+    const due = store.handle.prepare("SELECT * FROM lead_commitment WHERE state = 'open' AND check_at <= ? ORDER BY check_at, id LIMIT ?").all(at, PASS_LIMIT);
+    for (const row of due) {
+        const one = readCommitment(row);
+        const id = Number(row['id']);
+        const close = (state, outcome) => Number(store.handle.prepare("UPDATE lead_commitment SET state = ?, closed_at = ?, closed_by = 'lead', outcome = ?, checked_at = ? WHERE id = ? AND state = 'open'").run(state, at, outcome, at, id).changes) === 1;
+        if (one === null) {
+            close('cancelled', 'Its condition could not be read.');
+            continue;
+        }
+        // A reply still being written may yet be delivered; one that was not is dropped above.
+        const turn = one.turn === null ? null : store.getMateTurn(one.turn);
+        if (turn !== null && turn.state !== 'answered')
+            continue;
+        const account = store.accountOf(one.owner);
+        if (account === null || account.revokedAt !== null || one.repo !== null && !store.accountCanAccess(one.owner, one.repo)) {
+            close('cancelled', 'Access to this project ended.');
+            continue;
+        }
+        const thread = store.getMateThread(one.thread);
+        if (thread === null || thread.approver !== one.owner || thread.closedAt !== null) {
+            close('cancelled', 'The conversation it was promised in was closed.');
+            continue;
+        }
+        let seen;
+        try {
+            seen = observe(store, one, now, root);
+        }
+        catch {
+            seen = null;
+        }
+        if (seen === null) {
+            store.handle.prepare("UPDATE lead_commitment SET checked_at = ?, check_at = ? WHERE id = ? AND state = 'open'").run(at, new Date(now.getTime() + RECHECK_MS).toISOString(), id);
+            continue;
+        }
+        const line = `${seen} (I said I would ${promised(one.what)}.)`;
+        store.transact(() => {
+            if (!close('done', seen))
+                return;
+            // The shared conversation always keeps the line; a promise made on a phone or team chat is also said there, as
+            // the lead's own message to its owner, on that chat alone (the usual delivery receipts apply).
+            store.appendMateMessage({ thread: one.thread, turn: null, role: 'assistant', text: line }, now);
+            if (one.channel !== 'chat')
+                store.enqueueNotification({ dedupeKey: `${PROMISE_KEY}${one.channel}:${one.id}`, kind: LEAD_SAY_KIND, subject: leadNameOf(store, one.owner),
+                    body: line.slice(0, 300), recipient: one.owner, source: { installation: true } }, now);
+            reported++;
+        });
+    }
+    return reported;
+}

package/dist/lead-context.d.ts

@@ -1,8 +1,37 @@
 /** Bounded DB memory shared by browser and terminal lead turns. No provider,
- * repository scan, mutation, or hidden approval happens while catching up. */
+ * 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), the
+ * channel, what needs them now, projects by name with their active decisions,
+ * then the rest. Over 8 KB, the least important goes first. */
 import type { Store } from './store.js';
 import { type AssignmentCatchUp } from './assignment-brief.js';
-export declare function leadContext(store: Store, repos: readonly string[], now: Date, evidenceRoot?: string): string;
+export declare const LEAD_CONTEXT_MAX_BYTES = 8000;
+/** Where this turn's conversation happens. */
+export type LeadChannel = 'console' | 'terminal' | 'telegram' | 'slack' | 'discord' | 'teams';
+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): string;
-export declare const LEAD_CONTEXT_CSS = ".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}}";
+export declare const LEAD_CONTEXT_CSS = ".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}}";