@treeseed/core 0.8.19 → 0.9.4

package/dist/dev.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
 import { dirname, isAbsolute, resolve, sep } from "node:path";
@@ -32,7 +32,8 @@ const TREESEED_DEFAULT_LOCAL_SMTP_HOST = "127.0.0.1";
 const TREESEED_DEFAULT_LOCAL_SMTP_PORT = 1025;
 const TREESEED_DEFAULT_MAILPIT_UI_PORT = 8025;
 const DEV_RELOAD_FILE = "public/__treeseed/dev-reload.json";
-const DEV_RUNTIME_FILE = ".treeseed/generated/dev/runtime.json";
+const DEV_RUNTIME_DIR = ".treeseed/generated/dev";
+const DEV_RUNTIME_LEGACY_FILE = ".treeseed/generated/dev/runtime.json";
 const DEFAULT_READINESS_TIMEOUT_MS = 9e4;
 const DEFAULT_SETUP_STEP_TIMEOUT_MS = 3e5;
 const DEFAULT_PROCESS_READY_GRACE_MS = 1200;
@@ -132,10 +133,10 @@ function fallbackWebProviderFromDeployConfig(deployConfig) {
   const record = deployConfig && typeof deployConfig === "object" ? deployConfig : {};
   return normalizeProvider(record.providers?.deploy, "local");
 }
