@open-tomato/rafa 0.24.1 → 0.28.0

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

@@ -1,31 +1,37 @@
 // @bun
 import {
   CONFIG_DEFAULTS,
+  CONFIG_FILE,
   FINDING_DOMAINS,
   FINDING_KINDS,
   FINDING_SIGNALS,
   activeOutput,
   activeOutputMode,
+  configFilePath,
   createTextOutput,
+  isStampableStub,
   readRafaBlocks
-} from "./index-twbp38kz.js";
+} from "./index-rv7y8y1j.js";
 import {
   bless,
   merge
 } from "./index-d6d0942q.js";
 import {
   commandSpelling
-} from "./index-4fwgqveh.js";
+} from "./index-4j1e3h26.js";
 import {
+  BUSY_TIMEOUT_MAX_MS,
+  BUSY_TIMEOUT_MIN_MS,
   RAFA_INSTINCTS_PATH,
   STORE_BACKENDS,
   bundledBinDirectory,
   describeValue,
+  isBusyTimeoutMs,
   isMapping,
   messageOf,
   resolveInstinctScopes,
   tierExists
-} from "./index-pmkgvtfe.js";
+} from "./index-sf2brh4w.js";
 import {
   actionHash,
   triggerKey
@@ -34,6 +40,9 @@ import {
 // src/adapters/registry.ts
 import { homedir } from "os";
 
+// src/effort/store/ndjson.ts
+import { join as join3 } from "path";
+
 // src/effort/store.ts
 import {
   appendFileSync,
@@ -53,8 +62,8 @@ function asObject(value) {
 function normaliseKey(key) {
   return typeof key === "string" && key.length > 0 ? key : null;
 }
-function effortStorePath(repoRoot, kind) {
-  return join(repoRoot, EFFORT_STORE_DIR, STORE_FILE_NAMES[kind]);
+function effortStoreFileName(kind) {
+  return STORE_FILE_NAMES[kind];
 }
 function readStoreText(path) {
   return existsSync(path) ? readFileSync(path, "utf8") : null;
@@ -141,6 +150,54 @@ function appendRows(path, rows, keyOf) {
   };
 }
 
+// src/effort/store/location.ts
+import { existsSync as existsSync2, realpathSync } from "fs";
+import { tmpdir } from "os";
+import { isAbsolute, join as join2, relative, resolve, sep } from "path";
+var EFFORT_DIR_VARIABLE = "RAFA_EFFORT_DIR";
+var TEST_PROCESS_VARIABLE = "RAFA_TEST";
+var TEST_ENTRY_SUFFIX = ".test.ts";
+function canonical(path) {
+  const resolved = resolve(path);
+  return existsSync2(resolved) ? realpathSync(resolved) : resolved;
+}
+function isWithin(path, dir) {
+  const between = relative(resolve(dir), resolve(path));
+  const climbsOut = between === ".." || between.startsWith(`..${sep}`);
+  return !climbsOut && !isAbsolute(between);
+}
+function readEffortDirOverride(repoRoot, env = process.env) {
+  const value = env[EFFORT_DIR_VARIABLE];
+  if (value === undefined || value === "")
+    return null;
+  if (!isAbsolute(value)) {
+    throw new Error(`effort store: ${EFFORT_DIR_VARIABLE} is not an absolute path (${value}); run this command again` + ` with ${EFFORT_DIR_VARIABLE} set to the absolute path 'rafa effort copy' printed.`);
+  }
+  if (canonical(value) === canonical(join2(repoRoot, EFFORT_STORE_DIR))) {
+    throw new Error(`effort store: ${EFFORT_DIR_VARIABLE} names this project's own store (${value}); it points a command` + " at a copy only. Copy the store with 'rafa effort copy' and run this command with" + ` ${EFFORT_DIR_VARIABLE}=<the copy>.`);
+  }
+  return value;
+}
+function effortStoreDir(repoRoot, env = process.env) {
+  return readEffortDirOverride(repoRoot, env) ?? join2(repoRoot, EFFORT_STORE_DIR);
+}
+function isTestProcess(main = Bun.main, env = process.env) {
+  return main.endsWith(TEST_ENTRY_SUFFIX) || env[TEST_PROCESS_VARIABLE] === "1";
+}
+function isUnderTempDir(path, tempDir = tmpdir()) {
+  return isWithin(path, tempDir) || isWithin(path, canonical(tempDir));
+}
+function currentProbe() {
+  return { main: Bun.main, env: process.env, tempDir: tmpdir() };
+}
+function guardTestProcess(path, probe = currentProbe()) {
+  if (!isTestProcess(probe.main, probe.env))
+    return;
+  if (isUnderTempDir(path, probe.tempDir))
+    return;
+  throw new Error(`effort store: a test opened ${resolve(path)}, outside the temp directory ${probe.tempDir};` + " a test opens stores under tmpdir() only");
+}
+
 // src/effort/store/types.ts
 function keyOrNull(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
@@ -151,15 +208,23 @@ var EFFORT_KEY_PROJECTIONS = {
 };
 
 // src/effort/store/ndjson.ts
+function kindPath(repoRoot, kind) {
+  return join3(effortStoreDir(repoRoot), effortStoreFileName(kind));
+}
+function openedKindPath(repoRoot, kind) {
+  const path = kindPath(repoRoot, kind);
+  guardTestProcess(path);
+  return path;
+}
 function readKind(repoRoot, kind) {
-  return readStoreRows(effortStorePath(repoRoot, kind));
+  return readStoreRows(openedKindPath(repoRoot, kind));
 }
 function keysOfKind(repoRoot, kind) {
-  const path = effortStorePath(repoRoot, kind);
+  const path = openedKindPath(repoRoot, kind);
   return collectedKeys(path, EFFORT_KEY_PROJECTIONS[kind]);
 }
 function appendKind(repoRoot, kind, rows) {
-  const path = effortStorePath(repoRoot, kind);
+  const path = openedKindPath(repoRoot, kind);
   return appendRows(path, rows, EFFORT_KEY_PROJECTIONS[kind]);
 }
 function openNdjsonStore(repoRoot) {
@@ -167,19 +232,663 @@ function openNdjsonStore(repoRoot) {
     append: (kind, rows) => appendKind(repoRoot, kind, rows),
     keys: (kind) => keysOfKind(repoRoot, kind),
     read: (kind) => readKind(repoRoot, kind).rows,
-    path: (kind) => effortStorePath(repoRoot, kind),
+    path: (kind) => kindPath(repoRoot, kind),
     readRows: (kind) => readKind(repoRoot, kind)
   };
 }
 
 // src/effort/store/sqlite.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2, join as join2 } 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.28.0";
+
+// src/cli/version.ts
+var RAFA_VERSION = version;
+function versionLine() {
+  return `rafa ${RAFA_VERSION}`;
+}
+
+// src/effort/store/development-build.ts
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute3 } from "path";
+
+// src/loop/sessions.ts
+import {
+  linkSync,
+  mkdirSync as mkdirSync4,
+  readdirSync,
+  readFileSync as readFileSync4,
+  renameSync as renameSync3,
+  rmSync as rmSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { basename, dirname as dirname5, 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";
+var SCOPE_DIR = dirname2(CONFIG_FILE);
+var INIT_COMMAND = "rafa init";
+var DISK_FILE_SYSTEM = Object.freeze({
+  exists: (path) => existsSync3(path),
+  realpath: (path) => realpathSync2(path)
+});
+
+class ScopeError extends Error {
+  constructor(message, options) {
+    super(`rafa scope: ${message}`, options);
+    this.name = "ScopeError";
+  }
+}
+function scopeAt(base) {
+  return { dir: join4(base, SCOPE_DIR), configFile: configFilePath(base) };
+}
+function initHint(start, passedUserConfig = null) {
+  const passed = passedUserConfig === null ? [] : [`${passedUserConfig} is the user scope's config and marks no project`];
+  return [
+    `not inside a rafa project: no ${CONFIG_FILE} in ${start} or any directory above it`,
+    ...passed,
+    `run \`${INIT_COMMAND}\` to set one up`
+  ].join(`
+`);
+}
+function requireAbsolute(label, path) {
+  if (!isAbsolute2(path)) {
+    throw new ScopeError(`${label} is ${describeValue(path)}, expected an absolute path`);
+  }
+}
+function realStartOf(start, fs) {
+  try {
+    return fs.realpath(start);
+  } catch (error) {
+    const message = `start directory ${start} does not resolve (${messageOf(error)})`;
+    throw new ScopeError(message, { cause: error });
+  }
+}
+function realHomeOf(home, fs) {
+  try {
+    return fs.realpath(home);
+  } catch {
+    return null;
+  }
+}
+function selfAndAncestors(path) {
+  const parent = dirname2(path);
+  return parent === path ? [path] : [path, ...selfAndAncestors(parent)];
+}
+function walkUp(realStart, realHome, fs) {
+  let passedUserConfig = false;
+  for (const dir of selfAndAncestors(realStart)) {
+    if (!fs.exists(configFilePath(dir)))
+      continue;
+    if (dir !== realHome)
+      return { root: dir, passedUserConfig };
+    passedUserConfig = true;
+  }
+  return { root: null, passedUserConfig };
+}
+function resolveScope(start, seams) {
+  const { home, fs = DISK_FILE_SYSTEM } = 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 passed = walk.passedUserConfig ? user.configFile : null;
+    return { found: false, start, home, user, hint: initHint(start, passed) };
+  }
+  return { found: true, root: walk.root, home, project: scopeAt(walk.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)}` };
+  }
+  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
+var SESSION_STATES = Object.freeze(["running", "paused", "stopped", "done"]);
+var RUNS_DIR = "runs";
+var RECORD_EXTENSION = ".json";
+var SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+
+class SessionRecordError extends Error {
+  file;
+  constructor(file, problem) {
+    super(`session record ${file}: ${problem}`);
+    this.name = "SessionRecordError";
+    this.file = file;
+  }
+}
+
+class SessionConflictError extends Error {
+  conflicts;
+  constructor(conflicts) {
+    const named = conflicts.map((conflict) => `${conflict.record.sessionId} (${conflict.reason})`);
+    super(`the plan's sessions refuse the run: ${named.join(", ")}`);
+    this.name = "SessionConflictError";
+    this.conflicts = conflicts;
+  }
+}
+
+class SessionStateError extends Error {
+  file;
+  state;
+  constructor(file, state, onlyFrom) {
+    const acted = onlyFrom.length === 0 ? "no state" : onlyFrom.join(" or ");
+    super(`session record ${file}: stores ${state}, and the change acts on ${acted} alone`);
+    this.name = "SessionStateError";
+    this.file = file;
+    this.state = state;
+  }
+}
+function isSessionId(value) {
+  return SESSION_ID_PATTERN.test(value);
+}
+function runsDir(root) {
+  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 join7(runsDir(root), `${sessionId}${RECORD_EXTENSION}`);
+}
+function describeValue2(value) {
+  return value === undefined ? "missing" : JSON.stringify(value) ?? String(value);
+}
+function field(fields, key) {
+  return Object.hasOwn(fields, key) ? fields[key] : undefined;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPositiveWhole(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isText(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function taskProblem(task) {
+  if (task === null)
+    return null;
+  if (!isObject(task))
+    return `task is ${describeValue2(task)}, expected null or an object`;
+  if (!isPositiveWhole(field(task, "line"))) {
+    return `task.line is ${describeValue2(field(task, "line"))}, expected a whole number from 1`;
+  }
+  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 sessionIdProblem(sessionId, file) {
+  if (typeof sessionId !== "string" || !isSessionId(sessionId)) {
+    return `sessionId is ${describeValue2(sessionId)}, expected a plain file name`;
+  }
+  return basename(file) === `${sessionId}${RECORD_EXTENSION}` ? null : `sessionId ${JSON.stringify(sessionId)} is not the file's name`;
+}
+function planStubProblem(planStub) {
+  return planStub === null || typeof planStub === "string" && isStampableStub(planStub) ? null : `planStub is ${describeValue2(planStub)}, expected null or a plan stub`;
+}
+function textProblems(fields) {
+  return ["plan", "branch"].filter((key) => !isText(field(fields, key))).map((key) => `${key} is ${describeValue2(field(fields, key))}, expected a non-empty string`);
+}
+function recordProblems(fields, file) {
+  const pid = field(fields, "pid");
+  const startedAt = field(fields, "startedAt");
+  const state = field(fields, "state");
+  const problems = [
+    sessionIdProblem(field(fields, "sessionId"), file),
+    planStubProblem(field(fields, "planStub")),
+    ...textProblems(fields),
+    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")),
+    hopProblem(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");
+  return Object.freeze({
+    sessionId: field(fields, "sessionId"),
+    planStub: field(fields, "planStub"),
+    plan: field(fields, "plan"),
+    branch: field(fields, "branch"),
+    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,
+    ...hop2 === undefined ? {} : { hop: freezeHop(hop2) }
+  });
+}
+function parseSessionRecord(text, file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    throw new SessionRecordError(file, `holds no JSON: ${messageOf(error)}`);
+  }
+  if (!isObject(parsed))
+    throw new SessionRecordError(file, "holds no JSON object");
+  const problems = recordProblems(parsed, file);
+  if (problems.length > 0)
+    throw new SessionRecordError(file, problems.join("; "));
+  return freezeRecord(parsed);
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
+}
+function isPidAlive(pid) {
+  if (!isPositiveWhole(pid))
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return errorCode(error) === "EPERM";
+  }
+}
+function readState(record, isAlive = isPidAlive) {
+  if (record.state === "stopped" || record.state === "done")
+    return record.state;
+  return isAlive(record.pid) ? record.state : "stopped";
+}
+function readRecordFile(file) {
+  let text;
+  try {
+    text = readFileSync4(file, "utf8");
+  } catch (error) {
+    throw new SessionRecordError(file, `cannot be read: ${messageOf(error)}`);
+  }
+  return parseSessionRecord(text, file);
+}
+function recordNames(dir) {
+  try {
+    return readdirSync(dir);
+  } catch (error) {
+    if (errorCode(error) === "ENOENT")
+      return [];
+    throw new SessionRecordError(dir, `cannot be listed: ${messageOf(error)}`);
+  }
+}
+function byStart(a, b) {
+  return Date.parse(a.startedAt) - Date.parse(b.startedAt) || a.sessionId.localeCompare(b.sessionId);
+}
+function readSessions(root, seams = {}) {
+  const dir = runsDir(root);
+  const isAlive = seams.isAlive ?? isPidAlive;
+  const records = recordNames(dir).filter((name2) => name2.endsWith(RECORD_EXTENSION)).map((name2) => readRecordFile(join7(dir, name2))).map((record) => Object.freeze({ ...record, state: readState(record, isAlive) }));
+  return Object.freeze(records.sort(byStart));
+}
+function readSession(root, sessionId, seams = {}) {
+  const record = readRecordFile(sessionFilePath(root, sessionId));
+  return Object.freeze({ ...record, state: readState(record, seams.isAlive ?? isPidAlive) });
+}
+function samePlan(a, b) {
+  if (a.planStub !== null || b.planStub !== null)
+    return a.planStub === b.planStub;
+  return a.plan === b.plan;
+}
+function sessionConflicts(records, candidate) {
+  return records.filter((record) => samePlan(record, candidate)).flatMap((record) => {
+    if (record.branch !== candidate.branch)
+      return [{ reason: "branch", record }];
+    return record.state === "running" || record.state === "paused" ? [{ reason: "live", record }] : [];
+  });
+}
+function checkRecord(record, file) {
+  const problems = recordProblems(record, file);
+  if (problems.length > 0)
+    throw new SessionRecordError(file, `not written: ${problems.join("; ")}`);
+}
+function writeRecordFile(file, record, isNew) {
+  checkRecord(record, file);
+  mkdirSync4(dirname5(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.tmp`;
+  writeFileSync3(temporary, `${JSON.stringify(record, null, 2)}
+`);
+  try {
+    if (isNew)
+      linkSync(temporary, file);
+    else
+      renameSync3(temporary, file);
+  } finally {
+    rmSync3(temporary, { force: true });
+  }
+}
+function beginSession(root, draft, seams = {}) {
+  const file = sessionFilePath(root, draft.sessionId);
+  const record = freezeRecord({ ...draft, state: "running", task: null });
+  const conflicts = sessionConflicts(readSessions(root, seams), record);
+  if (conflicts.length > 0)
+    throw new SessionConflictError(conflicts);
+  writeRecordFile(file, record, true);
+  return record;
+}
+function updateSession(root, sessionId, change) {
+  const file = sessionFilePath(root, sessionId);
+  const stored = readRecordFile(file);
+  if (change.onlyFrom !== undefined && !change.onlyFrom.includes(stored.state)) {
+    throw new SessionStateError(file, stored.state, change.onlyFrom);
+  }
+  const record = freezeRecord({
+    ...stored,
+    state: change.state ?? stored.state,
+    task: change.task === undefined ? stored.task : change.task
+  });
+  writeRecordFile(file, record, false);
+  return record;
+}
+
+// src/runtime/identity.ts
+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 = join8("src", "rafa.ts");
+function realOrResolved(path) {
+  const resolved = resolve2(path);
+  return existsSync4(resolved) ? realpathSync3(resolved) : resolved;
+}
+function manifestName(file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync5(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return null;
+  const name2 = parsed["name"];
+  return typeof name2 === "string" ? name2 : null;
+}
+function nearestRafaPackage(start) {
+  let dir = start;
+  for (;; ) {
+    const manifest = join8(dir, MANIFEST);
+    if (existsSync4(manifest) && manifestName(manifest) === name)
+      return dir;
+    const parent = dirname6(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function readRuntimeIdentity(entry = Bun.main) {
+  const real = realOrResolved(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 };
+}
+
+// src/effort/store/development-build.ts
+var DEVELOPMENT_NEXT_STEP = "rafa effort copy";
+var ADOPTION_NAME = "schema_migrations";
+var EFFORT_DIR_NAME = "effort";
+var DEVELOPMENT_MARK = "+dev:";
+function appliedByName(identity) {
+  return identity.kind === "development" ? `${RAFA_VERSION}${DEVELOPMENT_MARK}${identity.checkout}` : RAFA_VERSION;
+}
+
+class DevelopmentBuildRefusedError extends Error {
+  path;
+  nextStep;
+  constructor(path, message) {
+    super(message);
+    this.name = "DevelopmentBuildRefusedError";
+    this.path = path;
+    this.nextStep = DEVELOPMENT_NEXT_STEP;
+  }
+}
+function storeProjectRoot(path) {
+  const storeDir = dirname7(path);
+  const scopeDir = dirname7(storeDir);
+  if (basename2(storeDir) !== EFFORT_DIR_NAME || basename2(scopeDir) !== SCOPE_DIR)
+    return null;
+  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))
+    return false;
+  return storeProjectRoot(path) === null && isUnderTempDir(path, override);
+}
+function loopSentence(record) {
+  return ` Loop ${record.sessionId} (pid ${String(record.pid)}, plan ${record.planStub ?? record.plan}) is running on this store.`;
+}
+function liveLoopSentences(path, isAlive) {
+  const root = storeProjectRoot(path);
+  if (root === null)
+    return "";
+  try {
+    return readSessions(root, { isAlive }).filter((record) => record.state === "running" || record.state === "paused").map(loopSentence).join("");
+  } catch (error) {
+    return ` The loop records under ${runsDir(root)} could not be read (${messageOf(error)}).`;
+  }
+}
+function developmentRefusalText(path, needs, checkout, loops) {
+  return `effort store: ${path} needs migration ${needs.join(", ")} and this rafa is a development build (${checkout});` + ` a development build migrates only a store under the temp directory or ${EFFORT_DIR_VARIABLE}.` + ` Copy it with '${DEVELOPMENT_NEXT_STEP}' and run this command with ${EFFORT_DIR_VARIABLE}=<the copy>.` + loops;
+}
+function refuseUnownedDevelopmentWrite(path, needs, probe = {}) {
+  const identity = probe.identity ?? readRuntimeIdentity();
+  if (identity.kind !== "development")
+    return;
+  if (isOwnedStore(path, probe.env ?? process.env, probe.tempDir ?? tmpdir2()))
+    return;
+  const loops = liveLoopSentences(path, probe.isAlive ?? isPidAlive);
+  throw new DevelopmentBuildRefusedError(path, developmentRefusalText(path, needs, identity.checkout, loops));
+}
+
 // src/effort/store/migrations.ts
+import { createHash } from "crypto";
+var LEGACY_GATE_OPEN = 13;
+var LEGACY_GATE_CLOSED = 1000;
 var SQLITE_MIGRATIONS = [
-  `
+  {
+    id: "kind-tables",
+    breaks: [],
+    sql: `
   CREATE TABLE sessions (
     seq        INTEGER PRIMARY KEY,
     session_id TEXT NOT NULL UNIQUE CHECK (session_id <> ''),
@@ -191,8 +900,12 @@ var SQLITE_MIGRATIONS = [
     sha      TEXT NOT NULL UNIQUE CHECK (sha <> ''),
     row_json TEXT NOT NULL
   );
-  `,
   `
+  },
+  {
+    id: "findings",
+    breaks: [],
+    sql: `
   CREATE TABLE findings (
     seq          INTEGER PRIMARY KEY,
     id           TEXT NOT NULL UNIQUE CHECK (id <> ''),
@@ -220,8 +933,12 @@ var SQLITE_MIGRATIONS = [
   CREATE UNIQUE INDEX findings_by_trigger_what
     ON findings (session_id, trigger, what)
     WHERE artifact IS NULL;
-  `,
   `
+  },
+  {
+    id: "blockers-and-bugs",
+    breaks: [],
+    sql: `
   CREATE TABLE blockers (
     seq          INTEGER PRIMARY KEY,
     id           TEXT NOT NULL UNIQUE CHECK (id <> ''),
@@ -252,8 +969,12 @@ var SQLITE_MIGRATIONS = [
 
   CREATE UNIQUE INDEX out_of_scope_bugs_by_entry
     ON out_of_scope_bugs (session_id, what, ifnull(artifact, ''), ifnull(security, -1));
-  `,
   `
+  },
+  {
+    id: "report-absences",
+    breaks: [],
+    sql: `
   CREATE TABLE report_absences (
     seq          INTEGER PRIMARY KEY,
     id           TEXT NOT NULL UNIQUE CHECK (id <> ''),
@@ -266,8 +987,12 @@ var SQLITE_MIGRATIONS = [
     outcome      TEXT NOT NULL,
     collected_at TEXT NOT NULL
   );
-  `,
   `
+  },
+  {
+    id: "task-reports",
+    breaks: [],
+    sql: `
   CREATE TABLE task_reports (
     seq          INTEGER PRIMARY KEY,
     id           TEXT NOT NULL UNIQUE CHECK (id <> ''),
@@ -278,8 +1003,12 @@ var SQLITE_MIGRATIONS = [
     outcome      TEXT NOT NULL,
     collected_at TEXT NOT NULL
   );
-  `,
   `
+  },
+  {
+    id: "preflight",
+    breaks: [],
+    sql: `
   CREATE TABLE preflight (
     seq          INTEGER PRIMARY KEY,
     run_id       TEXT NOT NULL CHECK (run_id <> ''),
@@ -295,8 +1024,12 @@ var SQLITE_MIGRATIONS = [
     UNIQUE (run_id, position),
     CHECK ((outcome = 'pass') = (failure IS NULL))
   );
-  `,
   `
+  },
+  {
+    id: "dispatches",
+    breaks: [],
+    sql: `
   CREATE TABLE dispatches (
     seq          INTEGER PRIMARY KEY,
     session_id   TEXT NOT NULL UNIQUE CHECK (session_id <> ''),
@@ -311,8 +1044,12 @@ var SQLITE_MIGRATIONS = [
     flags        TEXT NOT NULL,
     collected_at TEXT NOT NULL
   );
-  `,
   `
+  },
+  {
+    id: "changes",
+    breaks: [],
+    sql: `
   CREATE TABLE changes (
     seq          INTEGER PRIMARY KEY,
     id           TEXT NOT NULL UNIQUE CHECK (id <> ''),
@@ -328,20 +1065,32 @@ var SQLITE_MIGRATIONS = [
 
   CREATE UNIQUE INDEX changes_by_entry
     ON changes (session_id, level, ifnull(area, ''), summary);
-  `,
   `
+  },
+  {
+    id: "out-of-scope-bug-scope",
+    breaks: [],
+    sql: `
   ALTER TABLE out_of_scope_bugs
     ADD COLUMN scope TEXT CHECK (scope IN ('machine', 'rafa'));
-  `,
   `
+  },
+  {
+    id: "dispatch-skills",
+    breaks: [],
+    sql: `
   ALTER TABLE dispatches
     ADD COLUMN resolver TEXT CHECK (resolver IN ('planner', 'tag', 'none'));
   ALTER TABLE dispatches
     ADD COLUMN skills_offered TEXT CHECK (skills_offered IS NULL OR json_type(skills_offered) = 'array');
   ALTER TABLE dispatches
     ADD COLUMN lessons_offered TEXT CHECK (lessons_offered IS NULL OR json_type(lessons_offered) = 'array');
-  `,
   `
+  },
+  {
+    id: "skill-invocations",
+    breaks: [],
+    sql: `
   CREATE TABLE skill_invocations (
     seq        INTEGER PRIMARY KEY,
     session_id TEXT NOT NULL CHECK (session_id <> ''),
@@ -353,12 +1102,20 @@ var SQLITE_MIGRATIONS = [
 
   CREATE UNIQUE INDEX skill_invocations_by_use
     ON skill_invocations (session_id, ifnull(name, ''), ifnull(sidechain, -1));
-  `,
   `
+  },
+  {
+    id: "task-report-skills",
+    breaks: [],
+    sql: `
   ALTER TABLE task_reports
     ADD COLUMN skills_used TEXT CHECK (skills_used IS NULL OR json_type(skills_used) = 'array');
-  `,
   `
+  },
+  {
+    id: "plan-ci",
+    breaks: [],
+    sql: `
   CREATE TABLE plan_ci (
     seq       INTEGER PRIMARY KEY,
     plan_stub TEXT NOT NULL CHECK (plan_stub <> ''),
@@ -371,13 +1128,555 @@ 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;
+function legacyGate(applied) {
+  return applied.every(({ breaks }) => breaks.length === 0) ? LEGACY_GATE_OPEN : LEGACY_GATE_CLOSED;
+}
+function migrationChecksum(migration) {
+  return createHash("sha256").update(migration.sql, "utf8").digest("hex");
+}
+
+// src/effort/store/schema-plan.ts
+var FIX_SCHEMA_STEP = "rafa effort fix-schema --dry-run";
+function sqliteCatalogue(migrations) {
+  return migrations.map(({ sql, ...spec }) => ({ ...spec, sha256: migrationChecksum({ sql }) }));
+}
+function planSchema(store, catalogue, access, caller) {
+  const { path, userVersion, log } = store;
+  if (log === null && (userVersion < 0 || userVersion > LEGACY_GATE_OPEN)) {
+    return refuse("pre-log-unreleased", FIX_SCHEMA_STEP, `effort store: ${path} is at schema version` + ` ${String(userVersion)} with no migration log; no released rafa wrote that.` + " Refusing to read or write it.");
+  }
+  if (log !== null && userVersion !== LEGACY_GATE_OPEN && userVersion !== LEGACY_GATE_CLOSED) {
+    return refuse("gate-mismatch", FIX_SCHEMA_STEP, `effort store: ${path} has a migration log and` + ` schema version ${String(userVersion)}; a build older than the log migrated it after the` + " log was made. Refusing to read or write it.");
+  }
+  const adopted = log === null ? adoptedEntries(catalogue, userVersion) : [];
+  const held = log ?? [];
+  const logRefusal = judgeLog(path, held, catalogue);
+  if (logRefusal !== null)
+    return logRefusal;
+  const heldIds = new Set([...adopted, ...held].map(({ id }) => id));
+  const pending = catalogue.filter(({ id }) => !heldIds.has(id));
+  const unknown = held.filter(({ id }) => !catalogue.some((entry) => entry.id === id));
+  const writes = access === "write" || pending.length > 0;
+  const writersBroken = unknown.find(({ breaks }) => breaks.includes("writers"));
+  if (writes && writersBroken !== undefined) {
+    return refuseUnknown("unknown-breaks-writers", path, writersBroken);
+  }
+  const orderRefusal = judgePending(path, catalogue, heldIds, pending, caller);
+  if (orderRefusal !== null)
+    return orderRefusal;
+  return {
+    verdict: "use",
+    adopted,
+    pending,
+    unknown,
+    gate: legacyGate([...adopted, ...held, ...pending])
+  };
+}
+function adoptedEntries(catalogue, count) {
+  const adopted = catalogue.slice(0, count);
+  if (adopted.length < count) {
+    throw new Error(`schema plan: the catalogue holds ${String(catalogue.length)} migrations,` + ` fewer than the ${String(count)} legacy entries a store at that version holds`);
+  }
+  return adopted;
+}
+function judgeLog(path, log, catalogue) {
+  const byId = new Map(catalogue.map((entry) => [entry.id, entry]));
+  for (const row of log) {
+    const known = byId.get(row.id);
+    if (known !== undefined && known.sha256 !== row.sha256) {
+      return refuse("edited", FIX_SCHEMA_STEP, `effort store: ${path} recorded migration ${row.id}` + ` as sha256 ${row.sha256}, and this rafa holds it as ${known.sha256}; one was edited` + " after it ran. Refusing to read or write the store.");
+    }
+  }
+  const readersBroken = log.find(({ id, breaks }) => !byId.has(id) && breaks.some((word) => word !== "writers"));
+  return readersBroken === undefined ? null : refuseUnknown("unknown-breaks-readers", path, readersBroken);
+}
+function judgePending(path, catalogue, heldIds, pending, caller) {
+  const breaking = pending.filter(({ breaks }) => breaks.length > 0);
+  for (const entry of breaking) {
+    const later = catalogue.slice(catalogue.indexOf(entry) + 1).find(({ id }) => heldIds.has(id));
+    if (later !== undefined) {
+      return refuse("breaking-out-of-order", "rafa effort schema", `effort store: ${path} needs` + ` migration ${entry.id} ahead of ${later.id}, which is already applied; a migration that` + " breaks older runtimes applies only in order. Refusing to read or write the store.");
+    }
+  }
+  const [first] = breaking;
+  if (first === undefined || caller === "migrate")
+    return null;
+  return refuse("breaking-pending", "rafa effort migrate --dry-run", `effort store: ${path} needs` + ` migration ${first.id}, which breaks older runtimes and is applied only by` + " 'rafa effort migrate'; refusing to read or write the store until then.");
+}
+function refuseUnknown(reason, path, row) {
+  const ending = reason === "unknown-breaks-readers" ? "which breaks older readers; refusing to read or write it." : "which breaks older writers; refusing to write it.";
+  return refuse(reason, `install a rafa that knows ${row.id}, or ${FIX_SCHEMA_STEP}`, "effort store:" + ` ${path} holds migration ${row.id} (applied by ${row.appliedBy} on ${dateOf(row.appliedAt)}),` + ` which this rafa does not know and ${ending}`);
+}
+function dateOf(appliedAt) {
+  return /^\d{4}-\d{2}-\d{2}/.test(appliedAt) ? appliedAt.slice(0, 10) : appliedAt;
+}
+function refuse(reason, nextStep, text) {
+  return { verdict: "refuse", reason, message: `${text} Next safe step: ${nextStep}`, nextStep };
+}
+
+// src/effort/store/bring-forward.ts
+var MIGRATION_LOG_TABLE = "schema_migrations";
+var CREATE_MIGRATION_LOG = `
+  CREATE TABLE IF NOT EXISTS ${MIGRATION_LOG_TABLE} (
+    seq        INTEGER PRIMARY KEY,
+    id         TEXT NOT NULL UNIQUE CHECK (id <> ''),
+    sha256     TEXT NOT NULL CHECK (length(sha256) = 64),
+    breaks     TEXT NOT NULL,
+    applied_at TEXT NOT NULL,
+    applied_by TEXT NOT NULL CHECK (applied_by <> '')
+  );
+`;
+
+class SchemaRefusedError extends Error {
+  reason;
+  nextStep;
+  constructor(refusal) {
+    super(refusal.message);
+    this.name = "SchemaRefusedError";
+    this.reason = refusal.reason;
+    this.nextStep = refusal.nextStep;
+  }
+}
+function bringForward(db, path, access, caller, options = {}) {
+  const migrations = options.migrations ?? SQLITE_MIGRATIONS;
+  const catalogue = sqliteCatalogue(migrations);
+  const first = usablePlan(readStoreSchema(db, path), catalogue, access, caller);
+  if (!hasWork(first))
+    return nothingWritten(db);
+  if (options.builtAside !== true)
+    refuseUnownedDevelopmentWrite(path, writeNames(first), options);
+  const apply = db.transaction(() => {
+    const store = readStoreSchema(db, path);
+    const plan = usablePlan(store, catalogue, access, caller);
+    if (!hasWork(plan))
+      return nothingWritten(db);
+    const stamp = {
+      appliedAt: (options.now ?? (() => new Date))().toISOString(),
+      appliedBy: options.appliedBy ?? RAFA_VERSION
+    };
+    db.run(CREATE_MIGRATION_LOG);
+    for (const entry of plan.adopted)
+      logMigration(db, entry, stamp);
+    for (const entry of plan.pending) {
+      db.run(bodyOf(migrations, entry.id));
+      logMigration(db, entry, stamp);
+    }
+    db.run(`PRAGMA user_version = ${String(plan.gate)}`);
+    return {
+      adopted: plan.adopted.map(({ id }) => id),
+      applied: plan.pending.map(({ id }) => id),
+      userVersion: plan.gate
+    };
+  });
+  return apply.immediate();
+}
+function readStoreSchema(db, path) {
+  return { path, userVersion: readUserVersion(db), log: readMigrationLog(db, path) };
+}
+function usablePlan(store, catalogue, access, caller) {
+  const plan = planSchema(store, catalogue, access, caller);
+  if (plan.verdict === "refuse")
+    throw new SchemaRefusedError(plan);
+  return plan;
+}
+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/pr/git.ts
+import { spawnSync } from "child_process";
+function createGitRunner(cwd) {
+  return (args) => {
+    const result = spawnSync("git", [...args], {
+      cwd,
+      encoding: "utf8",
+      env: { ...process.env, LC_ALL: "C" }
+    });
+    if (result.error !== undefined) {
+      return { ok: false, stdout: "", stderr: `could not run git in ${cwd}: ${messageOf(result.error)}` };
+    }
+    return { ok: result.status === 0, stdout: result.stdout ?? "", stderr: result.stderr ?? "" };
+  };
+}
+function gitSaid(result) {
+  return [result.stderr, result.stdout].map((stream) => stream.trim()).filter((stream) => stream !== "").join(`
+`);
+}
+
+// src/schema/project-id.ts
+import { spawnSync as spawnSync2 } from "child_process";
+var PROJECT_ID_LENGTH = 12;
+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 STORE_FILE_NAME = "effort.sqlite";
+var SQLITE_STORE_FILE_NAME = "effort.sqlite";
 function sqliteStorePath(repoRoot) {
-  return join2(repoRoot, EFFORT_STORE_DIR, STORE_FILE_NAME);
+  return join9(effortStoreDir(repoRoot), SQLITE_STORE_FILE_NAME);
 }
 var KIND_TABLES = {
   sessions: { name: "sessions", keyColumn: "session_id" },
@@ -405,51 +1704,31 @@ function batchEntries(kind, rows) {
   }
   return keyed.map(({ key, row }) => ({ key, body: JSON.stringify(row) }));
 }
-function userVersion(db) {
-  const row = db.query("PRAGMA user_version").get();
-  return row?.user_version ?? 0;
-}
-function checkedVersion(db, path, latest) {
-  const version = userVersion(db);
-  if (version > latest) {
-    throw new Error(`effort store: ${path} is at schema version ${version}, past the` + ` ${latest} this rafa knows; refusing to read or write it`);
-  }
-  return version;
-}
-function migrateSchema(db, path, migrations = SQLITE_MIGRATIONS) {
-  const latest = migrations.length;
-  if (checkedVersion(db, path, latest) === latest)
-    return;
-  const applyPending = db.transaction(() => {
-    const from = checkedVersion(db, path, latest);
-    for (const sql of migrations.slice(from))
-      db.run(sql);
-    db.run(`PRAGMA user_version = ${latest}`);
-  });
-  applyPending.immediate();
-}
-function withSqliteStore(path, create, use) {
+function withSqliteStore(path, access, create, use, identity = {}) {
+  guardTestProcess(path);
   if (create)
-    mkdirSync2(dirname2(path), { recursive: true });
+    mkdirSync5(dirname9(path), { recursive: true });
   const db = new Database(path, { readwrite: true, create });
   try {
-    migrateSchema(db, path);
+    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) VALUES (?, ?)` + ` ON CONFLICT (${table.keyColumn}) DO NOTHING`);
+  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 = existsSync2(path);
+  const exists = existsSync5(path);
   if (rowCount > 0)
-    return withSqliteStore(path, !exists, insert);
+    return withSqliteStore(path, "write", !exists, insert);
   if (exists)
-    withSqliteStore(path, false, () => {
+    withSqliteStore(path, "write", false, () => {
       return;
     });
   return empty;
@@ -461,10 +1740,10 @@ function appendKind2(path, kind, rows) {
   return { path, appended, skipped: entries.length - appended };
 }
 function keysOfKind2(path, kind) {
-  if (!existsSync2(path))
+  if (!existsSync5(path))
     return new Set;
-  const { name, keyColumn } = KIND_TABLES[kind];
-  const keys = withSqliteStore(path, false, (db) => db.query(`SELECT ${keyColumn} AS key FROM ${name} ORDER BY seq`).all());
+  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) {
@@ -483,11 +1762,11 @@ function rowOf(body, where) {
   return value;
 }
 function readKind2(path, kind) {
-  if (!existsSync2(path))
+  if (!existsSync5(path))
     return [];
-  const { name } = KIND_TABLES[kind];
-  const stored = withSqliteStore(path, false, (db) => db.query(`SELECT seq, row_json AS body FROM ${name} ORDER BY seq`).all());
-  return stored.map(({ seq, body }) => rowOf(body, `${path}: ${name} row ${seq}`));
+  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);
@@ -501,15 +1780,15 @@ function openSqliteStore(repoRoot) {
 
 // src/adapters/learning/local.ts
 import { appendFile, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join12 } from "path";
 
 // src/commands/instinct/instinct-records.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
-import { join as join4 } from "path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
+import { join as join11 } from "path";
 
 // src/check/layout.ts
-import { readdirSync, statSync } from "fs";
-import { join as join3, relative } from "path";
+import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join10, relative as relative2 } from "path";
 var SKILL_FILE = "SKILL.md";
 var MARKDOWN_EXTENSION = ".md";
 var LAYOUT_SEVERITY = Object.freeze({
@@ -527,7 +1806,7 @@ function layoutIssue(code, message) {
 }
 function entryKind(path) {
   try {
-    const stats = statSync(path);
+    const stats = statSync2(path);
     if (stats.isFile())
       return "file";
     if (stats.isDirectory())
@@ -538,16 +1817,16 @@ function entryKind(path) {
   }
 }
 function visibleNames(dir) {
-  return readdirSync(dir).filter((name) => !name.startsWith(".")).sort((left, right) => left.localeCompare(right));
+  return readdirSync2(dir).filter((name2) => !name2.startsWith(".")).sort((left, right) => left.localeCompare(right));
 }
-function isMarkdown(name) {
-  return name.endsWith(MARKDOWN_EXTENSION);
+function isMarkdown(name2) {
+  return name2.endsWith(MARKDOWN_EXTENSION);
 }
-function markdownStem(name) {
-  return name.slice(0, -MARKDOWN_EXTENSION.length);
+function markdownStem(name2) {
+  return name2.slice(0, -MARKDOWN_EXTENSION.length);
 }
 function shown(root, path) {
-  return relative(root, path) || ".";
+  return relative2(root, path) || ".";
 }
 function dotfileOnlyEntry(kind, root, dir) {
   return {
@@ -569,37 +1848,37 @@ function unreadableEntry(kind, root, path) {
     issues: [layoutIssue("unreadable-entry", `${shown(root, path)} cannot be read (a broken symlink, or a path stat refuses)`)]
   };
 }
-function skillFileEntry(path, name) {
-  return { kind: "skill", path, isFile: true, shape: "skill-file", name, issues: [] };
+function skillFileEntry(path, name2) {
+  return { kind: "skill", path, isFile: true, shape: "skill-file", name: name2, issues: [] };
 }
-function flatGroupedEntry(root, path, name) {
+function flatGroupedEntry(root, path, name2) {
   return {
     kind: "skill",
     path,
     isFile: true,
     shape: "flat-grouped",
-    name,
-    issues: [layoutIssue("flat-grouped-layout", `${shown(root, path)} is the flat grouped layout <dir>/<group>/<name>.md,` + ` which does not register; move it to <dir>/${name}/${SKILL_FILE}`)]
+    name: name2,
+    issues: [layoutIssue("flat-grouped-layout", `${shown(root, path)} is the flat grouped layout <dir>/<group>/<name>.md,` + ` which does not register; move it to <dir>/${name2}/${SKILL_FILE}`)]
   };
 }
-function nestedGroupEntry(root, path, name) {
+function nestedGroupEntry(root, path, name2) {
   return {
     kind: "skill",
     path,
     isFile: true,
     shape: "nested-group",
-    name,
-    issues: [layoutIssue("nested-group-layout", `${shown(root, path)} is the nested layout <dir>/<group>/<name>/${SKILL_FILE},` + ` which does not register; move it to <dir>/${name}/${SKILL_FILE}`)]
+    name: name2,
+    issues: [layoutIssue("nested-group-layout", `${shown(root, path)} is the nested layout <dir>/<group>/<name>/${SKILL_FILE},` + ` which does not register; move it to <dir>/${name2}/${SKILL_FILE}`)]
   };
 }
-function looseFileEntry(root, path, name) {
+function looseFileEntry(root, path, name2) {
   return {
     kind: "skill",
     path,
     isFile: true,
     shape: "loose-file",
-    name,
-    issues: [layoutIssue("loose-file", `${shown(root, path)} sits directly under the skills directory, which registers` + ` only <dir>/<name>/${SKILL_FILE}; move it to <dir>/${name}/${SKILL_FILE}`)]
+    name: name2,
+    issues: [layoutIssue("loose-file", `${shown(root, path)} sits directly under the skills directory, which registers` + ` only <dir>/<name>/${SKILL_FILE}; move it to <dir>/${name2}/${SKILL_FILE}`)]
   };
 }
 function noSkillFileEntry(root, dir) {
@@ -612,30 +1891,30 @@ function noSkillFileEntry(root, dir) {
     issues: [layoutIssue("missing-skill-file", `${shown(root, dir)}/ holds no ${SKILL_FILE}, so it registers no skill`)]
   };
 }
-function nestedInstinctEntry(root, path, name) {
+function nestedInstinctEntry(root, path, name2) {
   return {
     kind: "instinct",
     path,
     isFile: true,
     shape: "nested-instinct",
-    name,
-    issues: [layoutIssue("nested-instinct-file", `${shown(root, path)} sits below the instincts directory, which is flat;` + ` move it to <dir>/${name}${MARKDOWN_EXTENSION}`)]
+    name: name2,
+    issues: [layoutIssue("nested-instinct-file", `${shown(root, path)} sits below the instincts directory, which is flat;` + ` move it to <dir>/${name2}${MARKDOWN_EXTENSION}`)]
   };
 }
-function scanGroupMember(root, dir, name) {
+function scanGroupMember(root, dir, name2) {
   const children = visibleNames(dir);
   if (children.length === 0)
     return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join3(dir, SKILL_FILE);
+  const skillPath = join10(dir, SKILL_FILE);
   if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
-    return [nestedGroupEntry(root, skillPath, name)];
+    return [nestedGroupEntry(root, skillPath, name2)];
   }
   return [noSkillFileEntry(root, dir)];
 }
 function scanSkillGroup(root, dir, children) {
   const entries = [];
   for (const child of children) {
-    const path = join3(dir, child);
+    const path = join10(dir, child);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("skill", root, path));
@@ -652,31 +1931,31 @@ function scanSkillGroup(root, dir, children) {
     return [noSkillFileEntry(root, dir)];
   return entries;
 }
-function scanSkillDirectory(root, dir, name) {
+function scanSkillDirectory(root, dir, name2) {
   const children = visibleNames(dir);
   if (children.length === 0)
     return [dotfileOnlyEntry("skill", root, dir)];
-  const skillPath = join3(dir, SKILL_FILE);
+  const skillPath = join10(dir, SKILL_FILE);
   if (children.includes(SKILL_FILE) && entryKind(skillPath) === "file") {
-    return [skillFileEntry(skillPath, name)];
+    return [skillFileEntry(skillPath, name2)];
   }
   return scanSkillGroup(root, dir, children);
 }
 function scanSkillRoot(root) {
   const entries = [];
-  for (const name of visibleNames(root)) {
-    const path = join3(root, name);
+  for (const name2 of visibleNames(root)) {
+    const path = join10(root, name2);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("skill", root, path));
       continue;
     }
     if (found === "directory") {
-      entries.push(...scanSkillDirectory(root, path, name));
+      entries.push(...scanSkillDirectory(root, path, name2));
       continue;
     }
-    if (isMarkdown(name))
-      entries.push(looseFileEntry(root, path, markdownStem(name)));
+    if (isMarkdown(name2))
+      entries.push(looseFileEntry(root, path, markdownStem(name2)));
   }
   return entries;
 }
@@ -686,7 +1965,7 @@ function scanInstinctSubdirectory(root, dir) {
     return [dotfileOnlyEntry("instinct", root, dir)];
   const entries = [];
   for (const child of children) {
-    const path = join3(dir, child);
+    const path = join10(dir, child);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("instinct", root, path));
@@ -703,8 +1982,8 @@ function scanInstinctSubdirectory(root, dir) {
 }
 function scanInstinctRoot(root) {
   const entries = [];
-  for (const name of visibleNames(root)) {
-    const path = join3(root, name);
+  for (const name2 of visibleNames(root)) {
+    const path = join10(root, name2);
     const found = entryKind(path);
     if (found === null) {
       entries.push(unreadableEntry("instinct", root, path));
@@ -714,14 +1993,14 @@ function scanInstinctRoot(root) {
       entries.push(...scanInstinctSubdirectory(root, path));
       continue;
     }
-    if (!isMarkdown(name))
+    if (!isMarkdown(name2))
       continue;
     entries.push({
       kind: "instinct",
       path,
       isFile: true,
       shape: "instinct-file",
-      name: markdownStem(name),
+      name: markdownStem(name2),
       issues: []
     });
   }
@@ -741,9 +2020,9 @@ function scanLayout(root, kind) {
 function declaredNameIssue(entry, declared) {
   if (entry.name === null || declared === null || declared === entry.name)
     return null;
-  const field = entry.kind === "skill" ? "name" : "id";
+  const field2 = entry.kind === "skill" ? "name" : "id";
   const source = entry.kind === "skill" ? "directory name" : "file name";
-  return layoutIssue("name-mismatch", `frontmatter ${field} "${declared}" is not the ${source} "${entry.name}"`);
+  return layoutIssue("name-mismatch", `frontmatter ${field2} "${declared}" is not the ${source} "${entry.name}"`);
 }
 
 // src/schema/frontmatter.ts
@@ -763,7 +2042,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) {
@@ -774,7 +2053,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);
@@ -831,32 +2110,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;
@@ -889,8 +2142,8 @@ var INSTINCT_KEY_ORDER = [
   "created_at",
   "updated_at"
 ];
-function issue(code, field, message) {
-  return { code, field, message };
+function issue(code, field2, message) {
+  return { code, field: field2, message };
 }
 function typeName(value) {
   if (value === null)
@@ -905,25 +2158,25 @@ function typeName(value) {
     return "a number";
   return `a ${typeof value}`;
 }
-function requiredString(data, field) {
-  const value = data[field];
+function requiredString(data, field2) {
+  const value = data[field2];
   if (value === undefined || value === null) {
-    return [issue("missing-field", field, `${field} is required and is absent`)];
+    return [issue("missing-field", field2, `${field2} is required and is absent`)];
   }
   if (typeof value !== "string") {
-    return [issue("wrong-type", field, `${field} must be a string, not ${typeName(value)}`)];
+    return [issue("wrong-type", field2, `${field2} must be a string, not ${typeName(value)}`)];
   }
   if (value.trim() === "") {
-    return [issue("missing-field", field, `${field} is required and is empty`)];
+    return [issue("missing-field", field2, `${field2} is required and is empty`)];
   }
   return [];
 }
-function requiredChoice(data, field, allowed, code) {
-  const issues = requiredString(data, field);
+function requiredChoice(data, field2, allowed, code) {
+  const issues = requiredString(data, field2);
   if (issues.length > 0)
     return issues;
-  const value = data[field];
-  return allowed.includes(value) ? [] : [issue(code, field, `${field} "${value}" is not one of ${allowed.join(", ")}`)];
+  const value = data[field2];
+  return allowed.includes(value) ? [] : [issue(code, field2, `${field2} "${value}" is not one of ${allowed.join(", ")}`)];
 }
 function checkId(data) {
   const issues = requiredString(data, "id");
@@ -959,11 +2212,11 @@ function checkSources(data) {
     return [issue("wrong-type", "sources", `sources must be a list, not ${typeName(value)}`)];
   }
   return value.flatMap((entry, index) => {
-    const field = `sources[${index}]`;
+    const field2 = `sources[${index}]`;
     if (typeof entry !== "string") {
-      return [issue("wrong-type", field, `sources entries must be strings, and this one is ${typeName(entry)}`)];
+      return [issue("wrong-type", field2, `sources entries must be strings, and this one is ${typeName(entry)}`)];
     }
-    return entry.trim() === "" ? [issue("wrong-type", field, "sources entries must name a source, and this one is blank")] : [];
+    return entry.trim() === "" ? [issue("wrong-type", field2, "sources entries must name a source, and this one is blank")] : [];
   });
 }
 function checkPromotedTo(data) {
@@ -992,26 +2245,26 @@ function checkProjectId(data) {
   }
   return PROJECT_ID_PATTERN.test(value) ? [] : [issue("invalid-project-id", "project_id", `project_id "${value}" is not ${PROJECT_ID_LENGTH} lowercase hex characters`)];
 }
-function checkTimestamp(data, field) {
-  const issues = requiredString(data, field);
+function checkTimestamp(data, field2) {
+  const issues = requiredString(data, field2);
   if (issues.length > 0)
     return issues;
-  const value = data[field];
-  return TIMESTAMP_PATTERN.test(value) && !Number.isNaN(Date.parse(value)) ? [] : [issue("invalid-timestamp", field, `${field} "${value}" is not an ISO 8601 instant such as 2026-09-11T10:00:00Z`)];
+  const value = data[field2];
+  return TIMESTAMP_PATTERN.test(value) && !Number.isNaN(Date.parse(value)) ? [] : [issue("invalid-timestamp", field2, `${field2} "${value}" is not an ISO 8601 instant such as 2026-09-11T10:00:00Z`)];
 }
 function isScalar(value) {
   return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 }
 function checkEvidenceEntry(entry, index) {
-  const field = `evidence[${index}]`;
+  const field2 = `evidence[${index}]`;
   if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-    return [issue("wrong-type", field, `evidence entries must be mappings, and this one is ${typeName(entry)}`)];
+    return [issue("wrong-type", field2, `evidence entries must be mappings, and this one is ${typeName(entry)}`)];
   }
   const entries = Object.entries(entry);
   if (entries.length === 0) {
-    return [issue("wrong-type", field, "evidence entries must say something, and this one is empty")];
+    return [issue("wrong-type", field2, "evidence entries must say something, and this one is empty")];
   }
-  return entries.flatMap(([key, value]) => isScalar(value) ? [] : [issue("wrong-type", `${field}.${key}`, `evidence values must be text, numbers or booleans, and this one is ${typeName(value)}`)]);
+  return entries.flatMap(([key, value]) => isScalar(value) ? [] : [issue("wrong-type", `${field2}.${key}`, `evidence values must be text, numbers or booleans, and this one is ${typeName(value)}`)]);
 }
 function checkEvidence(data) {
   const value = data["evidence"];
@@ -1171,11 +2424,11 @@ function writeInstinct(instinct, newline = `
 }
 
 // src/commands/instinct/instinct-records.ts
-function isRecordFile(name) {
-  return !name.startsWith(".") && name.endsWith(MARKDOWN_EXTENSION) && name !== MARKDOWN_EXTENSION;
+function isRecordFile(name2) {
+  return !name2.startsWith(".") && name2.endsWith(MARKDOWN_EXTENSION) && name2 !== MARKDOWN_EXTENSION;
 }
-function recordId(name) {
-  return name.slice(0, -MARKDOWN_EXTENSION.length);
+function recordId(name2) {
+  return name2.slice(0, -MARKDOWN_EXTENSION.length);
 }
 function unreadableIssue(message) {
   return { code: "missing-frontmatter", field: "file", message: `the file could not be read: ${message}` };
@@ -1183,7 +2436,7 @@ function unreadableIssue(message) {
 function readRecord(path, scope, id) {
   let text;
   try {
-    text = readFileSync2(path, "utf8");
+    text = readFileSync7(path, "utf8");
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     return { scope, path, id, instinct: null, issues: [unreadableIssue(message)] };
@@ -1193,13 +2446,13 @@ function readRecord(path, scope, id) {
 }
 function isFile(path) {
   try {
-    return statSync2(path).isFile();
+    return statSync3(path).isFile();
   } catch {
     return false;
   }
 }
 function recordFiles(dir) {
-  return readdirSync2(dir).filter((name) => isRecordFile(name) && isFile(join4(dir, name))).sort((left, right) => left.localeCompare(right));
+  return readdirSync3(dir).filter((name2) => isRecordFile(name2) && isFile(join11(dir, name2))).sort((left, right) => left.localeCompare(right));
 }
 function readScope(scope, dir) {
   if (!tierExists(dir))
@@ -1208,7 +2461,7 @@ function readScope(scope, dir) {
     scope,
     dir,
     exists: true,
-    records: recordFiles(dir).map((name) => readRecord(join4(dir, name), scope, recordId(name)))
+    records: recordFiles(dir).map((name2) => readRecord(join11(dir, name2), scope, recordId(name2)))
   };
 }
 function readScopes(seams) {
@@ -1220,9 +2473,9 @@ function allRecords(listings) {
 function findRecords(listings, id) {
   return allRecords(listings).filter((entry) => entry.id === id);
 }
-function instinctProject(context, name) {
+function instinctProject(context, name2) {
   if (context.project === null)
-    throw new Error(`${name} runs inside a project, and was handed none`);
+    throw new Error(`${name2} runs inside a project, and was handed none`);
   return context.project;
 }
 
@@ -1305,7 +2558,7 @@ var PREFIX = "local learning";
 var PUSH_REFUSAL = `${PREFIX}: refused to store a push`;
 var INSTINCTS_FILE = "instincts.ndjson";
 var FLAGS_FILE = "flags.ndjson";
-var RECORD_EXTENSION = ".md";
+var RECORD_EXTENSION2 = ".md";
 var MIN_CONFIDENCE = 0.3;
 var MAX_CONFIDENCE = 0.9;
 var SIGNALS = ["loud", "silent"];
@@ -1489,7 +2742,7 @@ function producedRecords(result) {
   for (const record of result.decisions.flatMap((decision) => decision.produced)) {
     const found = byId.get(record.id);
     if (found !== undefined && found !== record) {
-      throw new Error(`${PUSH_REFUSAL}: two records would be written to ${record.id}${RECORD_EXTENSION}`);
+      throw new Error(`${PUSH_REFUSAL}: two records would be written to ${record.id}${RECORD_EXTENSION2}`);
     }
     byId.set(record.id, record);
   }
@@ -1501,7 +2754,7 @@ function heldChanges(dir, held, result, described) {
   const writes = [];
   const kept = new Set;
   for (const record of producedRecords(result)) {
-    const file = `${record.id}${RECORD_EXTENSION}`;
+    const file = `${record.id}${RECORD_EXTENSION2}`;
     const instinct = toHeldInstinct(record, heldInstincts, payloadDescription(record, described));
     if (instinct === null) {
       throw new Error(`${PUSH_REFUSAL}: ${file} has no held member and no payload description to be written with`);
@@ -1511,7 +2764,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 = join5(dir, file);
+    const path = join12(dir, file);
     if (held.unreadable.has(path)) {
       throw new Error(`${PUSH_REFUSAL}: it would overwrite ${path}, which could not be read`);
     }
@@ -1541,18 +2794,18 @@ function pushLogLines(sourceId, described, result) {
   });
 }
 function localInstinctsDir(repoRoot) {
-  return join5(repoRoot, RAFA_INSTINCTS_PATH);
+  return join12(repoRoot, RAFA_INSTINCTS_PATH);
 }
 function userInstinctsDir(home) {
-  return join5(home, RAFA_INSTINCTS_PATH);
+  return join12(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 = join5(instinctsDir, INSTINCTS_FILE);
-  const flagsPath = join5(instinctsDir, FLAGS_FILE);
+  const instinctsPath = join12(instinctsDir, INSTINCTS_FILE);
+  const flagsPath = join12(instinctsDir, FLAGS_FILE);
   function readHeld(scope, dir) {
     const { records } = readScope(scope, dir);
     const unreadable = new Set;
@@ -1669,9 +2922,9 @@ function createJsonOutput({
 }
 
 // src/adapters/planner/claude.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
-import { posix, resolve } from "path";
+import { posix, resolve as resolve3 } from "path";
 
 // src/board/spec-review.ts
 var SPEC_REVIEW_KIND = "spec-review";
@@ -1693,7 +2946,7 @@ var VERDICT_BREAK = /[\s_]+/gu;
 function isMapping2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function describeValue2(value) {
+function describeValue3(value) {
   if (typeof value === "string")
     return JSON.stringify(value);
   if (value === null)
@@ -1726,39 +2979,39 @@ function verdictOf(value) {
   const word = spelled.replace(VERDICT_BREAK, "-");
   return SPEC_REVIEW_VERDICTS.includes(word) ? word : null;
 }
-function issueAt(field, text) {
-  return { field, text };
+function issueAt(field2, text) {
+  return { field: field2, text };
 }
-function readBlocking(item, field, issues) {
+function readBlocking(item, field2, issues) {
   const value = valueAt(item, "blocking");
   if (typeof value === "boolean")
     return value;
-  const text = `${field}.blocking is ${describeValue2(value)}, not true or false; ` + "the gap is read as blocking";
-  issues.push(issueAt(`${field}.blocking`, text));
+  const text = `${field2}.blocking is ${describeValue3(value)}, not true or false; ` + "the gap is read as blocking";
+  issues.push(issueAt(`${field2}.blocking`, text));
   return true;
 }
-function readGap(item, field, issues) {
+function readGap(item, field2, issues) {
   if (!isMapping2(item)) {
-    const text = `${field} is ${describeValue2(item)}, not a mapping of heading and what; dropped`;
-    issues.push(issueAt(field, text));
+    const text = `${field2} is ${describeValue3(item)}, not a mapping of heading and what; dropped`;
+    issues.push(issueAt(field2, text));
     return null;
   }
   const what = stringAt(item, "what");
   if (what === null) {
-    const text = `${field}.what is ${describeValue2(valueAt(item, "what"))}, ` + "not a sentence; the gap is dropped";
-    issues.push(issueAt(`${field}.what`, text));
+    const text = `${field2}.what is ${describeValue3(valueAt(item, "what"))}, ` + "not a sentence; the gap is dropped";
+    issues.push(issueAt(`${field2}.what`, text));
     return null;
   }
   const heading = stringAt(item, "heading");
   if (heading === null) {
-    const text = `${field}.heading is ${describeValue2(valueAt(item, "heading"))}, ` + `not a heading; the gap is filed under ${REVIEW_HEADING}`;
-    issues.push(issueAt(`${field}.heading`, text));
+    const text = `${field2}.heading is ${describeValue3(valueAt(item, "heading"))}, ` + `not a heading; the gap is filed under ${REVIEW_HEADING}`;
+    issues.push(issueAt(`${field2}.heading`, text));
   }
-  const blocking = readBlocking(item, field, issues);
+  const blocking = readBlocking(item, field2, issues);
   const assumption = stringAt(item, "assumption");
   if (!blocking && assumption === null) {
-    const text = `${field}.assumption is ${describeValue2(valueAt(item, "assumption"))}, ` + "not what a non-blocking gap would be planned under; the gap is read as blocking";
-    issues.push(issueAt(`${field}.assumption`, text));
+    const text = `${field2}.assumption is ${describeValue3(valueAt(item, "assumption"))}, ` + "not what a non-blocking gap would be planned under; the gap is read as blocking";
+    issues.push(issueAt(`${field2}.assumption`, text));
     return { heading: heading ?? REVIEW_HEADING, what, blocking: true, assumption: null };
   }
   return { heading: heading ?? REVIEW_HEADING, what, blocking, assumption };
@@ -1768,7 +3021,7 @@ function readGaps(document, issues) {
   if (value === null)
     return [];
   if (!Array.isArray(value)) {
-    const text = `gaps is ${describeValue2(value)}, not a list; no gap is read from it`;
+    const text = `gaps is ${describeValue3(value)}, not a list; no gap is read from it`;
     issues.push(issueAt("gaps", text));
     return [];
   }
@@ -1824,12 +3077,12 @@ function parseSpecReview(output) {
     return unreadable("malformed", block, text);
   }
   if (!isMapping2(document)) {
-    const text = `the rafa:spec-review block at line ${line} holds ${describeValue2(document)}, ` + "not a mapping of verdict and gaps";
+    const text = `the rafa:spec-review block at line ${line} holds ${describeValue3(document)}, ` + "not a mapping of verdict and gaps";
     return unreadable("malformed", block, text);
   }
   const verdict = verdictOf(valueAt(document, "verdict"));
   if (verdict === null) {
-    const text = `the rafa:spec-review block at line ${line} has a verdict of ` + `${describeValue2(valueAt(document, "verdict"))}, ` + `not one of ${SPEC_REVIEW_VERDICTS.join(", ")}`;
+    const text = `the rafa:spec-review block at line ${line} has a verdict of ` + `${describeValue3(valueAt(document, "verdict"))}, ` + `not one of ${SPEC_REVIEW_VERDICTS.join(", ")}`;
     return unreadable("malformed", block, text);
   }
   const issues = [];
@@ -1905,11 +3158,11 @@ class UndeclaredSpendError extends Error {
   name = "UndeclaredSpendError";
 }
 function carriesFlag(flags, flag) {
-  const name = flag.replace(/^--/, "");
-  const value = flags[name];
+  const name2 = flag.replace(/^--/, "");
+  const value = flags[name2];
   if (value !== undefined && value !== false)
     return true;
-  return name.startsWith("no-") && flags[name.slice(3)] === false;
+  return name2.startsWith("no-") && flags[name2.slice(3)] === false;
 }
 function spendRefusal(running2) {
   if (running2 === null)
@@ -2035,12 +3288,12 @@ function createClaudePlanner(options) {
   const create = async ({ specPath, stub }) => {
     const planPath = planFilePath(planDir, `PLAN-${stub}.md`);
     const prerequisitesPath = planFilePath(planDir, `PREREQUISITES-${stub}.md`);
-    const isWritten = (path) => existsSync3(resolve(repoRoot, path));
+    const isWritten = (path) => existsSync6(resolve3(repoRoot, path));
     if (isWritten(planPath)) {
       throw new ClaudePlannerError(`${planPath} already exists`, FAILURE_EXIT_CODE);
     }
-    const specContent = await readFile2(resolve(repoRoot, specPath), "utf8");
-    await mkdir2(resolve(repoRoot, planDir), { recursive: true });
+    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 review = parseSpecReview(session.stdout);
     const { exitCode } = session;
@@ -2151,8 +3404,8 @@ async function withDeadline(work, timeoutMs) {
   if (timeoutMs === undefined)
     return work;
   let timer;
-  const deadline = new Promise((resolve2) => {
-    timer = setTimeout(() => resolve2(TIMED_OUT), timeoutMs);
+  const deadline = new Promise((resolve4) => {
+    timer = setTimeout(() => resolve4(TIMED_OUT), timeoutMs);
   });
   try {
     return await Promise.race([work, deadline]);
@@ -2167,7 +3420,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) {
@@ -2179,8 +3432,8 @@ function isRepoName(value) {
 function isLabelPart(value) {
   return typeof value === "string" && !value.includes(",");
 }
-function optionalFlag(name, value) {
-  return value === undefined ? [] : [name, value];
+function optionalFlag(name2, value) {
+  return value === undefined ? [] : [name2, value];
 }
 function detailOf(result) {
   return result.stderr.trim() || result.stdout.trim() || "it exited non-zero and wrote nothing";
@@ -2222,7 +3475,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)) {
@@ -2243,7 +3496,7 @@ function labelNames(value) {
   if (!Array.isArray(value))
     return null;
   const names = value.map((label) => isMapping(label) && typeof label["name"] === "string" ? label["name"] : null);
-  return names.every((name) => name !== null) ? names : null;
+  return names.every((name2) => name2 !== null) ? names : null;
 }
 function viewProblem(payload, number) {
   if (!isMapping(payload))
@@ -2279,18 +3532,18 @@ function listedIssues(stdout) {
     throw new Error(`${PREFIX2}: ${command} answered ${describeValue(payload)}, expected a list`);
   }
   return payload.map((row, index) => {
-    const refuse = (problem) => new Error(`${PREFIX2}: ${command} answered row ${index} ${problem}`);
+    const refuse2 = (problem) => new Error(`${PREFIX2}: ${command} answered row ${index} ${problem}`);
     if (!isMapping(row))
-      throw refuse(`${describeValue(row)}, expected a mapping`);
+      throw refuse2(`${describeValue(row)}, expected a mapping`);
     const { number, url } = row;
     const labels = labelNames(row["labels"]);
-    if (typeof number !== "number" || !isIssueNumber(String(number))) {
-      throw refuse(`with number ${describeValue(number)}, expected an issue number`);
+    if (typeof number !== "number" || !isIssueNumber3(String(number))) {
+      throw refuse2(`with number ${describeValue(number)}, expected an issue number`);
     }
     if (typeof url !== "string")
-      throw refuse(`with url ${describeValue(url)}, expected a string`);
+      throw refuse2(`with url ${describeValue(url)}, expected a string`);
     if (labels === null)
-      throw refuse("with labels that are not a list of named labels");
+      throw refuse2("with labels that are not a list of named labels");
     return { number, url, labels };
   });
 }
@@ -2319,7 +3572,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)
   };
@@ -2344,9 +3597,9 @@ function createGithubTracker(options) {
     return result.stdout;
   }
   async function ensureLabels(names) {
-    const missing = [...new Set(names)].filter((name) => !knownLabels.has(name));
-    for (const name of missing) {
-      await run(["label", "create", name, "--force"], `gh label create ${describeValue(name)}`);
+    const missing = [...new Set(names)].filter((name2) => !knownLabels.has(name2));
+    for (const name2 of missing) {
+      await run(["label", "create", name2, "--force"], `gh label create ${describeValue(name2)}`);
     }
     knownLabels = new Set([...knownLabels, ...missing]);
   }
@@ -2457,7 +3710,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 join6 } from "path";
+import { join as join13 } from "path";
 var PREFIX3 = "local tracker";
 var FRONTMATTER = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
 var ISSUE_NUMBER2 = /^[1-9]\d*$/;
@@ -2510,11 +3763,11 @@ function parseIssueNumber(text) {
   const number = Number(text);
   return Number.isSafeInteger(number) ? number : null;
 }
-function issueNumberOfFile(name) {
-  return name.endsWith(ISSUE_EXTENSION) ? parseIssueNumber(name.slice(0, -ISSUE_EXTENSION.length)) : null;
+function issueNumberOfFile(name2) {
+  return name2.endsWith(ISSUE_EXTENSION) ? parseIssueNumber(name2.slice(0, -ISSUE_EXTENSION.length)) : null;
 }
 function issuePath(issuesDir, number) {
-  return join6(issuesDir, `${number}${ISSUE_EXTENSION}`);
+  return join13(issuesDir, `${number}${ISSUE_EXTENSION}`);
 }
 async function issueNumbers(issuesDir) {
   let names;
@@ -2528,7 +3781,7 @@ async function issueNumbers(issuesDir) {
   return names.map(issueNumberOfFile).filter((number) => number !== null).sort((a, b) => a - b);
 }
 function localIssuesDir(repoRoot) {
-  return join6(repoRoot, ".rafa", "issues");
+  return join13(repoRoot, ".rafa", "issues");
 }
 function renderLocalIssue(record) {
   const { draft } = record;
@@ -2849,7 +4102,7 @@ var CORE_ADAPTERS = [
 var CORE_ADAPTER_REGISTRY = createAdapterRegistry(CORE_ADAPTERS);
 
 // src/effort/store/index.ts
-function describeValue3(value) {
+function describeValue4(value) {
   if (typeof value === "string")
     return JSON.stringify(value);
   if (typeof value === "object" && value !== null)
@@ -2860,9 +4113,9 @@ function selectEffortStore(repoRoot, config) {
   const adapter = CORE_ADAPTER_REGISTRY.find("store", config.store);
   if (adapter === undefined) {
     const expected = CORE_ADAPTER_REGISTRY.kinds("store").join(", ");
-    throw new TypeError(`effort store: store is ${describeValue3(config.store)},` + ` expected one of: ${expected}`);
+    throw new TypeError(`effort store: store is ${describeValue4(config.store)},` + ` expected one of: ${expected}`);
   }
   return adapter.create({ repoRoot });
 }
 
-export { EFFORT_STORE_DIR, effortStorePath, EFFORT_KEY_PROJECTIONS, openNdjsonStore, SQLITE_MIGRATIONS, sqliteStorePath, LONE_SURROGATE, migrateSchema, 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, SCOPE_DIR, INIT_COMMAND, DISK_FILE_SYSTEM, ScopeError, scopeAt, initHint, selfAndAncestors, resolveScope, POSITION_FILE, positionFilePath, readPositionFile, writePositionFile, positionAt, rehome, hop, goHome, HOP_FILE, hopFilePath, readHopRecord, writeHopRecord, staleAgainst, SessionRecordError, SessionConflictError, SessionStateError, isSessionId, runsDir, sessionFilePath, errorCode, isPidAlive, readSessions, readSession, beginSession, updateSession, readRuntimeIdentity, DEVELOPMENT_NEXT_STEP, ADOPTION_NAME, DEVELOPMENT_MARK, appliedByName, DevelopmentBuildRefusedError, storeProjectRoot, refuseUnownedDevelopmentWrite, LEGACY_GATE_OPEN, LEGACY_GATE_CLOSED, SQLITE_MIGRATIONS, sqliteCatalogue, planSchema, MIGRATION_LOG_TABLE, SchemaRefusedError, bringForward, readStoreSchema, writeNames, ACROSS_STORES_ORDER, STAMPED_COLUMNS, stampedValues, setActiveStoreSettings, activeStoreSettings, createGitRunner, gitSaid, normalizeRemote, gitRemoteUrl, readProjectIdentity, readStoreMeta, SQLITE_STORE_FILE_NAME, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, SKILL_FILE, MARKDOWN_EXTENSION, scanLayout, declaredNameIssue, readFrontmatterDocument, readFrontmatter, renderFrontmatter, mergeFrontmatter, writeFrontmatter, ACTION_HEADING, CAUSE_HEADING, parseInstinct, writeInstinct, readScopes, allRecords, findRecords, instinctProject, toHeldRecords, sessionSpawnEnv, getClaudeUsagePercent, checkUsage, CLAUDE_BIN, claudeArgs, interruptClaudeSessions, runClaude, spawnClaudeCaptured, runClaudeCaptured, planFilePath, ClaudePlannerError, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_STATES, GITHUB_LABELS, createGhRunner, typeOfLabels, moduleOfLabels, createLocalTracker, PORT_VERSIONS, createAdapterRegistry, CORE_ADAPTER_REGISTRY, selectEffortStore };