@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/state-sync/write.js

@@ -0,0 +1,1469 @@
+// @bun
+// packages/runtime/src/control-plane/state-sync/write.ts
+import { isDeepStrictEqual } from "util";
+
+// packages/runtime/src/control-plane/native/git-native.ts
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, isAbsolute, resolve } from "path";
+import { createHash } from "crypto";
+function isTextTreeCommitUpdate(update) {
+  return typeof update.content === "string";
+}
+var sharedGitNativeOutputDir = resolve(tmpdir(), "rig-native");
+var sharedGitNativeOutputPath = resolve(sharedGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+var trackerCommandUsageProbe = "usage: rig-git fetch-ref <repo-path> <remote> <branch>";
+function temporaryGitBinaryOutputPath(outputPath) {
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  return resolve(dirname(outputPath), `.rig-git-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}${suffix}`);
+}
+function publishGitBinary(tempOutputPath, outputPath) {
+  try {
+    renameSync(tempOutputPath, outputPath);
+  } catch (error) {
+    if (process.platform === "win32" && existsSync(outputPath)) {
+      rmSync(outputPath, { force: true });
+      renameSync(tempOutputPath, outputPath);
+      return;
+    }
+    throw error;
+  }
+}
+function runtimeRigGitFileName() {
+  return `rig-git${process.platform === "win32" ? ".exe" : ""}`;
+}
+function rigGitSourceCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const cwd = process.cwd()?.trim() || "";
+  const projectRoot = process.env.PROJECT_RIG_ROOT?.trim() || "";
+  const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || "";
+  const moduleRelativeSource = resolve(import.meta.dir, "../../../native/rig-git.zig");
+  return [...new Set([
+    process.env.RIG_NATIVE_GIT_SOURCE?.trim() || "",
+    moduleRelativeSource,
+    projectRoot ? resolve(projectRoot, "packages/runtime/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve(hostProjectRoot, "packages/runtime/native/rig-git.zig") : "",
+    cwd ? resolve(cwd, "packages/runtime/native/rig-git.zig") : "",
+    execDir ? resolve(execDir, "..", "..", "packages/runtime/native/rig-git.zig") : "",
+    execDir ? resolve(execDir, "..", "native", "rig-git.zig") : ""
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve(cursor, "native", fileName), resolve(cursor, "native", "bin", fileName));
+    const parent = dirname(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function rigGitBinaryCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const fileName = runtimeRigGitFileName();
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  return [...new Set([
+    explicit,
+    ...nativePackageBinaryCandidates(import.meta.dir, fileName),
+    execDir ? resolve(execDir, fileName) : "",
+    execDir ? resolve(execDir, "..", fileName) : "",
+    execDir ? resolve(execDir, "..", "bin", fileName) : "",
+    sharedGitNativeOutputPath
+  ].filter(Boolean))];
+}
+function resolveGitSourcePath() {
+  for (const candidate of rigGitSourceCandidates()) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveGitBinaryPath() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  for (const candidate of rigGitBinaryCandidates()) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function preferredGitBinaryOutputPath() {
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  return explicit || sharedGitNativeOutputPath;
+}
+function binarySupportsTrackerCommandsSync(binaryPath) {
+  try {
+    const probe = Bun.spawnSync([binaryPath, "fetch-ref", "."], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = probe.stdout.toString().trim();
+    const stderr = probe.stderr.toString().trim();
+    if (stdout.includes('"error":"unknown command"')) {
+      return false;
+    }
+    return probe.exitCode === 2 && stderr.includes(trackerCommandUsageProbe);
+  } catch {
+    return false;
+  }
+}
+function nativeBuildManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+function hasMatchingNativeBuildManifestSync(manifestPath, buildKey) {
+  if (!existsSync(manifestPath)) {
+    return false;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    return manifest.version === 1 && manifest.buildKey === buildKey;
+  } catch {
+    return false;
+  }
+}
+function sha256FileSync(path) {
+  return createHash("sha256").update(readFileSync(path)).digest("hex");
+}
+function ensureRigGitBinaryPathSync(outputPath = preferredGitBinaryOutputPath()) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    throw new Error("Zig native git is disabled via RIG_DISABLE_ZIG_NATIVE=1");
+  }
+  const sourcePath = resolveGitSourcePath();
+  if (!sourcePath) {
+    const binaryPath = resolveGitBinaryPath();
+    if (binaryPath) {
+      return binaryPath;
+    }
+    throw new Error("rig-git.zig source file not found.");
+  }
+  const zigBinary = Bun.which("zig");
+  if (!zigBinary) {
+    throw new Error("zig is required to build native Rig git tools.");
+  }
+  mkdirSync(dirname(outputPath), { recursive: true });
+  const sourceDigest = sha256FileSync(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    zigBinary,
+    platform: process.platform,
+    arch: process.arch,
+    sourcePath,
+    sourceDigest
+  });
+  const manifestPath = nativeBuildManifestPath(outputPath);
+  const needsBuild = !existsSync(outputPath) || !hasMatchingNativeBuildManifestSync(manifestPath, buildKey) || !binarySupportsTrackerCommandsSync(outputPath);
+  if (!needsBuild) {
+    chmodSync(outputPath, 493);
+    return outputPath;
+  }
+  const tempOutputPath = temporaryGitBinaryOutputPath(outputPath);
+  const build = Bun.spawnSync([
+    zigBinary,
+    "build-exe",
+    sourcePath,
+    "-O",
+    "ReleaseFast",
+    `-femit-bin=${tempOutputPath}`
+  ], {
+    cwd: dirname(sourcePath),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (build.exitCode !== 0 || !existsSync(tempOutputPath)) {
+    const stderr = build.stderr.toString().trim();
+    const stdout = build.stdout.toString().trim();
+    const details = [stderr, stdout].filter(Boolean).join(`
+`);
+    throw new Error(`Failed to build native Rig git tools: ${details || `zig exited with code ${build.exitCode}`}`);
+  }
+  chmodSync(tempOutputPath, 493);
+  if (existsSync(outputPath) && hasMatchingNativeBuildManifestSync(manifestPath, buildKey)) {
+    rmSync(tempOutputPath, { force: true });
+    chmodSync(outputPath, 493);
+    return outputPath;
+  }
+  publishGitBinary(tempOutputPath, outputPath);
+  if (!binarySupportsTrackerCommandsSync(outputPath)) {
+    rmSync(outputPath, { force: true });
+    throw new Error("Failed to build native Rig git tools: tracker command probe failed");
+  }
+  writeFileSync(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`, "utf8");
+  return outputPath;
+}
+function runGitNative(command, args) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return { ok: false, error: "rig-git native disabled" };
+  }
+  const trackerCommand = command === "fetch-ref" || command === "read-blob-at-ref" || command === "write-tree-commit" || command === "push-ref-with-lease";
+  let binaryPath = null;
+  if (trackerCommand) {
+    try {
+      binaryPath = ensureRigGitBinaryPathSync(preferredGitBinaryOutputPath());
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("rig-git.zig source file not found")) {
+        return { ok: false, error: "rig-git binary not found" };
+      }
+      return { ok: false, error: message };
+    }
+  } else {
+    const explicitBinaryPath = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+    binaryPath = explicitBinaryPath && existsSync(explicitBinaryPath) ? explicitBinaryPath : !explicitBinaryPath ? resolveGitBinaryPath() : null;
+    if (!binaryPath) {
+      try {
+        binaryPath = ensureRigGitBinaryPathSync(preferredGitBinaryOutputPath());
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("rig-git.zig source file not found")) {
+          return { ok: false, error: "rig-git binary not found" };
+        }
+        return { ok: false, error: message };
+      }
+    }
+  }
+  try {
+    const proc = Bun.spawnSync([binaryPath, command, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: process.env
+    });
+    if (proc.exitCode !== 0) {
+      const stdoutText = proc.stdout.toString().trim();
+      if (stdoutText) {
+        try {
+          const parsed = JSON.parse(stdoutText);
+          if (!parsed.ok) {
+            return parsed;
+          }
+        } catch {}
+      }
+      const errText = proc.stderr.toString().trim() || `exit code ${proc.exitCode}`;
+      return { ok: false, error: errText };
+    }
+    const output = proc.stdout.toString().trim();
+    return JSON.parse(output);
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+function requireGitNative(command, args) {
+  const result = runGitNative(command, args);
+  if (!result.ok) {
+    throw new Error(`rig-git ${command} failed: ${result.error}`);
+  }
+  return result;
+}
+function requireGitNativeString(command, args) {
+  const result = requireGitNative(command, args);
+  if ("value" in result && typeof result.value === "string") {
+    return result.value;
+  }
+  throw new Error(`rig-git ${command} returned an unexpected result payload`);
+}
+function nativeFetchRef(repoPath, remote, branch) {
+  return requireGitNativeString("fetch-ref", [repoPath, remote, branch]);
+}
+function nativeReadBlobAtRef(repoPath, ref, path) {
+  const requestDir = resolve(sharedGitNativeOutputDir, "reads", `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync(requestDir, { recursive: true });
+  const outputPath = resolve(requestDir, "blob.txt");
+  try {
+    requireGitNative("read-blob-at-ref", [repoPath, ref, path, outputPath]);
+    return readFileSync(outputPath, "utf8");
+  } finally {
+    rmSync(requestDir, { recursive: true, force: true });
+  }
+}
+function serializeTreeCommitUpdates(updates) {
+  return updates.map((update) => {
+    if (isTextTreeCommitUpdate(update)) {
+      return { path: update.path, kind: "text", content: update.content };
+    }
+    if (!isAbsolute(update.sourceFilePath)) {
+      throw new Error("tree commit binary updates require an absolute sourceFilePath");
+    }
+    return { path: update.path, kind: "file", sourceFilePath: update.sourceFilePath };
+  });
+}
+function buildTreeCommitUpdatesJson(updates) {
+  return `${JSON.stringify(serializeTreeCommitUpdates(updates), null, 2)}
+`;
+}
+function nativeWriteTreeCommit(repoPath, baseRef, updates, message) {
+  const requestDir = resolve(sharedGitNativeOutputDir, "requests", `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync(requestDir, { recursive: true });
+  const messagePath = resolve(requestDir, "message.txt");
+  const updatesPath = resolve(requestDir, "updates.json");
+  try {
+    writeFileSync(messagePath, message, "utf8");
+    writeFileSync(updatesPath, buildTreeCommitUpdatesJson(updates), "utf8");
+    return requireGitNativeString("write-tree-commit", [repoPath, baseRef, messagePath, updatesPath]);
+  } finally {
+    rmSync(requestDir, { recursive: true, force: true });
+  }
+}
+function nativePushRefWithLease(repoPath, localOid, remoteRef, expectedOldOid, remote = "origin") {
+  return requireGitNativeString("push-ref-with-lease", [
+    repoPath,
+    localOid,
+    remoteRef,
+    expectedOldOid,
+    remote
+  ]);
+}
+
+// packages/runtime/src/control-plane/state-sync/read.ts
+import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve6 } from "path";
+
+// packages/runtime/src/layout.ts
+import { existsSync as existsSync2 } from "fs";
+import { basename, dirname as dirname2, resolve as resolve2 } from "path";
+function resolveMonorepoRoot(projectRoot) {
+  const normalizedProjectRoot = resolve2(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve2(explicit);
+    const explicitParent = dirname2(explicitRoot);
+    if (basename(explicitParent) === ".worktrees") {
+      const owner = dirname2(explicitParent);
+      const ownerHasGit = existsSync2(resolve2(owner, ".git"));
+      const ownerHasTaskConfig = existsSync2(resolve2(owner, ".rig", "task-config.json"));
+      const ownerHasRigConfig = existsSync2(resolve2(owner, "rig.config.ts"));
+      if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
+        return owner;
+      }
+      throw new Error(`MONOREPO_ROOT points to worktree ${explicitRoot}, but the owner checkout is incomplete at ${owner}.`);
+    }
+    if (!existsSync2(resolve2(explicitRoot, ".git"))) {
+      throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there.`);
+    }
+    const hasTaskConfig = existsSync2(resolve2(explicitRoot, ".rig", "task-config.json"));
+    const hasRigConfig = existsSync2(resolve2(explicitRoot, "rig.config.ts"));
+    if (!hasTaskConfig && !hasRigConfig) {
+      throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but neither .rig/task-config.json nor rig.config.ts exists there.`);
+    }
+    return explicitRoot;
+  }
+  const projectParent = dirname2(normalizedProjectRoot);
+  if (basename(projectParent) === ".worktrees") {
+    const worktreeOwner = dirname2(projectParent);
+    const ownerHasGit = existsSync2(resolve2(worktreeOwner, ".git"));
+    const ownerHasTaskConfig = existsSync2(resolve2(worktreeOwner, ".rig", "task-config.json"));
+    const ownerHasRigConfig = existsSync2(resolve2(worktreeOwner, "rig.config.ts"));
+    if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
+      return worktreeOwner;
+    }
+  }
+  return normalizedProjectRoot;
+}
+
+// packages/runtime/src/control-plane/native/runtime-native.ts
+import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
+import { copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, renameSync as renameSync2, rmSync as rmSync2, statSync } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname3, resolve as resolve3 } from "path";
+var sharedNativeRuntimeOutputDir = resolve3(tmpdir2(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve3(sharedNativeRuntimeOutputDir, `runtime-native-${process.platform}-${process.arch}.${suffix}`);
+var colocatedNativeRuntimeFileName = `runtime-native.${suffix}`;
+var nativeRuntimeLibrary = await loadNativeRuntimeLibrary();
+async function ensureNativeRuntimeLibraryPath(outputPath = sharedNativeRuntimeOutputPath, options = {}) {
+  if (await buildNativeRuntimeLibrary(outputPath, options)) {
+    return outputPath;
+  }
+  return !options.force && existsSync3(outputPath) ? outputPath : null;
+}
+async function loadNativeRuntimeLibrary() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  for (const candidate of nativeRuntimeLibraryCandidates()) {
+    if (!candidate || !existsSync3(candidate)) {
+      continue;
+    }
+    const loaded = tryDlopenNativeRuntimeLibrary(candidate);
+    if (loaded) {
+      return loaded;
+    }
+  }
+  const builtLibraryPath = await ensureNativeRuntimeLibraryPath(sharedNativeRuntimeOutputPath, { force: true });
+  if (!builtLibraryPath) {
+    return null;
+  }
+  return tryDlopenNativeRuntimeLibrary(builtLibraryPath);
+}
+function nativePackageLibraryCandidates(fromDir, names) {
+  const candidates = [];
+  let cursor = resolve3(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    for (const name of names) {
+      candidates.push(resolve3(cursor, "native", `${process.platform}-${process.arch}`, name), resolve3(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve3(cursor, "native", name), resolve3(cursor, "native", "lib", name));
+    }
+    const parent = dirname3(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function nativeRuntimeLibraryCandidates() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_LIB?.trim() || "";
+  const execDir = process.execPath?.trim() ? dirname3(process.execPath.trim()) : "";
+  const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
+  return [...new Set([
+    explicit,
+    ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
+    execDir ? resolve3(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve3(execDir, platformSpecific) : "",
+    execDir ? resolve3(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve3(execDir, "..", platformSpecific) : "",
+    execDir ? resolve3(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve3(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    sharedNativeRuntimeOutputPath
+  ].filter(Boolean))];
+}
+function resolveNativeRuntimeSourcePath() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
+  if (explicit && existsSync3(explicit)) {
+    return explicit;
+  }
+  const bundled = resolve3(import.meta.dir, "../../../native/snapshot.zig");
+  return existsSync3(bundled) ? bundled : null;
+}
+async function buildNativeRuntimeLibrary(outputPath, options = {}) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return false;
+  }
+  const zigBinary = Bun.which("zig");
+  const sourcePath = resolveNativeRuntimeSourcePath();
+  if (!zigBinary || !sourcePath) {
+    return false;
+  }
+  const tempOutputPath = `${outputPath}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  try {
+    mkdirSync2(dirname3(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync3(outputPath) || statSync(sourcePath).mtimeMs > statSync(outputPath).mtimeMs;
+    if (!needsBuild) {
+      return true;
+    }
+    const build = Bun.spawn([
+      zigBinary,
+      "build-lib",
+      sourcePath,
+      "-dynamic",
+      "-O",
+      "ReleaseFast",
+      `-femit-bin=${tempOutputPath}`
+    ], {
+      cwd: import.meta.dir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await build.exited;
+    if (exitCode !== 0 || !existsSync3(tempOutputPath)) {
+      rmSync2(tempOutputPath, { force: true });
+      return false;
+    }
+    renameSync2(tempOutputPath, outputPath);
+    return true;
+  } catch {
+    rmSync2(tempOutputPath, { force: true });
+    return false;
+  }
+}
+function tryDlopenNativeRuntimeLibrary(outputPath) {
+  try {
+    return dlopen(outputPath, {
+      rig_scope_match: {
+        args: ["ptr", "ptr"],
+        returns: "u8"
+      },
+      snapshot_capture: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_delta: {
+        args: ["ptr", "ptr"],
+        returns: "ptr"
+      },
+      snapshot_store_delta: {
+        args: ["ptr", "ptr", "ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_inspect_delta: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_apply_delta: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      snapshot_release: {
+        args: ["ptr"],
+        returns: "void"
+      },
+      runtime_hash_file: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_hash_tree: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_prepare_paths: {
+        args: ["ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_link_dependency_layer: {
+        args: ["ptr", "u64", "ptr", "u64"],
+        returns: "ptr"
+      },
+      runtime_scan_worktrees: {
+        args: ["ptr", "u64"],
+        returns: "ptr"
+      }
+    });
+  } catch {
+    return null;
+  }
+}
+
+// packages/runtime/src/control-plane/native/utils.ts
+function resolveMonorepoRoot2(projectRoot) {
+  return resolveMonorepoRoot(projectRoot);
+}
+var scopeRegexCache = new Map;
+
+// packages/runtime/src/control-plane/runtime/context.ts
+var RUNTIME_CONTEXT_ENV = "RIG_RUNTIME_CONTEXT_FILE";
+
+// packages/runtime/src/control-plane/state-sync/repo.ts
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve5 } from "path";
+
+// packages/runtime/src/control-plane/repos/layout.ts
+import { existsSync as existsSync4 } from "fs";
+import { basename as basename2, dirname as dirname4, join, resolve as resolve4 } from "path";
+
+// packages/runtime/src/control-plane/repos/registry.ts
+var MANAGED_REPOS = new Map;
+function getManagedRepoEntry(repoId) {
+  const entry = MANAGED_REPOS.get(repoId);
+  if (!entry) {
+    throw new Error(`managed repo not registered: ${repoId}. Plugins contribute repos via RigPlugin.contributes.repoSources; ` + `make sure a plugin declares this id and the plugin host has been initialized.`);
+  }
+  return entry;
+}
+function listManagedRepoEntries() {
+  return Array.from(MANAGED_REPOS.values());
+}
+
+// packages/runtime/src/control-plane/repos/layout.ts
+function resolveRepoStateDir(projectRoot) {
+  const normalizedProjectRoot = resolve4(projectRoot);
+  const projectParent = dirname4(normalizedProjectRoot);
+  if (basename2(projectParent) === ".worktrees") {
+    const ownerRoot = dirname4(projectParent);
+    const ownerHasRepoMarkers = existsSync4(resolve4(ownerRoot, ".git")) || existsSync4(resolve4(ownerRoot, ".rig", "state"));
+    if (ownerHasRepoMarkers) {
+      return resolve4(ownerRoot, ".rig", "state");
+    }
+  }
+  return resolve4(projectRoot, ".rig", "state");
+}
+function resolveManagedRepoLayout(projectRoot, repoId) {
+  const normalizedProjectRoot = resolve4(projectRoot);
+  const entry = getManagedRepoEntry(repoId);
+  const stateDir = resolveRepoStateDir(normalizedProjectRoot);
+  const metadataRelativePath = join("repos", entry.id);
+  const metadataRoot = resolve4(stateDir, metadataRelativePath);
+  const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  const runsInsideTaskWorktree = runtimeWorkspace && resolve4(runtimeWorkspace) === normalizedProjectRoot || basename2(dirname4(normalizedProjectRoot)) === ".worktrees";
+  const isPrimaryManagedRepo = listManagedRepoEntries()[0]?.id === repoId;
+  const checkoutRoot = isPrimaryManagedRepo && runsInsideTaskWorktree ? resolveMonorepoRoot(normalizedProjectRoot) : entry.checkoutEnvVar && process.env[entry.checkoutEnvVar]?.trim() ? resolve4(process.env[entry.checkoutEnvVar].trim()) : resolve4(normalizedProjectRoot, entry.alias);
+  return {
+    projectRoot: normalizedProjectRoot,
+    repoId: entry.id,
+    alias: entry.alias,
+    defaultBranch: entry.defaultBranch,
+    remoteUrl: entry.remoteEnvVar && process.env[entry.remoteEnvVar]?.trim() ? process.env[entry.remoteEnvVar].trim() : entry.defaultRemoteUrl,
+    checkoutRoot,
+    worktreesRoot: resolve4(checkoutRoot, ".worktrees"),
+    stateDir,
+    metadataRoot,
+    metadataRelativePath,
+    mirrorRoot: resolve4(metadataRoot, "mirror.git"),
+    mirrorStatePath: resolve4(metadataRoot, "mirror-state.json"),
+    mirrorStateRelativePath: join(metadataRelativePath, "mirror-state.json")
+  };
+}
+function resolveMonorepoRepoLayout(projectRoot) {
+  const entries = listManagedRepoEntries();
+  if (entries.length === 0) {
+    throw new Error("resolveMonorepoRepoLayout: no managed repos registered. Either contribute one via " + "RigPlugin.contributes.repoSources (with defaultBranch set), or avoid calling this " + "function for projects where the project root IS the monorepo.");
+  }
+  const primary = entries[0];
+  return resolveManagedRepoLayout(projectRoot, primary.id);
+}
+
+// packages/runtime/src/control-plane/state-sync/repo.ts
+function resolveTrackerRepoPath(projectRoot) {
+  const monorepoRoot = resolveMonorepoRoot2(projectRoot);
+  try {
+    const layout = resolveMonorepoRepoLayout(projectRoot);
+    if (existsSync5(resolve5(layout.mirrorRoot, "HEAD"))) {
+      return layout.mirrorRoot;
+    }
+  } catch {}
+  return monorepoRoot;
+}
+
+// packages/runtime/src/control-plane/state-sync/types.ts
+var SUPPORTED_TASK_STATE_SCHEMA_VERSION = 1;
+var CANONICAL_TASK_LIFECYCLE_STATUSES = new Set([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "completed",
+  "cancelled"
+]);
+function normalizeTaskLifecycleStatus(status) {
+  switch (status) {
+    case "draft":
+    case "open":
+    case "ready":
+    case "queued":
+    case "in_progress":
+    case "under_review":
+    case "blocked":
+    case "completed":
+    case "cancelled":
+      return status;
+    case "closed":
+      return "completed";
+    case "running":
+      return "in_progress";
+    case "failed":
+      return "ready";
+    default:
+      return null;
+  }
+}
+function normalizeTaskStateMetadataStatus(status) {
+  if (CANONICAL_TASK_LIFECYCLE_STATUSES.has(status)) {
+    return status;
+  }
+  switch (status) {
+    case "closed":
+      return "completed";
+    case "running":
+      return "in_progress";
+    case "failed":
+      return "ready";
+    default:
+      return;
+  }
+}
+function canonicalizeTaskStateMetadata(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return null;
+  }
+  const metadata = raw;
+  const claimId = typeof metadata.claimId === "string" && metadata.claimId.length > 0 ? metadata.claimId : undefined;
+  const status = normalizeTaskStateMetadataStatus(metadata.status);
+  if (!status) {
+    return null;
+  }
+  return {
+    ...claimId ? { claimId } : {},
+    status,
+    ...typeof metadata.ownerId === "string" && metadata.ownerId.length > 0 ? { ownerId: metadata.ownerId } : {},
+    ...typeof metadata.claimedAt === "string" && metadata.claimedAt.length > 0 ? { claimedAt: metadata.claimedAt } : {},
+    ...typeof metadata.lastEvidenceAt === "string" && metadata.lastEvidenceAt.length > 0 ? { lastEvidenceAt: metadata.lastEvidenceAt } : {},
+    ...typeof metadata.runId === "string" && metadata.runId.length > 0 ? { runId: metadata.runId } : {},
+    ...typeof metadata.branchName === "string" && metadata.branchName.length > 0 ? { branchName: metadata.branchName } : {},
+    ...typeof metadata.prNumber === "number" ? { prNumber: metadata.prNumber } : {},
+    ...typeof metadata.prUrl === "string" && metadata.prUrl.length > 0 ? { prUrl: metadata.prUrl } : {},
+    ...typeof metadata.reviewState === "string" && metadata.reviewState.length > 0 ? { reviewState: metadata.reviewState } : {},
+    ...typeof metadata.blockerReason === "string" && metadata.blockerReason.length > 0 ? { blockerReason: metadata.blockerReason } : {},
+    ...typeof metadata.sourceCommit === "string" && metadata.sourceCommit.length > 0 ? { sourceCommit: metadata.sourceCommit } : {}
+  };
+}
+function discardMismatchedTaskStateMetadata(input) {
+  input.taskId;
+  const canonicalMetadata = canonicalizeTaskStateMetadata(input.metadata);
+  if (!canonicalMetadata || !input.lifecycleStatus) {
+    return null;
+  }
+  const metadataStatus = canonicalMetadata.status ?? null;
+  if (metadataStatus && metadataStatus !== input.lifecycleStatus) {
+    return null;
+  }
+  return canonicalMetadata;
+}
+function readTaskStateMetadataEnvelope(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { schemaVersion: SUPPORTED_TASK_STATE_SCHEMA_VERSION, supported: true, baseTrackerCommit: null, tasks: {} };
+  }
+  const envelope = raw;
+  const schemaVersion = typeof envelope.schemaVersion === "number" ? envelope.schemaVersion : SUPPORTED_TASK_STATE_SCHEMA_VERSION;
+  if (schemaVersion !== SUPPORTED_TASK_STATE_SCHEMA_VERSION) {
+    return { schemaVersion, supported: false, baseTrackerCommit: null, tasks: {} };
+  }
+  const rawTasks = envelope.tasks && typeof envelope.tasks === "object" && !Array.isArray(envelope.tasks) ? envelope.tasks : {};
+  const tasks = Object.fromEntries(Object.entries(rawTasks).map(([taskId, metadata]) => [taskId, canonicalizeTaskStateMetadata(metadata)]).filter((entry) => entry[1] != null));
+  return {
+    schemaVersion,
+    supported: true,
+    baseTrackerCommit: typeof envelope.baseTrackerCommit === "string" && envelope.baseTrackerCommit.length > 0 ? envelope.baseTrackerCommit : null,
+    tasks
+  };
+}
+
+// packages/runtime/src/control-plane/state-sync/read.ts
+var DEFAULT_READ_DEPS = {
+  fetchRef: nativeFetchRef,
+  readBlobAtRef: nativeReadBlobAtRef,
+  exists: existsSync6,
+  readFile: (path) => readFileSync2(path, "utf8")
+};
+function parseIssueStatus(rawStatus) {
+  const normalized = normalizeTaskLifecycleStatus(rawStatus);
+  return normalized ?? "unknown";
+}
+function parseIssueDependencies(raw) {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.filter((entry) => !!entry && typeof entry === "object" && !Array.isArray(entry)).map((entry) => ({
+    issueId: typeof entry.issue_id === "string" && entry.issue_id.trim() ? entry.issue_id.trim() : null,
+    dependsOnId: typeof entry.depends_on_id === "string" && entry.depends_on_id.trim() ? entry.depends_on_id.trim() : null,
+    id: typeof entry.id === "string" && entry.id.trim() ? entry.id.trim() : null,
+    type: typeof entry.type === "string" && entry.type.trim() ? entry.type.trim() : null
+  }));
+}
+function parseIssuesJsonl(raw) {
+  const issues = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      const record = JSON.parse(trimmed);
+      const id = typeof record.id === "string" && record.id.trim() ? record.id.trim() : "";
+      if (!id) {
+        continue;
+      }
+      const rawStatus = typeof record.status === "string" && record.status.trim() ? record.status.trim() : null;
+      issues.push({
+        id,
+        title: typeof record.title === "string" && record.title.trim() ? record.title.trim() : null,
+        description: typeof record.description === "string" && record.description.trim() ? record.description.trim() : null,
+        acceptanceCriteria: typeof record.acceptance_criteria === "string" && record.acceptance_criteria.trim() ? record.acceptance_criteria.trim() : typeof record.acceptanceCriteria === "string" && record.acceptanceCriteria.trim() ? record.acceptanceCriteria.trim() : null,
+        issueType: typeof record.issue_type === "string" && record.issue_type.trim() ? record.issue_type.trim() : null,
+        status: parseIssueStatus(rawStatus),
+        rawStatus,
+        priority: typeof record.priority === "number" ? record.priority : null,
+        dependencies: parseIssueDependencies(record.dependencies)
+      });
+    } catch {}
+  }
+  return issues;
+}
+function parseTaskStateEnvelope(raw) {
+  if (!raw || !raw.trim()) {
+    return readTaskStateMetadataEnvelope(null);
+  }
+  try {
+    return readTaskStateMetadataEnvelope(JSON.parse(raw));
+  } catch {
+    return readTaskStateMetadataEnvelope(null);
+  }
+}
+function readRemoteBlobAtRef(deps, repoPath, ref, path, options) {
+  try {
+    return deps.readBlobAtRef(repoPath, ref, path);
+  } catch (error) {
+    if (options.required) {
+      throw error;
+    }
+    return null;
+  }
+}
+function shouldPreferLocalTrackerState(options) {
+  if (!options.allowLocalFallback) {
+    return false;
+  }
+  const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (!runtimeWorkspace) {
+    return false;
+  }
+  if (process.env.RIG_TASK_RUNTIME_ID?.trim()) {
+    return true;
+  }
+  const runtimeContextPath = process.env[RUNTIME_CONTEXT_ENV]?.trim();
+  if (runtimeContextPath) {
+    return true;
+  }
+  return existsSync6(resolve6(runtimeWorkspace, ".rig", "runtime-context.json"));
+}
+function readLocalTrackerState(projectRoot, deps) {
+  const monorepoRoot = resolveMonorepoRoot2(projectRoot);
+  const issuesPath = resolve6(monorepoRoot, ".beads", "issues.jsonl");
+  const taskStatePath = resolve6(monorepoRoot, ".beads", "task-state.json");
+  return projectSyncedTrackerSnapshot({
+    source: "local",
+    issuesBaseOid: null,
+    issuesText: deps.exists(issuesPath) ? deps.readFile(issuesPath) : "",
+    taskStateBaseOid: null,
+    taskStateText: deps.exists(taskStatePath) ? deps.readFile(taskStatePath) : null
+  });
+}
+function projectSyncedTrackerSnapshot(input) {
+  if (input.source === "remote" && input.issuesBaseOid && input.taskStateBaseOid && input.issuesBaseOid !== input.taskStateBaseOid) {
+    throw new Error("Remote tracker files must be read from the same fetched base.");
+  }
+  return {
+    source: input.source,
+    baseOid: input.issuesBaseOid ?? input.taskStateBaseOid ?? null,
+    issues: parseIssuesJsonl(input.issuesText),
+    taskState: parseTaskStateEnvelope(input.taskStateText)
+  };
+}
+function readSyncedTrackerState(projectRoot, deps = {}, options = {}) {
+  const readDeps = { ...DEFAULT_READ_DEPS, ...deps };
+  const trackerRepoPath = resolveTrackerRepoPath(projectRoot);
+  if (shouldPreferLocalTrackerState(options)) {
+    return readLocalTrackerState(projectRoot, readDeps);
+  }
+  try {
+    const baseOid = readDeps.fetchRef(trackerRepoPath, "origin", "main");
+    return projectSyncedTrackerSnapshot({
+      source: "remote",
+      issuesBaseOid: baseOid,
+      issuesText: readRemoteBlobAtRef(readDeps, trackerRepoPath, baseOid, ".beads/issues.jsonl", {
+        required: true
+      }) ?? "",
+      taskStateBaseOid: baseOid,
+      taskStateText: readRemoteBlobAtRef(readDeps, trackerRepoPath, baseOid, ".beads/task-state.json", {
+        required: false
+      })
+    });
+  } catch (error) {
+    if (!options.allowLocalFallback) {
+      throw error;
+    }
+    return readLocalTrackerState(projectRoot, readDeps);
+  }
+}
+
+// packages/runtime/src/control-plane/state-sync/reconcile.ts
+var STALE_CLAIM_MS = 24 * 60 * 60 * 1000;
+function parseTimestamp(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function inProgressOwnershipMetadataIssue(metadata) {
+  if (!metadata?.claimId || !metadata.ownerId || !metadata.claimedAt || !metadata.lastEvidenceAt) {
+    return "missing-ownership-metadata";
+  }
+  if (parseTimestamp(metadata.claimedAt) == null || parseTimestamp(metadata.lastEvidenceAt) == null) {
+    return "invalid-ownership-timestamps";
+  }
+  return null;
+}
+function hasExplicitPullRequestEvidence(evidence) {
+  return evidence != null && Object.prototype.hasOwnProperty.call(evidence, "pr");
+}
+function hasPrCloseoutCompletionEvidence(evidence) {
+  const pr = evidence?.pr;
+  return evidence?.closeoutPassed === true && (pr?.isOpen === true || pr?.isMerged === true);
+}
+function isTaskClaimStale(metadata, nowIso) {
+  if (!metadata) {
+    return false;
+  }
+  const now = parseTimestamp(nowIso);
+  if (now == null) {
+    return false;
+  }
+  const reference = parseTimestamp(metadata.lastEvidenceAt) ?? parseTimestamp(metadata.claimedAt);
+  if (reference == null) {
+    return false;
+  }
+  return now - reference > STALE_CLAIM_MS;
+}
+function projectTaskReconciliation(input) {
+  const reasons = [];
+  const nowIso = input.evidence?.now ?? new Date().toISOString();
+  const isStale = isTaskClaimStale(input.metadata, nowIso);
+  const pr = input.evidence?.pr ?? null;
+  const hasExplicitPrEvidence = hasExplicitPullRequestEvidence(input.evidence);
+  const activeOwnerIds = (input.evidence?.activeOwnerIds ?? []).filter(Boolean);
+  if (new Set(activeOwnerIds).size > 1) {
+    return {
+      valid: false,
+      reasons: ["multiple-active-owners"],
+      isStale,
+      wouldReconcileTo: null,
+      nextMetadata: input.metadata
+    };
+  }
+  if (input.lifecycleStatus === "blocked" || input.lifecycleStatus === "cancelled") {
+    return {
+      valid: true,
+      reasons,
+      isStale,
+      wouldReconcileTo: null,
+      nextMetadata: input.metadata
+    };
+  }
+  if (input.lifecycleStatus === "in_progress") {
+    const ownershipMetadataIssue = inProgressOwnershipMetadataIssue(input.metadata);
+    const hasOwnershipMetadata = ownershipMetadataIssue == null;
+    if (hasPrCloseoutCompletionEvidence(input.evidence)) {
+      return {
+        valid: hasOwnershipMetadata,
+        reasons: hasOwnershipMetadata ? reasons : [ownershipMetadataIssue],
+        isStale,
+        wouldReconcileTo: "completed",
+        nextMetadata: input.metadata ? {
+          ...input.metadata,
+          status: "completed",
+          lastEvidenceAt: nowIso,
+          ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+          ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        } : {
+          status: "completed",
+          lastEvidenceAt: nowIso,
+          ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+          ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        }
+      };
+    }
+    if (ownershipMetadataIssue) {
+      return {
+        valid: false,
+        reasons: [ownershipMetadataIssue],
+        isStale,
+        wouldReconcileTo: pr?.isOpen ? "under_review" : "ready",
+        nextMetadata: pr?.isOpen ? {
+          ...input.metadata ?? { status: "under_review" },
+          status: "under_review",
+          lastEvidenceAt: nowIso,
+          ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+          ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        } : null
+      };
+    }
+    if (isStale) {
+      if (pr?.isOpen) {
+        return {
+          valid: false,
+          reasons: ["stale-claim"],
+          isStale,
+          wouldReconcileTo: "under_review",
+          nextMetadata: {
+            ...input.metadata,
+            status: "under_review",
+            lastEvidenceAt: nowIso,
+            ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+            ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+            ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+          }
+        };
+      }
+      return {
+        valid: false,
+        reasons: ["stale-claim"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+  }
+  if (hasPrCloseoutCompletionEvidence(input.evidence) && (input.lifecycleStatus === "open" || input.lifecycleStatus === "ready" || input.lifecycleStatus === "queued")) {
+    return {
+      valid: false,
+      reasons: ["pr-closeout-before-completion"],
+      isStale,
+      wouldReconcileTo: "completed",
+      nextMetadata: {
+        ...input.metadata ?? { status: "completed" },
+        status: "completed",
+        lastEvidenceAt: nowIso,
+        ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+        ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+        ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+      }
+    };
+  }
+  if (input.lifecycleStatus === "under_review") {
+    const hasPrLink = Boolean(input.metadata?.prNumber || input.metadata?.prUrl || pr?.prNumber || pr?.prUrl);
+    if (!hasPrLink) {
+      return {
+        valid: false,
+        reasons: ["missing-pr-metadata"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+    if (hasExplicitPrEvidence && !pr) {
+      return {
+        valid: false,
+        reasons: ["missing-pr-evidence"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+    if (pr?.reviewState === "changes_requested") {
+      const ownershipMetadataIssue = inProgressOwnershipMetadataIssue(input.metadata);
+      if (ownershipMetadataIssue) {
+        return {
+          valid: false,
+          reasons: [ownershipMetadataIssue],
+          isStale,
+          wouldReconcileTo: "ready",
+          nextMetadata: null
+        };
+      }
+      return {
+        valid: true,
+        reasons,
+        isStale,
+        wouldReconcileTo: "in_progress",
+        nextMetadata: input.metadata ? {
+          ...input.metadata,
+          status: "in_progress",
+          lastEvidenceAt: nowIso,
+          reviewState: "changes_requested"
+        } : null
+      };
+    }
+    if (hasPrCloseoutCompletionEvidence(input.evidence)) {
+      return {
+        valid: true,
+        reasons,
+        isStale,
+        wouldReconcileTo: "completed",
+        nextMetadata: input.metadata ? {
+          ...input.metadata,
+          status: "completed",
+          lastEvidenceAt: nowIso,
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        } : null
+      };
+    }
+    if (pr && !pr.isOpen && !pr.isMerged) {
+      return {
+        valid: false,
+        reasons: ["closed-pr-without-merge"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+  }
+  if (input.lifecycleStatus === "completed" && pr?.isOpen && !hasPrCloseoutCompletionEvidence(input.evidence)) {
+    return {
+      valid: false,
+      reasons: ["completed-with-open-pr"],
+      isStale,
+      wouldReconcileTo: "under_review",
+      nextMetadata: {
+        ...input.metadata ?? { status: "under_review" },
+        status: "under_review",
+        lastEvidenceAt: nowIso,
+        ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+        ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+        ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+      }
+    };
+  }
+  if (pr?.isOpen && (input.lifecycleStatus === "draft" || input.lifecycleStatus === "open" || input.lifecycleStatus === "ready" || input.lifecycleStatus === "queued" || input.lifecycleStatus === "in_progress")) {
+    return {
+      valid: true,
+      reasons,
+      isStale,
+      wouldReconcileTo: "under_review",
+      nextMetadata: {
+        ...input.metadata ?? { status: "under_review" },
+        status: "under_review",
+        lastEvidenceAt: nowIso,
+        ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+        ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+        ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+      }
+    };
+  }
+  return {
+    valid: true,
+    reasons,
+    isStale,
+    wouldReconcileTo: null,
+    nextMetadata: input.metadata
+  };
+}
+
+// packages/runtime/src/control-plane/state-sync/write.ts
+var DEFAULT_WRITER_DEPS = {
+  fetchRef: nativeFetchRef,
+  readBlobAtRef: nativeReadBlobAtRef,
+  writeTreeCommit: nativeWriteTreeCommit,
+  pushRefWithLease: nativePushRefWithLease,
+  readSnapshot: readSyncedTrackerState,
+  createClaimId: () => `claim-${crypto.randomUUID()}`,
+  now: () => new Date().toISOString()
+};
+
+class TrackerStateMutationError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+}
+function parseIssuesJsonl2(raw) {
+  const rows = [];
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        rows.push(parsed);
+      }
+    } catch {}
+  }
+  return rows;
+}
+function parseRawTaskStateFile(raw) {
+  if (!raw || !raw.trim()) {
+    return {
+      schemaVersion: 1,
+      tasks: {}
+    };
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return {
+      schemaVersion: typeof parsed.schemaVersion === "number" ? parsed.schemaVersion : 1,
+      tasks: parsed.tasks && typeof parsed.tasks === "object" && !Array.isArray(parsed.tasks) ? parsed.tasks : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function parseTaskStateEnvelope2(raw, baseOid) {
+  if (!raw || !raw.trim()) {
+    return {
+      schemaVersion: 1,
+      supported: true,
+      baseTrackerCommit: baseOid,
+      tasks: {}
+    };
+  }
+  try {
+    const parsed = readTaskStateMetadataEnvelope(JSON.parse(raw));
+    return {
+      schemaVersion: parsed.supported ? parsed.schemaVersion : 1,
+      supported: true,
+      baseTrackerCommit: parsed.baseTrackerCommit ?? baseOid,
+      tasks: parsed.supported ? parsed.tasks : {}
+    };
+  } catch {
+    return {
+      schemaVersion: 1,
+      supported: true,
+      baseTrackerCommit: baseOid,
+      tasks: {}
+    };
+  }
+}
+function sanitizeTaskStateEnvelope(issueRows, envelope) {
+  const lifecycleByTaskId = new Map;
+  for (const row of issueRows) {
+    const taskId = typeof row.id === "string" ? row.id : null;
+    if (!taskId) {
+      continue;
+    }
+    lifecycleByTaskId.set(taskId, normalizeTaskLifecycleStatus(row.status));
+  }
+  return {
+    ...envelope,
+    tasks: Object.fromEntries(Object.entries(envelope.tasks).map(([taskId, metadata]) => [
+      taskId,
+      discardMismatchedTaskStateMetadata({
+        taskId,
+        lifecycleStatus: lifecycleByTaskId.get(taskId) ?? null,
+        metadata
+      })
+    ]).filter((entry) => entry[1] != null))
+  };
+}
+function serializeIssuesJsonl(rows) {
+  return `${rows.map((row) => JSON.stringify(row)).join(`
+`)}
+`;
+}
+function serializeTaskStateEnvelope(envelope) {
+  return `${JSON.stringify({
+    schemaVersion: envelope.schemaVersion,
+    baseTrackerCommit: envelope.baseTrackerCommit,
+    tasks: envelope.tasks
+  }, null, 2)}
+`;
+}
+function findIssueRowIndex(rows, taskId) {
+  return rows.findIndex((row) => typeof row.id === "string" && row.id === taskId);
+}
+function assertWritableTrackerStateBases(state) {
+  if (state.issuesBaseOid !== state.taskStateBaseOid) {
+    throw new TrackerStateMutationError("Tracker writes require issues.jsonl and task-state.json from the same remote base.", "same-base-required");
+  }
+}
+function readWritableTrackerState(projectRoot, deps) {
+  const repoPath = resolveTrackerRepoPath(projectRoot);
+  const baseOid = deps.fetchRef(repoPath, "origin", "main");
+  const issuesText = deps.readBlobAtRef(repoPath, baseOid, ".beads/issues.jsonl");
+  const taskStateText = (() => {
+    try {
+      return deps.readBlobAtRef(repoPath, baseOid, ".beads/task-state.json");
+    } catch {
+      return null;
+    }
+  })();
+  return {
+    repoPath,
+    baseOid,
+    issuesBaseOid: baseOid,
+    taskStateBaseOid: baseOid,
+    issueRows: parseIssuesJsonl2(issuesText),
+    taskStateEnvelope: sanitizeTaskStateEnvelope(parseIssuesJsonl2(issuesText), parseTaskStateEnvelope2(taskStateText, baseOid))
+  };
+}
+function cloneWritableState(state) {
+  return {
+    ...state,
+    issueRows: state.issueRows.map((row) => ({ ...row })),
+    taskStateEnvelope: {
+      ...state.taskStateEnvelope,
+      tasks: Object.fromEntries(Object.entries(state.taskStateEnvelope.tasks).map(([taskId, metadata]) => [taskId, { ...metadata }]))
+    }
+  };
+}
+function currentLifecycleStatus(state, taskId) {
+  const issueIndex = findIssueRowIndex(state.issueRows, taskId);
+  if (issueIndex === -1) {
+    throw new TrackerStateMutationError(`Task ${taskId} was not found in issues.jsonl.`, "task-not-found");
+  }
+  const status = normalizeTaskLifecycleStatus(state.issueRows[issueIndex]?.status);
+  if (!status) {
+    throw new TrackerStateMutationError(`Task ${taskId} has an invalid lifecycle status.`, "invalid-task-status");
+  }
+  return status;
+}
+function setLifecycleStatus(state, taskId, status) {
+  const issueIndex = findIssueRowIndex(state.issueRows, taskId);
+  if (issueIndex === -1) {
+    throw new TrackerStateMutationError(`Task ${taskId} was not found in issues.jsonl.`, "task-not-found");
+  }
+  state.issueRows[issueIndex] = {
+    ...state.issueRows[issueIndex],
+    status
+  };
+}
+function prepareClaimTaskMutation(state, input) {
+  assertWritableTrackerStateBases(state);
+  const next = cloneWritableState(state);
+  const lifecycleStatus = currentLifecycleStatus(next, input.taskId);
+  if (input.expectedStatus && lifecycleStatus !== input.expectedStatus) {
+    throw new TrackerStateMutationError(`Task ${input.taskId} is ${lifecycleStatus}, expected ${input.expectedStatus}.`, "claim-conflict");
+  }
+  if (lifecycleStatus !== "ready" && lifecycleStatus !== "queued") {
+    throw new TrackerStateMutationError(`Task ${input.taskId} cannot be claimed from ${lifecycleStatus}.`, "claim-conflict");
+  }
+  setLifecycleStatus(next, input.taskId, "in_progress");
+  next.taskStateEnvelope.baseTrackerCommit = next.baseOid;
+  next.taskStateEnvelope.tasks[input.taskId] = {
+    status: "in_progress",
+    claimId: input.claimId,
+    ownerId: input.ownerId,
+    claimedAt: input.now,
+    lastEvidenceAt: input.now,
+    ...input.runId ? { runId: input.runId } : {},
+    ...input.branchName ? { branchName: input.branchName } : {},
+    sourceCommit: next.baseOid
+  };
+  return next;
+}
+function prepareLifecycleTaskMutation(state, input) {
+  assertWritableTrackerStateBases(state);
+  const next = cloneWritableState(state);
+  const lifecycleStatus = currentLifecycleStatus(next, input.taskId);
+  if (input.allowedFrom && !input.allowedFrom.includes(lifecycleStatus)) {
+    throw new TrackerStateMutationError(`Task ${input.taskId} is ${lifecycleStatus}, expected one of ${input.allowedFrom.join(", ")}.`, "status-conflict");
+  }
+  setLifecycleStatus(next, input.taskId, input.status);
+  next.taskStateEnvelope.baseTrackerCommit = next.baseOid;
+  if (input.clearMetadata || input.metadata == null) {
+    delete next.taskStateEnvelope.tasks[input.taskId];
+  } else {
+    next.taskStateEnvelope.tasks[input.taskId] = input.metadata;
+  }
+  return next;
+}
+function prepareReconcileTaskMutation(state, input) {
+  assertWritableTrackerStateBases(state);
+  const next = cloneWritableState(state);
+  const lifecycleStatus = currentLifecycleStatus(next, input.taskId);
+  const projection = projectTaskReconciliation({
+    lifecycleStatus,
+    metadata: next.taskStateEnvelope.tasks[input.taskId] ?? null,
+    evidence: input.evidence
+  });
+  if (!projection.wouldReconcileTo) {
+    return null;
+  }
+  if (!projection.valid && projection.reasons.includes("multiple-active-owners")) {
+    throw new TrackerStateMutationError(`Task ${input.taskId} has multiple active owners.`, "invalid-reconciliation");
+  }
+  setLifecycleStatus(next, input.taskId, projection.wouldReconcileTo);
+  next.taskStateEnvelope.baseTrackerCommit = next.baseOid;
+  if (projection.nextMetadata) {
+    next.taskStateEnvelope.tasks[input.taskId] = projection.nextMetadata;
+  } else {
+    delete next.taskStateEnvelope.tasks[input.taskId];
+  }
+  return next;
+}
+function desiredTaskStateSatisfied(raw, desired) {
+  const issue = parseIssuesJsonl2(raw.issuesText).find((entry) => entry.id === desired.taskId);
+  if (!issue || issue.status !== desired.status) {
+    return false;
+  }
+  const rawTaskState = parseRawTaskStateFile(raw.taskStateText);
+  if (!rawTaskState || rawTaskState.schemaVersion !== 1) {
+    return false;
+  }
+  const rawMetadata = rawTaskState.tasks[desired.taskId] ?? null;
+  const snapshotMetadata = discardMismatchedTaskStateMetadata({
+    taskId: desired.taskId,
+    lifecycleStatus: desired.status,
+    metadata: rawMetadata
+  });
+  if (desired.metadata == null) {
+    return rawMetadata == null && snapshotMetadata == null;
+  }
+  if (rawMetadata == null || snapshotMetadata == null) {
+    return false;
+  }
+  return isDeepStrictEqual(snapshotMetadata ?? null, desired.metadata);
+}
+function persistTrackerState(projectRoot, state, desired, message, deps) {
+  const updates = [
+    { path: ".beads/issues.jsonl", content: serializeIssuesJsonl(state.issueRows) },
+    { path: ".beads/task-state.json", content: serializeTaskStateEnvelope(state.taskStateEnvelope) }
+  ];
+  const commitOid = deps.writeTreeCommit(state.repoPath, state.baseOid, updates, message);
+  try {
+    deps.pushRefWithLease(state.repoPath, commitOid, "refs/heads/main", state.baseOid);
+    return {
+      outcome: "applied",
+      snapshot: deps.readSnapshot(projectRoot),
+      commitOid
+    };
+  } catch (error) {
+    const latestBaseOid = deps.fetchRef(state.repoPath, "origin", "main");
+    const latestIssuesText = deps.readBlobAtRef(state.repoPath, latestBaseOid, ".beads/issues.jsonl");
+    const latestTaskStateText = (() => {
+      try {
+        return deps.readBlobAtRef(state.repoPath, latestBaseOid, ".beads/task-state.json");
+      } catch {
+        return null;
+      }
+    })();
+    const latestSnapshot = deps.readSnapshot(projectRoot);
+    if (desiredTaskStateSatisfied({
+      issuesText: latestIssuesText,
+      taskStateText: latestTaskStateText
+    }, desired)) {
+      return {
+        outcome: "noop",
+        snapshot: latestSnapshot,
+        commitOid: null
+      };
+    }
+    throw new TrackerStateMutationError(error instanceof Error ? error.message : String(error), "push-conflict");
+  }
+}
+function claimRemoteTrackerTask(projectRoot, input, deps = {}) {
+  const writerDeps = { ...DEFAULT_WRITER_DEPS, ...deps };
+  const claimId = writerDeps.createClaimId();
+  const nextState = prepareClaimTaskMutation(readWritableTrackerState(projectRoot, writerDeps), {
+    ...input,
+    now: writerDeps.now(),
+    claimId
+  });
+  const persisted = persistTrackerState(projectRoot, nextState, { taskId: input.taskId, status: "in_progress", metadata: nextState.taskStateEnvelope.tasks[input.taskId] ?? null }, `chore(tracker): claim ${input.taskId}`, writerDeps);
+  return {
+    ...persisted,
+    claimId
+  };
+}
+function reconcileRemoteTrackerTask(projectRoot, input, deps = {}) {
+  const writerDeps = { ...DEFAULT_WRITER_DEPS, ...deps };
+  const currentState = readWritableTrackerState(projectRoot, writerDeps);
+  const nextState = prepareReconcileTaskMutation(currentState, {
+    ...input,
+    evidence: {
+      ...input.evidence,
+      now: input.evidence?.now ?? writerDeps.now()
+    }
+  });
+  if (!nextState) {
+    return {
+      outcome: "noop",
+      snapshot: writerDeps.readSnapshot(projectRoot),
+      commitOid: null
+    };
+  }
+  const nextStatus = currentLifecycleStatus(nextState, input.taskId);
+  return persistTrackerState(projectRoot, nextState, { taskId: input.taskId, status: nextStatus, metadata: nextState.taskStateEnvelope.tasks[input.taskId] ?? null }, `chore(tracker): reconcile ${input.taskId}`, writerDeps);
+}
+function updateRemoteTrackerTaskLifecycle(projectRoot, input, deps = {}) {
+  const writerDeps = { ...DEFAULT_WRITER_DEPS, ...deps };
+  const nextState = prepareLifecycleTaskMutation(readWritableTrackerState(projectRoot, writerDeps), input);
+  return persistTrackerState(projectRoot, nextState, { taskId: input.taskId, status: input.status, metadata: input.clearMetadata ? null : nextState.taskStateEnvelope.tasks[input.taskId] ?? null }, `chore(tracker): ${input.reason ?? "update"} ${input.taskId} -> ${input.status}`, writerDeps);
+}
+export {
+  updateRemoteTrackerTaskLifecycle,
+  reconcileRemoteTrackerTask,
+  prepareReconcileTaskMutation,
+  prepareLifecycleTaskMutation,
+  prepareClaimTaskMutation,
+  claimRemoteTrackerTask,
+  assertWritableTrackerStateBases,
+  TrackerStateMutationError
+};