toolroll 0.9.52 → 0.9.54

package/dist/templates.js

@@ -1,6 +1,6 @@
 /**
- * The template library (adoption track, step 2) — common standing orders
- * shipped as STATIC DATA that renders into editable, UNAPPROVED drafts.
+ * The template library (adoption track, step 2) — common work shipped as
+ * STATIC DATA that renders into editable, UNAPPROVED drafts.
  *
  * What a template is: a pre-filled form. What it is not: automation with
  * authority. Applying one produces exactly the rows a manual filing
@@ -9,7 +9,10 @@
  * capitals, because `--file` must never read as a yes.
  *
  * The Codex adoption review (finding 10) drew the v1 line: templates may
- * express ONLY what a task or routine proposal can carry today. The two
+ * express ONLY what a task proposal or a scheduled flow can carry today. A
+ * repeating template (v115: what a routine template was) makes a scheduled
+ * flow whose schedule starts paused, and whose every firing waits for
+ * approval under the project's rules. The two
  * use cases that imply separate authenticated authority — GitHub issue
  * intake (a grant) and CI babysitting (publish + the repair button) —
  * ship as RECIPES: they display the existing ceremonies, and cannot be
@@ -21,10 +24,10 @@
  */
 export const TEMPLATES = [
     {
-        kind: "routine",
+        kind: "scheduled",
         name: "nightly-deps",
         purpose: "keep dependencies fresh without surprise majors",
-        routineName: "nightly-deps",
+        title: "Keep dependencies current",
         goal: "Update dependencies conservatively: refresh the lockfile within existing semver ranges, run the full test suite, and summarize what moved in the handoff — plus anything notable you saw (majors now available, security advisories, packages that look abandoned). If the suite fails after the refresh, park with the failure rather than pinning things until it passes.",
         outOfScope: "No major version bumps. No edits to application code beyond what the lockfile refresh itself forces. No changes to CI configuration.",
         touches: [],
@@ -37,10 +40,10 @@ export const TEMPLATES = [
         edit: ["schedule", "goal (name your package manager if it is unusual)", "ceiling (a weekly dollar cap)"],
     },
     {
-        kind: "routine",
+        kind: "scheduled",
         name: "test-coverage",
         purpose: "grow the test suite one module at a time",
-        routineName: "test-coverage",
+        title: "Test one overlooked module",
         goal: "Pick ONE module that is under-tested — no tests at all beats thin tests — and write focused tests for its observable behavior: inputs, outputs, and failure paths, not implementation details. One module per firing, then stop. If the module cannot be tested without refactoring it, do not refactor: park with a note naming the obstacle so a human can decide.",
         outOfScope: "No refactoring of the code under test. No snapshot tests. No changes outside the chosen module's test file(s).",
         touches: [],
@@ -53,10 +56,10 @@ export const TEMPLATES = [
         edit: ["schedule", "touches (pin the test directory layout if yours is unusual)"],
     },
     {
-        kind: "routine",
+        kind: "scheduled",
         name: "docs-drift",
         purpose: "keep the README and docs telling the truth weekly",
-        routineName: "docs-drift",
+        title: "Keep documentation accurate",
         goal: "Read the README and any docs/ pages against the code as it is today. Fix what has drifted: commands that moved, flags that changed, features that shipped undocumented, claims that stopped being true. Prefer deleting a stale claim over guessing a new one. Summarize every correction in the handoff.",
         outOfScope: "No restructuring or rewriting for style. No new documentation pages. No changes to code.",
         touches: ["README.md", "docs/"],

package/dist/toolroll-update.d.ts

@@ -103,6 +103,21 @@ export declare function releaseNotes(changelog: string, version: string): string
  * by its directory), and the directory after, so a crash never leaves a torn
  * database, catalog or command. */
 export declare function durableRename(temp: string, target: string): void;
+type Moved = {
+    into: string;
+    where: string;
+    rows?: string;
+};
+export declare const CHAT_MOVES: Record<string, Moved>;
+/** The tables a migration may remove whole (v115's removed features). */
+export declare const RETIRED_TABLES: readonly string[];
+/** A saved routine, as its move into a scheduled flow must account for it. */
+type RoutineDigest = {
+    id: number;
+    repo: string;
+    name: string;
+    live: boolean;
+};
 export type TableDigest = {
     name: string;
     columns: string[];
@@ -117,6 +132,11 @@ export type TableDigest = {
         count: number;
         nonNull: Record<string, number>;
     };
+    routines?: RoutineDigest[];
+    moved?: {
+        rows: number;
+        found: number;
+    };
 };
 /** Each saved table's columns, row count and last rowid; the append-only ones hashed (deploy-browser's rehearsal check).
  * Bounded: only the ledger and small tables are read row by row. */

package/dist/toolroll-update.js

@@ -166,7 +166,7 @@ export function runningWorkWords(db) {
     const runs = db.prepare("SELECT tr.external_id id, COALESCE(t.title, tr.external_id) title FROM run r JOIN task_ref tr ON tr.id = r.task_ref LEFT JOIN task t ON t.id = tr.external_id WHERE r.outcome IS NULL ORDER BY r.id LIMIT 3").all()
         .map(row => `${String(row["id"])} (${String(row["title"]).slice(0, 60)})`);
     const more = Number(active["runs"] ?? 0) - runs.length;
-    const other = Object.entries(active).filter(([key, n]) => key !== "runs" && n > 0).map(([key, n]) => `${n} ${key === "claims" ? "claimed task" : key === "conversations" ? "chat request" : key === "sessions" ? "held session" : key === "stopping" ? "run still stopping" : key === "codingDeliveries" ? "unconfirmed coding message" : "coding session"}${n === 1 ? "" : "s"}`);
+    const other = Object.entries(active).filter(([key, n]) => key !== "runs" && n > 0).map(([key, n]) => `${n} ${key === "claims" ? "claimed task" : key === "conversations" ? "chat request" : key === "stopping" ? "run still stopping" : key === "codingDeliveries" ? "unconfirmed coding message" : "coding session"}${n === 1 ? "" : "s"}`);
     const parts = [...(runs.length ? [`running ${runs.join(", ")}${more > 0 ? ` and ${more} more` : ""}`] : []), ...other];
     return parts.join("; ");
 }
@@ -322,16 +322,64 @@ export function durableRename(temp, target) {
  * only when every saved value is null, or, with `carried`, when the receiving table gained exactly one receipt under
  * that destination per row holding a value, and as many non-null values per column as the dropped columns held.
  * `receives`: the only rows the table may gain are those receipts. `compacted`: rows may go only into summary rows,
- * whose `sum` grows by exactly as many. */
+ * whose `sum` grows by exactly as many. `retired`: a removed feature's table, which may go whole. `fromRoutines`: rows
+ * kept as they were, and the only rows the table may gain are one per saved routine, moved into a scheduled flow (its
+ * flow, or its schedule trigger naming that routine) — on only when the routine was approved and running. `moved`:
+ * the table may go only when every row it had (or the ones `rows` counts) arrived in `into`: the rows there that
+ * `where` picks grew by exactly that many. */
 const LEGACY_DESTINATION = "legacy:single-destination";
+/** v116: every old per-app chat table into the shared chat tables, keyed by provider (chat-migration.ts). Several old
+ * tables fan into one shared table; each picks out only its own rows there, so every count is checked on its own. */
+const TELEGRAM_MOVES = {
+    telegram_binding: { into: "chat_binding", where: "1" },
+    telegram_pairing: { into: "chat_pair", where: "1" },
+    telegram_team_chat: { into: "chat_room", where: "1" },
+    // An applied update is a receipt; a pushed one still waiting is queued (one already applied was spent with it).
+    telegram_update: { into: "chat_event", where: "kind = 'update' AND state = 'done'" },
+    telegram_inbox: { into: "chat_event", where: "kind = 'update' AND state = 'queued'", rows: "update_id NOT IN (SELECT update_id FROM telegram_update)" },
+    telegram_conversation: { into: "chat_event", where: "kind = 'message'" },
+    telegram_conversation_part: { into: "chat_part", where: "1" },
+    telegram_proposal_action: { into: "chat_action", where: "proposal IS NOT NULL" },
+    telegram_action: { into: "chat_action", where: "decision IS NOT NULL" },
+    telegram_flow_action: { into: "chat_flow_action", where: "action IN ('approve','edit','send-back')" },
+    telegram_flow_confirm: { into: "chat_flow_action", where: "action IN ('yes','cancel')" },
+    telegram_flow_choice: { into: "chat_flow_choice", where: "1" },
+    telegram_flow_prompt: { into: "chat_flow_prompt", where: "1" },
+    telegram_question_action: { into: "chat_question_action", where: "1" },
+    telegram_question_prompt: { into: "chat_question_prompt", where: "1" },
+    telegram_decision_message: { into: "chat_message_ref", where: "kind = 'decision'" },
+    telegram_task_message: { into: "chat_message_ref", where: "kind = 'task'" },
+    telegram_outbound_message: { into: "chat_message_ref", where: "kind = 'notification'" },
+    telegram_note_draft: { into: "chat_note_draft", where: "1" },
+    // A bot's lease and its rate-limit wait share its one runtime row.
+    bridge_lease: { into: "chat_runtime", where: "lease_until IS NOT NULL" },
+    telegram_retry: { into: "chat_runtime", where: "retry_at IS NOT NULL" },
+    telegram_digest: { into: "chat_digest", where: "1", rows: "id = 1" },
+};
+const APP_TABLES = ["binding", "pair", "event", "part", "action", "progress", "runtime", "room", "meta",
+    "flow_action", "flow_prompt", "flow_choice", "flow_note", "question_action", "question_prompt", "ask_action"];
+export const CHAT_MOVES = {
+    ...Object.fromEntries(Object.entries(TELEGRAM_MOVES).map(([table, move]) => [table, { ...move, where: `provider = 'telegram' AND (${move.where})` }])),
+    ...Object.fromEntries(["slack", "discord", "teams"].flatMap(app => APP_TABLES.map(suffix => [`${app}_${suffix}`, { into: `chat_${suffix}`, where: `provider = '${app}'` }]))),
+};
 const HISTORY_RULES = {
+    ...Object.fromEntries(Object.entries(CHAT_MOVES).map(([table, moved]) => [table, { moved }])),
     action_ledger: { appendOnly: true }, ledger_seal: { appendOnly: true }, ledger_checkpoint: { appendOnly: true },
     // v114: a finished run whose process witnesses have all exited keeps one summary row in place of them.
     run_process: { compacted: { into: "run_process_summary", sum: "witnesses" } }, run_process_summary: { appendOnly: true },
     // v114: single-destination delivery columns may be dropped only once their values are legacy receipts.
     notification: { dropped: ["attempts", "last_attempt_at", "last_error", "delivered_at", "receipt", "claim_owner", "claim_expires_at"], carried: { into: "notification_delivery", destination: LEGACY_DESTINATION } },
     notification_delivery: { receives: LEGACY_DESTINATION },
+    // v115: contests, held sessions, fallback chains and routines are removed; their tables go whole.
+    tournament_terms: { retired: true }, contest: { retired: true }, contestant: { retired: true },
+    routine: { retired: true }, routine_fire: { retired: true },
+    attended_authorization: { retired: true }, session_turn: { retired: true }, held_session: { retired: true },
+    fallback_config: { retired: true }, fallback_cycle: { retired: true }, fallback_transition: { retired: true },
+    // v115: each routine becomes one scheduled flow and its schedule trigger.
+    flow: { fromRoutines: "flow" }, flow_trigger: { fromRoutines: "trigger" },
 };
+/** 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));
 const tableColumns = (db, name) => db.prepare("PRAGMA table_info(" + quote(name) + ")").all().map(r => String(r["name"]));
 const plainValue = (_, v) => v instanceof Uint8Array ? Buffer.from(v).toString("hex") : typeof v === "bigint" ? String(v) : v;
 /** Rows streamed into a sha256, never held together: through a rowid in rowid order, or a WITHOUT ROWID table whole. */
@@ -352,6 +400,8 @@ function receipts(db, name, destination, columns) {
     const r = db.prepare("SELECT count(*) AS n" + columns.map(column => ",count(" + quote(column) + ") AS " + quote(column)).join("") + " FROM " + quote(name) + " WHERE destination = ?").get(destination);
     return { count: Number(r["n"]), nonNull: Object.fromEntries(columns.map(column => [column, Number(r[column])])) };
 }
+/** The rows a moved table's rule picks out in its destination (none while there is no such table). */
+const arrived = (db, move) => db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(move.into) ? Number(db.prepare("SELECT count(*) AS n FROM " + quote(move.into) + " WHERE " + move.where).get()["n"]) : 0;
 const summed = (db, into) => db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(into.into) ? Number(db.prepare("SELECT coalesce(sum(" + quote(into.sum) + "),0) AS n FROM " + quote(into.into)).get()["n"]) : 0;
 /** Each saved table's columns, row count and last rowid; the append-only ones hashed (deploy-browser's rehearsal check).
  * Bounded: only the ledger and small tables are read row by row. */
@@ -371,13 +421,53 @@ export function historySnapshot(db) {
         }
         if (rule?.receives)
             t.received = receipts(db, name, rule.receives, columns.filter(column => column !== "notification" && column !== "destination"));
-        if (rule?.appendOnly)
+        if (rule?.appendOnly || rule?.fromRoutines)
             t.hash = rowsHash(db, name, columns, t.last).hash;
         if (rule?.compacted)
             t.summed = summed(db, rule.compacted);
+        if (rule?.fromRoutines)
+            t.routines = savedRoutines(db);
+        if (rule?.moved)
+            t.moved = { found: arrived(db, rule.moved),
+                rows: rule.moved.rows === undefined ? t.count : Number(db.prepare("SELECT count(*) AS n FROM " + quote(name) + " WHERE " + rule.moved.rows).get()["n"]) };
         return t;
     });
 }
+/** Each saved routine (none when the table is gone or was never made), and whether it was approved and running. */
+function savedRoutines(db) {
+    if (!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='routine'").get())
+        return [];
+    const columns = new Set(tableColumns(db, "routine"));
+    const live = ["approved_at", "approved_digest", "digest", "paused", "approved_profile_json", "approved_route_json"].every(c => columns.has(c))
+        ? "(approved_at IS NOT NULL AND approved_digest = digest AND approved_profile_json IS NOT NULL AND approved_route_json IS NOT NULL AND paused = 0)" : "0";
+    return db.prepare("SELECT id, repo, name, " + live + " AS live FROM routine ORDER BY id").all()
+        .map(r => ({ id: Number(r["id"]), repo: String(r["repo"]), name: String(r["name"]), live: Number(r["live"]) === 1 }));
+}
+/** Whether a table's rows past its saved last rowid are exactly the flows (or schedule triggers) its saved routines became. */
+function movedRoutines(db, t, before) {
+    const routines = t.routines ?? [];
+    if (HISTORY_RULES[t.name].fromRoutines === "flow") {
+        const added = db.prepare("SELECT repo, name, state FROM flow WHERE rowid > ? ORDER BY rowid").all(t.last);
+        const key = (repo, name) => JSON.stringify([String(repo), String(name)]);
+        return added.length === routines.length && added.every(r => r["state"] === "active")
+            && JSON.stringify(added.map(r => key(r["repo"], r["name"])).sort()) === JSON.stringify(routines.map(r => key(r.repo, r.name)).sort());
+    }
+    // A trigger names its routine in its order, and belongs to a flow the move added for that same routine.
+    const flows = before.find(one => one.name === "flow");
+    if (flows === undefined)
+        return false;
+    const added = db.prepare(`SELECT t.kind, t.state, json_extract(t.config_json, '$.order.routine') AS routine, f.id AS flow, f.repo, f.name FROM flow_trigger t
+    LEFT JOIN flow f ON f.id = t.flow AND f.rowid > ? WHERE t.rowid > ? ORDER BY t.rowid`).all(flows.last, t.last);
+    const byId = new Map(routines.map(r => [r.id, r]));
+    const seen = new Set();
+    return added.length === routines.length && added.every(r => {
+        const routine = byId.get(Number(r["routine"]));
+        if (r["kind"] !== "schedule" || routine === undefined || seen.has(routine.id) || r["flow"] === null)
+            return false;
+        seen.add(routine.id);
+        return r["repo"] === routine.repo && r["name"] === routine.name && (r["state"] === "paused" || (r["state"] === "active" && routine.live));
+    });
+}
 /** The tables whose saved history the migration changed beyond what HISTORY_RULES declares. */
 export function changedHistory(db, before) {
     const tables = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map(r => String(r["name"])));
@@ -402,8 +492,13 @@ export function changedHistory(db, before) {
         return got !== undefined && want !== undefined && got.count === want.count && Object.entries(want.nonNull).every(([c, n]) => got.nonNull[c] === n) && t.carry === want.count;
     };
     return before.filter(t => {
-        if (!tables.has(t.name))
-            return true;
+        if (!tables.has(t.name)) {
+            const rule = HISTORY_RULES[t.name];
+            if (rule?.retired === true)
+                return false;
+            const move = rule?.moved;
+            return move === undefined || t.moved === undefined || arrived(db, move) - t.moved.found !== t.moved.rows;
+        }
         const rule = HISTORY_RULES[t.name], present = new Set(tableColumns(db, t.name));
         if (t.columns.some(c => !present.has(c) && (!rule?.dropped?.includes(c) || (t.nonNull?.[c] !== 0 && !accounted(rule, t)))))
             return true;
@@ -412,6 +507,10 @@ export function changedHistory(db, before) {
             const after = rowsHash(db, t.name, columns);
             return after.count !== t.count || after.hash !== t.hash;
         }
+        if (rule?.fromRoutines) {
+            const kept = rowsHash(db, t.name, columns, t.last);
+            return kept.count !== t.count || kept.hash !== t.hash || !movedRoutines(db, t, before);
+        }
         if (rule?.appendOnly) {
             const after = rowsHash(db, t.name, columns, t.last);
             return after.count !== t.count || after.hash !== t.hash;

package/dist/work-index.js

@@ -72,8 +72,6 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
   JOIN run r ON r.id=d.run JOIN admitted a ON a.ref_id=r.task_ref
   WHERE d.state<>'answered' AND d.answered_at IS NULL GROUP BY r.task_ref
 ), custody AS MATERIALIZED (
-  SELECT r.task_ref FROM held_session h JOIN run r ON r.id=h.run JOIN admitted a ON a.ref_id=r.task_ref WHERE h.ended_at IS NULL
-  UNION
   SELECT r.task_ref FROM run r INDEXED BY work_spawned_run JOIN admitted a ON a.ref_id=r.task_ref
     WHERE r.provider_started_at IS NOT NULL AND NOT EXISTS(SELECT 1 FROM run_process p WHERE p.run=r.id) AND NOT EXISTS(SELECT 1 FROM run_process_summary s WHERE s.run=r.id)
   UNION
@@ -110,8 +108,7 @@ const PROJECTION = `WITH RECURSIVE admitted AS MATERIALIZED (
 ), workers AS MATERIALIZED (
   SELECT r.name,r.capacity,r.heartbeat_at,j.value repo,
     (SELECT COUNT(*) FROM claim c WHERE c.runner=r.name AND c.released_at IS NULL AND c.expires_at>$now
-      AND c.lease_generation=(SELECT MAX(newest.lease_generation) FROM claim newest WHERE newest.task_ref=c.task_ref)
-      AND c.lease_id NOT IN (SELECT lease_id FROM held_session WHERE ended_at IS NULL)) occupied
+      AND c.lease_generation=(SELECT MAX(newest.lease_generation) FROM claim newest WHERE newest.task_ref=c.task_ref)) occupied
   FROM runner r,json_each(CASE WHEN json_valid(r.repos) THEN r.repos ELSE '[]' END) j WHERE r.retired_at IS NULL
 ), facts AS MATERIALIZED (
   SELECT c.*,f.version_count,f.family_updated,f.earlier_active,f.earlier_id,f.family_running,f.question_id,
@@ -289,8 +286,7 @@ function registerValidators(store) {
  * `workspace`: a finished task whose last build's workspace note is still
  * there, which only the store can read (a held or unreadable workspace). */
 function custodyReadings(store) {
-    const refs = store.handle.prepare(`SELECT r.task_ref FROM held_session h JOIN run r ON r.id=h.run WHERE h.ended_at IS NULL
-    UNION SELECT r.task_ref FROM run r WHERE r.provider_started_at IS NOT NULL AND NOT EXISTS(SELECT 1 FROM run_process p WHERE p.run=r.id) AND NOT EXISTS(SELECT 1 FROM run_process_summary s WHERE s.run=r.id)
+    const refs = store.handle.prepare(`SELECT r.task_ref FROM run r WHERE r.provider_started_at IS NOT NULL AND NOT EXISTS(SELECT 1 FROM run_process p WHERE p.run=r.id) AND NOT EXISTS(SELECT 1 FROM run_process_summary s WHERE s.run=r.id)
     UNION SELECT r.task_ref FROM run_process p JOIN run r ON r.id=p.run WHERE p.exited_at IS NULL AND p.container_empty_at IS NULL`).all().map(row => Number(row['task_ref']));
     const noted = store.handle.prepare(`SELECT r.task_ref,r.worktree FROM task t JOIN task_ref tr ON tr.external_id=t.id
     JOIN run r ON r.id=(SELECT MAX(id) FROM run WHERE task_ref=tr.id AND role IN ('builder','scout') AND finished_at IS NOT NULL)

package/dist/workspace-revision.js

@@ -4,10 +4,12 @@ export const WORKSPACE_REVISION_KEY = 'workspace-content:v1';
 const KEY = WORKSPACE_REVISION_KEY;
 const MAX_AGE_MS = 60_000;
 const OMIT = new Set(['schema_version', 'service_cursor', 'wake', 'notification_delivery', 'sqlite_sequence',
-    'team_read', 'team_request', 'push_delivery', 'telegram_update', 'telegram_outbound_message', 'telegram_retry', 'bridge_lease']);
+    'team_read', 'team_request', 'push_delivery', 'chat_message_ref']);
 const QUIET = {
     runner: ['heartbeat_at'], claim: ['heartbeat_at', 'expires_at'], watch_lease: ['heartbeat_at', 'expires_at'],
     watch_episode: ['ticks'], provider_readiness: ['observed_at'],
+    // A chat worker's lease, poll cursor and rate-limit wait are its own bookkeeping; its connection and problem are news.
+    chat_runtime: ['owner', 'lease_until', 'generation', 'cursor', 'heartbeat', 'retry_at'],
 };
 /** A quiet beat that revives what a view already rendered as gone: the rows a beat may move, read before and after.
  * A runner beat after its liveness window (or backwards) is a revival; a lease renewed at or past its expiry is one. */

package/dist/workspace-ui.js

@@ -506,7 +506,7 @@ export function workCounts(rows) {
 export function compareWorkRows(a, b) {
     return a.rank - b.rank || (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0);
 }
-const WORK_KEYS = new Set(["inbox", "board", "queue", "work", "done", "activity", "review", "tasks", "runs", "workbench", "routines", "recipes", "ledger"]);
+const WORK_KEYS = new Set(["inbox", "board", "queue", "work", "done", "activity", "review", "tasks", "runs", "workbench", "recipes", "ledger"]);
 const SETTINGS_KEYS = new Set(["fleet", "caps", "people", "mode", "system", "settings"]);
 export function primaryDestinationOf(active) {
     if (active === "chat")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolroll",
-  "version": "0.9.52",
+  "version": "0.9.54",
   "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"

package/scripts/recovery-canary.mjs

@@ -27,7 +27,7 @@ for (let index = 2; index < process.argv.length; index++) {
 assert(Number.isSafeInteger(rounds) && rounds > 0 && rounds <= 1000, "rounds must be an integer from 1 to 1000");
 const { openStore } = await import(pathToFileURL(join(root, "dist/store.js")));
 const { register, recoverDead, DEFAULT_LIVENESS_MS } = await import(pathToFileURL(join(root, "dist/runner.js")));
-const { acquire, completeFenced } = await import(pathToFileURL(join(root, "dist/claim.js")));
+const { acquire, finalize } = await import(pathToFileURL(join(root, "dist/claim.js")));
 const { WorktreePool } = await import(pathToFileURL(join(root, "dist/worktree.js")));
 const { run } = await import(pathToFileURL(join(root, "dist/exec.js")));
 const { HANDOFF_PREFIX } = await import(pathToFileURL(join(root, "dist/evidence.js")));
@@ -101,7 +101,7 @@ try {
       const blocked = await pool.lease(request);
       assert.equal(blocked.ok, false);
       assert.equal(blocked.reason, "in-use");
-      assert.equal(completeFenced(store, "old-lease", "done", expired).ok, false);
+      assert.equal(finalize(store, "old-lease", { kind: "complete", state: "done", now: expired }).ok, false);
       assert.notEqual(store.getTask("work").state, "done");
       writer.kill("SIGKILL");
       await exited;
@@ -114,7 +114,7 @@ try {
       assert.equal(await readFile(join(path, "draft.txt"), "utf8"), draft);
       assert.equal(await git(path, ["rev-parse", "HEAD"]), head);
       assert((await readFile(resumed.reclaimed, "utf8")).includes(draft.trim()));
-      assert.equal(completeFenced(store, "new-lease", "failed", expired).ok, true);
+      assert.equal(finalize(store, "new-lease", { kind: "complete", state: "failed", now: expired }).ok, true);
       await pool.release(path, expired);
       cases.push({ round: index + 1, scenario, passed: true, oldCompletion: "fenced", liveWriter: "refused-reuse", draft: "preserved", commit: "preserved" });
     } finally {