toolroll 0.9.92 → 0.9.94

package/dist/dispatch.js

@@ -16,6 +16,8 @@ import { REVIEW_TOKENS, resultStatusOf, reviewFactsOf } from "./workspace-ui.js"
 import { replacedWords } from "./task-status.js";
 import { failedAttemptSentence, latestFinishedAttempt } from "./needs-you.js";
 import { buildReviewOf } from "./review-switch.js";
+import { vanishedStopOf, vanishedStopSentence } from "./vanished-retry.js";
+import { routeChangeOf } from "./route-change.js";
 import { BUILT_IN, refArchived, parseCapabilityKey } from "./store.js";
 import { shortWhen } from "./when-html.js";
 export const DEFAULT_MAX_OPEN_DECISIONS = 5;
@@ -81,7 +83,7 @@ export function scopeApprovedForDispatch(store, taskRef, now) {
        JOIN task_ref ON task_ref.id = ? AND task_scope.task_id = task_ref.external_id
        WHERE task_scope.approved_digest = task_scope.digest AND task_scope.approved_at IS NOT NULL
          AND ${authorityStandsSql("task_scope", "task_ref.repo", "?")}`)
-        .get(taskRef, now.toISOString(), now.toISOString(), now.toISOString());
+        .get(taskRef, now.toISOString(), now.toISOString(), now.toISOString(), now.toISOString());
     return row !== undefined;
 }
 /** The phase the ordinary dispatch loop would choose before it resolves an
@@ -229,9 +231,9 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
             return answer(code, code === "reviewing" ? "running" : "waiting", status.label, status.detail, { action: retry.state === "retryable" ? "retry-review" : "open-result", review });
         }
         if (!accepted && proof?.verdict === "refuted")
-            return answer("proof-refuted", "waiting", status.label, `${status.detail} Review the evidence to correct it, or record an explicit acceptance.`, { action: "open-result", review });
+            return answer("proof-refuted", "waiting", status.label, `${status.detail} Open the result to send it back, or accept it with a reason.`, { action: "open-result", review });
         if (!accepted && proof?.verdict === "short")
-            return answer("needs-verification", "waiting", status.label, `${status.detail} Open the result for the exact criteria still needing verification.`, { action: "open-result", review });
+            return answer("needs-verification", "waiting", status.label, `${status.detail} Open the result to see which requirements still need checking.`, { action: "open-result", review });
         if (!accepted && proof === null && noChangeRecord !== true)
             return answer("needs-verification", "waiting", status.label, status.detail, { action: "open-result", review });
         return answer("complete", "terminal", status.label, review?.state === "succeeded" && review.attempt !== null && review.attempt > 1
@@ -248,12 +250,13 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
         // The family's latest finished attempt's own recorded reason, or that none was recorded: never "review its incident".
         const family = store.taskFamilyOf(taskId, ref.repo === null ? [] : [ref.repo], ref.repo === null);
         const runs = family === null || family.problem !== null ? store.runsFor(ref.id) : family.versions.flatMap(version => store.runsFor(version.refId));
-        return answer("failed", "terminal", "Needs a retry", failedAttemptSentence(latestFinishedAttempt(runs)?.reason), { action: "retry-task" });
+        const stopped = vanishedStopOf(store, ref.id);
+        return answer("failed", "terminal", "Needs a retry", stopped === null ? failedAttemptSentence(latestFinishedAttempt(runs)?.reason) : vanishedStopSentence(stopped), { action: "retry-task" });
     }
     if (store.hasLiveClaim(ref.id, now))
-        return answer("running", "running", "Running now", "A worker owns the current live claim.");
+        return answer("running", "running", "Running now", "A builder is working on it now.");
     if (task.state === "running")
-        return answer("vanished-run", "waiting", "Build vanished", "The task says running, but no current claim owns it; reconcile it before retrying.", { action: "retry-task" });
+        return answer("vanished-run", "waiting", "Build vanished", "The build stopped unexpectedly. Retry it.", { action: "retry-task" });
     if (updateAdmissionPaused(store.raw()))
         return answer("updating", "waiting", "Waiting for app update", UPDATE_PAUSED);
     const local = taskReadinessBlocker(store, ref.id, now);
@@ -270,7 +273,7 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
         if (local.ownerKind === "decision")
             return answer("waiting-decision", "waiting", "Waiting on your answer", "An agent parked a question; answering it resumes the task.", { action: "answer-decision" });
         if (local.ownerKind === "incident")
-            return answer("waiting-incident", "waiting", "Needs a retry", "An unresolved incident holds the next attempt.", { action: "retry-task" });
+            return answer("waiting-incident", "waiting", "Needs a retry", "The last attempts failed the same way. Retry, or change the plan.", { action: "retry-task" });
         if (local.ownerKind === "stop")
             return answer("stopped", "waiting", "Paused", `${local.message.replace(/^held:\s*/, "")}. The attempt's work is preserved; resuming that exact attempt lifts this pause.`, { action: "resume-run" });
         return answer("held", "waiting", "On hold", local.message.replace(/^held:\s*/, ""), { action: local.ownerKind === "operator" ? "unhold" : "inspect-hold" });
@@ -288,14 +291,14 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
     const role = dispatchRoleFor(store, ref.id, now);
     const scope = store.getScope(taskId);
     if (ref.repo === null)
-        return answer("needs-project", "waiting", "Needs a project", "Place this task in a repository before a worker can claim it.", { action: "place-task", role });
+        return answer("needs-project", "waiting", "Needs a project", "Choose a project for this task so a builder can start it.", { action: "place-task", role });
     if (role !== "planner") {
         if (scope === null)
-            return answer("needs-scope", "waiting", "Needs a scope", "Write the success contract or ask the planner to draft it.", { action: "write-scope", role });
+            return answer("needs-scope", "waiting", "Needs a plan", "Write the plan, or ask the planner to draft it.", { action: "write-scope", role });
         if (scope.profileState === "unresolved")
             return answer("needs-agent-profile", "waiting", "Needs an agent profile", scope.unresolvedReason ?? "Choose an available provider and model.", { action: "select-agent", role });
         if (!scopeApprovedForDispatch(store, ref.id, now) || !approvalOf(scope).approved) {
-            return answer("needs-approval", "waiting", "Needs your approval", "Review and sign the current scope before a worker can claim it.", { action: "approve-scope", role });
+            return answer("needs-approval", "waiting", "Needs your approval", routeChangeOf(store, taskId) ?? "Review the plan and approve it so a builder can start.", { action: "approve-scope", role });
         }
     }
     const gap = missingCapability(store, ref.id, ref.repo, now);
@@ -315,14 +318,14 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
     }
     const available = alive.filter(one => store.liveClaimCount(one.name, now) < one.capacity);
     if (available.length === 0)
