@treeseed/sdk 0.6.39 → 0.6.40

package/dist/operations/services/project-platform.d.ts

@@ -244,6 +244,13 @@ export declare function deployProjectPlatform(options: ProjectPlatformActionOpti
             healthcheckPath: string | null;
             healthcheckTimeoutSeconds: number | null;
             runtimeMode: string | null;
+            volume: {
+                id: string;
+                name: string;
+                mountPath: any;
+                created: boolean;
+                updated: boolean;
+            } | null;
         } | null;
     } | undefined)[];
 }>;
@@ -737,6 +744,13 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
             healthcheckPath: string | null;
             healthcheckTimeoutSeconds: number | null;
             runtimeMode: string | null;
+            volume: {
+                id: string;
+                name: string;
+                mountPath: any;
+                created: boolean;
+                updated: boolean;
+            } | null;
         } | null;
     } | undefined)[];
 }>;

package/dist/operations/services/project-platform.js

@@ -631,9 +631,10 @@ function probeR2(tenantRoot, siteConfig, state, target) {
   }
 }
 function probeScaleConfiguration(siteConfig, state) {
-  const worker = state.services?.worker ?? {};
+  const worker = state.services?.workerRunner ?? state.services?.worker ?? {};
+  const workerConfig = siteConfig.services?.workerRunner ?? siteConfig.services?.worker ?? {};
   const scalerKind = String(process.env.TREESEED_WORKER_POOL_SCALER ?? "").trim();
-  if (scalerKind !== "railway" && siteConfig.services?.worker?.provider !== "railway") {
+  if (scalerKind !== "railway" && workerConfig.provider !== "railway") {
     return {
       ok: true,
       skipped: true,

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

@@ -53,6 +53,20 @@ export type RailwayCustomDomainSummary = {
     verificationToken: string | null;
     dnsRecords: RailwayCustomDomainDnsRecord[];
 };
+export type RailwayVolumeInstanceSummary = {
+    id: string;
+    serviceId: string | null;
+    environmentId: string | null;
+    mountPath: string | null;
+    sizeGb: number | null;
+    usedGb: number | null;
+};
+export type RailwayVolumeSummary = {
+    id: string;
+    name: string;
+    projectId: string | null;
+    instances: RailwayVolumeInstanceSummary[];
+};
 export declare function isUsableRailwayToken(value: string | undefined | null): boolean;
 export declare function resolveRailwayApiToken(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
 export declare function resolveRailwayApiUrl(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
@@ -235,6 +249,25 @@ export declare function upsertRailwayVariables({ projectId, environmentId, servi
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
 }): Promise<void>;
+export declare function listRailwayVolumes({ projectId, env, fetchImpl, }: {
+    projectId: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    fetchImpl?: typeof fetch;
+}): Promise<RailwayVolumeSummary[]>;
+export declare function ensureRailwayServiceVolume({ projectId, environmentId, serviceId, name, mountPath, env, fetchImpl, }: {
+    projectId: string;
+    environmentId: string;
+    serviceId: string;
+    name: string;
+    mountPath: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    fetchImpl?: typeof fetch;
+}): Promise<{
+    volume: RailwayVolumeSummary;
+    instance: RailwayVolumeInstanceSummary | null;
+    created: boolean;
+    updated: boolean;
+}>;
 export declare function listRailwayCustomDomains({ projectId, environmentId, serviceId, env, fetchImpl, }: {
     projectId: string;
     environmentId: string;

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

@@ -191,6 +191,83 @@ function normalizeRailwayCustomDomain(node) {
     dnsRecords
   };
 }
+function normalizeRailwayVolumeInstance(node) {
+  const id = railwayConnectionLabel(node.id);
+  if (!id) {
+    return null;
+  }
+  const sizeGb = normalizeRailwayNumber(node.sizeGb ?? node.sizeGB ?? node.size_gb ?? node.capacityGb ?? node.capacityGB);
+  const usedGb = normalizeRailwayNumber(node.usedGb ?? node.usedGB ?? node.used_gb ?? node.currentUsageGb ?? node.currentUsageGB);
+  return {
+    id,
+    serviceId: railwayConnectionLabel(node.serviceId) || railwayConnectionLabel(node.service?.id) || null,
+    environmentId: railwayConnectionLabel(node.environmentId) || railwayConnectionLabel(node.environment?.id) || null,
+    mountPath: railwayConnectionLabel(node.mountPath) || railwayConnectionLabel(node.mount_path) || null,
+    sizeGb,
+    usedGb
+  };
+}
+function normalizeVolumeInstances(value) {
+  const direct = Array.isArray(value) ? value : null;
+  if (direct) {
+    return direct.map((entry) => entry && typeof entry === "object" ? normalizeRailwayVolumeInstance(entry) : null).filter(Boolean);
+  }
+  return normalizeConnectionNodes(value, normalizeRailwayVolumeInstance);
+}
+function normalizeRailwayVolume(node) {
+  const id = railwayConnectionLabel(node.id);
+  if (!id) {
+    return null;
+  }
+  return {
+    id,
+    name: railwayConnectionLabel(node.name),
+    projectId: railwayConnectionLabel(node.projectId) || null,
+    instances: [
+      ...normalizeVolumeInstances(node.instances),
+      ...normalizeVolumeInstances(node.volumeInstances),
+      ...normalizeVolumeInstances(node.volume_instances)
+    ]
+  };
+}
+function collectRailwayVolumes(value, seen = /* @__PURE__ */ new Set()) {
+  const volumes = [];
+  const visit = (entry) => {
+    if (!entry || typeof entry !== "object") {
+      return;
+    }
+    if (seen.has(entry)) {
+      return;
+    }
+    seen.add(entry);
+    if (Array.isArray(entry)) {
+      for (const item of entry) {
+        visit(item);
+      }
+      return;
+    }
+    const record = entry;
+    const volume = normalizeRailwayVolume(record);
+    if (volume && (record.volumeInstances !== void 0 || record.instances !== void 0 || record.projectId !== void 0 || record.name !== void 0)) {
+      volumes.push(volume);
+    }
+    for (const child of Object.values(record)) {
+      visit(child);
+    }
+  };
+  visit(value);
+  const byId = /* @__PURE__ */ new Map();
+  for (const volume of volumes) {
+    const existing = byId.get(volume.id);
+    byId.set(volume.id, existing ? {
+      ...existing,
+      name: existing.name || volume.name,
+      projectId: existing.projectId || volume.projectId,
+      instances: [...existing.instances, ...volume.instances]
+    } : volume);
+  }
+  return [...byId.values()];
+}
 async function railwayGraphqlRequest({
   query,
   variables,
@@ -811,6 +888,200 @@ mutation TreeseedRailwayVariableCollectionUpsert($input: VariableCollectionUpser
     fetchImpl
   });
 }
+async function listRailwayVolumes({
+  projectId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const query = configuredEnvValue(env, "TREESEED_RAILWAY_VOLUME_LIST_QUERY") || `
+query TreeseedRailwayVolumeList($projectId: String!) {
+	project(id: $projectId) {
+		id
+		volumes {
+			edges {
+				node {
+					id
+					name
+					projectId
+					volumeInstances {
+						edges {
+							node {
+								id
+								serviceId
+								environmentId
+								mountPath
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+`.trim();
+  const payload = await railwayGraphqlRequest({
+    query,
+    variables: { projectId },
+    env,
+    fetchImpl
+  });
+  return collectRailwayVolumes(payload.data);
+}
+async function createRailwayVolume({
+  projectId,
+  environmentId,
+  serviceId,
+  name,
+  mountPath,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const mutation = configuredEnvValue(env, "TREESEED_RAILWAY_VOLUME_CREATE_MUTATION") || `
+mutation TreeseedRailwayVolumeCreate($input: VolumeCreateInput!) {
+	volumeCreate(input: $input) {
+		id
+		name
+		projectId
+		volumeInstances {
+			edges {
+				node {
+					id
+					serviceId
+					environmentId
+					mountPath
+				}
+			}
+		}
+	}
+}
+`.trim();
+  const payload = await railwayGraphqlRequest({
+    query: mutation,
+    variables: {
+      input: {
+        projectId,
+        environmentId,
+        serviceId,
+        name,
+        mountPath
+      }
+    },
+    env,
+    fetchImpl
+  });
+  const volume = collectRailwayVolumes(payload.data)[0] ?? null;
+  if (!volume) {
+    throw new Error(`Railway volume create did not return a usable volume for ${name}.`);
+  }
+  return volume;
+}
+async function updateRailwayVolumeName({
+  volumeId,
+  name,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const mutation = configuredEnvValue(env, "TREESEED_RAILWAY_VOLUME_UPDATE_MUTATION") || `
+mutation TreeseedRailwayVolumeUpdate($id: String!, $input: VolumeUpdateInput!) {
+	volumeUpdate(id: $id, input: $input) {
+		id
+		name
+		projectId
+		volumeInstances {
+			edges {
+				node {
+					id
+					serviceId
+					environmentId
+					mountPath
+				}
+			}
+		}
+	}
+}
+`.trim();
+  const payload = await railwayGraphqlRequest({
+    query: mutation,
+    variables: {
+      id: volumeId,
+      input: { name }
+    },
+    env,
+    fetchImpl
+  });
+  return collectRailwayVolumes(payload.data)[0] ?? null;
+}
+async function updateRailwayVolumeInstanceMountPath({
+  instanceId,
+  mountPath,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const mutation = configuredEnvValue(env, "TREESEED_RAILWAY_VOLUME_INSTANCE_UPDATE_MUTATION") || `
+mutation TreeseedRailwayVolumeInstanceUpdate($id: String!, $input: VolumeInstanceUpdateInput!) {
+	volumeInstanceUpdate(id: $id, input: $input) {
+		id
+		serviceId
+		environmentId
+		mountPath
+	}
+}
+`.trim();
+  await railwayGraphqlRequest({
+    query: mutation,
+    variables: {
+      id: instanceId,
+      input: { mountPath }
+    },
+    env,
+    fetchImpl
+  });
+}
+async function ensureRailwayServiceVolume({
+  projectId,
+  environmentId,
+  serviceId,
+  name,
+  mountPath,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  if (!mountPath.startsWith("/")) {
+    throw new Error(`Railway volume mount path must be absolute: ${mountPath}`);
+  }
+  const volumes = await listRailwayVolumes({ projectId, env, fetchImpl });
+  let volume = volumes.find(
+    (candidate) => candidate.instances.some((instance2) => instance2.serviceId === serviceId && instance2.environmentId === environmentId)
+  ) ?? volumes.find((candidate) => candidate.name === name) ?? null;
+  let created = false;
+  let updated = false;
+  if (!volume) {
+    volume = await createRailwayVolume({
+      projectId,
+      environmentId,
+      serviceId,
+      name,
+      mountPath,
+      env,
+      fetchImpl
+    });
+    created = true;
+  }
+  if (volume.name && volume.name !== name) {
+    volume = await updateRailwayVolumeName({ volumeId: volume.id, name, env, fetchImpl }) ?? { ...volume, name };
+    updated = true;
+  }
+  const instance = volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? null;
+  if (instance && instance.mountPath !== mountPath) {
+    await updateRailwayVolumeInstanceMountPath({ instanceId: instance.id, mountPath, env, fetchImpl });
+    volume = {
+      ...volume,
+      instances: volume.instances.map((entry) => entry.id === instance.id ? { ...entry, mountPath } : entry)
+    };
+    updated = true;
+  }
+  return { volume, instance, created, updated };
+}
 async function listRailwayCustomDomains({
   projectId,
   environmentId,
@@ -863,6 +1134,7 @@ export {
   ensureRailwayProject,
   ensureRailwayService,
   ensureRailwayServiceInstanceConfiguration,
+  ensureRailwayServiceVolume,
   getRailwayAuthProfile,
   getRailwayProject,
   getRailwayServiceInstance,
@@ -872,6 +1144,7 @@ export {
   listRailwayProjects,
   listRailwayServices,
   listRailwayVariables,
+  listRailwayVolumes,
   normalizeRailwayEnvironmentName,
   railwayGraphqlRequest,
   resolveRailwayApiToken,

package/dist/operations/services/railway-deploy.d.ts

@@ -1,4 +1,7 @@
 import { type TreeseedBootstrapTaskPrefix, type TreeseedBootstrapWriter } from './bootstrap-runner.ts';
+export declare function deriveRailwayWorkerRunnerServiceName(projectSlug: any, index?: number): string;
+export declare function deriveRailwayWorkerRunnerVolumeName(serviceName: any): string;
+export declare function railwayServiceRuntimeStartCommand(service: any): any;
 export declare function isUsableRailwayToken(value: any): boolean;
 export declare function resolveRailwayAuthToken(env?: NodeJS.ProcessEnv): string;
 export declare function buildRailwayCommandEnv(env?: NodeJS.ProcessEnv): {
@@ -55,6 +58,10 @@ export declare function configuredRailwayServices(tenantRoot: any, scope: any):
     runtimeMode: any;
     schedule: string[];
     hostingKind: string;
+    runnerPool: {
+        bootstrapIndex: number;
+        volumeMountPath: string;
+    } | null;
 } | null)[];
 export declare function configuredRailwayScheduledJobs(tenantRoot: any, scope: any, { phase }?: {
     phase?: string | undefined;
@@ -95,6 +102,10 @@ export declare function validateRailwayServiceConfiguration(tenantRoot: any, sco
         runtimeMode: any;
         schedule: string[];
         hostingKind: string;
+        runnerPool: {
+            bootstrapIndex: number;
+            volumeMountPath: string;
+        } | null;
     } | null)[];
     schedules: {
         service: string;
@@ -134,6 +145,10 @@ export declare function validateRailwayDeployPrerequisites(tenantRoot: any, scop
         runtimeMode: any;
         schedule: string[];
         hostingKind: string;
+        runnerPool: {
+            bootstrapIndex: number;
+            volumeMountPath: string;
+        } | null;
     } | null)[];
     schedules: {
         service: string;
@@ -296,5 +311,12 @@ export declare function deployRailwayService(tenantRoot: any, service: any, { dr
         healthcheckPath: string | null;
         healthcheckTimeoutSeconds: number | null;
         runtimeMode: string | null;
+        volume: {
+            id: string;
+            name: string;
+            mountPath: any;
+            created: boolean;
+            updated: boolean;
+        } | null;
     } | null;
 }>;

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()) {
@@ -455,7 +473,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 +486,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 +498,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 +901,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 +945,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 +957,42 @@ 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 ensureRailwayServiceVolume({
+    projectId: project.id,
+    environmentId: environment.id,
+    serviceId: railwayService.id,
+    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 deployRailwayService(tenantRoot, service, {
   dryRun = false,
@@ -954,13 +1012,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 +1057,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 +1065,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 +1077,8 @@ export {
   configuredRailwayScheduledJobs,
   configuredRailwayServices,
   deployRailwayService,
+  deriveRailwayWorkerRunnerServiceName,
+  deriveRailwayWorkerRunnerVolumeName,
   ensureRailwayEnvironmentExists,
   ensureRailwayProjectContext,
   ensureRailwayProjectExists,
@@ -1026,6 +1087,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>;