@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/workflow/runs.js

@@ -1,720 +0,0 @@
-import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { hostname } from "node:os";
-import { dirname, resolve } from "node:path";
-const WORKFLOW_CONTROL_DIR = ".treeseed/workflow";
-const WORKFLOW_RUNS_DIR = `${WORKFLOW_CONTROL_DIR}/runs`;
-const WORKTREE_METADATA_PATH = ".treeseed/worktree.json";
-const LOCK_STALE_AFTER_MS = 4 * 60 * 60 * 1e3;
-const WORKFLOW_RUN_STORAGE_ROOTS = /* @__PURE__ */ new Map();
-const SHARED_LOCK_COMMANDS = /* @__PURE__ */ new Set(["stage", "release"]);
-const ACTIVE_WORKFLOW_RUNS = /* @__PURE__ */ new Map();
-let SIGNAL_HANDLERS_INSTALLED = false;
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function markActiveWorkflowRunsInterrupted(signal) {
-  const interrupted = [];
-  for (const [runId, root] of ACTIVE_WORKFLOW_RUNS) {
-    const journal = readWorkflowRunJournal(root, runId);
-    if (journal?.status === "running") {
-      updateWorkflowRunJournal(root, runId, (current) => ({
-        ...current,
-        status: "failed",
-        failure: {
-          code: "interrupted",
-          message: `Treeseed workflow was interrupted by ${signal}.`,
-          details: {
-            resumable: true,
-            recoverCommand: "treeseed recover",
-            resumeCommand: `treeseed resume ${runId}`
-          },
-          at: nowIso()
-        }
-      }));
-    }
-    releaseWorkflowLock(root, runId);
-    interrupted.push(runId);
-  }
-  ACTIVE_WORKFLOW_RUNS.clear();
-  return interrupted;
-}
-function installWorkflowSignalHandlers() {
-  if (SIGNAL_HANDLERS_INSTALLED) return;
-  SIGNAL_HANDLERS_INSTALLED = true;
-  for (const signal of ["SIGINT", "SIGTERM"]) {
-    process.once(signal, () => {
-      markActiveWorkflowRunsInterrupted(signal);
-      process.kill(process.pid, signal);
-    });
-  }
-}
-function managedWorktreePrimaryRoot(root) {
-  const metadataPath = resolve(root, WORKTREE_METADATA_PATH);
-  if (!existsSync(metadataPath)) return null;
-  try {
-    const metadata = JSON.parse(readFileSync(metadataPath, "utf8"));
-    return metadata.kind === "treeseed.workflow.worktree" && typeof metadata.primaryRoot === "string" ? metadata.primaryRoot : null;
-  } catch {
-    return null;
-  }
-}
-function workflowLockScopeForCommand(command) {
-  return SHARED_LOCK_COMMANDS.has(command) ? "shared" : "worktree";
-}
-function isSharedWorkflowCommand(command) {
-  return command === "stage" || command === "release";
-}
-function workflowCommandFromRunId(runId) {
-  if (!runId) return null;
-  const prefix = runId.split("-", 1)[0];
-  return ["switch", "save", "update", "close", "stage", "release", "destroy"].includes(prefix) ? prefix : null;
-}
-function workflowStorageRootForScope(root, scope) {
-  return scope === "shared" ? managedWorktreePrimaryRoot(root) ?? root : root;
-}
-function workflowStorageRoot(root, runId, scope) {
-  const storageKey = runId ? `${resolve(root)}\0${runId}` : null;
-  if (storageKey && WORKFLOW_RUN_STORAGE_ROOTS.has(storageKey)) {
-    return WORKFLOW_RUN_STORAGE_ROOTS.get(storageKey);
-  }
-  const command = workflowCommandFromRunId(runId);
-  const resolvedScope = scope ?? (command ? workflowLockScopeForCommand(command) : "worktree");
-  const storageRoot = workflowStorageRootForScope(root, resolvedScope);
-  if (storageKey) {
-    WORKFLOW_RUN_STORAGE_ROOTS.set(storageKey, storageRoot);
-  }
-  return storageRoot;
-}
-function workflowControlRoot(root, runId, scope) {
-  return resolve(workflowStorageRoot(root, runId, scope), WORKFLOW_CONTROL_DIR);
-}
-function workflowRunsRoot(root, runId, scope) {
-  return resolve(workflowStorageRoot(root, runId, scope), WORKFLOW_RUNS_DIR);
-}
-function workflowLockPath(root, runId, scope) {
-  return resolve(workflowStorageRoot(root, runId, scope), WORKFLOW_CONTROL_DIR, "lock.json");
-}
-function workflowRunPath(root, runId) {
-  return resolve(workflowStorageRoot(root, runId), WORKFLOW_RUNS_DIR, `${runId}.json`);
-}
-function resolveGitDir(root) {
-  const gitPath = resolve(root, ".git");
-  if (existsSync(resolve(gitPath, "info"))) {
-    return gitPath;
-  }
-  if (!existsSync(gitPath)) {
-    return null;
-  }
-  try {
-    const gitFile = readFileSync(gitPath, "utf8").trim();
-    const match = gitFile.match(/^gitdir:\s*(.+)$/u);
-    return match ? resolve(root, match[1]) : null;
-  } catch {
-    return null;
-  }
-}
-function ensureWorkflowExcludeRule(root) {
-  const gitDir = resolveGitDir(root);
-  if (!gitDir) {
-    return;
-  }
-  const excludePath = resolve(gitDir, "info", "exclude");
-  const pattern = "/.treeseed/workflow/";
-  const current = existsSync(excludePath) ? readFileSync(excludePath, "utf8") : "";
-  if (current.includes(pattern)) {
-    return;
-  }
-  mkdirSync(dirname(excludePath), { recursive: true });
-  writeFileSync(excludePath, `${current}${current.endsWith("\n") || current.length === 0 ? "" : "\n"}${pattern}
-`, "utf8");
-}
-function ensureWorkflowControlDirs(root, runId, scope) {
-  const controlDir = workflowControlRoot(root, runId, scope);
-  const runsDir = workflowRunsRoot(root, runId, scope);
-  mkdirSync(runsDir, { recursive: true });
-  ensureWorkflowExcludeRule(root);
-  writeFileSync(resolve(controlDir, ".gitignore"), "*\n!.gitignore\n!runs/\nruns/*\n!runs/.gitignore\n", "utf8");
-  writeFileSync(resolve(runsDir, ".gitignore"), "*\n!.gitignore\n", "utf8");
-  return {
-    controlDir,
-    runsDir,
-    lockPath: workflowLockPath(root, runId, scope)
-  };
-}
-function safeJsonParse(filePath) {
-  if (!existsSync(filePath)) {
-    return null;
-  }
-  try {
-    return JSON.parse(readFileSync(filePath, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function pidIsAlive(pid) {
-  if (!Number.isInteger(pid) || (pid ?? 0) <= 0) {
-    return false;
-  }
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function generateWorkflowRunId(command) {
-  return `${command}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function inspectWorkflowLock(root, options = {}) {
-  const scope = options.scope ?? "worktree";
-  const lock = safeJsonParse(workflowLockPath(root, null, scope));
-  if (!lock) {
-    return {
-      lock: null,
-      active: false,
-      stale: false,
-      staleReason: null
-    };
-  }
-  let staleReason = null;
-  if (lock.host === hostname() && lock.pid != null && !pidIsAlive(lock.pid)) {
-    staleReason = `process ${lock.pid} is no longer running`;
-  } else if (Date.now() - Date.parse(lock.updatedAt) > LOCK_STALE_AFTER_MS) {
-    staleReason = "lock heartbeat expired";
-  }
-  return {
-    lock: {
-      ...lock,
-      scope: lock.scope ?? scope,
-      stale: staleReason != null,
-      staleReason
-    },
-    active: staleReason == null,
-    stale: staleReason != null,
-    staleReason
-  };
-}
-function acquireWorkflowLock(root, command, runId) {
-  const scope = workflowLockScopeForCommand(command);
-  const dirs = ensureWorkflowControlDirs(root, runId, scope);
-  const inspection = inspectWorkflowLock(root, { scope });
-  if (inspection.active && inspection.lock && inspection.lock.runId !== runId) {
-    return {
-      acquired: false,
-      lock: inspection.lock
-    };
-  }
-  if (inspection.stale) {
-    if (inspection.lock?.runId) {
-      const staleJournal = readWorkflowRunJournal(root, inspection.lock.runId);
-      if (staleJournal?.status === "running") {
-        updateWorkflowRunJournal(root, inspection.lock.runId, (journal) => ({
-          ...journal,
-          status: "failed",
-          failure: {
-            code: "interrupted",
-            message: `Workflow lock became stale because ${inspection.staleReason ?? "the owning process ended"}.`,
-            details: { resumable: true, resumeCommand: `treeseed resume ${inspection.lock.runId}` },
-            at: nowIso()
-          }
-        }));
-      }
-    }
-    rmSync(dirs.lockPath, { force: true });
-  }
-  const timestamp = nowIso();
-  const lock = {
-    schemaVersion: 1,
-    kind: "treeseed.workflow.lock",
-    scope,
-    runId,
-    command,
-    root,
-    host: hostname(),
-    pid: process.pid,
-    createdAt: inspection.lock?.runId === runId ? inspection.lock.createdAt : timestamp,
-    updatedAt: timestamp,
-    stale: false,
-    staleReason: null
-  };
-  writeFileSync(dirs.lockPath, `${JSON.stringify(lock, null, 2)}
-`, "utf8");
-  ACTIVE_WORKFLOW_RUNS.set(runId, root);
-  installWorkflowSignalHandlers();
-  return {
-    acquired: true,
-    lock,
-    replacedStale: inspection.stale
-  };
-}
-function refreshWorkflowLock(root, runId) {
-  const path = workflowLockPath(root, runId);
-  const lock = safeJsonParse(path);
-  if (!lock || lock.runId !== runId) {
-    return null;
-  }
-  const updated = {
-    ...lock,
-    updatedAt: nowIso(),
-    stale: false,
-    staleReason: null
-  };
-  writeFileSync(path, `${JSON.stringify(updated, null, 2)}
-`, "utf8");
-  return updated;
-}
-function releaseWorkflowLock(root, runId) {
-  ACTIVE_WORKFLOW_RUNS.delete(runId);
-  const path = workflowLockPath(root, runId);
-  const lock = safeJsonParse(path);
-  if (!lock || lock.runId !== runId) {
-    return false;
-  }
-  rmSync(path, { force: true });
-  return true;
-}
-function writeWorkflowRunJournal(root, journal) {
-  ensureWorkflowControlDirs(root, journal.runId);
-  writeFileSync(workflowRunPath(root, journal.runId), `${JSON.stringify(journal, null, 2)}
-`, "utf8");
-  return journal;
-}
-function readWorkflowRunJournal(root, runId) {
-  return safeJsonParse(workflowRunPath(root, runId));
-}
-function jsonStringField(source, key) {
-  const pattern = new RegExp(`"${key}"\\s*:\\s*"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"`, "u");
-  const match = source.match(pattern);
-  if (!match) return null;
-  try {
-    return JSON.parse(`"${match[1]}"`);
-  } catch {
-    return match[1];
-  }
-}
-function jsonBooleanField(source, key) {
-  const pattern = new RegExp(`"${key}"\\s*:\\s*(true|false)`, "u");
-  const match = source.match(pattern);
-  return match ? match[1] === "true" : null;
-}
-function readFileEnds(path, bytes) {
-  const fd = openSync(path, "r");
-  try {
-    const stat = fstatSync(fd);
-    const headLength = Math.min(bytes, stat.size);
-    const tailLength = Math.min(bytes, stat.size);
-    const head = Buffer.alloc(headLength);
-    const tail = Buffer.alloc(tailLength);
-    readSync(fd, head, 0, headLength, 0);
-    readSync(fd, tail, 0, tailLength, Math.max(0, stat.size - tailLength));
-    return { size: stat.size, head: head.toString("utf8"), tail: tail.toString("utf8") };
-  } finally {
-    closeSync(fd);
-  }
-}
-function archivedWorkflowRunSummary(path) {
-  const { head, tail } = readFileEnds(path, 128 * 1024);
-  if (!tail.includes('"archivedAt"')) {
-    return null;
-  }
-  const runId = jsonStringField(head, "runId");
-  const command = jsonStringField(head, "command");
-  const executionMode = jsonStringField(head, "executionMode");
-  const status = jsonStringField(head, "status");
-  const createdAt = jsonStringField(head, "createdAt");
-  const updatedAt = jsonStringField(head, "updatedAt");
-  const archivedAt = jsonStringField(tail, "archivedAt");
-  const classifiedAt = jsonStringField(tail, "classifiedAt") ?? archivedAt;
-  if (!runId || !command || !executionMode || !status || !createdAt || !updatedAt || !archivedAt || !classifiedAt) {
-    return null;
-  }
-  return {
-    schemaVersion: 1,
-    kind: "treeseed.workflow.run",
-    runId,
-    command,
-    executionMode,
-    status,
-    createdAt,
-    updatedAt,
-    resumable: jsonBooleanField(head, "resumable") ?? false,
-    input: {},
-    session: {
-      root: "",
-      mode: "root-only",
-      branchName: null,
-      repos: []
-    },
-    steps: [],
-    failure: null,
-    result: null,
-    classification: {
-      state: "obsolete",
-      reasons: ["workflow run was archived"],
-      classifiedAt,
-      archivedAt
-    }
-  };
-}
-function updateWorkflowRunJournal(root, runId, updater) {
-  const current = readWorkflowRunJournal(root, runId);
-  if (!current) {
-    return null;
-  }
-  const updated = updater(current);
-  writeWorkflowRunJournal(root, {
-    ...updated,
-    updatedAt: nowIso()
-  });
-  return readWorkflowRunJournal(root, runId);
-}
-function stringRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function journalReleasePlanHead(plan, repoName) {
-  if (repoName === "@treeseed/market") {
-    const rootRepo = stringRecord(plan.rootRepo);
-    return typeof rootRepo?.commitSha === "string" ? rootRepo.commitSha : null;
-  }
-  const repos = Array.isArray(plan.repos) ? plan.repos : [];
-  for (const repo of repos) {
-    const record = stringRecord(repo);
-    if (record?.name === repoName) {
-      return typeof record.commitSha === "string" ? record.commitSha : null;
-    }
-  }
-  return null;
-}
-function selectedReleasePackageNames(plan) {
-  const selection = stringRecord(plan.packageSelection);
-  const selected = Array.isArray(selection?.selected) ? selection.selected.filter((name) => typeof name === "string") : [];
-  return selected;
-}
-function isReleaseGateOnlyCompletion(journal) {
-  if (journal.command !== "release") return false;
-  const releaseRoot = journal.steps.find((step) => step.id === "release-root");
-  if (releaseRoot?.status !== "completed") return false;
-  const releaseRootData = stringRecord(releaseRoot.data);
-  if (typeof releaseRootData?.releasedCommit !== "string") return false;
-  const pendingStep = journal.steps.find((step) => step.status === "pending");
-  return pendingStep?.id === "release-root-gates" || pendingStep?.id === "release-back-merge";
-}
-function releaseStepData(journal, stepId) {
-  return stringRecord(journal.steps.find((step) => step.id === stepId)?.data);
-}
-function expectedPackageHeadAfterReleaseGate(journal, packageName) {
-  const data = releaseStepData(journal, `release-${packageName}`);
-  const backMerge = stringRecord(data?.backMerge);
-  if (typeof backMerge?.commitSha === "string") return backMerge.commitSha;
-  const commit = stringRecord(data?.commit);
-  if (typeof commit?.commitSha === "string") return commit.commitSha;
-  if (typeof data?.commitSha === "string") return data.commitSha;
-  return null;
-}
-function savePartialFailureData(journal) {
-  const details = stringRecord(journal.failure?.details);
-  return stringRecord(details?.partialFailure);
-}
-function collectSaveExpectedHeads(journal) {
-  const heads = {};
-  const saveData = stringRecord(journal.steps.find((step) => step.id === "save-repositories")?.data);
-  const partialFailure = savePartialFailureData(journal);
-  const source = saveData ?? partialFailure;
-  const partial = saveData == null && partialFailure != null;
-  const failingRepo = partial && typeof partialFailure?.failingRepo === "string" ? partialFailure.failingRepo : null;
-  const rootRepo = stringRecord(source?.rootRepo);
-  const rootCompletionUnknown = rootRepo?.pushed == null && rootRepo?.committed == null;
-  if (typeof rootRepo?.commitSha === "string" && (!partial || rootRepo.pushed === true || rootRepo.committed === true || rootCompletionUnknown && rootRepo.dirty !== true)) {
-    heads["@treeseed/market"] = rootRepo.commitSha;
-  }
-  const repos = Array.isArray(source?.repos) ? source.repos : [];
-  for (const entry of repos) {
-    const repo = stringRecord(entry);
-    const completionUnknown = repo?.pushed == null && repo?.committed == null;
-    if (typeof repo?.name === "string" && typeof repo.commitSha === "string" && (!partial || repo.pushed === true || repo.committed === true || completionUnknown && repo.name !== failingRepo && repo.dirty !== true)) {
-      heads[repo.name] = repo.commitSha;
-    }
-  }
-  return heads;
-}
-function collectStageExpectedHeads(journal) {
-  const heads = {};
-  const promotion = stringRecord(journal.steps.find((step) => step.id === "promote-to-staging")?.data);
-  const results = Array.isArray(promotion?.results) ? promotion.results : [];
-  for (const entry of results) {
-    const repo = stringRecord(entry);
-    if (typeof repo?.name === "string" && typeof repo.commitSha === "string" && repo.verified === true) {
-      heads[repo.name] = repo.commitSha;
-    }
-  }
-  return heads;
-}
-function classifyWorkflowRunJournal(journal, options = {}) {
-  const reasons = [];
-  const now = options.now ?? nowIso();
-  if (journal.classification?.archivedAt) {
-    return {
-      state: "obsolete",
-      reasons: journal.classification.reasons.length > 0 ? journal.classification.reasons : ["workflow run was archived"],
-      classifiedAt: now,
-      archivedAt: journal.classification.archivedAt
-    };
-  }
-  if (journal.status !== "failed") {
-    return {
-      state: "obsolete",
-      reasons: [`workflow run status is ${journal.status}`],
-      classifiedAt: now
-    };
-  }
-  const recovery = stringRecord(stringRecord(journal.failure)?.details)?.recovery;
-  const recoveryRecord = stringRecord(recovery);
-  const recoveryMarkedResumable = recoveryRecord?.resumable === true;
-  if (!journal.resumable && !recoveryMarkedResumable) {
-    return {
-      state: "obsolete",
-      reasons: ["workflow run is not marked resumable"],
-      classifiedAt: now
-    };
-  }
-  if (journal.command === "switch" && journal.steps.every((step) => step.status === "pending")) {
-    return {
-      state: "obsolete",
-      reasons: ["switch failed before completing any checkout step; rerun switch instead"],
-      classifiedAt: now
-    };
-  }
-  if (options.currentBranch && journal.session.branchName && options.currentBranch !== journal.session.branchName) {
-    reasons.push(`current branch ${options.currentBranch} does not match journal branch ${journal.session.branchName}`);
-  }
-  const releaseGateOnlyCompletion = isReleaseGateOnlyCompletion(journal);
-  if (journal.command === "release" && options.currentHeads && releaseGateOnlyCompletion) {
-    const rootRelease = releaseStepData(journal, "release-root");
-    const expectedRootHead = typeof rootRelease?.stagingCommit === "string" ? rootRelease.stagingCommit : null;
-    const rootHead = options.currentHeads["@treeseed/market"];
-    if (rootHead && expectedRootHead && rootHead !== expectedRootHead) {
-      reasons.push(`market staging head changed from ${expectedRootHead} to ${rootHead}`);
-    }
-    const releasePlan = releaseStepData(journal, "release-plan");
-    for (const name of selectedReleasePackageNames(releasePlan)) {
-      const currentHead = options.currentHeads[name];
-      const expectedHead = expectedPackageHeadAfterReleaseGate(journal, name);
-      if (currentHead && expectedHead && currentHead !== expectedHead) {
-        reasons.push(`${name} staging head changed from ${expectedHead} to ${currentHead}`);
-      }
-    }
-  }
-  if (journal.command === "release" && options.currentHeads && !releaseGateOnlyCompletion) {
-    const releasePlan = stringRecord(journal.steps.find((step) => step.id === "release-plan")?.data);
-    if (releasePlan) {
-      const rootHead = options.currentHeads["@treeseed/market"];
-      const plannedRootHead = journalReleasePlanHead(releasePlan, "@treeseed/market");
-      if (rootHead && plannedRootHead && rootHead !== plannedRootHead) {
-        reasons.push(`market head changed from ${plannedRootHead} to ${rootHead}`);
-      }
-      for (const name of selectedReleasePackageNames(releasePlan)) {
-        const currentHead = options.currentHeads[name];
-        const expectedHead = expectedPackageHeadAfterReleaseGate(journal, name) ?? options.acceptedReleaseHeads?.[name] ?? journalReleasePlanHead(releasePlan, name);
-        if (currentHead && expectedHead && currentHead !== expectedHead) {
-          reasons.push(`${name} head changed from ${expectedHead} to ${currentHead}`);
-        }
-      }
-    }
-  }
-  if (journal.command === "save" && options.currentHeads) {
-    const expectedHeads = collectSaveExpectedHeads(journal);
-    for (const [name, expectedHead] of Object.entries(expectedHeads)) {
-      const currentHead = options.currentHeads[name];
-      if (currentHead && expectedHead && currentHead !== expectedHead) {
-        reasons.push(`${name} head changed from ${expectedHead} to ${currentHead}`);
-      }
-    }
-  }
-  if (journal.command === "stage" && options.currentHeads) {
-    const expectedHeads = collectStageExpectedHeads(journal);
-    for (const [name, expectedHead] of Object.entries(expectedHeads)) {
-      const currentHead = options.currentHeads[name];
-      if (currentHead && currentHead !== expectedHead) {
-        reasons.push(`${name} head changed from staged candidate ${expectedHead} to ${currentHead}`);
-      }
-    }
-  }
-  return {
-    state: reasons.length > 0 ? "stale" : "resumable",
-    reasons: reasons.length > 0 ? reasons : releaseGateOnlyCompletion ? ["release commits already exist; remaining release gates can be rechecked"] : ["workflow run can be resumed"],
-    classifiedAt: now
-  };
-}
-function classifyWorkflowRunJournals(root, options = {}) {
-  return listWorkflowRunJournals(root).map((journal) => ({
-    journal,
-    classification: classifyWorkflowRunJournal(journal, options)
-  }));
-}
-function archiveWorkflowRun(root, runId, classification) {
-  const archivedAt = nowIso();
-  return updateWorkflowRunJournal(root, runId, (journal) => ({
-    ...journal,
-    resumable: false,
-    classification: {
-      ...classification,
-      state: classification.state === "resumable" ? "stale" : classification.state,
-      archivedAt,
-      classifiedAt: archivedAt
-    }
-  }));
-}
-function gateCacheMatches(entry, gate) {
-  return entry.workflow === gate.workflow && entry.headSha === gate.headSha && (gate.repository == null || entry.repo === gate.repository) && (gate.branch == null || entry.branch === gate.branch);
-}
-function getCachedSuccessfulWorkflowGate(root, runId, gate) {
-  const journal = readWorkflowRunJournal(root, runId);
-  const cache = journal?.gateCache ?? [];
-  return cache.find((entry) => gateCacheMatches(entry, gate) && entry.status === "completed" && entry.conclusion === "success") ?? null;
-}
-function cacheWorkflowGateResult(root, runId, result) {
-  const workflow = typeof result.workflow === "string" ? result.workflow : null;
-  const headSha = typeof result.headSha === "string" ? result.headSha : null;
-  if (!workflow || !headSha) {
-    return null;
-  }
-  const entry = {
-    repo: typeof result.repository === "string" ? result.repository : null,
-    workflow,
-    headSha,
-    branch: typeof result.branch === "string" ? result.branch : null,
-    status: typeof result.status === "string" ? result.status : "unknown",
-    conclusion: typeof result.conclusion === "string" ? result.conclusion : null,
-    runId: typeof result.runId === "string" || typeof result.runId === "number" ? result.runId : null,
-    url: typeof result.url === "string" ? result.url : null,
-    cachedAt: nowIso(),
-    result
-  };
-  updateWorkflowRunJournal(root, runId, (journal) => ({
-    ...journal,
-    gateCache: [
-      ...(journal.gateCache ?? []).filter((candidate) => !gateCacheMatches(candidate, {
-        repository: entry.repo,
-        workflow: entry.workflow,
-        headSha: entry.headSha,
-        branch: entry.branch
-      })),
-      entry
-    ]
-  }));
-  return entry;
-}
-function createWorkflowRunJournal(root, options) {
-  const timestamp = nowIso();
-  return writeWorkflowRunJournal(root, {
-    schemaVersion: 1,
-    kind: "treeseed.workflow.run",
-    runId: options.runId,
-    command: options.command,
-    executionMode: options.executionMode ?? "execute",
-    status: "running",
-    createdAt: timestamp,
-    updatedAt: timestamp,
-    resumable: options.steps.every((step) => step.resumable),
-    input: options.input,
-    session: options.session,
-    steps: options.steps.map((step) => ({
-      ...step,
-      status: "pending",
-      startedAt: null,
-      completedAt: null,
-      elapsedMs: null,
-      retryCount: 0,
-      lastFailure: null,
-      data: null
-    })),
-    failure: null,
-    result: null
-  });
-}
-function listWorkflowRunJournalsForScope(root, scope) {
-  const runsDir = workflowRunsRoot(root, null, scope);
-  if (!existsSync(runsDir)) {
-    return [];
-  }
-  return readdirSync(runsDir).filter((entry) => entry.endsWith(".json")).map((entry) => {
-    const path = resolve(runsDir, entry);
-    try {
-      if (statSync(path).size > 5 * 1024 * 1024) {
-        const archivedSummary = archivedWorkflowRunSummary(path);
-        if (archivedSummary) return archivedSummary;
-      }
-    } catch {
-      return null;
-    }
-    return safeJsonParse(path);
-  }).filter((entry) => entry != null).sort((left, right) => right.createdAt.localeCompare(left.createdAt));
-}
-function listWorkflowRunJournals(root) {
-  const local = listWorkflowRunJournalsForScope(root, "worktree");
-  const shared = listWorkflowRunJournalsForScope(root, "shared");
-  const byId = /* @__PURE__ */ new Map();
-  for (const journal of [...local, ...shared]) {
-    byId.set(journal.runId, journal);
-  }
-  return [...byId.values()].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
-}
-function listRecentWorkflowRunJournalsForScope(root, scope, limit) {
-  const runsDir = workflowRunsRoot(root, null, scope);
-  if (!existsSync(runsDir)) {
-    return [];
-  }
-  return readdirSync(runsDir).filter((entry) => entry.endsWith(".json")).map((entry) => {
-    const path = resolve(runsDir, entry);
-    try {
-      return { path, mtimeMs: statSync(path).mtimeMs };
-    } catch {
-      return null;
-    }
-  }).filter((entry) => entry != null).sort((left, right) => right.mtimeMs - left.mtimeMs).slice(0, Math.max(1, limit)).map((entry) => {
-    try {
-      if (statSync(entry.path).size > 5 * 1024 * 1024) {
-        const archivedSummary = archivedWorkflowRunSummary(entry.path);
-        if (archivedSummary) return archivedSummary;
-      }
-    } catch {
-      return null;
-    }
-    return safeJsonParse(entry.path);
-  }).filter((entry) => entry != null);
-}
-function listRecentWorkflowRunJournals(root, limit = 50) {
-  const local = listRecentWorkflowRunJournalsForScope(root, "worktree", limit);
-  const shared = listRecentWorkflowRunJournalsForScope(root, "shared", limit);
-  const byId = /* @__PURE__ */ new Map();
-  for (const journal of [...local, ...shared]) {
-    byId.set(journal.runId, journal);
-  }
-  return [...byId.values()].sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, Math.max(1, limit));
-}
-function listInterruptedWorkflowRuns(root, options = {}) {
-  const journals = options.recentLimit ? listRecentWorkflowRunJournals(root, options.recentLimit) : listWorkflowRunJournals(root);
-  return journals.filter((journal) => journal.status === "failed" && journal.resumable);
-}
-export {
-  acquireWorkflowLock,
-  archiveWorkflowRun,
-  cacheWorkflowGateResult,
-  classifyWorkflowRunJournal,
-  classifyWorkflowRunJournals,
-  createWorkflowRunJournal,
-  generateWorkflowRunId,
-  getCachedSuccessfulWorkflowGate,
-  inspectWorkflowLock,
-  isSharedWorkflowCommand,
-  listInterruptedWorkflowRuns,
-  listRecentWorkflowRunJournals,
-  listWorkflowRunJournals,
-  markActiveWorkflowRunsInterrupted,
-  readWorkflowRunJournal,
-  refreshWorkflowLock,
-  releaseWorkflowLock,
-  updateWorkflowRunJournal,
-  workflowLockScopeForCommand,
-  writeWorkflowRunJournal
-};