@devrouter/cli 0.1.1 → 0.1.2

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.2" : "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.2" : "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`);
@@ -6574,12 +6588,20 @@ function validate2(record5, identity2) {
     }
   }
 }
+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 +6660,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 +6673,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 +6698,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 +6756,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 +6988,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 +7009,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 +7389,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 +7468,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 +8547,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 +8557,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 +8623,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 +8763,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 +8788,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 +9066,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,
@@ -9353,7 +9484,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 +9582,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 +9778,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 +9790,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 +9926,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 +10168,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)) {
@@ -10260,12 +10391,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"));
@@ -11751,7 +11882,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 +12082,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();
@@ -13515,7 +13646,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 +13669,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 +13726,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 +13766,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 +13780,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 +13811,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 +13903,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();
   }
@@ -15095,14 +15226,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 +15921,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 +16011,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();
@@ -15897,25 +16028,34 @@ var init_managed_post_start = __esm({
 });
 
 // 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 [];
   }
@@ -17019,11 +17159,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 +17183,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_process26, 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_crypto21 = require("crypto");
     import_node_fs35 = __toESM(require("fs"));
     import_node_path43 = __toESM(require("path"));
     import_yaml4 = __toESM(require("yaml"));
@@ -17087,11 +17229,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();
@@ -17847,7 +17989,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 +18140,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 +18780,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 +18944,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 +19047,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 +19067,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 +19202,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 +19220,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 +19240,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 +19341,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 +19425,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 +19600,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 +19629,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 +19805,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 +19832,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 +21276,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
@@ -23205,7 +23351,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.2" : "0.0.0-dev");
   if (runningVersion === "0.0.0-dev") {
     return {
       id: id5,
@@ -23871,6 +24017,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 +24073,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 = [];
@@ -24053,7 +24210,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.2" : "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 +24436,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 +24465,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."
+    };
   }
 });
 
@@ -24916,7 +25081,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 +25179,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 +25250,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 +25288,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 +25330,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 +25461,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 +25541,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 +25565,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 +25673,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;
   }
 });
 
@@ -27538,7 +27801,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";
@@ -27741,12 +28004,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_process33, 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_crypto29 = require("crypto");
     import_node_fs51 = __toESM(require("fs"));
     import_node_path64 = __toESM(require("path"));
     import_yaml9 = __toESM(require("yaml"));
@@ -30033,7 +30296,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.2" : "0.0.0-dev";
 var VERSION_FLAGS = /* @__PURE__ */ new Set(["-V", "--version"]);
 function withErrorHandling(action2) {
   return async (...args) => {