toolroll 0.9.15 → 0.9.16

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.9.16 — 2026-10-03
+
+- **Name your lead.** Settings → Lead takes a name and a short persona. The
+  lead uses them wherever it speaks.
+- **The lead knows who it's talking to.** Every turn it sees your first name,
+  today's date, the channel it's on, what needs you, and your projects by name
+  with their decisions.
+- **It checks before it speaks.** It says what it checked and marks guesses.
+  It searches project memory before recommending anything, and it checks an
+  integration before promising work that needs it.
+- **Questions with buttons.** When it needs an answer, it asks one question
+  with tap-to-answer options in the console, Telegram, Slack, Discord and
+  Teams.
+- **It keeps its promises.** "I'll tell you when the checks pass" is recorded
+  and reported once, on the chat where you asked. Corrections become a card
+  you confirm, and it remembers them from the next reply.
+- Accepting a result that doesn't match its report needs a reason, enforced by
+  the server. Every time on a page shows in your time zone.
+
 ## 0.9.15 — 2026-10-02
 
 - **Accept finishes the task.** One step, Accept and finish, after the

package/dist/assignment-brief.d.ts

@@ -53,6 +53,7 @@ export type AssignmentCatchUp = {
             decisions: {
                 id: number;
                 claim: string;
+                why: string;
             }[];
         };
     }[];
@@ -65,6 +66,15 @@ export type AssignmentCatchUp = {
         notes: string[];
     };
 };
