@h-rig/runtime 0.0.6-alpha.0

package/dist/src/control-plane/native/workspace-ops.js

@@ -0,0 +1,1635 @@
+// @bun
+// packages/runtime/src/control-plane/native/workspace-ops.ts
+import { spawn } from "child_process";
+import {
+  appendFileSync as appendFileSync2,
+  closeSync,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  openSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  statSync as statSync3,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { join as join3, resolve as resolve8 } from "path";
+
+// packages/runtime/src/control-plane/authority-files.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync, appendFileSync, copyFileSync, statSync, readdirSync, chmodSync } from "fs";
+import { dirname as dirname2, join, relative, resolve as resolve2 } from "path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+
+// packages/runtime/src/layout.ts
+import { existsSync } from "fs";
+import { basename, dirname, resolve } from "path";
+function resolveMonorepoRoot(projectRoot) {
+  const normalizedProjectRoot = resolve(projectRoot);
+  const explicit = process.env.MONOREPO_ROOT?.trim();
+  if (explicit) {
+    const explicitRoot = resolve(explicit);
+    const explicitParent = dirname(explicitRoot);
+    if (basename(explicitParent) === ".worktrees") {
+      const owner = dirname(explicitParent);
+      const ownerHasGit = existsSync(resolve(owner, ".git"));
+      const ownerHasTaskConfig = existsSync(resolve(owner, ".rig", "task-config.json"));
+      const ownerHasRigConfig = existsSync(resolve(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 (!existsSync(resolve(explicitRoot, ".git"))) {
+      throw new Error(`MONOREPO_ROOT points to ${explicitRoot}, but no git checkout was found there.`);
+    }
+    const hasTaskConfig = existsSync(resolve(explicitRoot, ".rig", "task-config.json"));
+    const hasRigConfig = existsSync(resolve(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 = dirname(normalizedProjectRoot);
+  if (basename(projectParent) === ".worktrees") {
+    const worktreeOwner = dirname(projectParent);
+    const ownerHasGit = existsSync(resolve(worktreeOwner, ".git"));
+    const ownerHasTaskConfig = existsSync(resolve(worktreeOwner, ".rig", "task-config.json"));
+    const ownerHasRigConfig = existsSync(resolve(worktreeOwner, "rig.config.ts"));
+    if (ownerHasGit && (ownerHasTaskConfig || ownerHasRigConfig)) {
+      return worktreeOwner;
+    }
+  }
+  return normalizedProjectRoot;
+}
+
+// packages/runtime/src/control-plane/authority-files.ts
+function normalizeString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resolveAuthorityStateRoot(projectRoot) {
+  const normalizedRoot = resolve2(projectRoot);
+  const taskWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (taskWorkspace) {
+    return resolve2(taskWorkspace, ".rig");
+  }
+  const stateDir = process.env.RIG_STATE_DIR?.trim();
+  if (stateDir) {
+    return dirname2(resolve2(stateDir));
+  }
+  const logsDir = process.env.RIG_LOGS_DIR?.trim();
+  if (logsDir) {
+    return dirname2(resolve2(logsDir));
+  }
+  const sessionFile = process.env.RIG_SESSION_FILE?.trim();
+  if (sessionFile) {
+    return dirname2(dirname2(resolve2(sessionFile)));
+  }
+  const projectStateRoot = resolve2(normalizedRoot, ".rig");
+  if (existsSync2(projectStateRoot)) {
+    return projectStateRoot;
+  }
+  return resolve2(normalizedRoot, ".rig");
+}
+function resolveAuthorityArtifactsRoot(projectRoot) {
+  const explicit = process.env.ARTIFACTS_DIR?.trim();
+  if (explicit) {
+    return resolve2(explicit);
+  }
+  const projectArtifactsRoot = resolve2(projectRoot, "artifacts");
+  if (existsSync2(projectArtifactsRoot)) {
+    return projectArtifactsRoot;
+  }
+  const taskWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  if (taskWorkspace) {
+    return resolve2(taskWorkspace, "artifacts");
+  }
+  if (process.env.MONOREPO_ROOT?.trim()) {
+    return resolve2(resolveMonorepoRoot(projectRoot), "artifacts");
+  }
+  const normalizedRoot = resolve2(projectRoot);
+  const projectLooksLikeMonorepo = existsSync2(resolve2(normalizedRoot, ".git")) && existsSync2(resolve2(normalizedRoot, ".rig", "task-config.json"));
+  if (!projectLooksLikeMonorepo) {
+    return projectArtifactsRoot;
+  }
+  return resolve2(resolveMonorepoRoot(projectRoot), "artifacts");
+}
+function uniquePaths(paths) {
+  const seen = new Set;
+  const result = [];
+  for (const value of paths) {
+    const normalized = normalizeString(value);
+    if (!normalized || seen.has(normalized))
+      continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+function listAuthorityRunRoots(projectRoot) {
+  const normalizedRoot = resolve2(projectRoot);
+  const monorepoRoot = resolveMonorepoRoot(normalizedRoot);
+  return uniquePaths([
+    resolve2(resolveAuthorityStateRoot(normalizedRoot), "runs"),
+    resolve2(monorepoRoot, ".rig", "runs")
+  ]);
+}
+function listAuthorityArtifactRoots(projectRoot) {
+  return uniquePaths([
+    resolveAuthorityArtifactsRoot(projectRoot)
+  ]);
+}
+function readJsonFile(path, fallback) {
+  if (!existsSync2(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function listAuthorityRuns(projectRoot) {
+  const runs = new Map;
+  for (const runsDir of listAuthorityRunRoots(projectRoot)) {
+    if (!existsSync2(runsDir))
+      continue;
+    for (const runId of readDirRuns(runsDir)) {
+      if (runs.has(runId))
+        continue;
+      const entry = readJsonFile(resolve2(runsDir, runId, "run.json"), null);
+      if (entry && runBelongsToProject(projectRoot, entry, runsDir)) {
+        runs.set(runId, entry);
+      }
+    }
+  }
+  return [...runs.values()].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+function runBelongsToProject(projectRoot, run, runsDir) {
+  const normalizedRoot = resolve2(projectRoot);
+  const record = run;
+  const recordedProjectRoot = normalizeString(record.projectRoot);
+  if (recordedProjectRoot) {
+    return resolve2(recordedProjectRoot) === normalizedRoot;
+  }
+  const projectLocalRunsDir = resolve2(normalizedRoot, ".rig", "runs");
+  if (isPathWithin(projectLocalRunsDir, resolve2(runsDir))) {
+    return true;
+  }
+  const pathFields = [
+    run.worktreePath,
+    run.artifactRoot,
+    run.logRoot,
+    run.sessionPath,
+    run.sessionLogPath
+  ].filter((value) => typeof value === "string" && value.trim().length > 0);
+  if (pathFields.length === 0) {
+    return true;
+  }
+  return pathFields.some((value) => isPathWithin(normalizedRoot, resolve2(value)));
+}
+function isPathWithin(root, candidate) {
+  const relativePath = relative(root, candidate);
+  return relativePath === "" || !relativePath.startsWith("..") && !relativePath.startsWith(`/`) && !relativePath.startsWith(`\\`);
+}
+function readDirRuns(runsDir) {
+  try {
+    return readdirSync(runsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+function resolveTaskArtifactDirs(projectRoot, taskId) {
+  const candidates = [];
+  const seen = new Set;
+  const add = (value) => {
+    const normalized = normalizeString(value);
+    if (!normalized || seen.has(normalized))
+      return;
+    seen.add(normalized);
+    candidates.push(normalized);
+  };
+  for (const run of listAuthorityRuns(projectRoot)) {
+    if (run.taskId !== taskId)
+      continue;
+    add(run.artifactRoot);
+    if (run.worktreePath) {
+      add(resolve2(run.worktreePath, "artifacts", taskId));
+    }
+  }
+  for (const artifactsRoot of listAuthorityArtifactRoots(projectRoot)) {
+    add(resolve2(artifactsRoot, taskId));
+  }
+  return candidates;
+}
+
+// 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 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
+import { existsSync as existsSync7, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve7 } from "path";
+
+// packages/runtime/src/control-plane/native/git-native.ts
+import { chmodSync as chmodSync2, copyFileSync as copyFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname3, isAbsolute, resolve as resolve3 } from "path";
+import { createHash } from "crypto";
+var sharedGitNativeOutputDir = resolve3(tmpdir(), "rig-native");
+var sharedGitNativeOutputPath = resolve3(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 resolve3(dirname3(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" && existsSync3(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() ? dirname3(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 = resolve3(import.meta.dir, "../../../native/rig-git.zig");
+  return [...new Set([
+    process.env.RIG_NATIVE_GIT_SOURCE?.trim() || "",
+    moduleRelativeSource,
+    projectRoot ? resolve3(projectRoot, "packages/runtime/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve3(hostProjectRoot, "packages/runtime/native/rig-git.zig") : "",
+    cwd ? resolve3(cwd, "packages/runtime/native/rig-git.zig") : "",
+    execDir ? resolve3(execDir, "..", "..", "packages/runtime/native/rig-git.zig") : "",
+    execDir ? resolve3(execDir, "..", "native", "rig-git.zig") : ""
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve3(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve3(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve3(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve3(cursor, "native", fileName), resolve3(cursor, "native", "bin", fileName));
+    const parent = dirname3(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function rigGitBinaryCandidates() {
+  const execDir = process.execPath?.trim() ? dirname3(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 ? resolve3(execDir, fileName) : "",
+    execDir ? resolve3(execDir, "..", fileName) : "",
+    execDir ? resolve3(execDir, "..", "bin", fileName) : "",
+    sharedGitNativeOutputPath
+  ].filter(Boolean))];
+}
+function resolveGitSourcePath() {
+  for (const candidate of rigGitSourceCandidates()) {
+    if (candidate && existsSync3(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveGitBinaryPath() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  for (const candidate of rigGitBinaryCandidates()) {
+    if (candidate && existsSync3(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 (!existsSync3(manifestPath)) {
+    return false;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+    return manifest.version === 1 && manifest.buildKey === buildKey;
+  } catch {
+    return false;
+  }
+}
+function sha256FileSync(path) {
+  return createHash("sha256").update(readFileSync2(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.");
+  }
+  mkdirSync2(dirname3(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 = !existsSync3(outputPath) || !hasMatchingNativeBuildManifestSync(manifestPath, buildKey) || !binarySupportsTrackerCommandsSync(outputPath);
+  if (!needsBuild) {
+    chmodSync2(outputPath, 493);
+    return outputPath;
+  }
+  const tempOutputPath = temporaryGitBinaryOutputPath(outputPath);
+  const build = Bun.spawnSync([
+    zigBinary,
+    "build-exe",
+    sourcePath,
+    "-O",
+    "ReleaseFast",
+    `-femit-bin=${tempOutputPath}`
+  ], {
+    cwd: dirname3(sourcePath),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (build.exitCode !== 0 || !existsSync3(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}`}`);
+  }
+  chmodSync2(tempOutputPath, 493);
+  if (existsSync3(outputPath) && hasMatchingNativeBuildManifestSync(manifestPath, buildKey)) {
+    rmSync(tempOutputPath, { force: true });
+    chmodSync2(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");
+  }
+  writeFileSync2(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 && existsSync3(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 = resolve3(sharedGitNativeOutputDir, "reads", `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync2(requestDir, { recursive: true });
+  const outputPath = resolve3(requestDir, "blob.txt");
+  try {
+    requireGitNative("read-blob-at-ref", [repoPath, ref, path, outputPath]);
+    return readFileSync2(outputPath, "utf8");
+  } finally {
+    rmSync(requestDir, { recursive: true, force: true });
+  }
+}
+
+// packages/runtime/src/control-plane/native/runtime-native.ts
+import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
+import { copyFileSync as copyFileSync3, existsSync as existsSync4, mkdirSync as mkdirSync3, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname4, resolve as resolve4 } from "path";
+var sharedNativeRuntimeOutputDir = resolve4(tmpdir2(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve4(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 && existsSync4(outputPath) ? outputPath : null;
+}
+async function loadNativeRuntimeLibrary() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  for (const candidate of nativeRuntimeLibraryCandidates()) {
+    if (!candidate || !existsSync4(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 = resolve4(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    for (const name of names) {
+      candidates.push(resolve4(cursor, "native", `${process.platform}-${process.arch}`, name), resolve4(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve4(cursor, "native", name), resolve4(cursor, "native", "lib", name));
+    }
+    const parent = dirname4(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() ? dirname4(process.execPath.trim()) : "";
+  const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
+  return [...new Set([
+    explicit,
+    ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
+    execDir ? resolve4(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve4(execDir, platformSpecific) : "",
+    execDir ? resolve4(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve4(execDir, "..", platformSpecific) : "",
+    execDir ? resolve4(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve4(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    sharedNativeRuntimeOutputPath
+  ].filter(Boolean))];
+}
+function resolveNativeRuntimeSourcePath() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
+  if (explicit && existsSync4(explicit)) {
+    return explicit;
+  }
+  const bundled = resolve4(import.meta.dir, "../../../native/snapshot.zig");
+  return existsSync4(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 {
+    mkdirSync3(dirname4(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync4(outputPath) || statSync2(sourcePath).mtimeMs > statSync2(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 || !existsSync4(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 existsSync6 } from "fs";
+import { resolve as resolve6 } from "path";
+
+// packages/runtime/src/control-plane/repos/layout.ts
+import { existsSync as existsSync5 } from "fs";
+import { basename as basename2, dirname as dirname5, join as join2, resolve as resolve5 } 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 = resolve5(projectRoot);
+  const projectParent = dirname5(normalizedProjectRoot);
+  if (basename2(projectParent) === ".worktrees") {
+    const ownerRoot = dirname5(projectParent);
+    const ownerHasRepoMarkers = existsSync5(resolve5(ownerRoot, ".git")) || existsSync5(resolve5(ownerRoot, ".rig", "state"));
+    if (ownerHasRepoMarkers) {
+      return resolve5(ownerRoot, ".rig", "state");
+    }
+  }
+  return resolve5(projectRoot, ".rig", "state");
+}
+function resolveManagedRepoLayout(projectRoot, repoId) {
+  const normalizedProjectRoot = resolve5(projectRoot);
+  const entry = getManagedRepoEntry(repoId);
+  const stateDir = resolveRepoStateDir(normalizedProjectRoot);
+  const metadataRelativePath = join2("repos", entry.id);
+  const metadataRoot = resolve5(stateDir, metadataRelativePath);
+  const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  const runsInsideTaskWorktree = runtimeWorkspace && resolve5(runtimeWorkspace) === normalizedProjectRoot || basename2(dirname5(normalizedProjectRoot)) === ".worktrees";
+  const isPrimaryManagedRepo = listManagedRepoEntries()[0]?.id === repoId;
+  const checkoutRoot = isPrimaryManagedRepo && runsInsideTaskWorktree ? resolveMonorepoRoot(normalizedProjectRoot) : entry.checkoutEnvVar && process.env[entry.checkoutEnvVar]?.trim() ? resolve5(process.env[entry.checkoutEnvVar].trim()) : resolve5(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: resolve5(checkoutRoot, ".worktrees"),
+    stateDir,
+    metadataRoot,
+    metadataRelativePath,
+    mirrorRoot: resolve5(metadataRoot, "mirror.git"),
+    mirrorStatePath: resolve5(metadataRoot, "mirror-state.json"),
+    mirrorStateRelativePath: join2(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 (existsSync6(resolve6(layout.mirrorRoot, "HEAD"))) {
+      return layout.mirrorRoot;
+    }
+  } catch {}
+  return monorepoRoot;
+}
+
+// packages/runtime/src/control-plane/state-sync/read.ts
+var DEFAULT_READ_DEPS = {
+  fetchRef: nativeFetchRef,
+  readBlobAtRef: nativeReadBlobAtRef,
+  exists: existsSync7,
+  readFile: (path) => readFileSync3(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 existsSync7(resolve7(runtimeWorkspace, ".rig", "runtime-context.json"));
+}
+function readLocalTrackerState(projectRoot, deps) {
+  const monorepoRoot = resolveMonorepoRoot2(projectRoot);
+  const issuesPath = resolve7(monorepoRoot, ".beads", "issues.jsonl");
+  const taskStatePath = resolve7(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;
+// packages/runtime/src/control-plane/native/workspace-ops.ts
+var ONLINE_REMOTE_HOST_STATUSES = new Set(["ready", "busy", "degraded", "draining"]);
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function asStringArray(value) {
+  return Array.isArray(value) ? value.flatMap((entry) => typeof entry === "string" && entry.trim().length > 0 ? [entry.trim()] : []) : [];
+}
+function asStringMap(value) {
+  const record = asRecord(value);
+  if (!record) {
+    return {};
+  }
+  const entries = Object.entries(record).flatMap(([key, entry]) => {
+    if (typeof entry === "string" && entry.trim().length > 0) {
+      return [[key, entry]];
+    }
+    if (typeof entry === "number" || typeof entry === "boolean") {
+      return [[key, String(entry)]];
+    }
+    return [];
+  });
+  return Object.fromEntries(entries);
+}
+function parseScalar(raw) {
+  const value = raw.trim();
+  if (value.length === 0)
+    return "";
+  if (value === "null")
+    return null;
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (/^-?\d+$/.test(value))
+    return Number.parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value))
+    return Number.parseFloat(value);
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseYamlSubset(source) {
+  const lines = source.split(/\r?\n/).map((line) => line.replace(/\t/g, "  ")).filter((line) => line.trim().length > 0 && !line.trimStart().startsWith("#"));
+  const root = {};
+  const stack = [
+    { indent: -1, value: root }
+  ];
+  const ensureContainer = (indent) => {
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    return stack[stack.length - 1];
+  };
+  for (let index = 0;index < lines.length; index += 1) {
+    const rawLine = lines[index];
+    const indent = rawLine.match(/^ */)?.[0].length ?? 0;
+    const line = rawLine.trim();
+    const parent = ensureContainer(indent);
+    if (line.startsWith("- ")) {
+      const itemContent = line.slice(2);
+      if (!Array.isArray(parent.value)) {
+        continue;
+      }
+      if (itemContent.includes(":")) {
+        const [firstKey, ...rest] = itemContent.split(":");
+        const valueText2 = rest.join(":").trim();
+        const entry = {};
+        entry[firstKey.trim()] = valueText2.length > 0 ? parseScalar(valueText2) : "";
+        parent.value.push(entry);
+        stack.push({ indent, value: entry });
+      } else {
+        parent.value.push(parseScalar(itemContent));
+      }
+      continue;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1 || !asRecord(parent.value)) {
+      continue;
+    }
+    const key = line.slice(0, colonIndex).trim();
+    const valueText = line.slice(colonIndex + 1).trim();
+    const parentRecord = parent.value;
+    if (valueText.length > 0) {
+      parentRecord[key] = parseScalar(valueText);
+      continue;
+    }
+    const nextLine = lines[index + 1]?.trim() ?? "";
+    const container = nextLine.startsWith("- ") ? [] : {};
+    parentRecord[key] = container;
+    stack.push({ indent, value: container });
+  }
+  return root;
+}
+function relativePath(rootPath, targetPath) {
+  return targetPath.startsWith(rootPath) ? targetPath.slice(rootPath.length + 1) || "." : targetPath;
+}
+function resolveRuntimeWorkspaceRoot(projectRoot) {
+  return resolve8(process.env.RIG_TASK_WORKSPACE?.trim() || projectRoot);
+}
+function resolveServiceFabricPaths(projectRoot) {
+  const workspaceRoot = resolveRuntimeWorkspaceRoot(projectRoot);
+  const fabricRoot = resolve8(workspaceRoot, ".rig", "service-fabric");
+  return {
+    workspaceRoot,
+    fabricRoot,
+    statePath: resolve8(fabricRoot, "fabric-state.json"),
+    logsDir: resolve8(fabricRoot, "logs")
+  };
+}
+function issueStatus(status) {
+  switch (status) {
+    case "ready":
+    case "open":
+    case "queued":
+    case "blocked":
+    case "completed":
+    case "draft":
+    case "cancelled":
+      return status;
+    case "in_progress":
+    case "under_review":
+      return "running";
+    case "unknown":
+      return "unknown";
+  }
+}
+function collectTaskCounts(projectRoot) {
+  const initial = {
+    total: 0,
+    ready: 0,
+    open: 0,
+    queued: 0,
+    running: 0,
+    blocked: 0,
+    failed: 0,
+    unknown: 0,
+    completed: 0,
+    draft: 0,
+    cancelled: 0
+  };
+  const snapshot = readSyncedTrackerState(projectRoot, {}, { allowLocalFallback: true });
+  for (const issue of snapshot.issues) {
+    if (!issue.id.startsWith("bd-"))
+      continue;
+    if (issue.issueType === "epic")
+      continue;
+    initial.total += 1;
+    initial[issueStatus(issue.status)] += 1;
+  }
+  return initial;
+}
+function listManifestDirs(rootPath) {
+  const candidates = [join3(rootPath, "microservices")];
+  const discovered = new Set;
+  for (const candidate of candidates) {
+    if (!existsSync8(candidate))
+      continue;
+    for (const entry of readdirSync2(candidate, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith("_"))
+        continue;
+      const serviceDir = join3(candidate, entry.name);
+      if (existsSync8(join3(serviceDir, "service.yaml"))) {
+        discovered.add(serviceDir);
+      }
+    }
+  }
+  return [...discovered].sort((left, right) => left.localeCompare(right));
+}
+function parsePortValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Number(value);
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  return 0;
+}
+function resolveMonorepoWorkspaceRoot(projectRoot) {
+  return resolve8(process.env.MONOREPO_ROOT?.trim() || projectRoot);
+}
+function resolveLocalWorkingDir(monorepoRoot, serviceDir, rawWorkingDir) {
+  if (!rawWorkingDir) {
+    return serviceDir;
+  }
+  if (rawWorkingDir.startsWith("/")) {
+    return rawWorkingDir;
+  }
+  if (rawWorkingDir.startsWith(".")) {
+    return resolve8(serviceDir, rawWorkingDir);
+  }
+  return resolve8(monorepoRoot, rawWorkingDir);
+}
+function readNativeServicePlans(projectRoot, selectedServices = []) {
+  const manifestDirs = listManifestDirs(projectRoot);
+  const warnings = [];
+  const services = [];
+  const monorepoRoot = resolveMonorepoWorkspaceRoot(projectRoot);
+  for (const serviceDir of manifestDirs) {
+    const manifestPath = join3(serviceDir, "service.yaml");
+    try {
+      const parsed = asRecord(parseYamlSubset(readFileSync4(manifestPath, "utf-8")));
+      const name = asString(parsed?.name) ?? serviceDir.split("/").at(-1) ?? "service";
+      if (selectedServices.length > 0 && !selectedServices.includes(name)) {
+        continue;
+      }
+      const localDev = asRecord(parsed?.local_dev);
+      const runtime = asString(parsed?.runtime) ?? "unknown";
+      const healthcheck = asString(parsed?.healthcheck) ?? "/health";
+      const routePrefix = asString(localDev?.route_prefix);
+      const command = asString(localDev?.command);
+      const requestedMode = asString(localDev?.mode);
+      const environment = asStringMap(localDev?.env);
+      const port = parsePortValue(environment.PORT) || parsePortValue(environment.HTTP_PORT) || parsePortValue(parsed?.port) || 0;
+      const workingDir = resolveLocalWorkingDir(monorepoRoot, serviceDir, asString(localDev?.working_dir));
+      const readinessPath = asString(localDev?.readiness_path) ?? healthcheck;
+      let mode = requestedMode === "process" || requestedMode !== "stub" && command ? "process" : "stub";
+      if (requestedMode === "proxy" && !command) {
+        warnings.push(`${relativePath(projectRoot, manifestPath)} declares local_dev.mode=proxy without a command; treating it as a stub`);
+        mode = "stub";
+      }
+      if (mode === "process" && !command) {
+        warnings.push(`${relativePath(projectRoot, manifestPath)} declares process local_dev mode without a command; treating it as a stub`);
+        mode = "stub";
+      }
+      services.push({
+        name,
+        relativeRootPath: relativePath(projectRoot, serviceDir),
+        absoluteRootPath: serviceDir,
+        runtime,
+        port,
+        healthcheck,
+        routePrefix,
+        mode,
+        command: mode === "process" ? command : null,
+        workingDir,
+        environment,
+        readinessPath
+      });
+    } catch (error) {
+      warnings.push(`Failed to parse ${relativePath(projectRoot, manifestPath)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { services, warnings };
+}
+function readPersistedFabricState(projectRoot) {
+  const { statePath } = resolveServiceFabricPaths(projectRoot);
+  if (!existsSync8(statePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(readFileSync4(statePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writePersistedFabricState(projectRoot, state) {
+  const { fabricRoot, logsDir, statePath } = resolveServiceFabricPaths(projectRoot);
+  mkdirSync4(fabricRoot, { recursive: true });
+  mkdirSync4(logsDir, { recursive: true });
+  writeFileSync3(statePath, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+}
+function isProcessRunning(pid) {
+  if (!pid || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stopProcess(pid) {
+  if (!pid || pid <= 0) {
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    if (!isProcessRunning(pid)) {
+      return;
+    }
+    await Bun.sleep(100);
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {}
+}
+async function probeReadiness(service, timeoutMs = 1000) {
+  if (service.mode === "stub") {
+    return true;
+  }
+  if (!isProcessRunning(service.pid) || service.port <= 0) {
+    return false;
+  }
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`http://127.0.0.1:${service.port}${service.readinessPath}`, {
+      signal: controller.signal
+    });
+    return response.ok;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function waitForServiceHealthy(service, timeoutMs = 30000) {
+  if (service.mode === "stub") {
+    return true;
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await probeReadiness(service, 1000)) {
+      return true;
+    }
+    if (!isProcessRunning(service.pid)) {
+      return false;
+    }
+    await Bun.sleep(250);
+  }
+  return false;
+}
+function materializeStateFromPlans(projectRoot, plans, persisted) {
+  const persistedByName = new Map((persisted?.services ?? []).map((service) => [service.name, service]));
+  const { logsDir } = resolveServiceFabricPaths(projectRoot);
+  return plans.map((plan) => {
+    const previous = persistedByName.get(plan.name);
+    return {
+      ...plan,
+      pid: previous?.pid ?? null,
+      logPath: previous?.logPath ?? resolve8(logsDir, `${plan.name}.log`),
+      status: previous?.status ?? "stopped"
+    };
+  });
+}
+function summarizeFabricState(projectRoot, services, warnings, updatedAt) {
+  const { fabricRoot } = resolveServiceFabricPaths(projectRoot);
+  const healthyServiceCount = services.filter((service) => service.status === "healthy").length;
+  const status = services.length === 0 ? "empty" : services.every((service) => service.status === "stopped") ? "stopped" : services.every((service) => service.status === "healthy") ? "ready" : services.some((service) => service.status === "booting") ? "booting" : "degraded";
+  return {
+    updatedAt,
+    status,
+    serviceCount: services.length,
+    healthyServiceCount,
+    stateDir: fabricRoot,
+    services: services.map((service) => ({
+      name: service.name,
+      relativeRootPath: service.relativeRootPath,
+      absoluteRootPath: service.absoluteRootPath,
+      mode: service.mode,
+      port: service.port,
+      healthcheck: service.healthcheck,
+      routePrefix: service.routePrefix,
+      command: service.command,
+      environment: service.environment,
+      status: service.status,
+      pid: service.pid,
+      logPath: service.logPath
+    })),
+    warnings
+  };
+}
+function readWorkspaceTopology(projectRoot, compiledAt = new Date().toISOString()) {
+  const manifestDirs = listManifestDirs(projectRoot);
+  const warnings = [];
+  const services = [];
+  for (const serviceDir of manifestDirs) {
+    const manifestPath = join3(serviceDir, "service.yaml");
+    try {
+      const parsed = asRecord(parseYamlSubset(readFileSync4(manifestPath, "utf-8")));
+      const name = asString(parsed?.name) ?? serviceDir.split("/").at(-1) ?? "service";
+      const runtime = asString(parsed?.runtime) ?? "unknown";
+      const portValue = typeof parsed?.port === "number" ? parsed.port : typeof parsed?.port === "string" ? Number(parsed.port) : NaN;
+      services.push({
+        name,
+        relativeRootPath: relativePath(projectRoot, serviceDir),
+        runtime,
+        port: Number.isFinite(portValue) ? Number(portValue) : null,
+        healthcheck: asString(parsed?.healthcheck),
+        splitReadyChecklist: asStringArray(parsed?.split_ready_checklist)
+      });
+    } catch (error) {
+      warnings.push(`Failed to parse ${relativePath(projectRoot, manifestPath)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return {
+    compiledAt,
+    status: services.length === 0 ? "empty" : warnings.length > 0 ? "degraded" : "ready",
+    manifestCount: manifestDirs.length,
+    serviceCount: services.length,
+    services,
+    warnings
+  };
+}
+function discoverRemoteHostManifests(projectRoot) {
+  const workspaceRoot = resolveRuntimeWorkspaceRoot(projectRoot);
+  return [
+    join3(projectRoot, "rig.remote-hosts.yaml"),
+    resolve8(workspaceRoot, ".rig", "remote-hosts.yaml")
+  ].filter((candidate) => existsSync8(candidate));
+}
+function readWorkspaceRemoteFleet(projectRoot, updatedAt = new Date().toISOString()) {
+  const manifestPaths = discoverRemoteHostManifests(projectRoot);
+  const warnings = [];
+  const hostsById = new Map;
+  for (const manifestPath of manifestPaths) {
+    try {
+      const parsed = asRecord(parseYamlSubset(readFileSync4(manifestPath, "utf-8")));
+      const hosts2 = Array.isArray(parsed?.hosts) ? parsed.hosts : [];
+      for (const entry of hosts2) {
+        const host = asRecord(entry);
+        const id = asString(host?.id);
+        const name = asString(host?.name);
+        const baseUrl = asString(host?.base_url);
+        if (!id || !name || !baseUrl) {
+          warnings.push(`Skipped invalid remote host entry in ${relativePath(projectRoot, manifestPath)}`);
+          continue;
+        }
+        hostsById.set(id, {
+          id,
+          name,
+          baseUrl,
+          workspacePath: asString(host?.workspace_path),
+          transport: asString(host?.transport) ?? "websocket",
+          hostname: asString(host?.hostname),
+          region: asString(host?.region),
+          labels: asStringArray(host?.labels),
+          capabilities: asStringArray(host?.capabilities),
+          runtimeAdapters: asStringArray(host?.runtime_adapters),
+          status: asString(host?.status) ?? "offline",
+          currentLeaseCount: typeof host?.current_lease_count === "number" ? Number(host.current_lease_count) : 0,
+          manifestPath: relativePath(projectRoot, manifestPath)
+        });
+      }
+    } catch (error) {
+      warnings.push(`Failed to parse ${relativePath(projectRoot, manifestPath)}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const hosts = [...hostsById.values()].sort((left, right) => left.name.localeCompare(right.name));
+  const onlineHostCount = hosts.filter((host) => ONLINE_REMOTE_HOST_STATUSES.has(host.status)).length;
+  return {
+    updatedAt,
+    status: hosts.length === 0 ? "empty" : warnings.length > 0 || hosts.some((host) => host.status === "degraded" || host.status === "quarantined") ? "degraded" : onlineHostCount > 0 ? "ready" : "degraded",
+    manifestCount: manifestPaths.length,
+    hostCount: hosts.length,
+    onlineHostCount,
+    hosts,
+    warnings
+  };
+}
+async function readWorkspaceServiceFabric(projectRoot) {
+  try {
+    const updatedAt = new Date().toISOString();
+    const persisted = readPersistedFabricState(projectRoot);
+    const plans = readNativeServicePlans(projectRoot);
+    const services = materializeStateFromPlans(projectRoot, plans.services, persisted);
+    for (const service of services) {
+      if (service.status === "stopped") {
+        continue;
+      }
+      if (!isProcessRunning(service.pid)) {
+        service.pid = null;
+        service.status = "stopped";
+        continue;
+      }
+      service.status = await probeReadiness(service, 1000) ? "healthy" : "degraded";
+    }
+    const state = {
+      updatedAt,
+      rootPath: projectRoot,
+      services
+    };
+    writePersistedFabricState(projectRoot, state);
+    return summarizeFabricState(projectRoot, services, plans.warnings, updatedAt);
+  } catch (error) {
+    return {
+      status: "unavailable",
+      warnings: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+}
+async function mutateWorkspaceServiceFabric(projectRoot, command, services = []) {
+  const updatedAt = new Date().toISOString();
+  const persisted = readPersistedFabricState(projectRoot);
+  const plans = readNativeServicePlans(projectRoot, services);
+  const stateServices = materializeStateFromPlans(projectRoot, plans.services, persisted);
+  if (command === "verify") {
+    for (const service of stateServices) {
+      if (service.status === "stopped") {
+        continue;
+      }
+      if (!isProcessRunning(service.pid)) {
+        service.pid = null;
+        service.status = "stopped";
+        continue;
+      }
+      service.status = await probeReadiness(service, 1000) ? "healthy" : "degraded";
+    }
+  } else if (command === "up") {
+    const { logsDir } = resolveServiceFabricPaths(projectRoot);
+    mkdirSync4(logsDir, { recursive: true });
+    for (const service of stateServices) {
+      if (service.mode === "stub") {
+        service.pid = null;
+        service.status = "healthy";
+        continue;
+      }
+      if (isProcessRunning(service.pid) && await probeReadiness(service, 1000)) {
+        service.status = "healthy";
+        continue;
+      }
+      if (isProcessRunning(service.pid)) {
+        await stopProcess(service.pid);
+      }
+      const logPath = resolve8(logsDir, `${service.name}.log`);
+      service.logPath = logPath;
+      appendFileSync2(logPath, `
+=== ${updatedAt} :: rig service-fabric up :: ${service.name} ===
+`, "utf-8");
+      const logFd = openSync(logPath, "a");
+      try {
+        const child = spawn(service.command || "true", {
+          cwd: service.workingDir,
+          env: { ...process.env, ...service.environment },
+          shell: true,
+          detached: true,
+          stdio: ["ignore", logFd, logFd]
+        });
+        child.unref();
+        service.pid = child.pid ?? null;
+        service.status = "booting";
+      } finally {
+        closeSync(logFd);
+      }
+      service.status = await waitForServiceHealthy(service) ? "healthy" : "degraded";
+      if (service.status !== "healthy" && !isProcessRunning(service.pid)) {
+        service.pid = null;
+        service.status = "failed";
+      }
+    }
+  } else if (command === "down") {
+    for (const service of stateServices) {
+      await stopProcess(service.pid);
+      service.pid = null;
+      service.status = "stopped";
+    }
+  }
+  const merged = new Map;
+  for (const service of persisted?.services ?? []) {
+    merged.set(service.name, service);
+  }
+  for (const service of stateServices) {
+    merged.set(service.name, service);
+  }
+  const nextState = {
+    updatedAt,
+    rootPath: projectRoot,
+    services: [...merged.values()].sort((left, right) => left.name.localeCompare(right.name))
+  };
+  writePersistedFabricState(projectRoot, nextState);
+  return summarizeFabricState(projectRoot, stateServices, plans.warnings, updatedAt);
+}
+function countRuntimeDirs(projectRoot) {
+  const runtimeRoot = resolve8(resolveRuntimeWorkspaceRoot(projectRoot), ".rig", "runtime", "agents");
+  if (!existsSync8(runtimeRoot)) {
+    return 0;
+  }
+  return readdirSync2(runtimeRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).length;
+}
+function countArtifactTaskDirs(projectRoot) {
+  const artifactRoot = resolve8(resolveRuntimeWorkspaceRoot(projectRoot), "artifacts");
+  if (!existsSync8(artifactRoot)) {
+    return 0;
+  }
+  return readdirSync2(artifactRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== "remote-runs").length;
+}
+async function readWorkspaceSummary(projectRoot) {
+  const generatedAt = new Date().toISOString();
+  const warnings = [];
+  const topology = readWorkspaceTopology(projectRoot, generatedAt);
+  const remoteFleet = readWorkspaceRemoteFleet(projectRoot, generatedAt);
+  const serviceFabric = await readWorkspaceServiceFabric(projectRoot);
+  if (serviceFabric?.warnings) {
+    warnings.push(...serviceFabric.warnings.map((warning) => String(warning)));
+  }
+  warnings.push(...topology.warnings, ...remoteFleet.warnings);
+  return {
+    rootPath: projectRoot,
+    taskCounts: collectTaskCounts(projectRoot),
+    runtimeCount: countRuntimeDirs(projectRoot),
+    artifactTaskCount: countArtifactTaskDirs(projectRoot),
+    failedApproachesPresent: existsSync8(resolve8(resolveRuntimeWorkspaceRoot(projectRoot), ".rig", "state", "failed_approaches.md")),
+    topology,
+    remoteFleet,
+    serviceFabric,
+    warnings,
+    generatedAt
+  };
+}
+function readTaskArtifactPreview(projectRoot, taskId, fileName, maxBytes = 64 * 1024) {
+  const artifactPath = resolveTaskArtifactDirs(projectRoot, taskId).map((dir) => resolve8(dir, fileName)).find((candidate) => existsSync8(candidate));
+  if (!artifactPath) {
+    throw new Error(`Artifact not found for ${taskId}: ${fileName}`);
+  }
+  const stat = statSync3(artifactPath);
+  const buffer = readFileSync4(artifactPath);
+  const slice = buffer.subarray(0, maxBytes);
+  const contents = slice.includes(0) ? "[binary content omitted]" : slice.toString("utf-8");
+  return {
+    taskId,
+    fileName,
+    path: artifactPath,
+    sizeBytes: stat.size,
+    contents,
+    truncated: buffer.length > maxBytes,
+    maxBytes
+  };
+}
+export {
+  readWorkspaceTopology,
+  readWorkspaceSummary,
+  readWorkspaceServiceFabric,
+  readWorkspaceRemoteFleet,
+  readTaskArtifactPreview,
+  mutateWorkspaceServiceFabric
+};