@open-tomato/rafa 0.28.0 → 0.32.0

package/dist/{index-4rwvr6t4.js → index-wvm2s4pr.js}

@@ -2,6 +2,7 @@
 import {
   CONFIG_DEFAULTS,
   CONFIG_FILE,
+  ConfigError,
   FINDING_DOMAINS,
   FINDING_KINDS,
   FINDING_SIGNALS,
@@ -10,20 +11,24 @@ import {
   configFilePath,
   createTextOutput,
   isStampableStub,
-  readRafaBlocks
-} from "./index-rv7y8y1j.js";
+  parseConfigText,
+  readRafaBlocks,
+  resolveConfig
+} from "./index-9aph6ft9.js";
 import {
   bless,
   merge
 } from "./index-d6d0942q.js";
 import {
+  CommandExit,
   commandSpelling
-} from "./index-4j1e3h26.js";
+} from "./index-mt6hpsry.js";
 import {
   BUSY_TIMEOUT_MAX_MS,
   BUSY_TIMEOUT_MIN_MS,
   RAFA_INSTINCTS_PATH,
   STORE_BACKENDS,
+  SYNC_STRATEGIES,
   bundledBinDirectory,
   describeValue,
   isBusyTimeoutMs,
@@ -31,7 +36,7 @@ import {
   messageOf,
   resolveInstinctScopes,
   tierExists
-} from "./index-sf2brh4w.js";
+} from "./index-rs79dq9e.js";
 import {
   actionHash,
   triggerKey
@@ -244,7 +249,7 @@ import { Database } from "bun:sqlite";
 
 // package.json
 var name = "@open-tomato/rafa";
-var version = "0.28.0";
+var version = "0.32.0";
 
 // src/cli/version.ts
 var RAFA_VERSION = version;
@@ -254,7 +259,7 @@ function versionLine() {
 
 // src/effort/store/development-build.ts
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute3 } from "path";
+import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute5 } from "path";
 
 // src/loop/sessions.ts
 import {
@@ -266,7 +271,7 @@ import {
   rmSync as rmSync3,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename, dirname as dirname5, join as join7 } from "path";
+import { basename, dirname as dirname5, isAbsolute as isAbsolute4, join as join7 } from "path";
 
 // src/next/hop-record.ts
 import { randomUUID as randomUUID2 } from "crypto";
@@ -280,7 +285,73 @@ import { dirname as dirname3, join as join5 } from "path";
 
 // src/project/scope.ts
 import { existsSync as existsSync3, realpathSync as realpathSync2 } from "fs";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4 } from "path";