+/** A reason's first sentence, or its first line. */
+export declare function firstSentenceOf(text: string): string;
+/** A project's active decisions, newest first: each one's title and its reason in one line (first sentence or
+ * line). Memory absent on an older database reads as no decisions. */
+export declare function activeDecisionsOf(store: Store, repo: string, text?: (value: string, cap: number) => string): {
+    id: number;
+    claim: string;
+    why: string;
+}[];
 /** A current snapshot, never a receipt to acknowledge. Full assignment reads
  * remain the place to inspect exact saved work and obtain its current digest. */
 export declare function assignmentCatchUp(store: Store, now: Date, access: AssignmentAccess, query?: {

package/dist/assignment-brief.js

@@ -7,6 +7,26 @@ import { publicChatText } from "./chat-display.js";
 const sha = (value) => createHash("sha256").update(value).digest("hex");
 const MAX_BYTES = 16_000;
 const RECENT_MS = 7 * 24 * 60 * 60_000;
+/** A sentence's end: not an abbreviation's full stop ("e.g.", "i.e.", "etc."), and followed by a new sentence. */
+const SENTENCE_END = /(?<!\b(?:e\.g|i\.e|etc|vs|cf|approx|incl|Mr|Mrs|Ms|Dr|St|No))[.!?](?=\s+["'“(]?[\p{Lu}\p{N}])/u;
+/** A reason's first sentence, or its first line. */
+export function firstSentenceOf(text) {
+    const line = text.split("\n")[0].trim();
+    const end = SENTENCE_END.exec(line);
+    return end === null ? line : line.slice(0, end.index + 1);
+}
+/** A project's active decisions, newest first: each one's title and its reason in one line (first sentence or
+ * line). Memory absent on an older database reads as no decisions. */
+export function activeDecisionsOf(store, repo, text = publicChatText) {
+    try {
+        return store.handle.prepare("SELECT id,claim,why FROM project_decision WHERE repo=? AND status='active' ORDER BY id DESC LIMIT 8").all(repo).map(row => ({
+            id: Number(row["id"]), claim: text(String(row["claim"]), 160), why: text(firstSentenceOf(String(row["why"])), 160)
+        }));
+    }
+    catch {
+        return [];
+    }
+}
 /** A current snapshot, never a receipt to acknowledge. Full assignment reads
  * remain the place to inspect exact saved work and obtain its current digest. */
 export function assignmentCatchUp(store, now, access, query = {}, evidenceRoot) {
@@ -26,7 +46,7 @@ export function assignmentCatchUp(store, now, access, query = {}, evidenceRoot)
         return result;
     const repos = query.repo === undefined ? access.repos : [query.repo];
     const includeUnplaced = query.repo === undefined && access.principal === "operator" && access.includeUnplaced === true;
-    const scopedAccess = access.principal === "operator" ? { principal: "operator", repos, includeUnplaced } : { principal: "coordinator", repos: repos ?? [] };
+    const scopedAccess = access.principal === "operator" ? { principal: "operator", repos, includeUnplaced, ...(access.viewer == null ? {} : { viewer: access.viewer }) } : { principal: "coordinator", repos: repos ?? [] };
     const text = (value, cap) => {
         const rendered = publicChatText(value, cap);
         if (rendered !== value)
@@ -86,37 +106,40 @@ export function assignmentCatchUp(store, now, access, query = {}, evidenceRoot)
                 result.omissions.decisions += Math.max(0, count - decisions.length);
         }
         // Project knowledge is admitted in SQL before any payload or title read.
-        const projectRows = store.handle.prepare(`SELECT repo FROM project_knowledge WHERE ? = 1 OR repo IN (SELECT value FROM json_each(?)) ORDER BY repo LIMIT 9`)
+        // A project with settled decisions but no saved instructions yet still has knowledge to bring.
+        const known = store.handle.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='project_decision'").get() === undefined ? "SELECT repo FROM project_knowledge"
+            : "SELECT repo FROM project_knowledge UNION SELECT repo FROM project_decision WHERE status='active'";
+        const projectRows = store.handle.prepare(`SELECT repo FROM (${known}) WHERE ? = 1 OR repo IN (SELECT value FROM json_each(?)) ORDER BY repo LIMIT 9`)
             .all(repos === null ? 1 : 0, JSON.stringify(repos ?? []));
-        const projectCount = Number(store.handle.prepare('SELECT COUNT(*) AS n FROM project_knowledge WHERE ? = 1 OR repo IN (SELECT value FROM json_each(?))').get(repos === null ? 1 : 0, JSON.stringify(repos ?? []))?.["n"] ?? 0);
+        const projectCount = Number(store.handle.prepare(`SELECT COUNT(*) AS n FROM (${known}) WHERE ? = 1 OR repo IN (SELECT value FROM json_each(?))`).get(repos === null ? 1 : 0, JSON.stringify(repos ?? []))?.["n"] ?? 0);
         result.omissions.projects = Math.max(0, projectCount - 8);
         for (const project of projectRows.slice(0, 8)) {
             const repo = String(project["repo"]);
             const knowledge = { status: "unavailable", revision: null, identity: null, sha256: null, instructions: "", sources: [], decisions: [] };
             const row = store.handle.prepare('SELECT * FROM project_knowledge WHERE repo=?').get(repo);
-            try {
-                const payload = String(row["payload"]), revision = Number(row["revision"]), identity = String(row["identity"]);
-                const history = store.handle.prepare('SELECT sha FROM knowledge_change WHERE repo=? AND identity=? AND revision=?').get(repo, identity, revision);
-                if (Buffer.byteLength(payload) > 160_000 || !Number.isSafeInteger(revision) || revision < 1 || sha(payload) !== row["sha"] || history?.["sha"] !== row["sha"])
-                    throw Error("invalid stored context");
-                const saved = JSON.parse(payload);
-                if (typeof saved.instructions !== "string" || !Array.isArray(saved.references) || saved.references.length > 12)
-                    throw Error("invalid stored context");
-                const sources = saved.references.map((one) => {
-                    if (typeof one.id !== "string" || typeof one.title !== "string" || typeof one.content !== "string")
-                        throw Error("invalid stored source");
-                    const id = text(one.id, 80), path = typeof one.path === "string" ? text(one.path, 160) : null;
-                    return { id, title: text(one.title, 120), kind: path === null ? "saved-note" : "repository-document", path,
-                        sourceRevision: typeof one.sourceRevision === "string" && /^[a-f0-9]{40,64}$/.test(one.sourceRevision) ? one.sourceRevision : null,
-                        sourceSha: typeof one.sourceSha === "string" && /^[a-f0-9]{40,64}$/.test(one.sourceSha) ? one.sourceSha : null };
-                });
-                Object.assign(knowledge, { status: "stored", revision, identity: /^[a-f0-9]{64}$/.test(identity) ? identity : null, sha256: String(row["sha"]), instructions: text(saved.instructions, 600), sources });
-            }
-            catch { /* Integrity failures are explicit; never replay an older version as current. */ }
-            try {
-                knowledge.decisions = store.handle.prepare("SELECT id,claim FROM project_decision WHERE repo=? AND status='active' ORDER BY id DESC LIMIT 8").all(repo).map(row => ({ id: Number(row["id"]), claim: text(String(row["claim"]), 160) }));
-            }
-            catch { /* memory absent on an older database reads as no decisions */ }
+            if (row === undefined)
+                knowledge.status = "none";
+            else
+                try {
+                    const payload = String(row["payload"]), revision = Number(row["revision"]), identity = String(row["identity"]);
+                    const history = store.handle.prepare('SELECT sha FROM knowledge_change WHERE repo=? AND identity=? AND revision=?').get(repo, identity, revision);
+                    if (Buffer.byteLength(payload) > 160_000 || !Number.isSafeInteger(revision) || revision < 1 || sha(payload) !== row["sha"] || history?.["sha"] !== row["sha"])
+                        throw Error("invalid stored context");
+                    const saved = JSON.parse(payload);
+                    if (typeof saved.instructions !== "string" || !Array.isArray(saved.references) || saved.references.length > 12)
+                        throw Error("invalid stored context");
+                    const sources = saved.references.map((one) => {
+                        if (typeof one.id !== "string" || typeof one.title !== "string" || typeof one.content !== "string")
+                            throw Error("invalid stored source");
+                        const id = text(one.id, 80), path = typeof one.path === "string" ? text(one.path, 160) : null;
+                        return { id, title: text(one.title, 120), kind: path === null ? "saved-note" : "repository-document", path,
+                            sourceRevision: typeof one.sourceRevision === "string" && /^[a-f0-9]{40,64}$/.test(one.sourceRevision) ? one.sourceRevision : null,
+                            sourceSha: typeof one.sourceSha === "string" && /^[a-f0-9]{40,64}$/.test(one.sourceSha) ? one.sourceSha : null };
+                    });
+                    Object.assign(knowledge, { status: "stored", revision, identity: /^[a-f0-9]{64}$/.test(identity) ? identity : null, sha256: String(row["sha"]), instructions: text(saved.instructions, 600), sources });
+                }
+                catch { /* Integrity failures are explicit; never replay an older version as current. */ }
+            knowledge.decisions = activeDecisionsOf(store, repo, text);
             result.projects.push({ repo, knowledge });
             if (!fits()) {
                 result.projects.pop();

package/dist/assignment.d.ts

@@ -109,7 +109,7 @@ export type AssignmentSnapshot = {
         wait: WaitKey;
         build: number | null;
     } | null;
-    /** The person's lead took it on (lead-voice.ts): "Your lead is on it" until done, handed on, or two quiet hours. */
+    /** The person's lead took it on (lead-voice.ts): "<name> is on it" until done, handed on, or two quiet hours. */
     lead?: LeadClaim | null;
     /** How many earlier versions of this task are still queued or running; absent when none. */
     earlierActive?: number;
@@ -195,14 +195,15 @@ type Finished = {
     reason: string;
     message: string;
 };
-/** An acceptance this receipt owes before it finishes: the person's own check (no reason needed), or an
- * exception the proof needs and the person gave a reason for. Null when Accept and finish is a plain
- * completion: nothing is owed, it was already accepted, or an exception came without its reason. */
-export declare function owedAcceptance(receipt: AssignmentReceipt | null, note: string | null): "person-check" | "exception" | null;
+/** An acceptance this receipt owes before it finishes, by the result page's own rule: the person's own check
+ * (no reason needed), or an exception a report that doesn't match its changes needs a reason for. Null when
+ * Accept and finish is a plain completion: nothing is owed (no proof, a failed check, or a verified result),
+ * or it was already accepted. */
+export declare function owedAcceptance(receipt: AssignmentReceipt | null): "person-check" | "exception" | null;
 /** Accept and finish: the person's acceptance of the exact result they read and its completion, in one
  * transaction. Whether an acceptance is owed is decided here, against the receipt as it stands: only a
- * person's own check or a reasoned exception records one (with its ledger act); anything else is the plain
- * completion Mark complete always was. The completion names the receipt the acceptance produced, under the
+ * person's own check or a reasoned exception records one (with its ledger act); an exception without its
+ * reason is refused; anything else is the plain completion Mark complete always was. The completion names the receipt the acceptance produced, under the
  * same digest a separate Accept then Mark complete leave. `receiptDigest` is the receipt as read, before
  * accepting (`runId`, when named, must be its run); any other change refuses both, and a refused completion
  * keeps no acceptance. `finish` completes the receipt (Mark complete by default; Complete and open a pull

package/dist/assignment.js

@@ -15,6 +15,7 @@ import { reproveApprover } from "./principal.js";
 import { noteAssignmentStatus } from "./assignment-status.js";
 import { historicalAssessmentReason } from "./assignment-presentation.js";
 import { manualReviewOnly } from "./proof.js";
+import { ACCEPT_NEEDS_REASON, cantAcceptYetOf } from "./result-acts.js";
 import { runCheckLevel } from "./check-levels.js";
 import { followUpChecksOf, withFollowUps } from "./result-follow-ups.js";
 import { buildReviewOf, findingWords } from "./review-switch.js";
@@ -465,20 +466,21 @@ class Undone extends Error {
         this.result = result;
     }
 }
-/** An acceptance this receipt owes before it finishes: the person's own check (no reason needed), or an
- * exception the proof needs and the person gave a reason for. Null when Accept and finish is a plain
- * completion: nothing is owed, it was already accepted, or an exception came without its reason. */
-export function owedAcceptance(receipt, note) {
+/** An acceptance this receipt owes before it finishes, by the result page's own rule: the person's own check
+ * (no reason needed), or an exception a report that doesn't match its changes needs a reason for. Null when
+ * Accept and finish is a plain completion: nothing is owed (no proof, a failed check, or a verified result),
+ * or it was already accepted. */
+export function owedAcceptance(receipt) {
     if (receipt === null || receipt.proofAcceptance !== null)
         return null;
     if (personCheckPending(receipt))
         return "person-check";
-    return note !== null && receipt.proof?.verdict !== "verified" && receipt.proof?.verdict !== "attested" ? "exception" : null;
+    return cantAcceptYetOf(receipt.proof?.verdict ?? null, receipt.proof?.reasons ?? [], false) === ACCEPT_NEEDS_REASON ? "exception" : null;
 }
 /** Accept and finish: the person's acceptance of the exact result they read and its completion, in one
  * transaction. Whether an acceptance is owed is decided here, against the receipt as it stands: only a
- * person's own check or a reasoned exception records one (with its ledger act); anything else is the plain
- * completion Mark complete always was. The completion names the receipt the acceptance produced, under the
+ * person's own check or a reasoned exception records one (with its ledger act); an exception without its
+ * reason is refused; anything else is the plain completion Mark complete always was. The completion names the receipt the acceptance produced, under the
  * same digest a separate Accept then Mark complete leave. `receiptDigest` is the receipt as read, before
  * accepting (`runId`, when named, must be its run); any other change refuses both, and a refused completion
  * keeps no acceptance. `finish` completes the receipt (Mark complete by default; Complete and open a pull
@@ -497,7 +499,10 @@ export function acceptAndCompleteAsOperator(store, taskId, input, who, now, root
                 return { ok: false, reason: "stale", message: "This result changed. Open the current result before accepting it." };
             }
             // Already complete, or nothing owed: the plain completion of the receipt as read.
-            const owed = before.state === "ready-to-check" ? owedAcceptance(receipt, input.note) : null;
+            const owed = before.state === "ready-to-check" ? owedAcceptance(receipt) : null;
+            // An exception is accepted only with its reason: never a completion that skips it.
+            if (owed === "exception" && input.note === null)
+                return { ok: false, reason: "needs-reason", message: `${ACCEPT_NEEDS_REASON}.` };
             let digest = receipt.digest;
             if (owed !== null) {
                 store.acceptProof(receipt.runId, who.name, input.note, now);