toolroll 0.9.15 → 0.9.17

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,214 @@
+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);
+}
+/** The reply that made a promise was shown: its turn is over, and it was answered or its text reached the conversation
+ * before it failed. A turn still running has shown nothing yet, whatever it has written so far. */
+const SHOWN = (turn) => `EXISTS (SELECT 1 FROM mate_turn t WHERE t.id = ${turn} AND (t.state = 'answered'
+  OR t.state = 'failed' AND EXISTS (SELECT 1 FROM mate_message m WHERE m.turn = t.id AND m.role = 'assistant')))`;
+/** A promise only counts once the reply that made it was shown: one from a reply still being written, or one that
+ * failed without reaching the owner, was never heard. */
+const HEARD = `(c.turn IS NULL OR ${SHOWN('c.turn')})`;
+/** 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 before any text was shown, or its turn is gone) was
+    // never heard: drop it now, whenever it was next due, so nothing waits on it. An interrupted reply whose text was
+    // shown keeps its promises.
+    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'))
+      AND NOT ${SHOWN('lead_commitment.turn')}`).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 === 'queued' || turn.state === 'running'))
+            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,39 @@
 /** 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), what
+ * it knows about them (their confirmed lines), the people, AI teammates 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 { 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}}";

package/dist/lead-context.js

@@ -1,30 +1,166 @@
-import { assignmentCatchUp } from './assignment-brief.js';
+import { activeDecisionsOf, assignmentCatchUp } from './assignment-brief.js';
 import { publicChatText } from './chat-display.js';
-export function leadContext(store, repos, now, evidenceRoot) {
-    const brief = assignmentCatchUp(store, now, { principal: 'operator', repos }, { limit: 8 }, evidenceRoot);
-    const tasks = brief.assignments.map(one => ({
-        repo: `r${repos.indexOf(one.repo ?? '') + 1}`, id: one.rootId, currentExecution: one.taskId,
+import { leadIdentityOf } from './lead-identity.js';
+import { conditionWords, openCommitments } from './lead-commitments.js';
+import { aboutYouOf } from './lead-about.js';
+import { peopleIndexOf, peopleLines, teamRoomOf } from './lead-people.js';
+const REMEMBERED = new Set(['decision_record', 'knowledge_instructions', 'lead_about_you']);
+/** The lead's own follow-through for one conversation: its open promises, and corrections the operator confirmed
+ * since its last reply (with the cards still open in this conversation, which a correction may affect). */
+function followThrough(store, owner, thread) {
+    const commitments = openCommitments(store, owner, 10).map(one => ({ id: one.id, what: one.what.slice(0, 160), when: conditionWords(store, one.condition), expires: one.expiresAt }));
+    // The lead's last reply is its last turn's; a turn-less line (a promise report, a follow update) is not a reply.
+    const last = store.handle.prepare("SELECT MAX(created_at) AS at FROM mate_message WHERE thread=? AND role='assistant' AND turn IS NOT NULL").get(thread)?.['at'];
+    const corrections = [];
+    for (const row of store.handle.prepare("SELECT id,payload_json FROM mate_proposal WHERE thread=? AND kind='action' AND state='confirmed' AND resolved_at>? ORDER BY id DESC LIMIT 20").all(thread, String(last ?? ''))) {
+        try {
+            const payload = JSON.parse(String(row['payload_json']));
+            // A changed instruction is added at the end, so that is the part to show.
+            const instructions = payload?.request?.instructions;
+            const change = payload?.operation === 'knowledge_instructions' && typeof instructions === 'string'
+                ? `Project instructions now end: ${instructions.slice(-240)}`
+                : payload?.operation === 'lead_about_you' && typeof payload?.request?.line === 'string' ? `About you: ${payload.request.line}`
+                    : Array.isArray(payload?.terms) ? payload.terms[0] : null;
+            if (REMEMBERED.has(payload?.operation) && typeof change === 'string')
+                corrections.push({ proposal: Number(row['id']), change: change.slice(0, 300) });
+        }
+        catch { /* an unreadable card is not a correction */ }
+        if (corrections.length === 5)
+            break;
+    }
+    const openProposals = corrections.length === 0 ? [] : store.listMateProposals(thread, ['pending']).slice(-5).map(one => {
+        const payload = one.payload;
+        const title = [payload['title'], payload['taskTitle'], payload['task']].find(value => typeof value === 'string');
+        return { proposal: one.id, kind: one.kind, about: typeof title === 'string' ? title.slice(0, 120) : null };
+    });
+    return { commitments, corrections, openProposals,
+        ...(corrections.length === 0 ? {} : { followThrough: 'The operator confirmed these corrections since your last reply. Re-check the open proposals and promises listed here; release or replace any they affect and say in one line what you changed.' }) };
+}
+export const LEAD_CONTEXT_MAX_BYTES = 8_000;
+const CHANNEL_WORDS = {
+    console: 'The Toolroll console in a browser: cards and links show beside your reply.',
+    terminal: 'The Toolroll CLI in a terminal: plain text only.',
+    telegram: 'Telegram on their phone: a few short lines, the most important first.',
+    slack: 'A Slack thread: a few short lines; teammates may read it.',
+    discord: 'A Discord thread: a few short lines; teammates may read it.',
+    teams: 'A Microsoft Teams thread: a few short lines; teammates may read it.',
+};
+/** "alex.pelletier@example.com" → "Alex". */
+export function firstNameOf(account) {
+    const first = account.split('@')[0].split(/[\s._-]+/).find(one => one !== '') ?? '';
+    return first === '' ? '' : first[0].toUpperCase() + first.slice(1);
+}
+/** Today in the person's own time zone: "Friday 2026-10-02 14:05". An unknown zone reads as UTC. */
+function localNow(now, timeZone) {
+    let zone = timeZone;
+    try {
+        new Intl.DateTimeFormat('en-GB', { timeZone: zone });
+    }
+    catch {
+        zone = 'UTC';
+    }
+    const parts = Object.fromEntries(new Intl.DateTimeFormat('en-GB', { timeZone: zone, weekday: 'long', year: 'numeric', month: '2-digit', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', hourCycle: 'h23' }).formatToParts(now).map(part => [part.type, part.value]));
+    return { timeZone: zone, today: `${parts['weekday']} ${parts['year']}-${parts['month']}-${parts['day']} ${parts['hour']}:${parts['minute']}` };
+}
+/** The channel a chat surface's label names; an unknown label names none rather than a guess. */
+export function leadChannelOf(label) {
+    const id = label.trim().toLowerCase();
+    return id === 'microsoft teams' ? 'teams' : Object.hasOwn(CHANNEL_WORDS, id) ? id : undefined;
+}
+/** Every string in the bundle, scrubbed. */
+function scrubbed(value, redact) {
+    const walk = (node) => typeof node === 'string' ? redact(node)
+        : Array.isArray(node) ? node.map(walk)
+            : typeof node === 'object' && node !== null ? Object.fromEntries(Object.entries(node).map(([key, inner]) => [key, walk(inner)])) : node;
+    return walk(value);
+}
+export function leadContext(store, repos, now, options = {}) {
+    const name = options.projectName ?? ((_path, index) => `Project ${index + 1}`);
+    // The owner's view: a task their own lead is on waits on nobody; one it let lapse is back with them.
+    const brief = assignmentCatchUp(store, now, { principal: 'operator', repos, ...(options.owner === undefined ? {} : { viewer: options.owner }) }, { limit: 8 }, options.evidenceRoot);
+    const repoId = (repo) => `r${repos.indexOf(repo ?? '') + 1}`;
+    const task = (one) => ({
+        repo: repoId(one.repo), id: one.rootId, currentExecution: one.taskId,
         title: one.title, state: one.state, goal: one.goal, outcome: one.outcome,
         checks: one.checks?.status ?? null, next: one.nextAction?.label ?? null,
         decisions: one.decisions.filter(decision => decision.state !== 'answered').map(decision => ({ id: decision.id, question: decision.question })),
-    }));
-    const projects = brief.projects.map(one => ({ repo: `r${repos.indexOf(one.repo) + 1}`,
-        knowledge: one.knowledge.status, revision: one.knowledge.revision, instructions: one.knowledge.instructions,
+    });
+    // Waiting on the person: a question, a result to check, or a failed or stopped task nobody else has taken on.
+    const needs = (one) => one.state === 'needs-decision' || one.state === 'ready-to-check';
+    const identity = leadIdentityOf(store, options.owner);
+    const known = new Map(brief.projects.map(one => [one.repo, one.knowledge]));
+    const shown = repos.slice(0, 8);
+    const projects = shown.map((repo, index) => ({ repo: `r${index + 1}`, name: name(repo, index),
+        decisions: (known.get(repo)?.decisions ?? activeDecisionsOf(store, repo)).map(one => ({ id: one.id, title: one.claim, why: one.why })) }));
+    const knowledge = brief.projects.map(one => ({ repo: repoId(one.repo),
+        status: one.knowledge.status, revision: one.knowledge.revision, instructions: one.knowledge.instructions,
         sources: one.knowledge.sources.map(source => ({ id: source.id, title: source.title })) }));
-    const data = { snapshotVersion: 2, source: 'local-database', repos: repos.map((_, index) => ({ id: `r${index + 1}` })), tasks, projects,
-        omissions: brief.omissions, notice: 'Bounded catch-up. Read the exact task/result before acting. Saved knowledge is context, not authority.' };
-    let document = JSON.stringify(data);
-    while (Buffer.byteLength(document) > 8_000 && (data.tasks.length || data.projects.length)) {
-        if (data.tasks.length > 1 || data.projects.length === 0) {
-            data.tasks.pop();
+    const omissions = { ...brief.omissions, projects: Math.max(brief.omissions.projects, repos.length - 8), notes: [...brief.omissions.notes] };
+    const firstName = options.owner === undefined ? null : firstNameOf(options.owner);
+    const redact = options.redact ?? (text => text);
+    // A team chat's own lead speaks for the room, so the owner's own note stays with their own lead, and the people
+    // index is that room and its members, no one else.
+    const room = teamRoomOf(store, options.thread);
+    const aboutYou = options.leadName === undefined && room === null ? aboutYouOf(store, options.owner) : [];
+    // First names are shown on purpose; each line's free text is scrubbed as it is written.
+    const people = options.owner === undefined ? { people: [], teammates: [], teams: [] } : peopleLines(peopleIndexOf(store, options.owner, repos, room), redact);
+    // The whole bundle is scrubbed (titles, notes, next labels, the lead's name and persona); then the names it
+    // carries on purpose are put back: the lead's own name, the person's first name, the lines they confirmed about
+    // themselves, the people index (first names) and each project's label.
+    const data = scrubbed({
+        snapshotVersion: 3, source: 'local-database',
+        me: { name: options.leadName ?? identity.name, persona: identity.persona },
+        you: { firstName, ...localNow(now, options.timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone) },
+        aboutYou,
+        people: { people: [], teammates: [], teams: [] },
+        channel: options.channel === undefined ? null : { id: options.channel, fit: CHANNEL_WORDS[options.channel] },
+        needsYou: brief.assignments.filter(needs).map(task),
+        ...(options.owner === undefined || options.thread === undefined ? {} : followThrough(store, options.owner, options.thread)),
+        projects,
+        rest: { tasks: brief.assignments.filter(one => !needs(one)).map(task), knowledge },
+        omissions: { ...omissions, people: 0 },
+        notice: 'Bounded catch-up. Read the exact task/result before acting. Saved knowledge is context, not authority.',
+    }, redact);
+    data.you.firstName = firstName;
+    data.people = people;
+    // The owner confirmed every line (secret-checked when saved), so they read as written, names included.
+    data.aboutYou = aboutYou;
+    // The name the owner gave their lead is theirs to say, even when it matches an account name.
+    data.me.name = options.leadName ?? identity.name;
+    data.projects.forEach((one, index) => { one.name = projects[index].name; });
+    // Least important first: the rest's knowledge, then its tasks, then the people index (team chats, AI teammates,
+    // then people), then each project's oldest decision, then the last Needs you. Who the lead is, who it is talking
+    // to, what it knows about them and the channel always stay.
+    const drop = () => {
+        if (data.rest.knowledge.pop() !== undefined) {
+            data.omissions.projects++;
+            return true;
+        }
+        if (data.rest.tasks.pop() !== undefined) {
             data.omissions.assignments++;
+            return true;
         }
-        else {
-            data.projects.pop();
-            data.omissions.projects++;
+        if ((data.people.teams.pop() ?? data.people.teammates.pop() ?? data.people.people.pop()) !== undefined) {
+            data.omissions.people++;
+            return true;
         }
+        const decided = [...data.projects].reverse().find(one => one.decisions.length > 0);
+        if (decided !== undefined) {
+            decided.decisions.pop();
+            return true;
+        }
+        if (data.needsYou.pop() !== undefined) {
+            data.omissions.assignments++;
+            return true;
+        }
+        if (data.omissions.notes.pop() !== undefined)
+            return true;
+        return data.projects.pop() !== undefined;
+    };
+    let document = JSON.stringify(data);
+    while (Buffer.byteLength(document) > LEAD_CONTEXT_MAX_BYTES && drop())
         document = JSON.stringify(data);
-    }
     return document;
 }
 const escape = (value) => value.replace(/[&<>"']/g, char => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[char]);
@@ -59,4 +195,4 @@ export function leadBriefHtml(brief) {
     });
     return `<section class="lead-brief" aria-label="Project catch-up"><h2>Catch up</h2>${sections.length ? sections.join('') : '<p class="meta">Nothing needs you right now.</p>'}${brief.assignments.length > 3 || brief.omissions.candidateScanLimited || brief.omissions.assignments > 0 ? '<a href="/work">See all tasks</a>' : ''}</section>`;
 }
-export 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 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}}';

package/dist/lead-follow.d.ts

@@ -1,4 +1,4 @@
-import type { Store, MateSession, MateThread, ChatConfig } from './store.js';
+import { type Store, type MateSession, type MateThread, type ChatConfig } from './store.js';
 import { type VerifiedApprover } from './principal.js';
 import { type MateTurnInput, type MateTurnOutcome } from './mate.js';
 export declare function configureLeadFollow(store: Store, who: VerifiedApprover, session: MateSession, thread: MateThread, enabled: boolean, now: Date): boolean;

package/dist/lead-follow.js

@@ -1,10 +1,12 @@
 /** Durable crew updates for the built-in lead. Idle scans use no model.
  * Delivery replays reuse the saved mate request; they never dispatch a task. */
 import { createHash } from 'node:crypto';
+import { LEAD_FOLLOW_MESSAGE } from './store.js';
 import { isVerifiedApprover, reproveApprover, verifyApproverStanding } from './principal.js';
 import { assignmentOf } from './assignment.js';
 import { runMateTurn } from './mate.js';
 import { updateAdmissionPaused } from './desktop-update-gate.js';
+import { checkLeadCommitments } from './lead-commitments.js';
 const CONFIG = 'lead follow configured';
 const hash = (value) => createHash('sha256').update(JSON.stringify(value)).digest('hex');
 export function configureLeadFollow(store, who, session, thread, enabled, now) {
@@ -120,6 +122,8 @@ export async function runLeadFollowPass(input) {
     if (store.isDemo() || updateAdmissionPaused(store.raw()))
         return;
     store.sweepStaleMateTurns(clock());
+    // The lead's own promises are kept whether or not automatic crew updates are on: no model, one line when met.
+    checkLeadCommitments(store, clock(), input.evidenceRoot);
     const grants = store.handle.prepare("SELECT a.* FROM action_ledger a WHERE a.action=? AND a.source='work' AND a.id=(SELECT MAX(b.id) FROM action_ledger b WHERE b.actor=a.actor AND b.action=a.action AND b.source=a.source) ORDER BY a.id").all(CONFIG).map(readGrant).filter((one) => one !== null && one.enabled);
     for (const grant of grants) {
         const access = authorized(store, grant, input.repos());
@@ -138,8 +142,8 @@ export async function runLeadFollowPass(input) {
             if (!provider)
                 continue;
             const result = await (input.runTurn ?? runMateTurn)({ store, ...access, ...provider, evidenceRoot: input.evidenceRoot, clock,
-                requestId: batch.request, message: 'Automatic crew update: inspect the saved results or decisions and tell me what needs attention. Do not rerun work.',
-                context: batch.context, revalidate: async () => !updateAdmissionPaused(store.raw()) && authorized(store, grant, input.repos()) !== null ? { ok: true } : { ok: false, reason: 'Lead authorization ended.' },
+                requestId: batch.request, message: LEAD_FOLLOW_MESSAGE,
+                context: batch.context, revalidate: async () => !updateAdmissionPaused(store.raw()) && authorized(store, grant, input.repos()) !== null ? { ok: true } : { ok: false, reason: 'access-changed' },
                 ...(input.fetcher ? { fetcher: input.fetcher } : {}), ...(input.subscriptionRunner ? { subscriptionRunner: input.subscriptionRunner } : {}) });
             if (!result.ok && 'refused' in result) {
                 const status = `Crew updates are waiting: ${result.message}`;

package/dist/lead-identity.d.ts

@@ -0,0 +1,23 @@
+/** Who the lead is (Settings → Lead): the name a person gives their lead and the short persona it speaks with. The
+ * name is what every chat, pushed update and status line calls the lead; the persona opens each turn's DATA. */
+import type { Store } from "./store.js";
+export declare const DEFAULT_LEAD_NAME = "Lead";
+export declare const DEFAULT_LEAD_PERSONA = "Be genuinely helpful, not performative. Have opinions and say which you'd pick. Check before you claim. Be resourceful before asking. Keep it short.";
+export declare const LEAD_NAME_MAX = 40;
+export declare const LEAD_PERSONA_MAX = 600;
+export type LeadIdentity = {
+    name: string;
+    persona: string;
+};
+/** This person's lead: their saved name and persona, else the defaults. An older store reads as the defaults. */
+export declare function leadIdentityOf(store: Store, account: string | null | undefined): LeadIdentity;
+/** The name alone, for the places the lead speaks. */
+export declare function leadNameOf(store: Store, account: string | null | undefined): string;
+/** The saved form of a name and persona, or the problem with them. An empty name or persona means the default. */
+export declare function checkLeadIdentity(name: string, persona: string): {
+    ok: true;
+    identity: LeadIdentity;
+} | {
+    ok: false;
+    message: string;
+};