@open-tomato/rafa 0.34.1 → 0.35.0

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

@@ -1,49 +1,43 @@
 // @bun
 import {
-  CONFIG_DEFAULTS,
-  CONFIG_FILE,
-  ConfigError,
-  FINDING_DOMAINS,
-  FINDING_KINDS,
-  FINDING_SIGNALS,
-  activeOutput,
-  activeOutputMode,
-  configFilePath,
-  createTextOutput,
-  hubContextOf,
-  isStampableStub,
-  parseConfigText,
-  readRafaBlocks,
-  resolveConfig
-} from "./index-vp0xghk2.js";
-import {
-  bless,
-  merge
-} from "./index-d6d0942q.js";
-import {
-  CommandExit,
-  commandSpelling
-} from "./index-3mzw3kzh.js";
-import {
-  BUSY_TIMEOUT_MAX_MS,
-  BUSY_TIMEOUT_MIN_MS,
   RAFA_INSTINCTS_PATH,
-  STORE_BACKENDS,
-  SYNC_STRATEGIES,
-  TEST_SCOPES,
   bundledBinDirectory,
+  resolveInstinctScopes,
+  tierExists,
+  TEST_SCOPES,
+  isMapping,
   describeValue,
+  messageOf,
+  STORE_BACKENDS2,
+  SYNC_STRATEGIES2,
+  BUSY_TIMEOUT_MIN_MS,
+  BUSY_TIMEOUT_MAX_MS,
   isBusyTimeoutMs,
   isGitHubLogin,
-  isMapping,
-  messageOf,
-  resolveInstinctScopes,
-  tierExists
-} from "./index-fzhd3d4y.js";
+  hubContextOf,
+  CONFIG_FILE2,
+  CONFIG_DEFAULTS2,
+  ConfigError2,
+  configFilePath2,
+  parseConfigText2,
+  resolveConfig2,
+  isStampableStub,
+  createTextOutput,
+  activeOutput,
+  activeOutputMode,
+  readRafaBlocks2,
+  FINDING_KINDS2,
+  FINDING_SIGNALS2,
+  FINDING_DOMAINS
+} from "./index-2tjmxwvp.js";
 import {
-  actionHash,
-  triggerKey
-} from "./index-wp8c28fd.js";
+  bless2,
+  merge2
+} from "./index-hgcvjke7.js";
+import {
+  actionHash2,
+  triggerKey2
+} from "./index-21jcfatr.js";
 
 // src/adapters/registry.ts
 import { homedir } from "os";
