@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/workflow-state.js

@@ -1,844 +0,0 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { spawnSync } from "node:child_process";
-import {
-  getTreeseedMachineConfigPaths,
-  inspectTreeseedKeyAgentStatus,
-  loadTreeseedMachineConfig,
-  collectTreeseedConfigSeedValues,
-  resolveTreeseedMachineEnvironmentValues,
-  resolveTreeseedRemoteSession,
-  collectTreeseedEnvironmentContext,
-  withTreeseedKeyAgentAutopromptDisabled
-} from "./operations/services/config-runtime.js";
-import { resolveTreeseedGitHubToken } from "./service-credentials.js";
-import { resolveWranglerBin } from "./operations/services/runtime-tools.js";
-import { getTreeseedEnvironmentSuggestedValues, validateTreeseedEnvironmentValues } from "./platform/environment.js";
-import { resolveTreeseedWebCachePolicy } from "./platform/deploy-config.js";
-import {
-  createBranchPreviewDeployTarget,
-  createPersistentDeployTarget,
-  loadDeployState
-} from "./operations/services/deploy.js";
-import { loadTreeseedPlatformConfig } from "./platform/config.js";
-import { collectCliPreflight } from "./operations/services/workspace-preflight.js";
-import { collectPublicPackageReleaseLineState, currentBranch, gitStatusPorcelain } from "./operations/services/workspace-save.js";
-import { hasCompleteTreeseedPackageCheckout, isWorkspaceRoot } from "./operations/services/workspace-tools.js";
-import { classifyTreeseedGitMode, runTreeseedGitText } from "./operations/services/git-runner.js";
-import { packageAdapterPlanSummary } from "./operations/services/package-adapters.js";
-import { inspectWorkspaceDependencyMode } from "./operations/services/workspace-dependency-mode.js";
-import { inspectDetachedHeadRepair, PRODUCTION_BRANCH, STAGING_BRANCH } from "./operations/services/git-workflow.js";
-import { classifyWorkflowRunJournals, inspectWorkflowLock } from "./workflow/runs.js";
-import { createTreeseedManagedToolEnv, resolveTreeseedToolCommand } from "./managed-dependencies.js";
-import {
-  resolveTreeseedWorkflowPaths,
-  workflowEnvironmentForBranchRole
-} from "./workflow/policy.js";
-function runGit(args, options) {
-  return runTreeseedGitText(args, {
-    cwd: options.cwd,
-    mode: classifyTreeseedGitMode(args),
-    timeoutMs: options.timeoutMs,
-    maxBuffer: options.maxBuffer
-  });
-}
-function emptyPersistentEnvironments() {
-  return {
-    local: { initialized: false, phase: "pending", configured: false, provisioned: false, deployable: false, blockers: [], warnings: [], lastValidatedAt: null, lastDeploymentTimestamp: null, lastDeployedUrl: null },
-    staging: { initialized: false, phase: "pending", configured: false, provisioned: false, deployable: false, blockers: [], warnings: [], lastValidatedAt: null, lastDeploymentTimestamp: null, lastDeployedUrl: null },
-    prod: { initialized: false, phase: "pending", configured: false, provisioned: false, deployable: false, blockers: [], warnings: [], lastValidatedAt: null, lastDeploymentTimestamp: null, lastDeployedUrl: null }
-  };
-}
-function emptyEnvironmentStatus() {
-  return {
-    local: { phase: "pending", ready: false, configured: false, initialized: false, provisioned: false, deployable: false, lastValidatedAt: null, lastDeploymentTimestamp: null, lastDeployedUrl: null, blockers: [], warnings: [] },
-    staging: { phase: "pending", ready: false, configured: false, initialized: false, provisioned: false, deployable: false, lastValidatedAt: null, lastDeploymentTimestamp: null, lastDeployedUrl: null, blockers: [], warnings: [] },
-    prod: { phase: "pending", ready: false, configured: false, initialized: false, provisioned: false, deployable: false, lastValidatedAt: null, lastDeploymentTimestamp: null, lastDeployedUrl: null, blockers: [], warnings: [] }
-  };
-}
-function emptyProviderStatus() {
-  const emptyScope = () => ({
-    github: { configured: false },
-    cloudflare: { configured: false },
-    railway: { configured: false },
-    localDevelopment: { configured: false }
-  });
-  return {
-    local: {
-      ...emptyScope(),
-      railway: { configured: true, applicable: false, detail: "Railway services run locally in the local environment." }
-    },
-    staging: emptyScope(),
-    prod: emptyScope()
-  };
-}
-function readinessForEnvironment(state, scope) {
-  const blockers = [...state.persistentEnvironments[scope].blockers];
-  const warnings = [...state.persistentEnvironments[scope].warnings];
-  if (!state.deployConfigPresent) {
-    blockers.push("Missing treeseed.site.yaml.");
-  }
-  if (!state.files.machineConfig) {
-    blockers.push("Missing Treeseed machine config.");
-  }
-  if (!state.secrets.wrappedKeyPresent) {
-    blockers.push("Missing wrapped Treeseed machine key.");
-  }
-  if (state.secrets.migrationRequired) {
-    blockers.push("Treeseed machine key migration is still required.");
-  }
-  if (scope !== "local") {
-    if (!state.persistentEnvironments[scope].initialized) {
-      blockers.push(`Environment ${scope} is not initialized.`);
-    }
-    if (state.persistentEnvironments[scope].configured && !state.persistentEnvironments[scope].provisioned) {
-      warnings.push(`Environment ${scope} is configured but foundational infrastructure has not been provisioned yet.`);
-    }
-  }
-  return {
-    ready: blockers.length === 0,
-    blockers,
-    warnings
-  };
-}
-function safeResolveRemoteSession(cwd, hostId) {
-  try {
-    return withTreeseedKeyAgentAutopromptDisabled(() => resolveTreeseedRemoteSession(cwd, hostId ?? void 0));
-  } catch {
-    return null;
-  }
-}
-function safeResolveMachineEnvironmentValues(cwd, scope) {
-  try {
-    return withTreeseedKeyAgentAutopromptDisabled(() => resolveTreeseedMachineEnvironmentValues(cwd, scope));
-  } catch {
-    return {};
-  }
-}
-function collectStatusConfigScope(cwd, scope, environmentContext, env = process.env) {
-  const values = collectTreeseedConfigSeedValues(cwd, scope, env);
-  const suggestedValues = getTreeseedEnvironmentSuggestedValues({
-    scope,
-    purpose: "config",
-    deployConfig: environmentContext.context.deployConfig,
-    tenantConfig: environmentContext.context.tenantConfig,
-    plugins: environmentContext.context.plugins,
-    values
-  });
-  const validation = validateTreeseedEnvironmentValues({
-    values: {
-      ...suggestedValues,
-      ...values
-    },
-    scope,
-    purpose: "config",
-    deployConfig: environmentContext.context.deployConfig,
-    tenantConfig: environmentContext.context.tenantConfig,
-    plugins: environmentContext.context.plugins
-  });
-  return {
-    values,
-    suggestedValues,
-    resolvedValues: {
-      ...suggestedValues,
-      ...values
-    },
-    validation
-  };
-}
-function providerProblems(validation, provider) {
-  const problems = [...validation.missing, ...validation.invalid];
-  return problems.filter((problem) => {
-    const id = problem.id.toUpperCase();
-    const group = problem.entry.group;
-    if (provider === "github") {
-      return id === "TREESEED_GITHUB_TOKEN" || group === "github";
-    }
-    if (provider === "cloudflare") {
-      return id.startsWith("CLOUDFLARE_") || id.includes("TURNSTILE") || group === "cloudflare";
-    }
-    if (provider === "railway") {
-      return id.startsWith("RAILWAY_") || group === "railway";
-    }
-    return group === "local-development";
-  });
-}
-function isCloudflareProviderProblem(problem) {
-  const id = problem.id.toUpperCase();
-  return id.startsWith("CLOUDFLARE_") || id.includes("TURNSTILE") || problem.entry.group === "cloudflare";
-}
-function liveCheckResult(configured, live) {
-  return live ? { configured, live } : { configured };
-}
-function spawnLiveCheck(command, args, cwd, env) {
-  const result = spawnSync(command, args, {
-    cwd,
-    env: { ...process.env, ...env },
-    stdio: "pipe",
-    encoding: "utf8",
-    timeout: 15e3
-  });
-  const output = `${result.stderr ?? ""}
-${result.stdout ?? ""}`.trim();
-  return {
-    ok: result.status === 0,
-    detail: output || (result.status === 0 ? "Provider check succeeded." : `Provider check failed with status ${result.status ?? "unknown"}.`)
-  };
-}
-function providerLiveCheck(provider, configured, cwd, env) {
-  if (!configured) {
-    return { checked: true, ready: false, skipped: true, detail: `${provider} token/config is missing.` };
-  }
-  try {
-    const result = (() => {
-      if (provider === "github") {
-        const gh = resolveTreeseedToolCommand("gh", { env });
-        if (!gh) return { ok: false, detail: "GitHub CLI `gh` is unavailable." };
-        return spawnLiveCheck(gh.command, [...gh.argsPrefix, "api", "user", "--jq", ".login"], cwd, createTreeseedManagedToolEnv(env));
-      }
-      if (provider === "cloudflare") {
-        return spawnLiveCheck(process.execPath, [resolveWranglerBin(), "whoami"], cwd, env);
-      }
-      const railway = resolveTreeseedToolCommand("railway", { env });
-      if (!railway) return { ok: false, detail: "Railway CLI is unavailable." };
-      return spawnLiveCheck(railway.command, [...railway.argsPrefix, "whoami"], cwd, env);
-    })();
-    return {
-      checked: true,
-      ready: result.ok,
-      detail: result.detail
-    };
-  } catch (error) {
-    return {
-      checked: true,
-      ready: false,
-      detail: error instanceof Error ? error.message : `${provider} live check failed.`
-    };
-  }
-}
-function providerStatusForScope(cwd, scope, statusConfig, options) {
-  const values = statusConfig.values;
-  const githubConfigured = Boolean(resolveTreeseedGitHubToken(values));
-  const cloudflareConfigured = typeof values.TREESEED_CLOUDFLARE_API_TOKEN === "string" && values.TREESEED_CLOUDFLARE_API_TOKEN.trim().length > 0;
-  const railwayConfigured = typeof values.TREESEED_RAILWAY_API_TOKEN === "string" && values.TREESEED_RAILWAY_API_TOKEN.trim().length > 0;
-  const localDevelopmentConfigured = providerProblems(statusConfig.validation, "localDevelopment").length === 0;
-  const live = options.live === true;
-  const env = statusConfig.resolvedValues;
-  const cloudflare = scope === "local" ? {
-    configured: cloudflareConfigured,
-    applicable: false,
-    detail: cloudflareConfigured ? "Cloudflare is used locally only for optional AI-backed features." : "Cloudflare provider deployment is not used for the local runtime.",
-    ...live ? { live: { checked: true, ready: true, skipped: true, detail: "Wrangler provider checks are not used for the local runtime." } } : {}
-  } : liveCheckResult(cloudflareConfigured, live ? providerLiveCheck("cloudflare", cloudflareConfigured, cwd, env) : void 0);
-  const railway = scope === "local" ? {
-    configured: true,
-    applicable: false,
-    detail: "Railway services run locally in the local environment.",
-    ...live ? { live: { checked: true, ready: true, skipped: true, detail: "Railway is not used for the local environment." } } : {}
-  } : liveCheckResult(railwayConfigured, live ? providerLiveCheck("railway", railwayConfigured, cwd, env) : void 0);
-  return {
-    github: liveCheckResult(githubConfigured, live ? providerLiveCheck("github", githubConfigured, cwd, env) : void 0),
-    cloudflare,
-    railway,
-    localDevelopment: {
-      configured: localDevelopmentConfigured,
-      ...live ? { live: { checked: true, ready: localDevelopmentConfigured, skipped: true, detail: "Local development readiness is validated from saved configuration." } } : {}
-    }
-  };
-}
-function hasStatusConfigValue(statusConfigByScope, key) {
-  return ["local", "staging", "prod"].some((scope) => {
-    const value = statusConfigByScope[scope].values[key];
-    return typeof value === "string" && value.trim().length > 0;
-  });
-}
-function knownRemoteTrackingBranchExists(repoDir, branchName) {
-  try {
-    runGit(["show-ref", "--verify", "--quiet", `refs/remotes/origin/${branchName}`], { cwd: repoDir, capture: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function safeHeadCommit(repoDir) {
-  try {
-    return runGit(["rev-parse", "HEAD"], { cwd: repoDir, capture: true }).trim();
-  } catch {
-    return null;
-  }
-}
-function safeReleaseHistory(repoDir) {
-  if (!repoDir) {
-    return {
-      stagingAheadMain: null,
-      stagingBehindMain: null,
-      unreleasedStagingCommits: null,
-      backMerged: null,
-      detail: "Repository root is unavailable."
-    };
-  }
-  try {
-    const output = runGit(["rev-list", "--left-right", "--count", "staging...main"], { cwd: repoDir, capture: true }).trim();
-    const [aheadRaw, behindRaw] = output.split(/\s+/u);
-    const stagingAheadMain = Number.parseInt(aheadRaw ?? "", 10);
-    const stagingBehindMain = Number.parseInt(behindRaw ?? "", 10);
-    if (!Number.isFinite(stagingAheadMain) || !Number.isFinite(stagingBehindMain)) {
-      throw new Error("invalid rev-list output");
-    }
-    const stagingOnlySubjects = runGit(["log", "--format=%s", "main..staging"], { cwd: repoDir, capture: true }).split("\n").map((line) => line.trim()).filter(Boolean);
-    const unreleasedStagingCommits = stagingOnlySubjects.filter((subject) => subject !== "release: sync package staging heads" && subject !== "release: back-merge main into staging" && !subject.startsWith("release: back-merge main into staging ")).length;
-    return {
-      stagingAheadMain,
-      stagingBehindMain,
-      unreleasedStagingCommits,
-      backMerged: stagingBehindMain === 0,
-      detail: stagingBehindMain === 0 && unreleasedStagingCommits === 0 ? stagingAheadMain > 0 ? "Staging contains current main release history and is only ahead by release sync commits." : "Staging contains current main release history." : stagingBehindMain === 0 ? `Staging has ${unreleasedStagingCommits} unreleased commit${unreleasedStagingCommits === 1 ? "" : "s"} and contains current main release history.` : `Staging is missing ${stagingBehindMain} main commit${stagingBehindMain === 1 ? "" : "s"}.`
-    };
-  } catch {
-    return {
-      stagingAheadMain: null,
-      stagingBehindMain: null,
-      unreleasedStagingCommits: null,
-      backMerged: null,
-      detail: "Could not compare staging and main release history."
-    };
-  }
-}
-const DEFAULT_WORKFLOW_RUN_HISTORY_LIMIT = 20;
-function capWorkflowRunHistory(runs, options = {}) {
-  const historyMode = options.history === "all" ? "all" : "recent";
-  const limit = options.limit ?? DEFAULT_WORKFLOW_RUN_HISTORY_LIMIT;
-  const total = runs.length;
-  if (historyMode === "all") {
-    return {
-      historyMode,
-      runs,
-      total,
-      omitted: 0
-    };
-  }
-  const cappedRuns = runs.slice(0, limit);
-  return {
-    historyMode,
-    runs: cappedRuns,
-    total,
-    omitted: Math.max(0, total - cappedRuns.length)
-  };
-}
-function capObsoleteWorkflowRuns(obsoleteRuns, options = {}) {
-  const capped = capWorkflowRunHistory(obsoleteRuns, options);
-  return {
-    historyMode: capped.historyMode,
-    obsoleteRuns: capped.runs,
-    obsoleteRunsTotal: capped.total,
-    obsoleteRunsOmitted: capped.omitted
-  };
-}
-function resolveLocalStatusUrl(deployConfig) {
-  return deployConfig.surfaces?.web?.localBaseUrl ?? deployConfig.surfaces?.api?.localBaseUrl ?? Object.values(deployConfig.services ?? {}).find((service) => service?.enabled !== false && service.environments?.local?.baseUrl)?.environments?.local?.baseUrl ?? null;
-}
-function resolveTreeseedWorkflowState(cwd, options = {}) {
-  const resolved = resolveTreeseedWorkflowPaths(cwd);
-  const effectiveCwd = resolved.cwd;
-  const workspaceRoot = isWorkspaceRoot(effectiveCwd);
-  const treeseedConfigPath = resolve(effectiveCwd, "treeseed.site.yaml");
-  const tenantRoot = existsSync(treeseedConfigPath);
-  const root = resolved.repoRoot;
-  const branchName = resolved.branchName;
-  const branchRole = resolved.branchRole;
-  const dirtyWorktree = root ? gitStatusPorcelain(root).length > 0 : false;
-  const completePackageCheckout = hasCompleteTreeseedPackageCheckout(effectiveCwd);
-  const workspaceDependencyMode = inspectWorkspaceDependencyMode(effectiveCwd);
-  const packageAdapters = workspaceRoot ? packageAdapterPlanSummary(effectiveCwd) : [];
-  const packageSyncRepos = workspaceRoot ? packageAdapters.map((pkg) => {
-    const packageDir = resolve(effectiveCwd, pkg.path);
-    const repoBranch = currentBranch(packageDir) || null;
-    const dirty = gitStatusPorcelain(packageDir).length > 0;
-    const expectedBranch = branchName;
-    const detachedRepair = repoBranch ? null : inspectDetachedHeadRepair(packageDir, [expectedBranch, STAGING_BRANCH, PRODUCTION_BRANCH].filter((branch) => Boolean(branch)));
-    let localBranch = false;
-    if (expectedBranch) {
-      if (repoBranch === expectedBranch) {
-        localBranch = true;
-      } else {
-        try {
-          runGit(["show-ref", "--verify", "--quiet", `refs/heads/${expectedBranch}`], { cwd: packageDir, capture: true });
-          localBranch = true;
-        } catch {
-          localBranch = false;
-        }
-      }
-    }
-    const remoteBranch = Boolean(expectedBranch) ? knownRemoteTrackingBranchExists(packageDir, expectedBranch) : false;
-    return {
-      name: pkg.id,
-      path: pkg.path,
-      branchName: repoBranch,
-      dirty,
-      aligned: expectedBranch ? repoBranch === expectedBranch : true,
-      localBranch,
-      remoteBranch,
-      detached: repoBranch == null,
-      detachedRepair: detachedRepair ? {
-        repairable: detachedRepair.repairable,
-        targetBranch: detachedRepair.targetBranch,
-        headSha: detachedRepair.headSha,
-        targetSha: detachedRepair.targetSha,
-        dirty: detachedRepair.dirty,
-        blocker: detachedRepair.blocker
-      } : null
-    };
-  }) : [];
-  const packageSyncBlockers = [];
-  const packageSyncWarnings = [];
-  const packageReleaseLine = completePackageCheckout ? collectPublicPackageReleaseLineState(effectiveCwd) : null;
-  if (packageReleaseLine?.drifted) {
-    packageSyncWarnings.push(`Public package release lines are drifted: ${packageReleaseLine.packages.map((pkg) => `${pkg.name}@${pkg.version}`).join(", ")}.`);
-  }
-  for (const repo of packageSyncRepos) {
-    if (repo.dirty) {
-      packageSyncBlockers.push(`${repo.name} has uncommitted changes.`);
-    }
-    const detachedRepair = repo.detachedRepair;
-    if (repo.detached && detachedRepair?.repairable === true) {
-      const targetBranch = typeof detachedRepair.targetBranch === "string" ? detachedRepair.targetBranch : branchName;
-      const dirtyNote = detachedRepair.dirty === true ? " with local changes preserved" : "";
-      packageSyncWarnings.push(`${repo.name} is detached at ${targetBranch ?? "an expected branch"} HEAD${dirtyNote}; workflow commands can reattach it automatically.`);
-      continue;
-    }
-    if (repo.detached && detachedRepair?.repairable !== true) {
-      packageSyncBlockers.push(`${repo.name} is detached at a commit that does not match ${branchName ?? STAGING_BRANCH}/${PRODUCTION_BRANCH}; review manually.`);
-      continue;
-    }
-    if (branchName && !repo.localBranch && !repo.remoteBranch) {
-      packageSyncBlockers.push(`${repo.name} is missing branch ${branchName}.`);
-      continue;
-    }
-    if (branchName && !repo.aligned) {
-      packageSyncBlockers.push(`${repo.name} is on ${repo.branchName ?? "(detached)"} instead of ${branchName}.`);
-    }
-  }
-  const preflight = collectCliPreflight({ cwd: effectiveCwd, requireAuth: false });
-  const { configPath, keyPath } = getTreeseedMachineConfigPaths(effectiveCwd);
-  const machineConfig = existsSync(configPath) ? loadTreeseedMachineConfig(effectiveCwd) : null;
-  const keyStatus = inspectTreeseedKeyAgentStatus(effectiveCwd);
-  const marketSettings = machineConfig?.settings?.market && typeof machineConfig.settings.market === "object" ? machineConfig.settings.market : null;
-  const runnerHostId = typeof marketSettings?.runnerHostId === "string" && marketSettings.runnerHostId.trim() ? marketSettings.runnerHostId.trim() : typeof marketSettings?.projectId === "string" && marketSettings.projectId.trim() ? `operations-runner:${marketSettings.projectId.trim()}` : null;
-  const runnerSession = runnerHostId ? safeResolveRemoteSession(effectiveCwd, runnerHostId) : null;
-  const workflowLock = inspectWorkflowLock(effectiveCwd, { scope: "worktree" });
-  const workflowRunHeads = {};
-  if (root) {
-    workflowRunHeads["@treeseed/market"] = safeHeadCommit(root);
-  }
-  for (const pkg of packageAdapters) {
-    workflowRunHeads[pkg.id] = safeHeadCommit(resolve(effectiveCwd, pkg.path));
-  }
-  const classifiedRuns = classifyWorkflowRunJournals(effectiveCwd, {
-    currentBranch: branchName,
-    currentHeads: workflowRunHeads
-  });
-  const interruptedRuns = classifiedRuns.filter((entry) => entry.classification.state === "resumable").map(({ journal }) => ({
-    runId: journal.runId,
-    command: journal.command,
-    updatedAt: journal.updatedAt,
-    nextStep: journal.steps.find((step) => step.status === "pending")?.description ?? null
-  }));
-  const staleRuns = classifiedRuns.filter((entry) => entry.classification.state === "stale").map(({ journal, classification }) => ({
-    runId: journal.runId,
-    command: journal.command,
-    updatedAt: journal.updatedAt,
-    nextStep: journal.steps.find((step) => step.status === "pending")?.description ?? null,
-    reasons: classification.reasons
-  }));
-  const staleHistory = capWorkflowRunHistory(staleRuns, { history: options.history });
-  const obsoleteRuns = classifiedRuns.filter((entry) => entry.classification.state === "obsolete").map(({ journal, classification }) => ({
-    runId: journal.runId,
-    command: journal.command,
-    updatedAt: journal.updatedAt,
-    reasons: classification.reasons
-  }));
-  const obsoleteHistory = capObsoleteWorkflowRuns(obsoleteRuns, { history: options.history });
-  const workflowBlockers = [];
-  if (workflowLock.active && workflowLock.lock) {
-    workflowBlockers.push(`Workflow lock active for ${workflowLock.lock.command} (${workflowLock.lock.runId}).`);
-  }
-  if (workflowLock.stale && workflowLock.lock) {
-    workflowBlockers.push(`Workflow lock is stale: ${workflowLock.staleReason}.`);
-  }
-  if (interruptedRuns.length > 0) {
-    workflowBlockers.push(`Interrupted workflow runs detected: ${interruptedRuns.map((run2) => run2.runId).join(", ")}.`);
-  }
-  const releaseHistory = safeReleaseHistory(root);
-  const releaseReady = branchRole === "staging" && !dirtyWorktree && (releaseHistory.unreleasedStagingCommits ?? 0) > 0;
-  const state = {
-    cwd: effectiveCwd,
-    workspaceRoot,
-    tenantRoot,
-    deployConfigPresent: tenantRoot,
-    repoRoot: root,
-    branchName,
-    branchRole,
-    environment: workflowEnvironmentForBranchRole(branchRole),
-    dirtyWorktree,
-    workflowControl: {
-      lock: {
-        active: workflowLock.active,
-        stale: workflowLock.stale,
-        runId: workflowLock.lock?.runId ?? null,
-        command: workflowLock.lock?.command ?? null,
-        updatedAt: workflowLock.lock?.updatedAt ?? null,
-        staleReason: workflowLock.staleReason
-      },
-      interruptedRuns,
-      staleRuns: staleHistory.runs,
-      staleRunsTotal: staleHistory.total,
-      staleRunsOmitted: staleHistory.omitted,
-      obsoleteRuns: obsoleteHistory.obsoleteRuns,
-      historyMode: obsoleteHistory.historyMode,
-      obsoleteRunsTotal: obsoleteHistory.obsoleteRunsTotal,
-      obsoleteRunsOmitted: obsoleteHistory.obsoleteRunsOmitted,
-      blockers: workflowBlockers
-    },
-    packageSync: {
-      mode: completePackageCheckout || packageSyncRepos.length > 0 ? "recursive-workspace" : "root-only",
-      completeCheckout: completePackageCheckout,
-      dependencyMode: workspaceDependencyMode.mode,
-      workspaceLinks: workspaceDependencyMode,
-      expectedBranch: branchName,
-      aligned: packageSyncRepos.every((repo) => repo.aligned),
-      dirty: packageSyncRepos.some((repo) => repo.dirty),
-      repos: packageSyncRepos,
-      blockers: packageSyncBlockers,
-      warnings: packageSyncWarnings,
-      releaseLine: packageReleaseLine,
-      packages: packageAdapters
-    },
-    preview: {
-      enabled: false,
-      url: null,
-      lastDeploymentTimestamp: null
-    },
-    webCache: {
-      webHost: null,
-      contentHost: null,
-      sourcePagePolicy: null,
-      contentPagePolicy: null,
-      r2ObjectPolicy: null,
-      cloudflareRulesManaged: false,
-      lastDeployPurgeAt: null,
-      lastDeployPurgeCount: null,
-      lastContentPurgeAt: null,
-      lastContentPurgeCount: null
-    },
-    persistentEnvironments: emptyPersistentEnvironments(),
-    environmentStatus: emptyEnvironmentStatus(),
-    providerStatus: emptyProviderStatus(),
-    auth: {
-      gh: preflight.checks.auth.gh?.authenticated === true,
-      wrangler: preflight.checks.auth.wrangler?.authenticated === true,
-      railway: preflight.checks.auth.railway?.authenticated === true,
-      copilot: preflight.checks.auth.copilot?.configured === true,
-      remoteApi: Boolean(safeResolveRemoteSession(cwd))
-    },
-    marketConnection: {
-      configured: Boolean(marketSettings?.baseUrl && marketSettings?.projectId),
-      baseUrl: typeof marketSettings?.baseUrl === "string" ? marketSettings.baseUrl : null,
-      hostId: typeof marketSettings?.hostId === "string" ? marketSettings.hostId : null,
-      teamId: typeof marketSettings?.teamId === "string" ? marketSettings.teamId : null,
-      teamSlug: typeof marketSettings?.teamSlug === "string" ? marketSettings.teamSlug : null,
-      projectId: typeof marketSettings?.projectId === "string" ? marketSettings.projectId : null,
-      projectSlug: typeof marketSettings?.projectSlug === "string" ? marketSettings.projectSlug : null,
-      connectionMode: typeof marketSettings?.connectionMode === "string" ? marketSettings.connectionMode : null,
-      projectApiBaseUrl: typeof marketSettings?.projectApiBaseUrl === "string" ? marketSettings.projectApiBaseUrl : null,
-      hubMode: null,
-      runtimeMode: null,
-      runtimeRegistration: null,
-      runtimeAttached: false,
-      runtimeReady: true,
-      runnerHostId,
-      runnerReady: Boolean(
-        marketSettings?.runnerReady === true || typeof runnerSession?.accessToken === "string" && runnerSession.accessToken.length > 0
-      ),
-      runnerRegisteredAt: typeof marketSettings?.runnerRegisteredAt === "string" ? marketSettings.runnerRegisteredAt : null,
-      runnerLastSeenAt: typeof marketSettings?.runnerLastSeenAt === "string" ? marketSettings.runnerLastSeenAt : null,
-      launchPhase: typeof marketSettings?.launchPhase === "string" ? marketSettings.launchPhase : null,
-      lastSuccessfulPhase: typeof marketSettings?.lastSuccessfulPhase === "string" ? marketSettings.lastSuccessfulPhase : null,
-      githubRepository: typeof marketSettings?.githubRepository === "string" ? marketSettings.githubRepository : null,
-      workflowBootstrapReady: marketSettings?.workflowBootstrapReady === true,
-      currentWorkstreamId: branchRole === "feature" ? branchName : null,
-      verificationPosture: typeof marketSettings?.launchPhase === "string" && marketSettings.launchPhase === "failed" ? "blocked" : "pending",
-      approvalBlockers: Array.isArray(marketSettings?.approvalBlockers) ? marketSettings.approvalBlockers.map(String) : []
-    },
-    managedServices: {
-      api: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
-      workdayManager: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null },
-      workerRunner: { enabled: false, initialized: false, lastDeploymentTimestamp: null, lastDeployedUrl: null, provider: null }
-    },
-    files: {
-      treeseedConfig: tenantRoot,
-      machineConfig: existsSync(configPath),
-      machineKey: existsSync(keyPath)
-    },
-    secrets: {
-      keyAgentRunning: keyStatus.running,
-      keyAgentUnlocked: keyStatus.unlocked,
-      wrappedKeyPresent: keyStatus.wrappedKeyPresent,
-      migrationRequired: keyStatus.migrationRequired,
-      idleTimeoutMs: keyStatus.idleTimeoutMs,
-      idleRemainingMs: keyStatus.idleRemainingMs,
-      startupPassphraseConfigured: Boolean(process.env.TREESEED_KEY_PASSPHRASE?.trim())
-    },
-    releaseReady,
-    releaseHistory,
-    readiness: {
-      local: { ready: false, blockers: [], warnings: [] },
-      staging: { ready: false, blockers: [], warnings: [] },
-      prod: { ready: false, blockers: [], warnings: [] }
-    },
-    rollbackCandidates: [],
-    recommendations: []
-  };
-  if (tenantRoot) {
-    try {
-      const deployConfig = loadTreeseedPlatformConfig({ tenantRoot: effectiveCwd, environment: workflowEnvironmentForBranchRole(branchRole), env: options.env ?? process.env }).deployConfig;
-      const environmentContext = collectTreeseedEnvironmentContext(effectiveCwd);
-      const statusConfigByScope = Object.fromEntries(
-        ["local", "staging", "prod"].map((scope) => [
-          scope,
-          collectStatusConfigScope(effectiveCwd, scope, environmentContext, options.env)
-        ])
-      );
-      state.providerStatus = Object.fromEntries(
-        ["local", "staging", "prod"].map((scope) => [
-          scope,
-          providerStatusForScope(effectiveCwd, scope, statusConfigByScope[scope], options)
-        ])
-      );
-      const sharedConfigValues = statusConfigByScope.prod.resolvedValues;
-      const runtimeMode = deployConfig.runtime?.mode ?? "none";
-      const runtimeRegistration = deployConfig.runtime?.registration ?? "none";
-      const webCachePolicy = resolveTreeseedWebCachePolicy(deployConfig);
-      const registrationRequired2 = runtimeRegistration === "required";
-      const registrationEnabled = runtimeRegistration === "required" || runtimeRegistration === "optional";
-      const runtimeSessionReady = Boolean(
-        marketSettings?.runnerReady === true || typeof runnerSession?.accessToken === "string" && runnerSession.accessToken.length > 0
-      );
-      state.auth.gh = state.auth.gh || Boolean(resolveTreeseedGitHubToken(statusConfigByScope.local.values)) || Boolean(resolveTreeseedGitHubToken(statusConfigByScope.staging.values)) || Boolean(resolveTreeseedGitHubToken(statusConfigByScope.prod.values));
-      state.auth.wrangler = state.auth.wrangler || hasStatusConfigValue(statusConfigByScope, "TREESEED_CLOUDFLARE_API_TOKEN");
-      state.auth.railway = state.auth.railway || hasStatusConfigValue(statusConfigByScope, "TREESEED_RAILWAY_API_TOKEN");
-      state.auth.copilot = state.auth.copilot || state.auth.gh;
-      state.marketConnection.baseUrl = state.marketConnection.baseUrl ?? sharedConfigValues.TREESEED_API_BASE_URL ?? deployConfig.runtime?.marketBaseUrl ?? deployConfig.hosting?.marketBaseUrl ?? null;
-      state.marketConnection.teamId = state.marketConnection.teamId ?? sharedConfigValues.TREESEED_HOSTING_TEAM_ID ?? deployConfig.runtime?.teamId ?? deployConfig.hosting?.teamId ?? null;
-      state.marketConnection.projectId = state.marketConnection.projectId ?? sharedConfigValues.TREESEED_PROJECT_ID ?? deployConfig.runtime?.projectId ?? deployConfig.hosting?.projectId ?? null;
-      state.marketConnection.hubMode = deployConfig.hub?.mode ?? null;
-      state.marketConnection.runtimeMode = runtimeMode;
-      state.marketConnection.runtimeRegistration = runtimeRegistration;
-      state.marketConnection.runtimeAttached = runtimeMode !== "none" && (!registrationEnabled || state.marketConnection.configured);
-      state.marketConnection.runtimeReady = runtimeMode === "none" || !registrationEnabled || runtimeSessionReady;
-      state.marketConnection.runnerReady = runtimeSessionReady;
-      state.webCache.webHost = deployConfig.surfaces?.web?.publicBaseUrl ?? deployConfig.siteUrl ?? null;
-      state.webCache.contentHost = sharedConfigValues.TREESEED_CONTENT_PUBLIC_BASE_URL ?? deployConfig.cloudflare.r2?.publicBaseUrl ?? null;
-      state.webCache.sourcePagePolicy = `browser=${webCachePolicy.sourcePages.browserTtlSeconds}s edge=${webCachePolicy.sourcePages.edgeTtlSeconds}s swr=${webCachePolicy.sourcePages.staleWhileRevalidateSeconds}s sie=${webCachePolicy.sourcePages.staleIfErrorSeconds}s`;
-      state.webCache.contentPagePolicy = `browser=${webCachePolicy.contentPages.browserTtlSeconds}s edge=${webCachePolicy.contentPages.edgeTtlSeconds}s swr=${webCachePolicy.contentPages.staleWhileRevalidateSeconds}s sie=${webCachePolicy.contentPages.staleIfErrorSeconds}s`;
-      state.webCache.r2ObjectPolicy = `browser=${webCachePolicy.r2PublishedObjects.browserTtlSeconds}s edge=${webCachePolicy.r2PublishedObjects.edgeTtlSeconds}s swr=${webCachePolicy.r2PublishedObjects.staleWhileRevalidateSeconds}s sie=${webCachePolicy.r2PublishedObjects.staleIfErrorSeconds}s`;
-      state.marketConnection.configured = registrationRequired2 ? Boolean(state.marketConnection.baseUrl && state.marketConnection.projectId) : state.marketConnection.configured;
-      const localStatusUrl = resolveLocalStatusUrl(deployConfig);
-      for (const scope of ["local", "staging", "prod"]) {
-        const deployState = loadDeployState(effectiveCwd, deployConfig, { target: createPersistentDeployTarget(scope) });
-        const validation = statusConfigByScope[scope].validation;
-        const rawValidationProblems = [...validation.missing, ...validation.invalid];
-        const statusValidationProblems = scope === "local" ? rawValidationProblems.filter((problem) => !isCloudflareProviderProblem(problem)) : rawValidationProblems;
-        const validationProblems = statusValidationProblems.map((problem) => problem.message);
-        const statusValidationOk = statusValidationProblems.length === 0;
-        const persistentBlockers = Array.isArray(deployState.readiness?.blockers) ? deployState.readiness.blockers.map(String) : [];
-        const persistentWarnings = Array.isArray(deployState.readiness?.warnings) ? deployState.readiness.warnings.map(String) : [];
-        const configured = scope === "local" ? statusValidationOk : deployState.readiness?.configured === true && statusValidationOk;
-        const provisioned = scope === "local" ? true : configured && deployState.readiness?.provisioned === true;
-        const deployable = scope === "local" ? statusValidationOk : configured && deployState.readiness?.deployable === true;
-        const initialized = deployState.readiness?.initialized === true || scope === "local";
-        state.persistentEnvironments[scope] = {
-          initialized,
-          phase: statusValidationOk ? scope === "local" ? "code_ready" : provisioned ? "provisioned" : configured ? "config_complete" : initialized ? "config_complete" : "pending" : "config_incomplete",
-          configured,
-          provisioned,
-          deployable,
-          blockers: [
-            ...validationProblems,
-            ...persistentBlockers
-          ],
-          warnings: persistentWarnings,
-          lastValidatedAt: deployState.readiness?.lastValidatedAt ?? deployState.readiness?.initializedAt ?? null,
-          lastDeploymentTimestamp: scope === "local" ? null : deployState.lastDeploymentTimestamp ?? null,
-          lastDeployedUrl: scope === "local" ? localStatusUrl : deployState.lastDeployedUrl ?? null
-        };
-        if (scope !== "local") {
-          const history = Array.isArray(deployState.deploymentHistory) ? deployState.deploymentHistory ?? [] : [];
-          const latestHistory = history.at(-1) ?? null;
-          state.rollbackCandidates.push({
-            scope,
-            commit: typeof latestHistory?.commit === "string" ? latestHistory.commit : deployState.lastDeployedCommit ?? null,
-            timestamp: typeof latestHistory?.timestamp === "string" ? latestHistory.timestamp : deployState.lastDeploymentTimestamp ?? null,
-            url: typeof latestHistory?.url === "string" ? latestHistory.url : deployState.lastDeployedUrl ?? null
-          });
-        }
-        if (scope === "prod") {
-          state.webCache.cloudflareRulesManaged = deployState.webCache?.rulesManaged === true;
-          state.webCache.lastDeployPurgeAt = deployState.webCache?.deployPurge?.lastPurgedAt ?? null;
-          state.webCache.lastDeployPurgeCount = deployState.webCache?.deployPurge?.purgeCount ?? null;
-          state.webCache.lastContentPurgeAt = deployState.webCache?.contentPurge?.lastPurgedAt ?? null;
-          state.webCache.lastContentPurgeCount = deployState.webCache?.contentPurge?.purgeCount ?? null;
-        }
-        for (const serviceKey of ["api", "workdayManager", "workerRunner"]) {
-          const service = deployState.services?.[serviceKey];
-          if (!service) continue;
-          state.managedServices[serviceKey] = {
-            enabled: service.enabled === true,
-            initialized: service.initialized === true,
-            lastDeploymentTimestamp: service.lastDeploymentTimestamp ?? null,
-            lastDeployedUrl: service.lastDeployedUrl ?? service.publicBaseUrl ?? null,
-            provider: service.provider ?? null
-          };
-        }
-      }
-      if (branchRole === "feature" && branchName) {
-        const previewState = loadDeployState(effectiveCwd, deployConfig, { target: createBranchPreviewDeployTarget(branchName) });
-        state.preview = {
-          enabled: previewState.previewEnabled === true || previewState.readiness?.initialized === true,
-          url: previewState.lastDeployedUrl ?? null,
-          lastDeploymentTimestamp: previewState.lastDeploymentTimestamp ?? null
-        };
-      }
-    } catch {
-    }
-  }
-  state.readiness.local = readinessForEnvironment(state, "local");
-  state.readiness.staging = readinessForEnvironment(state, "staging");
-  state.readiness.prod = readinessForEnvironment(state, "prod");
-  for (const scope of ["local", "staging", "prod"]) {
-    const persistent = state.persistentEnvironments[scope];
-    const readiness = state.readiness[scope];
-    state.environmentStatus[scope] = {
-      phase: persistent.phase,
-      ready: readiness.ready,
-      configured: persistent.configured,
-      initialized: persistent.initialized,
-      provisioned: persistent.provisioned,
-      deployable: persistent.deployable,
-      lastValidatedAt: persistent.lastValidatedAt,
-      lastDeploymentTimestamp: persistent.lastDeploymentTimestamp,
-      lastDeployedUrl: persistent.lastDeployedUrl,
-      blockers: readiness.blockers,
-      warnings: readiness.warnings
-    };
-  }
-  state.marketConnection.verificationPosture = state.readiness.local.ready ? "ready" : state.files.machineConfig ? "blocked" : "pending";
-  const registrationRequired = state.marketConnection.runtimeRegistration === "required";
-  state.marketConnection.approvalBlockers = [
-    ...registrationRequired && !state.marketConnection.configured ? ["TreeSeed runtime attachment is not configured."] : [],
-    ...registrationRequired && !state.marketConnection.runtimeReady ? ["TreeSeed runtime credential is missing or not ready."] : []
-  ];
-  state.recommendations = recommendTreeseedNextSteps(state);
-  return state;
-}
-function recommendTreeseedNextSteps(state) {
-  const recommendations = [];
-  if (!state.workspaceRoot) {
-    return [{ operation: "status", reason: "Run this from inside a Treeseed workspace so the project root can be resolved." }];
-  }
-  if (!state.deployConfigPresent) {
-    return [{ operation: "init", reason: "Create a new Treeseed tenant before configuring or releasing anything.", input: { directory: "<directory>" } }];
-  }
-  if (!state.files.machineConfig) {
-    recommendations.push({ operation: "status", reason: "Validate tooling, auth, and repository readiness first." });
-    recommendations.push({ operation: "config", reason: "Bootstrap the local machine config and injected runtime environment." });
-    return recommendations;
-  }
-  if (!state.secrets.wrappedKeyPresent || state.secrets.migrationRequired) {
-    recommendations.push({
-      operation: state.secrets.migrationRequired ? "secrets:migrate-key" : "secrets:unlock",
-      reason: state.secrets.migrationRequired ? "Wrap the local machine key before running secret-backed commands." : "Create and unlock the local wrapped machine key before running secret-backed commands."
-    });
-    return recommendations;
-  }
-  if (state.workflowControl.interruptedRuns.length > 0) {
-    recommendations.push({
-      operation: "resume",
-      reason: "Resume the most recent interrupted workflow run before making new branch changes.",
-      input: { runId: state.workflowControl.interruptedRuns[0].runId }
-    });
-    recommendations.push({ operation: "recover", reason: "Inspect active workflow locks and interrupted runs." });
-    return recommendations.slice(0, 3);
-  }
-  if (state.workflowControl.lock.active && state.workflowControl.lock.runId) {
-    recommendations.push({ operation: "recover", reason: "Inspect the active workflow lock before starting another mutating command." });
-    return recommendations.slice(0, 3);
-  }
-  if (state.branchRole === "feature") {
-    if (state.packageSync.mode === "recursive-workspace" && state.packageSync.blockers.length > 0 && state.branchName) {
-      recommendations.push({
-        operation: "switch",
-        reason: "Realign the checked-out package repos to the current task branch before continuing.",
-        input: { branch: state.branchName }
-      });
-    }
-    recommendations.push({ operation: "stage", reason: "Merge this task branch into staging and clean up branch artifacts.", input: { message: "describe the resolution" } });
-    recommendations.push({ operation: "save", reason: "Persist, verify, and push the current task branch before or independently of staging it.", input: { message: "describe your change" } });
-    if (state.preview.enabled && state.branchName) {
-      recommendations.push({ operation: "save", reason: "Save refreshes the branch preview deployment when one is enabled.", input: { message: "describe your change", preview: true } });
-    } else {
-      recommendations.push({ operation: "dev", reason: "Use the local environment for iterative work on this feature branch." });
-    }
-    recommendations.push({ operation: "close", reason: "Archive this task without merging if it should be abandoned.", input: { message: "reason" } });
-    return recommendations.slice(0, 3);
-  }
-  if (state.branchRole === "staging") {
-    if (state.packageSync.mode === "recursive-workspace" && state.packageSync.warnings.length > 0 && state.branchName) {
-      recommendations.push({
-        operation: "release",
-        reason: "Reattach repairable package repos automatically before continuing the release.",
-        input: { bump: "patch" }
-      });
-    }
-    if (state.packageSync.mode === "recursive-workspace" && state.packageSync.blockers.length > 0 && state.branchName) {
-      recommendations.push({
-        operation: "switch",
-        reason: "Realign the checked-out package repos to staging before releasing.",
-        input: { branch: state.branchName }
-      });
-    }
-    if (!state.persistentEnvironments.staging.initialized) {
-      recommendations.push({ operation: "config", reason: "Initialize the staging environment before releasing.", input: { environment: ["staging"] } });
-    } else if ((state.releaseHistory.unreleasedStagingCommits ?? 0) > 0) {
-      recommendations.push({ operation: "release", reason: "Promote unreleased staging commits into production.", input: { bump: "patch" } });
-      if (state.managedServices.api.enabled) {
-        recommendations.push({ operation: "auth:login", reason: "Keep the local runtime authenticated to the remote API used by managed services." });
-      }
-    } else {
-      recommendations.push({ operation: "status", reason: "Inspect staging and production state; no unreleased staging commits are pending." });
-      if (state.managedServices.api.enabled) {
-        recommendations.push({ operation: "auth:login", reason: "Keep the local runtime authenticated to the remote API used by managed services." });
-      }
-    }
-    return recommendations.slice(0, 3);
-  }
-  if (state.branchRole === "main") {
-    if (state.dirtyWorktree) {
-      recommendations.push({ operation: "save", reason: "Only explicit hotfix saves are allowed on main.", input: { message: "describe the hotfix", hotfix: true } });
-    } else if (!state.persistentEnvironments.prod.initialized) {
-      recommendations.push({ operation: "config", reason: "Initialize production before a release requires it.", input: { environment: ["prod"] } });
-    } else {
-      recommendations.push({ operation: "status", reason: "Inspect production state and release readiness." });
-      recommendations.push({ operation: "rollback", reason: "Roll back production to the previous recorded deployment if needed.", input: { environment: "prod" } });
-    }
-    return recommendations.slice(0, 3);
-  }
-  recommendations.push({ operation: "dev", reason: "Start the local Treeseed development environment." });
-  recommendations.push({ operation: "switch", reason: "Create a task branch from the latest staging commit.", input: { branch: "feature/my-change" } });
-  return recommendations.slice(0, 3);
-}
-export {
-  capObsoleteWorkflowRuns,
-  capWorkflowRunHistory,
-  recommendTreeseedNextSteps,
-  resolveTreeseedWorkflowState
-};