toolroll 0.9.16 → 0.9.17

package/dist/lead-about.js

@@ -0,0 +1,62 @@
+import { scanForSecrets } from "./evidence.js";
+export const ABOUT_YOU_MAX_LINES = 20;
+/** Each line is under 200 characters. */
+export const ABOUT_YOU_LINE_MAX = 199;
+/** This person's confirmed lines; an older store reads as none. */
+export function aboutYouOf(store, account) {
+    if (account == null || account === "")
+        return [];
+    try {
+        return store.leadAbout(account);
+    }
+    catch {
+        return [];
+    }
+}
+/** One line as it is saved, or the problem with it. */
+export function checkAboutYouLine(value) {
+    const line = typeof value === "string" ? value.replace(/^\s*[-*•]\s*/, "").replace(/\s+/g, " ").trim() : "";
+    if (line.length < 2)
+        return { ok: false, message: "Say it in a few words." };
+    if (line.length > ABOUT_YOU_LINE_MAX)
+        return { ok: false, message: `Keep each line under ${ABOUT_YOU_LINE_MAX + 1} characters.` };
+    if (/[\u0000-\u001f\u007f​-‏‪-‮⁦-⁩�]/.test(line) || scanForSecrets(line).length > 0)
+        return { ok: false, message: "Use plain words, with no passwords or keys." };
+    return { ok: true, line };
+}
+/** The Settings form's text, one line each: the saved list, or the problem with it. Blank lines and repeats go. */
+export function checkAboutYou(text) {
+    const lines = [];
+    // A problem names the line as the person sees it in the box, blank lines and repeats counted.
+    for (const [index, raw] of text.replace(/\r\n?/g, "\n").split("\n").entries()) {
+        if (raw.trim() === "")
+            continue;
+        const checked = checkAboutYouLine(raw);
+        if (!checked.ok)
+            return { ok: false, message: `Line ${index + 1}: ${checked.message}` };
+        if (!lines.some(one => one.toLowerCase() === checked.line.toLowerCase()))
+            lines.push(checked.line);
+    }
+    if (lines.length > ABOUT_YOU_MAX_LINES)
+        return { ok: false, message: `Keep it to ${ABOUT_YOU_MAX_LINES} lines.` };
+    return { ok: true, lines };
+}
+/** Save the whole list for this person (already checked). Their lead's name and persona are left as they are. */
+export function saveAboutYou(store, account, lines, now) {
+    store.setLeadAbout(account, lines, now);
+}
+/** The list once a confirmed line is added, or once it replaces line `replaces` (1-based). */
+export function withAboutYouLine(lines, line, replaces) {
+    if (replaces > 0) {
+        if (replaces > lines.length)
+            return { ok: false, message: "That line is no longer in what your lead knows about you." };
+        const next = [...lines];
+        next[replaces - 1] = line;
+        return { ok: true, lines: next.filter((one, index) => index === replaces - 1 || one.toLowerCase() !== line.toLowerCase()) };
+    }
+    if (lines.some(one => one.toLowerCase() === line.toLowerCase()))
+        return { ok: false, message: "Your lead already knows this." };
+    if (lines.length >= ABOUT_YOU_MAX_LINES)
+        return { ok: false, message: `What your lead knows about you is full (${ABOUT_YOU_MAX_LINES} lines). Replace a line, or tidy it in Settings → Lead.` };
+    return { ok: true, lines: [...lines, line] };
+}

package/dist/lead-capabilities.d.ts

@@ -0,0 +1,64 @@
+/**
+ * What the lead can rely on right now, in one read (get_capabilities): the agents a project's route would run, the
+ * workers that would run them, the project's tools and skills, the integrations, and the project's checks. Every entry
+ * says what it lets the lead do and, when it can't, the one next step and the settings control (show_control) that
+ * takes the owner there. Everything here reads what is already recorded — runner readiness reports, sign-in pauses,
+ * plan-limit readings, tool tests, skill tests, integration checks — and never probes anything that spends.
+ */
+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-capabilities.js