+import { dirname as dirname2, isAbsolute as isAbsolute3, join as join4 } from "path";
+
+// src/project/worktree-root.ts
+import { isAbsolute as isAbsolute2 } from "path";
+
+// src/pr/git.ts
+import { spawnSync } from "child_process";
+function createGitRunner(cwd) {
+  return (args) => {
+    const result = spawnSync("git", [...args], {
+      cwd,
+      encoding: "utf8",
+      env: { ...process.env, LC_ALL: "C" }
+    });
+    if (result.error !== undefined) {
+      return { ok: false, stdout: "", stderr: `could not run git in ${cwd}: ${messageOf(result.error)}` };
+    }
+    return { ok: result.status === 0, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+  };
+}
+function gitSaid(result) {
+  return [result.stderr, result.stdout].map((stream) => stream.trim()).filter((stream) => stream !== "").join(`
+`);
+}
+
+// src/project/worktree-root.ts
+var NOT_A_REPOSITORY = "fatal: not a git repository (or any ";
+var WORKTREE_LIST_ARGS = Object.freeze(["worktree", "list", "--porcelain", "-z"]);
+var WORKTREE_PREFIX = "worktree ";
+var BARE_LINE = "bare";
+
+class WorktreeRootError extends Error {
+  constructor(message, options) {
+    super(`rafa worktree root: ${message}`, options);
+    this.name = "WorktreeRootError";
+  }
+}
+function firstRecordOf(stdout) {
+  const lines = stdout.split("\x00");
+  const end = lines.indexOf("");
+  return end === -1 ? lines : lines.slice(0, end);
+}
+function readListing(dir, stdout) {
+  const record = firstRecordOf(stdout);
+  const head = record[0];
+  if (head === undefined || !head.startsWith(WORKTREE_PREFIX)) {
+    throw new WorktreeRootError(`git worktree list in ${dir} printed no worktree line first`);
+  }
+  if (record.includes(BARE_LINE))
+    return null;
+  return head.slice(WORKTREE_PREFIX.length);
+}
+function readFailure(dir, result) {
+  if (result.stderr.startsWith(NOT_A_REPOSITORY))
+    return null;
+  throw new WorktreeRootError(`git worktree list failed in ${dir}: ${gitSaid(result)}`);
+}
+function mainCheckoutOf(dir, seams = {}) {
+  if (!isAbsolute2(dir)) {
+    throw new WorktreeRootError(`directory ${JSON.stringify(dir)} is not an absolute path`);
+  }
+  const git = (seams.openGit ?? createGitRunner)(dir);
+  const result = git(WORKTREE_LIST_ARGS);
+  return result.ok ? readListing(dir, result.stdout) : readFailure(dir, result);
+}
+
+// src/project/scope.ts
 var SCOPE_DIR = dirname2(CONFIG_FILE);
 var INIT_COMMAND = "rafa init";
 var DISK_FILE_SYSTEM = Object.freeze({
@@ -297,17 +368,19 @@ class ScopeError extends Error {
 function scopeAt(base) {
   return { dir: join4(base, SCOPE_DIR), configFile: configFilePath(base) };
 }
-function initHint(start, passedUserConfig = null) {
+function initHint(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`,
+    ...main,
     ...passed,
     `run \`${INIT_COMMAND}\` to set one up`
   ].join(`
 `);
 }
 function requireAbsolute(label, path) {
-  if (!isAbsolute2(path)) {
+  if (!isAbsolute3(path)) {
     throw new ScopeError(`${label} is ${describeValue(path)}, expected an absolute path`);
   }
 }
@@ -341,17 +414,36 @@ function walkUp(realStart, realHome, fs) {
   }
   return { root: null, passedUserConfig };
 }
+function mainCheckoutAt(realStart, mainCheckout) {
+  try {
+    return mainCheckout(realStart);
+  } catch (error) {
+    if (!(error instanceof WorktreeRootError))
+      throw error;
+    throw new ScopeError(`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)) {
+    return { root: null, probed: null };
+  }
+  return fs.exists(configFilePath(main)) ? { root: main, probed: main } : { root: null, probed: main };
+}
 function resolveScope(start, seams) {
-  const { home, fs = DISK_FILE_SYSTEM } = seams;
+  const { home, fs = DISK_FILE_SYSTEM, mainCheckout = mainCheckoutOf } = seams;
   requireAbsolute("start directory", start);
   requireAbsolute("home directory", home);
   const user = scopeAt(home);
-  const walk = walkUp(realStartOf(start, fs), realHomeOf(home, fs), fs);
-  if (walk.root === null) {
+  const realStart = realStartOf(start, fs);
+  const realHome = realHomeOf(home, fs);
+  const walk = walkUp(realStart, realHome, fs);
+  const fallback = walk.root === null ? fallBack(realStart, realHome, fs, mainCheckout) : { root: walk.root, probed: null };
+  if (fallback.root === null) {
     const passed = walk.passedUserConfig ? user.configFile : null;
-    return { found: false, start, home, user, hint: initHint(start, passed) };
+    return { found: false, start, home, user, hint: initHint(start, passed, fallback.probed) };
   }
-  return { found: true, root: walk.root, home, project: scopeAt(walk.root), user };
+  return { found: true, root: fallback.root, home, project: scopeAt(fallback.root), user };
 }
 
 // src/project/position.ts
@@ -612,6 +704,12 @@ function hopProblem(fields) {
   const hop2 = field(fields, "hop");
   return asHopRecord(hop2) === null ? `hop is ${describeValue2(hop2)}, expected a hop record` : null;
 }
+function worktreeProblem(fields) {
+  if (!Object.hasOwn(fields, "worktree"))
+    return null;
+  const worktree = field(fields, "worktree");
+  return isText(worktree) && isAbsolute4(worktree) ? null : `worktree is ${describeValue2(worktree)}, expected an absolute path`;
+}
 function sessionIdProblem(sessionId, file) {
   if (typeof sessionId !== "string" || !isSessionId(sessionId)) {
     return `sessionId is ${describeValue2(sessionId)}, expected a plain file name`;
@@ -636,7 +734,8 @@ function recordProblems(fields, file) {
     typeof startedAt === "string" && !Number.isNaN(Date.parse(startedAt)) ? null : `startedAt is ${describeValue2(startedAt)}, expected a timestamp`,
     SESSION_STATES.includes(state) ? null : `state is ${describeValue2(state)}, expected one of ${SESSION_STATES.join(", ")}`,
     taskProblem(field(fields, "task")),
-    hopProblem(fields)
+    hopProblem(fields),
+    worktreeProblem(fields)
   ];
   return problems.filter((problem) => problem !== null);
 }
@@ -647,6 +746,7 @@ function freezeHop(value) {
 function freezeRecord(fields) {
   const task = field(fields, "task");
   const hop2 = field(fields, "hop");
+  const worktree = field(fields, "worktree");
   return Object.freeze({
     sessionId: field(fields, "sessionId"),
     planStub: field(fields, "planStub"),
@@ -656,7 +756,8 @@ function freezeRecord(fields) {
     startedAt: field(fields, "startedAt"),
     state: field(fields, "state"),
     task: isObject(task) ? Object.freeze({ line: field(task, "line"), text: field(task, "text") }) : null,
-    ...hop2 === undefined ? {} : { hop: freezeHop(hop2) }
+    ...hop2 === undefined ? {} : { hop: freezeHop(hop2) },
+    ...worktree === undefined ? {} : { worktree }
   });
 }
 function parseSessionRecord(text, file) {
@@ -850,7 +951,7 @@ function isOwnedStore(path, env, tempDir) {
   if (isUnderTempDir(path, tempDir))
     return true;
   const override = env[EFFORT_DIR_VARIABLE];
-  if (override === undefined || override === "" || !isAbsolute3(override))
+  if (override === undefined || override === "" || !isAbsolute5(override))
     return false;
   return storeProjectRoot(path) === null && isUnderTempDir(path, override);
 }
@@ -1482,26 +1583,6 @@ import { createHmac } from "crypto";
 import { readFileSync as readFileSync6, realpathSync as realpathSync4, statSync } from "fs";
 import { hostname, platform as currentPlatform } from "os";
 
-// src/pr/git.ts
-import { spawnSync } from "child_process";
-function createGitRunner(cwd) {
-  return (args) => {
-    const result = spawnSync("git", [...args], {
-      cwd,
-      encoding: "utf8",
-      env: { ...process.env, LC_ALL: "C" }
-    });
-    if (result.error !== undefined) {
-      return { ok: false, stdout: "", stderr: `could not run git in ${cwd}: ${messageOf(result.error)}` };
-    }
-    return { ok: result.status === 0, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
-  };
-}
-function gitSaid(result) {
-  return [result.stderr, result.stdout].map((stream) => stream.trim()).filter((stream) => stream !== "").join(`
-`);
-}
-
 // src/schema/project-id.ts
 import { spawnSync as spawnSync2 } from "child_process";
 var PROJECT_ID_LENGTH = 12;
@@ -1778,17 +1859,1390 @@ function openSqliteStore(repoRoot) {
   };
 }
 
+// src/effort/sync/file.ts
+import { existsSync as existsSync12 } from "fs";
+import { join as join12, resolve as resolve5 } from "path";
+
+// src/effort/store/fix-schema.ts
+import { existsSync as existsSync7 } from "fs";
+import { Database as Database2 } from "bun:sqlite";
+
+// src/effort/store/rebuild-aside.ts
+import { existsSync as existsSync6, renameSync as renameSync4, rmSync as rmSync4 } from "fs";
+
+class RebuildRefusal extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RebuildRefusal";
+  }
+}
+function quoted(name2) {
+  return `"${name2.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}`)) {
+      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");
+    }
+  }
+}
+function checkedCounts(db, tables, original, added = {}) {
+  return tables.map((table) => {
+    const rows = count(db, `SELECT count(*) AS n FROM main.${quoted(table)}`);
+    const originalRows = count(db, `SELECT count(*) AS n FROM ${original}.${quoted(table)}`);
+    const addedRows = added[table] ?? 0;
+    if (rows !== originalRows + addedRows) {
+      const plus = addedRows === 0 ? "" : ` plus ${String(addedRows)} added`;
+      throw new RebuildRefusal(`the rebuilt ${table} holds ${String(rows)} rows, the store ${String(originalRows)}${plus}`);
+    }
+    return { table, rows };
+  });
+}
+function refuseCorrupt(db) {
+  const answer = db.query("PRAGMA main.integrity_check").get()?.integrity_check;
+  if (answer !== "ok")
+    throw new RebuildRefusal(`the rebuilt store failed integrity_check: ${answer ?? "no answer"}`);
+}
+function removeParallel(parallelPath) {
+  rmSync4(parallelPath, { force: true });
+  rmSync4(`${parallelPath}-journal`, { force: true });
+}
+function swapIn(path, parallelPath, backupPath) {
+  renameSync4(path, backupPath);
+  try {
+    renameSync4(parallelPath, path);
+  } catch (error) {
+    renameSync4(backupPath, path);
+    throw error;
+  }
+}
+function refuseTaken(paths) {
+  for (const taken of paths) {
+    if (existsSync6(taken))
+      throw new RebuildRefusal(`${taken} is already there; move it aside or pass another stamp`);
+  }
+}
+function rebuildAside(options) {
+  const { path, parallelPath, backupPath, dryRun, build } = options;
+  refuseInFlight(path);
+  refuseTaken([parallelPath, backupPath]);
+  let built;
+  try {
+    built = build(parallelPath);
+  } catch (error) {
+    removeParallel(parallelPath);
+    throw error;
+  }
+  if (dryRun) {
+    removeParallel(parallelPath);
+    return { built, backupPath: null };
+  }
+  swapIn(path, parallelPath, backupPath);
+  return { built, backupPath };
+}
+
+// src/effort/store/fix-schema.ts
+var REPAIRABLE_REASONS = [
+  "pre-log-unreleased",
+  "gate-mismatch",
+  "edited",
+  "unknown-breaks-readers",
+  "unknown-breaks-writers"
+];
+var LIVE = "live";
+function tableNames(db, schema) {
+  return db.query(`SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name <> ? ORDER BY name`).all(MIGRATION_LOG_TABLE).map((row) => row.name);
+}
+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 });
+  try {
+    return readStoreSchema(db, path);
+  } finally {
+    db.close();
+  }
+}
+function refuseRemoved(db, known, live) {
+  for (const table of known) {
+    if (!live.has(table)) {
+      throw new RebuildRefusal(`the store holds no table ${table}, which this rafa writes; its newer schema is not additive`);
+    }
+    const liveColumns = new Set(columnNames(db, LIVE, table));
+    const missing = columnNames(db, "main", table).filter((column) => !liveColumns.has(column));
+    if (missing.length > 0) {
+      throw new RebuildRefusal(`the store holds no column ${missing.map((column) => `${table}.${column}`).join(", ")}, which this rafa` + " writes; its newer schema is not additive");
+    }
+  }
+}
+function copyKnown(db, known) {
+  db.transaction(() => {
+    for (const table of known) {
+      const columns = columnNames(db, "main", table).map(quoted).join(", ");
+      db.run(`INSERT INTO main.${quoted(table)} (${columns}) SELECT ${columns} FROM ${LIVE}.${quoted(table)}`);
+    }
+  })();
+}
+function leftBehind(db, known, live) {
+  const leftTables = live.filter((table) => !known.has(table)).map((table) => ({ table, rows: count(db, `SELECT count(*) AS n FROM ${LIVE}.${quoted(table)}`) }));
+  const leftColumns = live.filter((table) => known.has(table)).flatMap((table) => {
+    const kept = new Set(columnNames(db, "main", table));
+    return columnNames(db, LIVE, table).filter((column) => !kept.has(column)).map((column) => ({
+      table,
+      column,
+      values: count(db, `SELECT count(*) AS n FROM ${LIVE}.${quoted(table)} WHERE ${quoted(column)} IS NOT NULL`)
+    }));
+  });
+  return { leftTables, leftColumns };
+}
+function refuseUnusable(db, parallelPath, migrations) {
+  const plan = planSchema(readStoreSchema(db, parallelPath), sqliteCatalogue(migrations), "write", "open");
+  if (plan.verdict === "refuse")
+    throw new RebuildRefusal(`the rebuilt store is refused as ${plan.reason}: ${plan.message}`);
+  const needs = writeNames(plan);
+  if (needs.length > 0)
+    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 });
+  try {
+    bringForward(db, parallelPath, "write", "open", { migrations, ...stamp, builtAside: true });
+    db.run(`ATTACH DATABASE ? AS ${LIVE}`, [path]);
+    const known = tableNames(db, "main");
+    const live = tableNames(db, LIVE);
+    refuseRemoved(db, known, new Set(live));
+    copyKnown(db, known);
+    const kept = checkedCounts(db, known, LIVE);
+    const left = leftBehind(db, new Set(known), live);
+    db.run(`DETACH DATABASE ${LIVE}`);
+    refuseCorrupt(db);
+    refuseUnusable(db, parallelPath, migrations);
+    return { kept, ...left };
+  } finally {
+    db.close();
+  }
+}
+function asidePaths(path, version2, stamp) {
+  return { parallelPath: `${path}.fix-${stamp}`, backupPath: `${path}.v${String(version2)}-${stamp}.bak` };
+}
+function isRepairable(reason) {
+  return REPAIRABLE_REASONS.includes(reason);
+}
+function refuseDevelopmentSwap(path, reason, identity) {
+  if (identity.kind !== "development")
+    return;
+  throw new RebuildRefusal(`${path} needs a rebuild (${reason}), and this rafa is a development build (${identity.checkout}), whose` + " migrations may be a branch's; a development build never swaps a rebuild in. Nothing was changed, and" + " --dry-run runs from here. Run the swap from an installed rafa. Next safe step: rafa effort fix-schema");
+}
+function fixStoreSchema(options) {
+  const { path, dryRun, stamp } = options;
+  guardTestProcess(path);
+  const migrations = options.migrations ?? SQLITE_MIGRATIONS;
+  const identity = options.identity ?? readRuntimeIdentity();
+  const appliedBy = appliedByName(identity);
+  const known = migrations.map(({ id }) => id);
+  const nothing = { known, appliedBy, pending: [], kept: [], leftTables: [], leftColumns: [], backupPath: null };
+  if (!existsSync7(path)) {
+    return { path, status: "missing", storeVersion: null, logged: false, reason: null, refusal: null, unknown: [], ...nothing };
+  }
+  refuseInFlight(path);
+  const store = readOnlySchema(path);
+  const knownIds = new Set(known);
+  const found = {
+    path,
+    storeVersion: store.userVersion,
+    logged: store.log !== null,
+    unknown: (store.log ?? []).filter(({ id }) => !knownIds.has(id))
+  };
+  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 };
+  }
+  if (!isRepairable(plan.reason)) {
+    throw new RebuildRefusal(`a rebuild at this rafa's migrations does not repair ${plan.reason}. ${plan.message}`);
+  }
+  if (!dryRun)
+    refuseDevelopmentSwap(path, plan.reason, identity);
+  const { built, backupPath } = rebuildAside({
+    path,
+    ...asidePaths(path, store.userVersion, stamp),
+    dryRun,
+    build: (parallelPath) => buildParallel(path, parallelPath, migrations, {
+      appliedBy,
+      now: options.now ?? (() => new Date)
+    })
+  });
+  const status = dryRun ? "would-rebuild" : "rebuilt";
+  const refusal = withoutWayOut(plan.message, plan.nextStep);
+  return { ...found, ...nothing, status, reason: plan.reason, refusal, ...built, backupPath };
+}
+function withoutWayOut(message, nextStep) {
+  const ending = ` Next safe step: ${nextStep}`;
+  return message.endsWith(ending) ? message.slice(0, -ending.length) : message;
+}
+
+// src/commands/plan/plan-files.ts
+import { statSync as statSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// src/config-load.ts
+import { existsSync as existsSync8, readFileSync as readFileSync7, realpathSync as realpathSync5 } from "fs";
+import { isAbsolute as isAbsolute6 } from "path";
+function readConfigFile(root) {
+  const path = configFilePath(root);
+  if (!existsSync8(path))
+    return null;
+  let text;
+  try {
+    text = readFileSync7(path, "utf8");
+  } catch (error) {
+    const problem = `${path}: cannot be read (${messageOf(error)})`;
+    throw new ConfigError([problem], { cause: error });
+  }
+  return parseConfigText(text, path);
+}
+function isSameDirectory(first, second) {
+  try {
+    return realpathSync5(first) === realpathSync5(second);
+  } catch {
+    return false;
+  }
+}
+function readUserConfigFile({ root, home }) {
+  if (!isAbsolute6(home)) {
+    throw new ConfigError([
+      `home directory is ${describeValue(home)}, expected an absolute path`
+    ]);
+  }
+  return isSameDirectory(root, home) ? null : readConfigFile(home);
+}
+function printWarning(message) {
+  activeOutput().warn(message);
+}
+function loadConfig(roots, cli = {}, warn = printWarning) {
+  const user = readUserConfigFile(roots);
+  const file = readConfigFile(roots.root);
+  const resolved = resolveConfig({ cli, file, user });
+  for (const warning of resolved.warnings)
+    warn(warning);
+  setActiveStoreSettings({ busyTimeoutMs: resolved.config.effortBusyTimeoutMs });
+  return resolved;
+}
+
+// src/commands/plan/plan-files.ts
+function plansDirAt(root, planDir) {
+  return { label: planDir, path: resolve3(root, planDir) };
+}
+function requireProject(context, command) {
+  if (context.project === null)
+    throw new Error(`${command} runs inside a project, and was handed none`);
+  return context.project;
+}
+function resolvePlansDir(project, command, warn) {
+  return plansDirAt(project.root, resolveProjectConfig(project, command, warn).planDir);
+}
+function resolveProjectConfig(project, command, warn) {
+  try {
+    return loadConfig({ root: project.root, home: project.home }, {}, warn).config;
+  } catch (error) {
+    if (!(error instanceof ConfigError))
+      throw error;
+    throw new CommandExit(1, [
+      `\u274C ${command}: the config cannot be used:`,
+      ...error.problems.map((problem) => `   ${problem}`)
+    ].join(`
+`));
+  }
+}
+var CHECKBOXES = {
+  unchecked: "[ ]",
+  blocked: "[BLOCKED]",
+  done: "[x]"
+};
+function countTasks(tasks) {
+  const done = tasks.filter((task) => task.status === "done").length;
+  const blocked = tasks.filter((task) => task.status === "blocked").length;
+  return { total: tasks.length, done, blocked, open: tasks.length - done - blocked };
+}
+function formatCounts(counts) {
+  return `${counts.done}/${counts.total} done, ${counts.blocked} blocked, ${counts.open} open`;
+}
+function checkbox(status) {
+  return CHECKBOXES[status];
+}
+function planFileName(stub, tracker) {
+  return tracker ? `PLAN_TRACKER-${stub}.md` : `PLAN-${stub}.md`;
+}
+function stubOfPlanFile(name2) {
+  const stub = /^PLAN-(.+)\.md$/.exec(name2)?.[1];
+  return stub !== undefined && isStampableStub(stub) ? stub : null;
+}
+function isFile(path) {
+  return statSync2(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 expectNoArgument(args, usage) {
+  if (args.length === 0)
+    return;
+  throw new CommandExit(1, `\u274C Expected no argument, got ${args.length}: ${args.join(" ")}
+Usage: ${usage}`);
+}
+function expectOneArgument(args, usage) {
+  const [only] = args;
+  if (args.length === 1 && only !== undefined)
+    return only;
+  const got = args.length === 0 ? "none" : `${args.length}: ${args.join(" ")}`;
+  throw new CommandExit(1, `\u274C Expected one argument, got ${got}
+Usage: ${usage}`);
+}
+function expectAtMostOneArgument(args, usage) {
+  const [only] = args;
+  if (only === undefined)
+    return null;
+  if (args.length === 1)
+    return only;
+  throw new CommandExit(1, `\u274C Expected at most one argument, got ${args.length}: ${args.join(" ")}
+Usage: ${usage}`);
+}
+function readSwitch(name2, 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}`);
+}
+
+// src/commands/effort/fix-schema.ts
+var COMMAND_NAME = "rafa effort fix-schema";
+var FIX_SCHEMA_USAGE = "rafa effort fix-schema [--dry-run]";
+var DRY_RUN_FLAG = "dry-run";
+function fileStamp(date) {
+  return date.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
+function refuseLiveLoop(root, isAlive) {
+  let records;
+  try {
+    records = readSessions(root, isAlive === undefined ? {} : { isAlive });
+  } catch (error) {
+    throw new CommandExit(1, `\u274C ${COMMAND_NAME}: the loop's run records cannot be read, so a live loop cannot be ruled out: ${String(error)}`);
+  }
+  const live = records.find((record) => record.state === "running" || record.state === "paused");
+  if (live === undefined)
+    return;
+  throw new CommandExit(1, `\u274C ${COMMAND_NAME}: loop session ${live.sessionId} on ${live.branch} is ${live.state} and writes the store;` + ` stop it with \`rafa loop stop -s ${live.sessionId}\` first. \`--dry-run\` runs beside it.`);
+}
+function migrationNames(result) {
+  return result.unknown.map(({ id, appliedBy }) => `${id} (applied by ${appliedBy})`).join(", ");
+}
+function rebuildLines(result) {
+  const rows = result.kept.reduce((sum, table) => sum + table.rows, 0);
+  const kept = result.kept.map((table) => `${table.table} ${String(table.rows)}`).join(", ");
+  const left = [
+    ...result.unknown.map(({ id, appliedBy }) => `migration ${id} (applied by ${appliedBy})`),
+    ...result.leftTables.map((table) => `table ${table.table} (${String(table.rows)} rows)`),
+    ...result.leftColumns.map((column) => `column ${column.table}.${column.column} (${String(column.values)} values)`)
+  ];
+  const newer = result.unknown.length === 0 ? [] : [`A rafa that knows ${result.unknown.map(({ id }) => id).join(", ")} uses the store as it is and keeps that data` + " in it; install one instead where you can."];
+  return [
+    `Refused as ${String(result.reason)}: ${String(result.refusal)}`,
+    `Rebuilds it at the ${String(result.known.length)} migrations this rafa knows, logged as applied by ${result.appliedBy}.`,
+    `Keeps ${String(result.kept.length)} tables, ${String(rows)} rows: ${kept}.`,
+    left.length === 0 ? "Leaves nothing behind." : `Leaves behind, kept only in the backup: ${left.join("; ")}.`,
+    ...newer
+  ];
+}
+function unknownAdditiveLines(result) {
+  return result.unknown.length === 0 ? [] : [`It logs ${migrationNames(result)}, which this rafa does not know; each is additive, so this rafa uses the store` + " through them."];
+}
+function renderFixSchema(result) {
+  switch (result.status) {
+    case "missing":
+      return [`No effort store at ${result.path}: nothing to repair.`];
+    case "current":
+      return [
+        `\u2705 ${result.path} is current: this rafa reads and writes it as it is. Nothing to repair.`,
+        ...unknownAdditiveLines(result)
+      ];
+    case "behind":
+      return [
+        `${result.path} is behind this rafa's migrations; the next command that opens it records` + ` ${result.pending.join(", ")}. Nothing to repair.`,
+        ...unknownAdditiveLines(result)
+      ];
+    case "would-rebuild":
+      return [
+        ...rebuildLines(result),
+        "\uD83D\uDD0D Dry run: the rebuild was built, checked (row counts, integrity_check, this rafa's schema plan) and" + " deleted. Run without `--dry-run` to swap it in."
+      ];
+    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."
+      ];
+  }
+}
+function runFixSchema(context, seams) {
+  expectNoArgument(context.args, FIX_SCHEMA_USAGE);
+  const dryRun = readSwitch(DRY_RUN_FLAG, context.flags[DRY_RUN_FLAG], `Usage: ${FIX_SCHEMA_USAGE}`);
+  if (context.project === null)
+    throw new Error(`${COMMAND_NAME} runs inside a project, and was handed none`);
+  const root = context.project.root;
+  if (!dryRun)
+    refuseLiveLoop(root, seams.isAlive);
+  const now = seams.now ?? (() => new Date);
+  let result;
+  try {
+    result = fixStoreSchema({
+      path: sqliteStorePath(root),
+      dryRun,
+      stamp: fileStamp(now()),
+      now,
+      ...seams.identity === undefined ? {} : { identity: seams.identity }
+    });
+  } catch (error) {
+    if (error instanceof RebuildRefusal)
+      throw new CommandExit(1, `\u274C ${COMMAND_NAME}: ${error.message}`);
+    throw error;
+  }
+  if (context.outputMode === "json") {
+    context.output.result(result);
+    return;
+  }
+  for (const line of renderFixSchema(result))
+    context.output.info(line);
+}
+function createFixSchemaCommand(seams = {}) {
+  const command = {
+    name: "effort fix-schema",
+    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.",
+    args: [],
+    flags: [
+      {
+        name: DRY_RUN_FLAG,
+        description: "Build and check the rebuild, print what it keeps and leaves behind, then delete it. The" + " live store is only read, so this runs beside a live loop and from a development build, and can be" + " repeated.",
+        type: "boolean"
+      }
+    ],
+    examples: [
+      {
+        cmd: "rafa effort fix-schema --dry-run",
+        note: "Prints what a rebuild would keep and leave behind, changing nothing."
+      },
+      {
+        cmd: "rafa effort fix-schema",
+        note: "Swaps the rebuild in and prints where the original was kept."
+      }
+    ],
+    outputs: ["text", "json"],
+    run: async (context) => {
+      runFixSchema(context, seams);
+      await Promise.resolve();
+    }
+  };
+  return Object.freeze(command);
+}
+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 { tmpdir as tmpdir3 } from "os";
+import { dirname as dirname10, join as join11 } from "path";
+import { Database as Database5, SQLiteError as SQLiteError2 } from "bun:sqlite";
+
+// src/effort/commits.ts
+import { execFileSync } from "child_process";
+var COMMIT_RECORD_MARKER = "@@ralph-commit@@";
+var HEADER_PLACEHOLDERS = ["%H", "%aI", "%P", "%an", "%S", "%s"];
+var FIELD_SEPARATOR = "\t";
+var COMMIT_LOG_FORMAT = [
+  COMMIT_RECORD_MARKER,
+  ...HEADER_PLACEHOLDERS
+].join("%x09");
+var MS_PER_MINUTE = 60000;
+var ELAPSED_DECIMALS = 3;
+function normaliseBranch(source) {
+  if (source.length === 0 || source === "HEAD")
+    return null;
+  return source.startsWith("refs/heads/") ? source.slice("refs/heads/".length) : source;
+}
+function parseStatCount(field2) {
+  return /^\d+$/.test(field2) ? Number(field2) : null;
+}
+function parseCommitHeader(line) {
+  const parts = line.split(FIELD_SEPARATOR);
+  if (parts[0] !== COMMIT_RECORD_MARKER)
+    return null;
+  if (parts.length <= HEADER_PLACEHOLDERS.length)
+    return null;
+  const [sha, timestamp, parents, author, source] = parts.slice(1);
+  if (sha === undefined || sha.length === 0)
+    return null;
+  return {
+    sha,
+    timestamp: timestamp ?? "",
+    subject: parts.slice(HEADER_PLACEHOLDERS.length).join(FIELD_SEPARATOR),
+    author: author ?? "",
+    branch: normaliseBranch(source ?? ""),
+    filesChanged: 0,
+    insertions: 0,
+    deletions: 0,
+    parentCount: countParents(parents ?? ""),
+    minutesSincePrevious: null
+  };
+}
+function countParents(parents) {
+  return parents.trim().length === 0 ? 0 : parents.trim().split(/ +/).length;
+}
+function applyStatLine(row, line) {
+  const parts = line.split(FIELD_SEPARATOR);
+  if (parts.length < 3)
+    return false;
+  const added = parts[0] ?? "";
+  const removed = parts[1] ?? "";
+  const isBinary = added === "-" && removed === "-";
+  const addedCount = parseStatCount(added);
+  const removedCount = parseStatCount(removed);
+  if (!isBinary && (addedCount === null || removedCount === null)) {
+    return false;
+  }
+  row.filesChanged += 1;
+  row.insertions += addedCount ?? 0;
+  row.deletions += removedCount ?? 0;
+  return true;
+}
+function minutesBetween(earlier, later) {
+  const from = Date.parse(earlier);
+  const to = Date.parse(later);
+  if (Number.isNaN(from) || Number.isNaN(to))
+    return null;
+  const minutes = (to - from) / MS_PER_MINUTE;
+  return Number(minutes.toFixed(ELAPSED_DECIMALS));
+}
+function assignElapsedMinutes(rows) {
+  const ordered = rows.map((row, index) => ({ index, epoch: Date.parse(row.timestamp) })).filter((entry) => !Number.isNaN(entry.epoch)).sort((a, b) => a.epoch - b.epoch);
+  for (let position = 1;position < ordered.length; position += 1) {
+    const entry = ordered[position];
+    const previous = ordered[position - 1];
+    if (entry === undefined || previous === undefined)
+      continue;
+    const row = rows[entry.index];
+    const earlier = rows[previous.index];
+    if (row === undefined || earlier === undefined)
+      continue;
+    row.minutesSincePrevious = minutesBetween(earlier.timestamp, row.timestamp);
+  }
+}
+function parseCommitLog(text) {
+  const rows = [];
+  let lineCount = 0;
+  let unparsedLineCount = 0;
+  let open = null;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trimEnd();
+    if (line.trim().length === 0)
+      continue;
+    lineCount += 1;
+    const header = parseCommitHeader(line);
+    if (header !== null) {
+      rows.push(header);
+      open = header;
+      continue;
+    }
+    if (open === null || !applyStatLine(open, line)) {
+      unparsedLineCount += 1;
+    }
+  }
+  assignElapsedMinutes(rows);
+  return { rows, lineCount, unparsedLineCount };
+}
+function commitLogArgs(options = {}) {
+  const args = [
+    "log",
+    "--source",
+    `--format=${COMMIT_LOG_FORMAT}`,
+    "--numstat"
+  ];
+  if (options.since !== undefined)
+    args.push(`--since=${options.since}`);
+  if (options.maxCount !== undefined) {
+    args.push(`--max-count=${options.maxCount}`);
+  }
+  if (options.revisionRange !== undefined)
+    args.push(options.revisionRange);
+  return args;
+}
+function readCommitLog(options = {}) {
+  const stdout = execFileSync("git", commitLogArgs(options), {
+    cwd: options.cwd ?? process.cwd(),
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024
+  });
+  return parseCommitLog(stdout);
+}
+
+// src/effort/store/merge-commit-gaps.ts
+var GAP_FIELD = "minutesSincePrevious";
+var UPDATE_GAP = "UPDATE commits SET row_json = ? WHERE seq = ?";
+function parsedObject2(text) {
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function withoutGap(rowJson) {
+  const row = parsedObject2(rowJson);
+  if (row === null)
+    return rowJson;
+  const rest = Object.fromEntries(Object.entries(row).filter(([key]) => key !== GAP_FIELD));
+  return JSON.stringify(rest);
+}
+function readCommits(db) {
+  return db.query("SELECT seq, sha, row_json FROM commits").all().map(({ seq, sha, row_json: rowJson }) => {
+    const row = parsedObject2(rowJson);
+    const timestamp = typeof row?.timestamp === "string" ? row.timestamp : null;
+    return { seq, sha, row, timestamp, epoch: timestamp === null ? Number.NaN : Date.parse(timestamp) };
+  });
+}
+function timeOrder(entries) {
+  return entries.filter((entry) => !Number.isNaN(entry.epoch)).sort((left, right) => left.epoch - right.epoch || compareText(left.sha, right.sha));
+}
+function compareText(left, right) {
+  if (left === right)
+    return 0;
+  return left < right ? -1 : 1;
+}
+function storedGap(entry) {
+  const value = entry.row?.[GAP_FIELD];
+  return typeof value === "number" ? value : null;
+}
+function namedRows(inserted, positions, order) {
+  const position = positions.get(inserted.seq);
+  if (position === undefined)
+    return [inserted.seq];
+  const next = order[position + 1];
+  return next === undefined ? [inserted.seq] : [inserted.seq, next.seq];
+}
+function recomputedGap(entry, positions, order) {
+  const position = positions.get(entry.seq);
+  if (position === undefined || position === 0)
+    return null;
+  const previous = order[position - 1];
+  if (previous?.timestamp == null || entry.timestamp === null)
+    return null;
+  return minutesBetween(previous.timestamp, entry.timestamp);
+}
+function recomputeCommitGaps(db, inserted) {
+  return db.transaction(() => {
+    const entries = readCommits(db);
+    const bySeq = new Map(entries.map((entry) => [entry.seq, entry]));
+    const order = timeOrder(entries);
+    const positions = new Map(order.map((entry, position) => [entry.seq, position]));
+    const named = new Set(inserted.flatMap((seq) => {
+      const entry = bySeq.get(seq);
+      return entry === undefined ? [] : namedRows(entry, positions, order);
+    }));
+    const targets = [...named].map((seq) => bySeq.get(seq)).filter((entry) => entry?.row != null).sort((left, right) => (positions.get(left.seq) ?? -1) - (positions.get(right.seq) ?? -1));
+    return targets.flatMap((entry) => {
+      const before = storedGap(entry);
+      const after = recomputedGap(entry, positions, order);
+      if (before === after && entry.row !== null && Object.hasOwn(entry.row, GAP_FIELD))
+        return [];
+      db.query(UPDATE_GAP).run(JSON.stringify({ ...entry.row, [GAP_FIELD]: after }), entry.seq);
+      return [{ seq: entry.seq, sha: entry.sha, before, after }];
+    });
+  })();
+}
+
+// src/effort/store/merge-rules.ts
+var SET_ONCE = "set-once";
+var RECOMPUTED = "recomputed";
+var APPEND_ONLY = {};
+function appendOnly(...identity) {
+  return { scope: "merged", identity, edited: APPEND_ONLY };
+}
+var MERGE_RULES = {
+  sessions: appendOnly("session_id"),
+  commits: { scope: "merged", identity: ["sha"], edited: { row_json: RECOMPUTED } },
+  findings: { scope: "merged", identity: ["id"], edited: { tracker_ref: SET_ONCE } },
+  blockers: appendOnly("id"),
+  out_of_scope_bugs: appendOnly("id"),
+  report_absences: appendOnly("id"),
+  task_reports: appendOnly("id"),
+  preflight: appendOnly("run_id", "position"),
+  dispatches: appendOnly("session_id"),
+  changes: appendOnly("id"),
+  skill_invocations: appendOnly("session_id", "name", "sidechain"),
+  plan_ci: appendOnly("pr", "head_sha", "read_at"),
+  schema_migrations: { scope: "local" },
+  store_meta: { scope: "local" },
+  merges: { scope: "local" },
+  merge_conflicts: { scope: "local" }
+};
+
+// src/effort/store/merge-union.ts
+import { SQLiteError } from "bun:sqlite";
+class UnionSchemaMismatch extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnionSchemaMismatch";
+  }
+}
+var UNIQUE_REFUSAL = "SQLITE_CONSTRAINT_UNIQUE";
+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");
+}
+function refuseColumnMismatch(local, other, tables) {
+  const faults = tables.flatMap(({ table }) => {
+    const here = new Set(carriedColumns(local, table));
+    const there = new Set(carriedColumns(other, table));
+    const onlyHere = [...here].filter((column) => !there.has(column)).map((column) => `${table}.${column} only here`);
+    const onlyThere = [...there].filter((column) => !here.has(column)).map((column) => `${table}.${column} only there`);
+    return [...onlyHere, ...onlyThere];
+  });
+  if (faults.length > 0) {
+    throw new UnionSchemaMismatch(`the two stores hold different columns (${faults.join(", ")}); bring both to the same migrations first`);
+  }
+}
+function valueOf(row, column) {
+  return row[column] ?? null;
+}
+function byOrigin(local, table, row) {
+  const store = valueOf(row, "origin_store");
+  const seq = valueOf(row, "origin_seq");
+  if (store === null || seq === null)
+    return null;
+  return local.query(`SELECT seq FROM ${quoted(table)} WHERE origin_store = ? AND origin_seq = ?`).get(store, seq)?.seq ?? null;
+}
+function byIdentity(local, { table, identity }, row) {
+  const where = identity.map((column) => `${quoted(column)} IS ?`).join(" AND ");
+  return local.query(`SELECT seq FROM ${quoted(table)} WHERE ${where} ORDER BY seq LIMIT 1`).get(...identity.map((column) => valueOf(row, column)))?.seq ?? null;
+}
+function insertRow(local, table, columns, row, incomingSeq) {
+  const columnList = columns.map(quoted).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const nextSeq = `(SELECT COALESCE(MAX(seq), 0) + 1 FROM ${quoted(table)})`;
+  try {
+    const inserted = local.query(`INSERT INTO ${quoted(table)} (seq, ${columnList}) VALUES (${nextSeq}, ${placeholders}) RETURNING seq`).get(...columns.map((column) => valueOf(row, column)));
+    if (inserted === null)
+      throw new Error(`the insert into ${table} returned no seq`);
+    return { kind: "added", localSeq: inserted.seq };
+  } catch (error) {
+    if (!(error instanceof SQLiteError) || error.code !== UNIQUE_REFUSAL)
+      throw error;
+    return { kind: "collided", collision: { incomingSeq, reason: error.message } };
+  }
+}
+function placeRow(local, merged, columns, row) {
+  const incomingSeq = Number(valueOf(row, "seq"));
+  const origin = byOrigin(local, merged.table, row);
+  if (origin !== null)
+    return { kind: "matched", match: { localSeq: origin, incomingSeq, by: "origin" } };
+  const identity = byIdentity(local, merged, row);
+  if (identity !== null)
+    return { kind: "matched", match: { localSeq: identity, incomingSeq, by: "identity" } };
+  return insertRow(local, merged.table, columns, row, incomingSeq);
+}
+function unionTable(local, other, merged) {
+  const columns = carriedColumns(local, merged.table);
+  const incoming = other.query(`SELECT seq, ${columns.map(quoted).join(", ")} FROM ${quoted(merged.table)} ORDER BY seq`).all();
+  const outcomes = incoming.map((row) => placeRow(local, merged, columns, row));
+  return {
+    table: merged.table,
+    added: outcomes.flatMap((outcome) => outcome.kind === "added" ? [outcome.localSeq] : []),
+    matched: outcomes.flatMap((outcome) => outcome.kind === "matched" ? [outcome.match] : []),
+    collided: outcomes.flatMap((outcome) => outcome.kind === "collided" ? [outcome.collision] : [])
+  };
+}
+function unionStores(local, other) {
+  const tables = mergedTables();
+  refuseColumnMismatch(local, other, tables);
+  return local.transaction(() => tables.map((merged) => unionTable(local, other, merged)))();
+}
+
+// src/effort/store/merge-conflicts.ts
+var SET_ONCE_FILLS = {
+  "findings.tracker_ref": "UPDATE findings SET tracker_ref = ? WHERE seq = ? AND tracker_ref IS NULL"
+};
+var RECOMPUTED_COMPARISONS = {
+  "commits.row_json": withoutGap
+};
+var NOT_CONTENT = new Set(["seq", "origin_store", "origin_seq"]);
+var INSERT_CONFLICT = `INSERT INTO merge_conflicts (merge_id, table_name, local_seq, field, incoming, recorded_at)
+  VALUES (?, ?, ?, ?, ?, ?)`;
+function rowAt(db, table, columns, seq, side) {
+  const row = db.query(`SELECT seq, ${columns.map(quoted).join(", ")} FROM ${quoted(table)} WHERE seq = ?`).get(seq);
+  if (row === null)
+    throw new Error(`the union matched ${table} row ${seq} ${side}, which that store does not hold`);
+  return row;
+}
+function sameValue(left, right) {
+  if (left instanceof Uint8Array && right instanceof Uint8Array)
+    return Buffer.from(left).equals(right);
+  return (left ?? null) === (right ?? null);
+}
+function fillStatement(table, field2) {
+  const statement = SET_ONCE_FILLS[`${table}.${field2}`];
+  if (statement === undefined) {
+    throw new Error(`${table}.${field2} 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;
+  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: [] };
+}
+function settleRecomputed(table, field2, here, there) {
+  const comparable = RECOMPUTED_COMPARISONS[`${table}.${field2}`];
+  if (comparable === undefined) {
+    throw new Error(`${table}.${field2} is recomputed in MERGE_RULES and has no entry in RECOMPUTED_COMPARISONS`);
+  }
+  const hereValue = here[field2];
+  const thereValue = there[field2];
+  const same = typeof hereValue === "string" && typeof thereValue === "string" && comparable(hereValue) === comparable(thereValue);
+  return same ? { skipped: true, filled: [], conflictFields: [] } : { skipped: false, filled: [], conflictFields: [null] };
+}
+function settlePair(local, table, edited, here, there) {
+  const differing = Object.keys(here).filter((column) => !NOT_CONTENT.has(column) && !sameValue(here[column], there[column]));
+  if (differing.length === 0)
+    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`);
+  });
+  return {
+    skipped: outcomes.every((outcome) => outcome.skipped),
+    filled: outcomes.flatMap((outcome) => outcome.filled),
+    conflictFields: outcomes.flatMap((outcome) => outcome.conflictFields)
+  };
+}
+function settleTable(local, other, union, trail) {
+  const rule = MERGE_RULES[union.table];
+  if (rule?.scope !== "merged")
+    throw new Error(`${union.table} is not a merged table in MERGE_RULES`);
+  const columns = carriedColumns(local, union.table);
+  const settled = union.matched.map((match) => {
+    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 };
+    });
+    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 }))),
+    conflicts: settled.flatMap(({ conflicts }) => conflicts)
+  };
+}
+function settleMatches(local, other, unions, trail) {
+  return local.transaction(() => unions.map((union) => settleTable(local, other, union, trail)))();
+}
+
+// src/effort/store/migrate.ts
+import { existsSync as existsSync10 } from "fs";
+import { Database as Database4 } from "bun:sqlite";
+var LIVE2 = "live";
+function asidePaths2(path, first, stamp) {
+  return { parallelPath: `${path}.migrate-${stamp}`, backupPath: `${path}.before-${first}-${stamp}.bak` };
+}
+function liveLoop(path, options, nothingDone = "Nothing was migrated.") {
+  const root = storeProjectRoot(path);
+  if (root === null)
+    return;
+  let records;
+  try {
+    records = readSessions(root, { isAlive: options.isAlive ?? isPidAlive });
+  } catch (error) {
+    throw new RebuildRefusal(`the loop's run records cannot be read, so a live loop on ${path} cannot be ruled out` + ` (${messageOf(error)}). ${nothingDone}`);
+  }
+  return records.find((record) => record.state === "running" || record.state === "paused");
+}
+function refuseLiveLoop2(path, breaking, options) {
+  const loop = liveLoop(path, options);
+  if (loop === undefined)
+    return;
+  const named = `loop ${loop.sessionId} (pid ${String(loop.pid)}, plan ${loop.planStub ?? loop.plan}) is running on this store`;
+  const [first] = breaking;
+  const opening = first === undefined ? `REFUSED \u2014 ${named}, and swapping the migrated store in under it would lose what it writes.` : `REFUSED \u2014 migration ${first} breaks older runtimes, and ${named}.`;
+  throw new RebuildRefusal(`${opening} Nothing was migrated. Finish or stop that loop, then run it again.`);
+}
+function buildMigrated(path, parallelPath, migrations, stamp) {
+  vacuumInto(path, parallelPath);
+  const db = new Database4(parallelPath, { readwrite: true });
+  try {
+    const brought = bringForward(db, parallelPath, "write", "migrate", { migrations, ...stamp, builtAside: true });
+    db.run(`ATTACH DATABASE ? AS ${LIVE2}`, [path]);
+    const live = new Set(tableNames(db, LIVE2));
+    const counted = checkedCounts(db, tableNames(db, "main").filter((table) => live.has(table)), LIVE2);
+    db.run(`DETACH DATABASE ${LIVE2}`);
+    refuseCorrupt(db);
+    refuseUnusable(db, parallelPath, migrations);
+    return { userVersion: brought.userVersion, counted };
+  } finally {
+    db.close();
+  }
+}
+function migrateStore(options) {
+  const { path, dryRun, stamp } = options;
+  guardTestProcess(path);
+  const migrations = options.migrations ?? SQLITE_MIGRATIONS;
+  const appliedBy = appliedByName(options.identity ?? readRuntimeIdentity());
+  const nothing = { applying: [], breaking: [], unknown: [], userVersion: null, counted: [], backupPath: null };
+  if (!existsSync10(path)) {
+    return { path, status: "missing", storeVersion: null, logged: false, appliedBy, ...nothing };
+  }
+  refuseInFlight(path);
+  const store = readOnlySchema(path);
+  const found = { path, storeVersion: store.userVersion, logged: store.log !== null, appliedBy };
+  const plan = planSchema(store, sqliteCatalogue(migrations), "write", "migrate");
+  if (plan.verdict === "refuse")
+    throw new RebuildRefusal(plan.message);
+  const applying = writeNames(plan);
+  const planned = {
+    applying,
+    breaking: plan.pending.filter(({ breaks }) => breaks.length > 0).map(({ id }) => id),
+    unknown: plan.unknown
+  };
+  if (applying.length === 0)
+    return { ...found, ...nothing, ...planned, status: "current" };
+  if (!dryRun) {
+    refuseUnownedDevelopmentWrite(path, applying, options);
+    refuseLiveLoop2(path, planned.breaking, options);
+  }
+  const first = plan.pending[0]?.id ?? ADOPTION_NAME;
+  const { built, backupPath } = rebuildAside({
+    path,
+    ...asidePaths2(path, first, stamp),
+    dryRun,
+    build: (parallelPath) => buildMigrated(path, parallelPath, migrations, {
+      appliedBy,
+      now: options.now ?? (() => new Date)
+    })
+  });
+  const status = dryRun ? "would-migrate" : "migrated";
+  return { ...found, ...planned, ...built, status, backupPath };
+}
+
+// src/effort/store/merge-store.ts
+var MOVE_TO_SQLITE = "rafa effort move --to=sqlite";
+
+class MergeRefusal extends RebuildRefusal {
+  reason;
+  constructor(reason, message) {
+    super(message);
+    this.name = "MergeRefusal";
+    this.reason = reason;
+  }
+}
+var LIVE3 = "live";
+var MERGES_TABLE = "merges";
+var INSERT_MERGE = `INSERT INTO merges (id, other_store, merged_at, rows_added, rows_skipped, rows_in_conflict)
+  VALUES (?, ?, ?, ?, ?, ?)`;
+var NOTHING_MERGED = "Nothing was merged.";
+function refuseNdjson(backend) {
+  if (backend !== "ndjson")
+    return;
+  throw new MergeRefusal("ndjson", `REFUSED \u2014 this project keeps its sessions and commits as NDJSON (store: ndjson), and a merge needs the SQLite store. ${NOTHING_MERGED}` + ` Next safe step: ${MOVE_TO_SQLITE}`);
+}
+function refuseMissing(path, which) {
+  if (existsSync11(path))
+    return;
+  throw new MergeRefusal("missing", `REFUSED \u2014 ${which} ${path} is not there. ${NOTHING_MERGED}`);
+}
+function refuseDamaged(path) {
+  let answers;
+  try {
+    const db = new Database5(path, { readonly: true });
+    try {
+      answers = db.query("PRAGMA integrity_check").all().map((row) => row.integrity_check);
+    } finally {
+      db.close();
+    }
+  } catch (error) {
+    if (!(error instanceof SQLiteError2))
+      throw error;
+    throw new MergeRefusal("damaged", `REFUSED \u2014 ${path} cannot be read as a SQLite store (${error.message}). ${NOTHING_MERGED}` + " Take a consistent copy on its device with rafa effort copy, and merge that.");
+  }
+  if (answers.length === 1 && answers[0] === "ok")
+    return;
+  throw new MergeRefusal("damaged", `REFUSED \u2014 ${path} failed integrity_check: ${answers.join("; ")}. ${NOTHING_MERGED}` + " Take a consistent copy on its device with rafa effort copy, and merge that.");
+}
+function writablePlan(path, migrations) {
+  const plan = planSchema(readOnlySchema(path), sqliteCatalogue(migrations), "write", "open");
+  if (plan.verdict === "refuse")
+    throw new MergeRefusal("schema", `REFUSED \u2014 ${path}: ${plan.message}`);
+  return plan;
+}
+function recordedMeta(path) {
+  const db = new Database5(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;
+  } finally {
+    db.close();
+  }
+}
+function refuseOtherProject(options) {
+  const other = recordedMeta(options.otherPath);
+  const here = recordedMeta(options.path)?.projectRootCommit ?? (options.readProject ?? readProjectIdentity)(dirname10(options.path)).rootCommit;
+  const there = other?.projectRootCommit ?? null;
+  if (here !== null && there !== null && here !== there) {
+    throw new MergeRefusal("other-project", `REFUSED \u2014 ${options.otherPath} is the effort store of another project (root commit ${there});` + ` this store's project has root commit ${here}. ${NOTHING_MERGED}`);
+  }
+  return other?.storeId ?? null;
+}
+function refuseLiveLoop3(path, options) {
+  const loop = liveLoop(path, options, NOTHING_MERGED);
+  if (loop === undefined)
+    return;
+  throw new MergeRefusal("live-loop", `REFUSED \u2014 loop ${loop.sessionId} (pid ${String(loop.pid)}, plan ${loop.planStub ?? loop.plan}) is running on this store,` + ` and swapping the merged store in under it would lose what it writes. ${NOTHING_MERGED}` + " Finish or stop that loop, then run it again.");
+}
+function openOther(otherPath, plan, stamp) {
+  const needs = writeNames(plan);
+  if (needs.length === 0) {
+    const db = new Database5(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 });
+  };
+  try {
+    const copyPath = join11(dir, "other.sqlite");
+    vacuumInto(otherPath, copyPath);
+    const db = new Database5(copyPath, { readwrite: true });
+    try {
+      bringForward(db, copyPath, "write", "open", { ...stamp, builtAside: true });
+    } catch (error) {
+      release(db);
+      throw error;
+    }
+    return { db, broughtForward: needs, release: () => release(db) };
+  } catch (error) {
+    release();
+    throw error;
+  }
+}
+function mergeInto(db, other, mergeId, otherStore, mergedAt) {
+  return db.transaction(() => {
+    const unions = unionStores(db, other);
+    const settlements = settleMatches(db, other, unions, { mergeId, recordedAt: mergedAt });
+    const gaps = recomputeCommitGaps(db, unions.find(({ table }) => table === "commits")?.added ?? []);
+    const tables = unions.map((union, index) => {
+      const settled = settlements[index];
+      return {
+        table: union.table,
+        added: union.added.length,
+        skipped: settled?.skipped.length ?? 0,
+        inConflict: settled?.conflicts.length ?? 0,
+        filled: settled?.filled.length ?? 0,
+        collided: union.collided.length
+      };
+    });
+    const sum = (field2) => tables.reduce((total, entry) => total + entry[field2], 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 };
+  })();
+}
+function addedRows(merged) {
+  return {
+    ...Object.fromEntries(merged.tables.map(({ table, added }) => [table, added])),
+    [MERGES_TABLE]: 1,
+    merge_conflicts: merged.rowsInConflict
+  };
+}
+function buildMerged(path, parallelPath, other, merge2) {
+  vacuumInto(path, parallelPath);
+  const db = new Database5(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());
+    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);
+    return merged;
+  } finally {
+    db.close();
+  }
+}
+function refuseUnmergeable(options, migrations) {
+  const { path, otherPath } = options;
+  refuseNdjson(options.backend);
+  refuseMissing(path, "this store");
+  refuseMissing(otherPath, "the other store");
+  refuseInFlight(path);
+  refuseInFlight(otherPath);
+  refuseDamaged(otherPath);
+  const otherPlan = writablePlan(otherPath, migrations);
+  const localPlan = writablePlan(path, migrations);
+  const otherStore = refuseOtherProject(options);
+  if (!options.dryRun) {
+    refuseUnownedDevelopmentWrite(path, [...writeNames(localPlan), MERGES_TABLE], options);
+    refuseLiveLoop3(path, options);
+  }
+  return { otherPlan, otherStore };
+}
+function mergeStore(options) {
+  const { path, otherPath, dryRun, stamp } = options;
+  guardTestProcess(path);
+  guardTestProcess(otherPath);
+  const migrations = options.migrations ?? SQLITE_MIGRATIONS;
+  const { otherPlan, otherStore } = refuseUnmergeable(options, migrations);
+  const mergeStamp = {
+    migrations,
+    appliedBy: appliedByName(options.identity ?? readRuntimeIdentity()),
+    now: options.now ?? (() => new Date)
+  };
+  const mergeId = (options.newMergeId ?? randomUUID4)();
+  const other = openOther(otherPath, otherPlan, mergeStamp);
+  try {
+    const { built, backupPath } = rebuildAside({
+      path,
+      parallelPath: `${path}.merge-${stamp}`,
+      backupPath: `${path}.before-merge-${stamp}.bak`,
+      dryRun,
+      build: (parallelPath) => buildMerged(path, parallelPath, other.db, { id: mergeId, otherStore, stamp: mergeStamp })
+    });
+    const status = dryRun ? "would-merge" : "merged";
+    return { path, otherPath, status, mergeId, otherStore, otherBroughtForward: other.broughtForward, ...built, backupPath };
+  } finally {
+    other.release();
+  }
+}
+
+// src/effort/sync/file.ts
+var REFUSAL = "effort sync (file)";
+var NOTHING_COPIED = "Nothing was copied.";
+
+class FileSyncRefusal extends Error {
+  name = "FileSyncRefusal";
+}
+function requirePath(field2, value) {
+  if (typeof value === "string" && value !== "")
+    return value;
+  throw new TypeError(`${REFUSAL}: ${field2} is ${describeValue(value)}, expected a path`);
+}
+function refuseUncarriable(backend, source) {
+  if (backend === "ndjson") {
+    throw new FileSyncRefusal(`${REFUSAL}: this project keeps its sessions and commits as NDJSON (store: ndjson), and the file carried` + ` is effort.sqlite, which would hold none of them. ${NOTHING_COPIED} Next safe step: ${MOVE_TO_SQLITE}`);
+  }
+  if (!existsSync12(join12(source, SQLITE_STORE_FILE_NAME))) {
+    throw new FileSyncRefusal(`${REFUSAL}: no ${SQLITE_STORE_FILE_NAME} in ${source}. ${NOTHING_COPIED}`);
+  }
+}
+function mergeSeams(options) {
+  const { identity, env, tempDir, isAlive, migrations, newMergeId, readProject } = options;
+  const seams = { identity, env, tempDir, isAlive, migrations, newMergeId, readProject };
+  return Object.fromEntries(Object.entries(seams).filter(([, value]) => value !== undefined));
+}
+function createFileSync(options) {
+  const { repoRoot, backend } = options;
+  const now = options.now ?? (() => new Date);
+  const storeDir = () => effortStoreDir(repoRoot, options.env);
+  const push = async ({ to }) => {
+    const target = resolve5(repoRoot, requirePath("to", to));
+    const source = storeDir();
+    refuseUncarriable(backend, source);
+    const copied = copyEffortStore({ source, target });
+    return Object.freeze({ status: "pushed", path: join12(copied.directory, SQLITE_STORE_FILE_NAME) });
+  };
+  const pull = async ({ from, dryRun }) => {
+    const otherPath = resolve5(repoRoot, requirePath("from", from));
+    const path = join12(storeDir(), SQLITE_STORE_FILE_NAME);
+    const merge2 = mergeStore({ ...mergeSeams(options), path, otherPath, backend, dryRun, stamp: fileStamp(now()), now });
+    return Object.freeze({ status: "pulled", merge: merge2 });
+  };
+  return Object.freeze({ kind: "file", push, pull });
+}
+
+// src/effort/sync/select.ts
+var REFUSAL2 = "effort sync";
+var MODULE_SYNC_STRATEGIES = Object.freeze(["git", "service", "p2p"]);
+var MODULE_DIRECTORY_PLACEHOLDER = "<module directory>";
+var MODULE_NAME_PLACEHOLDER = "<module name>";
+var NOTHING_TO_SYNC = Object.freeze({ status: "nothing-to-sync" });
+function createLocalSync() {
+  return Object.freeze({
+    kind: "local",
+    push: async () => NOTHING_TO_SYNC,
+    pull: async () => NOTHING_TO_SYNC
+  });
+}
+function listed(registered) {
+  return registered.length === 0 ? "none" : registered.join(", ");
+}
+function moduleMissingMessage(kind, registered) {
+  return [
+    `${REFUSAL2}: effort.sync is "${kind}", and no module registers a sync adapter of that kind` + ` (registered: ${listed(registered)}). Core ships no ${kind} strategy; load a module that provides` + " one with these lines in .rafa/config.yaml:",
+    "modules:",
+    `  - path: ${MODULE_DIRECTORY_PLACEHOLDER}`,
+    "allowList:",
+    `  - ${MODULE_NAME_PLACEHOLDER}`
+  ].join(`
+`);
+}
+
+class SyncModuleMissing extends Error {
+  name = "SyncModuleMissing";
+  kind;
+  constructor(kind, registered) {
+    super(moduleMissingMessage(kind, registered));
+    this.kind = kind;
+  }
+}
+function isModuleStrategy(kind) {
+  return MODULE_SYNC_STRATEGIES.includes(kind);
+}
+function selectSync(repoRoot, config, registry = CORE_ADAPTER_REGISTRY) {
+  const kind = config.effortSync;
+  const adapter = typeof kind === "string" ? registry.find("sync", kind) : undefined;
+  if (adapter !== undefined) {
+    return adapter.create(config.store === undefined ? { repoRoot } : { repoRoot, store: config.store });
+  }
+  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(", ")}`;
+  throw new TypeError(`${REFUSAL2}: effort.sync is ${describeValue(kind)}, and no sync adapter is registered under it; ${expected}`);
+}
+
 // src/adapters/learning/local.ts
 import { appendFile, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { join as join12 } from "path";
+import { join as join15 } from "path";
 
 // src/commands/instinct/instinct-records.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
-import { join as join11 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync8, statSync as statSync5 } from "fs";
+import { join as join14 } from "path";
 
 // src/check/layout.ts
-import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join10, relative as relative2 } from "path";
+import { readdirSync as readdirSync3, statSync as statSync4 } from "fs";
+import { join as join13, relative as relative2 } from "path";
 var SKILL_FILE = "SKILL.md";
 var MARKDOWN_EXTENSION = ".md";
 var LAYOUT_SEVERITY = Object.freeze({
@@ -1806,7 +3260,7 @@ function layoutIssue(code, message) {
 }
 function entryKind(path) {
   try {
-    const stats = statSync2(path);
+    const stats = statSync4(path);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -1817,7 +3271,7 @@ function entryKind(path) {
   }
 }
 function visibleNames(dir) {
-  return readdirSync2(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
+  return readdirSync3(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
 }
 function isMarkdown(name2) {
   return name2.endsWith(MARKDOWN_EXTENSION);
@@ -1905,7 +3359,7 @@ function scanGroupMember(root, dir, name2) {
   const children = visibleNames(dir);
   if (children.length === 0)
     return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join10(dir, SKILL_FILE);
+  const skillPath = join13(dir, SKILL_FILE);
   if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
     return [nestedGroupEntry(root, skillPath, name2)];
   }
@@ -1914,7 +3368,7 @@ function scanGroupMember(root, dir, name2) {
 function scanSkillGroup(root, dir, children) {
   const entries = [];
   for (const child of children) {
-    const path = join10(dir, child);
+    const path = join13(dir, child);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("skill", root, path));
@@ -1935,7 +3389,7 @@ function scanSkillDirectory(root, dir, name2) {
   const children = visibleNames(dir);
   if (children.length === 0)
     return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join10(dir, SKILL_FILE);
+  const skillPath = join13(dir, SKILL_FILE);
   if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
     return [skillFileEntry(skillPath, name2)];
   }
@@ -1944,7 +3398,7 @@ function scanSkillDirectory(root, dir, name2) {
 function scanSkillRoot(root) {
   const entries = [];
   for (const name2 of visibleNames(root)) {
-    const path = join10(root, name2);
+    const path = join13(root, name2);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("skill", root, path));
@@ -1965,7 +3419,7 @@ function scanInstinctSubdirectory(root, dir) {
     return [dotfileOnlyEntry("instinct", root, dir)];
   const entries = [];
   for (const child of children) {
-    const path = join10(dir, child);
+    const path = join13(dir, child);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("instinct", root, path));
@@ -1983,7 +3437,7 @@ function scanInstinctSubdirectory(root, dir) {
 function scanInstinctRoot(root) {
   const entries = [];
   for (const name2 of visibleNames(root)) {
-    const path = join10(root, name2);
+    const path = join13(root, name2);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("instinct", root, path));
@@ -2436,7 +3890,7 @@ function unreadableIssue(message) {
 function readRecord(path, scope, id) {
   let text;
   try {
-    text = readFileSync7(path, "utf8");
+    text = readFileSync8(path, "utf8");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return { scope, path, id, instinct: null, issues: [unreadableIssue(message)] };
@@ -2444,15 +3898,15 @@ function readRecord(path, scope, id) {
   const parsed = parseInstinct(text);
   return { scope, path, id, instinct: parsed.instinct, issues: parsed.issues };
 }
-function isFile(path) {
+function isFile2(path) {
   try {
-    return statSync3(path).isFile();
+    return statSync5(path).isFile();
   } catch {
     return false;
   }
 }
 function recordFiles(dir) {
-  return readdirSync3(dir).filter((name2) => isRecordFile(name2) && isFile(join11(dir, name2))).sort((left, right) => left.localeCompare(right));
+  return readdirSync4(dir).filter((name2) => isRecordFile(name2) && isFile2(join14(dir, name2))).sort((left, right) => left.localeCompare(right));
 }
 function readScope(scope, dir) {
   if (!tierExists(dir))
@@ -2461,7 +3915,7 @@ function readScope(scope, dir) {
     scope,
     dir,
     exists: true,
-    records: recordFiles(dir).map((name2) => readRecord(join11(dir, name2), scope, recordId(name2)))
+    records: recordFiles(dir).map((name2) => readRecord(join14(dir, name2), scope, recordId(name2)))
   };
 }
 function readScopes(seams) {
@@ -2480,7 +3934,7 @@ function instinctProject(context, name2) {
 }
 
 // src/adapters/learning/held.ts
-function compareText(left, right) {
+function compareText2(left, right) {
   if (left < right) {
     return -1;
   }
@@ -2490,7 +3944,7 @@ function compareText(left, right) {
   return 0;
 }
 function byAge(left, right) {
-  return compareText(left.createdAt, right.createdAt) || compareText(left.id, right.id);
+  return compareText2(left.createdAt, right.createdAt) || compareText2(left.id, right.id);
 }
 function toHeldRecord(instinct) {
   return {
@@ -2764,7 +4218,7 @@ function heldChanges(dir, held, result, described) {
     if (issue2 !== undefined) {
       throw new Error(`${PUSH_REFUSAL}: ${file} would not read back: ${issue2.field}: ${issue2.message}`);
     }
-    const path = join12(dir, file);
+    const path = join15(dir, file);
     if (held.unreadable.has(path)) {
       throw new Error(`${PUSH_REFUSAL}: it would overwrite ${path}, which could not be read`);
     }
@@ -2794,18 +4248,18 @@ function pushLogLines(sourceId, described, result) {
   });
 }
 function localInstinctsDir(repoRoot) {
-  return join12(repoRoot, RAFA_INSTINCTS_PATH);
+  return join15(repoRoot, RAFA_INSTINCTS_PATH);
 }
 function userInstinctsDir(home) {
-  return join12(home, RAFA_INSTINCTS_PATH);
+  return join15(home, RAFA_INSTINCTS_PATH);
 }
 function createLocalLearning(options) {
   const { instinctsDir, minConfidence } = options;
   const userDir = userInstinctsDir(options.home);
   const now = options.now ?? (() => new Date().toISOString());
   const warn = options.warn ?? warnThroughActiveOutput;
-  const instinctsPath = join12(instinctsDir, INSTINCTS_FILE);
-  const flagsPath = join12(instinctsDir, FLAGS_FILE);
+  const instinctsPath = join15(instinctsDir, INSTINCTS_FILE);
+  const flagsPath = join15(instinctsDir, FLAGS_FILE);
   function readHeld(scope, dir) {
     const { records } = readScope(scope, dir);
     const unreadable = new Set;
@@ -2922,9 +4376,9 @@ function createJsonOutput({
 }
 
 // src/adapters/planner/claude.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
-import { posix, resolve as resolve3 } from "path";
+import { posix, resolve as resolve6 } from "path";
 
 // src/board/spec-review.ts
 var SPEC_REVIEW_KIND = "spec-review";
@@ -2960,8 +4414,8 @@ function describeValue3(value) {
 function messageOf2(error) {
   return error instanceof Error ? error.message : String(error);
 }
-function counted(count, noun) {
-  return count === 1 ? `1 ${noun}` : `${String(count)} ${noun}s`;
+function counted(count2, noun) {
+  return count2 === 1 ? `1 ${noun}` : `${String(count2)} ${noun}s`;
 }
 function valueAt(mapping, key) {
   return Object.hasOwn(mapping, key) ? mapping[key] ?? null : null;
@@ -3187,17 +4641,18 @@ function guardSpend() {
   if (refusal !== null)
     throw new UndeclaredSpendError(refusal);
 }
-async function spawnClaude(args, prompt) {
+async function spawnClaude(args, prompt, options = {}) {
   guardSpend();
   if (activeOutputMode() === "json") {
-    const { exitCode } = await spawnCaptured(args, prompt);
+    const { exitCode } = await spawnCaptured(args, prompt, options);
     return exitCode;
   }
   const proc = Bun.spawn([CLAUDE_BIN, ...args], {
     stdin: new TextEncoder().encode(prompt),
     stdout: "inherit",
     stderr: "inherit",
-    env: sessionSpawnEnv(process.env)
+    env: sessionSpawnEnv(process.env),
+    ...cwdOption(options)
   });
   liveSessions.add(proc);
   try {
@@ -3206,8 +4661,11 @@ async function spawnClaude(args, prompt) {
     liveSessions.delete(proc);
   }
 }
-function runClaude(prompt, settingSources, flags = [], spawn = spawnClaude, served = []) {
-  return spawn(claudeArgs(settingSources, flags, served), prompt);
+function runClaude(prompt, settingSources, flags = [], spawn = spawnClaude, served = [], options = {}) {
+  return spawn(claudeArgs(settingSources, flags, served), prompt, options);
+}
+function cwdOption(options) {
+  return options.cwd === undefined ? {} : { cwd: options.cwd };
 }
 function writeWholeLines(text, write) {
   const lines = text.split(`
