@devrouter/cli 0.0.72 → 0.0.74

package/dist/devrouter.js

@@ -31,7 +31,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/core/controller-probe.ts
-function runControllerProbe(command, args, signal, options = {}) {
+function probe(command, args, signal, options) {
   return new Promise((resolve, reject) => {
     if (signal.aborted) {
       reject(new Error("Observation cancelled."));
@@ -85,12 +85,19 @@ function runControllerProbe(command, args, signal, options = {}) {
       if (finished) return;
       finished = true;
       cleanup();
-      if (failed || code !== 0)
-        reject(new Error("Observation process failed or exceeded its bound."));
-      else resolve(Buffer.concat(chunks).toString("utf8"));
+      if (failed) reject(new Error("Observation process failed or exceeded its bound."));
+      else resolve({ output: Buffer.concat(chunks).toString("utf8"), code });
     });
   });
 }
+async function runControllerProbe(command, args, signal, options = {}) {
+  const result = await probe(command, args, signal, options);
+  if (result.code !== 0) throw new Error("Observation process failed or exceeded its bound.");
+  return result.output;
+}
+function runControllerProbeStatus(command, args, signal, options = {}) {
+  return probe(command, args, signal, options);
+}
 var import_node_child_process, ControllerProbeUnavailable;
 var init_controller_probe = __esm({
   "src/core/controller-probe.ts"() {
@@ -132,12 +139,12 @@ async function readCapacityHostSnapshot(signal, dependencies = {}) {
   try {
     if ((dependencies.platform ?? process.platform) !== "darwin" || signal.aborted)
       throw new Error("Host probe unavailable.");
-    const probe = dependencies.probe ?? runControllerProbe;
+    const probe2 = dependencies.probe ?? runControllerProbe;
     const cancellation = new AbortController();
     const probeSignal = AbortSignal.any([signal, cancellation.signal]);
     const results = await Promise.allSettled(
       ["hw.memsize", "kern.memorystatus_vm_pressure_level"].map(
-        (name) => Promise.resolve().then(() => probe("/usr/sbin/sysctl", ["-n", name], probeSignal)).catch((error) => {
+        (name) => Promise.resolve().then(() => probe2("/usr/sbin/sysctl", ["-n", name], probeSignal)).catch((error) => {
           cancellation.abort();
           throw error;
         })
@@ -1170,6 +1177,55 @@ function inspectManagedStopWorkspaceIds(endpoint, composeDirectory) {
   assertUniqueContainerIds(ids2);
   return ids2;
 }
+function assertManagedStopCheckoutAbsent(endpoint, repoPath) {
+  const list2 = () => {
+    const ids3 = parseDockerLines(
+      runManagedStopDocker(["ps", "-a", "--no-trunc", "--format", "{{.ID}}"], endpoint)
+    );
+    if (ids3.length > 256) throw new Error("Managed stop population exceeds its bound.");
+    ids3.forEach(assertFullContainerId);
+    assertUniqueContainerIds(ids3);
+    return ids3;
+  };
+  const ids2 = list2();
+  const seen = [];
+  const labels = [
+    "com.docker.compose.project.working_dir",
+    "devcontainer.local_folder",
+    "vsch.local.folder"
+  ];
+  const template = '{"id":{{json .Id}},"labels":{"com.docker.compose.project.working_dir":{{json (index .Config.Labels "com.docker.compose.project.working_dir")}},"devcontainer.local_folder":{{json (index .Config.Labels "devcontainer.local_folder")}},"vsch.local.folder":{{json (index .Config.Labels "vsch.local.folder")}}},"mounts":[{{range $i, $m := .Mounts}}{{if $i}},{{end}}{"Type":{{json $m.Type}},"Source":{{json $m.Source}}}{{end}}]}';
+  if (ids2.length) {
+    for (const line of parseDockerLines(
+      runManagedStopDocker(["inspect", "--format", template, ...ids2], endpoint)
+    )) {
+      const value = parseManagedStopJson(line);
+      if (!isRecord(value) || !isRecord(value.labels) || !Array.isArray(value.mounts))
+        throw new Error("Managed stop checkout inspection is malformed.");
+      assertFullContainerId(value.id);
+      seen.push(value.id);
+      for (const label2 of labels) {
+        const field = value.labels[label2];
+        if (field !== null && typeof field !== "string")
+          throw new Error("Managed stop checkout labels are incomplete.");
+        if (typeof field === "string" && sameWorkspacePath(
+          field,
+          label2 === labels[0] ? import_node_path4.default.join(repoPath, ".devcontainer") : repoPath
+        ))
+          throw new Error("Managed stop observed a remaining checkout container.");
+      }
+      for (const mount of value.mounts) {
+        if (!isRecord(mount) || typeof mount.Type !== "string" || typeof mount.Source !== "string")
+          throw new Error("Managed stop checkout mounts are incomplete.");
+        if (mount.Type === "bind" && sameWorkspacePath(mount.Source, repoPath))
+          throw new Error("Managed stop observed a remaining checkout mount.");
+      }
+    }
+  }
+  assertUniqueContainerIds(seen);
+  requireSameContainerPopulation(ids2, seen);
+  requireSameContainerPopulation(ids2, list2());
+}
 function hasExactManagedStopMissingObjectError(stderr, id5) {
   if (typeof stderr !== "string") return false;
   const line = stderr.endsWith("\r\n") ? stderr.slice(0, -2) : stderr.endsWith("\n") ? stderr.slice(0, -1) : stderr;
@@ -1803,6 +1859,62 @@ function parseScheduling(value) {
   }
   return result;
 }
+function parseRecovery(value) {
+  if (value === void 0) return { ...DEFAULT_CAPACITY_RECOVERY };
+  const label2 = "recovery";
+  const recovery = ensureObject(value, label2);
+  ensureAllowedKeys(
+    recovery,
+    [
+      "enabled",
+      "maxProcessRestarts",
+      "maxServiceRestarts",
+      "maxCorrectiveActions",
+      "windowSeconds",
+      "observationSeconds",
+      "resumeDwellSeconds"
+    ],
+    label2
+  );
+  if (typeof recovery.enabled !== "boolean") {
+    throw new Error(`${label2}.enabled must be a boolean.`);
+  }
+  const result = {
+    enabled: recovery.enabled,
+    maxProcessRestarts: parseSafeInteger(
+      recovery.maxProcessRestarts,
+      `${label2}.maxProcessRestarts`,
+      0
+    ),
+    maxServiceRestarts: parseSafeInteger(
+      recovery.maxServiceRestarts,
+      `${label2}.maxServiceRestarts`,
+      0
+    ),
+    maxCorrectiveActions: parsePositiveInteger(
+      recovery.maxCorrectiveActions,
+      `${label2}.maxCorrectiveActions`
+    ),
+    windowSeconds: parsePositiveInteger(recovery.windowSeconds, `${label2}.windowSeconds`),
+    observationSeconds: parsePositiveInteger(
+      recovery.observationSeconds,
+      `${label2}.observationSeconds`
+    ),
+    resumeDwellSeconds: parsePositiveInteger(
+      recovery.resumeDwellSeconds,
+      `${label2}.resumeDwellSeconds`
+    )
+  };
+  if (result.maxCorrectiveActions < result.maxProcessRestarts + result.maxServiceRestarts) {
+    throw new Error(
+      `${label2}.maxCorrectiveActions must cover maxProcessRestarts and maxServiceRestarts.`
+    );
+  }
+  if (result.maxProcessRestarts > 4 || result.maxServiceRestarts > 2 || result.maxCorrectiveActions > 8 || result.windowSeconds > 3600 || result.observationSeconds > 300 || result.resumeDwellSeconds > 3600) {
+    throw new Error(`${label2} exceeds supported controller bounds.`);
+  }
+  return result;
+}
 function validateDomainReferences(domains) {
   const daemonIds = /* @__PURE__ */ new Map();
   const endpoints = /* @__PURE__ */ new Map();
@@ -1926,7 +2038,7 @@ function parseCapacityPolicy(value) {
   const root = ensureObject(value, "capacity policy");
   ensureAllowedKeys(
     root,
-    ["version", "revision", "admissions", "scheduling", "domains", "enrollments"],
+    ["version", "revision", "admissions", "scheduling", "recovery", "domains", "enrollments"],
     "capacity policy"
   );
   const version = parsePositiveInteger(root.version, "capacity policy.version");
@@ -1939,6 +2051,7 @@ function parseCapacityPolicy(value) {
     throw new Error("capacity policy.admissions must be 'enabled' or 'paused'.");
   }
   const scheduling = parseScheduling(root.scheduling);
+  const recovery = parseRecovery(root.recovery);
   const domainsValue = ensureObject(root.domains, "capacity policy.domains");
   const domainEntries = Object.entries(domainsValue);
   if (domainEntries.length > MAX_DOMAINS) {
@@ -1985,11 +2098,12 @@ function parseCapacityPolicy(value) {
     revision,
     admissions,
     scheduling,
+    recovery,
     domains,
     enrollments
   };
 }
-var import_node_fs4, import_node_path6, MAX_DOMAINS, MAX_ENROLLMENTS, MAX_PROFILES_PER_ENROLLMENT, MAX_STRING_LENGTH, MAX_PATH_LENGTH, DOMAIN_ID_RE, PROFILE_NAME_RE, WORKSPACE_TOKEN_RE, SHA256_RE;
+var import_node_fs4, import_node_path6, MAX_DOMAINS, MAX_ENROLLMENTS, MAX_PROFILES_PER_ENROLLMENT, MAX_STRING_LENGTH, MAX_PATH_LENGTH, DOMAIN_ID_RE, PROFILE_NAME_RE, WORKSPACE_TOKEN_RE, SHA256_RE, DEFAULT_CAPACITY_RECOVERY;
 var init_capacity_policy = __esm({
   "src/core/capacity-policy.ts"() {
     "use strict";
@@ -2004,6 +2118,15 @@ var init_capacity_policy = __esm({
     PROFILE_NAME_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
     WORKSPACE_TOKEN_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
     SHA256_RE = /^[0-9a-f]{64}$/;
+    DEFAULT_CAPACITY_RECOVERY = {
+      enabled: false,
+      maxProcessRestarts: 2,
+      maxServiceRestarts: 1,
+      maxCorrectiveActions: 3,
+      windowSeconds: 600,
+      observationSeconds: 30,
+      resumeDwellSeconds: 300
+    };
   }
 });
 
@@ -4133,7 +4256,7 @@ function loadRepoConfig(repoPath, read2 = (file) => import_node_fs7.default.read
   const config = parseConfig(parsed ?? {}, configPath);
   const requiredVersion = config.devrouter?.version;
   if (requiredVersion && !hasWarnedVersionMismatch) {
-    const cliVersion = true ? "0.0.72" : "0.0.0-dev";
+    const cliVersion = true ? "0.0.74" : "0.0.0-dev";
     if (cliVersion !== "0.0.0-dev" && compareSemver(requiredVersion, cliVersion) > 0) {
       hasWarnedVersionMismatch = true;
       process.stderr.write(
@@ -5386,7 +5509,7 @@ var init_reliability_contract = __esm({
 
 // src/core/reliability-operation-store.ts
 function installedCliVersion() {
-  return true ? "0.0.72" : "0.0.0-dev";
+  return true ? "0.0.74" : "0.0.0-dev";
 }
 function compareCliVersions(left, right) {
   const parts = (value) => value.split(".").map((part) => Number.parseInt(part, 10) || 0);
@@ -6423,6 +6546,16 @@ async function readProviderGeneration(repoPath, providerId, signal) {
     throw new Error("Capacity provider generation is malformed.");
   return generation;
 }
+function ownershipPopulationEvidence(record5, state) {
+  return {
+    environmentId: record5.state.environmentId,
+    executionPolicy: record5.state.executionPolicy,
+    enrollment: record5.enrollment ?? null,
+    composeProject: state?.composeProject ?? null,
+    devpodId: state?.devpodId ?? null,
+    stopBaseline: state?.stopBaseline ?? null
+  };
+}
 async function resolveCapacityOwnership(policy, runtimeDomain, signal, dependencies = {
   resolve: resolveCapacityEnrollment,
   providerGeneration: readProviderGeneration,
@@ -6473,18 +6606,21 @@ async function resolveCapacityOwnership(policy, runtimeDomain, signal, dependenc
         check();
         if (!(0, import_node_util5.isDeepStrictEqual)(current, entry.binding) || !(0, import_node_util5.isDeepStrictEqual)(generation, entry.generation))
           throw new Error("Capacity provider ownership changed during collection.");
-        if (!entry.evidence || !(0, import_node_util5.isDeepStrictEqual)(entry.evidence, {
-          record: dependencies.journal({
-            repoPath: entry.enrollment.repoPath,
-            workspace: entry.enrollment.workspace || null,
-            provider: entry.enrollment.provider
-          }),
-          state: dependencies.managed(
-            entry.enrollment.repoPath,
-            entry.enrollment.workspace || void 0,
-            (file) => readControllerEvidence(file, 1048576)
+        if (!entry.evidence || !(0, import_node_util5.isDeepStrictEqual)(
+          entry.evidence,
+          ownershipPopulationEvidence(
+            dependencies.journal({
+              repoPath: entry.enrollment.repoPath,
+              workspace: entry.enrollment.workspace || null,
+              provider: entry.enrollment.provider
+            }),
+            dependencies.managed(
+              entry.enrollment.repoPath,
+              entry.enrollment.workspace || void 0,
+              (file) => readControllerEvidence(file, 1048576)
+            )
           )
-        }))
+        ))
           throw new Error("Capacity ownership records changed before publication.");
       }
     },
@@ -6533,7 +6669,7 @@ async function resolveCapacityOwnership(policy, runtimeDomain, signal, dependenc
             throw new Error("Capacity witnessed startup generation changed.");
         } else if (!baseline || baseline.provider !== enrollment.provider || baseline.context !== entry.generation.context || baseline.uid !== entry.generation.uid || baseline.sourceContainer !== entry.generation.sourceContainer || baseline.endpoint !== `unix://${domain.endpoint}` || baseline.daemonId !== domain.daemonId)
           throw new Error("Capacity population lacks an exact retained runtime baseline.");
-        const evidence = { record: record5, state };
+        const evidence = ownershipPopulationEvidence(record5, state);
         if (entry.evidence && !(0, import_node_util5.isDeepStrictEqual)(entry.evidence, evidence))
           throw new Error("Capacity ownership generation changed during collection.");
         entry.evidence = structuredClone(evidence);
@@ -6569,7 +6705,13 @@ async function resolveCapacityOwnership(policy, runtimeDomain, signal, dependenc
             endpoint: `unix://${domain.endpoint}`
           });
         }
-        if (!(0, import_node_util5.isDeepStrictEqual)(state, readState()) || !(0, import_node_util5.isDeepStrictEqual)(record5, dependencies.journal(identity2)))
+        if (!(0, import_node_util5.isDeepStrictEqual)(state, readState()) || !(0, import_node_util5.isDeepStrictEqual)(
+          ownershipPopulationEvidence(record5, state),
+          ownershipPopulationEvidence(
+            dependencies.journal(identity2),
+            state
+          )
+        ))
           throw new Error("Capacity ownership records changed during collection.");
         result.push({ environmentId: binding.environment.id, containers: containers2 });
       }
@@ -6623,8 +6765,8 @@ async function collectDeclaredRuntimeCapacity(domain, proveOwned, signal, depend
   const sampledAtMs = Date.now();
   const cancellation = new AbortController();
   const combined = AbortSignal.any([signal, cancellation.signal]);
-  const timer = setTimeout(() => cancellation.abort(), 3e3);
-  const deadline = performance.now() + 3e3;
+  const timer = setTimeout(() => cancellation.abort(), RUNTIME_PROBE_BUDGET_MS);
+  const deadline = performance.now() + RUNTIME_PROBE_BUDGET_MS;
   const check = () => {
     if (combined.aborted || performance.now() >= deadline)
       throw new Error("Runtime capacity collection expired.");
@@ -6717,13 +6859,14 @@ async function collectDeclaredRuntimeCapacity(domain, proveOwned, signal, depend
     clearTimeout(timer);
   }
 }
-var import_node_util6;
+var import_node_util6, RUNTIME_PROBE_BUDGET_MS;
 var init_capacity_runtime_probe = __esm({
   "src/core/capacity-runtime-probe.ts"() {
     "use strict";
     import_node_util6 = require("util");
     init_capacity_docker_probe();
     init_capacity_host_probe();
+    RUNTIME_PROBE_BUDGET_MS = 8e3;
   }
 });
 
@@ -7577,10 +7720,11 @@ function inspectDevsyRuntimeAbsence(devsyId) {
     encoding: "utf-8",
     timeout: 1e4
   });
-  if (!result.error && result.status === 0) {
+  if (result.error || result.status === null) return false;
+  if (result.status === 0) {
     return parseDevsyRuntimeStatus(result.stdout, devsyId) === "not-found";
   }
-  const output2 = [result.error?.message, result.stdout, result.stderr].filter(Boolean).join("\n");
+  const output2 = [result.stdout, result.stderr].filter(Boolean).join("\n");
   return /workspace not found/i.test(output2);
 }
 function inspectDevsyWorkspaceOwnership(workspaces, devsyId, worktreePath) {
@@ -8423,8 +8567,10 @@ function listDevpodWorkspacesRaw(options = {}) {
   const result = (0, import_node_child_process9.spawnSync)("devpod", ["list", "--output", "json", "--skip-pro"], {
     encoding: "utf-8"
   });
-  if (options.allowMissingExecutable && result.error?.code === "ENOENT")
-    return [];
+  if (result.error?.code === "ENOENT") {
+    if (options.readLocalWhenMissing) return readLocalDevpodRegistry();
+    if (options.allowMissingExecutable) return [];
+  }
   if (result.error || result.status !== 0) {
     const details = [result.error?.message, result.stdout, result.stderr].filter(Boolean).join("\n").trim();
     throw new Error(`devpod list failed: ${details || "devpod is not installed or unavailable"}`);
@@ -8457,11 +8603,110 @@ function listDevpodWorkspacesRaw(options = {}) {
     return workspace;
   });
 }
-var import_node_child_process9;
+function devpodRegistryRoot() {
+  return import_node_path26.default.resolve(process.env.DEVPOD_HOME || import_node_path26.default.join(import_node_os3.default.homedir(), ".devpod"));
+}
+function readLocalDevpodRegistry() {
+  const fail4 = () => new Error("Local DevPod registry evidence is incomplete, unreadable, or changed.");
+  const stamps = /* @__PURE__ */ new Map();
+  const stamp = (stat, identityOnly = false) => JSON.stringify([
+    stat.dev,
+    stat.ino,
+    stat.mode,
+    stat.uid,
+    ...identityOnly ? [] : [stat.size, stat.mtimeMs, stat.ctimeMs]
+  ]);
+  const inspect = (file) => {
+    try {
+      return import_node_fs19.default.lstatSync(file);
+    } catch (error) {
+      if (error.code === "ENOENT") return void 0;
+      throw fail4();
+    }
+  };
+  const directory = (dir, optional = false, identityOnly = false) => {
+    const stat = inspect(dir);
+    if (!stat && !optional || stat && !stat.isDirectory()) throw fail4();
+    stamps.set(dir, { value: stat && stamp(stat, identityOnly), identityOnly });
+    return !!stat;
+  };
+  const entries = (dir) => {
+    const names = import_node_fs19.default.readdirSync(dir).sort();
+    if (names.length > 256) throw fail4();
+    return names;
+  };
+  const result = [];
+  try {
+    const root = devpodRegistryRoot();
+    let ancestor = import_node_path26.default.parse(root).root;
+    let present = directory(ancestor, false, ancestor !== root);
+    for (const part of root.slice(ancestor.length).split(import_node_path26.default.sep).filter(Boolean)) {
+      if (!present) break;
+      ancestor = import_node_path26.default.join(ancestor, part);
+      present = directory(ancestor, true, ancestor !== root);
+    }
+    const contexts = import_node_path26.default.join(root, "contexts");
+    if (present && directory(contexts, true)) {
+      for (const context of entries(contexts)) {
+        const contextDir = import_node_path26.default.join(contexts, context);
+        directory(contextDir);
+        const workspaces = import_node_path26.default.join(contextDir, "workspaces");
+        if (!directory(workspaces, true)) continue;
+        for (const id5 of entries(workspaces)) {
+          if (result.length >= 256) throw fail4();
+          const workspace = import_node_path26.default.join(workspaces, id5);
+          directory(workspace);
+          const file = import_node_path26.default.join(workspace, "workspace.json");
+          const stat = inspect(file);
+          if (!stat?.isFile() || stat.size > 1024 * 1024) throw fail4();
+          stamps.set(file, { value: stamp(stat), identityOnly: false });
+          const fd = import_node_fs19.default.openSync(file, import_node_fs19.default.constants.O_RDONLY | import_node_fs19.default.constants.O_NOFOLLOW);
+          let raw;
+          try {
+            if (stamp(import_node_fs19.default.fstatSync(fd)) !== stamp(stat)) throw fail4();
+            const buffer = Buffer.alloc(stat.size + 1);
+            const bytes2 = import_node_fs19.default.readSync(fd, buffer, 0, buffer.length, 0);
+            if (bytes2 !== stat.size || stamp(import_node_fs19.default.fstatSync(fd)) !== stamp(stat)) throw fail4();
+            raw = JSON.parse(buffer.subarray(0, bytes2).toString("utf8"));
+          } finally {
+            import_node_fs19.default.closeSync(fd);
+          }
+          if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw fail4();
+          const value = raw;
+          if (value.id !== id5 || !value.source || typeof value.source !== "object" || Array.isArray(value.source))
+            throw fail4();
+          const source = value.source;
+          if (source.localFolder !== void 0 && (typeof source.localFolder !== "string" || source.localFolder !== "" && !import_node_path26.default.isAbsolute(source.localFolder)))
+            throw fail4();
+          const remote = ["gitRepository", "image", "container"];
+          if (remote.some((key) => source[key] !== void 0 && typeof source[key] !== "string"))
+            throw fail4();
+          if (!source.localFolder && !remote.some((key) => typeof source[key] === "string" && source[key]))
+            throw fail4();
+          result.push({
+            id: id5,
+            source: { localFolder: source.localFolder ?? "" }
+          });
+        }
+      }
+    }
+    for (const [file, expected] of stamps) {
+      const actual = inspect(file);
+      if ((actual && stamp(actual, expected.identityOnly)) !== expected.value) throw fail4();
+    }
+    return result;
+  } catch {
+    throw fail4();
+  }
+}
+var import_node_child_process9, import_node_fs19, import_node_os3, import_node_path26;
 var init_devpod_registry = __esm({
   "src/core/devpod-registry.ts"() {
     "use strict";
     import_node_child_process9 = require("child_process");
+    import_node_fs19 = __toESM(require("fs"));
+    import_node_os3 = __toESM(require("os"));
+    import_node_path26 = __toESM(require("path"));
   }
 });
 
@@ -8479,13 +8724,13 @@ function proveManagedComposePopulation(options) {
     }
     services.add(service);
     const files = (container.labels["com.docker.compose.project.config_files"] ?? "").split(",").map((file) => file.trim());
-    if (files.some((file) => !file || !import_node_path26.default.isAbsolute(file)) || new Set(files.map((file) => import_node_path26.default.resolve(file))).size !== files.length || files.length < plan.composeFiles.length || plan.composeFiles.some((file, index) => !sameWorkspacePath(file, files[index]))) {
+    if (files.some((file) => !file || !import_node_path27.default.isAbsolute(file)) || new Set(files.map((file) => import_node_path27.default.resolve(file))).size !== files.length || files.length < plan.composeFiles.length || plan.composeFiles.some((file, index) => !sameWorkspacePath(file, files[index]))) {
       throw new Error("Managed stop Compose file identity changed.");
     }
     for (const file of files.slice(plan.composeFiles.length)) {
-      if (import_node_path26.default.dirname(file) !== featureDirectory || !/^docker-compose\.devcontainer\.containerFeatures-[a-zA-Z0-9_-]+\.yml$/.test(
-        import_node_path26.default.basename(file)
-      ) || import_node_fs19.default.realpathSync(file) !== import_node_path26.default.join(import_node_fs19.default.realpathSync(providerRoot), import_node_path26.default.relative(providerRoot, file))) {
+      if (import_node_path27.default.dirname(file) !== featureDirectory || !/^docker-compose\.devcontainer\.containerFeatures-[a-zA-Z0-9_-]+\.yml$/.test(
+        import_node_path27.default.basename(file)
+      ) || import_node_fs20.default.realpathSync(file) !== import_node_path27.default.join(import_node_fs20.default.realpathSync(providerRoot), import_node_path27.default.relative(providerRoot, file))) {
         throw new Error("Managed stop refuses a foreign or escaped provider Compose file.");
       }
     }
@@ -8503,12 +8748,12 @@ function proveManagedComposePopulation(options) {
   }
   return primary;
 }
-var import_node_fs19, import_node_path26;
+var import_node_fs20, import_node_path27;
 var init_managed_compose_population = __esm({
   "src/core/managed-compose-population.ts"() {
     "use strict";
-    import_node_fs19 = __toESM(require("fs"));
-    import_node_path26 = __toESM(require("path"));
+    import_node_fs20 = __toESM(require("fs"));
+    import_node_path27 = __toESM(require("path"));
     init_workspace();
   }
 });
@@ -8538,13 +8783,13 @@ function parseWorkspaceRuntime(value) {
 }
 function isRuntimeInstalled(runtime) {
   const probeArgs = runtime === "devsy" ? ["--version"] : ["version"];
-  const probe = (0, import_node_child_process10.spawnSync)(runtime, probeArgs, { encoding: "utf-8" });
-  return probe.status === 0 && !probe.error;
+  const probe2 = (0, import_node_child_process10.spawnSync)(runtime, probeArgs, { encoding: "utf-8" });
+  return probe2.status === 0 && !probe2.error;
 }
 function readWorkspaceRuntimeConfig() {
   let raw;
   try {
-    raw = JSON.parse(import_node_fs20.default.readFileSync(RUNTIME_CONFIG_FILE, "utf-8"));
+    raw = JSON.parse(import_node_fs21.default.readFileSync(RUNTIME_CONFIG_FILE, "utf-8"));
   } catch {
     return {};
   }
@@ -8565,7 +8810,7 @@ function readWorkspaceRuntimeConfig() {
 function inspectWorkspaceRuntimeConfig() {
   let rawText;
   try {
-    rawText = import_node_fs20.default.readFileSync(RUNTIME_CONFIG_FILE, "utf-8");
+    rawText = import_node_fs21.default.readFileSync(RUNTIME_CONFIG_FILE, "utf-8");
   } catch {
     return { exists: false, config: {}, problems: [] };
   }
@@ -8616,7 +8861,7 @@ function writeWorkspaceRuntimeConfig(config) {
     }
     next.devsyInactivityTimeout = timeout;
   }
-  import_node_fs20.default.mkdirSync(DEVROUTER_HOME, { recursive: true });
+  import_node_fs21.default.mkdirSync(DEVROUTER_HOME, { recursive: true });
   writeFileAtomically(RUNTIME_CONFIG_FILE, `${JSON.stringify(next, null, 2)}
 `);
 }
@@ -8724,20 +8969,20 @@ function resetWorkspaceRuntimeCaches() {
   cachedRuntime = void 0;
   cachedSnapshots = void 0;
 }
-var import_node_child_process10, import_node_fs20, import_node_path27, SUPPORTED_RUNTIMES2, RUNTIME_CONFIG_FILE, INACTIVITY_TIMEOUT_PATTERN, cachedRuntime, cachedSnapshots, UnsupportedWorkspaceRuntimeError, WorkspaceRuntimeOwnershipError;
+var import_node_child_process10, import_node_fs21, import_node_path28, SUPPORTED_RUNTIMES2, RUNTIME_CONFIG_FILE, INACTIVITY_TIMEOUT_PATTERN, cachedRuntime, cachedSnapshots, UnsupportedWorkspaceRuntimeError, WorkspaceRuntimeOwnershipError;
 var init_workspace_runtime = __esm({
   "src/core/workspace-runtime.ts"() {
     "use strict";
     import_node_child_process10 = require("child_process");
-    import_node_fs20 = __toESM(require("fs"));
-    import_node_path27 = __toESM(require("path"));
+    import_node_fs21 = __toESM(require("fs"));
+    import_node_path28 = __toESM(require("path"));
     init_atomic_file();
     init_devpod_registry();
     init_devsy_workspaces();
     init_router();
     init_workspace();
     SUPPORTED_RUNTIMES2 = ["devpod", "devsy"];
-    RUNTIME_CONFIG_FILE = import_node_path27.default.join(DEVROUTER_HOME, "workspace-runtime.json");
+    RUNTIME_CONFIG_FILE = import_node_path28.default.join(DEVROUTER_HOME, "workspace-runtime.json");
     INACTIVITY_TIMEOUT_PATTERN = /^(?:\d+(?:ms|s|m|h))+$/;
     UnsupportedWorkspaceRuntimeError = class extends Error {
     };
@@ -8864,7 +9109,7 @@ function resolveGitCommonDir(repoPath) {
   if (result.status !== 0 || !output2) {
     throw commandError("Could not resolve the Git common directory", repoPath, result.stderr);
   }
-  return comparableWorkspacePath(import_node_path28.default.isAbsolute(output2) ? output2 : import_node_path28.default.resolve(repoPath, output2));
+  return comparableWorkspacePath(import_node_path29.default.isAbsolute(output2) ? output2 : import_node_path29.default.resolve(repoPath, output2));
 }
 function resolveGitTopLevel(repoPath) {
   const result = (0, import_node_child_process12.spawnSync)("git", ["-C", repoPath, "rev-parse", "--show-toplevel"], {
@@ -8915,7 +9160,7 @@ function listGitWorktrees(repoPath) {
   return worktrees;
 }
 function ownershipDirectory(repoPath) {
-  return import_node_path28.default.join(resolveGitCommonDir(repoPath), OWNERSHIP_DIR);
+  return import_node_path29.default.join(resolveGitCommonDir(repoPath), OWNERSHIP_DIR);
 }
 function validateWorkspace(value, label2) {
   if (typeof value !== "string" || wsFromBranch(value) !== value) {
@@ -8943,7 +9188,7 @@ function validateRecord(value, expectedWorkspace) {
       `workspace ownership file '${expectedWorkspace}' contains identity '${workspace}'`
     );
   }
-  if (typeof candidate.worktreePath !== "string" || !import_node_path28.default.isAbsolute(candidate.worktreePath)) {
+  if (typeof candidate.worktreePath !== "string" || !import_node_path29.default.isAbsolute(candidate.worktreePath)) {
     throw new Error("invalid workspace ownership worktreePath");
   }
   if (candidate.branch !== null && typeof candidate.branch !== "string") {
@@ -8961,7 +9206,7 @@ function validateRecord(value, expectedWorkspace) {
   };
 }
 function recordPath(repoPath, workspace) {
-  return import_node_path28.default.join(
+  return import_node_path29.default.join(
     ownershipDirectory(repoPath),
     `${validateWorkspace(workspace, "workspace")}.json`
   );
@@ -8969,7 +9214,7 @@ function recordPath(repoPath, workspace) {
 function readRecordFile(filePath, expectedWorkspace) {
   let parsed;
   try {
-    parsed = JSON.parse(import_node_fs21.default.readFileSync(filePath, "utf-8"));
+    parsed = JSON.parse(import_node_fs22.default.readFileSync(filePath, "utf-8"));
   } catch (error) {
     if (error instanceof SyntaxError) {
       throw new Error(`invalid workspace ownership JSON at '${filePath}'`);
@@ -8994,7 +9239,7 @@ function listWorkspaceOwnership(repoPath) {
 function listWorkspaceOwnershipInDirectory(directory) {
   let entries;
   try {
-    entries = import_node_fs21.default.readdirSync(directory, { withFileTypes: true });
+    entries = import_node_fs22.default.readdirSync(directory, { withFileTypes: true });
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -9002,14 +9247,14 @@ function listWorkspaceOwnershipInDirectory(directory) {
   return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).sort((left, right) => left.name.localeCompare(right.name)).map((entry) => {
     const workspace = entry.name.slice(0, -".json".length);
     validateWorkspace(workspace, "filename");
-    return readRecordFile(import_node_path28.default.join(directory, entry.name), workspace);
+    return readRecordFile(import_node_path29.default.join(directory, entry.name), workspace);
   });
 }
 function writeWorkspaceOwnershipInDirectory(directory, input2) {
   const workspace = validateWorkspace(input2.workspace, "workspace");
   const devpodId = validateWorkspace(input2.devpodId, "devpodId");
   const worktreePath = comparableWorkspacePath(input2.worktreePath);
-  const filePath = import_node_path28.default.join(directory, `${workspace}.json`);
+  const filePath = import_node_path29.default.join(directory, `${workspace}.json`);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const records = listWorkspaceOwnershipInDirectory(directory);
   const existing = records.find((record6) => record6.workspace === workspace);
@@ -9045,9 +9290,9 @@ function writeWorkspaceOwnershipInDirectory(directory, input2) {
   return record5;
 }
 function removeWorkspaceOwnershipInDirectory(directory, workspace) {
-  const filePath = import_node_path28.default.join(directory, `${validateWorkspace(workspace, "workspace")}.json`);
+  const filePath = import_node_path29.default.join(directory, `${validateWorkspace(workspace, "workspace")}.json`);
   try {
-    import_node_fs21.default.rmSync(filePath);
+    import_node_fs22.default.rmSync(filePath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") return false;
@@ -9058,7 +9303,7 @@ function sameOwnershipRecord(left, right) {
   return left.version === right.version && left.workspace === right.workspace && sameWorkspacePath(left.worktreePath, right.worktreePath) && left.branch === right.branch && left.devpodId === right.devpodId && left.createdAt === right.createdAt && left.updatedAt === right.updatedAt;
 }
 function removeWorkspaceOwnershipIfMatchesInDirectory(directory, expected) {
-  const filePath = import_node_path28.default.join(
+  const filePath = import_node_path29.default.join(
     directory,
     `${validateWorkspace(expected.workspace, "workspace")}.json`
   );
@@ -9070,14 +9315,14 @@ function removeWorkspaceOwnershipIfMatchesInDirectory(directory, expected) {
     throw error;
   }
   if (!sameOwnershipRecord(current, expected)) return "changed";
-  import_node_fs21.default.rmSync(filePath);
+  import_node_fs22.default.rmSync(filePath);
   return "removed";
 }
 function withWorkspaceOwnershipTransaction(repoPath, operation, options = {}) {
   const directory = ownershipDirectory(repoPath);
-  import_node_fs21.default.mkdirSync(directory, { recursive: true });
+  import_node_fs22.default.mkdirSync(directory, { recursive: true });
   return withFileLockSync(
-    import_node_path28.default.join(directory, ".lock"),
+    import_node_path29.default.join(directory, ".lock"),
     {
       activity: "workspace ownership transaction",
       target: `'${repoPath}'`,
@@ -9110,7 +9355,7 @@ function persistedWorkspaceOwners(repoPath, worktreePath) {
     try {
       workspace = readPersistedWorkspace(worktree.path);
     } catch (error) {
-      if (!import_node_fs21.default.existsSync(worktree.path)) continue;
+      if (!import_node_fs22.default.existsSync(worktree.path)) continue;
       throw error;
     }
     if (!workspace) continue;
@@ -9273,7 +9518,7 @@ function inspectWorkspaceOwnership(record5, worktrees, devpods) {
   if (worktree?.locked) {
     return { ownerStatus: "locked", devpodStatus, worktree };
   }
-  if ((!worktree || worktree.prunable) && import_node_fs21.default.existsSync(record5.worktreePath)) {
+  if ((!worktree || worktree.prunable) && import_node_fs22.default.existsSync(record5.worktreePath)) {
     return { ownerStatus: "conflict", devpodStatus, worktree };
   }
   if (!worktree || worktree.prunable) {
@@ -9297,20 +9542,20 @@ function listMissingWorkspaceOwnership(repoPath) {
     (record5) => inspectWorkspaceOwnership(record5, worktrees, void 0).ownerStatus === "missing"
   );
 }
-var import_node_child_process12, import_node_fs21, import_node_path28, READ_ONLY_GIT_ENV, OWNERSHIP_VERSION, OWNERSHIP_DIR;
+var import_node_child_process12, import_node_fs22, import_node_path29, READ_ONLY_GIT_ENV, OWNERSHIP_VERSION, OWNERSHIP_DIR;
 var init_workspace_ownership = __esm({
   "src/core/workspace-ownership.ts"() {
     "use strict";
     import_node_child_process12 = require("child_process");
-    import_node_fs21 = __toESM(require("fs"));
-    import_node_path28 = __toESM(require("path"));
+    import_node_fs22 = __toESM(require("fs"));
+    import_node_path29 = __toESM(require("path"));
     init_atomic_file();
     init_devpod_workspaces();
     init_file_lock();
     init_workspace();
     READ_ONLY_GIT_ENV = { ...process.env, GIT_OPTIONAL_LOCKS: "0" };
     OWNERSHIP_VERSION = 1;
-    OWNERSHIP_DIR = import_node_path28.default.join("devrouter", "workspaces");
+    OWNERSHIP_DIR = import_node_path29.default.join("devrouter", "workspaces");
   }
 });
 
@@ -9559,12 +9804,12 @@ function managedStopRouteReferences(state) {
     (name) => ["http", "tcp"].map((protocol) => ({ repoPath: state.repoPath, name, protocol }))
   );
 }
-var import_node_os3, import_node_path29, import_node_util8;
+var import_node_os4, import_node_path30, import_node_util8;
 var init_managed_stop_recovery = __esm({
   "src/core/managed-stop-recovery.ts"() {
     "use strict";
-    import_node_os3 = __toESM(require("os"));
-    import_node_path29 = __toESM(require("path"));
+    import_node_os4 = __toESM(require("os"));
+    import_node_path30 = __toESM(require("path"));
     import_node_util8 = require("util");
     init_devpod_environment();
     init_devpod_registry();
@@ -9711,8 +9956,8 @@ function tlsSetupCommand(repoPath) {
 }
 function getMkcertRootCAPath(options = {}) {
   ensureMkcert();
-  const rootCAPath = import_node_path30.default.join(runOrThrow("mkcert", ["-CAROOT"]), "rootCA.pem");
-  if (!import_node_fs22.default.existsSync(rootCAPath)) {
+  const rootCAPath = import_node_path31.default.join(runOrThrow("mkcert", ["-CAROOT"]), "rootCA.pem");
+  if (!import_node_fs23.default.existsSync(rootCAPath)) {
     throw new Error(
       `mkcert root CA was not found at '${rootCAPath}'. Run: ${tlsSetupCommand(options.repoPath)}`
     );
@@ -9813,11 +10058,11 @@ function compactTLSCertificateHosts(hosts) {
   );
 }
 function readCurrentCertificateHosts(options = {}) {
-  if (!import_node_fs22.default.existsSync(CERT_FILE)) {
+  if (!import_node_fs23.default.existsSync(CERT_FILE)) {
     return [];
   }
   try {
-    const pem = import_node_fs22.default.readFileSync(CERT_FILE, "utf-8");
+    const pem = import_node_fs23.default.readFileSync(CERT_FILE, "utf-8");
     return parseCertificateDnsHosts(pem);
   } catch (error) {
     if (options.replaceMalformed) {
@@ -9945,20 +10190,20 @@ Run: ${tlsSetupCommand(options.repoPath)}`
     );
   }
 }
-var import_node_child_process14, import_node_crypto12, import_node_fs22, import_node_path30, DEFAULT_TLS_CERT_HOSTS, TLS_CERTIFICATE_LOCK_FILE, TLS_CERTIFICATE_LOCK_WAIT_MS, TLS_CERTIFICATE_WRITE_ATTEMPTS;
+var import_node_child_process14, import_node_crypto12, import_node_fs23, import_node_path31, DEFAULT_TLS_CERT_HOSTS, TLS_CERTIFICATE_LOCK_FILE, TLS_CERTIFICATE_LOCK_WAIT_MS, TLS_CERTIFICATE_WRITE_ATTEMPTS;
 var init_tls = __esm({
   "src/core/tls.ts"() {
     "use strict";
     import_node_child_process14 = require("child_process");
     import_node_crypto12 = require("crypto");
-    import_node_fs22 = __toESM(require("fs"));
-    import_node_path30 = __toESM(require("path"));
+    import_node_fs23 = __toESM(require("fs"));
+    import_node_path31 = __toESM(require("path"));
     init_docker();
     init_file_lock();
     init_host_routes();
     init_router();
     DEFAULT_TLS_CERT_HOSTS = ["localhost", "*.localhost"];
-    TLS_CERTIFICATE_LOCK_FILE = import_node_path30.default.join(DEVROUTER_HOME, "tls-certificate.lock");
+    TLS_CERTIFICATE_LOCK_FILE = import_node_path31.default.join(DEVROUTER_HOME, "tls-certificate.lock");
     TLS_CERTIFICATE_LOCK_WAIT_MS = 6e4;
     TLS_CERTIFICATE_WRITE_ATTEMPTS = 2;
   }
@@ -10039,6 +10284,174 @@ var init_route_publication = __esm({
   }
 });
 
+// src/core/traefik-route-health.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function inspectRouterApi(protocol) {
+  const result = (0, import_node_child_process15.spawnSync)(
+    "curl",
+    [
+      "--silent",
+      "--show-error",
+      "--fail",
+      "--max-time",
+      ROUTER_API_REQUEST_TIMEOUT_SECONDS,
+      `${ROUTER_API_BASE}/${protocol}/routers?per_page=${ROUTER_API_PAGE_SIZE}`
+    ],
+    { encoding: "utf-8" }
+  );
+  if (result.status !== 0) {
+    return {
+      ok: false,
+      details: result.stderr?.trim() || `curl exited with status ${result.status ?? "unknown"}`
+    };
+  }
+  let value;
+  try {
+    value = JSON.parse(result.stdout);
+  } catch {
+    return { ok: false, details: `${protocol.toUpperCase()} router API returned invalid JSON` };
+  }
+  if (!Array.isArray(value)) {
+    return { ok: false, details: `${protocol.toUpperCase()} router API returned a non-array` };
+  }
+  if (value.some((item) => !isRecord5(item) || typeof item.name !== "string" || !item.name))
+    return {
+      ok: false,
+      details: `${protocol.toUpperCase()} router API returned malformed entries`
+    };
+  return {
+    ok: true,
+    reachedPageLimit: value.length >= ROUTER_API_PAGE_SIZE,
+    names: new Set(
+      value.flatMap((item) => {
+        if (!item || typeof item !== "object") return [];
+        const name = item.name;
+        return typeof name === "string" ? [name] : [];
+      })
+    )
+  };
+}
+function isRecord5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function inspectExpectedRoutes(routes, expectation) {
+  const mismatched = [];
+  const failures = [];
+  for (const protocol of ["http", "tcp"]) {
+    const expected = routes.filter((route) => (route.protocol ?? "http") === protocol).map((route) => buildHostRouteRouterName(route.repoPath, route.name));
+    if (expected.length === 0) continue;
+    const result = inspectRouterApi(protocol);
+    if (!result.ok) {
+      failures.push(result.details);
+      mismatched.push(...expected);
+      continue;
+    }
+    const unexpected = expected.filter(
+      (name) => expectation === "loaded" ? !result.names.has(name) : result.names.has(name)
+    );
+    const boundedAbsenceIsUncertain = result.reachedPageLimit && (expectation === "loaded" ? unexpected.length > 0 : unexpected.length === 0);
+    if (boundedAbsenceIsUncertain) {
+      failures.push(
+        `${protocol.toUpperCase()} router API reached the ${ROUTER_API_PAGE_SIZE}-entry safety limit`
+      );
+    }
+    mismatched.push(...unexpected);
+    if (expectation === "removed" && unexpected.length === 0 && result.reachedPageLimit) {
+      mismatched.push(...expected);
+    }
+  }
+  return mismatched.length === 0 ? { ok: true } : {
+    ok: false,
+    routes: mismatched,
+    details: failures.length > 0 ? failures.join("; ") : expectation === "loaded" ? "router names are absent" : "router names are still present"
+  };
+}
+async function waitForExpectedRoutes(routes, expectation, timeoutMs, pollIntervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  let result;
+  do {
+    result = inspectExpectedRoutes(routes, expectation);
+    if (result.ok) return result;
+    if (Date.now() < deadline) {
+      await sleep(Math.min(pollIntervalMs, Math.max(1, deadline - Date.now())));
+    }
+  } while (Date.now() < deadline);
+  return result;
+}
+async function ensureTraefikRouteExpectation(routes, expectation, options) {
+  if (routes.length === 0) return { restarted: false };
+  const initialTimeoutMs = options.initialTimeoutMs ?? DEFAULT_INITIAL_TIMEOUT_MS;
+  const recoveryTimeoutMs = options.recoveryTimeoutMs ?? DEFAULT_RECOVERY_TIMEOUT_MS;
+  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const initial = await waitForExpectedRoutes(
+    routes,
+    expectation,
+    initialTimeoutMs,
+    pollIntervalMs
+  );
+  if (initial.ok) return { restarted: false };
+  if (options.allowRestart === false)
+    throw new Error(
+      "Traefik routes did not reload; shared router restart is disabled for this operation."
+    );
+  import_node_fs24.default.mkdirSync(DEVROUTER_HOME, { recursive: true });
+  return withFileLock(
+    ROUTER_RELOAD_LOCK_FILE,
+    {
+      activity: "Traefik route reload recovery",
+      waitMs: initialTimeoutMs + recoveryTimeoutMs + 1e4,
+      fair: true,
+      onWait: createStderrWaitReporter("Traefik route reload recovery", "shared router")
+    },
+    async () => {
+      const recheck = await waitForExpectedRoutes(routes, expectation, 0, pollIntervalMs);
+      if (recheck.ok) return { restarted: false };
+      claimLifecycleEffect();
+      restartRouterStack();
+      const recovered = await waitForExpectedRoutes(
+        routes,
+        expectation,
+        recoveryTimeoutMs,
+        pollIntervalMs
+      );
+      if (recovered.ok) return { restarted: true };
+      const action2 = expectation === "loaded" ? "load" : "remove";
+      throw new Error(
+        `Traefik did not ${action2} file-provider routes after one restart: ${recovered.routes.join(", ")} (${recovered.details}). Inspect: devrouter logs --tail 100`
+      );
+    }
+  );
+}
+async function ensureTraefikRoutesRemoved(routes, options = {}) {
+  return ensureTraefikRouteExpectation(routes, "removed", options);
+}
+function assertTraefikRoutesRemoved(routes) {
+  const result = inspectExpectedRoutes(routes, "removed");
+  if (!result.ok) throw new Error(`Workspace route cessation is not proven: ${result.details}`);
+}
+var import_node_child_process15, import_node_fs24, import_node_path32, ROUTER_API_BASE, ROUTER_RELOAD_LOCK_FILE, ROUTER_API_REQUEST_TIMEOUT_SECONDS, DEFAULT_INITIAL_TIMEOUT_MS, DEFAULT_RECOVERY_TIMEOUT_MS, DEFAULT_POLL_INTERVAL_MS, ROUTER_API_PAGE_SIZE;
+var init_traefik_route_health = __esm({
+  "src/core/traefik-route-health.ts"() {
+    "use strict";
+    import_node_child_process15 = require("child_process");
+    import_node_fs24 = __toESM(require("fs"));
+    import_node_path32 = __toESM(require("path"));
+    init_file_lock();
+    init_host_routes();
+    init_reliability_context();
+    init_router();
+    ROUTER_API_BASE = "http://127.0.0.1:8080/api";
+    ROUTER_RELOAD_LOCK_FILE = import_node_path32.default.join(DEVROUTER_HOME, "router-reload.lock");
+    ROUTER_API_REQUEST_TIMEOUT_SECONDS = "2";
+    DEFAULT_INITIAL_TIMEOUT_MS = 3e3;
+    DEFAULT_RECOVERY_TIMEOUT_MS = 1e4;
+    DEFAULT_POLL_INTERVAL_MS = 250;
+    ROUTER_API_PAGE_SIZE = 1e3;
+  }
+});
+
 // src/core/managed-devsy-stop.ts
 function sameSet(left, right) {
   return JSON.stringify([...left].sort()) === JSON.stringify([...right].sort());
@@ -10051,12 +10464,75 @@ function containerIdentity(container) {
     mounts: container.mounts.map((mount) => JSON.stringify(mount)).sort()
   });
 }
-function stopInitialManagedDevsyWorkspace(repoPath, devsyId) {
-  if (!import_node_fs23.default.existsSync(import_node_path31.default.join(repoPath, ".devrouter.yml"))) return false;
-  const linked = isLinkedWorktree(repoPath);
-  const workspace = linked ? resolveWorktreeWorkspace(repoPath) : void 0;
-  const registration2 = () => {
-    resetWorkspaceRuntimeCaches();
+function proveInitialManagedDevsyAbsence(repoPath, expectedId) {
+  if (!isLinkedWorktree(repoPath)) return void 0;
+  const workspace = resolveWorktreeWorkspace(repoPath);
+  if (!workspace || readManagedRuntimeState(repoPath, workspace)) return void 0;
+  if (!import_node_fs25.default.existsSync(import_node_path33.default.join(repoPath, ".devrouter.yml"))) return void 0;
+  const runtime = loadRuntimeConfig(repoPath, workspace);
+  if (!runtime.config.managedRuntime) return void 0;
+  const routes = proxyAppsFromConfig(runtime.config).flatMap(
+    (app) => ["http", "tcp"].map((protocol) => ({ repoPath, name: app.name, protocol }))
+  );
+  const record5 = readWorkspaceOwnership(repoPath, workspace);
+  if (!record5 || expectedId !== void 0 && record5.devpodId !== expectedId || record5.workspace !== workspace || !sameWorkspacePath(record5.worktreePath, repoPath))
+    throw new Error("Initial managed stop requires exact linked ownership.");
+  const devsyId = record5.devpodId;
+  const ownership = inspectDevsyWorkspaceOwnership(listDevsyWorkspaces(), devsyId, repoPath);
+  if (ownership.status === "conflict") throw new Error(ownership.reason);
+  if (ownership.status !== "absent") return void 0;
+  const gitCommonDir = resolveGitCommonDir(repoPath);
+  const endpoint = resolveManagedStopEndpoint();
+  if (!supportsManagedStopBaseline(endpoint))
+    throw new Error("Initial managed stop requires a local Docker endpoint.");
+  const daemon = inspectManagedStopDaemon(endpoint);
+  const legacyHome = devpodRegistryRoot();
+  const readLegacy = () => listDevpodWorkspacesRaw({ readLocalWhenMissing: true }).map(({ id: id5, source }) => ({ id: id5, source: { localFolder: source.localFolder } })).sort(
+    (a, b) => a.id.localeCompare(b.id) || a.source.localFolder.localeCompare(b.source.localFolder)
+  );
+  const legacyWorkspaces = readLegacy();
+  const observe = () => {
+    resetWorkspaceRuntimeCaches();
+    if (resolveWorkspaceRuntimeOrDefault(repoPath) !== "devsy" || !isLinkedWorktree(repoPath) || resolveWorktreeWorkspace(repoPath) !== workspace || resolveGitCommonDir(repoPath) !== gitCommonDir || !(0, import_node_util9.isDeepStrictEqual)(readWorkspaceOwnership(repoPath, workspace), record5) || inspectWorkspaceOwnership(record5, listGitWorktrees(repoPath), void 0).ownerStatus !== "present" || readManagedRuntimeState(repoPath, workspace))
+      throw new Error("Initial managed stop ownership or retained state changed.");
+    if (devpodRegistryRoot() !== legacyHome || !(0, import_node_util9.isDeepStrictEqual)(readLegacy(), legacyWorkspaces))
+      throw new Error("Initial managed stop legacy registry evidence changed.");
+    if (inspectDevsyWorkspaceOwnership(listDevsyWorkspaces(), devsyId, repoPath).status !== "absent" || legacyWorkspaces.some(
+      (entry) => entry.id === devsyId || entry.source.localFolder !== "" && sameWorkspacePath(entry.source.localFolder, repoPath)
+    ))
+      throw new Error("Initial managed stop requires both provider registrations absent.");
+    if (!inspectDevsyRuntimeAbsence(devsyId))
+      throw new Error("Initial managed stop requires positive runtime not-found.");
+    if (resolveManagedStopEndpoint() !== endpoint || inspectManagedStopDaemon(endpoint) !== daemon)
+      throw new Error("Initial managed stop Docker identity changed.");
+    if (inspectProviderRunnerContainers(endpoint, devsyId).length)
+      throw new Error("Initial managed stop observed a remaining provider runner.");
+    assertManagedStopCheckoutAbsent(endpoint, repoPath);
+    if (listHostRouteState().some((route) => sameWorkspacePath(route.repoPath, repoPath)))
+      throw new Error("Initial managed stop observed remaining workspace routes.");
+    assertTraefikRoutesRemoved(routes);
+    if (resolveManagedStopEndpoint() !== endpoint || inspectManagedStopDaemon(endpoint) !== daemon)
+      throw new Error("Initial managed stop Docker identity changed.");
+  };
+  observe();
+  observe();
+  return {
+    workspace,
+    record: record5,
+    gitCommonDir,
+    endpoint,
+    daemon,
+    routes,
+    legacyHome,
+    legacyWorkspaces
+  };
+}
+function stopInitialManagedDevsyWorkspace(repoPath, devsyId) {
+  if (!import_node_fs25.default.existsSync(import_node_path33.default.join(repoPath, ".devrouter.yml"))) return false;
+  const linked = isLinkedWorktree(repoPath);
+  const workspace = linked ? resolveWorktreeWorkspace(repoPath) : void 0;
+  const registration2 = () => {
+    resetWorkspaceRuntimeCaches();
     if (resolveWorkspaceRuntimeOrDefault(repoPath) !== "devsy")
       throw new Error("Initial managed stop provider selection changed.");
     const owner2 = inspectDevsyWorkspaceOwnership(listDevsyWorkspaces(), devsyId, repoPath);
@@ -10080,8 +10556,8 @@ function stopInitialManagedDevsyWorkspace(repoPath, devsyId) {
     profile: runtime.resolvedProfile,
     linked
   });
-  const providerRoot = import_node_path31.default.resolve(process.env.DEVSY_HOME || import_node_path31.default.join(import_node_os4.default.homedir(), ".devsy"));
-  const featureDirectory = import_node_path31.default.join(
+  const providerRoot = import_node_path33.default.resolve(process.env.DEVSY_HOME || import_node_path33.default.join(import_node_os5.default.homedir(), ".devsy"));
+  const featureDirectory = import_node_path33.default.join(
     providerRoot,
     "contexts",
     owner.context,
@@ -10152,7 +10628,10 @@ function stopRetainedManagedDevsyWorkspace(options) {
   const linked = isLinkedWorktree(repoPath);
   const workspace = linked ? resolveWorktreeWorkspace(repoPath) : void 0;
   const retainedState = readManagedRuntimeState(repoPath, workspace);
-  if (!retainedState) return stopInitialManagedDevsyWorkspace(repoPath, devsyId);
+  if (!retainedState) {
+    if (proveInitialManagedDevsyAbsence(repoPath, devsyId)) return "proven-absent";
+    return stopInitialManagedDevsyWorkspace(repoPath, devsyId);
+  }
   const state = retainedState;
   if (state.devpodId !== devsyId || linked && !workspace) {
     throw new Error("Managed stop requires the exact retained workspace identity.");
@@ -10213,7 +10692,7 @@ function stopRetainedManagedDevsyWorkspace(options) {
       const owned = inspectWorkspaceContainers().filter(
         (container) => sameWorkspacePath(
           container.labels["com.docker.compose.project.working_dir"] ?? "",
-          import_node_path31.default.join(repoPath, ".devcontainer")
+          import_node_path33.default.join(repoPath, ".devcontainer")
         )
       );
       if (owned.length !== 0) {
@@ -10242,8 +10721,8 @@ function stopRetainedManagedDevsyWorkspace(options) {
   if (!context || !/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(context) || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/.test(devsyId)) {
     throw new Error("Managed stop requires a valid exact Devsy context and workspace ID.");
   }
-  const devsyRoot = import_node_path31.default.resolve(process.env.DEVSY_HOME || import_node_path31.default.join(import_node_os4.default.homedir(), ".devsy"));
-  const featureDirectory = import_node_path31.default.join(
+  const devsyRoot = import_node_path33.default.resolve(process.env.DEVSY_HOME || import_node_path33.default.join(import_node_os5.default.homedir(), ".devsy"));
+  const featureDirectory = import_node_path33.default.join(
     devsyRoot,
     "contexts",
     context,
@@ -10347,23 +10826,25 @@ function stopRetainedManagedDevsyWorkspace(options) {
   if (providerFailed) throw providerError;
   return true;
 }
-var import_node_fs23, import_node_os4, import_node_path31, import_node_util9;
+var import_node_fs25, import_node_os5, import_node_path33, import_node_util9;
 var init_managed_devsy_stop = __esm({
   "src/core/managed-devsy-stop.ts"() {
     "use strict";
-    import_node_fs23 = __toESM(require("fs"));
-    import_node_os4 = __toESM(require("os"));
-    import_node_path31 = __toESM(require("path"));
+    import_node_fs25 = __toESM(require("fs"));
+    import_node_os5 = __toESM(require("os"));
+    import_node_path33 = __toESM(require("path"));
     import_node_util9 = require("util");
     init_devcontainer_profile();
     init_devpod_environment();
     init_devpod_registry();
     init_devsy_workspaces();
+    init_host_routes();
     init_managed_compose_population();
     init_managed_runtime_state();
     init_managed_stop_recovery();
     init_repo_config();
     init_route_publication();
+    init_traefik_route_health();
     init_workspace();
     init_workspace_ownership();
     init_workspace_runtime();
@@ -10909,7 +11390,7 @@ function hasControlCharacter2(value) {
 function readPolicyFile(filePath) {
   let initialStats;
   try {
-    initialStats = import_node_fs24.default.lstatSync(filePath);
+    initialStats = import_node_fs26.default.lstatSync(filePath);
   } catch (error) {
     if (isErrno(error, "ENOENT")) return { status: "absent" };
     return { status: "invalid", error: "network policy could not be read" };
@@ -10922,16 +11403,16 @@ function readPolicyFile(filePath) {
   }
   let fileDescriptor;
   try {
-    fileDescriptor = import_node_fs24.default.openSync(
+    fileDescriptor = import_node_fs26.default.openSync(
       filePath,
-      import_node_fs24.default.constants.O_RDONLY | import_node_fs24.default.constants.O_NONBLOCK | (import_node_fs24.default.constants.O_NOFOLLOW ?? 0)
+      import_node_fs26.default.constants.O_RDONLY | import_node_fs26.default.constants.O_NONBLOCK | (import_node_fs26.default.constants.O_NOFOLLOW ?? 0)
     );
   } catch (error) {
     if (isErrno(error, "ENOENT")) return { status: "absent" };
     return { status: "invalid", error: "network policy could not be read" };
   }
   try {
-    const openedStats = import_node_fs24.default.fstatSync(fileDescriptor);
+    const openedStats = import_node_fs26.default.fstatSync(fileDescriptor);
     if (!openedStats.isFile()) {
       return { status: "invalid", error: "network policy must be a regular file" };
     }
@@ -10944,12 +11425,12 @@ function readPolicyFile(filePath) {
     const buffer = Buffer.alloc(openedStats.size);
     let offset = 0;
     while (offset < buffer.length) {
-      const bytesRead = import_node_fs24.default.readSync(fileDescriptor, buffer, offset, buffer.length - offset, null);
+      const bytesRead = import_node_fs26.default.readSync(fileDescriptor, buffer, offset, buffer.length - offset, null);
       if (bytesRead === 0)
         return { status: "invalid", error: "network policy changed during read" };
       offset += bytesRead;
     }
-    const finalStats = import_node_fs24.default.fstatSync(fileDescriptor);
+    const finalStats = import_node_fs26.default.fstatSync(fileDescriptor);
     if (!finalStats.isFile() || finalStats.size !== openedStats.size) {
       return { status: "invalid", error: "network policy changed during read" };
     }
@@ -10958,7 +11439,7 @@ function readPolicyFile(filePath) {
     return { status: "invalid", error: "network policy could not be read" };
   } finally {
     try {
-      import_node_fs24.default.closeSync(fileDescriptor);
+      import_node_fs26.default.closeSync(fileDescriptor);
     } catch {
     }
   }
@@ -10975,16 +11456,16 @@ function assertDisjoint(cidrs, message) {
 function isErrno(error, code) {
   return typeof error === "object" && error !== null && "code" in error && error.code === code;
 }
-var import_node_fs24, import_node_path32, NETWORK_POLICY_VERSION, NETWORK_POLICY_FILE, DEFAULT_NETWORK_POLICY_ENDPOINT_RESERVE, NETWORK_POLICY_PREFIX_LENGTHS, MAX_NETWORK_POLICY_FILE_BYTES, MAX_NETWORK_POLICY_ARRAY_ENTRIES, MAX_NETWORK_POLICY_DAEMON_ID_LENGTH, NetworkPolicyValidationError, NETWORK_POLICY_KEYS, PRIVATE_IPV4_RANGES;
+var import_node_fs26, import_node_path34, NETWORK_POLICY_VERSION, NETWORK_POLICY_FILE, DEFAULT_NETWORK_POLICY_ENDPOINT_RESERVE, NETWORK_POLICY_PREFIX_LENGTHS, MAX_NETWORK_POLICY_FILE_BYTES, MAX_NETWORK_POLICY_ARRAY_ENTRIES, MAX_NETWORK_POLICY_DAEMON_ID_LENGTH, NetworkPolicyValidationError, NETWORK_POLICY_KEYS, PRIVATE_IPV4_RANGES;
 var init_network_policy = __esm({
   "src/core/network-policy.ts"() {
     "use strict";
-    import_node_fs24 = __toESM(require("fs"));
-    import_node_path32 = __toESM(require("path"));
+    import_node_fs26 = __toESM(require("fs"));
+    import_node_path34 = __toESM(require("path"));
     init_network_capacity();
     init_router();
     NETWORK_POLICY_VERSION = 1;
-    NETWORK_POLICY_FILE = import_node_path32.default.join(DEVROUTER_HOME, "network-policy.json");
+    NETWORK_POLICY_FILE = import_node_path34.default.join(DEVROUTER_HOME, "network-policy.json");
     DEFAULT_NETWORK_POLICY_ENDPOINT_RESERVE = 8;
     NETWORK_POLICY_PREFIX_LENGTHS = [24, 25, 26];
     MAX_NETWORK_POLICY_FILE_BYTES = 64 * 1024;
@@ -11085,27 +11566,27 @@ function assertExactKeys(value, keys2) {
 function readDocument(store) {
   let descriptor;
   try {
-    descriptor = import_node_fs25.default.openSync(
+    descriptor = import_node_fs27.default.openSync(
       store.filePath,
-      import_node_fs25.default.constants.O_RDONLY | import_node_fs25.default.constants.O_NONBLOCK | (import_node_fs25.default.constants.O_NOFOLLOW ?? 0)
+      import_node_fs27.default.constants.O_RDONLY | import_node_fs27.default.constants.O_NONBLOCK | (import_node_fs27.default.constants.O_NOFOLLOW ?? 0)
     );
   } catch (error) {
     if (isErrno2(error, "ENOENT")) return void 0;
     throw claimError("invalid-state", "network claim state could not be read");
   }
   try {
-    const stat = import_node_fs25.default.fstatSync(descriptor);
+    const stat = import_node_fs27.default.fstatSync(descriptor);
     if (!stat.isFile() || stat.size > NETWORK_CLAIMS_MAX_FILE_BYTES || (stat.mode & 63) !== 0) {
       throw claimError("invalid-state", "network claim state is not a bounded private file");
     }
     const buffer = Buffer.alloc(NETWORK_CLAIMS_MAX_FILE_BYTES + 1);
     let count = 0;
     while (count < buffer.length) {
-      const bytesRead = import_node_fs25.default.readSync(descriptor, buffer, count, buffer.length - count, null);
+      const bytesRead = import_node_fs27.default.readSync(descriptor, buffer, count, buffer.length - count, null);
       if (bytesRead === 0) break;
       count += bytesRead;
     }
-    const finalStat = import_node_fs25.default.fstatSync(descriptor);
+    const finalStat = import_node_fs27.default.fstatSync(descriptor);
     if (count > NETWORK_CLAIMS_MAX_FILE_BYTES || finalStat.size !== stat.size) {
       throw claimError("invalid-state", "network claim state changed during read");
     }
@@ -11117,7 +11598,7 @@ function readDocument(store) {
     }
     return validateDocument(parsed, store.daemonId);
   } finally {
-    import_node_fs25.default.closeSync(descriptor);
+    import_node_fs27.default.closeSync(descriptor);
   }
 }
 function validateDocument(value, daemonId) {
@@ -11184,16 +11665,16 @@ function createStore(daemonId, options) {
   return {
     root,
     daemonId,
-    filePath: import_node_path33.default.join(root, `${key}.json`),
-    lockPath: import_node_path33.default.join(root, `${key}.lock`),
+    filePath: import_node_path35.default.join(root, `${key}.json`),
+    lockPath: import_node_path35.default.join(root, `${key}.lock`),
     writeAtomic: options.writeAtomic ?? writeFileAtomically
   };
 }
 function validateRoot(root) {
-  if (typeof root !== "string" || !import_node_path33.default.isAbsolute(root) || root.includes("\0")) {
+  if (typeof root !== "string" || !import_node_path35.default.isAbsolute(root) || root.includes("\0")) {
     throw claimError("invalid-input", "network claim root is invalid");
   }
-  const resolved = import_node_path33.default.resolve(root);
+  const resolved = import_node_path35.default.resolve(root);
   if (resolved !== root) throw claimError("invalid-input", "network claim root is invalid");
   return resolved;
 }
@@ -11221,20 +11702,20 @@ function isErrno2(error, code) {
 function claimError(code, message) {
   return new NetworkClaimError(code, message);
 }
-var import_node_crypto13, import_node_fs25, import_node_path33, NETWORK_CLAIMS_VERSION, NETWORK_CLAIMS_ROOT, NETWORK_CLAIMS_MAX_RECORDS, NETWORK_CLAIMS_MAX_FILE_BYTES, NetworkClaimError, CLAIM_CORE_KEYS, CLAIM_KEYS, FENCE_KEYS, DOCUMENT_KEYS, MAX_CLAIM_TEXT, MAX_ENDPOINT_TEXT;
+var import_node_crypto13, import_node_fs27, import_node_path35, NETWORK_CLAIMS_VERSION, NETWORK_CLAIMS_ROOT, NETWORK_CLAIMS_MAX_RECORDS, NETWORK_CLAIMS_MAX_FILE_BYTES, NetworkClaimError, CLAIM_CORE_KEYS, CLAIM_KEYS, FENCE_KEYS, DOCUMENT_KEYS, MAX_CLAIM_TEXT, MAX_ENDPOINT_TEXT;
 var init_network_claims = __esm({
   "src/core/network-claims.ts"() {
     "use strict";
     import_node_crypto13 = require("crypto");
-    import_node_fs25 = __toESM(require("fs"));
-    import_node_path33 = __toESM(require("path"));
+    import_node_fs27 = __toESM(require("fs"));
+    import_node_path35 = __toESM(require("path"));
     init_atomic_file();
     init_file_lock();
     init_network_capacity();
     init_network_policy();
     init_router();
     NETWORK_CLAIMS_VERSION = 1;
-    NETWORK_CLAIMS_ROOT = import_node_path33.default.join(DEVROUTER_HOME, "networks");
+    NETWORK_CLAIMS_ROOT = import_node_path35.default.join(DEVROUTER_HOME, "networks");
     NETWORK_CLAIMS_MAX_RECORDS = 256;
     NETWORK_CLAIMS_MAX_FILE_BYTES = 512 * 1024;
     NetworkClaimError = class extends Error {
@@ -11276,14 +11757,14 @@ var init_network_claims = __esm({
 
 // src/core/network-claim-lookup.ts
 function networkOwnerKey(repoPath) {
-  if (!import_node_path34.default.isAbsolute(repoPath) || import_node_path34.default.resolve(repoPath) !== repoPath)
+  if (!import_node_path36.default.isAbsolute(repoPath) || import_node_path36.default.resolve(repoPath) !== repoPath)
     throw new Error("Invalid network owner path.");
   return (0, import_node_crypto14.createHash)("sha256").update(repoPath).digest("hex");
 }
 function findOwnedNetworkClaim(repoPath, root = NETWORK_CLAIMS_ROOT) {
   let names;
   try {
-    names = import_node_fs26.default.readdirSync(root);
+    names = import_node_fs28.default.readdirSync(root);
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw new Error("Network claims cannot be inspected; repair is required.");
@@ -11292,21 +11773,21 @@ function findOwnedNetworkClaim(repoPath, root = NETWORK_CLAIMS_ROOT) {
   if (files.length > 128) throw new Error("Network daemon inventory exceeds its bound.");
   let found;
   for (const file of files) {
-    const full = import_node_path34.default.join(root, file);
-    const stat = import_node_fs26.default.lstatSync(full);
+    const full = import_node_path36.default.join(root, file);
+    const stat = import_node_fs28.default.lstatSync(full);
     if (!stat.isFile() || stat.size > NETWORK_CLAIMS_MAX_FILE_BYTES)
       throw new Error("Invalid retained network claim file.");
     let value;
-    const descriptor = import_node_fs26.default.openSync(
+    const descriptor = import_node_fs28.default.openSync(
       full,
-      import_node_fs26.default.constants.O_RDONLY | import_node_fs26.default.constants.O_NONBLOCK | import_node_fs26.default.constants.O_NOFOLLOW
+      import_node_fs28.default.constants.O_RDONLY | import_node_fs28.default.constants.O_NONBLOCK | import_node_fs28.default.constants.O_NOFOLLOW
     );
     try {
-      if (!import_node_fs26.default.fstatSync(descriptor).isFile()) throw new Error();
+      if (!import_node_fs28.default.fstatSync(descriptor).isFile()) throw new Error();
       const bytes2 = Buffer.alloc(NETWORK_CLAIMS_MAX_FILE_BYTES + 1);
       let size = 0;
       while (size < bytes2.length) {
-        const count = import_node_fs26.default.readSync(descriptor, bytes2, size, bytes2.length - size, null);
+        const count = import_node_fs28.default.readSync(descriptor, bytes2, size, bytes2.length - size, null);
         if (!count) break;
         size += count;
       }
@@ -11316,7 +11797,7 @@ function findOwnedNetworkClaim(repoPath, root = NETWORK_CLAIMS_ROOT) {
     } catch {
       throw new Error("Retained network claim could not be read safely.");
     } finally {
-      import_node_fs26.default.closeSync(descriptor);
+      import_node_fs28.default.closeSync(descriptor);
     }
     if (typeof value.daemonId !== "string" || `${(0, import_node_crypto14.createHash)("sha256").update(value.daemonId).digest("hex")}.json` !== file)
       throw new Error("Retained network daemon identity is invalid.");
@@ -11332,13 +11813,13 @@ function findOwnedNetworkClaim(repoPath, root = NETWORK_CLAIMS_ROOT) {
   }
   return found;
 }
-var import_node_crypto14, import_node_fs26, import_node_path34;
+var import_node_crypto14, import_node_fs28, import_node_path36;
 var init_network_claim_lookup = __esm({
   "src/core/network-claim-lookup.ts"() {
     "use strict";
     import_node_crypto14 = require("crypto");
-    import_node_fs26 = __toESM(require("fs"));
-    import_node_path34 = __toESM(require("path"));
+    import_node_fs28 = __toESM(require("fs"));
+    import_node_path36 = __toESM(require("path"));
     init_network_claims();
   }
 });
@@ -11366,7 +11847,7 @@ function qualifyNetworkProviderDefinition(value, provider) {
   return (0, import_node_crypto15.createHash)("sha256").update(JSON.stringify({ name: definition.name, agent, options, exec })).digest("hex");
 }
 function read(provider, args) {
-  const result = (0, import_node_child_process15.spawnSync)(provider, args, {
+  const result = (0, import_node_child_process16.spawnSync)(provider, args, {
     encoding: "utf8",
     timeout: 5e3,
     maxBuffer: 2 * 1024 * 1024
@@ -11454,11 +11935,11 @@ function inspectNetworkProviderBinding(input2) {
     );
   }
 }
-var import_node_child_process15, import_node_crypto15;
+var import_node_child_process16, import_node_crypto15;
 var init_network_provider_inspect = __esm({
   "src/core/network-provider-inspect.ts"() {
     "use strict";
-    import_node_child_process15 = require("child_process");
+    import_node_child_process16 = require("child_process");
     import_node_crypto15 = require("crypto");
     init_devpod_environment();
   }
@@ -11497,7 +11978,7 @@ var init_network_provider_effect = __esm({
 
 // src/core/devsy-mutation.ts
 function withMutationLock(activity, target, operation) {
-  import_node_fs27.default.mkdirSync(DEVROUTER_HOME, { recursive: true });
+  import_node_fs29.default.mkdirSync(DEVROUTER_HOME, { recursive: true });
   return withFileLockSync(
     DEVSY_MUTATION_LOCK_FILE,
     {
@@ -11517,7 +11998,7 @@ function runDevsyAction(action2, devsyId, force = false, repoPath) {
   const args = action2 === "delete" ? ["delete", devsyId, ...force ? ["--force"] : [], "--ignore-not-found"] : ["stop", devsyId];
   claimLifecycleEffect();
   const binding = repoPath ? networkProviderEffectOptions("devsy", devsyId, repoPath) : { args: [] };
-  const result = (0, import_node_child_process16.spawnSync)("devsy", ["workspace", ...args, ...binding.args], {
+  const result = (0, import_node_child_process17.spawnSync)("devsy", ["workspace", ...args, ...binding.args], {
     encoding: "utf-8",
     ...binding.env ? { env: binding.env } : {}
   });
@@ -11578,13 +12059,13 @@ function stopOwnedDevsyWorkspace(devsyId, worktreePath) {
 function deleteOwnedDevsyWorkspace(devsyId, worktreePath) {
   return mutateOwnedDevsyWorkspace("delete", devsyId, worktreePath);
 }
-var import_node_child_process16, import_node_fs27, import_node_path35, DEVSY_MUTATION_LOCK_FILE, DEVSY_MUTATION_WAIT_MS;
+var import_node_child_process17, import_node_fs29, import_node_path37, DEVSY_MUTATION_LOCK_FILE, DEVSY_MUTATION_WAIT_MS;
 var init_devsy_mutation = __esm({
   "src/core/devsy-mutation.ts"() {
     "use strict";
-    import_node_child_process16 = require("child_process");
-    import_node_fs27 = __toESM(require("fs"));
-    import_node_path35 = __toESM(require("path"));
+    import_node_child_process17 = require("child_process");
+    import_node_fs29 = __toESM(require("fs"));
+    import_node_path37 = __toESM(require("path"));
     init_devsy_agent();
     init_devsy_workspaces();
     init_file_lock();
@@ -11593,7 +12074,7 @@ var init_devsy_mutation = __esm({
     init_network_provider_effect();
     init_reliability_context();
     init_router();
-    DEVSY_MUTATION_LOCK_FILE = import_node_path35.default.join(DEVROUTER_HOME, "devsy-mutation.lock");
+    DEVSY_MUTATION_LOCK_FILE = import_node_path37.default.join(DEVROUTER_HOME, "devsy-mutation.lock");
     DEVSY_MUTATION_WAIT_MS = 18e5;
   }
 });
@@ -12138,14 +12619,16 @@ function handleRecover(state, event) {
   if (state.executionPolicy === "manual" || state.desired !== "running")
     return unchanged(state, "blocked");
   if (possibleDispatch(state.operation)) return unchanged(state, "blocked");
+  const stranded = state.operation?.drained === true && ["NOT_STARTED", "NOT_LAUNCHED"].includes(state.operation.status);
+  const operation = stranded ? null : state.operation;
   if (state.incident !== null && state.incident.id !== event.incidentId) {
     return unchanged(state, "conflict");
   }
   if (state.incident !== null) {
-    if (state.operation && pendingCommand(state.operation)) {
-      return state.operation.id === event.operationId && state.phase === "recovering" ? unchanged(state, "joined") : unchanged(state, "conflict");
+    if (operation && pendingCommand(operation)) {
+      return operation.id === event.operationId && state.phase === "recovering" ? unchanged(state, "joined") : unchanged(state, "conflict");
     }
-    if (state.operation?.id === event.operationId && state.operation.status === "COMPLETED") {
+    if (operation?.id === event.operationId && operation.status === "COMPLETED") {
       return unchanged(state, "joined");
     }
     if (state.incident.correctiveActionsTaken >= state.incident.actionLimit) {
@@ -12153,17 +12636,20 @@ function handleRecover(state, event) {
     }
   }
   if (state.incident === null) {
-    if (state.operation?.status === "NOT_STARTED") return unchanged(state, "blocked");
-    if (state.operation?.id === event.operationId) return unchanged(state, "conflict");
+    if (operation?.status === "NOT_STARTED") return unchanged(state, "blocked");
+    if (operation?.id === event.operationId) return unchanged(state, "conflict");
     state.incident = {
       id: event.incidentId,
       correctiveActionsTaken: 0,
       actionLimit: event.actionLimit
     };
   }
-  if (!state.operation || state.operation.status === "COMPLETED" || state.operation.status === "INTERRUPTED") {
+  if (!operation || operation.status === "COMPLETED" || operation.status === "INTERRUPTED") {
     const runtimeGeneration = advance(state.runtimeGeneration);
     if (runtimeGeneration === null) return unchanged(state, "blocked");
+    const consumer = state.consumers[0];
+    if (state.profile === null || consumer === void 0) return unchanged(state, "blocked");
+    if (state.operationHistory.length >= RELIABILITY_MAX_ITEMS) return unchanged(state, "blocked");
     state.runtimeGeneration = runtimeGeneration;
     state.observations = [];
     state.operation = {
@@ -12173,6 +12659,12 @@ function handleRecover(state, event) {
       status: "NOT_STARTED",
       exitCode: null
     };
+    state.operationHistory.push({
+      ...state.operation,
+      key: event.operationId,
+      profile: state.profile,
+      consumer: cloneConsumer(consumer)
+    });
   }
   state.phase = "recovering";
   return transition(state, "accepted");
@@ -12265,6 +12757,49 @@ function stepReliability(state, event, nowMs) {
   }
   return result;
 }
+function requiredCapabilities(state) {
+  const required = /* @__PURE__ */ new Set();
+  for (const consumer of state.consumers) {
+    for (const capability of consumer.requiredCapabilities) required.add(capability);
+  }
+  return [...required];
+}
+function failedCapability(state, required, nowMs) {
+  return required.some((capability) => {
+    const observation = state.observations.find((entry) => entry.capability === capability);
+    return observation !== void 0 && observation.infrastructure === "failed" && observation.observedAtMs >= state.observationsAfterMs && observation.observedAtMs <= nowMs && nowMs - observation.observedAtMs < observation.validForMs;
+  });
+}
+function decideRecovery(input2) {
+  const { state, nowMs, actionLimit, pressureDwellSatisfied } = input2;
+  assertReliabilityState(state);
+  if (!isReliabilityCounter(nowMs) || nowMs < state.observationsAfterMs)
+    throw new Error("Invalid reliability clock.");
+  if (input2.failedCapabilities !== void 0 && (input2.failedCapabilities.length > RELIABILITY_MAX_ITEMS || input2.failedCapabilities.some((capability) => !isReliabilityId(capability))))
+    throw new Error("Invalid recovery evidence.");
+  if (state.executionPolicy === "manual") return { action: "none", reason: "unmanaged" };
+  if (state.desired === "stopped-by-user") return { action: "none", reason: "user-stopped" };
+  if (state.desired === "parked-for-capacity") {
+    const resumeReady = pressureDwellSatisfied && state.stopProof.workloadsStopped && state.stopProof.routesRemoved && state.consumers.length > 0 && state.admission === "admitted" && state.profile !== null && (state.incident === null || state.incident.correctiveActionsTaken < state.incident.actionLimit) && state.operation !== null && ["NOT_STARTED", "COMPLETED", "INTERRUPTED"].includes(state.operation.status);
+    return { action: resumeReady ? "resume" : "none", reason: "parked" };
+  }
+  if (!isReliabilityCounter(actionLimit) || actionLimit < 1)
+    throw new Error("Invalid recovery action budget.");
+  const failed = input2.failedCapabilities !== void 0 ? input2.failedCapabilities.length > 0 : failedCapability(state, requiredCapabilities(state), nowMs);
+  if (!failed) return { action: "none", reason: "healthy" };
+  if (possibleDispatch(state.operation)) return { action: "none", reason: "active-operation" };
+  if (state.incident !== null) {
+    if (state.incident.correctiveActionsTaken >= state.incident.actionLimit)
+      return { action: "blocked", reason: "budget-exhausted" };
+    return {
+      action: "continue",
+      reason: "recovery-eligible",
+      incidentId: state.incident.id,
+      actionLimit: state.incident.actionLimit
+    };
+  }
+  return { action: "start", reason: "recovery-eligible", actionLimit };
+}
 var INFRASTRUCTURE_VALUES, APPLICATION_VALUES, ADMISSION_VALUES;
 var init_reliability_model = __esm({
   "src/core/reliability-model.ts"() {
@@ -12311,10 +12846,10 @@ async function runLifecycleWorker(request2, supervision, beforeAdmission) {
     throw new Error("Lifecycle invocation was cancelled before dispatch.");
   if (process.platform === "win32")
     throw new Error("Lifecycle workers require POSIX process-group ownership.");
-  const workerPath = import_node_path36.default.join(__dirname, "devrouter-lifecycle-worker.js");
-  if (!import_node_fs28.default.existsSync(workerPath))
+  const workerPath = import_node_path38.default.join(__dirname, "devrouter-lifecycle-worker.js");
+  if (!import_node_fs30.default.existsSync(workerPath))
     throw new Error("The packaged lifecycle worker is missing; rebuild the CLI.");
-  const child = (0, import_node_child_process17.fork)(workerPath, [], {
+  const child = (0, import_node_child_process18.fork)(workerPath, [], {
     detached: true,
     stdio: supervision ? ["ignore", "pipe", "pipe", "ipc"] : ["inherit", "inherit", "inherit", "ipc"],
     execArgv: []
@@ -12541,14 +13076,14 @@ async function runLifecycleWorker(request2, supervision, beforeAdmission) {
 function newLifecycleIds() {
   return { requestId: (0, import_node_crypto16.randomUUID)(), operationId: (0, import_node_crypto16.randomUUID)(), workerId: (0, import_node_crypto16.randomUUID)() };
 }
-var import_node_child_process17, import_node_crypto16, import_node_fs28, import_node_path36, OUTPUT_BUFFER_LIMIT, DEFAULT_OUTPUT_PAGE_BYTES, LifecycleOutput, LifecycleWorkerAdmissionBusyError;
+var import_node_child_process18, import_node_crypto16, import_node_fs30, import_node_path38, OUTPUT_BUFFER_LIMIT, DEFAULT_OUTPUT_PAGE_BYTES, LifecycleOutput, LifecycleWorkerAdmissionBusyError;
 var init_reliability_worker = __esm({
   "src/core/reliability-worker.ts"() {
     "use strict";
-    import_node_child_process17 = require("child_process");
+    import_node_child_process18 = require("child_process");
     import_node_crypto16 = require("crypto");
-    import_node_fs28 = __toESM(require("fs"));
-    import_node_path36 = __toESM(require("path"));
+    import_node_fs30 = __toESM(require("fs"));
+    import_node_path38 = __toESM(require("path"));
     init_file_lock();
     init_reliability_contract();
     init_reliability_model();
@@ -12593,243 +13128,79 @@ var init_reliability_worker = __esm({
           throw new Error("Invalid output cursor.");
         const cursorChunk = this.chunks.find((chunk) => chunk.sequence === cursor.sequence);
         if (cursorChunk && cursor.offset > cursorChunk.data.byteLength)
-          throw new Error("Invalid output cursor.");
-        if (!Number.isSafeInteger(maxJsonBytes) || maxJsonBytes <= 0)
-          throw new Error("Invalid output page byte bound.");
-        const cursorHasPartialChunk = cursorChunk !== void 0 && this.partialSequences.has(cursor.sequence) && cursor.offset < cursorChunk.data.byteLength;
-        let page = {
-          encoding: "base64",
-          gap: cursor.sequence < this.droppedThrough || cursor.sequence > 0 && cursor.sequence <= this.droppedThrough && !cursorChunk || cursorHasPartialChunk,
-          sequence: cursor,
-          chunks: []
-        };
-        if (outputPageBytes(page) > maxJsonBytes)
-          throw new Error("Output page byte bound is too small.");
-        for (const chunk of this.chunks) {
-          if (chunk.sequence < cursor.sequence) continue;
-          let offset = chunk.sequence === cursor.sequence ? cursor.offset : 0;
-          if (offset >= chunk.data.byteLength) {
-            const nextPage = { ...page, sequence: { sequence: chunk.sequence, offset } };
-            if (outputPageBytes(nextPage) > maxJsonBytes) {
-              if (page.sequence.sequence === cursor.sequence && page.sequence.offset === cursor.offset)
-                throw new Error("Output page byte bound is too small.");
-              return page;
-            }
-            page = nextPage;
-            continue;
-          }
-          while (offset < chunk.data.byteLength) {
-            let low = offset + 1;
-            let high = chunk.data.byteLength;
-            let best;
-            while (low <= high) {
-              const midpoint = Math.floor((low + high) / 2);
-              const candidatePage = {
-                encoding: "base64",
-                gap: page.gap,
-                sequence: { sequence: chunk.sequence, offset: midpoint },
-                chunks: [
-                  ...page.chunks,
-                  {
-                    stream: chunk.stream,
-                    data: chunk.data.subarray(offset, midpoint).toString("base64"),
-                    sequence: chunk.sequence
-                  }
-                ]
-              };
-              if (outputPageBytes(candidatePage) <= maxJsonBytes) {
-                best = candidatePage;
-                low = midpoint + 1;
-              } else high = midpoint - 1;
-            }
-            if (!best) {
-              if (page.sequence.sequence === cursor.sequence && page.sequence.offset === cursor.offset)
-                throw new Error("Output page byte bound is too small.");
-              return page;
-            }
-            page = best;
-            offset = best.sequence.offset;
-          }
-        }
-        return page;
-      }
-    };
-    LifecycleWorkerAdmissionBusyError = class extends Error {
-      constructor() {
-        super("Lifecycle admission lost to another operation.");
-        this.name = "LifecycleWorkerAdmissionBusyError";
-      }
-    };
-  }
-});
-
-// src/core/traefik-route-health.ts
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function inspectRouterApi(protocol) {
-  const result = (0, import_node_child_process18.spawnSync)(
-    "curl",
-    [
-      "--silent",
-      "--show-error",
-      "--fail",
-      "--max-time",
-      ROUTER_API_REQUEST_TIMEOUT_SECONDS,
-      `${ROUTER_API_BASE}/${protocol}/routers?per_page=${ROUTER_API_PAGE_SIZE}`
-    ],
-    { encoding: "utf-8" }
-  );
-  if (result.status !== 0) {
-    return {
-      ok: false,
-      details: result.stderr?.trim() || `curl exited with status ${result.status ?? "unknown"}`
-    };
-  }
-  let value;
-  try {
-    value = JSON.parse(result.stdout);
-  } catch {
-    return { ok: false, details: `${protocol.toUpperCase()} router API returned invalid JSON` };
-  }
-  if (!Array.isArray(value)) {
-    return { ok: false, details: `${protocol.toUpperCase()} router API returned a non-array` };
-  }
-  if (value.some((item) => !isRecord5(item) || typeof item.name !== "string" || !item.name))
-    return {
-      ok: false,
-      details: `${protocol.toUpperCase()} router API returned malformed entries`
-    };
-  return {
-    ok: true,
-    reachedPageLimit: value.length >= ROUTER_API_PAGE_SIZE,
-    names: new Set(
-      value.flatMap((item) => {
-        if (!item || typeof item !== "object") return [];
-        const name = item.name;
-        return typeof name === "string" ? [name] : [];
-      })
-    )
-  };
-}
-function isRecord5(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function inspectExpectedRoutes(routes, expectation) {
-  const mismatched = [];
-  const failures = [];
-  for (const protocol of ["http", "tcp"]) {
-    const expected = routes.filter((route) => (route.protocol ?? "http") === protocol).map((route) => buildHostRouteRouterName(route.repoPath, route.name));
-    if (expected.length === 0) continue;
-    const result = inspectRouterApi(protocol);
-    if (!result.ok) {
-      failures.push(result.details);
-      mismatched.push(...expected);
-      continue;
-    }
-    const unexpected = expected.filter(
-      (name) => expectation === "loaded" ? !result.names.has(name) : result.names.has(name)
-    );
-    const boundedAbsenceIsUncertain = result.reachedPageLimit && (expectation === "loaded" ? unexpected.length > 0 : unexpected.length === 0);
-    if (boundedAbsenceIsUncertain) {
-      failures.push(
-        `${protocol.toUpperCase()} router API reached the ${ROUTER_API_PAGE_SIZE}-entry safety limit`
-      );
-    }
-    mismatched.push(...unexpected);
-    if (expectation === "removed" && unexpected.length === 0 && result.reachedPageLimit) {
-      mismatched.push(...expected);
-    }
-  }
-  return mismatched.length === 0 ? { ok: true } : {
-    ok: false,
-    routes: mismatched,
-    details: failures.length > 0 ? failures.join("; ") : expectation === "loaded" ? "router names are absent" : "router names are still present"
-  };
-}
-async function waitForExpectedRoutes(routes, expectation, timeoutMs, pollIntervalMs) {
-  const deadline = Date.now() + timeoutMs;
-  let result;
-  do {
-    result = inspectExpectedRoutes(routes, expectation);
-    if (result.ok) return result;
-    if (Date.now() < deadline) {
-      await sleep(Math.min(pollIntervalMs, Math.max(1, deadline - Date.now())));
-    }
-  } while (Date.now() < deadline);
-  return result;
-}
-async function ensureTraefikRouteExpectation(routes, expectation, options) {
-  if (routes.length === 0) return { restarted: false };
-  const initialTimeoutMs = options.initialTimeoutMs ?? DEFAULT_INITIAL_TIMEOUT_MS;
-  const recoveryTimeoutMs = options.recoveryTimeoutMs ?? DEFAULT_RECOVERY_TIMEOUT_MS;
-  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const initial = await waitForExpectedRoutes(
-    routes,
-    expectation,
-    initialTimeoutMs,
-    pollIntervalMs
-  );
-  if (initial.ok) return { restarted: false };
-  if (options.allowRestart === false)
-    throw new Error(
-      "Traefik routes did not reload; shared router restart is disabled for this operation."
-    );
-  import_node_fs29.default.mkdirSync(DEVROUTER_HOME, { recursive: true });
-  return withFileLock(
-    ROUTER_RELOAD_LOCK_FILE,
-    {
-      activity: "Traefik route reload recovery",
-      waitMs: initialTimeoutMs + recoveryTimeoutMs + 1e4,
-      fair: true,
-      onWait: createStderrWaitReporter("Traefik route reload recovery", "shared router")
-    },
-    async () => {
-      const recheck = await waitForExpectedRoutes(routes, expectation, 0, pollIntervalMs);
-      if (recheck.ok) return { restarted: false };
-      claimLifecycleEffect();
-      restartRouterStack();
-      const recovered = await waitForExpectedRoutes(
-        routes,
-        expectation,
-        recoveryTimeoutMs,
-        pollIntervalMs
-      );
-      if (recovered.ok) return { restarted: true };
-      const action2 = expectation === "loaded" ? "load" : "remove";
-      throw new Error(
-        `Traefik did not ${action2} file-provider routes after one restart: ${recovered.routes.join(", ")} (${recovered.details}). Inspect: devrouter logs --tail 100`
-      );
-    }
-  );
-}
-async function ensureTraefikRoutesRemoved(routes, options = {}) {
-  return ensureTraefikRouteExpectation(routes, "removed", options);
-}
-var import_node_child_process18, import_node_fs29, import_node_path37, ROUTER_API_BASE, ROUTER_RELOAD_LOCK_FILE, ROUTER_API_REQUEST_TIMEOUT_SECONDS, DEFAULT_INITIAL_TIMEOUT_MS, DEFAULT_RECOVERY_TIMEOUT_MS, DEFAULT_POLL_INTERVAL_MS, ROUTER_API_PAGE_SIZE;
-var init_traefik_route_health = __esm({
-  "src/core/traefik-route-health.ts"() {
-    "use strict";
-    import_node_child_process18 = require("child_process");
-    import_node_fs29 = __toESM(require("fs"));
-    import_node_path37 = __toESM(require("path"));
-    init_file_lock();
-    init_host_routes();
-    init_reliability_context();
-    init_router();
-    ROUTER_API_BASE = "http://127.0.0.1:8080/api";
-    ROUTER_RELOAD_LOCK_FILE = import_node_path37.default.join(DEVROUTER_HOME, "router-reload.lock");
-    ROUTER_API_REQUEST_TIMEOUT_SECONDS = "2";
-    DEFAULT_INITIAL_TIMEOUT_MS = 3e3;
-    DEFAULT_RECOVERY_TIMEOUT_MS = 1e4;
-    DEFAULT_POLL_INTERVAL_MS = 250;
-    ROUTER_API_PAGE_SIZE = 1e3;
+          throw new Error("Invalid output cursor.");
+        if (!Number.isSafeInteger(maxJsonBytes) || maxJsonBytes <= 0)
+          throw new Error("Invalid output page byte bound.");
+        const cursorHasPartialChunk = cursorChunk !== void 0 && this.partialSequences.has(cursor.sequence) && cursor.offset < cursorChunk.data.byteLength;
+        let page = {
+          encoding: "base64",
+          gap: cursor.sequence < this.droppedThrough || cursor.sequence > 0 && cursor.sequence <= this.droppedThrough && !cursorChunk || cursorHasPartialChunk,
+          sequence: cursor,
+          chunks: []
+        };
+        if (outputPageBytes(page) > maxJsonBytes)
+          throw new Error("Output page byte bound is too small.");
+        for (const chunk of this.chunks) {
+          if (chunk.sequence < cursor.sequence) continue;
+          let offset = chunk.sequence === cursor.sequence ? cursor.offset : 0;
+          if (offset >= chunk.data.byteLength) {
+            const nextPage = { ...page, sequence: { sequence: chunk.sequence, offset } };
+            if (outputPageBytes(nextPage) > maxJsonBytes) {
+              if (page.sequence.sequence === cursor.sequence && page.sequence.offset === cursor.offset)
+                throw new Error("Output page byte bound is too small.");
+              return page;
+            }
+            page = nextPage;
+            continue;
+          }
+          while (offset < chunk.data.byteLength) {
+            let low = offset + 1;
+            let high = chunk.data.byteLength;
+            let best;
+            while (low <= high) {
+              const midpoint = Math.floor((low + high) / 2);
+              const candidatePage = {
+                encoding: "base64",
+                gap: page.gap,
+                sequence: { sequence: chunk.sequence, offset: midpoint },
+                chunks: [
+                  ...page.chunks,
+                  {
+                    stream: chunk.stream,
+                    data: chunk.data.subarray(offset, midpoint).toString("base64"),
+                    sequence: chunk.sequence
+                  }
+                ]
+              };
+              if (outputPageBytes(candidatePage) <= maxJsonBytes) {
+                best = candidatePage;
+                low = midpoint + 1;
+              } else high = midpoint - 1;
+            }
+            if (!best) {
+              if (page.sequence.sequence === cursor.sequence && page.sequence.offset === cursor.offset)
+                throw new Error("Output page byte bound is too small.");
+              return page;
+            }
+            page = best;
+            offset = best.sequence.offset;
+          }
+        }
+        return page;
+      }
+    };
+    LifecycleWorkerAdmissionBusyError = class extends Error {
+      constructor() {
+        super("Lifecycle admission lost to another operation.");
+        this.name = "LifecycleWorkerAdmissionBusyError";
+      }
+    };
   }
 });
 
 // src/core/devpod-mutation.ts
 function withMutationLock2(activity, target, operation) {
-  import_node_fs30.default.mkdirSync(DEVROUTER_HOME, { recursive: true });
+  import_node_fs31.default.mkdirSync(DEVROUTER_HOME, { recursive: true });
   return withFileLockSync(
     DEVPOD_MUTATION_LOCK_FILE,
     {
@@ -12919,13 +13290,13 @@ function deleteOwnedDevpodWorkspace(devpodId, worktreePath) {
   resetWorkspaceRuntimeCaches();
   return result;
 }
-var import_node_child_process19, import_node_fs30, import_node_path38, DEVPOD_MUTATION_LOCK_FILE, DEVPOD_MUTATION_WAIT_MS;
+var import_node_child_process19, import_node_fs31, import_node_path39, DEVPOD_MUTATION_LOCK_FILE, DEVPOD_MUTATION_WAIT_MS;
 var init_devpod_mutation = __esm({
   "src/core/devpod-mutation.ts"() {
     "use strict";
     import_node_child_process19 = require("child_process");
-    import_node_fs30 = __toESM(require("fs"));
-    import_node_path38 = __toESM(require("path"));
+    import_node_fs31 = __toESM(require("fs"));
+    import_node_path39 = __toESM(require("path"));
     init_devpod_workspaces();
     init_devsy_mutation();
     init_file_lock();
@@ -12934,7 +13305,7 @@ var init_devpod_mutation = __esm({
     init_reliability_context();
     init_router();
     init_workspace_runtime();
-    DEVPOD_MUTATION_LOCK_FILE = import_node_path38.default.join(DEVROUTER_HOME, "devpod-mutation.lock");
+    DEVPOD_MUTATION_LOCK_FILE = import_node_path39.default.join(DEVROUTER_HOME, "devpod-mutation.lock");
     DEVPOD_MUTATION_WAIT_MS = 18e5;
   }
 });
@@ -13140,8 +13511,8 @@ function renderManagedComposeModel(plan, workspace) {
   }
 }
 function attributeHolderWorktree(workingDir) {
-  if (import_node_path39.default.basename(workingDir) !== ".devcontainer") return void 0;
-  return comparableWorkspacePath(import_node_path39.default.dirname(workingDir));
+  if (import_node_path40.default.basename(workingDir) !== ".devcontainer") return void 0;
+  return comparableWorkspacePath(import_node_path40.default.dirname(workingDir));
 }
 function holderAttribution(holder, repoPath) {
   const attribution = {};
@@ -13173,7 +13544,7 @@ function detectHostPortClaimConflicts(options) {
   );
   if (desired.length === 0) return [];
   const holders = listHolderSnapshots();
-  const devcontainerDir = import_node_path39.default.join(options.repoPath, ".devcontainer");
+  const devcontainerDir = import_node_path40.default.join(options.repoPath, ".devcontainer");
   const conflicts = [];
   for (const binding of desired) {
     for (const holder of holders) {
@@ -13195,12 +13566,12 @@ function detectHostPortClaimConflicts(options) {
   }
   return conflicts;
 }
-var import_node_child_process20, import_node_path39, COMPOSE_RENDER_TIMEOUT_MS, COMPOSE_RENDER_MAX_BUFFER, DOCKER_TIMEOUT_MS, DOCKER_MAX_BUFFER, MAX_DESIRED_HOST_PORTS, MAX_RUNNING_HOLDERS, HOST_PORT_INSPECT_TEMPLATE;
+var import_node_child_process20, import_node_path40, COMPOSE_RENDER_TIMEOUT_MS, COMPOSE_RENDER_MAX_BUFFER, DOCKER_TIMEOUT_MS, DOCKER_MAX_BUFFER, MAX_DESIRED_HOST_PORTS, MAX_RUNNING_HOLDERS, HOST_PORT_INSPECT_TEMPLATE;
 var init_host_port_claims = __esm({
   "src/core/host-port-claims.ts"() {
     "use strict";
     import_node_child_process20 = require("child_process");
-    import_node_path39 = __toESM(require("path"));
+    import_node_path40 = __toESM(require("path"));
     init_devcontainer_profile();
     init_network_effect_scope();
     init_workspace();
@@ -13374,20 +13745,20 @@ var init_http_route_probe = __esm({
 });
 
 // src/core/managed-host-preparation.ts
-var import_node_child_process22, import_node_fs31;
+var import_node_child_process22, import_node_fs32;
 var init_managed_host_preparation = __esm({
   "src/core/managed-host-preparation.ts"() {
     "use strict";
     import_node_child_process22 = require("child_process");
-    import_node_fs31 = __toESM(require("fs"));
+    import_node_fs32 = __toESM(require("fs"));
     init_repo_config();
   }
 });
 
 // src/core/managed-post-start.ts
 function readRegularFileBytes(filePath) {
-  if (!import_node_fs32.default.existsSync(filePath) || !import_node_fs32.default.lstatSync(filePath).isFile()) return void 0;
-  return import_node_fs32.default.readFileSync(filePath);
+  if (!import_node_fs33.default.existsSync(filePath) || !import_node_fs33.default.lstatSync(filePath).isFile()) return void 0;
+  return import_node_fs33.default.readFileSync(filePath);
 }
 function readRegularFile(filePath) {
   return readRegularFileBytes(filePath)?.toString("utf-8");
@@ -13396,11 +13767,11 @@ function adapterFingerprint(adapter) {
   return (0, import_node_crypto17.createHash)("sha256").update(adapter).digest("hex");
 }
 function resolveManagedPostStartPlan(repoPath) {
-  const adapterPath = import_node_path40.default.join(repoPath, MANAGED_ADAPTER_PATH);
+  const adapterPath = import_node_path41.default.join(repoPath, MANAGED_ADAPTER_PATH);
   const adapterBytes = readRegularFileBytes(adapterPath);
   const adapterText = adapterBytes?.toString("utf-8");
-  const dockerfilePath = import_node_path40.default.join(repoPath, ".devcontainer", "Dockerfile");
-  const devcontainerPath = import_node_path40.default.join(repoPath, ".devcontainer", "devcontainer.json");
+  const dockerfilePath = import_node_path41.default.join(repoPath, ".devcontainer", "Dockerfile");
+  const devcontainerPath = import_node_path41.default.join(repoPath, ".devcontainer", "devcontainer.json");
   const dockerfile = readRegularFile(dockerfilePath) ?? "";
   const devcontainer = readRegularFile(devcontainerPath) ?? "";
   const devrouterPattern = [adapterText, dockerfile, devcontainer].filter((value) => value !== void 0).some(
@@ -13483,14 +13854,14 @@ function runManagedProcessAction(options) {
   }
   return "drifted";
 }
-var import_node_child_process23, import_node_crypto17, import_node_fs32, import_node_path40, MANAGED_MARKER, MANAGED_ADAPTER_PATH, RUNTIME_HELPER_PATH;
+var import_node_child_process23, import_node_crypto17, import_node_fs33, import_node_path41, MANAGED_MARKER, MANAGED_ADAPTER_PATH, RUNTIME_HELPER_PATH;
 var init_managed_post_start = __esm({
   "src/core/managed-post-start.ts"() {
     "use strict";
     import_node_child_process23 = require("child_process");
     import_node_crypto17 = require("crypto");
-    import_node_fs32 = __toESM(require("fs"));
-    import_node_path40 = __toESM(require("path"));
+    import_node_fs33 = __toESM(require("fs"));
+    import_node_path41 = __toESM(require("path"));
     init_devcontainer_config();
     init_network_effect_scope();
     MANAGED_MARKER = "devrouter:managed devcontainer";
@@ -14429,26 +14800,26 @@ function hasLocalDockerNetworkNamespace(endpoint, procRoot = "/proc") {
   try {
     if (!endpoint.startsWith("unix:///")) return false;
     const socket = endpoint.slice("unix://".length);
-    const table = import_node_fs33.default.readFileSync(import_node_path41.default.join(procRoot, "net/unix"), "utf8");
+    const table = import_node_fs34.default.readFileSync(import_node_path42.default.join(procRoot, "net/unix"), "utf8");
     if (Buffer.byteLength(table) > 1024 * 1024) return false;
     const rows2 = table.split("\n").map((line) => line.trim().split(/\s+/)).filter((row) => row[7] === socket && row[3] === "00010000");
     if (rows2.length !== 1 || !/^\d+$/.test(rows2[0][6])) return false;
     const inode = `socket:[${rows2[0][6]}]`;
-    const ownNamespace = import_node_fs33.default.readlinkSync(import_node_path41.default.join(procRoot, "self/ns/net"));
-    const pids = import_node_fs33.default.readdirSync(procRoot).filter((name) => /^\d+$/.test(name));
+    const ownNamespace = import_node_fs34.default.readlinkSync(import_node_path42.default.join(procRoot, "self/ns/net"));
+    const pids = import_node_fs34.default.readdirSync(procRoot).filter((name) => /^\d+$/.test(name));
     if (pids.length > 4096) return false;
     for (const pid of pids) {
       if (Date.now() > deadline) return false;
       try {
-        const root = import_node_path41.default.join(procRoot, pid);
-        if (import_node_path41.default.basename(import_node_fs33.default.readlinkSync(import_node_path41.default.join(root, "exe"))) !== "dockerd") continue;
-        if (import_node_fs33.default.readlinkSync(import_node_path41.default.join(root, "ns/net")) !== ownNamespace) continue;
-        const descriptors = import_node_fs33.default.readdirSync(import_node_path41.default.join(root, "fd"));
+        const root = import_node_path42.default.join(procRoot, pid);
+        if (import_node_path42.default.basename(import_node_fs34.default.readlinkSync(import_node_path42.default.join(root, "exe"))) !== "dockerd") continue;
+        if (import_node_fs34.default.readlinkSync(import_node_path42.default.join(root, "ns/net")) !== ownNamespace) continue;
+        const descriptors = import_node_fs34.default.readdirSync(import_node_path42.default.join(root, "fd"));
         if (descriptors.length > 4096) continue;
         if (descriptors.some((fd) => {
           if (Date.now() > deadline) return false;
           try {
-            return import_node_fs33.default.readlinkSync(import_node_path41.default.join(root, "fd", fd)) === inode;
+            return import_node_fs34.default.readlinkSync(import_node_path42.default.join(root, "fd", fd)) === inode;
           } catch {
             return false;
           }
@@ -14462,12 +14833,12 @@ function hasLocalDockerNetworkNamespace(endpoint, procRoot = "/proc") {
   }
   return false;
 }
-var import_node_fs33, import_node_path41;
+var import_node_fs34, import_node_path42;
 var init_network_local_daemon = __esm({
   "src/core/network-local-daemon.ts"() {
     "use strict";
-    import_node_fs33 = __toESM(require("fs"));
-    import_node_path41 = __toESM(require("path"));
+    import_node_fs34 = __toESM(require("fs"));
+    import_node_path42 = __toESM(require("path"));
   }
 });
 
@@ -14583,14 +14954,14 @@ var init_network_compose = __esm({
 });
 
 // src/core/network-compose-files.ts
-var import_node_child_process26, import_node_crypto19, import_node_fs34, import_node_path42, import_yaml4, MAX_BYTES3;
+var import_node_child_process26, import_node_crypto19, import_node_fs35, import_node_path43, import_yaml4, MAX_BYTES3;
 var init_network_compose_files = __esm({
   "src/core/network-compose-files.ts"() {
     "use strict";
     import_node_child_process26 = require("child_process");
     import_node_crypto19 = require("crypto");
-    import_node_fs34 = __toESM(require("fs"));
-    import_node_path42 = __toESM(require("path"));
+    import_node_fs35 = __toESM(require("fs"));
+    import_node_path43 = __toESM(require("path"));
     import_yaml4 = __toESM(require("yaml"));
     init_atomic_file();
     init_devcontainer_profile();
@@ -14694,13 +15065,13 @@ function resolveLinkedTarget(repoPath) {
     gitCommonDir: resolveGitCommonDir(repoPath)
   };
 }
-var import_node_child_process28, import_node_fs35, import_node_path43;
+var import_node_child_process28, import_node_fs36, import_node_path44;
 var init_workspace_ensure = __esm({
   "src/core/workspace-ensure.ts"() {
     "use strict";
     import_node_child_process28 = require("child_process");
-    import_node_fs35 = __toESM(require("fs"));
-    import_node_path43 = __toESM(require("path"));
+    import_node_fs36 = __toESM(require("fs"));
+    import_node_path44 = __toESM(require("path"));
     init_devcontainer_profile();
     init_devpod_environment();
     init_devpod_mutation();
@@ -14836,13 +15207,59 @@ function prepareManagedLifecycleOperation(input2) {
     };
   });
 }
-function assertCurrentCapacityController(expected, directory = import_node_path44.default.join(DEVROUTER_HOME, "controller")) {
+function assertCurrentCapacityController(expected, directory = import_node_path45.default.join(DEVROUTER_HOME, "controller")) {
   const current = new ControllerStore(directory).read();
   if (!expected || current?.store !== expected.store || current.epoch !== expected.epoch)
     throw new Error("Capacity controller incarnation changed.");
 }
+function prepareRecoveryLifecycleOperation(input2) {
+  const ids2 = newLifecycleIds();
+  return updateReliabilityOperation(input2.identity, (record5) => {
+    assertCurrentCapacityController(input2.controller);
+    if (record5.version !== 2 || record5.state.executionPolicy !== "capacity-managed" || record5.enrollment?.policyRevision !== input2.policyRevision)
+      throw new Error("Managed recovery requires current durable enrollment.");
+    if (record5.phaseSettlement) return void 0;
+    reconcileDrained(record5);
+    if (record5.worker) return void 0;
+    const decision = decideRecovery({
+      state: record5.state,
+      nowMs: Date.now(),
+      actionLimit: input2.actionLimit,
+      pressureDwellSatisfied: false,
+      failedCapabilities: input2.failedCapabilities
+    });
+    if (decision.action !== "start" && decision.action !== "continue") return void 0;
+    const transition2 = stepReliability(
+      record5.state,
+      {
+        ...reliabilityFence(record5.state),
+        type: "recover",
+        incidentId: decision.action === "continue" ? decision.incidentId : input2.incidentId,
+        actionLimit: input2.actionLimit,
+        operationId: ids2.operationId
+      },
+      Date.now()
+    );
+    if (transition2.outcome !== "accepted") return void 0;
+    record5.state = transition2.state;
+    record5.outcome = null;
+    record5.result = null;
+    record5.startupWitness = null;
+    return {
+      operationId: ids2.operationId,
+      request: {
+        ...ids2,
+        kind: "ensure",
+        repoPath: input2.identity.repoPath,
+        identity: { ...input2.identity },
+        fence: reliabilityFence(record5.state),
+        options: { profile: input2.profile, quiet: true }
+      }
+    };
+  });
+}
 function settlePreparedLifecycleCapacity(input2) {
-  const directory = input2.directory ?? import_node_path44.default.join(DEVROUTER_HOME, "controller");
+  const directory = input2.directory ?? import_node_path45.default.join(DEVROUTER_HOME, "controller");
   const store = new CapacityStore(directory);
   for (let attempt = 0; attempt < 3; attempt++) {
     const snapshot = store.read();
@@ -15056,7 +15473,7 @@ async function superviseLifecycle(kind, repoPath, options = {}, command) {
     removeSignals();
   }
 }
-function admitLifecycleCapacity(request2, reservation, budgets, samples, nowMs, maxSampleAgeMs, directory = import_node_path44.default.join(DEVROUTER_HOME, "controller"), controller, admission) {
+function admitLifecycleCapacity(request2, reservation, budgets, samples, nowMs, maxSampleAgeMs, directory = import_node_path45.default.join(DEVROUTER_HOME, "controller"), controller, admission) {
   if (request2.kind === "stop") throw new Error("Stop never requires capacity admission.");
   const capacity = new CapacityStore(directory);
   const snapshot = capacity.read();
@@ -15156,7 +15573,7 @@ function admitLifecycleCapacity(request2, reservation, budgets, samples, nowMs,
   return decision;
 }
 function capacityPolicyTargets(repoPath) {
-  const policy = readCapacityPolicy(import_node_path44.default.join(DEVROUTER_HOME, "controller"));
+  const policy = readCapacityPolicy(import_node_path45.default.join(DEVROUTER_HOME, "controller"));
   return policy?.admissions === "enabled" && policy.enrollments.some((entry) => entry.repoPath === repoPath);
 }
 function controllerWaitSeconds(deadline) {
@@ -15165,7 +15582,7 @@ function controllerWaitSeconds(deadline) {
 async function superviseThroughController(input2) {
   if (input2.kind === "exec" && !input2.command)
     throw new Error("Exec requires a command for controller admission.");
-  const directory = import_node_path44.default.join(DEVROUTER_HOME, "controller");
+  const directory = import_node_path45.default.join(DEVROUTER_HOME, "controller");
   const cancellation = { requested: false };
   const removeSignals = installLifecycleWaitSignals(cancellation);
   const cancelled = () => {
@@ -15175,6 +15592,17 @@ async function superviseThroughController(input2) {
       );
   };
   const deadline = Date.now() + CAPACITY_CLIENT_WAIT_MS;
+  let outputGapReported = false;
+  const onOutput = (page) => {
+    if (page.gap && !outputGapReported) {
+      process.stderr.write("devrouter: controller output buffer dropped earlier command output.\n");
+      outputGapReported = true;
+    }
+    for (const chunk of page.chunks) {
+      const stream = chunk.stream === "stderr" ? process.stderr : process.stdout;
+      stream.write(Buffer.from(chunk.data, page.encoding));
+    }
+  };
   try {
     const bind = () => observeControllerBinding(directory, {
       path: input2.repoPath,
@@ -15189,7 +15617,7 @@ async function superviseThroughController(input2) {
     let pending = await submitControllerOperation(
       directory,
       input2.kind === "exec" ? { ...binding, requestId: input2.requestId, kind: "exec", command: input2.command ?? [] } : { ...binding, requestId: input2.requestId, kind: "ensure" },
-      { waitSeconds: controllerWaitSeconds(deadline) }
+      { waitSeconds: controllerWaitSeconds(deadline), onOutput }
     );
     while (pending.status !== "terminal") {
       cancelled();
@@ -15205,7 +15633,7 @@ async function superviseThroughController(input2) {
         pending = await followControllerOperation(
           directory,
           { ...binding, operationId: pending.operationId },
-          { waitSeconds: controllerWaitSeconds(deadline) }
+          { waitSeconds: controllerWaitSeconds(deadline), onOutput }
         );
       } catch {
         await new Promise((resolve) => setTimeout(resolve, Math.min(1e3, deadline - Date.now())));
@@ -15226,28 +15654,33 @@ async function superviseThroughController(input2) {
     removeSignals();
   }
 }
-function renewLifecycleCapacity(request2, policy, samples, controller, directory = import_node_path44.default.join(DEVROUTER_HOME, "controller"), nowMs = Date.now()) {
+function renewLifecycleCapacity(request2, policy, samples, controller, directory = import_node_path45.default.join(DEVROUTER_HOME, "controller"), nowMs = Date.now()) {
   return updateReliabilityOperation(request2.identity, (record5) => {
     const binding = record5.capacity;
     if (!matchesFence(record5, request2.fence) || !binding || binding.operationId !== request2.operationId || binding.workerId !== request2.workerId || binding.controller?.store !== controller.store || binding.controller?.epoch !== controller.epoch)
       throw new Error("Capacity renewal no longer owns this operation.");
-    binding.validUntilMs = 0;
     try {
-      if (record5.state.executionPolicy !== "capacity-managed" || record5.state.operation?.id !== request2.operationId || record5.state.operation.drained || record5.state.desired !== "running" || policy.admissions !== "enabled" || policy.revision !== binding.policyRevision || JSON.stringify(readCapacityPolicy(directory)) !== JSON.stringify(policy))
+      if (record5.state.executionPolicy !== "capacity-managed" || record5.state.operation?.id !== request2.operationId || record5.state.operation.drained || record5.state.desired !== "running" || policy.admissions !== "enabled" || policy.revision !== binding.policyRevision || JSON.stringify(readCapacityPolicy(directory)) !== JSON.stringify(policy)) {
+        binding.validUntilMs = 0;
         return false;
+      }
       const enrolled = record5.enrollment;
       const runtime = enrolled && policy.domains[enrolled.runtimeDomain];
       const enrollment = policy.enrollments.find(
         (entry) => entry.repoPath === record5.identity.repoPath && entry.workspace === record5.identity.workspace && entry.provider === record5.identity.provider && entry.providerId === enrolled?.providerId && entry.gitCommonDir === enrolled.gitCommonDir && entry.estimatesDigest === enrolled.estimatesDigest && entry.hostDomain === enrolled.hostDomain && entry.runtimeDomain === enrolled.runtimeDomain && entry.profiles.includes(record5.state.profile ?? "")
       );
-      if (!enrolled || enrolled.policyRevision !== policy.revision || !enrollment || runtime?.kind !== "runtime" || runtime.endpoint !== enrolled.endpoint || runtime.daemonId !== enrolled.daemonId)
+      if (!enrolled || enrolled.policyRevision !== policy.revision || !enrollment || runtime?.kind !== "runtime" || runtime.endpoint !== enrolled.endpoint || runtime.daemonId !== enrolled.daemonId) {
+        binding.validUntilMs = 0;
         return false;
+      }
       const snapshot = new CapacityStore(directory).read();
       const reservation = snapshot.reservations.find(
         (entry) => entry.reservationId === binding.reservationId
       );
-      if (!reservation || reservation.environmentId !== record5.state.environmentId || reservation.operationId !== request2.operationId || reservation.policyRevision !== policy.revision)
+      if (!reservation || reservation.environmentId !== record5.state.environmentId || reservation.operationId !== request2.operationId || reservation.policyRevision !== policy.revision) {
+        binding.validUntilMs = 0;
         return false;
+      }
       const maxAge = policy.scheduling.maxSampleAgeSeconds * 1e3;
       const decision = evaluateCapacity(
         policy.domains,
@@ -15274,16 +15707,21 @@ function renewLifecycleCapacity(request2, policy, samples, controller, directory
             snapshot.pools
           ).admitted;
         })();
-        if (!tolerated) return false;
+        if (!tolerated) {
+          if (decision.reason !== "unknown" && decision.reason !== "stale")
+            binding.validUntilMs = 0;
+          return false;
+        }
       }
+      const observed = Object.keys(reservation.totals).map(
+        (domain) => samples[domain]?.sampledAtMs
+      );
+      if (observed.some((sampledAtMs) => typeof sampledAtMs !== "number")) return false;
       binding.snapshotRevision = snapshot.revision;
-      binding.validUntilMs = Math.min(
-        ...Object.keys(reservation.totals).map((domain) => samples[domain]?.sampledAtMs ?? 0)
-      ) + maxAge;
+      binding.validUntilMs = Math.min(...observed) + maxAge;
       assertCapacityEffect(record5, request2.workerId, nowMs, directory);
       return true;
     } catch {
-      binding.validUntilMs = 0;
       return false;
     }
   });
@@ -15304,7 +15742,7 @@ function retireQueuedLifecycle(request2, supersededOnly = false) {
     return true;
   });
 }
-function bindLifecycleCapacity(request2, binding, directory = import_node_path44.default.join(DEVROUTER_HOME, "controller")) {
+function bindLifecycleCapacity(request2, binding, directory = import_node_path45.default.join(DEVROUTER_HOME, "controller")) {
   if (request2.kind === "stop") throw new Error("Stop never requires capacity admission.");
   updateReliabilityOperation(request2.identity, (record5) => {
     if (!matchesFence(record5, request2.fence) || record5.worker || record5.state.operation?.id !== request2.operationId || record5.state.operation.status !== "NOT_STARTED" || record5.state.operation.drained)
@@ -15319,12 +15757,12 @@ function bindLifecycleCapacity(request2, binding, directory = import_node_path44
       stepRecord(record5, { ...request2.fence, type: "admission", result: "admitted" });
   });
 }
-var import_node_crypto21, import_node_path44, import_node_util10, activeWorker, lockHeld, BUSY_LIFECYCLE_WAIT_MS, BUSY_LIFECYCLE_POLL_MS, CAPACITY_CLIENT_WAIT_MS, BUSY_LIFECYCLE_PROGRESS_MS;
+var import_node_crypto21, import_node_path45, import_node_util10, activeWorker, lockHeld, BUSY_LIFECYCLE_WAIT_MS, BUSY_LIFECYCLE_POLL_MS, CAPACITY_CLIENT_WAIT_MS, BUSY_LIFECYCLE_PROGRESS_MS;
 var init_reliability_lifecycle = __esm({
   "src/core/reliability-lifecycle.ts"() {
     "use strict";
     import_node_crypto21 = require("crypto");
-    import_node_path44 = __toESM(require("path"));
+    import_node_path45 = __toESM(require("path"));
     import_node_util10 = require("util");
     init_capacity_accounting();
     init_capacity_policy();
@@ -15337,6 +15775,7 @@ var init_reliability_lifecycle = __esm({
     init_devsy_mutation();
     init_file_lock();
     init_host_routes();
+    init_managed_devsy_stop();
     init_managed_runtime_state();
     init_managed_stop_recovery();
     init_reliability_context();
@@ -15427,6 +15866,11 @@ var init_capacity_queue = __esm({
         });
         return request2.operationId;
       }
+      /** True while the queue still owns the operation, awaiting admission or running. */
+      hasOperation(operationId) {
+        const entry = this.entries.get(operationId);
+        return entry !== void 0 && entry.phase !== "terminal";
+      }
       observe(operationId) {
         const entry = this.entries.get(operationId);
         return entry ? { operationId, phase: entry.phase, reason: entry.reason, output: entry.output.read() } : void 0;
@@ -15811,7 +16255,7 @@ function createCapacityController(options) {
         const record5 = readReliabilityOperation(identity2);
         if (!record5?.capacity || !record5.preparation && !record5.capacity.execSteady || record5.worker || !record5.state.operation?.drained || !["ensure", "exec"].includes(record5.state.operation.kind))
           continue;
-        const bytes2 = readControllerEvidence(import_node_path45.default.join(enrollment.repoPath, ".devrouter.yml"));
+        const bytes2 = readControllerEvidence(import_node_path46.default.join(enrollment.repoPath, ".devrouter.yml"));
         const estimates = loadRepoConfig(enrollment.repoPath, () => bytes2).capacity;
         if (!estimates) continue;
         settlePreparedLifecycleCapacity({
@@ -15964,6 +16408,87 @@ function createCapacityController(options) {
       settlePreparations();
       return queue.tick();
     },
+    /**
+     * Open or advance one bounded automatic recovery for an environment whose
+     * required capability has positively failed. It is inert unless the
+     * operator policy enables recovery, and every decision, budget, and
+     * admission rule is the one an operator-requested ensure obeys.
+     */
+    async recover(environment, failedCapabilities, signal) {
+      signal = AbortSignal.any([signal, lifetime.signal]);
+      if (signal.aborted || !policy.recovery.enabled) return;
+      if (failedCapabilities.length === 0 || failedCapabilities.length > 64) return;
+      const current = readCapacityPolicy(options.directory);
+      if (current?.admissions !== "enabled" || !(0, import_node_util12.isDeepStrictEqual)(current, policy)) return;
+      let resolved;
+      try {
+        resolved = await enrollCapacityLifecycle(
+          current,
+          { path: environment.repoPath, profile: environment.profile, require: [] },
+          signal,
+          options.directory
+        );
+      } catch {
+        return;
+      }
+      if (signal.aborted || !(0, import_node_util12.isDeepStrictEqual)(resolved.environment, environment)) return;
+      if (!(0, import_node_util12.isDeepStrictEqual)(readCapacityPolicy(options.directory), current)) return;
+      const runtime = current.domains[resolved.enrollment.runtimeDomain];
+      if (runtime?.kind !== "runtime" || runtime.hostDomain !== resolved.enrollment.hostDomain || current.domains[runtime.hostDomain]?.kind !== "host" || !current.enrollments.some((entry) => (0, import_node_util12.isDeepStrictEqual)(entry, resolved.enrollment)))
+        return;
+      const pool = {
+        daemonId: runtime.daemonId,
+        runtimeDomain: resolved.enrollment.runtimeDomain,
+        hostDomain: runtime.hostDomain,
+        hostChargeCeilingBytes: runtime.hostChargeCeilingBytes
+      };
+      const identity2 = {
+        repoPath: environment.repoPath,
+        workspace: environment.workspace || null,
+        provider: environment.provider
+      };
+      const record5 = readReliabilityOperation(identity2);
+      if (!record5) return;
+      if (record5.state.operation && queue.hasOperation(record5.state.operation.id)) return;
+      let prepared;
+      try {
+        prepared = prepareRecoveryLifecycleOperation({
+          identity: identity2,
+          controller,
+          policyRevision: current.revision,
+          actionLimit: policy.recovery.maxCorrectiveActions,
+          failedCapabilities,
+          profile: environment.profile,
+          incidentId: `incident-${(0, import_node_crypto22.randomUUID)()}`
+        });
+      } catch {
+        return;
+      }
+      if (!prepared) return;
+      const charge = capacityRequest(resolved.estimates, resolved.enrollment, {
+        environmentId: record5.state.environmentId,
+        profile: environment.profile,
+        ...record5.activeProfile ? { activeProfile: record5.activeProfile } : {},
+        kind: "ensure"
+      });
+      try {
+        queue.enqueue(
+          prepared.request,
+          {
+            ...charge,
+            operationId: prepared.operationId,
+            reservationId: (0, import_node_crypto22.randomUUID)(),
+            policyRevision: current.revision
+          },
+          { estimates: resolved.estimates, enrollment: resolved.enrollment, pool }
+        );
+      } catch {
+        try {
+          retireQueuedLifecycle(prepared.request);
+        } catch {
+        }
+      }
+    },
     close() {
       lifetime.abort();
       queue.close();
@@ -15971,12 +16496,12 @@ function createCapacityController(options) {
     }
   };
 }
-var import_node_crypto22, import_node_path45, import_node_util12;
+var import_node_crypto22, import_node_path46, import_node_util12;
 var init_capacity_controller = __esm({
   "src/core/capacity-controller.ts"() {
     "use strict";
     import_node_crypto22 = require("crypto");
-    import_node_path45 = __toESM(require("path"));
+    import_node_path46 = __toESM(require("path"));
     import_node_util12 = require("util");
     init_capacity_docker_probe();
     init_capacity_enrollment();
@@ -16094,12 +16619,13 @@ var init_controller_monitor = __esm({
     ControllerObservationBindingChanged = class extends Error {
     };
     ControllerMonitor = class {
-      constructor(sessions, collect, serialize, clock = () => Math.floor(performance.now()), fence = withReliabilityObservationFence) {
+      constructor(sessions, collect, serialize, clock = () => Math.floor(performance.now()), fence = withReliabilityObservationFence, recover) {
         this.sessions = sessions;
         this.collect = collect;
         this.serialize = serialize;
         this.clock = clock;
         this.fence = fence;
+        this.recover = recover;
       }
       active = /* @__PURE__ */ new Map();
       lastStarted = /* @__PURE__ */ new Map();
@@ -16194,6 +16720,18 @@ var init_controller_monitor = __esm({
                 this.sessions.publish(bindings, projections, commitTime, Date.now());
               });
             });
+            if (this.recover === void 0 || this.stopped) return;
+            const required = new Set(requirements.map(controllerCapability));
+            const failed = batch.capabilities.filter(
+              (capability) => capability.infrastructure === "failed" && required.has(capability.capability)
+            ).map((capability) => capability.capability);
+            if (failed.length > 0)
+              void this.recover(
+                batch.environment,
+                failed,
+                this.active.get(environment.id)?.signal ?? abort.signal
+              ).catch(() => {
+              });
           }).catch(async (error) => {
             if (!this.stopped)
               await this.serialize(() => {
@@ -16217,7 +16755,7 @@ var init_controller_monitor = __esm({
 async function observeControllerProcess(containerId, name, signal) {
   if (!/^[a-f0-9]{12,64}$/.test(containerId) || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(name))
     throw new Error("Process observation identity is invalid.");
-  const output2 = await runControllerProbe(
+  const result = await runControllerProbeStatus(
     "docker",
     [
       "exec",
@@ -16233,12 +16771,14 @@ async function observeControllerProcess(containerId, name, signal) {
     ],
     signal
   );
-  const identity2 = output2.trim();
+  if (result.code === PROCESS_ABSENT_EXIT) return { kind: "absent" };
+  if (result.code !== 0) throw new Error("Process observation is unavailable.");
+  const identity2 = result.output.trim();
   if (!/^[1-9][0-9]* [0-9]+ [a-zA-Z0-9][a-zA-Z0-9._:-]{0,4095}$/.test(identity2))
     throw new Error("Process observation is unavailable.");
-  return identity2;
+  return { kind: "present", identity: identity2 };
 }
-var PROCESS_OBSERVATION;
+var PROCESS_OBSERVATION, PROCESS_ABSENT_EXIT;
 var init_controller_process_observation = __esm({
   "src/core/controller-process-observation.ts"() {
     "use strict";
@@ -16248,7 +16788,9 @@ set -euo pipefail
 name="$1"
 [[ "$name" =~ ^[a-zA-Z0-9][a-zA-Z0-9._-]*$ ]] || exit 1
 file="${"$"}{DEVROUTER_PROCESS_STATE_DIR:-/tmp}/devrouter-process-$name.state"
-[ -f "$file" ] && [ ! -L "$file" ] || exit 1
+[ ! -L "$file" ] || exit 1
+# A missing marker is positive absence: the expected process was never recorded.
+[ -f "$file" ] || exit 3
 [ "$(stat -c %s "$file")" -le 4096 ] || exit 1
 before="$(head -c 4097 "$file")"
 read -r pid pgid fingerprint extra <<<"$before"
@@ -16268,11 +16810,13 @@ identity() {
   tr '\0' '\n' <"/proc/$pid/environ" | grep -Fx "DEVROUTER_PROCESS_FINGERPRINT=$fingerprint" >/dev/null || return 1
   printf '%s' "${"$"}{fields[19]}"
 }
-birth="$(identity)"
+birth="$(identity)" || exit 3
 [ "$birth" = "$(identity)" ] || exit 1
-[ ! -L "$file" ] && [ "$before" = "$(head -c 4097 "$file")" ] || exit 1
+[ ! -L "$file" ] || exit 1
+[ "$before" = "$(head -c 4097 "$file")" ] || exit 3
 printf '%s %s %s\n' "$pid" "$birth" "$fingerprint"
 `;
+    PROCESS_ABSENT_EXIT = 3;
   }
 });
 
@@ -16317,12 +16861,12 @@ async function containers(project, signal) {
   }
   return values.sort((a, b) => a.id.localeCompare(b.id));
 }
-var import_node_crypto24, import_node_path46, OBSERVATION_INSPECT_TEMPLATE, collectControllerObservation;
+var import_node_crypto24, import_node_path47, OBSERVATION_INSPECT_TEMPLATE, collectControllerObservation;
 var init_controller_observation = __esm({
   "src/core/controller-observation.ts"() {
     "use strict";
     import_node_crypto24 = require("crypto");
-    import_node_path46 = __toESM(require("path"));
+    import_node_path47 = __toESM(require("path"));
     init_controller_binding();
     init_controller_monitor();
     init_controller_probe();
@@ -16365,14 +16909,14 @@ var init_controller_observation = __esm({
       )).trim().split("\n");
       if (metadata.length !== 2) throw new Error("Observation ownership paths unavailable.");
       const [gitDir, commonDir] = metadata;
-      const sourcePath = import_node_path46.default.join(environment.repoPath, ".devcontainer/devcontainer.json");
+      const sourcePath = import_node_path47.default.join(environment.repoPath, ".devcontainer/devcontainer.json");
       const files = [
-        import_node_path46.default.join(commonDir, "devrouter/workspaces", `${environment.workspace}.json`),
-        import_node_path46.default.join(environment.repoPath, ".devrouter.yml"),
-        import_node_path46.default.join(gitDir, "devrouter-workspace"),
+        import_node_path47.default.join(commonDir, "devrouter/workspaces", `${environment.workspace}.json`),
+        import_node_path47.default.join(environment.repoPath, ".devrouter.yml"),
+        import_node_path47.default.join(gitDir, "devrouter-workspace"),
         managedRuntimeStatePath(environment.repoPath, environment.workspace),
         sourcePath,
-        import_node_path46.default.join(environment.repoPath, MANAGED_DEVCONTAINER_PATH)
+        import_node_path47.default.join(environment.repoPath, MANAGED_DEVCONTAINER_PATH)
       ];
       const persisted = captureControllerEvidence(files);
       if (controllerBindingFingerprint(persisted.contents[0], persisted.contents[1]) !== environment.fingerprint)
@@ -16397,7 +16941,7 @@ var init_controller_observation = __esm({
       if (!journal) throw new Error("Observation journal is unavailable.");
       const routes = readRoutes().filter((route) => route.repoPath === environment.repoPath);
       const before = await containers(state.composeProject, signal);
-      const composeDirectory = import_node_path46.default.join(environment.repoPath, ".devcontainer");
+      const composeDirectory = import_node_path47.default.join(environment.repoPath, ".devcontainer");
       const references = typeof source.dockerComposeFile === "string" ? [source.dockerComposeFile] : source.dockerComposeFile;
       if (!Array.isArray(references) || !references.length || references.some((value) => typeof value !== "string"))
         throw new Error("Observation Compose source is unavailable.");
@@ -16414,7 +16958,7 @@ var init_controller_observation = __esm({
         if (!recorded || container.labels["com.docker.compose.project.working_dir"] !== composeDirectory)
           throw new Error("Observation Compose ownership is unavailable.");
         const files2 = recorded.split(",").map((file) => file.trim());
-        if (files2.some((file) => !import_node_path46.default.isAbsolute(file)) || !hasExactComposeIdentity(container, {
+        if (files2.some((file) => !import_node_path47.default.isAbsolute(file)) || !hasExactComposeIdentity(container, {
           repoPath: environment.repoPath,
           service: container.labels["com.docker.compose.service"] ?? "",
           composeProject: state.composeProject,
@@ -16488,10 +17032,14 @@ var init_controller_observation = __esm({
       ];
       const processes = [];
       let processesVerified = healthy;
+      let processesAbsent = false;
       if (healthy && requirements.some((value) => value.startsWith("app:"))) {
         try {
-          for (const name of profile.managedRuntime.processes)
-            processes.push(await observeControllerProcess(primary[0].id, name, signal));
+          for (const name of profile.managedRuntime.processes) {
+            const observation = await observeControllerProcess(primary[0].id, name, signal);
+            if (observation.kind === "absent") processesAbsent = true;
+            else processes.push(observation.identity);
+          }
         } catch (error) {
           if (signal.aborted) throw error;
           processesVerified = false;
@@ -16505,7 +17053,7 @@ var init_controller_observation = __esm({
         const routeMatches = routes.some(
           (route) => route.workspace === environment.workspace && route.name === app.name && route.host === app.host && route.mode === "proxy" && route.upstreamHost === upstream.upstreamHost && route.port === upstream.port
         );
-        const http2 = healthy && routeMatches && processesVerified ? await probeHttpReadiness(
+        const http2 = healthy && routeMatches && processesVerified && !processesAbsent ? await probeHttpReadiness(
           app.host,
           app.readiness,
           signal,
@@ -16514,7 +17062,7 @@ var init_controller_observation = __esm({
         ) : void 0;
         capabilities.push({
           capability: controllerCapability(requirement),
-          infrastructure: healthy && routeMatches ? "healthy" : "unknown",
+          infrastructure: healthy && routeMatches ? processesAbsent ? "failed" : "healthy" : "unknown",
           application: http2?.ok ? "verified" : http2?.classification === "application-contract" ? "unready" : "unverified",
           observedAtMs: 0,
           validForMs: 15e3
@@ -16522,13 +17070,15 @@ var init_controller_observation = __esm({
       }
       if (processesVerified && requirements.some((value) => value.startsWith("app:"))) {
         try {
-          for (let index = 0; index < profile.managedRuntime.processes.length; index++)
-            if (processes[index] !== await observeControllerProcess(
+          for (let index = 0; index < profile.managedRuntime.processes.length; index++) {
+            const recheck = await observeControllerProcess(
               primary[0].id,
               profile.managedRuntime.processes[index],
               signal
-            ))
+            );
+            if (recheck.kind !== "present" || processes[index] !== recheck.identity)
               throw new Error("Observation process changed.");
+          }
         } catch (error) {
           if (signal.aborted) throw error;
           for (const capability of capabilities)
@@ -16773,26 +17323,26 @@ var init_controller_sessions = __esm({
 
 // src/core/controller-server.ts
 function privateDirectory(directory) {
-  const absolute2 = import_node_path47.default.resolve(directory);
-  let current = import_node_path47.default.parse(absolute2).root;
-  for (const part of absolute2.slice(current.length).split(import_node_path47.default.sep)) {
-    current = import_node_path47.default.join(current, part);
+  const absolute2 = import_node_path48.default.resolve(directory);
+  let current = import_node_path48.default.parse(absolute2).root;
+  for (const part of absolute2.slice(current.length).split(import_node_path48.default.sep)) {
+    current = import_node_path48.default.join(current, part);
     try {
-      const stat2 = import_node_fs36.default.lstatSync(current);
+      const stat2 = import_node_fs37.default.lstatSync(current);
       if (!stat2.isDirectory() || stat2.isSymbolicLink())
         throw new Error("Unsafe controller directory.");
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
-      import_node_fs36.default.mkdirSync(current, { mode: 448 });
+      import_node_fs37.default.mkdirSync(current, { mode: 448 });
     }
   }
-  const stat = import_node_fs36.default.lstatSync(absolute2);
+  const stat = import_node_fs37.default.lstatSync(absolute2);
   if (stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
     throw new Error("Controller directory is not private.");
 }
 function validateOwnedFile(file, socket) {
   try {
-    const stat = import_node_fs36.default.lstatSync(file);
+    const stat = import_node_fs37.default.lstatSync(file);
     if (stat.uid !== process.getuid?.() || (socket ? !stat.isSocket() : !stat.isFile()) || (stat.mode & 63) !== 0)
       throw new Error("Unsafe controller artifact.");
     return true;
@@ -16804,19 +17354,19 @@ function validateOwnedFile(file, socket) {
 async function runController(options) {
   if (options.operations && options.createOperations)
     throw new Error("Controller operations have multiple owners.");
-  const socketPath = import_node_path47.default.join(options.directory, "control.sock");
+  const socketPath = import_node_path48.default.join(options.directory, "control.sock");
   if (Buffer.byteLength(socketPath) > 103) throw new Error("Controller socket path is too long.");
   privateDirectory(options.directory);
-  const lockPath = import_node_path47.default.join(options.directory, "owner.lock");
+  const lockPath = import_node_path48.default.join(options.directory, "owner.lock");
   try {
-    const stat = import_node_fs36.default.lstatSync(lockPath);
+    const stat = import_node_fs37.default.lstatSync(lockPath);
     if (!stat.isFile() || stat.uid !== process.getuid?.())
       throw new Error("Unsafe controller owner lock.");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
   await withFileLock(lockPath, { activity: "controller ownership", waitMs: 0 }, async () => {
-    if (validateOwnedFile(socketPath, true)) import_node_fs36.default.unlinkSync(socketPath);
+    if (validateOwnedFile(socketPath, true)) import_node_fs37.default.unlinkSync(socketPath);
     const sessions = new ControllerSessions(new ControllerStore(options.directory));
     const incarnation = sessions.read();
     let startupAvailable = true;
@@ -16839,12 +17389,19 @@ async function runController(options) {
     let serial = Promise.resolve();
     const monotonic = () => Math.floor(performance.now());
     let fatal;
-    const monitor = options.collect ? new ControllerMonitor(sessions, options.collect, (operation) => {
-      const pending = serial.then(operation);
-      serial = pending.catch(() => {
-      });
-      return pending;
-    }) : void 0;
+    const monitor = options.collect ? new ControllerMonitor(
+      sessions,
+      options.collect,
+      (operation) => {
+        const pending = serial.then(operation);
+        serial = pending.catch(() => {
+        });
+        return pending;
+      },
+      void 0,
+      void 0,
+      operations?.recover
+    ) : void 0;
     const server = import_node_net4.default.createServer((socket) => {
       if (sockets.size >= 32) {
         socket.destroy();
@@ -17198,7 +17755,7 @@ async function runController(options) {
           resolve();
         });
       });
-      import_node_fs36.default.chmodSync(socketPath, 384);
+      import_node_fs37.default.chmodSync(socketPath, 384);
       await new Promise((resolve) => {
         finish = resolve;
         options.signal.addEventListener("abort", shutdown, { once: true });
@@ -17217,13 +17774,13 @@ async function runController(options) {
     }
   });
 }
-var import_node_fs36, import_node_net4, import_node_path47, FRAME_BYTES;
+var import_node_fs37, import_node_net4, import_node_path48, FRAME_BYTES;
 var init_controller_server = __esm({
   "src/core/controller-server.ts"() {
     "use strict";
-    import_node_fs36 = __toESM(require("fs"));
+    import_node_fs37 = __toESM(require("fs"));
     import_node_net4 = __toESM(require("net"));
-    import_node_path47 = __toESM(require("path"));
+    import_node_path48 = __toESM(require("path"));
     init_controller_monitor();
     init_controller_protocol();
     init_controller_sessions();
@@ -17240,7 +17797,7 @@ __export(controller_exports, {
   runControllerCommand: () => runControllerCommand
 });
 async function runControllerCommand(method, options, repo, dependencies = {}) {
-  const directory = import_node_path48.default.join(DEVROUTER_HOME, "controller");
+  const directory = import_node_path49.default.join(DEVROUTER_HOME, "controller");
   try {
     if (method === "run") {
       const controller = new AbortController();
@@ -17275,7 +17832,7 @@ async function runControllerCommand(method, options, repo, dependencies = {}) {
     if (fields2.timeout !== void 0) fields2.timeout = Number(fields2.timeout);
     await controllerRequest(
       directory,
-      { method, ...fields2, ...repo ? { path: import_node_path48.default.resolve(repo) } : {} },
+      { method, ...fields2, ...repo ? { path: import_node_path49.default.resolve(repo) } : {} },
       (value) => process.stdout.write(`${JSON.stringify(value)}
 `)
     );
@@ -17290,11 +17847,11 @@ async function runControllerCommand(method, options, repo, dependencies = {}) {
     process.exitCode = 1;
   }
 }
-var import_node_path48;
+var import_node_path49;
 var init_controller = __esm({
   "src/commands/controller.ts"() {
     "use strict";
-    import_node_path48 = __toESM(require("path"));
+    import_node_path49 = __toESM(require("path"));
     init_capacity_collector();
     init_capacity_controller();
     init_capacity_policy();
@@ -17345,28 +17902,28 @@ function replaceDevrouterSection(content) {
   return `${content.slice(0, start)}${buildDevrouterSection()}${content.slice(end)}`;
 }
 function writeRepoFile(repoPath, relPath, content) {
-  const absolutePath = (0, import_node_path49.join)(repoPath, relPath);
-  (0, import_node_fs37.mkdirSync)((0, import_node_path49.dirname)(absolutePath), { recursive: true });
-  (0, import_node_fs37.writeFileSync)(absolutePath, content, "utf-8");
+  const absolutePath = (0, import_node_path50.join)(repoPath, relPath);
+  (0, import_node_fs38.mkdirSync)((0, import_node_path50.dirname)(absolutePath), { recursive: true });
+  (0, import_node_fs38.writeFileSync)(absolutePath, content, "utf-8");
   return absolutePath;
 }
 function ensureAgentsMdSection(repoPath) {
-  const filePath = (0, import_node_path49.join)(repoPath, AGENTS_MD);
-  if ((0, import_node_fs37.existsSync)(filePath)) {
-    const content = (0, import_node_fs37.readFileSync)(filePath, "utf-8");
+  const filePath = (0, import_node_path50.join)(repoPath, AGENTS_MD);
+  if ((0, import_node_fs38.existsSync)(filePath)) {
+    const content = (0, import_node_fs38.readFileSync)(filePath, "utf-8");
     if (content.includes(DEVROUTER_SENTINEL)) {
       const updated = replaceDevrouterSection(content);
       if (updated === void 0 || updated === content) return { path: filePath, written: false };
-      (0, import_node_fs37.writeFileSync)(filePath, updated, "utf-8");
+      (0, import_node_fs38.writeFileSync)(filePath, updated, "utf-8");
       return { path: filePath, written: true };
     }
-    (0, import_node_fs37.writeFileSync)(filePath, `${content.trimEnd()}
+    (0, import_node_fs38.writeFileSync)(filePath, `${content.trimEnd()}
 
 ${buildDevrouterSection()}
 `, "utf-8");
     return { path: filePath, written: true };
   }
-  (0, import_node_fs37.writeFileSync)(filePath, `# AGENTS.md
+  (0, import_node_fs38.writeFileSync)(filePath, `# AGENTS.md
 
 ${buildDevrouterSection()}
 `, "utf-8");
@@ -17376,12 +17933,12 @@ function ensureSkillFile(repoPath) {
   const filePath = writeRepoFile(repoPath, DEVROUTER_SKILL_REL_PATH, DEVROUTER_SKILL_CONTENT);
   return { path: filePath, written: true };
 }
-var import_node_fs37, import_node_path49, DEVROUTER_SENTINEL, DEVROUTER_END_SENTINEL, LEGACY_DEVROUTER_SECTION_END, AGENTS_MD, DEVROUTER_SKILL_REL_PATH, DEVROUTER_SKILL_CONTENT;
+var import_node_fs38, import_node_path50, DEVROUTER_SENTINEL, DEVROUTER_END_SENTINEL, LEGACY_DEVROUTER_SECTION_END, AGENTS_MD, DEVROUTER_SKILL_REL_PATH, DEVROUTER_SKILL_CONTENT;
 var init_agents_md = __esm({
   "src/core/agents-md.ts"() {
     "use strict";
-    import_node_fs37 = require("fs");
-    import_node_path49 = require("path");
+    import_node_fs38 = require("fs");
+    import_node_path50 = require("path");
     DEVROUTER_SENTINEL = "<!-- devrouter -->";
     DEVROUTER_END_SENTINEL = "<!-- /devrouter -->";
     LEGACY_DEVROUTER_SECTION_END = "- `devrouter ls`";
@@ -17918,8 +18475,8 @@ function buildOnboardingPrompt(options = {}) {
     "- Lifecycle: after one-time setup, use `devrouter ensure .` for both primary and linked checkouts; never branch on checkout kind or use live verify as startup. Managed consumer images contain no devrouter package/helper: ensure delivers its matching helper at runtime and invokes an exact captured snapshot of the repository-owned post-start adapter. Keep `.devrouter.yml` as the only consumer-side version pin. Use `devrouter stop .` for a non-destructive pause, `devrouter stop . --delete` only for explicit exact-owner cleanup without removing the checkout, and `devrouter exec . -- <command...>` for container commands. Never substitute raw DevPod/Devsy mutations; they bypass the machine-global ownership lock, which serializes provider mutations in a fair arrival-order queue and lets contenders wait up to thirty minutes with throttled stderr progress before failing with the queue position or holder PID and true durations. `workspace up` creates linked worktrees; destructive worktree removal and GC remain ledger-scoped.",
     "- After a drained interrupted ensure, manual exec can use an exactly proven retained Devsy runtime with the plain local Docker command. Revalidate identity for each tooling command until later preparation reconciles startup; preserve configuration, data and interrupted history. This does not repair absent stop baselines or provide OOM protection.",
     "- Busy ensure and exec wait up to thirty minutes for a positively identified active lifecycle worker on the same checkout, with stderr progress. Do not stop healthy work to make room. Commands stay serial; timeout or cancellation before admission leaves prior work untouched. A lifecycle fence change cancels admission, and uncertain execution is never replayed.",
-    "- Ensure reconciles interrupted or never-dispatched ensure after positive worker drainage. Unknown arbitrary exec never replays; use explicit stop to reconcile that uncertainty. Preserve journals and generated configuration if evidence is unavailable. This does not prevent OOM or activate capacity-managed recovery.",
-    "- Capacity admission is opt-in: only an operator-enabled capacity policy with an enrolled checkout routes ensure and exec through controller admission. The CLI follows the decision with bounded reconnecting waits that survive controller restarts, worker results are journalled atomically, and stop bypasses admission. Without an enabled policy lifecycle behavior is unchanged.",
+    "- Ensure reconciles interrupted or never-dispatched ensure after positive worker drainage. Unknown arbitrary exec never replays; use explicit stop to reconcile that uncertainty. Preserve journals and generated configuration if evidence is unavailable. This does not detect or prevent OOM; bounded automatic recovery runs only when the operator enables the capacity recovery policy.",
+    "- Capacity admission is opt-in: only an operator-enabled capacity policy with an enrolled checkout routes ensure and exec through controller admission. The CLI follows the decision with bounded reconnecting waits that survive controller restarts, worker results are journalled atomically, and stop bypasses admission. Without an enabled policy lifecycle behavior is unchanged. An optional recovery block adds bounded automatic recovery: one journal-admitted corrective ensure per positively failed required capability, bounded by per-scope restart counts, an aggregate corrective-action cap and a rolling observation window. It is inert unless enabled.",
     "- A lock that cannot prove its owner fails closed with the failing inspection stage, the exact lock path, and a portable reproduction command; run the canonical command in a permitted host context. No identity fallback is attempted, and `devrouter controller` prints the underlying cause on stderr while keeping the stable `controller-unavailable` JSON on stdout.",
     "- Devsy agent readiness: run `devrouter setup --yes --workspace-runtime devsy` once so Devrouter acquires and verifies the pinned agent in its own machine cache. `doctor` reports `ready`, `missing`, `stale`, or `invalid` without network access, and `ensure` fails before the provider queue when readiness is not `ready`. An explicit `DEVSY_AGENT_BINARY` remains authoritative and must match a pinned official asset.",
     "- A managed adapter plus `postCreateCommand` requires `waitFor` exactly `postCreateCommand` or `postStartCommand`; managed selective config preserves lifecycle fields and changes only `runServices`.",
@@ -18106,7 +18663,7 @@ var init_ai_prompt = __esm({
       },
       {
         command: "devrouter stop [path] [--delete] [--json]",
-        purpose: "Stop the exact checkout workspace runtime and routes; --delete explicitly deletes the ownership-proven runtime without removing the checkout."
+        purpose: "Stop the exact checkout workspace runtime and routes, or prove absence after pre-registration failure; --delete explicitly deletes the ownership-proven runtime without removing the checkout."
       },
       {
         command: "devrouter exec [path] -- <command...>",
@@ -18660,11 +19217,11 @@ function extractCurrentVersionFromRepoConfig(repoPath) {
   };
 }
 function readPromptDirectory(promptDirPath) {
-  if (!import_node_fs38.default.existsSync(promptDirPath)) {
+  if (!import_node_fs39.default.existsSync(promptDirPath)) {
     throw new Error(`Missing ${UPGRADE_PROMPTS_DIR} directory at ${promptDirPath}.`);
   }
   const releases = [];
-  const files = import_node_fs38.default.readdirSync(promptDirPath, { withFileTypes: true });
+  const files = import_node_fs39.default.readdirSync(promptDirPath, { withFileTypes: true });
   for (const file of files) {
     if (!file.isFile() || !file.name.endsWith(".md")) {
       continue;
@@ -18674,8 +19231,8 @@ function readPromptDirectory(promptDirPath) {
       continue;
     }
     const version = normalizeVersion(basename);
-    const promptPath = import_node_path50.default.join(promptDirPath, file.name);
-    const prompt = import_node_fs38.default.readFileSync(promptPath, "utf-8").trim();
+    const promptPath = import_node_path51.default.join(promptDirPath, file.name);
+    const prompt = import_node_fs39.default.readFileSync(promptPath, "utf-8").trim();
     releases.push({ version, prompt, promptPath });
   }
   const deduped = /* @__PURE__ */ new Map();
@@ -18696,19 +19253,19 @@ function listAvailableUpgradeTargets(currentVersion, releases) {
 }
 function resolvePromptDirectory(explicitPath) {
   if (explicitPath) {
-    return import_node_path50.default.resolve(explicitPath);
+    return import_node_path51.default.resolve(explicitPath);
   }
-  const entryFile = process.argv[1] ? import_node_path50.default.resolve(process.argv[1]) : __filename;
-  const entryDir = import_node_path50.default.dirname(entryFile);
-  const resolvedEntryDir = import_node_fs38.default.existsSync(entryFile) ? import_node_path50.default.dirname(import_node_fs38.default.realpathSync(entryFile)) : entryDir;
+  const entryFile = process.argv[1] ? import_node_path51.default.resolve(process.argv[1]) : __filename;
+  const entryDir = import_node_path51.default.dirname(entryFile);
+  const resolvedEntryDir = import_node_fs39.default.existsSync(entryFile) ? import_node_path51.default.dirname(import_node_fs39.default.realpathSync(entryFile)) : entryDir;
   const candidates = [
-    import_node_path50.default.resolve(resolvedEntryDir, "..", UPGRADE_PROMPTS_DIR),
-    import_node_path50.default.resolve(entryDir, "..", UPGRADE_PROMPTS_DIR),
-    import_node_path50.default.resolve(__dirname, "..", UPGRADE_PROMPTS_DIR),
-    import_node_path50.default.resolve(__dirname, "..", "..", UPGRADE_PROMPTS_DIR),
-    import_node_path50.default.resolve(process.cwd(), UPGRADE_PROMPTS_DIR)
+    import_node_path51.default.resolve(resolvedEntryDir, "..", UPGRADE_PROMPTS_DIR),
+    import_node_path51.default.resolve(entryDir, "..", UPGRADE_PROMPTS_DIR),
+    import_node_path51.default.resolve(__dirname, "..", UPGRADE_PROMPTS_DIR),
+    import_node_path51.default.resolve(__dirname, "..", "..", UPGRADE_PROMPTS_DIR),
+    import_node_path51.default.resolve(process.cwd(), UPGRADE_PROMPTS_DIR)
   ];
-  const existing = candidates.find((candidate) => import_node_fs38.default.existsSync(candidate));
+  const existing = candidates.find((candidate) => import_node_fs39.default.existsSync(candidate));
   return existing ?? candidates[0];
 }
 function loadUpgradeCatalog(options = {}) {
@@ -18724,12 +19281,12 @@ function loadUpgradeCatalog(options = {}) {
     releases
   };
 }
-var import_node_fs38, import_node_path50, SEMVER_RE, UPGRADE_PROMPTS_DIR;
+var import_node_fs39, import_node_path51, SEMVER_RE, UPGRADE_PROMPTS_DIR;
 var init_upgrade = __esm({
   "src/core/upgrade.ts"() {
     "use strict";
-    import_node_fs38 = __toESM(require("fs"));
-    import_node_path50 = __toESM(require("path"));
+    import_node_fs39 = __toESM(require("fs"));
+    import_node_path51 = __toESM(require("path"));
     init_repo_config();
     SEMVER_RE = /^v?(\d+)\.(\d+)\.(\d+)$/;
     UPGRADE_PROMPTS_DIR = "upgrade-prompts";
@@ -18872,7 +19429,7 @@ function isLoopbackHost(host) {
   return host === "127.0.0.1" || host === "localhost" || host === "host.docker.internal";
 }
 function inspectCompose(composeFile, _workspace) {
-  if (!import_node_fs39.default.existsSync(composeFile)) {
+  if (!import_node_fs40.default.existsSync(composeFile)) {
     return {
       aliases: [],
       publishedPorts: [],
@@ -18881,7 +19438,7 @@ function inspectCompose(composeFile, _workspace) {
     };
   }
   try {
-    const raw = import_node_fs39.default.readFileSync(composeFile, "utf-8");
+    const raw = import_node_fs40.default.readFileSync(composeFile, "utf-8");
     const parsed = import_yaml5.default.parse(raw);
     const root = asRecord(parsed);
     const services = asRecord(root?.services);
@@ -18977,11 +19534,11 @@ function buildHostPortClaimsCheck(repoPath, workspace) {
   }
 }
 function buildDevcontainerChecks(repoPath, config, workspace) {
-  const devcontainerDir = import_node_path51.default.join(repoPath, ".devcontainer");
-  if (!import_node_fs39.default.existsSync(devcontainerDir)) {
+  const devcontainerDir = import_node_path52.default.join(repoPath, ".devcontainer");
+  if (!import_node_fs40.default.existsSync(devcontainerDir)) {
     return [];
   }
-  const compose = inspectCompose(import_node_path51.default.join(devcontainerDir, "docker-compose.yml"), workspace);
+  const compose = inspectCompose(import_node_path52.default.join(devcontainerDir, "docker-compose.yml"), workspace);
   const checks = [];
   if (compose.parseError) {
     checks.push({
@@ -19008,9 +19565,9 @@ function buildDevcontainerChecks(repoPath, config, workspace) {
     details: compose.publishedPorts.length > 0 ? compose.publishedPorts.join(", ") : void 0,
     suggestion: compose.parseError || compose.publishedPorts.length > 0 ? "Remove published ports and route services through devnet aliases with devrouter proxy apps." : void 0
   });
-  const dockerfilePath = import_node_path51.default.join(devcontainerDir, "Dockerfile");
-  const dockerfileExists = import_node_fs39.default.existsSync(dockerfilePath);
-  const dockerfile = dockerfileExists ? import_node_fs39.default.readFileSync(dockerfilePath, "utf-8") : "";
+  const dockerfilePath = import_node_path52.default.join(devcontainerDir, "Dockerfile");
+  const dockerfileExists = import_node_fs40.default.existsSync(dockerfilePath);
+  const dockerfile = dockerfileExists ? import_node_fs40.default.readFileSync(dockerfilePath, "utf-8") : "";
   const devrouterArtifacts = ["@devrouter/cli", "devrouter-process"].filter(
     (artifact) => dockerfile.includes(artifact)
   );
@@ -19068,12 +19625,12 @@ function buildDevcontainerChecks(repoPath, config, workspace) {
   });
   return checks;
 }
-var import_node_fs39, import_node_path51, import_yaml5;
+var import_node_fs40, import_node_path52, import_yaml5;
 var init_devcontainer_diagnostics = __esm({
   "src/core/devcontainer-diagnostics.ts"() {
     "use strict";
-    import_node_fs39 = __toESM(require("fs"));
-    import_node_path51 = __toESM(require("path"));
+    import_node_fs40 = __toESM(require("fs"));
+    import_node_path52 = __toESM(require("path"));
     import_yaml5 = __toESM(require("yaml"));
     init_devcontainer_profile();
     init_host_port_claims();
@@ -19168,11 +19725,11 @@ function reconcileRouteRunConflict(repoPath, app) {
     }
   }
 }
-var import_node_fs40;
+var import_node_fs41;
 var init_route_state = __esm({
   "src/core/route-state.ts"() {
     "use strict";
-    import_node_fs40 = __toESM(require("fs"));
+    import_node_fs41 = __toESM(require("fs"));
     init_host_routes();
     init_workspace();
   }
@@ -19347,7 +19904,7 @@ function toRepoStatus(repoPath) {
   const resolvedRepoPath = resolveRepoPath(repoPath);
   const configPath = getRepoConfigPath(resolvedRepoPath);
   const explicitRepo = typeof repoPath === "string" && repoPath.trim().length > 0;
-  const configExists = import_node_fs41.default.existsSync(configPath);
+  const configExists = import_node_fs42.default.existsSync(configPath);
   if (!explicitRepo && !configExists) {
     return void 0;
   }
@@ -19495,11 +20052,11 @@ async function collectRouterStatus(repoPath) {
     }
   };
 }
-var import_node_fs41;
+var import_node_fs42;
 var init_status = __esm({
   "src/core/status.ts"() {
     "use strict";
-    import_node_fs41 = __toESM(require("fs"));
+    import_node_fs42 = __toESM(require("fs"));
     init_docker();
     init_managed_runtime_state();
     init_managed_runtime_status();
@@ -19573,12 +20130,12 @@ function parseMinimumNodeMajor(value) {
   return Number(match[1]);
 }
 function readPackageJson(repoPath) {
-  const packagePath = import_node_path52.default.join(repoPath, "package.json");
-  if (!import_node_fs42.default.existsSync(packagePath)) {
+  const packagePath = import_node_path53.default.join(repoPath, "package.json");
+  if (!import_node_fs43.default.existsSync(packagePath)) {
     return void 0;
   }
   try {
-    return JSON.parse(import_node_fs42.default.readFileSync(packagePath, "utf-8"));
+    return JSON.parse(import_node_fs43.default.readFileSync(packagePath, "utf-8"));
   } catch {
     return void 0;
   }
@@ -19762,13 +20319,13 @@ function buildGlobalToolChecksWithoutTelemetry(repoPath) {
   checks.push(nodeToolchainCheck(repoPath));
   return checks;
 }
-var import_node_child_process29, import_node_fs42, import_node_path52, DEVSY_DISABLE_TELEMETRY;
+var import_node_child_process29, import_node_fs43, import_node_path53, DEVSY_DISABLE_TELEMETRY;
 var init_tool_diagnostics = __esm({
   "src/core/tool-diagnostics.ts"() {
     "use strict";
     import_node_child_process29 = require("child_process");
-    import_node_fs42 = __toESM(require("fs"));
-    import_node_path52 = __toESM(require("path"));
+    import_node_fs43 = __toESM(require("fs"));
+    import_node_path53 = __toESM(require("path"));
     init_devsy_agent();
     init_workspace_runtime();
     DEVSY_DISABLE_TELEMETRY = "DEVSY_DISABLE_TELEMETRY";
@@ -19785,10 +20342,10 @@ function inRepositoryWorkspaceScope(repoPath, worktreePath, livePaths) {
   if (livePaths.some((candidate) => sameWorkspacePath(candidate, worktreePath))) return true;
   const comparableRepo = comparableWorkspacePath(repoPath);
   const comparableWorktree = comparableWorkspacePath(worktreePath);
-  const localRoot = import_node_path53.default.join(comparableRepo, "trees") + import_node_path53.default.sep;
+  const localRoot = import_node_path54.default.join(comparableRepo, "trees") + import_node_path54.default.sep;
   if (comparableWorktree.startsWith(localRoot)) return true;
-  const legacyPrefix = `${import_node_path53.default.basename(comparableRepo)}-`;
-  return import_node_path53.default.dirname(comparableWorktree) === import_node_path53.default.dirname(comparableRepo) && import_node_path53.default.basename(comparableWorktree).startsWith(legacyPrefix);
+  const legacyPrefix = `${import_node_path54.default.basename(comparableRepo)}-`;
+  return import_node_path54.default.dirname(comparableWorktree) === import_node_path54.default.dirname(comparableRepo) && import_node_path54.default.basename(comparableWorktree).startsWith(legacyPrefix);
 }
 function previewActions(devpodStatus, routeCount, includeRecord) {
   const actions = [
@@ -20040,11 +20597,11 @@ function applyWorkspaceGc(plan) {
     candidates
   };
 }
-var import_node_path53;
+var import_node_path54;
 var init_workspace_gc = __esm({
   "src/core/workspace-gc.ts"() {
     "use strict";
-    import_node_path53 = __toESM(require("path"));
+    import_node_path54 = __toESM(require("path"));
     init_devpod_mutation();
     init_devpod_workspaces();
     init_host_routes();
@@ -20114,11 +20671,11 @@ function inspectPostgresCredentials(repoPath, config) {
         parseErrors.push(`${app.name}: ${composeFile} (${message})`);
         continue;
       }
-      if (!import_node_fs43.default.existsSync(absolutePath)) {
+      if (!import_node_fs44.default.existsSync(absolutePath)) {
         continue;
       }
       try {
-        const raw = import_node_fs43.default.readFileSync(absolutePath, "utf-8");
+        const raw = import_node_fs44.default.readFileSync(absolutePath, "utf-8");
         const parsed = import_yaml6.default.parse(raw);
         const root = asRecord2(parsed);
         const services = asRecord2(root?.services);
@@ -20398,7 +20955,7 @@ async function buildDoctorReport(options = {}) {
       const config = runtimeConfig.config;
       loadedConfig = config;
       loadedWorkspace = runtimeConfig.workspace;
-      const cliVersion = true ? "0.0.72" : "0.0.0-dev";
+      const cliVersion = true ? "0.0.74" : "0.0.0-dev";
       const configVersion = config.devrouter?.version;
       if (configVersion && cliVersion !== "0.0.0-dev" && compareSemver(configVersion, cliVersion) > 0) {
         addCheck(checks, {
@@ -20428,9 +20985,9 @@ async function buildDoctorReport(options = {}) {
         (app) => app.docker.composeFiles.map((filePath) => ({
           app: app.name,
           filePath,
-          absolutePath: import_node_path54.default.resolve(repo.path, filePath)
+          absolutePath: import_node_path55.default.resolve(repo.path, filePath)
         }))
-      ).filter((entry) => !import_node_fs43.default.existsSync(entry.absolutePath));
+      ).filter((entry) => !import_node_fs44.default.existsSync(entry.absolutePath));
       addCheck(checks, {
         id: "repo.compose-files",
         level: missingComposeFiles.length === 0 ? "ok" : "error",
@@ -20473,8 +21030,8 @@ async function buildDoctorReport(options = {}) {
       const missingHostCwds = config.apps.filter((app) => app.runtime === "host").map((app) => ({
         app: app.name,
         cwd: app.hostRun.cwd,
-        absolutePath: import_node_path54.default.resolve(repo.path, app.hostRun.cwd)
-      })).filter((entry) => !import_node_fs43.default.existsSync(entry.absolutePath));
+        absolutePath: import_node_path55.default.resolve(repo.path, app.hostRun.cwd)
+      })).filter((entry) => !import_node_fs44.default.existsSync(entry.absolutePath));
       addCheck(checks, {
         id: "repo.host-cwd",
         level: missingHostCwds.length === 0 ? "ok" : "error",
@@ -20618,12 +21175,12 @@ async function buildDoctorReport(options = {}) {
     nextSteps
   };
 }
-var import_node_fs43, import_node_path54, import_yaml6, POSTGRES_DEFAULTS;
+var import_node_fs44, import_node_path55, import_yaml6, POSTGRES_DEFAULTS;
 var init_doctor = __esm({
   "src/core/doctor.ts"() {
     "use strict";
-    import_node_fs43 = __toESM(require("fs"));
-    import_node_path54 = __toESM(require("path"));
+    import_node_fs44 = __toESM(require("fs"));
+    import_node_path55 = __toESM(require("path"));
     import_yaml6 = __toESM(require("yaml"));
     init_docker();
     init_host_routes();
@@ -21121,6 +21678,11 @@ async function runStopCommand(options) {
     return;
   }
   const label2 = result.kind === "primary" ? "Primary checkout" : `Workspace '${result.workspace}'`;
+  if (result.runtimeAbsent) {
+    process.stdout.write(`${label2} has no runtime or routes; stop is complete.
+`);
+    return;
+  }
   if (!result.stopped && !result.deleted && result.freedRoutes === 0) {
     process.stdout.write(`${label2} is already stopped; no routes needed removal.
 `);
@@ -21441,17 +22003,17 @@ function asRecord3(value) {
   return value;
 }
 function readJson(filePath) {
-  if (!import_node_fs44.default.existsSync(filePath)) {
+  if (!import_node_fs45.default.existsSync(filePath)) {
     return void 0;
   }
   try {
-    return JSON.parse(import_node_fs44.default.readFileSync(filePath, "utf-8"));
+    return JSON.parse(import_node_fs45.default.readFileSync(filePath, "utf-8"));
   } catch {
     return void 0;
   }
 }
 function relative(repoPath, filePath) {
-  return import_node_path55.default.relative(repoPath, filePath) || ".";
+  return import_node_path56.default.relative(repoPath, filePath) || ".";
 }
 function redactEnvAssignments(value) {
   return value.replace(
@@ -21492,7 +22054,7 @@ function inspectPackageManager(repoPath, pkg) {
     ["bun.lock", "bun"]
   ];
   for (const [fileName, name] of lockfiles) {
-    if (import_node_fs44.default.existsSync(import_node_path55.default.join(repoPath, fileName))) {
+    if (import_node_fs45.default.existsSync(import_node_path56.default.join(repoPath, fileName))) {
       return { name, source: fileName };
     }
   }
@@ -21507,9 +22069,9 @@ function inspectNode(repoPath, pkg) {
   if (typeof engines?.node === "string") {
     return { version: engines.node, source: "package.json:engines.node" };
   }
-  const nvmrc = import_node_path55.default.join(repoPath, ".nvmrc");
-  if (import_node_fs44.default.existsSync(nvmrc)) {
-    const version = import_node_fs44.default.readFileSync(nvmrc, "utf-8").trim();
+  const nvmrc = import_node_path56.default.join(repoPath, ".nvmrc");
+  if (import_node_fs45.default.existsSync(nvmrc)) {
+    const version = import_node_fs45.default.readFileSync(nvmrc, "utf-8").trim();
     return { version, source: ".nvmrc" };
   }
   return void 0;
@@ -21570,7 +22132,7 @@ function configuredComposeFiles(repoPath) {
     const files = config.apps.filter(
       (app) => app.runtime === "docker"
     ).flatMap((app) => app.docker.composeFiles).filter(
-      (fileName) => !import_node_path55.default.isAbsolute(fileName) && !import_node_path55.default.normalize(fileName).startsWith("..")
+      (fileName) => !import_node_path56.default.isAbsolute(fileName) && !import_node_path56.default.normalize(fileName).startsWith("..")
     );
     return Array.from(new Set(files));
   } catch {
@@ -21588,7 +22150,7 @@ function composeFiles(repoPath) {
     ...configuredComposeFiles(repoPath)
   ];
   return Array.from(new Set(candidates)).filter(
-    (fileName) => import_node_fs44.default.existsSync(import_node_path55.default.join(repoPath, fileName))
+    (fileName) => import_node_fs45.default.existsSync(import_node_path56.default.join(repoPath, fileName))
   );
 }
 function stringArray2(value) {
@@ -21626,7 +22188,7 @@ function inspectServices(repoPath) {
   const services = [];
   for (const fileName of composeFiles(repoPath)) {
     try {
-      const parsed = import_yaml7.default.parse(import_node_fs44.default.readFileSync(import_node_path55.default.join(repoPath, fileName), "utf-8"));
+      const parsed = import_yaml7.default.parse(import_node_fs45.default.readFileSync(import_node_path56.default.join(repoPath, fileName), "utf-8"));
       const serviceMap = asRecord3(asRecord3(parsed)?.services);
       for (const [name, value] of Object.entries(serviceMap ?? {})) {
         const service = asRecord3(value);
@@ -21661,8 +22223,8 @@ function inspectServices(repoPath) {
   return services;
 }
 function inspectEnvFiles(repoPath) {
-  const files = import_node_fs44.default.readdirSync(repoPath).filter((fileName) => /^\.env(\.|$)/.test(fileName)).sort().map((fileName) => {
-    const content = import_node_fs44.default.readFileSync(import_node_path55.default.join(repoPath, fileName), "utf-8");
+  const files = import_node_fs45.default.readdirSync(repoPath).filter((fileName) => /^\.env(\.|$)/.test(fileName)).sort().map((fileName) => {
+    const content = import_node_fs45.default.readFileSync(import_node_path56.default.join(repoPath, fileName), "utf-8");
     const names = content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#") && line.includes("=")).map((line) => line.split("=")[0]?.trim()).filter((name) => Boolean(name)).sort();
     return { path: fileName, names };
   });
@@ -21676,18 +22238,18 @@ function inspectEnvFiles(repoPath) {
   };
 }
 function inspectDevcontainer(repoPath) {
-  const dir = import_node_path55.default.join(repoPath, ".devcontainer");
-  if (!import_node_fs44.default.existsSync(dir)) {
+  const dir = import_node_path56.default.join(repoPath, ".devcontainer");
+  if (!import_node_fs45.default.existsSync(dir)) {
     return { exists: false, files: [] };
   }
   return {
     exists: true,
-    files: import_node_fs44.default.readdirSync(dir).filter((fileName) => import_node_fs44.default.statSync(import_node_path55.default.join(dir, fileName)).isFile()).sort().map((fileName) => `.devcontainer/${fileName}`)
+    files: import_node_fs45.default.readdirSync(dir).filter((fileName) => import_node_fs45.default.statSync(import_node_path56.default.join(dir, fileName)).isFile()).sort().map((fileName) => `.devcontainer/${fileName}`)
   };
 }
 function inspectDevrouter(repoPath) {
   const configPath = getRepoConfigPath(repoPath);
-  if (!import_node_fs44.default.existsSync(configPath)) {
+  if (!import_node_fs45.default.existsSync(configPath)) {
     return {
       exists: false,
       configPath,
@@ -21731,15 +22293,15 @@ function inspectAgentGuidance(repoPath) {
     ["AGENTS.md", "agents"],
     ["CLAUDE.md", "claude"]
   ]) {
-    if (import_node_fs44.default.existsSync(import_node_path55.default.join(repoPath, fileName))) {
+    if (import_node_fs45.default.existsSync(import_node_path56.default.join(repoPath, fileName))) {
       results.push({ path: fileName, kind });
     }
   }
-  const skillsDir = import_node_path55.default.join(repoPath, ".agents", "skills");
-  if (import_node_fs44.default.existsSync(skillsDir)) {
-    for (const name of import_node_fs44.default.readdirSync(skillsDir).sort()) {
-      const skillPath = import_node_path55.default.join(skillsDir, name, "SKILL.md");
-      if (import_node_fs44.default.existsSync(skillPath)) {
+  const skillsDir = import_node_path56.default.join(repoPath, ".agents", "skills");
+  if (import_node_fs45.default.existsSync(skillsDir)) {
+    for (const name of import_node_fs45.default.readdirSync(skillsDir).sort()) {
+      const skillPath = import_node_path56.default.join(skillsDir, name, "SKILL.md");
+      if (import_node_fs45.default.existsSync(skillPath)) {
         results.push({ path: relative(repoPath, skillPath), kind: "skill" });
       }
     }
@@ -21782,7 +22344,7 @@ function buildIssues(report) {
 }
 function inspectRepo(options = {}) {
   const repoPath = resolveRepoPath(options.repo);
-  const pkg = readJson(import_node_path55.default.join(repoPath, "package.json"));
+  const pkg = readJson(import_node_path56.default.join(repoPath, "package.json"));
   const scripts = inspectScripts(pkg);
   const reportWithoutIssues = {
     repoPath,
@@ -21801,12 +22363,12 @@ function inspectRepo(options = {}) {
     issues: buildIssues(reportWithoutIssues)
   };
 }
-var import_node_fs44, import_node_path55, import_yaml7;
+var import_node_fs45, import_node_path56, import_yaml7;
 var init_repo_inspect = __esm({
   "src/core/repo-inspect.ts"() {
     "use strict";
-    import_node_fs44 = __toESM(require("fs"));
-    import_node_path55 = __toESM(require("path"));
+    import_node_fs45 = __toESM(require("fs"));
+    import_node_path56 = __toESM(require("path"));
     import_yaml7 = __toESM(require("yaml"));
     init_repo_config();
   }
@@ -21911,7 +22473,7 @@ function requiredFileChecks(repoPath) {
     ".devcontainer/docker-compose.yml",
     ".devrouter.yml"
   ];
-  const missing = required.filter((fileName) => !import_node_fs45.default.existsSync(import_node_path56.default.join(repoPath, fileName)));
+  const missing = required.filter((fileName) => !import_node_fs46.default.existsSync(import_node_path57.default.join(repoPath, fileName)));
   return {
     id: "repo.devcontainer.verify-files",
     level: missing.length === 0 ? "ok" : "error",
@@ -22136,12 +22698,12 @@ async function verifyDevcontainer(options = {}) {
     nextSteps: collectNextSteps3(checks)
   };
 }
-var import_node_fs45, import_node_path56;
+var import_node_fs46, import_node_path57;
 var init_devcontainer_verify = __esm({
   "src/core/devcontainer-verify.ts"() {
     "use strict";
-    import_node_fs45 = __toESM(require("fs"));
-    import_node_path56 = __toESM(require("path"));
+    import_node_fs46 = __toESM(require("fs"));
+    import_node_path57 = __toESM(require("path"));
     init_capabilities();
     init_doctor();
     init_host_routes();
@@ -22438,7 +23000,7 @@ function packageManagerIssues(repo) {
 }
 function plannedFiles(repoPath, version) {
   const repo = inspectRepo({ repo: repoPath });
-  const projectName = sanitizeProjectName(import_node_path57.default.basename(repo.repoPath));
+  const projectName = sanitizeProjectName(import_node_path58.default.basename(repo.repoPath));
   const nodeMajor = majorVersion(repo.node?.version, "24");
   const pnpmVersion = repo.packageManager?.name === "pnpm" && repo.packageManager.version ? repo.packageManager.version : DEFAULT_PNPM_VERSION;
   const port = inferPort2(repo);
@@ -22483,8 +23045,8 @@ function plannedFiles(repoPath, version) {
   };
 }
 function classifyFile(repoPath, file) {
-  const absolutePath = import_node_path57.default.join(repoPath, file.relativePath);
-  if (!import_node_fs46.default.existsSync(absolutePath)) {
+  const absolutePath = import_node_path58.default.join(repoPath, file.relativePath);
+  if (!import_node_fs47.default.existsSync(absolutePath)) {
     return {
       path: file.relativePath,
       action: "create",
@@ -22492,7 +23054,7 @@ function classifyFile(repoPath, file) {
       bytes: Buffer.byteLength(file.content)
     };
   }
-  const current = import_node_fs46.default.readFileSync(absolutePath, "utf-8");
+  const current = import_node_fs47.default.readFileSync(absolutePath, "utf-8");
   if (!current.includes(MANAGED_MARKER2)) {
     return {
       path: file.relativePath,
@@ -22549,11 +23111,11 @@ function buildPlan(repoPath, dryRun, version) {
   };
 }
 function writeFile(repoPath, file) {
-  const absolutePath = import_node_path57.default.join(repoPath, file.relativePath);
-  import_node_fs46.default.mkdirSync(import_node_path57.default.dirname(absolutePath), { recursive: true });
-  import_node_fs46.default.writeFileSync(absolutePath, file.content, "utf-8");
+  const absolutePath = import_node_path58.default.join(repoPath, file.relativePath);
+  import_node_fs47.default.mkdirSync(import_node_path58.default.dirname(absolutePath), { recursive: true });
+  import_node_fs47.default.writeFileSync(absolutePath, file.content, "utf-8");
   if (file.executable) {
-    import_node_fs46.default.chmodSync(absolutePath, 493);
+    import_node_fs47.default.chmodSync(absolutePath, 493);
   }
 }
 function writeDevcontainer(options = {}) {
@@ -22591,12 +23153,12 @@ function writeDevcontainer(options = {}) {
     nextSteps: postWriteNextSteps(repoPath)
   };
 }
-var import_node_fs46, import_node_path57, MANAGED_MARKER2, DEFAULT_DEVROUTER_VERSION, DEFAULT_PNPM_VERSION, VALID_PACKAGE_VERSION_RE;
+var import_node_fs47, import_node_path58, MANAGED_MARKER2, DEFAULT_DEVROUTER_VERSION, DEFAULT_PNPM_VERSION, VALID_PACKAGE_VERSION_RE;
 var init_devcontainer_write = __esm({
   "src/core/devcontainer-write.ts"() {
     "use strict";
-    import_node_fs46 = __toESM(require("fs"));
-    import_node_path57 = __toESM(require("path"));
+    import_node_fs47 = __toESM(require("fs"));
+    import_node_path58 = __toESM(require("path"));
     init_repo_config();
     init_repo_inspect();
     MANAGED_MARKER2 = "devrouter:managed devcontainer";
@@ -22930,13 +23492,13 @@ function buildProfilePlanReport(options) {
   return { ...report, contractPath, bindings };
 }
 function loadContract(repoPath, contractPath) {
-  if (import_node_path58.default.isAbsolute(contractPath)) {
+  if (import_node_path59.default.isAbsolute(contractPath)) {
     fail3("profile plan contract path must be relative to the repository.");
   }
   const absolutePath = assertPathWithinRepo(contractPath, repoPath, "Profile plan contract");
   let metadata;
   try {
-    metadata = import_node_fs47.default.lstatSync(absolutePath);
+    metadata = import_node_fs48.default.lstatSync(absolutePath);
   } catch (error) {
     fail3(`could not inspect profile plan contract '${contractPath}': ${error.message}`);
   }
@@ -22946,16 +23508,16 @@ function loadContract(repoPath, contractPath) {
   if (metadata.size > MAX_CONTRACT_BYTES) {
     fail3(`profile plan contract exceeds the ${MAX_CONTRACT_BYTES}-byte limit.`);
   }
-  const realRepo = import_node_fs47.default.realpathSync(repoPath);
-  const realContract = import_node_fs47.default.realpathSync(absolutePath);
+  const realRepo = import_node_fs48.default.realpathSync(repoPath);
+  const realContract = import_node_fs48.default.realpathSync(absolutePath);
   assertPathWithinRepo(realContract, realRepo, "Profile plan contract");
-  const source = import_node_fs47.default.readFileSync(absolutePath, "utf-8");
+  const source = import_node_fs48.default.readFileSync(absolutePath, "utf-8");
   if (Buffer.byteLength(source, "utf-8") > MAX_CONTRACT_BYTES) {
     fail3(`profile plan contract exceeds the ${MAX_CONTRACT_BYTES}-byte limit.`);
   }
   return {
     contract: parseProfilePlanContract(source),
-    contractPath: import_node_path58.default.relative(repoPath, absolutePath).split(import_node_path58.default.sep).join("/")
+    contractPath: import_node_path59.default.relative(repoPath, absolutePath).split(import_node_path59.default.sep).join("/")
   };
 }
 function resolveProfilePlan(options) {
@@ -22969,12 +23531,12 @@ function resolveProfilePlan(options) {
     contractPath: loaded.contractPath
   });
 }
-var import_node_fs47, import_node_path58, import_yaml8, CONTRACT_VERSION, MAX_CONTRACT_BYTES, MAX_APP_MAPPINGS, MAX_BINDING_KEYS, MAX_BINDING_VALUES, MAX_LITERAL_LENGTH, BINDING_KEY;
+var import_node_fs48, import_node_path59, import_yaml8, CONTRACT_VERSION, MAX_CONTRACT_BYTES, MAX_APP_MAPPINGS, MAX_BINDING_KEYS, MAX_BINDING_VALUES, MAX_LITERAL_LENGTH, BINDING_KEY;
 var init_profile_plan = __esm({
   "src/core/profile-plan.ts"() {
     "use strict";
-    import_node_fs47 = __toESM(require("fs"));
-    import_node_path58 = __toESM(require("path"));
+    import_node_fs48 = __toESM(require("fs"));
+    import_node_path59 = __toESM(require("path"));
     import_yaml8 = require("yaml");
     init_paths();
     init_profile_resolution();
@@ -23006,7 +23568,7 @@ async function runProfileResolveCommand(options) {
 async function runProfilePlanCommand(options) {
   const report = resolveProfilePlan(options);
   if (options.output) {
-    writeFileAtomically(import_node_path59.default.resolve(options.output), `${JSON.stringify(report, null, 2)}
+    writeFileAtomically(import_node_path60.default.resolve(options.output), `${JSON.stringify(report, null, 2)}
 `);
   }
   if (options.json) {
@@ -23042,14 +23604,14 @@ function printProfilePlanSummary(report, output2) {
     process.stdout.write(`Binding ${key}: ${renderValues(report.bindings[key] ?? [])}
 `);
   }
-  if (output2) process.stdout.write(`Output: ${import_node_path59.default.resolve(output2)}
+  if (output2) process.stdout.write(`Output: ${import_node_path60.default.resolve(output2)}
 `);
 }
-var import_node_path59;
+var import_node_path60;
 var init_profile = __esm({
   "src/commands/profile.ts"() {
     "use strict";
-    import_node_path59 = __toESM(require("path"));
+    import_node_path60 = __toESM(require("path"));
     init_atomic_file();
     init_output();
     init_profile_plan();
@@ -23339,7 +23901,7 @@ function sanitizeRouterId(value) {
   return value.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function repoHash(repoPath) {
-  return (0, import_node_crypto26.createHash)("sha1").update(import_node_path60.default.resolve(repoPath)).digest("hex").slice(0, 12);
+  return (0, import_node_crypto26.createHash)("sha1").update(import_node_path61.default.resolve(repoPath)).digest("hex").slice(0, 12);
 }
 function asDockerApp(app) {
   return app.runtime === "docker";
@@ -23418,11 +23980,11 @@ function prepareDockerOverlay(repoPath, appName, apps, publishTcpPorts = false)
   if (dockerApps.length === 0) {
     throw new Error("No docker apps selected to prepare compose overlay.");
   }
-  const cachePath = import_node_path60.default.join(CACHE_DIR, repoHash(repoPath), sanitizeRouterId(appName));
-  import_node_fs48.default.mkdirSync(cachePath, { recursive: true });
-  const overlayPath = import_node_path60.default.join(cachePath, "compose.devrouter.yml");
+  const cachePath = import_node_path61.default.join(CACHE_DIR, repoHash(repoPath), sanitizeRouterId(appName));
+  import_node_fs49.default.mkdirSync(cachePath, { recursive: true });
+  const overlayPath = import_node_path61.default.join(cachePath, "compose.devrouter.yml");
   const overlayDocument = buildOverlayDocument(dockerApps, publishTcpPorts);
-  import_node_fs48.default.writeFileSync(overlayPath, import_yaml9.default.stringify(overlayDocument, { lineWidth: 0 }), "utf-8");
+  import_node_fs49.default.writeFileSync(overlayPath, import_yaml9.default.stringify(overlayDocument, { lineWidth: 0 }), "utf-8");
   return {
     overlayPath,
     composeFiles: ensureComposeFiles(dockerApps),
@@ -23542,14 +24104,14 @@ function queryMappedPort(repoPath, composeFiles2, overlayPath, service, internal
   const port = Number(match[1]);
   return Number.isInteger(port) && port > 0 ? port : void 0;
 }
-var import_node_child_process33, import_node_crypto26, import_node_fs48, import_node_path60, import_yaml9;
+var import_node_child_process33, import_node_crypto26, import_node_fs49, import_node_path61, import_yaml9;
 var init_docker_run = __esm({
   "src/core/docker-run.ts"() {
     "use strict";
     import_node_child_process33 = require("child_process");
     import_node_crypto26 = require("crypto");
-    import_node_fs48 = __toESM(require("fs"));
-    import_node_path60 = __toESM(require("path"));
+    import_node_fs49 = __toESM(require("fs"));
+    import_node_path61 = __toESM(require("path"));
     import_yaml9 = __toESM(require("yaml"));
     init_docker_error_guidance();
     init_paths();
@@ -24371,13 +24933,13 @@ function measureWorktreeConsumption(worktreePath, options) {
   const startedAt = Date.now();
   let rootStat;
   try {
-    rootStat = import_node_fs49.default.lstatSync(worktreePath);
+    rootStat = import_node_fs50.default.lstatSync(worktreePath);
   } catch (error) {
     return { status: "unknown", reason: describeError(error, worktreePath) };
   }
   let rootEntries;
   try {
-    rootEntries = import_node_fs49.default.readdirSync(worktreePath, { withFileTypes: true });
+    rootEntries = import_node_fs50.default.readdirSync(worktreePath, { withFileTypes: true });
   } catch (error) {
     return { status: "unknown", reason: describeError(error, worktreePath) };
   }
@@ -24403,10 +24965,10 @@ function measureWorktreeConsumption(worktreePath, options) {
         timedOut = true;
         break;
       }
-      const entryPath = import_node_path61.default.join(dirPath, entry.name);
+      const entryPath = import_node_path62.default.join(dirPath, entry.name);
       let entryStat;
       try {
-        entryStat = import_node_fs49.default.lstatSync(entryPath);
+        entryStat = import_node_fs50.default.lstatSync(entryPath);
       } catch (error) {
         if (error?.code === "ENOENT") continue;
         unreadableReason = describeIncompleteWalk(error);
@@ -24416,7 +24978,7 @@ function measureWorktreeConsumption(worktreePath, options) {
       if (!entryStat.isDirectory()) continue;
       let childEntries;
       try {
-        childEntries = import_node_fs49.default.readdirSync(entryPath, { withFileTypes: true });
+        childEntries = import_node_fs50.default.readdirSync(entryPath, { withFileTypes: true });
       } catch (error) {
         unreadableReason = describeIncompleteWalk(error);
         break;
@@ -24480,12 +25042,12 @@ function describeError(error, worktreePath) {
   }
   return `could not stat worktree path '${worktreePath}': ${error?.message ?? String(error)}`;
 }
-var import_node_fs49, import_node_path61, DEFAULT_DEADLINE_MS, BLOCK_SIZE_BYTES;
+var import_node_fs50, import_node_path62, DEFAULT_DEADLINE_MS, BLOCK_SIZE_BYTES;
 var init_workspace_consumption = __esm({
   "src/core/workspace-consumption.ts"() {
     "use strict";
-    import_node_fs49 = __toESM(require("fs"));
-    import_node_path61 = __toESM(require("path"));
+    import_node_fs50 = __toESM(require("fs"));
+    import_node_path62 = __toESM(require("path"));
     init_devpod_environment();
     DEFAULT_DEADLINE_MS = 1e4;
     BLOCK_SIZE_BYTES = 512;
@@ -24586,7 +25148,7 @@ function evaluateWorkspaceActivity(evidence, cutoff) {
 }
 function readGitSnapshot(worktree, commandRunner) {
   const comparablePath = comparableWorkspacePath(worktree.path);
-  if (worktree.prunable || !import_node_fs50.default.existsSync(comparablePath)) {
+  if (worktree.prunable || !import_node_fs51.default.existsSync(comparablePath)) {
     return { worktree, checkout: "missing", head: null, committerDate: null };
   }
   const head = gitOutput(comparablePath, ["rev-parse", "--verify", "HEAD"], commandRunner);
@@ -25111,7 +25673,7 @@ function buildWorkspaceCleanupReport(options = {}, dependencies = {}) {
       containers2 = measureContainersFn(worktreePaths);
     } catch (error) {
       const reason = `container measurement failed: ${describeCause(error)}`;
-      containers2 = new Map(worktreePaths.map((path62) => [path62, unknownContainers(reason)]));
+      containers2 = new Map(worktreePaths.map((path63) => [path63, unknownContainers(reason)]));
     }
   }
   const rows2 = records.map((record5) => {
@@ -25161,12 +25723,12 @@ function buildWorkspaceCleanupReport(options = {}, dependencies = {}) {
     networkCapacity: (dependencies.inspectNetworkCapacity ?? inspectNetworkCapacity)()
   };
 }
-var import_node_child_process35, import_node_fs50, DEFAULT_INACTIVE_FOR, READ_ONLY_GIT_ENV2, ACTIVITY_SOURCES, defaultCommandRunner;
+var import_node_child_process35, import_node_fs51, DEFAULT_INACTIVE_FOR, READ_ONLY_GIT_ENV2, ACTIVITY_SOURCES, defaultCommandRunner;
 var init_workspace_cleanup = __esm({
   "src/core/workspace-cleanup.ts"() {
     "use strict";
     import_node_child_process35 = require("child_process");
-    import_node_fs50 = __toESM(require("fs"));
+    import_node_fs51 = __toESM(require("fs"));
     init_devpod_workspaces();
     init_host_routes();
     init_network_diagnostics();
@@ -25278,7 +25840,7 @@ function warnMissingWorkspaceOwnership(repoPath) {
   );
 }
 function defaultWorktreePath(mainRepo, ws) {
-  return import_node_path62.default.join(mainRepo, "trees", ws);
+  return import_node_path63.default.join(mainRepo, "trees", ws);
 }
 function assertDefaultWorktreeRootIgnored(mainRepo) {
   const ignored = (0, import_node_child_process36.spawnSync)("git", ["-C", mainRepo, "check-ignore", "-q", "--no-index", "trees/"], {
@@ -25286,12 +25848,12 @@ function assertDefaultWorktreeRootIgnored(mainRepo) {
   });
   if (ignored.status !== 0) {
     throw new Error(
-      `Default worktree root '${import_node_path62.default.join(mainRepo, "trees")}' is not ignored. Add 'trees/' to '${import_node_path62.default.join(mainRepo, ".gitignore")}' or use --path.`
+      `Default worktree root '${import_node_path63.default.join(mainRepo, "trees")}' is not ignored. Add 'trees/' to '${import_node_path63.default.join(mainRepo, ".gitignore")}' or use --path.`
     );
   }
 }
 function legacyDefaultWorktreePath(mainRepo, ws) {
-  return import_node_path62.default.join(import_node_path62.default.dirname(mainRepo), `${import_node_path62.default.basename(mainRepo)}-${ws}`);
+  return import_node_path63.default.join(import_node_path63.default.dirname(mainRepo), `${import_node_path63.default.basename(mainRepo)}-${ws}`);
 }
 function teardownFallbackPath(mainRepo, workspace) {
   const candidates = [
@@ -25403,7 +25965,7 @@ function assertFullDownPreflight(mainRepo, target) {
   if (sameWorkspacePath(target.worktreePath, mainRepo)) {
     throw new Error("Refusing to remove the primary Git checkout.");
   }
-  if (!target.worktree || target.worktree.prunable || !import_node_fs51.default.existsSync(target.worktreePath)) return;
+  if (!target.worktree || target.worktree.prunable || !import_node_fs52.default.existsSync(target.worktreePath)) return;
   if (target.worktree.locked) {
     throw new Error(
       `Worktree '${target.worktreePath}' is locked; unlock it before workspace down.`
@@ -25443,9 +26005,9 @@ async function workspaceUp(branch, opts = {}) {
       (candidate) => defaultWorktreePath(mainRepo, candidate)
     );
     const generatedPath = candidatePaths.find(
-      (candidate) => !import_node_fs51.default.existsSync(candidate) && !worktrees.some((worktree) => sameWorkspacePath(worktree.path, candidate))
+      (candidate) => !import_node_fs52.default.existsSync(candidate) && !worktrees.some((worktree) => sameWorkspacePath(worktree.path, candidate))
     );
-    const selectedPath = opts.path ? import_node_path62.default.resolve(opts.path) : existingBranch?.path ?? generatedPath;
+    const selectedPath = opts.path ? import_node_path63.default.resolve(opts.path) : existingBranch?.path ?? generatedPath;
     if (!selectedPath) {
       throw new Error(`Could not allocate a collision-safe worktree path for branch '${branch}'.`);
     }
@@ -25454,7 +26016,7 @@ async function workspaceUp(branch, opts = {}) {
         `Branch '${branch}' already uses worktree '${existingBranch.path}', not '${selectedPath}'.`
       );
     }
-    if (import_node_fs51.default.existsSync(selectedPath)) {
+    if (import_node_fs52.default.existsSync(selectedPath)) {
       const registered = worktrees.find(
         (worktree) => sameWorkspacePath(worktree.path, selectedPath)
       );
@@ -25557,7 +26119,7 @@ async function mutateWorkspaceRuntime(action2, resolved, worktrees, quiet = fals
     );
   }
   const retained = action2 === "stop" ? readManagedRuntimeState(resolved.worktreePath, resolved.workspace) : void 0;
-  let absent = false;
+  let absent = mutation.status === "proven-absent";
   const remove = () => {
     if (retained?.stopBaseline) {
       absent = proveManagedStop(retained).status === "proven-absent";
@@ -25566,6 +26128,11 @@ async function mutateWorkspaceRuntime(action2, resolved, worktrees, quiet = fals
       ))
         throw new Error("Absent stop contains routes outside the retained desired set.");
     }
+    if (absent && !retained) {
+      if (listRoutesForWorktreePath(resolved.worktreePath).length)
+        throw new Error("Initial managed stop observed remaining workspace routes.");
+      return [];
+    }
     claimLifecycleEffect();
     return removeWorkspaceRoutesForWorktree(resolved.workspace, resolved.worktreePath);
   };
@@ -25601,7 +26168,8 @@ async function runWorkspaceLifecycle(action2, target, opts = {}) {
       workspace: resolved.workspace,
       devpodId: stopped.devpodId,
       freedRoutes: stopped.freedRoutes,
-      providerChanged: stopped.stopped
+      providerChanged: stopped.stopped && !stopped.runtimeAbsent,
+      ...stopped.runtimeAbsent ? { runtimeAbsent: true } : {}
     };
   }
   const operation = async () => {
@@ -25611,7 +26179,7 @@ async function runWorkspaceLifecycle(action2, target, opts = {}) {
     }
     const result = await mutateWorkspaceRuntime("delete", resolved, worktrees, opts.quiet);
     if (removeWorktree) {
-      if (resolved.worktree && !resolved.worktree.prunable && import_node_fs51.default.existsSync(resolved.worktreePath)) {
+      if (resolved.worktree && !resolved.worktree.prunable && import_node_fs52.default.existsSync(resolved.worktreePath)) {
         const rm = (0, import_node_child_process36.spawnSync)("git", ["-C", mainRepo, "worktree", "remove", resolved.worktreePath], {
           encoding: "utf-8"
         });
@@ -25630,7 +26198,7 @@ async function runWorkspaceLifecycle(action2, target, opts = {}) {
     }
     return result;
   };
-  return resolved.worktree && !resolved.worktree.prunable && import_node_fs51.default.existsSync(resolved.worktreePath) ? withLifecycleOperationLock(resolved.worktreePath, operation) : operation();
+  return resolved.worktree && !resolved.worktree.prunable && import_node_fs52.default.existsSync(resolved.worktreePath) ? withLifecycleOperationLock(resolved.worktreePath, operation) : operation();
 }
 async function workspaceStop(target, opts = {}) {
   return runWorkspaceLifecycle("stop", target, opts);
@@ -25638,13 +26206,13 @@ async function workspaceStop(target, opts = {}) {
 async function workspaceDown(target, opts = {}) {
   return runWorkspaceLifecycle("down", target, opts);
 }
-var import_node_child_process36, import_node_fs51, import_node_path62, WORKSPACE_ALLOCATION_LOCK_WAIT_MS;
+var import_node_child_process36, import_node_fs52, import_node_path63, WORKSPACE_ALLOCATION_LOCK_WAIT_MS;
 var init_workspace_lifecycle = __esm({
   "src/core/workspace-lifecycle.ts"() {
     "use strict";
     import_node_child_process36 = require("child_process");
-    import_node_fs51 = __toESM(require("fs"));
-    import_node_path62 = __toESM(require("path"));
+    import_node_fs52 = __toESM(require("fs"));
+    import_node_path63 = __toESM(require("path"));
     init_devpod_mutation();
     init_devpod_workspaces();
     init_devsy_mutation();
@@ -25828,7 +26396,7 @@ var init_version = __esm({
 
 // src/cli.ts
 var import_commander = require("commander");
-var CLI_VERSION = true ? "0.0.72" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.0.74" : "0.0.0-dev";
 var VERSION_FLAGS = /* @__PURE__ */ new Set(["-V", "--version"]);
 function withErrorHandling(action2) {
   return async (...args) => {
@@ -26201,10 +26769,10 @@ workspaceCommand2.command("down").description("Delete a workspace's runtime and
 workspaceCommand2.command("journal").description("Inspect and recover workspace lifecycle journals").command("settle").description(
   "Settle an interrupted lifecycle operation as unobservable so ensure and stop can proceed"
 ).argument("[path]", "Checkout path (defaults to current directory)").option("--json", "Output JSON").action(
-  withErrorHandling(async (path62, _options, command) => {
+  withErrorHandling(async (path63, _options, command) => {
     const options = command.opts();
     const { runWorkspaceJournalSettleCommand: runWorkspaceJournalSettleCommand2 } = await Promise.resolve().then(() => (init_workspace2(), workspace_exports));
-    await runWorkspaceJournalSettleCommand2({ ...path62 ? { path: path62 } : {}, ...options });
+    await runWorkspaceJournalSettleCommand2({ ...path63 ? { path: path63 } : {}, ...options });
   })
 );
 function parseVersionRequest(argv) {