@@ -0,0 +1,199 @@
+import { resolveRouteCandidates } from "./agentconfig.js";
+import { authPauseOf, messageCommand, providerName } from "./provider-auth.js";
+import { readAuthMode, SUBSCRIPTION_CAPABLE } from "./keys.js";
+import { DEFAULT_LIVENESS_MS } from "./runner.js";
+import { projectToolsOf, secretsSetFor, toolStanding } from "./project-tools.js";
+import { conversationSkills } from "./project-skills.js";
+import { CHECK_LEVEL_WORDS, liveQuickCommand, projectCheckLevel } from "./check-levels.js";
+import { STATE_WORDS } from "./integrations.js";
+const ROLE_WORDS = { plan: "plan", build: "build", repair: "fix failed checks", review: "review" };
+const MAX_LISTED = 12;
+/** The exact provider and model pairs a project's route would use, with the roles each would play. */
+function routePairs(store, repo) {
+    const pairs = new Map();
+    const resolved = resolveRouteCandidates(store, repo);
+    if (!resolved.ok)
+        return { pairs, problem: resolved.problem };
+    const add = (phase, candidate) => {
+        if (candidate === null)
+            return;
+        const key = `${candidate.provider} ${candidate.model}`;
+        const pair = pairs.get(key) ?? { provider: candidate.provider, model: candidate.model, roles: [] };
+        if (!pair.roles.includes(ROLE_WORDS[phase]))
+            pair.roles.push(ROLE_WORDS[phase]);
+        pairs.set(key, pair);
+    };
+    for (const phase of ["plan", "build", "repair", "review"]) {
+        const leg = resolved.candidates[phase];
+        add(phase, leg.routine ?? (phase === "repair" ? resolved.candidates.build.routine : null));
+        add(phase, leg.strong);
+    }
+    return { pairs, problem: null };
+}
+/** A provider's plan or quota running out, from the last readings (provider_limit and the runners' quota rows). */
+function outOfBudget(store, provider, now) {
+    const stamp = now.toISOString();
+    const window = store.providerLimits().find(one => one.provider === provider && one.reached && (one.resetsAt === null || one.resetsAt > stamp));
+    if (window !== undefined)
+        return { until: window.resetsAt };
+    const quota = store.handle.prepare("SELECT reset_at FROM quota WHERE provider = ? AND state = 'exhausted' AND (reset_at IS NULL OR reset_at > ?) ORDER BY reset_at DESC LIMIT 1").get(provider, stamp);
+    return quota === undefined ? null : { until: quota["reset_at"] == null ? null : String(quota["reset_at"]) };
+}
+function agentsOf(store, repo, now, authMode) {
+    const { pairs, problem } = routePairs(store, repo);
+    if (problem !== null) {
+        return { agents: [], agentsProblem: { name: "Agents", state: "Not set up", ok: false, lets: "plan and build this project's tasks", next: `Choose an exact model for each role: ${problem}`, link: "providers" } };
+    }
+    const readiness = store.readinessLookupFor(repo, null, now);
+    const agents = [...pairs.values()].map(pair => {
+        const name = `${providerName(pair.provider)} · ${pair.model}`;
+        const lets = `${pair.roles.join(", ")} this project's tasks`;
+        const base = { provider: pair.provider, model: pair.model, roles: pair.roles, name, lets };
+        // Signed out only on a real sign-in failure: a sign-in pause from a run, the worker's login check saying not logged
+        // in, or the key a key-only provider needs missing. A provider on an API key gets the key step, never the sign-in.
+        const pause = authPauseOf(store, pair.provider);
+        const mode = pause?.authMode ?? (SUBSCRIPTION_CAPABLE[pair.provider] ? authMode(pair.provider) : "api-key");
+        const key = mode === "api-key";
+        const outWords = key ? "Needs a working API key" : "Signed out";
+        const outNext = (detail) => key ? `Save a working API key: run \`${messageCommand({ provider: pair.provider, authMode: "api-key" })}\` on this computer${detail}.` : `Sign in: run \`${messageCommand({ provider: pair.provider, authMode: "subscription" })}\` on this computer${detail}.`;
+        if (pause !== null)
+            return { ...base, state: outWords, ok: false, next: outNext("; its tasks start again on their own"), link: "providers" };
+        const seen = readiness(pair.provider);
+        const authFailed = seen?.state === "unavailable" && (seen.probe === "key" || (seen.probe === "identity" && !key));
+        if (authFailed)
+            return { ...base, state: outWords, ok: false, next: outNext(""), link: "providers" };
+        if (seen?.state === "unavailable" && seen.probe !== "identity") {
+            return { ...base, state: `Not available: ${seen.reason}`, ok: false, next: `Fix it on the worker: ${seen.reason}.`, link: "providers" };
+        }
+        const spent = outOfBudget(store, pair.provider, now);
+        if (spent !== null)
+            return { ...base, state: "Out of plan budget", ok: false, next: spent.until === null ? "Wait for the plan to reset, or choose another agent." : `Wait until ${spent.until}, when the plan resets, or choose another agent.`, link: "providers" };
+        if (seen === null)
+            return { ...base, state: "Not checked yet", ok: false, next: "No worker has reported this agent yet: start a worker for this project.", link: "workers" };
+        // On an API key, only a key check speaks for it: a CLI login check (passed or not) says nothing about the key.
+        if (seen.state !== "ready" || (key && seen.probe !== "key")) {
+            return { ...base, state: "Not checked yet", ok: false, next: key ? "Its API key has not been checked without spending; the first task shows whether it works." : "A worker could not check it without spending; the first task shows whether it works.", link: "providers" };
+        }
+        return { ...base, state: key ? "API key set" : "Signed in", ok: true, next: null, link: null };
+    });
+    return { agents, agentsProblem: null };
+}
+function toolsOf(store, repo) {
+    return projectToolsOf(store, repo).slice(0, MAX_LISTED).map(tool => {
+        let set = [];
+        try {
+            set = secretsSetFor(repo, tool.spec);
+        }
+        catch {
+            set = [];
+        }
+        const standing = toolStanding(tool, set);
+        const state = standing.words;
+        const lets = `builds in this project can use ${tool.name}${tool.spec.about ? ` (${tool.spec.about})` : ""}`;
+        if (state.startsWith("Needs"))
+            return { name: tool.name, state, ok: false, lets, next: `Add ${state.slice("Needs ".length)} on the Tools page; never in chat.`, link: "tools" };
+        if (state === "Last test failed")
+            return { name: tool.name, state, ok: false, lets, next: `Fix it and test it again on the Tools page${tool.lastTest?.problem ? `: ${tool.lastTest.problem}` : ""}.`, link: "tools" };
+        if (state === "Not tested yet")
+            return { name: tool.name, state, ok: true, lets, next: "Test it on the Tools page to be sure it works.", link: "tools" };
+        return { name: tool.name, state: "Working", ok: true, lets, next: null, link: null };
+    });
+}
+/** The newest test of one skill version in a project: passed, failed or still running; null when never tested. */
+function lastSkillTest(store, repo, sha) {
+    const row = store.handle.prepare("SELECT skill_test.task_ref AS ref FROM skill_test JOIN task_ref ON task_ref.id = skill_test.task_ref WHERE task_ref.repo = ? AND skill_test.package = ? ORDER BY skill_test.task_ref DESC LIMIT 1").get(repo, sha);
+    if (row === undefined)
+        return null;
+    const run = store.runsFor(Number(row["ref"]))[0];
+    if (run === undefined || run.outcome === null)
+        return "running";
+    return run.outcome === "built" || run.outcome === "no-change" ? "passed" : "failed";
+}
+function skillsOf(store, repo, actor) {
+    let skills;
+    try {
+        skills = conversationSkills(store, repo, actor).skills;
+    }
+    catch {
+        return [];
+    }
+    return skills.filter(one => one.enabled).slice(0, MAX_LISTED).map(skill => {
+        const lets = `builds in this project are given the ${skill.name} skill${skill.description ? ` (${skill.description.slice(0, 120)})` : ""}`;
+        const test = lastSkillTest(store, repo, skill.sha);
+        if (test === "failed")
+            return { name: skill.name, state: "Last test failed", ok: false, lets, next: "Read it with get_skills, then fix and test it again on the Skills page.", link: "skills" };
+        const needs = skill.requirements.trim();
+        if (needs !== "" && test !== "passed")
+            return { name: skill.name, state: `Needs ${needs.slice(0, 120)}`, ok: false, lets, next: "Make sure what it needs is set up, then test it on the Skills page.", link: "skills" };
+        return { name: skill.name, state: test === "running" ? "Working · test running" : "Working", ok: true, lets, next: null, link: null };
+    });
+}
+function checksOf(store, repo) {
+    const level = projectCheckLevel(store, repo).level;
+    const releaseCheck = store.liveVerifyCommand(repo) !== null, quickCheck = liveQuickCommand(store, repo) !== null;
+    const base = { name: "Checks", level: CHECK_LEVEL_WORDS[level], quickCheck, releaseCheck, lets: "say whether a result's checks passed before you call it done" };
+    if (level === "off")
+        return { ...base, state: "Off", ok: false, next: "Builds are not checked. Turn checks on for the project if results need them.", link: "projects" };
+    if (!releaseCheck)
+        return { ...base, state: `${CHECK_LEVEL_WORDS[level]} · no release check`, ok: false, next: "No release check is set up, so no result can show a passing check. Set one for the project.", link: "projects" };
+    return { ...base, state: level === "quick" && !quickCheck ? "Quick · runs the release check" : `${CHECK_LEVEL_WORDS[level]} · release check set`, ok: true, next: null, link: null };
+}
+function workersOf(store, repos, now) {
+    const live = store.handle.prepare(`SELECT ref.external_id AS task, ref.repo AS repo FROM claim JOIN task_ref AS ref ON ref.id = claim.task_ref
+    WHERE claim.runner = ? AND claim.released_at IS NULL AND claim.expires_at > ?
+      AND claim.lease_generation = (SELECT MAX(newest.lease_generation) FROM claim AS newest WHERE newest.task_ref = claim.task_ref)`);
+    const workers = store.listRunners()
+        .filter(one => one.retiredAt === null && one.repos.some(repo => repos.includes(repo)))
+        .slice(0, MAX_LISTED)
+        .map(runner => {
+        const online = now.getTime() - Date.parse(runner.heartbeatAt) <= DEFAULT_LIVENESS_MS;
+        const held = live.all(runner.name, now.toISOString());
+        const running = held.filter(row => repos.includes(String(row["repo"]))).map(row => String(row["task"]));
+        const busy = store.liveClaimCount(runner.name, now);
+        const lets = `run tasks for ${runner.repos.filter(repo => repos.includes(repo)).length} of your projects, ${runner.capacity} at a time`;
+        if (!online)
+            return { name: runner.name, state: `Offline since ${runner.heartbeatAt}`, ok: false, online, capacity: runner.capacity, running, lets,
+                next: `Start that computer, or reinstall its background worker there: \`toolroll daemon install --runner ${runner.name}\`.`, link: "workers" };
+        const full = busy >= runner.capacity;
+        return { name: runner.name, state: full ? `Online · full (${busy} of ${runner.capacity})` : `Online · ${busy} of ${runner.capacity} busy`, ok: true, online, capacity: runner.capacity, running, lets,
+            next: full ? "New work waits for a free slot; raise its capacity on the Workers page if it should run more at once." : null, link: full ? "workers" : null };
+    });
+    if (workers.length === 0) {
+        return [{ name: "No worker", state: "None for your projects", ok: false, online: false, capacity: 0, running: [], lets: "run any task",
+                next: "Add a worker for the project: run `toolroll daemon install` on the computer that should do the work.", link: "workers" }];
+    }
+    return workers;
+}
+const INTEGRATION_LINK = { slack: "slack", discord: "discord" };
+/** The integrations exactly as get_integrations reads them, with what each lets the lead do and the next step. */
+export function integrationCapabilities(list) {
+    return list.map(one => {
+        const link = one.group === "agents" ? "providers" : one.group === "tools" ? "tools" : INTEGRATION_LINK[one.key.replace(/^.*:/, "").toLowerCase()] ?? INTEGRATION_LINK[one.name.toLowerCase()] ?? "integrations";
+        const lets = one.usedBy.length > 0 ? `use ${one.name} for ${one.usedBy.join(", ")}` : `use ${one.name}`;
+        const next = one.action.kind === "setup" ? `Not set up: set up ${one.name} in Settings` : one.action.kind === "fix" ? `Fix: ${one.action.words}` : null;
+        return { name: one.name, kind: one.group, state: STATE_WORDS[one.state], ok: one.state === "connected", account: one.account, usedBy: one.usedBy, lastError: one.lastError, lets, next, link: next === null ? null : link };
+    });
+}
+/** Every capability, for one project or every admitted one. Read-only and spends nothing. */
+export function capabilitiesOf(store, input) {
+    const authMode = input.authMode ?? (provider => readAuthMode(provider));
+    return {
+        projects: input.repos.map(repo => ({ repo, ...agentsOf(store, repo, input.now, authMode), tools: toolsOf(store, repo), skills: skillsOf(store, repo, input.actor), checks: checksOf(store, repo) })),
+        workers: workersOf(store, input.admitted, input.now),
+        integrations: integrationCapabilities(input.integrations),
+    };
+}
+/** Whether a call depends on an agent, a worker or an integration, and so needs get_capabilities read first this turn:
+ * a task always does (a worker runs it with an agent); a flow change that sets up or starts work does; a promise to
+ * report on a task, attempt or check does (crew work must run), and a timed one does when it is reported on a chat app. */
+const FLOW_WORK = new Set(["create", "edit", "kit", "starter", "add_trigger", "resume_trigger", "add_card"]);
+export function needsCapabilities(name, args, channel) {
+    if (name === "propose_task")
+        return true;
+    if (name === "propose_flow")
+        return FLOW_WORK.has(String(args["operation"]));
+    if (name === "commit_to")
+        return args["when"] === "time" ? channel !== undefined && channel !== "chat" : true;
+    return false;
+}
+export 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-commitments.js

