@treeseed/sdk 0.10.28 → 0.11.0

package/dist/operations/services/package-adapters.js

@@ -0,0 +1,288 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { relative, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { workspacePackages, workspaceRoot } from "./workspace-tools.js";
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readStructuredFile(filePath) {
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    return filePath.endsWith(".yaml") || filePath.endsWith(".yml") ? parseYaml(raw) : JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function readPackageJsonVersion(filePath) {
+  const packageJson = readJsonFile(filePath);
+  return typeof packageJson?.version === "string" ? packageJson.version : null;
+}
+function normalizeGitHubRepositorySlug(value) {
+  const raw = typeof value === "string" ? value : value && typeof value === "object" && !Array.isArray(value) ? value.url : null;
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  const normalized = raw.trim().replace(/^git\+/u, "").replace(/^ssh:\/\/git@github\.com[:/]/u, "").replace(/^git@github\.com:/u, "").replace(/^https:\/\/github\.com\//u, "").replace(/\.git$/u, "").replace(/\/$/u, "");
+  return /^[^/\s]+\/[^/\s]+$/u.test(normalized) ? normalized : null;
+}
+function readMixProjectVersion(filePath) {
+  if (!existsSync(filePath)) return null;
+  const source = readFileSync(filePath, "utf8");
+  const match = source.match(/\bversion:\s*"([^"]+)"/u);
+  return match?.[1] ?? null;
+}
+function commandFromScript(dir, script, label) {
+  if (typeof script !== "string" || !script.trim()) return null;
+  const trimmed = script.trim();
+  if (trimmed.startsWith("scripts/")) {
+    return { label, command: "bash", args: [trimmed], cwd: dir };
+  }
+  return { label, command: "bash", args: ["-lc", trimmed], cwd: dir };
+}
+function nodeTypeScriptAdapter(pkg) {
+  const manifest = readTreeseedPackageManifest(pkg.dir);
+  const scripts = pkg.packageJson?.scripts && typeof pkg.packageJson.scripts === "object" && !Array.isArray(pkg.packageJson.scripts) ? pkg.packageJson.scripts : {};
+  const manifestVerify = manifest?.verify && typeof manifest.verify === "object" && !Array.isArray(manifest.verify) ? manifest.verify : {};
+  const repository = stringValue(manifest?.repository) ?? normalizeGitHubRepositorySlug(pkg.packageJson?.repository);
+  const id = stringValue(manifest?.id) ?? String(pkg.name);
+  const name = stringValue(manifest?.name) ?? String(pkg.name);
+  const publishTarget = stringValue(manifest?.publishTarget) ?? "npm";
+  const hostedVerifyWorkflow = stringValue(stringRecord(manifest?.releaseGate).workflow) ?? (existsSync(resolve(pkg.dir, ".github/workflows/deploy.yml")) ? "deploy.yml" : null);
+  const verifyLocal = typeof scripts["verify:local"] === "string" ? "verify:local" : typeof scripts.verify === "string" ? "verify" : typeof scripts["verify:action"] === "string" ? "verify:action" : null;
+  return {
+    id,
+    name,
+    kind: "node-typescript",
+    dir: pkg.dir,
+    relativeDir: pkg.relativeDir,
+    version: typeof pkg.packageJson?.version === "string" ? pkg.packageJson.version : null,
+    publishTarget,
+    manifestPath: treeseedPackageManifestPath(pkg.dir) ?? resolve(pkg.dir, "package.json"),
+    versionSource: resolve(pkg.dir, "package.json"),
+    verifyCommands: {
+      fast: commandFromScript(pkg.dir, manifestVerify.fast, "fast") ?? (typeof scripts.verify === "string" ? { label: "verify", command: "npm", args: ["run", "verify"], cwd: pkg.dir } : null),
+      local: commandFromScript(pkg.dir, manifestVerify.local, "local") ?? (verifyLocal ? { label: verifyLocal, command: "npm", args: ["run", verifyLocal], cwd: pkg.dir } : null),
+      release: commandFromScript(pkg.dir, manifestVerify.release, "release") ?? (typeof scripts["release:publish"] === "string" ? { label: "release:publish", command: "npm", args: ["run", "release:publish"], cwd: pkg.dir } : null)
+    },
+    artifacts: [{ provider: "npm", name: String(pkg.name) }],
+    releaseChecks: [
+      { kind: "github-workflow", name: "publish workflow", detail: ".github/workflows/publish.yml" },
+      { kind: "npm-pack-dry-run", name: "npm pack", detail: "npm pack --dry-run" }
+    ],
+    metadata: {
+      ...repository ? { repository } : {},
+      ...hostedVerifyWorkflow ? {
+        hostedVerifyWorkflow: hostedVerifyWorkflow.startsWith(".github/workflows/") ? hostedVerifyWorkflow : `.github/workflows/${hostedVerifyWorkflow}`
+      } : {},
+      scripts
+    }
+  };
+}
+function treeseedPackageManifestPath(dir) {
+  for (const fileName of ["treeseed.package.yaml", "treeseed.package.yml", "treeseed.package.json", ".treeseed-package.json"]) {
+    const filePath = resolve(dir, fileName);
+    if (existsSync(filePath)) return filePath;
+  }
+  return null;
+}
+function readTreeseedPackageManifest(dir) {
+  const filePath = treeseedPackageManifestPath(dir);
+  return filePath ? readStructuredFile(filePath) : null;
+}
+function stringRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.map((entry) => stringValue(entry)).filter((entry) => Boolean(entry)) : [];
+}
+function beamPackageAdapter(root, dir) {
+  const manifest = readTreeseedPackageManifest(dir);
+  const hasMixProject = existsSync(resolve(dir, "apps/api/mix.exs")) || existsSync(resolve(dir, "mix.exs"));
+  if (!manifest && !hasMixProject) return null;
+  const kind = typeof manifest?.kind === "string" ? manifest.kind : "beam-elixir-rust";
+  if (kind !== "beam-elixir-rust") return null;
+  const id = typeof manifest?.id === "string" && manifest.id.trim() ? manifest.id.trim() : relative(resolve(root, "packages"), dir).replaceAll("\\", "/");
+  const name = typeof manifest?.name === "string" && manifest.name.trim() ? manifest.name.trim() : id;
+  const versionSourceRel = typeof manifest?.versionSource === "string" && manifest.versionSource.trim() ? manifest.versionSource.trim() : existsSync(resolve(dir, "apps/api/mix.exs")) ? "apps/api/mix.exs" : "mix.exs";
+  const versionSource = resolve(dir, versionSourceRel);
+  const image = typeof manifest?.image === "string" && manifest.image.trim() ? manifest.image.trim() : id === "treedx" ? "treeseed/treedx" : null;
+  const repository = stringValue(manifest?.repository) ?? (id === "treedx" ? "treeseed-ai/treedx" : null);
+  const developmentImages = stringRecord(manifest?.developmentImages);
+  const developmentImageHosting = stringRecord(developmentImages.hosting);
+  const developmentImageWorkflow = image ? stringValue(developmentImages.workflow) ?? (id === "treedx" ? "dev-image.yml" : null) : null;
+  const hostedVerifyWorkflow = stringValue(stringRecord(manifest?.releaseGate).workflow) ?? (existsSync(resolve(dir, ".github/workflows/release-gate.yml")) ? "release-gate.yml" : null);
+  const developmentImageDefaultBranch = stringValue(developmentImages.defaultBranch) ?? "staging";
+  const developmentImageTagPrefix = stringValue(developmentImages.tagPrefix) ?? "dev";
+  const developmentImageMovingTag = developmentImages.movingTag === false ? false : true;
+  const developmentImageArchitectures = stringArray(developmentImages.architectures);
+  const verify = manifest?.verify && typeof manifest.verify === "object" && !Array.isArray(manifest.verify) ? manifest.verify : {};
+  const fast = verify.fast ?? (existsSync(resolve(dir, "scripts/test-treedx-fast.sh")) ? "scripts/test-treedx-fast.sh" : null);
+  const local = verify.local ?? (existsSync(resolve(dir, "scripts/test-all.sh")) ? "scripts/test-all.sh" : null);
+  const releaseGate = manifest?.releaseGate ?? verify.release ?? (existsSync(resolve(dir, "scripts/release-gate.sh")) ? "scripts/release-gate.sh" : null);
+  const version = readMixProjectVersion(versionSource);
+  const shaTag = "sha-<short-sha>";
+  return {
+    id,
+    name,
+    kind: "beam-elixir-rust",
+    dir,
+    relativeDir: relative(root, dir).replaceAll("\\", "/"),
+    version,
+    publishTarget: image,
+    manifestPath: treeseedPackageManifestPath(dir),
+    versionSource,
+    verifyCommands: {
+      fast: commandFromScript(dir, fast, "fast"),
+      local: commandFromScript(dir, local, "local"),
+      release: commandFromScript(dir, releaseGate, "release")
+    },
+    artifacts: image ? [{ provider: "docker", name: image, tags: version ? [version, shaTag] : [shaTag] }] : [],
+    releaseChecks: image ? [{ kind: "docker-manifest", name: "Docker image manifest", detail: `${image}:${version ?? "<version>"}` }] : [],
+    metadata: {
+      hasCargo: existsSync(resolve(dir, "Cargo.toml")),
+      hasDockerfile: existsSync(resolve(dir, "Dockerfile")),
+      repository,
+      versionSource: versionSourceRel,
+      ...developmentImageWorkflow ? {
+        developmentImageWorkflow: developmentImageWorkflow.startsWith(".github/workflows/") ? developmentImageWorkflow : `.github/workflows/${developmentImageWorkflow}`,
+        developmentImageDefaultBranch,
+        developmentImageTagPrefix,
+        developmentImageMovingTag,
+        developmentImageArchitectures,
+        developmentImageTagPattern: `${image}:${developmentImageTagPrefix}-<branch-slug>-<short-sha>`,
+        developmentImageMovingTagPattern: developmentImageMovingTag ? `${image}:${developmentImageTagPrefix}-<branch-slug>` : null,
+        developmentImageHosting: Object.keys(developmentImageHosting).length > 0 ? developmentImageHosting : null
+      } : {},
+      ...hostedVerifyWorkflow ? {
+        hostedVerifyWorkflow: hostedVerifyWorkflow.startsWith(".github/workflows/") ? hostedVerifyWorkflow : `.github/workflows/${hostedVerifyWorkflow}`
+      } : {}
+    }
+  };
+}
+function gitOutput(cwd, args) {
+  const result = spawnSync("git", args, { cwd, encoding: "utf8", stdio: "pipe" });
+  if (result.status !== 0) {
+    const stderr = typeof result.stderr === "string" ? result.stderr.trim() : "";
+    throw new Error(stderr || `git ${args.join(" ")} failed in ${cwd}.`);
+  }
+  return result.stdout.trim();
+}
+function branchSlug(value) {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 40);
+  return normalized || "branch";
+}
+function planTreeseedPackageDevelopmentImage(root = workspaceRoot(), idOrName, { branch } = {}) {
+  const adapter = findTreeseedPackageAdapter(root, idOrName);
+  if (!adapter) {
+    throw new Error(`Treeseed package adapter ${idOrName} was not discovered.`);
+  }
+  const imageName = typeof adapter.publishTarget === "string" && adapter.publishTarget.trim() ? adapter.publishTarget.trim() : null;
+  if (!imageName) {
+    throw new Error(`${adapter.id} does not declare a publish image target.`);
+  }
+  const metadata = adapter.metadata;
+  const workflow = stringValue(metadata.developmentImageWorkflow)?.replace(/^\.github\/workflows\//u, "") ?? null;
+  if (!workflow) {
+    throw new Error(`${adapter.id} does not declare a development image workflow.`);
+  }
+  const selectedBranch = branch ?? stringValue(metadata.developmentImageDefaultBranch) ?? "staging";
+  const sha = gitOutput(adapter.dir, ["rev-parse", selectedBranch]);
+  const slug = branchSlug(selectedBranch);
+  const shortSha = sha.slice(0, 12);
+  const tagPrefix = stringValue(metadata.developmentImageTagPrefix) ?? "dev";
+  const immutableTag = `${tagPrefix}-${slug}-${shortSha}`;
+  const movingTag = metadata.developmentImageMovingTag === false ? null : `${tagPrefix}-${slug}`;
+  const architectures = stringArray(metadata.developmentImageArchitectures);
+  const hosting = stringRecord(metadata.developmentImageHosting);
+  const app = stringValue(hosting.app);
+  const environment = stringValue(hosting.environment) ?? selectedBranch;
+  const overrideEnvVar = stringValue(hosting.envVar);
+  const imageRef = `${imageName}:${immutableTag}`;
+  const movingImageRef = movingTag ? `${imageName}:${movingTag}` : null;
+  const hostingImageRef = movingImageRef ?? imageRef;
+  return {
+    package: {
+      id: adapter.id,
+      name: adapter.name,
+      path: adapter.relativeDir,
+      kind: adapter.kind,
+      version: adapter.version,
+      publishTarget: adapter.publishTarget,
+      metadata: adapter.metadata
+    },
+    repository: stringValue(metadata.repository) ?? `${adapter.id}`,
+    workflow,
+    branch: selectedBranch,
+    refs: {
+      imageName,
+      branch: selectedBranch,
+      branchSlug: slug,
+      sha,
+      shortSha,
+      immutableTag,
+      movingTag,
+      imageRef,
+      movingImageRef,
+      archImageRefs: architectures.map((arch) => `${imageName}:${immutableTag}-${arch}`)
+    },
+    hosting: app && overrideEnvVar ? {
+      app,
+      environment,
+      overrideEnvVar,
+      override: { [overrideEnvVar]: hostingImageRef },
+      command: `${overrideEnvVar}=${hostingImageRef} npx trsd hosting apply --environment ${environment} --app ${app} --execute --json`
+    } : null
+  };
+}
+function discoverTreeseedPackageAdapters(root = workspaceRoot()) {
+  const adapters = /* @__PURE__ */ new Map();
+  for (const pkg of workspacePackages(root)) {
+    if (typeof pkg.name === "string" && pkg.name.startsWith("@treeseed/")) {
+      adapters.set(pkg.name, nodeTypeScriptAdapter(pkg));
+    }
+  }
+  const packagesDir = resolve(root, "packages");
+  const packageDirs = existsSync(packagesDir) ? readdirSync(packagesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => resolve(packagesDir, entry.name)) : [];
+  for (const dir of packageDirs) {
+    if (!existsSync(dir)) continue;
+    const adapter = beamPackageAdapter(root, dir);
+    if (adapter) adapters.set(adapter.id, adapter);
+  }
+  return [...adapters.values()].sort((left, right) => {
+    if (left.kind !== right.kind) return left.kind === "node-typescript" ? -1 : 1;
+    return left.id.localeCompare(right.id);
+  });
+}
+function findTreeseedPackageAdapter(root, idOrName) {
+  return discoverTreeseedPackageAdapters(root).find((adapter) => adapter.id === idOrName || adapter.name === idOrName) ?? null;
+}
+function packageAdapterPlanSummary(root = workspaceRoot()) {
+  return discoverTreeseedPackageAdapters(root).map((adapter) => ({
+    id: adapter.id,
+    name: adapter.name,
+    kind: adapter.kind,
+    path: adapter.relativeDir,
+    version: adapter.version,
+    publishTarget: adapter.publishTarget,
+    verify: Object.fromEntries(Object.entries(adapter.verifyCommands).map(([key, command]) => [
+      key,
+      command ? `${command.command} ${command.args.join(" ")}` : null
+    ])),
+    artifacts: adapter.artifacts,
+    releaseChecks: adapter.releaseChecks,
+    metadata: adapter.metadata
+  }));
+}
+export {
+  discoverTreeseedPackageAdapters,
+  findTreeseedPackageAdapter,
+  packageAdapterPlanSummary,
+  planTreeseedPackageDevelopmentImage,
+  readMixProjectVersion
+};

package/dist/operations/services/package-reference-policy.d.ts

@@ -52,6 +52,7 @@ export declare function createPackageDependencyReference(input: {
     gitDependencyProtocol?: GitDependencyProtocol;
 }): PackageDependencyReference;
 export declare function updateInternalDependencySpecs(packageJson: Record<string, unknown> | null, references: Map<string, PackageDependencyReference>): RewrittenDevReference[];
+export declare function installableInternalDependencyVersions(root: any, versions: Map<string, string>): Map<string, string>;
 export declare function rewriteInternalDependenciesToStableVersions(root: any, versions: Map<string, string>): (RewrittenDevReference & {
     repoName: string;
     packageJsonPath: string;

package/dist/operations/services/package-reference-policy.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { discoverTreeseedPackageAdapters } from "./package-adapters.js";
 import { run, workspacePackages, workspaceRoot } from "./workspace-tools.js";
 const INTERNAL_DEPENDENCY_FIELDS = ["dependencies", "optionalDependencies", "peerDependencies", "devDependencies"];
 function readJson(filePath) {
@@ -155,14 +156,24 @@ function updateInternalDependencySpecs(packageJson, references) {
   }
   return changed;
 }
+function installableInternalDependencyVersions(root = workspaceRoot(), versions) {
+  const publishTargets = /* @__PURE__ */ new Map();
+  for (const adapter of discoverTreeseedPackageAdapters(root)) {
+    const publishTarget = adapter.publishTarget ?? "npm";
+    publishTargets.set(adapter.id, publishTarget);
+    publishTargets.set(adapter.name, publishTarget);
+  }
+  return new Map([...versions.entries()].filter(([packageName]) => (publishTargets.get(packageName) ?? "npm") === "npm"));
+}
 function rewriteInternalDependenciesToStableVersions(root = workspaceRoot(), versions) {
   const rewrites = [];
+  const installableVersions = installableInternalDependencyVersions(root, versions);
   for (const pkg of workspacePackages(root)) {
     const packageJsonPath = resolve(pkg.dir, "package.json");
     const packageJson = readJson(packageJsonPath);
     const changed = updateInternalDependencySpecs(
       packageJson,
-      new Map([...versions.entries()].map(([packageName, version]) => [packageName, {
+      new Map([...installableVersions.entries()].map(([packageName, version]) => [packageName, {
         packageName,
         version,
         spec: version,
@@ -185,6 +196,7 @@ function rewriteInternalDependenciesToStableVersions(root = workspaceRoot(), ver
 }
 function rewriteProjectInternalDependenciesToStableVersions(root = workspaceRoot(), versions) {
   const rewrites = [];
+  const installableVersions = installableInternalDependencyVersions(root, versions);
   const targets = [
     { name: "@treeseed/market", dir: root },
     ...workspacePackages(root).map((pkg) => ({ name: pkg.name, dir: pkg.dir }))
@@ -195,7 +207,7 @@ function rewriteProjectInternalDependenciesToStableVersions(root = workspaceRoot
     const packageJson = readJson(packageJsonPath);
     const changed = updateInternalDependencySpecs(
       packageJson,
-      new Map([...versions.entries()].map(([packageName, version]) => [packageName, {
+      new Map([...installableVersions.entries()].map(([packageName, version]) => [packageName, {
         packageName,
         version,
         spec: version,
@@ -458,6 +470,7 @@ export {
   createPackageDependencyReference,
   devTagFromDependencySpec,
   gitTagMessage,
+  installableInternalDependencyVersions,
   internalDependencyFields,
   isGitDependencySpec,
   isPrereleaseVersion,

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

@@ -273,6 +273,13 @@ export declare function deployProjectPlatform(options: ProjectPlatformActionOpti
         cwd: any;
         publicBaseUrl: any;
         timings: TreeseedTimingEntry[];
+        transport: {
+            railway: {
+                reconcile: string;
+                deploy: string;
+            };
+        };
+        deploymentId?: undefined;
         runtimeConfiguration?: undefined;
     } | {
         service: any;
@@ -281,19 +288,41 @@ export declare function deployProjectPlatform(options: ProjectPlatformActionOpti
         cwd: any;
         publicBaseUrl: any;
         timings: TreeseedTimingEntry[];
+        deploymentId: any;
+        transport: {
+            railway: {
+                reconcile: string;
+                deploy: string;
+            };
+        };
+        runtimeConfiguration: {
+            updated: any;
+            healthcheckPath: any;
+            healthcheckTimeoutSeconds: any;
+            runtimeMode: any;
+            volume: any;
+        } | null;
+    } | {
+        service: any;
+        status: string;
+        command: string;
+        cwd: any;
+        publicBaseUrl: any;
+        timings: TreeseedTimingEntry[];
+        transport: {
+            railway: {
+                reconcile: string;
+                deploy: string;
+            };
+        };
         runtimeConfiguration: {
-            updated: boolean;
-            healthcheckPath: string | null;
-            healthcheckTimeoutSeconds: number | null;
-            runtimeMode: string | null;
-            volume: {
-                id: any;
-                name: any;
-                mountPath: any;
-                created: boolean;
-                updated: boolean;
-            } | null;
+            updated: any;
+            healthcheckPath: any;
+            healthcheckTimeoutSeconds: any;
+            runtimeMode: any;
+            volume: any;
         } | null;
+        deploymentId?: undefined;
     } | undefined)[];
     timings: TreeseedTimingEntry[];
 }>;
@@ -816,6 +845,13 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
         cwd: any;
         publicBaseUrl: any;
         timings: TreeseedTimingEntry[];
+        transport: {
+            railway: {
+                reconcile: string;
+                deploy: string;
+            };
+        };
+        deploymentId?: undefined;
         runtimeConfiguration?: undefined;
     } | {
         service: any;
@@ -824,19 +860,41 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
         cwd: any;
         publicBaseUrl: any;
         timings: TreeseedTimingEntry[];
+        deploymentId: any;
+        transport: {
+            railway: {
+                reconcile: string;
+                deploy: string;
+            };
+        };
+        runtimeConfiguration: {
+            updated: any;
+            healthcheckPath: any;
+            healthcheckTimeoutSeconds: any;
+            runtimeMode: any;
+            volume: any;
+        } | null;
+    } | {
+        service: any;
+        status: string;
+        command: string;
+        cwd: any;
+        publicBaseUrl: any;
+        timings: TreeseedTimingEntry[];
+        transport: {
+            railway: {
+                reconcile: string;
+                deploy: string;
+            };
+        };
         runtimeConfiguration: {
-            updated: boolean;
-            healthcheckPath: string | null;
-            healthcheckTimeoutSeconds: number | null;
-            runtimeMode: string | null;
-            volume: {
-                id: any;
-                name: any;
-                mountPath: any;
-                created: boolean;
-                updated: boolean;
-            } | null;
+            updated: any;
+            healthcheckPath: any;
+            healthcheckTimeoutSeconds: any;
+            runtimeMode: any;
+            volume: any;
         } | null;
+        deploymentId?: undefined;
     } | undefined)[];
     timings: TreeseedTimingEntry[];
 }>;

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

@@ -48,7 +48,7 @@ import { CloudflareQueuePullClient, CloudflareQueuePushClient } from "../../remo
 import { runPrefixedCommand, runTreeseedBootstrapDag, sleep, writeTreeseedBootstrapLine } from "./bootstrap-runner.js";
 import { runTenantDeployPreflight } from "./save-deploy-preflight.js";
 const PROJECT_PLATFORM_BOOTSTRAP_SYSTEMS = ["data", "web", "api", "agents"];
-const WEB_PLATFORM_BOOTSTRAP_SYSTEMS = PROJECT_PLATFORM_BOOTSTRAP_SYSTEMS;
+const WEB_PLATFORM_BOOTSTRAP_SYSTEMS = ["data", "web"];
 const PROCESSING_PLATFORM_BOOTSTRAP_SYSTEMS = ["api", "agents"];
 function stableHash(value) {
   return createHash("sha256").update(value).digest("hex");
@@ -63,6 +63,13 @@ function recordTiming(timings, name, startMs, status = "success", metadata) {
   timings.push(entry);
   return entry;
 }
+function writeWorkflowStatus(message) {
+  if (!process.env.TREESEED_WORKFLOW_ACTION && !process.env.TREESEED_WORKFLOW_DEBUG) {
+    return;
+  }
+  process.stderr.write(`[project-platform] ${message}
+`);
+}
 async function timedPhase(timings, name, run, metadata) {
   const startMs = performance.now();
   try {
@@ -658,10 +665,14 @@ function findFirstMatchingString(value, matcher, seen = /* @__PURE__ */ new Set(
   return null;
 }
 function resolveImmediatePagesProbeUrl(siteConfig, state, target) {
+  const configuredUrl = resolveConfiguredSurfaceBaseUrl(siteConfig, target, "web");
+  if (configuredUrl) {
+    return configuredUrl;
+  }
   if (target.kind === "persistent" && target.scope === "staging" && state.pages?.projectName) {
     return `https://${state.pages?.stagingBranch ?? "staging"}.${state.pages.projectName}.pages.dev`;
   }
-  return state.pages?.url ?? resolveConfiguredSurfaceBaseUrl(siteConfig, target, "web") ?? siteConfig.siteUrl;
+  return state.pages?.url ?? siteConfig.siteUrl;
 }
 function resolveImmediateApiProbeUrl(siteConfig, state, target) {
   const configuredUrl = resolveConfiguredSurfaceBaseUrl(siteConfig, target, "api") ?? siteConfig.services?.api?.environments?.[target.kind === "persistent" ? target.scope : "prod"]?.baseUrl ?? siteConfig.services?.api?.publicBaseUrl ?? process.env.TREESEED_API_BASE_URL ?? state.services?.api?.lastDeployedUrl ?? null;
@@ -801,8 +812,8 @@ function probeR2(tenantRoot, siteConfig, state, target) {
 function probeScaleConfiguration(siteConfig, state) {
   const worker = state.services?.workerRunner ?? state.services?.worker ?? {};
   const workerConfig = siteConfig.services?.workerRunner ?? siteConfig.services?.worker ?? {};
-  const marketRunner = state.services?.marketOperationsRunner ?? {};
-  const marketRunnerConfig = siteConfig.services?.marketOperationsRunner ?? {};
+  const marketRunner = state.services?.operationsRunner ?? {};
+  const marketRunnerConfig = siteConfig.services?.operationsRunner ?? {};
   const scalerKind = String(process.env.TREESEED_WORKER_POOL_SCALER ?? "").trim();
   if (marketRunnerConfig.provider === "railway" && workerConfig.provider !== "railway") {
     const runnerServiceId = marketRunner.serviceId ?? null;
@@ -1058,30 +1069,46 @@ async function publishContent(options, reporter, publishOptions = {}) {
   }
 }
 async function provisionProjectPlatform(options) {
+  writeWorkflowStatus(`provision:start scope=${options.scope}`);
   const timings = [];
+  writeWorkflowStatus("provision:resolve-reporter");
   const reporter = resolveReporter(options.tenantRoot, options.reporter);
+  writeWorkflowStatus(`provision:reporter kind=${reporter.kind} enabled=${reporter.enabled ? "true" : "false"}`);
   const target = createPersistentDeployTarget(options.scope === "local" ? "staging" : options.scope);
+  writeWorkflowStatus(`provision:target ${deployTargetLabel(target)}`);
   const siteConfig = loadCliDeployConfig(options.tenantRoot);
+  writeWorkflowStatus("provision:resolve-bootstrap-systems");
   const bootstrapSystems = resolveProjectPlatformBootstrapSystems(options, siteConfig);
   const selectedSystems = new Set(bootstrapSystems);
   const env = { ...process.env, ...options.env ?? {} };
+  writeWorkflowStatus(`provision:reconcile:start systems=${bootstrapSystems.join(",") || "(none)"}`);
   const summary = await timedPhase(timings, "provision:reconcile", () => reconcileTreeseedTarget({
     tenantRoot: options.tenantRoot,
     target,
     env,
     systems: bootstrapSystems,
-    write: options.write
+    write: options.write,
+    dryRun: options.dryRun
   }));
+  writeWorkflowStatus("provision:reconcile:done");
   timings.push(...summary.timings ?? []);
+  writeWorkflowStatus("provision:collect-reconcile-status:start");
   const verification = await timedPhase(timings, "provision:collect-reconcile-status", () => collectTreeseedReconcileStatus({
     tenantRoot: options.tenantRoot,
     target,
     env,
     systems: bootstrapSystems
   }));
-  await timedPhase(timings, "provision:ensure-wrangler-config", () => {
-    ensureGeneratedWranglerConfig(options.tenantRoot, { target });
-  });
+  writeWorkflowStatus("provision:collect-reconcile-status:done");
+  if (selectedSystems.has("data") || selectedSystems.has("web")) {
+    writeWorkflowStatus("provision:ensure-wrangler-config:start");
+    await timedPhase(timings, "provision:ensure-wrangler-config", () => {
+      ensureGeneratedWranglerConfig(options.tenantRoot, { target });
+    });
+    writeWorkflowStatus("provision:ensure-wrangler-config:done");
+  } else {
+    writeWorkflowStatus("provision:ensure-wrangler-config:skipped");
+  }
   const shouldValidateRailway = selectedSystems.has("api") || selectedSystems.has("agents");
   const railwayValidation = shouldValidateRailway ? options.scope === "local" ? validateRailwayServiceConfiguration(options.tenantRoot, options.scope) : validateRailwayDeployPrerequisites(options.tenantRoot, options.scope, { env }) : { services: [] };
   const railwaySchedules = [];
@@ -1239,16 +1266,22 @@ async function provisionProjectPlatform(options) {
   };
 }
 async function deployProjectPlatform(options) {
+  writeWorkflowStatus(`deploy:start scope=${options.scope} dryRun=${options.dryRun ? "true" : "false"}`);
   const timings = [];
   const deployStartMs = performance.now();
+  writeWorkflowStatus("deploy:resolve-reporter");
   const reporter = resolveReporter(options.tenantRoot, options.reporter);
+  writeWorkflowStatus(`deploy:reporter kind=${reporter.kind} enabled=${reporter.enabled ? "true" : "false"}`);
   const commitSha = currentCommit(options.tenantRoot);
   const branchName = currentRef(options.tenantRoot);
+  writeWorkflowStatus("deploy:resolve-bootstrap-systems");
   const bootstrapSystems = resolveProjectPlatformBootstrapSystems(options);
   const selectedSystems = new Set(bootstrapSystems);
   const execution = options.bootstrapExecution ?? "parallel";
   const write = options.write;
   const env = { ...process.env, ...options.env ?? {} };
+  writeWorkflowStatus(`deploy:bootstrap-systems ${bootstrapSystems.join(",") || "(none)"}`);
+  writeWorkflowStatus("deploy:report-running");
   await reportDeployment(reporter, {
     environment: options.scope,
     deploymentKind: "code",
@@ -1258,9 +1291,12 @@ async function deployProjectPlatform(options) {
     triggeredByType: "project_runner",
     metadata: { scope: options.scope }
   });
+  writeWorkflowStatus("deploy:reported-running");
   if (!options.skipProvision) {
+    writeWorkflowStatus("deploy:provision:start");
     const provision = await timedPhase(timings, "deploy:provision", () => provisionProjectPlatform({ ...options, reporter, bootstrapSystems }));
     timings.push(...provision.timings ?? []);
+    writeWorkflowStatus("deploy:provision:done");
   }
   const nodes = [];
   let cloudflareContext = null;
@@ -1565,8 +1601,13 @@ async function runProjectPlatformAction(action, options) {
   const previousWorkflowPlane = process.env.TREESEED_WORKFLOW_PLANE;
   process.env.TREESEED_WORKFLOW_ACTION = action;
   process.env.TREESEED_WORKFLOW_PLANE = previousWorkflowPlane ?? "all";
+  writeWorkflowStatus(`action:start ${action} scope=${options.scope}`);
+  writeWorkflowStatus("action:apply-environment:start");
   applyTreeseedEnvironmentToProcess({ tenantRoot: options.tenantRoot, scope: options.scope, override: true });
+  writeWorkflowStatus("action:apply-environment:done");
+  writeWorkflowStatus("action:resolve-reporter:start");
   const reporter = resolveReporter(options.tenantRoot, options.reporter);
+  writeWorkflowStatus(`action:resolve-reporter:done kind=${reporter.kind} enabled=${reporter.enabled ? "true" : "false"}`);
   try {
     switch (action) {
       case "deploy_web":