toolroll 0.9.16 → 0.9.18

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;

package/dist/lead-people.js

@@ -0,0 +1,128 @@
+/** Who the lead works with: the people on this installation who share a project with its owner, the AI teammates in
+ * those projects, and the team chats the owner is in. The bundle carries one line each (lead-context.ts); get_person
+ * reads one in full, with their open work. Ids stay the same from turn to turn however the list changes: p and c plus a
+ * short digest of the account or team chat, t plus the teammate's number. In a team chat the lead speaks for the room,
+ * so only that room and its members are listed. Only the owner's own projects are listed, by their r1.. ids; first
+ * names are shown on purpose, everything else is scrubbed by the caller. */
+import { createHash } from "node:crypto";
+import { firstNameOf } from "./lead-context.js";
+import { labelOf, nameOf, zonesOf } from "./teammate-admin.js";
+import { parseSoul } from "./teammates.js";
+import { deskOf } from "./teammate-desk.js";
+const OPEN_TASK = new Set(["queued", "running", "failed"]);
+/** get_person's id shapes. */
+export const PERSON_ID = /^(p[0-9a-f]{8}|t[0-9]{1,9}|c[0-9a-f]{8})$/;
+const stableId = (prefix, key) => `${prefix}${createHash("sha256").update(key).digest("hex").slice(0, 8)}`;
+/** The team chat this conversation is, or null when it is the person's own chat with their lead. */
+export function teamRoomOf(store, thread) {
+    if (thread === undefined)
+        return null;
+    try {
+        const row = store.handle.prepare("SELECT id FROM team_conversation WHERE thread = ?").get(thread);
+        return row === undefined ? null : String(row["id"]);
+    }
+    catch {
+        return null;
+    } // an older store has no team chats
+}
+const line = (text, max) => { const flat = text.replace(/\s+/g, " ").trim(); return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat; };
+/** Everyone the owner's lead works with, in order; in a team chat (`room`), only that room and its members. */
+export function peopleIndexOf(store, owner, repos, room = null) {
+    const label = (repo) => { const index = repos.indexOf(repo); return index === -1 ? null : `r${index + 1}`; };
+    const named = (list) => list.map(label).filter((one) => one !== null);
+    const inRoom = room === null ? null : new Set(store.handle.prepare("SELECT account FROM team_participant WHERE conversation = ? AND active = 1").all(room).map(one => String(one["account"])));
+    const people = store.accountFacts()
+        .filter(one => one.name !== owner && one.revokedAt === null && (inRoom === null || inRoom.has(one.name)))
+        .map(one => ({ one, shared: one.projects === null ? [...repos] : repos.filter(repo => one.projects.includes(repo)) }))
+        .filter(({ shared }) => shared.length > 0)
+        .map(({ one, shared }) => ({ id: stableId("p", one.name), account: one.name, name: firstNameOf(one.name) || one.name,
+        role: one.role === "approver" ? "approves work" : "watches work",
+        // No person has a written profile yet; the field is there for when one does.
+        projects: named(shared), profile: null }));
+    // AI teammates are not members of a team chat.
+    const teammates = room !== null ? [] : store.teammates(repos).map(mate => {
+        const soul = parseSoul(mate.soul);
+        return { id: `t${mate.id}`, mate, name: nameOf(mate), role: soul.ok ? soul.soul.role : labelOf(mate), project: label(mate.repo) ?? "" };
+    });
+    let teams = [];
+    try {
+        const rows = store.handle.prepare(`SELECT c.id, c.title, c.projects_json, l.name AS lead, l.instructions FROM team_conversation c JOIN team_lead l ON l.id = c.lead
+      WHERE EXISTS (SELECT 1 FROM team_participant p WHERE p.conversation = c.id AND p.account = ? AND p.active = 1)
+         OR (c.visibility = 'team' AND EXISTS (SELECT 1 FROM team_lead_member m WHERE m.lead = c.lead AND m.account = ? AND m.active = 1))
+      ORDER BY c.created_at, c.id`).all(owner, owner);
+        teams = rows.filter(row => room === null || String(row["id"]) === room).map(row => {
+            const members = store.handle.prepare("SELECT account FROM team_participant WHERE conversation = ? AND active = 1 ORDER BY account").all(row["id"])
+                .map(one => String(one["account"])).map(account => account === owner ? "you" : firstNameOf(account) || account);
+            let projects = [];
+            try {
+                const listed = JSON.parse(String(row["projects_json"]));
+                if (Array.isArray(listed))
+                    projects = named(listed.map(String));
+            }
+            catch { /* none named */ }
+            const purpose = String(row["instructions"] ?? "").split("\n").map(one => one.trim()).find(one => one !== "") ?? "";
+            return { id: stableId("c", String(row["id"])), conversation: String(row["id"]), name: String(row["title"]), members, purpose: purpose || String(row["lead"]), projects };
+        });
+    }
+    catch { /* an older store has no team chats */ }
+    return { people, teammates, teams };
+}
+/** One line each, as the bundle carries them. Free text goes through `redact`; names and project ids do not. */
+export function peopleLines(index, redact) {
+    return {
+        people: index.people.map(one => `${one.id} ${one.name}: ${one.role}; ${one.projects.join(", ")}${one.profile === null ? "" : `; ${line(redact(one.profile), 120)}`}`),
+        teammates: index.teammates.map(one => `${one.id} ${one.name}: ${line(redact(one.role), 60)}${one.project === "" ? "" : ` (${one.project})`}`),
+        teams: index.teams.map(one => `${one.id} ${line(redact(one.name), 60)}: ${one.members.join(", ")}; ${line(redact(one.purpose), 120)}`),
+    };
+}
+/** The work still open for one person: tasks last filed, approved or handed to them in the owner's projects, and flow cards they own. */
+function openWorkOf(store, account, repos) {
+    const repoId = (repo) => `r${repos.indexOf(repo) + 1}`;
+    const tasks = repos.length === 0 ? [] : store.handle.prepare(`SELECT r.external_id AS task, r.repo FROM task_ref r JOIN task_act a ON a.id = (SELECT MAX(id) FROM task_act WHERE task_ref = r.id AND act IN ('filed', 'approved', 'asked'))
+      WHERE r.repo IN (${repos.map(() => "?").join(", ")}) AND ((a.act IN ('filed', 'approved') AND a.account = ?) OR (a.act = 'asked' AND a.person = ?)) ORDER BY r.id DESC LIMIT 100`).all(...repos, account, account)
+        .flatMap(row => { const task = store.getTask(String(row["task"])); return task !== null && OPEN_TASK.has(task.state) ? [{ task: task.id, title: task.title, state: task.state, repo: repoId(String(row["repo"])) }] : []; })
+        .slice(0, 10);
+    const cards = repos.flatMap(repo => store.activeFlowCards(repo).filter(card => card.owner === account).map(card => ({ card: card.id, flow: card.flow, title: card.title, zone: card.stage, repo: repoId(repo) }))).slice(0, 10);
+    return { tasks, cards };
+}
+/** 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 function personEntry(store, owner, repos, ask, room = null) {
+    const index = peopleIndexOf(store, owner, repos, room);
+    const wanted = ask.name?.trim().toLowerCase() ?? "";
+    const all = [
+        ...index.people.map(one => ({ id: one.id, name: one.name, kind: "person", also: one.account })),
+        ...index.teammates.map(one => ({ id: one.id, name: one.name, kind: "AI teammate", also: one.mate.handle })),
+        ...index.teams.map(one => ({ id: one.id, name: one.name, kind: "team chat", also: "" })),
+    ];
+    const hits = ask.id !== undefined ? all.filter(one => one.id === ask.id)
+        : all.filter(one => one.name.toLowerCase() === wanted || one.also.toLowerCase() === wanted);
+    const loose = hits.length > 0 || wanted.length < 2 ? hits : all.filter(one => one.name.toLowerCase().includes(wanted));
+    if (loose.length === 0)
+        return null;
+    if (loose.length > 1)
+        return { several: loose.map(({ id, name, kind }) => ({ id, name, kind })) };
+    const id = loose[0].id;
+    const person = index.people.find(one => one.id === id);
+    if (person !== undefined) {
+        const work = openWorkOf(store, person.account, repos);
+        return { found: { id, kind: "person", name: person.name, role: person.role, projects: person.projects, profile: person.profile, openTasks: work.tasks, openCards: work.cards } };
+    }
+    const mate = index.teammates.find(one => one.id === id);
+    if (mate !== undefined) {
+        const flows = new Set([...zonesOf(store, mate.mate).map(one => `${one.flow}:${one.zone}`)]);
+        const desk = deskOf(store, mate.mate)?.id ?? null;
+        const cards = store.activeFlowCards(mate.mate.repo).filter(card => flows.has(`${card.flow}:${card.stage}`) || card.flow === desk)
+            .slice(0, 10).map(card => ({ card: card.id, flow: card.flow, title: card.title, zone: card.stage }));
+        return { found: { id, kind: "AI teammate", name: mate.name, role: mate.role, project: mate.project, working: mate.mate.state === "active", soul: mate.mate.soul,
+                worksOn: zonesOf(store, mate.mate).map(one => ({ flow: one.flowName, zone: one.title, how: one.kind })),
+                openTasks: cards, questions: store.openTeammateQuestions([mate.mate.id]).map(one => ({ question: one.id, asks: one.question })),
+                more: "get_teammates with this teammate's number reads its memory, routines, tools and recent log." } };
+    }
+    const team = index.teams.find(one => one.id === id);
+    const purpose = String(store.handle.prepare("SELECT l.instructions FROM team_conversation c JOIN team_lead l ON l.id = c.lead WHERE c.id = ?").get(team.conversation)?.["instructions"] ?? "");
+    const tasks = store.handle.prepare("SELECT r.external_id AS task, r.repo FROM team_task_owner o JOIN task_ref r ON r.id = o.task_ref WHERE o.conversation = ? ORDER BY r.id DESC LIMIT 100").all(team.conversation)
+        .flatMap(row => { const task = store.getTask(String(row["task"])), repo = String(row["repo"]); return task !== null && OPEN_TASK.has(task.state) && repos.includes(repo) ? [{ task: task.id, title: task.title, state: task.state, repo: `r${repos.indexOf(repo) + 1}` }] : []; })
+        .slice(0, 10);
+    return { found: { id, kind: "team chat", name: team.name, members: team.members, purpose: line(purpose || team.purpose, 600), projects: team.projects, openTasks: tasks } };
+}

package/dist/lead-voice.d.ts

@@ -54,8 +54,9 @@ export declare function leadSay(store: Store, actor: Actor, text: string, taskId
  * earlier cards too; any other row's own subject. `reader`: who the chat belongs to, for a row with no recipient
  * (only its owner ever receives a lead row). */
 export declare function leadSubjectOf(store: Store, row: Pick<Notification, "kind" | "subject" | "recipient">, reader?: string | null): string;
