@treeseed/sdk 0.4.6 → 0.4.7

package/dist/workflow/operations.js

@@ -73,6 +73,10 @@ import {
 } from "../operations/services/workspace-save.js";
 import { run, workspaceRoot } from "../operations/services/workspace-tools.js";
 import { resolveTreeseedWorkflowState } from "../workflow-state.js";
+import {
+  classifyTreeseedBranchRole,
+  resolveTreeseedWorkflowPaths
+} from "./policy.js";
 class TreeseedWorkflowError extends Error {
   code;
   operation;
@@ -125,17 +129,6 @@ function withContextEnv(env, action) {
     }
   }
 }
-function runChild(command, args, context, cwd, label) {
-  const result = spawnSync(command, args, {
-    cwd,
-    env: { ...process.env, ...context.env ?? {} },
-    stdio: "inherit"
-  });
-  if (result.status !== 0) {
-    workflowError("dev", "unsupported_state", `${label} failed.`, { exitCode: result.status ?? 1 });
-  }
-  return result;
-}
 function runNodeScript(scriptName, context, cwd, label) {
   const result = spawnSync(process.execPath, [packageScriptPath(scriptName)], {
     cwd,
@@ -157,6 +150,52 @@ function normalizeConfigScopes(input) {
   }
   return ["local", "staging", "prod"].filter((scope) => requested.includes(scope));
 }
+function resolveWorkflowStateSnapshot(cwd) {
+  return resolveTreeseedWorkflowState(cwd);
+}
+function resolveProjectRootOrThrow(operation, cwd) {
+  const resolved = resolveTreeseedWorkflowPaths(cwd);
+  if (!resolved.tenantRoot) {
+    workflowError(operation, "validation_failed", `Treeseed ${operation} requires a Treeseed project. Run the command from inside a tenant or initialize one first.`);
+  }
+  return resolved.cwd;
+}
+function resolveRepoState(repoDir) {
+  const branchName = currentBranch(repoDir) || null;
+  return {
+    repoDir,
+    branchName,
+    branchRole: classifyTreeseedBranchRole(branchName, repoDir),
+    dirtyWorktree: gitStatusPorcelain(repoDir).length > 0
+  };
+}
+function buildWorkflowResult(operation, cwd, payload, nextSteps) {
+  return {
+    ok: true,
+    operation,
+    payload: {
+      ...payload,
+      finalState: resolveWorkflowStateSnapshot(cwd)
+    },
+    nextSteps
+  };
+}
+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;
+}
 function dedupeRepairActions(actions) {
   const seen = /* @__PURE__ */ new Set();
   return actions.filter((action) => {
@@ -342,6 +381,56 @@ function resolveDestroyConfirmation(context, expected, input) {
   }
   return false;
 }
+function syncCurrentBranchToOrigin(operation, repoDir, branch) {
+  try {
+    if (remoteBranchExists(repoDir, branch)) {
+      run("git", ["pull", "--rebase", "origin", branch], { cwd: repoDir });
+      run("git", ["push", "origin", branch], { cwd: repoDir });
+      return {
+        remoteBranchExisted: true,
+        pulledRebase: true,
+        pushed: true,
+        createdRemoteBranch: false,
+        conflicts: false
+      };
+    }
+    run("git", ["push", "-u", "origin", branch], { cwd: repoDir });
+    return {
+      remoteBranchExisted: false,
+      pulledRebase: false,
+      pushed: true,
+      createdRemoteBranch: true,
+      conflicts: false
+    };
+  } catch {
+    const report = collectMergeConflictReport(repoDir);
+    throw new TreeseedWorkflowError(operation, "merge_conflict", formatMergeConflictReport(report, repoDir, branch), {
+      details: { branch, report },
+      exitCode: 12
+    });
+  }
+}
+async function maybeAutoSaveCurrentTaskBranch(helpers, operation, input) {
+  const tenantRoot = resolveProjectRootOrThrow(operation, helpers.cwd());
+  const repoDir = gitWorkflowRoot(tenantRoot);
+  const before = resolveRepoState(repoDir);
+  if (!before.dirtyWorktree) {
+    return { performed: false, save: null };
+  }
+  if (input.autoSave === false) {
+    workflowError(operation, "validation_failed", `Treeseed ${operation} requires a clean worktree or autoSave enabled.`);
+  }
+  const saveResult = await workflowSave(helpers, {
+    message: operation === "close" ? `close: ${input.message}` : input.message,
+    verify: input.verify === true,
+    refreshPreview: false,
+    preview: input.preview
+  });
+  return {
+    performed: true,
+    save: saveResult.payload
+  };
+}
 async function workflowStatus(helpers) {
   return withContextEnv(helpers.context.env, () => createStatusResult(helpers.cwd()));
 }
@@ -351,7 +440,7 @@ async function workflowTasks(helpers) {
 async function workflowConfig(helpers, input = {}) {
   try {
     return await withContextEnv(helpers.context.env, async () => {
-      const tenantRoot = helpers.cwd();
+      const tenantRoot = resolveProjectRootOrThrow("config", helpers.cwd());
       const scopes = normalizeConfigScopes(input);
       const sync = input.syncProviders ?? input.sync ?? "all";
       const printEnv = input.printEnv === true;
@@ -442,10 +531,10 @@ async function workflowConfig(helpers, input = {}) {
       applyTreeseedEnvironmentToProcess({ tenantRoot, scope: "local", override: true });
       const { configPath, keyPath } = getTreeseedMachineConfigPaths(tenantRoot);
       const state = resolveTreeseedWorkflowState(tenantRoot);
-      return {
-        ok: true,
-        operation: "config",
-        payload: {
+      return buildWorkflowResult(
+        "config",
+        tenantRoot,
+        {
           mode: "configure",
           scopes,
           sync,
@@ -455,14 +544,15 @@ async function workflowConfig(helpers, input = {}) {
           preflight,
           toolHealth,
           result: wizardResult,
-          state
+          state,
+          readiness: state.readiness
         },
-        nextSteps: createNextSteps([
+        createNextSteps([
           ...scopes.includes("local") ? [{ operation: "dev", reason: "Start the local Treeseed runtime on the initialized local environment." }] : [],
           ...scopes.includes("staging") ? [{ operation: "status", reason: "Confirm staging readiness after initializing shared services." }] : [],
           { operation: "switch", reason: "Create or resume a task branch once the runtime foundation is ready.", input: { branch: "feature/my-change", preview: true } }
         ])
-      };
+      );
     });
   } catch (error) {
     toError("config", error);
@@ -471,7 +561,7 @@ async function workflowConfig(helpers, input = {}) {
 async function workflowSwitch(helpers, input) {
   try {
     return withContextEnv(helpers.context.env, () => {
-      const tenantRoot = helpers.cwd();
+      const tenantRoot = resolveProjectRootOrThrow("switch", helpers.cwd());
       const branchName = String(input.branch ?? input.branchName ?? "").trim();
       if (!branchName) {
         workflowError("switch", "validation_failed", "Treeseed switch requires a branch name.");
@@ -503,10 +593,10 @@ async function workflowSwitch(helpers, input) {
         previewResult = deployBranchPreview(tenantRoot, branchName, helpers.context, { initialize: true });
       }
       const state = resolveTreeseedWorkflowState(tenantRoot);
-      return {
-        ok: true,
-        operation: "switch",
-        payload: {
+      return buildWorkflowResult(
+        "switch",
+        tenantRoot,
+        {
           branchName,
           created,
           resumed,
@@ -517,13 +607,16 @@ async function workflowSwitch(helpers, input) {
             lastDeploymentTimestamp: state.preview.lastDeploymentTimestamp
           },
           previewResult,
-          state
+          preconditions: {
+            cleanWorktreeRequired: true,
+            baseBranch: STAGING_BRANCH
+          }
         },
-        nextSteps: createNextSteps([
-          state.preview.enabled ? { operation: "save", reason: "Persist and verify the current task branch, then refresh its preview deployment.", input: { message: "describe your change" } } : { operation: "dev", reason: "Start the local development environment for this task branch." },
+        createNextSteps([
+          state.preview.enabled ? { operation: "save", reason: "Persist and verify the current task branch, then refresh its preview deployment.", input: { message: "describe your change", preview: true } } : { operation: "dev", reason: "Start the local development environment for this task branch." },
           { operation: "stage", reason: "Merge the task into staging once the task branch is verified.", input: { message: "describe the resolution" } }
         ])
-      };
+      );
     });
   } catch (error) {
     toError("switch", error);
@@ -535,7 +628,8 @@ async function workflowDev(helpers, input = {}) {
       if (helpers.context.transport === "api") {
         workflowError("dev", "unsupported_transport", "Treeseed dev is not supported over the HTTP workflow API.");
       }
-      const tenantRoot = helpers.cwd();
+      const tenantRoot = resolveProjectRootOrThrow("dev", helpers.cwd());
+      const readiness = ensureLocalReadinessOrThrow("dev", tenantRoot);
       applyTreeseedEnvironmentToProcess({ tenantRoot, scope: "local", override: true });
       assertTreeseedCommandEnvironment({ tenantRoot, scope: "local", purpose: "dev" });
       const args = [packageScriptPath("tenant-dev")];
@@ -553,38 +647,42 @@ async function workflowDev(helpers, input = {}) {
           stdio: input.stdio ?? "inherit",
           detached: process.platform !== "win32"
         });
-        return {
-          ok: true,
-          operation: "dev",
-          payload: {
-            watch: input.watch === true,
-            background: true,
-            command: process.execPath,
-            args,
-            cwd: tenantRoot,
-            pid: child.pid ?? null,
-            exitCode: null
-          }
-        };
+        return buildWorkflowResult("dev", tenantRoot, {
+          watch: input.watch === true,
+          background: true,
+          command: process.execPath,
+          args,
+          cwd: tenantRoot,
+          pid: child.pid ?? null,
+          exitCode: null,
+          runtime: {
+            mode: process.env.TREESEED_LOCAL_DEV_MODE ?? "cloudflare",
+            apiBaseUrl: process.env.TREESEED_API_BASE_URL ?? "http://127.0.0.1:3000",
+            webUrl: "http://127.0.0.1:8787"
+          },
+          readiness: readiness.readiness.local
+        });
       }
       const result = spawnSync(process.execPath, args, {
         cwd: tenantRoot,
         env,
         stdio: input.stdio ?? "inherit"
       });
-      return {
-        ok: (result.status ?? 1) === 0,
-        operation: "dev",
-        payload: {
-          watch: input.watch === true,
-          background: false,
-          command: process.execPath,
-          args,
-          cwd: tenantRoot,
-          pid: null,
-          exitCode: result.status ?? 1
-        }
-      };
+      return buildWorkflowResult("dev", tenantRoot, {
+        watch: input.watch === true,
+        background: false,
+        command: process.execPath,
+        args,
+        cwd: tenantRoot,
+        pid: null,
+        exitCode: result.status ?? 1,
+        runtime: {
+          mode: process.env.TREESEED_LOCAL_DEV_MODE ?? "cloudflare",
+          apiBaseUrl: process.env.TREESEED_API_BASE_URL ?? "http://127.0.0.1:3000",
+          webUrl: "http://127.0.0.1:8787"
+        },
+        readiness: readiness.readiness.local
+      });
     });
   } catch (error) {
     toError("dev", error);
@@ -593,7 +691,7 @@ async function workflowDev(helpers, input = {}) {
 async function workflowSave(helpers, input) {
   try {
     return withContextEnv(helpers.context.env, () => {
-      const tenantRoot = helpers.cwd();
+      const tenantRoot = resolveProjectRootOrThrow("save", helpers.cwd());
       const message = ensureMessage("save", input.message, "a commit message");
       const optionsHotfix = input.hotfix === true;
       const root = workspaceRoot(tenantRoot);
@@ -616,45 +714,49 @@ async function workflowSave(helpers, input) {
       if (input.verify !== false) {
         runWorkspaceSavePreflight({ cwd: root });
       }
-      if (!hasMeaningfulChanges(gitRoot)) {
-        workflowError("save", "validation_failed", "Treeseed save found no meaningful repository changes to commit.");
+      const hadMeaningfulChanges = hasMeaningfulChanges(gitRoot);
+      let head = run("git", ["rev-parse", "HEAD"], { cwd: gitRoot, capture: true }).trim();
+      let commitCreated = false;
+      if (hadMeaningfulChanges) {
+        run("git", ["add", "-A"], { cwd: gitRoot });
+        run("git", ["commit", "-m", message], { cwd: gitRoot });
+        head = run("git", ["rev-parse", "HEAD"], { cwd: gitRoot, capture: true }).trim();
+        commitCreated = true;
       }
-      run("git", ["add", "-A"], { cwd: gitRoot });
-      run("git", ["commit", "-m", message], { cwd: gitRoot });
-      const head = run("git", ["rev-parse", "HEAD"], { cwd: gitRoot, capture: true }).trim();
-      try {
-        if (remoteBranchExists(gitRoot, branch)) {
-          run("git", ["pull", "--rebase", "origin", branch], { cwd: gitRoot });
-          run("git", ["push", "origin", branch], { cwd: gitRoot });
-        } else {
-          run("git", ["push", "-u", "origin", branch], { cwd: gitRoot });
+      const branchSync = syncCurrentBranchToOrigin("save", gitRoot, branch);
+      let previewAction = { status: "skipped" };
+      if (beforeState.branchRole === "feature" && branch) {
+        if (input.preview === true) {
+          previewAction = {
+            status: beforeState.preview.enabled ? "refreshed" : "created",
+            details: deployBranchPreview(root, branch, helpers.context, { initialize: !beforeState.preview.enabled })
+          };
+        } else if (input.refreshPreview !== false && beforeState.preview.enabled) {
+          previewAction = {
+            status: "refreshed",
+            details: deployBranchPreview(root, branch, helpers.context, { initialize: false })
+          };
         }
-      } catch {
-        const report = collectMergeConflictReport(gitRoot);
-        throw new TreeseedWorkflowError("save", "merge_conflict", formatMergeConflictReport(report, gitRoot, branch), {
-          details: { branch, report },
-          exitCode: 12
-        });
       }
-      let previewRefresh = null;
-      if (input.refreshPreview !== false && beforeState.branchRole === "feature" && beforeState.preview.enabled && branch) {
-        previewRefresh = deployBranchPreview(root, branch, helpers.context, { initialize: false });
-      }
-      return {
-        ok: true,
-        operation: "save",
-        payload: {
+      return buildWorkflowResult(
+        "save",
+        root,
+        {
           branch,
           scope,
           hotfix: optionsHotfix,
           message,
           commitSha: head,
-          previewRefresh
+          commitCreated,
+          noChanges: !hadMeaningfulChanges,
+          branchSync,
+          previewAction,
+          mergeConflict: null
         },
-        nextSteps: createNextSteps([
+        createNextSteps([
           branch === STAGING_BRANCH ? { operation: "release", reason: "Promote the validated staging branch into production.", input: { bump: "patch" } } : branch === PRODUCTION_BRANCH ? { operation: "status", reason: "Inspect production state after the explicit hotfix save." } : { operation: "stage", reason: "Merge the verified task branch into staging.", input: { message: "describe the resolution" } }
         ])
-      };
+      );
     });
   } catch (error) {
     toError("save", error);
@@ -662,9 +764,13 @@ async function workflowSave(helpers, input) {
 }
 async function workflowClose(helpers, input) {
   try {
-    return withContextEnv(helpers.context.env, () => {
-      const tenantRoot = helpers.cwd();
+    return withContextEnv(helpers.context.env, async () => {
+      const tenantRoot = resolveProjectRootOrThrow("close", helpers.cwd());
       const message = ensureMessage("close", input.message, "a close reason");
+      const autoSave = await maybeAutoSaveCurrentTaskBranch(helpers, "close", {
+        message,
+        autoSave: input.autoSave
+      });
       const featureBranch = assertFeatureBranch(tenantRoot);
       const repoDir = gitWorkflowRoot(tenantRoot);
       assertCleanWorktree(tenantRoot);
@@ -675,21 +781,24 @@ async function workflowClose(helpers, input) {
       if (input.deleteBranch !== false) {
         deleteLocalBranch(repoDir, featureBranch);
       }
-      return {
-        ok: true,
-        operation: "close",
-        payload: {
+      return buildWorkflowResult(
+        "close",
+        tenantRoot,
+        {
           branchName: featureBranch,
           message,
+          autoSaved: autoSave.performed,
+          autoSaveResult: autoSave.save,
           deprecatedTag,
           previewCleanup,
           remoteDeleted,
-          localDeleted: input.deleteBranch !== false
+          localDeleted: input.deleteBranch !== false,
+          finalBranch: currentBranch(repoDir) || STAGING_BRANCH
         },
-        nextSteps: createNextSteps([
+        createNextSteps([
           { operation: "tasks", reason: "Inspect the remaining task branches after closing this one." }
         ])
-      };
+      );
     });
   } catch (error) {
     toError("close", error);
@@ -697,12 +806,25 @@ async function workflowClose(helpers, input) {
 }
 async function workflowStage(helpers, input) {
   try {
-    return withContextEnv(helpers.context.env, () => {
-      const tenantRoot = helpers.cwd();
+    return withContextEnv(helpers.context.env, async () => {
+      const tenantRoot = resolveProjectRootOrThrow("stage", helpers.cwd());
       const message = ensureMessage("stage", input.message, "a resolution message");
+      const autoSave = await maybeAutoSaveCurrentTaskBranch(helpers, "stage", {
+        message,
+        autoSave: input.autoSave
+      });
       const featureBranch = assertFeatureBranch(tenantRoot);
       runWorkspaceSavePreflight({ cwd: tenantRoot });
-      const repoDir = mergeCurrentBranchIntoStaging(tenantRoot, featureBranch);
+      let repoDir;
+      try {
+        repoDir = mergeCurrentBranchIntoStaging(tenantRoot, featureBranch);
+      } catch (error) {
+        const report = collectMergeConflictReport(gitWorkflowRoot(tenantRoot));
+        throw new TreeseedWorkflowError("stage", "merge_conflict", formatMergeConflictReport(report, gitWorkflowRoot(tenantRoot), STAGING_BRANCH), {
+          details: { branch: featureBranch, report, originalError: error instanceof Error ? error.message : String(error) },
+          exitCode: 12
+        });
+      }
       const stagingWait = input.waitForStaging === false ? { status: "skipped", reason: "disabled" } : waitForStagingAutomation(repoDir);
       const previewCleanup = input.deletePreview === false ? { performed: false } : destroyPreviewIfPresent(tenantRoot, featureBranch);
       const deprecatedTag = createDeprecatedTaskTag(repoDir, featureBranch, `stage: ${message}`);
@@ -710,24 +832,27 @@ async function workflowStage(helpers, input) {
       if (input.deleteBranch !== false) {
         deleteLocalBranch(repoDir, featureBranch);
       }
-      return {
-        ok: true,
-        operation: "stage",
-        payload: {
+      return buildWorkflowResult(
+        "stage",
+        tenantRoot,
+        {
           branchName: featureBranch,
           mergeTarget: STAGING_BRANCH,
           message,
+          autoSaved: autoSave.performed,
+          autoSaveResult: autoSave.save,
           deprecatedTag,
           stagingWait,
           previewCleanup,
           remoteDeleted,
-          localDeleted: input.deleteBranch !== false
+          localDeleted: input.deleteBranch !== false,
+          finalBranch: currentBranch(repoDir) || STAGING_BRANCH
         },
-        nextSteps: createNextSteps([
+        createNextSteps([
           { operation: "release", reason: "Promote the updated staging branch into production when ready.", input: { bump: "patch" } },
           { operation: "status", reason: "Inspect staging readiness after the task branch merge." }
         ])
-      };
+      );
     });
   } catch (error) {
     toError("stage", error);
@@ -737,7 +862,7 @@ async function workflowRelease(helpers, input) {
   try {
     return withContextEnv(helpers.context.env, () => {
       const level = input.bump ?? "patch";
-      const root = workspaceRoot(helpers.cwd());
+      const root = resolveProjectRootOrThrow("release", helpers.cwd());
       const gitRoot = repoRoot(root);
       prepareReleaseBranches(root);
       applyTreeseedEnvironmentToProcess({ tenantRoot: root, scope: "staging", override: true });
@@ -750,23 +875,32 @@ async function workflowRelease(helpers, input) {
       run("git", ["commit", "-m", `release: ${level} bump`], { cwd: gitRoot });
       pushBranch(gitRoot, STAGING_BRANCH);
       mergeStagingIntoMain(root);
+      const releasedCommit = run("git", ["rev-parse", PRODUCTION_BRANCH], { cwd: gitRoot, capture: true }).trim();
       run("git", ["tag", "-a", rootVersion, "-m", `release: ${rootVersion}`], { cwd: gitRoot });
       run("git", ["push", "origin", rootVersion], { cwd: gitRoot });
-      return {
-        ok: true,
-        operation: "release",
-        payload: {
+      syncBranchWithOrigin(gitRoot, STAGING_BRANCH);
+      return buildWorkflowResult(
+        "release",
+        root,
+        {
           level,
           rootVersion,
           releaseTag: rootVersion,
+          releasedCommit,
           stagingBranch: STAGING_BRANCH,
           productionBranch: PRODUCTION_BRANCH,
-          touchedPackages: [...plan.touched]
+          touchedPackages: [...plan.touched],
+          finalBranch: currentBranch(gitRoot) || STAGING_BRANCH,
+          pushStatus: {
+            stagingPushed: true,
+            productionPushed: true,
+            tagPushed: true
+          }
         },
-        nextSteps: createNextSteps([
+        createNextSteps([
           { operation: "status", reason: "Inspect release readiness and production state after the promotion." }
         ])
-      };
+      );
     });
   } catch (error) {
     toError("release", error);

package/dist/workflow/policy.d.ts

@@ -0,0 +1,12 @@
+export type TreeseedWorkflowBranchRole = 'feature' | 'staging' | 'main' | 'detached' | 'none';
+export type TreeseedResolvedWorkflowPaths = {
+    requestedCwd: string;
+    tenantRoot: string | null;
+    cwd: string;
+    repoRoot: string | null;
+    branchName: string | null;
+    branchRole: TreeseedWorkflowBranchRole;
+};
+export declare function classifyTreeseedBranchRole(branchName: string | null, repoDir: string | null): TreeseedWorkflowBranchRole;
+export declare function resolveTreeseedWorkflowPaths(startCwd: string): TreeseedResolvedWorkflowPaths;
+export declare function workflowEnvironmentForBranchRole(branchRole: TreeseedWorkflowBranchRole): "local" | "staging" | "prod" | "none";

package/dist/workflow/policy.js

@@ -0,0 +1,58 @@
+import { findNearestTreeseedRoot, run } from "../operations/services/workspace-tools.js";
+import { currentBranch, repoRoot } from "../operations/services/workspace-save.js";
+import { PRODUCTION_BRANCH, STAGING_BRANCH } from "../operations/services/git-workflow.js";
+function safeRepoRoot(cwd) {
+  try {
+    return repoRoot(cwd);
+  } catch {
+    return null;
+  }
+}
+function repoHasHead(repoDir) {
+  try {
+    run("git", ["rev-parse", "--verify", "HEAD"], { cwd: repoDir, capture: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function classifyTreeseedBranchRole(branchName, repoDir) {
+  if (!repoDir) {
+    return "none";
+  }
+  if (!branchName) {
+    return repoHasHead(repoDir) ? "detached" : "none";
+  }
+  if (branchName === STAGING_BRANCH) {
+    return "staging";
+  }
+  if (branchName === PRODUCTION_BRANCH) {
+    return "main";
+  }
+  return "feature";
+}
+function resolveTreeseedWorkflowPaths(startCwd) {
+  const tenantRoot = findNearestTreeseedRoot(startCwd);
+  const cwd = tenantRoot ?? startCwd;
+  const gitRoot = safeRepoRoot(cwd);
+  const branchName = gitRoot ? currentBranch(gitRoot) || null : null;
+  return {
+    requestedCwd: startCwd,
+    tenantRoot,
+    cwd,
+    repoRoot: gitRoot,
+    branchName,
+    branchRole: classifyTreeseedBranchRole(branchName, gitRoot)
+  };
+}
+function workflowEnvironmentForBranchRole(branchRole) {
+  if (branchRole === "staging") return "staging";
+  if (branchRole === "main") return "prod";
+  if (branchRole === "feature") return "local";
+  return "none";
+}
+export {
+  classifyTreeseedBranchRole,
+  resolveTreeseedWorkflowPaths,
+  workflowEnvironmentForBranchRole
+};

package/dist/workflow-state.d.ts

@@ -1,5 +1,6 @@
 import type { TreeseedWorkflowNextStep } from './workflow.ts';
-export type TreeseedBranchRole = 'feature' | 'staging' | 'main' | 'detached' | 'none';
+import { type TreeseedWorkflowBranchRole } from './workflow/policy.ts';
+export type TreeseedBranchRole = TreeseedWorkflowBranchRole;
 export type TreeseedWorkflowRecommendation = TreeseedWorkflowNextStep;
 export type TreeseedWorkflowState = {
     cwd: string;
@@ -44,6 +45,23 @@ export type TreeseedWorkflowState = {
         devVars: boolean;
     };
     releaseReady: boolean;
+    readiness: {
+        local: {
+            ready: boolean;
+            blockers: string[];
+            warnings: string[];
+        };
+        staging: {
+            ready: boolean;
+            blockers: string[];
+            warnings: string[];
+        };
+        prod: {
+            ready: boolean;
+            blockers: string[];
+            warnings: string[];
+        };
+    };
     rollbackCandidates: Array<{
         scope: 'staging' | 'prod';
         commit: string | null;