@h-rig/task-sources-plugin 0.0.6-alpha.157 → 0.0.6-alpha.159

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

@@ -0,0 +1,1205 @@
+// @bun
+// packages/task-sources-plugin/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/task-sources-plugin/src/control-plane/state-sync/read.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve3 } from "path";
+
+// packages/task-sources-plugin/src/control-plane/native/native-git.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, isAbsolute, resolve } from "path";
+import { createHash } from "crypto";
+var taskSourcesGitNativeOutputDir = resolve(tmpdir(), "rig-task-sources-native");
+var taskSourcesGitNativeOutputPath = resolve(taskSourcesGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+var trackerCommandUsageProbe = "usage: rig-git fetch-ref <repo-path> <remote> <branch>";
+function nativeFetchRef(repoPath, remote, branch) {
+  return requireGitNativeString("fetch-ref", [repoPath, remote, branch]);
+}
+function nativeReadBlobAtRef(repoPath, ref, path) {
+  const requestDir = resolve(taskSourcesGitNativeOutputDir, "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 nativeWriteTreeCommit(repoPath, baseRef, updates, message) {
+  const requestDir = resolve(taskSourcesGitNativeOutputDir, "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, `${JSON.stringify(serializeTreeCommitUpdates(updates), null, 2)}
+`, "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]);
+}
+function runGitNative(command, args) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return { ok: false, error: "rig-git native disabled" };
+  }
+  let binaryPath;
+  try {
+    binaryPath = resolveGitBinaryPath() ?? ensureRigGitBinaryPathSync(preferredGitBinaryOutputPath());
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message.includes("rig-git.zig source file not found") ? "rig-git binary not found" : message };
+  }
+  try {
+    const proc = Bun.spawnSync([binaryPath, command, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: gitNativeEnv()
+    });
+    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 error = proc.stderr.toString().trim() || `exit code ${proc.exitCode}`;
+      return { ok: false, error };
+    }
+    return JSON.parse(proc.stdout.toString().trim());
+  } catch (error) {
+    return { ok: false, error: String(error) };
+  }
+}
+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 serializeTreeCommitUpdates(updates) {
+  return updates.map((update) => {
+    if (typeof update.content === "string") {
+      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 gitNativeEnv() {
+  const env = { ...process.env };
+  const token = env.GITHUB_TOKEN?.trim() || env.GH_TOKEN?.trim() || env.RIG_GITHUB_TOKEN?.trim() || "";
+  if (token) {
+    env.RIG_GITHUB_TOKEN = env.RIG_GITHUB_TOKEN || token;
+    env.GITHUB_TOKEN = env.GITHUB_TOKEN || token;
+    env.GH_TOKEN = env.GH_TOKEN || token;
+    env.GIT_TERMINAL_PROMPT = "0";
+    env.GIT_CONFIG_COUNT = "2";
+    env.GIT_CONFIG_KEY_0 = "credential.helper";
+    env.GIT_CONFIG_VALUE_0 = "";
+    env.GIT_CONFIG_KEY_1 = "credential.helper";
+    env.GIT_CONFIG_VALUE_1 = '!f() { test "$1" = get || exit 0; token="${GITHUB_TOKEN:-${GH_TOKEN:-${RIG_GITHUB_TOKEN:-}}}"; test -n "$token" || exit 0; echo username=x-access-token; echo password="$token"; }; f';
+  }
+  return env;
+}
+function runtimeRigGitFileName() {
+  return `rig-git${process.platform === "win32" ? ".exe" : ""}`;
+}
+function preferredGitBinaryOutputPath() {
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  return explicit || taskSourcesGitNativeOutputPath;
+}
+function resolveGitBinaryPath() {
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  if (explicit && existsSync(explicit)) {
+    return explicit;
+  }
+  if (explicit) {
+    return null;
+  }
+  for (const candidate of rigGitBinaryCandidates()) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function ensureRigGitBinaryPathSync(outputPath = taskSourcesGitNativeOutputPath) {
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  if (explicit && existsSync(explicit)) {
+    return explicit;
+  }
+  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 buildKey = JSON.stringify({
+    version: 1,
+    zigBinary,
+    platform: process.platform,
+    arch: process.arch,
+    sourcePath,
+    sourceDigest: createHash("sha256").update(readFileSync(sourcePath)).digest("hex")
+  });
+  const manifestPath = `${outputPath}.build-manifest.json`;
+  if (nativeBuildIsFresh(outputPath, manifestPath, buildKey)) {
+    chmodSync(outputPath, 493);
+    return outputPath;
+  }
+  const tempOutputPath = resolve(dirname(outputPath), `.rig-git-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}${process.platform === "win32" ? ".exe" : ""}`);
+  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 details = [build.stderr.toString().trim(), build.stdout.toString().trim()].filter(Boolean).join(`
+`);
+    throw new Error(`Failed to build native Rig git tools: ${details || `zig exited with code ${build.exitCode}`}`);
+  }
+  chmodSync(tempOutputPath, 493);
+  renameSync(tempOutputPath, outputPath);
+  if (!binarySupportsTrackerCommands(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 nativeBuildIsFresh(outputPath, manifestPath, buildKey) {
+  if (!existsSync(outputPath) || !existsSync(manifestPath)) {
+    return false;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    return manifest.version === 1 && manifest.buildKey === buildKey && binarySupportsTrackerCommands(outputPath);
+  } catch {
+    return false;
+  }
+}
+function binarySupportsTrackerCommands(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 resolveGitSourcePath() {
+  for (const candidate of rigGitSourceCandidates()) {
+    if (candidate && existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+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() || "";
+  return [...new Set([
+    process.env.RIG_NATIVE_GIT_SOURCE?.trim() || "",
+    resolve(import.meta.dir, "../../../native/rig-git.zig"),
+    projectRoot ? resolve(projectRoot, "packages/task-sources-plugin/native/rig-git.zig") : "",
+    projectRoot ? resolve(projectRoot, "packages/isolation-plugin/native/rig-git.zig") : "",
+    projectRoot ? resolve(projectRoot, "packages/shared/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve(hostProjectRoot, "packages/task-sources-plugin/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve(hostProjectRoot, "packages/isolation-plugin/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve(hostProjectRoot, "packages/shared/native/rig-git.zig") : "",
+    cwd ? resolve(cwd, "packages/task-sources-plugin/native/rig-git.zig") : "",
+    cwd ? resolve(cwd, "packages/isolation-plugin/native/rig-git.zig") : "",
+    cwd ? resolve(cwd, "packages/shared/native/rig-git.zig") : "",
+    execDir ? resolve(execDir, "..", "native", "rig-git.zig") : ""
+  ].filter(Boolean))];
+}
+function rigGitBinaryCandidates() {
+  const execDir = process.execPath?.trim() ? dirname(process.execPath.trim()) : "";
+  const fileName = runtimeRigGitFileName();
+  return [...new Set([
+    ...nativePackageBinaryCandidates(import.meta.dir, fileName),
+    execDir ? resolve(execDir, fileName) : "",
+    execDir ? resolve(execDir, "..", fileName) : "",
+    execDir ? resolve(execDir, "..", "bin", fileName) : "",
+    taskSourcesGitNativeOutputPath
+  ].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;
+}
+// packages/task-sources-plugin/src/control-plane/native/utils.ts
+import { getScopeRules } from "@rig/core/scope-rules";
+import { unique } from "@rig/core/exec";
+import {
+  runCapture,
+  runCaptureAsync,
+  runInherit,
+  getValidationTimeoutMs,
+  readJsonFile,
+  nowIso,
+  unique as unique2,
+  fileLines
+} from "@rig/core/exec";
+import { resolveCheckoutRoot } from "@rig/core/checkout-root";
+import { resolveHarnessPaths } from "@rig/core/harness-paths";
+var scopeRegexCache = new Map;
+
+// packages/task-sources-plugin/src/control-plane/state-sync/read.ts
+import { RUNTIME_CONTEXT_ENV } from "@rig/core/runtime-context";
+
+// packages/task-sources-plugin/src/control-plane/state-sync/repo.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { MANAGED_REPO_SERVICE_CAPABILITY } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { getInstalledCapability } from "@rig/core/capability-loaders";
+function resolveTrackerRepoPath(projectRoot) {
+  const monorepoRoot = resolveCheckoutRoot(projectRoot);
+  const managedRepos = getInstalledCapability(defineCapability(MANAGED_REPO_SERVICE_CAPABILITY));
+  if (managedRepos) {
+    try {
+      const layout = managedRepos.resolveMonorepoRepoLayout(projectRoot);
+      if (existsSync2(resolve2(layout.mirrorRoot, "HEAD"))) {
+        return layout.mirrorRoot;
+      }
+    } catch {}
+  }
+  return monorepoRoot;
+}
+
+// packages/task-sources-plugin/src/control-plane/state-sync/read.ts
+var DEFAULT_READ_DEPS = {
+  fetchRef: nativeFetchRef,
+  readBlobAtRef: nativeReadBlobAtRef,
+  exists: existsSync3,
+  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 dependencyTargetId(dependency) {
+  for (const candidate of [dependency.dependsOnId, dependency.id ?? null, dependency.issueId]) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+  return 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 existsSync3(resolve3(runtimeWorkspace, ".rig", "runtime-context.json"));
+}
+function readLocalTrackerState(projectRoot, deps) {
+  const monorepoRoot = resolveCheckoutRoot(projectRoot);
+  const issuesPath = resolve3(monorepoRoot, ".beads", "issues.jsonl");
+  const taskStatePath = resolve3(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);
+  }
+}
+function listReadyTaskIdsFromTracker(snapshot) {
+  const tasks = snapshot.issues.filter((issue) => issue.issueType === "task");
+  const taskById = new Map(tasks.map((issue) => [issue.id, issue]));
+  const readyTaskIds = [];
+  for (const issue of tasks) {
+    if (issue.status === "ready") {
+      readyTaskIds.push(issue.id);
+      continue;
+    }
+    if (issue.status !== "open") {
+      continue;
+    }
+    const hasOpenBlocker = issue.dependencies.some((dependency) => {
+      if (dependency.type === "parent-child") {
+        return false;
+      }
+      const targetTaskId = dependencyTargetId(dependency);
+      if (!targetTaskId) {
+        return false;
+      }
+      const dependencyStatus = taskById.get(targetTaskId)?.status ?? "unknown";
+      return dependencyStatus !== "completed" && dependencyStatus !== "cancelled";
+    });
+    if (!hasOpenBlocker) {
+      readyTaskIds.push(issue.id);
+    }
+  }
+  return readyTaskIds;
+}
+// packages/task-sources-plugin/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, nowIso2) {
+  if (!metadata) {
+    return false;
+  }
+  const now = parseTimestamp(nowIso2);
+  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 nowIso2 = input.evidence?.now ?? new Date().toISOString();
+  const isStale = isTaskClaimStale(input.metadata, nowIso2);
+  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: nowIso2,
+          ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+          ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        } : {
+          status: "completed",
+          lastEvidenceAt: nowIso2,
+          ...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: nowIso2,
+          ...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: nowIso2,
+            ...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: nowIso2,
+        ...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: nowIso2,
+          reviewState: "changes_requested"
+        } : null
+      };
+    }
+    if (hasPrCloseoutCompletionEvidence(input.evidence)) {
+      return {
+        valid: true,
+        reasons,
+        isStale,
+        wouldReconcileTo: "completed",
+        nextMetadata: input.metadata ? {
+          ...input.metadata,
+          status: "completed",
+          lastEvidenceAt: nowIso2,
+          ...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: nowIso2,
+        ...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: nowIso2,
+        ...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/task-sources-plugin/src/control-plane/state-sync/write.ts
+import { isDeepStrictEqual } from "util";
+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,
+    ...input.evidence ? { 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,
+  readTaskStateMetadataEnvelope,
+  readSyncedTrackerState,
+  projectTaskReconciliation,
+  projectSyncedTrackerSnapshot,
+  prepareReconcileTaskMutation,
+  prepareLifecycleTaskMutation,
+  prepareClaimTaskMutation,
+  normalizeTaskLifecycleStatus,
+  listReadyTaskIdsFromTracker,
+  isTaskClaimStale,
+  discardMismatchedTaskStateMetadata,
+  claimRemoteTrackerTask,
+  assertWritableTrackerStateBases,
+  TrackerStateMutationError
+};