@open-tomato/rafa 0.26.0 → 0.31.0

package/dist/{index-azptzvp3.js → index-13wzpgc1.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-t6q4k1tq.js";
 import {
   bless,
   merge
 } from "./index-d6d0942q.js";
 import {
+  CommandExit,
   commandSpelling
-} from "./index-4j1e3h26.js";
+} from "./index-e10rwa4g.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-dnwcx1cs.js";
 import {
   actionHash,
   triggerKey
@@ -238,13 +243,13 @@ function openNdjsonStore(repoRoot) {
 }
 
 // src/effort/store/sqlite.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
-import { dirname as dirname6, join as join7 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
+import { dirname as dirname9, join as join9 } from "path";
 import { Database } from "bun:sqlite";
 
 // package.json
 var name = "@open-tomato/rafa";
-var version = "0.26.0";
+var version = "0.31.0";
 
 // src/cli/version.ts
 var RAFA_VERSION = version;
@@ -254,23 +259,99 @@ function versionLine() {
 
 // src/effort/store/development-build.ts
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute3 } from "path";
+import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute5 } from "path";
 
 // src/loop/sessions.ts
 import {
   linkSync,
-  mkdirSync as mkdirSync2,
+  mkdirSync as mkdirSync4,
   readdirSync,
-  readFileSync as readFileSync2,
-  renameSync,
-  rmSync,
-  writeFileSync
+  readFileSync as readFileSync4,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { basename, dirname as dirname3, join as join5 } 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";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname4, join as join6 } from "path";
+
+// src/project/position.ts
+import { randomUUID } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "fs";
+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({
@@ -287,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`);
   }
 }
@@ -331,17 +414,215 @@ 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: fallback.root, home, project: scopeAt(fallback.root), user };
+}
+
+// src/project/position.ts
+var POSITION_FILE = "position.json";
+function positionFilePath(root) {
+  return join5(scopeAt(root).dir, POSITION_FILE);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIssueNumber(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function asPlace(value) {
+  if (!isRecord(value) || !isIssueNumber(value.board))
+    return null;
+  if (value.epic !== null && !isIssueNumber(value.epic))
+    return null;
+  return { board: value.board, epic: value.epic };
+}
+function asPosition(value) {
+  if (!isRecord(value))
+    return null;
+  const current = asPlace(value.current);
+  const home = asPlace(value.home);
+  const previous = value.previous === null ? null : asPlace(value.previous);
+  if (current === null || home === null)
+    return null;
+  if (previous === null && value.previous !== null)
+    return null;
+  return { current, previous, home };
+}
+function readPositionFile(root) {
+  const file = positionFilePath(root);
+  let text;
+  try {
+    text = readFileSync2(file, "utf8");
+  } catch (error) {
+    const code = error.code;
+    return code === "ENOENT" ? { set: false, reason: "absent", detail: `No position file at ${file}` } : { set: false, reason: "unreadable", detail: `Cannot read ${file}: ${messageOf(error)}` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    return { set: false, reason: "invalid-json", detail: `${file} holds no JSON: ${messageOf(error)}` };
+  }
+  const position = asPosition(parsed);
+  return position === null ? { set: false, reason: "wrong-shape", detail: `${file} does not hold a current, previous and home place` } : { set: true, position };
+}
+function writePositionFile(root, position) {
+  const file = positionFilePath(root);
+  mkdirSync2(dirname3(file), { recursive: true });
+  const temporary = `${file}.${String(process.pid)}.${randomUUID()}.tmp`;
+  const { current, previous, home } = position;
+  try {
+    writeFileSync(temporary, `${JSON.stringify({ current, previous, home }, null, 2)}
+`);
+    renameSync(temporary, file);
+  } catch (error) {
+    rmSync(temporary, { force: true });
+    throw error;
+  }
+}
+function positionAt(place) {
+  return { current: place, previous: null, home: place };
+}
+function rehome(position, place) {
+  return { current: place, previous: position.current, home: place };
+}
+function hop(position, place) {
+  return { current: place, previous: position.current, home: position.home };
+}
+function goHome(position) {
+  return { current: position.home, previous: position.current, home: position.home };
+}
+
+// src/next/hop-record.ts
+var HOP_FILE = "hop.json";
+var HOP_KINDS = ["blocker", "dry"];
+var HOP_STATES = ["away", "waiting", "merged", "halted"];
+function hopFilePath(root) {
+  return join6(scopeAt(root).dir, HOP_FILE);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIssueNumber2(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isIssueOrNull(value) {
+  return value === null || isIssueNumber2(value);
+}
+function isTimestamp(value) {
+  return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+function issuesMatchKind(kind, blocked, target) {
+  return kind === "blocker" ? blocked !== null && target !== null : blocked === null && target === null;
+}
+function asHopRecord(value) {
+  if (!isRecord2(value))
+    return null;
+  const { kind, blocked, target, targetEpic, targetBoard, state, pullRequest, startedAt } = value;
+  const home = asPlace(value.home);
+  const from = asPlace(value.from);
+  if (typeof kind !== "string" || !HOP_KINDS.includes(kind))
+    return null;
+  if (typeof state !== "string" || !HOP_STATES.includes(state))
+    return null;
+  if (home === null || from === null)
+    return null;
+  if (!isIssueOrNull(blocked) || !isIssueOrNull(target) || !isIssueOrNull(pullRequest))
+    return null;
+  if (!isIssueNumber2(targetEpic) || !isIssueNumber2(targetBoard) || !isTimestamp(startedAt))
+    return null;
+  const hopKind = kind;
+  if (!issuesMatchKind(hopKind, blocked, target))
+    return null;
+  return {
+    kind: hopKind,
+    home,
+    from,
+    blocked,
+    target,
+    targetEpic,
+    targetBoard,
+    state,
+    pullRequest,
+    startedAt
+  };
+}
+function readHopRecord(root) {
+  const file = hopFilePath(root);
+  let text;
+  try {
+    text = readFileSync3(file, "utf8");
+  } catch (error) {
+    const code = error.code;
+    return code === "ENOENT" ? { set: false, reason: "absent", detail: `No hop record at ${file}` } : { set: false, reason: "unreadable", detail: `Cannot read ${file}: ${messageOf(error)}` };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    return { set: false, reason: "wrong-shape", detail: `${file} holds no JSON: ${messageOf(error)}` };
   }
-  return { found: true, root: walk.root, home, project: scopeAt(walk.root), user };
+  const record = asHopRecord(parsed);
+  return record === null ? { set: false, reason: "wrong-shape", detail: `${file} does not hold a hop record` } : { set: true, record };
+}
+function ownKeys(record) {
+  const { kind, home, from, blocked, target, targetEpic, targetBoard, state, pullRequest, startedAt } = record;
+  return {
+    kind,
+    home: { board: home.board, epic: home.epic },
+    from: { board: from.board, epic: from.epic },
+    blocked,
+    target,
+    targetEpic,
+    targetBoard,
+    state,
+    pullRequest,
+    startedAt
+  };
+}
+function writeHopRecord(root, record) {
+  const file = hopFilePath(root);
+  mkdirSync3(dirname4(file), { recursive: true });
+  const temporary = `${file}.${String(process.pid)}.${randomUUID2()}.tmp`;
+  try {
+    writeFileSync2(temporary, `${JSON.stringify(ownKeys(record), null, 2)}
+`);
+    renameSync2(temporary, file);
+  } catch (error) {
+    rmSync2(temporary, { force: true });
+    throw error;
+  }
+}
+function staleAgainst(record, position) {
+  return position.home.board !== record.home.board || position.home.epic !== record.home.epic;
 }
 
 // src/loop/sessions.ts
@@ -384,13 +665,13 @@ function isSessionId(value) {
   return SESSION_ID_PATTERN.test(value);
 }
 function runsDir(root) {
-  return join5(scopeAt(root).dir, RUNS_DIR);
+  return join7(scopeAt(root).dir, RUNS_DIR);
 }
 function sessionFilePath(root, sessionId) {
   if (!isSessionId(sessionId)) {
     throw new Error(`session record: unusable session id ${JSON.stringify(sessionId)}`);
   }
-  return join5(runsDir(root), `${sessionId}${RECORD_EXTENSION}`);
+  return join7(runsDir(root), `${sessionId}${RECORD_EXTENSION}`);
 }
 function describeValue2(value) {
   return value === undefined ? "missing" : JSON.stringify(value) ?? String(value);
@@ -417,6 +698,18 @@ function taskProblem(task) {
   }
   return isText(field(task, "text")) ? null : `task.text is ${describeValue2(field(task, "text"))}, expected a non-empty string`;
 }
+function hopProblem(fields) {
+  if (!Object.hasOwn(fields, "hop"))
+    return null;
+  const hop2 = field(fields, "hop");
+  return asHopRecord(hop2) === null ? `hop is ${describeValue2(hop2)}, expected a hop record` : null;
+}
+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`;
@@ -440,12 +733,20 @@ function recordProblems(fields, file) {
     isPositiveWhole(pid) ? null : `pid is ${describeValue2(pid)}, expected a whole number from 1`,
     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"))
+    taskProblem(field(fields, "task")),
+    hopProblem(fields),
+    worktreeProblem(fields)
   ];
   return problems.filter((problem) => problem !== null);
 }
+function freezeHop(value) {
+  const hop2 = asHopRecord(value);
+  return Object.freeze({ ...hop2, home: Object.freeze(hop2.home), from: Object.freeze(hop2.from) });
+}
 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"),
@@ -454,7 +755,9 @@ function freezeRecord(fields) {
     pid: field(fields, "pid"),
     startedAt: field(fields, "startedAt"),
     state: field(fields, "state"),
-    task: isObject(task) ? Object.freeze({ line: field(task, "line"), text: field(task, "text") }) : null
+    task: isObject(task) ? Object.freeze({ line: field(task, "line"), text: field(task, "text") }) : null,
+    ...hop2 === undefined ? {} : { hop: freezeHop(hop2) },
+    ...worktree === undefined ? {} : { worktree }
   });
 }
 function parseSessionRecord(text, file) {
@@ -492,7 +795,7 @@ function readState(record, isAlive = isPidAlive) {
 function readRecordFile(file) {
   let text;
   try {
-    text = readFileSync2(file, "utf8");
+    text = readFileSync4(file, "utf8");
   } catch (error) {
     throw new SessionRecordError(file, `cannot be read: ${messageOf(error)}`);
   }
@@ -513,7 +816,7 @@ function byStart(a, b) {
 function readSessions(root, seams = {}) {
   const dir = runsDir(root);
   const isAlive = seams.isAlive ?? isPidAlive;
-  const records = recordNames(dir).filter((name2) => name2.endsWith(RECORD_EXTENSION)).map((name2) => readRecordFile(join5(dir, name2))).map((record) => Object.freeze({ ...record, state: readState(record, isAlive) }));
+  const records = recordNames(dir).filter((name2) => name2.endsWith(RECORD_EXTENSION)).map((name2) => readRecordFile(join7(dir, name2))).map((record) => Object.freeze({ ...record, state: readState(record, isAlive) }));
   return Object.freeze(records.sort(byStart));
 }
 function readSession(root, sessionId, seams = {}) {
@@ -539,17 +842,17 @@ function checkRecord(record, file) {
 }
 function writeRecordFile(file, record, isNew) {
   checkRecord(record, file);
-  mkdirSync2(dirname3(file), { recursive: true });
+  mkdirSync4(dirname5(file), { recursive: true });
   const temporary = `${file}.${process.pid}.tmp`;
-  writeFileSync(temporary, `${JSON.stringify(record, null, 2)}
+  writeFileSync3(temporary, `${JSON.stringify(record, null, 2)}
 `);
   try {
     if (isNew)
       linkSync(temporary, file);
     else
-      renameSync(temporary, file);
+      renameSync3(temporary, file);
   } finally {
-    rmSync(temporary, { force: true });
+    rmSync3(temporary, { force: true });
   }
 }
 function beginSession(root, draft, seams = {}) {
@@ -577,10 +880,10 @@ function updateSession(root, sessionId, change) {
 }
 
 // src/runtime/identity.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, realpathSync as realpathSync3 } from "fs";
-import { dirname as dirname4, join as join6, resolve as resolve2 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync5, realpathSync as realpathSync3 } from "fs";
+import { dirname as dirname6, join as join8, resolve as resolve2 } from "path";
 var MANIFEST = "package.json";
-var CHECKOUT_ENTRY = join6("src", "rafa.ts");
+var CHECKOUT_ENTRY = join8("src", "rafa.ts");
 function realOrResolved(path) {
   const resolved = resolve2(path);
   return existsSync4(resolved) ? realpathSync3(resolved) : resolved;
@@ -588,7 +891,7 @@ function realOrResolved(path) {
 function manifestName(file) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync3(file, "utf8"));
+    parsed = JSON.parse(readFileSync5(file, "utf8"));
   } catch {
     return null;
   }
@@ -600,10 +903,10 @@ function manifestName(file) {
 function nearestRafaPackage(start) {
   let dir = start;
   for (;; ) {
-    const manifest = join6(dir, MANIFEST);
+    const manifest = join8(dir, MANIFEST);
     if (existsSync4(manifest) && manifestName(manifest) === name)
       return dir;
-    const parent = dirname4(dir);
+    const parent = dirname6(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -611,8 +914,8 @@ function nearestRafaPackage(start) {
 }
 function readRuntimeIdentity(entry = Bun.main) {
   const real = realOrResolved(entry);
-  const packageDir = nearestRafaPackage(dirname4(real));
-  if (packageDir !== null && existsSync4(join6(packageDir, CHECKOUT_ENTRY))) {
+  const packageDir = nearestRafaPackage(dirname6(real));
+  if (packageDir !== null && existsSync4(join8(packageDir, CHECKOUT_ENTRY))) {
     return { kind: "development", entry: real, checkout: packageDir };
   }
   return { kind: "installed", entry: real };
@@ -638,17 +941,17 @@ class DevelopmentBuildRefusedError extends Error {
   }
 }
 function storeProjectRoot(path) {
-  const storeDir = dirname5(path);
-  const scopeDir = dirname5(storeDir);
+  const storeDir = dirname7(path);
+  const scopeDir = dirname7(storeDir);
   if (basename2(storeDir) !== EFFORT_DIR_NAME || basename2(scopeDir) !== SCOPE_DIR)
     return null;
-  return dirname5(scopeDir);
+  return dirname7(scopeDir);
 }
 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);
 }
@@ -926,6 +1229,120 @@ var SQLITE_MIGRATIONS = [
     CHECK ((verdict = 'red') = (json_array_length(failing) > 0))
   );
   `
+  },
+  {
+    id: "row-origins",
+    breaks: [],
+    sql: `
+  ALTER TABLE sessions ADD COLUMN origin_store TEXT;
+  ALTER TABLE sessions ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX sessions_by_origin
+    ON sessions (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE commits ADD COLUMN origin_store TEXT;
+  ALTER TABLE commits ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX commits_by_origin
+    ON commits (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE findings ADD COLUMN origin_store TEXT;
+  ALTER TABLE findings ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX findings_by_origin
+    ON findings (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE blockers ADD COLUMN origin_store TEXT;
+  ALTER TABLE blockers ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX blockers_by_origin
+    ON blockers (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE out_of_scope_bugs ADD COLUMN origin_store TEXT;
+  ALTER TABLE out_of_scope_bugs ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX out_of_scope_bugs_by_origin
+    ON out_of_scope_bugs (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE report_absences ADD COLUMN origin_store TEXT;
+  ALTER TABLE report_absences ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX report_absences_by_origin
+    ON report_absences (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE task_reports ADD COLUMN origin_store TEXT;
+  ALTER TABLE task_reports ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX task_reports_by_origin
+    ON task_reports (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE preflight ADD COLUMN origin_store TEXT;
+  ALTER TABLE preflight ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX preflight_by_origin
+    ON preflight (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE dispatches ADD COLUMN origin_store TEXT;
+  ALTER TABLE dispatches ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX dispatches_by_origin
+    ON dispatches (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE changes ADD COLUMN origin_store TEXT;
+  ALTER TABLE changes ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX changes_by_origin
+    ON changes (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE skill_invocations ADD COLUMN origin_store TEXT;
+  ALTER TABLE skill_invocations ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX skill_invocations_by_origin
+    ON skill_invocations (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+
+  ALTER TABLE plan_ci ADD COLUMN origin_store TEXT;
+  ALTER TABLE plan_ci ADD COLUMN origin_seq INTEGER;
+  CREATE UNIQUE INDEX plan_ci_by_origin
+    ON plan_ci (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+  `
+  },
+  {
+    id: "store-meta",
+    breaks: [],
+    sql: `
+  CREATE TABLE store_meta (
+    id                  INTEGER PRIMARY KEY CHECK (id = 1),
+    store_id            TEXT NOT NULL CHECK (store_id <> ''),
+    project_root_commit TEXT NOT NULL CHECK (project_root_commit <> ''),
+    project_remote      TEXT CHECK (project_remote <> ''),
+    host_id             TEXT NOT NULL CHECK (host_id <> ''),
+    store_path          TEXT NOT NULL CHECK (store_path <> ''),
+    file_dev            INTEGER NOT NULL CHECK (typeof(file_dev) = 'integer'),
+    file_ino            INTEGER NOT NULL CHECK (typeof(file_ino) = 'integer'),
+    minted_at           TEXT NOT NULL CHECK (minted_at <> '')
+  );
+
+  CREATE TABLE merges (
+    seq              INTEGER PRIMARY KEY,
+    id               TEXT NOT NULL UNIQUE CHECK (id <> ''),
+    other_store      TEXT CHECK (other_store <> ''),
+    merged_at        TEXT NOT NULL CHECK (merged_at <> ''),
+    rows_added       INTEGER NOT NULL CHECK (typeof(rows_added) = 'integer' AND rows_added >= 0),
+    rows_skipped     INTEGER NOT NULL CHECK (typeof(rows_skipped) = 'integer' AND rows_skipped >= 0),
+    rows_in_conflict INTEGER NOT NULL CHECK (typeof(rows_in_conflict) = 'integer' AND rows_in_conflict >= 0)
+  );
+
+  CREATE TABLE merge_conflicts (
+    seq         INTEGER PRIMARY KEY,
+    merge_id    TEXT NOT NULL CHECK (merge_id <> ''),
+    table_name  TEXT NOT NULL CHECK (table_name <> ''),
+    local_seq   INTEGER NOT NULL CHECK (typeof(local_seq) = 'integer'),
+    field       TEXT CHECK (field <> ''),
+    incoming    TEXT NOT NULL CHECK (json_valid(incoming) AND json_type(incoming) = 'object'),
+    recorded_at TEXT NOT NULL CHECK (recorded_at <> '')
+  );
+  `
   }
 ];
 var SQLITE_SCHEMA_VERSION = SQLITE_MIGRATIONS.length;
@@ -1080,188 +1497,1752 @@ function usablePlan(store, catalogue, access, caller) {
     throw new SchemaRefusedError(plan);
   return plan;
 }
-function hasWork(plan) {
-  return plan.adopted.length > 0 || plan.pending.length > 0;
+function hasWork(plan) {
+  return plan.adopted.length > 0 || plan.pending.length > 0;
+}
+function writeNames(plan) {
+  const adoption = plan.adopted.length > 0 ? [ADOPTION_NAME] : [];
+  return [...adoption, ...plan.pending.map(({ id }) => id)];
+}
+function nothingWritten(db) {
+  return { adopted: [], applied: [], userVersion: readUserVersion(db) };
+}
+function readUserVersion(db) {
+  const row = db.query("PRAGMA user_version").get();
+  return row?.user_version ?? 0;
+}
+function readMigrationLog(db, path) {
+  const table = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(MIGRATION_LOG_TABLE);
+  if (table === null)
+    return null;
+  return db.query(`SELECT id, sha256, breaks, applied_at, applied_by FROM ${MIGRATION_LOG_TABLE} ORDER BY seq`).all().map((row) => ({
+    id: row.id,
+    sha256: row.sha256,
+    breaks: parseBreaks(row.breaks, row.id, path),
+    appliedAt: row.applied_at,
+    appliedBy: row.applied_by
+  }));
+}
+function parseBreaks(text, id, path) {
+  const refused = new Error(`effort store: ${path} logs migration ${id} with breaks ${text},` + " which is not a JSON array of words; refusing to read or write it");
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (cause) {
+    throw new Error(refused.message, { cause });
+  }
+  if (!Array.isArray(parsed) || !parsed.every((word) => typeof word === "string"))
+    throw refused;
+  return parsed;
+}
+function bodyOf(migrations, id) {
+  const migration = migrations.find((candidate) => candidate.id === id);
+  if (migration === undefined)
+    throw new Error(`bring forward: no migration ${id} in the catalogue it planned from`);
+  return migration.sql;
+}
+function logMigration(db, entry, stamp) {
+  db.run(`INSERT INTO ${MIGRATION_LOG_TABLE} (id, sha256, breaks, applied_at, applied_by) VALUES (?, ?, ?, ?, ?)`, [entry.id, entry.sha256, JSON.stringify(entry.breaks), stamp.appliedAt, stamp.appliedBy]);
+}
+
+// src/effort/store/origins.ts
+var ACROSS_STORES_ORDER = "collected_at, origin_store, origin_seq, seq";
+var STAMPED_COLUMNS = "seq, origin_store, origin_seq";
+var STORE_ID = "(SELECT store_id FROM store_meta WHERE id = 1)";
+function stampedValues(table) {
+  const nextSeq = `(SELECT COALESCE(MAX(seq), 0) + 1 FROM ${table})`;
+  return `${nextSeq}, ${STORE_ID}, CASE WHEN ${STORE_ID} IS NULL THEN NULL ELSE ${nextSeq} END`;
+}
+
+// src/effort/store/settings.ts
+var DEFAULT_STORE_SETTINGS = Object.freeze({
+  busyTimeoutMs: CONFIG_DEFAULTS.effortBusyTimeoutMs
+});
+var active = DEFAULT_STORE_SETTINGS;
+function setActiveStoreSettings(settings) {
+  if (settings === null) {
+    active = DEFAULT_STORE_SETTINGS;
+    return;
+  }
+  if (!isBusyTimeoutMs(settings.busyTimeoutMs)) {
+    throw new RangeError(`effort store: busy timeout ${String(settings.busyTimeoutMs)} is not a whole number ` + `of milliseconds from ${String(BUSY_TIMEOUT_MIN_MS)} to ${String(BUSY_TIMEOUT_MAX_MS)}`);
+  }
+  active = Object.freeze({ busyTimeoutMs: settings.busyTimeoutMs });
+}
+function activeStoreSettings() {
+  return active;
+}
+
+// src/effort/store/store-meta.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { dirname as dirname8 } from "path";
+
+// src/effort/store/store-identity.ts
+import { spawnSync as spawnSync3 } from "child_process";
+import { createHmac } from "crypto";
+import { readFileSync as readFileSync6, realpathSync as realpathSync4, statSync } from "fs";
+import { hostname, platform as currentPlatform } from "os";
+
+// src/schema/project-id.ts
+import { spawnSync as spawnSync2 } from "child_process";
+var PROJECT_ID_LENGTH = 12;
+var PROJECT_ID_PATTERN = new RegExp(`^[0-9a-f]{${PROJECT_ID_LENGTH}}$`);
+function hasColonAfterAt(url) {
+  const at = url.indexOf("@");
+  return at !== -1 && url.lastIndexOf(":") > at;
+}
+function normalizeRemote(url) {
+  const stripped = url.replace(/:\/\/[^@]+@/, "://");
+  const network = !stripped.startsWith("file://") && (stripped.includes("://") || hasColonAfterAt(stripped));
+  const trimmed = stripped.replace(/^[A-Za-z][A-Za-z0-9+.-]*:\/\//, "").replace(/^[^@/:]+@([^:/]+):/, "$1/").replace(/\.git\/?$/, "").replace(/\/+$/, "");
+  return network ? trimmed.toLowerCase() : trimmed;
+}
+function gitRemoteUrl(dir) {
+  const result = spawnSync2("git", ["remote", "get-url", "origin"], {
+    cwd: dir,
+    encoding: "utf8",
+    env: { ...process.env, LC_ALL: "C" }
+  });
+  if (result.error !== undefined || result.status !== 0)
+    return null;
+  const url = result.stdout.trim();
+  return url === "" ? null : url;
+}
+
+// src/effort/store/store-identity.ts
+var HOST_ID_KEY = "rafa effort store host id";
+var MACHINE_ID_PATH = "/etc/machine-id";
+var IOREG_ARGS = ["-rd1", "-c", "IOPlatformExpertDevice"];
+function hostIdFrom(source, value) {
+  return createHmac("sha256", HOST_ID_KEY).update(`${source}:${value}`).digest("hex");
+}
+function readMachineIdFile() {
+  try {
+    const value = readFileSync6(MACHINE_ID_PATH, "utf8").trim();
+    return value === "" ? null : value;
+  } catch {
+    return null;
+  }
+}
+function parseIoregPlatformUuid(output) {
+  const match = /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(output);
+  return match?.[1] ?? null;
+}
+function readIoregPlatformUuid() {
+  const result = spawnSync3("ioreg", [...IOREG_ARGS], { encoding: "utf8" });
+  if (result.error !== undefined || result.status !== 0)
+    return null;
+  return parseIoregPlatformUuid(result.stdout);
+}
+function readHostId(seams = {}) {
+  const platform = seams.platform ?? currentPlatform();
+  if (platform === "linux") {
+    const machineId = (seams.readMachineId ?? readMachineIdFile)();
+    if (machineId !== null)
+      return hostIdFrom("machine-id", machineId);
+  }
+  if (platform === "darwin") {
+    const platformUuid = (seams.readPlatformUuid ?? readIoregPlatformUuid)();
+    if (platformUuid !== null)
+      return hostIdFrom("platform-uuid", platformUuid);
+  }
+  return hostIdFrom("hostname", (seams.readHostname ?? hostname)());
+}
+function readStoreFileFacts(path) {
+  const storePath = realpathSync4(path);
+  const stats = statSync(storePath, { bigint: true });
+  return { storePath, fileDev: stats.dev, fileIno: stats.ino };
+}
+function observeStore(path, readHost = readHostId) {
+  return { hostId: readHost(), ...readStoreFileFacts(path) };
+}
+function movedFacts(recorded, facts) {
+  const sameFile = BigInt(recorded.fileDev) === facts.fileDev && BigInt(recorded.fileIno) === facts.fileIno;
+  const moved = [
+    ["host", recorded.hostId !== facts.hostId],
+    ["path", recorded.storePath !== facts.storePath],
+    ["file", !sameFile]
+  ];
+  return moved.filter(([, differs]) => differs).map(([reason]) => reason);
+}
+function decideStoreIdentity(access, recorded, observe) {
+  if (access === "read")
+    return { action: "none" };
+  const facts = observe();
+  if (recorded === null)
+    return { action: "mint", reasons: ["unminted"], facts };
+  const reasons = movedFacts(recorded, facts);
+  return reasons.length === 0 ? { action: "keep", storeId: recorded.storeId } : { action: "mint", reasons, facts };
+}
+function smallestRootCommit(git) {
+  const result = git(["rev-list", "--max-parents=0", "HEAD"]);
+  if (!result.ok)
+    return null;
+  const roots = result.stdout.split(`
+`).map((line) => line.trim()).filter((line) => line !== "");
+  return [...roots].sort()[0] ?? null;
+}
+function normalisedRemote(git) {
+  const result = git(["remote", "get-url", "origin"]);
+  if (!result.ok)
+    return null;
+  const remote = normalizeRemote(result.stdout.trim());
+  return remote === "" ? null : remote;
+}
+function readProjectIdentity(dir, git = createGitRunner(dir)) {
+  return { rootCommit: smallestRootCommit(git), remote: normalisedRemote(git) };
+}
+
+// src/effort/store/store-meta.ts
+var STORED_INTEGER_BITS = 64;
+function toStoredInteger(value) {
+  return BigInt.asIntN(STORED_INTEGER_BITS, value);
+}
+function fromStoredInteger(text) {
+  return BigInt.asUintN(STORED_INTEGER_BITS, BigInt(text));
+}
+function readStoreMeta(db) {
+  const row = db.query("SELECT store_id, project_root_commit, project_remote, host_id, store_path," + " CAST(file_dev AS TEXT) AS file_dev, CAST(file_ino AS TEXT) AS file_ino, minted_at" + " FROM store_meta WHERE id = 1").get();
+  if (row === null)
+    return null;
+  return {
+    storeId: row.store_id,
+    projectRootCommit: row.project_root_commit,
+    projectRemote: row.project_remote,
+    hostId: row.host_id,
+    storePath: row.store_path,
+    fileDev: fromStoredInteger(row.file_dev),
+    fileIno: fromStoredInteger(row.file_ino),
+    mintedAt: row.minted_at
+  };
+}
+function projectFor(storePath, recorded, seams) {
+  const read = (seams.readProject ?? readProjectIdentity)(dirname8(storePath));
+  if (read.rootCommit !== null)
+    return { rootCommit: read.rootCommit, remote: read.remote };
+  if (recorded === null)
+    return null;
+  return { rootCommit: recorded.projectRootCommit, remote: recorded.projectRemote };
+}
+function writeStoreMeta(db, facts, project, seams) {
+  const storeId = (seams.newStoreId ?? randomUUID3)();
+  const mintedAt = (seams.now?.() ?? new Date).toISOString();
+  db.query("INSERT OR REPLACE INTO store_meta (id, store_id, project_root_commit, project_remote," + " host_id, store_path, file_dev, file_ino, minted_at) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?)").run(storeId, project.rootCommit, project.remote, facts.hostId, facts.storePath, toStoredInteger(facts.fileDev), toStoredInteger(facts.fileIno), mintedAt);
+  return storeId;
+}
+function unminted(decision) {
+  return decision.action === "keep" ? { action: "keep", storeId: decision.storeId } : { action: "none" };
+}
+function settleStoreIdentity(db, path, access, seams = {}) {
+  if (access === "read")
+    return { action: "none" };
+  const observe = () => observeStore(path, seams.readHostId ?? readHostId);
+  const recorded = readStoreMeta(db);
+  const first = decideStoreIdentity(access, recorded, observe);
+  if (first.action !== "mint")
+    return unminted(first);
+  const project = projectFor(first.facts.storePath, recorded, seams);
+  if (project === null)
+    return { action: "no-project", reasons: first.reasons };
+  const mintUnderLock = db.transaction(() => {
+    const second = decideStoreIdentity(access, readStoreMeta(db), observe);
+    if (second.action !== "mint")
+      return unminted(second);
+    const storeId = writeStoreMeta(db, second.facts, project, seams);
+    return { action: "mint", storeId, reasons: second.reasons };
+  });
+  return mintUnderLock.immediate();
+}
+
+// src/effort/store/sqlite.ts
+var SQLITE_STORE_FILE_NAME = "effort.sqlite";
+function sqliteStorePath(repoRoot) {
+  return join9(effortStoreDir(repoRoot), SQLITE_STORE_FILE_NAME);
+}
+var KIND_TABLES = {
+  sessions: { name: "sessions", keyColumn: "session_id" },
+  commits: { name: "commits", keyColumn: "sha" }
+};
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+function hasKey(entry) {
+  return entry.key !== null;
+}
+function refused(index, length, reason) {
+  return new Error(`effort store: row ${index} of ${length} ${reason}; batch refused`);
+}
+function batchEntries(kind, rows) {
+  const keyOf = EFFORT_KEY_PROJECTIONS[kind];
+  const projected = rows.map((row) => ({ key: keyOf(row), row }));
+  const keyed = projected.filter(hasKey);
+  if (keyed.length < projected.length) {
+    const keylessAt = projected.findIndex((entry) => !hasKey(entry));
+    throw refused(keylessAt, rows.length, "carries no key");
+  }
+  const unholdableAt = keyed.findIndex(({ key }) => LONE_SURROGATE.test(key));
+  if (unholdableAt !== -1) {
+    const reason = "carries a key with a lone UTF-16 surrogate," + " which SQLite text cannot hold";
+    throw refused(unholdableAt, rows.length, reason);
+  }
+  return keyed.map(({ key, row }) => ({ key, body: JSON.stringify(row) }));
+}
+function withSqliteStore(path, access, create, use, identity = {}) {
+  guardTestProcess(path);
+  if (create)
+    mkdirSync5(dirname9(path), { recursive: true });
+  const db = new Database(path, { readwrite: true, create });
+  try {
+    db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
+    bringForward(db, path, access, "open");
+    settleStoreIdentity(db, path, access, identity);
+    return use(db);
+  } finally {
+    db.close();
+  }
+}
+function insertBatch(db, table, entries) {
+  const insert = db.query(`INSERT INTO ${table.name} (${table.keyColumn}, row_json, ${STAMPED_COLUMNS})` + ` VALUES (?, ?, ${stampedValues(table.name)})` + ` ON CONFLICT (${table.keyColumn}) DO NOTHING`);
+  const insertAll = db.transaction(() => entries.reduce((appended, { key, body }) => appended + insert.run(key, body).changes, 0));
+  return insertAll.immediate();
+}
+function writeSqliteStore(path, rowCount, empty, insert) {
+  const exists = existsSync5(path);
+  if (rowCount > 0)
+    return withSqliteStore(path, "write", !exists, insert);
+  if (exists)
+    withSqliteStore(path, "write", false, () => {
+      return;
+    });
+  return empty;
+}
+function appendKind2(path, kind, rows) {
+  const entries = batchEntries(kind, rows);
+  const table = KIND_TABLES[kind];
+  const appended = writeSqliteStore(path, entries.length, 0, (db) => insertBatch(db, table, entries));
+  return { path, appended, skipped: entries.length - appended };
+}
+function keysOfKind2(path, kind) {
+  if (!existsSync5(path))
+    return new Set;
+  const { name: name2, keyColumn } = KIND_TABLES[kind];
+  const keys = withSqliteStore(path, "read", false, (db) => db.query(`SELECT ${keyColumn} AS key FROM ${name2} ORDER BY seq`).all());
+  return new Set(keys.map(({ key }) => key));
+}
+function parsedObject(body) {
+  try {
+    const value = JSON.parse(body);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function rowOf(body, where) {
+  const value = parsedObject(body);
+  if (value === null) {
+    throw new Error(`effort store: ${where} does not hold a JSON object;` + " no append writes one");
+  }
+  return value;
+}
+function readKind2(path, kind) {
+  if (!existsSync5(path))
+    return [];
+  const { name: name2 } = KIND_TABLES[kind];
+  const stored = withSqliteStore(path, "read", false, (db) => db.query(`SELECT seq, row_json AS body FROM ${name2} ORDER BY seq`).all());
+  return stored.map(({ seq, body }) => rowOf(body, `${path}: ${name2} row ${seq}`));
+}
+function openSqliteStore(repoRoot) {
+  const path = sqliteStorePath(repoRoot);
+  return {
+    append: (kind, rows) => appendKind2(path, kind, rows),
+    keys: (kind) => keysOfKind2(path, kind),
+    read: (kind) => readKind2(path, kind),
+    path: () => path
+  };
+}
+
+// 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 writeNames(plan) {
-  const adoption = plan.adopted.length > 0 ? [ADOPTION_NAME] : [];
-  return [...adoption, ...plan.pending.map(({ id }) => id)];
+function carriedColumns(db, table) {
+  return db.query(`PRAGMA table_info(${quoted(table)})`).all().map(({ name: name2 }) => name2).filter((name2) => name2 !== "seq");
 }
-function nothingWritten(db) {
-  return { adopted: [], applied: [], userVersion: readUserVersion(db) };
+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 readUserVersion(db) {
-  const row = db.query("PRAGMA user_version").get();
-  return row?.user_version ?? 0;
+function valueOf(row, column) {
+  return row[column] ?? null;
 }
-function readMigrationLog(db, path) {
-  const table = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(MIGRATION_LOG_TABLE);
-  if (table === 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 db.query(`SELECT id, sha256, breaks, applied_at, applied_by FROM ${MIGRATION_LOG_TABLE} ORDER BY seq`).all().map((row) => ({
-    id: row.id,
-    sha256: row.sha256,
-    breaks: parseBreaks(row.breaks, row.id, path),
-    appliedAt: row.applied_at,
-    appliedBy: row.applied_by
-  }));
+  return local.query(`SELECT seq FROM ${quoted(table)} WHERE origin_store = ? AND origin_seq = ?`).get(store, seq)?.seq ?? null;
 }
-function parseBreaks(text, id, path) {
-  const refused = new Error(`effort store: ${path} logs migration ${id} with breaks ${text},` + " which is not a JSON array of words; refusing to read or write it");
-  let parsed;
+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 {
-    parsed = JSON.parse(text);
-  } catch (cause) {
-    throw new Error(refused.message, { cause });
-  }
-  if (!Array.isArray(parsed) || !parsed.every((word) => typeof word === "string"))
-    throw refused;
-  return parsed;
+    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 bodyOf(migrations, id) {
-  const migration = migrations.find((candidate) => candidate.id === id);
-  if (migration === undefined)
-    throw new Error(`bring forward: no migration ${id} in the catalogue it planned from`);
-  return migration.sql;
+function unionStores(local, other) {
+  const tables = mergedTables();
+  refuseColumnMismatch(local, other, tables);
+  return local.transaction(() => tables.map((merged) => unionTable(local, other, merged)))();
 }
-function logMigration(db, entry, stamp) {
-  db.run(`INSERT INTO ${MIGRATION_LOG_TABLE} (id, sha256, breaks, applied_at, applied_by) VALUES (?, ?, ?, ?, ?)`, [entry.id, entry.sha256, JSON.stringify(entry.breaks), stamp.appliedAt, stamp.appliedBy]);
+
+// 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/settings.ts
-var DEFAULT_STORE_SETTINGS = Object.freeze({
-  busyTimeoutMs: CONFIG_DEFAULTS.effortBusyTimeoutMs
-});
-var active = DEFAULT_STORE_SETTINGS;
-function setActiveStoreSettings(settings) {
-  if (settings === null) {
-    active = DEFAULT_STORE_SETTINGS;
+// 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}`);
   }
-  if (!isBusyTimeoutMs(settings.busyTimeoutMs)) {
-    throw new RangeError(`effort store: busy timeout ${String(settings.busyTimeoutMs)} is not a whole number ` + `of milliseconds from ${String(BUSY_TIMEOUT_MIN_MS)} to ${String(BUSY_TIMEOUT_MAX_MS)}`);
+  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();
   }
-  active = Object.freeze({ busyTimeoutMs: settings.busyTimeoutMs });
 }
-function activeStoreSettings() {
-  return active;
+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/sqlite.ts
-var SQLITE_STORE_FILE_NAME = "effort.sqlite";
-function sqliteStorePath(repoRoot) {
-  return join7(effortStoreDir(repoRoot), SQLITE_STORE_FILE_NAME);
+// 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 KIND_TABLES = {
-  sessions: { name: "sessions", keyColumn: "session_id" },
-  commits: { name: "commits", keyColumn: "sha" }
-};
-var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
-function hasKey(entry) {
-  return entry.key !== null;
+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 refused(index, length, reason) {
-  return new Error(`effort store: row ${index} of ${length} ${reason}; batch refused`);
+function refuseMissing(path, which) {
+  if (existsSync11(path))
+    return;
+  throw new MergeRefusal("missing", `REFUSED \u2014 ${which} ${path} is not there. ${NOTHING_MERGED}`);
 }
-function batchEntries(kind, rows) {
-  const keyOf = EFFORT_KEY_PROJECTIONS[kind];
-  const projected = rows.map((row) => ({ key: keyOf(row), row }));
-  const keyed = projected.filter(hasKey);
-  if (keyed.length < projected.length) {
-    const keylessAt = projected.findIndex((entry) => !hasKey(entry));
-    throw refused(keylessAt, rows.length, "carries no key");
-  }
-  const unholdableAt = keyed.findIndex(({ key }) => LONE_SURROGATE.test(key));
-  if (unholdableAt !== -1) {
-    const reason = "carries a key with a lone UTF-16 surrogate," + " which SQLite text cannot hold";
-    throw refused(unholdableAt, rows.length, reason);
+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.");
   }
-  return keyed.map(({ key, row }) => ({ key, body: JSON.stringify(row) }));
+  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 withSqliteStore(path, access, create, use) {
-  guardTestProcess(path);
-  if (create)
-    mkdirSync3(dirname6(path), { recursive: true });
-  const db = new Database(path, { readwrite: true, create });
+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 {
-    db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
-    bringForward(db, path, access, "open");
-    return use(db);
+    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 insertBatch(db, table, entries) {
-  const insert = db.query(`INSERT INTO ${table.name} (${table.keyColumn}, row_json) VALUES (?, ?)` + ` ON CONFLICT (${table.keyColumn}) DO NOTHING`);
-  const insertAll = db.transaction(() => entries.reduce((appended, { key, body }) => appended + insert.run(key, body).changes, 0));
-  return insertAll.immediate();
+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 writeSqliteStore(path, rowCount, empty, insert) {
-  const exists = existsSync5(path);
-  if (rowCount > 0)
-    return withSqliteStore(path, "write", !exists, insert);
-  if (exists)
-    withSqliteStore(path, "write", false, () => {
-      return;
-    });
-  return empty;
+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 appendKind2(path, kind, rows) {
-  const entries = batchEntries(kind, rows);
-  const table = KIND_TABLES[kind];
-  const appended = writeSqliteStore(path, entries.length, 0, (db) => insertBatch(db, table, entries));
-  return { path, appended, skipped: entries.length - appended };
+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 keysOfKind2(path, kind) {
-  if (!existsSync5(path))
-    return new Set;
-  const { name: name2, keyColumn } = KIND_TABLES[kind];
-  const keys = withSqliteStore(path, "read", false, (db) => db.query(`SELECT ${keyColumn} AS key FROM ${name2} ORDER BY seq`).all());
-  return new Set(keys.map(({ key }) => key));
+function addedRows(merged) {
+  return {
+    ...Object.fromEntries(merged.tables.map(({ table, added }) => [table, added])),
+    [MERGES_TABLE]: 1,
+    merge_conflicts: merged.rowsInConflict
+  };
 }
-function parsedObject(body) {
+function buildMerged(path, parallelPath, other, merge2) {
+  vacuumInto(path, parallelPath);
+  const db = new Database5(parallelPath, { readwrite: true });
   try {
-    const value = JSON.parse(body);
-    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-  } catch {
-    return null;
+    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 rowOf(body, where) {
-  const value = parsedObject(body);
-  if (value === null) {
-    throw new Error(`effort store: ${where} does not hold a JSON object;` + " no append writes one");
+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();
   }
-  return value;
 }
-function readKind2(path, kind) {
-  if (!existsSync5(path))
-    return [];
-  const { name: name2 } = KIND_TABLES[kind];
-  const stored = withSqliteStore(path, "read", false, (db) => db.query(`SELECT seq, row_json AS body FROM ${name2} ORDER BY seq`).all());
-  return stored.map(({ seq, body }) => rowOf(body, `${path}: ${name2} row ${seq}`));
+
+// src/effort/sync/file.ts
+var REFUSAL = "effort sync (file)";
+var NOTHING_COPIED = "Nothing was copied.";
+
+class FileSyncRefusal extends Error {
+  name = "FileSyncRefusal";
 }
-function openSqliteStore(repoRoot) {
-  const path = sqliteStorePath(repoRoot);
-  return {
-    append: (kind, rows) => appendKind2(path, kind, rows),
-    keys: (kind) => keysOfKind2(path, kind),
-    read: (kind) => readKind2(path, kind),
-    path: () => path
+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 join10 } from "path";
+import { join as join15 } from "path";
 
 // src/commands/instinct/instinct-records.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { join as join9 } 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 } from "fs";
-import { join as join8, 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({
@@ -1279,7 +3260,7 @@ function layoutIssue(code, message) {
 }
 function entryKind(path) {
   try {
-    const stats = statSync(path);
+    const stats = statSync4(path);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -1290,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);
@@ -1378,7 +3359,7 @@ function scanGroupMember(root, dir, name2) {
   const children = visibleNames(dir);
   if (children.length === 0)
     return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join8(dir, SKILL_FILE);
+  const skillPath = join13(dir, SKILL_FILE);
   if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
     return [nestedGroupEntry(root, skillPath, name2)];
   }
@@ -1387,7 +3368,7 @@ function scanGroupMember(root, dir, name2) {
 function scanSkillGroup(root, dir, children) {
   const entries = [];
   for (const child of children) {
-    const path = join8(dir, child);
+    const path = join13(dir, child);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("skill", root, path));
@@ -1408,7 +3389,7 @@ function scanSkillDirectory(root, dir, name2) {
   const children = visibleNames(dir);
   if (children.length === 0)
     return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join8(dir, SKILL_FILE);
+  const skillPath = join13(dir, SKILL_FILE);
   if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
     return [skillFileEntry(skillPath, name2)];
   }
@@ -1417,7 +3398,7 @@ function scanSkillDirectory(root, dir, name2) {
 function scanSkillRoot(root) {
   const entries = [];
   for (const name2 of visibleNames(root)) {
-    const path = join8(root, name2);
+    const path = join13(root, name2);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("skill", root, path));
@@ -1438,7 +3419,7 @@ function scanInstinctSubdirectory(root, dir) {
     return [dotfileOnlyEntry("instinct", root, dir)];
   const entries = [];
   for (const child of children) {
-    const path = join8(dir, child);
+    const path = join13(dir, child);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("instinct", root, path));
@@ -1456,7 +3437,7 @@ function scanInstinctSubdirectory(root, dir) {
 function scanInstinctRoot(root) {
   const entries = [];
   for (const name2 of visibleNames(root)) {
-    const path = join8(root, name2);
+    const path = join13(root, name2);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("instinct", root, path));
@@ -1515,7 +3496,7 @@ function scanLine(text, offset) {
     next: index + 1
   };
 }
-function isRecord(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseBlock(yaml) {
@@ -1526,7 +3507,7 @@ function parseBlock(yaml) {
   } catch {
     return null;
   }
-  return isRecord(parsed) ? parsed : null;
+  return isRecord3(parsed) ? parsed : null;
 }
 function readFrontmatterDocument(text) {
   const opening = scanLine(text, 0);
@@ -1583,32 +3564,6 @@ function writeFrontmatter(document, data) {
   ].join("");
 }
 
-// src/schema/project-id.ts
-import { spawnSync } from "child_process";
-var PROJECT_ID_LENGTH = 12;
-var PROJECT_ID_PATTERN = new RegExp(`^[0-9a-f]{${PROJECT_ID_LENGTH}}$`);
-function hasColonAfterAt(url) {
-  const at = url.indexOf("@");
-  return at !== -1 && url.lastIndexOf(":") > at;
-}
-function normalizeRemote(url) {
-  const stripped = url.replace(/:\/\/[^@]+@/, "://");
-  const network = !stripped.startsWith("file://") && (stripped.includes("://") || hasColonAfterAt(stripped));
-  const trimmed = stripped.replace(/^[A-Za-z][A-Za-z0-9+.-]*:\/\//, "").replace(/^[^@/:]+@([^:/]+):/, "$1/").replace(/\.git\/?$/, "").replace(/\/+$/, "");
-  return network ? trimmed.toLowerCase() : trimmed;
-}
-function gitRemoteUrl(dir) {
-  const result = spawnSync("git", ["remote", "get-url", "origin"], {
-    cwd: dir,
-    encoding: "utf8",
-    env: { ...process.env, LC_ALL: "C" }
-  });
-  if (result.error !== undefined || result.status !== 0)
-    return null;
-  const url = result.stdout.trim();
-  return url === "" ? null : url;
-}
-
 // src/schema/instinct.ts
 var INSTINCT_KINDS = FINDING_KINDS;
 var INSTINCT_SIGNALS = FINDING_SIGNALS;
@@ -1935,7 +3890,7 @@ function unreadableIssue(message) {
 function readRecord(path, scope, id) {
   let text;
   try {
-    text = readFileSync4(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)] };
@@ -1943,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 statSync2(path).isFile();
+    return statSync5(path).isFile();
   } catch {
     return false;
   }
 }
 function recordFiles(dir) {
-  return readdirSync3(dir).filter((name2) => isRecordFile(name2) && isFile(join9(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))
@@ -1960,7 +3915,7 @@ function readScope(scope, dir) {
     scope,
     dir,
     exists: true,
-    records: recordFiles(dir).map((name2) => readRecord(join9(dir, name2), scope, recordId(name2)))
+    records: recordFiles(dir).map((name2) => readRecord(join14(dir, name2), scope, recordId(name2)))
   };
 }
 function readScopes(seams) {
@@ -1979,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;
   }
@@ -1989,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 {
@@ -2263,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 = join10(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`);
     }
@@ -2293,18 +4248,18 @@ function pushLogLines(sourceId, described, result) {
   });
 }
 function localInstinctsDir(repoRoot) {
-  return join10(repoRoot, RAFA_INSTINCTS_PATH);
+  return join15(repoRoot, RAFA_INSTINCTS_PATH);
 }
 function userInstinctsDir(home) {
-  return join10(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 = join10(instinctsDir, INSTINCTS_FILE);
-  const flagsPath = join10(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;
@@ -2421,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";
@@ -2459,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;
@@ -2686,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 {
@@ -2705,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(`
@@ -2750,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;
@@ -2762,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
@@ -2784,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,
@@ -2903,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]);
@@ -2919,7 +4879,7 @@ function notOnPath(command, cwd, path) {
 function isOneOf(members, value) {
   return typeof value === "string" && members.includes(value);
 }
-function isIssueNumber(value) {
+function isIssueNumber3(value) {
   return typeof value === "string" && ISSUE_NUMBER.test(value) && Number.isSafeInteger(Number(value));
 }
 function isRepoName(value) {
@@ -2974,7 +4934,7 @@ function issueNumberOfRef(ref) {
   if (ref.kind !== "github") {
     throw new Error(`${PREFIX2}: refused a ref of kind ${describeValue(ref.kind)}; this tracker reads github refs only`);
   }
-  if (!isIssueNumber(ref.externalId)) {
+  if (!isIssueNumber3(ref.externalId)) {
     throw new Error(`${PREFIX2}: externalId ${describeValue(ref.externalId)} is not a GitHub issue number,` + " expected a positive whole number with no leading zero");
   }
   if (ref.repo !== undefined && !isRepoName(ref.repo)) {
@@ -3036,7 +4996,7 @@ function listedIssues(stdout) {
       throw refuse2(`${describeValue(row)}, expected a mapping`);
     const { number, url } = row;
     const labels = labelNames(row["labels"]);
-    if (typeof number !== "number" || !isIssueNumber(String(number))) {
+    if (typeof number !== "number" || !isIssueNumber3(String(number))) {
       throw refuse2(`with number ${describeValue(number)}, expected an issue number`);
     }
     if (typeof url !== "string")
@@ -3071,7 +5031,7 @@ function issueOf(ref, viewed) {
     module: moduleOfLabels(viewed.labels),
     priority: isOneOf(ISSUE_PRIORITIES, priority) ? priority : null,
     project: null,
-    blockedBy: viewed.labels.map((label) => label.startsWith(GITHUB_LABELS.blockedByPrefix) ? label.slice(GITHUB_LABELS.blockedByPrefix.length) : "").filter(isIssueNumber).map(Number),
+    blockedBy: viewed.labels.map((label) => label.startsWith(GITHUB_LABELS.blockedByPrefix) ? label.slice(GITHUB_LABELS.blockedByPrefix.length) : "").filter(isIssueNumber3).map(Number),
     ref: { ...ref, url: viewed.url },
     state: stateOf(viewed)
   };
@@ -3209,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 join11 } 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*$/;
@@ -3266,7 +5226,7 @@ function issueNumberOfFile(name2) {
   return name2.endsWith(ISSUE_EXTENSION) ? parseIssueNumber(name2.slice(0, -ISSUE_EXTENSION.length)) : null;
 }
 function issuePath(issuesDir, number) {
-  return join11(issuesDir, `${number}${ISSUE_EXTENSION}`);
+  return join16(issuesDir, `${number}${ISSUE_EXTENSION}`);
 }
 async function issueNumbers(issuesDir) {
   let names;
@@ -3280,7 +5240,7 @@ async function issueNumbers(issuesDir) {
   return names.map(issueNumberOfFile).filter((number) => number !== null).sort((a, b) => a - b);
 }
 function localIssuesDir(repoRoot) {
-  return join11(repoRoot, ".rafa", "issues");
+  return join16(repoRoot, ".rafa", "issues");
 }
 function renderLocalIssue(record) {
   const { draft } = record;
@@ -3459,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 });
 }
@@ -3503,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 = []) {
@@ -3518,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);
@@ -3586,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);
@@ -3617,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, 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, bringForward, readStoreSchema, writeNames, setActiveStoreSettings, activeStoreSettings, SQLITE_STORE_FILE_NAME, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, SKILL_FILE, MARKDOWN_EXTENSION, scanLayout, declaredNameIssue, readFrontmatterDocument, readFrontmatter, renderFrontmatter, mergeFrontmatter, writeFrontmatter, normalizeRemote, gitRemoteUrl, 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, 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 };