@open-tomato/rafa 0.32.0 → 0.33.0

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

@@ -10,11 +10,12 @@ import {
   activeOutputMode,
   configFilePath,
   createTextOutput,
+  hubContextOf,
   isStampableStub,
   parseConfigText,
   readRafaBlocks,
   resolveConfig
-} from "./index-9aph6ft9.js";
+} from "./index-dv0ycmp8.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
@@ -249,7 +252,7 @@ import { Database } from "bun:sqlite";
 
 // package.json
 var name = "@open-tomato/rafa";
-var version = "0.32.0";
+var version = "0.33.0";
 
 // src/cli/version.ts
 var RAFA_VERSION = version;
@@ -271,17 +274,7 @@ 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 dirname5, join as join7 } from "path";
 
 // src/project/scope.ts
 import { existsSync as existsSync3, realpathSync as realpathSync2 } from "fs";
@@ -403,16 +396,20 @@ function selfAndAncestors(path) {
   const parent = dirname2(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 +427,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 +441,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, 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 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";
 var POSITION_FILE = "position.json";
 function positionFilePath(root) {
   return join5(scopeAt(root).dir, POSITION_FILE);
@@ -625,11 +642,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 +658,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,6 +698,63 @@ 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`;
@@ -735,14 +780,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 +828,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 +854,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;
 }
@@ -870,10 +984,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;
@@ -2865,7 +2984,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 +2994,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);
@@ -3011,8 +3130,8 @@ function refuseOtherProject(options) {
   }
   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 +3222,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 +3290,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 +3338,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 +4462,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 +4798,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 +4832,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);
@@ -5513,6 +5668,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 +5740,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 +6109,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 };