@@ -87,9 +87,13 @@ 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 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)
@@ -153,10 +157,12 @@ 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.
+    // 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', 'answered'))`).run(at);
+    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);
@@ -168,7 +174,7 @@ export function checkLeadCommitments(store, now, root) {
         }
         // 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')
+        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)) {

package/dist/lead-context.d.ts

@@ -2,9 +2,11 @@
  * 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. */
+ * 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 const LEAD_CONTEXT_MAX_BYTES = 8000;

package/dist/lead-context.js

@@ -2,7 +2,9 @@ import { activeDecisionsOf, assignmentCatchUp } from './assignment-brief.js';
 import { publicChatText } from './chat-display.js';
 import { leadIdentityOf } from './lead-identity.js';
 import { conditionWords, openCommitments } from './lead-commitments.js';
-const REMEMBERED = new Set(['decision_record', 'knowledge_instructions']);
+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) {
@@ -16,7 +18,9 @@ function followThrough(store, owner, thread) {
             // 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)}` : Array.isArray(payload?.terms) ? payload.terms[0] : null;
+                ? `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) });
         }
@@ -94,26 +98,40 @@ export function leadContext(store, repos, now, options = {}) {
         sources: one.knowledge.sources.map(source => ({ id: source.id, title: source.title })) }));
     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 and each project's label.
+    // 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: { ...omissions, people: 0 },
         notice: 'Bounded catch-up. Read the exact task/result before acting. Saved knowledge is context, not authority.',
-    }, options.redact ?? (text => text));
+    }, 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 each project's oldest decision, then the
-    // last Needs you. Who the lead is, who it is talking to and the channel always stay.
+    // 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++;
@@ -123,6 +141,10 @@ export function leadContext(store, repos, now, options = {}) {
             data.omissions.assignments++;
             return true;
         }
+        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();

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,6 +1,7 @@
 /** 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';
@@ -141,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.js

@@ -9,7 +9,7 @@ export function leadIdentityOf(store, account) {
     try {
         const saved = store.leadConfig(account);
         if (saved !== null)
-            return { name: saved.name, persona: saved.persona };
+            return { name: saved.name || DEFAULT_LEAD_NAME, persona: saved.persona || DEFAULT_LEAD_PERSONA };
     }
     catch { /* no lead_config yet: the defaults */ }
     return { name: DEFAULT_LEAD_NAME, persona: DEFAULT_LEAD_PERSONA };

package/dist/lead-people.d.ts

@@ -0,0 +1,55 @@
+import type { Store, TeammateRow } from "./store.js";
+export type PersonEntry = {
+    id: string;
+    account: string;
+    name: string;
+    role: string;
+    projects: string[];
+    profile: string | null;
+};
+export type MateEntry = {
+    id: string;
+    mate: TeammateRow;
+    name: string;
+    role: string;
+    project: string;
+};
+export type TeamEntry = {
+    id: string;
+    conversation: string;
+    name: string;
+    members: string[];
+    purpose: string;
+    projects: string[];
+};
+export type PeopleIndex = {
+    people: PersonEntry[];
+    teammates: MateEntry[];
+    teams: TeamEntry[];
+};
+/** get_person's id shapes. */
+export declare const PERSON_ID: RegExp;
+/** The team chat this conversation is, or null when it is the person's own chat with their lead. */
+export declare function teamRoomOf(store: Store, thread: number | undefined): string | null;
+/** Everyone the owner's lead works with, in order; in a team chat (`room`), only that room and its members. */
+export declare function peopleIndexOf(store: Store, owner: string, repos: readonly string[], room?: string | null): PeopleIndex;
+/** One line each, as the bundle carries them. Free text goes through `redact`; names and project ids do not. */
+export declare function peopleLines(index: PeopleIndex, redact: (text: string) => string): {
+    people: string[];
+    teammates: string[];
+    teams: string[];
+};
+/** One entry in full by its id (p3fa91c2e, t5, c07b1d9a4) or by name; the candidates when a name fits several, null when
+ * none. In a team chat (`room`), only that room and its members. */
+export declare function personEntry(store: Store, owner: string, repos: readonly string[], ask: {
+    id?: string;
+    name?: string;
+}, room?: string | null): {
+    found: Record<string, unknown>;
+} | {
+    several: {
+        id: string;
+        name: string;
+        kind: string;
+    }[];
+} | null;