@@ -3251,7 +4709,7 @@ async function spawnCaptured(args, prompt, options = {}) {
     stdout: "pipe",
     stderr: "inherit",
     env: sessionSpawnEnv(process.env),
-    ...options.cwd === undefined ? {} : { cwd: options.cwd }
+    ...cwdOption(options)
   });
   liveSessions.add(proc);
   let stdout;
@@ -3263,8 +4721,8 @@ async function spawnCaptured(args, prompt, options = {}) {
   }
   return { exitCode: await proc.exited, stdout };
 }
-function runClaudeCaptured(prompt, settingSources, flags = [], spawn = spawnClaudeCaptured, served = []) {
-  return spawn(claudeArgs(settingSources, flags, served), prompt);
+function runClaudeCaptured(prompt, settingSources, flags = [], spawn = spawnClaudeCaptured, served = [], options = {}) {
+  return spawn(claudeArgs(settingSources, flags, served), prompt, options);
 }
 
 // src/adapters/planner/claude.ts
@@ -3285,23 +4743,24 @@ class ClaudePlannerError extends Error {
 }
 function createClaudePlanner(options) {
   const { repoRoot, planDir, settingSources, buildPrompt, spawn = spawnClaudeCaptured } = options;
+  const root = resolve6(repoRoot);
   const create = async ({ specPath, stub }) => {
     const planPath = planFilePath(planDir, `PLAN-${stub}.md`);
     const prerequisitesPath = planFilePath(planDir, `PREREQUISITES-${stub}.md`);
-    const isWritten = (path) => existsSync6(resolve3(repoRoot, path));
+    const isWritten = (path) => existsSync13(resolve6(root, path));
     if (isWritten(planPath)) {
       throw new ClaudePlannerError(`${planPath} already exists`, FAILURE_EXIT_CODE);
     }
-    const specContent = await readFile2(resolve3(repoRoot, specPath), "utf8");
-    await mkdir2(resolve3(repoRoot, planDir), { recursive: true });
-    const session = await runClaudeCaptured(buildPrompt(specContent, stub), settingSources, [], spawn);
+    const specContent = await readFile2(resolve6(root, specPath), "utf8");
+    await mkdir2(resolve6(root, planDir), { recursive: true });
+    const session = await spawn(claudeArgs(settingSources), buildPrompt(specContent, stub), { cwd: root });
     const review = parseSpecReview(session.stdout);
     const { exitCode } = session;
     if (exitCode !== 0) {
       throw new ClaudePlannerError(`Plan generation failed (exit ${exitCode}).`, exitCode, review);
     }
     if (!isWritten(planPath)) {
-      throw new ClaudePlannerError(`The session finished but ${planPath} was not created \u2014 inspect the output above.`, FAILURE_EXIT_CODE, review);
+      throw new ClaudePlannerError(`The session finished but ${planPath} was not created under ${root} \u2014 inspect the output above.`, FAILURE_EXIT_CODE, review);
     }
     return {
       planPath,
@@ -3404,8 +4863,8 @@ async function withDeadline(work, timeoutMs) {
   if (timeoutMs === undefined)
     return work;
   let timer;
-  const deadline = new Promise((resolve4) => {
-    timer = setTimeout(() => resolve4(TIMED_OUT), timeoutMs);
+  const deadline = new Promise((resolve7) => {
+    timer = setTimeout(() => resolve7(TIMED_OUT), timeoutMs);
   });
   try {
     return await Promise.race([work, deadline]);
@@ -3710,7 +5169,7 @@ function createGithubTracker(options) {
 
 // src/adapters/tracker/local.ts
 import { mkdir as mkdir3, readdir, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { join as join13 } from "path";
+import { join as join16 } from "path";
 var PREFIX3 = "local tracker";
 var FRONTMATTER = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
 var ISSUE_NUMBER2 = /^[1-9]\d*$/;
@@ -3767,7 +5226,7 @@ function issueNumberOfFile(name2) {
   return name2.endsWith(ISSUE_EXTENSION) ? parseIssueNumber(name2.slice(0, -ISSUE_EXTENSION.length)) : null;
 }
 function issuePath(issuesDir, number) {
-  return join13(issuesDir, `${number}${ISSUE_EXTENSION}`);
+  return join16(issuesDir, `${number}${ISSUE_EXTENSION}`);
 }
 async function issueNumbers(issuesDir) {
   let names;
@@ -3781,7 +5240,7 @@ async function issueNumbers(issuesDir) {
   return names.map(issueNumberOfFile).filter((number) => number !== null).sort((a, b) => a - b);
 }
 function localIssuesDir(repoRoot) {
-  return join13(repoRoot, ".rafa", "issues");
+  return join16(repoRoot, ".rafa", "issues");
 }
 function renderLocalIssue(record) {
   const { draft } = record;
@@ -3960,40 +5419,41 @@ function createLocalTracker(options) {
 }
 
 // src/adapters/registry.ts
-var REFUSAL = "adapter registry";
+var REFUSAL3 = "adapter registry";
 var PORT_VERSIONS = Object.freeze({
   tracker: 1,
   store: 1,
   learning: 1,
   output: 1,
-  planner: 1
+  planner: 1,
+  sync: 1
 });
 var SERVED_VERSIONS = new Map(Object.entries(PORT_VERSIONS));
 var PORT_TYPE_LIST = [...SERVED_VERSIONS.keys()].join(", ");
 function checkPortType(port) {
   if (!SERVED_VERSIONS.has(port)) {
-    throw new TypeError(`${REFUSAL}: port is ${describeValue(port)}, expected one of: ${PORT_TYPE_LIST}`);
+    throw new TypeError(`${REFUSAL3}: port is ${describeValue(port)}, expected one of: ${PORT_TYPE_LIST}`);
   }
 }
 function accept(adapter, held) {
   if (typeof adapter !== "object" || adapter === null) {
-    throw new TypeError(`${REFUSAL}: an adapter is ${describeValue(adapter)}, expected a mapping`);
+    throw new TypeError(`${REFUSAL3}: an adapter is ${describeValue(adapter)}, expected a mapping`);
   }
   const { port, kind, portVersion, create } = adapter;
   checkPortType(port);
   if (typeof kind !== "string" || kind === "") {
-    throw new TypeError(`${REFUSAL}: a ${port} adapter has kind ${describeValue(kind)}, expected a non-empty name`);
+    throw new TypeError(`${REFUSAL3}: a ${port} adapter has kind ${describeValue(kind)}, expected a non-empty name`);
   }
   const key = `${port}/${kind}`;
   if (typeof create !== "function") {
-    throw new TypeError(`${REFUSAL}: ${key} has create ${describeValue(create)}, expected a function`);
+    throw new TypeError(`${REFUSAL3}: ${key} has create ${describeValue(create)}, expected a function`);
   }
   const served = SERVED_VERSIONS.get(port);
   if (portVersion !== served) {
-    throw new Error(`${REFUSAL}: ${key} implements ${port} port version ${describeValue(portVersion)},` + ` and core serves ${port} port version ${served}`);
+    throw new Error(`${REFUSAL3}: ${key} implements ${port} port version ${describeValue(portVersion)},` + ` and core serves ${port} port version ${served}`);
   }
   if (held.some((other) => other.port === port && other.kind === kind)) {
-    throw new Error(`${REFUSAL}: ${key} is already registered`);
+    throw new Error(`${REFUSAL3}: ${key} is already registered`);
   }
   return Object.freeze({ port, kind, portVersion, create });
 }
@@ -4004,7 +5464,8 @@ function indexByPort(adapters) {
     store: only("store"),
     learning: only("learning"),
     output: only("output"),
-    planner: only("planner")
+    planner: only("planner"),
+    sync: only("sync")
   };
 }
 function createAdapterRegistry(adapters = []) {
@@ -4019,8 +5480,8 @@ function createAdapterRegistry(adapters = []) {
       if (adapter !== undefined)
         return adapter;
       const registered = [...byPort[port].keys()];
-      const listed = registered.length === 0 ? "none" : registered.join(", ");
-      throw new Error(`${REFUSAL}: no ${port} adapter is registered as ${describeValue(kind)};` + ` registered: ${listed}`);
+      const listed2 = registered.length === 0 ? "none" : registered.join(", ");
+      throw new Error(`${REFUSAL3}: no ${port} adapter is registered as ${describeValue(kind)};` + ` registered: ${listed2}`);
     },
     kinds: (port) => {
       checkPortType(port);
@@ -4087,16 +5548,33 @@ var CORE_ADAPTERS = [
     portVersion: PORT_VERSIONS.planner,
     create: ({ repoRoot, settingSources, planPrompt, planDir, claude }) => {
       if (!Array.isArray(settingSources)) {
-        throw new TypeError(`${REFUSAL}: planner/claude has settingSources ${describeValue(settingSources)} in its context,` + " expected a list of setting sources");
+        throw new TypeError(`${REFUSAL3}: planner/claude has settingSources ${describeValue(settingSources)} in its context,` + " expected a list of setting sources");
       }
       if (typeof planPrompt !== "function") {
-        throw new TypeError(`${REFUSAL}: planner/claude has planPrompt ${describeValue(planPrompt)} in its context,` + " expected a function");
+        throw new TypeError(`${REFUSAL3}: planner/claude has planPrompt ${describeValue(planPrompt)} in its context,` + " expected a function");
       }
       if (typeof planDir !== "string") {
-        throw new TypeError(`${REFUSAL}: planner/claude has planDir ${describeValue(planDir)} in its context,` + " expected a directory path");
+        throw new TypeError(`${REFUSAL3}: planner/claude has planDir ${describeValue(planDir)} in its context,` + " expected a directory path");
       }
       return createClaudePlanner({ repoRoot, planDir, settingSources, buildPrompt: planPrompt, spawn: claude });
     }
+  },
+  {
+    port: "sync",
+    kind: "local",
+    portVersion: PORT_VERSIONS.sync,
+    create: () => createLocalSync()
+  },
+  {
+    port: "sync",
+    kind: "file",
+    portVersion: PORT_VERSIONS.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(", ")}`);
+      }
+      return createFileSync({ repoRoot, backend: store });
+    }
   }
 ];
 var CORE_ADAPTER_REGISTRY = createAdapterRegistry(CORE_ADAPTERS);
@@ -4118,4 +5596,4 @@ function selectEffortStore(repoRoot, config) {
   return adapter.create({ repoRoot });
 }
 
-export { EFFORT_STORE_DIR, effortStoreFileName, EFFORT_DIR_VARIABLE, effortStoreDir, guardTestProcess, EFFORT_KEY_PROJECTIONS, openNdjsonStore, name, version, RAFA_VERSION, versionLine, 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, SessionConflictError, SessionStateError, isSessionId, runsDir, sessionFilePath, errorCode, isPidAlive, readSessions, readSession, beginSession, updateSession, readRuntimeIdentity, DEVELOPMENT_NEXT_STEP, ADOPTION_NAME, DEVELOPMENT_MARK, appliedByName, DevelopmentBuildRefusedError, storeProjectRoot, refuseUnownedDevelopmentWrite, LEGACY_GATE_OPEN, LEGACY_GATE_CLOSED, SQLITE_MIGRATIONS, sqliteCatalogue, planSchema, MIGRATION_LOG_TABLE, SchemaRefusedError, bringForward, readStoreSchema, writeNames, ACROSS_STORES_ORDER, STAMPED_COLUMNS, stampedValues, setActiveStoreSettings, activeStoreSettings, createGitRunner, gitSaid, normalizeRemote, gitRemoteUrl, readProjectIdentity, readStoreMeta, SQLITE_STORE_FILE_NAME, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, SKILL_FILE, MARKDOWN_EXTENSION, scanLayout, declaredNameIssue, readFrontmatterDocument, readFrontmatter, renderFrontmatter, mergeFrontmatter, writeFrontmatter, ACTION_HEADING, CAUSE_HEADING, parseInstinct, writeInstinct, readScopes, allRecords, findRecords, instinctProject, toHeldRecords, sessionSpawnEnv, getClaudeUsagePercent, checkUsage, CLAUDE_BIN, claudeArgs, interruptClaudeSessions, runClaude, spawnClaudeCaptured, runClaudeCaptured, planFilePath, ClaudePlannerError, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_STATES, GITHUB_LABELS, createGhRunner, typeOfLabels, moduleOfLabels, createLocalTracker, PORT_VERSIONS, createAdapterRegistry, CORE_ADAPTER_REGISTRY, selectEffortStore };
+export { EFFORT_STORE_DIR, effortStoreFileName, EFFORT_DIR_VARIABLE, effortStoreDir, guardTestProcess, EFFORT_KEY_PROJECTIONS, openNdjsonStore, name, version, RAFA_VERSION, versionLine, createGitRunner, gitSaid, NOT_A_REPOSITORY, mainCheckoutOf, SCOPE_DIR, INIT_COMMAND, DISK_FILE_SYSTEM, ScopeError, scopeAt, initHint, selfAndAncestors, resolveScope, POSITION_FILE, positionFilePath, readPositionFile, writePositionFile, positionAt, rehome, hop, goHome, HOP_FILE, hopFilePath, readHopRecord, writeHopRecord, staleAgainst, SessionRecordError, SessionConflictError, SessionStateError, isSessionId, 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, 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, selectEffortStore };