@treeseed/sdk 0.6.7 → 0.6.8

package/dist/workflow-state.d.ts

@@ -1,7 +1,42 @@
+import { inspectWorkspaceDependencyMode } from './operations/services/workspace-dependency-mode.ts';
 import type { TreeseedWorkflowNextStep } from './workflow.ts';
 import { type TreeseedWorkflowBranchRole } from './workflow/policy.ts';
 export type TreeseedBranchRole = TreeseedWorkflowBranchRole;
 export type TreeseedWorkflowRecommendation = TreeseedWorkflowNextStep;
+export type TreeseedWorkflowEnvironmentStatus = {
+    phase: string;
+    ready: boolean;
+    configured: boolean;
+    initialized: boolean;
+    provisioned: boolean;
+    deployable: boolean;
+    lastValidatedAt: string | null;
+    lastDeploymentTimestamp: string | null;
+    lastDeployedUrl: string | null;
+    blockers: string[];
+    warnings: string[];
+};
+export type TreeseedWorkflowProviderCheck = {
+    configured: boolean;
+    applicable?: boolean;
+    detail?: string;
+    live?: {
+        checked: boolean;
+        ready: boolean;
+        skipped?: boolean;
+        detail: string;
+    };
+};
+export type TreeseedWorkflowProviderStatus = Record<'local' | 'staging' | 'prod', {
+    github: TreeseedWorkflowProviderCheck;
+    cloudflare: TreeseedWorkflowProviderCheck;
+    railway: TreeseedWorkflowProviderCheck;
+    localDevelopment: TreeseedWorkflowProviderCheck;
+}>;
+export type TreeseedWorkflowStatusOptions = {
+    live?: boolean;
+    env?: NodeJS.ProcessEnv;
+};
 export type TreeseedWorkflowState = {
     cwd: string;
     workspaceRoot: boolean;
@@ -32,6 +67,8 @@ export type TreeseedWorkflowState = {
     packageSync: {
         mode: 'root-only' | 'recursive-workspace';
         completeCheckout: boolean;
+        dependencyMode: string;
+        workspaceLinks: ReturnType<typeof inspectWorkspaceDependencyMode>;
         expectedBranch: string | null;
         aligned: boolean;
         dirty: boolean;
@@ -75,6 +112,8 @@ export type TreeseedWorkflowState = {
         lastDeploymentTimestamp: string | null;
         lastDeployedUrl: string | null;
     }>;
+    environmentStatus: Record<'local' | 'staging' | 'prod', TreeseedWorkflowEnvironmentStatus>;
+    providerStatus: TreeseedWorkflowProviderStatus;
     auth: {
         gh: boolean;
         wrangler: boolean;
@@ -156,5 +195,5 @@ export type TreeseedWorkflowState = {
     }>;
     recommendations: TreeseedWorkflowRecommendation[];
 };
-export declare function resolveTreeseedWorkflowState(cwd: string): TreeseedWorkflowState;
+export declare function resolveTreeseedWorkflowState(cwd: string, options?: TreeseedWorkflowStatusOptions): TreeseedWorkflowState;
 export declare function recommendTreeseedNextSteps(state: TreeseedWorkflowState): TreeseedWorkflowRecommendation[];

package/dist/workflow-state.js

@@ -1,15 +1,18 @@
 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 { validateTreeseedEnvironmentValues } from "./platform/environment.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,
@@ -20,7 +23,9 @@ import { loadCliDeployConfig } from "./operations/services/runtime-tools.js";
 import { collectCliPreflight } from "./operations/services/workspace-preflight.js";
 import { currentBranch, gitStatusPorcelain } from "./operations/services/workspace-save.js";
 import { hasCompleteTreeseedPackageCheckout, isWorkspaceRoot, run, workspacePackages } from "./operations/services/workspace-tools.js";
+import { inspectWorkspaceDependencyMode } from "./operations/services/workspace-dependency-mode.js";
 import { inspectWorkflowLock, listInterruptedWorkflowRuns } from "./workflow/runs.js";
+import { createTreeseedManagedToolEnv, resolveTreeseedToolCommand } from "./managed-dependencies.js";
 import {
   resolveTreeseedWorkflowPaths,
   workflowEnvironmentForBranchRole
@@ -32,6 +37,29 @@ function emptyPersistentEnvironments() {
     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];
@@ -75,6 +103,143 @@ function safeResolveMachineEnvironmentValues(cwd, scope) {
     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 === "GH_TOKEN" || id === "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 = typeof values.GH_TOKEN === "string" && values.GH_TOKEN.trim().length > 0;
+  const cloudflareConfigured = typeof values.CLOUDFLARE_API_TOKEN === "string" && values.CLOUDFLARE_API_TOKEN.trim().length > 0;
+  const railwayConfigured = typeof values.RAILWAY_API_TOKEN === "string" && values.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 {
     run("git", ["show-ref", "--verify", "--quiet", `refs/remotes/origin/${branchName}`], { cwd: repoDir, capture: true });
@@ -83,7 +248,10 @@ function knownRemoteTrackingBranchExists(repoDir, branchName) {
     return false;
   }
 }
-function resolveTreeseedWorkflowState(cwd) {
+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);
@@ -94,6 +262,7 @@ function resolveTreeseedWorkflowState(cwd) {
   const branchRole = resolved.branchRole;
   const dirtyWorktree = root ? gitStatusPorcelain(root).length > 0 : false;
   const completePackageCheckout = hasCompleteTreeseedPackageCheckout(effectiveCwd);
+  const workspaceDependencyMode = inspectWorkspaceDependencyMode(effectiveCwd);
   const packageSyncRepos = completePackageCheckout ? workspacePackages(effectiveCwd).filter((pkg) => pkg.name?.startsWith("@treeseed/")).map((pkg) => {
     const repoBranch = currentBranch(pkg.dir) || null;
     const dirty = gitStatusPorcelain(pkg.dir).length > 0;
@@ -184,6 +353,8 @@ function resolveTreeseedWorkflowState(cwd) {
     packageSync: {
       mode: completePackageCheckout ? "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),
@@ -208,6 +379,8 @@ function resolveTreeseedWorkflowState(cwd) {
       lastContentPurgeCount: null
     },
     persistentEnvironments: emptyPersistentEnvironments(),
+    environmentStatus: emptyEnvironmentStatus(),
+    providerStatus: emptyProviderStatus(),
     auth: {
       gh: preflight.checks.auth.gh?.authenticated === true,
       wrangler: preflight.checks.auth.wrangler?.authenticated === true,
@@ -278,7 +451,19 @@ function resolveTreeseedWorkflowState(cwd) {
     try {
       const deployConfig = loadCliDeployConfig(effectiveCwd);
       const environmentContext = collectTreeseedEnvironmentContext(effectiveCwd);
-      const sharedConfigValues = safeResolveMachineEnvironmentValues(effectiveCwd, "prod");
+      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);
@@ -287,6 +472,10 @@ function resolveTreeseedWorkflowState(cwd) {
       const runtimeSessionReady = Boolean(
         marketSettings?.runnerReady === true || typeof runnerSession?.accessToken === "string" && runnerSession.accessToken.length > 0
       );
+      state.auth.gh = state.auth.gh || hasStatusConfigValue(statusConfigByScope, "GH_TOKEN");
+      state.auth.wrangler = state.auth.wrangler || hasStatusConfigValue(statusConfigByScope, "CLOUDFLARE_API_TOKEN");
+      state.auth.railway = state.auth.railway || hasStatusConfigValue(statusConfigByScope, "RAILWAY_API_TOKEN");
+      state.auth.copilot = state.auth.copilot || state.auth.gh;
       state.marketConnection.baseUrl = state.marketConnection.baseUrl ?? sharedConfigValues.TREESEED_MARKET_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;
@@ -302,26 +491,23 @@ function resolveTreeseedWorkflowState(cwd) {
       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 = validateTreeseedEnvironmentValues({
-          values: safeResolveMachineEnvironmentValues(effectiveCwd, scope),
-          scope,
-          purpose: "config",
-          deployConfig: environmentContext.context.deployConfig,
-          tenantConfig: environmentContext.context.tenantConfig,
-          plugins: environmentContext.context.plugins
-        });
-        const validationProblems = [...validation.missing, ...validation.invalid].map((problem) => problem.message);
+        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" ? validation.ok : deployState.readiness?.configured === true && validation.ok;
+        const configured = scope === "local" ? statusValidationOk : deployState.readiness?.configured === true && statusValidationOk;
         const provisioned = scope === "local" ? true : configured && deployState.readiness?.provisioned === true;
-        const deployable = scope === "local" ? validation.ok : configured && deployState.readiness?.deployable === true;
+        const deployable = scope === "local" ? statusValidationOk : configured && deployState.readiness?.deployable === true;
         const initialized = deployState.readiness?.initialized === true || scope === "local";
         state.persistentEnvironments[scope] = {
           initialized,
-          phase: validation.ok ? scope === "local" ? "code_ready" : provisioned ? "provisioned" : configured ? "config_complete" : initialized ? "config_complete" : "pending" : "config_incomplete",
+          phase: statusValidationOk ? scope === "local" ? "code_ready" : provisioned ? "provisioned" : configured ? "config_complete" : initialized ? "config_complete" : "pending" : "config_incomplete",
           configured,
           provisioned,
           deployable,
@@ -331,8 +517,8 @@ function resolveTreeseedWorkflowState(cwd) {
           ],
           warnings: persistentWarnings,
           lastValidatedAt: deployState.readiness?.lastValidatedAt ?? deployState.readiness?.initializedAt ?? null,
-          lastDeploymentTimestamp: deployState.lastDeploymentTimestamp ?? null,
-          lastDeployedUrl: deployState.lastDeployedUrl ?? 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 ?? [] : [];
@@ -377,6 +563,23 @@ function resolveTreeseedWorkflowState(cwd) {
   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 = [

package/dist/workflow-support.d.ts

@@ -7,6 +7,9 @@ export { configuredRailwayServices, deployRailwayService, validateRailwayDeployP
 export { ensureRailwayEnvironment, ensureRailwayProject, ensureRailwayService, getRailwayAuthProfile, listRailwayEnvironments, listRailwayProjects, listRailwayServices, listRailwayVariables, railwayGraphqlRequest, resolveRailwayApiToken, resolveRailwayApiUrl, resolveRailwayWorkspace, resolveRailwayWorkspaceContext, upsertRailwayVariables, } from './operations/services/railway-api.ts';
 export { runTenantDeployPreflight, runWorkspaceSavePreflight, } from './operations/services/save-deploy-preflight.ts';
 export { collectCliPreflight } from './operations/services/workspace-preflight.ts';
+export { collectTreeseedDependencyStatus, createTreeseedManagedToolEnv, formatTreeseedDependencyFailureDetails, formatTreeseedDependencyReport, installTreeseedDependencies, resolveTreeseedToolBinary, resolveTreeseedToolCommand, } from './managed-dependencies.ts';
+export { runTreeseedCopilotTask, type TreeseedCopilotTaskInput, type TreeseedCopilotTaskResult, } from './copilot.ts';
 export { applyWorkspaceVersionChanges, collectMergeConflictReport, currentBranch, formatMergeConflictReport, gitStatusPorcelain, hasMeaningfulChanges, incrementVersion, originRemoteUrl, planWorkspaceReleaseBump, repoRoot, } from './operations/services/workspace-save.ts';
+export { assertNoWorkspaceLinksInDeploymentLockfiles, collectDeploymentLockfileWorkspaceIssues, discoverWorkspaceLinks, ensureLocalWorkspaceLinks, inspectWorkspaceDependencyMode, unlinkLocalWorkspaceLinks, type DependencyResolutionMode, type DeploymentLockfileWorkspaceIssue, type WorkspaceLinksMode, } from './operations/services/workspace-dependency-mode.ts';
 export { findNearestTreeseedRoot, findNearestTreeseedWorkspaceRoot, isWorkspaceRoot, run, workspaceRoot, } from './operations/services/workspace-tools.ts';
 export { collectTreeseedReconcileStatus, createTreeseedReconcileRegistry, deriveTreeseedDesiredUnits, destroyTreeseedTargetUnits, observeTreeseedUnits, planTreeseedReconciliation, reconcileTreeseedTarget, } from './reconcile/index.ts';

package/dist/workflow-support.js

@@ -111,6 +111,18 @@ import {
   runWorkspaceSavePreflight
 } from "./operations/services/save-deploy-preflight.js";
 import { collectCliPreflight } from "./operations/services/workspace-preflight.js";
+import {
+  collectTreeseedDependencyStatus,
+  createTreeseedManagedToolEnv,
+  formatTreeseedDependencyFailureDetails,
+  formatTreeseedDependencyReport,
+  installTreeseedDependencies,
+  resolveTreeseedToolBinary,
+  resolveTreeseedToolCommand
+} from "./managed-dependencies.js";
+import {
+  runTreeseedCopilotTask
+} from "./copilot.js";
 import {
   applyWorkspaceVersionChanges,
   collectMergeConflictReport,
@@ -123,6 +135,14 @@ import {
   planWorkspaceReleaseBump,
   repoRoot
 } from "./operations/services/workspace-save.js";
+import {
+  assertNoWorkspaceLinksInDeploymentLockfiles,
+  collectDeploymentLockfileWorkspaceIssues,
+  discoverWorkspaceLinks,
+  ensureLocalWorkspaceLinks,
+  inspectWorkspaceDependencyMode,
+  unlinkLocalWorkspaceLinks
+} from "./operations/services/workspace-dependency-mode.js";
 import {
   findNearestTreeseedRoot,
   findNearestTreeseedWorkspaceRoot,
@@ -151,6 +171,7 @@ export {
   assertCleanWorktree,
   assertDeploymentInitialized,
   assertFeatureBranch,
+  assertNoWorkspaceLinksInDeploymentLockfiles,
   assertTreeseedCommandEnvironment,
   branchExists,
   checkTreeseedProviderConnections,
@@ -158,8 +179,10 @@ export {
   cleanupDestroyedState,
   clearTreeseedRemoteSession,
   collectCliPreflight,
+  collectDeploymentLockfileWorkspaceIssues,
   collectMergeConflictReport,
   collectTreeseedConfigContext,
+  collectTreeseedDependencyStatus,
   collectTreeseedPrintEnvReport,
   collectTreeseedReconcileStatus,
   configuredRailwayServices,
@@ -168,6 +191,7 @@ export {
   createDeprecatedTaskTag,
   createFeatureBranchFromStaging,
   createPersistentDeployTarget,
+  createTreeseedManagedToolEnv,
   createTreeseedReconcileRegistry,
   currentBranch,
   currentManagedBranch,
@@ -178,8 +202,10 @@ export {
   deriveTreeseedDesiredUnits,
   destroyCloudflareResources,
   destroyTreeseedTargetUnits,
+  discoverWorkspaceLinks,
   ensureGeneratedWranglerConfig,
   ensureLocalBranchTracking,
+  ensureLocalWorkspaceLinks,
   ensureRailwayEnvironment,
   ensureRailwayProject,
   ensureRailwayService,
@@ -192,6 +218,8 @@ export {
   findNearestTreeseedRoot,
   findNearestTreeseedWorkspaceRoot,
   formatMergeConflictReport,
+  formatTreeseedDependencyFailureDetails,
+  formatTreeseedDependencyReport,
   getRailwayAuthProfile,
   getTreeseedMachineConfigPaths,
   gitStatusPorcelain,
@@ -201,6 +229,8 @@ export {
   inspectTreeseedKeyAgentStatus,
   inspectTreeseedKeyAgentTransportDiagnostic,
   inspectTreeseedPassphraseEnvDiagnostic,
+  inspectWorkspaceDependencyMode,
+  installTreeseedDependencies,
   isWorkspaceRoot,
   listDeprecatedTreeseedLocalEnvFiles,
   listRailwayEnvironments,
@@ -238,16 +268,20 @@ export {
   resolveTreeseedMachineEnvironmentValues,
   resolveTreeseedRemoteConfig,
   resolveTreeseedRemoteSession,
+  resolveTreeseedToolBinary,
+  resolveTreeseedToolCommand,
   resolveWranglerBin,
   rotateTreeseedMachineKey,
   rotateTreeseedMachineKeyPassphrase,
   run,
   runRemoteD1Migrations,
   runTenantDeployPreflight,
+  runTreeseedCopilotTask,
   runWorkspaceSavePreflight,
   setTreeseedRemoteSession,
   syncBranchWithOrigin,
   syncCloudflareSecrets,
+  unlinkLocalWorkspaceLinks,
   unlockTreeseedSecretSessionFromEnv,
   unlockTreeseedSecretSessionInteractive,
   unlockTreeseedSecretSessionWithPassphrase,

package/dist/workflow.d.ts

@@ -1,4 +1,4 @@
-import { resolveTreeseedWorkflowState } from './workflow-state.ts';
+import { resolveTreeseedWorkflowState, type TreeseedWorkflowStatusOptions } from './workflow-state.ts';
 import { listTaskBranches } from './operations/services/git-workflow.ts';
 import { TreeseedWorkflowError, type TreeseedWorkflowErrorCode } from './workflow/operations.ts';
 export type TreeseedWorkflowOperationId = 'status' | 'config' | 'tasks' | 'switch' | 'dev' | 'save' | 'close' | 'stage' | 'release' | 'resume' | 'recover' | 'destroy' | 'export';
@@ -90,12 +90,20 @@ export type TreeseedWorkflowWorkstreamSummary = {
     archived: boolean;
 };
 export type TreeseedSaveInput = {
-    message: string;
+    message?: string;
     hotfix?: boolean;
     verify?: boolean;
     refreshPreview?: boolean;
     preview?: boolean;
     rebase?: boolean;
+    bump?: 'major' | 'minor' | 'patch';
+    devVersionStrategy?: 'prerelease';
+    devDependencyReferenceMode?: 'git-tag' | 'registry-prerelease';
+    gitDependencyProtocol?: 'preserve-origin' | 'https' | 'ssh';
+    gitRemoteWriteMode?: 'ssh-pushurl' | 'off';
+    verifyMode?: 'action-first' | 'local-only' | 'skip';
+    commitMessageMode?: 'auto' | 'cloudflare' | 'generated' | 'fallback';
+    workspaceLinks?: 'auto' | 'off';
     plan?: boolean;
     dryRun?: boolean;
 };
@@ -104,6 +112,7 @@ export type TreeseedCloseInput = {
     deletePreview?: boolean;
     deleteBranch?: boolean;
     autoSave?: boolean;
+    workspaceLinks?: 'auto' | 'off';
     plan?: boolean;
     dryRun?: boolean;
 };
@@ -113,6 +122,7 @@ export type TreeseedStageInput = {
     deletePreview?: boolean;
     deleteBranch?: boolean;
     autoSave?: boolean;
+    workspaceLinks?: 'auto' | 'off';
     plan?: boolean;
     dryRun?: boolean;
 };
@@ -122,6 +132,7 @@ export type TreeseedSwitchInput = {
     preview?: boolean;
     createIfMissing?: boolean;
     baseBranch?: string;
+    workspaceLinks?: 'auto' | 'off';
     plan?: boolean;
     dryRun?: boolean;
 };
@@ -166,6 +177,10 @@ export type TreeseedExportInput = {
 };
 export type TreeseedReleaseInput = {
     bump: 'major' | 'minor' | 'patch';
+    devTagCleanup?: 'safe-after-release' | 'off';
+    gitDependencyProtocol?: 'preserve-origin' | 'https' | 'ssh';
+    gitRemoteWriteMode?: 'ssh-pushurl' | 'off';
+    workspaceLinks?: 'auto' | 'off';
     plan?: boolean;
     dryRun?: boolean;
 };
@@ -191,6 +206,7 @@ export type TreeseedWorkflowDevInput = {
     port?: number | string;
     background?: boolean;
     stdio?: 'inherit' | 'pipe';
+    workspaceLinks?: 'auto' | 'off';
 };
 export { TreeseedWorkflowError };
 export type { TreeseedWorkflowErrorCode };
@@ -202,7 +218,7 @@ export declare class TreeseedWorkflowSdk {
         tasks: TreeseedTaskBranchMetadata[];
         workstreams: TreeseedWorkflowWorkstreamSummary[];
     }> | TreeseedWorkflowResult<Record<string, unknown>>>;
-    status(): Promise<TreeseedWorkflowResult<ReturnType<typeof resolveTreeseedWorkflowState>>>;
+    status(input?: TreeseedWorkflowStatusOptions): Promise<TreeseedWorkflowResult<ReturnType<typeof resolveTreeseedWorkflowState>>>;
     tasks(): Promise<TreeseedWorkflowResult<{
         tasks: TreeseedTaskBranchMetadata[];
         workstreams: TreeseedWorkflowWorkstreamSummary[];

package/dist/workflow.js

@@ -41,7 +41,7 @@ class TreeseedWorkflowSdk {
   async execute(operation, input = {}) {
     switch (operation) {
       case "status":
-        return this.status();
+        return this.status(input);
       case "tasks":
         return this.tasks();
       case "config":
@@ -70,8 +70,8 @@ class TreeseedWorkflowSdk {
         throw new Error(`Unsupported workflow operation "${operation}".`);
     }
   }
-  async status() {
-    return workflowStatus(this.helpers());
+  async status(input = {}) {
+    return workflowStatus(this.helpers(), input);
   }
   async tasks() {
     return workflowTasks(this.helpers());

package/dist/wrangler-d1.js

@@ -1,5 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { resolveTreeseedToolCommand } from "./managed-dependencies.js";
 const execFileAsync = promisify(execFile);
 function toSqlValue(value) {
   if (value === null || value === void 0) {
@@ -41,7 +42,11 @@ class WranglerD1PreparedStatement {
     if (this.persistTo) {
       args.splice(3, 0, "--local", "--persist-to", this.persistTo);
     }
-    const { stdout } = await execFileAsync("wrangler", args, {
+    const wrangler = resolveTreeseedToolCommand("wrangler");
+    if (!wrangler) {
+      throw new Error("Wrangler CLI is unavailable.");
+    }
+    const { stdout } = await execFileAsync(wrangler.command, [...wrangler.argsPrefix, ...args], {
       cwd: this.cwd,
       env: process.env
     });