toolroll 0.9.97 → 0.9.98

package/dist/contracts/lead-tools.d.ts

@@ -756,6 +756,10 @@ export declare const LEAD_TOOL_INPUTS: {
         report: z.ZodOptional<z.ZodBoolean>;
         checks: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
+    readonly propose_start: z.ZodObject<{
+        repo: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strict>;
     readonly propose_sweep: z.ZodObject<{
         repo: z.ZodString;
         title: z.ZodString;
@@ -1567,6 +1571,10 @@ export declare const LEAD_TOOL_READ_INPUTS: {
         report: z.ZodOptional<z.ZodBoolean>;
         checks: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>;
+    readonly propose_start: z.ZodObject<{
+        repo: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strict>;
     readonly propose_sweep: z.ZodObject<{
         repo: z.ZodString;
         title: z.ZodString;
@@ -2212,6 +2220,15 @@ export declare const LEAD_TOOL_OUTPUTS: {
         kind: z.ZodLiteral<"task">;
         awaiting: z.ZodString;
     }, z.core.$loose>;
+    readonly propose_start: z.ZodObject<{
+        proposal: z.ZodNumber;
+        kind: z.ZodEnum<{
+            action: "action";
+            task: "task";
+        }>;
+        startsNow: z.ZodBoolean;
+        awaiting: z.ZodString;
+    }, z.core.$loose>;
     readonly propose_sweep: z.ZodObject<{
         proposal: z.ZodNumber;
         label: z.ZodString;

package/dist/contracts/lead-tools.js

@@ -52,7 +52,7 @@ export const CODE_MAP_VIEWS = ["overview", "area", "file", "search"];
 /** Task states a list filters by. */
 export const LISTED_TASK_STATES = ["queued", "running", "done", "failed", "cancelled"];
 /** The shared actions the lead proposes with propose_action; flows and subagents have their own tools. */
-const ACTION_OPERATIONS = Object.keys(CHAT_ACTIONS).filter(one => !one.startsWith("flow_") && !one.startsWith("subagent_"));
+const ACTION_OPERATIONS = Object.keys(CHAT_ACTIONS).filter(one => !one.startsWith("flow_") && !one.startsWith("subagent_") && one !== "task_start");
 /** A card's spec as the lead sees it: one flat props object. Each element's own props are read strictly by card-catalog.ts. */
 const cardProps = z.strictObject({
     source: z.enum(CARD_SOURCES).optional(), chart: z.enum(CARD_CHART_TYPES).optional(), columns: z.array(z.string().max(40)).max(CARD_LIMITS.columns).optional(), facts: z.array(z.string().max(40)).max(CARD_LIMITS.facts).optional(),
@@ -147,6 +147,8 @@ export const LEAD_TOOL_INPUTS = {
         not: scopeText.nullable().optional(), touches: touches.optional(), acceptance,
         planning: z.enum(["auto", "required", "skip"]).optional(), report: z.boolean().optional(), checks: text("checksWords").optional(),
     }),
+    // One-step start from chat (docs/plans/one-step-chat.md C3): one small change the person asked to be done now.
+    propose_start: z.strictObject({ repo: repoId, title: text("taskTitle") }),
     // Lead fan-out (docs/plans/lead-fan-out.md): 2 to 20 independent items under one shared brief and one success test.
     propose_sweep: z.strictObject({
         repo: repoId, title: text("taskTitle"), brief: scopeText,
@@ -286,6 +288,7 @@ export const LEAD_TOOL_OUTPUTS = {
     get_decision: decisionOutput,
     queue: z.looseObject({ repo: str, queueRevision: int, ...queueColumnsOutput }),
     propose_task: proposed("task", { repo: str, deliverable: z.enum(["branch", "report"]), planning: str }),
+    propose_start: z.looseObject({ proposal: int, kind: z.enum(["action", "task"]), startsNow: z.boolean(), awaiting: str }),
     propose_sweep: cardDrafted,
     get_sweep: z.looseObject({ sweep: int, title: str, line: str, table: str, maxParallel: int, items: z.array(z.looseObject({ item: int, label: str, task: str, state: str })) }),
     propose_sweep_cancel: cardDrafted,

package/dist/contracts/store-json.d.ts

@@ -232,6 +232,7 @@ declare const STORE_COLUMN_VALUES: {
             task_reopen: "task_reopen";
             task_restore: "task_restore";
             task_resume: "task_resume";
+            task_start: "task_start";
             tool_add: "tool_add";
             tool_remove: "tool_remove";
             trial_stop: "trial_stop";

package/dist/desktop-update.d.ts

@@ -97,7 +97,6 @@ export declare function sqliteLock(file: string, busyTimeoutMs?: number): Databa
 export declare function lockHeld(file: string): boolean;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
-    version?: never;
     active: boolean;
     phase: string;
     detail: string;
@@ -111,6 +110,7 @@ export declare function desktopUpdateStatus(stateDir: string): {
     wasRunning?: never;
     backupPath?: never;
     updateId?: never;
+    version?: never;
     buildId?: never;
     workDir?: never;
 } | {

package/dist/fast-start.d.ts

@@ -1,4 +1,5 @@
 import { type ApprovalPasswordFacts } from "./approval-password.js";
+import type { ChatApprovalLimits } from "./chat-approval.js";
 import { type TaskSizing } from "./phase-routing.js";
 import { type ApproveResult, type Scope } from "./scope.js";
 import { type Store } from "./store.js";
@@ -9,9 +10,10 @@ export declare const FAST_MAX_FILES = 3;
 export declare const FAST_MAX_LINES = 150;
 /** How long a rendered form may still be pressed. */
 export declare const FAST_PREVIEW_MS: number;
-/** Which person surface is filing. A chat, a flow, a token or an agent has no entry here. */
-export type FastVia = "console" | "terminal-ui" | "cli";
-export type FastRefusal = "setting" | "size" | "classifier" | "plan" | "quality" | "rules" | "protected" | "password" | "release" | "trial" | "chain" | "monthly" | "policy" | "agents" | "machine" | "mode";
+/** Which person surface is filing. `chat` is a Start card a person taps or answers yes to (one-step-chat.md); a flow, a
+ * token or an agent has no entry here. */
+export type FastVia = "console" | "terminal-ui" | "cli" | "chat";
+export type FastRefusal = "setting" | "size" | "classifier" | "plan" | "quality" | "rules" | "protected" | "password" | "release" | "trial" | "chain" | "monthly" | "policy" | "agents" | "machine" | "mode" | "limit";
 export declare const fastRefusalWords: (reason: FastRefusal) => string;
 /** Small tasks start right away: a project's own choice, else on for single-approver installs and off once there's more
  * than one approver. */
@@ -32,10 +34,34 @@ export type FastInput = {
     permissionMode?: "auto" | "bypassPermissions" | undefined;
 };
 export type PasswordFacts = Pick<ApprovalPasswordFacts, "passwordless" | "localOwner" | "freshAt" | "returnTo">;
+/** How the person is proved at the one step that differs by surface: the password rule the form reads, or (a chat
+ * start) the person's own chat approval limits. */
+export type FastProof = {
+    password: PasswordFacts;
+} | {
+    chat: ChatApprovalLimits;
+};
+/** Every person surface's eligibility: the rules, then a machine is refused. */
 export declare function fastStartEligible(store: Store, input: FastInput & {
     taskId: string;
     sizing: TaskSizing;
+} & ({
     password: PasswordFacts;
+} | {
+    proof: FastProof;
+}), now: Date): {
+    ok: true;
+    scope: Scope;
+} | {
+    ok: false;
+    reason: FastRefusal;
+};
+/** The rules alone, the same for every surface: only the person-proof step has two forms (FastProof). A preview reads
+ * these as any caller; Build reads them again behind the machine check (fastStartEligible). */
+export declare function fastStartRules(store: Store, input: FastInput & {
+    taskId: string;
+    sizing: TaskSizing;
+    proof: FastProof;
 }, now: Date): {
     ok: true;
     scope: Scope;
@@ -59,7 +85,7 @@ export type FastPreview = {
  * files exactly this, whatever is posted.
  */
 export declare function prepareFastStart(store: Store, input: FastInput & {
-    via: FastVia;
+    via: Exclude<FastVia, "chat">;
     password: PasswordFacts;
 }, now: Date): Promise<FastPreview>;
 export type FastBuild = {
@@ -84,9 +110,14 @@ export declare function fastStartBuild(store: Store, input: {
     digest: string;
     actor: string;
     via: FastVia;
-    password: PasswordFacts;
     approveNow: FastApprove;
-}, now: Date): FastBuild;
+    /** A chat start: the lead turn its card was drafted in. Its preview must have been prepared in that same turn. */
+    turn?: number;
+} & ({
+    password: PasswordFacts;
+} | {
+    proof: FastProof;
+}), now: Date): FastBuild;
 /**
  * A fast start that didn't start in time: its seal is cleared, in a logged transaction, and the task shows the ordinary
  * Approve plan. A task with a build running or a result to read is left to that.
@@ -134,3 +165,49 @@ export declare function keepGrownChange(store: Store, taskId: string, now: Date)
     ok: false;
     message: string;
 };
+/** What a chat start's preview is for: who asked, where, the lead's one-line title, and the lead turn it is prepared in. */
+export type ChatStartInput = {
+    actor: string;
+    repo: string;
+    title: string;
+    turn: number;
+};
+/**
+ * A chat start's preview, prepared by the lead's turn loop before the Start card is drafted: the classifier asked (at
+ * most its budget), the filing dry-run, and the rules read. It refuses no machine caller, because a preview grants
+ * nothing (the lead's turn runs as the lead): Build refuses a machine (fastStartBuild), and only a person's own tap or
+ * typed yes reaches Build. The row is bound to the person, `via = 'chat'` and the turn; a preview without a turn is
+ * unusable. The person's own chat limits are read again at the tap, for the chat it comes from; here only the loosest
+ * limit that still means something applies (no full access, no cap), so a card is never drafted for terms no chat
+ * approval could allow.
+ */
+export declare function prepareChatStart(store: Store, input: ChatStartInput, now: Date): Promise<FastPreview>;
+/** A chat start's preview, as the Start card reads it again: this person's, `via = 'chat'`, prepared in this turn,
+ * unexpired and unused. Null otherwise. */
+export declare function chatStartPreview(store: Store, preview: string, actor: string, turn: number, now: Date): {
+    taskId: string;
+    repo: string;
+    title: string;
+    sizing: TaskSizing;
+    digest: string;
+} | null;
+/** A dismissed Start card's preview can't be used: consumed, in the dismissal's transaction. */
+export declare function consumeChatStartPreview(store: Store, preview: string, now: Date): void;
+/**
+ * A chat start's filing dry-run, for its card: the scope filing would make, read in a savepoint that is always rolled
+ * back, with the rules read on it (any proof form; the card shows the terms, the tap proves the person). The card is made
+ * from these words; the tap files again and compares.
+ */
+export declare function chatStartDryRun(store: Store, input: {
+    actor: string;
+    repo: string;
+    title: string;
+    taskId: string;
+    sizing: TaskSizing;
+}, now: Date): {
+    ok: true;
+    scope: Scope;
+} | {
+    ok: false;
+    reason: FastRefusal;
+};

package/dist/fast-start.js

@@ -11,11 +11,18 @@
  * - **the Accept backstop**: a machine can't complete it, the project's grant doesn't push it until a person accepted it,
  *   and completion, publication and merge all read one verified measure of the whole change (verifiedChange).
  *
- * Only a person's own surfaces reach here (the browser, the terminal UI as the local owner, interactive `task new`).
- * Every machine is refused in the writer from trusted context. `task add` never comes this way.
+ * Only a person's own surfaces reach here (the browser, the terminal UI as the local owner, interactive `task new`, and
+ * a person's own tap or typed yes on a chat's Start card: docs/plans/one-step-chat.md). Every machine is refused in the
+ * writer from trusted context. `task add` never comes this way.
+ *
+ * A chat start (`via: "chat"`) runs the same rules (fastStartRules). Its words are the lead's, so it is filed as the
+ * lead's text (`proposedVia: "mate"`, quarantined), and only its person-proof step differs: chat has no password, so
+ * instead of the password field it passes only within the person's own chat approval limits (chatLimitProblem), and
+ * quarantined text is approvable in chat only on a card that showed every term whole (store.ts sealScopeApproval).
  */
 import { randomBytes } from "node:crypto";
 import { approvalPasswordField } from "./approval-password.js";
+import { chatLimitProblem } from "./chat-terms.js";
 import { isProtectedWork, protectedChanges } from "./approval-policy.js";
 import { originalTaskBase } from "./observations.js";
 import { legOf, makesNoPlan, routeFromJson } from "./phase-routing.js";
@@ -53,6 +60,7 @@ const FAST_WORDS = {
     agents: "Choose an agent first.",
     machine: "Only a person starts work this way.",
     mode: "This project's mode approves it.",
+    limit: "This is more than your chat approval setting allows.",
 };
 export const fastRefusalWords = (reason) => FAST_WORDS[reason];
 // ---- the project setting ---------------------------------------------------------------------------------------------
@@ -78,10 +86,16 @@ export function setFastStart(store, repo, on, by, now) {
 // ---- eligibility: one function, read by the form and again inside the transaction ------------------------------------
 /** Filed this way, the plan's words are the person's words, and they inspect the result. */
 export const fastAcceptance = (title) => [{ id: "c1", statement: title, how: null, evidence: ["manual-review"] }];
+/** Every person surface's eligibility: the rules, then a machine is refused. */
 export function fastStartEligible(store, input, now) {
-    const no = (reason) => ({ ok: false, reason });
     if (machineActing())
-        return no("machine");
+        return { ok: false, reason: "machine" };
+    return fastStartRules(store, { ...input, proof: "proof" in input ? input.proof : { password: input.password } }, now);
+}
+/** The rules alone, the same for every surface: only the person-proof step has two forms (FastProof). A preview reads
+ * these as any caller; Build reads them again behind the machine check (fastStartEligible). */
+export function fastStartRules(store, input, now) {
+    const no = (reason) => ({ ok: false, reason });
     if (!fastStartOn(store, input.repo))
         return no("setting");
     const account = store.accountOf(input.actor);
@@ -126,9 +140,13 @@ export function fastStartEligible(store, input, now) {
     const profile = scope.profile;
     if (levelOfProfile(scope.profile) === "escalated" || profile["checkAccess"] !== undefined || profile["machLookup"] !== undefined)
         return no("password");
-    const field = approvalPasswordField(store, { name: input.actor, taskId: input.taskId, scope, ...input.password });
-    if (field.field === "required" || field.field === "local-refused")
-        return no("password");
+    if ("password" in input.proof) {
+        const field = approvalPasswordField(store, { name: input.actor, taskId: input.taskId, scope, ...input.proof.password });
+        if (field.field === "required" || field.field === "local-refused")
+            return no("password");
+    }
+    else if (chatLimitProblem(scope, input.proof.chat, "your chat approval setting") !== null)
+        return no("limit");
     const ref = store.lookupRef(input.taskId);
     if (ref === null || store.budgetGate(now)({ ...store.budgetSubject(ref.id), agents: store.agentsFor([scope.profile.provider]) }).over !== null)
         return no("monthly");
@@ -136,12 +154,14 @@ export function fastStartEligible(store, input, now) {
         return no("policy");
     return { ok: true, scope };
 }
-/** File the task, inside the caller's transaction, exactly as Build will. */
+/** File the task, inside the caller's transaction, exactly as Build will. A chat start's words are the lead's: its text
+ * stays quarantined (`proposedVia: "mate"`), as every lead-written scope is. */
 function fileIt(store, id, input, now) {
     const filed = fileTaskProposal(store, {
         id, title: titleWithin(input.title), repo: input.repo, goal: input.title, acceptance: fastAcceptance(input.title), planning: "skip", sizing: input.sizing,
         ...(input.permissionMode === undefined ? {} : { permissionMode: input.permissionMode }),
-        filedVia: input.via === "console" ? "console" : input.via === "terminal-ui" ? "tui" : "cli", filedBy: { name: input.actor, kind: "person" },
+        filedVia: input.via === "console" ? "console" : input.via === "terminal-ui" ? "tui" : input.via === "chat" ? "chat" : "cli", filedBy: { name: input.actor, kind: "person" },
+        ...(input.via === "chat" ? { proposedVia: "mate" } : {}),
     }, now);
     return filed.ok ? { ok: true } : { ok: false, message: filed.message };
 }
@@ -152,10 +172,11 @@ class RolledBack extends Error {
         this.answer = answer;
     }
 }
-/** Run `body` in a transaction that never commits: a preview writes nothing. */
+/** Run `body` in a savepoint that never commits: a preview writes nothing, at any nesting depth (a nested transact runs
+ * in place, so only the savepoint undoes the writes when a caller already holds a transaction). */
 function dryRun(store, body) {
     try {
-        store.transact(() => { throw new RolledBack(body()); });
+        store.transact(() => store.savepoint(() => { throw new RolledBack(body()); }));
     }
     catch (error) {
         if (error instanceof RolledBack)
@@ -172,6 +193,9 @@ function dryRun(store, body) {
 export async function prepareFastStart(store, input, now) {
     if (machineActing())
         return { eligible: false, reason: "machine" };
+    // A chat start is prepared in the lead's turn (prepareChatStart), bound to it.
+    if (input.via === "chat")
+        return { eligible: false, reason: "rules" };
     if (!fastStartOn(store, input.repo))
         return { eligible: false, reason: "setting" };
     if (heuristicSizing({ title: input.title, goal: input.title }).size !== "small")
@@ -203,6 +227,10 @@ export async function prepareFastStart(store, input, now) {
 export function fastStartBuild(store, input, now) {
     if (machineActing())
         return { ok: false, reason: "machine", message: FAST_WORDS.machine };
+    const proof = "proof" in input ? input.proof : { password: input.password };
+    // The chat form of the proof is a chat start's alone; the form's surfaces keep the password rule.
+    if ("chat" in proof && input.via !== "chat")
+        return { ok: false, reason: "rules", message: FAST_WORDS.rules };
     class Refused extends Error {
         answer;
         constructor(answer) {
@@ -212,29 +240,37 @@ export function fastStartBuild(store, input, now) {
     }
     const refuse = (answer) => { throw new Refused(answer); };
     try {
-        return store.transact(() => {
+        // A savepoint inside the transaction: a refusal undoes the filing even when the caller already holds a transaction
+        // (a nested transact runs in place, and this function catches its own refusal).
+        return store.transact(() => store.savepoint(() => {
             const row = store.handle.prepare("SELECT * FROM fast_preview WHERE id = ? AND consumed_at IS NULL AND expires_at > ?").get(input.preview, now.toISOString());
             if (row === undefined || row["actor"] !== input.actor || row["via"] !== input.via)
                 return refuse({ ok: false, reason: "gone", message: "This form has expired. Start again." });
+            // A chat preview without a turn, or from another turn than its card's, is nobody's card.
+            if (input.via === "chat" && (row["turn"] === null || row["turn"] === undefined || input.turn === undefined || Number(row["turn"]) !== input.turn))
+                return refuse({ ok: false, reason: "gone", message: "This card has expired. Ask again." });
             const sizing = JSON.parse(String(row["sizing_json"]));
             const taskId = String(row["task_id"]);
             const filing = { actor: input.actor, repo: String(row["repo"]), title: String(row["title"]), ...(row["permission"] === null ? {} : { permissionMode: row["permission"] }) };
             const filed = fileIt(store, taskId, { ...filing, via: input.via, sizing }, now);
             if (!filed.ok)
                 return refuse({ ok: false, reason: "changed", message: filed.message });
-            const eligible = fastStartEligible(store, { ...filing, taskId, sizing, password: input.password }, now);
+            const eligible = fastStartEligible(store, { ...filing, taskId, sizing, proof }, now);
             if (!eligible.ok)
                 return refuse({ ok: false, reason: eligible.reason, message: FAST_WORDS[eligible.reason] });
             const at = now.toISOString();
             // approve() compares the digest the person saw with the plan just filed: changed terms refuse "changed".
             const approved = input.approveNow(taskId, input.digest, { rule: FAST_START_RULE, at });
+            if (!approved.ok && approved.reason === "changed")
+                return refuse({ ok: false, reason: "changed", message: "This changed since you read it. Read it again." });
+            // Chat has no password: a refusal there says the rule, not "takes your password".
             if (!approved.ok)
-                return refuse({ ok: false, reason: approved.reason === "changed" ? "changed" : "password", message: approved.reason === "changed" ? "This changed since you read it. Read it again." : FAST_WORDS.password });
+                return refuse(input.via === "chat" ? { ok: false, reason: "rules", message: approved.reason === "policy" ? approved.message : FAST_WORDS.rules } : { ok: false, reason: "password", message: FAST_WORDS.password });
             store.handle.prepare("UPDATE fast_preview SET consumed_at = ? WHERE id = ?").run(at, input.preview);
             store.handle.prepare("UPDATE task_ref SET fast_start_at = ?, fast_start_until = ? WHERE backend = ? AND external_id = ?").run(at, new Date(now.getTime() + FAST_WINDOW_MS).toISOString(), BUILT_IN, taskId);
             store.bumpWake();
             return { ok: true, taskId };
-        });
+        }));
     }
     catch (error) {
         if (error instanceof Refused)
@@ -429,3 +465,64 @@ export function keepGrownChange(store, taskId, now) {
         return { ok: true, digest: proposed.digest };
     });
 }
+/**
+ * A chat start's preview, prepared by the lead's turn loop before the Start card is drafted: the classifier asked (at
+ * most its budget), the filing dry-run, and the rules read. It refuses no machine caller, because a preview grants
+ * nothing (the lead's turn runs as the lead): Build refuses a machine (fastStartBuild), and only a person's own tap or
+ * typed yes reaches Build. The row is bound to the person, `via = 'chat'` and the turn; a preview without a turn is
+ * unusable. The person's own chat limits are read again at the tap, for the chat it comes from; here only the loosest
+ * limit that still means something applies (no full access, no cap), so a card is never drafted for terms no chat
+ * approval could allow.
+ */
+export async function prepareChatStart(store, input, now) {
+    if (!Number.isSafeInteger(input.turn) || input.turn < 1)
+        return { eligible: false, reason: "rules" };
+    if (!fastStartOn(store, input.repo))
+        return { eligible: false, reason: "setting" };
+    if (heuristicSizing({ title: input.title, goal: input.title }).size !== "small")
+        return { eligible: false, reason: "size" };
+    const mode = store.activeMode(input.repo, now);
+    if (mode !== null && /"autoApproveFiling":true/.test(mode.termsJson))
+        return { eligible: false, reason: "mode" };
+    const sizer = filingSizer();
+    const sizing = await classifyTask({ title: input.title, goal: input.title }, sizer.sizer, sizer.budget);
+    const taskId = `task-${randomBytes(8).toString("hex")}`;
+    const filing = { actor: input.actor, repo: input.repo, title: input.title };
+    const read = dryRun(store, () => {
+        const filed = fileIt(store, taskId, { ...filing, via: "chat", sizing }, now);
+        if (!filed.ok)
+            return { ok: false, reason: "plan" };
+        return fastStartRules(store, { ...filing, taskId, sizing, proof: { chat: { fullAccess: false, capMicrousd: null } } }, now);
+    });
+    if (!read.ok)
+        return { eligible: false, reason: read.reason };
+    const preview = randomBytes(16).toString("hex");
+    store.handle.prepare(`INSERT INTO fast_preview (id, actor, via, task_id, repo, title, permission, sizing_json, digest, created_at, expires_at, turn) VALUES (?, ?, 'chat', ?, ?, ?, NULL, ?, ?, ?, ?, ?)`)
+        .run(preview, input.actor, taskId, input.repo, input.title, JSON.stringify(sizing), read.scope.digest, now.toISOString(), new Date(now.getTime() + FAST_PREVIEW_MS).toISOString(), input.turn);
+    return { eligible: true, preview, digest: read.scope.digest, scope: read.scope, taskId };
+}
+/** A chat start's preview, as the Start card reads it again: this person's, `via = 'chat'`, prepared in this turn,
+ * unexpired and unused. Null otherwise. */
+export function chatStartPreview(store, preview, actor, turn, now) {
+    const row = store.handle.prepare("SELECT * FROM fast_preview WHERE id = ? AND consumed_at IS NULL AND expires_at > ?").get(preview, now.toISOString());
+    if (row === undefined || row["actor"] !== actor || row["via"] !== "chat" || row["turn"] === null || Number(row["turn"]) !== turn)
+        return null;
+    return { taskId: String(row["task_id"]), repo: String(row["repo"]), title: String(row["title"]), sizing: JSON.parse(String(row["sizing_json"])), digest: String(row["digest"]) };
+}
+/** A dismissed Start card's preview can't be used: consumed, in the dismissal's transaction. */
+export function consumeChatStartPreview(store, preview, now) {
+    store.handle.prepare("UPDATE fast_preview SET consumed_at = ? WHERE id = ? AND via = 'chat' AND consumed_at IS NULL").run(now.toISOString(), preview);
+}
+/**
+ * A chat start's filing dry-run, for its card: the scope filing would make, read in a savepoint that is always rolled
+ * back, with the rules read on it (any proof form; the card shows the terms, the tap proves the person). The card is made
+ * from these words; the tap files again and compares.
+ */
+export function chatStartDryRun(store, input, now) {
+    return dryRun(store, () => {
+        const filed = fileIt(store, input.taskId, { actor: input.actor, repo: input.repo, title: input.title, via: "chat", sizing: input.sizing }, now);
+        if (!filed.ok)
+            return { ok: false, reason: "plan" };
+        return fastStartRules(store, { actor: input.actor, repo: input.repo, title: input.title, taskId: input.taskId, sizing: input.sizing, proof: { chat: { fullAccess: false, capMicrousd: null } } }, now);
+    });
+}

package/dist/home-groups.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Home's three groups (docs/plans/one-step-chat.md H1): what waits on you, what is working, what is done. One rule for
+ * every surface that groups work this way (Home in the browser, the terminal UI), so they never disagree. Pure: no
+ * server, store or rendering imports, so the terminal UI's source can use it too.
+ */
+export type HomeGroup = "you" | "working" | "done";
+/** The groups in the order every surface shows them. */
+export declare const HOME_GROUPS: readonly HomeGroup[];
+/** Each group's heading. */
+export declare const HOME_GROUP_LABEL: Readonly<Record<HomeGroup, string>>;
+/** What the rule reads of a work index item (work-index.ts WorkIndexItem): the Tasks views that list it. */
+export type HomeGroupFacts = {
+    readonly status: {
+        readonly views: readonly string[];
+    };
+};
+/**
+ * Which group a work index item belongs to, in this order: it waits on you when the Needs you view lists it; it is
+ * working when the Running or the Queued view lists it (it runs, or it waits its turn or on Toolroll or another task:
+ * nobody is asked), so Working is exactly what the Running and Queued figures count; it is done when it is complete.
+ * Null for anything else: cancelled, replaced, put away.
+ */
+export declare function homeGroupOf(item: HomeGroupFacts): HomeGroup | null;
+/** The work index totals Home's figures show, each the count of the Tasks list its figure opens. */
+export type HomeFigures = {
+    readonly waitingOnYou: number;
+    readonly running: number;
+    readonly queued: number;
+    readonly done: number;
+};
+/** Home's figures from work index totals (work-index.ts WorkIndexCounts): Done is the whole Completed list. */
+export declare function homeFiguresOf(totals: {
+    readonly "needs-you": number;
+    readonly running: number;
+    readonly queued: number;
+    readonly completed: number;
+}): HomeFigures;
+/** "Waiting on you 2 · Running 1 · Queued 0 · Done 14": the opening line of `toolroll status` and chat /status. */
+export declare function homeFiguresLine(figures: HomeFigures): string;

package/dist/home-groups.js

@@ -0,0 +1,33 @@
+/**
+ * Home's three groups (docs/plans/one-step-chat.md H1): what waits on you, what is working, what is done. One rule for
+ * every surface that groups work this way (Home in the browser, the terminal UI), so they never disagree. Pure: no
+ * server, store or rendering imports, so the terminal UI's source can use it too.
+ */
+/** The groups in the order every surface shows them. */
+export const HOME_GROUPS = ["you", "working", "done"];
+/** Each group's heading. */
+export const HOME_GROUP_LABEL = { you: "Waiting on you", working: "Working", done: "Done" };
+/**
+ * Which group a work index item belongs to, in this order: it waits on you when the Needs you view lists it; it is
+ * working when the Running or the Queued view lists it (it runs, or it waits its turn or on Toolroll or another task:
+ * nobody is asked), so Working is exactly what the Running and Queued figures count; it is done when it is complete.
+ * Null for anything else: cancelled, replaced, put away.
+ */
+export function homeGroupOf(item) {
+    const views = item.status.views;
+    if (views.includes("needs-you"))
+        return "you";
+    if (views.includes("running") || views.includes("queued"))
+        return "working";
+    if (views.includes("completed"))
+        return "done";
+    return null;
+}
+/** Home's figures from work index totals (work-index.ts WorkIndexCounts): Done is the whole Completed list. */
+export function homeFiguresOf(totals) {
+    return { waitingOnYou: totals["needs-you"], running: totals.running, queued: totals.queued, done: totals.completed };
+}
+/** "Waiting on you 2 · Running 1 · Queued 0 · Done 14": the opening line of `toolroll status` and chat /status. */
+export function homeFiguresLine(figures) {
+    return `Waiting on you ${figures.waitingOnYou} · Running ${figures.running} · Queued ${figures.queued} · Done ${figures.done}`;
+}

package/dist/lead-answer-eval.d.ts

@@ -1,5 +1,6 @@
 import { type ChatConfig, type Store } from "./store.js";
 import { type VerifiedApprover } from "./principal.js";
+import { type ReplyVoice, type VoiceSummary } from "./reply-voice.js";
 import type { SubscriptionLeadRunner } from "./subscription-chat.js";
 export declare const LEAD_ANSWER_K = 3;
 type Seeded = {
@@ -47,6 +48,7 @@ type Run = {
     named: boolean;
     falseClaims: number;
     failed: string | null;
+    voice: ReplyVoice;
 };
 export type LeadAnswerReport = {
     mode: "scripted" | "real";
@@ -70,6 +72,11 @@ export type LeadAnswerReport = {
         total: number;
         failures: string[];
     };
+    /** How the read answers read, per model (docs/plans/lead-voice.md, V3). Reported; `pass` does not depend on it. */
+    voice: {
+        main: VoiceSummary;
+        quick: VoiceSummary;
+    };
     speedup: number;
     pass: boolean;
     reasons: string[];

package/dist/lead-answer-eval.js

@@ -32,6 +32,7 @@ import { verifyApproverStanding } from "./principal.js";
 import { subscriptionCredentialKey } from "./converse.js";
 import { runLeadTurn } from "./lead.js";
 import { quickLeadModel, quickRoute } from "./lead-route.js";
+import { replyVoice, summarizeVoice } from "./reply-voice.js";
 export const LEAD_ANSWER_K = 3;
 const T0 = new Date("2026-11-08T12:00:00.000Z");
 const REPO = "/eval/shop";
@@ -191,10 +192,10 @@ export async function runLeadAnswerEval(options) {
         const answer = outcome.ok && !outcome.replayed ? outcome.reply : "";
         const graded = gradeAnswer(question, answer);
         const failed = outcome.ok ? null : "refused" in outcome ? `refused: ${outcome.refused}` : `failed: ${outcome.failed}`;
-        return { model, route: turn?.route ?? null, answer, ms, named: failed === null && graded.named, falseClaims: graded.falseClaims, failed };
+        return { model, route: turn?.route ?? null, answer, ms, named: failed === null && graded.named, falseClaims: graded.falseClaims, failed, voice: replyVoice(answer) };
     };
     const read = questions.filter(one => one.kind === "read");
-    const tally = { main: { passK: 0, falseClaims: 0, ms: [] }, quick: { passK: 0, falseClaims: 0, ms: [] } };
+    const tally = { main: { passK: 0, falseClaims: 0, ms: [], voices: [] }, quick: { passK: 0, falseClaims: 0, ms: [], voices: [] } };
     for (const question of read) {
         for (const model of ["main", "quick"]) {
             let all = true;
@@ -206,6 +207,8 @@ export async function runLeadAnswerEval(options) {
                     all = false;
                 tally[model].falseClaims += one.falseClaims;
                 tally[model].ms.push(one.ms);
+                if (one.answer !== "")
+                    tally[model].voices.push(one.voice);
             }
             if (all)
                 tally[model].passK++;
@@ -250,6 +253,7 @@ export async function runLeadAnswerEval(options) {
         mode: options.mode, k, quickModel,
         read: { main: { passK: tally.main.passK, falseClaims: tally.main.falseClaims, medianMs: mainMs }, quick: { passK: tally.quick.passK, falseClaims: tally.quick.falseClaims, medianMs: quickMs }, questions: read.length },
         act: { kept, total: acts.length, failures: actFailures },
+        voice: { main: summarizeVoice(tally.main.voices), quick: summarizeVoice(tally.quick.voices) },
         speedup, pass: reasons.length === 0, reasons, runs,
     };
 }

package/dist/lead-capabilities.js

@@ -200,7 +200,7 @@ export function capabilitiesOf(store, input) {
  * 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" || name === "propose_sweep")
+    if (name === "propose_task" || name === "propose_start" || name === "propose_sweep")
         return true;
     if (name === "propose_flow")
         return FLOW_WORK.has(String(args["operation"]));

package/dist/lead-context.js

@@ -58,8 +58,8 @@ export const LEAD_REPLY_LIMITS = {
 };
 const within = (channel) => { const limit = LEAD_REPLY_LIMITS[channel]; return limit === null ? '' : ` Keep each reply within ${limit.toLocaleString('en-US')} characters, one message; a longer one is split across messages.`; };
 const CHANNEL_WORDS = {
-    console: 'The Toolroll console in a browser: cards and links show beside your reply.',
-    terminal: 'The Toolroll CLI in a terminal: plain text only.',
+    console: "The Toolroll console in a browser: a few short lines. Cards and links show beside your reply, so don't repeat what a card shows.",
+    terminal: 'The Toolroll CLI in a terminal: a few short lines of plain text.',
     telegram: `Telegram on their phone: a few short lines, the most important first.${within('telegram')}`,
     slack: `A Slack thread: a few short lines; teammates may read it.${within('slack')}`,
     discord: `A Discord thread: a few short lines; teammates may read it.${within('discord')}`,

package/dist/lead-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 LEAD_CONTRACT_VERSION = 51;
+export declare const LEAD_CONTRACT_VERSION = 53;
 export declare const LEAD_CONTRACT: string;