-function selectWebLocalRuntime(surfaceConfig, providerFallback = "local") {
+function selectWebLocalRuntime(surfaceConfig, providerFallback = "local", overrideRuntime) {
   const record = surfaceConfig && typeof surfaceConfig === "object" ? surfaceConfig : {};
   const provider = normalizeProvider(record.provider, providerFallback);
-  const requested = normalizeLocalRuntimeMode(record.local?.runtime);
+  const requested = overrideRuntime ?? normalizeLocalRuntimeMode(record.local?.runtime);
   if (provider === "cloudflare" && requested !== "local") {
     return {
       requested,
@@ -151,7 +152,7 @@ function selectWebLocalRuntime(surfaceConfig, providerFallback = "local") {
     requested,
     provider,
     selected: "astro-local",
-    reason: requested === "local" ? "Configured to use the full local Astro runtime." : `Provider "${provider}" has no provider-local web runtime; using Astro local.`
+    reason: overrideRuntime === "local" ? "CLI override selected the full local Astro runtime for faster UI development." : requested === "local" ? "Configured to use the full local Astro runtime." : `Provider "${provider}" has no provider-local web runtime; using Astro local.`
   };
 }
 function loadDevDeployConfig(tenantRoot) {
@@ -271,6 +272,30 @@ function resolveSeededLocalProjectId(persistTo, projectSlug = "market") {
     db?.close();
   }
 }
+function resolveSeededLocalTeamId(persistTo, projectId, teamSlug = "treeseed") {
+  const sqlitePath = resolveLocalD1SqlitePath(persistTo);
+  if (!sqlitePath) return null;
+  let db = null;
+  try {
+    db = new DatabaseSync(sqlitePath, { readOnly: true });
+    if (projectId) {
+      const projectRow = db.prepare(
+        `SELECT team_id FROM projects WHERE id = ? LIMIT 1`
+      ).get(projectId);
+      if (typeof projectRow?.team_id === "string" && projectRow.team_id.trim()) {
+        return projectRow.team_id.trim();
+      }
+    }
+    const teamRow = db.prepare(
+      `SELECT id FROM teams WHERE LOWER(slug) = LOWER(?) ORDER BY created_at ASC LIMIT 1`
+    ).get(teamSlug);
+    return typeof teamRow?.id === "string" && teamRow.id.trim() ? teamRow.id.trim() : null;
+  } catch {
+    return null;
+  } finally {
+    db?.close();
+  }
+}
 function createTreeseedIntegratedDevResetPlan(options) {
   if (!options.enabled) {
     return null;
@@ -529,10 +554,13 @@ function createTreeseedIntegratedDevPlan(options = {}) {
   const agentPackageRoot = resolvePackageRootEnvOverride(mergedEnv, "TREESEED_AGENT_PACKAGE_ROOT", tenantRoot) ?? resolveOptionalPackageRoot("@treeseed/agent", tenantRoot);
   const cliPackageRoot = resolveOptionalPackageRoot("@treeseed/cli", tenantRoot);
   const deployConfig = loadDevDeployConfig(tenantRoot);
-  const webLocalRuntime = selectWebLocalRuntime(deployConfig?.surfaces?.web, fallbackWebProviderFromDeployConfig(deployConfig));
+  const webLocalRuntime = selectWebLocalRuntime(deployConfig?.surfaces?.web, fallbackWebProviderFromDeployConfig(deployConfig), options.webRuntime);
   const usesCloudflareWebRuntime = webLocalRuntime.selected === "cloudflare-wrangler-local";
-  const localD1PersistTo = mergedEnv.TREESEED_API_D1_LOCAL_PERSIST_TO ?? (usesCloudflareWebRuntime ? resolve(tenantRoot, ".treeseed", "generated", "environments", "local", ".wrangler", "state", "v3", "d1") : resolve(tenantRoot, ".wrangler", "state", "v3", "d1"));
+  const usesGeneratedLocalD1State = usesCloudflareWebRuntime || webLocalRuntime.provider === "cloudflare" || selectedCommandIds.some((id) => id !== "web");
+  const localD1PersistTo = mergedEnv.TREESEED_API_D1_LOCAL_PERSIST_TO ?? (usesGeneratedLocalD1State ? resolve(tenantRoot, ".treeseed", "generated", "environments", "local", ".wrangler", "state", "v3", "d1") : resolve(tenantRoot, ".wrangler", "state", "v3", "d1"));
   const projectId = options.projectId ?? mergedEnv.TREESEED_PROJECT_ID ?? resolveSeededLocalProjectId(localD1PersistTo);
+  const resolvedHostingTeamId = teamId ?? mergedEnv.TREESEED_HOSTING_TEAM_ID;
+  const resolvedTeamId = mergedEnv.TREESEED_TEAM_ID ?? resolvedHostingTeamId ?? resolveSeededLocalTeamId(localD1PersistTo, projectId ?? null);
   const webEntrypoint = resolveNodeEntrypoint(
     sdkPackageRoot,
     "scripts/tenant-astro-command.ts",
@@ -557,13 +585,14 @@ function createTreeseedIntegratedDevPlan(options = {}) {
   const resetRequested = options.reset === true;
   const sharedEnv = {
     ...mergedEnv,
-    TREESEED_LOCAL_DEV_MODE: mergedEnv.TREESEED_LOCAL_DEV_MODE ?? "cloudflare",
+    TREESEED_LOCAL_DEV_MODE: usesCloudflareWebRuntime ? mergedEnv.TREESEED_LOCAL_DEV_MODE ?? "cloudflare" : void 0,
     TREESEED_SITE_URL: mergedEnv.TREESEED_SITE_URL ?? webUrl,
     BETTER_AUTH_URL: mergedEnv.BETTER_AUTH_URL ?? webUrl,
     TREESEED_API_BASE_URL: apiBaseUrl,
     TREESEED_MARKET_API_BASE_URL: mergedEnv.TREESEED_MARKET_API_BASE_URL ?? apiBaseUrl,
     TREESEED_PROJECT_ID: projectId ?? mergedEnv.TREESEED_PROJECT_ID,
-    TREESEED_HOSTING_TEAM_ID: teamId ?? mergedEnv.TREESEED_HOSTING_TEAM_ID,
+    TREESEED_TEAM_ID: resolvedTeamId ?? mergedEnv.TREESEED_TEAM_ID,
+    TREESEED_HOSTING_TEAM_ID: resolvedHostingTeamId ?? mergedEnv.TREESEED_HOSTING_TEAM_ID,
     TREESEED_API_D1_DATABASE_NAME: mergedEnv.TREESEED_API_D1_DATABASE_NAME ?? "SITE_DATA_DB",
     SITE_DATA_DB: mergedEnv.SITE_DATA_DB ?? "SITE_DATA_DB",
     TREESEED_API_D1_LOCAL_PERSIST_TO: localD1PersistTo,
@@ -645,6 +674,7 @@ function createTreeseedIntegratedDevPlan(options = {}) {
     readyChecks,
     watchEntries,
     commands,
+    logPath: resolve(tenantRoot, ".treeseed", "logs", `dev-${runtimeScopeKey(commands.map((command) => command.id))}.jsonl`),
     localRuntimes: {
       ...commands.some((command) => command.id === "web") ? { web: webLocalRuntime } : {},
       ...commands.some((command) => command.id === "api") ? { api: nodeLocalRuntime("Treeseed API") } : {},
@@ -686,6 +716,29 @@ function defaultProcessIsAlive(pid) {
     return false;
   }
 }
+function defaultInspectPortOwners(ports) {
+  const uniquePorts = [...new Set(ports.filter((port) => Number.isInteger(port) && port > 0))];
+  if (uniquePorts.length === 0) return [];
+  const result = spawnSync("ss", ["-ltnp"], { encoding: "utf8" });
+  if ((result.status ?? 1) !== 0) return [];
+  const lines = String(result.stdout ?? "").split(/\r?\n/u);
+  const owners = [];
+  for (const port of uniquePorts) {
+    const portPattern = new RegExp(`:${port}\\b`, "u");
+    for (const line of lines) {
+      if (!portPattern.test(line)) continue;
+      const pidMatch = line.match(/pid=(\d+)/u);
+      const nameMatch = line.match(/users:\(\("([^"]+)"/u);
+      owners.push({
+        port,
+        pid: pidMatch ? Number(pidMatch[1]) : null,
+        processName: nameMatch?.[1],
+        detail: line.trim()
+      });
+    }
+  }
+  return owners;
+}
 function defaultRemovePath(path) {
   rmSync(path, { recursive: true, force: true });
 }
@@ -782,44 +835,131 @@ function resolveLocalMachineEnv(tenantRoot) {
     return {};
   }
 }
-function devRuntimeStatePath(tenantRoot) {
-  return resolve(tenantRoot, DEV_RUNTIME_FILE);
+function devRuntimeStateDir(tenantRoot) {
+  return resolve(tenantRoot, DEV_RUNTIME_DIR);
+}
+function devRuntimeStatePath(tenantRoot, key) {
+  return resolve(devRuntimeStateDir(tenantRoot), `runtime-${key}.json`);
+}
+function legacyDevRuntimeStatePath(tenantRoot) {
+  return resolve(tenantRoot, DEV_RUNTIME_LEGACY_FILE);
 }
-function readDevRuntimeState(tenantRoot) {
+function runtimeScopeKey(commandIds) {
+  const selected = CANONICAL_COMMAND_IDS.filter((id) => commandIds.includes(id));
+  return selected.length > 0 ? selected.join("-") : "integrated";
+}
+function readDevRuntimeStateFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync(devRuntimeStatePath(tenantRoot), "utf8"));
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
     if (!Number.isInteger(parsed.pid) || typeof parsed.tenantRoot !== "string" || typeof parsed.startedAt !== "string") {
       return null;
     }
+    const commandIds = Array.isArray(parsed.commandIds) ? parsed.commandIds.filter((id) => CANONICAL_COMMAND_IDS.includes(id)) : void 0;
     return {
       pid: parsed.pid,
       tenantRoot: parsed.tenantRoot,
-      startedAt: parsed.startedAt
+      startedAt: parsed.startedAt,
+      ...commandIds ? { commandIds } : {},
+      statePath: path
     };
   } catch {
     return null;
   }
 }
-function writeCurrentDevRuntimeState(tenantRoot) {
-  const outputPath = devRuntimeStatePath(tenantRoot);
+function listDevRuntimeStates(tenantRoot) {
+  const states = [];
+  const legacy = readDevRuntimeStateFile(legacyDevRuntimeStatePath(tenantRoot));
+  if (legacy) {
+    states.push(legacy);
+  }
+  try {
+    for (const entry of readdirSync(devRuntimeStateDir(tenantRoot))) {
+      if (!entry.startsWith("runtime-") || !entry.endsWith(".json")) {
+        continue;
+      }
+      const state = readDevRuntimeStateFile(resolve(devRuntimeStateDir(tenantRoot), entry));
+      if (state) {
+        states.push(state);
+      }
+    }
+  } catch {
+  }
+  return states;
+}
+function runtimeStateOverlaps(state, commandIds) {
+  if (!state.commandIds || state.commandIds.length === 0) {
+    return true;
+  }
+  return state.commandIds.some((id) => commandIds.includes(id));
+}
+function listLiveOverlappingDevRuntimeStates(tenantRoot, commandIds, processIsAlive) {
+  const live = [];
+  for (const state of listDevRuntimeStates(tenantRoot)) {
+    const statePath = state.statePath;
+    if (!statePath || !runtimeStateOverlaps(state, commandIds)) {
+      continue;
+    }
+    if (state.pid === process.pid) {
+      continue;
+    }
+    if (!processIsAlive(state.pid)) {
+      rmSync(statePath, { force: true });
+      continue;
+    }
+    live.push(state);
+  }
+  return live;
+}
+function parsePortFromUrl(value) {
+  if (!value) return null;
+  try {
+    const url = new URL(value);
+    const port = Number(url.port || (url.protocol === "https:" ? 443 : 80));
+    return Number.isInteger(port) && port > 0 ? port : null;
+  } catch {
+    return null;
+  }
+}
+function requiredDevPorts(plan) {
+  const ports = [];
+  for (const command of plan.commands) {
+    if (command.id === "web") {
+      const port = parsePortFromUrl(plan.webUrl ?? void 0);
+      if (port) ports.push(port);
+    }
+    if (command.id === "api") {
+      const port = parsePortFromUrl(plan.apiBaseUrl);
+      if (port) ports.push(port);
+    }
+  }
+  return [...new Set(ports)];
+}
+function formatPortOwner(owner) {
+  return `port ${owner.port}${owner.pid ? ` pid ${owner.pid}` : ""}${owner.processName ? ` (${owner.processName})` : ""}`;
+}
+function writeCurrentDevRuntimeState(tenantRoot, commandIds) {
+  const outputPath = devRuntimeStatePath(tenantRoot, runtimeScopeKey(commandIds));
   mkdirSync(dirname(outputPath), { recursive: true });
   writeFileSync(
     outputPath,
     `${JSON.stringify({
       pid: process.pid,
       tenantRoot,
+      commandIds,
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     }, null, 2)}
 `,
     "utf8"
   );
+  return outputPath;
 }
-function removeCurrentDevRuntimeState(tenantRoot) {
-  const state = readDevRuntimeState(tenantRoot);
+function removeCurrentDevRuntimeState(tenantRoot, commandIds) {
+  const statePath = devRuntimeStatePath(tenantRoot, runtimeScopeKey(commandIds));
+  const state = readDevRuntimeStateFile(statePath);
   if (!state || state.pid !== process.pid) {
     return;
   }
-  rmSync(devRuntimeStatePath(tenantRoot), { force: true });
+  rmSync(statePath, { force: true });
 }
 async function waitForProcessExit(pid, processIsAlive, timeoutMs) {
   const startedAt = Date.now();
@@ -831,38 +971,106 @@ async function waitForProcessExit(pid, processIsAlive, timeoutMs) {
   }
   return !processIsAlive(pid);
 }
-async function stopPreviousDevRuntime(tenantRoot, options, deps) {
-  const state = readDevRuntimeState(tenantRoot);
-  if (!state) {
-    return;
-  }
-  const statePath = devRuntimeStatePath(tenantRoot);
-  if (state.pid === process.pid) {
-    return;
-  }
-  if (!deps.processIsAlive(state.pid)) {
+async function stopPreviousDevRuntimes(tenantRoot, commandIds, options, deps) {
+  for (const state of listLiveOverlappingDevRuntimeStates(tenantRoot, commandIds, deps.processIsAlive)) {
+    const statePath = state.statePath;
+    if (!statePath) continue;
+    emitEvent(options, deps.write, {
+      type: "replace",
+      message: `Stopping previous Treeseed dev runtime (${state.pid}) before starting overlapping surfaces.`,
+      detail: { pid: state.pid, startedAt: state.startedAt, commandIds: state.commandIds ?? null }
+    });
+    try {
+      deps.killProcess(state.pid, "SIGTERM");
+    } catch {
+    }
+    if (await waitForProcessExit(state.pid, deps.processIsAlive, options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS)) {
+      rmSync(statePath, { force: true });
+      continue;
+    }
+    try {
+      deps.killProcess(state.pid, "SIGKILL");
+    } catch {
+    }
+    await waitForProcessExit(state.pid, deps.processIsAlive, DEFAULT_KILL_GRACE_MS);
     rmSync(statePath, { force: true });
-    return;
   }
-  emitEvent(options, deps.write, {
-    type: "replace",
-    message: `Stopping previous Treeseed dev runtime (${state.pid}) before starting a new one.`,
-    detail: { pid: state.pid, startedAt: state.startedAt }
-  });
-  try {
-    deps.killProcess(state.pid, "SIGTERM");
-  } catch {
+}
+async function stopPortOwners(owners, options, deps) {
+  const pids = [...new Set(owners.map((owner) => owner.pid).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid))];
+  for (const pid of pids) {
+    emitEvent(options, deps.write, {
+      type: "replace",
+      message: `Stopping service on required dev port (pid ${pid}).`,
+      detail: owners.filter((owner) => owner.pid === pid)
+    });
+    try {
+      deps.killProcess(pid, "SIGTERM");
+    } catch {
+    }
+    if (await waitForProcessExit(pid, deps.processIsAlive, options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS)) {
+      continue;
+    }
+    try {
+      deps.killProcess(pid, "SIGKILL");
+    } catch {
+    }
+    await waitForProcessExit(pid, deps.processIsAlive, DEFAULT_KILL_GRACE_MS);
   }
-  if (await waitForProcessExit(state.pid, deps.processIsAlive, options.shutdownGraceMs ?? DEFAULT_SHUTDOWN_GRACE_MS)) {
-    rmSync(statePath, { force: true });
-    return;
+}
+async function prepareDevRuntimeSlots(plan, options, deps) {
+  const commandIds = plan.commands.map((command) => command.id);
+  const liveRuntimeStates = listLiveOverlappingDevRuntimeStates(plan.tenantRoot, commandIds, deps.processIsAlive);
+  const ports = requiredDevPorts(plan);
+  const portOwners = deps.inspectPortOwners(ports).filter((owner) => owner.pid !== process.pid);
+  if (options.force !== true) {
+    if (liveRuntimeStates.length > 0 || portOwners.length > 0) {
+      emitEvent(options, deps.write, {
+        type: "error",
+        status: "existing-service",
+        message: [
+          "Treeseed dev found an existing runtime or service on a required port.",
+          "Stop it first, or rerun with --force to terminate overlapping Treeseed dev services and port owners."
+        ].join(" "),
+        detail: {
+          runtimes: liveRuntimeStates.map((state) => ({
+            pid: state.pid,
+            startedAt: state.startedAt,
+            commandIds: state.commandIds ?? null,
+            statePath: state.statePath ?? null
+          })),
+          ports: portOwners.map((owner) => ({ ...owner, label: formatPortOwner(owner) }))
+        }
+      });
+      return false;
+    }
+    return true;
   }
-  try {
-    deps.killProcess(state.pid, "SIGKILL");
-  } catch {
+  await stopPreviousDevRuntimes(plan.tenantRoot, commandIds, options, deps);
+  if (portOwners.length > 0) {
+    const ownersWithoutPid = portOwners.filter((owner) => owner.pid == null);
+    if (ownersWithoutPid.length > 0) {
+      emitEvent(options, deps.write, {
+        type: "error",
+        status: "existing-service",
+        message: `Cannot force-stop required dev ports because some listeners did not expose process ids: ${ownersWithoutPid.map(formatPortOwner).join(", ")}.`,
+        detail: ownersWithoutPid
+      });
+      return false;
+    }
+    await stopPortOwners(portOwners, options, deps);
   }
-  await waitForProcessExit(state.pid, deps.processIsAlive, DEFAULT_KILL_GRACE_MS);
-  rmSync(statePath, { force: true });
+  const remainingPortOwners = deps.inspectPortOwners(ports).filter((owner) => owner.pid !== process.pid);
+  if (remainingPortOwners.length > 0) {
+    emitEvent(options, deps.write, {
+      type: "error",
+      status: "existing-service",
+      message: `Required dev ports are still occupied after --force: ${remainingPortOwners.map(formatPortOwner).join(", ")}.`,
+      detail: remainingPortOwners
+    });
+    return false;
+  }
+  return true;
 }
 function emitEvent(options, write, event, stream = event.type === "error" ? "stderr" : "stdout") {
   if (options.json) {
@@ -875,6 +1083,20 @@ function emitEvent(options, write, event, stream = event.type === "error" ? "std
   write(`${surface} ${String(message)}
 `, stream);
 }
+function createDevLogWrite(baseWrite, logPath) {
+  mkdirSync(dirname(logPath), { recursive: true });
+  appendFileSync(logPath, `${JSON.stringify({
+    schemaVersion: 1,
+    kind: "treeseed.dev.log",
+    type: "start",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  })}
+`, "utf8");
+  return (line, stream) => {
+    baseWrite(line, stream);
+    appendFileSync(logPath, line, "utf8");
+  };
+}
 function runTreeseedIntegratedDevReset(reset, options, deps) {
   if (!reset?.enabled) {
     return null;
@@ -979,6 +1201,8 @@ function writePlan(plan, options, write) {
 `, "stdout");
   }
   write(`api: ${plan.apiBaseUrl}
+`, "stdout");
+  write(`log: ${plan.logPath}
 `, "stdout");
   for (const [name, runtime] of Object.entries(plan.localRuntimes)) {
     write(`runtime ${name}: ${runtime.selected} (${runtime.provider}, requested ${runtime.requested})${runtime.reason ? ` - ${runtime.reason}` : ""}
@@ -1216,7 +1440,7 @@ function failedSetupMessage(failed) {
 }
 async function runTreeseedIntegratedDev(options = {}, deps = {}) {
   const tenantRoot = resolve(options.cwd ?? process.cwd());
-  const write = deps.write ?? defaultWrite;
+  let write = deps.write ?? defaultWrite;
   const spawnProcess = deps.spawn ?? spawn;
   const spawnSyncProcess = deps.spawnSync ?? spawnSync;
   const onSignal = deps.onSignal ?? defaultSignalRegistrar;
@@ -1228,6 +1452,7 @@ async function runTreeseedIntegratedDev(options = {}, deps = {}) {
   const prepareEnvironment = deps.prepareEnvironment ?? defaultPrepareEnvironment;
   const removePath = deps.removePath ?? defaultRemovePath;
   const stopMailpit = deps.stopMailpitContainers ?? stopKnownMailpitContainers;
+  const inspectPortOwners = deps.inspectPortOwners ?? defaultInspectPortOwners;
   prepareEnvironment(tenantRoot);
   const plan = createTreeseedIntegratedDevPlan({
     ...options,
@@ -1241,8 +1466,15 @@ async function runTreeseedIntegratedDev(options = {}, deps = {}) {
     writePlan(plan, options, write);
     return 0;
   }
-  if (readDevRuntimeState(tenantRoot)) {
-    await stopPreviousDevRuntime(tenantRoot, options, { write, killProcess, processIsAlive });
+  const commandIds = plan.commands.map((command) => command.id);
+  write = createDevLogWrite(write, plan.logPath);
+  emitEvent(options, write, {
+    type: "log",
+    message: `Writing Treeseed dev logs to ${plan.logPath}.`,
+    detail: { logPath: plan.logPath }
+  });
+  if (!await prepareDevRuntimeSlots(plan, options, { write, killProcess, processIsAlive, inspectPortOwners })) {
+    return 1;
   }
   const resetResults = runTreeseedIntegratedDevReset(plan.reset, options, {
     write,
@@ -1258,7 +1490,7 @@ async function runTreeseedIntegratedDev(options = {}, deps = {}) {
     });
     return 1;
   }
-  writeCurrentDevRuntimeState(tenantRoot);
+  writeCurrentDevRuntimeState(tenantRoot, commandIds);
   const children = /* @__PURE__ */ new Map();
   const commandsById = new Map(plan.commands.map((command) => [command.id, command]));
   const requiredSurfaceIds = new Set(plan.readyChecks.filter((check) => check.required).map((check) => check.id));
@@ -1311,7 +1543,7 @@ async function runTreeseedIntegratedDev(options = {}, deps = {}) {
       for (const dispose of disposers) {
         dispose();
       }
-      removeCurrentDevRuntimeState(tenantRoot);
+      removeCurrentDevRuntimeState(tenantRoot, commandIds);
       emitEvent(
         options,
         write,