toolroll 0.9.58 → 0.9.59

package/dist/store.js

@@ -559,7 +559,10 @@ const REGISTERED_AT_FILING = "again, as it was filed";
 // v118 (D7) keeps every machine credential in one table, `credential`: a person's API tokens (so_…), the lead's tokens
 // (lt_…) and coordinators, each with its kind, read/act access, project limit, expiry, revocation and generation. Every
 // row moves with its id, hash and dates; the references to coordinators and API tokens point at it.
-export const SCHEMA_VERSION = 118;
+// v119 keeps planning generations: a rewritten scope starts a clean planning context (task_ref, run and plan_revision
+// carry planning_generation, 0 for all earlier history), and a question closed without an answer says why
+// (decision.superseded_reason: its task's scope changed, or the task was cancelled).
+export const SCHEMA_VERSION = 119;
 /** v118: the tables merged into `credential`, in the order they move (a person's API tokens keep their ids first). */
 export const V118_MERGED_TABLES = Object.freeze({ api_token: "person", coordinator_credential: "coordinator", lead_credential: "lead" });
 /** The foreign keys that named a merged table, exactly as their DDL wrote them; each names `credential(id)` instead. */
@@ -680,9 +683,18 @@ const V115_DROPPED_REFERENCES = /\s+REFERENCES (?:contestant|contest|tournament_
  * teammates' to its subagents' (SQLite's RENAME, every row, id and link carried), renames their teammate column, and rewrites four internal kinds from 'teammate' to 'subagent' in place; the rehearsal checks
  * each renamed table's rows arrived under its new name. v118 (D7) is checked the same way: every row of api_token,
  * coordinator_credential and lead_credential moves into credential under its kind in one transaction that counts them
- * before the old tables drop, and the references that named them name credential in place, their rows untouched.
+ * before the old tables drop, and the references that named them name credential in place, their rows untouched. v119 only adds four columns
+ * (planning_generation on task_ref, run and plan_revision, defaulting to 0, and decision.superseded_reason, null);
+ * the rehearsal checks every saved row reads the declared default (HISTORY_RULES' added columns).
  */
-export const UPDATE_SAFE_MIGRATIONS = Object.freeze([108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118]);
+export const UPDATE_SAFE_MIGRATIONS = Object.freeze([108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119]);
+/** v119: the columns it adds, by table, with the value every row saved before it reads (toolroll-update's HISTORY_RULES). */
+export const V119_ADDED_COLUMNS = Object.freeze({
+    task_ref: { planning_generation: { definition: "INTEGER NOT NULL DEFAULT 0", saved: "0" } },
+    run: { planning_generation: { definition: "INTEGER NOT NULL DEFAULT 0", saved: "0" } },
+    plan_revision: { planning_generation: { definition: "INTEGER NOT NULL DEFAULT 0", saved: "0" } },
+    decision: { superseded_reason: { definition: "TEXT CHECK (superseded_reason IN ('scope-changed','cancelled'))", saved: "NULL" } },
+});
 /** Whether a database settled at `version` reaches this build's schema through update-safe migrations alone. */
 export function updateSafeSchema(version) {
     if (version === null || !Number.isSafeInteger(version) || version <= 0 || version > SCHEMA_VERSION)
@@ -3474,6 +3486,11 @@ function initializeStore(db, file) {
     // v115: the task each standing-order firing filed, kept on the firing itself (a card's task changes as it moves).
     addColumn(db, "flow_trigger_event", "task", "TEXT");
     db.exec(PLAN_AUTO_SCHEMA);
+    // v119: planning generations, and why a question closed unanswered (additive only; saved rows read the defaults).
+    for (const [table, columns] of Object.entries(V119_ADDED_COLUMNS)) {
+        for (const [column, { definition }] of Object.entries(columns))
+            addColumn(db, table, column, definition);
+    }
     installLedgerTriggers(db);
     // Attention/history indexes come AFTER migration: on a database whose
     // constrained tables still carry a pre-rebuild shape, creating a partial
@@ -4796,6 +4813,10 @@ export class Store {
         // just the state verb's.
         if (ref !== undefined)
             this.supersedeSteerNotes(Number(ref["id"]), now);
+        // Its open questions close the same way (v119), typed 'cancelled', with their holds and pages: a question about
+        // work that will never run must leave every decision queue. Answered ones stay exactly as they were.
+        if (ref !== undefined)
+            this.closeQuestionsLocked(Number(ref["id"]), "cancelled", now);
         // The reason is part of the transition, not decoration: a
         // coordinator-filed task's dismissal writes its durable event IN THIS
         // transaction — operator text and typed machine codes alike (MCP spec
@@ -9942,6 +9963,66 @@ export class Store {
             return { ok: true };
         });
     }
+    /**
+     * A rewritten scope starts planning again (v119), in one transaction: the task's planning generation advances, a
+     * requested or drafted plan becomes requested with no strikes, and what the old goal produced leaves the active
+     * planning context — its open questions close (typed 'scope-changed', never a fake answer, their holds and pages
+     * with them) and a revision still waiting for a person is rejected with its hold. The old runs, plans, revisions,
+     * answers and ledger rows all stay: generation-bound reads simply stop offering them to the next planner. Only a
+     * task already planning restarts; false (nothing changed) for any other.
+     */
+    restartPlanning(taskRef, now) {
+        return this.transact(() => {
+            const moved = this.db
+                .prepare("UPDATE task_ref SET planning_generation = planning_generation + 1, plan = 'requested', plan_strikes = 0 WHERE id = ? AND plan IN ('requested','drafted')")
+                .run(taskRef);
+            if (Number(moved.changes) === 0)
+                return false;
+            const ref = this.db.prepare("SELECT external_id, repo, planning_generation FROM task_ref WHERE id = ?").get(taskRef);
+            const generation = Number(ref["planning_generation"]);
+            this.closeQuestionsLocked(taskRef, "scope-changed", now, generation);
+            const blocked = this.db
+                .prepare("SELECT id FROM plan_revision WHERE task_ref = ? AND status = 'blocked' AND planning_generation < ?")
+                .all(taskRef, generation)
+                .map(row => Number(row["id"]));
+            for (const id of blocked) {
+                this.resolvePlanRevision(id, "rejected", "toolroll", now);
+                this.releaseOwnedHold("revision", String(id));
+            }
+            this.recordAction({
+                at: now.toISOString(), actor: currentActor() === null ? "system" : actorLabel(currentActor()), repo: ref["repo"] === null ? null : String(ref["repo"]),
+                taskId: String(ref["external_id"]), runId: null, action: "planning restarted", outcome: "scope changed", source: "work",
+            });
+            this.bumpWake();
+            return true;
+        });
+    }
+    /**
+     * Close a task's open and expired questions without answering them (v119): typed with why, no choice, their
+     * holds lifted and their pages resolved, so they leave every decision queue. Answered questions are never touched.
+     * `belowGeneration` limits it to questions asked in earlier planning generations. Caller holds the transaction.
+     */
+    closeQuestionsLocked(taskRef, reason, now, belowGeneration) {
+        const ids = this.db
+            .prepare(`SELECT decision.id FROM decision JOIN run ON run.id = decision.run
+          WHERE run.task_ref = ? AND decision.state IN ('open','expired') AND (? IS NULL OR run.planning_generation < ?)
+          ORDER BY decision.id`)
+            .all(taskRef, belowGeneration ?? null, belowGeneration ?? null)
+            .map(row => Number(row["id"]));
+        const close = this.db.prepare("UPDATE decision SET state = 'answered', answered_at = ?, answered_by = 'toolroll', superseded_reason = ? WHERE id = ? AND state IN ('open','expired')");
+        for (const id of ids) {
+            close.run(now.toISOString(), reason, id);
+            this.releaseOwnedHold("decision", String(id));
+            this.resolveEpisode(`decision:${id}`, now);
+        }
+        return ids;
+    }
+    /** The number the next plan revision of a task takes: one past every revision it ever had, in any planning
+     * generation, so a restarted plan's revisions never collide with the history they follow. */
+    nextPlanRevisionNumber(taskRef) {
+        const row = this.db.prepare("SELECT coalesce(max(revision), 0) AS n FROM plan_revision WHERE task_ref = ?").get(taskRef);
+        return Number(row?.["n"] ?? 0) + 1;
+    }
     /** Move the planning state; null clears it. Caller owns the transaction story. */
     setPlanState(taskRef, state) {
         this.db.prepare("UPDATE task_ref SET plan = ? WHERE id = ?").run(state, taskRef);
@@ -11653,8 +11734,8 @@ export class Store {
             })();
         const inserted = this.db
             .prepare(`INSERT INTO run (task_ref, lease_id, runner, branch, worktree, model, role, provider, parent_run, session_id, quality_mode,
-                          started_at, review_attempt)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                          started_at, review_attempt, planning_generation)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, (SELECT planning_generation FROM task_ref WHERE id = ?1))`)
             .run(run.taskRef, run.leaseId, run.runner, run.branch ?? null, run.worktree ?? null, model, role, provider ?? "claude", run.parentRun ?? null, run.sessionId ?? null, qualityMode, run.now.toISOString(), 
         // The root reviewer's ordinal (v50) rides the insert: a root and
         // its attempt number are one fact, and the ordinal index refuses a
@@ -12599,12 +12680,14 @@ export class Store {
      * reads in the order the questions arrived. "unanswered" is open + expired:
      * expiry makes a decision louder, never gone.
      */
-    /** The newest planner run's plan document for a task, when one exists. */
+    /** The newest planner run's plan document for a task, when one exists in its current planning generation (v119:
+     * a plan drafted for a scope since rewritten is history, read by its artifact id). */
     latestPlanArtifact(taskRef) {
         const row = this.db
             .prepare(`SELECT artifact.* FROM artifact
          JOIN run ON run.id = artifact.run
          WHERE run.task_ref = ? AND run.role = 'planner' AND artifact.kind = 'plan'
+           AND run.planning_generation = (SELECT planning_generation FROM task_ref WHERE id = run.task_ref)
          ORDER BY artifact.id DESC LIMIT 1`)
             .get(taskRef);
         return row === undefined ? null : readArtifact(row);
@@ -12619,6 +12702,7 @@ export class Store {
          JOIN run ON run.id = artifact.run
          WHERE run.task_ref = ? AND run.role = 'planner' AND artifact.kind = 'plan-contract'
            AND artifact.key LIKE '%/plan-contract.json'
+           AND run.planning_generation = (SELECT planning_generation FROM task_ref WHERE id = run.task_ref)
          ORDER BY artifact.id DESC LIMIT 1`)
             .get(taskRef);
         return row === undefined ? null : readArtifact(row);
@@ -12646,16 +12730,17 @@ export class Store {
         const inserted = this.db
             .prepare(`INSERT INTO plan_revision
            (task_ref, revision, artifact, parent_hash, reason, evidence_link, author, origin_run,
-            kind, authority_kind, authority_digest, changed_fields, status, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            kind, authority_kind, authority_digest, changed_fields, status, created_at, planning_generation)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, (SELECT planning_generation FROM task_ref WHERE id = ?1))`)
             .run(revision.taskRef, revision.revision, revision.artifact, revision.parentHash, revision.reason, revision.evidenceLink, revision.author, revision.originRun, revision.kind, revision.authorityKind, revision.authorityDigest, JSON.stringify(revision.changedFields), revision.status, now.toISOString());
         return Number(inserted.lastInsertRowid);
     }
-    /** Every revision for a task, newest first — the immutable history a
-     * reader can show without a second table. */
+    /** Every revision for a task in its current planning generation, newest
+     * first — the immutable history a reader can show without a second table
+     * (v119: an earlier generation's rows stay, read by id). */
     listPlanRevisions(taskRef) {
         return this.db
-            .prepare("SELECT * FROM plan_revision WHERE task_ref = ? ORDER BY revision DESC")
+            .prepare("SELECT * FROM plan_revision WHERE task_ref = ? AND planning_generation = (SELECT planning_generation FROM task_ref WHERE id = plan_revision.task_ref) ORDER BY revision DESC")
             .all(taskRef)
             .map(readPlanRevision);
     }
@@ -12666,7 +12751,7 @@ export class Store {
      * `latestPlanArtifact`'s synthetic revision 1 in both cases. */
     currentPlanRevision(taskRef) {
         const row = this.db
-            .prepare("SELECT * FROM plan_revision WHERE task_ref = ? AND status = 'applied' ORDER BY revision DESC LIMIT 1")
+            .prepare("SELECT * FROM plan_revision WHERE task_ref = ? AND planning_generation = (SELECT planning_generation FROM task_ref WHERE id = plan_revision.task_ref) AND status = 'applied' ORDER BY revision DESC LIMIT 1")
             .get(taskRef);
         return row === undefined ? null : readPlanRevision(row);
     }
@@ -12674,7 +12759,7 @@ export class Store {
      * 'blocked' awaiting an operator's decision — what a reader shows
      * alongside the current one to render a pending proposal at all. */
     latestPlanRevision(taskRef) {
-        const row = this.db.prepare("SELECT * FROM plan_revision WHERE task_ref = ? ORDER BY revision DESC LIMIT 1").get(taskRef);
+        const row = this.db.prepare("SELECT * FROM plan_revision WHERE task_ref = ? AND planning_generation = (SELECT planning_generation FROM task_ref WHERE id = plan_revision.task_ref) ORDER BY revision DESC LIMIT 1").get(taskRef);
         return row === undefined ? null : readPlanRevision(row);
     }
     getPlanRevision(id) {
@@ -12762,7 +12847,8 @@ export class Store {
             .get(taskRef);
         return row === undefined ? null : readArtifact(row);
     }
-    /** Answered questions for one task, newest first — the planner's memory. */
+    /** Answered questions for one task, newest first — the planner's memory. Only real answers from its current
+     * planning generation (v119): a question closed unanswered, or asked about a scope since rewritten, is history. */
     answeredDecisionsFor(taskId, limit = 5) {
         return this.db
             .prepare(`SELECT decision.question, decision.choice, decision.note
@@ -12770,7 +12856,8 @@ export class Store {
          JOIN run ON run.id = decision.run
          JOIN task_ref ON task_ref.id = run.task_ref
          WHERE task_ref.backend = ? AND task_ref.external_id = ?
-           AND decision.answered_at IS NOT NULL
+           AND decision.answered_at IS NOT NULL AND decision.superseded_reason IS NULL
+           AND run.planning_generation = task_ref.planning_generation
          ORDER BY decision.answered_at DESC, decision.id DESC LIMIT ?`)
             .all(BUILT_IN, taskId, Math.max(1, Math.min(Math.floor(limit), 20)))
             .map(row => ({
@@ -12869,6 +12956,9 @@ export class Store {
          JOIN task_ref ON task_ref.id = run.task_ref
          WHERE run.task_ref = ? AND decision.state = 'answered'
            AND decision.contestant IS NULL
+           -- v119: a question closed unanswered carries no answer, and one asked about a rewritten scope is history.
+           AND decision.superseded_reason IS NULL
+           AND run.planning_generation = task_ref.planning_generation
            AND NOT EXISTS (
              SELECT 1 FROM run_decision
              JOIN run AS delivered ON delivered.id = run_decision.run
@@ -13022,6 +13112,9 @@ export class Store {
         const existing = this.getDecision(answer.id);
         if (existing === null)
             return { ok: false, reason: "unknown-decision" };
+        // A question closed without an answer (v119) stays closed: its task's scope changed or the task was cancelled.
+        if (existing.supersededReason !== null)
+            return { ok: false, reason: "closed" };
         if (!existing.options.some(option => option.id === answer.choice)) {
             return { ok: false, reason: "bad-option" };
         }
@@ -17443,6 +17536,7 @@ function readRun(row) {
         taskRef: Number(row["task_ref"]),
         leaseId: String(row["lease_id"]),
         runner: String(row["runner"]),
+        planningGeneration: Number(row["planning_generation"] ?? 0),
         watchIncarnation: row["watch_incarnation"] == null ? null : String(row["watch_incarnation"]),
         reviewAttempt: wholeNumber(row["review_attempt"]),
         role: String(row["role"] ?? "builder"),
@@ -17575,6 +17669,7 @@ function readDecision(row) {
         answeredVia: row["answered_via"] === null ? null : String(row["answered_via"]),
         choice: row["choice"] === null ? null : String(row["choice"]),
         note: row["note"] === null ? null : String(row["note"]),
+        supersededReason: row["superseded_reason"] === "scope-changed" || row["superseded_reason"] === "cancelled" ? row["superseded_reason"] : null,
     };
 }
 function readArtifact(row) {
@@ -17762,6 +17857,7 @@ function readTaskRef(row) {
             ? null
             : String(row["plan"]),
         planStrikes: Number(row["plan_strikes"] ?? 0),
+        planningGeneration: Number(row["planning_generation"] ?? 0),
         deliverable: row["deliverable"] === "report" ? "report" : "branch",
         strikes: Number(row["strikes"] ?? 0),
         agentProvider: row["agent_provider"] === null || row["agent_provider"] === undefined

package/dist/task-status.js

@@ -261,7 +261,9 @@ export const taskStatusOf = statusOf;
  * wait on a person stay Needs you; everything else waits in the queue. */
 const CODE_STAGE = {
     queued: ["queued"], ready: ["queued"], "worker-at-capacity": ["queued"], "retry-scheduled": ["queued"], updating: ["queued"],
-    "waiting-dependency": ["queued"], "scouting-ready": ["queued"], "planning-ready": ["queued"], "provider-quota": ["queued"], "planner-source": ["queued"],
+    "waiting-dependency": ["queued"], "scouting-ready": ["queued"], "planning-ready": ["queued"], "provider-quota": ["queued"],
+    // A request the planner cannot be given (too long to hand back, say) waits on a person to shorten it.
+    "planner-source": ["needs-you", "fix-request"],
     running: ["building"], reviewing: ["reviewing"], "review-pending": ["building"],
     "signed-out": ["needs-you", "sign-in"],
     "needs-approval": ["needs-you", "approval"],

package/dist/telegram-lead.js

@@ -204,6 +204,12 @@ export function applyProposalTap(store, binding, token, message, repos, options,
     const who = verified.who;
     const preview = proposalPreview(store, proposal, actionRepos, "telegram");
     const origin = options.phoneOrigin?.() ?? null;
+    if (preview.closed) {
+        store.consumeTelegramProposalActions(proposal.id, now);
+        ack("This question is closed.");
+        edit(preview.text, []);
+        return { effects, confirmed: false, ignored: true };
+    }
     if (action.phase === "dismiss") {
         if (!store.consumeTelegramProposalAction(token, now)) {
             ack("that button was already used");

package/dist/telegram.js

@@ -25,7 +25,7 @@ import { resultImageFileName, resultTaskLabel, verifyResultImage } from "./chat-
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
 import { chmodSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { validateNote } from "./decision.js";
+import { closedQuestionWords, validateNote } from "./decision.js";
 import { isShotsKind, resultShotsFor } from "./result-shots.js";
 import { isLifecycleNotification, isTelegramProgressNotification, RESULT_SHOTS_KIND, TELEGRAM_HOLD_REASONS } from "./store.js";
 import { telegramProgressCard } from "./telegram-progress.js";
@@ -1998,7 +1998,7 @@ function applyNote(context, update, effects) {
         return;
     }
     if (decision.state === "answered") {
-        say(`already answered: ${decision.choice ?? "?"} — this note did not travel`);
+        say(`${decision.supersededReason !== null ? closedQuestionWords(decision.supersededReason) : `already answered: ${decision.choice ?? "?"}`} — this note did not travel`);
         report.ignored++;
         return;
     }
@@ -2344,8 +2344,8 @@ function applyCallback(context, update, effects) {
     }
     if (decision.state === "answered") {
         store.consumeTelegramAction(token, clock());
-        ack(`already answered: ${decision.choice ?? "?"}`);
-        editText(answeredText(store, decision));
+        ack(decision.supersededReason !== null ? closedQuestionWords(decision.supersededReason) : `already answered: ${decision.choice ?? "?"}`);
+        editText(answeredText(store, decision), []);
         return;
     }
     if (action.phase === "choose") {
@@ -2451,13 +2451,13 @@ function answerNow(context, decision, choice, binding, ack, editText) {
         editText(answeredText(store, answered.decision));
         return;
     }
-    if (answered.reason === "already-answered") {
+    if (answered.reason === "already-answered" || answered.reason === "closed") {
         if (draft !== null)
             store.setNoteDraftState(draft.id, "discarded");
         const settled = store.getDecision(decision.id);
-        ack(`already answered: ${settled?.choice ?? "?"}${draft === null ? "" : " — your note did NOT travel"}`);
+        ack(`${settled?.supersededReason != null ? closedQuestionWords(settled.supersededReason) : `already answered: ${settled?.choice ?? "?"}`}${draft === null ? "" : " — your note did NOT travel"}`);
         if (settled !== null)
-            editText(answeredText(store, settled));
+            editText(answeredText(store, settled), []);
         return;
     }
     ack(`could not answer: ${answered.reason}`);
@@ -2479,6 +2479,8 @@ function armedDecisionText(option, note) {
     ].join("\n");
 }
 function answeredText(store, decision) {
+    if (decision.supersededReason !== null)
+        return [closedQuestionWords(decision.supersededReason), taskOf(store, decision)].join("\n");
     const chosen = decision.options.find(one => one.id === decision.choice)?.label ?? decision.choice ?? "?";
     return [
         `✓ Answered: ${chosen}`,

package/dist/toolroll-update.js

@@ -35,7 +35,7 @@ import { processMayBeAlive } from "./process-liveness.js";
 import { assertCodingUpdateStopped, backupCodingCatalog, codingCatalogExists, releaseStaleCodingOwner, removeCodingUpdateGate } from "./coding-update.js";
 import { installLaunchdService, launchdPlist, stopLaunchdService, writeFileDurably } from "./daemon.js";
 import { NAME } from "./names.js";
-import { orphanKey, updateSafeSchema, V117_RENAMED_COLUMNS, V117_RENAMED_TABLES, V118_MERGED_TABLES } from "./store.js";
+import { orphanKey, updateSafeSchema, V117_RENAMED_COLUMNS, V117_RENAMED_TABLES, V118_MERGED_TABLES, V119_ADDED_COLUMNS } from "./store.js";
 import { isNewer, REGISTRY } from "./releases.js";
 import { markNeverIndex } from "./never-index.js";
 import { readRuntimeUpdateJournal, RUNTIME_PHASES, RUNTIME_UPDATE_STEPS, stagedStartedAt, updaterStartingOf } from "./contracts/update-journal.js";
@@ -384,6 +384,9 @@ const HISTORY_RULES = {
     ...Object.fromEntries(V117_RENAMED_COLUMNS.filter(([table]) => !Object.values(V117_RENAMED_TABLES).includes(table)).map(([table, from, to]) => [table, { renamed: { [from]: to } }])),
     // v118 (D7): every API token, coordinator and lead token arrives in the one credential table under its kind.
     ...Object.fromEntries(Object.entries(V118_MERGED_TABLES).map(([table, kind]) => [table, { moved: { into: "credential", where: `kind = '${kind}'` } }])),
+    // v119: planning generations and a question's closure reason are new columns; every row saved before them reads
+    // the declared value (generation 0, no closure reason).
+    ...Object.fromEntries(Object.entries(V119_ADDED_COLUMNS).map(([table, columns]) => [table, { added: Object.fromEntries(Object.entries(columns).map(([column, { saved }]) => [column, saved])) }])),
 };
 /** The tables a migration may remove whole (v115's removed features). */
 export const RETIRED_TABLES = Object.freeze(Object.keys(HISTORY_RULES).filter(name => HISTORY_RULES[name].retired));
@@ -537,6 +540,10 @@ export function changedHistory(db, before) {
         if (t.columns.some(c => !kept(c) && (!rule?.dropped?.includes(c) || (t.nonNull?.[c] !== 0 && !accounted(rule, t)))))
             return true;
         const columns = t.columns.filter(c => present.has(c));
+        // A declared new column: every row saved before it reads its declared value.
+        const added = Object.entries(rule?.added ?? {}).filter(([c]) => !t.columns.includes(c) && present.has(c));
+        if (t.rowid && added.some(([c, saved]) => Number(db.prepare("SELECT count(*) AS n FROM " + quote(t.name) + " WHERE rowid <= ? AND " + quote(c) + " IS NOT " + saved).get(t.last)["n"]) > 0))
+            return true;
         if (!t.rowid) {
             const after = rowsHash(db, t.name, columns);
             return after.count !== t.count || after.hash !== t.hash;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.58",
+  "version": "0.9.59",
   "description": "A control plane for unattended coding agents — queue tasks, walk away, come back to pull requests. Agents build in leased worktrees, never touch your default branch, and interrupt you only for decisions that need a human.",
   "directories": {
     "doc": "docs"