@open-tomato/rafa 0.34.1 → 0.36.0

package/dist/{index-bebv92ha.js → index-qvbeqrx3.js}

@@ -15,7 +15,7 @@ import {
   parseConfigText,
   readRafaBlocks,
   resolveConfig
-} from "./index-vp0xghk2.js";
+} from "./index-jfas157k.js";
 import {
   bless,
   merge
@@ -255,11 +255,11 @@ function openNdjsonStore(repoRoot) {
 // src/effort/store/sqlite.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
 import { dirname as dirname10, join as join9 } from "path";
-import { Database } from "bun:sqlite";
+import { Database as Database2 } from "bun:sqlite";
 
 // package.json
 var name = "@open-tomato/rafa";
-var version = "0.34.1";
+var version = "0.36.0";
 
 // src/cli/version.ts
 var RAFA_VERSION = version;
@@ -656,6 +656,7 @@ var DEFAULT_PHASE = "task";
 var RECORD_EXTENSION = ".json";
 var SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 var SESSION_STEP_KINDS = Object.freeze(["baseline", "task", "stage", "pre-wrap-up"]);
+var SESSION_STEP_REASONS = Object.freeze(["declared", "trigger", "fallback", "no-module-tests", "stage"]);
 
 class SessionRecordError extends Error {
   file;
@@ -805,10 +806,17 @@ function freezeHop(value) {
 function freezeFailures(failures) {
   return Object.freeze(failures.map((failure) => Object.freeze({ file: failure.file, name: failure.name })));
 }
+function isSessionStepReason(value) {
+  return SESSION_STEP_REASONS.includes(value);
+}
+function reasonEntry(reason) {
+  return isSessionStepReason(reason) ? { reason } : {};
+}
 function freezeStep(step) {
   return Object.freeze({
     kind: step.kind,
     scope: typeof step.scope === "string" ? step.scope : Object.freeze([...step.scope]),
+    ...reasonEntry(field(step, "reason")),
     command: Object.freeze([...step.command]),
     exitCode: step.exitCode,
     summary: step.summary,
@@ -1469,6 +1477,20 @@ var SQLITE_MIGRATIONS = [
     recorded_at TEXT NOT NULL CHECK (recorded_at <> '')
   );
   `
+  },
+  {
+    id: "store-meta-generation",
+    breaks: [],
+    sql: `
+  ALTER TABLE store_meta ADD COLUMN generation TEXT CHECK (generation <> '');
+  `
+  },
+  {
+    id: "session-worktree",
+    breaks: [],
+    sql: `
+  ALTER TABLE sessions ADD COLUMN worktree TEXT;
+  `
   }
 ];
 var SQLITE_SCHEMA_VERSION = SQLITE_MIGRATIONS.length;
@@ -1700,13 +1722,55 @@ function activeStoreSettings() {
 }
 
 // src/effort/store/store-meta.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { dirname as dirname9 } from "path";
+import { Database } from "bun:sqlite";
+
+// src/effort/store/store-generation.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { readFileSync as readFileSync6, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "fs";
+var STORE_GENERATION_SUFFIX = ".generation";
+function storeGenerationPath(storePath) {
+  return `${storePath}${STORE_GENERATION_SUFFIX}`;
+}
+function isMissingFile(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function readStoreGeneration(storePath) {
+  let text;
+  try {
+    text = readFileSync6(storeGenerationPath(storePath), "utf8");
+  } catch (error) {
+    if (isMissingFile(error))
+      return null;
+    throw error;
+  }
+  const generation = text.trim();
+  return generation === "" ? null : generation;
+}
+function assertWritableGeneration(generation) {
+  if (generation === "" || generation !== generation.trim() || /[\r\n]/.test(generation)) {
+    throw new Error(`store generation must be non-empty, unpadded and on one line, got ${JSON.stringify(generation)}`);
+  }
+}
+function writeStoreGeneration(storePath, generation) {
+  assertWritableGeneration(generation);
+  const file = storeGenerationPath(storePath);
+  const temporary = `${file}.${String(process.pid)}.${randomUUID3()}.tmp`;
+  try {
+    writeFileSync4(temporary, `${generation}
+`, { encoding: "utf8", flag: "wx" });
+    renameSync4(temporary, file);
+  } catch (error) {
+    rmSync4(temporary, { force: true });
+    throw error;
+  }
+}
 
 // src/effort/store/store-identity.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import { createHmac } from "crypto";
-import { readFileSync as readFileSync6, realpathSync as realpathSync4, statSync } from "fs";
+import { readFileSync as readFileSync7, realpathSync as realpathSync4, statSync } from "fs";
 import { hostname, platform as currentPlatform } from "os";
 
 // src/schema/project-id.ts
@@ -1744,7 +1808,7 @@ function hostIdFrom(source, value) {
 }
 function readMachineIdFile() {
   try {
-    const value = readFileSync6(MACHINE_ID_PATH, "utf8").trim();
+    const value = readFileSync7(MACHINE_ID_PATH, "utf8").trim();
     return value === "" ? null : value;
   } catch {
     return null;
@@ -1780,14 +1844,19 @@ function readStoreFileFacts(path) {
   return { storePath, fileDev: stats.dev, fileIno: stats.ino };
 }
 function observeStore(path, readHost = readHostId) {
-  return { hostId: readHost(), ...readStoreFileFacts(path) };
+  const fileFacts = readStoreFileFacts(path);
+  return { hostId: readHost(), ...fileFacts, generation: readStoreGeneration(fileFacts.storePath) };
+}
+function staleGeneration(recorded, facts) {
+  return recorded.generation !== null && recorded.generation !== facts.generation;
 }
 function movedFacts(recorded, facts) {
   const sameFile = BigInt(recorded.fileDev) === facts.fileDev && BigInt(recorded.fileIno) === facts.fileIno;
   const moved = [
     ["host", recorded.hostId !== facts.hostId],
     ["path", recorded.storePath !== facts.storePath],
-    ["file", !sameFile]
+    ["file", !sameFile],
+    ["generation", staleGeneration(recorded, facts)]
   ];
   return moved.filter(([, differs]) => differs).map(([reason]) => reason);
 }
@@ -1827,8 +1896,12 @@ function toStoredInteger(value) {
 function fromStoredInteger(text) {
   return BigInt.asUintN(STORED_INTEGER_BITS, BigInt(text));
 }
+function hasGenerationColumn(db) {
+  return db.query("SELECT count(*) AS n FROM pragma_table_info('store_meta') WHERE name = 'generation'").get()?.n === 1;
+}
 function readStoreMeta(db) {
-  const row = db.query("SELECT store_id, project_root_commit, project_remote, host_id, store_path," + " CAST(file_dev AS TEXT) AS file_dev, CAST(file_ino AS TEXT) AS file_ino, minted_at" + " FROM store_meta WHERE id = 1").get();
+  const generation = hasGenerationColumn(db) ? "generation" : "NULL AS generation";
+  const row = db.query("SELECT store_id, project_root_commit, project_remote, host_id, store_path," + " CAST(file_dev AS TEXT) AS file_dev, CAST(file_ino AS TEXT) AS file_ino, minted_at," + ` ${generation} FROM store_meta WHERE id = 1`).get();
   if (row === null)
     return null;
   return {
@@ -1839,7 +1912,8 @@ function readStoreMeta(db) {
     storePath: row.store_path,
     fileDev: fromStoredInteger(row.file_dev),
     fileIno: fromStoredInteger(row.file_ino),
-    mintedAt: row.minted_at
+    mintedAt: row.minted_at,
+    generation: row.generation
   };
 }
 function projectFor(storePath, recorded, seams) {
@@ -1850,14 +1924,30 @@ function projectFor(storePath, recorded, seams) {
     return null;
   return { rootCommit: recorded.projectRootCommit, remote: recorded.projectRemote };
 }
-function writeStoreMeta(db, facts, project, seams) {
-  const storeId = (seams.newStoreId ?? randomUUID3)();
+function writeStoreMeta(db, facts, project, generation, seams) {
+  const storeId = (seams.newStoreId ?? randomUUID4)();
   const mintedAt = (seams.now?.() ?? new Date).toISOString();
-  db.query("INSERT OR REPLACE INTO store_meta (id, store_id, project_root_commit, project_remote," + " host_id, store_path, file_dev, file_ino, minted_at) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?)").run(storeId, project.rootCommit, project.remote, facts.hostId, facts.storePath, toStoredInteger(facts.fileDev), toStoredInteger(facts.fileIno), mintedAt);
+  db.query("INSERT OR REPLACE INTO store_meta (id, store_id, project_root_commit, project_remote," + " host_id, store_path, file_dev, file_ino, minted_at, generation) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(storeId, project.rootCommit, project.remote, facts.hostId, facts.storePath, toStoredInteger(facts.fileDev), toStoredInteger(facts.fileIno), mintedAt, generation);
   return storeId;
 }
-function unminted(decision) {
-  return decision.action === "keep" ? { action: "keep", storeId: decision.storeId } : { action: "none" };
+function settleUnderLock(db, observe, prefetched, seams) {
+  const current = readStoreMeta(db);
+  const facts = observe();
+  const decision = decideStoreIdentity("write", current, () => facts);
+  if (decision.action === "none")
+    return { action: "none" };
+  const generation = (seams.newGeneration ?? randomUUID4)();
+  if (decision.action === "keep") {
+    db.query("UPDATE store_meta SET generation = ? WHERE id = 1").run(generation);
+    writeStoreGeneration(facts.storePath, generation);
+    return { action: "keep", storeId: decision.storeId };
+  }
+  const project = prefetched ?? projectFor(facts.storePath, current, seams);
+  if (project === null)
+    return { action: "no-project", reasons: decision.reasons };
+  const storeId = writeStoreMeta(db, facts, project, generation, seams);
+  writeStoreGeneration(facts.storePath, generation);
+  return { action: "mint", storeId, reasons: decision.reasons };
 }
 function settleStoreIdentity(db, path, access, seams = {}) {
   if (access === "read")
@@ -1865,19 +1955,72 @@ function settleStoreIdentity(db, path, access, seams = {}) {
   const observe = () => observeStore(path, seams.readHostId ?? readHostId);
   const recorded = readStoreMeta(db);
   const first = decideStoreIdentity(access, recorded, observe);
-  if (first.action !== "mint")
-    return unminted(first);
-  const project = projectFor(first.facts.storePath, recorded, seams);
-  if (project === null)
+  const prefetched = first.action === "mint" ? projectFor(first.facts.storePath, recorded, seams) : undefined;
+  if (first.action === "mint" && prefetched === null)
     return { action: "no-project", reasons: first.reasons };
-  const mintUnderLock = db.transaction(() => {
-    const second = decideStoreIdentity(access, readStoreMeta(db), observe);
-    if (second.action !== "mint")
-      return unminted(second);
-    const storeId = writeStoreMeta(db, second.facts, project, seams);
-    return { action: "mint", storeId, reasons: second.reasons };
-  });
-  return mintUnderLock.immediate();
+  const underLock = db.transaction(() => settleUnderLock(db, observe, prefetched ?? undefined, seams));
+  return underLock.immediate();
+}
+function hasStoreMetaTable(db) {
+  return db.query("SELECT count(*) AS n FROM sqlite_master WHERE type = 'table' AND name = 'store_meta'").get()?.n === 1;
+}
+function decideLiveWrite(livePath, readHost) {
+  const live = new Database(livePath, { readonly: true });
+  let recorded;
+  try {
+    if (!hasStoreMetaTable(live))
+      return { action: "no-table" };
+    recorded = readStoreMeta(live);
+  } finally {
+    live.close();
+  }
+  if (recorded === null)
+    return { action: "no-row" };
+  const facts = observeStore(livePath, readHost);
+  const decision = decideStoreIdentity("write", recorded, () => facts);
+  if (decision.action === "keep")
+    return { action: "keep", storeId: decision.storeId };
+  const reasons = decision.action === "mint" ? decision.reasons : [];
+  return { action: "mint", reasons };
+}
+function holdsRowOf(db, storeId) {
+  return hasStoreMetaTable(db) && readStoreMeta(db)?.storeId === storeId;
+}
+function spoilGeneration(db, newGeneration) {
+  if (!hasStoreMetaTable(db) || !hasGenerationColumn(db))
+    return null;
+  const rows = db.query("SELECT count(*) AS n FROM store_meta WHERE id = 1").get()?.n;
+  if (rows !== 1)
+    return null;
+  const generation = newGeneration();
+  db.query("UPDATE store_meta SET generation = ? WHERE id = 1").run(generation);
+  return generation;
+}
+function writeCarried(db, storeId, parallel, newGeneration) {
+  const dev = toStoredInteger(parallel.fileDev);
+  const ino = toStoredInteger(parallel.fileIno);
+  if (hasGenerationColumn(db)) {
+    const generation = newGeneration();
+    db.query("UPDATE store_meta SET file_dev = ?, file_ino = ?, generation = ? WHERE id = 1").run(dev, ino, generation);
+    return { action: "carried", storeId, generation };
+  }
+  db.query("UPDATE store_meta SET file_dev = ?, file_ino = ? WHERE id = 1").run(dev, ino);
+  return { action: "carried", storeId, generation: null };
+}
+function carryStoreIdentity(livePath, parallelPath, seams = {}) {
+  const parallel = readStoreFileFacts(parallelPath);
+  const live = decideLiveWrite(livePath, seams.readHostId ?? readHostId);
+  const newGeneration = seams.newGeneration ?? randomUUID4;
+  const db = new Database(parallelPath, { readwrite: true });
+  try {
+    if (live.action === "keep" && holdsRowOf(db, live.storeId)) {
+      return writeCarried(db, live.storeId, parallel, newGeneration);
+    }
+    const spoiled = spoilGeneration(db, newGeneration);
+    return live.action === "keep" ? { action: "other-row", spoiled } : { ...live, spoiled };
+  } finally {
+    db.close();
+  }
 }
 
 // src/effort/store/sqlite.ts
@@ -1886,8 +2029,12 @@ function sqliteStorePath(repoRoot) {
   return join9(effortStoreDir(repoRoot), SQLITE_STORE_FILE_NAME);
 }
 var KIND_TABLES = {
-  sessions: { name: "sessions", keyColumn: "session_id" },
-  commits: { name: "commits", keyColumn: "sha" }
+  sessions: {
+    name: "sessions",
+    keyColumn: "session_id",
+    fieldColumns: [{ column: "worktree", value: (row) => row.worktree ?? null }]
+  },
+  commits: { name: "commits", keyColumn: "sha", fieldColumns: [] }
 };
 var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
 function hasKey(entry) {
@@ -1898,6 +2045,7 @@ function refused(index, length, reason) {
 }
 function batchEntries(kind, rows) {
   const keyOf = EFFORT_KEY_PROJECTIONS[kind];
+  const fieldColumns = KIND_TABLES[kind].fieldColumns;
   const projected = rows.map((row) => ({ key: keyOf(row), row }));
   const keyed = projected.filter(hasKey);
   if (keyed.length < projected.length) {
@@ -1909,13 +2057,17 @@ function batchEntries(kind, rows) {
     const reason = "carries a key with a lone UTF-16 surrogate," + " which SQLite text cannot hold";
     throw refused(unholdableAt, rows.length, reason);
   }
-  return keyed.map(({ key, row }) => ({ key, body: JSON.stringify(row) }));
+  return keyed.map(({ key, row }) => ({
+    key,
+    body: JSON.stringify(row),
+    fields: fieldColumns.map(({ value }) => value(row))
+  }));
 }
 function withSqliteStore(path, access, create, use, identity = {}) {
   guardTestProcess(path);
   if (create)
     mkdirSync5(dirname10(path), { recursive: true });
-  const db = new Database(path, { readwrite: true, create });
+  const db = new Database2(path, { readwrite: true, create });
   try {
     db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
     bringForward(db, path, access, "open");
@@ -1926,8 +2078,11 @@ function withSqliteStore(path, access, create, use, identity = {}) {
   }
 }
 function insertBatch(db, table, entries) {
-  const insert = db.query(`INSERT INTO ${table.name} (${table.keyColumn}, row_json, ${STAMPED_COLUMNS})` + ` VALUES (?, ?, ${stampedValues(table.name)})` + ` ON CONFLICT (${table.keyColumn}) DO NOTHING`);
-  const insertAll = db.transaction(() => entries.reduce((appended, { key, body }) => appended + insert.run(key, body).changes, 0));
+  const fieldNames = table.fieldColumns.map(({ column }) => column);
+  const columns = [table.keyColumn, "row_json", ...fieldNames].join(", ");
+  const placeholders = ["?", "?", ...fieldNames.map(() => "?")].join(", ");
+  const insert = db.query(`INSERT INTO ${table.name} (${columns}, ${STAMPED_COLUMNS})` + ` VALUES (${placeholders}, ${stampedValues(table.name)})` + ` ON CONFLICT (${table.keyColumn}) DO NOTHING`);
+  const insertAll = db.transaction(() => entries.reduce((appended, { key, body, fields }) => appended + insert.run(key, body, ...fields).changes, 0));
   return insertAll.immediate();
 }
 function writeSqliteStore(path, rowCount, empty, insert) {
@@ -1990,15 +2145,105 @@ import { existsSync as existsSync12 } from "fs";
 import { join as join12, resolve as resolve5 } from "path";
 
 // src/effort/store/fix-schema.ts
-import { existsSync as existsSync7 } from "fs";
-import { Database as Database2 } from "bun:sqlite";
+import { existsSync as existsSync8 } from "fs";
+import { Database as Database4 } from "bun:sqlite";
 
 // src/effort/store/rebuild-aside.ts
-import { existsSync as existsSync6, renameSync as renameSync4, rmSync as rmSync4 } from "fs";
+import { closeSync, existsSync as existsSync7, fsyncSync, openSync, renameSync as renameSync5, rmSync as rmSync6 } from "fs";
+
+// src/effort/store/copy.ts
+import { copyFileSync, constants, existsSync as existsSync6, mkdirSync as mkdirSync6, readdirSync as readdirSync2, rmSync as rmSync5, statSync as statSync2 } from "fs";
+import { join as join10, resolve as resolve3 } from "path";
+import { Database as Database3 } from "bun:sqlite";
+var NDJSON_KINDS = { sessions: true, commits: true };
+var EFFORT_COPY_FILE_NAMES = [
+  SQLITE_STORE_FILE_NAME,
+  ...Object.keys(NDJSON_KINDS).map((kind) => effortStoreFileName(kind))
+];
+
+class EffortCopyRefusal extends Error {
+  name = "EffortCopyRefusal";
+}
 
+class EffortCopyFailure extends Error {
+  name = "EffortCopyFailure";
+}
+function refuseUsedTarget(target) {
+  if (!existsSync6(target))
+    return;
+  let entries;
+  try {
+    if (!statSync2(target).isDirectory()) {
+      throw new EffortCopyRefusal(`${target} is a file, not a directory; name an empty or absent directory with --to=<dir>.`);
+    }
+    entries = readdirSync2(target);
+  } catch (error) {
+    if (error instanceof EffortCopyRefusal)
+      throw error;
+    throw new EffortCopyFailure(`${target} cannot be read: ${String(error)}`);
+  }
+  if (entries.length === 0)
+    return;
+  throw new EffortCopyRefusal(`${target} is not empty (${String(entries.length)} entries); nothing was copied.` + " Name an empty or absent directory with --to=<dir>.");
+}
+function vacuumInto(source, target) {
+  const db = new Database3(source, { readonly: true });
+  try {
+    db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
+    db.run("VACUUM INTO ?", [target]);
+  } finally {
+    db.close();
+  }
+}
+function copyOne(name2, source, target) {
+  if (name2 === SQLITE_STORE_FILE_NAME) {
+    vacuumInto(join10(source, name2), join10(target, name2));
+    return;
+  }
+  copyFileSync(join10(source, name2), join10(target, name2), constants.COPYFILE_EXCL);
+}
+function undo(target, written, madeDir) {
+  try {
+    if (madeDir === undefined) {
+      for (const name2 of written)
+        rmSync5(join10(target, name2), { force: true });
+    } else {
+      rmSync5(madeDir, { recursive: true, force: true });
+    }
+    return "";
+  } catch (error) {
+    return ` Removing what it made failed too: ${String(error)}`;
+  }
+}
+function copyEffortStore(request) {
+  const source = resolve3(request.source);
+  const target = resolve3(request.target);
+  guardTestProcess(source);
+  guardTestProcess(target);
+  const files = EFFORT_COPY_FILE_NAMES.filter((name2) => existsSync6(join10(source, name2)));
+  if (files.length === 0) {
+    throw new EffortCopyRefusal(`no effort store at ${source}: it holds none of ${EFFORT_COPY_FILE_NAMES.join(", ")}. Nothing to copy.`);
+  }
+  refuseUsedTarget(target);
+  const written = [];
+  let madeDir;
+  try {
+    madeDir = mkdirSync6(target, { recursive: true });
+    for (const name2 of files) {
+      written.push(name2);
+      copyOne(name2, source, target);
+    }
+  } catch (error) {
+    const left = undo(target, written, madeDir);
+    throw new EffortCopyFailure(`copying ${source} to ${target} failed: ${String(error)}.${left}`);
+  }
+  return Object.freeze({ source, directory: target, files: Object.freeze(files) });
+}
+
+// src/effort/store/rebuild-aside.ts
 class RebuildRefusal extends Error {
-  constructor(message) {
-    super(message);
+  constructor(message, options) {
+    super(message, options);
     this.name = "RebuildRefusal";
   }
 }
@@ -2010,7 +2255,7 @@ function count(db, sql) {
 }
 function refuseInFlight(path) {
   for (const suffix of ["-journal", "-wal"]) {
-    if (existsSync6(`${path}${suffix}`)) {
+    if (existsSync7(`${path}${suffix}`)) {
       throw new RebuildRefusal(`${path}${suffix} is there, so a write is in flight or was interrupted; stop whatever uses the store` + " and open it once with rafa before repairing it");
     }
   }
@@ -2033,21 +2278,78 @@ function refuseCorrupt(db) {
     throw new RebuildRefusal(`the rebuilt store failed integrity_check: ${answer ?? "no answer"}`);
 }
 function removeParallel(parallelPath) {
-  rmSync4(parallelPath, { force: true });
-  rmSync4(`${parallelPath}-journal`, { force: true });
+  rmSync6(parallelPath, { force: true });
+  rmSync6(`${parallelPath}-journal`, { force: true });
+}
+var STEP_TEXT = {
+  backup: ({ path, backupPath }) => ({
+    doing: `writing ${path} out to the backup ${backupPath}`,
+    backup: `any part of the backup written at ${backupPath}`
+  }),
+  carry: ({ path, parallelPath, backupPath }) => ({
+    doing: `carrying the store id of ${path} onto ${parallelPath}`,
+    backup: `the whole backup at ${backupPath}`
+  }),
+  record: ({ path, parallelPath, backupPath }) => ({
+    doing: `writing the generation carried onto ${parallelPath} to the side record of ${path}`,
+    backup: `the whole backup at ${backupPath}`
+  }),
+  rename: ({ path, parallelPath, backupPath }) => ({
+    doing: `renaming ${parallelPath} over ${path}`,
+    backup: `the whole backup at ${backupPath}`
+  })
+};
+
+class SwapFailure extends RebuildRefusal {
+  step;
+  parallelPath;
+  backupPath;
+  constructor(step, files, cause) {
+    const { doing, backup } = STEP_TEXT[step](files);
+    const reason = cause instanceof Error ? cause.message : String(cause);
+    super(`${doing} failed (${reason}), so ${files.path} was not replaced and is unchanged.` + ` The rebuilt store is left at ${files.parallelPath}, and ${backup}.`, { cause });
+    this.name = "SwapFailure";
+    this.step = step;
+    this.parallelPath = files.parallelPath;
+    this.backupPath = files.backupPath;
+  }
+}
+function writeBackup(path, backupPath) {
+  vacuumInto(path, backupPath);
+  const backup = openSync(backupPath, "r");
+  try {
+    fsyncSync(backup);
+  } finally {
+    closeSync(backup);
+  }
 }
-function swapIn(path, parallelPath, backupPath) {
-  renameSync4(path, backupPath);
+var SWAP_STEPS = {
+  backup: writeBackup,
+  carry: (path, parallelPath) => carryStoreIdentity(path, parallelPath),
+  record: writeStoreGeneration,
+  rename: renameSync5
+};
+function runStep(step, files, act) {
   try {
-    renameSync4(parallelPath, path);
+    return act();
   } catch (error) {
-    renameSync4(backupPath, path);
-    throw error;
+    throw new SwapFailure(step, files, error);
+  }
+}
+function swapIn(path, parallelPath, backupPath, steps = {}) {
+  const { backup, carry, record, rename } = { ...SWAP_STEPS, ...steps };
+  const files = { path, parallelPath, backupPath };
+  runStep("backup", files, () => backup(path, backupPath));
+  const carried = runStep("carry", files, () => carry(path, parallelPath));
+  if (carried.action === "carried" && carried.generation !== null) {
+    const { generation } = carried;
+    runStep("record", files, () => record(path, generation));
   }
+  runStep("rename", files, () => rename(parallelPath, path));
 }
 function refuseTaken(paths) {
   for (const taken of paths) {
-    if (existsSync6(taken))
+    if (existsSync7(taken))
       throw new RebuildRefusal(`${taken} is already there; move it aside or pass another stamp`);
   }
 }
@@ -2086,7 +2388,7 @@ function columnNames(db, schema, table) {
   return db.query("SELECT name FROM pragma_table_info(?, ?)").all(table, schema).map((row) => row.name);
 }
 function readOnlySchema(path) {
-  const db = new Database2(path, { readonly: true });
+  const db = new Database4(path, { readonly: true });
   try {
     return readStoreSchema(db, path);
   } finally {
@@ -2134,7 +2436,7 @@ function refuseUnusable(db, parallelPath, migrations) {
     throw new RebuildRefusal(`the rebuilt store still needs ${needs.join(", ")}`);
 }
 function buildParallel(path, parallelPath, migrations, stamp) {
-  const db = new Database2(parallelPath, { create: true, readwrite: true });
+  const db = new Database4(parallelPath, { create: true, readwrite: true });
   try {
     bringForward(db, parallelPath, "write", "open", { migrations, ...stamp, builtAside: true });
     db.run(`ATTACH DATABASE ? AS ${LIVE}`, [path]);
@@ -2171,7 +2473,7 @@ function fixStoreSchema(options) {
   const appliedBy = appliedByName(identity);
   const known = migrations.map(({ id }) => id);
   const nothing = { known, appliedBy, pending: [], kept: [], leftTables: [], leftColumns: [], backupPath: null };
-  if (!existsSync7(path)) {
+  if (!existsSync8(path)) {
     return { path, status: "missing", storeVersion: null, logged: false, reason: null, refusal: null, unknown: [], ...nothing };
   }
   refuseInFlight(path);
@@ -2213,19 +2515,19 @@ function withoutWayOut(message, nextStep) {
 }
 
 // src/commands/plan/plan-files.ts
-import { statSync as statSync2 } from "fs";
-import { resolve as resolve3 } from "path";
+import { statSync as statSync3 } from "fs";
+import { resolve as resolve4 } from "path";
 
 // src/config-load.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7, realpathSync as realpathSync5 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync8, realpathSync as realpathSync5 } from "fs";
 import { isAbsolute as isAbsolute6 } from "path";
 function readConfigFile(root) {
   const path = configFilePath(root);
-  if (!existsSync8(path))
+  if (!existsSync9(path))
     return null;
   let text;
   try {
-    text = readFileSync7(path, "utf8");
+    text = readFileSync8(path, "utf8");
   } catch (error) {
     const problem = `${path}: cannot be read (${messageOf(error)})`;
     throw new ConfigError([problem], { cause: error });
@@ -2262,7 +2564,7 @@ function loadConfig(roots, cli = {}, warn = printWarning) {
 
 // src/commands/plan/plan-files.ts
 function plansDirAt(root, planDir) {
-  return { label: planDir, path: resolve3(root, planDir) };
+  return { label: planDir, path: resolve4(root, planDir) };
 }
 function requireProject(context, command) {
   if (context.project === null)
@@ -2309,7 +2611,7 @@ function stubOfPlanFile(name2) {
   return stub !== undefined && isStampableStub(stub) ? stub : null;
 }
 function isFile(path) {
-  return statSync2(path, { throwIfNoEntry: false })?.isFile() ?? false;
+  return statSync3(path, { throwIfNoEntry: false })?.isFile() ?? false;
 }
 function issueLine(file, issue) {
   return `${file}:${issue.line}: ${issue.reason}: ${issue.text}`;
@@ -2355,6 +2657,9 @@ var DRY_RUN_FLAG = "dry-run";
 function fileStamp(date) {
   return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
 }
+function keepsIdLine(swapped) {
+  return `The ${swapped} keeps the store's id; the backup is a copy, so renamed back it takes a new id on its` + " next write.";
+}
 function refuseLiveLoop(root, isAlive) {
   let records;
   try {
@@ -2412,7 +2717,7 @@ function renderFixSchema(result) {
     case "rebuilt":
       return [
         ...rebuildLines(result),
-        `\u2705 Rebuilt at this rafa's migrations. The original is kept whole at ${String(result.backupPath)};` + " rename it back to undo."
+        `\u2705 Rebuilt at this rafa's migrations. The original is kept whole at ${String(result.backupPath)};` + ` rename it back to undo. ${keepsIdLine("rebuild")}`
       ];
   }
 }
@@ -2452,7 +2757,7 @@ function createFixSchemaCommand(seams = {}) {
     subject: "effort",
     action: "fix-schema",
     summary: "rebuild an effort store this rafa refuses at the migrations it knows, keeping the original",
-    description: "Repairs `.rafa/effort/effort.sqlite`, or the store under `RAFA_EFFORT_DIR`, when this rafa refuses" + " it for a reason a rebuild repairs: no migration log past the legacy entries (pre-log-unreleased), a log" + " with a schema version it does not match (gate-mismatch), a logged checksum this rafa holds otherwise" + " (edited), or a logged migration this rafa does not know that breaks older readers or writers" + " (unknown-breaks-readers, unknown-breaks-writers). Installing a rafa that knows the store's migrations" + " comes first where one exists. It builds a parallel store beside it at this rafa's migrations, with a" + " migration log naming this rafa, copies every table and column this rafa knows, checks the row counts," + " SQLite's integrity_check and the schema plan, and lists what only the newer schema holds, unknown" + " migrations included. Then it renames the original to `effort.sqlite.v<user_version>-<stamp>.bak`," + " whole, and moves the rebuild into its place. A store this rafa uses, current or behind, or no store, is" + " left alone. It refuses, changing nothing, while a loop session under the project is running or paused," + " from a development build, while a journal beside the store shows a write in flight, when the newer" + " schema lacks a table or column this rafa writes, and on a refusal a rebuild does not repair. With" + " `--output=json` the outcome is the data of the terminal result event. Starts no session.",
+    description: "Repairs `.rafa/effort/effort.sqlite`, or the store under `RAFA_EFFORT_DIR`, when this rafa refuses" + " it for a reason a rebuild repairs: no migration log past the legacy entries (pre-log-unreleased), a log" + " with a schema version it does not match (gate-mismatch), a logged checksum this rafa holds otherwise" + " (edited), or a logged migration this rafa does not know that breaks older readers or writers" + " (unknown-breaks-readers, unknown-breaks-writers). Installing a rafa that knows the store's migrations" + " comes first where one exists. It builds a parallel store beside it at this rafa's migrations, with a" + " migration log naming this rafa, copies every table and column this rafa knows, checks the row counts," + " SQLite's integrity_check and the schema plan, and lists what only the newer schema holds, unknown" + " migrations included. Then it writes the original to `effort.sqlite.v<user_version>-<stamp>.bak`," + " whole, and moves the rebuild into its place. The rebuild keeps the store's id; the backup is a copy," + " so renamed back it takes a new id on its next write. A store this rafa uses, current or behind, or no store, is" + " left alone. It refuses, changing nothing, while a loop session under the project is running or paused," + " from a development build, while a journal beside the store shows a write in flight, when the newer" + " schema lacks a table or column this rafa writes, and on a refusal a rebuild does not repair. With" + " `--output=json` the outcome is the data of the terminal result event. Starts no session.",
     args: [],
     flags: [
       {
@@ -2481,101 +2786,12 @@ function createFixSchemaCommand(seams = {}) {
 }
 var fix_schema_default = createFixSchemaCommand();
 
-// src/effort/store/copy.ts
-import { copyFileSync, constants, existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync2, rmSync as rmSync5, statSync as statSync3 } from "fs";
-import { join as join10, resolve as resolve4 } from "path";
-import { Database as Database3 } from "bun:sqlite";
-var NDJSON_KINDS = { sessions: true, commits: true };
-var EFFORT_COPY_FILE_NAMES = [
-  SQLITE_STORE_FILE_NAME,
-  ...Object.keys(NDJSON_KINDS).map((kind) => effortStoreFileName(kind))
-];
-
-class EffortCopyRefusal extends Error {
-  name = "EffortCopyRefusal";
-}
-
-class EffortCopyFailure extends Error {
-  name = "EffortCopyFailure";
-}
-function refuseUsedTarget(target) {
-  if (!existsSync9(target))
-    return;
-  let entries;
-  try {
-    if (!statSync3(target).isDirectory()) {
-      throw new EffortCopyRefusal(`${target} is a file, not a directory; name an empty or absent directory with --to=<dir>.`);
-    }
-    entries = readdirSync2(target);
-  } catch (error) {
-    if (error instanceof EffortCopyRefusal)
-      throw error;
-    throw new EffortCopyFailure(`${target} cannot be read: ${String(error)}`);
-  }
-  if (entries.length === 0)
-    return;
-  throw new EffortCopyRefusal(`${target} is not empty (${String(entries.length)} entries); nothing was copied.` + " Name an empty or absent directory with --to=<dir>.");
-}
-function vacuumInto(source, target) {
-  const db = new Database3(source, { readonly: true });
-  try {
-    db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
-    db.run("VACUUM INTO ?", [target]);
-  } finally {
-    db.close();
-  }
-}
-function copyOne(name2, source, target) {
-  if (name2 === SQLITE_STORE_FILE_NAME) {
-    vacuumInto(join10(source, name2), join10(target, name2));
-    return;
-  }
-  copyFileSync(join10(source, name2), join10(target, name2), constants.COPYFILE_EXCL);
-}
-function undo(target, written, madeDir) {
-  try {
-    if (madeDir === undefined) {
-      for (const name2 of written)
-        rmSync5(join10(target, name2), { force: true });
-    } else {
-      rmSync5(madeDir, { recursive: true, force: true });
-    }
-    return "";
-  } catch (error) {
-    return ` Removing what it made failed too: ${String(error)}`;
-  }
-}
-function copyEffortStore(request) {
-  const source = resolve4(request.source);
-  const target = resolve4(request.target);
-  guardTestProcess(source);
-  guardTestProcess(target);
-  const files = EFFORT_COPY_FILE_NAMES.filter((name2) => existsSync9(join10(source, name2)));
-  if (files.length === 0) {
-    throw new EffortCopyRefusal(`no effort store at ${source}: it holds none of ${EFFORT_COPY_FILE_NAMES.join(", ")}. Nothing to copy.`);
-  }
-  refuseUsedTarget(target);
-  const written = [];
-  let madeDir;
-  try {
-    madeDir = mkdirSync6(target, { recursive: true });
-    for (const name2 of files) {
-      written.push(name2);
-      copyOne(name2, source, target);
-    }
-  } catch (error) {
-    const left = undo(target, written, madeDir);
-    throw new EffortCopyFailure(`copying ${source} to ${target} failed: ${String(error)}.${left}`);
-  }
-  return Object.freeze({ source, directory: target, files: Object.freeze(files) });
-}
-
 // src/effort/store/merge-store.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync11, mkdtempSync, rmSync as rmSync6 } from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+import { existsSync as existsSync11, mkdtempSync, rmSync as rmSync7 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
 import { dirname as dirname11, join as join11 } from "path";
-import { Database as Database5, SQLiteError as SQLiteError2 } from "bun:sqlite";
+import { Database as Database6, SQLiteError as SQLiteError2 } from "bun:sqlite";
 
 // src/effort/commits.ts
 import { execFileSync } from "child_process";
@@ -2986,7 +3202,7 @@ function settleMatches(local, other, unions, trail) {
 
 // src/effort/store/migrate.ts
 import { existsSync as existsSync10 } from "fs";
-import { Database as Database4 } from "bun:sqlite";
+import { Database as Database5 } from "bun:sqlite";
 var LIVE2 = "live";
 function asidePaths2(path, first, stamp) {
   return { parallelPath: `${path}.migrate-${stamp}`, backupPath: `${path}.before-${first}-${stamp}.bak` };
@@ -3014,7 +3230,7 @@ function refuseLiveLoop2(path, breaking, options) {
 }
 function buildMigrated(path, parallelPath, migrations, stamp) {
   vacuumInto(path, parallelPath);
-  const db = new Database4(parallelPath, { readwrite: true });
+  const db = new Database5(parallelPath, { readwrite: true });
   try {
     const brought = bringForward(db, parallelPath, "write", "migrate", { migrations, ...stamp, builtAside: true });
     db.run(`ATTACH DATABASE ? AS ${LIVE2}`, [path]);
@@ -3098,7 +3314,7 @@ function refuseMissing(path, which) {
 function refuseDamaged(path) {
   let answers;
   try {
-    const db = new Database5(path, { readonly: true });
+    const db = new Database6(path, { readonly: true });
     try {
       answers = db.query("PRAGMA integrity_check").all().map((row) => row.integrity_check);
     } finally {
@@ -3120,7 +3336,7 @@ function writablePlan(path, migrations) {
   return plan;
 }
 function recordedMeta(path) {
-  const db = new Database5(path, { readonly: true });
+  const db = new Database6(path, { readonly: true });
   try {
     const hasTable = db.query("SELECT count(*) AS n FROM sqlite_master WHERE type = 'table' AND name = 'store_meta'").get()?.n === 1;
     return hasTable ? readStoreMeta(db) : null;
@@ -3146,18 +3362,18 @@ function refuseLiveLoop3(path, options, sessionId) {
 function openOther(otherPath, plan, stamp) {
   const needs = writeNames(plan);
   if (needs.length === 0) {
-    const db = new Database5(otherPath, { readonly: true });
+    const db = new Database6(otherPath, { readonly: true });
     return { db, broughtForward: [], release: () => db.close() };
   }
   const dir = mkdtempSync(join11(tmpdir3(), "rafa-merge-other-"));
   const release = (db) => {
     db?.close();
-    rmSync6(dir, { recursive: true, force: true });
+    rmSync7(dir, { recursive: true, force: true });
   };
   try {
     const copyPath = join11(dir, "other.sqlite");
     vacuumInto(otherPath, copyPath);
-    const db = new Database5(copyPath, { readwrite: true });
+    const db = new Database6(copyPath, { readwrite: true });
     try {
       bringForward(db, copyPath, "write", "open", { ...stamp, builtAside: true });
     } catch (error) {
@@ -3201,7 +3417,7 @@ function addedRows(merged) {
 }
 function buildMerged(path, parallelPath, other, merge2) {
   vacuumInto(path, parallelPath);
-  const db = new Database5(parallelPath, { readwrite: true });
+  const db = new Database6(parallelPath, { readwrite: true });
   try {
     bringForward(db, parallelPath, "write", "open", { ...merge2.stamp, builtAside: true });
     const merged = mergeInto(db, other, merge2.id, merge2.otherStore, merge2.stamp.now().toISOString());
@@ -3244,7 +3460,7 @@ function mergeStore(options) {
     appliedBy: appliedByName(options.identity ?? readRuntimeIdentity()),
     now: options.now ?? (() => new Date)
   };
-  const mergeId = (options.newMergeId ?? randomUUID4)();
+  const mergeId = (options.newMergeId ?? randomUUID5)();
   const other = openOther(otherPath, otherPlan, mergeStamp);
   try {
     const { built, backupPath } = rebuildAside({
@@ -3371,7 +3587,7 @@ import { appendFile, mkdir, readFile, rm, writeFile } from "fs/promises";
 import { join as join15 } from "path";
 
 // src/commands/instinct/instinct-records.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync5 } from "fs";
 import { join as join14 } from "path";
 
 // src/check/layout.ts
@@ -4024,7 +4240,7 @@ function unreadableIssue(message) {
 function readRecord(path, scope, id) {
   let text;
   try {
-    text = readFileSync8(path, "utf8");
+    text = readFileSync9(path, "utf8");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return { scope, path, id, instinct: null, issues: [unreadableIssue(message)] };
@@ -4725,35 +4941,6 @@ function sessionSpawnEnv(base, binDir = bundledBinDirectory()) {
 }
 
 // src/utils/claude.ts
-async function getClaudeUsagePercent() {
-  const envPct = process.env["CLAUDE_USAGE_PERCENT"];
-  if (envPct !== undefined) {
-    const pct = Number(envPct);
-    return Number.isFinite(pct) ? Math.max(0, Math.min(100, pct)) : null;
-  }
-  return null;
-}
-async function checkUsage(context) {
-  const pct = await getClaudeUsagePercent();
-  if (pct === null)
-    return false;
-  if (context === "task" && pct >= 90) {
-    activeOutput().warn(`
-Claude usage at ${pct.toFixed(0)}% (>=90%). Pausing after current task to avoid hitting the limit.`);
-    return true;
-  }
-  if (pct >= 80) {
-    activeOutput().warn(`
-Claude usage at ${pct.toFixed(0)}% (>=80%). Monitor closely \u2014 tasks may be interrupted.`);
-  } else if (context === "issue" && pct >= 70) {
-    activeOutput().warn(`
-Claude usage at ${pct.toFixed(0)}% (>=70%). Consider whether to start the next issue.`);
-  } else {
-    activeOutput().info(`
-Claude usage: ${pct.toFixed(0)}%`);
-  }
-  return false;
-}
 var CLAUDE_BIN = "claude";
 var CLAUDE_BASE_ARGS = [
   "-p",
@@ -4941,7 +5128,8 @@ var TYPE_MEMBERS = {
   adr: true,
   chore: true,
   "package-api": true,
-  epic: true
+  epic: true,
+  spec: true
 };
 var PRIORITY_MEMBERS = {
   urgent: true,
@@ -4969,7 +5157,8 @@ var GITHUB_LABELS = Object.freeze({
   typePrefix: "type:",
   priorityPrefix: "priority:",
   needsTriage: "needs-triage",
-  blockedByPrefix: "blocked-by:OPT-"
+  blockedByPrefix: "blocked-by:OPT-",
+  specBlocked: "spec:blocked"
 });
 var VIEW_FIELDS = "number,title,body,state,stateReason,labels,url";
 var LIST_COMMAND = "gh issue list";
@@ -5078,7 +5267,8 @@ var DRAFT_CHECKS = [
     "blockedBy",
     (value) => Array.isArray(value) && value.every((item) => Number.isSafeInteger(item) && item > 0),
     "a list of positive whole numbers"
-  ]
+  ],
+  ["specBlocked", (value) => value === undefined || typeof value === "boolean", "absent or a boolean"]
 ];
 function draftProblem(draft) {
   if (!isMapping(draft))
@@ -5092,6 +5282,7 @@ function labelsFor(draft) {
     `${GITHUB_LABELS.modulePrefix}${draft.module}`,
     `${GITHUB_LABELS.typePrefix}${draft.type}`,
     ...draft.blockedBy.map((opt) => `${GITHUB_LABELS.blockedByPrefix}${opt}`),
+    ...draft.specBlocked === true ? [GITHUB_LABELS.specBlocked] : [],
     priority
   ];
 }
@@ -5387,6 +5578,12 @@ function oneOf2(members) {
 function orNull(accepts) {
   return (value) => value === null || accepts(value);
 }
+function orAbsent(accepts) {
+  return (value) => value === undefined || accepts(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
 function listOf(accepts) {
   return (value) => Array.isArray(value) && value.every(accepts);
 }
@@ -5398,6 +5595,7 @@ var FIELD_CHECKS = {
   project: [orNull(isString2), "a string or null"],
   title: [isString2, "a string"],
   blockedBy: [listOf(isFiniteNumber), "a list of numbers"],
+  specBlocked: [orAbsent(isBoolean), "absent or a boolean"],
   state: [oneOf2(ISSUE_STATES), `one of: ${ISSUE_STATES.join(", ")}`],
   fallbackReason: [orNull(isString2), "a string or null"],
   capturedAt: [isString2, "a string"],
@@ -5453,6 +5651,7 @@ function renderLocalIssue(record) {
     project: draft.project,
     title: draft.title,
     blockedBy: draft.blockedBy,
+    ...draft.specBlocked === undefined ? {} : { specBlocked: draft.specBlocked },
     state: record.state,
     fallbackReason: record.fallbackReason,
     capturedAt: record.capturedAt,
@@ -5494,7 +5693,8 @@ function parseLocalIssue(contents, sourcePath) {
       module: fields.module,
       priority: fields.priority,
       project: fields.project,
-      blockedBy: fields.blockedBy
+      blockedBy: fields.blockedBy,
+      ...fields.specBlocked === undefined ? {} : { specBlocked: fields.specBlocked }
     },
     fallbackReason: fields.fallbackReason,
     capturedAt: fields.capturedAt,
@@ -5911,10 +6111,10 @@ function requireTrustedAuthor(item, reading) {
   throw new CommandExit(TRUST_REFUSAL_EXIT, trustRefusalMessage(item, reading));
 }
 // src/effort/sync/wire.ts
-import { existsSync as existsSync14, mkdtempSync as mkdtempSync2, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync14, mkdtempSync as mkdtempSync2, rmSync as rmSync8 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join17 } from "path";
-import { Database as Database6, SQLiteError as SQLiteError3 } from "bun:sqlite";
+import { Database as Database7, SQLiteError as SQLiteError3 } from "bun:sqlite";
 var WIRE_FORMAT = "rafa-effort-wire";
 var WIRE_VERSION = 1;
 
@@ -6076,7 +6276,7 @@ function exportWirePayload(options) {
   guardTestProcess(path);
   if (!existsSync14(path))
     throw new WireExportRefusal(`wire: ${path} is not there`);
-  const db = new Database6(path, { readonly: true, safeIntegers: true });
+  const db = new Database7(path, { readonly: true, safeIntegers: true });
   try {
     db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
     return db.transaction(() => readPayload(db, path, cursor))();
@@ -6115,7 +6315,7 @@ function insertRows(db, table, rows) {
 }
 function buildStore(path, payload, options) {
   const migrations = namedMigrations(payload.migrations, options.migrations ?? SQLITE_MIGRATIONS);
-  const db = new Database6(path, { create: true, readwrite: true });
+  const db = new Database7(path, { create: true, readwrite: true });
   try {
     bringForward(db, path, "write", "open", {
       migrations,
@@ -6134,7 +6334,7 @@ function buildStore(path, payload, options) {
 function materialiseWirePayload(payload, options = {}) {
   const checked = checkPayload(payload);
   const directory = mkdtempSync2(join17(options.tempDir ?? tmpdir4(), "rafa-wire-"));
-  const release = () => rmSync7(directory, { recursive: true, force: true });
+  const release = () => rmSync8(directory, { recursive: true, force: true });
   const path = join17(directory, SQLITE_STORE_FILE_NAME);
   try {
     guardTestProcess(path);
@@ -6163,4 +6363,4 @@ function selectEffortStore(repoRoot, config) {
   return adapter.create({ repoRoot });
 }
 
-export { EFFORT_STORE_DIR, effortStoreFileName, EFFORT_DIR_VARIABLE, effortStoreDir, guardTestProcess, EFFORT_KEY_PROJECTIONS, openNdjsonStore, name, version, RAFA_VERSION, versionLine, createGitRunner, gitSaid, NOT_A_REPOSITORY, mainCheckoutOf, SCOPE_DIR, INIT_COMMAND, DISK_FILE_SYSTEM, ScopeError, scopeAt, initHint, selfAndAncestors, resolveScope, POSITION_FILE, positionFilePath, readPositionFile, writePositionFile, positionAt, rehome, hop, goHome, HOP_FILE, hopFilePath, readHopRecord, writeHopRecord, staleAgainst, SessionRecordError, isSessionId, sessionPhase, SessionConflictError, SessionStateError, runsDir, sessionFilePath, errorCode, isPidAlive, readSessions, readSession, beginSession, updateSession, DEVELOPMENT_NEXT_STEP, DEVELOPMENT_MARK, DevelopmentBuildRefusedError, refuseUnownedDevelopmentWrite, LEGACY_GATE_OPEN, LEGACY_GATE_CLOSED, SQLITE_MIGRATIONS, sqliteCatalogue, planSchema, SchemaRefusedError, readStoreSchema, writeNames, ACROSS_STORES_ORDER, STAMPED_COLUMNS, stampedValues, activeStoreSettings, normalizeRemote, gitRemoteUrl, readStoreMeta, SQLITE_STORE_FILE_NAME, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, RebuildRefusal, readConfigFile, loadConfig, plansDirAt, requireProject, resolvePlansDir, resolveProjectConfig, countTasks, formatCounts, checkbox, planFileName, stubOfPlanFile, isFile, issueLine, plural, expectNoArgument, expectOneArgument, expectAtMostOneArgument, readSwitch, fileStamp, fix_schema_default, EffortCopyRefusal, EffortCopyFailure, copyEffortStore, minutesBetween, readCommitLog, UnionSchemaMismatch, migrateStore, MOVE_TO_SQLITE, MergeRefusal, mergeStore, createFileSync, SyncModuleMissing, selectSync, SKILL_FILE, MARKDOWN_EXTENSION, scanLayout, declaredNameIssue, readFrontmatterDocument, readFrontmatter, renderFrontmatter, mergeFrontmatter, writeFrontmatter, ACTION_HEADING, CAUSE_HEADING, parseInstinct, writeInstinct, readScopes, allRecords, findRecords, instinctProject, toHeldRecords, padKind, oneLine, sessionSpawnEnv, getClaudeUsagePercent, checkUsage, CLAUDE_BIN, claudeArgs, interruptClaudeSessions, spawnClaude, runClaude, spawnClaudeCaptured, runClaudeCaptured, planFilePath, ClaudePlannerError, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_STATES, GITHUB_LABELS, createGhRunner, typeOfLabels, moduleOfLabels, createLocalTracker, PORT_VERSIONS, createAdapterRegistry, CORE_ADAPTER_REGISTRY, TRUSTED_PERMISSIONS, createGhPermissions, readAuthorTrust, ghBoardTrust, readBoardTrust, requireTrustedBoardAuthor, trustRefusalClause, requireTrustedAuthor, WIRE_FORMAT, WIRE_VERSION, WireFormatError, WireExportRefusal, encodeWirePayload, decodeWirePayload, exportWirePayload, materialiseWirePayload, selectEffortStore };
+export { EFFORT_STORE_DIR, effortStoreFileName, EFFORT_DIR_VARIABLE, effortStoreDir, guardTestProcess, EFFORT_KEY_PROJECTIONS, openNdjsonStore, name, version, RAFA_VERSION, versionLine, createGitRunner, gitSaid, NOT_A_REPOSITORY, mainCheckoutOf, SCOPE_DIR, INIT_COMMAND, DISK_FILE_SYSTEM, ScopeError, scopeAt, initHint, selfAndAncestors, resolveScope, POSITION_FILE, positionFilePath, readPositionFile, writePositionFile, positionAt, rehome, hop, goHome, HOP_FILE, hopFilePath, readHopRecord, writeHopRecord, staleAgainst, SessionRecordError, isSessionId, sessionPhase, SessionConflictError, SessionStateError, runsDir, sessionFilePath, errorCode, isPidAlive, readSessions, readSession, beginSession, updateSession, DEVELOPMENT_NEXT_STEP, DEVELOPMENT_MARK, DevelopmentBuildRefusedError, refuseUnownedDevelopmentWrite, LEGACY_GATE_OPEN, LEGACY_GATE_CLOSED, SQLITE_MIGRATIONS, sqliteCatalogue, planSchema, SchemaRefusedError, readStoreSchema, writeNames, ACROSS_STORES_ORDER, STAMPED_COLUMNS, stampedValues, activeStoreSettings, normalizeRemote, gitRemoteUrl, readStoreMeta, SQLITE_STORE_FILE_NAME, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, EffortCopyRefusal, EffortCopyFailure, copyEffortStore, RebuildRefusal, readConfigFile, loadConfig, plansDirAt, requireProject, resolvePlansDir, resolveProjectConfig, countTasks, formatCounts, checkbox, planFileName, stubOfPlanFile, isFile, issueLine, plural, expectNoArgument, expectOneArgument, expectAtMostOneArgument, readSwitch, fileStamp, keepsIdLine, fix_schema_default, minutesBetween, readCommitLog, UnionSchemaMismatch, migrateStore, MOVE_TO_SQLITE, MergeRefusal, mergeStore, createFileSync, SyncModuleMissing, selectSync, SKILL_FILE, MARKDOWN_EXTENSION, scanLayout, declaredNameIssue, readFrontmatterDocument, readFrontmatter, renderFrontmatter, mergeFrontmatter, writeFrontmatter, ACTION_HEADING, CAUSE_HEADING, parseInstinct, writeInstinct, readScopes, allRecords, findRecords, instinctProject, toHeldRecords, EVENT_PREFIX, padKind, oneLine, sessionSpawnEnv, CLAUDE_BIN, claudeArgs, interruptClaudeSessions, spawnClaude, runClaude, spawnClaudeCaptured, runClaudeCaptured, planFilePath, ClaudePlannerError, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_STATES, GITHUB_LABELS, createGhRunner, typeOfLabels, moduleOfLabels, createLocalTracker, PORT_VERSIONS, createAdapterRegistry, CORE_ADAPTER_REGISTRY, TRUSTED_PERMISSIONS, createGhPermissions, readAuthorTrust, ghBoardTrust, readBoardTrust, requireTrustedBoardAuthor, trustRefusalClause, requireTrustedAuthor, WIRE_FORMAT, WIRE_VERSION, WireFormatError, WireExportRefusal, encodeWirePayload, decodeWirePayload, exportWirePayload, materialiseWirePayload, selectEffortStore };