@devrouter/cli 0.1.1 → 0.1.3

package/dist/devrouter.js

@@ -4275,7 +4275,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.1.1" : "0.0.0-dev";
+    const cliVersion = true ? "0.1.3" : "0.0.0-dev";
     if (cliVersion !== "0.0.0-dev" && compareSemver(requiredVersion, cliVersion) > 0) {
       hasWarnedVersionMismatch = true;
       process.stderr.write(
@@ -5263,10 +5263,11 @@ function serializeSnapshot(snapshot) {
     throw new Error("Capacity reservation snapshot exceeds byte limit.");
   return contents;
 }
-var import_node_fs9, import_node_path11, MAX_BYTES2, CapacityHistoryError, CapacitySnapshotChangedError, CapacityStore;
+var import_node_crypto6, import_node_fs9, import_node_path11, MAX_BYTES2, CapacityHistoryError, CapacitySnapshotChangedError, CapacityStore;
 var init_capacity_store = __esm({
   "src/core/capacity-store.ts"() {
     "use strict";
+    import_node_crypto6 = require("crypto");
     import_node_fs9 = __toESM(require("fs"));
     import_node_path11 = __toESM(require("path"));
     init_atomic_file();
@@ -5274,11 +5275,13 @@ var init_capacity_store = __esm({
     init_file_lock();
     MAX_BYTES2 = 1048576;
     CapacityHistoryError = class extends Error {
-      constructor(code) {
+      constructor(code, cause = null, location = null) {
         super(
           code === "capacity-ledger-lost" ? "Capacity ledger history is lost; restore verified capacity-reservations.json." : "Capacity history cannot be proven; inspect the private lifecycle journals."
         );
         this.code = code;
+        this.cause = cause;
+        this.location = location;
         this.name = "CapacityHistoryError";
       }
     };
@@ -5351,9 +5354,10 @@ var init_capacity_store = __esm({
           const buffer = Buffer.alloc(MAX_BYTES2 + 1);
           const count = import_node_fs9.default.readSync(descriptor, buffer, 0, buffer.length, 0);
           if (count > MAX_BYTES2) throw new Error("Capacity reservation snapshot exceeds byte limit.");
-          const value = JSON.parse(buffer.subarray(0, count).toString("utf8"));
+          const bytes2 = buffer.subarray(0, count);
+          const value = JSON.parse(bytes2.toString("utf8"));
           validate(value);
-          this.ledgerGeneration = `${stat.dev}:${stat.ino}`;
+          this.ledgerGeneration = this.generationIdentity(stat, bytes2);
           if (value.revision < minimumRevision) return { kind: "stale", revision: value.revision };
           this.observedLedger = true;
           return { kind: "intact", revision: value.revision, snapshot: value };
@@ -5406,20 +5410,30 @@ var init_capacity_store = __esm({
         return snapshot;
       }
       commit(snapshot) {
-        this.write(this.file, serializeSnapshot(snapshot));
+        const contents = serializeSnapshot(snapshot);
+        this.write(this.file, contents);
         this.observedLedger = true;
-        this.rememberGeneration();
+        this.rememberGeneration(contents);
         this.establish();
       }
       /** Remember the published snapshot identity for the next generation fence. */
-      rememberGeneration() {
+      rememberGeneration(contents) {
         try {
           const stat = import_node_fs9.default.statSync(this.file);
-          this.ledgerGeneration = stat.isFile() ? `${stat.dev}:${stat.ino}` : void 0;
+          this.ledgerGeneration = stat.isFile() ? this.generationIdentity(stat, contents) : void 0;
         } catch {
           this.ledgerGeneration = void 0;
         }
       }
+      /**
+       * File identity plus content digest. Deleting and recreating the snapshot can
+       * reuse its inode number, so the inode alone cannot fence a replacement that
+       * reuses a revision number.
+       */
+      generationIdentity(stat, contents) {
+        const digest3 = (0, import_node_crypto6.createHash)("sha256").update(contents).digest("hex");
+        return `${stat.dev}:${stat.ino}:${digest3}`;
+      }
       /**
        * Durable evidence that recorded history is gone, for a stop whose physical
        * cessation is already proven. The caller holds that proof; this writes no
@@ -5898,11 +5912,11 @@ function retain(session, previous) {
     environment: { ...environment }
   };
 }
-var import_node_crypto6, import_node_fs10, import_node_path12, CONTROLLER_SNAPSHOT_BYTES, EVENT_KINDS, LEGACY_EVENT_KINDS, PROJECTION_STATUSES, ControllerStore;
+var import_node_crypto7, import_node_fs10, import_node_path12, CONTROLLER_SNAPSHOT_BYTES, EVENT_KINDS, LEGACY_EVENT_KINDS, PROJECTION_STATUSES, ControllerStore;
 var init_controller_store = __esm({
   "src/core/controller-store.ts"() {
     "use strict";
-    import_node_crypto6 = require("crypto");
+    import_node_crypto7 = require("crypto");
     import_node_fs10 = __toESM(require("fs"));
     import_node_path12 = __toESM(require("path"));
     init_atomic_file();
@@ -5993,7 +6007,7 @@ var init_controller_store = __esm({
       provenance(identity2) {
         if (identity2.version !== 2) throw new Error("Controller binding provenance is unavailable.");
         return {
-          digest: (0, import_node_crypto6.createHash)("sha256").update(JSON.stringify(["devrouter-controller-binding-v1", identity2.store, identity2.key])).digest("hex"),
+          digest: (0, import_node_crypto7.createHash)("sha256").update(JSON.stringify(["devrouter-controller-binding-v1", identity2.store, identity2.key])).digest("hex"),
           enrolledEpoch: identity2.enrolledEpoch
         };
       }
@@ -6017,7 +6031,7 @@ var init_controller_store = __esm({
           if (!current || current.store !== captured.store || current.epoch !== captured.epoch || JSON.stringify(current.fingerprint) !== JSON.stringify(captured.fingerprint) || identity2?.version !== 2)
             throw new Error("Controller binding incarnation changed.");
           this.checkProvenance(current, identity2);
-          return (0, import_node_crypto6.createHmac)("sha256", Buffer.from(identity2.key, "hex")).update(JSON.stringify({ owner, config })).digest("hex");
+          return (0, import_node_crypto7.createHmac)("sha256", Buffer.from(identity2.key, "hex")).update(JSON.stringify({ owner, config })).digest("hex");
         };
       }
       read() {
@@ -6070,7 +6084,7 @@ var init_controller_store = __esm({
         const identity2 = existing?.version === 2 ? existing : {
           version: 2,
           store,
-          key: (0, import_node_crypto6.randomBytes)(32).toString("hex"),
+          key: (0, import_node_crypto7.randomBytes)(32).toString("hex"),
           enrolledEpoch: epoch
         };
         if (existing?.version !== 2)
@@ -6116,7 +6130,7 @@ var init_controller_store = __esm({
         if (!previous) {
           previous = {
             version: 2,
-            store: (0, import_node_crypto6.randomUUID)(),
+            store: (0, import_node_crypto7.randomUUID)(),
             epoch: 0,
             revision: 0,
             parkingRevision: 0,
@@ -6259,7 +6273,7 @@ var init_reliability_contract = __esm({
 
 // src/core/reliability-operation-store.ts
 function installedCliVersion() {
-  return true ? "0.1.1" : "0.0.0-dev";
+  return true ? "0.1.3" : "0.0.0-dev";
 }
 function compareCliVersions(left, right) {
   const parts = (value) => value.split(".").map((part) => Number.parseInt(part, 10) || 0);
@@ -6275,7 +6289,7 @@ function identityKey(identity2) {
   if (!import_node_path13.default.isAbsolute(identity2.repoPath) || import_node_path13.default.resolve(identity2.repoPath) !== identity2.repoPath || identity2.repoPath.includes("\0") || identity2.workspace !== null && !isReliabilityId(identity2.workspace) || !["devpod", "devsy"].includes(identity2.provider)) {
     throw new Error("Invalid reliability workspace identity.");
   }
-  return (0, import_node_crypto7.createHash)("sha256").update(identity2.repoPath).digest("hex");
+  return (0, import_node_crypto8.createHash)("sha256").update(identity2.repoPath).digest("hex");
 }
 function reliabilityOperationPath(identity2) {
   return import_node_path13.default.join(DEVROUTER_HOME, "reliability", `${identityKey(identity2)}.json`);
@@ -6392,6 +6406,7 @@ function validate2(record5, identity2) {
     "revision",
     "state",
     "worker",
+    "stopWorkStarted",
     "effectSequence",
     "outcome",
     "result",
@@ -6573,13 +6588,24 @@ function validate2(record5, identity2) {
       throw new Error("Reliability worker identity is invalid.");
     }
   }
+  if (record5.stopWorkStarted !== void 0 && record5.stopWorkStarted !== null) {
+    if (record5.stopWorkStarted !== true) throw new Error("Invalid stop work marker.");
+  }
+}
+function journalEntryLocation(name) {
+  const printable = name.replace(/[^A-Za-z0-9._-]/g, "?");
+  return printable.length > MAX_REPORTED_ENTRY_NAME ? `${printable.slice(0, MAX_REPORTED_ENTRY_NAME - 3)}...` : printable;
 }
 function createLifecycleCapacityStore(directory = import_node_path13.default.join(DEVROUTER_HOME, "controller")) {
   return new CapacityStore(directory, void 0, () => {
     try {
       return listUnsettledCapacityBindings().floor;
-    } catch {
-      throw new CapacityHistoryError("capacity-history-unprovable");
+    } catch (error) {
+      throw error instanceof ReliabilityJournalError ? new CapacityHistoryError("capacity-history-unprovable", error.cause, error.location) : new CapacityHistoryError(
+        "capacity-history-unprovable",
+        "journal-enumeration-failed",
+        null
+      );
     }
   });
 }
@@ -6638,11 +6664,12 @@ function readBoundedPrivateJson(file, label2) {
   try {
     const stat = import_node_fs11.default.fstatSync(descriptor);
     if (!stat.isFile() || stat.uid !== process.getuid?.() || stat.size > MAX_RECORD_BYTES || (stat.mode & 63) !== 0) {
-      throw new Error(`${label2} is not a bounded private file.`);
+      throw new JournalFileGuardError(`${label2} is not a bounded private file.`);
     }
     const bytes2 = Buffer.alloc(MAX_RECORD_BYTES + 1);
     const count = import_node_fs11.default.readSync(descriptor, bytes2, 0, bytes2.length, 0);
-    if (count > MAX_RECORD_BYTES) throw new Error(`${label2} exceeds its byte limit.`);
+    if (count > MAX_RECORD_BYTES)
+      throw new JournalFileGuardError(`${label2} exceeds its byte limit.`);
     return JSON.parse(bytes2.subarray(0, count).toString("utf8"));
   } finally {
     import_node_fs11.default.closeSync(descriptor);
@@ -6650,7 +6677,11 @@ function readBoundedPrivateJson(file, label2) {
 }
 function assertReliabilityEnumerationTime(startedAtMs) {
   if (performance.now() - startedAtMs > MAX_RELIABILITY_ENUMERATION_MS)
-    throw new Error("Reliability journal enumeration exceeded its time limit.");
+    throw new ReliabilityJournalError(
+      "journal-enumeration-timeout",
+      null,
+      "Reliability journal enumeration exceeded its time limit."
+    );
 }
 function reliabilityDirectory() {
   return import_node_path13.default.join(DEVROUTER_HOME, "reliability");
@@ -6671,22 +6702,56 @@ function listReliabilityOperations() {
     stat = import_node_fs11.default.lstatSync(directory);
   } catch (error) {
     if (error.code === "ENOENT") return [];
-    throw error;
+    throw new ReliabilityJournalError(
+      "journal-directory-unreadable",
+      null,
+      "Reliability journal directory could not be read."
+    );
   }
   if (!stat.isDirectory() || stat.isSymbolicLink())
-    throw new Error("Reliability journal directory is unsafe.");
+    throw new ReliabilityJournalError(
+      "journal-directory-unsafe",
+      null,
+      "Reliability journal directory is unsafe."
+    );
   if (stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
-    throw new Error("Reliability journal directory is not private.");
+    throw new ReliabilityJournalError(
+      "journal-directory-unsafe",
+      null,
+      "Reliability journal directory is not private."
+    );
   const entries = [];
-  const handle = import_node_fs11.default.opendirSync(directory);
+  let handle;
+  try {
+    handle = import_node_fs11.default.opendirSync(directory);
+  } catch {
+    throw new ReliabilityJournalError(
+      "journal-directory-unreadable",
+      null,
+      "Reliability journal directory could not be read."
+    );
+  }
   try {
     for (; ; ) {
       assertReliabilityEnumerationTime(startedAtMs);
-      const entry = handle.readSync();
+      let entry;
+      try {
+        entry = handle.readSync();
+      } catch {
+        throw new ReliabilityJournalError(
+          "journal-directory-unreadable",
+          null,
+          "Reliability journal directory could not be read."
+        );
+      }
       if (!entry) break;
       entries.push(entry);
       if (entries.length > MAX_RELIABILITY_DIRECTORY_ENTRIES)
-        throw new Error("Reliability journal directory exceeds its entry limit.");
+        throw new ReliabilityJournalError(
+          "journal-enumeration-limit",
+          null,
+          "Reliability journal directory exceeds its entry limit."
+        );
     }
   } finally {
     handle.closeSync();
@@ -6695,27 +6760,82 @@ function listReliabilityOperations() {
   for (const entry of entries) {
     assertReliabilityEnumerationTime(startedAtMs);
     if (entry.isSymbolicLink())
-      throw new Error("Reliability journal directory contains a symlink.");
+      throw new ReliabilityJournalError(
+        "journal-entry-unsupported",
+        journalEntryLocation(entry.name),
+        "Reliability journal directory contains a symlink."
+      );
     if (!entry.isFile())
-      throw new Error("Reliability journal directory contains an unsupported entry.");
+      throw new ReliabilityJournalError(
+        "journal-entry-unsupported",
+        journalEntryLocation(entry.name),
+        "Reliability journal directory contains an unsupported entry."
+      );
     if (RELIABILITY_LOCK_NAME_RE.test(entry.name) || RELIABILITY_ATOMIC_TEMP_NAME_RE.test(entry.name))
       continue;
     const match = RELIABILITY_JOURNAL_NAME_RE.exec(entry.name);
-    if (!match) throw new Error("Reliability journal directory contains an unsupported entry.");
+    if (!match)
+      throw new ReliabilityJournalError(
+        "journal-entry-unsupported",
+        journalEntryLocation(entry.name),
+        "Reliability journal directory contains an unsupported entry."
+      );
     journals.push({ name: entry.name, key: match[1] });
   }
   if (journals.length > MAX_RELIABILITY_JOURNALS)
-    throw new Error("Reliability journal directory exceeds its journal limit.");
+    throw new ReliabilityJournalError(
+      "journal-enumeration-limit",
+      null,
+      "Reliability journal directory exceeds its journal limit."
+    );
   journals.sort((left, right) => left.name.localeCompare(right.name));
   const records = [];
   for (const journal of journals) {
     assertReliabilityEnumerationTime(startedAtMs);
     const file = import_node_path13.default.join(directory, journal.name);
-    const identity2 = journalIdentity(readBoundedPrivateJson(file, "Reliability journal"));
-    if (identityKey(identity2) !== journal.key)
-      throw new Error("Reliability journal filename does not match its identity.");
-    const record5 = readReliabilityOperation(identity2);
-    if (!record5) throw new Error("Reliability journal disappeared during enumeration.");
+    let raw;
+    try {
+      raw = readBoundedPrivateJson(file, "Reliability journal");
+    } catch (error) {
+      const fsCode = error?.code;
+      const cause = error instanceof JournalFileGuardError ? "journal-entry-unsafe" : error instanceof SyntaxError || !fsCode ? "journal-invalid" : "journal-unreadable";
+      throw new ReliabilityJournalError(
+        cause,
+        journalEntryLocation(journal.name),
+        error instanceof JournalFileGuardError ? error.message : cause === "journal-invalid" ? "Reliability journal entry is invalid." : "Reliability journal entry could not be read."
+      );
+    }
+    if (raw === void 0)
+      throw new ReliabilityJournalError(
+        "journal-unstable",
+        journalEntryLocation(journal.name),
+        "Reliability journal disappeared during enumeration."
+      );
+    let identity2;
+    let record5;
+    try {
+      identity2 = journalIdentity(raw);
+      if (identityKey(identity2) !== journal.key)
+        throw new ReliabilityJournalError(
+          "journal-identity-mismatch",
+          journalEntryLocation(journal.name),
+          "Reliability journal filename does not match its identity."
+        );
+      record5 = readReliabilityOperation(identity2);
+    } catch (error) {
+      if (error instanceof ReliabilityJournalError) throw error;
+      throw new ReliabilityJournalError(
+        "journal-invalid",
+        journalEntryLocation(journal.name),
+        "Reliability journal entry is invalid."
+      );
+    }
+    if (!record5)
+      throw new ReliabilityJournalError(
+        "journal-unstable",
+        journalEntryLocation(journal.name),
+        "Reliability journal disappeared during enumeration."
+      );
     records.push(record5);
     assertReliabilityEnumerationTime(startedAtMs);
   }
@@ -6872,11 +6992,11 @@ function setReliabilityHumanPin(identity2, expectedJournalRevision, expectedProt
     };
   });
 }
-var import_node_crypto7, import_node_fs11, import_node_path13, import_node_util3, MAX_RECORD_BYTES, MAX_RELIABILITY_JOURNALS, MAX_RELIABILITY_DIRECTORY_ENTRIES, MAX_RELIABILITY_ENUMERATION_MS, RELIABILITY_JOURNAL_NAME_RE, RELIABILITY_LOCK_NAME_RE, RELIABILITY_ATOMIC_TEMP_NAME_RE;
+var import_node_crypto8, import_node_fs11, import_node_path13, import_node_util3, MAX_RECORD_BYTES, MAX_RELIABILITY_JOURNALS, MAX_RELIABILITY_DIRECTORY_ENTRIES, MAX_RELIABILITY_ENUMERATION_MS, RELIABILITY_JOURNAL_NAME_RE, RELIABILITY_LOCK_NAME_RE, RELIABILITY_ATOMIC_TEMP_NAME_RE, ReliabilityJournalError, MAX_REPORTED_ENTRY_NAME, JournalFileGuardError;
 var init_reliability_operation_store = __esm({
   "src/core/reliability-operation-store.ts"() {
     "use strict";
-    import_node_crypto7 = require("crypto");
+    import_node_crypto8 = require("crypto");
     import_node_fs11 = __toESM(require("fs"));
     import_node_path13 = __toESM(require("path"));
     import_node_util3 = require("util");
@@ -6893,6 +7013,21 @@ var init_reliability_operation_store = __esm({
     RELIABILITY_JOURNAL_NAME_RE = /^([0-9a-f]{64})\.json$/;
     RELIABILITY_LOCK_NAME_RE = /^[0-9a-f]{64}\.json\.lock(?:\.[0-9]+\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.candidate(?:\.stale)?|\.queue\.[0-9]+\.[0-9]+\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}(?:\.candidate)?)?$/;
     RELIABILITY_ATOMIC_TEMP_NAME_RE = /^\.[0-9a-f]{64}\.json\.[0-9]+\.[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.tmp$/;
+    ReliabilityJournalError = class extends Error {
+      constructor(cause, location, message) {
+        super(message);
+        this.cause = cause;
+        this.location = location;
+        this.name = "ReliabilityJournalError";
+      }
+    };
+    MAX_REPORTED_ENTRY_NAME = 160;
+    JournalFileGuardError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "JournalFileGuardError";
+      }
+    };
   }
 });
 
@@ -7258,7 +7393,7 @@ var init_managed_stop_baseline = __esm({
 
 // src/core/managed-runtime-state.ts
 function stateKey(repoPath, workspace) {
-  return (0, import_node_crypto8.createHash)("sha256").update(`${repoPath}\0${workspace ?? ""}`, "utf-8").digest("hex");
+  return (0, import_node_crypto9.createHash)("sha256").update(`${repoPath}\0${workspace ?? ""}`, "utf-8").digest("hex");
 }
 function managedRuntimeStatePath(repoPath, workspace) {
   return import_node_path17.default.join(DEVROUTER_HOME, "managed-runtime", `${stateKey(repoPath, workspace)}.json`);
@@ -7337,11 +7472,11 @@ function readManagedRuntimeState(repoPath, workspace, read2 = (file) => import_n
   }
   return validateState(parsed, repoPath, workspace);
 }
-var import_node_crypto8, import_node_fs13, import_node_path17;
+var import_node_crypto9, import_node_fs13, import_node_path17;
 var init_managed_runtime_state = __esm({
   "src/core/managed-runtime-state.ts"() {
     "use strict";
-    import_node_crypto8 = require("crypto");
+    import_node_crypto9 = require("crypto");
     import_node_fs13 = __toESM(require("fs"));
     import_node_path17 = __toESM(require("path"));
     init_atomic_file();
@@ -8416,7 +8551,7 @@ async function observeControllerBinding(directory, input2) {
   };
 }
 async function controllerRequest(directory, input2, emit, timeoutMs) {
-  const request2 = parseControllerRequest({ ...input2, version: 1, id: (0, import_node_crypto9.randomUUID)() });
+  const request2 = parseControllerRequest({ ...input2, version: 1, id: (0, import_node_crypto10.randomUUID)() });
   const socketPath = import_node_path20.default.join(directory, "control.sock");
   const stat = import_node_fs14.default.lstatSync(socketPath);
   if (!stat.isSocket() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
@@ -8426,7 +8561,7 @@ async function controllerRequest(directory, input2, emit, timeoutMs) {
     let buffer = Buffer.alloc(0);
     let handshake = false;
     let completed = false;
-    const handshakeId = (0, import_node_crypto9.randomUUID)();
+    const handshakeId = (0, import_node_crypto10.randomUUID)();
     const timeout = request2.method === "watch" || request2.method === "operation-watch" ? Math.min(request2.timeout + 5, 2147483) * 1e3 : 5e3;
     const timer = setTimeout(
       () => {
@@ -8492,11 +8627,11 @@ async function controllerRequest(directory, input2, emit, timeoutMs) {
     });
   });
 }
-var import_node_crypto9, import_node_fs14, import_node_net, import_node_path20, CONTROLLER_OPERATION_WATCH_SECONDS, CONTROLLER_OPERATION_DEFAULT_WAIT_SECONDS, CONTROLLER_OPERATION_MAX_WAIT_SECONDS, CONTROLLER_ID_RE2, ControllerResponseDeadlineError, ControllerOperationSubmissionError;
+var import_node_crypto10, import_node_fs14, import_node_net, import_node_path20, CONTROLLER_OPERATION_WATCH_SECONDS, CONTROLLER_OPERATION_DEFAULT_WAIT_SECONDS, CONTROLLER_OPERATION_MAX_WAIT_SECONDS, CONTROLLER_ID_RE2, ControllerResponseDeadlineError, ControllerOperationSubmissionError;
 var init_controller_client = __esm({
   "src/core/controller-client.ts"() {
     "use strict";
-    import_node_crypto9 = require("crypto");
+    import_node_crypto10 = require("crypto");
     import_node_fs14 = __toESM(require("fs"));
     import_node_net = __toESM(require("net"));
     import_node_path20 = __toESM(require("path"));
@@ -8632,11 +8767,11 @@ var init_reliability_output = __esm({
 
 // src/core/controller-monitor.ts
 function controllerCapability(selector) {
-  return selector === "runtime" ? "runtime" : `app-${(0, import_node_crypto10.createHash)("sha256").update(selector).digest("hex")}`;
+  return selector === "runtime" ? "runtime" : `app-${(0, import_node_crypto11.createHash)("sha256").update(selector).digest("hex")}`;
 }
 function sessionConsumerId(input2) {
   const { store, epoch, session, generation } = input2;
-  return `session-${(0, import_node_crypto10.createHash)("sha256").update(JSON.stringify([store, epoch, session, generation])).digest("hex")}`;
+  return `session-${(0, import_node_crypto11.createHash)("sha256").update(JSON.stringify([store, epoch, session, generation])).digest("hex")}`;
 }
 function environmentIdentity(environment) {
   return {
@@ -8657,11 +8792,11 @@ function parkingConsumers(consumers) {
     consentRevision
   })).sort((a, b) => a.id.localeCompare(b.id));
 }
-var import_node_crypto10, import_node_util7, ControllerObservationBindingChanged, UNFINISHED_PARK_SCAN_MS, ControllerMonitor;
+var import_node_crypto11, import_node_util7, ControllerObservationBindingChanged, UNFINISHED_PARK_SCAN_MS, ControllerMonitor;
 var init_controller_monitor = __esm({
   "src/core/controller-monitor.ts"() {
     "use strict";
-    import_node_crypto10 = require("crypto");
+    import_node_crypto11 = require("crypto");
     import_node_util7 = require("util");
     init_reliability_operation_store();
     init_reliability_output();
@@ -8935,7 +9070,7 @@ var init_controller_monitor = __esm({
                 const projections = /* @__PURE__ */ new Map();
                 for (const consumer of consumers) {
                   const transient = structuredClone(journal.state);
-                  const consumerId = `observer-${(0, import_node_crypto10.createHash)("sha256").update(consumer.id).digest("hex")}`;
+                  const consumerId = `observer-${(0, import_node_crypto11.createHash)("sha256").update(consumer.id).digest("hex")}`;
                   transient.consumers = [
                     {
                       id: consumerId,
@@ -9055,9 +9190,11 @@ function listDevsyWorkspaces() {
   );
   if (result.status !== 0) {
     const details = [result.error?.message, result.stdout, result.stderr].filter(Boolean).join("\n").trim();
-    throw new Error(
+    const failure2 = new Error(
       `devsy workspace list failed: ${details || "devsy is not installed or unavailable"}`
     );
+    if (result.error) failure2.code = result.error.code;
+    throw failure2;
   }
   let parsed;
   try {
@@ -9353,7 +9490,7 @@ function writeManifestRecord(cacheRoot, manifest) {
   import_node_fs16.default.mkdirSync(directory, { recursive: true, mode: 448 });
   const temporary = import_node_path22.default.join(
     directory,
-    `.${DEVSY_AGENT_MANIFEST_FILE}.${process.pid}.${(0, import_node_crypto11.randomUUID)()}.tmp`
+    `.${DEVSY_AGENT_MANIFEST_FILE}.${process.pid}.${(0, import_node_crypto12.randomUUID)()}.tmp`
   );
   const record5 = {
     version: 1,
@@ -9451,7 +9588,7 @@ function managedBinaryPath(cacheRoot, devsyVersion, asset) {
   return import_node_path22.default.join(cacheRoot, `v${devsyVersion}`, asset.name);
 }
 function hashOpenFile(file) {
-  const digest3 = (0, import_node_crypto11.createHash)("sha256");
+  const digest3 = (0, import_node_crypto12.createHash)("sha256");
   const buffer = Buffer.allocUnsafe(1024 * 1024);
   let position = 0;
   for (; ; ) {
@@ -9647,7 +9784,7 @@ async function downloadAndPublish(asset, binaryPath, fetcher, githubCliDownloade
   import_node_fs16.default.mkdirSync(directory, { recursive: true, mode: 448 });
   const temporaryPath = import_node_path22.default.join(
     directory,
-    `.${import_node_path22.default.basename(binaryPath)}.${process.pid}.${(0, import_node_crypto11.randomUUID)()}.tmp`
+    `.${import_node_path22.default.basename(binaryPath)}.${process.pid}.${(0, import_node_crypto12.randomUUID)()}.tmp`
   );
   let handle;
   try {
@@ -9659,7 +9796,7 @@ async function downloadAndPublish(asset, binaryPath, fetcher, githubCliDownloade
       directFailure = error;
     }
     handle = await import_node_fs16.default.promises.open(temporaryPath, "wx", 384);
-    const digest3 = (0, import_node_crypto11.createHash)("sha256");
+    const digest3 = (0, import_node_crypto12.createHash)("sha256");
     let size = 0;
     const writeChunk = async (chunk) => {
       size += chunk.byteLength;
@@ -9795,12 +9932,12 @@ async function prepareDevsyAgent(options = {}) {
     return { ...preparedFromInspection(published), changed: true, transport };
   });
 }
-var import_node_child_process7, import_node_crypto11, import_node_fs16, import_node_path22, PINNED_DEVSY_AGENT_VERSION, SUPPORTED_DEVSY_MIN_VERSION, SUPPORTED_DEVSY_MAX_VERSION, SUPPORTED_DEVSY_RANGE, DEVSY_AGENT_SETUP_COMMAND, DEVSY_RELEASE_TAG_PREFIX, DEVSY_RELEASE_METADATA_BASE_URL, DEVSY_AGENT_ASSETS, DevsyAgentReadinessError, DEVSY_AGENT_CACHE_LOCK, DEVSY_AGENT_LOCK_WAIT_MS, DEVSY_AGENT_MANIFEST_FILE, DEVSY_AGENT_ASSET_NAMES, GITHUB_CLI_STDERR_TAIL_BYTES;
+var import_node_child_process7, import_node_crypto12, import_node_fs16, import_node_path22, PINNED_DEVSY_AGENT_VERSION, SUPPORTED_DEVSY_MIN_VERSION, SUPPORTED_DEVSY_MAX_VERSION, SUPPORTED_DEVSY_RANGE, DEVSY_AGENT_SETUP_COMMAND, DEVSY_RELEASE_TAG_PREFIX, DEVSY_RELEASE_METADATA_BASE_URL, DEVSY_AGENT_ASSETS, DevsyAgentReadinessError, DEVSY_AGENT_CACHE_LOCK, DEVSY_AGENT_LOCK_WAIT_MS, DEVSY_AGENT_MANIFEST_FILE, DEVSY_AGENT_ASSET_NAMES, GITHUB_CLI_STDERR_TAIL_BYTES;
 var init_devsy_agent = __esm({
   "src/core/devsy-agent.ts"() {
     "use strict";
     import_node_child_process7 = require("child_process");
-    import_node_crypto11 = require("crypto");
+    import_node_crypto12 = require("crypto");
     import_node_fs16 = __toESM(require("fs"));
     import_node_path22 = __toESM(require("path"));
     init_file_lock();
@@ -10037,7 +10174,7 @@ function isWildcard(values) {
   return values?.length === 1 && values[0] === "*";
 }
 function sha256(contents) {
-  return (0, import_node_crypto12.createHash)("sha256").update(contents, "utf-8").digest("hex");
+  return (0, import_node_crypto13.createHash)("sha256").update(contents, "utf-8").digest("hex");
 }
 function safeComposeProject(value) {
   if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value)) {
@@ -10123,6 +10260,9 @@ ${JSON.stringify(effective, null, 2)}
     contents
   };
 }
+function writeManagedDevcontainerConfig(plan) {
+  writeFileAtomically(plan.generatedPath, plan.contents);
+}
 function inspectManagedDevcontainerGeneratedConfig(plan) {
   let stat;
   try {
@@ -10260,12 +10400,12 @@ function stopExactManagedService(containerId, service, options) {
     throw new Error(`Could not stop exact managed service '${service}' (${containerId}).`);
   }
 }
-var import_node_child_process8, import_node_crypto12, import_node_fs18, import_node_path25, import_yaml3, MANAGED_DEVCONTAINER_PATH, MANAGED_DEVCONTAINER_MARKER, COMPOSE_HASH_TIMEOUT_MS;
+var import_node_child_process8, import_node_crypto13, import_node_fs18, import_node_path25, import_yaml3, MANAGED_DEVCONTAINER_PATH, MANAGED_DEVCONTAINER_MARKER, COMPOSE_HASH_TIMEOUT_MS;
 var init_devcontainer_profile = __esm({
   "src/core/devcontainer-profile.ts"() {
     "use strict";
     import_node_child_process8 = require("child_process");
-    import_node_crypto12 = require("crypto");
+    import_node_crypto13 = require("crypto");
     import_node_fs18 = __toESM(require("fs"));
     import_node_path25 = __toESM(require("path"));
     import_yaml3 = __toESM(require("yaml"));
@@ -10291,7 +10431,11 @@ function listDevpodWorkspacesRaw(options = {}) {
   }
   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"}`);
+    const failure2 = new Error(
+      `devpod list failed: ${details || "devpod is not installed or unavailable"}`
+    );
+    if (result.error) failure2.code = result.error.code;
+    throw failure2;
   }
   let parsed;
   try {
@@ -10583,25 +10727,23 @@ function writeWorkspaceRuntimeConfig(config) {
   writeFileAtomically(RUNTIME_CONFIG_FILE, `${JSON.stringify(next, null, 2)}
 `);
 }
+function readRegistrySnapshot(runtime, read2, snapshots) {
+  try {
+    return read2();
+  } catch (error) {
+    if (error?.code === "ENOENT") return void 0;
+    snapshots.unavailable.push(runtime);
+    snapshots.errors[runtime] = error instanceof Error ? error.message : String(error);
+    return void 0;
+  }
+}
 function getWorkspaceRegistrySnapshots() {
   if (cachedSnapshots) return cachedSnapshots;
   const snapshots = { unavailable: [], errors: {} };
-  if (isRuntimeInstalled("devsy")) {
-    try {
-      snapshots.devsy = listDevsyWorkspaces();
-    } catch (error) {
-      snapshots.unavailable.push("devsy");
-      snapshots.errors.devsy = error instanceof Error ? error.message : String(error);
-    }
-  }
-  if (isRuntimeInstalled("devpod")) {
-    try {
-      snapshots.devpod = listDevpodWorkspacesRaw();
-    } catch (error) {
-      snapshots.unavailable.push("devpod");
-      snapshots.errors.devpod = error instanceof Error ? error.message : String(error);
-    }
-  }
+  const devsy = readRegistrySnapshot("devsy", listDevsyWorkspaces, snapshots);
+  if (devsy !== void 0) snapshots.devsy = devsy;
+  const devpod = readRegistrySnapshot("devpod", listDevpodWorkspacesRaw, snapshots);
+  if (devpod !== void 0) snapshots.devpod = devpod;
   cachedSnapshots = snapshots;
   return snapshots;
 }
@@ -11380,11 +11522,19 @@ function absentRegistrationIdentity(state) {
   resetWorkspaceRuntimeCaches();
   if (resolveWorkspaceRuntimeOrDefault(state.repoPath) !== "devsy")
     throw new Error("Stop provider changed.");
-  if (!state.workspace || !isLinkedWorktree(state.repoPath))
-    throw new Error("Absent stop requires a linked workspace.");
-  const record5 = readWorkspaceOwnership(state.repoPath, state.workspace);
-  if (!record5 || record5.workspace !== state.workspace || record5.devpodId !== state.devpodId || !sameWorkspacePath(record5.worktreePath, state.repoPath) || resolveWorktreeWorkspace(state.repoPath) !== state.workspace || inspectWorkspaceOwnership(record5, listGitWorktrees(state.repoPath), void 0).ownerStatus !== "present")
-    throw new Error("Absent stop workspace ownership changed.");
+  const linked = isLinkedWorktree(state.repoPath);
+  if (linked !== (state.workspace !== void 0))
+    throw new Error("Absent stop requires the exact workspace identity.");
+  let identity2;
+  if (linked) {
+    const workspace = state.workspace;
+    const record5 = readWorkspaceOwnership(state.repoPath, workspace);
+    if (!record5 || record5.workspace !== workspace || record5.devpodId !== state.devpodId || !sameWorkspacePath(record5.worktreePath, state.repoPath) || resolveWorktreeWorkspace(state.repoPath) !== workspace || inspectWorkspaceOwnership(record5, listGitWorktrees(state.repoPath), void 0).ownerStatus !== "present")
+      throw new Error("Absent stop workspace ownership changed.");
+    identity2 = { kind: "linked", record: record5, gitCommonDir: resolveGitCommonDir(state.repoPath) };
+  } else {
+    identity2 = { kind: "primary", repoPath: state.repoPath, devpodId: state.devpodId };
+  }
   for (const entries of [
     listDevsyWorkspaces(),
     listDevpodWorkspacesRaw({ allowMissingExecutable: true })
@@ -11394,7 +11544,7 @@ function absentRegistrationIdentity(state) {
     ))
       throw new Error("Absent stop requires both provider registrations to remain absent.");
   }
-  return { record: record5, gitCommonDir: resolveGitCommonDir(state.repoPath) };
+  return identity2;
 }
 function replacementObservation(state) {
   resetWorkspaceRuntimeCaches();
@@ -11504,7 +11654,7 @@ function proveManagedStop(state) {
     const identityKeys = ["context", "providerId", "uid", "sourcePath", "sourceContainer"];
     const current = identityOf(owner.workspace);
     const changed = identityKeys.filter((key) => baseline[key] !== current[key]);
-    if (changed.length === 0 && state.workspace !== void 0 && isLinkedWorktree(state.repoPath) && inspectManagedStopContainers(baseline.project, baseline.endpoint).length === 0) {
+    if (changed.length === 0 && inspectManagedStopContainers(baseline.project, baseline.endpoint).length === 0) {
       proveAbsentPopulationStop(state, baseline, current);
       return { status: "proven-absent", containers: [] };
     }
@@ -11751,7 +11901,7 @@ function parseDnsHostsFromSubjectAltName(subjectAltName) {
   return normalizeUniqueHosts(names);
 }
 function parseCertificateDnsHosts(pem) {
-  const certificate = new import_node_crypto13.X509Certificate(pem);
+  const certificate = new import_node_crypto14.X509Certificate(pem);
   const subjectAltName = certificate.subjectAltName ?? "";
   if (subjectAltName.length === 0) {
     return [];
@@ -11951,12 +12101,12 @@ Run: ${tlsSetupCommand(options.repoPath)}`
     );
   }
 }
-var import_node_child_process14, import_node_crypto13, import_node_fs23, import_node_path31, DEFAULT_TLS_CERT_HOSTS, TLS_CERTIFICATE_LOCK_FILE, TLS_CERTIFICATE_LOCK_WAIT_MS, TLS_CERTIFICATE_WRITE_ATTEMPTS;
+var import_node_child_process14, import_node_crypto14, 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_crypto13 = require("crypto");
+    import_node_crypto14 = require("crypto");
     import_node_fs23 = __toESM(require("fs"));
     import_node_path31 = __toESM(require("path"));
     init_docker();
@@ -12455,6 +12605,41 @@ function stopInitialManagedDevsyWorkspace(repoPath, devsyId) {
     throw new Error("Initial managed stop left a workload running.");
   return true;
 }
+function restoreRecordedManagedDevcontainerConfig(repoPath) {
+  const plan = recordedManagedDevcontainerRestorePlan(repoPath);
+  if (!plan) return false;
+  writeManagedDevcontainerConfig(plan);
+  if (inspectManagedDevcontainerGeneratedConfig(plan).status !== "valid") {
+    throw new Error(
+      `Managed Dev Container path '${plan.generatedPath}' could not be restored from the recorded state.`
+    );
+  }
+  return true;
+}
+function recordedManagedDevcontainerRestorePlan(repoPath) {
+  try {
+    if (!import_node_fs25.default.existsSync(import_node_path33.default.join(repoPath, ".devrouter.yml"))) return void 0;
+    const linked = isLinkedWorktree(repoPath);
+    const workspace = linked ? resolveWorktreeWorkspace(repoPath) : void 0;
+    const state = readManagedRuntimeState(repoPath, workspace);
+    if (!state) return void 0;
+    const runtime = loadRuntimeConfig(repoPath, workspace ?? "", state.profile);
+    if (!runtime.config.managedRuntime || runtime.profile !== state.profile || runtime.workspace !== workspace)
+      return void 0;
+    const plan = inspectManagedDevcontainerConfig({
+      repoPath,
+      config: runtime.config,
+      profile: runtime.resolvedProfile,
+      linked
+    });
+    if (inspectManagedDevcontainerGeneratedConfig(plan).status !== "missing") return void 0;
+    if (plan.sourceConfigSha256 !== state.sourceConfigSha256 || plan.effectiveConfigSha256 !== state.effectiveConfigSha256)
+      return void 0;
+    return plan;
+  } catch {
+    return void 0;
+  }
+}
 function stopRetainedManagedDevsyWorkspace(options) {
   const { repoPath, devsyId } = options;
   const linked = isLinkedWorktree(repoPath);
@@ -13515,7 +13700,7 @@ function validateRoot(root) {
   return resolved;
 }
 function hashKey(value) {
-  return (0, import_node_crypto14.createHash)("sha256").update(value).digest("hex");
+  return (0, import_node_crypto15.createHash)("sha256").update(value).digest("hex");
 }
 function cloneFence(fence) {
   return { ...fence };
@@ -13538,11 +13723,11 @@ function isErrno2(error, code) {
 function claimError(code, message) {
   return new NetworkClaimError(code, message);
 }
-var import_node_crypto14, 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 import_node_crypto15, 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_crypto14 = require("crypto");
+    import_node_crypto15 = require("crypto");
     import_node_fs27 = __toESM(require("fs"));
     import_node_path35 = __toESM(require("path"));
     init_atomic_file();
@@ -13595,7 +13780,7 @@ var init_network_claims = __esm({
 function networkOwnerKey(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_crypto15.createHash)("sha256").update(repoPath).digest("hex");
+  return (0, import_node_crypto16.createHash)("sha256").update(repoPath).digest("hex");
 }
 function findOwnedNetworkClaim(repoPath, root = NETWORK_CLAIMS_ROOT) {
   let names;
@@ -13635,7 +13820,7 @@ function findOwnedNetworkClaim(repoPath, root = NETWORK_CLAIMS_ROOT) {
     } finally {
       import_node_fs28.default.closeSync(descriptor);
     }
-    if (typeof value.daemonId !== "string" || `${(0, import_node_crypto15.createHash)("sha256").update(value.daemonId).digest("hex")}.json` !== file)
+    if (typeof value.daemonId !== "string" || `${(0, import_node_crypto16.createHash)("sha256").update(value.daemonId).digest("hex")}.json` !== file)
       throw new Error("Retained network daemon identity is invalid.");
     const claim2 = readNetworkClaim({
       daemonId: value.daemonId,
@@ -13649,11 +13834,11 @@ function findOwnedNetworkClaim(repoPath, root = NETWORK_CLAIMS_ROOT) {
   }
   return found;
 }
-var import_node_crypto15, import_node_fs28, import_node_path36;
+var import_node_crypto16, import_node_fs28, import_node_path36;
 var init_network_claim_lookup = __esm({
   "src/core/network-claim-lookup.ts"() {
     "use strict";
-    import_node_crypto15 = require("crypto");
+    import_node_crypto16 = require("crypto");
     import_node_fs28 = __toESM(require("fs"));
     import_node_path36 = __toESM(require("path"));
     init_network_claims();
@@ -13680,7 +13865,7 @@ function qualifyNetworkProviderDefinition(value, provider) {
   if (definition.name !== "docker" || ![true, "true"].includes(agent.local) || agent.driver !== void 0 && agent.driver !== "docker" && agent.driver !== "" || docker.path !== "${DOCKER_PATH}" || docker.builder !== "${DOCKER_BUILDER}" || ![false, "false"].includes(docker.install) || (provider === "devsy" ? docker.elevation !== "${DOCKER_ELEVATION}" : docker.elevation !== void 0 && docker.elevation !== "") || env.DOCKER_HOST !== "${DOCKER_HOST}" || Object.keys(env).some((key) => key !== "DOCKER_HOST") || host.global !== true || dockerPath.default !== "docker" || actualCommand.length !== 1 || typeof actualCommand[0] !== "string" || actualCommand[0].trim() !== command || Object.keys(exec).some((key) => key !== "command") || agent.path !== void 0 && agent.path !== "" || agent.downloadURL !== void 0 && agent.downloadURL !== "") {
     throw new Error("Docker provider definition is not qualified for network allocation.");
   }
-  return (0, import_node_crypto16.createHash)("sha256").update(JSON.stringify({ name: definition.name, agent, options, exec })).digest("hex");
+  return (0, import_node_crypto17.createHash)("sha256").update(JSON.stringify({ name: definition.name, agent, options, exec })).digest("hex");
 }
 function read(provider, args) {
   const result = (0, import_node_child_process16.spawnSync)(provider, args, {
@@ -13772,12 +13957,12 @@ function inspectNetworkProviderBinding(input2) {
     );
   }
 }
-var import_node_child_process16, import_node_crypto16;
+var import_node_child_process16, import_node_crypto17;
 var init_network_provider_inspect = __esm({
   "src/core/network-provider-inspect.ts"() {
     "use strict";
     import_node_child_process16 = require("child_process");
-    import_node_crypto16 = require("crypto");
+    import_node_crypto17 = require("crypto");
     init_devpod_environment();
     init_devsy_agent();
   }
@@ -13853,6 +14038,7 @@ function inspectExactOwnership(devsyId, worktreePath) {
 }
 function mutateOwnedDevsyWorkspace(action2, devsyId, worktreePath) {
   return withMutationLock(`Devsy ${action2}`, worktreePath, () => {
+    restoreRecordedManagedDevcontainerConfig(worktreePath);
     if (action2 === "stop") {
       const stopped = stopRetainedManagedDevsyWorkspace({
         repoPath: worktreePath,
@@ -14261,7 +14447,7 @@ function handleOperationRequest(state, event) {
   if (state.phase === "stopping" || state.desired === "parked-for-capacity")
     return blocked(
       state,
-      `phase is '${state.phase}' with desired '${state.desired}'; wait for the running stop to finish.`
+      `phase is '${state.phase}' with desired '${state.desired}'; wait for the running stop to finish, or when no stop worker is running rerun 'devrouter stop <path> --delete', removing the exact provider registration first when the stop cannot prove the recorded population.`
     );
   if (event.kind === "exec" && (!event.runtimeRunning || state.desired !== "running" && state.intentRevision !== 0))
     return blocked(
@@ -15095,14 +15281,14 @@ async function runLifecycleWorker(request2, supervision, beforeAdmission) {
   }
 }
 function newLifecycleIds() {
-  return { requestId: (0, import_node_crypto17.randomUUID)(), operationId: (0, import_node_crypto17.randomUUID)(), workerId: (0, import_node_crypto17.randomUUID)() };
+  return { requestId: (0, import_node_crypto18.randomUUID)(), operationId: (0, import_node_crypto18.randomUUID)(), workerId: (0, import_node_crypto18.randomUUID)() };
 }
-var import_node_child_process18, import_node_crypto17, import_node_fs30, import_node_path38, OUTPUT_BUFFER_LIMIT, DEFAULT_OUTPUT_PAGE_BYTES, LifecycleOutput, LifecycleWorkerAdmissionBusyError;
+var import_node_child_process18, import_node_crypto18, 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_process18 = require("child_process");
-    import_node_crypto17 = require("crypto");
+    import_node_crypto18 = require("crypto");
     import_node_fs30 = __toESM(require("fs"));
     import_node_path38 = __toESM(require("path"));
     init_file_lock();
@@ -15790,7 +15976,7 @@ function readRegularFile(filePath) {
   return readRegularFileBytes(filePath)?.toString("utf-8");
 }
 function adapterFingerprint(adapter) {
-  return (0, import_node_crypto18.createHash)("sha256").update(adapter).digest("hex");
+  return (0, import_node_crypto19.createHash)("sha256").update(adapter).digest("hex");
 }
 function resolveManagedPostStartPlan(repoPath) {
   const adapterPath = import_node_path41.default.join(repoPath, MANAGED_ADAPTER_PATH);
@@ -15880,12 +16066,12 @@ function runManagedProcessAction(options) {
   }
   return "drifted";
 }
-var import_node_child_process23, import_node_crypto18, import_node_fs33, import_node_path41, MANAGED_MARKER, MANAGED_ADAPTER_PATH, RUNTIME_HELPER_PATH;
+var import_node_child_process23, import_node_crypto19, 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_crypto18 = require("crypto");
+    import_node_crypto19 = require("crypto");
     import_node_fs33 = __toESM(require("fs"));
     import_node_path41 = __toESM(require("path"));
     init_devcontainer_config();
@@ -15896,26 +16082,132 @@ var init_managed_post_start = __esm({
   }
 });
 
+// src/core/managed-mount-nesting.ts
+function normalizeDestination(value) {
+  const trimmed = value.trim().replace(/\/+$/, "");
+  return trimmed === "" ? "/" : trimmed;
+}
+function isNestedWithin(destination, candidate) {
+  return candidate === "/" ? destination !== "/" : destination.startsWith(`${candidate}/`);
+}
+function unescapeMountField(value) {
+  return value.replace(
+    /\\([0-7]{3})/g,
+    (_match, octal) => String.fromCharCode(Number.parseInt(octal, 8))
+  );
+}
+function parseMountinfoDestinations(text4) {
+  const destinations = /* @__PURE__ */ new Set();
+  for (const line of text4.split("\n")) {
+    const fields2 = line.split(" ");
+    if (fields2.length < 5 || !/^\d+$/.test(fields2[0] ?? "")) continue;
+    destinations.add(normalizeDestination(unescapeMountField(fields2[4] ?? "")));
+  }
+  return [...destinations];
+}
+function isNestedIndex(destinations, index) {
+  return destinations.some(
+    (candidate, other) => other !== index && isNestedWithin(destinations[index] ?? "", candidate)
+  );
+}
+function configuredDestinations(configured) {
+  return configured.map((mount) => normalizeDestination(mount.Destination));
+}
+function classifyManagedMountNesting(configured, effectiveDestinations, containerId) {
+  const destinations = configuredDestinations(configured);
+  const nested = configured.filter((_mount, index) => isNestedIndex(destinations, index));
+  const identity2 = containerId ? { container: containerId } : {};
+  if (nested.length === 0) {
+    return { status: "not-applicable", checked: [], unwound: [], reason: NESTED_MOUNT_REASON };
+  }
+  if (effectiveDestinations === null) {
+    return {
+      status: "unverified",
+      checked: [],
+      unwound: [],
+      ...identity2,
+      reason: UNREADABLE_MOUNT_REASON
+    };
+  }
+  const effective = new Set(effectiveDestinations.map(normalizeDestination));
+  const checked = [];
+  const unwound = [];
+  for (const mount of nested) {
+    const destination = normalizeDestination(mount.Destination);
+    if (effective.has(destination)) {
+      checked.push(mount.Destination);
+      continue;
+    }
+    const nestedWithin = destinations.filter((candidate) => isNestedWithin(destination, candidate)).sort((a, b) => a.length - b.length)[0];
+    unwound.push({
+      destination: mount.Destination,
+      source: mount.Source,
+      nestedWithin: nestedWithin ?? "/"
+    });
+  }
+  return {
+    status: unwound.length > 0 ? "unwound" : "effective",
+    checked,
+    unwound,
+    ...identity2
+  };
+}
+function readContainerMountinfo(containerId, options) {
+  const result = (0, import_node_child_process24.spawnSync)("docker", ["exec", containerId, "cat", "/proc/self/mountinfo"], {
+    encoding: "utf-8",
+    timeout: options.timeoutMs ?? 5e3,
+    stdio: ["ignore", "pipe", "pipe"],
+    ...networkDockerOptions()
+  });
+  if (result.status !== 0 || typeof result.stdout !== "string") return null;
+  const destinations = parseMountinfoDestinations(result.stdout);
+  return destinations.length > 0 ? destinations : null;
+}
+function observeManagedMountNesting(container, options = {}) {
+  const destinations = configuredDestinations(container.mounts);
+  const effective = destinations.some((_destination, index) => isNestedIndex(destinations, index)) ? readContainerMountinfo(container.id, options) : null;
+  return classifyManagedMountNesting(container.mounts, effective, container.id);
+}
+var import_node_child_process24, NESTED_MOUNT_REASON, UNREADABLE_MOUNT_REASON;
+var init_managed_mount_nesting = __esm({
+  "src/core/managed-mount-nesting.ts"() {
+    "use strict";
+    import_node_child_process24 = require("child_process");
+    init_network_effect_scope();
+    NESTED_MOUNT_REASON = "no configured mount is nested inside another configured mount";
+    UNREADABLE_MOUNT_REASON = "the container's own mount table could not be read";
+  }
+});
+
 // src/core/managed-runtime-status.ts
+function recoveryPath(repoPath) {
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(repoPath)) return repoPath;
+  return `'${repoPath.replaceAll("'", "'\\''")}'`;
+}
 function reliabilityRecovery(reason, repoPath) {
+  const checkout = recoveryPath(repoPath);
   switch (reason) {
     case "stop-incomplete":
     case "operation-unknown":
-      return [`Run: devrouter stop ${repoPath}`, `Run: devrouter ensure ${repoPath} --repair`];
+      return [`Run: devrouter stop ${checkout}`, `Run: devrouter ensure ${checkout} --repair`];
     case "start-refused":
       return [
-        `Run: devrouter doctor ${repoPath} to read the refused fixed host-port claim and its holder`,
-        `Stop the holding workspace or change this repository's own published binding, then run: devrouter ensure ${repoPath}`
+        `Run: devrouter doctor --repo ${checkout} to read the refused fixed host-port claim and its holder`,
+        `Stop the holding workspace or change this repository's own published binding, then run: devrouter ensure ${checkout}`
       ];
     case "unadmittable":
       return [
-        `Run: devrouter stop ${repoPath}`,
-        `Lower the requested capacity in .devrouter.yml, then run: devrouter ensure ${repoPath}`
+        `Run: devrouter stop ${checkout}`,
+        `Lower the requested capacity in .devrouter.yml, then run: devrouter ensure ${checkout}`
       ];
     case "capacity-parked":
-      return [`Run: devrouter ensure ${repoPath} (waits for capacity to free up)`];
+      return [
+        "Parked for host capacity: the enrolled foreground controller resumes this checkout after its pressure dwell and live-consumer checks pass.",
+        `Inspect the parked intent with: devrouter status --repo ${checkout} --json`,
+        `'devrouter ensure' refuses while the journal stays parked; release the intent instead with: devrouter stop ${checkout}`
+      ];
     case "capacity-waiting":
-      return [`Run: devrouter ensure ${repoPath} (still queued until capacity frees up)`];
+      return [`Run: devrouter ensure ${checkout} (still queued until capacity frees up)`];
     default:
       return [];
   }
@@ -16162,6 +16454,7 @@ function inspectManagedRuntime(options) {
     (mount) => mount.Type === "bind" && sameWorkspacePath(mount.Source, repoPath)
   )?.Destination;
   const primaryActive = Boolean(primary?.state.Running);
+  const mountNesting = primary && primaryActive ? observeManagedMountNesting(primary) : void 0;
   if (generatedConfigMissing && (state || primaryActive || managedServicesActive)) {
     drift.push("managed generated Dev Container configuration is missing");
   }
@@ -16228,7 +16521,8 @@ function inspectManagedRuntime(options) {
     processStatuses,
     activeServices: sortedUnique2(activeServices),
     activeProcesses: sortedUnique2(activeProcesses),
-    drift
+    drift,
+    ...mountNesting ? { mountNesting } : {}
   };
 }
 function collectManagedRuntimeStatus(options) {
@@ -16376,6 +16670,7 @@ function collectManagedRuntimeStatus(options) {
     baseServiceStatuses: inspection.baseStatuses,
     processStatuses: inspection.processStatuses,
     drift: sortedUnique2(drift),
+    ...inspection.mountNesting ? { mountNesting: inspection.mountNesting } : {},
     ...inspection.plan?.sourceConfigSha256 || state?.sourceConfigSha256 ? { sourceConfigSha256: inspection.plan?.sourceConfigSha256 ?? state?.sourceConfigSha256 } : {},
     ...inspection.plan?.effectiveConfigSha256 || state?.effectiveConfigSha256 ? {
       effectiveConfigSha256: inspection.plan?.effectiveConfigSha256 ?? state?.effectiveConfigSha256
@@ -16390,6 +16685,7 @@ var init_managed_runtime_status = __esm({
     init_devcontainer_profile();
     init_devpod_environment();
     init_host_routes();
+    init_managed_mount_nesting();
     init_managed_post_start();
     init_managed_runtime_state();
     init_reliability_operation_store();
@@ -16409,7 +16705,7 @@ function readDocker(endpoint, args, timeoutMs) {
   const env = { ...process.env };
   delete env.DOCKER_CONTEXT;
   delete env.DOCKER_HOST;
-  const result = (0, import_node_child_process24.spawnSync)("docker", ["--host", endpoint, ...args], {
+  const result = (0, import_node_child_process25.spawnSync)("docker", ["--host", endpoint, ...args], {
     env,
     encoding: "utf-8",
     timeout: timeoutMs,
@@ -16440,7 +16736,14 @@ function id4(value) {
 }
 function rows(output2) {
   const trimmed = output2.trim();
-  return trimmed ? trimmed.split(/\r?\n/).map((line) => JSON.parse(line)) : [];
+  return trimmed ? trimmed.split(/\r?\n/).map((line) => parseRecord(line)) : [];
+}
+function parseRecord(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    throw new NetworkInventoryError("Docker network inventory contains a malformed record.");
+  }
 }
 function ids(output2) {
   const values = output2.trim() ? output2.trim().split(/\r?\n/).map(id4) : [];
@@ -16485,7 +16788,7 @@ function collectDockerNetworkInventory(options = {}, dependencies = {}) {
       return output2;
     };
     const info = record4(
-      JSON.parse(
+      parseRecord(
         read2(["info", "--format", '{"id":{{json .ID}},"pools":{{json .DefaultAddressPools}}}'])
       )
     );
@@ -16564,18 +16867,18 @@ function collectDockerNetworkInventory(options = {}, dependencies = {}) {
   }
   return result;
 }
-var import_node_child_process24, NetworkInventoryError, MAX_IDS, MAX_OUTPUT_BYTES, FULL_ID, NETWORK_TEMPLATE, CONTAINER_TEMPLATE;
+var import_node_child_process25, NetworkInventoryError, MAX_IDS, MAX_OUTPUT_BYTES, FULL_ID, NETWORK_TEMPLATE, CONTAINER_TEMPLATE;
 var init_network_inventory = __esm({
   "src/core/network-inventory.ts"() {
     "use strict";
-    import_node_child_process24 = require("child_process");
+    import_node_child_process25 = require("child_process");
     init_devpod_environment();
     NetworkInventoryError = class extends Error {
     };
     MAX_IDS = 4096;
     MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
     FULL_ID = /^[a-f0-9]{64}$/;
-    NETWORK_TEMPLATE = '{"id":{{json .Id}},"name":{{json .Name}},"driver":{{json .Driver}},"ipam":{{json .IPAM.Config}},"activeEndpoints":{{len .Containers}},"project":{{json (index .Labels "com.docker.compose.project")}},"network":{{json (index .Labels "com.docker.compose.network")}}';
+    NETWORK_TEMPLATE = '{"id":{{json .Id}},"name":{{json .Name}},"driver":{{json .Driver}},"ipam":{{json .IPAM.Config}},"activeEndpoints":{{len .Containers}},"project":{{json (index .Labels "com.docker.compose.project")}},"network":{{json (index .Labels "com.docker.compose.network")}}}';
     CONTAINER_TEMPLATE = '{"id":{{json .Id}},"networks":{{json .NetworkSettings.Networks}}}';
   }
 });
@@ -16962,7 +17265,7 @@ function parseLinuxNetworkRoutes(output2) {
 function collectNetworkRoutes(options) {
   if ((options.platform ?? process.platform) !== "linux" || !hasLocalDockerNetworkNamespace(options.endpoint))
     return { status: "unknown", routes: [] };
-  const result = (0, import_node_child_process25.spawnSync)("ip", ["-j", "-4", "route", "show", "table", "all"], {
+  const result = (0, import_node_child_process26.spawnSync)("ip", ["-j", "-4", "route", "show", "table", "all"], {
     encoding: "utf8",
     timeout: 5e3,
     maxBuffer: 1024 * 1024
@@ -16970,11 +17273,11 @@ function collectNetworkRoutes(options) {
   if (result.error || result.status !== 0) return { status: "unknown", routes: [] };
   return parseLinuxNetworkRoutes(result.stdout);
 }
-var import_node_child_process25, import_node_net3;
+var import_node_child_process26, import_node_net3;
 var init_network_routes = __esm({
   "src/core/network-routes.ts"() {
     "use strict";
-    import_node_child_process25 = require("child_process");
+    import_node_child_process26 = require("child_process");
     import_node_net3 = require("net");
     init_network_capacity();
     init_network_local_daemon();
@@ -17019,11 +17322,13 @@ function networkCapacityCheck(report) {
     (pool) => pool.candidates.some((candidate) => candidate.overlappingNetworkIds.length === 0)
   );
   const managedDetails = managed ? ` Managed policy: ${managed.policy.status}; /${managed.policy.requestedPrefixLength} capacity: ${managed.configuredPolicyCapacity.status}; claims: ${managed.claims.reserved} reserved, ${managed.claims.attached} attached, ${managed.claims.uncertain} uncertain.` : "";
+  const blockers = report.allocation.blockers.slice(0, 4).map((blocker) => blocker.slice(0, 120));
+  const blockerDetails = blockers.length > 0 ? ` Missing evidence: ${blockers.join("; ")}.` : "";
   return {
     id: "global.network-capacity",
     level: legacyAvailable ? "ok" : "warn",
     summary: exhausted ? "Docker default address pools are exhausted for new networks." : legacyAvailable ? "Docker default pools have unoccupied capacity; managed allocation is not configured." : "Network allocation readiness requires complete route and capacity evidence.",
-    details: `${report.pools.length} pool(s); ${retained} network(s) have no active endpoints but retain container references. Allocation readiness: ${report.allocation.status}.${managedDetails}`,
+    details: `${report.pools.length} pool(s); ${retained} network(s) have no active endpoints but retain container references. Allocation readiness: ${report.allocation.status}.${blockerDetails}${managedDetails}`,
     suggestion: exhausted ? "Existing network reuse can continue. Review operator-approved route-safe pools or exact ownership-aware recovery. Stop and worktree removal do not release subnets; do not prune automatically." : "Review complete Docker, LAN, VPN and guest route evidence before allocating a new subnet. Unknown evidence does not authorize cleanup."
   };
 }
@@ -17041,21 +17346,21 @@ var init_network_diagnostics = __esm({
 });
 
 // src/core/network-compose.ts
-var import_node_crypto19;
+var import_node_crypto20;
 var init_network_compose = __esm({
   "src/core/network-compose.ts"() {
     "use strict";
-    import_node_crypto19 = require("crypto");
+    import_node_crypto20 = require("crypto");
   }
 });
 
 // src/core/network-compose-files.ts
-var import_node_child_process26, import_node_crypto20, import_node_fs35, import_node_path43, import_yaml4, MAX_BYTES3;
+var import_node_child_process27, import_node_crypto21, 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_crypto20 = require("crypto");
+    import_node_child_process27 = require("child_process");
+    import_node_crypto21 = require("crypto");
     import_node_fs35 = __toESM(require("fs"));
     import_node_path43 = __toESM(require("path"));
     import_yaml4 = __toESM(require("yaml"));
@@ -17067,11 +17372,11 @@ var init_network_compose_files = __esm({
 });
 
 // src/core/network-connected-route.ts
-var import_node_child_process27;
+var import_node_child_process28;
 var init_network_connected_route = __esm({
   "src/core/network-connected-route.ts"() {
     "use strict";
-    import_node_child_process27 = require("child_process");
+    import_node_child_process28 = require("child_process");
     init_network_capacity();
   }
 });
@@ -17087,11 +17392,11 @@ var init_network_lifecycle = __esm({
 });
 
 // src/core/network-managed.ts
-var import_node_crypto21;
+var import_node_crypto22;
 var init_network_managed = __esm({
   "src/core/network-managed.ts"() {
     "use strict";
-    import_node_crypto21 = require("crypto");
+    import_node_crypto22 = require("crypto");
     init_devpod_environment();
     init_network_capacity();
     init_network_claim_lookup();
@@ -17161,11 +17466,11 @@ function resolveLinkedTarget(repoPath) {
     gitCommonDir: resolveGitCommonDir(repoPath)
   };
 }
-var import_node_child_process28, import_node_fs36, import_node_path44;
+var import_node_child_process29, 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_child_process29 = require("child_process");
     import_node_fs36 = __toESM(require("fs"));
     import_node_path44 = __toESM(require("path"));
     init_devcontainer_profile();
@@ -17445,6 +17750,44 @@ function restoreParkedIntentAfterFailedResume(input2) {
     record5.state = transition2.state;
   });
 }
+function snapshotLifecycleStopIntent(state) {
+  return {
+    intentRevision: state.intentRevision,
+    observationsAfterMs: state.observationsAfterMs,
+    desired: state.desired,
+    phase: state.phase,
+    profile: state.profile,
+    admission: state.admission,
+    stopProof: { ...state.stopProof },
+    requests: state.requests.map((request2) => ({ ...request2 })),
+    observations: state.observations.map((observation) => ({ ...observation })),
+    operation: state.operation ? { ...state.operation } : null
+  };
+}
+function withdrawUnstartedLifecycleStop(input2) {
+  return updateReliabilityOperation(input2.identity, (record5) => {
+    const state = record5.state;
+    const intent = input2.intent;
+    if (!intent.wroteIntent) return false;
+    if (!matchesFence(record5, intent.fence)) return false;
+    if (record5.worker || record5.stopWorkStarted) return false;
+    if (state.desired !== "stopped-by-user" || state.phase !== "stopping") return false;
+    if (state.stopProof.workloadsStopped || state.stopProof.routesRemoved) return false;
+    if (!(0, import_node_util11.isDeepStrictEqual)(state.operation, intent.recordedOperation)) return false;
+    const prior = intent.prior;
+    state.intentRevision = prior.intentRevision;
+    state.observationsAfterMs = prior.observationsAfterMs;
+    state.desired = prior.desired;
+    state.phase = prior.phase;
+    state.profile = prior.profile;
+    state.admission = prior.admission;
+    state.stopProof = { ...prior.stopProof };
+    state.requests = prior.requests.map((request2) => ({ ...request2 }));
+    state.observations = prior.observations.map((observation) => ({ ...observation }));
+    state.operation = prior.operation ? { ...prior.operation } : null;
+    return true;
+  });
+}
 function prepareResumeLifecycleOperation(input2) {
   const ids2 = newLifecycleIds();
   return updateReliabilityOperation(input2.identity, (record5) => {
@@ -17597,12 +17940,37 @@ async function superviseLifecycle(kind, repoPath, options = {}, command) {
   const copiedOptions = { ...options };
   const copiedCommand = command ? [...command] : void 0;
   if (kind === "stop") {
-    const fence = updateReliabilityOperation(identity2, (record5) => {
+    const intent = updateReliabilityOperation(identity2, (record5) => {
       reconcileDrained(record5);
+      const prior = snapshotLifecycleStopIntent(record5.state);
       stepRecord(record5, { ...reliabilityFence(record5.state), type: "stop" });
-      return reliabilityFence(record5.state);
+      return {
+        fence: reliabilityFence(record5.state),
+        prior,
+        recordedOperation: record5.state.operation ? { ...record5.state.operation } : null,
+        wroteIntent: record5.state.intentRevision !== prior.intentRevision
+      };
     });
-    return runLifecycleWorker({ kind, repoPath, identity: identity2, ...ids2, fence, options: copiedOptions });
+    try {
+      return await runLifecycleWorker({
+        kind,
+        repoPath,
+        identity: identity2,
+        ...ids2,
+        fence: intent.fence,
+        options: copiedOptions
+      });
+    } catch (error) {
+      try {
+        withdrawUnstartedLifecycleStop({ identity: identity2, intent });
+      } catch (withdrawal) {
+        process.stderr.write(
+          `Lifecycle stop intent could not be withdrawn: ${withdrawal instanceof Error ? withdrawal.message : String(withdrawal)}
+`
+        );
+      }
+      throw error;
+    }
   }
   const initial = readReliabilityOperation(identity2) ?? updateReliabilityOperation(identity2, (record5) => record5);
   if (initial.state.executionPolicy === "capacity-managed" || capacityPolicyTargets(repoPath))
@@ -17847,7 +18215,7 @@ async function superviseThroughController(input2) {
   try {
     const bind = () => observeControllerBinding(directory, {
       path: input2.repoPath,
-      session: (0, import_node_crypto22.randomUUID)(),
+      session: (0, import_node_crypto23.randomUUID)(),
       profile: input2.profile ?? "full",
       // The protocol requires at least one readiness selector, and every
       // supervised operation depends on runtime readiness; "runtime" is the
@@ -17998,11 +18366,11 @@ function bindLifecycleCapacity(request2, binding, directory = import_node_path45
       stepRecord(record5, { ...request2.fence, type: "admission", result: "admitted" });
   });
 }
-var import_node_crypto22, import_node_path45, import_node_util11, activeWorker, lockHeld, BUSY_LIFECYCLE_WAIT_MS, BUSY_LIFECYCLE_POLL_MS, CAPACITY_CLIENT_WAIT_MS, BUSY_LIFECYCLE_PROGRESS_MS;
+var import_node_crypto23, import_node_path45, import_node_util11, 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_crypto22 = require("crypto");
+    import_node_crypto23 = require("crypto");
     import_node_path45 = __toESM(require("path"));
     import_node_util11 = require("util");
     init_capacity_accounting();
@@ -18638,7 +19006,7 @@ function createCapacityController(options) {
     controller,
     policyRevision: policy.revision
   });
-  const payloadKey = (0, import_node_crypto23.randomBytes)(32);
+  const payloadKey = (0, import_node_crypto24.randomBytes)(32);
   const acceptedPayloads = /* @__PURE__ */ new Map();
   const settlePreparations = () => {
     if (lifetime.signal.aborted) return;
@@ -18802,7 +19170,7 @@ function createCapacityController(options) {
           {
             ...charge,
             operationId: prepared.operationId,
-            reservationId: (0, import_node_crypto23.randomUUID)(),
+            reservationId: (0, import_node_crypto24.randomUUID)(),
             policyRevision: target.current.revision
           },
           {
@@ -18905,7 +19273,7 @@ function createCapacityController(options) {
           throw error;
         }
       }
-      const signature = (0, import_node_crypto23.createHmac)("sha256", payloadKey).update(
+      const signature = (0, import_node_crypto24.createHmac)("sha256", payloadKey).update(
         JSON.stringify({
           repoPath: identity2.repoPath,
           profile: environment.profile,
@@ -18925,7 +19293,7 @@ function createCapacityController(options) {
             {
               ...charge,
               operationId: prepared.operationId,
-              reservationId: (0, import_node_crypto23.randomUUID)(),
+              reservationId: (0, import_node_crypto24.randomUUID)(),
               policyRevision: current.revision
             },
             { estimates: resolved.estimates, enrollment: resolved.enrollment, pool }
@@ -19060,7 +19428,7 @@ function createCapacityController(options) {
           // the budget module then falls back to the conservative wall duration.
           activeElapsedMs: null,
           profile: environment.profile,
-          incidentId: `incident-${(0, import_node_crypto23.randomUUID)()}`
+          incidentId: `incident-${(0, import_node_crypto24.randomUUID)()}`
         });
       } catch {
         return;
@@ -19078,7 +19446,7 @@ function createCapacityController(options) {
           {
             ...charge,
             operationId: prepared.operationId,
-            reservationId: (0, import_node_crypto23.randomUUID)(),
+            reservationId: (0, import_node_crypto24.randomUUID)(),
             policyRevision: current.revision
           },
           { estimates: resolved.estimates, enrollment: resolved.enrollment, pool }
@@ -19098,11 +19466,11 @@ function createCapacityController(options) {
     }
   };
 }
-var import_node_crypto23, import_node_path46, import_node_util13;
+var import_node_crypto24, import_node_path46, import_node_util13;
 var init_capacity_controller = __esm({
   "src/core/capacity-controller.ts"() {
     "use strict";
-    import_node_crypto23 = require("crypto");
+    import_node_crypto24 = require("crypto");
     import_node_path46 = __toESM(require("path"));
     import_node_util13 = require("util");
     init_capacity_accounting();
@@ -19199,7 +19567,7 @@ printf '%s %s %s\n' "$pid" "$birth" "$fingerprint"
 
 // src/core/controller-observation.ts
 function digest2(value) {
-  return (0, import_node_crypto24.createHash)("sha256").update(JSON.stringify(value)).digest("hex");
+  return (0, import_node_crypto25.createHash)("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function readRoutes() {
   return readHostRouteStateReadOnly((file) => readControllerEvidence(file, 1048576));
@@ -19283,7 +19651,7 @@ function createControllerObservationCollector(resolve, fingerprint) {
       () => persisted.contents[3]
     );
     const source = parseDevcontainerConfig(persisted.contents[4], sourcePath);
-    if (!state || state.devpodId !== environment.providerId || state.profile !== environment.profile || typeof source.service !== "string" || !source.service || (0, import_node_crypto24.createHash)("sha256").update(persisted.contents[4]).digest("hex") !== state.sourceConfigSha256 || (0, import_node_crypto24.createHash)("sha256").update(persisted.contents[5]).digest("hex") !== state.effectiveConfigSha256)
+    if (!state || state.devpodId !== environment.providerId || state.profile !== environment.profile || typeof source.service !== "string" || !source.service || (0, import_node_crypto25.createHash)("sha256").update(persisted.contents[4]).digest("hex") !== state.sourceConfigSha256 || (0, import_node_crypto25.createHash)("sha256").update(persisted.contents[5]).digest("hex") !== state.effectiveConfigSha256)
       throw new ControllerObservationBindingChanged("Observation retained configuration changed.");
     const identity2 = {
       repoPath: environment.repoPath,
@@ -19458,11 +19826,11 @@ function createControllerObservationCollector(resolve, fingerprint) {
     };
   };
 }
-var import_node_crypto24, import_node_path47, OBSERVATION_INSPECT_TEMPLATE;
+var import_node_crypto25, import_node_path47, OBSERVATION_INSPECT_TEMPLATE;
 var init_controller_observation = __esm({
   "src/core/controller-observation.ts"() {
     "use strict";
-    import_node_crypto24 = require("crypto");
+    import_node_crypto25 = require("crypto");
     import_node_path47 = __toESM(require("path"));
     init_controller_binding();
     init_controller_monitor();
@@ -19487,11 +19855,11 @@ var init_controller_observation = __esm({
 });
 
 // src/core/controller-sessions.ts
-var import_node_crypto25, import_node_util14, ControllerSessions;
+var import_node_crypto26, import_node_util14, ControllerSessions;
 var init_controller_sessions = __esm({
   "src/core/controller-sessions.ts"() {
     "use strict";
-    import_node_crypto25 = require("crypto");
+    import_node_crypto26 = require("crypto");
     import_node_util14 = require("util");
     ControllerSessions = class {
       constructor(store) {
@@ -19663,7 +20031,7 @@ var init_controller_sessions = __esm({
         const session = {
           id: id5,
           environmentId: environment.id,
-          generation: (0, import_node_crypto25.randomUUID)(),
+          generation: (0, import_node_crypto26.randomUUID)(),
           requirements: required,
           renewedAtMs: wall,
           parkingConsent: "protected",
@@ -19690,7 +20058,7 @@ var init_controller_sessions = __esm({
         const session = {
           id: previous.session,
           environmentId: environment.id,
-          generation: (0, import_node_crypto25.randomUUID)(),
+          generation: (0, import_node_crypto26.randomUUID)(),
           requirements: required,
           renewedAtMs: wall,
           parkingConsent: "protected",
@@ -21134,26 +21502,30 @@ checkout's environment is mid-transition. Wire \`devrouter harness gate\` as a
     {
       "hooks": {
         "PreToolUse": [
-          { "matcher": "Bash", "hooks": [
+          { "matcher": ".*", "hooks": [
             { "type": "command", "command": "devrouter harness gate", "timeout": 90 }
           ] }
         ]
       }
     }
 
-The Codex CLI reads the same hook from \`$CODEX_HOME/hooks.json\`, where the shell
-tool is named \`exec_command\`:
+The Codex CLI reads the same hook from \`$CODEX_HOME/hooks.json\`:
 
     {
       "hooks": {
         "PreToolUse": [
-          { "matcher": "exec_command|Bash|shell", "hooks": [
+          { "matcher": ".*", "hooks": [
             { "type": "command", "command": "devrouter harness gate", "timeout": 180 }
           ] }
         ]
       }
     }
 
+\`.*\` matches every tool, including the shell, file-editing and MCP tools a model
+can point at the environment. The gate answers a settled checkout immediately, so
+the price is one short-lived process per gated call; narrow the matcher when that
+price matters more than covering every tool.
+
 The gate identifies the requesting harness from its payload and answers in that
 harness's accepted shape: a refusal is a \`deny\` in both, while an allowed call is
 \`permissionDecision: allow\` for Claude Code and Codex receives a bare completion
@@ -21849,6 +22221,13 @@ function appendManagedRuntimeRows(rows2, managedRuntime) {
   rows2.push(["Effective config SHA-256", managedRuntime.effectiveConfigSha256 ?? "-"]);
   rows2.push(["Transition phase", managedRuntime.transitionPhase ?? "-"]);
   rows2.push(["Runtime drift", formatResourceNames(managedRuntime.drift)]);
+  if (managedRuntime.mountNesting && managedRuntime.mountNesting.status !== "not-applicable") {
+    const nesting = managedRuntime.mountNesting;
+    rows2.push([
+      "Mount nesting",
+      nesting.status === "unwound" ? `unwound: ${nesting.unwound.map((entry) => entry.destination).join(", ")} (restart the container to re-apply)` : nesting.status === "unverified" ? `unverified (${nesting.reason ?? "unknown"})` : `effective (${nesting.checked.join(", ")})`
+    ]);
+  }
   if (managedRuntime.reliability) {
     const reliability = managedRuntime.reliability;
     rows2.push(["Lifecycle intent", reliability.desired]);
@@ -22960,6 +23339,11 @@ async function collectRouterStatus(repoPath) {
     nextSteps.push(`Run: dev app ls --repo ${repo.path}`);
     nextSteps.push("Run: dev app run <name> --repo <path> --yes");
     nextSteps.push("Run: dev ls");
+    if (repo.managedRuntime?.mountNesting?.status === "unwound") {
+      nextSteps.push(
+        `Run: devrouter stop ${repo.path} and then devrouter ensure ${repo.path} to re-apply the unwound nested mount`
+      );
+    }
   }
   const files = getRouterFileLayout();
   if (files.missing.length > 0) {
@@ -23003,7 +23387,7 @@ function outputFromResult(result) {
   return output2.length > 0 ? output2 : void 0;
 }
 function runTool(command, args = []) {
-  const result = (0, import_node_child_process29.spawnSync)(command, args, {
+  const result = (0, import_node_child_process30.spawnSync)(command, args, {
     encoding: "utf-8"
   });
   if (result.error) {
@@ -23194,7 +23578,7 @@ function displayPath(filePath) {
   return `~${filePath.slice(home.length)}`;
 }
 function probeInstalledCliVersion(executable) {
-  const result = (0, import_node_child_process29.spawnSync)(executable, ["-V"], {
+  const result = (0, import_node_child_process30.spawnSync)(executable, ["-V"], {
     encoding: "utf-8",
     timeout: CLI_PATH_PROBE_TIMEOUT_MS
   });
@@ -23205,7 +23589,7 @@ function probeInstalledCliVersion(executable) {
 }
 function buildCliPathCheck(options = {}) {
   const id5 = "global.cli-path";
-  const runningVersion = options.runningVersion ?? (true ? "0.1.1" : "0.0.0-dev");
+  const runningVersion = options.runningVersion ?? (true ? "0.1.3" : "0.0.0-dev");
   if (runningVersion === "0.0.0-dev") {
     return {
       id: id5,
@@ -23380,11 +23764,11 @@ function buildGlobalToolChecksWithoutTelemetry(repoPath) {
   checks.push(nodeToolchainCheck(repoPath));
   return checks;
 }
-var import_node_child_process29, import_node_fs43, import_node_path54, DEVSY_DISABLE_TELEMETRY, CLI_PATH_PROBE_TIMEOUT_MS, INSTALLED_CLI_VERSION_RE;
+var import_node_child_process30, import_node_fs43, import_node_path54, DEVSY_DISABLE_TELEMETRY, CLI_PATH_PROBE_TIMEOUT_MS, INSTALLED_CLI_VERSION_RE;
 var init_tool_diagnostics = __esm({
   "src/core/tool-diagnostics.ts"() {
     "use strict";
-    import_node_child_process29 = require("child_process");
+    import_node_child_process30 = require("child_process");
     import_node_fs43 = __toESM(require("fs"));
     import_node_path54 = __toESM(require("path"));
     init_devsy_agent();
@@ -23871,6 +24255,17 @@ function collectNextSteps(checks, statusNextSteps) {
   }
   return Array.from(steps.values());
 }
+function capacityHistoryDetails(error) {
+  if (!(error instanceof CapacityHistoryError)) return "capacity-history-unprovable";
+  const parts = [error.code];
+  if (error.cause) parts.push(error.cause);
+  if (error.location) parts.push(`at ${error.location}`);
+  return parts.join("; ");
+}
+function capacityHistorySuggestion(error) {
+  const cause = error instanceof CapacityHistoryError ? error.cause : null;
+  return (cause ? CAPACITY_RECOVERY_BY_CAUSE[cause] : void 0) ?? "Preserve ledger and lifecycle records; restore verified history before retrying admission.";
+}
 async function buildDoctorReport(options = {}) {
   const checks = [];
   const fileLayout = getRouterFileLayout();
@@ -23916,8 +24311,8 @@ async function buildDoctorReport(options = {}) {
       id: "global.capacity-ledger",
       level: "error",
       summary: "Capacity ledger history is unavailable for safe admission.",
-      details: error instanceof CapacityHistoryError ? error.code : "capacity-history-unprovable",
-      suggestion: absent ? "Preserve ledger and lifecycle records; with every enrolled environment stopped, run: devrouter capacity reconcile --yes" : "Preserve ledger and lifecycle records; restore verified history before retrying admission."
+      details: capacityHistoryDetails(error),
+      suggestion: absent ? "Preserve ledger and lifecycle records; with every enrolled environment stopped, run: devrouter capacity reconcile --yes" : capacityHistorySuggestion(error)
     });
   }
   let statusNextSteps = [];
@@ -24029,6 +24424,43 @@ async function buildDoctorReport(options = {}) {
           ...details ? { details } : {},
           suggestion: managedRuntime.mode === "legacy" ? void 0 : managedRuntime.status === "failed-transition" ? `Inspect: dev status --repo ${repo.path}; resolve the reported drift before retrying ensure.` : managedRuntime.status === "ready" ? void 0 : `Run: dev ensure ${repo.path}`
         });
+        const mountNesting = managedRuntime.mountNesting;
+        if (mountNesting && mountNesting.status !== "not-applicable") {
+          const container = mountNesting.container ?? "unknown";
+          const shortContainer = container === "unknown" ? container : container.slice(0, 12);
+          if (mountNesting.status === "unwound") {
+            const first = mountNesting.unwound[0];
+            addCheck(checks, {
+              id: "repo.managed-mount-nesting",
+              level: "warn",
+              summary: `Managed container ${shortContainer} no longer reports ${first?.destination ?? "a nested mount"} in its own mount table, so the mount underneath it is visible in the container.`,
+              details: [
+                `container=${container}`,
+                ...mountNesting.unwound.map(
+                  (entry) => `unwound=${entry.destination} (source ${entry.source} inside ${entry.nestedWithin})`
+                )
+              ].join("; "),
+              suggestion: `Run: devrouter stop ${repo.path} and then devrouter ensure ${repo.path} to restart the exact container, which re-applies the nested mount.`
+            });
+          } else if (mountNesting.status === "unverified") {
+            addCheck(checks, {
+              id: "repo.managed-mount-nesting",
+              level: "warn",
+              summary: `Managed container ${shortContainer} did not report its own mount table, so its nested mounts are unverified.`,
+              details: [
+                `container=${container}`,
+                `reason=${mountNesting.reason ?? "unknown"}`
+              ].join("; "),
+              suggestion: `Run: devrouter exec ${repo.path} -- cat /proc/self/mountinfo to read the container's own mount table.`
+            });
+          } else {
+            addCheck(checks, {
+              id: "repo.managed-mount-nesting",
+              level: "ok",
+              summary: `Managed container ${shortContainer} still reports ${mountNesting.checked.join(", ")} in its own mount table.`
+            });
+          }
+        }
       }
       if (repo.appCount === 0) {
         addCheck(checks, {
@@ -24053,7 +24485,7 @@ async function buildDoctorReport(options = {}) {
           suggestion: `Remedy ${expansionNotice.remedy.code}: set a named default profile other than '${expansionNotice.profile}'${remedyCandidates}.`
         });
       }
-      const cliVersion = true ? "0.1.1" : "0.0.0-dev";
+      const cliVersion = true ? "0.1.3" : "0.0.0-dev";
       const configVersion = config.devrouter?.version;
       const installedKnown = cliVersion !== "0.0.0-dev";
       const versionComparison = installedKnown && configVersion ? compareSemver(configVersion, cliVersion) : void 0;
@@ -24279,7 +24711,7 @@ async function buildDoctorReport(options = {}) {
     nextSteps
   };
 }
-var import_node_fs44, import_node_path56, import_yaml6, POSTGRES_DEFAULTS;
+var import_node_fs44, import_node_path56, import_yaml6, POSTGRES_DEFAULTS, CAPACITY_RECOVERY_BY_CAUSE;
 var init_doctor = __esm({
   "src/core/doctor.ts"() {
     "use strict";
@@ -24308,6 +24740,14 @@ var init_doctor = __esm({
       POSTGRES_PASSWORD: "prisma",
       POSTGRES_DB: "prisma"
     };
+    CAPACITY_RECOVERY_BY_CAUSE = {
+      "journal-entry-unsupported": "Move the named unrecognised entry out of the private reliability journal directory, preserving its contents; it blocks every capacity read while it stays there.",
+      "journal-directory-unsafe": "Restore private ownership and mode 0700 on the reliability journal directory, then retry.",
+      "journal-directory-unreadable": "Restore read access to the reliability journal directory, then retry.",
+      "journal-invalid": "Preserve the named journal entry and restore verified history before retrying admission.",
+      "journal-unreadable": "Preserve the named journal entry and restore verified history before retrying admission.",
+      "journal-entry-unsafe": "Restore private ownership, mode 0600 and a bounded size on the named journal entry, then retry."
+    };
   }
 });
 
@@ -24609,12 +25049,12 @@ function parseSsPortListeners(stdout, port) {
   return listeners;
 }
 function findPortListeners(port) {
-  const result = (0, import_node_child_process30.spawnSync)("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN"], {
+  const result = (0, import_node_child_process31.spawnSync)("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN"], {
     encoding: "utf-8"
   });
   if (result.error && result.error.code === "ENOENT") {
     if (process.platform === "linux") {
-      const ssResult = (0, import_node_child_process30.spawnSync)("ss", ["-H", "-lntp", "-p"], { encoding: "utf-8" });
+      const ssResult = (0, import_node_child_process31.spawnSync)("ss", ["-H", "-lntp", "-p"], { encoding: "utf-8" });
       if (ssResult.status === 0 && ssResult.stdout) {
         return parseSsPortListeners(ssResult.stdout, port);
       }
@@ -24643,11 +25083,11 @@ function findPortListeners(port) {
     };
   });
 }
-var import_node_child_process30;
+var import_node_child_process31;
 var init_ports = __esm({
   "src/util/ports.ts"() {
     "use strict";
-    import_node_child_process30 = require("child_process");
+    import_node_child_process31 = require("child_process");
   }
 });
 
@@ -24916,7 +25356,7 @@ var init_status2 = __esm({
 
 // src/core/harness-continuation.ts
 function harnessContinuationPath(repoRoot) {
-  const key = (0, import_node_crypto26.createHash)("sha256").update(comparableWorkspacePath(repoRoot)).digest("hex");
+  const key = (0, import_node_crypto27.createHash)("sha256").update(comparableWorkspacePath(repoRoot)).digest("hex");
   return import_node_path57.default.join(DEVROUTER_HOME, "harness", `${key}.json`);
 }
 function counter4(value) {
@@ -25014,11 +25454,11 @@ function settleHarnessContinuation(repoRoot, toolUseId, settlement) {
   } catch {
   }
 }
-var import_node_crypto26, import_node_fs45, import_node_path57, HARNESS_CONTINUATION_MAX_ENTRIES, HARNESS_CONTINUATION_TTL_MS, HARNESS_CONTINUATION_LOCK_WAIT_MS, MAX_LEDGER_BYTES, MAX_TOOL_USE_ID_LENGTH, MAX_PHASE_LENGTH;
+var import_node_crypto27, import_node_fs45, import_node_path57, HARNESS_CONTINUATION_MAX_ENTRIES, HARNESS_CONTINUATION_TTL_MS, HARNESS_CONTINUATION_LOCK_WAIT_MS, MAX_LEDGER_BYTES, MAX_TOOL_USE_ID_LENGTH, MAX_PHASE_LENGTH;
 var init_harness_continuation = __esm({
   "src/core/harness-continuation.ts"() {
     "use strict";
-    import_node_crypto26 = require("crypto");
+    import_node_crypto27 = require("crypto");
     import_node_fs45 = __toESM(require("fs"));
     import_node_path57 = __toESM(require("path"));
     init_atomic_file();
@@ -25085,17 +25525,20 @@ async function waitForHarnessGate(options) {
     options.onObservation?.(observation, now() - started);
     if (!isTransitionalHarnessPhase(observation.phase)) {
       const waitedMs2 = now() - started;
+      let reason = deferred ? "settled-after-wait" : "settled";
+      if (observation.phase === "unknown") reason = "evidence-unavailable";
       return {
         version: 1,
         decision: deferred ? "deferred-allow" : "allow",
-        reason: deferred ? "settled-after-wait" : "settled",
+        reason,
         waitedMs: waitedMs2,
         observations,
         observedPhase: observation.phase
       };
     }
     const waitedMs = now() - started;
-    if (waitedMs + interval > budget) {
+    const remainingMs = budget - waitedMs;
+    if (remainingMs <= 0) {
       return {
         version: 1,
         decision: "refuse",
@@ -25120,7 +25563,7 @@ async function waitForHarnessGate(options) {
       }
     }
     deferred = true;
-    await sleep3(Math.min(interval, budget - waitedMs));
+    await sleep3(Math.min(interval, remainingMs));
   }
 }
 function parseHarnessGateBudget(value) {
@@ -25162,6 +25605,91 @@ __export(harness_exports, {
   detectHarnessHook: () => detectHarnessHook,
   runHarnessCommand: () => runHarnessCommand
 });
+function commandSegments(command) {
+  const segments = [];
+  let current = "";
+  let quote;
+  for (const char of command) {
+    if (quote) {
+      current += char;
+      if (char === quote) quote = void 0;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char === ";" || char === "\n" || char === "&" || char === "|" || char === "(" || char === ")") {
+      segments.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  segments.push(current);
+  return segments;
+}
+function segmentWords(segment, limit) {
+  const words = [];
+  let current = "";
+  let quote;
+  const flush = () => {
+    if (current) words.push(current);
+    current = "";
+  };
+  for (const char of segment) {
+    if (quote) {
+      if (char === quote) {
+        quote = void 0;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (char === " " || char === "	") {
+      flush();
+      if (words.length >= limit) return words;
+      continue;
+    }
+    current += char;
+  }
+  flush();
+  return words;
+}
+function executableName(word) {
+  return word.slice(word.lastIndexOf("/") + 1);
+}
+function commandWord(segment) {
+  const words = segmentWords(segment, COMMAND_WORD_LIMIT);
+  let index = 0;
+  for (; ; ) {
+    const word = words[index];
+    if (word === void 0) return void 0;
+    if (word === "env" || /^[A-Za-z_][A-Za-z0-9_]*=/u.test(word)) {
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  const launcher = words[index];
+  if (launcher !== void 0 && LAUNCHER_WORDS.has(executableName(launcher))) {
+    index += 1;
+    const subcommand = words[index];
+    if (subcommand !== void 0 && LAUNCHER_SUBCOMMANDS.has(subcommand)) index += 1;
+  }
+  return words[index];
+}
+function isDevrouterLifecycleCommand(command) {
+  return commandSegments(command).some((segment) => {
+    const word = commandWord(segment);
+    return word !== void 0 && DEVROUTER_EXECUTABLES.has(executableName(word));
+  });
+}
 function detectHarnessHook(payload) {
   const turnId = payload.turn_id;
   return typeof turnId === "string" && turnId.length > 0 ? "codex" : "claude";
@@ -25208,11 +25736,19 @@ function permitReason(decision) {
     }
     return `devrouter: this tool call's wait was cancelled${age}; the harness may have run it. Verify whether it ran before issuing a new call.`;
   }
-  switch (decision.decision) {
-    case "refuse":
+  switch (decision.reason) {
+    case "budget-exhausted":
       return `devrouter: the managed environment is still ${decision.observedPhase} after waiting ${seconds}s. Do not retry automatically; run 'devrouter status .' and continue once it settles.`;
-    case "deferred-allow":
+    case "settled-after-wait":
       return `devrouter: environment settled after ${seconds}s; the tool may run now.`;
+    case "devrouter-command":
+      return "devrouter: lifecycle command; the gate left it to the lifecycle engine and did not observe the environment.";
+    case "unmanaged-checkout":
+      return "devrouter: no managed checkout was found for this call; the gate did not observe environment state.";
+    case "hook-payload-invalid":
+      return "devrouter: the hook payload was unreadable; the gate did not observe environment state.";
+    case "evidence-unavailable":
+      return "devrouter: lifecycle evidence was unavailable; the gate observed no settled phase and the tool proceeds.";
     default:
       return "devrouter: environment settled.";
   }
@@ -25280,10 +25816,9 @@ async function runHarnessCommand(method, options, repoPath, dependencies = {}) {
     return;
   }
   kind = detectHarnessHook(payload);
-  const toolName = typeof payload.tool_name === "string" ? payload.tool_name : "";
   const toolInput = isRecord7(payload.tool_input) ? payload.tool_input : {};
-  const command = typeof toolInput.command === "string" ? toolInput.command : "";
-  if (toolName === "Bash" && DEVROUTER_COMMAND_RE.test(command)) {
+  const command = typeof toolInput.command === "string" ? toolInput.command : typeof toolInput.cmd === "string" ? toolInput.cmd : "";
+  if (isDevrouterLifecycleCommand(command)) {
     const decision2 = gateDecision("allow", "devrouter-command");
     process.stdout.write(
       json ? `${JSON.stringify(decision2)}
@@ -25305,7 +25840,7 @@ async function runHarnessCommand(method, options, repoPath, dependencies = {}) {
   }
   const budgetMs = parseHarnessGateBudget(options.waitBudgetMs);
   const toolUseId = typeof payload.tool_use_id === "string" && payload.tool_use_id.length > 0 && payload.tool_use_id.length <= MAX_TOOL_USE_ID_LENGTH2 ? payload.tool_use_id : void 0;
-  const payloadSha256 = (0, import_node_crypto27.createHash)("sha256").update(JSON.stringify(toolInput)).digest("hex");
+  const payloadSha256 = (0, import_node_crypto28.createHash)("sha256").update(JSON.stringify(toolInput)).digest("hex");
   const claim2 = dependencies.claim ?? ((root, input2) => {
     const outcome = claimHarnessContinuation(root, input2);
     if (outcome.kind === "claimed") {
@@ -25413,17 +25948,20 @@ async function runHarnessCommand(method, options, repoPath, dependencies = {}) {
 `
   );
 }
-var import_node_crypto27, MAX_HOOK_PAYLOAD_BYTES, STDIN_TIMEOUT_MS, MAX_TOOL_USE_ID_LENGTH2, DEVROUTER_COMMAND_RE;
+var import_node_crypto28, MAX_HOOK_PAYLOAD_BYTES, STDIN_TIMEOUT_MS, MAX_TOOL_USE_ID_LENGTH2, DEVROUTER_EXECUTABLES, LAUNCHER_WORDS, LAUNCHER_SUBCOMMANDS, COMMAND_WORD_LIMIT;
 var init_harness = __esm({
   "src/commands/harness.ts"() {
     "use strict";
-    import_node_crypto27 = require("crypto");
+    import_node_crypto28 = require("crypto");
     init_harness_continuation();
     init_harness_gate();
     MAX_HOOK_PAYLOAD_BYTES = 256 * 1024;
     STDIN_TIMEOUT_MS = 5e3;
     MAX_TOOL_USE_ID_LENGTH2 = 256;
-    DEVROUTER_COMMAND_RE = /(?:^|[\s;&|()])(?:npx\s+|pnpm\s+(?:exec\s+)?|npm\s+(?:exec\s+)?|yarn\s+)?devrouter(?:-process)?(?:\s|$)/;
+    DEVROUTER_EXECUTABLES = /* @__PURE__ */ new Set(["devrouter", "devrouter-process"]);
+    LAUNCHER_WORDS = /* @__PURE__ */ new Set(["npx", "pnpm", "npm", "yarn"]);
+    LAUNCHER_SUBCOMMANDS = /* @__PURE__ */ new Set(["exec", "dlx"]);
+    COMMAND_WORD_LIMIT = 8;
   }
 });
 
@@ -25530,7 +26068,7 @@ async function runOpenCommand(name) {
     );
     return;
   }
-  const result = (0, import_node_child_process31.spawnSync)("open", [url], { encoding: "utf-8" });
+  const result = (0, import_node_child_process32.spawnSync)("open", [url], { encoding: "utf-8" });
   if (result.status !== 0) {
     const details = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
     throw new Error(`Unable to open '${url}': ${details || "unknown error"}`);
@@ -25538,11 +26076,11 @@ async function runOpenCommand(name) {
   process.stdout.write(`Opened ${url}
 `);
 }
-var import_node_child_process31;
+var import_node_child_process32;
 var init_open = __esm({
   "src/commands/open.ts"() {
     "use strict";
-    import_node_child_process31 = require("child_process");
+    import_node_child_process32 = require("child_process");
     init_docker();
     init_host_routes();
     init_repo_config();
@@ -25565,7 +26103,7 @@ async function runLogsCommand(options) {
   const args = ["logs", "--tail", tail, ROUTER_CONTAINER_NAME];
   if (options.follow) {
     args.splice(1, 0, "-f");
-    const child = (0, import_node_child_process32.spawn)("docker", args, { stdio: "inherit" });
+    const child = (0, import_node_child_process33.spawn)("docker", args, { stdio: "inherit" });
     const onSignal = () => {
       child.kill("SIGTERM");
     };
@@ -25579,17 +26117,17 @@ async function runLogsCommand(options) {
       });
     });
   } else {
-    const result = (0, import_node_child_process32.spawnSync)("docker", args, { stdio: "inherit" });
+    const result = (0, import_node_child_process33.spawnSync)("docker", args, { stdio: "inherit" });
     if (result.status !== 0) {
       throw new Error("Failed to retrieve router logs.");
     }
   }
 }
-var import_node_child_process32;
+var import_node_child_process33;
 var init_logs = __esm({
   "src/commands/logs.ts"() {
     "use strict";
-    import_node_child_process32 = require("child_process");
+    import_node_child_process33 = require("child_process");
     init_docker();
     init_router();
   }
@@ -27538,7 +28076,7 @@ function sanitizeRouterId(value) {
   return value.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
 function repoHash(repoPath) {
-  return (0, import_node_crypto28.createHash)("sha1").update(import_node_path64.default.resolve(repoPath)).digest("hex").slice(0, 12);
+  return (0, import_node_crypto29.createHash)("sha1").update(import_node_path64.default.resolve(repoPath)).digest("hex").slice(0, 12);
 }
 function asDockerApp(app) {
   return app.runtime === "docker";
@@ -27635,7 +28173,7 @@ function runDockerComposeUp(repoPath, composeFiles2, overlayPath, services) {
     fileArgs.push("-f", resolved);
   }
   const args = ["compose", ...fileArgs, "-f", overlayPath, "up", "-d", "--wait", ...services];
-  const result = (0, import_node_child_process33.spawnSync)("docker", args, {
+  const result = (0, import_node_child_process34.spawnSync)("docker", args, {
     encoding: "utf-8",
     cwd: repoPath
   });
@@ -27663,7 +28201,7 @@ function queryRunningComposeServices(repoPath, composeFiles2, overlayPath, servi
     "--services",
     ...services
   ];
-  const result = (0, import_node_child_process33.spawnSync)("docker", args, {
+  const result = (0, import_node_child_process34.spawnSync)("docker", args, {
     encoding: "utf-8",
     cwd: repoPath
   });
@@ -27689,7 +28227,7 @@ function runDockerComposeStop(repoPath, composeFiles2, overlayPath, services) {
     fileArgs.push("-f", resolved);
   }
   const args = ["compose", ...fileArgs, "-f", overlayPath, "stop", ...services];
-  const result = (0, import_node_child_process33.spawnSync)("docker", args, {
+  const result = (0, import_node_child_process34.spawnSync)("docker", args, {
     encoding: "utf-8",
     cwd: repoPath
   });
@@ -27715,7 +28253,7 @@ function runDockerComposeLogs(repoPath, composeFiles2, overlayPath, services, ta
     String(tail),
     ...services
   ];
-  (0, import_node_child_process33.spawnSync)("docker", args, {
+  (0, import_node_child_process34.spawnSync)("docker", args, {
     stdio: "inherit",
     cwd: repoPath
   });
@@ -27727,7 +28265,7 @@ function queryMappedPort(repoPath, composeFiles2, overlayPath, service, internal
     fileArgs.push("-f", resolved);
   }
   const args = ["compose", ...fileArgs, "-f", overlayPath, "port", service, String(internalPort)];
-  const result = (0, import_node_child_process33.spawnSync)("docker", args, {
+  const result = (0, import_node_child_process34.spawnSync)("docker", args, {
     encoding: "utf-8",
     cwd: repoPath
   });
@@ -27741,12 +28279,12 @@ 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_crypto28, import_node_fs51, import_node_path64, import_yaml9;
+var import_node_child_process34, import_node_crypto29, import_node_fs51, import_node_path64, import_yaml9;
 var init_docker_run = __esm({
   "src/core/docker-run.ts"() {
     "use strict";
-    import_node_child_process33 = require("child_process");
-    import_node_crypto28 = require("crypto");
+    import_node_child_process34 = require("child_process");
+    import_node_crypto29 = require("crypto");
     import_node_fs51 = __toESM(require("fs"));
     import_node_path64 = __toESM(require("path"));
     import_yaml9 = __toESM(require("yaml"));
@@ -27838,7 +28376,7 @@ function isProcessRunning(pid) {
   }
 }
 function readProcessTree(rootPid) {
-  const result = (0, import_node_child_process34.spawnSync)("ps", ["-ax", "-o", "pid=,ppid="], { encoding: "utf-8" });
+  const result = (0, import_node_child_process35.spawnSync)("ps", ["-ax", "-o", "pid=,ppid="], { encoding: "utf-8" });
   if (result.status !== 0) {
     return [rootPid];
   }
@@ -27949,12 +28487,12 @@ function detectListeningPorts(pids) {
   if (pids.length === 0) {
     return [];
   }
-  const result = (0, import_node_child_process34.spawnSync)("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-a", "-p", pids.join(",")], {
+  const result = (0, import_node_child_process35.spawnSync)("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-a", "-p", pids.join(",")], {
     encoding: "utf-8"
   });
   if (result.error && result.error.code === "ENOENT") {
     if (process.platform === "linux") {
-      const ssResult = (0, import_node_child_process34.spawnSync)("ss", ["-H", "-lntp", "-p"], { encoding: "utf-8" });
+      const ssResult = (0, import_node_child_process35.spawnSync)("ss", ["-H", "-lntp", "-p"], { encoding: "utf-8" });
       if (ssResult.status === 0 && ssResult.stdout) {
         return parseSsListeningPorts(ssResult.stdout, new Set(pids));
       }
@@ -28013,7 +28551,7 @@ async function runHostApp(repoPath, app, extraEnv = {}, secretManager, env, work
     app.hostRun.command,
     true
   ) : app.hostRun.command;
-  const child = (0, import_node_child_process34.spawn)(spawnCommand, {
+  const child = (0, import_node_child_process35.spawn)(spawnCommand, {
     cwd: commandCwd,
     stdio: "inherit",
     shell: true,
@@ -28381,7 +28919,7 @@ async function execWithAppEnv(options) {
           options.command[0],
           true
         );
-        child = (0, import_node_child_process34.spawn)(wrapped, {
+        child = (0, import_node_child_process35.spawn)(wrapped, {
           cwd: deps.repoPath,
           stdio: "inherit",
           shell: true,
@@ -28395,7 +28933,7 @@ async function execWithAppEnv(options) {
           false
         );
         const [cmd, ...wrappedArgs] = wrapped;
-        child = (0, import_node_child_process34.spawn)(cmd, wrappedArgs, {
+        child = (0, import_node_child_process35.spawn)(cmd, wrappedArgs, {
           cwd: deps.repoPath,
           stdio: "inherit",
           shell: false,
@@ -28403,7 +28941,7 @@ async function execWithAppEnv(options) {
         });
       }
     } else if (options.shell) {
-      child = (0, import_node_child_process34.spawn)(options.command[0], {
+      child = (0, import_node_child_process35.spawn)(options.command[0], {
         cwd: deps.repoPath,
         stdio: "inherit",
         shell: true,
@@ -28411,7 +28949,7 @@ async function execWithAppEnv(options) {
       });
     } else {
       const [command, ...args] = options.command;
-      child = (0, import_node_child_process34.spawn)(command, args, {
+      child = (0, import_node_child_process35.spawn)(command, args, {
         cwd: deps.repoPath,
         stdio: "inherit",
         shell: false,
@@ -28432,11 +28970,11 @@ async function execWithAppEnv(options) {
     deps.stopDeps();
   }
 }
-var import_node_child_process34, import_node_net5, import_node_process, import_promises, POLL_INTERVAL_MS, DEFAULT_PORT_TIMEOUT_MS, PROCESS_TERMINATION_GRACE_MS;
+var import_node_child_process35, import_node_net5, import_node_process, import_promises, POLL_INTERVAL_MS, DEFAULT_PORT_TIMEOUT_MS, PROCESS_TERMINATION_GRACE_MS;
 var init_app_run = __esm({
   "src/core/app-run.ts"() {
     "use strict";
-    import_node_child_process34 = require("child_process");
+    import_node_child_process35 = require("child_process");
     import_node_net5 = __toESM(require("net"));
     import_node_process = require("process");
     import_promises = require("readline/promises");
@@ -29360,11 +29898,11 @@ function buildWorkspaceCleanupReport(options = {}, dependencies = {}) {
     networkCapacity: (dependencies.inspectNetworkCapacity ?? inspectNetworkCapacity)()
   };
 }
-var import_node_child_process35, import_node_fs53, DEFAULT_INACTIVE_FOR, READ_ONLY_GIT_ENV2, ACTIVITY_SOURCES, defaultCommandRunner;
+var import_node_child_process36, import_node_fs53, 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_child_process36 = require("child_process");
     import_node_fs53 = __toESM(require("fs"));
     init_devpod_workspaces();
     init_host_routes();
@@ -29383,7 +29921,7 @@ var init_workspace_cleanup = __esm({
     ];
     defaultCommandRunner = (command, args, input2) => {
       const environment = command === "git" ? READ_ONLY_GIT_ENV2 : { ...process.env, LC_ALL: "C" };
-      const result = (0, import_node_child_process35.spawnSync)(command, args, {
+      const result = (0, import_node_child_process36.spawnSync)(command, args, {
         encoding: "utf-8",
         env: environment,
         ...input2 === void 0 ? {} : { input: input2 }
@@ -29480,7 +30018,7 @@ function defaultWorktreePath(mainRepo, ws) {
   return import_node_path66.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/"], {
+  const ignored = (0, import_node_child_process37.spawnSync)("git", ["-C", mainRepo, "check-ignore", "-q", "--no-index", "trees/"], {
     encoding: "utf-8"
   });
   if (ignored.status !== 0) {
@@ -29608,7 +30146,7 @@ function assertFullDownPreflight(mainRepo, target) {
       `Worktree '${target.worktreePath}' is locked; unlock it before workspace down.`
     );
   }
-  const status = (0, import_node_child_process36.spawnSync)(
+  const status = (0, import_node_child_process37.spawnSync)(
     "git",
     ["-C", target.worktreePath, "status", "--porcelain", "--untracked-files=normal"],
     { encoding: "utf-8" }
@@ -29672,11 +30210,11 @@ async function workspaceUp(branch, opts = {}) {
       return selectedPath;
     }
     if (!opts.path) assertDefaultWorktreeRootIgnored(mainRepo);
-    const add = (0, import_node_child_process36.spawnSync)("git", ["-C", mainRepo, "worktree", "add", selectedPath, branch], {
+    const add = (0, import_node_child_process37.spawnSync)("git", ["-C", mainRepo, "worktree", "add", selectedPath, branch], {
       encoding: "utf-8"
     });
     if (add.status !== 0) {
-      const addNew = (0, import_node_child_process36.spawnSync)(
+      const addNew = (0, import_node_child_process37.spawnSync)(
         "git",
         ["-C", mainRepo, "worktree", "add", "-b", branch, selectedPath],
         { encoding: "utf-8" }
@@ -29817,7 +30355,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_fs54.default.existsSync(resolved.worktreePath)) {
-        const rm = (0, import_node_child_process36.spawnSync)("git", ["-C", mainRepo, "worktree", "remove", resolved.worktreePath], {
+        const rm = (0, import_node_child_process37.spawnSync)("git", ["-C", mainRepo, "worktree", "remove", resolved.worktreePath], {
           encoding: "utf-8"
         });
         if (rm.status !== 0) {
@@ -29843,11 +30381,11 @@ async function workspaceStop(target, opts = {}) {
 async function workspaceDown(target, opts = {}) {
   return runWorkspaceLifecycle("down", target, opts);
 }
-var import_node_child_process36, import_node_fs54, import_node_path66, WORKSPACE_ALLOCATION_LOCK_WAIT_MS;
+var import_node_child_process37, import_node_fs54, import_node_path66, 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_child_process37 = require("child_process");
     import_node_fs54 = __toESM(require("fs"));
     import_node_path66 = __toESM(require("path"));
     init_devpod_mutation();
@@ -30033,7 +30571,7 @@ var init_version = __esm({
 
 // src/cli.ts
 var import_commander = require("commander");
-var CLI_VERSION = true ? "0.1.1" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.1.3" : "0.0.0-dev";
 var VERSION_FLAGS = /* @__PURE__ */ new Set(["-V", "--version"]);
 function withErrorHandling(action2) {
   return async (...args) => {