@treeseed/sdk 0.12.59 → 0.12.61

package/dist/reconcile/providers/railway-iac.js

@@ -1,9 +1,160 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import {
   runRailwayIac
 } from "railway/iac";
 import { assertApiRailwaySourcePolicy, isApiRailwaySourcePolicyService } from "../../operations/services/railway-source-policy.js";
+async function waitForRailwayVolumeAdoptionResources({
+  load,
+  serviceName,
+  volumeId,
+  attempts = 12,
+  intervalMs = 2500,
+  sleep = (milliseconds) => new Promise((resolve2) => setTimeout(resolve2, milliseconds))
+}) {
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const current = await load();
+    const service = current.services.find((candidate) => candidate.name === serviceName) ?? null;
+    const volume = current.volumes.find((candidate) => candidate.id === volumeId) ?? null;
+    if (service && volume) return { service, volume, services: current.services, volumes: current.volumes, attempt };
+    if (attempt < attempts) await sleep(intervalMs);
+  }
+  return null;
+}
+async function waitForRailwayServices({
+  load,
+  serviceNames,
+  attempts = 12,
+  intervalMs = 2500,
+  sleep = (milliseconds) => new Promise((resolve2) => setTimeout(resolve2, milliseconds))
+}) {
+  const expected = [...new Set(serviceNames)];
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const services = await load();
+    const observed = new Set(services.map((service) => service.name).filter(Boolean));
+    if (expected.every((name) => observed.has(name))) return { services, attempt };
+    if (attempt < attempts) await sleep(intervalMs);
+  }
+  return null;
+}
+async function waitForRailwayVolumeName({
+  load,
+  volumeId,
+  expectedName,
+  attempts = 12,
+  intervalMs = 2500,
+  sleep = (milliseconds) => new Promise((resolve2) => setTimeout(resolve2, milliseconds))
+}) {
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const volume = (await load()).find((candidate) => candidate.id === volumeId) ?? null;
+    if (volume?.name === expectedName) return { volume, attempt };
+    if (attempt < attempts) await sleep(intervalMs);
+  }
+  return null;
+}
+async function waitForRailwayVolumeDetachment({
+  load,
+  volumeId,
+  environmentId,
+  serviceId,
+  attempts = 12,
+  intervalMs = 2500,
+  sleep = (milliseconds) => new Promise((resolve2) => setTimeout(resolve2, milliseconds))
+}) {
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const volume = (await load()).find((candidate) => candidate.id === volumeId) ?? null;
+    const attached = volume?.instances?.some(
+      (instance) => instance.environmentId === environmentId && instance.serviceId === serviceId
+    ) ?? false;
+    if (!attached) return { volume, attempt };
+    if (attempt < attempts) await sleep(intervalMs);
+  }
+  return null;
+}
+async function waitForRailwayServiceAbsence({
+  load,
+  serviceId,
+  attempts = 12,
+  intervalMs = 2500,
+  sleep = (milliseconds) => new Promise((resolve2) => setTimeout(resolve2, milliseconds))
+}) {
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    if (!(await load()).some((service) => service.id === serviceId)) return { attempt };
+    if (attempt < attempts) await sleep(intervalMs);
+  }
+  return null;
+}
+const STALE_RAILWAY_IAC_RENDER_AGE_MS = 15 * 60 * 1e3;
+function cleanupStaleRailwayIacRenders(tenantRoot, now = Date.now()) {
+  const tempParent = resolve(tenantRoot, ".treeseed", "tmp");
+  let entries;
+  try {
+    entries = readdirSync(tempParent);
+  } catch {
+    return [];
+  }
+  const removed = [];
+  for (const entry of entries.filter((name) => name.startsWith("railway-iac-"))) {
+    const path = resolve(tempParent, entry);
+    try {
+      if (now - statSync(path).mtimeMs < STALE_RAILWAY_IAC_RENDER_AGE_MS) continue;
+      rmSync(path, { recursive: true, force: true });
+      removed.push(path);
+    } catch {
+    }
+  }
+  return removed;
+}
+function railwayIacApplyFailure(response) {
+  const diagnostics = (response.diagnostics ?? []).map((entry) => String(entry.message ?? "").trim()).filter(Boolean);
+  if (!response.ok) return diagnostics.join("; ") || "Railway IaC planning failed before apply.";
+  const changes = response.changeSet?.changes ?? [];
+  if (changes.length === 0) return null;
+  if (!response.applyResult) return "Railway IaC returned no apply result for a non-empty change set.";
+  const successfulStatuses = /* @__PURE__ */ new Set(["APPLIED", "COMPLETED", "SUCCESS", "SUCCEEDED"]);
+  const applyStatus = String(response.applyResult.status ?? "").trim().toUpperCase();
+  const failedChanges = (response.applyResult.changes ?? []).filter((change) => !successfulStatuses.has(String(change.status ?? "").trim().toUpperCase())).map((change) => `${change.path ?? change.kind}: ${change.status || "unknown"}`);
+  const applyDiagnostics = (response.applyResult.diagnostics ?? []).map((entry) => typeof entry === "string" ? entry : JSON.stringify(entry)).filter(Boolean);
+  if (!successfulStatuses.has(applyStatus) || failedChanges.length > 0 || applyDiagnostics.length > 0) {
+    return [
+      `apply status ${applyStatus || "unknown"}`,
+      ...failedChanges,
+      ...diagnostics,
+      ...applyDiagnostics
+    ].join("; ");
+  }
+  return null;
+}
+async function runRailwayIacWithRateLimitRetry(run, {
+  delaysMs = [15e3, 45e3, 9e4],
+  sleep = (milliseconds) => new Promise((resolve2) => setTimeout(resolve2, milliseconds)),
+  onRetry,
+  onWait
+} = {}) {
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      const result = await run();
+      if (result && typeof result === "object" && "ok" in result && result.ok === false) {
+        const diagnostics = Array.isArray(result.diagnostics) ? result.diagnostics.map((entry) => typeof entry === "string" ? entry : String(entry?.message ?? "")).filter(Boolean).join("; ") : "";
+        if (/fetch failed|timed out|etimedout|econnreset|enetunreach|temporarily unavailable|aborted|HTTP\s+429|rate[ -]?limit/iu.test(diagnostics)) {
+          throw new Error(diagnostics || "Railway IaC transport failed.");
+        }
+      }
+      return result;
+    } catch (error) {
+      const delayMs = delaysMs[attempt - 1];
+      if (delayMs === void 0 || !/fetch failed|timed out|etimedout|econnreset|enetunreach|temporarily unavailable|aborted|HTTP\s+429|rate[ -]?limit/iu.test(String(error))) throw error;
+      onRetry?.(attempt + 1, delayMs, error);
+      let remainingMs = delayMs;
+      while (remainingMs > 0) {
+        const sliceMs = Math.min(15e3, remainingMs);
+        await sleep(sliceMs);
+        remainingMs -= sliceMs;
+        if (remainingMs > 0) onWait?.(attempt + 1, remainingMs);
+      }
+    }
+  }
+}
 function js(value) {
   return JSON.stringify(value);
 }