@@ -217,7 +211,7 @@ function guardTestProcess(path, probe = currentProbe()) {
 function keyOrNull(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
-var EFFORT_KEY_PROJECTIONS = {
+var EFFORT_KEY_PROJECTIONS2 = {
   sessions: (row) => keyOrNull(row.sessionId),
   commits: (row) => keyOrNull(row.sha)
 };
@@ -236,13 +230,13 @@ function readKind(repoRoot, kind) {
 }
 function keysOfKind(repoRoot, kind) {
   const path = openedKindPath(repoRoot, kind);
-  return collectedKeys(path, EFFORT_KEY_PROJECTIONS[kind]);
+  return collectedKeys(path, EFFORT_KEY_PROJECTIONS2[kind]);
 }
 function appendKind(repoRoot, kind, rows) {
   const path = openedKindPath(repoRoot, kind);
-  return appendRows(path, rows, EFFORT_KEY_PROJECTIONS[kind]);
+  return appendRows(path, rows, EFFORT_KEY_PROJECTIONS2[kind]);
 }
-function openNdjsonStore(repoRoot) {
+function openNdjsonStore2(repoRoot) {
   return {
     append: (kind, rows) => appendKind(repoRoot, kind, rows),
     keys: (kind) => keysOfKind(repoRoot, kind),
@@ -255,11 +249,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.35.0";
 
 // src/cli/version.ts
 var RAFA_VERSION = version;
@@ -352,36 +346,36 @@ function mainCheckoutOf(dir, seams = {}) {
 }
 
 // src/project/scope.ts
-var SCOPE_DIR = dirname3(CONFIG_FILE);
-var INIT_COMMAND = "rafa init";
-var DISK_FILE_SYSTEM = Object.freeze({
+var SCOPE_DIR2 = dirname3(CONFIG_FILE2);
+var INIT_COMMAND2 = "rafa init";
+var DISK_FILE_SYSTEM2 = Object.freeze({
   exists: (path) => existsSync3(path),
   realpath: (path) => realpathSync2(path)
 });
 
-class ScopeError extends Error {
+class ScopeError2 extends Error {
   constructor(message, options) {
     super(`rafa scope: ${message}`, options);
     this.name = "ScopeError";
   }
 }
-function scopeAt(base) {
-  return { dir: join4(base, SCOPE_DIR), configFile: configFilePath(base) };
+function scopeAt2(base) {
+  return { dir: join4(base, SCOPE_DIR2), configFile: configFilePath2(base) };
 }
-function initHint(start, passedUserConfig = null, probedMainCheckout = null) {
+function initHint2(start, passedUserConfig = null, probedMainCheckout = null) {
   const passed = passedUserConfig === null ? [] : [`${passedUserConfig} is the user scope's config and marks no project`];
   const main = probedMainCheckout === null ? [] : [`nor in ${probedMainCheckout}, the main checkout of the repository holding it`];
   return [
-    `not inside a rafa project: no ${CONFIG_FILE} in ${start} or any directory above it`,
+    `not inside a rafa project: no ${CONFIG_FILE2} in ${start} or any directory above it`,
     ...main,
     ...passed,
-    `run \`${INIT_COMMAND}\` to set one up`
+    `run \`${INIT_COMMAND2}\` to set one up`
   ].join(`
 `);
 }
 function requireAbsolute(label, path) {
   if (!isAbsolute3(path)) {
-    throw new ScopeError(`${label} is ${describeValue(path)}, expected an absolute path`);
+    throw new ScopeError2(`${label} is ${describeValue(path)}, expected an absolute path`);
   }
 }
 function realStartOf(start, fs) {
@@ -389,7 +383,7 @@ function realStartOf(start, fs) {
     return fs.realpath(start);
   } catch (error) {
     const message = `start directory ${start} does not resolve (${messageOf(error)})`;
-    throw new ScopeError(message, { cause: error });
+    throw new ScopeError2(message, { cause: error });
   }
 }
 function realHomeOf(home, fs) {
@@ -399,15 +393,15 @@ function realHomeOf(home, fs) {
     return null;
   }
 }
-function selfAndAncestors(path) {
+function selfAndAncestors2(path) {
   const parent = dirname3(path);
-  return parent === path ? [path] : [path, ...selfAndAncestors(parent)];
+  return parent === path ? [path] : [path, ...selfAndAncestors2(parent)];
 }
 var GIT_MARKER = ".git";
 function walkUp(dirs, realHome, fs, stopAtTopLevel) {
   let passedUserConfig = false;
   for (const dir of dirs) {
-    if (fs.exists(configFilePath(dir))) {
+    if (fs.exists(configFilePath2(dir))) {
       if (dir !== realHome)
         return { root: dir, passedUserConfig, topLevel: null };
       passedUserConfig = true;
@@ -424,39 +418,39 @@ function mainCheckoutAt(realStart, mainCheckout) {
   } catch (error) {
     if (!(error instanceof WorktreeRootError))
       throw error;
-    throw new ScopeError(`cannot read the main checkout of ${realStart} (${error.message})`, { cause: error });
+    throw new ScopeError2(`cannot read the main checkout of ${realStart} (${error.message})`, { cause: error });
   }
 }
 function fallBack(realStart, realHome, fs, mainCheckout) {
   const main = mainCheckoutAt(realStart, mainCheckout);
-  if (main === null || main === realHome || selfAndAncestors(realStart).includes(main)) {
+  if (main === null || main === realHome || selfAndAncestors2(realStart).includes(main)) {
     return { root: null, probed: null };
   }
-  return fs.exists(configFilePath(main)) ? { root: main, probed: main } : { root: null, probed: main };
+  return fs.exists(configFilePath2(main)) ? { root: main, probed: main } : { root: null, probed: main };
 }
 function walkAbove(lower, realHome, fs) {
   if (lower.topLevel === null)
     return lower;
-  const above = selfAndAncestors(lower.topLevel).slice(1);
+  const above = selfAndAncestors2(lower.topLevel).slice(1);
   const upper = walkUp(above, realHome, fs, false);
   return { ...upper, passedUserConfig: lower.passedUserConfig || upper.passedUserConfig };
 }
-function resolveScope(start, seams) {
-  const { home, fs = DISK_FILE_SYSTEM, mainCheckout = mainCheckoutOf } = seams;
+function resolveScope2(start, seams) {
+  const { home, fs = DISK_FILE_SYSTEM2, mainCheckout = mainCheckoutOf } = seams;
   requireAbsolute("start directory", start);
   requireAbsolute("home directory", home);
-  const user = scopeAt(home);
+  const user = scopeAt2(home);
   const realStart = realStartOf(start, fs);
   const realHome = realHomeOf(home, fs);
-  const lower = walkUp(selfAndAncestors(realStart), realHome, fs, true);
+  const lower = walkUp(selfAndAncestors2(realStart), realHome, fs, true);
   const fallback = lower.root === null ? fallBack(realStart, realHome, fs, mainCheckout) : { root: lower.root, probed: null };
   const walk = fallback.root === null ? walkAbove(lower, realHome, fs) : lower;
   const root = fallback.root ?? walk.root;
   if (root === null) {
     const passed = walk.passedUserConfig ? user.configFile : null;
-    return { found: false, start, home, user, hint: initHint(start, passed, fallback.probed) };
+    return { found: false, start, home, user, hint: initHint2(start, passed, fallback.probed) };
   }
-  return { found: true, root, home, project: scopeAt(root), user };
+  return { found: true, root, home, project: scopeAt2(root), user };
 }
 
 // src/loop/session-record-parse.ts
@@ -473,7 +467,7 @@ import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, rmS
 import { dirname as dirname4, join as join5 } from "path";
 var POSITION_FILE = "position.json";
 function positionFilePath(root) {
-  return join5(scopeAt(root).dir, POSITION_FILE);
+  return join5(scopeAt2(root).dir, POSITION_FILE);
 }
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -550,7 +544,7 @@ var HOP_FILE = "hop.json";
 var HOP_KINDS = ["blocker", "dry"];
 var HOP_STATES = ["away", "waiting", "merged", "halted"];
 function hopFilePath(root) {
-  return join6(scopeAt(root).dir, HOP_FILE);
+  return join6(scopeAt2(root).dir, HOP_FILE);
 }
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -696,8 +690,8 @@ function taskProblem(task) {
 function hopProblem(fields) {
   if (!Object.hasOwn(fields, "hop"))
     return null;
-  const hop2 = field(fields, "hop");
-  return asHopRecord(hop2) === null ? `hop is ${describeValue2(hop2)}, expected a hop record` : null;
+  const hop = field(fields, "hop");
+  return asHopRecord(hop) === null ? `hop is ${describeValue2(hop)}, expected a hop record` : null;
 }
 function worktreeProblem(fields) {
   if (!Object.hasOwn(fields, "worktree"))
@@ -799,8 +793,8 @@ function phaseEntry(phase) {
   return isSessionPhase(phase) ? { phase } : {};
 }
 function freezeHop(value) {
-  const hop2 = asHopRecord(value);
-  return Object.freeze({ ...hop2, home: Object.freeze(hop2.home), from: Object.freeze(hop2.from) });
+  const hop = asHopRecord(value);
+  return Object.freeze({ ...hop, home: Object.freeze(hop.home), from: Object.freeze(hop.from) });
 }
 function freezeFailures(failures) {
   return Object.freeze(failures.map((failure) => Object.freeze({ file: failure.file, name: failure.name })));
@@ -824,7 +818,7 @@ function stepsEntry(steps) {
 }
 function freezeRecord(fields) {
   const task = field(fields, "task");
-  const hop2 = field(fields, "hop");
+  const hop = field(fields, "hop");
   const worktree = field(fields, "worktree");
   return Object.freeze({
     sessionId: field(fields, "sessionId"),
@@ -836,7 +830,7 @@ function freezeRecord(fields) {
     state: field(fields, "state"),
     task: isObject(task) ? Object.freeze({ line: field(task, "line"), text: field(task, "text") }) : null,
     ...phaseEntry(field(fields, "phase")),
-    ...hop2 === undefined ? {} : { hop: freezeHop(hop2) },
+    ...hop === undefined ? {} : { hop: freezeHop(hop) },
     ...worktree === undefined ? {} : { worktree },
     ...stepsEntry(field(fields, "steps"))
   });
@@ -887,7 +881,7 @@ class SessionStateError extends Error {
   }
 }
 function runsDir(root) {
-  return join7(scopeAt(root).dir, RUNS_DIR);
+  return join7(scopeAt2(root).dir, RUNS_DIR);
 }
 function sessionFilePath(root, sessionId) {
   if (!isSessionId(sessionId)) {
@@ -937,7 +931,7 @@ function byStart(a, b) {
 function readSessions(root, seams = {}) {
   const dir = runsDir(root);
   const isAlive = seams.isAlive ?? isPidAlive;
-  const records = recordNames(dir).filter((name2) => name2.endsWith(RECORD_EXTENSION)).map((name2) => readRecordFile(join7(dir, name2))).map((record) => Object.freeze({ ...record, state: readState(record, isAlive) }));
+  const records = recordNames(dir).filter((name) => name.endsWith(RECORD_EXTENSION)).map((name) => readRecordFile(join7(dir, name))).map((record) => Object.freeze({ ...record, state: readState(record, isAlive) }));
   return Object.freeze(records.sort(byStart));
 }
 function readSession(root, sessionId, seams = {}) {
@@ -1023,8 +1017,8 @@ function manifestName(file) {
   }
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
     return null;
-  const name2 = parsed["name"];
-  return typeof name2 === "string" ? name2 : null;
+  const name = parsed["name"];
+  return typeof name === "string" ? name : null;
 }
 function nearestRafaPackage(start) {
   let dir = start;
@@ -1069,7 +1063,7 @@ class DevelopmentBuildRefusedError extends Error {
 function storeProjectRoot(path) {
   const storeDir = dirname8(path);
   const scopeDir = dirname8(storeDir);
-  if (basename3(storeDir) !== EFFORT_DIR_NAME || basename3(scopeDir) !== SCOPE_DIR)
+  if (basename3(storeDir) !== EFFORT_DIR_NAME || basename3(scopeDir) !== SCOPE_DIR2)
     return null;
   return dirname8(scopeDir);
 }
@@ -1469,6 +1463,13 @@ 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 <> '');
+  `
   }
 ];
 var SQLITE_SCHEMA_VERSION = SQLITE_MIGRATIONS.length;
@@ -1682,7 +1683,7 @@ function stampedValues(table) {
 
 // src/effort/store/settings.ts
 var DEFAULT_STORE_SETTINGS = Object.freeze({
-  busyTimeoutMs: CONFIG_DEFAULTS.effortBusyTimeoutMs
+  busyTimeoutMs: CONFIG_DEFAULTS2.effortBusyTimeoutMs
 });
 var active = DEFAULT_STORE_SETTINGS;
 function setActiveStoreSettings(settings) {
@@ -1700,13 +1701,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 +1787,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 +1823,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 +1875,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 +1891,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 +1903,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 +1934,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
@@ -1897,7 +2019,7 @@ function refused(index, length, reason) {
   return new Error(`effort store: row ${index} of ${length} ${reason}; batch refused`);
 }
 function batchEntries(kind, rows) {
-  const keyOf = EFFORT_KEY_PROJECTIONS[kind];
+  const keyOf = EFFORT_KEY_PROJECTIONS2[kind];
   const projected = rows.map((row) => ({ key: keyOf(row), row }));
   const keyed = projected.filter(hasKey);
   if (keyed.length < projected.length) {
@@ -1915,7 +2037,7 @@ 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");
@@ -1949,8 +2071,8 @@ function appendKind2(path, kind, rows) {
 function keysOfKind2(path, kind) {
   if (!existsSync5(path))
     return new Set;
-  const { name: name2, keyColumn } = KIND_TABLES[kind];
-  const keys = withSqliteStore(path, "read", false, (db) => db.query(`SELECT ${keyColumn} AS key FROM ${name2} ORDER BY seq`).all());
+  const { name, keyColumn } = KIND_TABLES[kind];
+  const keys = withSqliteStore(path, "read", false, (db) => db.query(`SELECT ${keyColumn} AS key FROM ${name} ORDER BY seq`).all());
   return new Set(keys.map(({ key }) => key));
 }
 function parsedObject(body) {
@@ -1971,11 +2093,11 @@ function rowOf(body, where) {
 function readKind2(path, kind) {
   if (!existsSync5(path))
     return [];
-  const { name: name2 } = KIND_TABLES[kind];
-  const stored = withSqliteStore(path, "read", false, (db) => db.query(`SELECT seq, row_json AS body FROM ${name2} ORDER BY seq`).all());
-  return stored.map(({ seq, body }) => rowOf(body, `${path}: ${name2} row ${seq}`));
+  const { name } = KIND_TABLES[kind];
+  const stored = withSqliteStore(path, "read", false, (db) => db.query(`SELECT seq, row_json AS body FROM ${name} ORDER BY seq`).all());
+  return stored.map(({ seq, body }) => rowOf(body, `${path}: ${name} row ${seq}`));
 }
-function openSqliteStore(repoRoot) {
+function openSqliteStore2(repoRoot) {
   const path = sqliteStorePath(repoRoot);
   return {
     append: (kind, rows) => appendKind2(path, kind, rows),
@@ -1989,28 +2111,241 @@ function openSqliteStore(repoRoot) {
 import { existsSync as existsSync12 } from "fs";
 import { join as join12, resolve as resolve5 } from "path";
 
+// src/cli/spends.ts
+var SPENDS_GLYPH = "\uD83E\uDE99";
+var SPENDS_WHEN = ["always", "with", "unless", "through"];
+var FLAGGED = ["with", "unless"];
+var FLAG_SPELLING = /^--[^\s-]\S*$/;
+function flagProblem(when, flag) {
+  if (FLAGGED.includes(when)) {
+    return typeof flag === "string" && FLAG_SPELLING.test(flag) ? null : `spends.flag is ${describeValue(flag)}, expected a flag as typed, starting with --`;
+  }
+  return flag === undefined ? null : `spends.flag is ${describeValue(flag)}, expected absent when spends.when is "${when}"`;
+}
+function spendsProblem(value) {
+  if (value === undefined)
+    return null;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return `spends is ${describeValue(value)}, expected absent or a mapping`;
+  }
+  const { when, what, flag } = value;
+  if (!SPENDS_WHEN.includes(when)) {
+    return `spends.when is ${describeValue(when)}, expected one of ${SPENDS_WHEN.join(", ")}`;
+  }
+  if (typeof what !== "string") {
+    return `spends.what is ${describeValue(what)}, expected a string`;
+  }
+  return flagProblem(when, flag);
+}
+
+// src/cli/command.ts
+var COMMAND_OUTPUTS = ["text", "json", "events", "tui"];
+var MAX_EXIT_CODE = 255;
+
+class CommandExit extends Error {
+  exitCode;
+  constructor(exitCode, message = "") {
+    super(message);
+    if (!Number.isInteger(exitCode) || exitCode < 0 || exitCode > MAX_EXIT_CODE) {
+      throw new TypeError(`CommandExit: exit code is ${describeValue(exitCode)}, expected a whole number from 0 to ${MAX_EXIT_CODE}`);
+    }
+    this.name = "CommandExit";
+    this.exitCode = exitCode;
+  }
+}
+function isListOf(value, check) {
+  return Array.isArray(value) && value.every(check);
+}
+function hasStrings(value, keys) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const record = value;
+  return keys.every((key) => typeof record[key] === "string");
+}
+function isRoutingWord(value) {
+  return typeof value === "string" && /^[^\s/-][^\s/]*$/.test(value);
+}
+function isFlag(item) {
+  if (!hasStrings(item, ["name"]))
+    return false;
+  const { deprecated } = item;
+  return deprecated === undefined || hasStrings(deprecated, ["use"]);
+}
+function fieldProblem(fields) {
+  const checks = [
+    ["subject", isRoutingWord(fields.subject), "a word with no space, no slash and no leading dash"],
+    ["action", isRoutingWord(fields.action), "a word with no space, no slash and no leading dash"],
+    ["name", typeof fields.name === "string", "a string"],
+    ["summary", typeof fields.summary === "string", "a string"],
+    ["description", typeof fields.description === "string", "a string"],
+    ["args", isListOf(fields.args, (item) => hasStrings(item, ["name"])), "a list of named arguments"],
+    ["flags", isListOf(fields.flags, isFlag), "a list of named flags, each deprecation naming its use"],
+    ["examples", isListOf(fields.examples, (item) => hasStrings(item, ["cmd", "note"])), "a list of examples"],
+    [
+      "outputs",
+      isListOf(fields.outputs, (item) => COMMAND_OUTPUTS.includes(item)),
+      `a list of ${COMMAND_OUTPUTS.join(", ")}`
+    ],
+    [
+      "aliases",
+      fields.aliases === undefined || isListOf(fields.aliases, (item) => typeof item === "string"),
+      "absent or a list of strings"
+    ],
+    [
+      "lastingAliases",
+      fields.lastingAliases === undefined || isListOf(fields.lastingAliases, (item) => typeof item === "string"),
+      "absent or a list of strings"
+    ],
+    [
+      "deprecated",
+      fields.deprecated === undefined || hasStrings(fields.deprecated, ["since", "use"]),
+      "absent or a mapping of since and use"
+    ],
+    ["hidden", fields.hidden === undefined || typeof fields.hidden === "boolean", "absent or a boolean"],
+    [
+      "needsProject",
+      fields.needsProject === undefined || typeof fields.needsProject === "boolean",
+      "absent or a boolean"
+    ],
+    ["exec", fields.exec === undefined || fields.exec === true, "absent or true"],
+    ["run", typeof fields.run === "function", "a function"]
+  ];
+  const failed = checks.find(([, passes]) => !passes);
+  if (failed === undefined)
+    return null;
+  const [key, , expected] = failed;
+  return `${key} is ${describeValue(fields[key])}, expected ${expected}`;
+}
+function commandProblem(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return `a command is ${describeValue(value)}, expected a mapping`;
+  }
+  const fields = value;
+  const problem = fieldProblem(fields) ?? spendsProblem(fields.spends);
+  if (problem === null)
+    return null;
+  const named = isRoutingWord(fields.subject) && isRoutingWord(fields.action) ? `command "${commandSpelling(fields)}"` : "a command";
+  return `${named}: ${problem}`;
+}
+function isTopLevel(command) {
+  return command.subject === command.action;
+}
+function commandSpelling(command) {
+  return isTopLevel(command) ? command.subject : `${command.subject} ${command.action}`;
+}
+
 // 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(name, source, target) {
+  if (name === SQLITE_STORE_FILE_NAME) {
+    vacuumInto(join10(source, name), join10(target, name));
+    return;
+  }
+  copyFileSync(join10(source, name), join10(target, name), constants.COPYFILE_EXCL);
+}
+function undo(target, written, madeDir) {
+  try {
+    if (madeDir === undefined) {
+      for (const name of written)
+        rmSync5(join10(target, name), { 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((name) => existsSync6(join10(source, name)));
+  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 name of files) {
+      written.push(name);
+      copyOne(name, 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";
   }
 }
-function quoted(name2) {
-  return `"${name2.replaceAll('"', '""')}"`;
+function quoted(name) {
+  return `"${name.replaceAll('"', '""')}"`;
 }
 function count(db, sql) {
   return db.query(sql).get()?.n ?? 0;
 }
 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 +2368,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 +2478,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 +2526,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]);
@@ -2152,8 +2544,8 @@ function buildParallel(path, parallelPath, migrations, stamp) {
     db.close();
   }
 }
-function asidePaths(path, version2, stamp) {
-  return { parallelPath: `${path}.fix-${stamp}`, backupPath: `${path}.v${String(version2)}-${stamp}.bak` };
+function asidePaths(path, version, stamp) {
+  return { parallelPath: `${path}.fix-${stamp}`, backupPath: `${path}.v${String(version)}-${stamp}.bak` };
 }
 function isRepairable(reason) {
   return REPAIRABLE_REASONS.includes(reason);
@@ -2171,7 +2563,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);
@@ -2186,8 +2578,8 @@ function fixStoreSchema(options) {
   const plan = planSchema(store, sqliteCatalogue(migrations), "write", "open");
   if (plan.verdict === "use") {
     const pending = writeNames(plan);
-    const status2 = pending.length === 0 ? "current" : "behind";
-    return { ...found, ...nothing, status: status2, reason: null, refusal: null, pending };
+    const status = pending.length === 0 ? "current" : "behind";
+    return { ...found, ...nothing, status, reason: null, refusal: null, pending };
   }
   if (!isRepairable(plan.reason)) {
     throw new RebuildRefusal(`a rebuild at this rafa's migrations does not repair ${plan.reason}. ${plan.message}`);
@@ -2213,24 +2605,24 @@ 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))
+function readConfigFile2(root) {
+  const path = configFilePath2(root);
+  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 });
+    throw new ConfigError2([problem], { cause: error });
   }
-  return parseConfigText(text, path);
+  return parseConfigText2(text, path);
 }
 function isSameDirectory(first, second) {
   try {
@@ -2241,19 +2633,19 @@ function isSameDirectory(first, second) {
 }
 function readUserConfigFile({ root, home }) {
   if (!isAbsolute6(home)) {
-    throw new ConfigError([
+    throw new ConfigError2([
       `home directory is ${describeValue(home)}, expected an absolute path`
     ]);
   }
-  return isSameDirectory(root, home) ? null : readConfigFile(home);
+  return isSameDirectory(root, home) ? null : readConfigFile2(home);
 }
 function printWarning(message) {
   activeOutput().warn(message);
 }
-function loadConfig(roots, cli = {}, warn = printWarning) {
+function loadConfig2(roots, cli = {}, warn = printWarning) {
   const user = readUserConfigFile(roots);
-  const file = readConfigFile(roots.root);
-  const resolved = resolveConfig({ cli, file, user });
+  const file = readConfigFile2(roots.root);
+  const resolved = resolveConfig2({ cli, file, user });
   for (const warning of resolved.warnings)
     warn(warning);
   setActiveStoreSettings({ busyTimeoutMs: resolved.config.effortBusyTimeoutMs });
@@ -2262,7 +2654,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)
@@ -2274,9 +2666,9 @@ function resolvePlansDir(project, command, warn) {
 }
 function resolveProjectConfig(project, command, warn) {
   try {
-    return loadConfig({ root: project.root, home: project.home }, {}, warn).config;
+    return loadConfig2({ root: project.root, home: project.home }, {}, warn).config;
   } catch (error) {
-    if (!(error instanceof ConfigError))
+    if (!(error instanceof ConfigError2))
       throw error;
     throw new CommandExit(1, [
       `\u274C ${command}: the config cannot be used:`,
@@ -2304,18 +2696,18 @@ function checkbox(status) {
 function planFileName(stub, tracker) {
   return tracker ? `PLAN_TRACKER-${stub}.md` : `PLAN-${stub}.md`;
 }
-function stubOfPlanFile(name2) {
-  const stub = /^PLAN-(.+)\.md$/.exec(name2)?.[1];
+function stubOfPlanFile(name) {
+  const stub = /^PLAN-(.+)\.md$/.exec(name)?.[1];
   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}`;
 }
-function plural(count2, noun) {
-  return count2 === 1 ? `${count2} ${noun}` : `${count2} ${noun}s`;
+function plural(count, noun) {
+  return count === 1 ? `${count} ${noun}` : `${count} ${noun}s`;
 }
 function expectNoArgument(args, usage) {
   if (args.length === 0)
@@ -2340,12 +2732,12 @@ function expectAtMostOneArgument(args, usage) {
   throw new CommandExit(1, `\u274C Expected at most one argument, got ${args.length}: ${args.join(" ")}
 Usage: ${usage}`);
 }
-function readSwitch(name2, value, hint) {
+function readSwitch(name, value, hint) {
   if (value === undefined || value === false || value === "false")
     return false;
   if (value === true || value === "true")
     return true;
-  throw new CommandExit(1, `\u274C --${name2} takes no value, and read "${value}" as one. ${hint}`);
+  throw new CommandExit(1, `\u274C --${name} takes no value, and read "${value}" as one. ${hint}`);
 }
 
 // src/commands/effort/fix-schema.ts
@@ -2355,6 +2747,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 +2807,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 +2847,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 +2876,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";
@@ -2593,8 +2899,8 @@ function normaliseBranch(source) {
     return null;
   return source.startsWith("refs/heads/") ? source.slice("refs/heads/".length) : source;
 }
-function parseStatCount(field2) {
-  return /^\d+$/.test(field2) ? Number(field2) : null;
+function parseStatCount(field) {
+  return /^\d+$/.test(field) ? Number(field) : null;
 }
 function parseCommitHeader(line) {
   const parts = line.split(FIELD_SEPARATOR);
@@ -2822,7 +3128,7 @@ function mergedTables() {
   return Object.entries(MERGE_RULES).flatMap(([table, rule]) => rule.scope === "merged" ? [{ table, identity: rule.identity }] : []);
 }
 function carriedColumns(db, table) {
-  return db.query(`PRAGMA table_info(${quoted(table)})`).all().map(({ name: name2 }) => name2).filter((name2) => name2 !== "seq");
+  return db.query(`PRAGMA table_info(${quoted(table)})`).all().map(({ name }) => name).filter((name) => name !== "seq");
 }
 function refuseColumnMismatch(local, other, tables) {
   const faults = tables.flatMap(({ table }) => {
@@ -2913,29 +3219,29 @@ function sameValue(left, right) {
     return Buffer.from(left).equals(right);
   return (left ?? null) === (right ?? null);
 }
-function fillStatement(table, field2) {
-  const statement = SET_ONCE_FILLS[`${table}.${field2}`];
+function fillStatement(table, field) {
+  const statement = SET_ONCE_FILLS[`${table}.${field}`];
   if (statement === undefined) {
-    throw new Error(`${table}.${field2} is set-once in MERGE_RULES and has no statement in SET_ONCE_FILLS`);
+    throw new Error(`${table}.${field} is set-once in MERGE_RULES and has no statement in SET_ONCE_FILLS`);
   }
   return statement;
 }
-function settleSetOnce(local, table, field2, here, there) {
-  const incoming = there[field2] ?? null;
+function settleSetOnce(local, table, field, here, there) {
+  const incoming = there[field] ?? null;
   if (incoming === null)
     return { skipped: true, filled: [], conflictFields: [] };
-  if ((here[field2] ?? null) !== null)
-    return { skipped: false, filled: [], conflictFields: [field2] };
-  local.query(fillStatement(table, field2)).run(incoming, Number(here.seq));
-  return { skipped: true, filled: [field2], conflictFields: [] };
+  if ((here[field] ?? null) !== null)
+    return { skipped: false, filled: [], conflictFields: [field] };
+  local.query(fillStatement(table, field)).run(incoming, Number(here.seq));
+  return { skipped: true, filled: [field], conflictFields: [] };
 }
-function settleRecomputed(table, field2, here, there) {
-  const comparable = RECOMPUTED_COMPARISONS[`${table}.${field2}`];
+function settleRecomputed(table, field, here, there) {
+  const comparable = RECOMPUTED_COMPARISONS[`${table}.${field}`];
   if (comparable === undefined) {
-    throw new Error(`${table}.${field2} is recomputed in MERGE_RULES and has no entry in RECOMPUTED_COMPARISONS`);
+    throw new Error(`${table}.${field} is recomputed in MERGE_RULES and has no entry in RECOMPUTED_COMPARISONS`);
   }
-  const hereValue = here[field2];
-  const thereValue = there[field2];
+  const hereValue = here[field];
+  const thereValue = there[field];
   const same = typeof hereValue === "string" && typeof thereValue === "string" && comparable(hereValue) === comparable(thereValue);
   return same ? { skipped: true, filled: [], conflictFields: [] } : { skipped: false, filled: [], conflictFields: [null] };
 }
@@ -2945,12 +3251,12 @@ function settlePair(local, table, edited, here, there) {
     return { skipped: true, filled: [], conflictFields: [] };
   if (differing.some((column) => !Object.hasOwn(edited, column)))
     return { skipped: false, filled: [], conflictFields: [null] };
-  const outcomes = differing.map((field2) => {
-    if (edited[field2] === SET_ONCE)
-      return settleSetOnce(local, table, field2, here, there);
-    if (edited[field2] === RECOMPUTED)
-      return settleRecomputed(table, field2, here, there);
-    throw new Error(`${table}.${field2} has the rule ${edited[field2]}, which the merge does not apply`);
+  const outcomes = differing.map((field) => {
+    if (edited[field] === SET_ONCE)
+      return settleSetOnce(local, table, field, here, there);
+    if (edited[field] === RECOMPUTED)
+      return settleRecomputed(table, field, here, there);
+    throw new Error(`${table}.${field} has the rule ${edited[field]}, which the merge does not apply`);
   });
   return {
     skipped: outcomes.every((outcome) => outcome.skipped),
@@ -2967,16 +3273,16 @@ function settleTable(local, other, union, trail) {
     const here = rowAt(local, union.table, columns, match.localSeq, "here");
     const there = rowAt(other, union.table, columns, match.incomingSeq, "in the other store");
     const outcome = settlePair(local, union.table, rule.edited, here, there);
-    const conflicts = outcome.conflictFields.map((field2) => {
-      local.query(INSERT_CONFLICT).run(trail.mergeId, union.table, match.localSeq, field2, JSON.stringify(there), trail.recordedAt);
-      return { localSeq: match.localSeq, incomingSeq: match.incomingSeq, field: field2 };
+    const conflicts = outcome.conflictFields.map((field) => {
+      local.query(INSERT_CONFLICT).run(trail.mergeId, union.table, match.localSeq, field, JSON.stringify(there), trail.recordedAt);
+      return { localSeq: match.localSeq, incomingSeq: match.incomingSeq, field };
     });
     return { match, outcome, conflicts };
   });
   return {
     table: union.table,
     skipped: settled.flatMap(({ match, outcome }) => outcome.skipped ? [match.localSeq] : []),
-    filled: settled.flatMap(({ match, outcome }) => outcome.filled.map((field2) => ({ localSeq: match.localSeq, field: field2 }))),
+    filled: settled.flatMap(({ match, outcome }) => outcome.filled.map((field) => ({ localSeq: match.localSeq, field }))),
     conflicts: settled.flatMap(({ conflicts }) => conflicts)
   };
 }
@@ -2986,7 +3292,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 +3320,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 +3404,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 +3426,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 +3452,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) {
@@ -3186,7 +3492,7 @@ function mergeInto(db, other, mergeId, otherStore, mergedAt) {
         collided: union.collided.length
       };
     });
-    const sum = (field2) => tables.reduce((total, entry) => total + entry[field2], 0);
+    const sum = (field) => tables.reduce((total, entry) => total + entry[field], 0);
     const totals = { rowsAdded: sum("added"), rowsSkipped: sum("skipped"), rowsInConflict: sum("inConflict") };
     db.query(INSERT_MERGE).run(mergeId, otherStore, mergedAt, totals.rowsAdded, totals.rowsSkipped, totals.rowsInConflict);
     return { tables, ...totals, gapsRewritten: gaps.length };
@@ -3199,18 +3505,18 @@ function addedRows(merged) {
     merge_conflicts: merged.rowsInConflict
   };
 }
-function buildMerged(path, parallelPath, other, merge2) {
+function buildMerged(path, parallelPath, other, merge) {
   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());
+    bringForward(db, parallelPath, "write", "open", { ...merge.stamp, builtAside: true });
+    const merged = mergeInto(db, other, merge.id, merge.otherStore, merge.stamp.now().toISOString());
     db.run(`ATTACH DATABASE ? AS ${LIVE3}`, [path]);
     const live = new Set(tableNames(db, LIVE3));
     checkedCounts(db, tableNames(db, "main").filter((table) => live.has(table)), LIVE3, addedRows(merged));
     db.run(`DETACH DATABASE ${LIVE3}`);
     refuseCorrupt(db);
-    refuseUnusable(db, parallelPath, merge2.stamp.migrations);
+    refuseUnusable(db, parallelPath, merge.stamp.migrations);
     return merged;
   } finally {
     db.close();
@@ -3233,7 +3539,7 @@ function refuseUnmergeable(options, migrations) {
   }
   return { otherPlan, otherStore };
 }
-function mergeStore(options) {
+function mergeStore2(options) {
   const { path, otherPath, dryRun, stamp } = options;
   guardTestProcess(path);
   guardTestProcess(otherPath);
@@ -3244,7 +3550,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({
@@ -3268,10 +3574,10 @@ var NOTHING_COPIED = "Nothing was copied.";
 class FileSyncRefusal extends Error {
   name = "FileSyncRefusal";
 }
-function requirePath(field2, value) {
+function requirePath(field, value) {
   if (typeof value === "string" && value !== "")
     return value;
-  throw new TypeError(`${REFUSAL}: ${field2} is ${describeValue(value)}, expected a path`);
+  throw new TypeError(`${REFUSAL}: ${field} is ${describeValue(value)}, expected a path`);
 }
 function refuseUncarriable(backend, source) {
   if (backend === "ndjson") {
@@ -3301,8 +3607,8 @@ function createFileSync(options) {
     const otherPath = resolve5(repoRoot, requirePath("from", from));
     const path = join12(storeDir(), SQLITE_STORE_FILE_NAME);
     const stamp = fileStamp(now());
-    const merge2 = mergeStore({ ...mergeSeams(options), path, otherPath, backend, dryRun, stamp, now, sessionId });
-    return Object.freeze({ status: "pulled", merge: merge2 });
+    const merge = mergeStore2({ ...mergeSeams(options), path, otherPath, backend, dryRun, stamp, now, sessionId });
+    return Object.freeze({ status: "pulled", merge });
   };
   return Object.freeze({ kind: "file", push, pull });
 }
@@ -3353,7 +3659,7 @@ function contextOf(repoRoot, config) {
     ...hub === undefined ? {} : { hub }
   };
 }
-function selectSync(repoRoot, config, registry = CORE_ADAPTER_REGISTRY) {
+function selectSync(repoRoot, config, registry = CORE_ADAPTER_REGISTRY2) {
   const kind = config.effortSync;
   const adapter = typeof kind === "string" ? registry.find("sync", kind) : undefined;
   if (adapter !== undefined)
@@ -3361,8 +3667,8 @@ function selectSync(repoRoot, config, registry = CORE_ADAPTER_REGISTRY) {
   const registered = registry.kinds("sync");
   if (isModuleStrategy(kind))
     throw new SyncModuleMissing(kind, registered);
-  const known = SYNC_STRATEGIES.includes(kind);
-  const expected = known ? `registered: ${listed(registered)}` : `expected one of: ${SYNC_STRATEGIES.join(", ")}`;
+  const known = SYNC_STRATEGIES2.includes(kind);
+  const expected = known ? `registered: ${listed(registered)}` : `expected one of: ${SYNC_STRATEGIES2.join(", ")}`;
   throw new TypeError(`${REFUSAL2}: effort.sync is ${describeValue(kind)}, and no sync adapter is registered under it; ${expected}`);
 }
 
@@ -3371,13 +3677,13 @@ 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
 import { readdirSync as readdirSync3, statSync as statSync4 } from "fs";
 import { join as join13, relative as relative2 } from "path";
-var SKILL_FILE = "SKILL.md";
+var SKILL_FILE2 = "SKILL.md";
 var MARKDOWN_EXTENSION = ".md";
 var LAYOUT_SEVERITY = Object.freeze({
   "flat-grouped-layout": "failure",
@@ -3405,13 +3711,13 @@ function entryKind(path) {
   }
 }
 function visibleNames(dir) {
-  return readdirSync3(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
+  return readdirSync3(dir).filter((name) => !name.startsWith(".")).sort((left, right) => left.localeCompare(right));
 }
-function isMarkdown(name2) {
-  return name2.endsWith(MARKDOWN_EXTENSION);
+function isMarkdown(name) {
+  return name.endsWith(MARKDOWN_EXTENSION);
 }
-function markdownStem(name2) {
-  return name2.slice(0, -MARKDOWN_EXTENSION.length);
+function markdownStem(name) {
+  return name.slice(0, -MARKDOWN_EXTENSION.length);
 }
 function shown(root, path) {
   return relative2(root, path) || ".";
@@ -3436,37 +3742,37 @@ function unreadableEntry(kind, root, path) {
     issues: [layoutIssue("unreadable-entry", `${shown(root, path)} cannot be read (a broken symlink, or a path stat refuses)`)]
   };
 }
-function skillFileEntry(path, name2) {
-  return { kind: "skill", path, isFile: true, shape: "skill-file", name: name2, issues: [] };
+function skillFileEntry(path, name) {
+  return { kind: "skill", path, isFile: true, shape: "skill-file", name, issues: [] };
 }
-function flatGroupedEntry(root, path, name2) {
+function flatGroupedEntry(root, path, name) {
   return {
     kind: "skill",
     path,
     isFile: true,
     shape: "flat-grouped",
-    name: name2,
-    issues: [layoutIssue("flat-grouped-layout", `${shown(root, path)} is the flat grouped layout <dir>/<group>/<name>.md,` + ` which does not register; move it to <dir>/${name2}/${SKILL_FILE}`)]
+    name,
+    issues: [layoutIssue("flat-grouped-layout", `${shown(root, path)} is the flat grouped layout <dir>/<group>/<name>.md,` + ` which does not register; move it to <dir>/${name}/${SKILL_FILE2}`)]
   };
 }
-function nestedGroupEntry(root, path, name2) {
+function nestedGroupEntry(root, path, name) {
   return {
     kind: "skill",
     path,
     isFile: true,
     shape: "nested-group",
-    name: name2,
-    issues: [layoutIssue("nested-group-layout", `${shown(root, path)} is the nested layout <dir>/<group>/<name>/${SKILL_FILE},` + ` which does not register; move it to <dir>/${name2}/${SKILL_FILE}`)]
+    name,
+    issues: [layoutIssue("nested-group-layout", `${shown(root, path)} is the nested layout <dir>/<group>/<name>/${SKILL_FILE2},` + ` which does not register; move it to <dir>/${name}/${SKILL_FILE2}`)]
   };
 }
-function looseFileEntry(root, path, name2) {
+function looseFileEntry(root, path, name) {
   return {
     kind: "skill",
     path,
     isFile: true,
     shape: "loose-file",
-    name: name2,
-    issues: [layoutIssue("loose-file", `${shown(root, path)} sits directly under the skills directory, which registers` + ` only <dir>/<name>/${SKILL_FILE}; move it to <dir>/${name2}/${SKILL_FILE}`)]
+    name,
+    issues: [layoutIssue("loose-file", `${shown(root, path)} sits directly under the skills directory, which registers` + ` only <dir>/<name>/${SKILL_FILE2}; move it to <dir>/${name}/${SKILL_FILE2}`)]
   };
 }
 function noSkillFileEntry(root, dir) {
@@ -3476,26 +3782,26 @@ function noSkillFileEntry(root, dir) {
     isFile: false,
     shape: "no-skill-file",
     name: null,
-    issues: [layoutIssue("missing-skill-file", `${shown(root, dir)}/ holds no ${SKILL_FILE}, so it registers no skill`)]
+    issues: [layoutIssue("missing-skill-file", `${shown(root, dir)}/ holds no ${SKILL_FILE2}, so it registers no skill`)]
   };
 }
-function nestedInstinctEntry(root, path, name2) {
+function nestedInstinctEntry(root, path, name) {
   return {
     kind: "instinct",
     path,
     isFile: true,
     shape: "nested-instinct",
-    name: name2,
-    issues: [layoutIssue("nested-instinct-file", `${shown(root, path)} sits below the instincts directory, which is flat;` + ` move it to <dir>/${name2}${MARKDOWN_EXTENSION}`)]
+    name,
+    issues: [layoutIssue("nested-instinct-file", `${shown(root, path)} sits below the instincts directory, which is flat;` + ` move it to <dir>/${name}${MARKDOWN_EXTENSION}`)]
   };
 }
-function scanGroupMember(root, dir, name2) {
+function scanGroupMember(root, dir, name) {
   const children = visibleNames(dir);
   if (children.length === 0)
     return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join13(dir, SKILL_FILE);
-  if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
-    return [nestedGroupEntry(root, skillPath, name2)];
+  const skillPath = join13(dir, SKILL_FILE2);
+  if (children.includes(SKILL_FILE2) && entryKind(skillPath) === "file") {
+    return [nestedGroupEntry(root, skillPath, name)];
   }
   return [noSkillFileEntry(root, dir)];
 }
@@ -3519,31 +3825,31 @@ function scanSkillGroup(root, dir, children) {
     return [noSkillFileEntry(root, dir)];
   return entries;
 }
-function scanSkillDirectory(root, dir, name2) {
+function scanSkillDirectory(root, dir, name) {
   const children = visibleNames(dir);
   if (children.length === 0)
     return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join13(dir, SKILL_FILE);
-  if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
-    return [skillFileEntry(skillPath, name2)];
+  const skillPath = join13(dir, SKILL_FILE2);
+  if (children.includes(SKILL_FILE2) && entryKind(skillPath) === "file") {
+    return [skillFileEntry(skillPath, name)];
   }
   return scanSkillGroup(root, dir, children);
 }
 function scanSkillRoot(root) {
   const entries = [];
-  for (const name2 of visibleNames(root)) {
-    const path = join13(root, name2);
+  for (const name of visibleNames(root)) {
+    const path = join13(root, name);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("skill", root, path));
       continue;
     }
     if (found === "directory") {
-      entries.push(...scanSkillDirectory(root, path, name2));
+      entries.push(...scanSkillDirectory(root, path, name));
       continue;
     }
-    if (isMarkdown(name2))
-      entries.push(looseFileEntry(root, path, markdownStem(name2)));
+    if (isMarkdown(name))
+      entries.push(looseFileEntry(root, path, markdownStem(name)));
   }
   return entries;
 }
@@ -3570,8 +3876,8 @@ function scanInstinctSubdirectory(root, dir) {
 }
 function scanInstinctRoot(root) {
   const entries = [];
-  for (const name2 of visibleNames(root)) {
-    const path = join13(root, name2);
+  for (const name of visibleNames(root)) {
+    const path = join13(root, name);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("instinct", root, path));
@@ -3581,14 +3887,14 @@ function scanInstinctRoot(root) {
       entries.push(...scanInstinctSubdirectory(root, path));
       continue;
     }
-    if (!isMarkdown(name2))
+    if (!isMarkdown(name))
       continue;
     entries.push({
       kind: "instinct",
       path,
       isFile: true,
       shape: "instinct-file",
-      name: markdownStem(name2),
+      name: markdownStem(name),
       issues: []
     });
   }
@@ -3608,9 +3914,9 @@ function scanLayout(root, kind) {
 function declaredNameIssue(entry, declared) {
   if (entry.name === null || declared === null || declared === entry.name)
     return null;
-  const field2 = entry.kind === "skill" ? "name" : "id";
+  const field = entry.kind === "skill" ? "name" : "id";
   const source = entry.kind === "skill" ? "directory name" : "file name";
-  return layoutIssue("name-mismatch", `frontmatter ${field2} "${declared}" is not the ${source} "${entry.name}"`);
+  return layoutIssue("name-mismatch", `frontmatter ${field} "${declared}" is not the ${source} "${entry.name}"`);
 }
 
 // src/schema/frontmatter.ts
@@ -3699,8 +4005,8 @@ function writeFrontmatter(document, data) {
 }
 
 // src/schema/instinct.ts
-var INSTINCT_KINDS = FINDING_KINDS;
-var INSTINCT_SIGNALS = FINDING_SIGNALS;
+var INSTINCT_KINDS = FINDING_KINDS2;
+var INSTINCT_SIGNALS = FINDING_SIGNALS2;
 var INSTINCT_DOMAINS = FINDING_DOMAINS;
 var INSTINCT_SCOPES = ["project", "user"];
 var INSTINCT_SOURCES = ["task-report", "loop-observed", "imported", "demoted"];
@@ -3730,8 +4036,8 @@ var INSTINCT_KEY_ORDER = [
   "created_at",
   "updated_at"
 ];
-function issue(code, field2, message) {
-  return { code, field: field2, message };
+function issue(code, field, message) {
+  return { code, field, message };
 }
 function typeName(value) {
   if (value === null)
@@ -3746,25 +4052,25 @@ function typeName(value) {
     return "a number";
   return `a ${typeof value}`;
 }
-function requiredString(data, field2) {
-  const value = data[field2];
+function requiredString(data, field) {
+  const value = data[field];
   if (value === undefined || value === null) {
-    return [issue("missing-field", field2, `${field2} is required and is absent`)];
+    return [issue("missing-field", field, `${field} is required and is absent`)];
   }
   if (typeof value !== "string") {
-    return [issue("wrong-type", field2, `${field2} must be a string, not ${typeName(value)}`)];
+    return [issue("wrong-type", field, `${field} must be a string, not ${typeName(value)}`)];
   }
   if (value.trim() === "") {
-    return [issue("missing-field", field2, `${field2} is required and is empty`)];
+    return [issue("missing-field", field, `${field} is required and is empty`)];
   }
   return [];
 }
-function requiredChoice(data, field2, allowed, code) {
-  const issues = requiredString(data, field2);
+function requiredChoice(data, field, allowed, code) {
+  const issues = requiredString(data, field);
   if (issues.length > 0)
     return issues;
-  const value = data[field2];
-  return allowed.includes(value) ? [] : [issue(code, field2, `${field2} "${value}" is not one of ${allowed.join(", ")}`)];
+  const value = data[field];
+  return allowed.includes(value) ? [] : [issue(code, field, `${field} "${value}" is not one of ${allowed.join(", ")}`)];
 }
 function checkId(data) {
   const issues = requiredString(data, "id");
@@ -3800,11 +4106,11 @@ function checkSources(data) {
     return [issue("wrong-type", "sources", `sources must be a list, not ${typeName(value)}`)];
   }
   return value.flatMap((entry, index) => {
-    const field2 = `sources[${index}]`;
+    const field = `sources[${index}]`;
     if (typeof entry !== "string") {
-      return [issue("wrong-type", field2, `sources entries must be strings, and this one is ${typeName(entry)}`)];
+      return [issue("wrong-type", field, `sources entries must be strings, and this one is ${typeName(entry)}`)];
     }
-    return entry.trim() === "" ? [issue("wrong-type", field2, "sources entries must name a source, and this one is blank")] : [];
+    return entry.trim() === "" ? [issue("wrong-type", field, "sources entries must name a source, and this one is blank")] : [];
   });
 }
 function checkPromotedTo(data) {
@@ -3833,26 +4139,26 @@ function checkProjectId(data) {
   }
   return PROJECT_ID_PATTERN.test(value) ? [] : [issue("invalid-project-id", "project_id", `project_id "${value}" is not ${PROJECT_ID_LENGTH} lowercase hex characters`)];
 }
-function checkTimestamp(data, field2) {
-  const issues = requiredString(data, field2);
+function checkTimestamp(data, field) {
+  const issues = requiredString(data, field);
   if (issues.length > 0)
     return issues;
-  const value = data[field2];
-  return TIMESTAMP_PATTERN.test(value) && !Number.isNaN(Date.parse(value)) ? [] : [issue("invalid-timestamp", field2, `${field2} "${value}" is not an ISO 8601 instant such as 2026-09-11T10:00:00Z`)];
+  const value = data[field];
+  return TIMESTAMP_PATTERN.test(value) && !Number.isNaN(Date.parse(value)) ? [] : [issue("invalid-timestamp", field, `${field} "${value}" is not an ISO 8601 instant such as 2026-09-11T10:00:00Z`)];
 }
 function isScalar(value) {
   return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 }
 function checkEvidenceEntry(entry, index) {
-  const field2 = `evidence[${index}]`;
+  const field = `evidence[${index}]`;
   if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-    return [issue("wrong-type", field2, `evidence entries must be mappings, and this one is ${typeName(entry)}`)];
+    return [issue("wrong-type", field, `evidence entries must be mappings, and this one is ${typeName(entry)}`)];
   }
   const entries = Object.entries(entry);
   if (entries.length === 0) {
-    return [issue("wrong-type", field2, "evidence entries must say something, and this one is empty")];
+    return [issue("wrong-type", field, "evidence entries must say something, and this one is empty")];
   }
-  return entries.flatMap(([key, value]) => isScalar(value) ? [] : [issue("wrong-type", `${field2}.${key}`, `evidence values must be text, numbers or booleans, and this one is ${typeName(value)}`)]);
+  return entries.flatMap(([key, value]) => isScalar(value) ? [] : [issue("wrong-type", `${field}.${key}`, `evidence values must be text, numbers or booleans, and this one is ${typeName(value)}`)]);
 }
 function checkEvidence(data) {
   const value = data["evidence"];
@@ -3965,7 +4271,7 @@ function buildInstinct(data, body) {
     updatedAt: data["updated_at"],
     action,
     cause: sectionText(body, CAUSE_HEADING) ?? "",
-    actionHash: actionHash(action)
+    actionHash: actionHash2(action)
   };
 }
 function instinctFrontmatter(instinct) {
@@ -4012,11 +4318,11 @@ function writeInstinct(instinct, newline = `
 }
 
 // src/commands/instinct/instinct-records.ts
-function isRecordFile(name2) {
-  return !name2.startsWith(".") && name2.endsWith(MARKDOWN_EXTENSION) && name2 !== MARKDOWN_EXTENSION;
+function isRecordFile(name) {
+  return !name.startsWith(".") && name.endsWith(MARKDOWN_EXTENSION) && name !== MARKDOWN_EXTENSION;
 }
-function recordId(name2) {
-  return name2.slice(0, -MARKDOWN_EXTENSION.length);
+function recordId(name) {
+  return name.slice(0, -MARKDOWN_EXTENSION.length);
 }
 function unreadableIssue(message) {
   return { code: "missing-frontmatter", field: "file", message: `the file could not be read: ${message}` };
@@ -4024,7 +4330,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)] };
@@ -4040,7 +4346,7 @@ function isFile2(path) {
   }
 }
 function recordFiles(dir) {
-  return readdirSync4(dir).filter((name2) => isRecordFile(name2) && isFile2(join14(dir, name2))).sort((left, right) => left.localeCompare(right));
+  return readdirSync4(dir).filter((name) => isRecordFile(name) && isFile2(join14(dir, name))).sort((left, right) => left.localeCompare(right));
 }
 function readScope(scope, dir) {
   if (!tierExists(dir))
@@ -4049,7 +4355,7 @@ function readScope(scope, dir) {
     scope,
     dir,
     exists: true,
-    records: recordFiles(dir).map((name2) => readRecord(join14(dir, name2), scope, recordId(name2)))
+    records: recordFiles(dir).map((name) => readRecord(join14(dir, name), scope, recordId(name)))
   };
 }
 function readScopes(seams) {
@@ -4061,9 +4367,9 @@ function allRecords(listings) {
 function findRecords(listings, id) {
   return allRecords(listings).filter((entry) => entry.id === id);
 }
-function instinctProject(context, name2) {
+function instinctProject(context, name) {
   if (context.project === null)
-    throw new Error(`${name2} runs inside a project, and was handed none`);
+    throw new Error(`${name} runs inside a project, and was handed none`);
   return context.project;
 }
 
@@ -4100,17 +4406,17 @@ function toHeldRecord(instinct) {
 function toHeldRecords(held) {
   const actions = new Map;
   for (const instinct of held) {
-    const key = triggerKey(instinct.trigger);
+    const key = triggerKey2(instinct.trigger);
     actions.set(key, (actions.get(key) ?? new Set).add(instinct.actionHash));
   }
   return held.map((instinct) => {
     const record = toHeldRecord(instinct);
-    return actions.get(triggerKey(instinct.trigger)).size > 1 ? { ...record, status: "flagged" } : record;
+    return actions.get(triggerKey2(instinct.trigger)).size > 1 ? { ...record, status: "flagged" } : record;
   });
 }
 function earliestHeldMember(record, held) {
-  const key = triggerKey(record.trigger);
-  const members = held.filter((instinct) => instinct.actionHash === record.action_hash && triggerKey(instinct.trigger) === key);
+  const key = triggerKey2(record.trigger);
+  const members = held.filter((instinct) => instinct.actionHash === record.action_hash && triggerKey2(instinct.trigger) === key);
   return [...members].sort(byAge)[0] ?? null;
 }
 function toHeldInstinct(record, held, fallback) {
@@ -4137,7 +4443,7 @@ function toHeldInstinct(record, held, fallback) {
     updatedAt: record.updated_at,
     action: record.action,
     cause: description.cause,
-    actionHash: actionHash(record.action)
+    actionHash: actionHash2(record.action)
   };
 }
 
@@ -4219,7 +4525,7 @@ function recordProblem(record, index) {
   if (problem !== null)
     return problem;
   const { action, action_hash: hash, description } = record;
-  if (hash !== actionHash(action)) {
+  if (hash !== actionHash2(action)) {
     return `action_hash is ${describeValue(hash)} in ${at}, expected the sha256 of its trimmed, lower-cased action`;
   }
   return description === undefined ? null : fieldsProblem(description, DESCRIPTION_CHECKS, `${at}.description`);
@@ -4231,7 +4537,7 @@ function payloadProblem(payload) {
   const { instincts } = payload;
   return instincts.map(recordProblem).find((found) => found !== null) ?? null;
 }
-function flagProblem(value) {
+function flagProblem2(value) {
   return fieldsProblem(value, FLAG_CHECKS, "the flag");
 }
 function copyInstinct(record) {
@@ -4308,9 +4614,9 @@ function unflagged(records, flagged) {
   return records.filter((record) => !flagged.has(record.id));
 }
 function userAdditions(userBlessed, projectHeld, flagged) {
-  const heldTriggers = new Set(projectHeld.map((record) => triggerKey(record.trigger)));
+  const heldTriggers = new Set(projectHeld.map((record) => triggerKey2(record.trigger)));
   const heldIds = new Set(projectHeld.map((record) => record.id));
-  return unflagged(userBlessed, flagged).filter((record) => !heldTriggers.has(triggerKey(record.trigger)) && !heldIds.has(record.id));
+  return unflagged(userBlessed, flagged).filter((record) => !heldTriggers.has(triggerKey2(record.trigger)) && !heldIds.has(record.id));
 }
 function byAge2(left, right) {
   if (left.created_at !== right.created_at) {
@@ -4321,8 +4627,8 @@ function byAge2(left, right) {
   return left.id < right.id ? -1 : 1;
 }
 function payloadDescription(record, described) {
-  const key = triggerKey(record.trigger);
-  const members = described.filter((candidate) => candidate.description !== undefined && candidate.action_hash === record.action_hash && triggerKey(candidate.trigger) === key);
+  const key = triggerKey2(record.trigger);
+  const members = described.filter((candidate) => candidate.description !== undefined && candidate.action_hash === record.action_hash && triggerKey2(candidate.trigger) === key);
   return [...members].sort(byAge2)[0]?.description;
 }
 function producedRecords(result) {
@@ -4348,35 +4654,35 @@ function heldChanges(dir, held, result, described) {
       throw new Error(`${PUSH_REFUSAL}: ${file} has no held member and no payload description to be written with`);
     }
     const text = writeInstinct(instinct);
-    const [issue2] = parseInstinct(text).issues;
-    if (issue2 !== undefined) {
-      throw new Error(`${PUSH_REFUSAL}: ${file} would not read back: ${issue2.field}: ${issue2.message}`);
+    const [issue] = parseInstinct(text).issues;
+    if (issue !== undefined) {
+      throw new Error(`${PUSH_REFUSAL}: ${file} would not read back: ${issue.field}: ${issue.message}`);
     }
     const path = join15(dir, file);
     if (held.unreadable.has(path)) {
       throw new Error(`${PUSH_REFUSAL}: it would overwrite ${path}, which could not be read`);
     }
     const before = heldAt.get(path);
-    if (before !== undefined && triggerKey(before.trigger) !== triggerKey(record.trigger)) {
+    if (before !== undefined && triggerKey2(before.trigger) !== triggerKey2(record.trigger)) {
       throw new Error(`${PUSH_REFUSAL}: it would overwrite ${path}, which holds another trigger`);
     }
     kept.add(path);
     if (before === undefined || writeInstinct(before) !== text)
       writes.push({ path, text });
   }
-  const touched = new Set(result.decisions.map((decision) => triggerKey(decision.incoming.trigger)));
-  const removals = held.files.filter((file) => touched.has(triggerKey(file.instinct.trigger)) && !kept.has(file.path)).map((file) => file.path);
+  const touched = new Set(result.decisions.map((decision) => triggerKey2(decision.incoming.trigger)));
+  const removals = held.files.filter((file) => touched.has(triggerKey2(file.instinct.trigger)) && !kept.has(file.path)).map((file) => file.path);
   return { writes, removals };
 }
 function pushLogLines(sourceId, described, result) {
   return result.decisions.map((decision, index) => {
-    const key = triggerKey(decision.incoming.trigger);
+    const key = triggerKey2(decision.incoming.trigger);
     const line = {
       source_id: sourceId,
       rule: decision.rule,
       incoming: loggedIncoming(described[index]),
       produced: decision.produced.map((record) => record.id),
-      discarded: result.discarded.filter((record) => triggerKey(record.trigger) === key).map((record) => record.id)
+      discarded: result.discarded.filter((record) => triggerKey2(record.trigger) === key).map((record) => record.id)
     };
     return JSON.stringify(line);
   });
@@ -4401,7 +4707,7 @@ function createLocalLearning(options) {
     for (const entry of records) {
       if (entry.instinct === null) {
         unreadable.add(entry.path);
-        const problems = entry.issues.map((issue2) => `${issue2.field}: ${issue2.message}`).join("; ");
+        const problems = entry.issues.map((issue) => `${issue.field}: ${issue.message}`).join("; ");
         warn(`${PREFIX}: ${entry.path} is not a held instinct, so it was skipped: ${problems}`);
       } else {
         files.push({ path: entry.path, instinct: entry.instinct });
@@ -4418,7 +4724,7 @@ function createLocalLearning(options) {
   async function flaggedIds() {
     const lines = numberedLines(await readIfPresent(flagsPath));
     return new Set(lines.map(([number, line]) => {
-      const reading = readLine(line, flagProblem);
+      const reading = readLine(line, flagProblem2);
       if (reading.ok)
         return reading.value.id;
       throw new Error(`${PREFIX}: line ${number} of ${flagsPath} is not a flag,` + ` and a bundle skipping it could hold an instinct it flags: ${reading.problem}`);
@@ -4432,7 +4738,7 @@ function createLocalLearning(options) {
       }
       const described = payload.instincts;
       const held = heldSet();
-      const result = merge(toHeldRecords(held.files.map((file) => file.instinct)), { source_id: payload.source_id, instincts: described.map(copyInstinct) }, now());
+      const result = merge2(toHeldRecords(held.files.map((file) => file.instinct)), { source_id: payload.source_id, instincts: described.map(copyInstinct) }, now());
       const changes = heldChanges(instinctsDir, held, result, described);
       const lines = pushLogLines(payload.source_id, described, result);
       if (lines.length > 0) {
@@ -4450,13 +4756,13 @@ function createLocalLearning(options) {
     pullBlessed: async () => {
       const flagged = await flaggedIds();
       const projectHeld = heldRecords(heldSet());
-      const project = bless(unflagged(projectHeld, flagged), { minConfidence }).instincts;
-      const user = bless(heldRecords(readHeld("user", userDir)), { minConfidence }).instincts;
+      const project = bless2(unflagged(projectHeld, flagged), { minConfidence }).instincts;
+      const user = bless2(heldRecords(readHeld("user", userDir)), { minConfidence }).instincts;
       return { version: now(), instincts: [...project, ...userAdditions(user, projectHeld, flagged)] };
     },
     flag: async (id, reason) => {
       const flag = { id, reason, flagged_at: now() };
-      const problem = flagProblem(flag);
+      const problem = flagProblem2(flag);
       if (problem !== null) {
         throw new TypeError(`${PREFIX}: refused to write an invalid flag: ${problem}`);
       }
@@ -4576,8 +4882,8 @@ function describeValue3(value) {
 function messageOf2(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function counted(count2, noun) {
-  return count2 === 1 ? `1 ${noun}` : `${String(count2)} ${noun}s`;
+function counted(count, noun) {
+  return count === 1 ? `1 ${noun}` : `${String(count)} ${noun}s`;
 }
 function valueAt(mapping, key) {
   return Object.hasOwn(mapping, key) ? mapping[key] ?? null : null;
@@ -4595,39 +4901,39 @@ function verdictOf(value) {
   const word = spelled.replace(VERDICT_BREAK, "-");
   return SPEC_REVIEW_VERDICTS.includes(word) ? word : null;
 }
-function issueAt(field2, text) {
-  return { field: field2, text };
+function issueAt(field, text) {
+  return { field, text };
 }
-function readBlocking(item, field2, issues) {
+function readBlocking(item, field, issues) {
   const value = valueAt(item, "blocking");
   if (typeof value === "boolean")
     return value;
-  const text = `${field2}.blocking is ${describeValue3(value)}, not true or false; ` + "the gap is read as blocking";
-  issues.push(issueAt(`${field2}.blocking`, text));
+  const text = `${field}.blocking is ${describeValue3(value)}, not true or false; ` + "the gap is read as blocking";
+  issues.push(issueAt(`${field}.blocking`, text));
   return true;
 }
-function readGap(item, field2, issues) {
+function readGap(item, field, issues) {
   if (!isMapping2(item)) {
-    const text = `${field2} is ${describeValue3(item)}, not a mapping of heading and what; dropped`;
-    issues.push(issueAt(field2, text));
+    const text = `${field} is ${describeValue3(item)}, not a mapping of heading and what; dropped`;
+    issues.push(issueAt(field, text));
     return null;
   }
   const what = stringAt(item, "what");
   if (what === null) {
-    const text = `${field2}.what is ${describeValue3(valueAt(item, "what"))}, ` + "not a sentence; the gap is dropped";
-    issues.push(issueAt(`${field2}.what`, text));
+    const text = `${field}.what is ${describeValue3(valueAt(item, "what"))}, ` + "not a sentence; the gap is dropped";
+    issues.push(issueAt(`${field}.what`, text));
     return null;
   }
   const heading = stringAt(item, "heading");
   if (heading === null) {
-    const text = `${field2}.heading is ${describeValue3(valueAt(item, "heading"))}, ` + `not a heading; the gap is filed under ${REVIEW_HEADING}`;
-    issues.push(issueAt(`${field2}.heading`, text));
+    const text = `${field}.heading is ${describeValue3(valueAt(item, "heading"))}, ` + `not a heading; the gap is filed under ${REVIEW_HEADING}`;
+    issues.push(issueAt(`${field}.heading`, text));
   }
-  const blocking = readBlocking(item, field2, issues);
+  const blocking = readBlocking(item, field, issues);
   const assumption = stringAt(item, "assumption");
   if (!blocking && assumption === null) {
-    const text = `${field2}.assumption is ${describeValue3(valueAt(item, "assumption"))}, ` + "not what a non-blocking gap would be planned under; the gap is read as blocking";
-    issues.push(issueAt(`${field2}.assumption`, text));
+    const text = `${field}.assumption is ${describeValue3(valueAt(item, "assumption"))}, ` + "not what a non-blocking gap would be planned under; the gap is read as blocking";
+    issues.push(issueAt(`${field}.assumption`, text));
     return { heading: heading ?? REVIEW_HEADING, what, blocking: true, assumption: null };
   }
   return { heading: heading ?? REVIEW_HEADING, what, blocking, assumption };
@@ -4676,7 +4982,7 @@ function judged(verdict, gaps, block, issues) {
   };
 }
 function parseSpecReview(output) {
-  const reviews = readRafaBlocks(output).filter((found) => found.kind === SPEC_REVIEW_KIND);
+  const reviews = readRafaBlocks2(output).filter((found) => found.kind === SPEC_REVIEW_KIND);
   const block = reviews.at(-1);
   if (block === undefined) {
     return unreadable("absent", null, "the session output holds no rafa:spec-review block");
@@ -4725,35 +5031,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",
@@ -4774,16 +5051,16 @@ class UndeclaredSpendError extends Error {
   name = "UndeclaredSpendError";
 }
 function carriesFlag(flags, flag) {
-  const name2 = flag.replace(/^--/, "");
-  const value = flags[name2];
+  const name = flag.replace(/^--/, "");
+  const value = flags[name];
   if (value !== undefined && value !== false)
     return true;
-  return name2.startsWith("no-") && flags[name2.slice(3)] === false;
+  return name.startsWith("no-") && flags[name.slice(3)] === false;
 }
-function spendRefusal(running2) {
-  if (running2 === null)
+function spendRefusal(running) {
+  if (running === null)
     return null;
-  const { command, flags } = running2;
+  const { command, flags } = running;
   const spend = command.spends;
   const named = `rafa ${commandSpelling(command)}`;
   const remedy = "declare spends on the command to cover this run";
@@ -5028,8 +5305,8 @@ async function withDeadline(work, timeoutMs) {
   if (timeoutMs === undefined)
     return work;
   let timer;
-  const deadline = new Promise((resolve7) => {
-    timer = setTimeout(() => resolve7(TIMED_OUT), timeoutMs);
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(TIMED_OUT), timeoutMs);
   });
   try {
     return await Promise.race([work, deadline]);
@@ -5056,8 +5333,8 @@ function isRepoName(value) {
 function isLabelPart(value) {
   return typeof value === "string" && !value.includes(",");
 }
-function optionalFlag(name2, value) {
-  return value === undefined ? [] : [name2, value];
+function optionalFlag(name, value) {
+  return value === undefined ? [] : [name, value];
 }
 function detailOf(result) {
   return result.stderr.trim() || result.stdout.trim() || "it exited non-zero and wrote nothing";
@@ -5120,7 +5397,7 @@ function labelNames(value) {
   if (!Array.isArray(value))
     return null;
   const names = value.map((label) => isMapping(label) && typeof label["name"] === "string" ? label["name"] : null);
-  return names.every((name2) => name2 !== null) ? names : null;
+  return names.every((name) => name !== null) ? names : null;
 }
 function viewProblem(payload, number) {
   if (!isMapping(payload))
@@ -5178,13 +5455,13 @@ function listedIssues(stdout) {
 }
 function listedOpenIssues(stdout) {
   return listedRows(stdout).map((row, index) => {
-    const listed2 = listedRow(row, index);
+    const listed = listedRow(row, index);
     const { title, body } = row;
     if (typeof title !== "string")
       throw rowRefusal(index, `with title ${describeValue(title)}, expected a string`);
     if (typeof body !== "string")
       throw rowRefusal(index, `with body ${describeValue(body)}, expected a string`);
-    return { ...listed2, title, body };
+    return { ...listed, title, body };
   });
 }
 function refOfRow(row) {
@@ -5242,9 +5519,9 @@ function createGithubTracker(options) {
     return result.stdout;
   }
   async function ensureLabels(names) {
-    const missing = [...new Set(names)].filter((name2) => !knownLabels.has(name2));
-    for (const name2 of missing) {
-      await run(["label", "create", name2, "--force"], `gh label create ${describeValue(name2)}`);
+    const missing = [...new Set(names)].filter((name) => !knownLabels.has(name));
+    for (const name of missing) {
+      await run(["label", "create", name, "--force"], `gh label create ${describeValue(name)}`);
     }
     knownLabels = new Set([...knownLabels, ...missing]);
   }
@@ -5423,8 +5700,8 @@ function parseIssueNumber(text) {
   const number = Number(text);
   return Number.isSafeInteger(number) ? number : null;
 }
-function issueNumberOfFile(name2) {
-  return name2.endsWith(ISSUE_EXTENSION) ? parseIssueNumber(name2.slice(0, -ISSUE_EXTENSION.length)) : null;
+function issueNumberOfFile(name) {
+  return name.endsWith(ISSUE_EXTENSION) ? parseIssueNumber(name.slice(0, -ISSUE_EXTENSION.length)) : null;
 }
 function issuePath(issuesDir, number) {
   return join16(issuesDir, `${number}${ISSUE_EXTENSION}`);
@@ -5629,7 +5906,7 @@ function createLocalTracker(options) {
 
 // src/adapters/registry.ts
 var REFUSAL3 = "adapter registry";
-var PORT_VERSIONS = Object.freeze({
+var PORT_VERSIONS2 = Object.freeze({
   tracker: 1,
   store: 1,
   learning: 1,
@@ -5637,7 +5914,7 @@ var PORT_VERSIONS = Object.freeze({
   planner: 1,
   sync: 1
 });
-var SERVED_VERSIONS = new Map(Object.entries(PORT_VERSIONS));
+var SERVED_VERSIONS = new Map(Object.entries(PORT_VERSIONS2));
 var PORT_TYPE_LIST = [...SERVED_VERSIONS.keys()].join(", ");
 function checkPortType(port) {
   if (!SERVED_VERSIONS.has(port)) {
@@ -5677,11 +5954,11 @@ function indexByPort(adapters) {
     sync: only("sync")
   };
 }
-function createAdapterRegistry(adapters = []) {
+function createAdapterRegistry2(adapters = []) {
   const held = adapters.reduce((accepted, adapter) => [...accepted, accept(adapter, accepted)], []);
   const byPort = indexByPort(held);
   const registry = {
-    register: (adapter) => createAdapterRegistry([...held, adapter]),
+    register: (adapter) => createAdapterRegistry2([...held, adapter]),
     find: (port, kind) => SERVED_VERSIONS.has(port) ? byPort[port].get(kind) : undefined,
     resolve: (port, kind) => {
       checkPortType(port);
@@ -5689,8 +5966,8 @@ function createAdapterRegistry(adapters = []) {
       if (adapter !== undefined)
         return adapter;
       const registered = [...byPort[port].keys()];
-      const listed2 = registered.length === 0 ? "none" : registered.join(", ");
-      throw new Error(`${REFUSAL3}: no ${port} adapter is registered as ${describeValue(kind)};` + ` registered: ${listed2}`);
+      const listed = registered.length === 0 ? "none" : registered.join(", ");
+      throw new Error(`${REFUSAL3}: no ${port} adapter is registered as ${describeValue(kind)};` + ` registered: ${listed}`);
     },
     kinds: (port) => {
       checkPortType(port);
@@ -5700,38 +5977,38 @@ function createAdapterRegistry(adapters = []) {
   return Object.freeze(registry);
 }
 var STORE_OPENERS = {
-  sqlite: openSqliteStore,
-  ndjson: openNdjsonStore
+  sqlite: openSqliteStore2,
+  ndjson: openNdjsonStore2
 };
 var CORE_ADAPTERS = [
-  ...STORE_BACKENDS.map((backend) => ({
+  ...STORE_BACKENDS2.map((backend) => ({
     port: "store",
     kind: backend,
-    portVersion: PORT_VERSIONS.store,
+    portVersion: PORT_VERSIONS2.store,
     create: ({ repoRoot }) => STORE_OPENERS[backend](repoRoot)
   })),
   {
     port: "output",
     kind: "text",
-    portVersion: PORT_VERSIONS.output,
+    portVersion: PORT_VERSIONS2.output,
     create: ({ stream = process.stdout, verbosity = 0 }) => createTextOutput({ verbosity, stream })
   },
   {
     port: "output",
     kind: "json",
-    portVersion: PORT_VERSIONS.output,
+    portVersion: PORT_VERSIONS2.output,
     create: ({ stream = process.stdout }) => createJsonOutput({ stream })
   },
   {
     port: "output",
     kind: "events",
-    portVersion: PORT_VERSIONS.output,
+    portVersion: PORT_VERSIONS2.output,
     create: ({ stream = process.stdout }) => createEventsOutput({ stream })
   },
   {
     port: "tracker",
     kind: "local",
-    portVersion: PORT_VERSIONS.tracker,
+    portVersion: PORT_VERSIONS2.tracker,
     create: ({ repoRoot, fallbackReason = null }) => createLocalTracker({
       issuesDir: localIssuesDir(repoRoot),
       fallbackReason
@@ -5740,17 +6017,17 @@ var CORE_ADAPTERS = [
   {
     port: "tracker",
     kind: "github",
-    portVersion: PORT_VERSIONS.tracker,
+    portVersion: PORT_VERSIONS2.tracker,
     create: ({ repoRoot, gh }) => createGithubTracker({ gh: gh ?? createGhRunner({ cwd: repoRoot }) })
   },
   {
     port: "learning",
     kind: "local",
-    portVersion: PORT_VERSIONS.learning,
+    portVersion: PORT_VERSIONS2.learning,
     create: ({
       repoRoot,
       home = homedir(),
-      learningBlessMinConfidence = CONFIG_DEFAULTS.learningBlessMinConfidence
+      learningBlessMinConfidence = CONFIG_DEFAULTS2.learningBlessMinConfidence
     }) => createLocalLearning({
       instinctsDir: localInstinctsDir(repoRoot),
       home,
@@ -5760,7 +6037,7 @@ var CORE_ADAPTERS = [
   {
     port: "planner",
     kind: "claude",
-    portVersion: PORT_VERSIONS.planner,
+    portVersion: PORT_VERSIONS2.planner,
     create: ({ repoRoot, settingSources, planPrompt, planDir, claude }) => {
       if (!Array.isArray(settingSources)) {
         throw new TypeError(`${REFUSAL3}: planner/claude has settingSources ${describeValue(settingSources)} in its context,` + " expected a list of setting sources");
@@ -5777,26 +6054,26 @@ var CORE_ADAPTERS = [
   {
     port: "sync",
     kind: "local",
-    portVersion: PORT_VERSIONS.sync,
+    portVersion: PORT_VERSIONS2.sync,
     create: () => createLocalSync()
   },
   {
     port: "sync",
     kind: "file",
-    portVersion: PORT_VERSIONS.sync,
+    portVersion: PORT_VERSIONS2.sync,
     create: ({ repoRoot, store }) => {
-      if (!STORE_BACKENDS.includes(store)) {
-        throw new TypeError(`${REFUSAL3}: sync/file has store ${describeValue(store)} in its context,` + ` expected one of: ${STORE_BACKENDS.join(", ")}`);
+      if (!STORE_BACKENDS2.includes(store)) {
+        throw new TypeError(`${REFUSAL3}: sync/file has store ${describeValue(store)} in its context,` + ` expected one of: ${STORE_BACKENDS2.join(", ")}`);
       }
       return createFileSync({ repoRoot, backend: store });
     }
   }
 ];
-var CORE_ADAPTER_REGISTRY = createAdapterRegistry(CORE_ADAPTERS);
+var CORE_ADAPTER_REGISTRY2 = createAdapterRegistry2(CORE_ADAPTERS);
 
 // src/board/trust.ts
 var REPO_PATH = "{owner}/{repo}";
-var TRUSTED_PERMISSIONS = ["admin", "maintain", "write"];
+var TRUSTED_PERMISSIONS2 = ["admin", "maintain", "write"];
 var TRUST_REFUSAL_EXIT = 2;
 var REMEDY = Object.freeze({
   issue: "a member must open the spec",
@@ -5808,7 +6085,7 @@ function failureDetail(reading) {
   return detail === "" ? UNREPORTED : detail;
 }
 function isTrustedPermission(value) {
-  return TRUSTED_PERMISSIONS.some((permission) => permission === value);
+  return TRUSTED_PERMISSIONS2.some((permission) => permission === value);
 }
 function stringOrNull(value) {
   return typeof value === "string" ? value : null;
@@ -5858,8 +6135,8 @@ async function readAuthorTrust(options) {
     };
   }
   const wanted = login.toLowerCase();
-  const listed2 = trustedAuthors.some((author) => author.toLowerCase() === wanted);
-  if (listed2) {
+  const listed = trustedAuthors.some((author) => author.toLowerCase() === wanted);
+  if (listed) {
     return { login, trusted: true, source: "allow-list", refusal: null, permission: null };
   }
   const permission = await permissions(login);
@@ -5911,18 +6188,18 @@ 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";
-var WIRE_FORMAT = "rafa-effort-wire";
-var WIRE_VERSION = 1;
+import { Database as Database7, SQLiteError as SQLiteError3 } from "bun:sqlite";
+var WIRE_FORMAT2 = "rafa-effort-wire";
+var WIRE_VERSION2 = 1;
 
-class WireFormatError extends Error {
+class WireFormatError2 extends Error {
   name = "WireFormatError";
 }
 
-class WireExportRefusal extends Error {
+class WireExportRefusal2 extends Error {
   name = "WireExportRefusal";
 }
 var MERGED_TABLES = Object.entries(MERGE_RULES).filter(([, rule]) => rule.scope === "merged").map(([table]) => table);
@@ -5933,17 +6210,17 @@ function isRecord4(value) {
 function isCount(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 }
-function isMergedTable(name2) {
-  return MERGED_TABLES.includes(name2);
+function isMergedTable(name) {
+  return MERGED_TABLES.includes(name);
 }
 function checkCursor(value) {
   if (!isRecord4(value))
-    throw new WireFormatError("wire: cursor is not an object");
+    throw new WireFormatError2("wire: cursor is not an object");
   const entries = Object.entries(value).map(([table, seq]) => {
     if (!isMergedTable(table))
-      throw new WireFormatError(`wire: cursor names ${JSON.stringify(table)}, which is no merged table`);
+      throw new WireFormatError2(`wire: cursor names ${JSON.stringify(table)}, which is no merged table`);
     if (!isCount(seq))
-      throw new WireFormatError(`wire: cursor for ${table} is ${JSON.stringify(seq)}, expected a whole number of 0 or more`);
+      throw new WireFormatError2(`wire: cursor for ${table} is ${JSON.stringify(seq)}, expected a whole number of 0 or more`);
     return [table, seq];
   });
   return Object.freeze(Object.fromEntries(entries));
@@ -5951,67 +6228,67 @@ function checkCursor(value) {
 function checkRow(table, value, index) {
   const where = `wire: ${table} row ${String(index)}`;
   if (!isRecord4(value))
-    throw new WireFormatError(`${where} is not an object`);
+    throw new WireFormatError2(`${where} is not an object`);
   for (const [column, cell] of Object.entries(value)) {
     const carried = cell === null || typeof cell === "string" || typeof cell === "number" && Number.isFinite(cell);
     if (!carried)
-      throw new WireFormatError(`${where} holds ${JSON.stringify(cell) ?? typeof cell} in ${column}, expected a string, a number or null`);
+      throw new WireFormatError2(`${where} holds ${JSON.stringify(cell) ?? typeof cell} in ${column}, expected a string, a number or null`);
   }
   const seq = value.seq;
   if (!isCount(seq) || seq === 0)
-    throw new WireFormatError(`${where} has seq ${JSON.stringify(seq) ?? "undefined"}, expected a whole number above 0`);
+    throw new WireFormatError2(`${where} has seq ${JSON.stringify(seq) ?? "undefined"}, expected a whole number above 0`);
   return Object.freeze({ ...value });
 }
 function checkMigrations(value) {
   if (!Array.isArray(value))
-    throw new WireFormatError("wire: migrations is not a list");
+    throw new WireFormatError2("wire: migrations is not a list");
   const ids = value.map((id) => {
     if (typeof id !== "string" || id === "")
-      throw new WireFormatError(`wire: migration id ${JSON.stringify(id)} is not a name`);
+      throw new WireFormatError2(`wire: migration id ${JSON.stringify(id)} is not a name`);
     return id;
   });
   const twice = ids.filter((id, index) => ids.indexOf(id) !== index);
   if (twice.length > 0)
-    throw new WireFormatError(`wire: migrations name ${twice.join(", ")} more than once`);
+    throw new WireFormatError2(`wire: migrations name ${twice.join(", ")} more than once`);
   return Object.freeze(ids);
 }
 function checkTables(value) {
   if (!isRecord4(value))
-    throw new WireFormatError("wire: tables is not an object");
+    throw new WireFormatError2("wire: tables is not an object");
   const entries = Object.entries(value).map(([table, rows]) => {
     if (!isMergedTable(table))
-      throw new WireFormatError(`wire: tables names ${JSON.stringify(table)}, which is no merged table`);
+      throw new WireFormatError2(`wire: tables names ${JSON.stringify(table)}, which is no merged table`);
     if (!Array.isArray(rows))
-      throw new WireFormatError(`wire: tables.${table} is not a list`);
+      throw new WireFormatError2(`wire: tables.${table} is not a list`);
     return [table, Object.freeze(rows.map((row, index) => checkRow(table, row, index)))];
   });
   return Object.freeze(Object.fromEntries(entries));
 }
 function checkPayload(value) {
   if (!isRecord4(value))
-    throw new WireFormatError("wire: the payload is not an object");
-  if (value.format !== WIRE_FORMAT)
-    throw new WireFormatError(`wire: format is ${JSON.stringify(value.format) ?? "undefined"}, expected ${JSON.stringify(WIRE_FORMAT)}`);
-  if (value.version !== WIRE_VERSION)
-    throw new WireFormatError(`wire: version is ${JSON.stringify(value.version) ?? "undefined"}; this rafa reads version ${String(WIRE_VERSION)}`);
+    throw new WireFormatError2("wire: the payload is not an object");
+  if (value.format !== WIRE_FORMAT2)
+    throw new WireFormatError2(`wire: format is ${JSON.stringify(value.format) ?? "undefined"}, expected ${JSON.stringify(WIRE_FORMAT2)}`);
+  if (value.version !== WIRE_VERSION2)
+    throw new WireFormatError2(`wire: version is ${JSON.stringify(value.version) ?? "undefined"}; this rafa reads version ${String(WIRE_VERSION2)}`);
   return Object.freeze({
-    format: WIRE_FORMAT,
-    version: WIRE_VERSION,
+    format: WIRE_FORMAT2,
+    version: WIRE_VERSION2,
     migrations: checkMigrations(value.migrations),
     tables: checkTables(value.tables),
     cursor: checkCursor(value.cursor)
   });
 }
-function encodeWirePayload(payload) {
+function encodeWirePayload2(payload) {
   return JSON.stringify(payload);
 }
-function decodeWirePayload(text) {
+function decodeWirePayload2(text) {
   let parsed;
   try {
     parsed = JSON.parse(text);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
-    throw new WireFormatError(`wire: the payload is not JSON (${reason})`);
+    throw new WireFormatError2(`wire: the payload is not JSON (${reason})`);
   }
   return checkPayload(parsed);
 }
@@ -6022,17 +6299,17 @@ function readLoggedIds(db) {
   return db.query(`SELECT id FROM ${MIGRATION_LOG_TABLE} ORDER BY seq`).all().map(({ id }) => id);
 }
 function columnsOf(db, table) {
-  return db.query(`PRAGMA table_info(${quoted(table)})`).all().map(({ name: name2 }) => name2);
+  return db.query(`PRAGMA table_info(${quoted(table)})`).all().map(({ name }) => name);
 }
 function wireValue(value, where) {
   if (typeof value === "bigint") {
     const number = Number(value);
     if (Number.isSafeInteger(number))
       return number;
-    throw new WireExportRefusal(`wire: ${where} holds ${String(value)}, past the whole numbers JSON carries exactly`);
+    throw new WireExportRefusal2(`wire: ${where} holds ${String(value)}, past the whole numbers JSON carries exactly`);
   }
   if (value instanceof Uint8Array)
-    throw new WireExportRefusal(`wire: ${where} holds a BLOB, which the wire does not carry`);
+    throw new WireExportRefusal2(`wire: ${where} holds a BLOB, which the wire does not carry`);
   return value;
 }
 function readRows(db, table, columns, after, path) {
@@ -6045,7 +6322,7 @@ function readRows(db, table, columns, after, path) {
 function readPayload(db, path, cursor) {
   const migrations = readLoggedIds(db);
   if (migrations === null) {
-    throw new WireExportRefusal(`wire: ${path} has no migration log; any rafa command that writes the store brings it forward`);
+    throw new WireExportRefusal2(`wire: ${path} has no migration log; any rafa command that writes the store brings it forward`);
   }
   const tables = {};
   const next = { ...cursor };
@@ -6055,7 +6332,7 @@ function readPayload(db, path, cursor) {
       continue;
     const missing = ORIGIN_COLUMNS.filter((column) => !columns.includes(column));
     if (missing.length > 0) {
-      throw new WireExportRefusal(`wire: ${path} holds no ${missing.map((column) => `${table}.${column}`).join(", ")}, so its rows carry no origin pair`);
+      throw new WireExportRefusal2(`wire: ${path} holds no ${missing.map((column) => `${table}.${column}`).join(", ")}, so its rows carry no origin pair`);
     }
     const rows = readRows(db, table, columns, cursor[table] ?? 0, path);
     tables[table] = Object.freeze(rows);
@@ -6063,20 +6340,20 @@ function readPayload(db, path, cursor) {
     next[table] = last === undefined ? cursor[table] ?? 0 : Number(last.seq);
   }
   return Object.freeze({
-    format: WIRE_FORMAT,
-    version: WIRE_VERSION,
+    format: WIRE_FORMAT2,
+    version: WIRE_VERSION2,
     migrations: Object.freeze([...migrations]),
     tables: Object.freeze(tables),
     cursor: Object.freeze(next)
   });
 }
-function exportWirePayload(options) {
+function exportWirePayload2(options) {
   const { path } = options;
   const cursor = checkCursor(options.cursor ?? {});
   guardTestProcess(path);
   if (!existsSync14(path))
-    throw new WireExportRefusal(`wire: ${path} is not there`);
-  const db = new Database6(path, { readonly: true, safeIntegers: true });
+    throw new WireExportRefusal2(`wire: ${path} is not there`);
+  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))();
@@ -6088,34 +6365,34 @@ function namedMigrations(ids, catalogue) {
   const known = new Set(catalogue.map(({ id }) => id));
   const unknown = ids.filter((id) => !known.has(id));
   if (unknown.length > 0) {
-    throw new WireFormatError(`wire: the payload's store holds migration ${unknown.join(", ")}, which this rafa does not know; update rafa to take its rows`);
+    throw new WireFormatError2(`wire: the payload's store holds migration ${unknown.join(", ")}, which this rafa does not know; update rafa to take its rows`);
   }
   return catalogue.filter(({ id }) => ids.includes(id));
 }
 function insertRows(db, table, rows) {
   const columns = columnsOf(db, table);
   if (columns.length === 0)
-    throw new WireFormatError(`wire: the payload carries ${table}, which its migrations do not make`);
+    throw new WireFormatError2(`wire: the payload carries ${table}, which its migrations do not make`);
   const statement = db.query(`INSERT INTO ${quoted(table)} (${columns.map(quoted).join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`);
   const expected = [...columns].sort().join(",");
   rows.forEach((row, index) => {
     const where = `wire: ${table} row ${String(index)}`;
     const held = Object.keys(row);
     if ([...held].sort().join(",") !== expected) {
-      throw new WireFormatError(`${where} holds columns ${held.join(", ")}; its migrations make ${columns.join(", ")}`);
+      throw new WireFormatError2(`${where} holds columns ${held.join(", ")}; its migrations make ${columns.join(", ")}`);
     }
     try {
       statement.run(...columns.map((column) => row[column] ?? null));
     } catch (error) {
       if (!(error instanceof SQLiteError3))
         throw error;
-      throw new WireFormatError(`${where} (seq ${String(row.seq)}) is refused by the table: ${error.message}`);
+      throw new WireFormatError2(`${where} (seq ${String(row.seq)}) is refused by the table: ${error.message}`);
     }
   });
 }
 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,
@@ -6131,10 +6408,10 @@ function buildStore(path, payload, options) {
     db.close();
   }
 }
-function materialiseWirePayload(payload, options = {}) {
+function materialiseWirePayload2(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);
@@ -6154,13 +6431,13 @@ function describeValue4(value) {
     return "an object";
   return String(value);
 }
-function selectEffortStore(repoRoot, config) {
-  const adapter = CORE_ADAPTER_REGISTRY.find("store", config.store);
+function selectEffortStore2(repoRoot, config) {
+  const adapter = CORE_ADAPTER_REGISTRY2.find("store", config.store);
   if (adapter === undefined) {
-    const expected = CORE_ADAPTER_REGISTRY.kinds("store").join(", ");
+    const expected = CORE_ADAPTER_REGISTRY2.kinds("store").join(", ");
     throw new TypeError(`effort store: store is ${describeValue4(config.store)},` + ` expected one of: ${expected}`);
   }
   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_PROJECTIONS2, openNdjsonStore2, name, version, RAFA_VERSION, versionLine, createGitRunner, gitSaid, NOT_A_REPOSITORY, mainCheckoutOf, SCOPE_DIR2, INIT_COMMAND2, DISK_FILE_SYSTEM2, ScopeError2, scopeAt2, initHint2, selfAndAncestors2, resolveScope2, 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, openSqliteStore2, SPENDS_GLYPH, CommandExit, isRoutingWord, commandProblem, isTopLevel, commandSpelling, EffortCopyRefusal, EffortCopyFailure, copyEffortStore, RebuildRefusal, readConfigFile2, loadConfig2, 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, mergeStore2, createFileSync, SyncModuleMissing, selectSync, SKILL_FILE2, MARKDOWN_EXTENSION, scanLayout, declaredNameIssue, readFrontmatterDocument, readFrontmatter, renderFrontmatter, mergeFrontmatter, writeFrontmatter, ACTION_HEADING, CAUSE_HEADING, parseInstinct, writeInstinct, readScopes, allRecords, findRecords, instinctProject, toHeldRecords, 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_VERSIONS2, createAdapterRegistry2, CORE_ADAPTER_REGISTRY2, TRUSTED_PERMISSIONS2, createGhPermissions, readAuthorTrust, ghBoardTrust, readBoardTrust, requireTrustedBoardAuthor, trustRefusalClause, requireTrustedAuthor, WIRE_FORMAT2, WIRE_VERSION2, WireFormatError2, WireExportRefusal2, encodeWirePayload2, decodeWirePayload2, exportWirePayload2, materialiseWirePayload2, selectEffortStore2 };