toolroll 0.9.31 → 0.9.33

package/dist/builder.js

@@ -1,5 +1,7 @@
 import { OBSERVATION_MAILBOX, observationBrief, parseObservationCases, collectObservations } from "./observations.js";
 import { checkCommandFor, effectiveCheckLevel, recordRunCheckLevel } from "./check-levels.js";
+import { queueBatchCheck } from "./batch-checks.js";
+import { batchesFullCheck } from "./batch-policy.js";
 import { skillsContext } from "./project-skills.js";
 import { failedVerificationEvidence, sealVerificationReceipt, verificationEvidence, reuseObservationVerification } from "./verification-evidence.js";
 import { learningContext } from "./project-learning.js";
@@ -684,7 +686,7 @@ export async function build(store, request) {
             // copy links it instead of installing its own; a setup that is about to
             // run never reaches through an old link into a shared copy.
             const depsRoot = sharedDepsRootOf(store);
-            const sharing = depsRoot === null ? null : sharingFor({ repo: leased.repo, worktree, setup: setupWanted });
+            const sharing = depsRoot === null ? null : sharingFor({ repo: leased.repo, worktree, setup: setupWanted, root: depsRoot });
             if (depsRoot !== null)
                 detachShared(worktree, depsRoot);
             if (depsRoot !== null && sharing !== null) {
@@ -2175,6 +2177,11 @@ async function settleProof(captured, statArtifactId, sealedHead) {
     const configured = chosenCheck?.command ?? null;
     if (repo !== null && chosenCheck !== null)
         recordRunCheckLevel(store, { id: runId, taskId: request.taskId, repo }, chosenCheck.level, checkChoice.from, now());
+    // Batch checks (batch-checks.ts): with the project's batching on, a Full check waits to run once with
+    // other results on a temporary batch commit. The build seals no check of its own; the batch's sealed
+    // receipt is this result's check, and Merge waits for it.
+    const batched = repo !== null && chosenCheck !== null && batchesFullCheck(store, repo, chosenCheck.level, configured);
+    const gateCommand = batched ? null : configured;
     let verifyCommand;
     const checkLog = [];
     const checkOutcomes = [];
@@ -2210,6 +2217,10 @@ async function settleProof(captured, statArtifactId, sealedHead) {
     else if (configured === null) {
         verifyCommand = { configured: false };
     }
+    else if (batched && repo !== null) {
+        verifyCommand = { configured: false };
+        queueBatchCheck(store, { runId, taskId: request.taskId, repo, head: sealedHead, base: captured.baseRevision, command: configured }, now());
+    }
     else if (!store.proveRunnerCustodyForSpawn(runId, now())) {
         verifyCommand = { configured: true, ran: false, attemptFailed: true, failure: "custody-lost" };
         recordCheckNote("Verification did not start: this worker no longer owned the build.");
@@ -2258,7 +2269,7 @@ async function settleProof(captured, statArtifactId, sealedHead) {
             const live = linked === null ? null : store.liveWorktreeSetup(repo);
             if (linked === null || live === null)
                 return null;
-            if (sharingFor({ repo, worktree, setup: live })?.key === linked && readyCopy(depsRoot, linked) !== null)
+            if (sharingFor({ repo, worktree, setup: live, root: depsRoot })?.key === linked && readyCopy(depsRoot, linked) !== null)
                 return null;
             if (!store.proveRunnerCustodyForSpawn(runId, now()))
                 return "custody-lost";
@@ -2497,7 +2508,7 @@ async function settleProof(captured, statArtifactId, sealedHead) {
     }
     const { verdict, reasons, matrix, machineVerdict } = adjudicate({
         directAssessment: true,
-        ...(configured === null ? {} : { verificationCommand: configured.command }),
+        ...(gateCommand === null ? {} : { verificationCommand: gateCommand.command }),
         proofArtifactPresent,
         proofParse,
         handoffPresent: handoffArtifact !== null,

package/dist/chat-actions.js

@@ -5,7 +5,7 @@ import { TEXT_LIMITS } from "./text-limits.js";
 import { publicChatText } from "./chat-display.js";
 import { gateWords } from "./approval-policy.js";
 import { createHash, randomBytes } from "node:crypto";
-import { verifiedAuthor } from "./store.js";
+import { mateTurnKeepsProposals, verifiedAuthor } from "./store.js";
 import { isVerifiedApprover, reproveApprover, } from "./principal.js";
 import { changeSkills, importSkill, skillsView, skillsVersion, testSkill, validateSkill, } from "./project-skills.js";
 import { changeKnowledge, knowledgeVersion, knowledgeView, } from "./project-knowledge.js";
@@ -1025,7 +1025,7 @@ function savedActionContext(store, who, id, state) {
         session.ceilingDigest !== who.ceilingDigest ||
         proposal.ceilingDigest !== who.ceilingDigest ||
         (!shared && turn?.session !== session.id) ||
-        turn?.state !== "answered")
+        !mateTurnKeepsProposals(turn))
         throw Error("This conversation ended or its project access changed. Ask for a fresh proposal.");
     requireActor(store, who, payload.repo, payload.operation);
     return payload;

package/dist/check-levels-ui.d.ts

@@ -19,6 +19,10 @@ export type CheckSettingsView = {
         on: boolean;
         source: "project" | "hands-off" | "default";
     };
+    /** Batch checks (batch-checks.ts): off by default. */
+    batch?: {
+        on: boolean;
+    };
     said: string | null;
     problem: string | null;
 };

package/dist/check-levels-ui.js

@@ -3,6 +3,7 @@
  * one. Every change takes the password and lands in the ledger; approving a
  * command restates exactly what will run, unattended, before the yes. */
 import { CHECK_LEVELS, CHECK_LEVEL_HINTS, CHECK_LEVEL_WORDS } from "./check-levels.js";
+import { BATCH_HINT } from "./batch-policy.js";
 const escape = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 export function checkSettingsHtml(view) {
     const hidden = (act) => `<input type="hidden" name="csrf" value="${escape(view.csrf)}"><input type="hidden" name="repo" value="${escape(view.repo)}"><input type="hidden" name="act" value="${act}">`;
@@ -19,7 +20,7 @@ export function checkSettingsHtml(view) {
         (fallsBack ? `<p class="meta">No quick command yet, so builds run the full check.</p>` : "") +
         (view.level !== "full" && view.full !== null ? `<p class="meta">The full check still runs when a pull request opens, and Merge waits for it.</p>` : "");
     if (!view.canChange) {
-        return head + `<section class="card check-settings">${current}</section>` + reviewHtml(view, "") +
+        return head + `<section class="card check-settings">${current}</section>` + batchHtml(view, "") + reviewHtml(view, "") +
             `<section class="card check-settings"><h2>Quick check</h2>${view.quick === null ? `<p class="meta">None yet.</p>` : command(view.quick)}</section>` +
             `<section class="card check-settings"><h2>Full check</h2>${view.full === null ? `<p class="meta">None yet.</p>` : command(view.full)}</section>`;
     }
@@ -45,7 +46,25 @@ export function checkSettingsHtml(view) {
             `<p class="meta">Quick builds run the full check instead.</p>${password}<button type="submit" class="danger">Remove</button></form></details></section>`;
     const full = `<details class="settings-more"><summary>Full check</summary><section class="card check-settings">` +
         (view.full === null ? `<p class="meta">None yet. Approve one with <span class="mono">toolroll verify set --repo … --command "…"</span>.</p>` : command(view.full)) + `</section></details>`;
-    return head + levelForm + reviewHtml(view, password) + quick + full;
+    return head + levelForm + batchHtml(view, password) + reviewHtml(view, password) + quick + full;
+}
+/** Batch checks: one state and one sentence; turning it on restates exactly what happens, behind a disclosure with the password. */
+function batchHtml(view, password) {
+    const batch = view.batch;
+    if (batch === undefined)
+        return "";
+    const act = batch.on ? "Turn off" : "Turn on";
+    const terms = batch.on ? `<p class="meta">Each result runs its own full check again. Results already waiting are checked now.</p>`
+        : `<ul class="check-terms"><li>When results finish within 10 minutes of each other, they're merged in a temporary checkout and the full check runs once.</li>` +
+            `<li>If it fails, the batch is split until the result that breaks it is found. Results that conflict are checked on their own.</li>` +
+            `<li>Nothing is merged into a real branch. Each result still lands on its own.</li></ul>`;
+    const change = password === "" ? ""
+        : `<details class="settings-more"><summary>${act}</summary><form method="post" action="/settings/checks" class="check-settings">` +
+            `<input type="hidden" name="csrf" value="${escape(view.csrf)}"><input type="hidden" name="repo" value="${escape(view.repo)}"><input type="hidden" name="act" value="batch">` +
+            `<input type="hidden" name="on" value="${batch.on ? "0" : "1"}">${terms}${password}<button type="submit">${act}</button></form></details>`;
+    return `<section class="card check-settings" data-batch-checks="${batch.on ? "on" : "off"}"><h2>Batch checks</h2>` +
+        `<p><strong>${batch.on ? "On" : "Off"}</strong> · ${escape(BATCH_HINT)}</p>` +
+        (batch.on && view.level !== "full" ? `<p class="meta">Only Full checks are batched.</p>` : "") + `${change}</section>`;
 }
 /** Automatic review: one state, one sentence, and its one change behind a disclosure (the password). */
 function reviewHtml(view, password) {

package/dist/checkout-cleanup.d.ts

@@ -1,7 +1,7 @@
 import { type CheckoutCleanup } from "./storage.js";
 import type { Store, WorktreeRow } from "./store.js";
 import { type WorktreePool } from "./worktree.js";
-/** A release candidate's checkout holds the build a deploy installs: kept a week after its task was done. */
+/** A release candidate's checkout holds the build a deploy installs: the newest complete one waits at most a week for it. */
 export declare const CANDIDATE_KEEP_MS: number;
 /** The worker's pass removes at most this many; a clean-up by hand has no cap. */
 export declare const AUTO_MAX = 20;
@@ -43,6 +43,7 @@ type Status = {
 export type Deployed = {
     head: string | null;
     run: number | null;
+    at?: string | null;
 };
 export declare function deployedRelease(stateDir: string | null): Deployed | null;
 /**

package/dist/checkout-cleanup.js

@@ -7,9 +7,10 @@
  *
  * Always kept: a checkout in use, one whose task isn't finished (on hold, failed, a revision under way), a result
  * still waiting for review, a checkout with changes (files Toolroll wrote itself aside), and one with commits on no
- * branch. A release candidate's checkout (a deploy installs from it) is kept only while it is the newest gate for its
- * release (for a week after it was done) or the one deployed; a superseded or cancelled gate goes at once, whatever
- * its task's state (staged releases keep the rollback copy). A checkout no task names (adopted after a crash) goes only
+ * branch. A release check's checkout (a deploy installs from it) goes once its task is complete, with its dependency
+ * install and journey output, except the one deployed now and the project's newest complete one still waiting for its
+ * deploy (no deploy since it was complete; at most a week). A superseded or cancelled gate goes at once, whatever its
+ * task's state (staged releases keep the rollback copy). A checkout no task names (adopted after a crash) goes only
  * in a clean-up by hand. Every removal is in the ledger.
  *
  * A kept checkout waiting for review or with changes drops its dependencies and build output once its run ends
@@ -23,7 +24,7 @@ import { COMPLETION_ACTION } from "./result-completion.js";
 import { CLEANUP_CHOICES, bytesWords, diskBytes } from "./storage.js";
 import { worktreePath } from "./worktree.js";
 const DAY_MS = 86_400_000;
-/** A release candidate's checkout holds the build a deploy installs: kept a week after its task was done. */
+/** A release candidate's checkout holds the build a deploy installs: the newest complete one waits at most a week for it. */
 export const CANDIDATE_KEEP_MS = 7 * DAY_MS;
 /** The worker's pass removes at most this many; a clean-up by hand has no cap. */
 export const AUTO_MAX = 20;
@@ -56,7 +57,7 @@ export function deployedRelease(stateDir) {
             continue;
         newest = { at, head: typeof journal["candidate"] === "string" ? journal["candidate"] : null, run: Number.isSafeInteger(journal["builder"]) ? Number(journal["builder"]) : null };
     }
-    return newest === null ? null : { head: newest.head, run: newest.run };
+    return newest === null ? null : { head: newest.head, run: newest.run, at: newest.at === "" ? null : newest.at };
 }
 /** The folder beside the database (where staged releases live), or null for a database in memory. */
 function stateDirOf(store) {
@@ -117,6 +118,19 @@ export function taskStatuses(store, now, deployed) {
         if (ref !== undefined && (completedRef.get(ref) ?? "") < at)
             completedRef.set(ref, at);
     }
+    const completedAtOf = (row) => [completed.get(String(row["id"])), completedRef.get(Number(row["ref"]))].filter((one) => one !== undefined).sort().at(-1) ?? null;
+    // Per project, the newest complete gate (by when it was complete): the one a deploy may still be about to install.
+    // Once the project deployed after it was complete, it waits for nothing.
+    const deployedRepo = deployedRef === undefined ? (live?.head == null ? undefined : gates.find(row => String(row["candidate"]) === live.head)?.["repo"]) : refs.find(row => Number(row["ref"]) === deployedRef)?.["repo"];
+    const newestDone = new Map();
+    for (const row of gates) {
+        if (row["state"] !== "done")
+            continue;
+        const at = completedAtOf(row) ?? (row["updated_at"] === null ? "" : String(row["updated_at"]));
+        const seen = newestDone.get(String(row["repo"]));
+        if (seen === undefined || at > seen.at || (at === seen.at && Number(row["ref"]) > seen.ref))
+            newestDone.set(String(row["repo"]), { ref: Number(row["ref"]), at });
+    }
     const byRef = new Map();
     const byId = new Map();
     const parentOf = new Map();
@@ -139,11 +153,13 @@ export function taskStatuses(store, now, deployed) {
         else if (state === "cancelled")
             status = { keep: null, taskId: id, finishedAt: updated };
         else {
-            const completedAt = [completed.get(id), completedRef.get(ref)].filter((one) => one !== undefined).sort().at(-1) ?? null;
+            const completedAt = completedAtOf(row);
             if (gate) {
                 const since = completedAt ?? updated ?? now.toISOString();
                 const until = new Date(Date.parse(since) + CANDIDATE_KEEP_MS).toISOString();
-                status = until > now.toISOString() ? { keep: "release candidate", taskId: id, finishedAt: since, dueAt: until } : { keep: null, taskId: id, finishedAt: since };
+                const deployedSince = live?.at != null && deployedRepo !== undefined && String(row["repo"]) === String(deployedRepo) && live.at >= since;
+                const waiting = newestDone.get(String(row["repo"]))?.ref === ref && !deployedSince && until > now.toISOString();
+                status = waiting ? { keep: "release candidate", taskId: id, finishedAt: since, dueAt: until } : { keep: null, taskId: id, finishedAt: since, atOnce: true };
             }
             else
                 status = completedAt === null ? { keep: "waiting for review", taskId: id, finishedAt: null } : { keep: null, taskId: id, finishedAt: completedAt };
@@ -353,7 +369,7 @@ export function whyWords(item) {
         case "in use": return "in use";
         case "task not finished": return "its task isn't finished";
         case "waiting for review": return "its result is waiting for review";
-        case "release candidate": return item.dueAt === undefined ? "the deployed release candidate" : `newest release candidate, kept until ${item.dueAt.slice(0, 10)}`;
+        case "release candidate": return item.dueAt === undefined ? "the deployed release candidate" : `newest release candidate, kept for its deploy until ${item.dueAt.slice(0, 10)}`;
         case "has changes": return "has changes";
         case "has commits": return "has commits on no branch";
         case "unreadable": return "git couldn't read it";

package/dist/coding-context.js

@@ -4,7 +4,7 @@ import { createHash } from 'node:crypto';
 import { basename, dirname, join, resolve, relative, isAbsolute, sep } from 'node:path';
 import { KNOWLEDGE_GUIDANCE, selectProjectKnowledge } from './project-knowledge.js';
 import { materializeProjectSkills, PROJECT_SKILLS_GUIDANCE, selectProjectSkills } from './project-skills.js';
-import { learningIdentity, learningSha } from './project-learning.js';
+import { identityMatches, learningIdentity, learningSha } from './project-learning.js';
 function freeze(value) {
     if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
         for (const child of Object.values(value))
@@ -74,7 +74,7 @@ export function prepareCodingContext(store, args) {
 }
 /** Integrity check for a persisted capture. The caller must separately recheck current account access. */
 export function verifyCodingContext(context, repo, baseRevision) {
-    if (context.metadata.version !== 1 || context.metadata.repo !== repo || context.metadata.baseRevision !== baseRevision || context.metadata.identity !== learningIdentity(repo) || context.sha256 !== digest(context.text, context.metadata))
+    if (context.metadata.version !== 1 || context.metadata.repo !== repo || context.metadata.baseRevision !== baseRevision || !identityMatches(repo, context.metadata.identity) || context.sha256 !== digest(context.text, context.metadata))
         throw Error('The coding session context could not be verified.');
     if (context.metadata.files.length && context.metadata.directory === null)
         throw Error('The coding session skill files are unavailable.');

package/dist/coding-handoff.js

@@ -4,7 +4,7 @@ import { lstatSync, realpathSync } from 'node:fs';
 import { sqliteRuntime } from './sqlite-runtime.js';
 import { codingCatalogPath } from './coding-update.js';
 import { updateAdmissionPaused } from './desktop-update-gate.js';
-import { learningIdentity, learningSha } from './project-learning.js';
+import { acceptedIdentities, learningIdentity, learningSha } from './project-learning.js';
 import { fileTaskProposal } from './proposal.js';
 import { parseAcceptanceCriteria, proposeGuarded } from './scope.js';
 import { validateTaskText } from './task-text.js';
@@ -164,7 +164,7 @@ export function readCodingHandoff(store, taskId) {
         if (!row)
             throw Error('The coding handoff receipt is missing. Restore it before review.');
         const receipt = parseReceipt(row), scope = store.getScope(taskId), ref = store.lookupRef(taskId);
-        if (receipt.taskId !== taskId || ref?.repo !== receipt.repo || receipt.identity !== learningIdentity(receipt.repo) || !scope || scope.termsProblem != null || scope.candidate !== receipt.candidate)
+        if (receipt.taskId !== taskId || ref?.repo !== receipt.repo || !acceptedIdentities(store, receipt.repo).has(receipt.identity) || !scope || scope.termsProblem != null || scope.candidate !== receipt.candidate)
             throw Error('The coding review no longer matches its saved project, candidate or scope.');
         verifySeal(db, receipt, scope.digest);
         return { taskId, scopeDigest: scope.digest, receipt };

package/dist/desktop-update.d.ts

@@ -125,13 +125,13 @@ export declare function prepareDesktopUpdate(stateDir: string, installed: string
 export declare function sqliteLock(file: string, busyTimeoutMs?: number): DatabaseSync | null;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
-    error?: never;
     active: boolean;
     phase: string;
     detail: string;
     running: boolean;
     canResume: boolean;
     canCancel: boolean;
+    error?: never;
     automaticRecovery?: never;
     recoveryAttempts?: never;
     recoveryRepairs?: never;

package/dist/exec.d.ts

@@ -56,6 +56,8 @@ export type RunOptions = ProcessTreeObserver & {
      * timeoutMs there is deliberately no absolute wall-clock ceiling.
      */
     idleTimeoutMs?: number;
+    /** Ends a process-group run early, exactly as its timeout does: the whole group is killed and the result reads timed out. */
+    signal?: AbortSignal;
     maxBuffer?: number;
     /**
      * Extra environment, merged over the process's own. A capability probe is a

package/dist/exec.js

@@ -526,6 +526,7 @@ export function run(file, args, options = {}) {
         return retryTransientSpawn(() => runBufferedGroup(file, args, {
             timeoutMs,
             maxBuffer,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
             ...(options.stdin === undefined ? {} : { stdin: options.stdin }),
             ...(cwd === undefined ? {} : { cwd }),
             ...(childEnv === undefined ? {} : { childEnv }),
@@ -610,6 +611,15 @@ function runBufferedGroup(file, args, bag) {
             timedOut = true;
             killGroup(child);
         }, bag.timeoutMs);
+        // The caller's deadline, when it owns one: the same group kill as the timer.
+        const aborted = () => {
+            timedOut = true;
+            killGroup(child);
+        };
+        if (bag.signal?.aborted === true)
+            aborted();
+        else
+            bag.signal?.addEventListener("abort", aborted, { once: true });
         child.stdout?.setEncoding("utf8");
         child.stdout?.on("data", (chunk) => {
             stdout += chunk;
@@ -638,6 +648,7 @@ function runBufferedGroup(file, args, bag) {
                 return;
             settled = true;
             clearTimeout(timer);
+            bag.signal?.removeEventListener("abort", aborted);
             liveProviders.delete(child);
             // The OS object is settled BEFORE the answer: a root that exited is
             // not an empty container until the OS says so.

package/dist/guides.js

@@ -419,6 +419,9 @@ and crew agent reads from it before working:
 - Instructions and references change on the Knowledge page under Settings,
   or through the lead's knowledge cards. Every change keeps a revision you
   can restore.
+- If a project was replaced at the same path, its saved knowledge waits:
+  tasks run without it until an approver applies it on the Knowledge page
+  or with \`toolroll knowledge apply --repo PATH --as <you> --token <t>\`.
 - Agent conclusions are not instructions: a crew agent reports; a person or
   the lead's confirmed card records.
 

package/dist/knowledge-cli.d.ts

@@ -89,7 +89,38 @@ export declare const KNOWLEDGE_DESCRIPTORS: readonly [{
         readonly takesValue: true;
         readonly meaning: 'environment variable containing a scoped coordinator token';
     }];
+}, {
+    readonly action: 'apply';
+    readonly synopsis: "carry this project's saved knowledge from before a change forward as a new revision; an approver's --as/--token";
+    readonly mutation: 'identity-idempotent';
+    readonly takesQuery: false;
+    readonly flags: readonly [{
+        readonly name: 'repo';
+        readonly takesValue: true;
+        readonly meaning: 'admitted project checkout root';
+    }, {
+        readonly name: 'as';
+        readonly takesValue: true;
+        readonly meaning: 'approver account name';
+    }, {
+        readonly name: 'token';
+        readonly takesValue: true;
+        readonly meaning: "the approver's password (never a lead token)";
+    }, {
+        readonly name: 'json';
+        readonly takesValue: false;
+        readonly meaning: 'versioned structured response';
+    }, {
+        readonly name: 'db';
+        readonly takesValue: true;
+        readonly meaning: 'local Toolroll database';
+    }];
+    readonly audience: 'operator';
 }];
+/** `knowledge apply`: the caller has verified `actor` as an approver of `repo` (never the lead). */
+export declare function runKnowledgeApply(options: Map<string, string | true>, context: KnowledgeCliContext & {
+    actor: string | null;
+}): number;
 export type KnowledgeCliContext = {
     store: Store;
     write: (line: string) => void;

package/dist/knowledge-cli.js

@@ -6,6 +6,7 @@ import { authenticateCoordinator } from './coordinator.js';
 import { envelopeJson } from './envelope.js';
 import { repositoryContext } from './repository-context.js';
 import { namedPath } from './names.js';
+import { applySavedKnowledge } from './project-knowledge.js';
 const flags = [
     { name: 'repo', takesValue: true, meaning: 'admitted project checkout root' },
     { name: 'base', takesValue: true, meaning: 'exact committed task base; defaults to current HEAD' },
@@ -14,11 +15,43 @@ const flags = [
     { name: 'token-file', takesValue: true, meaning: 'explicit scoped coordinator credential file' },
     { name: 'token-env', takesValue: true, meaning: 'environment variable containing a scoped coordinator token' },
 ];
+const applyFlags = [
+    { name: 'repo', takesValue: true, meaning: 'admitted project checkout root' },
+    { name: 'as', takesValue: true, meaning: 'approver account name' },
+    { name: 'token', takesValue: true, meaning: "the approver's password (never a lead token)" },
+    { name: 'json', takesValue: false, meaning: 'versioned structured response' },
+    { name: 'db', takesValue: true, meaning: 'local Toolroll database' },
+];
 export const KNOWLEDGE_DESCRIPTORS = [
     { action: 'search', synopsis: 'find bounded source excerpts and relevant code symbols', mutation: 'none', takesQuery: true, flags },
     { action: 'impact', synopsis: 'inspect static imports affected by one file or unambiguous symbol', mutation: 'none', takesQuery: true, flags },
     { action: 'refresh', synopsis: 'refresh the optional local code index; never starts a model or task', mutation: 'identity-idempotent', takesQuery: false, flags },
+    // A person's action: the approver carries saved knowledge from before a project change forward.
+    { action: 'apply', synopsis: "carry this project's saved knowledge from before a change forward as a new revision; an approver's --as/--token", mutation: 'identity-idempotent', takesQuery: false, flags: applyFlags, audience: 'operator' },
 ];
+/** `knowledge apply`: the caller has verified `actor` as an approver of `repo` (never the lead). */
+export function runKnowledgeApply(options, context) {
+    const command = 'knowledge apply';
+    const fail = (reason, message) => { context.write(context.json ? envelopeJson({ ok: false, command, reason, message }) : message); return reason === 'usage' ? 2 : 3; };
+    for (const key of options.keys())
+        if (!applyFlags.some(flag => flag.name === key))
+            return fail('usage', `--${key} is not a knowledge apply option.`);
+    const repo = options.get('repo');
+    if (typeof repo !== 'string' || !repo.trim() || repo.length > 4096 || /[\x00-\x1f]/.test(repo))
+        return fail('usage', 'Use --repo with the project checkout root.');
+    if (context.actor === null)
+        return fail('unauthenticated', 'An approver of this project applies saved knowledge: --as <you> --token <password>.');
+    let revision;
+    try {
+        revision = applySavedKnowledge(context.store, resolve(repo), context.actor, context.now);
+    }
+    catch (error) {
+        return fail('failed', error instanceof Error ? error.message : 'Saved knowledge could not be applied.');
+    }
+    const message = revision === null ? 'Nothing to apply.' : `Applied saved knowledge as version ${revision}.`;
+    context.write(context.json ? envelopeJson({ ok: true, command, result: { revision, message } }) : message);
+    return 0;
+}
 function lines(result) {
     return [
         `Repository context: ${result.index.status}${result.index.engine === 'text-search' ? ' · source search' : ' · code relationships'}`,
@@ -32,8 +65,8 @@ export async function runKnowledgeCommand(positional, options, context) {
     const spec = KNOWLEDGE_DESCRIPTORS.find(s => s.action === positional[0]);
     const command = spec ? `knowledge ${spec.action}` : 'knowledge';
     const fail = (reason, message) => { context.write(context.json ? envelopeJson({ ok: false, command, reason, message }) : message); return reason === 'usage' ? 2 : 3; };
-    if (!spec)
-        return fail('usage', 'Use knowledge search <query>, impact <file-or-symbol>, or refresh with --repo PATH.');
+    if (!spec || spec.action === 'apply')
+        return fail('usage', 'Use knowledge search <query>, impact <file-or-symbol>, refresh or apply with --repo PATH.');
     if (positional.length !== (spec.takesQuery ? 2 : 1))
         return fail('usage', spec.takesQuery ? 'Provide one quoted query or source path.' : 'knowledge refresh takes no query.');
     for (const key of options.keys())

package/dist/knowledge-ui.d.ts

@@ -1,4 +1,4 @@
-import type { KnowledgeDraft, KnowledgeSelection, KnowledgeView } from './project-knowledge.js';
+import { type KnowledgeDraft, type KnowledgeSelection, type KnowledgeView } from './project-knowledge.js';
 export declare const KNOWLEDGE_CSS = ".knowledge{max-width:780px;min-width:0;overflow-wrap:anywhere}.knowledge .card{padding:20px;min-width:0;margin:16px 0}.knowledge h2{margin:0 0 12px}.knowledge form{display:grid;gap:12px;margin:0}.knowledge label{display:grid;gap:6px}.knowledge textarea,.knowledge input,.knowledge select{box-sizing:border-box;width:100%;min-width:0;max-width:100%}.knowledge textarea{resize:vertical;min-height:110px}.knowledge button,.knowledge summary,.knowledge .button-link{min-height:44px}.knowledge button{justify-self:start;white-space:nowrap}.knowledge summary{padding:12px 0;cursor:pointer}.knowledge pre{white-space:pre-wrap;overflow-wrap:anywhere;font:inherit}.knowledge .knowledge-actions{display:flex;gap:12px;flex-wrap:wrap}.knowledge .meta{font-size:.86rem}.knowledge .knowledge-source{display:block}.knowledge details+details{border-top:1px solid var(--so-line)}.memory-stats{display:flex;flex-wrap:wrap;gap:.4rem}.memory-stats span{padding:.15rem .55rem;border-radius:.375rem;background:var(--so-neutral-soft);color:var(--so-neutral-ink)}@media(max-width:600px){.knowledge .card{padding:16px}.knowledge h2{font-size:1.1rem}}";
 export declare function knowledgeHtml(view: KnowledgeView, csrf: string, canManage: boolean, draft?: KnowledgeDraft, error?: string): string;
 export declare function knowledgeContextHtml(snapshot: KnowledgeSelection | null): string;

package/dist/knowledge-ui.js

@@ -1,3 +1,4 @@
+import { STALE_KNOWLEDGE } from './project-knowledge.js';
 const e = (s) => String(s ?? '').replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c]));
 const fields = (data) => Object.entries(data).map(([k, v]) => `<input type="hidden" name="${e(k)}" value="${e(v)}">`).join('');
 export const KNOWLEDGE_CSS = `.knowledge{max-width:780px;min-width:0;overflow-wrap:anywhere}.knowledge .card{padding:20px;min-width:0;margin:16px 0}.knowledge h2{margin:0 0 12px}.knowledge form{display:grid;gap:12px;margin:0}.knowledge label{display:grid;gap:6px}.knowledge textarea,.knowledge input,.knowledge select{box-sizing:border-box;width:100%;min-width:0;max-width:100%}.knowledge textarea{resize:vertical;min-height:110px}.knowledge button,.knowledge summary,.knowledge .button-link{min-height:44px}.knowledge button{justify-self:start;white-space:nowrap}.knowledge summary{padding:12px 0;cursor:pointer}.knowledge pre{white-space:pre-wrap;overflow-wrap:anywhere;font:inherit}.knowledge .knowledge-actions{display:flex;gap:12px;flex-wrap:wrap}.knowledge .meta{font-size:.86rem}.knowledge .knowledge-source{display:block}.knowledge details+details{border-top:1px solid var(--so-line)}.memory-stats{display:flex;flex-wrap:wrap;gap:.4rem}.memory-stats span{padding:.15rem .55rem;border-radius:.375rem;background:var(--so-neutral-soft);color:var(--so-neutral-ink)}@media(max-width:600px){.knowledge .card{padding:16px}.knowledge h2{font-size:1.1rem}}`;
@@ -8,6 +9,12 @@ export function knowledgeHtml(view, csrf, canManage, draft, error) {
     const referenceFields = (d) => `<label>Name<input name="title" maxlength="120" value="${e(d.title)}" required></label><label>Reference text<textarea name="content" rows="5" maxlength="12000">${e(d.content)}</textarea></label><details${d.path ? ' open' : ''}><summary>Use a project document</summary><label>Committed .md or .txt path<input name="path" value="${e(d.path)}" placeholder="docs/design-guide.md"></label><p class="meta">Uses the committed file instead of the text above. Save again to refresh it.</p></details><button type="submit">Save reference</button>`;
     const refs = view.knowledge.references.map(ref => `<details class="card"${draft?.id === ref.id ? ' open' : ''}><summary><strong>${e(ref.title)}</strong></summary>${ref.path ? `<span class="meta knowledge-source">${e(ref.path)} · ${e(ref.sourceRevision?.slice(0, 7))}</span>` : ''}<pre>${e(ref.content)}</pre>${manage ? `<details${draft?.id === ref.id ? ' open' : ''}><summary>Edit reference</summary>${form('save', referenceFields(draft?.id === ref.id ? draft : { title: ref.title, content: ref.path ? '' : ref.content, path: ref.path ?? '' }), { id: ref.id })}<details><summary>Remove reference</summary>${form('remove', '<p>Remove from future tasks. Previous run context stays available.</p><button>Remove reference</button>', { id: ref.id })}</details></details>` : ''}</details>`).join('');
     const history = view.history.map(h => `<li><a class="button-link" href="/settings/knowledge?repo=${encodeURIComponent(view.repo)}&version=${h.revision}">Version ${h.revision}</a> · ${e(h.actor)} · ${e(h.at.slice(0, 16).replace('T', ' '))} UTC</li>`).join('');
+    if (view.stale) {
+        // One notice, the saved knowledge on demand, one approver action. Editing waits until it is applied.
+        const saved = view.stale.knowledge;
+        const review = `<details><summary>Review saved knowledge</summary><pre class="knowledge-instructions">${e(saved.instructions || 'No project instructions.')}</pre>${saved.references.map(ref => `<details><summary>${e(ref.title)}</summary><pre>${e(ref.content)}</pre></details>`).join('')}</details>`;
+        return `<section class="knowledge knowledge-library">${error ? `<p class="problem" role="alert">${e(error)}</p>` : ''}<section class="card knowledge-stale"><p role="status">${e(STALE_KNOWLEDGE)}.</p>${review}${manage ? form('apply', '<button>Apply saved knowledge</button>') : ''}</section></section>`;
+    }
     const instructions = `<pre class="knowledge-instructions">${e(view.knowledge.instructions || 'No project instructions yet.')}</pre>`;
     const editor = manage ? `<details class="knowledge-editor"${draft?.instructions !== undefined ? ' open' : ''}><summary>${view.knowledge.instructions ? 'Edit instructions' : 'Add instructions'}</summary>${form('instructions', `<textarea aria-label="Project instructions" name="instructions" rows="5" maxlength="4000" placeholder="Goals, preferences, and what good work looks like…">${e(draft?.instructions ?? view.knowledge.instructions)}</textarea><button>Save instructions</button>`)}</details>` : '';
     return `<section class="knowledge knowledge-library">${error ? `<p class="problem" role="alert">${e(error)}</p>` : ''}<section class="knowledge-intro"><h2>Instructions</h2>${instructions}${editor}</section><section><h2>References</h2>${refs || '<p class="meta">Add a spec, design guide, or useful project document.</p>'}${manage ? `<details class="card"${draft?.title && !draft.id ? ' open' : ''}><summary>Add reference</summary>${form('save', referenceFields(draft?.id ? {} : draft ?? {}))}</details>` : ''}</section>${history ? `<details><summary>Change history</summary><ol>${history}</ol></details>` : ''}</section>`;

package/dist/lead-capabilities.d.ts

@@ -1,10 +1,3 @@
-/**
- * What the lead can rely on right now, in one read (get_capabilities): the agents a project's route would run, the
- * workers that would run them, the project's tools and skills, the integrations, and the project's checks. Every entry
- * says what it lets the lead do and, when it can't, the one next step and the settings control (show_control) that
- * takes the owner there. Everything here reads what is already recorded — runner readiness reports, sign-in pauses,
- * plan-limit readings, tool tests, skill tests, integration checks — and never probes anything that spends.
- */
 import type { Store } from "./store.js";
 import type { ChatControl } from "./chat-controls.js";
 import type { ProviderId } from "./provider.js";

package/dist/lead-capabilities.js

@@ -1,3 +1,11 @@
+/**
+ * What the lead can rely on right now, in one read (get_capabilities): the agents a project's route would run, the
+ * workers that would run them, the project's tools and skills, the integrations, and the project's checks. Every entry
+ * says what it lets the lead do and, when it can't, the one next step and the settings control (show_control) that
+ * takes the owner there. Everything here reads what is already recorded — runner readiness reports, sign-in pauses,
+ * plan-limit readings, tool tests, skill tests, integration checks — and never probes anything that spends.
+ */
+import { projectBatchChecks } from "./batch-policy.js";
 import { resolveRouteCandidates } from "./agentconfig.js";
 import { authPauseOf, messageCommand, providerName } from "./provider-auth.js";
 import { readAuthMode, SUBSCRIPTION_CAPABLE } from "./keys.js";
@@ -136,7 +144,9 @@ function checksOf(store, repo) {
         return { ...base, state: "Off", ok: false, next: "Builds are not checked. Turn checks on for the project if results need them.", link: "projects" };
     if (!releaseCheck)
         return { ...base, state: `${CHECK_LEVEL_WORDS[level]} · no release check`, ok: false, next: "No release check is set up, so no result can show a passing check. Set one for the project.", link: "projects" };
-    return { ...base, state: level === "quick" && !quickCheck ? "Quick · runs the release check" : `${CHECK_LEVEL_WORDS[level]} · release check set`, ok: true, next: null, link: null };
+    // Batch checks are changed in Settings → Projects → Checks (or `project checks --batch on|off`), never from chat.
+    const batched = level === "full" && projectBatchChecks(store, repo).on ? " · batched with results that finish together" : "";
+    return { ...base, state: level === "quick" && !quickCheck ? "Quick · runs the release check" : `${CHECK_LEVEL_WORDS[level]} · release check set${batched}`, ok: true, next: null, link: null };
 }
 function workersOf(store, repos, now) {
     const live = store.handle.prepare(`SELECT ref.external_id AS task, ref.repo AS repo FROM claim JOIN task_ref AS ref ON ref.id = claim.task_ref

package/dist/mate-doors.js

@@ -15,7 +15,7 @@ import { executeSharedAction, sharedActionPayload, sharedActionAllowsChallenge,
  * silent re-read.
  */
 import { isCheckLevel, setTaskCheckLevel } from "./check-levels.js";
-import { verifiedAuthor } from "./store.js";
+import { mateTurnKeepsProposals, verifiedAuthor } from "./store.js";
 import { isVerifiedApprover, reproveApprover } from "./principal.js";
 import { TeamLeads } from './team-leads.js';
 import { fileTaskProposal } from "./proposal.js";
@@ -97,7 +97,7 @@ export function confirmMateProposal(store, who, proposalId, now, options) {
             return { ok: false, kind: proposal.kind, reason: "ceiling-changed", said: "the admitted projects changed since this was proposed — it cannot be confirmed" };
         }
         const turn = store.getMateTurn(proposal.turn);
-        if (turn === null || turn.state !== "answered") {
+        if (!mateTurnKeepsProposals(turn) || proposal.state === "drafting") {
             return { ok: false, kind: proposal.kind, reason: "turn-not-answered", said: "this proposal's turn did not finish — it cannot be confirmed" };
         }
         if (proposal.kind === "cancel") {

package/dist/mate.d.ts

@@ -93,6 +93,7 @@ export type MateTurnOutcome = {
     failed: MateFailure;
     message: string;
     unknownSpend: boolean;
+    saved?: boolean;
 };
 /** What happened, what it means, and one next step: plain words a person can act on, never internal terms. */
 export declare const MATE_REFUSAL_COPY: Record<MateRefusal, string>;
@@ -102,7 +103,7 @@ export declare const MATE_CHANNEL_COPY: Record<MateChannelProblem, string>;
 export declare const MATE_FAILURE_COPY: {
     readonly stopped: "This reply was stopped before it finished, from another window or by a newer message. Nothing it proposed was kept. Send your message again if you still need an answer.";
     readonly ended: "Your sign-in or this conversation ended while the lead was answering. Nothing it proposed was kept. Sign in again or start a new chat, then send your message again.";
-    readonly tooLong: "The reply took too long and was stopped. Nothing it proposed was kept. Send your message again, or ask for less at once.";
+    readonly tooLong: string;
     readonly secretRead: "Something the lead read looked like a password or key, so it stopped before sending it anywhere. Nothing was kept. Remove the password or key from that task or note, then ask again.";
     readonly secretReply: "The lead's reply contained something that looked like a password or key, so it was thrown away. Nothing was kept. Ask again, without asking for a password or key.";
     readonly paused: "An earlier reply stopped before its cost was known, so chat is paused. This message wasn't answered. Confirm that earlier reply on the Chat page, then send again.";
@@ -111,7 +112,7 @@ export declare const MATE_FAILURE_COPY: {
     readonly unreadable: "The chat provider sent back an answer that couldn't be read, so it was thrown away. Nothing was kept. Send your message again.";
     readonly signIn: "The chat provider couldn't answer; its sign-in may have expired. Nothing was kept. Sign in to it again on this computer, then send your message again.";
     readonly refused: "The chat provider turned the request down. Nothing was kept or charged. Try again in a minute; if it keeps happening, check the provider in Settings → Lead.";
-    readonly tooLongUnknownCost: "The reply took too long and was stopped, and its cost isn't known yet, so chat is paused. Nothing it proposed was kept. Confirm the cost on the Chat page to turn chat back on.";
+    readonly tooLongUnknownCost: string;
     readonly lostUnknownCost: "The chat provider stopped responding partway through, and the cost isn't known, so chat is paused. Nothing it proposed was kept. Confirm the cost on the Chat page to turn chat back on.";
     readonly unreadableUnknownCost: "The chat provider sent back an answer that couldn't be read, and its cost isn't known, so chat is paused. Nothing it proposed was kept. Confirm the cost on the Chat page to turn chat back on.";
     readonly empty: "The lead sent back an empty answer. Nothing was kept. Send your message again.";
@@ -119,6 +120,9 @@ export declare const MATE_FAILURE_COPY: {
 };
 /** A failed turn's saved reason as plain words, for a surface that reads the turn back later (a restart, a delivery retry). */
 export declare function mateFailureText(reason: string | null): string;
+/** How long a provider that ignored its abort at the turn's deadline is waited for before the turn ends without it.
+ * Its process group was already killed at the deadline; this only bounds the wait for the transport to say so. */
+export declare const MATE_ABORT_GRACE_MS = 5000;
 /** The last messages of the thread as provider-neutral history, newest kept first until the byte cap. */
 export declare function historyFor(store: Store, thread: number, queuedMessageId?: number): MateHistoryMessage[];
 /** "read 3 · proposed 1 · 2 steps" — counts only, never results (ruling 11). */