-/** The words a chat shows for a lead-say row: the lead's name, then each line, plain, with no task id. */
-export declare function leadSayText(store: Store, row: Pick<Notification, "kind" | "subject" | "body" | "recipient">): string;
+/** The words a chat shows for a lead-say row: the lead's name, then each line, plain, with no task id. `reader`: whose
+ * chat it is, for a row with no recipient (see leadSubjectOf). */
+export declare function leadSayText(store: Store, row: Pick<Notification, "kind" | "subject" | "body" | "recipient">, reader?: string | null): string;
 /** The earlier rows of a lead-say message (newest first): a chat that showed one edits it rather than sending again. */
 export declare function leadSayEarlier(store: Store, row: Pick<Notification, "id" | "kind" | "dedupeKey" | "recipient">): number[];
 /** `assignment claim` under the lead token: the task is the lead's until it completes it, hands it on, or goes

package/dist/lead-voice.js

@@ -112,9 +112,10 @@ export function leadSubjectOf(store, row, reader) {
     const name = leadNameOf(store, owner);
     return row.kind === LEAD_SAY_KIND ? name : row.kind === LEAD_ON_IT_KIND ? `${name} is on it` : leadLapsed(name);
 }
-/** The words a chat shows for a lead-say row: the lead's name, then each line, plain, with no task id. */
-export function leadSayText(store, row) {
-    return chatText([plain(leadSubjectOf(store, row), 60), "", ...row.body.split("\n").map(line => plain(line, LEAD_SAY_MAX)).filter(line => line !== "")].join("\n"));
+/** The words a chat shows for a lead-say row: the lead's name, then each line, plain, with no task id. `reader`: whose
+ * chat it is, for a row with no recipient (see leadSubjectOf). */
+export function leadSayText(store, row, reader) {
+    return chatText([plain(leadSubjectOf(store, row, reader), 60), "", ...row.body.split("\n").map(line => plain(line, LEAD_SAY_MAX)).filter(line => line !== "")].join("\n"));
 }
 /** The earlier rows of a lead-say message (newest first): a chat that showed one edits it rather than sending again. */
 export function leadSayEarlier(store, row) {

package/dist/mate-cli.d.ts

@@ -1,4 +1,5 @@
 import { type MateProposal, type Store } from "./store.js";
+import { type ShapeOptions } from "./reply-shape.js";
 import type { SubscriptionMateRunner } from "./subscription-chat.js";
 export type MateCliSeams = {
     fetcher?: typeof fetch;
@@ -27,6 +28,8 @@ export type MateCliInput = {
     seams?: MateCliSeams;
     /** Where evidence lives — a scout's report reads from here. */
     evidenceRoot?: string;
+    /** The console's address(es): a reply's links there are named as its pages ("the task"), not by host. */
+    appOrigin?: ShapeOptions["appOrigin"];
 };
 export type MateCliResult = {
     code: number;