@treeseed/sdk 0.4.12 → 0.4.13

package/dist/operations/providers/default.js

@@ -454,6 +454,8 @@ class DefaultTreeseedOperationsProvider {
       new WorkflowOperation("save"),
       new WorkflowOperation("close"),
       new WorkflowOperation("stage"),
+      new WorkflowOperation("resume"),
+      new WorkflowOperation("recover"),
       new WorkflowOperation("config"),
       new WorkflowOperation("export"),
       new WorkflowOperation("release"),

package/dist/operations/services/git-workflow.d.ts

@@ -1,24 +1,55 @@
 export declare const STAGING_BRANCH = "staging";
 export declare const PRODUCTION_BRANCH = "main";
+export declare function headCommit(repoDir: any, ref?: string): string;
 export declare function gitWorkflowRoot(cwd?: any): string;
 export declare function assertCleanWorktree(cwd?: any): string;
+export declare function assertCleanWorktrees(repoDirs: any): any;
 export declare function branchExists(repoDir: any, branchName: any): boolean;
 export declare function remoteBranchExists(repoDir: any, branchName: any): boolean;
 export declare function fetchOrigin(repoDir: any): void;
 export declare function ensureLocalBranchTracking(repoDir: any, branchName: any): void;
 export declare function checkoutBranch(repoDir: any, branchName: any): void;
+export declare function checkoutTaskBranchFromStaging(cwd: any, branchName: any, { createIfMissing, pushIfCreated }?: {
+    createIfMissing?: boolean | undefined;
+    pushIfCreated?: boolean | undefined;
+}): {
+    repoDir: string;
+    branchName: any;
+    baseBranch: string;
+    created: boolean;
+    resumed: boolean;
+    remoteBranch: boolean;
+};
 export declare function syncBranchWithOrigin(repoDir: any, branchName: any): void;
 export declare function createFeatureBranchFromStaging(cwd: any, branchName: any): {
     repoDir: string;
-    baseBranch: string;
     branchName: any;
+    baseBranch: string;
+    created: boolean;
+    resumed: boolean;
+    remoteBranch: boolean;
 };
 export declare function pushBranch(repoDir: any, branchName: any, { setUpstream }?: {
     setUpstream?: boolean | undefined;
 }): void;
 export declare function deleteLocalBranch(repoDir: any, branchName: any): void;
 export declare function deleteRemoteBranch(repoDir: any, branchName: any): boolean;
-export declare function mergeCurrentBranchIntoStaging(cwd: any, featureBranch: any): string;
+export declare function mergeCurrentBranchIntoStaging(cwd: any, featureBranch: any): {
+    repoDir: string;
+    targetBranch: string;
+    committed: boolean;
+    commitSha: string;
+    pushed: boolean;
+};
+export declare function squashMergeBranchIntoStaging(cwd: any, featureBranch: any, message: any, { pushTarget }?: {
+    pushTarget?: boolean | undefined;
+}): {
+    repoDir: string;
+    targetBranch: string;
+    committed: boolean;
+    commitSha: string;
+    pushed: boolean;
+};
 export declare function currentManagedBranch(cwd?: any): string;
 export declare function isTaskBranch(branchName: any): boolean;
 export declare function assertFeatureBranch(cwd?: any): string;
@@ -46,4 +77,17 @@ export declare function waitForStagingAutomation(repoDir: any): {
     reason?: undefined;
 };
 export declare function prepareReleaseBranches(cwd?: any): string;
-export declare function mergeStagingIntoMain(cwd?: any): string;
+export declare function mergeStagingIntoMain(cwd?: any): {
+    repoDir: string;
+    targetBranch: any;
+    commitSha: string;
+    pushed: boolean;
+};
+export declare function mergeBranchIntoTarget(cwd?: any, { sourceBranch, targetBranch, message, pushTarget }?: {
+    pushTarget?: boolean | undefined;
+}): {
+    repoDir: string;
+    targetBranch: any;
+    commitSha: string;
+    pushed: boolean;
+};

package/dist/operations/services/git-workflow.js

@@ -6,6 +6,17 @@ const RESERVED_BRANCHES = /* @__PURE__ */ new Set([STAGING_BRANCH, PRODUCTION_BR
 function runGit(args, { cwd, capture = false } = {}) {
   return run("git", args, { cwd, capture });
 }
+function repoHasStagedChanges(repoDir) {
+  try {
+    runGit(["diff", "--cached", "--quiet"], { cwd: repoDir });
+    return false;
+  } catch {
+    return true;
+  }
+}
+function headCommit(repoDir, ref = "HEAD") {
+  return runGit(["rev-parse", ref], { cwd: repoDir, capture: true }).trim();
+}
 function gitWorkflowRoot(cwd = workspaceRoot()) {
   return repoRoot(cwd);
 }
@@ -16,6 +27,12 @@ function assertCleanWorktree(cwd = workspaceRoot()) {
   }
   return root;
 }
+function assertCleanWorktrees(repoDirs) {
+  for (const repoDir of repoDirs) {
+    assertCleanWorktree(repoDir);
+  }
+  return repoDirs;
+}
 function branchExists(repoDir, branchName) {
   try {
     runGit(["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoDir });
@@ -48,6 +65,63 @@ function ensureLocalBranchTracking(repoDir, branchName) {
 function checkoutBranch(repoDir, branchName) {
   runGit(["checkout", branchName], { cwd: repoDir });
 }
+function checkoutTaskBranchFromStaging(cwd, branchName, { createIfMissing = true, pushIfCreated = false } = {}) {
+  const repoDir = assertCleanWorktree(cwd);
+  fetchOrigin(repoDir);
+  syncBranchWithOrigin(repoDir, STAGING_BRANCH);
+  if (currentBranch(repoDir) === branchName) {
+    return {
+      repoDir,
+      branchName,
+      baseBranch: STAGING_BRANCH,
+      created: false,
+      resumed: true,
+      remoteBranch: remoteBranchExists(repoDir, branchName)
+    };
+  }
+  if (branchExists(repoDir, branchName)) {
+    checkoutBranch(repoDir, branchName);
+    if (remoteBranchExists(repoDir, branchName)) {
+      runGit(["pull", "--rebase", "origin", branchName], { cwd: repoDir });
+    }
+    return {
+      repoDir,
+      branchName,
+      baseBranch: STAGING_BRANCH,
+      created: false,
+      resumed: true,
+      remoteBranch: remoteBranchExists(repoDir, branchName)
+    };
+  }
+  if (remoteBranchExists(repoDir, branchName)) {
+    runGit(["checkout", "-b", branchName, `origin/${branchName}`], { cwd: repoDir });
+    runGit(["pull", "--rebase", "origin", branchName], { cwd: repoDir });
+    return {
+      repoDir,
+      branchName,
+      baseBranch: STAGING_BRANCH,
+      created: false,
+      resumed: true,
+      remoteBranch: true
+    };
+  }
+  if (!createIfMissing) {
+    throw new Error(`Branch "${branchName}" does not exist locally or on origin.`);
+  }
+  checkoutBranch(repoDir, STAGING_BRANCH);
+  runGit(["checkout", "-b", branchName], { cwd: repoDir });
+  if (pushIfCreated) {
+    pushBranch(repoDir, branchName, { setUpstream: true });
+  }
+  return {
+    repoDir,
+    branchName,
+    baseBranch: STAGING_BRANCH,
+    created: true,
+    resumed: false,
+    remoteBranch: pushIfCreated
+  };
+}
 function syncBranchWithOrigin(repoDir, branchName) {
   fetchOrigin(repoDir);
   if (!branchExists(repoDir, branchName) && remoteBranchExists(repoDir, branchName)) {
@@ -60,18 +134,14 @@ function syncBranchWithOrigin(repoDir, branchName) {
   }
 }
 function createFeatureBranchFromStaging(cwd, branchName) {
-  const repoDir = assertCleanWorktree(cwd);
-  fetchOrigin(repoDir);
-  if (branchExists(repoDir, branchName) || remoteBranchExists(repoDir, branchName)) {
+  const result = checkoutTaskBranchFromStaging(cwd, branchName, {
+    createIfMissing: true,
+    pushIfCreated: false
+  });
+  if (!result.created) {
     throw new Error(`Branch "${branchName}" already exists locally or on origin.`);
   }
-  syncBranchWithOrigin(repoDir, STAGING_BRANCH);
-  runGit(["checkout", "-b", branchName], { cwd: repoDir });
-  return {
-    repoDir,
-    baseBranch: STAGING_BRANCH,
-    branchName
-  };
+  return result;
 }
 function pushBranch(repoDir, branchName, { setUpstream = false } = {}) {
   const args = setUpstream ? ["push", "-u", "origin", branchName] : ["push", "origin", branchName];
@@ -91,12 +161,28 @@ function deleteRemoteBranch(repoDir, branchName) {
   return true;
 }
 function mergeCurrentBranchIntoStaging(cwd, featureBranch) {
+  return squashMergeBranchIntoStaging(cwd, featureBranch, `stage: ${featureBranch}`);
+}
+function squashMergeBranchIntoStaging(cwd, featureBranch, message, { pushTarget = true } = {}) {
   const repoDir = assertCleanWorktree(cwd);
   fetchOrigin(repoDir);
   syncBranchWithOrigin(repoDir, STAGING_BRANCH);
-  runGit(["merge", "--no-ff", featureBranch, "-m", `merge: ${featureBranch} -> ${STAGING_BRANCH}`], { cwd: repoDir });
-  pushBranch(repoDir, STAGING_BRANCH);
-  return repoDir;
+  runGit(["merge", "--squash", featureBranch], { cwd: repoDir });
+  let committed = false;
+  if (repoHasStagedChanges(repoDir)) {
+    runGit(["commit", "-m", message], { cwd: repoDir });
+    committed = true;
+  }
+  if (pushTarget) {
+    pushBranch(repoDir, STAGING_BRANCH);
+  }
+  return {
+    repoDir,
+    targetBranch: STAGING_BRANCH,
+    committed,
+    commitSha: headCommit(repoDir),
+    pushed: pushTarget
+  };
 }
 function currentManagedBranch(cwd = workspaceRoot()) {
   return currentBranch(gitWorkflowRoot(cwd));
@@ -180,23 +266,40 @@ function prepareReleaseBranches(cwd = workspaceRoot()) {
   return repoDir;
 }
 function mergeStagingIntoMain(cwd = workspaceRoot()) {
+  return mergeBranchIntoTarget(cwd, {
+    sourceBranch: STAGING_BRANCH,
+    targetBranch: PRODUCTION_BRANCH,
+    message: `release: ${STAGING_BRANCH} -> ${PRODUCTION_BRANCH}`,
+    pushTarget: true
+  });
+}
+function mergeBranchIntoTarget(cwd = workspaceRoot(), { sourceBranch, targetBranch, message, pushTarget = true } = {}) {
   const repoDir = prepareReleaseBranches(cwd);
-  checkoutBranch(repoDir, PRODUCTION_BRANCH);
-  if (remoteBranchExists(repoDir, PRODUCTION_BRANCH)) {
-    runGit(["pull", "--rebase", "origin", PRODUCTION_BRANCH], { cwd: repoDir });
+  checkoutBranch(repoDir, targetBranch);
+  if (remoteBranchExists(repoDir, targetBranch)) {
+    runGit(["pull", "--rebase", "origin", targetBranch], { cwd: repoDir });
   }
-  runGit(["merge", "--no-ff", STAGING_BRANCH, "-m", `release: ${STAGING_BRANCH} -> ${PRODUCTION_BRANCH}`], { cwd: repoDir });
+  runGit(["merge", "--no-ff", sourceBranch, "-m", message], { cwd: repoDir });
   pushBranch(repoDir, STAGING_BRANCH);
-  pushBranch(repoDir, PRODUCTION_BRANCH);
-  return repoDir;
+  if (pushTarget) {
+    pushBranch(repoDir, targetBranch);
+  }
+  return {
+    repoDir,
+    targetBranch,
+    commitSha: headCommit(repoDir),
+    pushed: pushTarget
+  };
 }
 export {
   PRODUCTION_BRANCH,
   STAGING_BRANCH,
   assertCleanWorktree,
+  assertCleanWorktrees,
   assertFeatureBranch,
   branchExists,
   checkoutBranch,
+  checkoutTaskBranchFromStaging,
   createDeprecatedTaskTag,
   createFeatureBranchFromStaging,
   currentManagedBranch,
@@ -205,13 +308,16 @@ export {
   ensureLocalBranchTracking,
   fetchOrigin,
   gitWorkflowRoot,
+  headCommit,
   isTaskBranch,
   listTaskBranches,
+  mergeBranchIntoTarget,
   mergeCurrentBranchIntoStaging,
   mergeStagingIntoMain,
   prepareReleaseBranches,
   pushBranch,
   remoteBranchExists,
+  squashMergeBranchIntoStaging,
   syncBranchWithOrigin,
   taskTagSlug,
   waitForStagingAutomation

package/dist/operations/services/github-automation.d.ts

@@ -190,3 +190,28 @@ export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun }
         mode?: undefined;
     };
 };
+export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repository, workflow, headSha, branch, timeoutSeconds, pollSeconds, }?: {
+    workflow?: string | undefined;
+    timeoutSeconds?: number | undefined;
+    pollSeconds?: number | undefined;
+}): {
+    status: string;
+    reason: string;
+    repository: any;
+    workflow: string;
+    headSha: any;
+    branch: any;
+    runId?: undefined;
+    conclusion?: undefined;
+    url?: undefined;
+} | {
+    status: string;
+    repository: any;
+    workflow: string;
+    runId: any;
+    headSha: any;
+    conclusion: any;
+    url: any;
+    reason?: undefined;
+    branch?: undefined;
+};

package/dist/operations/services/github-automation.js

@@ -53,6 +53,14 @@ function runGh(args, { cwd, allowFailure = false, capture = true, input } = {})
   }
   return result;
 }
+function sleepSeconds(seconds) {
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    return;
+  }
+  spawnSync("sleep", [String(seconds)], {
+    stdio: "ignore"
+  });
+}
 function resolveGitHubRepositorySlug(tenantRoot) {
   const remoteResult = runGit(["remote", "get-url", "origin"], { cwd: tenantRoot });
   const remoteUrl = remoteResult.stdout?.trim() ?? "";
@@ -291,6 +299,78 @@ function ensureGitHubDeployAutomation(tenantRoot, { dryRun = false } = {}) {
     environment
   };
 }
+function waitForGitHubWorkflowCompletion(tenantRoot, {
+  repository,
+  workflow = "publish.yml",
+  headSha,
+  branch,
+  timeoutSeconds = 600,
+  pollSeconds = 5
+} = {}) {
+  if (isGitHubAutomationStubbed()) {
+    return {
+      status: "skipped",
+      reason: "stubbed",
+      repository: repository ?? maybeResolveGitHubRepositorySlug(tenantRoot),
+      workflow,
+      headSha: headSha ?? null,
+      branch: branch ?? null
+    };
+  }
+  const repo = repository ?? resolveGitHubRepositorySlug(tenantRoot);
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutSeconds * 1e3) {
+    const result = runGh([
+      "run",
+      "list",
+      "--repo",
+      repo,
+      "--workflow",
+      workflow,
+      "--limit",
+      "20",
+      "--json",
+      "databaseId,headSha,headBranch,status,conclusion,event,displayTitle,url"
+    ], { cwd: tenantRoot });
+    const runs = JSON.parse(result.stdout || "[]");
+    const match = runs.find((run) => {
+      if (headSha && run?.headSha !== headSha) {
+        return false;
+      }
+      if (branch && run?.headBranch !== branch) {
+        return false;
+      }
+      return true;
+    });
+    if (match?.databaseId) {
+      runGh(["run", "watch", String(match.databaseId), "--repo", repo, "--exit-status"], {
+        cwd: tenantRoot,
+        capture: false
+      });
+      const finalResult = runGh([
+        "run",
+        "view",
+        String(match.databaseId),
+        "--repo",
+        repo,
+        "--json",
+        "status,conclusion,url,workflowName,headSha"
+      ], { cwd: tenantRoot });
+      const finalRun = JSON.parse(finalResult.stdout || "{}");
+      return {
+        status: "completed",
+        repository: repo,
+        workflow,
+        runId: match.databaseId,
+        headSha: finalRun.headSha ?? match.headSha ?? null,
+        conclusion: finalRun.conclusion ?? match.conclusion ?? null,
+        url: finalRun.url ?? match.url ?? null
+      };
+    }
+    sleepSeconds(pollSeconds);
+  }
+  throw new Error(`Timed out waiting for GitHub workflow ${workflow} in ${repo}.`);
+}
 export {
   ensureDeployWorkflow,
   ensureGitHubDeployAutomation,
@@ -309,5 +389,6 @@ export {
   requiredGitHubEnvironment,
   requiredGitHubSecrets,
   resolveGitHubRepositorySlug,
-  resolveGitRepositoryRoot
+  resolveGitRepositoryRoot,
+  waitForGitHubWorkflowCompletion
 };

package/dist/operations/services/workspace-save.d.ts

@@ -8,12 +8,21 @@ export declare function planWorkspaceVersionChanges(root?: any): {
     touched: Set<unknown>;
 };
 export declare function applyWorkspaceVersionChanges(plan: any): any;
-export declare function planWorkspaceReleaseBump(level?: string, root?: any): {
+export declare function planWorkspaceReleaseBump(level?: string, root?: any, options?: {}): {
     packages: any[];
     touched: Set<unknown>;
     versions: Map<any, any>;
     level: string;
+    selected: Set<any>;
 };
+export declare function collectWorkspaceVersionConsistencyIssues(root?: any): {
+    packageName: any;
+    dependencyName: string;
+    field: string;
+    currentSpec: unknown;
+    expectedSpec: string;
+}[];
+export declare function assertWorkspaceVersionConsistency(root?: any): void;
 export declare function repoRoot(cwd?: any): string;
 export declare function currentBranch(repoDir: any): string;
 export declare function originRemoteUrl(repoDir: any): string;

package/dist/operations/services/workspace-save.js

@@ -113,17 +113,20 @@ function applyWorkspaceVersionChanges(plan) {
   }
   return plan;
 }
-function planWorkspaceReleaseBump(level = "patch", root = workspaceRoot()) {
+function planWorkspaceReleaseBump(level = "patch", root = workspaceRoot(), options = {}) {
   const packages = workspacePackages(root).map((pkg) => ({
     ...pkg,
     packageJsonPath: resolve(pkg.dir, "package.json"),
     packageJson: readPackageJson(resolve(pkg.dir, "package.json"))
   }));
   const publishable = new Set(publishableWorkspacePackages(root).map((pkg) => pkg.name));
+  const selected = options.selectedPackageNames ? new Set(
+    [...options.selectedPackageNames].map((name) => String(name)).filter((name) => publishable.has(name))
+  ) : new Set(publishable);
   const touched = /* @__PURE__ */ new Set();
   const versions = /* @__PURE__ */ new Map();
   for (const pkg of packages) {
-    if (!publishable.has(pkg.name)) {
+    if (!publishable.has(pkg.name) || !selected.has(pkg.name)) {
       continue;
     }
     const nextVersion = incrementVersion(pkg.packageJson.version, level);
@@ -132,6 +135,9 @@ function planWorkspaceReleaseBump(level = "patch", root = workspaceRoot()) {
     touched.add(pkg.name);
   }
   for (const pkg of packages) {
+    if (!selected.has(pkg.name)) {
+      continue;
+    }
     for (const field of internalDependencyFields(pkg.packageJson)) {
       for (const depName of Object.keys(pkg.packageJson[field] ?? {})) {
         if (!versions.has(depName)) {
@@ -146,9 +152,52 @@ function planWorkspaceReleaseBump(level = "patch", root = workspaceRoot()) {
     packages,
     touched,
     versions,
-    level
+    level,
+    selected
   };
 }
+function collectWorkspaceVersionConsistencyIssues(root = workspaceRoot()) {
+  const packages = workspacePackages(root).map((pkg) => ({
+    ...pkg,
+    packageJson: readPackageJson(resolve(pkg.dir, "package.json"))
+  }));
+  const versions = new Map(packages.map((pkg) => [pkg.name, pkg.packageJson.version]));
+  const issues = [];
+  for (const pkg of packages) {
+    for (const field of internalDependencyFields(pkg.packageJson)) {
+      for (const [depName, currentSpec] of Object.entries(pkg.packageJson[field] ?? {})) {
+        if (!versions.has(depName)) {
+          continue;
+        }
+        const expectedSpec = `^${versions.get(depName)}`;
+        if (currentSpec !== expectedSpec) {
+          issues.push({
+            packageName: pkg.name,
+            dependencyName: depName,
+            field,
+            currentSpec,
+            expectedSpec
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function assertWorkspaceVersionConsistency(root = workspaceRoot()) {
+  const issues = collectWorkspaceVersionConsistencyIssues(root);
+  if (issues.length === 0) {
+    return;
+  }
+  const rendered = issues.map((issue) => `${issue.packageName} ${issue.field}.${issue.dependencyName}=${issue.currentSpec} expected ${issue.expectedSpec}`).join("\n");
+  throw new Error(
+    [
+      "Treeseed save found inconsistent checked-out package dependency versions.",
+      "Resolve the package manifest drift before saving.",
+      rendered
+    ].join("\n")
+  );
+}
 function repoRoot(cwd = workspaceRoot()) {
   return run("git", ["rev-parse", "--show-toplevel"], { cwd, capture: true }).trim();
 }
@@ -220,7 +269,9 @@ function formatMergeConflictReport(report, repoDir, targetBranch = "main") {
 export {
   MERGE_CONFLICT_EXIT_CODE,
   applyWorkspaceVersionChanges,
+  assertWorkspaceVersionConsistency,
   collectMergeConflictReport,
+  collectWorkspaceVersionConsistencyIssues,
   countConflictMarkers,
   currentBranch,
   formatMergeConflictReport,

package/dist/operations/services/workspace-tools.d.ts

@@ -1,3 +1,4 @@
+export declare const TREESEED_WORKSPACE_PACKAGE_DIRS: string[];
 export declare function workspaceRoot(startCwd?: string): any;
 export declare function findNearestTreeseedRoot(startCwd?: string): string | null;
 export declare function isWorkspaceRoot(root?: string): any;

package/dist/operations/services/workspace-tools.js

@@ -1,7 +1,21 @@
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { join, relative, resolve } from "node:path";
-const TREESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli", "agent", "api"];
+const TREESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli"];
+function packageSortWeight(pkg) {
+  const relativeDir = String(pkg.relativeDir ?? "");
+  const dirName = relativeDir.split("/").pop() ?? "";
+  const index = TREESEED_WORKSPACE_PACKAGE_DIRS.indexOf(dirName);
+  return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
+}
+function compareWorkspacePackages(left, right) {
+  const leftWeight = packageSortWeight(left);
+  const rightWeight = packageSortWeight(right);
+  if (leftWeight !== rightWeight) {
+    return leftWeight - rightWeight;
+  }
+  return left.name.localeCompare(right.name);
+}
 function escapeRegex(source) {
   return source.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
 }
@@ -103,7 +117,7 @@ function workspacePackages(root = workspaceRoot()) {
       });
     }
   }
-  return [...discovered.values()].sort((left, right) => left.name.localeCompare(right.name));
+  return [...discovered.values()].sort(compareWorkspacePackages);
 }
 function internalDependenciesFor(pkg, packageNames) {
   const internalDeps = /* @__PURE__ */ new Set();
@@ -127,7 +141,7 @@ function sortWorkspacePackages(packages) {
       indegree.set(pkg.name, (indegree.get(pkg.name) ?? 0) + 1);
     }
   }
-  const ready = [...packages].filter((pkg) => (indegree.get(pkg.name) ?? 0) === 0).sort((left, right) => left.name.localeCompare(right.name));
+  const ready = [...packages].filter((pkg) => (indegree.get(pkg.name) ?? 0) === 0).sort(compareWorkspacePackages);
   const ordered = [];
   while (ready.length > 0) {
     const next = ready.shift();
@@ -142,13 +156,13 @@ function sortWorkspacePackages(packages) {
         const dependent = packageMap.get(dependentName);
         if (dependent) {
           ready.push(dependent);
-          ready.sort((left, right) => left.name.localeCompare(right.name));
+          ready.sort(compareWorkspacePackages);
         }
       }
     }
   }
   if (ordered.length !== packages.length) {
-    return [...packages].sort((left, right) => left.name.localeCompare(right.name));
+    return [...packages].sort(compareWorkspacePackages);
   }
   return ordered;
 }
@@ -251,6 +265,7 @@ function cleanupDir(dirPath) {
   }
 }
 export {
+  TREESEED_WORKSPACE_PACKAGE_DIRS,
   changedWorkspacePackages,
   cleanupDir,
   createTempDir,

package/dist/operations-registry.js

@@ -3,11 +3,13 @@ function operation(spec) {
 }
 const TRESEED_OPERATION_SPECS = [
   operation({ id: "workspace.status", name: "status", aliases: [], group: "Workflow", summary: "Show Treeseed project health and the current task state.", description: "Report branch/task state, runtime readiness, preview/deploy state, auth readiness, and recommended next operations.", provider: "default", related: ["tasks", "switch", "config"] }),
-  operation({ id: "branch.tasks", name: "tasks", aliases: [], group: "Workflow", summary: "List task branches and preview metadata.", description: "List task-based preview Git branches from local and origin, excluding protected and deprecated refs.", provider: "default", related: ["status", "switch", "close"] }),
-  operation({ id: "branch.switch", name: "switch", aliases: [], group: "Workflow", summary: "Create or resume a task branch.", description: "Create a new task branch from staging or resume an existing local or remote task branch.", provider: "default", related: ["tasks", "dev", "save"] }),
-  operation({ id: "branch.save", name: "save", aliases: [], group: "Workflow", summary: "Verify, commit, sync, push, and refresh preview for the current task.", description: "Run lint, test, and build verification, sync the current branch with origin, push it, and refresh the branch preview when enabled.", provider: "default", related: ["switch", "stage", "status"] }),
-  operation({ id: "branch.close", name: "close", aliases: [], group: "Workflow", summary: "Archive a task branch without merging it.", description: "Destroy branch preview resources, create a deprecated resurrection tag, push the tag, and delete the local and remote branch.", provider: "default", related: ["tasks", "switch", "stage"] }),
-  operation({ id: "branch.stage", name: "stage", aliases: [], group: "Workflow", summary: "Merge the current task into staging and clean it up.", description: "Verify the current task branch, merge it into staging, wait for staging automation, clean preview resources, create a deprecated resurrection tag, and delete the task branch.", provider: "default", related: ["save", "release", "close"] }),
+  operation({ id: "branch.tasks", name: "tasks", aliases: [], group: "Workflow", summary: "List task branches plus package branch alignment.", description: "List task branches from market and checked-out package repos, including preview metadata and branch/pointer alignment state.", provider: "default", related: ["status", "switch", "close"] }),
+  operation({ id: "branch.switch", name: "switch", aliases: [], group: "Workflow", summary: "Create or resume a recursive task branch.", description: "Create or resume the task branch in market and any checked-out package repos, with optional preview provisioning.", provider: "default", related: ["tasks", "dev", "save"] }),
+  operation({ id: "branch.save", name: "save", aliases: [], group: "Workflow", summary: "Recursively verify, commit, and push the current task checkpoint.", description: "Save dirty package repos in dependency order, then verify, commit, push, and optionally refresh preview for market.", provider: "default", related: ["switch", "stage", "status"] }),
+  operation({ id: "branch.close", name: "close", aliases: [], group: "Workflow", summary: "Recursively archive and delete a task branch.", description: "Auto-save if needed, clean preview resources, create deprecated tags, and remove the task branch across market and checked-out package repos.", provider: "default", related: ["tasks", "switch", "stage"] }),
+  operation({ id: "branch.stage", name: "stage", aliases: [], group: "Workflow", summary: "Squash a task branch into staging across market and packages.", description: "Auto-save if needed, squash-merge package task branches into staging first, update market submodule pointers, then squash-merge market into staging and clean up the task branch.", provider: "default", related: ["save", "release", "close"] }),
+  operation({ id: "workspace.resume", name: "resume", aliases: [], group: "Workflow", summary: "Resume an interrupted workflow run.", description: "Continue a failed journaled workflow run from its next incomplete step after validating current workspace preconditions.", provider: "default", related: ["recover", "status"] }),
+  operation({ id: "workspace.recover", name: "recover", aliases: [], group: "Workflow", summary: "Inspect active workflow locks and interrupted runs.", description: "List active workflow locks, resumable interrupted runs, and the exact commands needed to continue or recover the workspace state.", provider: "default", related: ["resume", "status"] }),
   operation({ id: "deploy.rollback", name: "rollback", aliases: [], group: "Workflow", summary: "Roll back staging or production to a recorded deployment.", description: "Redeploy a previously recorded staging or production commit using a temporary checkout of that revision.", provider: "default", related: ["status", "release"] }),
   operation({ id: "workspace.doctor", name: "doctor", aliases: [], group: "Validation", summary: "Diagnose Treeseed tooling, auth, and workflow readiness.", description: "Collect doctor-style diagnostics for workspace readiness and optional safe repairs.", provider: "default", related: ["status", "config"] }),
   operation({ id: "auth.login", name: "auth:login", aliases: [], group: "Validation", summary: "Authenticate against the configured Treeseed API.", description: "Start the device login flow against the active Treeseed API host and persist the returned session locally.", provider: "default", related: ["auth:check", "auth:whoami", "auth:logout"] }),
@@ -18,7 +20,7 @@ const TRESEED_OPERATION_SPECS = [
   operation({ id: "project.init", name: "init", aliases: [], group: "Workflow", summary: "Scaffold a new Treeseed tenant project.", description: "Create a new Treeseed tenant directory from a remote-catalog template backed by the packaged scaffold artifact.", provider: "default", related: ["config", "switch", "dev"] }),
   operation({ id: "project.config", name: "config", aliases: [], group: "Workflow", summary: "Configure and test the runtime foundation.", description: "Apply safe repairs, collect environment values, write local machine config, generate local env files, initialize environments, sync providers, and run doctor-style checks.", provider: "default", related: ["status", "switch", "dev"] }),
   operation({ id: "project.export", name: "export", aliases: [], group: "Utilities", summary: "Export a Markdown snapshot of the current codebase.", description: "Generate a Markdown codebase snapshot for the selected directory using the SDK-owned repomix integration and store it under .treeseed/exports.", provider: "default", related: ["status", "config"] }),
-  operation({ id: "deploy.release", name: "release", aliases: [], group: "Workflow", summary: "Promote staging to production with a version bump.", description: "Validate staging, apply one version bump, tag the release, merge staging into main, push, and rely on production deploy automation.", provider: "default", related: ["stage", "status", "rollback"] }),
+  operation({ id: "deploy.release", name: "release", aliases: [], group: "Workflow", summary: "Release changed packages and market from staging to production.", description: "Select changed packages plus dependents, validate publish workflows, release packages first, then promote market from staging to main with aligned package pointers.", provider: "default", related: ["stage", "status", "rollback"] }),
   operation({ id: "deploy.destroy", name: "destroy", aliases: [], group: "Workflow", summary: "Destroy a persistent environment and its local state.", description: "Delete the selected persistent environment resources and remove the local deploy state after confirmation.", provider: "default", related: ["config", "status"] }),
   operation({ id: "local.dev", name: "dev", aliases: [], group: "Local Development", summary: "Start the unified local Treeseed development environment.", description: "Start the unified local Treeseed development environment.", provider: "default" }),
   operation({ id: "local.devWatch", name: "dev:watch", aliases: [], group: "Local Development", summary: "Start local development with rebuild and watch mode.", description: "Start local development with rebuild and watch mode.", provider: "default" }),