@treeseed/sdk 0.13.0-rc.8 → 0.13.0-rc.80

package/dist/workflow/operations/repositories/gates-for-saved-repository-reports.js

@@ -1,226 +0,0 @@
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { checkoutBranch } from "../../../operations/services/operations/git-workflow.js";
-import { discoverPackageAdapters } from "../../../operations/services/reconciliation/package-adapters.js";
-import { currentBranch, repoRoot } from "../../../operations/services/treedx/workspaces/workspace-save.js";
-import { archiveWorkflowRun, classifyWorkflowRunJournal, listInterruptedWorkflowRuns } from "../../runs.js";
-import { checkedOutWorkspacePackageRepos } from "../../session.js";
-import { workflowError } from "../release-support/helpers/run-release-production-guarantees.js";
-import { hostedWorkflowsForSavedRepository } from "../support/workflow-helpers.js";
-import { ensureWorkflowWorkspaceLinks, runGit } from "../recovery/workflow-write.js";
-function gatesForSavedRepositoryReports(root, reports) {
-  const adapterByPath = new Map(discoverPackageAdapters(root).map((adapter) => [resolve(adapter.dir), adapter]));
-  return reports.filter((repo) => repo.pushed && repo.commitSha && repo.branch && (repo.committed || repo.tagName)).flatMap((repo) => {
-    const adapter = adapterByPath.get(resolve(repo.path));
-    return hostedWorkflowsForSavedRepository(root, repo, adapter).map((workflow) => {
-      const gate = {
-        name: repo.name,
-        repoPath: repo.path,
-        workflow,
-        branch: String(repo.branch),
-        headSha: String(repo.commitSha),
-        ...packageHostedVerifyTimeoutSeconds(adapter) ? { timeoutSeconds: packageHostedVerifyTimeoutSeconds(adapter) } : {}
-      };
-      return gate;
-    });
-  });
-}
-function packageHostedVerifyWorkflow(adapter) {
-  const workflow = adapter?.metadata?.hostedVerifyWorkflow;
-  return typeof workflow === "string" && workflow.trim() ? workflow.trim().replace(/^\.github\/workflows\//u, "") : null;
-}
-function packageHostedVerifyTimeoutSeconds(adapter) {
-  const timeoutSeconds = adapter?.metadata?.hostedVerifyTimeoutSeconds;
-  return typeof timeoutSeconds === "number" && Number.isFinite(timeoutSeconds) && timeoutSeconds > 0 ? Math.floor(timeoutSeconds) : null;
-}
-function gateForSavedRootReport(report, branch, scope) {
-  if (!branch || scope === "local" || !report.pushed || !report.commitSha) {
-    return [];
-  }
-  return [{
-    name: report.name,
-    repoPath: report.path,
-    workflow: "verify.yml",
-    branch,
-    headSha: report.commitSha
-  }];
-}
-function findAutoResumableTaskRun(root, command, branch) {
-  if (!branch) return null;
-  const currentHeads = Object.fromEntries([
-    ["@treeseed/market", runGit(["rev-parse", "HEAD"], { cwd: repoRoot(root), capture: true }).trim()],
-    ...checkedOutWorkspacePackageRepos(root).map((repo) => [
-      repo.name,
-      runGit(["rev-parse", "HEAD"], { cwd: repo.dir, capture: true }).trim()
-    ])
-  ]);
-  return listInterruptedWorkflowRuns(root).find((journal) => {
-    if (journal.command !== command || !journal.resumable || journal.session.branchName !== branch) {
-      return false;
-    }
-    const classification = classifyWorkflowRunJournal(journal, {
-      currentBranch: branch,
-      currentHeads
-    });
-    if (classification.state === "resumable") {
-      return true;
-    }
-    if (classification.state === "stale") {
-      archiveWorkflowRun(root, journal.runId, {
-        ...classification,
-        reasons: [`${command} implicit resume skipped stale failed run`, ...classification.reasons]
-      });
-    }
-    return false;
-  }) ?? null;
-}
-function rejectImplicitWorkflowResume(operation, journal) {
-  if (!journal) return;
-  workflowError(
-    operation,
-    "resume_unavailable",
-    `Treeseed ${operation} found interrupted run ${journal.runId} for this branch and will not auto-resume recorded inputs. Run \`trsd resume ${journal.runId}\` to continue it, or \`trsd recover --obsolete ${journal.runId} --reason "superseded by a fresh ${operation}"\` before starting a new ${operation}.`,
-    {
-      details: {
-        recovery: {
-          resumable: true,
-          runId: journal.runId,
-          resumeCommand: `trsd resume ${journal.runId}`,
-          obsoleteCommand: `trsd recover --obsolete ${journal.runId} --reason "superseded by a fresh ${operation}"`
-        }
-      }
-    }
-  );
-}
-function stringRecord(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
-}
-function releasePlanHead(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 releasePlanMatchesCurrentHeads(plan, rootRepo, packageReports) {
-  if (releasePlanHead(plan, rootRepo.name) !== rootRepo.commitSha) {
-    return false;
-  }
-  const packageSelection = stringRecord(plan.packageSelection);
-  const selected = Array.isArray(packageSelection?.selected) ? packageSelection.selected.filter((name) => typeof name === "string") : packageReports.map((report) => report.name);
-  for (const name of selected) {
-    const current = packageReports.find((report) => report.name === name);
-    if (!current || releasePlanHead(plan, name) !== current.commitSha) {
-      return false;
-    }
-  }
-  return true;
-}
-function releaseRunHasCompletedMutation(journal) {
-  return journal.steps.some((step) => step.status === "completed" && step.id !== "release-plan" && step.id !== "workspace-unlink");
-}
-function generatedReleaseMetadataFiles(repoDir) {
-  return ["package.json", "package-lock.json", "npm-shrinkwrap.json"].filter((filePath) => {
-    if (existsSync(resolve(repoDir, filePath))) return true;
-    try {
-      runGit(["ls-files", "--error-unmatch", filePath], { cwd: repoDir, capture: true });
-      return true;
-    } catch {
-      return false;
-    }
-  });
-}
-function collectReleaseCleanupSnapshot(root, selectedPackageNames) {
-  return {
-    repos: [
-      {
-        name: "@treeseed/market",
-        path: repoRoot(root),
-        branch: currentBranch(repoRoot(root)) || null,
-        files: generatedReleaseMetadataFiles(repoRoot(root))
-      },
-      ...checkedOutWorkspacePackageRepos(root).filter((pkg) => selectedPackageNames.has(pkg.name)).map((pkg) => ({
-        name: pkg.name,
-        path: pkg.dir,
-        branch: currentBranch(pkg.dir) || null,
-        files: generatedReleaseMetadataFiles(pkg.dir)
-      }))
-    ]
-  };
-}
-function restoreReleaseGeneratedMetadata(repo) {
-  const restored = [];
-  const skipped = [];
-  for (const filePath of repo.files) {
-    const status = runGit(["status", "--porcelain", "--", filePath], { cwd: repo.path, capture: true });
-    if (!status.trim()) {
-      skipped.push(filePath);
-      continue;
-    }
-    runGit(["restore", "--staged", "--worktree", "--", filePath], { cwd: repo.path, capture: true });
-    restored.push(filePath);
-  }
-  return { restored, skipped };
-}
-function cleanupFailedReleaseLocalState(root, helpers, snapshot, workspaceLinksMode) {
-  const report = { restored: [], skipped: [], manualReview: [] };
-  try {
-    ensureWorkflowWorkspaceLinks(root, helpers, workspaceLinksMode ?? "auto");
-  } catch (error) {
-    report.manualReview.push({
-      scope: "workspace-links",
-      reason: error instanceof Error ? error.message : String(error)
-    });
-  }
-  if (!snapshot) {
-    report.skipped.push({ scope: "release-metadata", reason: "cleanup snapshot was not recorded before failure" });
-    return report;
-  }
-  for (const repo of snapshot.repos) {
-    try {
-      const restored = restoreReleaseGeneratedMetadata(repo);
-      if (repo.branch && currentBranch(repo.path) !== repo.branch) {
-        checkoutBranch(repo.path, repo.branch);
-      }
-      if (restored.restored.length > 0) {
-        report.restored.push({ repo: repo.name, path: repo.path, files: restored.restored });
-      }
-      if (restored.skipped.length > 0) {
-        report.skipped.push({ repo: repo.name, path: repo.path, files: restored.skipped, reason: "unchanged" });
-      }
-    } catch (error) {
-      report.manualReview.push({
-        repo: repo.name,
-        path: repo.path,
-        branch: repo.branch,
-        files: repo.files,
-        reason: error instanceof Error ? error.message : String(error),
-        nextCommand: repo.branch ? `git -C ${repo.path} restore --staged --worktree -- ${repo.files.join(" ")} && git -C ${repo.path} checkout ${repo.branch}` : null
-      });
-    }
-  }
-  return report;
-}
-export {
-  cleanupFailedReleaseLocalState,
-  collectReleaseCleanupSnapshot,
-  findAutoResumableTaskRun,
-  gateForSavedRootReport,
-  gatesForSavedRepositoryReports,
-  generatedReleaseMetadataFiles,
-  packageHostedVerifyTimeoutSeconds,
-  packageHostedVerifyWorkflow,
-  rejectImplicitWorkflowResume,
-  releasePlanHead,
-  releasePlanMatchesCurrentHeads,
-  releaseRunHasCompletedMutation,
-  restoreReleaseGeneratedMetadata,
-  stringRecord
-};

package/dist/workflow/operations/support/cleanup-stage-source-branches.d.ts

@@ -1,20 +0,0 @@
-import { StageCandidateManifest } from '../workspace-lifecycle/workflow-close.js';
-export declare function cleanupStageSourceBranches(root: string, branchName: string, manifest: StageCandidateManifest): {
-    status: string;
-    repos: Record<string, unknown>[];
-    worktreeCleanup: {
-        removed: boolean;
-        reason: string;
-        worktreePath?: undefined;
-        primaryRoot?: undefined;
-        branch?: undefined;
-        deletedLocalBranch?: undefined;
-    } | {
-        removed: boolean;
-        worktreePath: string;
-        primaryRoot: string;
-        branch: string;
-        deletedLocalBranch: boolean;
-        reason?: undefined;
-    };
-};

package/dist/workflow/operations/support/cleanup-stage-source-branches.js

@@ -1,52 +0,0 @@
-import { branchExists, deleteLocalBranch, deleteRemoteBranchIfMerged, STAGING_BRANCH, syncBranchWithOrigin } from "../../../operations/services/operations/git-workflow.js";
-import { currentBranch, repoRoot } from "../../../operations/services/treedx/workspaces/workspace-save.js";
-import { managedWorkflowWorktreeMetadata, removeManagedWorkflowWorktree } from "../../worktrees.js";
-import { checkedOutStagePromotionRepos, syncAllCheckedOutReleaseHelperRepos } from "../coordination/staging-candidate-workflow-gates.js";
-function cleanupStageSourceBranches(root, branchName, manifest) {
-  const results = [];
-  for (const repo of checkedOutStagePromotionRepos(root)) {
-    const manifestRepo = manifest.packages.find((entry) => entry.name === repo.name);
-    if (!manifestRepo) continue;
-    const remoteDeleted = deleteRemoteBranchIfMerged(repo.dir, branchName, STAGING_BRANCH, manifestRepo.commit);
-    if ((currentBranch(repo.dir) || null) === branchName) {
-      syncBranchWithOrigin(repo.dir, STAGING_BRANCH);
-    }
-    const localExists = branchExists(repo.dir, branchName);
-    if (localExists && (currentBranch(repo.dir) || null) !== branchName) {
-      deleteLocalBranch(repo.dir, branchName);
-    }
-    results.push({
-      name: repo.name,
-      path: repo.dir,
-      remoteDeleted,
-      localDeleted: localExists && !branchExists(repo.dir, branchName)
-    });
-  }
-  syncAllCheckedOutReleaseHelperRepos(root, STAGING_BRANCH);
-  const gitRoot = repoRoot(root);
-  const rootRemoteDeleted = deleteRemoteBranchIfMerged(gitRoot, branchName, STAGING_BRANCH, manifest.root.commit);
-  const managedWorktree = managedWorkflowWorktreeMetadata(root);
-  const worktreeCleanup = managedWorktree ? removeManagedWorkflowWorktree(root, { deleteBranch: false }) : { removed: false, reason: "not-managed" };
-  const branchDeletionRoot = managedWorktree?.primaryRoot ? repoRoot(managedWorktree.primaryRoot) : gitRoot;
-  if (!managedWorktree && (currentBranch(gitRoot) || null) === branchName) {
-    syncBranchWithOrigin(gitRoot, STAGING_BRANCH);
-  }
-  const rootLocalExists = branchExists(branchDeletionRoot, branchName);
-  if (rootLocalExists && (currentBranch(branchDeletionRoot) || null) !== branchName) {
-    deleteLocalBranch(branchDeletionRoot, branchName);
-  }
-  results.push({
-    name: "@treeseed/market",
-    path: branchDeletionRoot,
-    remoteDeleted: rootRemoteDeleted,
-    localDeleted: rootLocalExists && !branchExists(branchDeletionRoot, branchName)
-  });
-  return {
-    status: "completed",
-    repos: results,
-    worktreeCleanup
-  };
-}
-export {
-  cleanupStageSourceBranches
-};

package/dist/workflow/operations/support/create-repo-report.d.ts

@@ -1,64 +0,0 @@
-import { type HostingAuditEnvironment } from "../../../operations/services/hosting/audit/hosting-audit.js";
-import { type WorkflowTiming } from "../../../operations/services/operations/workflow-timing.js";
-import type { WorkflowExecutionMode, WorkflowFact, WorkflowNextStep, WorkflowOperationId, WorkflowRecovery, WorkflowResult } from "../../../operations/workflow.js";
-import { WorkflowRepoReport } from '../release-support/helpers/run-release-production-guarantees.js';
-import { WorkflowOperationHelpers, WorkflowStatePayload } from '../recovery/workflow-write.js';
-export declare function createRepoReport(name: string, path: string, branch: string | null, dirty: boolean): WorkflowRepoReport;
-export declare function createWorkspaceRootRepoReport(root: string): WorkflowRepoReport;
-export declare function createWorkspacePackageReports(root: string): WorkflowRepoReport[];
-export declare function createManagedWorkflowRepoReports(root: string): WorkflowRepoReport[];
-export declare function findReportByName(reports: WorkflowRepoReport[], name: string): WorkflowRepoReport | null;
-export declare function findReportByPath(reports: WorkflowRepoReport[], path: string): WorkflowRepoReport | null;
-export declare function assertWorkspaceClean(root: string): string[];
-export declare function buildWorkflowResult<TPayload>(operation: WorkflowOperationId, cwd: string, payload: TPayload, options?: {
-    nextSteps?: WorkflowNextStep[];
-    executionMode?: WorkflowExecutionMode;
-    runId?: string | null;
-    summary?: string;
-    facts?: WorkflowFact[];
-    recovery?: WorkflowRecovery | null;
-    errors?: Array<{
-        code: string;
-        message: string;
-        details?: Record<string, unknown> | null;
-    }>;
-    includeFinalState?: boolean;
-    timing?: WorkflowTiming;
-}): WorkflowResult<TPayload & {
-    finalState?: WorkflowStatePayload;
-    timing?: WorkflowTiming;
-}>;
-export type WorkflowApplicationSelection = {
-    selected: string[];
-    skipped: Array<{
-        appId: string;
-        reason: string;
-    }>;
-    reasons: Array<{
-        appId: string;
-        reason: string;
-    }>;
-    source: 'changed-paths' | 'package-selection' | 'default';
-};
-export declare function parseGitStatusChangedPaths(status: string): string[];
-export declare function availableWorkflowAppIds(root: string): string[];
-export declare function selectWorkflowApplications(root: string, input?: {
-    packageSelection?: {
-        selected?: string[];
-        changed?: string[];
-        dependents?: string[];
-    };
-    changedPaths?: string[];
-}): WorkflowApplicationSelection;
-export declare function singleSelectedWorkflowAppId(selection: WorkflowApplicationSelection): string | undefined;
-export declare function workflowHostedVerificationGateRequired(operation: WorkflowOperationId, root: string, helpers: WorkflowOperationHelpers, environment: HostingAuditEnvironment, options?: {
-    enabled: boolean;
-    strict?: boolean;
-    live?: boolean;
-    appId?: string;
-}): Promise<null>;
-export declare function normalizeExecutionMode(input: {
-    plan?: boolean;
-} | undefined): WorkflowExecutionMode;
-export declare function submodulePointerForRef(repoDir: string, ref: string, relativeDir: string): string | null;
-export declare function ensureLocalReadinessOrThrow(operation: WorkflowOperationId, tenantRoot: string): import("../../../workflow-state/branch-role.js").WorkflowState;

package/dist/workflow/operations/support/create-repo-report.js

@@ -1,224 +0,0 @@
-import { discoverApplications } from "../../../hosting/apps.js";
-import { collectDeploymentReadiness } from "../../../operations/services/hosting/deployment/deployment-readiness.js";
-import { assertCleanWorktrees, headCommit } from "../../../operations/services/operations/git-workflow.js";
-import { createWorkflowTimer } from "../../../operations/services/operations/workflow-timing.js";
-import { checkedOutManagedWorkflowRepos } from "../../../operations/services/support/managed-repositories.js";
-import { currentBranch, gitStatusPorcelain, hasMeaningfulChanges, repoRoot } from "../../../operations/services/treedx/workspaces/workspace-save.js";
-import { checkedOutWorkspacePackageRepos } from "../../session.js";
-import { resolveWorkflowStateSnapshot, workflowError } from "../release-support/helpers/run-release-production-guarantees.js";
-import { runGit } from "../recovery/workflow-write.js";
-function createRepoReport(name, path, branch, dirty) {
-  return {
-    name,
-    path,
-    branch,
-    dirty,
-    created: false,
-    resumed: false,
-    merged: false,
-    verified: false,
-    committed: false,
-    pushed: false,
-    deletedLocal: false,
-    deletedRemote: false,
-    tagName: null,
-    commitSha: branch ? headCommit(path) : null,
-    skippedReason: null,
-    publishWait: null,
-    workflowGates: [],
-    backMerge: null
-  };
-}
-function createWorkspaceRootRepoReport(root) {
-  const gitRoot = repoRoot(root);
-  return createRepoReport("@treeseed/market", gitRoot, currentBranch(gitRoot) || null, hasMeaningfulChanges(gitRoot));
-}
-function createWorkspacePackageReports(root) {
-  return checkedOutWorkspacePackageRepos(root).map((pkg) => createRepoReport(pkg.name, pkg.dir, currentBranch(pkg.dir) || null, hasMeaningfulChanges(pkg.dir)));
-}
-function createManagedWorkflowRepoReports(root) {
-  return checkedOutManagedWorkflowRepos(root).map((repo) => createRepoReport(repo.name, repo.dir, currentBranch(repo.dir) || null, hasMeaningfulChanges(repo.dir)));
-}
-function findReportByName(reports, name) {
-  return reports.find((report) => report.name === name) ?? null;
-}
-function findReportByPath(reports, path) {
-  return reports.find((report) => report.path === path) ?? null;
-}
-function assertWorkspaceClean(root) {
-  const repoDirs = [repoRoot(root), ...checkedOutManagedWorkflowRepos(root).map((repo) => repo.dir)];
-  assertCleanWorktrees(repoDirs);
-  return repoDirs;
-}
-function buildWorkflowResult(operation, cwd, payload, options = {}) {
-  const timing = options.timing ?? createWorkflowTimer().finish();
-  const resolvedPayload = options.includeFinalState ?? true ? {
-    ...payload,
-    timing,
-    finalState: resolveWorkflowStateSnapshot(cwd)
-  } : {
-    ...payload,
-    timing
-  };
-  return {
-    schemaVersion: 1,
-    kind: "treeseed.workflow.result",
-    command: operation,
-    executionMode: options.executionMode ?? "execute",
-    runId: options.runId ?? null,
-    ok: true,
-    operation,
-    summary: options.summary,
-    facts: options.facts,
-    payload: resolvedPayload,
-    result: resolvedPayload,
-    nextSteps: options.nextSteps,
-    recovery: options.recovery ?? null,
-    errors: options.errors ?? []
-  };
-}
-function parseGitStatusChangedPaths(status) {
-  return status.split("\n").map((line) => line.trimEnd()).filter(Boolean).map((line) => {
-    const value = line.slice(3).trim();
-    return value.includes(" -> ") ? value.split(" -> ").at(-1).trim() : value;
-  }).filter(Boolean);
-}
-function availableWorkflowAppIds(root) {
-  try {
-    const ids = discoverApplications(root).map((app) => app.id);
-    return ids.length > 0 ? ids : ["web"];
-  } catch {
-    return ["web"];
-  }
-}
-function selectWorkflowApplications(root, input = {}) {
-  const available = availableWorkflowAppIds(root);
-  const availableSet = new Set(available);
-  const selected = /* @__PURE__ */ new Set();
-  const reasons = [];
-  const add = (appId, reason) => {
-    if (!availableSet.has(appId)) return;
-    selected.add(appId);
-    reasons.push({ appId, reason });
-  };
-  const packages = [
-    ...input.packageSelection?.selected ?? [],
-    ...input.packageSelection?.changed ?? [],
-    ...input.packageSelection?.dependents ?? []
-  ];
-  const appByPackage = new Map(discoverApplications(root).filter((app) => app.relativeRoot.startsWith("packages/")).map((app) => [`@treeseed/${app.relativeRoot.slice("packages/".length).split("/")[0]}`, app.id]));
-  for (const packageName of packages) {
-    if (packageName === "@treeseed/api" || packageName === "@treeseed/treedx" || packageName === "@treeseed/agent") {
-      add("api", `${packageName} changed`);
-    } else if (packageName === "@treeseed/core" || packageName === "@treeseed/ui" || packageName === "@treeseed/admin") {
-      add("web", `${packageName} changed`);
-    } else if (packageName === "@treeseed/sdk" || packageName === "@treeseed/cli") {
-      add("web", `${packageName} is shared`);
-      add("api", `${packageName} is shared`);
-    }
-    const packageAppId = appByPackage.get(packageName);
-    if (packageAppId) add(packageAppId, `${packageName} owns ${packageAppId}`);
-  }
-  const changedPaths = input.changedPaths ?? parseGitStatusChangedPaths(gitStatusPorcelain(root));
-  const appByPackagePath = new Map(discoverApplications(root).filter((app) => app.relativeRoot.startsWith("packages/")).map((app) => [app.relativeRoot, app.id]));
-  for (const file of changedPaths) {
-    if (file.startsWith("packages/api/") || file === "packages/api") {
-      add("api", `${file} is API-owned`);
-    } else if (file.startsWith("packages/treedx/") || file === "packages/treedx") {
-      add("api", `${file} is TreeDX implementation`);
-    } else if (file.startsWith("packages/core/") || file.startsWith("packages/ui/") || file.startsWith("packages/admin/") || file.startsWith("src/") || file.startsWith("content/") || file.startsWith("public/") || file === "treeseed.site.yaml") {
-      add("web", `${file} is web-owned`);
-    } else if (file.startsWith("packages/sdk/") || file.startsWith("packages/cli/") || file === "package.json" || file === "package-lock.json" || file.startsWith(".github/")) {
-      add("web", `${file} is shared workflow/config`);
-      add("api", `${file} is shared workflow/config`);
-    }
-    for (const [packageRoot, appId] of appByPackagePath) {
-      if (file === packageRoot || file.startsWith(`${packageRoot}/`)) {
-        add(appId, `${file} is ${appId}-owned`);
-      }
-    }
-  }
-  const source = packages.length > 0 ? "package-selection" : changedPaths.length > 0 ? "changed-paths" : "default";
-  const finalSelected = selected.size > 0 ? available.filter((appId) => selected.has(appId)) : available;
-  return {
-    selected: finalSelected,
-    skipped: available.filter((appId) => !finalSelected.includes(appId)).map((appId) => ({ appId, reason: "No changed files or selected packages target this application." })),
-    reasons,
-    source
-  };
-}
-function singleSelectedWorkflowAppId(selection) {
-  return selection.selected.length === 1 ? selection.selected[0] : void 0;
-}
-async function workflowHostedVerificationGateRequired(operation, root, helpers, environment, options = { enabled: true }) {
-  if (!options.enabled) return null;
-  const target = environment === "prod" ? "prod" : environment === "local" ? "local" : "staging";
-  const readiness = collectDeploymentReadiness({
-    tenantRoot: root,
-    environment: target,
-    appId: options.appId
-  });
-  if (options.strict && !readiness.ok) {
-    const failures = readiness.checks.filter((check) => check.status === "failed").map((check) => `${check.id}: ${check.message}${check.remediation ? ` Remediation: ${check.remediation}` : ""}`);
-    workflowError(operation, "validation_failed", `Deployment readiness failed for ${target}:
-${failures.join("\n")}`, {
-      details: { readiness }
-    });
-  }
-  workflowError(operation, "validation_failed", `Hosted live verification for ${target} is reconciler-owned. Use stage/release release-gate:hosted-reconcile and release-gate:live-verify resources, or run trsd reconcile verify with a hosted selector.`, {
-    details: {
-      readiness,
-      live: options.live === true,
-      appId: options.appId ?? null
-    }
-  });
-}
-function normalizeExecutionMode(input) {
-  return input?.plan === true ? "plan" : "execute";
-}
-function submodulePointerForRef(repoDir, ref, relativeDir) {
-  try {
-    const output = runGit(["ls-tree", ref, relativeDir], { cwd: repoDir, capture: true }).trim();
-    if (!output) {
-      return null;
-    }
-    const match = output.match(/^[0-9]{6}\s+commit\s+([0-9a-f]{40})\t/u);
-    return match?.[1] ?? null;
-  } catch {
-    return null;
-  }
-}
-function ensureLocalReadinessOrThrow(operation, tenantRoot) {
-  const state = resolveWorkflowStateSnapshot(tenantRoot);
-  if (!state.readiness.local.ready) {
-    workflowError(
-      operation,
-      "validation_failed",
-      [
-        `Treeseed ${operation} requires the local environment to be configured.`,
-        ...state.readiness.local.blockers,
-        "Run `treeseed config --environment local` first."
-      ].join("\n"),
-      { details: { readiness: state.readiness.local } }
-    );
-  }
-  return state;
-}
-export {
-  assertWorkspaceClean,
-  availableWorkflowAppIds,
-  buildWorkflowResult,
-  createManagedWorkflowRepoReports,
-  createRepoReport,
-  createWorkspacePackageReports,
-  createWorkspaceRootRepoReport,
-  ensureLocalReadinessOrThrow,
-  findReportByName,
-  findReportByPath,
-  normalizeExecutionMode,
-  parseGitStatusChangedPaths,
-  selectWorkflowApplications,
-  singleSelectedWorkflowAppId,
-  submodulePointerForRef,
-  workflowHostedVerificationGateRequired
-};

package/dist/workflow/operations/support/resolve-generated-dependency-conflict.d.ts

@@ -1,7 +0,0 @@
-export declare function resolveGeneratedDependencyMergeConflict(repoDir: string, conflictedFiles: string[]): {
-    resolved: boolean;
-    strategy: "preserve-verified-task-generated-state";
-    conflictedFiles: string[];
-    incomingFiles: string[];
-    verifiedGitlinks: string[];
-} | null;