@@ -59,16 +210,14 @@ function buildConfig(service) {
   }
   return null;
 }
-function deployConfig(service, region) {
+function deployConfig(service) {
   const runtimeMode = String(service.runtimeMode ?? "").trim();
   const deploy = {
     ...service.startCommand ? { startCommand: service.startCommand } : {},
     ...service.healthcheckPath ? { healthcheckPath: service.healthcheckPath } : {},
     ...service.healthcheckTimeoutSeconds ? { healthcheckTimeout: service.healthcheckTimeoutSeconds } : {},
-    ...runtimeMode === "serverless" ? { sleepApplication: true } : {},
-    ...runtimeMode === "service" || runtimeMode === "replicated" ? { sleepApplication: false } : {},
-    ...service.volumeMountPath ? { requiredMountPath: service.volumeMountPath } : {},
-    region
+    ...typeof service.numReplicas === "number" ? { numReplicas: service.numReplicas } : {},
+    ...runtimeMode === "serverless" ? { sleepApplication: true } : {}
   };
   return Object.keys(deploy).length > 0 ? deploy : null;
 }
@@ -105,10 +254,96 @@ function normalizeIacScope(input) {
   const environmentName = String(input.environmentName ?? "").trim().toLowerCase();
   return environmentName === "production" || environmentName === "prod" ? "prod" : environmentName === "staging" ? "staging" : "local";
 }
+function activeObservedVolumeInstances(volume) {
+  return volume.instances.filter((instance) => {
+    const state = String(instance.state ?? "READY").toUpperCase();
+    return instance.isPendingDeletion !== true && !(typeof instance.deletedAt === "string" && instance.deletedAt.trim()) && state !== "DELETING" && state !== "DELETED";
+  });
+}
+function findRailwayPendingVolumeNameCollisions(input) {
+  const serviceIdByName = new Map((input.liveServices ?? []).map((service) => [service.name, service.id]));
+  return input.services.flatMap((service) => {
+    if (!service.volumeMountPath) return [];
+    const canonicalVolumeName = `${service.serviceName}-volume`;
+    const desiredServiceId = serviceIdByName.get(service.serviceName) ?? null;
+    return input.volumes.filter((volume) => volume.name === canonicalVolumeName || String(volume.name ?? "").startsWith("pending-delete-") && Boolean(desiredServiceId) && volume.instances.some((instance) => instance.serviceId === desiredServiceId)).filter((volume) => volume.instances.length > 0 && activeObservedVolumeInstances(volume).length === 0).map((volume) => ({
+      serviceName: service.serviceName,
+      volumeId: volume.id,
+      canonicalVolumeName,
+      mountPath: service.volumeMountPath,
+      serviceId: volume.instances.find((instance) => instance.serviceId)?.serviceId ?? null
+    }));
+  });
+}
+function resolveRailwayIacVolumeBindings(input) {
+  const bindings = [];
+  const blockedReasons = [];
+  const serviceIdByName = new Map(input.liveServices.map((service) => [service.name, service.id]));
+  for (const service of input.services.filter((candidate) => Boolean(candidate.volumeMountPath))) {
+    const canonicalVolumeName = `${service.serviceName}-volume`;
+    const desiredServiceId = serviceIdByName.get(service.serviceName) ?? null;
+    const canonical = input.volumes.flatMap(
+      (volume) => activeObservedVolumeInstances(volume).filter((instance) => instance.environmentId === input.environmentId && volume.name === canonicalVolumeName).map((instance) => ({ volume, instance }))
+    );
+    const candidatesByVolume = new Map(canonical.map((candidate) => [candidate.volume.id, candidate]));
+    if (candidatesByVolume.size > 1) {
+      blockedReasons.push(`${service.serviceName}: ${candidatesByVolume.size} active volumes are viable in environment ${input.environmentId}; refusing ambiguous stateful volume ownership.`);
+      continue;
+    }
+    const selected = candidatesByVolume.values().next().value;
+    if (!selected?.volume.id || !selected.volume.name) {
+      const pendingCanonicalCollision = input.volumes.some(
+        (volume) => (volume.name === canonicalVolumeName || String(volume.name ?? "").startsWith("pending-delete-") && Boolean(desiredServiceId) && volume.instances.some((instance) => instance.serviceId === desiredServiceId)) && volume.instances.length > 0 && activeObservedVolumeInstances(volume).length === 0
+      );
+      if (pendingCanonicalCollision) continue;
+      continue;
+    }
+    bindings.push({
+      serviceName: service.serviceName,
+      volumeId: selected.volume.id,
+      volumeName: selected.volume.name,
+      canonicalVolumeName,
+      mode: "canonical",
+      reason: selected.instance.serviceId === desiredServiceId ? "existing desired-service attachment" : "active canonical volume"
+    });
+  }
+  return { bindings, blockedReasons };
+}
+function detachRetainedRailwayVolumeBindings(resources, bindings) {
+  const movedVolumeNames = new Set(bindings.map((binding) => binding.volumeName));
+  return resources.map((resource) => {
+    if (resource.type !== "service" && resource.type !== "database") return resource;
+    const attachments = Object.fromEntries(Object.entries(resource.volumeAttachments ?? {}).filter(([, attachment]) => !movedVolumeNames.has(String(attachment.volume).replace(/^volume\./u, ""))));
+    const volumeMounts = Object.fromEntries(Object.entries(resource.volumeMounts ?? {}).filter(([volumeId]) => !bindings.some((binding) => binding.volumeId === volumeId)));
+    let deploy = resource.deploy;
+    if (deploy && Object.keys(attachments).length === 0 && Object.keys(volumeMounts).length === 0) {
+      const { requiredMountPath: _requiredMountPath, ...deployWithoutMountRequirement } = deploy;
+      deploy = Object.keys(deployWithoutMountRequirement).length > 0 ? deployWithoutMountRequirement : void 0;
+    }
+    const { volumeAttachments: _attachments, volumeMounts: _volumeMounts, ...retained } = resource;
+    return {
+      ...retained,
+      ...Object.keys(attachments).length > 0 ? { volumeAttachments: attachments } : {},
+      ...Object.keys(volumeMounts).length > 0 ? { volumeMounts } : {},
+      ...deploy ? { deploy } : {}
+    };
+  });
+}
+function detachRetainedRailwayCustomDomains(resources, domains) {
+  const selected = new Set(domains);
+  return resources.map((resource) => {
+    if (resource.type !== "service" || selected.size === 0) return resource;
+    const customDomains = Object.fromEntries(Object.entries(resource.networking?.customDomains ?? {}).filter(([domain]) => !selected.has(domain)));
+    if (Object.keys(customDomains).length === Object.keys(resource.networking?.customDomains ?? {}).length) return resource;
+    const networking = { ...resource.networking ?? {}, customDomains };
+    return { ...resource, networking };
+  });
+}
 function renderRailwayIacProject(input) {
   const scope = normalizeIacScope(input);
   const region = input.region?.trim() || "us-east4-eqdc4a";
   const tempParent = resolve(input.tenantRoot, ".treeseed", "tmp");
+  cleanupStaleRailwayIacRenders(input.tenantRoot);
   mkdirSync(tempParent, { recursive: true });
   const tempDir = mkdtempSync(resolve(tempParent, "railway-iac-"));
   const filePath = resolve(tempDir, "railway.mjs");
@@ -175,23 +410,30 @@ function renderRailwayIacProject(input) {
       `env: ${renderServiceEnv(service, databaseVariableName, databaseEnvName)}`
     ];
     const build = buildConfig(service);
-    const deploy = deployConfig(service, region);
+    const deploy = deployConfig(service);
     if (build) entries.push(`build: ${js(build)}`);
     if (deploy) entries.push(`deploy: ${js(deploy)}`);
+    entries.push(`regions: ${js({ [region]: 1 })}`);
+    if ((service.customDomains?.length ?? 0) > 0) {
+      entries.push(`networking: ${js({
+        customDomains: Object.fromEntries(service.customDomains.map((domain) => [domain, {}]))
+      })}`);
+    }
     if (service.volumeMountPath) {
-      const volumeName = `${service.serviceName}-volume`;
+      const volumeName = service.volumeName?.trim() || `${service.serviceName}-volume`;
+      const volumeAddress = service.volumeAddress?.trim() || null;
       const volumeVar = id("vol", index);
       const volumeMounts = [
         ...(service.detachVolumeIds ?? []).map((volumeId) => `${js(volumeId)}: null`),
         `${js(service.volumeMountPath)}: ${volumeVar}`
       ];
       volumeNames.push(volumeName);
-      declarations.push(`  const ${volumeVar} = volume(${js(volumeName)}, ${js({
+      declarations.push(`  const ${volumeVar} = ${volumeAddress ? "Object.assign(" : ""}volume(${js(volumeName)}, ${js({
         region,
         sizeMB: 5e4,
         allowOnlineResize: true,
         alerts: { usage: { 80: {}, 95: {}, 100: {} } }
-      })});`);
+      })})${volumeAddress ? `, { address: ${js(volumeAddress)} })` : ""};`);
       entries.push(`volumeMounts: { ${volumeMounts.join(", ")} }`);
       resources.push(volumeVar);
     }
@@ -223,11 +465,16 @@ ${declarations.join("\n")}
 }
 function selectRailwayIacRetainedResources(plan, allowedNames) {
   const allowed = new Set(allowedNames);
-  const deletedAllowedNames = new Set((plan.changeSet?.changes ?? []).filter((change) => change.kind === "resource.delete").map((change) => changeName(change)).filter((name) => allowed.has(name)));
-  return (plan.currentGraph?.resources ?? []).filter((resource) => deletedAllowedNames.has(resource.name));
+  return (plan.currentGraph?.resources ?? []).filter((resource) => allowed.has(resource.name));
 }
 function changeName(change) {
-  return String(change?.resource?.name ?? change?.previous?.name ?? change?.address ?? change?.path ?? "");
+  const directName = String(change?.resource?.name ?? change?.previous?.name ?? "").trim();
+  if (directName) return directName;
+  const location = String(change?.address ?? change?.path ?? "").trim();
+  const pathMatch = /(?:^|\.)?(?:resources\.)?(?:service|database|volume)\.([^\.\s]+)/u.exec(location);
+  if (pathMatch?.[1]) return pathMatch[1];
+  const summaryMatch = /\b(?:service|database|volume)\s+([^\s]+)/iu.exec(String(change?.summary ?? ""));
+  return summaryMatch?.[1] ?? location;
 }
 function changeFieldText(change) {
   return [
@@ -255,10 +502,12 @@ function validateRailwayIacChangeSet(changeSet, desiredNames) {
   const blockedReasons = [];
   const destructiveChanges = [];
   const desired = /* @__PURE__ */ new Set([...desiredNames.services, ...desiredNames.volumes, ...desiredNames.database ? [desiredNames.database] : []]);
+  const allowedResourceDeletions = new Set(desiredNames.allowedResourceDeletions ?? []);
+  const protectedResourceNames = new Set(desiredNames.protectedResourceNames ?? []);
   const created = new Set((changeSet?.changes ?? []).filter((change) => change.kind === "resource.create").map((change) => changeName(change)));
   for (const change of changeSet?.changes ?? []) {
     const name = changeName(change);
-    const serviceName = name.replace(/^(service|database)\./u, "");
+    const serviceName = name.replace(/^(service|database|volume)\./u, "");
     const sourceMode = desiredNames.serviceSourceModes?.[name] ?? desiredNames.serviceSourceModes?.[serviceName] ?? null;
     const sourceRef = desiredNames.serviceSourceRefs?.[name] ?? desiredNames.serviceSourceRefs?.[serviceName] ?? null;
     const sourceChanged = change.kind === "resource.update" && isRailwaySourceChange(change);
@@ -267,9 +516,14 @@ function validateRailwayIacChangeSet(changeSet, desiredNames) {
     const desiredGitSource = sourceMode === "git" && typeof sourceRef === "string" && sourceRef.startsWith("github:");
     const desiredImageSource = sourceMode === "image" && typeof sourceRef === "string" && sourceRef.startsWith("image:");
     const apiPolicyService = isApiRailwaySourcePolicyService({ serviceName });
+    if (protectedResourceNames.has(name) && (change.kind === "resource.update" || change.kind === "resource.delete")) {
+      blockedReasons.push(`Railway IaC plan would ${change.kind === "resource.delete" ? "delete" : "update"} sibling-environment resource ${name}.`);
+    }
     if (change.kind === "resource.delete") {
       destructiveChanges.push(change.summary);
-      blockedReasons.push(`Railway IaC plan would delete resource ${name || change.summary}; hosting reconciliation only updates or creates resources. Use the explicit destroy workflow for deletions.`);
+      if (!allowedResourceDeletions.has(name) && !allowedResourceDeletions.has(serviceName)) {
+        blockedReasons.push(`Railway IaC plan would delete resource ${name || change.summary}; hosting reconciliation only deletes explicitly recognized obsolete aliases. Use the explicit destroy workflow for other deletions.`);
+      }
       if (desired.has(name) && !created.has(name)) {
         blockedReasons.push(`Railway IaC plan would delete desired resource ${name}.`);
       }
@@ -301,7 +555,7 @@ function validateRailwayIacChangeSet(changeSet, desiredNames) {
   };
 }
 async function planRailwayIacProject(input, rendered = renderRailwayIacProject(input)) {
-  return runRailwayIac({
+  return runRailwayIacWithRateLimitRetry(() => runRailwayIac({
     command: "plan",
     cwd: rendered.tempDir,
     file: rendered.filePath,
@@ -314,10 +568,15 @@ async function planRailwayIacProject(input, rendered = renderRailwayIacProject(i
       decryptVariables: false,
       merge: true
     }
+  }), {
+    onRetry: (attempt, delayMs, error) => process.stderr.write(`[trsd][railway][iac:retry] command=plan attempt=${attempt} waitMs=${delayMs} reason=${error instanceof Error ? error.message : String(error)}
+`),
+    onWait: (attempt, remainingMs) => process.stderr.write(`[trsd][railway][iac:retry] command=plan attempt=${attempt} cooldownRemainingMs=${remainingMs}
+`)
   });
 }
 async function applyRailwayIacProject(input, rendered = renderRailwayIacProject(input)) {
-  return runRailwayIac({
+  return runRailwayIacWithRateLimitRetry(() => runRailwayIac({
     command: "apply",
     cwd: rendered.tempDir,
     file: rendered.filePath,
@@ -330,6 +589,11 @@ async function applyRailwayIacProject(input, rendered = renderRailwayIacProject(
       decryptVariables: false,
       merge: true
     }
+  }), {
+    onRetry: (attempt, delayMs, error) => process.stderr.write(`[trsd][railway][iac:retry] command=apply attempt=${attempt} waitMs=${delayMs} reason=${error instanceof Error ? error.message : String(error)}
+`),
+    onWait: (attempt, remainingMs) => process.stderr.write(`[trsd][railway][iac:retry] command=apply attempt=${attempt} cooldownRemainingMs=${remainingMs}
+`)
   });
 }
 function cleanupRailwayIacRender(rendered) {
@@ -338,8 +602,20 @@ function cleanupRailwayIacRender(rendered) {
 export {
   applyRailwayIacProject,
   cleanupRailwayIacRender,
+  cleanupStaleRailwayIacRenders,
+  detachRetainedRailwayCustomDomains,
+  detachRetainedRailwayVolumeBindings,
+  findRailwayPendingVolumeNameCollisions,
   planRailwayIacProject,
+  railwayIacApplyFailure,
   renderRailwayIacProject,
+  resolveRailwayIacVolumeBindings,
+  runRailwayIacWithRateLimitRetry,
   selectRailwayIacRetainedResources,
-  validateRailwayIacChangeSet
+  validateRailwayIacChangeSet,
+  waitForRailwayServiceAbsence,
+  waitForRailwayServices,
+  waitForRailwayVolumeAdoptionResources,
+  waitForRailwayVolumeDetachment,
+  waitForRailwayVolumeName
 };

package/dist/scenes/runner.js

@@ -243,10 +243,10 @@ async function runTreeseedScene(input) {
   const recordingVideo = Boolean(videoDir);
   const capture = resolveCapture({ scene, device, runtimeMode: runtime.mode, recording: Boolean(videoDir) });
   const artifacts = createTreeseedSceneRunArtifacts({ paths, playwrightTracePath: tracePath });
-  writeFileSync(artifacts.consoleLogPath ?? join(paths.playwrightRoot, "console.jsonl"), "", "utf8");
-  writeFileSync(artifacts.networkLogPath ?? join(paths.playwrightRoot, "network.jsonl"), "", "utf8");
-  writeFileSync(artifacts.errorsLogPath ?? join(paths.playwrightRoot, "errors.jsonl"), "", "utf8");
-  if (artifacts.progressPath) writeFileSync(artifacts.progressPath, "", "utf8");
+  writeFileSync(artifacts.consoleLogPath, "", "utf8");
+  writeFileSync(artifacts.networkLogPath, "", "utf8");
+  writeFileSync(artifacts.errorsLogPath, "", "utf8");
+  writeFileSync(artifacts.progressPath, "", "utf8");
   const timeline = createTreeseedSceneTimeline({ sceneId: scene.id, runId: paths.runId, startedAtMs: startedAt.getTime() });
   const progress = createTreeseedSceneProgress({ sceneId: scene.id, runId: paths.runId, startedAtMs: startedAt.getTime(), progressPath: artifacts.progressPath, onProgress: input.onProgress });
   progress.push("scene.run.started", { title: scene.title, environment: plan.environment });
@@ -368,15 +368,15 @@ async function runTreeseedScene(input) {
       if (message.type() !== "error") return;
       const entry = { message: message.text(), timestamp: now().toISOString(), ...currentStepId ? { stepId: currentStepId } : {} };
       consoleErrors.push(entry);
-      if (artifacts.consoleLogPath) appendTreeseedSceneJsonl(artifacts.consoleLogPath, entry);
-      if (artifacts.errorsLogPath) appendTreeseedSceneJsonl(artifacts.errorsLogPath, { kind: "console", ...entry });
+      appendTreeseedSceneJsonl(artifacts.consoleLogPath, entry);
+      appendTreeseedSceneJsonl(artifacts.errorsLogPath, { kind: "console", ...entry });
       timeline.push("console", entry, currentStepId);
     });
     session.page.on("requestfailed", (request) => {
       const entry = { message: request.failure()?.errorText ?? "request failed", timestamp: now().toISOString(), url: request.url(), method: request.method(), ...currentStepId ? { stepId: currentStepId } : {} };
       networkErrors.push(entry);
-      if (artifacts.networkLogPath) appendTreeseedSceneJsonl(artifacts.networkLogPath, entry);
-      if (artifacts.errorsLogPath) appendTreeseedSceneJsonl(artifacts.errorsLogPath, { kind: "network", ...entry });
+      appendTreeseedSceneJsonl(artifacts.networkLogPath, entry);
+      appendTreeseedSceneJsonl(artifacts.errorsLogPath, { kind: "network", ...entry });
       timeline.push("network", entry, currentStepId);
     });
     session.page.on("response", (response) => {
@@ -391,8 +391,8 @@ async function runTreeseedScene(input) {
       if (status < 400) return;
       const entry = { message: `HTTP ${status}`, timestamp: now().toISOString(), url: response.url(), method: response.request().method(), status, ...currentStepId ? { stepId: currentStepId } : {} };
       networkErrors.push(entry);
-      if (artifacts.networkLogPath) appendTreeseedSceneJsonl(artifacts.networkLogPath, entry);
-      if (artifacts.errorsLogPath) appendTreeseedSceneJsonl(artifacts.errorsLogPath, { kind: "network", ...entry });
+      appendTreeseedSceneJsonl(artifacts.networkLogPath, entry);
+      appendTreeseedSceneJsonl(artifacts.errorsLogPath, { kind: "network", ...entry });
       timeline.push("network", entry, currentStepId);
     });
     if (tracePath) await session.startTracing?.();
@@ -673,7 +673,7 @@ async function runTreeseedScene(input) {
     segments,
     checkpoints,
     resumedFrom: null,
-    progressPath: artifacts.progressPath ?? null,
+    progressPath: artifacts.progressPath,
     warnings: splitDiagnostics(diagnostics, "warning"),
     blockers: splitDiagnostics(diagnostics, "error"),
     diagnostics

package/dist/scripts/build-dist.js

@@ -36,6 +36,27 @@ function lockOwnerIsRunning() {
         return code === 'EPERM';
     }
 }
+function processIsRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        const code = typeof error === 'object' && error && 'code' in error ? error.code : null;
+        return code === 'EPERM';
+    }
+}
+function removeStaleBuildRoots() {
+    for (const entry of readdirSync(packageRoot, { withFileTypes: true })) {
+        const match = entry.isDirectory() ? /^\.treeseed-dist-build-(\d+)$/u.exec(entry.name) : null;
+        if (!match?.[1])
+            continue;
+        const pid = Number.parseInt(match[1], 10);
+        if (pid === process.pid || processIsRunning(pid))
+            continue;
+        rmSync(resolve(packageRoot, entry.name), { recursive: true, force: true });
+    }
+}
 async function acquireBuildLock() {
     const startedAt = Date.now();
     while (true) {
@@ -45,6 +66,7 @@ async function acquireBuildLock() {
                 pid: process.pid,
                 startedAt: new Date().toISOString(),
             }, null, 2));
+            removeStaleBuildRoots();
             return () => rmSync(buildLockRoot, { recursive: true, force: true });
         }
         catch (error) {

package/dist/workflow/operations.d.ts

@@ -1085,6 +1085,10 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
             status: string;
             reason: string;
             attempts?: undefined;
+        } | {
+            status: string;
+            reason: string;
+            attempts: number;
         } | {
             status: string;
             reason: null;
@@ -1144,6 +1148,14 @@ export declare function workflowRelease(helpers: WorkflowOperationHelpers, input
             cached: boolean;
         }[];
     };
+    apiEnvironmentIsolation: {
+        status: string;
+        order: string[];
+        reports: Record<string, import("../workflow-support.js").TreeseedLiveHostedServiceCheckReport>;
+    } | {
+        status: string;
+        reason: string;
+    };
     productionImageRefs: {
         persisted: Record<string, string>;
         readiness: import("../workflow-support.js").TreeseedDeploymentReadinessReport;