@open-tomato/rafa 0.32.0 → 0.34.0

package/dist/{index-wvm2s4pr.js → index-bvfbfa63.js}

@@ -10,11 +10,12 @@ import {
   activeOutputMode,
   configFilePath,
   createTextOutput,
+  hubContextOf,
   isStampableStub,
   parseConfigText,
   readRafaBlocks,
   resolveConfig
-} from "./index-9aph6ft9.js";
+} from "./index-vp0xghk2.js";
 import {
   bless,
   merge
@@ -22,21 +23,23 @@ import {
 import {
   CommandExit,
   commandSpelling
-} from "./index-mt6hpsry.js";
+} from "./index-3mzw3kzh.js";
 import {
   BUSY_TIMEOUT_MAX_MS,
   BUSY_TIMEOUT_MIN_MS,
   RAFA_INSTINCTS_PATH,
   STORE_BACKENDS,
   SYNC_STRATEGIES,
+  TEST_SCOPES,
   bundledBinDirectory,
   describeValue,
   isBusyTimeoutMs,
+  isGitHubLogin,
   isMapping,
   messageOf,
   resolveInstinctScopes,
   tierExists
-} from "./index-rs79dq9e.js";
+} from "./index-fzhd3d4y.js";
 import {
   actionHash,
   triggerKey
@@ -158,7 +161,7 @@ function appendRows(path, rows, keyOf) {
 // src/effort/store/location.ts
 import { existsSync as existsSync2, realpathSync } from "fs";
 import { tmpdir } from "os";
-import { isAbsolute, join as join2, relative, resolve, sep } from "path";
+import { basename, dirname as dirname2, isAbsolute, join as join2, relative, resolve, sep } from "path";
 var EFFORT_DIR_VARIABLE = "RAFA_EFFORT_DIR";
 var TEST_PROCESS_VARIABLE = "RAFA_TEST";
 var TEST_ENTRY_SUFFIX = ".test.ts";
@@ -166,6 +169,13 @@ function canonical(path) {
   const resolved = resolve(path);
   return existsSync2(resolved) ? realpathSync(resolved) : resolved;
 }
+function realPathOf(path) {
+  const resolved = resolve(path);
+  if (existsSync2(resolved))
+    return realpathSync(resolved);
+  const parent = dirname2(resolved);
+  return parent === resolved ? resolved : join2(realPathOf(parent), basename(resolved));
+}
 function isWithin(path, dir) {
   const between = relative(resolve(dir), resolve(path));
   const climbsOut = between === ".." || between.startsWith(`..${sep}`);
@@ -190,7 +200,7 @@ function isTestProcess(main = Bun.main, env = process.env) {
   return main.endsWith(TEST_ENTRY_SUFFIX) || env[TEST_PROCESS_VARIABLE] === "1";
 }
 function isUnderTempDir(path, tempDir = tmpdir()) {
-  return isWithin(path, tempDir) || isWithin(path, canonical(tempDir));
+  return isWithin(path, tempDir) || isWithin(realPathOf(path), realPathOf(tempDir));
 }
 function currentProbe() {
   return { main: Bun.main, env: process.env, tempDir: tmpdir() };
@@ -244,12 +254,12 @@ function openNdjsonStore(repoRoot) {
 
 // src/effort/store/sqlite.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync5 } from "fs";
-import { dirname as dirname9, join as join9 } from "path";
+import { dirname as dirname10, join as join9 } from "path";
 import { Database } from "bun:sqlite";
 
 // package.json
 var name = "@open-tomato/rafa";
-var version = "0.32.0";
+var version = "0.34.0";
 
 // src/cli/version.ts
 var RAFA_VERSION = version;
@@ -259,7 +269,7 @@ function versionLine() {
 
 // src/effort/store/development-build.ts
 import { tmpdir as tmpdir2 } from "os";
-import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute5 } from "path";
+import { basename as basename3, dirname as dirname8, isAbsolute as isAbsolute5 } from "path";
 
 // src/loop/sessions.ts
 import {
@@ -271,21 +281,11 @@ import {
   rmSync as rmSync3,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename, dirname as dirname5, isAbsolute as isAbsolute4, join as join7 } from "path";
-
-// src/next/hop-record.ts
-import { randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname4, join as join6 } from "path";
-
-// src/project/position.ts
-import { randomUUID } from "crypto";
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "fs";
-import { dirname as dirname3, join as join5 } from "path";
+import { dirname as dirname6, join as join7 } from "path";
 
 // src/project/scope.ts
 import { existsSync as existsSync3, realpathSync as realpathSync2 } from "fs";
-import { dirname as dirname2, isAbsolute as isAbsolute3, join as join4 } from "path";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join4 } from "path";
 
 // src/project/worktree-root.ts
 import { isAbsolute as isAbsolute2 } from "path";
@@ -352,7 +352,7 @@ function mainCheckoutOf(dir, seams = {}) {
 }
 
 // src/project/scope.ts
-var SCOPE_DIR = dirname2(CONFIG_FILE);
+var SCOPE_DIR = dirname3(CONFIG_FILE);
 var INIT_COMMAND = "rafa init";
 var DISK_FILE_SYSTEM = Object.freeze({
   exists: (path) => existsSync3(path),
@@ -400,19 +400,23 @@ function realHomeOf(home, fs) {
   }
 }
 function selfAndAncestors(path) {
-  const parent = dirname2(path);
+  const parent = dirname3(path);
   return parent === path ? [path] : [path, ...selfAndAncestors(parent)];
 }
-function walkUp(realStart, realHome, fs) {
+var GIT_MARKER = ".git";
+function walkUp(dirs, realHome, fs, stopAtTopLevel) {
   let passedUserConfig = false;
-  for (const dir of selfAndAncestors(realStart)) {
-    if (!fs.exists(configFilePath(dir)))
-      continue;
-    if (dir !== realHome)
-      return { root: dir, passedUserConfig };
-    passedUserConfig = true;
+  for (const dir of dirs) {
+    if (fs.exists(configFilePath(dir))) {
+      if (dir !== realHome)
+        return { root: dir, passedUserConfig, topLevel: null };
+      passedUserConfig = true;
+    }
+    if (stopAtTopLevel && fs.exists(join4(dir, GIT_MARKER))) {
+      return { root: null, passedUserConfig, topLevel: dir };
+    }
   }
-  return { root: null, passedUserConfig };
+  return { root: null, passedUserConfig, topLevel: null };
 }
 function mainCheckoutAt(realStart, mainCheckout) {
   try {
@@ -430,6 +434,13 @@ function fallBack(realStart, realHome, fs, mainCheckout) {
   }
   return fs.exists(configFilePath(main)) ? { root: main, probed: main } : { root: null, probed: main };
 }
+function walkAbove(lower, realHome, fs) {
+  if (lower.topLevel === null)
+    return lower;
+  const above = selfAndAncestors(lower.topLevel).slice(1);
+  const upper = walkUp(above, realHome, fs, false);
+  return { ...upper, passedUserConfig: lower.passedUserConfig || upper.passedUserConfig };
+}
 function resolveScope(start, seams) {
   const { home, fs = DISK_FILE_SYSTEM, mainCheckout = mainCheckoutOf } = seams;
   requireAbsolute("start directory", start);
@@ -437,16 +448,29 @@ function resolveScope(start, seams) {
   const user = scopeAt(home);
   const realStart = realStartOf(start, fs);
   const realHome = realHomeOf(home, fs);
-  const walk = walkUp(realStart, realHome, fs);
-  const fallback = walk.root === null ? fallBack(realStart, realHome, fs, mainCheckout) : { root: walk.root, probed: null };
-  if (fallback.root === null) {
+  const lower = walkUp(selfAndAncestors(realStart), realHome, fs, true);
+  const fallback = lower.root === null ? fallBack(realStart, realHome, fs, mainCheckout) : { root: lower.root, probed: null };
+  const walk = fallback.root === null ? walkAbove(lower, realHome, fs) : lower;
+  const root = fallback.root ?? walk.root;
+  if (root === null) {
     const passed = walk.passedUserConfig ? user.configFile : null;
     return { found: false, start, home, user, hint: initHint(start, passed, fallback.probed) };
   }
-  return { found: true, root: fallback.root, home, project: scopeAt(fallback.root), user };
+  return { found: true, root, home, project: scopeAt(root), user };
 }
 
+// src/loop/session-record-parse.ts
+import { basename as basename2, isAbsolute as isAbsolute4 } from "path";
+
+// src/next/hop-record.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname5, join as join6 } from "path";
+
 // src/project/position.ts
+import { randomUUID } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync } from "fs";
+import { dirname as dirname4, join as join5 } from "path";
 var POSITION_FILE = "position.json";
 function positionFilePath(root) {
   return join5(scopeAt(root).dir, POSITION_FILE);
@@ -496,7 +520,7 @@ function readPositionFile(root) {
 }
 function writePositionFile(root, position) {
   const file = positionFilePath(root);
-  mkdirSync2(dirname3(file), { recursive: true });
+  mkdirSync2(dirname4(file), { recursive: true });
   const temporary = `${file}.${String(process.pid)}.${randomUUID()}.tmp`;
   const { current, previous, home } = position;
   try {
@@ -610,7 +634,7 @@ function ownKeys(record) {
 }
 function writeHopRecord(root, record) {
   const file = hopFilePath(root);
-  mkdirSync3(dirname4(file), { recursive: true });
+  mkdirSync3(dirname5(file), { recursive: true });
   const temporary = `${file}.${String(process.pid)}.${randomUUID2()}.tmp`;
   try {
     writeFileSync2(temporary, `${JSON.stringify(ownKeys(record), null, 2)}
@@ -625,11 +649,13 @@ function staleAgainst(record, position) {
   return position.home.board !== record.home.board || position.home.epic !== record.home.epic;
 }
 
-// src/loop/sessions.ts
+// src/loop/session-record-parse.ts
 var SESSION_STATES = Object.freeze(["running", "paused", "stopped", "done"]);
-var RUNS_DIR = "runs";
+var SESSION_PHASES = Object.freeze(["task", "wrap-up", "pull-request", "ci", "repair"]);
+var DEFAULT_PHASE = "task";
 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"]);
 
 class SessionRecordError extends Error {
   file;
@@ -639,40 +665,9 @@ class SessionRecordError extends Error {
     this.file = file;
   }
 }
-
-class SessionConflictError extends Error {
-  conflicts;
-  constructor(conflicts) {
-    const named = conflicts.map((conflict) => `${conflict.record.sessionId} (${conflict.reason})`);
-    super(`the plan's sessions refuse the run: ${named.join(", ")}`);
-    this.name = "SessionConflictError";
-    this.conflicts = conflicts;
-  }
-}
-
-class SessionStateError extends Error {
-  file;
-  state;
-  constructor(file, state, onlyFrom) {
-    const acted = onlyFrom.length === 0 ? "no state" : onlyFrom.join(" or ");
-    super(`session record ${file}: stores ${state}, and the change acts on ${acted} alone`);
-    this.name = "SessionStateError";
-    this.file = file;
-    this.state = state;
-  }
-}
 function isSessionId(value) {
   return SESSION_ID_PATTERN.test(value);
 }
-function runsDir(root) {
-  return join7(scopeAt(root).dir, RUNS_DIR);
-}
-function sessionFilePath(root, sessionId) {
-  if (!isSessionId(sessionId)) {
-    throw new Error(`session record: unusable session id ${JSON.stringify(sessionId)}`);
-  }
-  return join7(runsDir(root), `${sessionId}${RECORD_EXTENSION}`);
-}
 function describeValue2(value) {
   return value === undefined ? "missing" : JSON.stringify(value) ?? String(value);
 }
@@ -710,11 +705,68 @@ function worktreeProblem(fields) {
   const worktree = field(fields, "worktree");
   return isText(worktree) && isAbsolute4(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 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`;
+  return basename2(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`;
@@ -735,14 +787,41 @@ function recordProblems(fields, file) {
     SESSION_STATES.includes(state) ? null : `state is ${describeValue2(state)}, expected one of ${SESSION_STATES.join(", ")}`,
     taskProblem(field(fields, "task")),
     hopProblem(fields),
-    worktreeProblem(fields)
+    worktreeProblem(fields),
+    ...stepsProblems(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 hop2 = asHopRecord(value);
   return Object.freeze({ ...hop2, home: Object.freeze(hop2.home), from: Object.freeze(hop2.from) });
 }
+function freezeFailures(failures) {
+  return Object.freeze(failures.map((failure) => Object.freeze({ file: failure.file, name: failure.name })));
+}
+function freezeStep(step) {
+  return Object.freeze({
+    kind: step.kind,
+    scope: typeof step.scope === "string" ? step.scope : Object.freeze([...step.scope]),
+    command: Object.freeze([...step.command]),
+    exitCode: step.exitCode,
+    summary: step.summary,
+    failures: freezeFailures(step.failures),
+    newFailures: freezeFailures(step.newFailures),
+    ...step.interrupted === true ? { interrupted: true } : {}
+  });
+}
+function stepsEntry(steps) {
+  if (!Array.isArray(steps) || steps.length === 0)
+    return {};
+  return { steps: Object.freeze(steps.map(freezeStep)) };
+}
 function freezeRecord(fields) {
   const task = field(fields, "task");
   const hop2 = field(fields, "hop");
@@ -756,10 +835,18 @@ function freezeRecord(fields) {
     startedAt: field(fields, "startedAt"),
     state: field(fields, "state"),
     task: isObject(task) ? Object.freeze({ line: field(task, "line"), text: field(task, "text") }) : null,
+    ...phaseEntry(field(fields, "phase")),
     ...hop2 === undefined ? {} : { hop: freezeHop(hop2) },
-    ...worktree === undefined ? {} : { worktree }
+    ...worktree === undefined ? {} : { worktree },
+    ...stepsEntry(field(fields, "steps"))
   });
 }
+function sessionSteps(record) {
+  return record.steps ?? [];
+}
+function sessionPhase(record) {
+  return record.phase ?? DEFAULT_PHASE;
+}
 function parseSessionRecord(text, file) {
   let parsed;
   try {
@@ -774,6 +861,40 @@ function parseSessionRecord(text, file) {
     throw new SessionRecordError(file, problems.join("; "));
   return freezeRecord(parsed);
 }
+
+// src/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 join7(scopeAt(root).dir, RUNS_DIR);
+}
+function sessionFilePath(root, sessionId) {
+  if (!isSessionId(sessionId)) {
+    throw new Error(`session record: unusable session id ${JSON.stringify(sessionId)}`);
+  }
+  return join7(runsDir(root), `${sessionId}${RECORD_EXTENSION}`);
+}
 function errorCode(error) {
   return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : null;
 }
@@ -842,7 +963,7 @@ function checkRecord(record, file) {
 }
 function writeRecordFile(file, record, isNew) {
   checkRecord(record, file);
-  mkdirSync4(dirname5(file), { recursive: true });
+  mkdirSync4(dirname6(file), { recursive: true });
   const temporary = `${file}.${process.pid}.tmp`;
   writeFileSync3(temporary, `${JSON.stringify(record, null, 2)}
 `);
@@ -870,10 +991,15 @@ function updateSession(root, sessionId, change) {
   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
+    task: change.task === undefined ? stored.task : change.task,
+    phase: change.phase ?? stored.phase,
+    steps: change.appendStep === undefined ? sessionSteps(stored) : [...sessionSteps(stored), change.appendStep]
   });
   writeRecordFile(file, record, false);
   return record;
@@ -881,7 +1007,7 @@ function updateSession(root, sessionId, change) {
 
 // src/runtime/identity.ts
 import { existsSync as existsSync4, readFileSync as readFileSync5, realpathSync as realpathSync3 } from "fs";
-import { dirname as dirname6, join as join8, resolve as resolve2 } from "path";
+import { dirname as dirname7, join as join8, resolve as resolve2 } from "path";
 var MANIFEST = "package.json";
 var CHECKOUT_ENTRY = join8("src", "rafa.ts");
 function realOrResolved(path) {
@@ -906,7 +1032,7 @@ function nearestRafaPackage(start) {
     const manifest = join8(dir, MANIFEST);
     if (existsSync4(manifest) && manifestName(manifest) === name)
       return dir;
-    const parent = dirname6(dir);
+    const parent = dirname7(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -914,7 +1040,7 @@ function nearestRafaPackage(start) {
 }
 function readRuntimeIdentity(entry = Bun.main) {
   const real = realOrResolved(entry);
-  const packageDir = nearestRafaPackage(dirname6(real));
+  const packageDir = nearestRafaPackage(dirname7(real));
   if (packageDir !== null && existsSync4(join8(packageDir, CHECKOUT_ENTRY))) {
     return { kind: "development", entry: real, checkout: packageDir };
   }
@@ -941,11 +1067,11 @@ class DevelopmentBuildRefusedError extends Error {
   }
 }
 function storeProjectRoot(path) {
-  const storeDir = dirname7(path);
-  const scopeDir = dirname7(storeDir);
-  if (basename2(storeDir) !== EFFORT_DIR_NAME || basename2(scopeDir) !== SCOPE_DIR)
+  const storeDir = dirname8(path);
+  const scopeDir = dirname8(storeDir);
+  if (basename3(storeDir) !== EFFORT_DIR_NAME || basename3(scopeDir) !== SCOPE_DIR)
     return null;
-  return dirname7(scopeDir);
+  return dirname8(scopeDir);
 }
 function isOwnedStore(path, env, tempDir) {
   if (isUnderTempDir(path, tempDir))
@@ -1575,7 +1701,7 @@ function activeStoreSettings() {
 
 // src/effort/store/store-meta.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 
 // src/effort/store/store-identity.ts
 import { spawnSync as spawnSync3 } from "child_process";
@@ -1717,7 +1843,7 @@ function readStoreMeta(db) {
   };
 }
 function projectFor(storePath, recorded, seams) {
-  const read = (seams.readProject ?? readProjectIdentity)(dirname8(storePath));
+  const read = (seams.readProject ?? readProjectIdentity)(dirname9(storePath));
   if (read.rootCommit !== null)
     return { rootCommit: read.rootCommit, remote: read.remote };
   if (recorded === null)
@@ -1788,7 +1914,7 @@ function batchEntries(kind, rows) {
 function withSqliteStore(path, access, create, use, identity = {}) {
   guardTestProcess(path);
   if (create)
-    mkdirSync5(dirname9(path), { recursive: true });
+    mkdirSync5(dirname10(path), { recursive: true });
   const db = new Database(path, { readwrite: true, create });
   try {
     db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
@@ -2448,7 +2574,7 @@ function copyEffortStore(request) {
 import { randomUUID as randomUUID4 } from "crypto";
 import { existsSync as existsSync11, mkdtempSync, rmSync as rmSync6 } from "fs";
 import { tmpdir as tmpdir3 } from "os";
-import { dirname as dirname10, join as join11 } from "path";
+import { dirname as dirname11, join as join11 } from "path";
 import { Database as Database5, SQLiteError as SQLiteError2 } from "bun:sqlite";
 
 // src/effort/commits.ts
@@ -2865,7 +2991,7 @@ var LIVE2 = "live";
 function asidePaths2(path, first, stamp) {
   return { parallelPath: `${path}.migrate-${stamp}`, backupPath: `${path}.before-${first}-${stamp}.bak` };
 }
-function liveLoop(path, options, nothingDone = "Nothing was migrated.") {
+function liveLoop(path, options, nothingDone = "Nothing was migrated.", ownSessionId = null) {
   const root = storeProjectRoot(path);
   if (root === null)
     return;
@@ -2875,7 +3001,7 @@ function liveLoop(path, options, nothingDone = "Nothing was migrated.") {
   } catch (error) {
     throw new RebuildRefusal(`the loop's run records cannot be read, so a live loop on ${path} cannot be ruled out` + ` (${messageOf(error)}). ${nothingDone}`);
   }
-  return records.find((record) => record.state === "running" || record.state === "paused");
+  return records.find((record) => (record.state === "running" || record.state === "paused") && record.sessionId !== ownSessionId);
 }
 function refuseLiveLoop2(path, breaking, options) {
   const loop = liveLoop(path, options);
@@ -3004,15 +3130,15 @@ function recordedMeta(path) {
 }
 function refuseOtherProject(options) {
   const other = recordedMeta(options.otherPath);
-  const here = recordedMeta(options.path)?.projectRootCommit ?? (options.readProject ?? readProjectIdentity)(dirname10(options.path)).rootCommit;
+  const here = recordedMeta(options.path)?.projectRootCommit ?? (options.readProject ?? readProjectIdentity)(dirname11(options.path)).rootCommit;
   const there = other?.projectRootCommit ?? null;
   if (here !== null && there !== null && here !== there) {
     throw new MergeRefusal("other-project", `REFUSED \u2014 ${options.otherPath} is the effort store of another project (root commit ${there});` + ` this store's project has root commit ${here}. ${NOTHING_MERGED}`);
   }
   return other?.storeId ?? null;
 }
-function refuseLiveLoop3(path, options) {
-  const loop = liveLoop(path, options, NOTHING_MERGED);
+function refuseLiveLoop3(path, options, sessionId) {
+  const loop = liveLoop(path, options, NOTHING_MERGED, sessionId);
   if (loop === undefined)
     return;
   throw new MergeRefusal("live-loop", `REFUSED \u2014 loop ${loop.sessionId} (pid ${String(loop.pid)}, plan ${loop.planStub ?? loop.plan}) is running on this store,` + ` and swapping the merged store in under it would lose what it writes. ${NOTHING_MERGED}` + " Finish or stop that loop, then run it again.");
@@ -3103,7 +3229,7 @@ function refuseUnmergeable(options, migrations) {
   const otherStore = refuseOtherProject(options);
   if (!options.dryRun) {
     refuseUnownedDevelopmentWrite(path, [...writeNames(localPlan), MERGES_TABLE], options);
-    refuseLiveLoop3(path, options);
+    refuseLiveLoop3(path, options, options.sessionId ?? null);
   }
   return { otherPlan, otherStore };
 }
@@ -3171,10 +3297,11 @@ function createFileSync(options) {
     const copied = copyEffortStore({ source, target });
     return Object.freeze({ status: "pushed", path: join12(copied.directory, SQLITE_STORE_FILE_NAME) });
   };
-  const pull = async ({ from, dryRun }) => {
+  const pull = async ({ from, dryRun, sessionId = null }) => {
     const otherPath = resolve5(repoRoot, requirePath("from", from));
     const path = join12(storeDir(), SQLITE_STORE_FILE_NAME);
-    const merge2 = mergeStore({ ...mergeSeams(options), path, otherPath, backend, dryRun, stamp: fileStamp(now()), now });
+    const stamp = fileStamp(now());
+    const merge2 = mergeStore({ ...mergeSeams(options), path, otherPath, backend, dryRun, stamp, now, sessionId });
     return Object.freeze({ status: "pulled", merge: merge2 });
   };
   return Object.freeze({ kind: "file", push, pull });
@@ -3218,12 +3345,19 @@ class SyncModuleMissing extends Error {
 function isModuleStrategy(kind) {
   return MODULE_SYNC_STRATEGIES.includes(kind);
 }
+function contextOf(repoRoot, config) {
+  const hub = hubContextOf(config);
+  return {
+    repoRoot,
+    ...config.store === undefined ? {} : { store: config.store },
+    ...hub === undefined ? {} : { hub }
+  };
+}
 function selectSync(repoRoot, config, registry = CORE_ADAPTER_REGISTRY) {
   const kind = config.effortSync;
   const adapter = typeof kind === "string" ? registry.find("sync", kind) : undefined;
-  if (adapter !== undefined) {
-    return adapter.create(config.store === undefined ? { repoRoot } : { repoRoot, store: config.store });
-  }
+  if (adapter !== undefined)
+    return adapter.create(contextOf(repoRoot, config));
   const registered = registry.kinds("sync");
   if (isModuleStrategy(kind))
     throw new SyncModuleMissing(kind, registered);
@@ -4335,6 +4469,34 @@ function createLocalLearning(options) {
   return Object.freeze(learning);
 }
 
+// src/adapters/output/events.ts
+var EVENT_PREFIX = "rafa\xB7 ";
+var KIND_COLUMN = 17;
+function padKind(kind) {
+  return `${kind} `.padEnd(KIND_COLUMN);
+}
+function oneLine(message) {
+  return message.split(`
+`).map((part) => part.trim()).filter((part) => part !== "").join(" ");
+}
+function createEventsOutput({ stream }) {
+  const writeLine = (line) => {
+    stream.write(`${EVENT_PREFIX}${line}
+`);
+  };
+  const error = (message) => {
+    writeLine(`${padKind("error")}${oneLine(message)}`);
+  };
+  const silent = () => {};
+  const emit = (event) => {
+    if (event.type === "event")
+      writeLine(oneLine(event.summary));
+    if (event.type === "log" && event.level === "error")
+      error(event.message);
+  };
+  return Object.freeze({ info: silent, warn: silent, debug: silent, error, emit, result: silent });
+}
+
 // src/adapters/output/json.ts
 var SECOND_RESULT_REFUSAL = "json output: refused a second terminal result event; a command emits exactly one";
 function createJsonOutput({
@@ -4643,7 +4805,7 @@ function guardSpend() {
 }
 async function spawnClaude(args, prompt, options = {}) {
   guardSpend();
-  if (activeOutputMode() === "json") {
+  if (activeOutputMode() !== "text") {
     const { exitCode } = await spawnCaptured(args, prompt, options);
     return exitCode;
   }
@@ -4677,22 +4839,22 @@ function writeWholeLines(text, write) {
 }
 async function teeToOperator(stream) {
   const decoder = new TextDecoder;
-  const jsonOutput = activeOutputMode() === "json" ? activeOutput() : null;
+  const routed = activeOutputMode() === "text" ? null : activeOutput();
   const writeLine = (line) => {
-    jsonOutput?.info(line);
+    routed?.info(line);
   };
   let text = "";
   let pending = "";
   for await (const chunk of stream) {
-    if (jsonOutput === null)
+    if (routed === null)
       process.stdout.write(chunk);
     const decoded = decoder.decode(chunk, { stream: true });
     text += decoded;
-    if (jsonOutput !== null)
+    if (routed !== null)
       pending = writeWholeLines(pending + decoded, writeLine);
   }
   const tail = decoder.decode();
-  if (jsonOutput !== null) {
+  if (routed !== null) {
     const rest = writeWholeLines(pending + tail, writeLine);
     if (rest !== "")
       writeLine(rest);
@@ -4810,9 +4972,12 @@ var GITHUB_LABELS = Object.freeze({
   blockedByPrefix: "blocked-by:OPT-"
 });
 var VIEW_FIELDS = "number,title,body,state,stateReason,labels,url";
+var LIST_COMMAND = "gh issue list";
 var LIST_FIELDS = "number,url,labels";
+var OPEN_LIST_FIELDS = "number,url,labels,title,body";
+var OPEN_ISSUES_LIMIT = 1000;
 var DEFAULT_FIND_LIMIT = 30;
-var NOT_PLANNED = "NOT_PLANNED";
+var CANCELLED_REASONS = new Set(["NOT_PLANNED", "DUPLICATE"]);
 var ISSUE_NUMBER = /^[1-9]\d*$/;
 var REPO_PART = /^[\w.-]+$/;
 var CREATED_ISSUE_URL = /^https:\/\/[^\s/]+\/[\w.-]+\/[\w.-]+\/issues\/([1-9]\d*)$/;
@@ -4984,28 +5149,49 @@ function viewedIssue(stdout, number) {
   const checked = payload;
   return { ...checked, labels: labelNames(checked.labels) ?? [] };
 }
-function listedIssues(stdout) {
-  const command = "gh issue list";
-  const payload = parseJson(stdout, command);
+function listedRows(stdout) {
+  const payload = parseJson(stdout, LIST_COMMAND);
   if (!Array.isArray(payload)) {
-    throw new Error(`${PREFIX2}: ${command} answered ${describeValue(payload)}, expected a list`);
-  }
-  return payload.map((row, index) => {
-    const refuse2 = (problem) => new Error(`${PREFIX2}: ${command} answered row ${index} ${problem}`);
-    if (!isMapping(row))
-      throw refuse2(`${describeValue(row)}, expected a mapping`);
-    const { number, url } = row;
-    const labels = labelNames(row["labels"]);
-    if (typeof number !== "number" || !isIssueNumber3(String(number))) {
-      throw refuse2(`with number ${describeValue(number)}, expected an issue number`);
-    }
-    if (typeof url !== "string")
-      throw refuse2(`with url ${describeValue(url)}, expected a string`);
-    if (labels === null)
-      throw refuse2("with labels that are not a list of named labels");
-    return { number, url, labels };
+    throw new Error(`${PREFIX2}: ${LIST_COMMAND} answered ${describeValue(payload)}, expected a list`);
+  }
+  return payload;
+}
+function rowRefusal(index, problem) {
+  return new Error(`${PREFIX2}: ${LIST_COMMAND} answered row ${index} ${problem}`);
+}
+function listedRow(row, index) {
+  if (!isMapping(row))
+    throw rowRefusal(index, `${describeValue(row)}, expected a mapping`);
+  const { number, url } = row;
+  const labels = labelNames(row["labels"]);
+  if (typeof number !== "number" || !isIssueNumber3(String(number))) {
+    throw rowRefusal(index, `with number ${describeValue(number)}, expected an issue number`);
+  }
+  if (typeof url !== "string")
+    throw rowRefusal(index, `with url ${describeValue(url)}, expected a string`);
+  if (labels === null)
+    throw rowRefusal(index, "with labels that are not a list of named labels");
+  return { number, url, labels };
+}
+function listedIssues(stdout) {
+  return listedRows(stdout).map(listedRow);
+}
+function listedOpenIssues(stdout) {
+  return listedRows(stdout).map((row, index) => {
+    const listed2 = listedRow(row, index);
+    const { title, body } = row;
+    if (typeof title !== "string")
+      throw rowRefusal(index, `with title ${describeValue(title)}, expected a string`);
+    if (typeof body !== "string")
+      throw rowRefusal(index, `with body ${describeValue(body)}, expected a string`);
+    return { ...listed2, title, body };
   });
 }
+function refOfRow(row) {
+  const module = labelValue(row.labels, GITHUB_LABELS.modulePrefix);
+  const ref = { opt: 0, kind: "github", externalId: String(row.number), url: row.url };
+  return module === undefined ? ref : { ...ref, module };
+}
 function labelValue(labels, prefix) {
   return labels.find((label) => label.startsWith(prefix))?.slice(prefix.length);
 }
@@ -5019,7 +5205,7 @@ function moduleOfLabels(labels) {
 function stateOf(viewed) {
   if (viewed.state === "OPEN")
     return "todo";
-  return viewed.stateReason === NOT_PLANNED ? "cancelled" : "done";
+  return viewed.stateReason !== null && CANCELLED_REASONS.has(viewed.stateReason) ? "cancelled" : "done";
 }
 function issueOf(ref, viewed) {
   const priority = labelValue(viewed.labels, GITHUB_LABELS.priorityPrefix);
@@ -5130,12 +5316,26 @@ function createGithubTracker(options) {
         ...optionalFlag("--label", moduleLabel),
         ...optionalFlag("--label", typeLabel),
         ...optionalFlag("--search", query.text)
-      ], "gh issue list");
-      return listedIssues(stdout).map((row) => {
-        const module = labelValue(row.labels, GITHUB_LABELS.modulePrefix);
-        const ref = { opt: 0, kind: "github", externalId: String(row.number), url: row.url };
-        return module === undefined ? ref : { ...ref, module };
-      });
+      ], LIST_COMMAND);
+      return listedIssues(stdout).map(refOfRow);
+    },
+    openIssues: async (type) => {
+      if (!isOneOf(ISSUE_TYPES, type)) {
+        throw new TypeError(`${PREFIX2}: openIssues refused type ${describeValue(type)}, expected one of: ${ISSUE_TYPES.join(", ")}`);
+      }
+      const stdout = await run([
+        "issue",
+        "list",
+        "--state",
+        "open",
+        "--json",
+        OPEN_LIST_FIELDS,
+        "--limit",
+        String(OPEN_ISSUES_LIMIT),
+        "--label",
+        `${GITHUB_LABELS.typePrefix}${type}`
+      ], LIST_COMMAND);
+      return listedOpenIssues(stdout).map((row) => ({ ref: refOfRow(row), title: row.title, body: row.body }));
     },
     comment: async (ref, body) => {
       const number = issueNumberOfRef(ref);
@@ -5173,6 +5373,7 @@ import { join as join16 } from "path";
 var PREFIX3 = "local tracker";
 var FRONTMATTER = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
 var ISSUE_NUMBER2 = /^[1-9]\d*$/;
+var CLOSED_STATES = new Set(["done", "released", "cancelled"]);
 var ISSUE_EXTENSION = ".md";
 function isString2(value) {
   return typeof value === "string";
@@ -5304,7 +5505,7 @@ function parseLocalIssue(contents, sourcePath) {
 function warnThroughActiveOutput2(message) {
   activeOutput().warn(message);
 }
-async function listLocalIssues(issuesDir, warn = warnThroughActiveOutput2) {
+async function listLocalIssues(issuesDir, warn = warnThroughActiveOutput2, reader = "find") {
   const numbers = await issueNumbers(issuesDir);
   const settled = await Promise.allSettled(numbers.map(async (number) => {
     const path = issuePath(issuesDir, number);
@@ -5319,7 +5520,7 @@ async function listLocalIssues(issuesDir, warn = warnThroughActiveOutput2) {
   return settled.flatMap((result) => {
     if (result.status === "fulfilled")
       return [result.value];
-    warn(`${messageOf(result.reason)}; find skipped it`);
+    warn(`${messageOf(result.reason)}; ${reader} skipped it`);
     return [];
   });
 }
@@ -5405,6 +5606,14 @@ function createLocalTracker(options) {
       const matched = (await listLocalIssues(issuesDir, warn)).filter(({ record }) => matchesQuery(record, query));
       return matched.slice(0, query.limit ?? matched.length).map(({ number, record }) => refFor(number, record.draft.opt));
     },
+    openIssues: async (type) => {
+      const open = (await listLocalIssues(issuesDir, warn, "openIssues")).filter(({ record }) => record.draft.type === type && !CLOSED_STATES.has(record.state));
+      return open.map(({ number, record }) => ({
+        ref: refFor(number, record.draft.opt),
+        title: record.draft.title,
+        body: record.draft.body
+      }));
+    },
     comment: async (ref, body) => {
       const { number, record } = await read(ref);
       await rewrite(number, { ...record, comments: [...record.comments, `${now()}: ${body}`] });
@@ -5513,6 +5722,12 @@ var CORE_ADAPTERS = [
     portVersion: PORT_VERSIONS.output,
     create: ({ stream = process.stdout }) => createJsonOutput({ stream })
   },
+  {
+    port: "output",
+    kind: "events",
+    portVersion: PORT_VERSIONS.output,
+    create: ({ stream = process.stdout }) => createEventsOutput({ stream })
+  },
   {
     port: "tracker",
     kind: "local",
@@ -5579,6 +5794,358 @@ var CORE_ADAPTERS = [
 ];
 var CORE_ADAPTER_REGISTRY = createAdapterRegistry(CORE_ADAPTERS);
 
+// src/board/trust.ts
+var REPO_PATH = "{owner}/{repo}";
+var TRUSTED_PERMISSIONS = ["admin", "maintain", "write"];
+var TRUST_REFUSAL_EXIT = 2;
+var REMEDY = Object.freeze({
+  issue: "a member must open the spec",
+  "pull request": "a member must open the pull request"
+});
+var UNREPORTED = "the lookup wrote nothing";
+function failureDetail(reading) {
+  const detail = reading.permission?.detail ?? "";
+  return detail === "" ? UNREPORTED : detail;
+}
+function isTrustedPermission(value) {
+  return TRUSTED_PERMISSIONS.some((permission) => permission === value);
+}
+function stringOrNull(value) {
+  return typeof value === "string" ? value : null;
+}
+function lookupFailed(login, detail) {
+  return { login, permission: null, roleName: null, detail };
+}
+function detailOf2(result, command) {
+  const written = result.stderr.trim() || result.stdout.trim();
+  return written === "" ? `${command} failed and wrote nothing` : `${command} failed: ${written}`;
+}
+function createGhPermissions(options) {
+  const { gh } = options;
+  return async (login) => {
+    if (!isGitHubLogin(login)) {
+      return lookupFailed(login, `${describeValue(login)} is not a GitHub login, so no permission was read`);
+    }
+    const path = `repos/${REPO_PATH}/collaborators/${login}/permission`;
+    const command = `gh api ${path}`;
+    const result = await gh(["api", path]);
+    if (!result.ok)
+      return lookupFailed(login, detailOf2(result, command));
+    let payload;
+    try {
+      payload = JSON.parse(result.stdout);
+    } catch (error) {
+      return lookupFailed(login, `${command} wrote output that is not JSON: ${messageOf(error)}`);
+    }
+    if (!isMapping(payload)) {
+      return lookupFailed(login, `${command} answered ${describeValue(payload)}, expected a mapping`);
+    }
+    const permission = stringOrNull(payload["permission"]);
+    const roleName = stringOrNull(payload["role_name"]);
+    return permission === null && roleName === null ? lookupFailed(login, `${command} answered neither a permission nor a role_name`) : { login, permission, roleName, detail: "" };
+  };
+}
+async function readAuthorTrust(options) {
+  const { login, permissions, trustedAuthors } = options;
+  if (!isGitHubLogin(login)) {
+    const detail = `${describeValue(login)} is not a GitHub login, so no permission was read`;
+    return {
+      login,
+      trusted: false,
+      source: null,
+      refusal: "lookup-failed",
+      permission: lookupFailed(login, detail)
+    };
+  }
+  const wanted = login.toLowerCase();
+  const listed2 = trustedAuthors.some((author) => author.toLowerCase() === wanted);
+  if (listed2) {
+    return { login, trusted: true, source: "allow-list", refusal: null, permission: null };
+  }
+  const permission = await permissions(login);
+  if (permission.detail !== "") {
+    return { login, trusted: false, source: null, refusal: "lookup-failed", permission };
+  }
+  const trusted = isTrustedPermission(permission.permission) || isTrustedPermission(permission.roleName);
+  return {
+    login,
+    trusted,
+    source: trusted ? "permission" : null,
+    refusal: trusted ? null : "no-write-access",
+    permission
+  };
+}
+function ghBoardTrust(options) {
+  return {
+    permissions: createGhPermissions({ gh: options.gh }),
+    trustedAuthors: options.trustedAuthors,
+    repo: options.repo
+  };
+}
+function readBoardTrust(trust, login) {
+  return readAuthorTrust({
+    login,
+    permissions: trust.permissions,
+    trustedAuthors: trust.trustedAuthors
+  });
+}
+async function requireTrustedBoardAuthor(item, trust, login) {
+  const reading = await readBoardTrust(trust, login);
+  requireTrustedAuthor({ kind: item.kind, number: item.number, repo: trust.repo }, reading);
+  return reading;
+}
+function trustRefusalClause(repo, reading) {
+  if (reading.trusted) {
+    throw new TypeError(`board trust: ${reading.login} is trusted, and has no refusal to name`);
+  }
+  return reading.refusal === "lookup-failed" ? `whose write access to ${repo} could not be read (${failureDetail(reading)})` : `who has no write access to ${repo}`;
+}
+function trustRefusalMessage(item, reading) {
+  const because = trustRefusalClause(item.repo, reading);
+  const opened = `${item.kind} #${String(item.number)} was opened by ${reading.login}`;
+  return `${opened}, ${because}; ${REMEDY[item.kind]}`;
+}
+function requireTrustedAuthor(item, reading) {
+  if (reading.trusted)
+    return;
+  throw new CommandExit(TRUST_REFUSAL_EXIT, trustRefusalMessage(item, reading));
+}
+// src/effort/sync/wire.ts
+import { existsSync as existsSync14, mkdtempSync as mkdtempSync2, rmSync as rmSync7 } from "fs";
+import { tmpdir as tmpdir4 } from "os";
+import { join as join17 } from "path";
+import { Database as Database6, SQLiteError as SQLiteError3 } from "bun:sqlite";
+var WIRE_FORMAT = "rafa-effort-wire";
+var WIRE_VERSION = 1;
+
+class WireFormatError extends Error {
+  name = "WireFormatError";
+}
+
+class WireExportRefusal extends Error {
+  name = "WireExportRefusal";
+}
+var MERGED_TABLES = Object.entries(MERGE_RULES).filter(([, rule]) => rule.scope === "merged").map(([table]) => table);
+var ORIGIN_COLUMNS = ["origin_store", "origin_seq"];
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCount(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isMergedTable(name2) {
+  return MERGED_TABLES.includes(name2);
+}
+function checkCursor(value) {
+  if (!isRecord4(value))
+    throw new WireFormatError("wire: cursor is not an object");
+  const entries = Object.entries(value).map(([table, seq]) => {
+    if (!isMergedTable(table))
+      throw new WireFormatError(`wire: cursor names ${JSON.stringify(table)}, which is no merged table`);
+    if (!isCount(seq))
+      throw new WireFormatError(`wire: cursor for ${table} is ${JSON.stringify(seq)}, expected a whole number of 0 or more`);
+    return [table, seq];
+  });
+  return Object.freeze(Object.fromEntries(entries));
+}
+function checkRow(table, value, index) {
+  const where = `wire: ${table} row ${String(index)}`;
+  if (!isRecord4(value))
+    throw new WireFormatError(`${where} is not an object`);
+  for (const [column, cell] of Object.entries(value)) {
+    const carried = cell === null || typeof cell === "string" || typeof cell === "number" && Number.isFinite(cell);
+    if (!carried)
+      throw new WireFormatError(`${where} holds ${JSON.stringify(cell) ?? typeof cell} in ${column}, expected a string, a number or null`);
+  }
+  const seq = value.seq;
+  if (!isCount(seq) || seq === 0)
+    throw new WireFormatError(`${where} has seq ${JSON.stringify(seq) ?? "undefined"}, expected a whole number above 0`);
+  return Object.freeze({ ...value });
+}
+function checkMigrations(value) {
+  if (!Array.isArray(value))
+    throw new WireFormatError("wire: migrations is not a list");
+  const ids = value.map((id) => {
+    if (typeof id !== "string" || id === "")
+      throw new WireFormatError(`wire: migration id ${JSON.stringify(id)} is not a name`);
+    return id;
+  });
+  const twice = ids.filter((id, index) => ids.indexOf(id) !== index);
+  if (twice.length > 0)
+    throw new WireFormatError(`wire: migrations name ${twice.join(", ")} more than once`);
+  return Object.freeze(ids);
+}
+function checkTables(value) {
+  if (!isRecord4(value))
+    throw new WireFormatError("wire: tables is not an object");
+  const entries = Object.entries(value).map(([table, rows]) => {
+    if (!isMergedTable(table))
+      throw new WireFormatError(`wire: tables names ${JSON.stringify(table)}, which is no merged table`);
+    if (!Array.isArray(rows))
+      throw new WireFormatError(`wire: tables.${table} is not a list`);
+    return [table, Object.freeze(rows.map((row, index) => checkRow(table, row, index)))];
+  });
+  return Object.freeze(Object.fromEntries(entries));
+}
+function checkPayload(value) {
+  if (!isRecord4(value))
+    throw new WireFormatError("wire: the payload is not an object");
+  if (value.format !== WIRE_FORMAT)
+    throw new WireFormatError(`wire: format is ${JSON.stringify(value.format) ?? "undefined"}, expected ${JSON.stringify(WIRE_FORMAT)}`);
+  if (value.version !== WIRE_VERSION)
+    throw new WireFormatError(`wire: version is ${JSON.stringify(value.version) ?? "undefined"}; this rafa reads version ${String(WIRE_VERSION)}`);
+  return Object.freeze({
+    format: WIRE_FORMAT,
+    version: WIRE_VERSION,
+    migrations: checkMigrations(value.migrations),
+    tables: checkTables(value.tables),
+    cursor: checkCursor(value.cursor)
+  });
+}
+function encodeWirePayload(payload) {
+  return JSON.stringify(payload);
+}
+function decodeWirePayload(text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new WireFormatError(`wire: the payload is not JSON (${reason})`);
+  }
+  return checkPayload(parsed);
+}
+function readLoggedIds(db) {
+  const hasLog = db.query("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?").get(MIGRATION_LOG_TABLE) !== null;
+  if (!hasLog)
+    return null;
+  return db.query(`SELECT id FROM ${MIGRATION_LOG_TABLE} ORDER BY seq`).all().map(({ id }) => id);
+}
+function columnsOf(db, table) {
+  return db.query(`PRAGMA table_info(${quoted(table)})`).all().map(({ name: name2 }) => name2);
+}
+function wireValue(value, where) {
+  if (typeof value === "bigint") {
+    const number = Number(value);
+    if (Number.isSafeInteger(number))
+      return number;
+    throw new WireExportRefusal(`wire: ${where} holds ${String(value)}, past the whole numbers JSON carries exactly`);
+  }
+  if (value instanceof Uint8Array)
+    throw new WireExportRefusal(`wire: ${where} holds a BLOB, which the wire does not carry`);
+  return value;
+}
+function readRows(db, table, columns, after, path) {
+  const named = columns.map(quoted).join(", ");
+  return db.query(`SELECT ${named} FROM ${quoted(table)} WHERE seq > ? ORDER BY seq`).all(after).map((row) => Object.freeze(Object.fromEntries(Object.entries(row).map(([column, value]) => [
+    column,
+    wireValue(value, `${path} ${table}.${column} at seq ${String(row.seq)}`)
+  ]))));
+}
+function readPayload(db, path, cursor) {
+  const migrations = readLoggedIds(db);
+  if (migrations === null) {
+    throw new WireExportRefusal(`wire: ${path} has no migration log; any rafa command that writes the store brings it forward`);
+  }
+  const tables = {};
+  const next = { ...cursor };
+  for (const table of MERGED_TABLES) {
+    const columns = columnsOf(db, table);
+    if (columns.length === 0)
+      continue;
+    const missing = ORIGIN_COLUMNS.filter((column) => !columns.includes(column));
+    if (missing.length > 0) {
+      throw new WireExportRefusal(`wire: ${path} holds no ${missing.map((column) => `${table}.${column}`).join(", ")}, so its rows carry no origin pair`);
+    }
+    const rows = readRows(db, table, columns, cursor[table] ?? 0, path);
+    tables[table] = Object.freeze(rows);
+    const last = rows[rows.length - 1];
+    next[table] = last === undefined ? cursor[table] ?? 0 : Number(last.seq);
+  }
+  return Object.freeze({
+    format: WIRE_FORMAT,
+    version: WIRE_VERSION,
+    migrations: Object.freeze([...migrations]),
+    tables: Object.freeze(tables),
+    cursor: Object.freeze(next)
+  });
+}
+function exportWirePayload(options) {
+  const { path } = options;
+  const cursor = checkCursor(options.cursor ?? {});
+  guardTestProcess(path);
+  if (!existsSync14(path))
+    throw new WireExportRefusal(`wire: ${path} is not there`);
+  const db = new Database6(path, { readonly: true, safeIntegers: true });
+  try {
+    db.run(`PRAGMA busy_timeout = ${String(activeStoreSettings().busyTimeoutMs)}`);
+    return db.transaction(() => readPayload(db, path, cursor))();
+  } finally {
+    db.close();
+  }
+}
+function namedMigrations(ids, catalogue) {
+  const known = new Set(catalogue.map(({ id }) => id));
+  const unknown = ids.filter((id) => !known.has(id));
+  if (unknown.length > 0) {
+    throw new WireFormatError(`wire: the payload's store holds migration ${unknown.join(", ")}, which this rafa does not know; update rafa to take its rows`);
+  }
+  return catalogue.filter(({ id }) => ids.includes(id));
+}
+function insertRows(db, table, rows) {
+  const columns = columnsOf(db, table);
+  if (columns.length === 0)
+    throw new WireFormatError(`wire: the payload carries ${table}, which its migrations do not make`);
+  const statement = db.query(`INSERT INTO ${quoted(table)} (${columns.map(quoted).join(", ")}) VALUES (${columns.map(() => "?").join(", ")})`);
+  const expected = [...columns].sort().join(",");
+  rows.forEach((row, index) => {
+    const where = `wire: ${table} row ${String(index)}`;
+    const held = Object.keys(row);
+    if ([...held].sort().join(",") !== expected) {
+      throw new WireFormatError(`${where} holds columns ${held.join(", ")}; its migrations make ${columns.join(", ")}`);
+    }
+    try {
+      statement.run(...columns.map((column) => row[column] ?? null));
+    } catch (error) {
+      if (!(error instanceof SQLiteError3))
+        throw error;
+      throw new WireFormatError(`${where} (seq ${String(row.seq)}) is refused by the table: ${error.message}`);
+    }
+  });
+}
+function buildStore(path, payload, options) {
+  const migrations = namedMigrations(payload.migrations, options.migrations ?? SQLITE_MIGRATIONS);
+  const db = new Database6(path, { create: true, readwrite: true });
+  try {
+    bringForward(db, path, "write", "open", {
+      migrations,
+      appliedBy: appliedByName(options.identity ?? readRuntimeIdentity()),
+      now: options.now,
+      builtAside: true
+    });
+    db.transaction(() => {
+      for (const [table, rows] of Object.entries(payload.tables))
+        insertRows(db, table, rows);
+    })();
+  } finally {
+    db.close();
+  }
+}
+function materialiseWirePayload(payload, options = {}) {
+  const checked = checkPayload(payload);
+  const directory = mkdtempSync2(join17(options.tempDir ?? tmpdir4(), "rafa-wire-"));
+  const release = () => rmSync7(directory, { recursive: true, force: true });
+  const path = join17(directory, SQLITE_STORE_FILE_NAME);
+  try {
+    guardTestProcess(path);
+    buildStore(path, checked, options);
+  } catch (error) {
+    release();
+    throw error;
+  }
+  return Object.freeze({ directory, path, release });
+}
+
 // src/effort/store/index.ts
 function describeValue4(value) {
   if (typeof value === "string")
@@ -5596,4 +6163,4 @@ function selectEffortStore(repoRoot, config) {
   return adapter.create({ repoRoot });
 }
 
-export { EFFORT_STORE_DIR, effortStoreFileName, EFFORT_DIR_VARIABLE, effortStoreDir, guardTestProcess, EFFORT_KEY_PROJECTIONS, openNdjsonStore, name, version, RAFA_VERSION, versionLine, createGitRunner, gitSaid, NOT_A_REPOSITORY, mainCheckoutOf, SCOPE_DIR, INIT_COMMAND, DISK_FILE_SYSTEM, ScopeError, scopeAt, initHint, selfAndAncestors, resolveScope, POSITION_FILE, positionFilePath, readPositionFile, writePositionFile, positionAt, rehome, hop, goHome, HOP_FILE, hopFilePath, readHopRecord, writeHopRecord, staleAgainst, SessionRecordError, SessionConflictError, SessionStateError, isSessionId, runsDir, sessionFilePath, errorCode, isPidAlive, readSessions, readSession, beginSession, updateSession, DEVELOPMENT_NEXT_STEP, DEVELOPMENT_MARK, DevelopmentBuildRefusedError, refuseUnownedDevelopmentWrite, LEGACY_GATE_OPEN, LEGACY_GATE_CLOSED, SQLITE_MIGRATIONS, sqliteCatalogue, planSchema, SchemaRefusedError, readStoreSchema, writeNames, ACROSS_STORES_ORDER, STAMPED_COLUMNS, stampedValues, activeStoreSettings, normalizeRemote, gitRemoteUrl, readStoreMeta, SQLITE_STORE_FILE_NAME, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, RebuildRefusal, readConfigFile, loadConfig, plansDirAt, requireProject, resolvePlansDir, resolveProjectConfig, countTasks, formatCounts, checkbox, planFileName, stubOfPlanFile, isFile, issueLine, plural, expectNoArgument, expectOneArgument, expectAtMostOneArgument, readSwitch, fileStamp, fix_schema_default, EffortCopyRefusal, EffortCopyFailure, copyEffortStore, minutesBetween, readCommitLog, UnionSchemaMismatch, migrateStore, MOVE_TO_SQLITE, MergeRefusal, mergeStore, createFileSync, SyncModuleMissing, selectSync, SKILL_FILE, MARKDOWN_EXTENSION, scanLayout, declaredNameIssue, readFrontmatterDocument, readFrontmatter, renderFrontmatter, mergeFrontmatter, writeFrontmatter, ACTION_HEADING, CAUSE_HEADING, parseInstinct, writeInstinct, readScopes, allRecords, findRecords, instinctProject, toHeldRecords, sessionSpawnEnv, getClaudeUsagePercent, checkUsage, CLAUDE_BIN, claudeArgs, interruptClaudeSessions, spawnClaude, runClaude, spawnClaudeCaptured, runClaudeCaptured, planFilePath, ClaudePlannerError, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_STATES, GITHUB_LABELS, createGhRunner, typeOfLabels, moduleOfLabels, createLocalTracker, PORT_VERSIONS, createAdapterRegistry, CORE_ADAPTER_REGISTRY, selectEffortStore };
+export { EFFORT_STORE_DIR, effortStoreFileName, EFFORT_DIR_VARIABLE, effortStoreDir, guardTestProcess, EFFORT_KEY_PROJECTIONS, openNdjsonStore, name, version, RAFA_VERSION, versionLine, createGitRunner, gitSaid, NOT_A_REPOSITORY, mainCheckoutOf, SCOPE_DIR, INIT_COMMAND, DISK_FILE_SYSTEM, ScopeError, scopeAt, initHint, selfAndAncestors, resolveScope, POSITION_FILE, positionFilePath, readPositionFile, writePositionFile, positionAt, rehome, hop, goHome, HOP_FILE, hopFilePath, readHopRecord, writeHopRecord, staleAgainst, SessionRecordError, isSessionId, sessionPhase, SessionConflictError, SessionStateError, runsDir, sessionFilePath, errorCode, isPidAlive, readSessions, readSession, beginSession, updateSession, DEVELOPMENT_NEXT_STEP, DEVELOPMENT_MARK, DevelopmentBuildRefusedError, refuseUnownedDevelopmentWrite, LEGACY_GATE_OPEN, LEGACY_GATE_CLOSED, SQLITE_MIGRATIONS, sqliteCatalogue, planSchema, SchemaRefusedError, readStoreSchema, writeNames, ACROSS_STORES_ORDER, STAMPED_COLUMNS, stampedValues, activeStoreSettings, normalizeRemote, gitRemoteUrl, readStoreMeta, SQLITE_STORE_FILE_NAME, sqliteStorePath, LONE_SURROGATE, withSqliteStore, writeSqliteStore, openSqliteStore, RebuildRefusal, readConfigFile, loadConfig, plansDirAt, requireProject, resolvePlansDir, resolveProjectConfig, countTasks, formatCounts, checkbox, planFileName, stubOfPlanFile, isFile, issueLine, plural, expectNoArgument, expectOneArgument, expectAtMostOneArgument, readSwitch, fileStamp, fix_schema_default, EffortCopyRefusal, EffortCopyFailure, copyEffortStore, minutesBetween, readCommitLog, UnionSchemaMismatch, migrateStore, MOVE_TO_SQLITE, MergeRefusal, mergeStore, createFileSync, SyncModuleMissing, selectSync, SKILL_FILE, MARKDOWN_EXTENSION, scanLayout, declaredNameIssue, readFrontmatterDocument, readFrontmatter, renderFrontmatter, mergeFrontmatter, writeFrontmatter, ACTION_HEADING, CAUSE_HEADING, parseInstinct, writeInstinct, readScopes, allRecords, findRecords, instinctProject, toHeldRecords, padKind, oneLine, sessionSpawnEnv, getClaudeUsagePercent, checkUsage, CLAUDE_BIN, claudeArgs, interruptClaudeSessions, spawnClaude, runClaude, spawnClaudeCaptured, runClaudeCaptured, planFilePath, ClaudePlannerError, ISSUE_TYPES, ISSUE_PRIORITIES, ISSUE_STATES, GITHUB_LABELS, createGhRunner, typeOfLabels, moduleOfLabels, createLocalTracker, PORT_VERSIONS, createAdapterRegistry, CORE_ADAPTER_REGISTRY, TRUSTED_PERMISSIONS, createGhPermissions, readAuthorTrust, ghBoardTrust, readBoardTrust, requireTrustedBoardAuthor, trustRefusalClause, requireTrustedAuthor, WIRE_FORMAT, WIRE_VERSION, WireFormatError, WireExportRefusal, encodeWirePayload, decodeWirePayload, exportWirePayload, materialiseWirePayload, selectEffortStore };