toolroll 0.9.15 → 0.9.17

package/dist/lead-identity.js

@@ -0,0 +1,33 @@
+export const DEFAULT_LEAD_NAME = "Lead";
+export 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 const LEAD_NAME_MAX = 40;
+export const LEAD_PERSONA_MAX = 600;
+/** This person's lead: their saved name and persona, else the defaults. An older store reads as the defaults. */
+export function leadIdentityOf(store, account) {
+    if (account == null || account === "")
+        return { name: DEFAULT_LEAD_NAME, persona: DEFAULT_LEAD_PERSONA };
+    try {
+        const saved = store.leadConfig(account);
+        if (saved !== null)
+            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 };
+}
+/** The name alone, for the places the lead speaks. */
+export function leadNameOf(store, account) {
+    return leadIdentityOf(store, account).name;
+}
+/** The saved form of a name and persona, or the problem with them. An empty name or persona means the default. */
+export function checkLeadIdentity(name, persona) {
+    const named = name.trim().replace(/\s+/g, " "), described = persona.trim().replace(/\r\n?/g, "\n");
+    if (named.length > LEAD_NAME_MAX)
+        return { ok: false, message: `Keep the name to ${LEAD_NAME_MAX} characters.` };
+    if (!/^[\p{L}\p{N}][\p{L}\p{N} .'’_-]*$/u.test(named) && named !== "")
+        return { ok: false, message: "Use letters, numbers and spaces in the name." };
+    if (described.length > LEAD_PERSONA_MAX)
+        return { ok: false, message: `Keep the persona to ${LEAD_PERSONA_MAX} characters.` };
+    if (/[\u0000-\u0009\u000b-\u001f\u007f]/.test(described))
+        return { ok: false, message: "Use plain text in the persona." };
+    return { ok: true, identity: { name: named || DEFAULT_LEAD_NAME, persona: described || 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

@@ -1,14 +1,12 @@
 /** The lead's voice: what the person's lead (an agent under their lead token) is doing, in their chat and on the
- * console. `lead say` posts one short message from "Your lead"; several within two minutes are one message, edited
- * in place as it grows. `assignment claim` marks a task the lead's: it reads "Your lead is on it" and leaves Needs
+ * console. `lead say` posts one short message from the lead, by the name its person gave it (Settings → Lead); several within two minutes are one message, edited
+ * in place as it grows. `assignment claim` marks a task the lead's: it reads "<name> is on it" and leaves Needs
  * you until the lead completes it, hands it to a person, or two hours pass with no lead act on it.
  *
  * Every fact is an append-only ledger row under "lead for <owner>"; no table of its own. The chat message is an
  * ordinary notification addressed to the owner, so every chat delivers it with the usual receipts. */
 import { type Actor } from "./actor.js";
 import { type Notification, type Store } from "./store.js";
-/** Who the person's chat says the lead's messages are from. */
-export declare const LEAD_NAME = "Your lead";
 export declare const LEAD_SAY_KIND = "lead-say";
 /** Repaints the owner's task card when the lead takes a task on: it never makes a new message in quiet chat. */
 export declare const LEAD_ON_IT_KIND = "lead-on-it";
@@ -34,7 +32,8 @@ export type LeadActivity = {
     owner: string;
     doing: string;
     at: string;
-    taskId: string | null;
+    taskId: string | null; /** What the owner calls their lead. */
+    name: string;
 };
 type Failure = {
     ok: false;
@@ -51,8 +50,13 @@ export declare function leadSay(store: Store, actor: Actor, text: string, taskId
     joined: boolean;
     notification: number | null;
 } | Failure;
-/** The words a chat shows for a lead-say row: "Your lead", then each line, plain, with no task id. */
-export declare function leadSayText(row: Pick<Notification, "subject" | "body">): string;
+/** A lead row's subject in its owner's current name for their lead, read when it is shown, so a rename reaches
+ * 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. `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
@@ -72,10 +76,10 @@ export declare function enqueueLeadLapses(store: Store, now: Date): number;
 /** The lead's act on a task that a claim counts (a retry, a state change, a steer): one ledger row as the lead. */
 export declare function noteLeadWork(store: Store, actor: Actor, taskId: string, what: string, now: Date): void;
 /** What `owner`'s own lead is doing now and when it last acted, both from its one newest act: its words when that
- * was a say, else the act in words. Nobody (null) has no lead line: another person's lead is never "Your lead". */
+ * was a say, else the act in words. Nobody (null) has no lead line: another person's lead is never theirs. */
 export declare function leadActivity(store: Store, owner: string | null | undefined): LeadActivity | null;
 /** "just now", "3 min ago", "2 h ago", "yesterday", "4 days ago". */
 export declare function agoWords(at: string, now: Date): string;
-/** The one line `toolroll status` and the console say: "Your lead: fixing 0.9.12's release check · 3 min ago". */
+/** The one line `toolroll status` and the console say: "Lead: fixing 0.9.12's release check · 3 min ago". */
 export declare function leadActivityLine(activity: LeadActivity, now: Date): string;
 export {};

package/dist/lead-voice.js

@@ -1,6 +1,6 @@
 /** The lead's voice: what the person's lead (an agent under their lead token) is doing, in their chat and on the
- * console. `lead say` posts one short message from "Your lead"; several within two minutes are one message, edited
- * in place as it grows. `assignment claim` marks a task the lead's: it reads "Your lead is on it" and leaves Needs
+ * console. `lead say` posts one short message from the lead, by the name its person gave it (Settings → Lead); several within two minutes are one message, edited
+ * in place as it grows. `assignment claim` marks a task the lead's: it reads "<name> is on it" and leaves Needs
  * you until the lead completes it, hands it to a person, or two hours pass with no lead act on it.
  *
  * Every fact is an append-only ledger row under "lead for <owner>"; no table of its own. The chat message is an
@@ -9,10 +9,9 @@ import { actorLabel, withActor } from "./actor.js";
 import { chatControlHref } from "./chat-controls.js";
 import { BATCH_MS, chatText, chatTitle } from "./chat-voice.js";
 import { BUILT_IN } from "./store.js";
-import { LEAD_LAPSED } from "./task-status.js";
+import { leadNameOf } from "./lead-identity.js";
+import { leadLapsed } from "./task-status.js";
 import { phoneText as plain } from "./telegram-status.js";
-/** Who the person's chat says the lead's messages are from. */
-export const LEAD_NAME = "Your lead";
 export const LEAD_SAY_KIND = "lead-say";
 /** Repaints the owner's task card when the lead takes a task on: it never makes a new message in quiet chat. */
 export const LEAD_ON_IT_KIND = "lead-on-it";
@@ -97,15 +96,26 @@ export function leadSay(store, actor, text, taskId, now) {
         if (joined)
             store.handle.prepare("UPDATE notification SET resolved_at = ? WHERE id = ? AND resolved_at IS NULL").run(stamp, Number(open["id"]));
         const key = `lead-say:${joined ? opened : stamp}:${ledger}`;
-        store.enqueueNotification({ dedupeKey: key, kind: LEAD_SAY_KIND, subject: LEAD_NAME, body: lines.join("\n"),
+        store.enqueueNotification({ dedupeKey: key, kind: LEAD_SAY_KIND, subject: leadNameOf(store, actor.account), body: lines.join("\n"),
             recipient: actor.account, source: { installation: true }, ...(taskId === null ? {} : { link: chatControlHref("task", taskId) }) }, now);
         const row = store.handle.prepare("SELECT id FROM notification WHERE dedupe_key = ?").get(key);
         return { ok: true, joined, notification: row === undefined ? null : Number(row["id"]) };
     });
 }
-/** The words a chat shows for a lead-say row: "Your lead", then each line, plain, with no task id. */
-export function leadSayText(row) {
-    return chatText([plain(row.subject, 60), "", ...row.body.split("\n").map(line => plain(line, LEAD_SAY_MAX)).filter(line => line !== "")].join("\n"));
+/** A lead row's subject in its owner's current name for their lead, read when it is shown, so a rename reaches
+ * 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 function leadSubjectOf(store, row, reader) {
+    const owner = row.recipient ?? reader ?? null;
+    if (owner === null || (row.kind !== LEAD_SAY_KIND && row.kind !== LEAD_ON_IT_KIND && row.kind !== LEAD_LAPSED_KIND))
+        return row.subject;
+    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. `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) {
@@ -129,9 +139,9 @@ export function leadClaim(store, actor, taskId, now) {
     store.transact(() => {
         const ledger = store.recordAction({ at: now.toISOString(), actor: actorLabel(actor), repo: task.repo, taskId: root, runId: null,
             action: LEAD_CLAIMED, outcome: "recorded", source: "work" });
-        // The owner's card for this task repaints to "Your lead is on it": quiet chat edits its card, and every-update
+        // The owner's card for this task repaints to "<name> is on it": quiet chat edits its card, and every-update
         // chat edits the attempt's own card (the Failed alert), or follows it up when that message is gone.
-        store.enqueueNotification({ dedupeKey: `lead-on-it:${ledger}`, kind: LEAD_ON_IT_KIND, subject: "Your lead is on it", body: "",
+        store.enqueueNotification({ dedupeKey: `lead-on-it:${ledger}`, kind: LEAD_ON_IT_KIND, subject: `${leadNameOf(store, actor.account)} is on it`, body: "",
             link: chatControlHref("task", taskId), source: cardSource(store, root) ?? { taskRef: task.refId } }, now);
     });
     return { ok: true, root, claim: leadClaimOf(store, taskId, now, actor.account) };
@@ -210,7 +220,7 @@ export function enqueueLeadLapses(store, now) {
                 continue;
             // The owner's lead let it go: only its owner's card hears of it (store.pingAllowed).
             if (withActor({ account: owner, lead: true }, () => store.enqueueNotification({ dedupeKey: `lead-lapsed:${root}:${owner}:${claim.lastActedAt}`,
-                kind: LEAD_LAPSED_KIND, subject: LEAD_LAPSED, body: "", link: chatControlHref("task", root), source }, now)))
+                kind: LEAD_LAPSED_KIND, subject: leadLapsed(leadNameOf(store, owner)), body: "", link: chatControlHref("task", root), source }, now)))
                 count++;
         }
     }
@@ -233,7 +243,7 @@ const ACT_WORDS = {
     "task handed to a person": "handed on", [LEAD_CLAIMED]: "working on",
 };
 /** What `owner`'s own lead is doing now and when it last acted, both from its one newest act: its words when that
- * was a say, else the act in words. Nobody (null) has no lead line: another person's lead is never "Your lead". */
+ * was a say, else the act in words. Nobody (null) has no lead line: another person's lead is never theirs. */
 export function leadActivity(store, owner) {
     if (owner == null || owner === "")
         return null;
@@ -250,7 +260,7 @@ export function leadActivity(store, owner) {
         } })();
         const doing = last["action"] === LEAD_SAID && last["detail"] != null ? chatText(String(last["detail"]), task === null ? [] : [{ id: task, title: title.trim() }])
             : `${ACT_WORDS[String(last["action"])] ?? String(last["action"]).replace(/^lead /, "")}${title}`;
-        return { owner, doing: doing.replace(/[.\s]+$/u, ""), at: String(last["at"]), taskId: task };
+        return { owner, doing: doing.replace(/[.\s]+$/u, ""), at: String(last["at"]), taskId: task, name: leadNameOf(store, owner) };
     }
     catch {
         return null;
@@ -269,7 +279,7 @@ export function agoWords(at, now) {
     const days = Math.floor(hours / 24);
     return days === 1 ? "yesterday" : `${days} days ago`;
 }
-/** The one line `toolroll status` and the console say: "Your lead: fixing 0.9.12's release check · 3 min ago". */
+/** The one line `toolroll status` and the console say: "Lead: fixing 0.9.12's release check · 3 min ago". */
 export function leadActivityLine(activity, now) {
-    return `${LEAD_NAME}: ${activity.doing} · ${agoWords(activity.at, now)}`;
+    return `${activity.name}: ${activity.doing} · ${agoWords(activity.at, now)}`;
 }

package/dist/ledger-view.js

@@ -1,4 +1,5 @@
 import { projectName } from "./project.js";
+import { exactWhenHtml } from "./when-html.js";
 const html = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 /** The ledger's kinds of event, as the filter names them. */
 const EVENT_KINDS = [["work", "Work"], ["request", "Requests"], ["access", "Access"], ["sign-in", "Sign-ins"], ["policy", "Policy changes"]];
@@ -47,11 +48,11 @@ export function ledgerBody(rows, projects, params, chain) {
 <label>Outcome<input type="text" name="outcome" value="${html(params.get("outcome") ?? "")}" placeholder="Any outcome"></label>
 <label>Task<input type="text" name="task" value="${html(params.get("task") ?? "")}" placeholder="Any task"></label>
 <button type="submit">Filter</button><a href="/ledger">Clear</a></form></details>
-<div class="ledger-list" aria-label="Action history"><div class="ledger-event ledger-labels" aria-hidden="true"><span>Time (UTC)</span><span>Actor</span><span>Action</span><span>Project / work</span><span>Outcome / event</span></div>${shown.length === 0 ? `<p class="ledger-empty">No actions match these filters yet.</p>` : shown.map(row => {
+<div class="ledger-list" aria-label="Action history"><div class="ledger-event ledger-labels" aria-hidden="true"><span>Time</span><span>Actor</span><span>Action</span><span>Project / work</span><span>Outcome / event</span></div>${shown.length === 0 ? `<p class="ledger-empty">No actions match these filters yet.</p>` : shown.map(row => {
         const subject = row.runId !== null ? `<a href="/r/${row.runId}">Run #${row.runId}</a>` : row.taskId !== null ? `<a href="/t/${encodeURIComponent(row.taskId)}">${html(row.taskId)}</a>` : "";
         const byActor = new URLSearchParams(fresh);
         byActor.set("actor", row.actor);
-        return `<article class="ledger-event" data-ledger-id="${row.id}"><div class="ledger-time"><time datetime="${html(row.at)}" title="${html(row.at)}">${html(row.at.slice(0, 19).replace("T", " "))}</time></div><div class="ledger-actor"><a class="actor" href="/ledger?${html(byActor.toString())}" title="Filter by this actor">${html(row.actor)}</a></div><div class="ledger-action">${html(row.action)}${row.detail === null ? "" : `<small class="ledger-detail">${html(row.detail)}</small>`}</div><div class="ledger-place">${row.repo === null ? "Instance" : html(projectName(row.repo))} ${subject}</div><div class="ledger-result">${html(row.outcome)}<small>${html(row.source)}</small></div></article>`;
+        return `<article class="ledger-event" data-ledger-id="${row.id}"><div class="ledger-time">${exactWhenHtml(row.at)}</div><div class="ledger-actor"><a class="actor" href="/ledger?${html(byActor.toString())}" title="Filter by this actor">${html(row.actor)}</a></div><div class="ledger-action">${html(row.action)}${row.detail === null ? "" : `<small class="ledger-detail">${html(row.detail)}</small>`}</div><div class="ledger-place">${row.repo === null ? "Instance" : html(projectName(row.repo))} ${subject}</div><div class="ledger-result">${html(row.outcome)}<small>${html(row.source)}</small></div></article>`;
     }).join("")}</div>
 <p class="row"><a href="/ledger?${html(fresh.toString())}">Newest actions</a>${more ? `<a rel="next" href="/ledger?${html(next.toString())}">Older actions</a>` : ""}</p>
 <p class="meta">Accepted requests record acceptance; worker events record results. History starts from this upgrade. Review evidence is on each task or run.</p>`;

package/dist/mate-cli.d.ts

@@ -1,4 +1,5 @@
-import type { MateProposal, Store } from "./store.js";
+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;

package/dist/mate-cli.js

@@ -10,9 +10,11 @@ import { configureLeadFollow, leadFollowStatus } from './lead-follow.js';
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { MATE_ASK_OTHER } from "./store.js";
 import { CHAT_KEY_ENV, credentialKeyOf, isDirectChatProvider, priceForConfig, subscriptionCredentialKey } from "./converse.js";
 import { verifyApproverByPassword } from "./principal.js";
 import { runMateTurn } from "./mate.js";
+import { voiceReply } from "./reply-shape.js";
 import { confirmMateProposal, dismissMateProposal } from "./mate-doors.js";
 import { projectName } from "./project.js";
 import { CHAT_CONTROLS, chatControlHref, isChatControl } from "./chat-controls.js";
@@ -152,7 +154,7 @@ export async function runMateCli(input) {
         return refuse("no-key", `no ${directProvider} key — export ${CHAT_KEY_ENV[directProvider]}, or paste one on the console's chat page`);
     const repos = [...input.repos];
     if (repos.length === 0)
-        return refuse("empty-ceiling", "the mate needs projects to see — name them with --repo, or enroll some in the console", MATE_CLI_EXIT.usage);
+        return refuse("empty-ceiling", "The lead has no projects to look at. Name some with --repo, or add projects in the console.", MATE_CLI_EXIT.usage);
     const verified = verifyApproverByPassword(store, input.credentials.name, input.credentials.token, repos);
     if (!verified.ok)
         return refuse("unauthenticated", "that is not an approver, or the password does not match");
@@ -163,7 +165,7 @@ export async function runMateCli(input) {
         const sessions = store.endMateSessionsFor(who.name, who.name, now);
         const threads = store.closeMateThreadsFor(who.name, now);
         emit({ ok: true, ended: { sessions, threads, turns } });
-        say(sessions === 0 ? "no mate session was live; the thread is gone" : "the session is over and the thread is forgotten");
+        say(sessions === 0 ? "No conversation was open, so there was nothing to end." : "The conversation has ended and its history is forgotten.");
         return { code: MATE_CLI_EXIT.ok };
     }
     store.sweepStaleMateTurns(now);
@@ -172,12 +174,12 @@ export async function runMateCli(input) {
     if (session !== null && session.credentialKey !== credentialKey) {
         // A session minted under another provider key cannot be spent by this
         // one (slice-2 review, finding 9): say so, never loop on `not-yours`.
-        return refuse("key-mismatch", "the live mate session was minted under a different provider key — use that key, or end the session with --end and mint a new one");
+        return refuse("key-mismatch", "The open conversation was started with a different provider key. Use that key, or end it with --end and start a new one.");
     }
     if (session !== null && session.ceilingDigest !== who.ceilingDigest) {
         store.endMateSession(session.id, who.name, now);
         store.closeMateThreadsFor(who.name, now);
-        say("the projects named differ from the live session's — that session ended; minting a new one");
+        say("The projects you named differ from the open conversation's, so it ended. Starting a new one.");
         session = null;
     }
     if (session === null) {
@@ -189,15 +191,15 @@ export async function runMateCli(input) {
         const id = store.mintMateSession({ approver: who.name, approverGeneration: who.generation, credentialKey, ceilingMicrousd, ceilingDigest: who.ceilingDigest, termsDigest }, now);
         session = store.getMateSession(id);
         if (session === null)
-            return refuse("failed", "the session could not be minted", MATE_CLI_EXIT.failed);
+            return refuse("failed", "A new conversation couldn't be started. Try again.", MATE_CLI_EXIT.failed);
         if (!direct && input.ceilingUsd !== undefined)
             say("the supplied --ceiling-usd value is ignored for membership usage");
-        say(`mate conversation started: ${direct ? `up to ${money(ceilingMicrousd)}` : "subscription usage (no dollar ceiling)"} over ${repos.map((one, index) => `r${index + 1} ${projectName(one)}`).join(", ")} — live until you end it`);
+        say(`mate conversation started: ${direct ? `up to ${money(ceilingMicrousd)}` : "subscription usage (no dollar limit)"} over ${repos.map(one => projectName(one)).join(", ")} — live until you end it`);
         if (direct)
-            say(`(the weekly chat ceiling, ${money(config.weeklyCeilingMicrousd)}, still binds above it)`);
+            say(`(the weekly chat limit, ${money(config.weeklyCeilingMicrousd)}, still applies)`);
     }
     else {
-        say(`mate conversation live: ${direct ? `${money(session.spentMicrousd)} of ${money(session.ceilingMicrousd)} spent` : "subscription usage (no dollar ceiling)"} — live until you end it`);
+        say(`mate conversation live: ${direct ? `${money(session.spentMicrousd)} of ${money(session.ceilingMicrousd)} spent` : "subscription usage (no dollar limit)"} — live until you end it`);
     }
     const thread = store.openMateThread(who.name, who.ceilingDigest, now).thread;
     if (input.follow !== undefined) {
@@ -239,21 +241,26 @@ export async function runMateCli(input) {
     const turn = async (message) => {
         const live = store.activeMateSession(who.name);
         if (live === null) {
-            const outcome = { ok: false, refused: "session-ended", message: "this mate session has ended — run chat again to mint one" };
+            const outcome = { ok: false, refused: "session-ended", message: "This conversation has ended. Run chat again to start a new one." };
             return outcome;
         }
-        return runMateTurn({ store, who, session: live, thread, config, key, message, ...(seams.fetcher === undefined ? {} : { fetcher: seams.fetcher }), ...(seams.subscriptionRunner === undefined ? {} : { subscriptionRunner: seams.subscriptionRunner }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), clock });
+        return runMateTurn({ store, who, session: live, thread, config, key, message, channel: "terminal", ...(seams.fetcher === undefined ? {} : { fetcher: seams.fetcher }), ...(seams.subscriptionRunner === undefined ? {} : { subscriptionRunner: seams.subscriptionRunner }), ...(input.evidenceRoot === undefined ? {} : { evidenceRoot: input.evidenceRoot }), clock });
     };
-    const report = (outcome) => {
+    const report = (outcome, message) => {
         if (outcome.ok && outcome.replayed) {
             emit(outcome);
             say(`Message already received as turn #${outcome.turn}.`);
             return;
         }
         if (outcome.ok) {
-            emit({ ok: true, turn: outcome.turn, reply: outcome.reply, activity: outcome.activity, steps: outcome.steps, settledMicrousd: outcome.settledMicrousd, proposals: pendingProposals().map(one => ({ id: one.id, ordinal: ordinalOf(one), kind: one.kind, payload: one.payload })) });
+            const ask = store.mateAsk(outcome.turn);
+            emit({ ok: true, turn: outcome.turn, reply: outcome.reply, activity: outcome.activity, steps: outcome.steps, settledMicrousd: outcome.settledMicrousd, proposals: pendingProposals().map(one => ({ id: one.id, ordinal: ordinalOf(one), kind: one.kind, payload: one.payload })),
+                ...(ask === null ? {} : { ask: { question: ask.question, options: [...ask.options, MATE_ASK_OTHER] } }) });
             say(`  ${outcome.activity}`);
-            say(outcome.reply);
+            say(voiceReply(outcome.reply, "terminal", { appOrigin: input.appOrigin ?? null, ...(message === undefined ? {} : { asked: message }) }));
+            // The lead's question: the terminal has no buttons, so the options are listed to type back.
+            if (ask !== null)
+                say(`${ask.question}\n${ask.options.map(one => `  · ${one}`).join("\n")}\n  · ${MATE_ASK_OTHER} (type your answer)`);
             printProposals();
             return;
         }
@@ -262,7 +269,7 @@ export async function runMateCli(input) {
     };
     if (input.say !== undefined) {
         const outcome = await turn(input.say);
-        report(outcome);
+        report(outcome, input.say);
         return { code: outcome.ok ? MATE_CLI_EXIT.ok : MATE_CLI_EXIT.refused };
     }
     // The REPL. Text is a turn; a few words are acts on the cards.
@@ -331,7 +338,7 @@ export async function runMateCli(input) {
             store.failLiveMateTurnsFor(who.name, "ended", now);
             store.endMateSessionsFor(who.name, who.name, now);
             store.closeMateThreadsFor(who.name, now);
-            say("the session is over and the thread is forgotten");
+            say("The conversation has ended and its history is forgotten.");
             emit({ ok: true, ended: true });
             return { code: MATE_CLI_EXIT.ok };
         }
@@ -339,7 +346,7 @@ export async function runMateCli(input) {
             say("say something, or: proposals · confirm N · dismiss N · open N · end · quit");
             continue;
         }
-        report(await turn(line));
+        report(await turn(line), line);
     }
     return { code: MATE_CLI_EXIT.ok };
 }

package/dist/mate-contract.d.ts

@@ -6,5 +6,5 @@
  * recommendations never reach the model — the tools already hide them —
  * so the contract need not forbid repeating what it cannot see.
  */
-export declare const MATE_CONTRACT_VERSION = 43;
+export declare const MATE_CONTRACT_VERSION = 47;
 export declare const MATE_CONTRACT: string;