@treeseed/sdk 0.6.39 → 0.6.41

package/dist/operations/services/railway-deploy.js

@@ -10,6 +10,7 @@ import {
   ensureRailwayProject,
   ensureRailwayService,
   ensureRailwayServiceInstanceConfiguration,
+  ensureRailwayServiceVolume,
   listRailwayEnvironments,
   listRailwayProjects,
   listRailwayServices,
@@ -18,7 +19,8 @@ import {
   resolveRailwayApiToken,
   resolveRailwayApiUrl,
   resolveRailwayWorkspace,
-  resolveRailwayWorkspaceContext
+  resolveRailwayWorkspaceContext,
+  upsertRailwayVariables
 } from "./railway-api.js";
 function normalizeScope(scope) {
   return scope === "prod" ? "prod" : scope === "staging" ? "staging" : "local";
@@ -26,13 +28,29 @@ function normalizeScope(scope) {
 function resolveRailwayEnvironmentForScope(scope, configuredEnvironment) {
   return normalizeRailwayEnvironmentName(configuredEnvironment || normalizeScope(scope));
 }
-const RAILWAY_SERVICE_KEYS = ["api", "manager", "worker", "workdayStart", "workdayReport"];
-const HOSTED_PROJECT_SERVICE_KEYS = ["api", "manager", "worker"];
+const RAILWAY_SERVICE_KEYS = ["api", "workdayManager", "workerRunner"];
+const HOSTED_PROJECT_SERVICE_KEYS = ["api", "workdayManager", "workerRunner"];
+const WORKER_RUNNER_BOOTSTRAP_INDEX = 1;
+const WORKER_RUNNER_VOLUME_MOUNT_PATH = "/data";
 function shouldManageRailwaySchedules(scope, phase = "deploy") {
-  return phase === "deploy" && normalizeRailwayEnvironmentName(scope) === "production";
+  const environment = normalizeRailwayEnvironmentName(scope);
+  return phase === "deploy" && (environment === "staging" || environment === "production");
 }
 function railwayServiceNameSuffix(serviceKey) {
-  return serviceKey === "workdayStart" ? "workday-start" : serviceKey === "workdayReport" ? "workday-report" : serviceKey;
+  return serviceKey === "workdayManager" ? "workday-manager" : serviceKey === "workerRunner" ? "worker-runner" : serviceKey;
+}
+function deriveRailwayWorkerRunnerServiceName(projectSlug, index = WORKER_RUNNER_BOOTSTRAP_INDEX) {
+  const normalizedIndex = Math.max(1, Number.parseInt(String(index), 10) || WORKER_RUNNER_BOOTSTRAP_INDEX);
+  return `${projectSlug}-worker-runner-${String(normalizedIndex).padStart(2, "0")}`;
+}
+function deriveRailwayWorkerRunnerVolumeName(serviceName) {
+  return `${serviceName}-data`;
+}
+function railwayServiceRuntimeStartCommand(service) {
+  if (service.key === "workdayManager" && Array.isArray(service.schedule) && service.schedule.length > 0) {
+    return `node -e "console.log('workday-manager scheduled-only service idle')"`;
+  }
+  return service.startCommand;
 }
 function normalizeScheduleExpressions(value) {
   if (typeof value === "string" && value.trim()) {
@@ -55,6 +73,61 @@ function configuredEnvValue(env, name) {
   const value = env?.[name];
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
+function parseRailwayJsonOutput(output) {
+  const trimmed = typeof output === "string" ? output.trim() : "";
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+  }
+  const lines = trimmed.split(/\r?\n/u);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const candidate = lines.slice(index).join("\n").trim();
+    if (!candidate.startsWith("{") && !candidate.startsWith("[")) {
+      continue;
+    }
+    try {
+      return JSON.parse(candidate);
+    } catch {
+    }
+  }
+  return null;
+}
+function normalizeRailwayCliVolume(value, { serviceId, environmentId, fallbackName, fallbackMountPath }) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const id = typeof record.id === "string" && record.id.trim() ? record.id.trim() : "";
+  if (!id) {
+    return null;
+  }
+  const name = typeof record.name === "string" && record.name.trim() ? record.name.trim() : fallbackName;
+  const mountPath = typeof record.mountPath === "string" && record.mountPath.trim() ? record.mountPath.trim() : fallbackMountPath;
+  const sizeMb = typeof record.sizeMB === "number" ? record.sizeMB : null;
+  const currentSizeMb = typeof record.currentSizeMB === "number" ? record.currentSizeMB : null;
+  return {
+    id,
+    name,
+    projectId: null,
+    instances: [{
+      id,
+      serviceId,
+      environmentId,
+      mountPath,
+      sizeGb: sizeMb === null ? null : sizeMb / 1e3,
+      usedGb: currentSizeMb === null ? null : currentSizeMb / 1e3
+    }]
+  };
+}
+function normalizeRailwayCliVolumeList(value, options) {
+  if (!value || typeof value !== "object" || !Array.isArray(value.volumes)) {
+    return [];
+  }
+  return value.volumes.map((entry) => normalizeRailwayCliVolume(entry, options)).filter(Boolean);
+}
 function isUsableRailwayToken(value) {
   return typeof value === "string" && value.trim().length >= 8;
 }
@@ -455,7 +528,7 @@ function configuredRailwayServices(tenantRoot, scope) {
     if (!service || service.enabled === false || (service.provider ?? "railway") !== "railway") {
       return null;
     }
-    const defaultRootDir = ["api", "manager", "worker", "workdayStart", "workdayReport"].includes(serviceKey) ? "." : "packages/core";
+    const defaultRootDir = ["api", "workdayManager", "workerRunner"].includes(serviceKey) ? "." : "packages/core";
     const serviceRoot = resolve(tenantRoot, service.railway?.rootDir ?? service.rootDir ?? defaultRootDir);
     const railwayEnvironment = resolveRailwayEnvironmentForScope(
       normalizedScope,
@@ -468,7 +541,7 @@ function configuredRailwayServices(tenantRoot, scope) {
       projectId: service.railway?.projectId ?? null,
       projectName: service.railway?.projectName ?? identity.deploymentKey,
       serviceId: service.railway?.serviceId ?? null,
-      serviceName: service.railway?.serviceName ?? `${identity.deploymentKey}-${railwayServiceNameSuffix(serviceKey)}`,
+      serviceName: service.railway?.serviceName ?? (serviceKey === "workerRunner" ? deriveRailwayWorkerRunnerServiceName(identity.deploymentKey) : `${identity.deploymentKey}-${railwayServiceNameSuffix(serviceKey)}`),
       rootDir: serviceRoot,
       publicBaseUrl,
       railwayEnvironment,
@@ -480,7 +553,11 @@ function configuredRailwayServices(tenantRoot, scope) {
       restartPolicy: service.railway?.restartPolicy ?? null,
       runtimeMode: service.railway?.runtimeMode ?? null,
       schedule: normalizeScheduleExpressions(service.railway?.schedule),
-      hostingKind
+      hostingKind,
+      runnerPool: serviceKey === "workerRunner" ? {
+        bootstrapIndex: WORKER_RUNNER_BOOTSTRAP_INDEX,
+        volumeMountPath: WORKER_RUNNER_VOLUME_MOUNT_PATH
+      } : null
     };
   }).filter(Boolean);
 }
@@ -879,7 +956,8 @@ async function resolveRailwayDeployProjectContext(service, { env = process.env }
 }
 async function syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, service, { env = process.env } = {}) {
   const wantsInstanceConfig = service.buildCommand || service.startCommand || service.rootDir || service.healthcheckPath || service.healthcheckTimeoutSeconds !== null || service.healthcheckTimeoutSeconds !== void 0 || service.healthcheckIntervalSeconds !== null || service.healthcheckIntervalSeconds !== void 0 || service.restartPolicy || service.runtimeMode;
-  if (!wantsInstanceConfig) {
+  const wantsRunnerVolume = service.key === "workerRunner";
+  if (!wantsInstanceConfig && !wantsRunnerVolume) {
     return null;
   }
   const workspace = await resolveRailwayWorkspaceContext({ env });
@@ -922,11 +1000,11 @@ async function syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, ser
       env
     }).then((result) => result.service);
   }
-  return await ensureRailwayServiceInstanceConfiguration({
+  const runtimeConfiguration = wantsInstanceConfig ? await ensureRailwayServiceInstanceConfiguration({
     serviceId: railwayService.id,
     environmentId: environment.id,
     buildCommand: service.buildCommand,
-    startCommand: service.startCommand,
+    startCommand: railwayServiceRuntimeStartCommand(service),
     rootDirectory: relativeRailwayRootDir(tenantRoot, service.rootDir),
     healthcheckPath: service.healthcheckPath,
     healthcheckTimeoutSeconds: service.healthcheckTimeoutSeconds,
@@ -934,7 +1012,123 @@ async function syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, ser
     restartPolicy: service.restartPolicy,
     runtimeMode: service.runtimeMode,
     env
+  }) : null;
+  const volumeMountPath = service.runnerPool?.volumeMountPath ?? WORKER_RUNNER_VOLUME_MOUNT_PATH;
+  const volumeConfiguration = wantsRunnerVolume ? await ensureRailwayServiceVolumeWithCliFallback({
+    tenantRoot,
+    projectId: project.id,
+    environmentId: environment.id,
+    environmentName: environment.name,
+    serviceId: railwayService.id,
+    serviceName: railwayService.name,
+    name: deriveRailwayWorkerRunnerVolumeName(railwayService.name),
+    mountPath: volumeMountPath,
+    env
+  }) : null;
+  if (wantsRunnerVolume) {
+    await upsertRailwayVariables({
+      projectId: project.id,
+      environmentId: environment.id,
+      serviceId: railwayService.id,
+      variables: {
+        TREESEED_RUNNER_SERVICE_NAME: railwayService.name,
+        TREESEED_RUNNER_VOLUME_ROOT: volumeMountPath,
+        TREESEED_RUNNER_VOLUME_NAME: volumeConfiguration?.volume.name ?? deriveRailwayWorkerRunnerVolumeName(railwayService.name),
+        TREESEED_WORKER_IDLE_EXIT_MS: configuredEnvValue(env, "TREESEED_WORKER_IDLE_EXIT_MS") || "60000",
+        ...volumeConfiguration?.volume.id ? { TREESEED_RUNNER_VOLUME_ID: volumeConfiguration.volume.id } : {}
+      },
+      env
+    });
+  }
+  return {
+    instance: runtimeConfiguration?.instance ?? null,
+    updated: Boolean(runtimeConfiguration?.updated || volumeConfiguration?.updated || volumeConfiguration?.created),
+    volume: volumeConfiguration ? {
+      id: volumeConfiguration.volume.id,
+      name: volumeConfiguration.volume.name,
+      mountPath: volumeConfiguration.instance?.mountPath ?? volumeMountPath,
+      created: volumeConfiguration.created,
+      updated: volumeConfiguration.updated
+    } : null
+  };
+}
+async function ensureRailwayServiceVolumeWithCliFallback({
+  tenantRoot,
+  projectId,
+  environmentId,
+  environmentName,
+  serviceId,
+  serviceName,
+  name,
+  mountPath,
+  env = process.env
+}) {
+  try {
+    return await ensureRailwayServiceVolume({
+      projectId,
+      environmentId,
+      serviceId,
+      name,
+      mountPath,
+      env
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes("Problem processing request")) {
+      throw error;
+    }
+  }
+  const cliOptions = {
+    cwd: tenantRoot,
+    capture: true,
+    env
+  };
+  const volumeArgs = ["volume", "--service", serviceId, "--environment", environmentId];
+  const listResult = runRailway([...volumeArgs, "list", "--json"], cliOptions);
+  const existingVolumes = normalizeRailwayCliVolumeList(parseRailwayJsonOutput(listResult.stdout ?? ""), {
+    serviceId,
+    environmentId,
+    fallbackName: name,
+    fallbackMountPath: mountPath
   });
+  let volume = existingVolumes.find((entry) => entry.name === name) ?? existingVolumes.find((entry) => entry.instances.some((instance2) => instance2.mountPath === mountPath)) ?? existingVolumes[0] ?? null;
+  let created = false;
+  let updated = false;
+  if (!volume) {
+    const createResult = runRailway([...volumeArgs, "add", "--mount-path", mountPath, "--json"], cliOptions);
+    volume = normalizeRailwayCliVolume(parseRailwayJsonOutput(createResult.stdout ?? ""), {
+      serviceId,
+      environmentId,
+      fallbackName: name,
+      fallbackMountPath: mountPath
+    });
+    if (!volume) {
+      throw new Error(`Railway CLI volume add did not return a usable volume for ${serviceName} in ${environmentName}.`);
+    }
+    created = true;
+  }
+  const instance = volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? volume.instances[0] ?? null;
+  if (volume.name !== name || instance?.mountPath !== mountPath) {
+    const updateResult = runRailway([...volumeArgs, "update", "--volume", volume.id, "--name", name, "--mount-path", mountPath, "--json"], cliOptions);
+    const updatedVolume = normalizeRailwayCliVolume(parseRailwayJsonOutput(updateResult.stdout ?? ""), {
+      serviceId,
+      environmentId,
+      fallbackName: name,
+      fallbackMountPath: mountPath
+    });
+    volume = updatedVolume ?? {
+      ...volume,
+      name,
+      instances: volume.instances.map((entry) => ({ ...entry, mountPath }))
+    };
+    updated = true;
+  }
+  return {
+    volume,
+    instance: volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? volume.instances[0] ?? null,
+    created,
+    updated
+  };
 }
 async function deployRailwayService(tenantRoot, service, {
   dryRun = false,
@@ -954,13 +1148,16 @@ async function deployRailwayService(tenantRoot, service, {
   }
   const deployService = await resolveRailwayDeployProjectContext(service, { env });
   const plan = planRailwayServiceDeploy(deployService, { env });
+  const commandEnv = buildRailwayCommandEnv({ ...process.env, ...env });
   const taskPrefix = prefix ?? {
     scope: normalizeScope(deployService.scope ?? deployService.railwayEnvironment ?? "railway"),
     system: deployService.key === "api" ? "api" : "agents",
     task: `${deployService.key}-railway-deploy`,
     stage: "deploy"
   };
-  const commandEnv = buildRailwayCommandEnv({ ...process.env, ...env });
+  const runtimeConfiguration = await syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, deployService, {
+    env: commandEnv
+  });
   if (deployService.buildCommand) {
     const buildResult = await runPrefixedCommand("bash", ["-lc", deployService.buildCommand], {
       cwd: deployService.rootDir,
@@ -996,9 +1193,6 @@ async function deployRailwayService(tenantRoot, service, {
   if (lastFailure) {
     throw new Error(lastFailure.stderr?.trim() || lastFailure.stdout?.trim() || `railway ${plan.args.join(" ")} failed`);
   }
-  const runtimeConfiguration = await syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, deployService, {
-    env: commandEnv
-  });
   return {
     service: deployService.key,
     status: "deployed",
@@ -1007,9 +1201,10 @@ async function deployRailwayService(tenantRoot, service, {
     publicBaseUrl: deployService.publicBaseUrl,
     runtimeConfiguration: runtimeConfiguration ? {
       updated: runtimeConfiguration.updated,
-      healthcheckPath: runtimeConfiguration.instance.healthcheckPath,
-      healthcheckTimeoutSeconds: runtimeConfiguration.instance.healthcheckTimeoutSeconds,
-      runtimeMode: runtimeConfiguration.instance.runtimeMode
+      healthcheckPath: runtimeConfiguration.instance?.healthcheckPath ?? null,
+      healthcheckTimeoutSeconds: runtimeConfiguration.instance?.healthcheckTimeoutSeconds ?? null,
+      runtimeMode: runtimeConfiguration.instance?.runtimeMode ?? null,
+      volume: runtimeConfiguration.volume ?? null
     } : null
   };
 }
@@ -1018,6 +1213,8 @@ export {
   configuredRailwayScheduledJobs,
   configuredRailwayServices,
   deployRailwayService,
+  deriveRailwayWorkerRunnerServiceName,
+  deriveRailwayWorkerRunnerVolumeName,
   ensureRailwayEnvironmentExists,
   ensureRailwayProjectContext,
   ensureRailwayProjectExists,
@@ -1026,6 +1223,7 @@ export {
   isRailwayTransientFailure,
   isUsableRailwayToken,
   planRailwayServiceDeploy,
+  railwayServiceRuntimeStartCommand,
   resolveRailwayAuthToken,
   resolveRailwayDeploymentProfile,
   runRailway,

package/dist/operations/services/release-candidate.d.ts

@@ -8,6 +8,7 @@ export type ReleaseCandidateFailure = {
 };
 export type ReleaseCandidateFingerprint = {
     key: string;
+    policyVersion: string;
     rootSha: string | null;
     packageShas: Record<string, string | null>;
     plannedVersions: Record<string, string>;
@@ -36,4 +37,5 @@ export type ReleaseCandidateInput = {
 export declare function buildReleaseCandidateFingerprint(input: ReleaseCandidateInput): ReleaseCandidateFingerprint;
 export declare function readCachedReleaseCandidateReport(root: string, key: string): ReleaseCandidateReport | null;
 export declare function writeReleaseCandidateReport(root: string, report: ReleaseCandidateReport): ReleaseCandidateReport;
+export declare function collectReleaseCandidateOutputFailures(line: string): string[];
 export declare function runReleaseCandidateGate(input: ReleaseCandidateInput): Promise<ReleaseCandidateReport>;

package/dist/operations/services/release-candidate.js

@@ -13,6 +13,7 @@ import { loadCliDeployConfig } from "./runtime-tools.js";
 import { packagesWithScript, run, workspacePackages } from "./workspace-tools.js";
 import { createBuildWarningSummary, formatAllowedBuildWarnings } from "./build-warning-policy.js";
 const RELEASE_CANDIDATE_CACHE_DIR = ".treeseed/workflow/release-candidates";
+const RELEASE_CANDIDATE_POLICY_VERSION = "strict-output-v1";
 const STABLE_SEMVER = /^\d+\.\d+\.\d+$/u;
 const REHEARSAL_IGNORED_SEGMENTS = /* @__PURE__ */ new Set([
   ".git",
@@ -86,6 +87,7 @@ function buildReleaseCandidateFingerprint(input) {
     ...Object.fromEntries(packages.map((pkg) => [pkg.name, fileSha256(resolve(pkg.dir, "package-lock.json"))]))
   });
   const base = {
+    policyVersion: RELEASE_CANDIDATE_POLICY_VERSION,
     rootSha: safeGitHead(input.root),
     packageShas,
     plannedVersions,
@@ -241,11 +243,15 @@ function runNpmRehearsalCommand(args, options) {
     throw new Error(message);
   }
   const warningSummary = createBuildWarningSummary();
+  const outputFailures = [];
   const emitFiltered = (text, stream) => {
     for (const line of text.split(/\r?\n/u)) {
       if (!line) continue;
       const classified = warningSummary.record(line);
       if (classified.kind === "allowed") continue;
+      for (const failure of collectReleaseCandidateOutputFailures(line)) {
+        outputFailures.push(failure);
+      }
       stream.write(`${line}
 `);
     }
@@ -256,6 +262,27 @@ function runNpmRehearsalCommand(args, options) {
     process.stdout.write(`${line}
 `);
   }
+  if (outputFailures.length > 0) {
+    throw new Error([
+      `npm ${args.join(" ")} completed with error output despite exit code 0.`,
+      ...outputFailures.slice(0, 12)
+    ].join("\n"));
+  }
+}
+function collectReleaseCandidateOutputFailures(line) {
+  const value = String(line ?? "").trim();
+  if (!value) return [];
+  const failures = [];
+  if (/^stderr\s+\|\s+/u.test(value)) {
+    failures.push(`Captured test stderr: ${value}`);
+  }
+  if (/(^|\s)ERROR(?:\s|\[|:)/u.test(value)) {
+    failures.push(`Error output: ${value}`);
+  }
+  if (/\bFailed to run background task\b/u.test(value)) {
+    failures.push(`Background task failure output: ${value}`);
+  }
+  return failures;
 }
 function buildRehearsalWorkspacePackageArtifacts(root) {
   for (const pkg of packagesWithScript("build:dist", root)) {
@@ -561,6 +588,7 @@ async function runReleaseCandidateGate(input) {
 }
 export {
   buildReleaseCandidateFingerprint,
+  collectReleaseCandidateOutputFailures,
   readCachedReleaseCandidateReport,
   runReleaseCandidateGate,
   writeReleaseCandidateReport

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

@@ -53,7 +53,7 @@ const TREESEED_DEFAULT_PROVIDER_SELECTIONS = {
   },
   site: "default"
 };
-const TRESEED_MANAGED_SERVICE_KEYS = ["api", "manager", "worker", "workdayStart", "workdayReport"];
+const TRESEED_MANAGED_SERVICE_KEYS = ["api", "workdayManager", "workerRunner"];
 const TRESEED_WORKSPACE_PACKAGE_DIRS = ["sdk", "core", "cli"];
 const CLOUDFLARE_ACCOUNT_ID_PLACEHOLDER = "replace-with-cloudflare-account-id";
 function normalizePlanesFromLegacyHosting(hosting) {

package/dist/operations-registry.js

@@ -10,6 +10,7 @@ const TRESEED_OPERATION_SPECS = [
   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.tags.cleanup", name: "tags:cleanup", aliases: [], group: "Utilities", summary: "Clean stale Treeseed-managed package dev tags.", description: "Plan or delete stale staging and preview package dev tags that are older than each package current version line while preserving active references and non-Treeseed tags.", provider: "default", related: ["release", "status"] }),
   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: "workspace.links.status", name: workspaceCommand("status"), aliases: [], group: "Utilities", summary: "Inspect local workspace dependency links.", description: "Inspect whether Treeseed package dependencies are linked to local package checkouts or resolved through deployment references.", provider: "default", related: ["dev", "save"] }),

package/dist/reconcile/bootstrap-systems.js

@@ -55,7 +55,7 @@ function agentsSystemDisabled(config) {
   if (config.runtime?.mode === "none") {
     return "runtime.mode is none.";
   }
-  const enabled = ["manager", "worker", "workdayStart", "workdayReport"].some((serviceKey) => serviceEnabled(config, serviceKey));
+  const enabled = ["workdayManager", "workerRunner"].some((serviceKey) => serviceEnabled(config, serviceKey));
   return enabled ? null : "No agent Railway services are enabled.";
 }
 function hasValue(env, key) {

package/dist/reconcile/builtin-adapters.js

@@ -1439,7 +1439,7 @@ async function syncRailwayEnvironmentForScope(input, { dryRun = false } = {}) {
     includeInstances: !dryRun,
     includeVariables: false
   });
-  const workerEntry = topology.services.get("worker") ?? null;
+  const workerEntry = topology.services.get("workerRunner") ?? topology.services.get("worker") ?? null;
   const railwayRuntimeVariables = Object.fromEntries(
     [
       ["TREESEED_RAILWAY_PROJECT_ID", workerEntry?.project?.id],
@@ -2140,16 +2140,12 @@ function createCloudflareReconcileAdapters() {
 function createRailwayReconcileAdapters() {
   return [
     buildRailwayAdapter("railway-service:api"),
-    buildRailwayAdapter("railway-service:manager"),
-    buildRailwayAdapter("railway-service:worker"),
-    buildRailwayAdapter("railway-service:workday-start"),
-    buildRailwayAdapter("railway-service:workday-report"),
+    buildRailwayAdapter("railway-service:workday-manager"),
+    buildRailwayAdapter("railway-service:worker-runner"),
     buildCustomDomainAdapter("custom-domain:api", "railway"),
     buildCompositeAdapter("api-runtime"),
-    buildCompositeAdapter("manager-runtime"),
-    buildCompositeAdapter("worker-runtime"),
-    buildCompositeAdapter("workday-start-runtime"),
-    buildCompositeAdapter("workday-report-runtime")
+    buildCompositeAdapter("workday-manager-runtime"),
+    buildCompositeAdapter("worker-runner-runtime")
   ];
 }
 export {

package/dist/reconcile/contracts.d.ts

@@ -3,7 +3,7 @@ export type TreeseedReconcileProviderId = string;
 export type TreeseedReconcileActionKind = 'noop' | 'create' | 'update' | 'reuse' | 'drift_correct' | 'destroy';
 export type TreeseedReconcileStatusKind = 'pending' | 'ready' | 'drifted' | 'error';
 export type TreeseedReconcileVerificationSource = 'cli' | 'api' | 'sdk' | 'derived';
-export type TreeseedReconcileUnitType = 'web-ui' | 'api-runtime' | 'manager-runtime' | 'worker-runtime' | 'workday-start-runtime' | 'workday-report-runtime' | 'edge-worker' | 'content-store' | 'queue' | 'database' | 'kv-form-guard' | 'pages-project' | 'custom-domain:web' | 'custom-domain:api' | 'dns-record' | 'railway-service:api' | 'railway-service:manager' | 'railway-service:worker' | 'railway-service:workday-start' | 'railway-service:workday-report';
+export type TreeseedReconcileUnitType = 'web-ui' | 'api-runtime' | 'workday-manager-runtime' | 'worker-runner-runtime' | 'edge-worker' | 'content-store' | 'queue' | 'database' | 'kv-form-guard' | 'pages-project' | 'custom-domain:web' | 'custom-domain:api' | 'dns-record' | 'railway-service:api' | 'railway-service:workday-manager' | 'railway-service:worker-runner';
 export type TreeseedReconcileTarget = {
     kind: 'persistent';
     scope: 'local' | 'staging' | 'prod';

package/dist/reconcile/desired-state.js

@@ -11,14 +11,10 @@ function railwayConcreteUnitTypeForServiceKey(serviceKey) {
   switch (serviceKey) {
     case "api":
       return "railway-service:api";
-    case "manager":
-      return "railway-service:manager";
-    case "worker":
-      return "railway-service:worker";
-    case "workdayStart":
-      return "railway-service:workday-start";
-    case "workdayReport":
-      return "railway-service:workday-report";
+    case "workdayManager":
+      return "railway-service:workday-manager";
+    case "workerRunner":
+      return "railway-service:worker-runner";
     default:
       return "railway-service:api";
   }
@@ -227,7 +223,7 @@ function deriveTreeseedDesiredUnits({
         serviceKey,
         scheduleManaged: Array.isArray(configuredService.schedule) && configuredService.schedule.length > 0,
         scheduleBootstrap: false,
-        scheduleDeployScopes: ["prod"],
+        scheduleDeployScopes: ["staging", "prod"],
         bootstrapSystem: serviceBootstrapSystem
       }
     });
@@ -270,14 +266,10 @@ function deriveTreeseedDesiredUnits({
       switch (serviceKey) {
         case "api":
           return "api-runtime";
-        case "manager":
-          return "manager-runtime";
-        case "worker":
-          return "worker-runtime";
-        case "workdayStart":
-          return "workday-start-runtime";
-        case "workdayReport":
-          return "workday-report-runtime";
+        case "workdayManager":
+          return "workday-manager-runtime";
+        case "workerRunner":
+          return "worker-runner-runtime";
         default:
           return "api-runtime";
       }

package/dist/reconcile/state.js

@@ -6,11 +6,11 @@ function stableHash(value) {
   return createHash("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function railwayUnitTypeForServiceKey(serviceKey) {
-  if (serviceKey === "workdayStart") {
-    return "railway-service:workday-start";
+  if (serviceKey === "workdayManager") {
+    return "railway-service:workday-manager";
   }
-  if (serviceKey === "workdayReport") {
-    return "railway-service:workday-report";
+  if (serviceKey === "workerRunner") {
+    return "railway-service:worker-runner";
   }
   return `railway-service:${serviceKey}`;
 }

package/dist/reconcile/units.js

@@ -1,10 +1,8 @@
 const TRESEED_RECONCILE_UNIT_TYPES = [
   "web-ui",
   "api-runtime",
-  "manager-runtime",
-  "worker-runtime",
-  "workday-start-runtime",
-  "workday-report-runtime",
+  "workday-manager-runtime",
+  "worker-runner-runtime",
   "edge-worker",
   "content-store",
   "queue",
@@ -15,10 +13,8 @@ const TRESEED_RECONCILE_UNIT_TYPES = [
   "custom-domain:api",
   "dns-record",
   "railway-service:api",
-  "railway-service:manager",
-  "railway-service:worker",
-  "railway-service:workday-start",
-  "railway-service:workday-report"
+  "railway-service:workday-manager",
+  "railway-service:worker-runner"
 ];
 function targetKey(target) {
   return target.kind === "persistent" ? target.scope : `branch:${target.branchName}`;