-        return answer("worker-at-capacity", "retrying", "Waiting for worker capacity", "Every eligible worker is busy; this task starts when a slot is released.", { role });
+        return answer("worker-at-capacity", "retrying", "Waiting its turn", "Builders are busy; it starts when one is free.", { role });
     const profile = approvedProfile(scope);
     if (profile !== null) {
         const exhausted = available.map(one => store.readQuotaState(one.name, profile.provider, profile.model, now)).filter(one => one?.state === "exhausted");
         if (exhausted.length === available.length) {
             const resets = exhausted.map(one => one?.resetAt ?? null).filter((one) => one !== null).sort();
             const nextAt = resets[0] ?? null;
-            return answer("provider-quota", "retrying", "Provider quota exhausted", nextAt === null ? "The provider has not supplied a reset time; this needs operator attention." : `The next recorded reset is ${nextAt}.`, { action: nextAt === null ? "select-agent" : null, nextAt, role });
+            return answer("provider-quota", "retrying", "Provider quota exhausted", nextAt === null ? "The provider gave no reset time. Choose another agent, or wait for the limit to reset." : `The next recorded reset is ${nextAt}.`, { action: nextAt === null ? "select-agent" : null, nextAt, role });
         }
     }
     // The sign-in pause: the task's provider stopped working; nothing it would
@@ -343,11 +346,11 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
         const sourceProblem = plannerSourceProblemOf(store, taskId);
         if (sourceProblem !== null)
             return answer("planner-source", "waiting", sourceProblem.title, sourceProblem.detail, { action: "write-scope", role });
-        return answer("planning-ready", "retrying", "Planner ready", "An eligible worker can draft the scope on the next pass.", { role });
+        return answer("planning-ready", "retrying", "Waiting to plan", "A builder can draft the plan next.", { role });
     }
     if (role === "scout")
