@treeseed/sdk 0.8.3 → 0.8.5

package/dist/capacity.d.ts

@@ -1,5 +1,38 @@
 import type { CapacityEstimateConfidence, CapacityGrant, CapacityPlan, CapacityProviderLane, CapacityReservation, TaskEstimateProfile } from './sdk-types.ts';
 import type { AgentProviderProfile } from './types/agents.ts';
+export type ProcessingEnvironment = 'local' | 'staging' | 'prod';
+export interface CapacityProviderRegistration {
+    id: string;
+    teamId: string;
+    providerKind: 'processing-host';
+    serviceBaseUrl: string;
+    environments: ProcessingEnvironment[];
+    capabilities: string[];
+    status: 'pending' | 'active' | 'degraded' | 'disabled';
+    heartbeatAt: string;
+    limits: {
+        maxWorkers: number;
+        dailyTaskCreditBudget: number;
+        maxQueuedTasks: number;
+    };
+}
+export interface CapacityProviderHeartbeat {
+    providerId: string;
+    status: CapacityProviderRegistration['status'];
+    heartbeatAt: string;
+    queueDepth?: number | null;
+    activeWorkers?: number | null;
+    draining?: boolean;
+}
+export interface CapacityProviderHealth {
+    ok: boolean;
+    status: CapacityProviderRegistration['status'];
+    capabilities: string[];
+    queueDepth: number;
+    activeWorkers: number;
+    draining: boolean;
+    checkedAt: string;
+}
 export interface CapacityEstimateInput {
     taskSignature?: string | null;
     taskKind?: string | null;

package/dist/fixture-support.d.ts

@@ -4,7 +4,7 @@ export type FixtureSupportDeclaration = {
     modes: readonly FixtureInjectionMode[];
     workspaceDirName?: string;
     entrySpecifier?: string;
-    contractsShim?: 'core-agent';
+    contractsShim?: 'agent-contracts';
 };
 export type ResolveSharedFixtureOptions = {
     packageRoot?: string;

package/dist/fixture-support.js

@@ -106,15 +106,15 @@ function ensureFixtureLinkedPackage(fixtureRoot, packageName, resolvedPackageRoo
   rmSync(packageDir, { recursive: true, force: true });
   symlinkSync(resolvedPackageRoot, packageDir, "dir");
 }
-function buildCoreAgentContractsShimPackage(fixtureRoot) {
-  const packageDir = resolve(fixtureRoot, "node_modules", "@treeseed", "core");
+function buildAgentContractsShimPackage(fixtureRoot) {
+  const packageDir = resolve(fixtureRoot, "node_modules", "@treeseed", "agent");
   rmSync(packageDir, { recursive: true, force: true });
   mkdirSync(resolve(packageDir, "contracts"), { recursive: true });
   writeFileSync(
     resolve(packageDir, "package.json"),
     JSON.stringify(
       {
-        name: "@treeseed/core",
+        name: "@treeseed/agent",
         type: "module",
         exports: {
           "./runtime-types": {
@@ -315,8 +315,8 @@ function prepareFixturePackages(options) {
         satisfied = true;
         break;
       }
-      if (mode === "contracts-only" && declaration.contractsShim === "core-agent") {
-        buildCoreAgentContractsShimPackage(options.fixtureRoot);
+      if (mode === "contracts-only" && declaration.contractsShim === "agent-contracts") {
+        buildAgentContractsShimPackage(options.fixtureRoot);
         satisfied = true;
         break;
       }

package/dist/managed-dependencies.js

@@ -18,7 +18,13 @@ const GH_ASSETS = [
 ];
 const NPM_TOOLS = [
   { name: "wrangler", packageName: "wrangler", binName: "wrangler", version: "4.86.0" },
-  { name: "railway", packageName: "@railway/cli", binName: "railway", version: "4.44.0" },
+  {
+    name: "railway",
+    packageName: "@railway/cli",
+    binName: "railway",
+    version: "4.44.0",
+    runtimeBinary: (packageRoot) => resolve(packageRoot, "bin", process.platform === "win32" ? "railway.exe" : "railway")
+  },
   { name: "copilot", packageName: "@github/copilot", binName: "copilot", version: "1.0.39" },
   { name: "copilot-language-server", packageName: "@github/copilot-language-server", binName: "copilot-language-server", version: "1.480.0" }
 ];
@@ -186,11 +192,45 @@ function resolvePackageRoot(packageName) {
 function findNpmTool(name) {
   return NPM_TOOLS.find((tool) => tool.name === name) ?? null;
 }
+function resolveNpmToolRuntimeBinary(tool) {
+  const packageJsonPath = resolvePackageJsonPathOptional(tool.packageName);
+  if (!packageJsonPath) {
+    return null;
+  }
+  const packageRoot = dirname(packageJsonPath);
+  const packageBin = resolvePackageBinaryOptional(tool.packageName, tool.binName);
+  if (!packageBin || !existsSync(packageBin)) {
+    return null;
+  }
+  if (!tool.runtimeBinary) {
+    return packageBin;
+  }
+  const runtimeBinary = tool.runtimeBinary(packageRoot);
+  return existsSync(runtimeBinary) ? runtimeBinary : null;
+}
+function npmToolMissingDetail(tool) {
+  const packageJsonPath = resolvePackageJsonPathOptional(tool.packageName);
+  if (!packageJsonPath) {
+    return `${tool.packageName} is missing from the installed package graph.`;
+  }
+  const packageRoot = dirname(packageJsonPath);
+  const packageBin = resolvePackageBinaryOptional(tool.packageName, tool.binName);
+  if (!packageBin || !existsSync(packageBin)) {
+    return `${tool.packageName} binary ${tool.binName} is missing from the installed package.`;
+  }
+  if (tool.runtimeBinary) {
+    const runtimeBinary = tool.runtimeBinary(packageRoot);
+    if (!existsSync(runtimeBinary)) {
+      return `${tool.packageName} runtime binary ${runtimeBinary} is missing. Run \`npx trsd install --json\` or npm install without --ignore-scripts.`;
+    }
+  }
+  return `${tool.packageName} is unavailable.`;
+}
 function npmBackedDependenciesAvailable() {
   try {
     for (const tool of NPM_TOOLS) {
-      const binaryPath = resolvePackageBinary(tool.packageName, tool.binName);
-      if (!existsSync(binaryPath)) {
+      const binaryPath = resolveNpmToolRuntimeBinary(tool);
+      if (!binaryPath || !existsSync(binaryPath)) {
         return false;
       }
     }
@@ -228,6 +268,21 @@ function resolveNpmInstallCommand(env = process.env) {
     display: ["npm", "install", "--no-audit", "--no-fund"]
   };
 }
+function resolveNpmRebuildCommand(env = process.env, packageNames) {
+  const npmExecPath = env.npm_execpath || env.NPM_EXEC_PATH;
+  if (npmExecPath?.trim()) {
+    return {
+      command: process.execPath,
+      args: [npmExecPath, "rebuild", ...packageNames],
+      display: [process.execPath, npmExecPath, "rebuild", ...packageNames]
+    };
+  }
+  return {
+    command: "npm",
+    args: ["rebuild", ...packageNames],
+    display: ["npm", "rebuild", ...packageNames]
+  };
+}
 function runNpmBootstrap(options) {
   const tenantRoot = options.tenantRoot ? resolve(options.tenantRoot) : null;
   const npmCommand = resolveNpmInstallCommand(options.env);
@@ -251,6 +306,16 @@ function runNpmBootstrap(options) {
   }
   const nodeModulesMissing = !existsSync(resolve(tenantRoot, "node_modules"));
   const npmDepsMissing = !npmBackedDependenciesAvailable();
+  const missingRuntimeTools = npmToolsMissingRuntime();
+  if (!options.force && !nodeModulesMissing && npmDepsMissing && missingRuntimeTools.length > 0) {
+    return [{
+      root: tenantRoot,
+      command: npmCommand.display,
+      status: "already-present",
+      exitCode: 0,
+      detail: `npm dependencies are installed; rebuilding missing runtime tools: ${missingRuntimeTools.map((tool) => tool.packageName).join(", ")}.`
+    }];
+  }
   if (!options.force && !nodeModulesMissing && !npmDepsMissing) {
     return [{
       root: tenantRoot,
@@ -292,11 +357,65 @@ ${result.stdout ?? ""}`.trim() || result.error?.message || "";
     detail: ok ? detail || "npm install completed successfully." : detail || "npm install failed."
   }];
 }
+function npmToolsMissingRuntime() {
+  return NPM_TOOLS.filter((tool) => !resolveNpmToolRuntimeBinary(tool));
+}
+function runNpmToolRebuilds(options) {
+  const missingRuntimeTools = npmToolsMissingRuntime();
+  if (missingRuntimeTools.length === 0) {
+    return [];
+  }
+  const tenantRoot = options.tenantRoot ? resolve(options.tenantRoot) : null;
+  const npmCommand = resolveNpmRebuildCommand(options.env, missingRuntimeTools.map((tool) => tool.packageName));
+  if (!tenantRoot || !existsSync(resolve(tenantRoot, "package.json"))) {
+    return [{
+      root: tenantRoot,
+      command: npmCommand.display,
+      status: "skipped",
+      exitCode: null,
+      detail: tenantRoot ? `No package.json found in ${tenantRoot}; npm rebuild skipped.` : "No tenant root was provided; npm rebuild skipped."
+    }];
+  }
+  if (options.env.TREESEED_MANAGED_NPM_INSTALL === "1") {
+    return [{
+      root: tenantRoot,
+      command: npmCommand.display,
+      status: "skipped",
+      exitCode: null,
+      detail: "npm rebuild skipped because TREESEED_MANAGED_NPM_INSTALL=1 is set."
+    }];
+  }
+  options.write?.(`Rebuilding npm-backed Treeseed tools in ${tenantRoot}...`);
+  const result = options.spawn(npmCommand.command, npmCommand.args, {
+    cwd: tenantRoot,
+    env: {
+      ...options.env,
+      TREESEED_MANAGED_NPM_INSTALL: "1"
+    },
+    stdio: "pipe",
+    encoding: "utf8"
+  });
+  const detail = `${result.stderr ?? ""}
+${result.stdout ?? ""}`.trim() || result.error?.message || "";
+  const stillMissing = npmToolsMissingRuntime().map((tool) => tool.packageName);
+  const ok = result.status === 0 && !result.error && stillMissing.length === 0;
+  return [{
+    root: tenantRoot,
+    command: npmCommand.display,
+    status: ok ? "installed" : "failed",
+    exitCode: result.status ?? (ok ? 0 : 1),
+    detail: ok ? detail || "npm-backed Treeseed tools rebuilt successfully." : [
+      detail || "npm-backed Treeseed tool rebuild failed.",
+      stillMissing.length > 0 ? `Missing runtime tools after rebuild: ${stillMissing.join(", ")}` : ""
+    ].filter(Boolean).join("\n")
+  }];
+}
 function formatTreeseedDependencyFailureDetails(result) {
   const npmFailures = result.npmInstalls.filter((entry) => entry.status === "failed").map((entry) => {
     const root = entry.root ?? "no tenant root";
     const exit = entry.exitCode === null ? "unknown exit code" : `exit code ${entry.exitCode}`;
-    return `npm install in ${root}: ${entry.command.join(" ")} failed with ${exit}${entry.detail ? `: ${entry.detail}` : ""}`;
+    const operation = entry.command.includes("rebuild") ? "npm rebuild" : "npm install";
+    return `${operation} in ${root}: ${entry.command.join(" ")} failed with ${exit}${entry.detail ? `: ${entry.detail}` : ""}`;
   });
   const toolFailures = result.reports.filter((entry) => entry.required && ["failed", "missing", "unsupported"].includes(entry.status)).map((entry) => `${entry.name}: ${entry.detail}`);
   return [...npmFailures, ...toolFailures].join("\n- ") || "No dependency failure details were reported.";
@@ -311,7 +430,7 @@ function resolveTreeseedToolBinary(toolName, options = {}) {
   }
   const npmTool = findNpmTool(toolName);
   if (npmTool) {
-    return resolvePackageBinaryOptional(npmTool.packageName, npmTool.binName);
+    return resolveNpmToolRuntimeBinary(npmTool);
   }
   if (toolName === "git" || toolName === "docker") {
     return locateSystemBinary(toolName, spawnSync, options.env ?? process.env);
@@ -323,7 +442,7 @@ function resolveTreeseedToolCommand(toolName, options = {}) {
   if (!binaryPath) {
     return null;
   }
-  if (findNpmTool(toolName)) {
+  if (findNpmTool(toolName) && /\.(?:cjs|mjs|js)$/u.test(binaryPath)) {
     return { command: process.execPath, argsPrefix: [binaryPath], binaryPath };
   }
   return { command: binaryPath, argsPrefix: [], binaryPath };
@@ -339,7 +458,7 @@ function invocationForTool(toolName, env = process.env) {
     };
   }
   return {
-    mode: findNpmTool(toolName) ? "node" : "direct",
+    mode: findNpmTool(toolName) && /\.(?:cjs|mjs|js)$/u.test(command.binaryPath) ? "node" : "direct",
     command: command.command,
     argsPrefix: command.argsPrefix,
     binaryPath: command.binaryPath
@@ -546,7 +665,7 @@ async function installGh(options) {
 }
 function statusForNpmTool(tool, options) {
   try {
-    const binaryPath = resolvePackageBinaryOptional(tool.packageName, tool.binName);
+    const binaryPath = resolveNpmToolRuntimeBinary(tool);
     return report({
       name: tool.name,
       kind: "npm",
@@ -555,7 +674,7 @@ function statusForNpmTool(tool, options) {
       binaryPath,
       status: binaryPath && existsSync(binaryPath) ? "already-present" : "missing",
       required: true,
-      detail: binaryPath && existsSync(binaryPath) ? `${tool.packageName} is available from the Treeseed SDK dependency graph.` : `${tool.packageName} binary ${tool.binName} is missing from the installed package.`
+      detail: binaryPath && existsSync(binaryPath) ? `${tool.packageName} is available from the Treeseed SDK dependency graph.` : npmToolMissingDetail(tool)
     });
   } catch (error) {
     return report({
@@ -681,7 +800,10 @@ async function installTreeseedDependencies(options = {}) {
   };
   mkdirSync(resolveToolsHome(env), { recursive: true });
   mkdirSync(createTreeseedManagedToolEnv(env).GH_CONFIG_DIR, { recursive: true });
-  const npmInstalls = runNpmBootstrap(effectiveOptions);
+  const npmInstalls = [
+    ...runNpmBootstrap(effectiveOptions),
+    ...runNpmToolRebuilds(effectiveOptions)
+  ];
   const reports = [
     systemStatus("git", true, effectiveOptions),
     await installGh(effectiveOptions),

package/dist/operations/services/bootstrap-runner.js

@@ -73,9 +73,15 @@ async function runPrefixedCommand(command, args, {
   prefix
 }) {
   return await new Promise((resolvePromise, reject) => {
+    const childEnv = {};
+    for (const [key, value] of Object.entries({ ...process.env, ...env })) {
+      if (value !== void 0) {
+        childEnv[key] = String(value);
+      }
+    }
     const child = spawn(command, args, {
       cwd,
-      env: { ...process.env, ...env },
+      env: childEnv,
       stdio: ["pipe", "pipe", "pipe"]
     });
     let stdout = "";

package/dist/operations/services/config-runtime.js

@@ -1225,11 +1225,9 @@ function ensureTreeseedRailwayIgnoreEntries(tenantRoot) {
     ".treeseed/",
     ".wrangler/",
     "coverage/",
-    "dist/",
     "node_modules/",
     "npm-debug.log*",
     "packages/*/.git/",
-    "packages/*/dist/",
     "packages/*/node_modules/",
     "public/__treeseed/*.json",
     "public/books/*.json",
@@ -1239,9 +1237,20 @@ function ensureTreeseedRailwayIgnoreEntries(tenantRoot) {
     "*.log",
     "*.tgz"
   ];
+  const removedEntries = /* @__PURE__ */ new Set([
+    "dist/",
+    "**/dist/",
+    "packages/*/dist/"
+  ]);
   const current = existsSync(railwayIgnorePath) ? readFileSync(railwayIgnorePath, "utf8") : "";
-  const lines = current.split(/\r?\n/);
   let changed = false;
+  const lines = current.split(/\r?\n/).filter((line) => {
+    const keep = !removedEntries.has(line.trim());
+    if (!keep) {
+      changed = true;
+    }
+    return keep;
+  });
   for (const entry of requiredEntries) {
     if (!lines.includes(entry)) {
       lines.push(entry);
@@ -2363,7 +2372,7 @@ function createConfigReadiness(values, validation) {
       configured: providerIssues("cloudflare").length === 0
     },
     railway: {
-      configured: providerIssues("railway").length === 0
+      configured: validConfigValue("RAILWAY_API_TOKEN") && providerIssues("railway").length === 0
     },
     localDevelopment: {
       configured: localDevelopmentIssues.length === 0

package/dist/operations/services/github-actions-verification.d.ts

@@ -18,6 +18,9 @@ export type GitHubActionsWorkflowGate = {
     headSha: string;
     timeoutSeconds?: number;
     pollSeconds?: number;
+    dispatchIfMissing?: boolean;
+    dispatchAfterSeconds?: number;
+    dispatchInputs?: Record<string, string>;
 };
 export type GitHubActionsWorkflowJobStep = {
     name: string;

package/dist/operations/services/github-actions-verification.js

@@ -541,6 +541,9 @@ async function waitForGitHubActionsGate(gate, options = {}) {
     branch: gate.branch,
     timeoutSeconds: gate.timeoutSeconds ?? options.timeoutSeconds,
     pollSeconds: gate.pollSeconds ?? options.pollSeconds,
+    dispatchIfMissing: gate.dispatchIfMissing ?? gate.workflow === "verify.yml",
+    dispatchAfterSeconds: gate.dispatchAfterSeconds ?? 75,
+    dispatchInputs: gate.dispatchInputs,
     onProgress: reportProgress
   });
 }

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

@@ -150,13 +150,16 @@ export declare function upsertGitHubRepositoryVariableWithGhCli(repository: stri
 export declare function waitForGitHubWorkflowRunCompletion(repository: string | {
     owner: string;
     name: string;
-}, { client, workflow, headSha, branch, timeoutSeconds, pollSeconds, onProgress, }?: {
+}, { client, workflow, headSha, branch, timeoutSeconds, pollSeconds, dispatchIfMissing, dispatchAfterSeconds, dispatchInputs, onProgress, }?: {
     client?: GitHubApiClient;
     workflow?: string;
     headSha?: string | null;
     branch?: string | null;
     timeoutSeconds?: number;
     pollSeconds?: number;
+    dispatchIfMissing?: boolean;
+    dispatchAfterSeconds?: number;
+    dispatchInputs?: Record<string, string>;
     onProgress?: (event: GitHubWorkflowProgressEvent) => void;
 }): Promise<{
     status: string;

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

@@ -196,13 +196,13 @@ async function paginateNames(request) {
 async function listGitHubRepositorySecretNames(repository, { client = createGitHubApiClient() } = {}) {
   const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
   try {
-    return await paginateNames(
+    return await withGitHubApiRetries(() => paginateNames(
       () => client.paginate(client.rest.actions.listRepoSecrets, {
         owner,
         repo: name,
         per_page: 100
       })
-    );
+    ));
   } catch (error) {
     throw normalizeGitHubApiError(error, `Unable to list GitHub secrets for ${owner}/${name}`);
   }
@@ -210,13 +210,13 @@ async function listGitHubRepositorySecretNames(repository, { client = createGitH
 async function listGitHubRepositoryVariableNames(repository, { client = createGitHubApiClient() } = {}) {
   const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
   try {
-    return await paginateNames(
+    return await withGitHubApiRetries(() => paginateNames(
       () => client.paginate(client.rest.actions.listRepoVariables, {
         owner,
         repo: name,
         per_page: 100
       })
-    );
+    ));
   } catch (error) {
     throw normalizeGitHubApiError(error, `Unable to list GitHub variables for ${owner}/${name}`);
   }
@@ -322,11 +322,11 @@ async function paginateGitHubEnvironmentNames(client, route, params) {
 async function listGitHubEnvironmentSecretNames(repository, environmentName, { client = createGitHubApiClient() } = {}) {
   const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
   try {
-    return await paginateGitHubEnvironmentNames(
+    return await withGitHubApiRetries(() => paginateGitHubEnvironmentNames(
       client,
       "GET /repos/{owner}/{repo}/environments/{environment_name}/secrets",
       { owner, repo: name, environment_name: environmentName }
-    );
+    ));
   } catch (error) {
     throw normalizeGitHubApiError(error, `Unable to list GitHub environment secrets for ${owner}/${name}:${environmentName}`);
   }
@@ -334,11 +334,11 @@ async function listGitHubEnvironmentSecretNames(repository, environmentName, { c
 async function listGitHubEnvironmentVariableNames(repository, environmentName, { client = createGitHubApiClient() } = {}) {
   const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
   try {
-    return await paginateGitHubEnvironmentNames(
+    return await withGitHubApiRetries(() => paginateGitHubEnvironmentNames(
       client,
       "GET /repos/{owner}/{repo}/environments/{environment_name}/variables",
       { owner, repo: name, environment_name: environmentName }
-    );
+    ));
   } catch (error) {
     throw normalizeGitHubApiError(error, `Unable to list GitHub environment variables for ${owner}/${name}:${environmentName}`);
   }
@@ -571,10 +571,14 @@ async function waitForGitHubWorkflowRunCompletion(repository, {
   branch,
   timeoutSeconds = 600,
   pollSeconds = 5,
+  dispatchIfMissing = false,
+  dispatchAfterSeconds = 60,
+  dispatchInputs,
   onProgress
 } = {}) {
   const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
   const startedAt = Date.now();
+  let dispatchedMissingRun = false;
   let lastProgress = null;
   const emitProgress = (type, run = null, jobs = []) => {
     const completedJobs = jobs.filter((job) => job.status === "completed");
@@ -610,6 +614,20 @@ async function waitForGitHubWorkflowRunCompletion(repository, {
       const match = listed.data.workflow_runs.map((run) => normalizeWorkflowRun(run)).find((run) => (!headSha || run.headSha === headSha) && (!branch || run.headBranch === branch));
       if (!match?.id) {
         emitProgress("waiting");
+        if (dispatchIfMissing && branch && !dispatchedMissingRun && Date.now() - startedAt >= dispatchAfterSeconds * 1e3) {
+          try {
+            await client.rest.actions.createWorkflowDispatch({
+              owner,
+              repo: name,
+              workflow_id: workflow,
+              ref: branch,
+              inputs: dispatchInputs
+            });
+            dispatchedMissingRun = true;
+          } catch (error) {
+            throw normalizeGitHubApiError(error, `Unable to dispatch GitHub workflow ${workflow} in ${owner}/${name}`);
+          }
+        }
         await sleep(pollSeconds * 1e3);
         continue;
       }

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

@@ -77,18 +77,26 @@ export declare function requiredGitHubEnvironment(tenantRoot: any, { scope, purp
     variables: string[];
 };
 export declare function requiredGitHubSecrets(tenantRoot: any): string[];
-export declare function renderDeployWorkflow({ workingDirectory, executionBoundary }: {
+export declare function renderDeployWebWorkflow({ workingDirectory }: {
+    workingDirectory: any;
+}): string;
+export declare function renderDeployProcessingWorkflow({ workingDirectory }: {
     workingDirectory: any;
-    executionBoundary?: string | undefined;
 }): string;
 export declare function renderHostedProjectWorkflow({ workingDirectory }: {
     workingDirectory: any;
 }): string;
 export declare function ensureDeployWorkflow(tenantRoot: any): {
-    workingDirectory: string;
-    executionBoundary: string;
     workflowPath: string;
     changed: boolean;
+    workingDirectory: string;
+    executionBoundary: string;
+    additionalWorkflows: {
+        workingDirectory: string;
+        executionBoundary: string;
+        workflowPath: string;
+        changed: boolean;
+    }[];
 };
 export declare function ensureHostedProjectWorkflow(tenantRoot: any): {
     workingDirectory: string;
@@ -197,10 +205,11 @@ export declare function ensureGitHubDeployAutomation(tenantRoot: any, { dryRun,
         skipped?: undefined;
     };
 }>;
-export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repository, workflow, headSha, branch, timeoutSeconds, pollSeconds, onProgress, }?: {
+export declare function waitForGitHubWorkflowCompletion(tenantRoot: any, { repository, workflow, headSha, branch, timeoutSeconds, pollSeconds, dispatchIfMissing, dispatchAfterSeconds, dispatchInputs, onProgress, }?: {
     workflow?: string | undefined;
     timeoutSeconds?: number | undefined;
     pollSeconds?: number | undefined;
+    dispatchIfMissing?: boolean | undefined;
 }): Promise<{
     status: string;
     repository: string;

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

@@ -279,7 +279,6 @@ function requiredGitHubSecrets(tenantRoot) {
 function renderTenantWorkflowActionCommand() {
   return [
     "EXTRA_ARGS=()",
-    'if [[ "${TREESEED_WORKFLOW_SKIP_PROVISION:-}" == "1" ]]; then EXTRA_ARGS+=(--skip-provision); fi',
     'if [[ -n "${TREESEED_WORKFLOW_PROJECT:-}" ]]; then EXTRA_ARGS+=(--project-id "${TREESEED_WORKFLOW_PROJECT}"); fi',
     'if [[ -n "${TREESEED_WORKFLOW_PREVIEW_ID:-}" ]]; then EXTRA_ARGS+=(--preview-id "${TREESEED_WORKFLOW_PREVIEW_ID}"); fi',
     "if test -f ./packages/sdk/scripts/tenant-workflow-action.ts; then",
@@ -305,11 +304,11 @@ function renderWorkflowTemplate(templateName, { workingDirectory }) {
     normalizedWorkingDirectory === "." ? "package-lock.json" : `${normalizedWorkingDirectory}/package-lock.json`
   );
 }
-function deployWorkflowTemplateName(executionBoundary = "direct") {
-  return executionBoundary === "managed" ? "deploy.managed.workflow.yml" : "deploy.workflow.yml";
+function renderDeployWebWorkflow({ workingDirectory }) {
+  return renderWorkflowTemplate("deploy-web.workflow.yml", { workingDirectory });
 }
-function renderDeployWorkflow({ workingDirectory, executionBoundary = "direct" }) {
-  return renderWorkflowTemplate(deployWorkflowTemplateName(executionBoundary), { workingDirectory });
+function renderDeployProcessingWorkflow({ workingDirectory }) {
+  return renderWorkflowTemplate("deploy-processing.workflow.yml", { workingDirectory });
 }
 function renderHostedProjectWorkflow({ workingDirectory }) {
   return renderWorkflowTemplate("hosted-project.workflow.yml", { workingDirectory });
@@ -324,16 +323,44 @@ function ensureWorkflowFile(tenantRoot, fileName, expected) {
   writeFileSync(workflowPath, expected, "utf8");
   return { workflowPath, changed: true };
 }
+function hasConcreteProcessingServices(deployConfig) {
+  return Object.entries(deployConfig.services ?? {}).some(
+    ([serviceKey, service]) => ["api", "manager", "worker", "workerRunner", "workdayStart", "workdayReport"].includes(serviceKey) && service && service.enabled !== false
+  );
+}
+function shouldWriteProcessingWorkflow(deployConfig) {
+  if ((deployConfig.hosting?.kind ?? "self_hosted_project") === "market_control_plane") {
+    return true;
+  }
+  const mode = deployConfig.processing?.mode ?? "market-assigned";
+  return mode === "project-owned" || mode === "local" || hasConcreteProcessingServices(deployConfig);
+}
 function ensureDeployWorkflow(tenantRoot) {
   const repositoryRoot = resolveGitRepositoryRoot(tenantRoot);
   const workingDirectory = relative(repositoryRoot, tenantRoot).replaceAll("\\", "/") || ".";
   const deployConfig = loadCliDeployConfig(tenantRoot);
-  const executionBoundary = usesManagedHostOperationRequests(deployConfig) ? "managed" : "direct";
-  const expected = renderDeployWorkflow({ workingDirectory, executionBoundary });
+  const web = ensureWorkflowFile(tenantRoot, "deploy-web.yml", renderDeployWebWorkflow({ workingDirectory }));
+  const additionalWorkflows = [];
+  let changed = web.changed;
+  if (shouldWriteProcessingWorkflow(deployConfig)) {
+    const processing = ensureWorkflowFile(
+      tenantRoot,
+      "deploy-processing.yml",
+      renderDeployProcessingWorkflow({ workingDirectory })
+    );
+    changed = changed || processing.changed;
+    additionalWorkflows.push({
+      ...processing,
+      workingDirectory,
+      executionBoundary: "split-plane"
+    });
+  }
   return {
-    ...ensureWorkflowFile(tenantRoot, "deploy.yml", expected),
+    workflowPath: web.workflowPath,
+    changed,
     workingDirectory,
-    executionBoundary
+    executionBoundary: "split-plane",
+    additionalWorkflows
   };
 }
 function ensureHostedProjectWorkflow(tenantRoot) {
@@ -348,7 +375,7 @@ function ensureHostedProjectWorkflow(tenantRoot) {
 function ensureStandardizedGitHubWorkflows(tenantRoot) {
   const deployConfig = loadCliDeployConfig(tenantRoot);
   const deploy = ensureDeployWorkflow(tenantRoot);
-  const workflows = [deploy];
+  const workflows = [deploy, ...deploy.additionalWorkflows ?? []];
   if ((deployConfig.hosting?.kind ?? "self_hosted_project") === "market_control_plane") {
     workflows.push(ensureHostedProjectWorkflow(tenantRoot));
   }
@@ -465,6 +492,9 @@ async function waitForGitHubWorkflowCompletion(tenantRoot, {
   branch,
   timeoutSeconds = 600,
   pollSeconds = 5,
+  dispatchIfMissing = false,
+  dispatchAfterSeconds,
+  dispatchInputs,
   onProgress
 } = {}) {
   const repo = repository ?? resolveGitHubRepositorySlug(tenantRoot);
@@ -475,6 +505,9 @@ async function waitForGitHubWorkflowCompletion(tenantRoot, {
     branch,
     timeoutSeconds,
     pollSeconds,
+    dispatchIfMissing,
+    dispatchAfterSeconds,
+    dispatchInputs,
     onProgress
   });
 }
@@ -494,7 +527,8 @@ export {
   listGitHubVariableNames,
   maybeResolveGitHubRepositorySlug,
   parseGitHubRepositoryFromRemote,
-  renderDeployWorkflow,
+  renderDeployProcessingWorkflow,
+  renderDeployWebWorkflow,
   renderHostedProjectWorkflow,
   requiredGitHubEnvironment,
   requiredGitHubSecrets,