@open-tomato/rafa 0.45.0 → 0.46.0

package/dist/index-cy98y87p.js

@@ -0,0 +1,2597 @@
+// @bun
+import {
+  activeOutput,
+  activeOutputMode,
+  isStampableStub
+} from "./index-2a7nb3an.js";
+import {
+  CORE_SECTION,
+  SCOPE_DIR,
+  scopeAt
+} from "./index-gvek4r8m.js";
+import {
+  BUSY_TIMEOUT_MAX_MS,
+  BUSY_TIMEOUT_MIN_MS,
+  TEST_SCOPES,
+  bundledBinDirectory,
+  describeValue,
+  isBusyTimeoutMs,
+  messageOf
+} from "./index-ykggr043.js";
+
+// packages/rafa/src/core/adapters/registry.ts
+var REFUSAL = "adapter registry";
+var PORT_VERSIONS = Object.freeze({
+  tracker: 1,
+  store: 1,
+  learning: 1,
+  output: 1,
+  planner: 1,
+  sync: 1,
+  logger: 1
+});
+var SERVED_VERSIONS = new Map(Object.entries(PORT_VERSIONS));
+var PORT_TYPE_LIST = [...SERVED_VERSIONS.keys()].join(", ");
+function checkPortType(port) {
+  if (!SERVED_VERSIONS.has(port)) {
+    throw new TypeError(`${REFUSAL}: port is ${describeValue(port)}, expected one of: ${PORT_TYPE_LIST}`);
+  }
+}
+function accept(adapter, held) {
+  if (typeof adapter !== "object" || adapter === null) {
+    throw new TypeError(`${REFUSAL}: an adapter is ${describeValue(adapter)}, expected a mapping`);
+  }
+  const { port, kind, portVersion, create } = adapter;
+  checkPortType(port);
+  if (typeof kind !== "string" || kind === "") {
+    throw new TypeError(`${REFUSAL}: a ${port} adapter has kind ${describeValue(kind)}, expected a non-empty name`);
+  }
+  const key = `${port}/${kind}`;
+  if (typeof create !== "function") {
+    throw new TypeError(`${REFUSAL}: ${key} has create ${describeValue(create)}, expected a function`);
+  }
+  const served = SERVED_VERSIONS.get(port);
+  if (portVersion !== served) {
+    throw new Error(`${REFUSAL}: ${key} implements ${port} port version ${describeValue(portVersion)},` + ` and core serves ${port} port version ${served}`);
+  }
+  if (held.some((other) => other.port === port && other.kind === kind)) {
+    throw new Error(`${REFUSAL}: ${key} is already registered`);
+  }
+  return Object.freeze({ port, kind, portVersion, create });
+}
+function indexByPort(adapters) {
+  const only = (port) => new Map(adapters.filter((adapter) => adapter.port === port).map((adapter) => [adapter.kind, adapter]));
+  return {
+    tracker: only("tracker"),
+    store: only("store"),
+    learning: only("learning"),
+    output: only("output"),
+    planner: only("planner"),
+    sync: only("sync"),
+    logger: only("logger")
+  };
+}
+function createAdapterRegistry(adapters = []) {
+  const held = adapters.reduce((accepted, adapter) => [...accepted, accept(adapter, accepted)], []);
+  const byPort = indexByPort(held);
+  const registry = {
+    register: (adapter) => createAdapterRegistry([...held, adapter]),
+    find: (port, kind) => SERVED_VERSIONS.has(port) ? byPort[port].get(kind) : undefined,
+    resolve: (port, kind) => {
+      checkPortType(port);
+      const adapter = byPort[port].get(kind);
+      if (adapter !== undefined)
+        return adapter;
+      const registered = [...byPort[port].keys()];
+      const listed = registered.length === 0 ? "none" : registered.join(", ");
+      throw new Error(`${REFUSAL}: no ${port} adapter is registered as ${describeValue(kind)};` + ` registered: ${listed}`);
+    },
+    kinds: (port) => {
+      checkPortType(port);
+      return [...byPort[port].keys()];
+    }
+  };
+  return Object.freeze(registry);
+}
+var EMPTY_ADAPTER_REGISTRY = createAdapterRegistry();
+var COMPOSITION_ROOT = "src/adapter-registry.ts";
+var active = EMPTY_ADAPTER_REGISTRY;
+function holdsNone(registry) {
+  return [...SERVED_VERSIONS.keys()].every((port) => registry.kinds(port).length === 0);
+}
+function registerAdapters(adapters) {
+  const previous = active;
+  active = adapters.reduce((registry, adapter) => registry.register(adapter), previous);
+  return previous;
+}
+function restoreAdapters(registry) {
+  if (registry === CORE_ADAPTER_REGISTRY) {
+    throw new TypeError(`${REFUSAL}: CORE_ADAPTER_REGISTRY reads the active registry and cannot be made the active one;` + " restore what registerAdapters or activeAdapterRegistry answered");
+  }
+  active = registry;
+}
+function activeAdapterRegistry() {
+  return active;
+}
+function registered() {
+  if (holdsNone(active)) {
+    throw new Error(`${REFUSAL}: no adapter is registered: call registerCoreAdapters() from ${COMPOSITION_ROOT}` + " before reading CORE_ADAPTER_REGISTRY");
+  }
+  return active;
+}
+var CORE_ADAPTER_REGISTRY = Object.freeze({
+  register: (adapter) => registered().register(adapter),
+  find: (port, kind) => registered().find(port, kind),
+  resolve: (port, kind) => registered().resolve(port, kind),
+  kinds: (port) => registered().kinds(port)
+});
+// packages/rafa/src/effort/store/types.ts
+function keyOrNull(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+var EFFORT_KEY_PROJECTIONS = {
+  sessions: (row) => keyOrNull(row.sessionId),
+  commits: (row) => keyOrNull(row.sha)
+};
+
+// packages/rafa/src/core/command/spends.ts
+var SPENDS_GLYPH = "\uD83E\uDE99";
+
+// packages/rafa/src/core/command/command.ts
+var MAX_EXIT_CODE = 255;
+
+class CommandExit extends Error {
+  exitCode;
+  constructor(exitCode, message = "", options) {
+    super(message, options);
+    if (!Number.isInteger(exitCode) || exitCode < 0 || exitCode > MAX_EXIT_CODE) {
+      throw new TypeError(`CommandExit: exit code is ${describeValue(exitCode)}, expected a whole number from 0 to ${MAX_EXIT_CODE}`);
+    }
+    this.name = "CommandExit";
+    this.exitCode = exitCode;
+  }
+}
+function isTopLevel(command) {
+  return command.subject === command.action;
+}
+function commandSpelling(command) {
+  return isTopLevel(command) ? command.subject : `${command.subject} ${command.action}`;
+}
+
+// packages/rafa/src/core/command/confirm.ts
+import { createInterface } from "readline";
+var YES_ANSWERS = Object.freeze(["y", "yes"]);
+function createLinePrompter(input, output) {
+  const buffered = [];
+  const waiting = [];
+  let ended = false;
+  const lines = createInterface({ input, terminal: false, crlfDelay: Infinity });
+  lines.on("line", (line) => {
+    const reader = waiting.shift();
+    if (reader === undefined)
+      buffered.push(line);
+    else
+      reader(line);
+  });
+  lines.on("close", () => {
+    ended = true;
+    for (const reader of waiting.splice(0))
+      reader(null);
+  });
+  return {
+    say: (text) => {
+      output.write(`${text}
+`);
+    },
+    ask: async (question) => {
+      output.write(question);
+      const next = buffered.shift();
+      if (next !== undefined)
+        return next;
+      if (ended)
+        return null;
+      return new Promise((settle) => {
+        waiting.push(settle);
+      });
+    },
+    close: () => {
+      lines.close();
+    }
+  };
+}
+function lazyPrompter(open) {
+  let prompter = null;
+  return {
+    ask: async (question) => {
+      prompter ??= open();
+      const answer = await prompter.ask(question);
+      return answer !== null && YES_ANSWERS.includes(answer.trim().toLowerCase());
+    },
+    close: () => {
+      prompter?.close();
+      prompter = null;
+    }
+  };
+}
+// packages/rafa/src/core/command/running.ts
+import { AsyncLocalStorage } from "async_hooks";
+var scopes = new AsyncLocalStorage;
+var running = null;
+function runningCommand() {
+  return scopes.getStore() ?? running;
+}
+// package.json
+var version = "0.46.0";
+
+// packages/rafa/src/core/command/version.ts
+var RAFA_VERSION = version;
+// packages/rafa/src/core/git/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(`
+`);
+}
+// packages/rafa/src/core/git/commit.ts
+import { spawnSync as spawnSync2 } from "child_process";
+var DEFAULT_COMMIT_TYPE = "chore";
+var TEST_NOUN_WINDOW = 40;
+var FIX_VERBS = ["fix", "repair", "correct", "resolve"];
+var REFACTOR_VERBS = [
+  "remove",
+  "delete",
+  "drop",
+  "move",
+  "rename",
+  "relocate",
+  "extract",
+  "split",
+  "inline",
+  "collapse"
+];
+var FEAT_VERBS = [
+  "add",
+  "implement",
+  "introduce",
+  "register",
+  "extend",
+  "call",
+  "wire",
+  "expose",
+  "parse",
+  "strip",
+  "enforce",
+  "generate"
+];
+var CHORE_VERBS = [
+  "capture",
+  "measure",
+  "run",
+  "sweep",
+  "verify",
+  "ensure",
+  "regenerate",
+  "update",
+  "gitignore",
+  "take",
+  "bump",
+  "pin"
+];
+function openingVerbs(verbs) {
+  return new RegExp(`^(?:${verbs.join("|")})\\b`, "i");
+}
+var COMMIT_TYPE_RULES = [
+  {
+    type: "test",
+    pattern: new RegExp(`^.{0,${TEST_NOUN_WINDOW}}?\\btests?\\b`, "i")
+  },
+  { type: "docs", pattern: /\.md\b/i },
+  { type: "fix", pattern: openingVerbs(FIX_VERBS) },
+  { type: "refactor", pattern: openingVerbs(REFACTOR_VERBS) },
+  { type: "feat", pattern: openingVerbs(FEAT_VERBS) },
+  { type: "chore", pattern: openingVerbs(CHORE_VERBS) }
+];
+var MAX_SUBJECT_LENGTH = 72;
+var FALLBACK_DESCRIPTION = "complete the scoped task";
+var MAX_MESSAGE_CHARS = 4000;
+function normaliseTaskText(taskText) {
+  return taskText.replace(/\s+/g, " ").trim();
+}
+function inferCommitType(taskText) {
+  const text = normaliseTaskText(taskText);
+  for (const rule of COMMIT_TYPE_RULES) {
+    if (rule.pattern.test(text))
+      return rule.type;
+  }
+  return DEFAULT_COMMIT_TYPE;
+}
+function countBackticks(text) {
+  let count = 0;
+  for (const character of text) {
+    if (character === "`")
+      count += 1;
+  }
+  return count;
+}
+function balanceCodeSpans(text) {
+  let result = text;
+  while (countBackticks(result) % 2 === 1) {
+    const lastSpace = result.lastIndexOf(" ");
+    if (lastSpace <= 0)
+      return result.replace(/`/g, "");
+    result = result.slice(0, lastSpace).trimEnd();
+  }
+  return result;
+}
+function stripTrailingPeriod(text) {
+  if (!text.endsWith("."))
+    return text;
+  const withoutDot = text.slice(0, -1);
+  const lastToken = withoutDot.slice(withoutDot.lastIndexOf(" ") + 1);
+  if (lastToken.includes("."))
+    return text;
+  return withoutDot;
+}
+function lowerFirstWord(text) {
+  const match = text.match(/^[A-Za-z]+/);
+  const word = match?.[0];
+  if (word === undefined)
+    return text;
+  if (word.length > 1 && word === word.toUpperCase())
+    return text;
+  return text.slice(0, 1).toLowerCase() + text.slice(1);
+}
+var CLAUSE_ENDINGS = new Set([",", ":", "(", ")"]);
+function backtickRunLength(text, start) {
+  let end = start;
+  while (text.charAt(end) === "`")
+    end += 1;
+  return end - start;
+}
+function codeSpanEnd(text, from, length) {
+  let index = text.indexOf("`", from);
+  while (index !== -1) {
+    const run = backtickRunLength(text, index);
+    if (run === length)
+      return index + run;
+    index = text.indexOf("`", index + run);
+  }
+  return -1;
+}
+function firstClause(text) {
+  let index = 0;
+  while (index < text.length) {
+    const character = text.charAt(index);
+    if (character === "`") {
+      const run = backtickRunLength(text, index);
+      const end = codeSpanEnd(text, index + run, run);
+      index = end === -1 ? index + run : end;
+      continue;
+    }
+    if (CLAUSE_ENDINGS.has(character))
+      return text.slice(0, index).trimEnd();
+    index += 1;
+  }
+  return text.trimEnd();
+}
+function truncateDescription(description, budget) {
+  if (budget <= 0)
+    return "";
+  if (description.length <= budget)
+    return description;
+  const window = description.slice(0, budget + 1);
+  const lastSpace = window.lastIndexOf(" ");
+  const cut = lastSpace > 0 ? window.slice(0, lastSpace) : window.slice(0, budget);
+  return balanceCodeSpans(cut.trimEnd()).replace(/[\s,;:-]+$/, "");
+}
+function subjectDescription(normalised) {
+  const clause = firstClause(normalised);
+  const description = clause.length === 0 ? normalised : clause;
+  return lowerFirstWord(stripTrailingPeriod(description));
+}
+function deriveCommitSubject(taskText, options = {}) {
+  const type = inferCommitType(taskText);
+  const scope = options.scope;
+  const prefix = scope === undefined || scope.length === 0 ? `${type}: ` : `${type}(${scope}): `;
+  const normalised = normaliseTaskText(taskText);
+  const uncut = normalised.length === 0 ? FALLBACK_DESCRIPTION : subjectDescription(normalised);
+  const maxLength = options.maxLength ?? MAX_SUBJECT_LENGTH;
+  const description = truncateDescription(uncut, maxLength - prefix.length);
+  const truncated = description !== uncut;
+  return {
+    subject: `${prefix}${description}`,
+    type,
+    truncated
+  };
+}
+function buildCommitMessage(taskText, options = {}) {
+  const derived = deriveCommitSubject(taskText, options);
+  const body = normaliseTaskText(taskText);
+  return { ...derived, body };
+}
+function stageAllArgs() {
+  return ["add", "-A"];
+}
+function stagedChangesArgs() {
+  return ["diff", "--cached", "--quiet"];
+}
+function commitArgs(subject, body = "") {
+  const args = ["commit", "--cleanup=whitespace", "-m", subject];
+  if (body.length > 0)
+    args.push("-m", body);
+  return args;
+}
+function headShaArgs() {
+  return ["rev-parse", "HEAD"];
+}
+var MAX_GIT_BUFFER = 16 * 1024 * 1024;
+function failureMessage(result) {
+  const combined = [result.stderr, result.stdout].map((stream) => stream.trim()).filter((stream) => stream.length > 0).join(`
+`);
+  if (combined.length <= MAX_MESSAGE_CHARS)
+    return combined;
+  return `${combined.slice(0, MAX_MESSAGE_CHARS)}
+[truncated]`;
+}
+function failed(step, subject, result) {
+  return {
+    outcome: "failed",
+    subject,
+    sha: null,
+    failedStep: step,
+    exitCode: result.status,
+    message: failureMessage(result)
+  };
+}
+function spawnGit(cwd) {
+  return (args) => {
+    const result = spawnSync2("git", args, {
+      cwd,
+      encoding: "utf8",
+      maxBuffer: MAX_GIT_BUFFER
+    });
+    if (result.error !== undefined) {
+      return { status: null, stdout: "", stderr: result.error.message };
+    }
+    return {
+      status: result.status,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? ""
+    };
+  };
+}
+function commitTaskWork(options) {
+  const run = options.runGit ?? spawnGit(options.cwd ?? process.cwd());
+  const message = buildCommitMessage(options.taskText, {
+    scope: options.scope,
+    maxLength: options.maxLength
+  });
+  const { subject } = message;
+  const staged = run(stageAllArgs());
+  if (staged.status !== 0)
+    return failed("stage", subject, staged);
+  const pending = run(stagedChangesArgs());
+  if (pending.status === 0) {
+    return {
+      outcome: "nothing-to-commit",
+      subject,
+      sha: null,
+      failedStep: null,
+      exitCode: 0,
+      message: ""
+    };
+  }
+  if (pending.status !== 1)
+    return failed("inspect", subject, pending);
+  const committed = run(commitArgs(subject, message.body));
+  if (committed.status !== 0)
+    return failed("commit", subject, committed);
+  const head = run(headShaArgs());
+  const sha = head.status === 0 ? head.stdout.trim() : null;
+  return {
+    outcome: "committed",
+    subject,
+    sha,
+    failedStep: null,
+    exitCode: 0,
+    message: ""
+  };
+}
+// packages/rafa/src/effort/store/sqlite.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname7, join as join5 } from "path";
+import { Database as Database2 } from "bun:sqlite";
+
+// packages/rafa/src/effort/store/development-build.ts
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename3, dirname as dirname5, isAbsolute as isAbsolute3 } from "path";
+
+// packages/rafa/src/core/loop/sessions.ts
+import {
+  linkSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { dirname, join } from "path";
+
+// packages/rafa/src/core/loop/session-record-parse.ts
+import { basename, isAbsolute } from "path";
+
+// packages/rafa/src/core/loop/hop-record.ts
+var HOP_KINDS = ["blocker", "dry"];
+var HOP_STATES = ["away", "waiting", "merged", "halted"];
+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 isIssueOrNull(value) {
+  return value === null || isIssueNumber(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 (!isRecord(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 (!isIssueNumber(targetEpic) || !isIssueNumber(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
+  };
+}
+
+// packages/rafa/src/core/loop/session-record-parse.ts
+var SESSION_STATES = Object.freeze(["running", "paused", "stopped", "done"]);
+var SESSION_PHASES = Object.freeze(["task", "wrap-up", "pull-request", "ci", "repair"]);
+var RECORD_EXTENSION = ".json";
+var SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+var SESSION_STEP_KINDS = Object.freeze(["baseline", "task", "stage", "pre-wrap-up"]);
+var SESSION_STEP_REASONS = Object.freeze(["declared", "trigger", "fallback", "no-module-tests", "stage"]);
+var SESSION_DECISION_STRATEGIES = Object.freeze(["jump", "defer"]);
+
+class SessionRecordError extends Error {
+  file;
+  constructor(file, problem) {
+    super(`session record ${file}: ${problem}`);
+    this.name = "SessionRecordError";
+    this.file = file;
+  }
+}
+function isSessionId(value) {
+  return SESSION_ID_PATTERN.test(value);
+}
+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 hop = field(fields, "hop");
+  return asHopRecord(hop) === null ? `hop is ${describeValue2(hop)}, expected a hop record` : null;
+}
+function worktreeProblem(fields) {
+  if (!Object.hasOwn(fields, "worktree"))
+    return null;
+  const worktree = field(fields, "worktree");
+  return isText(worktree) && isAbsolute(worktree) ? null : `worktree is ${describeValue2(worktree)}, expected an absolute path`;
+}
+function isTextList(value) {
+  return Array.isArray(value) && value.every(isText);
+}
+function isFailure(value) {
+  return isObject(value) && isText(field(value, "file")) && isText(field(value, "name"));
+}
+function isFailureList(value) {
+  return Array.isArray(value) && value.every(isFailure);
+}
+function failureKey(failure) {
+  return JSON.stringify([failure.file, failure.name]);
+}
+function stepFailuresProblem(step, at) {
+  const failures = field(step, "failures");
+  const newFailures = field(step, "newFailures");
+  if (!isFailureList(failures))
+    return `${at}.failures is ${describeValue2(failures)}, expected a list of failing tests`;
+  if (!isFailureList(newFailures)) {
+    return `${at}.newFailures is ${describeValue2(newFailures)}, expected a list of failing tests`;
+  }
+  const known = new Set(failures.map(failureKey));
+  const stray = newFailures.find((failure) => !known.has(failureKey(failure)));
+  return stray === undefined ? null : `${at}.newFailures names ${describeValue2(stray)}, which ${at}.failures does not`;
+}
+function stepInterruptedProblem(step, at) {
+  if (!Object.hasOwn(step, "interrupted"))
+    return null;
+  const interrupted = field(step, "interrupted");
+  return interrupted === true ? null : `${at}.interrupted is ${describeValue2(interrupted)}, expected true or no key`;
+}
+function stepProblems(step, at) {
+  if (!isObject(step))
+    return [`${at} is ${describeValue2(step)}, expected a step`];
+  const kind = field(step, "kind");
+  const scope = field(step, "scope");
+  const command = field(step, "command");
+  const exitCode = field(step, "exitCode");
+  const summary = field(step, "summary");
+  const problems = [
+    SESSION_STEP_KINDS.includes(kind) ? null : `${at}.kind is ${describeValue2(kind)}, expected one of ${SESSION_STEP_KINDS.join(", ")}`,
+    TEST_SCOPES.includes(scope) || isTextList(scope) ? null : `${at}.scope is ${describeValue2(scope)}, expected one of ${TEST_SCOPES.join(", ")} or a list of paths`,
+    isTextList(command) && command.length > 0 ? null : `${at}.command is ${describeValue2(command)}, expected a non-empty list of arguments`,
+    typeof exitCode === "number" && Number.isSafeInteger(exitCode) ? null : `${at}.exitCode is ${describeValue2(exitCode)}, expected a whole number`,
+    summary === null || typeof summary === "string" ? null : `${at}.summary is ${describeValue2(summary)}, expected null or a string`,
+    stepFailuresProblem(step, at),
+    stepInterruptedProblem(step, at)
+  ];
+  return problems.filter((problem) => problem !== null);
+}
+function isLineIndex(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function taskRefProblems(ref, at) {
+  if (!isObject(ref))
+    return [`${at} is ${describeValue2(ref)}, expected a task`];
+  const lineNum = field(ref, "lineNum");
+  const task = field(ref, "task");
+  const ordinal = field(ref, "ordinal");
+  return [
+    isLineIndex(lineNum) ? null : `${at}.lineNum is ${describeValue2(lineNum)}, expected a whole number from 0`,
+    isText(task) ? null : `${at}.task is ${describeValue2(task)}, expected a non-empty string`,
+    ordinal === undefined || isPositiveWhole(ordinal) ? null : `${at}.ordinal is ${describeValue2(ordinal)}, expected a whole number from 1`
+  ].filter((problem) => problem !== null);
+}
+function afterProblems(decision, strategy, at) {
+  const after = field(decision, "after");
+  if (strategy === "defer") {
+    return after === undefined ? [`${at}.after is missing, expected the task a defer waits on`] : taskRefProblems(after, `${at}.after`);
+  }
+  return after === undefined ? [] : [`${at}.after is ${describeValue2(after)}, expected no key on a jump`];
+}
+function decisionProblems(decision, at) {
+  if (!isObject(decision))
+    return [`${at} is ${describeValue2(decision)}, expected a decision`];
+  const strategy = field(decision, "strategy");
+  const reason = field(decision, "reason");
+  const problems = [
+    ...taskRefProblems(field(decision, "task"), `${at}.task`),
+    SESSION_DECISION_STRATEGIES.includes(strategy) ? null : `${at}.strategy is ${describeValue2(strategy)}, expected one of ${SESSION_DECISION_STRATEGIES.join(", ")}`,
+    isText(reason) ? null : `${at}.reason is ${describeValue2(reason)}, expected a non-empty string`,
+    ...afterProblems(decision, strategy, at)
+  ];
+  return problems.filter((problem) => problem !== null);
+}
+function decisionsProblems(fields) {
+  if (!Object.hasOwn(fields, "decisions"))
+    return [];
+  const decisions = field(fields, "decisions");
+  if (!Array.isArray(decisions))
+    return [`decisions is ${describeValue2(decisions)}, expected a list of decisions`];
+  return decisions.flatMap((decision, index) => decisionProblems(decision, `decisions[${index}]`));
+}
+function stepsProblems(fields) {
+  if (!Object.hasOwn(fields, "steps"))
+    return [];
+  const steps = field(fields, "steps");
+  if (!Array.isArray(steps))
+    return [`steps is ${describeValue2(steps)}, expected a list of steps`];
+  return steps.flatMap((step, index) => stepProblems(step, `steps[${index}]`));
+}
+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),
+    worktreeProblem(fields),
+    ...stepsProblems(fields),
+    ...decisionsProblems(fields)
+  ];
+  return problems.filter((problem) => problem !== null);
+}
+function isSessionPhase(value) {
+  return SESSION_PHASES.includes(value);
+}
+function phaseEntry(phase) {
+  return isSessionPhase(phase) ? { phase } : {};
+}
+function freezeHop(value) {
+  const hop = asHopRecord(value);
+  return Object.freeze({ ...hop, home: Object.freeze(hop.home), from: Object.freeze(hop.from) });
+}
+function errorLinesEntry(errorLines) {
+  const kept = Array.isArray(errorLines) && errorLines.length > 0 && errorLines.every((line) => typeof line === "string");
+  return kept ? { errorLines: Object.freeze([...errorLines]) } : {};
+}
+function freezeFailures(failures) {
+  return Object.freeze(failures.map((failure) => Object.freeze({
+    file: failure.file,
+    name: failure.name,
+    ...errorLinesEntry(field(failure, "errorLines"))
+  })));
+}
+function isStringList(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function isStepOnly(value) {
+  if (!isObject(value))
+    return false;
+  const position = field(value, "position");
+  return isText(field(value, "file")) && isTextList(field(value, "tests")) && isStringList(field(value, "errorLines")) && (position === null || isPositiveWhole(position)) && isTextList(field(value, "before"));
+}
+function stepOnlyEntry(stepOnly) {
+  const whole = Array.isArray(stepOnly) ? stepOnly.filter(isStepOnly) : [];
+  if (whole.length === 0)
+    return {};
+  return { stepOnly: Object.freeze(whole.map((entry) => Object.freeze({
+    file: entry.file,
+    tests: Object.freeze([...entry.tests]),
+    errorLines: Object.freeze([...entry.errorLines]),
+    position: entry.position,
+    before: Object.freeze([...entry.before])
+  }))) };
+}
+function outsideCaseEntry(outsideCase, outputTail) {
+  if (outsideCase !== true)
+    return {};
+  const tail = isStringList(outputTail) ? outputTail : [];
+  return { outsideCase: true, outputTail: Object.freeze([...tail]) };
+}
+function isSessionStepReason(value) {
+  return SESSION_STEP_REASONS.includes(value);
+}
+function reasonEntry(reason) {
+  return isSessionStepReason(reason) ? { reason } : {};
+}
+function freezeStep(step) {
+  return Object.freeze({
+    kind: step.kind,
+    scope: typeof step.scope === "string" ? step.scope : Object.freeze([...step.scope]),
+    ...reasonEntry(field(step, "reason")),
+    command: Object.freeze([...step.command]),
+    exitCode: step.exitCode,
+    summary: step.summary,
+    failures: freezeFailures(step.failures),
+    newFailures: freezeFailures(step.newFailures),
+    ...stepOnlyEntry(field(step, "stepOnly")),
+    ...outsideCaseEntry(field(step, "outsideCase"), field(step, "outputTail")),
+    ...step.interrupted === true ? { interrupted: true } : {}
+  });
+}
+function stepsEntry(steps) {
+  if (!Array.isArray(steps) || steps.length === 0)
+    return {};
+  return { steps: Object.freeze(steps.map(freezeStep)) };
+}
+function freezeTaskRef(ref) {
+  return Object.freeze({
+    lineNum: ref.lineNum,
+    task: ref.task,
+    ...ref.ordinal === undefined ? {} : { ordinal: ref.ordinal }
+  });
+}
+function freezeDecision(decision) {
+  return Object.freeze({
+    task: freezeTaskRef(decision.task),
+    strategy: decision.strategy,
+    reason: decision.reason,
+    ...decision.after === undefined ? {} : { after: freezeTaskRef(decision.after) }
+  });
+}
+function decisionsEntry(decisions) {
+  if (!Array.isArray(decisions) || decisions.length === 0)
+    return {};
+  return { decisions: Object.freeze(decisions.map(freezeDecision)) };
+}
+function freezeRecord(fields) {
+  const task = field(fields, "task");
+  const hop = field(fields, "hop");
+  const worktree = field(fields, "worktree");
+  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,
+    ...phaseEntry(field(fields, "phase")),
+    ...hop === undefined ? {} : { hop: freezeHop(hop) },
+    ...worktree === undefined ? {} : { worktree },
+    ...stepsEntry(field(fields, "steps")),
+    ...decisionsEntry(field(fields, "decisions"))
+  });
+}
+function sessionSteps(record) {
+  return record.steps ?? [];
+}
+function sessionDecisions(record) {
+  return record.decisions ?? [];
+}
+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);
+}
+
+// packages/rafa/src/core/loop/sessions.ts
+var RUNS_DIR = "runs";
+
+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 runsDir(root) {
+  return join(scopeAt(root).dir, RUNS_DIR);
+}
+function sessionFilePath(root, sessionId) {
+  if (!isSessionId(sessionId)) {
+    throw new Error(`session record: unusable session id ${JSON.stringify(sessionId)}`);
+  }
+  return join(runsDir(root), `${sessionId}${RECORD_EXTENSION}`);
+}
+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 = readFileSync(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((name) => name.endsWith(RECORD_EXTENSION)).map((name) => readRecordFile(join(dir, name))).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);
+  mkdirSync(dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(record, null, 2)}
+`);
+  try {
+    if (isNew)
+      linkSync(temporary, file);
+    else
+      renameSync(temporary, file);
+  } finally {
+    rmSync(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 appended = change.appendStep === undefined ? [] : stepProblems(change.appendStep, `steps[${sessionSteps(stored).length}]`);
+  if (appended.length > 0)
+    throw new SessionRecordError(file, `not written: ${appended.join("; ")}`);
+  const record = freezeRecord({
+    ...stored,
+    state: change.state ?? stored.state,
+    task: change.task === undefined ? stored.task : change.task,
+    phase: change.phase ?? stored.phase,
+    steps: change.appendStep === undefined ? sessionSteps(stored) : [...sessionSteps(stored), change.appendStep],
+    decisions: change.decisions ?? sessionDecisions(stored)
+  });
+  writeRecordFile(file, record, false);
+  return record;
+}
+// packages/rafa/src/core/loop/session-env.ts
+import { delimiter } from "path";
+function sessionPath(base, binDir) {
+  return base === undefined || base === "" ? binDir : `${binDir}${delimiter}${base}`;
+}
+function sessionSpawnEnv(base, binDir = bundledBinDirectory()) {
+  return {
+    ...base,
+    PATH: sessionPath(base["PATH"], binDir),
+    CLAUDE_CODE_ENTRYPOINT: "cli"
+  };
+}
+
+// packages/rafa/src/core/loop/claude.ts
+var CLAUDE_BIN = "claude";
+var CLAUDE_BASE_ARGS = [
+  "-p",
+  "--dangerously-skip-permissions"
+];
+var SETTING_SOURCES_FLAG = "--setting-sources";
+function claudeArgs(settingSources, flags = [], served = []) {
+  return [...CLAUDE_BASE_ARGS, SETTING_SOURCES_FLAG, settingSources.join(","), ...served, ...flags];
+}
+var liveSessions = new Set;
+function interruptClaudeSessions() {
+  for (const session of liveSessions)
+    session.kill("SIGINT");
+  return liveSessions.size;
+}
+function carriesFlag(flags, flag) {
+  const name = flag.replace(/^--/, "");
+  const value = flags[name];
+  if (value !== undefined && value !== false)
+    return true;
+  return name.startsWith("no-") && flags[name.slice(3)] === false;
+}
+function spendWarning(running2) {
+  if (running2 === null)
+    return null;
+  const { command, flags } = running2;
+  const spend = command.spends;
+  const named = `rafa ${commandSpelling(command)}`;
+  const remedy = "declare spends on the command to cover this run";
+  if (spend === undefined) {
+    return `${named} started a Claude session but declares no spends: ${remedy}`;
+  }
+  if (spend.when === "with" && !carriesFlag(flags, spend.flag)) {
+    return `${named} started a Claude session without ${spend.flag}, and its spends covers only a run with ${spend.flag}: ${remedy}`;
+  }
+  if (spend.when === "unless" && carriesFlag(flags, spend.flag)) {
+    return `${named} started a Claude session with ${spend.flag}, and its spends covers no run with ${spend.flag}: ${remedy}`;
+  }
+  return null;
+}
+function guardSpend() {
+  const warning = spendWarning(runningCommand());
+  if (warning !== null)
+    activeOutput().warn(`\u26A0\uFE0F  ${warning}`);
+}
+async function spawnClaude(args, prompt, options = {}) {
+  guardSpend();
+  if (activeOutputMode() !== "text") {
+    const { exitCode } = await spawnCaptured(args, prompt, options);
+    return exitCode;
+  }
+  const proc = Bun.spawn([CLAUDE_BIN, ...args], {
+    stdin: new TextEncoder().encode(prompt),
+    stdout: "inherit",
+    stderr: "inherit",
+    env: sessionSpawnEnv(process.env),
+    ...cwdOption(options)
+  });
+  liveSessions.add(proc);
+  try {
+    return await proc.exited ?? 1;
+  } finally {
+    liveSessions.delete(proc);
+  }
+}
+function runClaude(prompt, settingSources, flags = [], spawn = spawnClaude, served = [], options = {}) {
+  return spawn(claudeArgs(settingSources, flags, served), prompt, options);
+}
+function cwdOption(options) {
+  return options.cwd === undefined ? {} : { cwd: options.cwd };
+}
+function writeWholeLines(text, write) {
+  const lines = text.split(`
+`);
+  const rest = lines.pop() ?? "";
+  for (const line of lines)
+    write(line);
+  return rest;
+}
+async function teeToOperator(stream) {
+  const decoder = new TextDecoder;
+  const routed = activeOutputMode() === "text" ? null : activeOutput();
+  const writeLine = (line) => {
+    routed?.info(line);
+  };
+  let text = "";
+  let pending = "";
+  for await (const chunk of stream) {
+    if (routed === null)
+      process.stdout.write(chunk);
+    const decoded = decoder.decode(chunk, { stream: true });
+    text += decoded;
+    if (routed !== null)
+      pending = writeWholeLines(pending + decoded, writeLine);
+  }
+  const tail = decoder.decode();
+  if (routed !== null) {
+    const rest = writeWholeLines(pending + tail, writeLine);
+    if (rest !== "")
+      writeLine(rest);
+  }
+  return text + tail;
+}
+async function spawnClaudeCaptured(args, prompt, options = {}) {
+  guardSpend();
+  return spawnCaptured(args, prompt, options);
+}
+async function spawnCaptured(args, prompt, options = {}) {
+  const proc = Bun.spawn([CLAUDE_BIN, ...args], {
+    stdin: new TextEncoder().encode(prompt),
+    stdout: "pipe",
+    stderr: "inherit",
+    env: sessionSpawnEnv(process.env),
+    ...cwdOption(options)
+  });
+  liveSessions.add(proc);
+  let stdout;
+  try {
+    stdout = await teeToOperator(proc.stdout);
+  } finally {
+    await proc.exited;
+    liveSessions.delete(proc);
+  }
+  return { exitCode: await proc.exited, stdout };
+}
+function runClaudeCaptured(prompt, settingSources, flags = [], spawn = spawnClaudeCaptured, served = [], options = {}) {
+  return spawn(claudeArgs(settingSources, flags, served), prompt, options);
+}
+// packages/rafa/src/core/runtime/identity.ts
+import { existsSync, readFileSync as readFileSync2, realpathSync } from "fs";
+import { dirname as dirname2, join as join2, resolve } from "path";
+var RAFA_PACKAGE_NAME = "@open-tomato/rafa";
+var MANIFEST = "package.json";
+var CHECKOUT_ENTRY = join2("src", "rafa.ts");
+function realOrResolved(path) {
+  const resolved = resolve(path);
+  return existsSync(resolved) ? realpathSync(resolved) : resolved;
+}
+function manifestName(file) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return null;
+  const name = parsed["name"];
+  return typeof name === "string" ? name : null;
+}
+function nearestRafaPackage(start) {
+  let dir = start;
+  for (;; ) {
+    const manifest = join2(dir, MANIFEST);
+    if (existsSync(manifest) && manifestName(manifest) === RAFA_PACKAGE_NAME)
+      return dir;
+    const parent = dirname2(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function readRuntimeIdentity(entry = Bun.main) {
+  const real = realOrResolved(entry);
+  const packageDir = nearestRafaPackage(dirname2(real));
+  if (packageDir !== null && existsSync(join2(packageDir, CHECKOUT_ENTRY))) {
+    return { kind: "development", entry: real, checkout: packageDir };
+  }
+  return { kind: "installed", entry: real };
+}
+// packages/rafa/src/effort/store/location.ts
+import { existsSync as existsSync3, realpathSync as realpathSync2 } from "fs";
+import { tmpdir } from "os";
+import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, join as join4, relative, resolve as resolve2, sep } from "path";
+
+// packages/rafa/src/effort/store/ndjson-files.ts
+import {
+  appendFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3
+} from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+var EFFORT_STORE_DIR = join3(".rafa", "effort");
+var STORE_FILE_NAMES = {
+  sessions: "sessions.ndjson",
+  commits: "commits.ndjson"
+};
+function asObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function normaliseKey(key) {
+  return typeof key === "string" && key.length > 0 ? key : null;
+}
+function effortStoreFileName(kind) {
+  return STORE_FILE_NAMES[kind];
+}
+function readStoreText(path) {
+  return existsSync2(path) ? readFileSync3(path, "utf8") : null;
+}
+function parseStoreText(text) {
+  const rows = [];
+  if (text === null || text.length === 0) {
+    return { rows, lineCount: 0, unparsedLineCount: 0 };
+  }
+  const lines = text.split(/\r?\n/);
+  if (lines[lines.length - 1] === "")
+    lines.pop();
+  let unparsedLineCount = 0;
+  for (const line of lines) {
+    const record = parseRow(line);
+    if (record === null) {
+      unparsedLineCount += 1;
+      continue;
+    }
+    rows.push(record);
+  }
+  return { rows, lineCount: lines.length, unparsedLineCount };
+}
+function parseRow(line) {
+  if (line.trim().length === 0)
+    return null;
+  try {
+    return asObject(JSON.parse(line));
+  } catch {
+    return null;
+  }
+}
+function readStoreRows(path) {
+  return parseStoreText(readStoreText(path));
+}
+function keysOfRows(rows, keyOf) {
+  const keys = new Set;
+  for (const row of rows) {
+    const key = normaliseKey(keyOf(row));
+    if (key !== null)
+      keys.add(key);
+  }
+  return keys;
+}
+function collectedKeys(path, keyOf) {
+  return keysOfRows(readStoreRows(path).rows, keyOf);
+}
+function appendRows(path, rows, keyOf) {
+  const keys = rows.map((row) => normaliseKey(keyOf(row)));
+  const keylessAt = keys.indexOf(null);
+  if (keylessAt !== -1) {
+    const at = `row ${keylessAt} of ${rows.length}`;
+    throw new Error(`effort store: ${at} carries no key; batch refused`);
+  }
+  const text = readStoreText(path);
+  const held = keysOfRows(parseStoreText(text).rows, keyOf);
+  const lines = [];
+  let skipped = 0;
+  for (const [index, row] of rows.entries()) {
+    const key = keys[index] ?? null;
+    if (key === null || held.has(key)) {
+      skipped += 1;
+      continue;
+    }
+    held.add(key);
+    lines.push(JSON.stringify(row));
+  }
+  if (lines.length === 0) {
+    return { path, appended: 0, skipped, separatedPartialLine: false };
+  }
+  const separatedPartialLine = text !== null && text.length > 0 && !text.endsWith(`
+`);
+  const lead = separatedPartialLine ? `
+` : "";
+  mkdirSync2(dirname3(path), { recursive: true });
+  appendFileSync(path, `${lead}${lines.join(`
+`)}
+`, "utf8");
+  return {
+    path,
+    appended: lines.length,
+    skipped,
+    separatedPartialLine
+  };
+}
+
+// packages/rafa/src/effort/store/location.ts
+var EFFORT_DIR_VARIABLE = "RAFA_EFFORT_DIR";
+var TEST_PROCESS_VARIABLE = "RAFA_TEST";
+var TEST_ENTRY_SUFFIX = ".test.ts";
+function canonical(path) {
+  const resolved = resolve2(path);
+  return existsSync3(resolved) ? realpathSync2(resolved) : resolved;
+}
+function realPathOf(path) {
+  const resolved = resolve2(path);
+  if (existsSync3(resolved))
+    return realpathSync2(resolved);
+  const parent = dirname4(resolved);
+  return parent === resolved ? resolved : join4(realPathOf(parent), basename2(resolved));
+}
+function isWithin(path, dir) {
+  const between = relative(resolve2(dir), resolve2(path));
+  const climbsOut = between === ".." || between.startsWith(`..${sep}`);
+  return !climbsOut && !isAbsolute2(between);
+}
+function readEffortDirOverride(repoRoot, env = process.env) {
+  const value = env[EFFORT_DIR_VARIABLE];
+  if (value === undefined || value === "")
+    return null;
+  if (!isAbsolute2(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(join4(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) ?? join4(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(realPathOf(path), realPathOf(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 ${resolve2(path)}, outside the temp directory ${probe.tempDir};` + " a test opens stores under tmpdir() only");
+}
+
+// packages/rafa/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 = dirname5(path);
+  const scopeDir = dirname5(storeDir);
+  if (basename3(storeDir) !== EFFORT_DIR_NAME || basename3(scopeDir) !== SCOPE_DIR)
+    return null;
+  return dirname5(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));
+}
+
+// packages/rafa/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 <> ''),
+    row_json   TEXT NOT NULL
+  );
+
+  CREATE TABLE commits (
+    seq      INTEGER PRIMARY KEY,
+    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 <> ''),
+    session_id   TEXT NOT NULL CHECK (session_id <> ''),
+    plan_stub    TEXT,
+    task_line    TEXT NOT NULL,
+    kind         TEXT
+      CHECK (kind IN ('gotcha', 'pattern', 'location', 'skill-suggestion')),
+    trigger      TEXT CHECK (trigger <> ''),
+    what         TEXT CHECK (what <> ''),
+    cause        TEXT,
+    resolution   TEXT,
+    artifact     TEXT CHECK (artifact <> ''),
+    signal       TEXT CHECK (signal IN ('loud', 'silent')),
+    outcome      TEXT NOT NULL,
+    tracker_ref  TEXT,
+    collected_at TEXT NOT NULL,
+    CHECK (artifact IS NOT NULL OR (trigger IS NOT NULL AND what IS NOT NULL))
+  );
+
+  CREATE UNIQUE INDEX findings_by_artifact
+    ON findings (session_id, artifact)
+    WHERE artifact IS NOT NULL;
+
+  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 <> ''),
+    session_id   TEXT NOT NULL CHECK (session_id <> ''),
+    plan_stub    TEXT,
+    task_line    TEXT NOT NULL,
+    what         TEXT NOT NULL CHECK (what <> ''),
+    artifact     TEXT CHECK (artifact <> ''),
+    outcome      TEXT NOT NULL,
+    collected_at TEXT NOT NULL
+  );
+
+  CREATE UNIQUE INDEX blockers_by_entry
+    ON blockers (session_id, what, ifnull(artifact, ''));
+
+  CREATE TABLE out_of_scope_bugs (
+    seq          INTEGER PRIMARY KEY,
+    id           TEXT NOT NULL UNIQUE CHECK (id <> ''),
+    session_id   TEXT NOT NULL CHECK (session_id <> ''),
+    plan_stub    TEXT,
+    task_line    TEXT NOT NULL,
+    what         TEXT NOT NULL CHECK (what <> ''),
+    artifact     TEXT CHECK (artifact <> ''),
+    security     INTEGER CHECK (security IN (0, 1)),
+    outcome      TEXT NOT NULL,
+    collected_at TEXT NOT NULL
+  );
+
+  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 <> ''),
+    session_id   TEXT NOT NULL UNIQUE CHECK (session_id <> ''),
+    plan_stub    TEXT,
+    task_line    TEXT NOT NULL,
+    reason       TEXT NOT NULL CHECK (reason <> ''),
+    detail       TEXT NOT NULL CHECK (detail <> ''),
+    block_body   TEXT,
+    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 <> ''),
+    session_id   TEXT NOT NULL UNIQUE CHECK (session_id <> ''),
+    plan_stub    TEXT,
+    task_line    TEXT NOT NULL,
+    status       TEXT CHECK (status IN ('done', 'blocked')),
+    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 <> ''),
+    position     INTEGER NOT NULL CHECK (typeof(position) = 'integer' AND position >= 0),
+    tier         TEXT NOT NULL CHECK (tier IN ('required', 'optional')),
+    kind         TEXT NOT NULL CHECK (kind <> ''),
+    item         TEXT NOT NULL CHECK (item <> ''),
+    probe        TEXT CHECK (probe <> ''),
+    outcome      TEXT NOT NULL CHECK (outcome IN ('pass', 'fail', 'timeout')),
+    duration_ms  INTEGER NOT NULL CHECK (typeof(duration_ms) = 'integer' AND duration_ms >= 0),
+    failure      TEXT CHECK (failure <> ''),
+    collected_at TEXT NOT NULL,
+    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 <> ''),
+    plan_stub    TEXT,
+    task_line    TEXT NOT NULL,
+    declaration  TEXT CHECK (declaration <> ''),
+    agent        TEXT CHECK (agent <> ''),
+    model        TEXT CHECK (model <> ''),
+    effort       TEXT CHECK (effort <> ''),
+    budget_usd   REAL CHECK (budget_usd IS NULL OR (typeof(budget_usd) IN ('integer', 'real') AND budget_usd > 0)),
+    tools        TEXT CHECK (tools <> ''),
+    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 <> ''),
+    session_id   TEXT NOT NULL CHECK (session_id <> ''),
+    plan_stub    TEXT,
+    task_line    TEXT NOT NULL,
+    level        TEXT NOT NULL
+      CHECK (level IN ('patch', 'minor', 'major', 'none')),
+    area         TEXT CHECK (area <> ''),
+    summary      TEXT NOT NULL CHECK (summary <> ''),
+    collected_at TEXT NOT NULL
+  );
+
+  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 <> ''),
+    name       TEXT CHECK (name <> ''),
+    sidechain  INTEGER CHECK (sidechain IN (0, 1)),
+    count      INTEGER CHECK (count IS NULL OR (typeof(count) = 'integer' AND count > 0)),
+    CHECK ((name IS NULL) = (count IS NULL) AND (name IS NULL) = (sidechain IS NULL))
+  );
+
+  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 <> ''),
+    pr        INTEGER NOT NULL CHECK (typeof(pr) = 'integer' AND pr > 0),
+    head_sha  TEXT NOT NULL CHECK (head_sha <> ''),
+    verdict   TEXT NOT NULL CHECK (verdict IN ('green', 'red', 'none')),
+    failing   TEXT NOT NULL CHECK (json_valid(failing) AND json_type(failing) = 'array'),
+    read_at   TEXT NOT NULL CHECK (read_at <> ''),
+    UNIQUE (pr, head_sha, read_at),
+    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 <> '')
+  );
+  `
+  },
+  {
+    id: "store-meta-generation",
+    breaks: [],
+    sql: `
+  ALTER TABLE store_meta ADD COLUMN generation TEXT CHECK (generation <> '');
+  `
+  },
+  {
+    id: "session-worktree",
+    breaks: [],
+    sql: `
+  ALTER TABLE sessions ADD COLUMN worktree TEXT;
+  `
+  },
+  {
+    id: "store-replaced",
+    breaks: [],
+    sql: `
+  CREATE TABLE store_replaced (
+    store_id    TEXT NOT NULL PRIMARY KEY CHECK (store_id <> ''),
+    replaced_at TEXT NOT NULL CHECK (replaced_at <> '')
+  );
+  `
+  },
+  {
+    id: "stale-docs",
+    breaks: [],
+    sql: `
+  CREATE TABLE stale_docs (
+    seq          INTEGER PRIMARY KEY,
+    id           TEXT NOT NULL UNIQUE CHECK (id <> ''),
+    session_id   TEXT NOT NULL CHECK (session_id <> ''),
+    plan_stub    TEXT,
+    task_line    TEXT NOT NULL,
+    kind         TEXT NOT NULL CHECK (kind IN ('sighting', 'unsettled')),
+    where_at     TEXT CHECK (where_at <> ''),
+    what         TEXT NOT NULL CHECK (what <> ''),
+    outcome      TEXT NOT NULL,
+    collected_at TEXT NOT NULL,
+    origin_store TEXT,
+    origin_seq   INTEGER
+  );
+
+  CREATE UNIQUE INDEX stale_docs_by_entry
+    ON stale_docs (session_id, kind, ifnull(where_at, ''), what);
+
+  CREATE UNIQUE INDEX stale_docs_by_origin
+    ON stale_docs (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+  `
+  },
+  {
+    id: "bug-routes",
+    breaks: [],
+    sql: `
+  CREATE TABLE bug_routes (
+    seq          INTEGER PRIMARY KEY,
+    id           TEXT NOT NULL UNIQUE CHECK (id <> ''),
+    session_id   TEXT NOT NULL CHECK (session_id <> ''),
+    plan_stub    TEXT,
+    task_line    TEXT NOT NULL,
+    entry_index  INTEGER NOT NULL CHECK (entry_index >= 0),
+    what         TEXT NOT NULL CHECK (what <> ''),
+    said         TEXT CHECK (said IN ('bug', 'own-fallout', 'own-gap', 'convention', 'docs', 'machine')),
+    kind         TEXT NOT NULL CHECK (kind IN ('bug', 'own-fallout', 'own-gap', 'convention', 'docs', 'machine')),
+    route        TEXT NOT NULL CHECK (route IN ('filed', 'private', 'machine', 'inherited', 'repair', 'follow-up', 'pr-body', 'docs')),
+    collected_at TEXT NOT NULL,
+    origin_store TEXT,
+    origin_seq   INTEGER
+  );
+
+  CREATE UNIQUE INDEX bug_routes_by_entry
+    ON bug_routes (session_id, entry_index, what);
+
+  CREATE UNIQUE INDEX bug_routes_by_origin
+    ON bug_routes (origin_store, origin_seq)
+    WHERE origin_store IS NOT NULL;
+  `
+  }
+];
+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");
+}
+
+// packages/rafa/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 };
+}
+
+// packages/rafa/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]);
+}
+
+// packages/rafa/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`;
+}
+
+// packages/rafa/src/effort/store/settings.ts
+var DEFAULT_STORE_SETTINGS = Object.freeze({
+  busyTimeoutMs: CORE_SECTION.defaults.effortBusyTimeoutMs
+});
+var active2 = DEFAULT_STORE_SETTINGS;
+function setActiveStoreSettings(settings) {
+  if (settings === null) {
+    active2 = 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)}`);
+  }
+  active2 = Object.freeze({ busyTimeoutMs: settings.busyTimeoutMs });
+}
+function activeStoreSettings() {
+  return active2;
+}
+
+// packages/rafa/src/effort/store/store-meta.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { dirname as dirname6 } from "path";
+import { Database } from "bun:sqlite";
+
+// packages/rafa/src/effort/store/store-generation.ts
+import { randomUUID } from "crypto";
+import { readFileSync as readFileSync4, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+var STORE_GENERATION_SUFFIX = ".generation";
+function storeGenerationPath(storePath) {
+  return `${storePath}${STORE_GENERATION_SUFFIX}`;
+}
+function isMissingFile(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function readStoreGeneration(storePath) {
+  let text;
+  try {
+    text = readFileSync4(storeGenerationPath(storePath), "utf8");
+  } catch (error) {
+    if (isMissingFile(error))
+      return null;
+    throw error;
+  }
+  const generation = text.trim();
+  return generation === "" ? null : generation;
+}
+function assertWritableGeneration(generation) {
+  if (generation === "" || generation !== generation.trim() || /[\r\n]/.test(generation)) {
+    throw new Error(`store generation must be non-empty, unpadded and on one line, got ${JSON.stringify(generation)}`);
+  }
+}
+function writeStoreGeneration(storePath, generation) {
+  assertWritableGeneration(generation);
+  const file = storeGenerationPath(storePath);
+  const temporary = `${file}.${String(process.pid)}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync2(temporary, `${generation}
+`, { encoding: "utf8", flag: "wx" });
+    renameSync2(temporary, file);
+  } catch (error) {
+    rmSync2(temporary, { force: true });
+    throw error;
+  }
+}
+
+// packages/rafa/src/effort/store/store-identity.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import { createHmac } from "crypto";
+import { readFileSync as readFileSync5, realpathSync as realpathSync3, statSync } from "fs";
+import { hostname, platform as currentPlatform } from "os";
+
+// packages/rafa/src/schema/project-id.ts
+import { spawnSync as spawnSync3 } 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 = spawnSync3("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;
+}
+
+// packages/rafa/src/effort/store/store-identity.ts
+var HOST_ID_KEY = "rafa effort store host id";
+var MACHINE_ID_PATH = "/etc/machine-id";
+var IOREG_PATH = "/usr/sbin/ioreg";
+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 = readFileSync5(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 = spawnSync4(IOREG_PATH, [...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 = realpathSync3(path);
+  const stats = statSync(storePath, { bigint: true });
+  return { storePath, fileDev: stats.dev, fileIno: stats.ino };
+}
+function observeStore(path, readHost = readHostId) {
+  const fileFacts = readStoreFileFacts(path);
+  return { hostId: readHost(), ...fileFacts, generation: readStoreGeneration(fileFacts.storePath) };
+}
+function staleGeneration(recorded, facts) {
+  return recorded.generation !== null && recorded.generation !== facts.generation;
+}
+function movedFacts(recorded, facts) {
+  const sameFile = BigInt(recorded.fileDev) === facts.fileDev && BigInt(recorded.fileIno) === facts.fileIno;
+  const moved = [
+    ["host", recorded.hostId !== facts.hostId],
+    ["path", recorded.storePath !== facts.storePath],
+    ["file", !sameFile],
+    ["generation", staleGeneration(recorded, facts)]
+  ];
+  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) };
+}
+
+// packages/rafa/src/effort/store/store-replaced.ts
+var STORE_REPLACED_TABLE = "store_replaced";
+function hasStoreReplacedTable(db) {
+  return db.query("SELECT count(*) AS n FROM sqlite_master WHERE type = 'table' AND name = ?").get(STORE_REPLACED_TABLE)?.n === 1;
+}
+function readReplacedStoreIds(db) {
+  if (!hasStoreReplacedTable(db))
+    return [];
+  return db.query("SELECT store_id, replaced_at FROM store_replaced ORDER BY replaced_at, store_id").all().map((row) => ({ storeId: row.store_id, replacedAt: row.replaced_at }));
+}
+function recordReplacedStoreId(db, storeId, replacedAt) {
+  if (storeId === "")
+    throw new Error("replaced store id must be non-empty");
+  if (Number.isNaN(replacedAt.getTime())) {
+    throw new Error(`replaced time of store ${storeId} is not a valid date`);
+  }
+  db.query("INSERT INTO store_replaced (store_id, replaced_at) VALUES (?, ?) ON CONFLICT (store_id) DO NOTHING").run(storeId, replacedAt.toISOString());
+}
+function clearReplacedStoreIds(db) {
+  if (!hasStoreReplacedTable(db))
+    return;
+  db.run("DELETE FROM store_replaced");
+}
+
+// packages/rafa/src/effort/store/store-meta.ts
+var STORED_INTEGER_BITS = 64;
+var COPY_REASONS = ["host", "path"];
+function toStoredInteger(value) {
+  return BigInt.asIntN(STORED_INTEGER_BITS, value);
+}
+function fromStoredInteger(text) {
+  return BigInt.asUintN(STORED_INTEGER_BITS, BigInt(text));
+}
+function hasGenerationColumn(db) {
+  return db.query("SELECT count(*) AS n FROM pragma_table_info('store_meta') WHERE name = 'generation'").get()?.n === 1;
+}
+function readStoreMeta(db) {
+  const generation = hasGenerationColumn(db) ? "generation" : "NULL AS generation";
+  const row = db.query("SELECT store_id, project_root_commit, project_remote, host_id, store_path," + " CAST(file_dev AS TEXT) AS file_dev, CAST(file_ino AS TEXT) AS file_ino, minted_at," + ` ${generation} FROM store_meta WHERE id = 1`).get();
+  if (row === null)
+    return null;
+  return {
+    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,
+    generation: row.generation
+  };
+}
+function projectFor(storePath, recorded, seams) {
+  const read = (seams.readProject ?? readProjectIdentity)(dirname6(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, generation, mintedAt, seams) {
+  const storeId = (seams.newStoreId ?? randomUUID2)();
+  db.query("INSERT OR REPLACE INTO store_meta (id, store_id, project_root_commit, project_remote," + " host_id, store_path, file_dev, file_ino, minted_at, generation) VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?, ?)").run(storeId, project.rootCommit, project.remote, facts.hostId, facts.storePath, toStoredInteger(facts.fileDev), toStoredInteger(facts.fileIno), mintedAt.toISOString(), generation);
+  return storeId;
+}
+function settleReplacedIds(db, outgoing, reasons, mintedAt) {
+  if (reasons.some((reason) => COPY_REASONS.includes(reason))) {
+    clearReplacedStoreIds(db);
+    return;
+  }
+  if (outgoing === null)
+    return;
+  recordReplacedStoreId(db, outgoing.storeId, mintedAt);
+}
+function settleUnderLock(db, observe, prefetched, seams) {
+  const current = readStoreMeta(db);
+  const facts = observe();
+  const decision = decideStoreIdentity("write", current, () => facts);
+  if (decision.action === "none")
+    return { action: "none" };
+  const generation = (seams.newGeneration ?? randomUUID2)();
+  if (decision.action === "keep") {
+    db.query("UPDATE store_meta SET generation = ? WHERE id = 1").run(generation);
+    writeStoreGeneration(facts.storePath, generation);
+    return { action: "keep", storeId: decision.storeId };
+  }
+  const project = prefetched ?? projectFor(facts.storePath, current, seams);
+  if (project === null)
+    return { action: "no-project", reasons: decision.reasons };
+  const mintedAt = seams.now?.() ?? new Date;
+  settleReplacedIds(db, current, decision.reasons, mintedAt);
+  const storeId = writeStoreMeta(db, facts, project, generation, mintedAt, seams);
+  writeStoreGeneration(facts.storePath, generation);
+  return { action: "mint", storeId, reasons: decision.reasons };
+}
+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);
+  const prefetched = first.action === "mint" ? projectFor(first.facts.storePath, recorded, seams) : undefined;
+  if (first.action === "mint" && prefetched === null)
+    return { action: "no-project", reasons: first.reasons };
+  const underLock = db.transaction(() => settleUnderLock(db, observe, prefetched ?? undefined, seams));
+  return underLock.immediate();
+}
+function hasStoreMetaTable(db) {
+  return db.query("SELECT count(*) AS n FROM sqlite_master WHERE type = 'table' AND name = 'store_meta'").get()?.n === 1;
+}
+function decideLiveWrite(livePath, readHost) {
+  const live = new Database(livePath, { readonly: true });
+  let recorded;
+  try {
+    if (!hasStoreMetaTable(live))
+      return { action: "no-table" };
+    recorded = readStoreMeta(live);
+  } finally {
+    live.close();
+  }
+  if (recorded === null)
+    return { action: "no-row" };
+  const facts = observeStore(livePath, readHost);
+  const decision = decideStoreIdentity("write", recorded, () => facts);
+  if (decision.action === "keep")
+    return { action: "keep", storeId: decision.storeId };
+  const reasons = decision.action === "mint" ? decision.reasons : [];
+  return { action: "mint", reasons };
+}
+function holdsRowOf(db, storeId) {
+  return hasStoreMetaTable(db) && readStoreMeta(db)?.storeId === storeId;
+}
+function spoilGeneration(db, newGeneration) {
+  if (!hasStoreMetaTable(db) || !hasGenerationColumn(db))
+    return null;
+  const rows = db.query("SELECT count(*) AS n FROM store_meta WHERE id = 1").get()?.n;
+  if (rows !== 1)
+    return null;
+  const generation = newGeneration();
+  db.query("UPDATE store_meta SET generation = ? WHERE id = 1").run(generation);
+  return generation;
+}
+function writeCarried(db, storeId, parallel, newGeneration) {
+  const dev = toStoredInteger(parallel.fileDev);
+  const ino = toStoredInteger(parallel.fileIno);
+  if (hasGenerationColumn(db)) {
+    const generation = newGeneration();
+    db.query("UPDATE store_meta SET file_dev = ?, file_ino = ?, generation = ? WHERE id = 1").run(dev, ino, generation);
+    return { action: "carried", storeId, generation };
+  }
+  db.query("UPDATE store_meta SET file_dev = ?, file_ino = ? WHERE id = 1").run(dev, ino);
+  return { action: "carried", storeId, generation: null };
+}
+function carryStoreIdentity(livePath, parallelPath, seams = {}) {
+  const parallel = readStoreFileFacts(parallelPath);
+  const live = decideLiveWrite(livePath, seams.readHostId ?? readHostId);
+  const newGeneration = seams.newGeneration ?? randomUUID2;
+  const db = new Database(parallelPath, { readwrite: true });
+  try {
+    if (live.action === "keep" && holdsRowOf(db, live.storeId)) {
+      return writeCarried(db, live.storeId, parallel, newGeneration);
+    }
+    const spoiled = spoilGeneration(db, newGeneration);
+    return live.action === "keep" ? { action: "other-row", spoiled } : { ...live, spoiled };
+  } finally {
+    db.close();
+  }
+}
+
+// packages/rafa/src/effort/store/sqlite.ts
+var SQLITE_STORE_FILE_NAME = "effort.sqlite";
+function sqliteStorePath(repoRoot) {
+  return join5(effortStoreDir(repoRoot), SQLITE_STORE_FILE_NAME);
+}
+var KIND_TABLES = {
+  sessions: {
+    name: "sessions",
+    keyColumn: "session_id",
+    fieldColumns: [{ column: "worktree", value: (row) => row.worktree ?? null }]
+  },
+  commits: { name: "commits", keyColumn: "sha", fieldColumns: [] }
+};
+var LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+function hasKey(entry) {
+  return entry.key !== null;
+}
+function refused(index, length, reason) {
+  return new Error(`effort store: row ${index} of ${length} ${reason}; batch refused`);
+}
+function batchEntries(kind, rows) {
+  const keyOf = EFFORT_KEY_PROJECTIONS[kind];
+  const fieldColumns = KIND_TABLES[kind].fieldColumns;
+  const projected = rows.map((row) => ({ key: keyOf(row), row }));
+  const keyed = projected.filter(hasKey);
+  if (keyed.length < projected.length) {
+    const keylessAt = projected.findIndex((entry) => !hasKey(entry));
+    throw refused(keylessAt, rows.length, "carries no key");
+  }
+  const unholdableAt = keyed.findIndex(({ key }) => LONE_SURROGATE.test(key));
+  if (unholdableAt !== -1) {
+    const reason = "carries a key with a lone UTF-16 surrogate," + " which SQLite text cannot hold";
+    throw refused(unholdableAt, rows.length, reason);
+  }
+  return keyed.map(({ key, row }) => ({
+    key,
+    body: JSON.stringify(row),
+    fields: fieldColumns.map(({ value }) => value(row))
+  }));
+}
+function withSqliteStore(path, access, create, use, identity = {}) {
+  guardTestProcess(path);
+  if (create)
+    mkdirSync3(dirname7(path), { recursive: true });
+  const db = new Database2(path, { readwrite: true, create });
+  try {
+    db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
+    bringForward(db, path, access, "open");
+    settleStoreIdentity(db, path, access, identity);
+    return use(db);
+  } finally {
+    db.close();
+  }
+}
+function insertBatch(db, table, entries) {
+  const fieldNames = table.fieldColumns.map(({ column }) => column);
+  const columns = [table.keyColumn, "row_json", ...fieldNames].join(", ");
+  const placeholders = ["?", "?", ...fieldNames.map(() => "?")].join(", ");
+  const insert = db.query(`INSERT INTO ${table.name} (${columns}, ${STAMPED_COLUMNS})` + ` VALUES (${placeholders}, ${stampedValues(table.name)})` + ` ON CONFLICT (${table.keyColumn}) DO NOTHING`);
+  const insertAll = db.transaction(() => entries.reduce((appended, { key, body, fields }) => appended + insert.run(key, body, ...fields).changes, 0));
+  return insertAll.immediate();
+}
+function writeSqliteStore(path, rowCount, empty, insert) {
+  const exists = existsSync4(path);
+  if (rowCount > 0)
+    return withSqliteStore(path, "write", !exists, insert);
+  if (exists)
+    withSqliteStore(path, "write", false, () => {
+      return;
+    });
+  return empty;
+}
+function appendKind(path, kind, rows) {
+  const entries = batchEntries(kind, rows);
+  const table = KIND_TABLES[kind];
+  const appended = writeSqliteStore(path, entries.length, 0, (db) => insertBatch(db, table, entries));
+  return { path, appended, skipped: entries.length - appended };
+}
+function keysOfKind(path, kind) {
+  if (!existsSync4(path))
+    return new Set;
+  const { name, keyColumn } = KIND_TABLES[kind];
+  const keys = withSqliteStore(path, "read", false, (db) => db.query(`SELECT ${keyColumn} AS key FROM ${name} ORDER BY seq`).all());
+  return new Set(keys.map(({ key }) => key));
+}
+function parsedObject(body) {
+  try {
+    const value = JSON.parse(body);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function rowOf(body, where) {
+  const value = parsedObject(body);
+  if (value === null) {
+    throw new Error(`effort store: ${where} does not hold a JSON object;` + " no append writes one");
+  }
+  return value;
+}
+function readKind(path, kind) {
+  if (!existsSync4(path))
+    return [];
+  const { name } = KIND_TABLES[kind];
+  const stored = withSqliteStore(path, "read", false, (db) => db.query(`SELECT seq, row_json AS body FROM ${name} ORDER BY seq`).all());
+  return stored.map(({ seq, body }) => rowOf(body, `${path}: ${name} row ${seq}`));
+}
+function openSqliteStore(repoRoot) {
+  const path = sqliteStorePath(repoRoot);
+  return {
+    append: (kind, rows) => appendKind(path, kind, rows),
+    keys: (kind) => keysOfKind(path, kind),
+    read: (kind) => readKind(path, kind),
+    path: () => path
+  };
+}
+
+// packages/rafa/src/effort/store/trusted-permissions.ts
+var TRUSTED_PERMISSIONS = ["admin", "maintain", "write"];
+
+export { PORT_VERSIONS, createAdapterRegistry, registerAdapters, restoreAdapters, activeAdapterRegistry, CORE_ADAPTER_REGISTRY, effortStoreFileName, readStoreRows, collectedKeys, appendRows, EFFORT_DIR_VARIABLE, effortStoreDir, guardTestProcess, EFFORT_KEY_PROJECTIONS, SPENDS_GLYPH, CommandExit, commandSpelling, createLinePrompter, lazyPrompter, version, RAFA_VERSION, isRecord, asPlace, asHopRecord, SessionRecordError, isSessionId, sessionSteps, sessionDecisions, SessionConflictError, runsDir, sessionFilePath, errorCode, isPidAlive, readSessions, readSession, samePlan, beginSession, updateSession, claudeArgs, interruptClaudeSessions, spawnClaude, runClaude, spawnClaudeCaptured, runClaudeCaptured, readRuntimeIdentity, DEVELOPMENT_NEXT_STEP, appliedByName, DevelopmentBuildRefusedError, storeProjectRoot, refuseUnownedDevelopmentWrite, SQLITE_MIGRATIONS, sqliteCatalogue, planSchema, MIGRATION_LOG_TABLE, bringForward, readStoreSchema, writeNames, ACROSS_STORES_ORDER, STAMPED_COLUMNS, stampedValues, setActiveStoreSettings, activeStoreSettings, writeStoreGeneration, createGitRunner, gitSaid, commitTaskWork, PROJECT_ID_LENGTH, PROJECT_ID_PATTERN, normalizeRemote, gitRemoteUrl, readProjectIdentity, readReplacedStoreIds, readStoreMeta, carryStoreIdentity, SQLITE_STORE_FILE_NAME, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, TRUSTED_PERMISSIONS };