-        return answer("scouting-ready", "retrying", "Scout ready", "An eligible worker can produce the report on the next pass.", { role });
-    return answer("ready", "retrying", "Ready to run", "An eligible worker has capacity and every dispatch gate currently passes.", { role });
+        return answer("scouting-ready", "retrying", "Waiting to research", "A builder can write the report next.", { role });
+    return answer("ready", "retrying", "Ready to run", "A builder is free and nothing is in the way.", { role });
 }
 export function diagnosisIsDispatchable(diagnosis) {
     return diagnosis?.code === "ready" || diagnosis?.code === "planning-ready" || diagnosis?.code === "scouting-ready";

package/dist/dispose.js

@@ -1,4 +1,6 @@
 // Assignment tracking grants no repair authority or attempts.
+import { authorizeCheckOnly } from "./check-only.js";
+import { proposeNewRoute } from "./route-change.js";
 import { originalTaskBase, focusedTestCommandSupported } from "./observations.js";
 /**
  * The build disposition service (Parity II Phase 2, v4 Q2 / v6 W1): the
@@ -158,6 +160,8 @@ function disposeBuildOutcomeLocked(context, result) {
             });
             // A stated no-change publishes nothing.
             if (result.noChange !== true && result.committed) {
+                // The approval that built this commit allows one automatic recheck of it, should its verdict go missing.
+                authorizeCheckOnly(store, runId, clock());
                 const grant = store.publicationGrantFor(repo);
                 const headSha = store.getRun(runId)?.headRevision ?? null;
                 if (grant !== null &&
@@ -357,6 +361,8 @@ function disposeBuildOutcomeLocked(context, result) {
  */
 export function holdStaleApproval(store, args, now) {
     const scope = store.getScope(args.taskId);
+    // Toolroll proposes the new exact route itself (route-change.ts): the person's one act is Approve, on one line.
+    const proposed = proposeNewRoute(store, args.taskRef, args.taskId, now);
     store.holdOwned({
         taskRef: args.taskRef,
         ownerKind: "backoff",
@@ -370,8 +376,8 @@ export function holdStaleApproval(store, args, now) {
         kind: "stale-approval",
         pushClass: "attention",
         link: `/t/${encodeURIComponent(args.taskId)}`,
-        subject: `${args.taskId}: its approval no longer matches the build routing — approve it again`,
-        body: `${args.message}\nNothing runs on it until the scope is approved again; the hold lifts with the yes.`,
+        subject: `${args.taskId}: its agents changed — approve it again`,
+        body: `${proposed?.words ?? args.message}\nNothing runs on it until it's approved again.`,
     }, now);
 }
 // ---- the bounded repair loop (v40, evidence-review-v1) --------------------

package/dist/easy-start.js

@@ -284,9 +284,8 @@ export function defaultEasyStartSeams(options) {
             }
         },
         findRepo: async (dir) => {
-            const { run } = await import("./exec.js");
-            const top = await run("git", ["rev-parse", "--show-toplevel"], { cwd: dir, timeoutMs: 10_000 });
-            return top.code === 0 ? top.stdout.trim() : null;
+            const { checkoutTop } = await import("./teardown-git.js");
+            return checkoutTop(dir);
         },
         enrolled: async (repo) => {
             const { loadRepos } = await import("./repos.js");

package/dist/eval-hooks.d.ts

@@ -1,3 +1,4 @@
+import type ts from "typescript-parser";
 /** One required call: in this file, inside this top-level function, a call to this name, the name bound as `from`
  * says (a module specifier its un-renamed named import comes from; `self`: the file's own top-level function; `local`:
  * declared inside `inside`). `args`: the call's arguments, as text, must stay as the base has them. */
@@ -9,12 +10,17 @@ export type EvalHook = {
     args?: true;
     why: string;
 };
+/** `fn` may also be `outer>inner` (docs/plans/learning-loops.md, Protection 3): a `const inner = (…) => …` (or function
+ * expression) or `function inner`, bound once in the file and never reassigned, inside the top-level function `outer`
+ * and in no other function between them. `strict`: a base that holds the file but can't resolve the pin is a problem,
+ * never skipped (a base without the file at all is a project that isn't Toolroll, and holds none). */
 /** One function whose body (its text, as the candidate has it) must stay as the base has it: a top-level function, or
  * `Class#method`, a method of a top-level class. */
 export type EvalPinned = {
     file: string;
     fn: string;
     why: string;
+    strict?: true;
 };
 export declare const EVAL_HOOKS: readonly EvalHook[];
 export declare const EVAL_PINNED: readonly EvalPinned[];
@@ -37,3 +43,52 @@ export declare const EVAL_HOOK_FILES: readonly string[];
  * files the verified diff says exist at the candidate, so no bytes is a failed read, never a deletion.
  */
 export declare function storeRewriteProblem(paths: readonly string[], candidate: ((file: string) => Buffer | null) | null, base: ((file: string) => Buffer | null) | null, pinned?: readonly string[]): string | null;
+/** The calls that record a check's facts: at disposition, and as the check's command starts. */
+export declare const LEARNING_HOOKS: readonly EvalHook[];
+/** The bodies a release can't change by itself, every one strict: what a run is told from project memory, how a memory
+ * proposal and a decision are written, and where a check's conditions are captured. */
+export declare const LEARNING_PINNED: readonly EvalPinned[];
+/** Every file the learning manifest reads. */
+export declare const LEARNING_HOOK_FILES: readonly string[];
+/** Each protected table and its only writer modules (the v149 migration in store.ts aside). The decision tables'
+ * existing writers stay theirs: project-memory.ts records and retires, project-delete.ts deletes a whole project. */
+export declare const LEARNING_WRITERS: Readonly<Record<string, readonly string[]>>;
+/** One SQL-shaped construct in a file: its static text (a placeholder `${}` where an expression sits), the protected
+ * tables it writes, and the top-level declaration it's in ("" for none). `unreadable`: a write whose table name is
+ * split around an expression; `bare`: a string that is only a protected table's name (SQL assembled elsewhere). */
+type LearningConstruct = {
+    text: string;
+    tables: string[];
+    inside: string;
+    unreadable: boolean;
+    bare: boolean;
+};
+/**
+ * Every construct in the file that could write a protected table: each string literal, template (its static parts)
+ * and `+` concatenation (its literal operands), whatever it's passed to — `prepare`, `exec`, a renamed `prepare`, a
+ * helper. A write verb next to a protected table's name, a table name split around an expression next to a write
+ * word, and a string that is only a protected table's name are each found.
+ */
+export declare function learningConstructs(source: ts.SourceFile): LearningConstruct[];
+/**
+ * Why a changed file writes a learning-loops table (or a decision merge or restore) from a place that may not, or null
+ * (docs/plans/learning-loops.md, Protection 4). Every changed JavaScript or TypeScript file but tests is parsed; a
+ * construct its writer module doesn't own is new unless the base's copy of that file already had exactly that text
+ * (counted by its sha256, as storeRewriteProblem does). A file that can't be read or parsed needs a person. It reads
+ * text the candidate wrote, never runs it: it raises the bar for review; a person reviewing these files is the backstop.
+ */
+export declare function learningWriteProblem(paths: readonly string[], candidate: ((file: string) => Buffer | null) | null, base: ((file: string) => Buffer | null) | null): string | null;
+/**
+ * Why a candidate needs a person for learning loops, or null: a required call dropped, a pinned body changed (strict
+ * pins included), or a changed file writing a protected table from outside its writers. With `manifest.base`, only what
+ * the base holds is required, as evalHookProblem does — except a strict pin whose file the base holds.
+ */
+export declare function learningHookProblem(manifest: {
+    candidate: (file: string) => Buffer | null;
+    base?: (file: string) => Buffer | null;
+}, changed: {
+    paths: readonly string[];
+    candidate: ((file: string) => Buffer | null) | null;
+    base: ((file: string) => Buffer | null) | null;
+}): string | null;
+export {};

package/dist/eval-hooks.js

@@ -36,6 +36,7 @@ export const EVAL_HOOKS = Object.freeze([
     { file: "src/release-auto.ts", inside: "changeProblem", calls: "evalHookProblem", from: "./eval-hooks.js", why: "this check itself" },
     { file: "src/release-auto.ts", inside: "changeProblem", calls: "autoPathProblem", from: "self", why: "policy paths need a person" },
     { file: "src/release-auto.ts", inside: "changeProblem", calls: "storeRewriteProblem", from: "./eval-hooks.js", why: "no changed file rewrites a pinned Store method" },
+    { file: "src/release-auto.ts", inside: "changeProblem", calls: "learningHookProblem", from: "./eval-hooks.js", why: "learning loops' hooks, pins and writers (docs/plans/learning-loops.md)" },
     // The invocation gateway (invoke.ts): every agent run an eval world spawns takes a slot.
     { file: "src/invoke.ts", inside: "invokeAgent", calls: "takeEvalDispatch", from: "./eval-gate.js", why: "every agent dispatch in an eval world takes a slot" },
     // PR #263 review: what the run's billing basis and its unknown cost are computed from is held too, not only the call.
@@ -227,7 +228,7 @@ function boundAs(source, name, from, inside) {
     if (from === "self")
         return compiler.isFunctionDeclaration(only) && only.parent === source ? null : `${name} isn't its own top-level function`;
     if (from === "local")
-        return only.pos >= inside.pos && only.end <= inside.end && !compiler.isParameter(only) ? null : `${name} isn't declared inside ${inside.name?.text ?? "it"}`;
+        return only.pos >= inside.pos && only.end <= inside.end && !compiler.isParameter(only) ? null : `${name} isn't declared inside its function`;
     if (!compiler.isImportSpecifier(only) || only.propertyName !== undefined || only.isTypeOnly)
         return `${name} isn't imported by its own name`;
     const clause = only.parent.parent;
@@ -254,6 +255,46 @@ function heldFunction(source, name) {
     const fn = topFunction(source, name);
     return fn === null || boundAs(source, name, "self", fn) !== null ? null : fn;
 }
+/** `outer>inner`: the one function-like `inner` declared inside the held top-level `outer` (no other function between
+ * them), bound once in the file and never reassigned — a `function inner` or a `const inner =` arrow or function
+ * expression. Null otherwise. */
+function nestedFunction(source, spec) {
+    const compiler = typescript();
+    const [outerName, innerName, ...rest] = spec.split(">");
+    if (outerName === undefined || innerName === undefined || rest.length > 0 || outerName === "" || innerName === "")
+        return null;
+    const outer = heldFunction(source, outerName);
+    if (outer === null || outer.body === undefined)
+        return null;
+    const all = bindingsOf(source, innerName);
+    if (all.length !== 1)
+        return null;
+    const only = all[0];
+    let fn = null;
+    if (compiler.isFunctionDeclaration(only) && only.body !== undefined)
+        fn = only;
+    else if (compiler.isVariableDeclaration(only) && only.initializer !== undefined && (compiler.isArrowFunction(only.initializer) || compiler.isFunctionExpression(only.initializer))
+        && compiler.isVariableDeclarationList(only.parent) && (only.parent.flags & compiler.NodeFlags.Const) !== 0)
+        fn = only.initializer;
+    if (fn === null)
+        return null;
+    // Directly inside `outer`: the first function-like ancestor of the declaration is `outer` itself.
+    for (let at = only.parent; at !== undefined; at = at.parent) {
+        if (at === outer)
+            return fn;
+        if (compiler.isFunctionLike(at) || compiler.isClassLike(at))
+            return null;
+    }
+    return null;
+}
+/** A held function by its manifest name: top-level, `Class#method` or `outer>inner`. */
+function heldNode(source, spec) {
+    if (spec.includes(">"))
+        return nestedFunction(source, spec);
+    if (spec.includes("#"))
+        return classMethod(source, spec);
+    return heldFunction(source, spec);
+}
 /** A reader that parses each file once. */
 function parser(read) {
     const seen = new Map();
@@ -265,7 +306,7 @@ function hookIn(tree, hook) {
     const parsed = tree(hook.file);
     if ("problem" in parsed)
         return { missing: `${parsed.problem}, and it holds a required call (${hook.why})` };
-    const fn = heldFunction(parsed.source, hook.inside);
+    const fn = (hook.inside.includes(">") ? nestedFunction(parsed.source, hook.inside) : heldFunction(parsed.source, hook.inside));
     if (fn === null || fn.body === undefined)
         return { missing: `${hook.file} no longer has ${hook.inside} as one function, which must call ${hook.calls} (${hook.why})` };
     const found = callsOf(fn.body, hook.calls);
@@ -281,7 +322,7 @@ function pinnedText(tree, pin) {
     const parsed = tree(pin.file);
     if ("problem" in parsed)
         return null;
-    const fn = pin.fn.includes("#") ? classMethod(parsed.source, pin.fn) : heldFunction(parsed.source, pin.fn);
+    const fn = heldNode(parsed.source, pin.fn);
     if (fn === null)
         return null;
     // The static block's pin holds the class header too: its name, modifiers and heritage, as the base has them.
@@ -308,8 +349,12 @@ export function evalHookProblem(candidate, base, hooks = EVAL_HOOKS, pinned = EV
     }
     for (const pin of pinned) {
         const before = was === null ? null : pinnedText(was, pin);
-        if (was !== null && before === null)
+        if (was !== null && before === null) {
+            // A strict pin the base holds the file of but can't resolve is a problem (learning loops, Protection 2), never a skip.
+            if (pin.strict === true && base(pin.file) !== null)
+                return `${pin.file} at the base has no ${pin.fn} as one function, which is pinned strictly (${pin.why})`;
             continue;
+        }
         const after = pinnedText(now, pin);
         if (after === null)
             return `${pin.file} no longer has ${pin.fn} as one function (${pin.why})`;
@@ -475,3 +520,181 @@ export function storeRewriteProblem(paths, candidate, base, pinned = PINNED_STOR
     }
     return null;
 }
+// ---- learning loops (docs/plans/learning-loops.md, "Safety", Protection 2-4) ----------------------------------------
+/** The calls that record a check's facts: at disposition, and as the check's command starts. */
+export const LEARNING_HOOKS = Object.freeze([
+    { file: "src/builder.ts", inside: "settleProof", calls: "recordCheckFacts", from: "./check-facts.js", why: "every settled check records its facts" },
+    { file: "src/builder.ts", inside: "settleProof>runVerification", calls: "captureCheckConditions", from: "./check-facts.js", why: "a check's conditions are captured as its command starts" },
+]);
+/** The bodies a release can't change by itself, every one strict: what a run is told from project memory, how a memory
+ * proposal and a decision are written, and where a check's conditions are captured. */
+export const LEARNING_PINNED = Object.freeze([
+    { file: "src/project-knowledge.ts", fn: "knowledgeContext", strict: true, why: "the decisions and references a run is given, and their snapshot" },
+    { file: "src/project-learning.ts", fn: "learningContext", strict: true, why: "the lessons a run is given, and their snapshot" },
+    { file: "src/memory-pass.ts", fn: "decideProposal", strict: true, why: "a memory proposal's one writer" },
+    { file: "src/project-memory.ts", fn: "recordDecision", strict: true, why: "how a decision is recorded and what it supersedes" },
+    { file: "src/project-memory.ts", fn: "retireDecision", strict: true, why: "how a decision is retired" },
+    { file: "src/builder.ts", fn: "settleProof>runVerification", strict: true, why: "the check's command and the conditions it starts under" },
+]);
+/** Every file the learning manifest reads. */
+export const LEARNING_HOOK_FILES = Object.freeze([...new Set([...LEARNING_HOOKS.map(hook => hook.file), ...LEARNING_PINNED.map(pin => pin.file)])]);
+/** Each protected table and its only writer modules (the v149 migration in store.ts aside). The decision tables'
+ * existing writers stay theirs: project-memory.ts records and retires, project-delete.ts deletes a whole project. */
+export const LEARNING_WRITERS = Object.freeze({
+    check_fact: ["src/check-facts.ts"], check_result: ["src/check-facts.ts"],
+    local_observation: ["src/flaky.ts"], ci_flaky_observation: ["src/flaky-ci.ts"], ci_pairing_rejected: ["src/flaky-ci.ts"],
+    learning_watch: ["src/flaky.ts", "src/lesson-notes.ts"],
+    lesson_note: ["src/lesson-notes.ts"], lesson_note_tally: ["src/lesson-notes.ts"],
+    memory_use: ["src/memory-use.ts"],
+    memory_tidy_proposal: ["src/memory-tidy.ts"], decision_merge: ["src/memory-tidy.ts"],
+    project_decision: ["src/memory-tidy.ts", "src/project-memory.ts", "src/project-delete.ts"],
+    decision_change: ["src/memory-tidy.ts", "src/project-memory.ts", "src/project-delete.ts"],
+});
+/** store.ts's v149 migration: the only place outside the writers that may name these tables in SQL. */
+const LEARNING_MIGRATION = Object.freeze({ "src/store.ts": ["V149_SCHEMA", "V149_TABLES", "V149_REPO_TABLES"] });
+const PROTECTED = Object.keys(LEARNING_WRITERS);
+const tableWrite = (table) => new RegExp(String.raw `(?:\b(?:(?:INSERT(?:\s+OR\s+\w+)?|REPLACE)\s+INTO|UPDATE(?:\s+OR\s+\w+)?|DELETE\s+FROM)\s+(?:main\s*\.\s*)?["\`\[]?${table}["\`\]]?(?!\w)`
+    + String.raw `|\b(?:DROP\s+(?:TABLE|TRIGGER|INDEX|VIEW)(?:\s+IF\s+EXISTS)?|ALTER\s+TABLE)\s+(?:main\s*\.\s*)?["\`\[]?${table})`, "i");
+const TABLE_WRITES = PROTECTED.map(table => ({ table, write: tableWrite(table) }));
+const WRITE_WORD = /\b(?:INSERT|UPDATE|DELETE|REPLACE|DROP|ALTER)\b/i;
+const BARE_NAME = new RegExp(String.raw `^\s*(?:main\s*\.\s*)?["\`\[]?(?:${PROTECTED.join("|")})["\`\]]?\s*$`, "i");
+/**
+ * Every construct in the file that could write a protected table: each string literal, template (its static parts)
+ * and `+` concatenation (its literal operands), whatever it's passed to — `prepare`, `exec`, a renamed `prepare`, a
+ * helper. A write verb next to a protected table's name, a table name split around an expression next to a write
+ * word, and a string that is only a protected table's name are each found.
+ */
+export function learningConstructs(source) {
+    const compiler = typescript();
+    const found = [];
+    const topOf = (node) => {
+        let at = node;
+        while (at.parent !== undefined && !compiler.isSourceFile(at.parent))
+            at = at.parent;
+        if (compiler.isFunctionDeclaration(at) || compiler.isClassDeclaration(at))
+            return at.name?.text ?? "";
+        if (compiler.isVariableStatement(at))
+            return at.declarationList.declarations.map(one => compiler.isIdentifier(one.name) ? one.name.text : "").join(",");
+        return "";
+    };
+    const fragmentRisk = (parts) => {
+        // Around each placeholder: the identifier characters just before and just after it.
+        for (let i = 0; i < parts.length - 1; i++) {
+            const before = /[A-Za-z0-9_]*$/.exec(parts[i])[0].toLowerCase(), after = /^[A-Za-z0-9_]*/.exec(parts[i + 1])[0].toLowerCase();
+            if (before === "" && after === "")
+                continue;
+            if (PROTECTED.some(table => (before !== "" && table.startsWith(before) && table !== before) || (after !== "" && table.endsWith(after) && table !== after)
+                || (before !== "" && after !== "" && table.startsWith(before) && table.endsWith(after))))
+                return true;
+        }
+        return false;
+    };
+    const consider = (node, parts) => {
+        const text = parts.join("${}");
+        const tables = TABLE_WRITES.filter(one => one.write.test(text)).map(one => one.table);
+        const unreadable = parts.length > 1 && WRITE_WORD.test(text) && fragmentRisk(parts);
+        const bare = parts.length === 1 && BARE_NAME.test(text);
+        if (tables.length > 0 || unreadable || bare)
+            found.push({ text: text.replace(/\s+/g, " ").trim(), tables, inside: topOf(node), unreadable, bare });
+    };
+    const isPlus = (node) => compiler.isBinaryExpression(node) && node.operatorToken.kind === compiler.SyntaxKind.PlusToken;
+    const flatten = (node, into) => {
+        let at = node;
+        while (compiler.isParenthesizedExpression(at))
+            at = at.expression;
+        if (isPlus(at)) {
+            flatten(at.left, into);
+            flatten(at.right, into);
+        }
+        else
+            into.push(at);
+    };
+    const visit = (node) => {
+        if (isPlus(node) && !(node.parent !== undefined && (isPlus(node.parent) || (compiler.isParenthesizedExpression(node.parent) && node.parent.parent !== undefined && isPlus(node.parent.parent))))) {
+            const operands = [];
+            flatten(node, operands);
+            if (operands.some(one => compiler.isStringLiteralLike(one) || compiler.isTemplateExpression(one))) {
+                const parts = [""];
+                for (const one of operands) {
+                    if (compiler.isStringLiteralLike(one))
+                        parts[parts.length - 1] += one.text;
+                    else if (compiler.isTemplateExpression(one)) {
+                        parts[parts.length - 1] += one.head.text;
+                        for (const span of one.templateSpans)
+                            parts.push(span.literal.text);
+                    }
+                    else
+                        parts.push("");
+                }
+                if (parts.length > 1 || operands.length > 1)
+                    consider(node, parts);
+            }
+        }
+        if (compiler.isStringLiteralLike(node))
+            consider(node, [node.text]);
+        else if (compiler.isTemplateExpression(node))
+            consider(node, [node.head.text, ...node.templateSpans.map(span => span.literal.text)]);
+        compiler.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
+}
+/** Whether this construct may stand in this file: its writer module for every table it writes, or the migration's own
+ * declarations in store.ts. An unreadable or bare construct stands only in a writer of some protected table. */
+function learningAllowed(file, one) {
+    if ((LEARNING_MIGRATION[file] ?? []).some(name => one.inside.split(",").includes(name)))
+        return true;
+    if (one.tables.length > 0)
+        return one.tables.every(table => LEARNING_WRITERS[table].includes(file));
+    return Object.values(LEARNING_WRITERS).some(writers => writers.includes(file));
+}
+/**
+ * Why a changed file writes a learning-loops table (or a decision merge or restore) from a place that may not, or null
+ * (docs/plans/learning-loops.md, Protection 4). Every changed JavaScript or TypeScript file but tests is parsed; a
+ * construct its writer module doesn't own is new unless the base's copy of that file already had exactly that text
+ * (counted by its sha256, as storeRewriteProblem does). A file that can't be read or parsed needs a person. It reads
+ * text the candidate wrote, never runs it: it raises the bar for review; a person reviewing these files is the backstop.
+ */
+export function learningWriteProblem(paths, candidate, base) {
+    const scanned = paths.filter(path => /\.(?:[cm]?[jt]sx?)$/.test(path) && !/\.test\.[cm]?[jt]sx?$/.test(path) && !path.startsWith("test/")
+        && !path.startsWith("node_modules/") && !path.includes("/node_modules/"));
+    if (scanned.length === 0)
+        return null;
+    if (candidate === null || base === null)
+        return "the changed files can't be read";
+    const key = (text) => createHash("sha256").update(text).digest("hex");
+    for (const path of scanned) {
+        const bytes = candidate(path);
+        if (bytes === null)
+            return `${path} can't be read`;
+        const now = parse(path, bytes);
+        if ("problem" in now)
+            return now.problem;
+        const before = base(path);
+        const was = before === null ? null : parse(path, before);
+        const kept = new Map();
+        if (was !== null && !("problem" in was))
+            for (const one of learningConstructs(was.source))
+                kept.set(key(one.text), (kept.get(key(one.text)) ?? 0) + 1);
+        for (const one of learningConstructs(now.source)) {
+            if (learningAllowed(path, one))
+                continue;
+            const left = kept.get(key(one.text)) ?? 0;
+            if (left > 0) {
+                kept.set(key(one.text), left - 1);
+                continue;
+            }
+            const what = one.unreadable ? "builds a learning-loops table's name around an expression in SQL" : one.bare ? "names a learning-loops table outside its writers" : "writes learning-loops rows outside their writers";
+            return `${path} ${what} (\`${one.text.slice(0, 80)}\`)`;
+        }
+    }
+    return null;
+}
+/**
+ * Why a candidate needs a person for learning loops, or null: a required call dropped, a pinned body changed (strict
+ * pins included), or a changed file writing a protected table from outside its writers. With `manifest.base`, only what
+ * the base holds is required, as evalHookProblem does — except a strict pin whose file the base holds.
+ */
+export function learningHookProblem(manifest, changed) {
+    return evalHookProblem(manifest.candidate, manifest.base, LEARNING_HOOKS, LEARNING_PINNED) ?? learningWriteProblem(changed.paths, changed.candidate, changed.base);
+}

package/dist/evals.js

@@ -27,6 +27,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { closeSync, constants, lstatSync, mkdirSync, mkdtempSync, openSync, readdirSync, realpathSync, rmSync, writeSync } from "node:fs";
 import { dirname, join, relative, sep } from "node:path";
 import { homedir, hostname } from "node:os";
+import { sameMachineHost } from "./machine-identity.js";
 import { fileURLToPath } from "node:url";
 import { createRequire } from "node:module";
 import { readVerifiedCommit, verifiedBlobs } from "./commit-extract.js";
@@ -840,7 +841,7 @@ export function recoverEvalCampaigns(store, now, options = {}) {
     const out = [];
     for (const campaign of store.handle.prepare("SELECT id, runner_host, runner_pid, runner_started FROM eval_campaign WHERE state = 'running' ORDER BY admitted_at").all()) {
         const id = String(campaign["id"]);
-        if (String(campaign["runner_host"]) !== host) {
+        if (!sameMachineHost(String(campaign["runner_host"]), host)) {
             out.push({ id, recovered: false, why: `its runner is on ${String(campaign["runner_host"])}` });
             continue;
         }