@h-rig/runtime 0.0.6-alpha.0

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

@@ -0,0 +1,260 @@
+// @bun
+// packages/runtime/src/control-plane/state-sync/reconcile.ts
+var STALE_CLAIM_MS = 24 * 60 * 60 * 1000;
+function parseTimestamp(value) {
+  if (!value) {
+    return null;
+  }
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function inProgressOwnershipMetadataIssue(metadata) {
+  if (!metadata?.claimId || !metadata.ownerId || !metadata.claimedAt || !metadata.lastEvidenceAt) {
+    return "missing-ownership-metadata";
+  }
+  if (parseTimestamp(metadata.claimedAt) == null || parseTimestamp(metadata.lastEvidenceAt) == null) {
+    return "invalid-ownership-timestamps";
+  }
+  return null;
+}
+function hasExplicitPullRequestEvidence(evidence) {
+  return evidence != null && Object.prototype.hasOwnProperty.call(evidence, "pr");
+}
+function hasPrCloseoutCompletionEvidence(evidence) {
+  const pr = evidence?.pr;
+  return evidence?.closeoutPassed === true && (pr?.isOpen === true || pr?.isMerged === true);
+}
+function isTaskClaimStale(metadata, nowIso) {
+  if (!metadata) {
+    return false;
+  }
+  const now = parseTimestamp(nowIso);
+  if (now == null) {
+    return false;
+  }
+  const reference = parseTimestamp(metadata.lastEvidenceAt) ?? parseTimestamp(metadata.claimedAt);
+  if (reference == null) {
+    return false;
+  }
+  return now - reference > STALE_CLAIM_MS;
+}
+function projectTaskReconciliation(input) {
+  const reasons = [];
+  const nowIso = input.evidence?.now ?? new Date().toISOString();
+  const isStale = isTaskClaimStale(input.metadata, nowIso);
+  const pr = input.evidence?.pr ?? null;
+  const hasExplicitPrEvidence = hasExplicitPullRequestEvidence(input.evidence);
+  const activeOwnerIds = (input.evidence?.activeOwnerIds ?? []).filter(Boolean);
+  if (new Set(activeOwnerIds).size > 1) {
+    return {
+      valid: false,
+      reasons: ["multiple-active-owners"],
+      isStale,
+      wouldReconcileTo: null,
+      nextMetadata: input.metadata
+    };
+  }
+  if (input.lifecycleStatus === "blocked" || input.lifecycleStatus === "cancelled") {
+    return {
+      valid: true,
+      reasons,
+      isStale,
+      wouldReconcileTo: null,
+      nextMetadata: input.metadata
+    };
+  }
+  if (input.lifecycleStatus === "in_progress") {
+    const ownershipMetadataIssue = inProgressOwnershipMetadataIssue(input.metadata);
+    const hasOwnershipMetadata = ownershipMetadataIssue == null;
+    if (hasPrCloseoutCompletionEvidence(input.evidence)) {
+      return {
+        valid: hasOwnershipMetadata,
+        reasons: hasOwnershipMetadata ? reasons : [ownershipMetadataIssue],
+        isStale,
+        wouldReconcileTo: "completed",
+        nextMetadata: input.metadata ? {
+          ...input.metadata,
+          status: "completed",
+          lastEvidenceAt: nowIso,
+          ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+          ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        } : {
+          status: "completed",
+          lastEvidenceAt: nowIso,
+          ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+          ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        }
+      };
+    }
+    if (ownershipMetadataIssue) {
+      return {
+        valid: false,
+        reasons: [ownershipMetadataIssue],
+        isStale,
+        wouldReconcileTo: pr?.isOpen ? "under_review" : "ready",
+        nextMetadata: pr?.isOpen ? {
+          ...input.metadata ?? { status: "under_review" },
+          status: "under_review",
+          lastEvidenceAt: nowIso,
+          ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+          ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        } : null
+      };
+    }
+    if (isStale) {
+      if (pr?.isOpen) {
+        return {
+          valid: false,
+          reasons: ["stale-claim"],
+          isStale,
+          wouldReconcileTo: "under_review",
+          nextMetadata: {
+            ...input.metadata,
+            status: "under_review",
+            lastEvidenceAt: nowIso,
+            ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+            ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+            ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+          }
+        };
+      }
+      return {
+        valid: false,
+        reasons: ["stale-claim"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+  }
+  if (hasPrCloseoutCompletionEvidence(input.evidence) && (input.lifecycleStatus === "open" || input.lifecycleStatus === "ready" || input.lifecycleStatus === "queued")) {
+    return {
+      valid: false,
+      reasons: ["pr-closeout-before-completion"],
+      isStale,
+      wouldReconcileTo: "completed",
+      nextMetadata: {
+        ...input.metadata ?? { status: "completed" },
+        status: "completed",
+        lastEvidenceAt: nowIso,
+        ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+        ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+        ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+      }
+    };
+  }
+  if (input.lifecycleStatus === "under_review") {
+    const hasPrLink = Boolean(input.metadata?.prNumber || input.metadata?.prUrl || pr?.prNumber || pr?.prUrl);
+    if (!hasPrLink) {
+      return {
+        valid: false,
+        reasons: ["missing-pr-metadata"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+    if (hasExplicitPrEvidence && !pr) {
+      return {
+        valid: false,
+        reasons: ["missing-pr-evidence"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+    if (pr?.reviewState === "changes_requested") {
+      const ownershipMetadataIssue = inProgressOwnershipMetadataIssue(input.metadata);
+      if (ownershipMetadataIssue) {
+        return {
+          valid: false,
+          reasons: [ownershipMetadataIssue],
+          isStale,
+          wouldReconcileTo: "ready",
+          nextMetadata: null
+        };
+      }
+      return {
+        valid: true,
+        reasons,
+        isStale,
+        wouldReconcileTo: "in_progress",
+        nextMetadata: input.metadata ? {
+          ...input.metadata,
+          status: "in_progress",
+          lastEvidenceAt: nowIso,
+          reviewState: "changes_requested"
+        } : null
+      };
+    }
+    if (hasPrCloseoutCompletionEvidence(input.evidence)) {
+      return {
+        valid: true,
+        reasons,
+        isStale,
+        wouldReconcileTo: "completed",
+        nextMetadata: input.metadata ? {
+          ...input.metadata,
+          status: "completed",
+          lastEvidenceAt: nowIso,
+          ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+        } : null
+      };
+    }
+    if (pr && !pr.isOpen && !pr.isMerged) {
+      return {
+        valid: false,
+        reasons: ["closed-pr-without-merge"],
+        isStale,
+        wouldReconcileTo: "ready",
+        nextMetadata: null
+      };
+    }
+  }
+  if (input.lifecycleStatus === "completed" && pr?.isOpen && !hasPrCloseoutCompletionEvidence(input.evidence)) {
+    return {
+      valid: false,
+      reasons: ["completed-with-open-pr"],
+      isStale,
+      wouldReconcileTo: "under_review",
+      nextMetadata: {
+        ...input.metadata ?? { status: "under_review" },
+        status: "under_review",
+        lastEvidenceAt: nowIso,
+        ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+        ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+        ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+      }
+    };
+  }
+  if (pr?.isOpen && (input.lifecycleStatus === "draft" || input.lifecycleStatus === "open" || input.lifecycleStatus === "ready" || input.lifecycleStatus === "queued" || input.lifecycleStatus === "in_progress")) {
+    return {
+      valid: true,
+      reasons,
+      isStale,
+      wouldReconcileTo: "under_review",
+      nextMetadata: {
+        ...input.metadata ?? { status: "under_review" },
+        status: "under_review",
+        lastEvidenceAt: nowIso,
+        ...pr?.prNumber != null ? { prNumber: pr?.prNumber } : {},
+        ...pr?.prUrl ? { prUrl: pr?.prUrl } : {},
+        ...pr?.reviewState ? { reviewState: pr?.reviewState } : {}
+      }
+    };
+  }
+  return {
+    valid: true,
+    reasons,
+    isStale,
+    wouldReconcileTo: null,
+    nextMetadata: input.metadata
+  };
+}
+export {
+  projectTaskReconciliation,
+  isTaskClaimStale
+};

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

@@ -0,0 +1,302 @@
+// @bun
+// packages/runtime/src/control-plane/state-sync/repo.ts
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve4 } from "path";
+
+// 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/native/runtime-native.ts
+import { dlopen, ptr, suffix, toBuffer } from "bun:ffi";
+import { copyFileSync, existsSync as existsSync2, mkdirSync, renameSync, rmSync, statSync } from "fs";
+import { tmpdir } from "os";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+var sharedNativeRuntimeOutputDir = resolve2(tmpdir(), "rig-native");
+var sharedNativeRuntimeOutputPath = resolve2(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 && existsSync2(outputPath) ? outputPath : null;
+}
+async function loadNativeRuntimeLibrary() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  for (const candidate of nativeRuntimeLibraryCandidates()) {
+    if (!candidate || !existsSync2(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 = resolve2(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    for (const name of names) {
+      candidates.push(resolve2(cursor, "native", `${process.platform}-${process.arch}`, name), resolve2(cursor, "native", `${process.platform}-${process.arch}`, "lib", name), resolve2(cursor, "native", name), resolve2(cursor, "native", "lib", name));
+    }
+    const parent = dirname2(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() ? dirname2(process.execPath.trim()) : "";
+  const platformSpecific = `runtime-native-${process.platform}-${process.arch}.${suffix}`;
+  return [...new Set([
+    explicit,
+    ...nativePackageLibraryCandidates(import.meta.dir, [colocatedNativeRuntimeFileName, platformSpecific]),
+    execDir ? resolve2(execDir, colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, platformSpecific) : "",
+    execDir ? resolve2(execDir, "..", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, "..", platformSpecific) : "",
+    execDir ? resolve2(execDir, "lib", colocatedNativeRuntimeFileName) : "",
+    execDir ? resolve2(execDir, "..", "lib", colocatedNativeRuntimeFileName) : "",
+    sharedNativeRuntimeOutputPath
+  ].filter(Boolean))];
+}
+function resolveNativeRuntimeSourcePath() {
+  const explicit = process.env.RIG_NATIVE_RUNTIME_SOURCE?.trim();
+  if (explicit && existsSync2(explicit)) {
+    return explicit;
+  }
+  const bundled = resolve2(import.meta.dir, "../../../native/snapshot.zig");
+  return existsSync2(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 {
+    mkdirSync(dirname2(outputPath), { recursive: true });
+    const needsBuild = options.force === true || !existsSync2(outputPath) || statSync(sourcePath).mtimeMs > statSync(outputPath).mtimeMs;
+    if (!needsBuild) {
+      return true;
+    }
+    const build = Bun.spawn([
+      zigBinary,
+      "build-lib",
+      sourcePath,
+      "-dynamic",
+      "-O",
+      "ReleaseFast",
+      `-femit-bin=${tempOutputPath}`
+    ], {
+      cwd: import.meta.dir,
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await build.exited;
+    if (exitCode !== 0 || !existsSync2(tempOutputPath)) {
+      rmSync(tempOutputPath, { force: true });
+      return false;
+    }
+    renameSync(tempOutputPath, outputPath);
+    return true;
+  } catch {
+    rmSync(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/repos/layout.ts
+import { existsSync as existsSync3 } from "fs";
+import { basename as basename2, dirname as dirname3, join, resolve as resolve3 } 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 = resolve3(projectRoot);
+  const projectParent = dirname3(normalizedProjectRoot);
+  if (basename2(projectParent) === ".worktrees") {
+    const ownerRoot = dirname3(projectParent);
+    const ownerHasRepoMarkers = existsSync3(resolve3(ownerRoot, ".git")) || existsSync3(resolve3(ownerRoot, ".rig", "state"));
+    if (ownerHasRepoMarkers) {
+      return resolve3(ownerRoot, ".rig", "state");
+    }
+  }
+  return resolve3(projectRoot, ".rig", "state");
+}
+function resolveManagedRepoLayout(projectRoot, repoId) {
+  const normalizedProjectRoot = resolve3(projectRoot);
+  const entry = getManagedRepoEntry(repoId);
+  const stateDir = resolveRepoStateDir(normalizedProjectRoot);
+  const metadataRelativePath = join("repos", entry.id);
+  const metadataRoot = resolve3(stateDir, metadataRelativePath);
+  const runtimeWorkspace = process.env.RIG_TASK_WORKSPACE?.trim();
+  const runsInsideTaskWorktree = runtimeWorkspace && resolve3(runtimeWorkspace) === normalizedProjectRoot || basename2(dirname3(normalizedProjectRoot)) === ".worktrees";
+  const isPrimaryManagedRepo = listManagedRepoEntries()[0]?.id === repoId;
+  const checkoutRoot = isPrimaryManagedRepo && runsInsideTaskWorktree ? resolveMonorepoRoot(normalizedProjectRoot) : entry.checkoutEnvVar && process.env[entry.checkoutEnvVar]?.trim() ? resolve3(process.env[entry.checkoutEnvVar].trim()) : resolve3(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: resolve3(checkoutRoot, ".worktrees"),
+    stateDir,
+    metadataRoot,
+    metadataRelativePath,
+    mirrorRoot: resolve3(metadataRoot, "mirror.git"),
+    mirrorStatePath: resolve3(metadataRoot, "mirror-state.json"),
+    mirrorStateRelativePath: join(metadataRelativePath, "mirror-state.json")
+  };
+}
+function resolveMonorepoRepoLayout(projectRoot) {
+  const entries = listManagedRepoEntries();
+  if (entries.length === 0) {
+    throw new Error("resolveMonorepoRepoLayout: no managed repos registered. Either contribute one via " + "RigPlugin.contributes.repoSources (with defaultBranch set), or avoid calling this " + "function for projects where the project root IS the monorepo.");
+  }
+  const primary = entries[0];
+  return resolveManagedRepoLayout(projectRoot, primary.id);
+}
+
+// packages/runtime/src/control-plane/state-sync/repo.ts
+function resolveTrackerRepoPath(projectRoot) {
+  const monorepoRoot = resolveMonorepoRoot2(projectRoot);
+  try {
+    const layout = resolveMonorepoRepoLayout(projectRoot);
+    if (existsSync4(resolve4(layout.mirrorRoot, "HEAD"))) {
+      return layout.mirrorRoot;
+    }
+  } catch {}
+  return monorepoRoot;
+}
+export {
+  resolveTrackerRepoPath
+};

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

@@ -0,0 +1,111 @@
+// @bun
+// packages/runtime/src/control-plane/state-sync/types.ts
+var SUPPORTED_TASK_STATE_SCHEMA_VERSION = 1;
+var CANONICAL_TASK_LIFECYCLE_STATUSES = new Set([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "completed",
+  "cancelled"
+]);
+function normalizeTaskLifecycleStatus(status) {
+  switch (status) {
+    case "draft":
+    case "open":
+    case "ready":
+    case "queued":
+    case "in_progress":
+    case "under_review":
+    case "blocked":
+    case "completed":
+    case "cancelled":
+      return status;
+    case "closed":
+      return "completed";
+    case "running":
+      return "in_progress";
+    case "failed":
+      return "ready";
+    default:
+      return null;
+  }
+}
+function normalizeTaskStateMetadataStatus(status) {
+  if (CANONICAL_TASK_LIFECYCLE_STATUSES.has(status)) {
+    return status;
+  }
+  switch (status) {
+    case "closed":
+      return "completed";
+    case "running":
+      return "in_progress";
+    case "failed":
+      return "ready";
+    default:
+      return;
+  }
+}
+function canonicalizeTaskStateMetadata(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return null;
+  }
+  const metadata = raw;
+  const claimId = typeof metadata.claimId === "string" && metadata.claimId.length > 0 ? metadata.claimId : undefined;
+  const status = normalizeTaskStateMetadataStatus(metadata.status);
+  if (!status) {
+    return null;
+  }
+  return {
+    ...claimId ? { claimId } : {},
+    status,
+    ...typeof metadata.ownerId === "string" && metadata.ownerId.length > 0 ? { ownerId: metadata.ownerId } : {},
+    ...typeof metadata.claimedAt === "string" && metadata.claimedAt.length > 0 ? { claimedAt: metadata.claimedAt } : {},
+    ...typeof metadata.lastEvidenceAt === "string" && metadata.lastEvidenceAt.length > 0 ? { lastEvidenceAt: metadata.lastEvidenceAt } : {},
+    ...typeof metadata.runId === "string" && metadata.runId.length > 0 ? { runId: metadata.runId } : {},
+    ...typeof metadata.branchName === "string" && metadata.branchName.length > 0 ? { branchName: metadata.branchName } : {},
+    ...typeof metadata.prNumber === "number" ? { prNumber: metadata.prNumber } : {},
+    ...typeof metadata.prUrl === "string" && metadata.prUrl.length > 0 ? { prUrl: metadata.prUrl } : {},
+    ...typeof metadata.reviewState === "string" && metadata.reviewState.length > 0 ? { reviewState: metadata.reviewState } : {},
+    ...typeof metadata.blockerReason === "string" && metadata.blockerReason.length > 0 ? { blockerReason: metadata.blockerReason } : {},
+    ...typeof metadata.sourceCommit === "string" && metadata.sourceCommit.length > 0 ? { sourceCommit: metadata.sourceCommit } : {}
+  };
+}
+function discardMismatchedTaskStateMetadata(input) {
+  input.taskId;
+  const canonicalMetadata = canonicalizeTaskStateMetadata(input.metadata);
+  if (!canonicalMetadata || !input.lifecycleStatus) {
+    return null;
+  }
+  const metadataStatus = canonicalMetadata.status ?? null;
+  if (metadataStatus && metadataStatus !== input.lifecycleStatus) {
+    return null;
+  }
+  return canonicalMetadata;
+}
+function readTaskStateMetadataEnvelope(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { schemaVersion: SUPPORTED_TASK_STATE_SCHEMA_VERSION, supported: true, baseTrackerCommit: null, tasks: {} };
+  }
+  const envelope = raw;
+  const schemaVersion = typeof envelope.schemaVersion === "number" ? envelope.schemaVersion : SUPPORTED_TASK_STATE_SCHEMA_VERSION;
+  if (schemaVersion !== SUPPORTED_TASK_STATE_SCHEMA_VERSION) {
+    return { schemaVersion, supported: false, baseTrackerCommit: null, tasks: {} };
+  }
+  const rawTasks = envelope.tasks && typeof envelope.tasks === "object" && !Array.isArray(envelope.tasks) ? envelope.tasks : {};
+  const tasks = Object.fromEntries(Object.entries(rawTasks).map(([taskId, metadata]) => [taskId, canonicalizeTaskStateMetadata(metadata)]).filter((entry) => entry[1] != null));
+  return {
+    schemaVersion,
+    supported: true,
+    baseTrackerCommit: typeof envelope.baseTrackerCommit === "string" && envelope.baseTrackerCommit.length > 0 ? envelope.baseTrackerCommit : null,
+    tasks
+  };
+}
+export {
+  readTaskStateMetadataEnvelope,
+  normalizeTaskLifecycleStatus,
+  discardMismatchedTaskStateMetadata
+};