@tridha643/hestia 1.2.0 → 1.3.1

package/dist/cli.js

@@ -7254,7 +7254,7 @@ function parsePidfile(source, path) {
   if (pidfile.schemaVersion !== undefined && pidfile.schemaVersion !== STATE_SCHEMA_VERSION) {
     throw new HestiaError("state-corrupt", `invalid pidfile ${path}: unsupported schemaVersion`, { path });
   }
-  if (typeof pidfile.name !== "string" || !Number.isInteger(pidfile.pid) || typeof pidfile.startTime !== "string" || typeof pidfile.logPath !== "string") {
+  if (typeof pidfile.name !== "string" || !Number.isSafeInteger(pidfile.pid) || pidfile.pid <= 0 || typeof pidfile.startTime !== "string" || typeof pidfile.logPath !== "string") {
     throw new HestiaError("state-corrupt", `invalid pidfile ${path}: missing process identity`, { path });
   }
   if (pidfile.schemaVersion === STATE_SCHEMA_VERSION && typeof pidfile.specFingerprint !== "string") {
@@ -7272,12 +7272,25 @@ function removePidfile(worktreeRoot, name) {
   rmSync2(pidfilePath(worktreeRoot, name), { force: true });
 }
 function listPidfiles(dir) {
+  const scan = scanPidfiles(dir);
+  if (scan.errors[0] !== undefined)
+    throw scan.errors[0];
+  return scan.pidfiles;
+}
+function scanPidfiles(dir) {
   if (!existsSync2(dir))
-    return [];
-  return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => {
-    const path = join2(dir, f);
-    return parsePidfile(readFileSync2(path, "utf8"), path);
-  });
+    return { pidfiles: [], errors: [] };
+  const pidfiles = [];
+  const errors2 = [];
+  for (const file of readdirSync(dir).filter((candidate) => candidate.endsWith(".json"))) {
+    const path = join2(dir, file);
+    try {
+      pidfiles.push(parsePidfile(readFileSync2(path, "utf8"), path));
+    } catch (error) {
+      errors2.push(error);
+    }
+  }
+  return { pidfiles, errors: errors2 };
 }
 function procSpecFingerprint(spec) {
   const env = Object.entries(spec.env ?? {}).sort(([left], [right]) => left.localeCompare(right));
@@ -7290,23 +7303,28 @@ function procSpecFingerprint(spec) {
     backend: spec.backend ?? "proc",
     resolver: spec.varlock ? "varlock" : "direct",
     inspectorPort: spec.inspectorPort ?? null,
+    healthPath: spec.healthPath ?? null,
     configPath: spec.configPath ?? null,
     originService: spec.originService ?? null,
     originEndpoint: spec.originEndpoint ?? null
   });
   return createHash3("sha256").update(canonical).digest("hex");
 }
-function readProcessStartTime(pid, env) {
+function probeProcessStartTime(pid, env) {
   try {
     const out = execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
       encoding: "utf8",
       env
     }).trim();
-    return out === "" ? null : out;
+    return { status: "ok", value: out === "" ? null : out };
   } catch {
-    return null;
+    return { status: "error" };
   }
 }
+function readProcessStartTime(pid, env) {
+  const result = probeProcessStartTime(pid, env);
+  return result.status === "ok" ? result.value : null;
+}
 function startTimeOf(pid) {
   return readProcessStartTime(pid, { ...process.env, LC_ALL: "C", LANG: "C" });
 }
@@ -7357,30 +7375,40 @@ function plausibleProcessLocales(canonicalStartTime, recordedStartTime) {
   });
   return [...new Set(plausible)];
 }
-function legacyLocalizedStartTimeMatches(pid, canonicalStartTime, recordedStartTime) {
+function probeLegacyLocalizedStartTime(pid, canonicalStartTime, recordedStartTime) {
   const cacheKey = `${pid}\x00${canonicalStartTime}\x00${recordedStartTime}`;
   const cached = legacyStartTimeMatches.get(cacheKey);
   if (cached !== undefined)
-    return cached;
+    return cached ? "live" : "dead";
   let matched = false;
+  let readFailed = false;
   for (const locale of plausibleProcessLocales(canonicalStartTime, recordedStartTime)) {
-    const localized = readProcessStartTime(pid, {
+    const read = probeProcessStartTime(pid, {
       ...process.env,
       LC_ALL: locale,
       LANG: locale
     });
-    if (localized !== null && processStartTimeMatches(localized, recordedStartTime)) {
+    if (read.status === "error") {
+      readFailed = true;
+      continue;
+    }
+    if (read.value !== null && processStartTimeMatches(read.value, recordedStartTime)) {
       matched = true;
       break;
     }
   }
+  if (!matched && readFailed)
+    return "unknown";
   if (legacyStartTimeMatches.size >= 512) {
     const oldest = legacyStartTimeMatches.keys().next().value;
     if (oldest !== undefined)
       legacyStartTimeMatches.delete(oldest);
   }
   legacyStartTimeMatches.set(cacheKey, matched);
-  return matched;
+  return matched ? "live" : "dead";
+}
+function legacyLocalizedStartTimeMatches(pid, canonicalStartTime, recordedStartTime) {
+  return probeLegacyLocalizedStartTime(pid, canonicalStartTime, recordedStartTime) === "live";
 }
 function processStartTimeMatches(current, recorded) {
   if (current === recorded)
@@ -7402,6 +7430,27 @@ function isLive(pf) {
     return true;
   return current !== null && legacyLocalizedStartTimeMatches(pf.pid, current, pf.startTime);
 }
+function probeProcessIdentity(pf) {
+  try {
+    process.kill(pf.pid, 0);
+  } catch (error) {
+    return error.code === "ESRCH" ? "dead" : "unknown";
+  }
+  let current;
+  try {
+    current = execFileSync("ps", ["-o", "lstart=", "-p", String(pf.pid)], {
+      encoding: "utf8",
+      env: { ...process.env, LC_ALL: "C", LANG: "C" }
+    }).trim();
+  } catch {
+    return "unknown";
+  }
+  if (current === "")
+    return "dead";
+  if (processStartTimeMatches(current, pf.startTime))
+    return "live";
+  return probeLegacyLocalizedStartTime(pf.pid, current, pf.startTime);
+}
 var installedProcessLocales, legacyStartTimeMatches, legacyMacosProcessLocales;
 var init_pidfile = __esm(() => {
   init_src();
@@ -7529,6 +7578,13 @@ function readMirrorState(project) {
   chmodSync2(p, 384);
   return record;
 }
+function readMirrorStateSafe(project) {
+  try {
+    return { status: "ok", record: readMirrorState(project) };
+  } catch (error) {
+    return { status: "error", error };
+  }
+}
 function clearState(worktreeRoot, project) {
   const p = statePath(worktreeRoot);
   if (existsSync3(p))
@@ -7738,6 +7794,26 @@ var init_override = __esm(() => {
 // packages/engine/src/repository-config.ts
 import { existsSync as existsSync4, readFileSync as readFileSync5 } from "fs";
 import { join as join5 } from "path";
+function parseEnvironment(value, path) {
+  if (value === undefined)
+    return {};
+  const environment = {};
+  for (const [name, rawValue] of Object.entries(table(value, path))) {
+    if (!ENVIRONMENT_KEY.test(name))
+      throw new Error(`${path} has invalid environment key ${JSON.stringify(name)}`);
+    if (typeof rawValue === "string") {
+      environment[name] = rawValue;
+      continue;
+    }
+    const fileValue = table(rawValue, `${path}.${name}`);
+    knownKeys(fileValue, ["file"], `${path}.${name}`);
+    if (typeof fileValue.file !== "string" || !/^\.hestia\//.test(fileValue.file) || fileValue.file.includes("..")) {
+      throw new Error(`${path}.${name}.file must be a path below .hestia/`);
+    }
+    environment[name] = { file: fileValue.file };
+  }
+  return environment;
+}
 function emptyConfig() {
   return { version: 1, workloads: {} };
 }
@@ -7797,7 +7873,19 @@ function parseRepositoryWorkloadConfig(source, path) {
       if (!WORKLOAD_NAME.test(name))
         throw new Error(`invalid workload name ${JSON.stringify(name)}`);
       const workload = table(rawWorkload, `workloads.${name}`);
-      knownKeys(workload, ["source", "compose_service", "dockerfile", "command", "wrangler_config", "port", "endpoints"], `workloads.${name}`);
+      knownKeys(workload, [
+        "source",
+        "compose_service",
+        "dockerfile",
+        "command",
+        "wrangler_config",
+        "port",
+        "cwd",
+        "varlock",
+        "health_path",
+        "env",
+        "endpoints"
+      ], `workloads.${name}`);
       if (!["compose", "dockerfile", "proc", "wrangler"].includes(workload.source)) {
         throw new Error(`workloads.${name}.source must be compose, dockerfile, proc, or wrangler`);
       }
@@ -7813,6 +7901,18 @@ function parseRepositoryWorkloadConfig(source, path) {
           throw new Error(`workloads.${name}.${key} must be a string`);
         }
       }
+      if (workload.cwd !== undefined && typeof workload.cwd !== "string") {
+        throw new Error(`workloads.${name}.cwd must be a string`);
+      }
+      if (workload.varlock !== undefined && typeof workload.varlock !== "boolean") {
+        throw new Error(`workloads.${name}.varlock must be a boolean`);
+      }
+      if (workload.health_path !== undefined && (typeof workload.health_path !== "string" || !workload.health_path.startsWith("/"))) {
+        throw new Error(`workloads.${name}.health_path must start with /`);
+      }
+      if (workload.health_path !== undefined && workload.port === "none") {
+        throw new Error(`workloads.${name}.health_path requires a port`);
+      }
       if (sourceKind === "compose" && typeof workload.compose_service !== "string") {
         throw new Error(`workloads.${name}.compose_service is required for compose`);
       }
@@ -7826,6 +7926,10 @@ function parseRepositoryWorkloadConfig(source, path) {
         command: workload.command,
         wranglerConfig: workload.wrangler_config,
         port: workload.port,
+        cwd: workload.cwd,
+        varlock: workload.varlock,
+        healthPath: workload.health_path,
+        env: parseEnvironment(workload.env, `workloads.${name}.env`),
         endpoints: parseEndpoints(workload.endpoints, `workloads.${name}.endpoints`)
       };
     }
@@ -7870,6 +7974,17 @@ function renderRepositoryWorkloadConfig(config) {
       lines.push(`wrangler_config = ${quote(workload.wranglerConfig)}`);
     if (workload.port !== undefined)
       lines.push(`port = ${quote(workload.port)}`);
+    if (workload.cwd !== undefined)
+      lines.push(`cwd = ${quote(workload.cwd)}`);
+    if (workload.varlock !== undefined)
+      lines.push(`varlock = ${workload.varlock}`);
+    if (workload.healthPath !== undefined)
+      lines.push(`health_path = ${quote(workload.healthPath)}`);
+    for (const key of Object.keys(workload.env).sort()) {
+      const value = workload.env[key];
+      const rendered = typeof value === "string" ? quote(value) : `{ file = ${quote(value.file)} }`;
+      lines.push(`env.${quote(key)} = ${rendered}`);
+    }
     lines.push("");
     for (const alias of Object.keys(workload.endpoints).sort()) {
       const endpoint = workload.endpoints[alias];
@@ -7883,12 +7998,13 @@ function renderRepositoryWorkloadConfig(config) {
 `).trimEnd()}
 `;
 }
-var WORKLOAD_NAME, BINDING;
+var WORKLOAD_NAME, BINDING, ENVIRONMENT_KEY;
 var init_repository_config = __esm(() => {
   init_src();
   init_state();
   WORKLOAD_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
   BINDING = /^(?:main|[1-9][0-9]{0,4})\/(?:tcp|udp)$/;
+  ENVIRONMENT_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
 });
 
 // packages/engine/src/discovery.ts
@@ -7926,7 +8042,12 @@ function sameEndpoint(left, right) {
   return left.binding === right.binding && left.kind === right.kind && left.local === right.local;
 }
 function cloneWorkload(workload) {
-  return { ...workload, command: workload.command?.slice(), endpoints: { ...workload.endpoints } };
+  return {
+    ...workload,
+    command: workload.command?.slice(),
+    env: { ...workload.env },
+    endpoints: { ...workload.endpoints }
+  };
 }
 function mergeConfigLayers(repository, machine) {
   const workloads = {};
@@ -7952,6 +8073,10 @@ function mergeConfigLayers(repository, machine) {
       conflicts.push(`machine workload ${name} cannot replace committed source ${committed.source} with ${overlay.source}`);
       continue;
     }
+    committed.cwd = overlay.cwd ?? committed.cwd;
+    committed.varlock = overlay.varlock ?? committed.varlock;
+    committed.healthPath = overlay.healthPath ?? committed.healthPath;
+    committed.env = { ...committed.env, ...overlay.env };
     for (const [alias, endpoint] of Object.entries(overlay.endpoints)) {
       const existing = committed.endpoints[alias];
       if (existing !== undefined && !sameEndpoint(existing, endpoint)) {
@@ -8244,7 +8369,7 @@ async function composeUp(ctx, services) {
 async function composeDown(ctx, destroy) {
   const rest = ["down", "--remove-orphans"];
   if (destroy)
-    rest.push("-v");
+    rest.push("-v", "--rmi", "local");
   await docker(ctx, rest);
 }
 async function composePs(ctx) {
@@ -8373,7 +8498,7 @@ function allocatePort() {
     });
   });
 }
-function psSnapshot() {
+function tryPsSnapshot() {
   try {
     const out = execFileSync2("ps", ["-A", "-o", "pid=,pgid=,ppid="], {
       encoding: "utf8",
@@ -8388,11 +8513,10 @@ function psSnapshot() {
     }
     return rows;
   } catch {
-    return [];
+    return null;
   }
 }
-function processTree(rootPid) {
-  const rows = psSnapshot();
+function processTreeFromSnapshot(rootPid, rows) {
   const byParent = new Map;
   for (const r of rows) {
     const list = byParent.get(r.ppid) ?? [];
@@ -8415,6 +8539,9 @@ function processTree(rootPid) {
   }
   return tree;
 }
+function processTree(rootPid) {
+  return processTreeFromSnapshot(rootPid, tryPsSnapshot() ?? []);
+}
 function parseLsof(out) {
   const listeners = [];
   let pid = 0;
@@ -8450,12 +8577,12 @@ async function allListeners() {
       return parseLsof(stdout);
     } catch (err) {
       const e = err;
-      if (typeof e.stdout === "string" && e.code !== "ENOENT") {
+      if (typeof e.stdout === "string" && e.code === 1 && (e.stderr ?? "").trim() === "") {
         tool = "lsof";
         return parseLsof(e.stdout);
       }
-      if (tool === "lsof")
-        return [];
+      if (e.code !== "ENOENT")
+        throw err;
     }
   }
   try {
@@ -8464,16 +8591,24 @@ async function allListeners() {
     });
     tool = "ss";
     return parseSs(stdout);
-  } catch {
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
     throw new HestiaError("ownership-tool-missing", "neither lsof nor ss is available \u2014 cannot verify port ownership " + "(required: tools like next dev silently bind a different port when " + "theirs is taken, so a bare listen-check would report the wrong port healthy)");
   }
 }
 async function inspectPort(rootPid, port) {
-  const members = new Set(processTree(rootPid).map((r) => r.pid));
+  const firstSnapshot = tryPsSnapshot();
+  if (firstSnapshot === null)
+    throw new Error("Port ownership process-tree inspection failed: ps unavailable");
+  const members = new Set(processTreeFromSnapshot(rootPid, firstSnapshot).map((r) => r.pid));
   const listeners = await allListeners();
   const owner = listeners.find((l) => l.port === port);
   if (owner !== undefined && !members.has(owner.pid)) {
-    for (const member of processTree(rootPid))
+    const secondSnapshot = tryPsSnapshot();
+    if (secondSnapshot === null)
+      throw new Error("Port ownership process-tree recheck failed: ps unavailable");
+    for (const member of processTreeFromSnapshot(rootPid, secondSnapshot))
       members.add(member.pid);
   }
   return {
@@ -8543,19 +8678,32 @@ var init_shutdown = __esm(() => {
 
 // packages/engine/src/proc/resolver.ts
 import { existsSync as existsSync6 } from "fs";
-import { join as join8 } from "path";
-function detectVarlock(worktreeRoot) {
-  const schema = join8(worktreeRoot, ".env.schema");
-  const bin = join8(worktreeRoot, "node_modules", ".bin", "varlock");
-  return existsSync6(schema) && existsSync6(bin) ? bin : null;
+import { dirname as dirname3, join as join8, resolve as resolve2 } from "path";
+function detectVarlock(worktreeRoot, workingDirectory = worktreeRoot) {
+  const root = resolve2(worktreeRoot);
+  const cwd = resolve2(workingDirectory);
+  if (!existsSync6(join8(cwd, ".env.schema")))
+    return null;
+  let directory = cwd;
+  for (;; ) {
+    const bin = join8(directory, "node_modules", ".bin", "varlock");
+    if (existsSync6(bin))
+      return bin;
+    if (directory === root)
+      return null;
+    const parent = dirname3(directory);
+    if (parent === directory || !parent.startsWith(root))
+      return null;
+    directory = parent;
+  }
 }
 function wrapWithVarlock(bin, argv) {
   return [bin, "run", "--no-redact-stdout", "--", ...argv];
 }
-function requireVarlock(worktreeRoot) {
-  const bin = detectVarlock(worktreeRoot);
+function requireVarlock(worktreeRoot, workingDirectory = worktreeRoot) {
+  const bin = detectVarlock(worktreeRoot, workingDirectory);
   if (bin === null) {
-    throw new HestiaError("varlock-missing", `--varlock requires both ${join8(worktreeRoot, ".env.schema")} and a local ` + `node_modules/.bin/varlock in the worktree`);
+    throw new HestiaError("varlock-missing", `--varlock requires ${join8(workingDirectory, ".env.schema")} and a local ` + `node_modules/.bin/varlock between that directory and the worktree root`);
   }
   return bin;
 }
@@ -8582,7 +8730,7 @@ function spawnOnce(argv, cwd, env, logPath, attempt) {
   closeSync2(openProcAttemptLog(logPath, attempt));
   const relaySpec = Buffer.from(JSON.stringify({ argv, cwd, env, logPath })).toString("base64");
   const relayFd = openSync2(logPath, "a", 384);
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const child = spawn(process.execPath, [PROC_RELAY_ENTRYPOINT], {
       cwd,
       env: { ...process.env, [RELAY_SPEC_ENV]: relaySpec },
@@ -8596,7 +8744,7 @@ function spawnOnce(argv, cwd, env, logPath, attempt) {
     child.once("spawn", () => {
       closeSync2(relayFd);
       child.unref();
-      resolve2(child.pid);
+      resolve3(child.pid);
     });
   });
 }
@@ -8613,18 +8761,22 @@ async function startProc(worktreeRoot, spec, stackEnv, mirrorPidfile2) {
   const cwd = spec.cwd ? join9(worktreeRoot, spec.cwd) : worktreeRoot;
   const wantPort = spec.port !== "none";
   const readyTimeoutMs = spec.readyTimeoutMs ?? READY_TIMEOUT_MS;
-  const varlockBin = spec.varlock ? requireVarlock(worktreeRoot) : null;
+  const varlockBin = spec.varlock ? requireVarlock(worktreeRoot, cwd) : null;
   let lastFailure = "";
   for (let attempt = 1;attempt <= MAX_ATTEMPTS; attempt++) {
     const port = wantPort ? await allocatePort() : undefined;
     let argv = port === undefined ? spec.argv : substitutePort(spec.argv, port);
     if (varlockBin !== null)
       argv = wrapWithVarlock(varlockBin, argv);
+    const resolvedSpecEnvironment = port === undefined ? spec.env : Object.fromEntries(Object.entries(spec.env ?? {}).map(([name, value]) => [
+      name,
+      substitutePort([value], port)[0]
+    ]));
     const env = {
       ...process.env,
       ...stackEnv,
       ...port !== undefined ? { PORT: String(port), [`HESTIA_${envKey(spec.name)}_PORT`]: String(port) } : {},
-      ...spec.env
+      ...resolvedSpecEnvironment
     };
     const pid = await spawnOnce(argv, cwd, env, logPath, attempt);
     const startTime = startTimeOf(pid) ?? "";
@@ -8644,7 +8796,7 @@ async function startProc(worktreeRoot, spec, stackEnv, mirrorPidfile2) {
     };
     writePidfile(worktreeRoot, pf);
     mirrorPidfile2?.(pf);
-    const outcome = await waitUntilReady(pf, port, readyTimeoutMs);
+    const outcome = await waitUntilReady(pf, port, readyTimeoutMs, spec.healthPath);
     const record = {
       name: spec.name,
       backend: pf.backend,
@@ -8680,7 +8832,7 @@ async function startProc(worktreeRoot, spec, stackEnv, mirrorPidfile2) {
         continue;
       case "timeout": {
         record.state = "unhealthy";
-        const bound = outcome.memberPorts.length > 0 ? `it is listening on port(s) ${outcome.memberPorts.join(", ")} instead` : `it never opened a listening socket (if it isn't a server, use --no-port)`;
+        const bound = outcome.healthPending ? `it owned port ${port}, but ${spec.healthPath} never returned a 2xx response` : outcome.memberPorts.length > 0 ? `it is listening on port(s) ${outcome.memberPorts.join(", ")} instead` : `it never opened a listening socket (if it isn't a server, use --no-port)`;
         return {
           record,
           pidfile: pf,
@@ -8691,26 +8843,41 @@ async function startProc(worktreeRoot, spec, stackEnv, mirrorPidfile2) {
   }
   throw new HestiaError("port-allocation-failed", `could not hold a port for "${spec.name}" after ${MAX_ATTEMPTS} attempts (${lastFailure})`);
 }
-async function waitUntilReady(pf, port, timeoutMs) {
+async function waitUntilReady(pf, port, timeoutMs, healthPath) {
   const deadline = Date.now() + timeoutMs;
   if (port === undefined) {
     await new Promise((r) => setTimeout(r, NO_PORT_GRACE_MS));
     return isLive(pf) ? { kind: "ready" } : { kind: "exited" };
   }
   let memberPorts = [];
+  let ownershipProven = false;
   while (Date.now() < deadline) {
     if (!isLive(pf))
       return { kind: "exited" };
-    const view = await inspectPort(pf.pgid, port);
-    memberPorts = view.memberPorts;
-    if (view.ownerIsMember)
-      return { kind: "ready" };
-    if (view.owner !== undefined) {
-      return { kind: "stolen", byPid: view.owner.pid };
+    if (!ownershipProven) {
+      const view = await inspectPort(pf.pgid, port);
+      memberPorts = view.memberPorts;
+      if (view.ownerIsMember)
+        ownershipProven = true;
+      else if (view.owner !== undefined)
+        return { kind: "stolen", byPid: view.owner.pid };
+    }
+    if (ownershipProven) {
+      if (healthPath === undefined)
+        return { kind: "ready" };
+      try {
+        const response = await fetch(`http://127.0.0.1:${port}${healthPath}`);
+        if (response.ok)
+          return { kind: "ready" };
+      } catch {}
     }
     await new Promise((r) => setTimeout(r, POLL_MS2));
   }
-  return { kind: "timeout", memberPorts };
+  return {
+    kind: "timeout",
+    memberPorts,
+    healthPending: healthPath !== undefined && ownershipProven
+  };
 }
 var READY_TIMEOUT_MS = 60000, NO_PORT_GRACE_MS = 2000, POLL_MS2 = 300, MAX_ATTEMPTS = 3, PROC_RESTART_SENTINEL = `--- hestia: proc restarted (port stolen) ---
 `, RELAY_SPEC_ENV = "HESTIA_PROC_RELAY_SPEC", PROC_RELAY_ENTRYPOINT, PORT_TOKEN = "{port}", ESCAPED = "{{port}}", SENTINEL = "\x00";
@@ -9106,12 +9273,12 @@ class SlotLedger {
     return { live, reserved, warnings };
   }
 }
-var DEFAULT_MAX_STACKS = 5, RESERVATION_TTL_MS = 60000, DOCKER_PROBE_TIMEOUT_MS = 5000, dockerProbe = (project) => new Promise((resolve2) => {
+var DEFAULT_MAX_STACKS = 5, RESERVATION_TTL_MS = 60000, DOCKER_PROBE_TIMEOUT_MS = 5000, dockerProbe = (project) => new Promise((resolve3) => {
   execFile5("docker", ["ps", "-q", "--filter", `label=${LABELS.stack}=${project}`], { timeout: DOCKER_PROBE_TIMEOUT_MS }, (err, stdout) => {
     if (err)
-      resolve2(null);
+      resolve3(null);
     else
-      resolve2(stdout.trim() === "" ? "dead" : "live");
+      resolve3(stdout.trim() === "" ? "dead" : "live");
   });
 });
 var init_slots = __esm(() => {
@@ -9312,7 +9479,7 @@ var init_client = __esm(() => {
 import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync11, rmSync as rmSync6 } from "fs";
 import { execFileSync as execFileSync3 } from "child_process";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname3, join as join13 } from "path";
+import { dirname as dirname4, join as join13 } from "path";
 import { fileURLToPath } from "url";
 function launchAgentsDir() {
   return process.env.HESTIA_LAUNCHD_DIR ?? join13(homedir2(), "Library", "LaunchAgents");
@@ -9321,7 +9488,7 @@ function plistPath() {
   return join13(launchAgentsDir(), `${LAUNCHD_LABEL}.plist`);
 }
 function daemonMainPath() {
-  const bundled = join13(dirname3(fileURLToPath(import.meta.url)), "daemon.js");
+  const bundled = join13(dirname4(fileURLToPath(import.meta.url)), "daemon.js");
   if (existsSync11(bundled))
     return bundled;
   return fileURLToPath(new URL("./main.ts", import.meta.url));
@@ -9424,7 +9591,7 @@ function installLaunchd(opts) {
     return { plist, warnings };
   }
   mkdirSync6(launchAgentsDir(), { recursive: true });
-  mkdirSync6(dirname3(input.logPath), { recursive: true });
+  mkdirSync6(dirname4(input.logPath), { recursive: true });
   const target = plistPath();
   const previous = existsSync11(target) ? readFileSync11(target, "utf8") : null;
   const previouslyBootstrapped = isBootstrapped();
@@ -9510,14 +9677,14 @@ class Admission {
     const first = await this.#locked(() => this.#try(identity2, holder));
     if (first.granted || waitMs <= 0)
       return first;
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const waiter = {
         identity: identity2,
         holder,
-        resolve: resolve2,
+        resolve: resolve3,
         timer: setTimeout(() => {
           this.#queue = this.#queue.filter((candidate) => candidate !== waiter);
-          resolve2({ granted: false, live: first.live });
+          resolve3({ granted: false, live: first.live });
         }, waitMs)
       };
       this.#queue.push(waiter);
@@ -9579,11 +9746,11 @@ class Admission {
     return { granted: false, live: occupancy.live };
   }
   async#pump() {
-    if (this.#queue.length === 0)
-      return;
     const { maxStacks } = resolveMaxStacks();
     const occupancy = await this.ledger.occupancy();
     this.#cache(occupancy);
+    if (this.#queue.length === 0)
+      return;
     let used = occupancy.live.length + occupancy.reserved.length;
     const granted = [];
     for (const waiter of this.#queue) {
@@ -9621,7 +9788,7 @@ class Admission {
     };
   }
 }
-var HESTIAD_PROTOCOL_VERSION = 5, MAX_JSON_BODY_BYTES;
+var HESTIAD_PROTOCOL_VERSION = 6, MAX_JSON_BODY_BYTES;
 var init_routes = __esm(() => {
   init_src();
   init_state();
@@ -9758,13 +9925,13 @@ function portlessPayloadProvenanceIsCurrent(value) {
   const provenance = value;
   return provenance.package === "portless" && provenance.version === HESTIA_PORTLESS_VERSION && provenance.patchSha256 === HESTIA_PORTLESS_PATCH_SHA256;
 }
-var HESTIA_PORTLESS_VERSION = "0.15.1", HESTIA_PORTLESS_PATCH_SHA256 = "9ca94ca771ce502769a2c7cbe3bb4fe8d54dc847ff9f7e3e2b34abf728618690";
+var HESTIA_PORTLESS_VERSION = "0.15.1", HESTIA_PORTLESS_PATCH_SHA256 = "7d969a7e8bc556d0e866accc836b06e237f567b68d3d7fb7eaed5b0378fbc2d6";
 
 // packages/engine/src/router/portless-adapter.ts
 import { execFile as execFile6, spawnSync } from "child_process";
 import { existsSync as existsSync12, readFileSync as readFileSync12, rmSync as rmSync7, statSync } from "fs";
 import { promisify as promisify5 } from "util";
-import { dirname as dirname4, join as join15 } from "path";
+import { dirname as dirname5, join as join15 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { createConnection } from "net";
 import { tmpdir } from "os";
@@ -9775,12 +9942,12 @@ function hestiaPortlessAliasesPath() {
   return join15(hestiaHome(), "router", "portless", "aliases.json");
 }
 function portlessCliPath() {
-  const moduleDirectory = dirname4(fileURLToPath2(import.meta.url));
+  const moduleDirectory = dirname5(fileURLToPath2(import.meta.url));
   const bundled = join15(moduleDirectory, "assets", "portless", "dist", "cli.js");
-  if (existsSync12(bundled) && portlessPayloadRootIsCurrent(dirname4(dirname4(bundled))))
+  if (existsSync12(bundled) && portlessPayloadRootIsCurrent(dirname5(dirname5(bundled))))
     return bundled;
   const workspaceBuild = join15(moduleDirectory, "..", "..", "..", "..", "dist", "assets", "portless", "dist", "cli.js");
-  if (existsSync12(workspaceBuild) && portlessPayloadRootIsCurrent(dirname4(dirname4(workspaceBuild)))) {
+  if (existsSync12(workspaceBuild) && portlessPayloadRootIsCurrent(dirname5(dirname5(workspaceBuild)))) {
     return workspaceBuild;
   }
   throw new HestiaError("router-version-unsupported", "current hardened Portless payload is unavailable; run bun run build and retry");
@@ -9904,11 +10071,11 @@ async function runRootCommand(command, args, interactive, optional = false) {
   }
 }
 async function prepareHardenedPortlessPayloadAt(installDir, interactive) {
-  const packageRoot = dirname4(dirname4(portlessCliPath()));
+  const packageRoot = dirname5(dirname5(portlessCliPath()));
   const portlessDir = join15(installDir, "portless");
   const bunPath = join15(installDir, "bun");
-  const provenanceSource = join15(dirname4(hestiaPortlessAliasesPath()), "payload-provenance.json");
-  ensureDir(dirname4(provenanceSource));
+  const provenanceSource = join15(dirname5(hestiaPortlessAliasesPath()), "payload-provenance.json");
+  ensureDir(dirname5(provenanceSource));
   writeAtomicJsonFile(provenanceSource, expectedPortlessPayloadProvenance());
   await runRootCommand("mkdir", ["-p", installDir], interactive);
   await runRootCommand("rm", ["-rf", portlessDir], interactive);
@@ -9942,7 +10109,7 @@ async function rollbackHardenedPortlessInstall(interactive) {
     await removeHestiaPortlessCa(interactive);
   } catch {}
   await runRootCommand("rm", ["-rf", HESTIA_ROUTER_INSTALL_DIR], interactive, true);
-  rmSync7(dirname4(hestiaPortlessAliasesPath()), { recursive: true, force: true });
+  rmSync7(dirname5(hestiaPortlessAliasesPath()), { recursive: true, force: true });
 }
 async function trustHestiaPortlessCa(interactive) {
   await runRootCommand("env", [
@@ -10008,11 +10175,11 @@ function requireNonInteractivePrivilege() {
   }
 }
 async function loopbackPortIsBusy(port) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const socket = createConnection({ host: "127.0.0.1", port });
     const finish = (busy) => {
       socket.destroy();
-      resolve2(busy);
+      resolve3(busy);
     };
     socket.setTimeout(500, () => finish(false));
     socket.once("connect", () => finish(true));
@@ -10023,7 +10190,7 @@ async function waitForInstalledHestiaRouter(timeoutMs = 1e4) {
   const deadline = Date.now() + timeoutMs;
   let status = await readHestiaRouterStatus();
   while (Date.now() < deadline && !(status.installed && status.running && status.trusted)) {
-    await new Promise((resolve2) => setTimeout(resolve2, 200));
+    await new Promise((resolve3) => setTimeout(resolve3, 200));
     status = await readHestiaRouterStatus();
   }
   if (!(status.installed && status.running && status.trusted)) {
@@ -10035,7 +10202,7 @@ async function waitForRunningHestiaRouter(timeoutMs = 1e4) {
   const deadline = Date.now() + timeoutMs;
   let status = await readHestiaRouterStatus();
   while (Date.now() < deadline && !(status.installed && status.running)) {
-    await new Promise((resolve2) => setTimeout(resolve2, 200));
+    await new Promise((resolve3) => setTimeout(resolve3, 200));
     status = await readHestiaRouterStatus();
   }
   if (!(status.installed && status.running)) {
@@ -10147,7 +10314,7 @@ async function installHestiaRouter(interactive) {
   } else {
     requireNonInteractivePrivilege();
   }
-  ensureDir(dirname4(hestiaPortlessAliasesPath()));
+  ensureDir(dirname5(hestiaPortlessAliasesPath()));
   if (!existsSync12(hestiaPortlessAliasesPath())) {
     writeAtomicJsonFile(hestiaPortlessAliasesPath(), []);
   }
@@ -10182,7 +10349,7 @@ async function uninstallHestiaRouter(interactive) {
     if (ownership === "hestia") {
       await runRootCommand("rm", ["-rf", HESTIA_ROUTER_INSTALL_DIR], interactive);
     }
-    rmSync7(dirname4(hestiaPortlessAliasesPath()), { recursive: true, force: true });
+    rmSync7(dirname5(hestiaPortlessAliasesPath()), { recursive: true, force: true });
   } catch (error) {
     const detail = error.stderr ?? error.message;
     throw new HestiaError("router-unreachable", `Router uninstall failed: ${detail.trim()}`);
@@ -10354,11 +10521,93 @@ var init_shared = __esm(() => {
   PATH_SEGMENT_RE = /^[A-Za-z0-9._~!$&'()*+,;=:@%-]+$/;
 });
 
-// packages/engine/src/router/local-http-router.ts
+// packages/engine/src/router/origin-liveness.ts
 import { execFile as execFile7 } from "child_process";
+import { promisify as promisify6 } from "util";
+async function probeDockerOrigin(target, port) {
+  try {
+    const service = target.service;
+    const args = [
+      "ps",
+      "--no-trunc",
+      "--format",
+      "{{.ID}}\t{{.Ports}}",
+      "--filter",
+      `label=dev.hestia.stack=${target.project}`,
+      "--filter",
+      `label=com.docker.compose.service=${service.name}`
+    ];
+    const { stdout } = await pexec6("docker", args, { timeout: 2000 });
+    const matches = stdout.split(`
+`).some((line) => {
+      const [id, ports = ""] = line.split("\t");
+      const identityMatches = service.containerId === undefined || id?.startsWith(service.containerId);
+      return identityMatches && new RegExp(`(?:127\\.0\\.0\\.1|0\\.0\\.0\\.0):${port}->`).test(ports);
+    });
+    return matches ? "live" : "dead";
+  } catch {
+    return "unknown";
+  }
+}
+async function probeProcOrigin(service, port) {
+  if (service.pid === undefined || service.startTime === undefined)
+    return "dead";
+  if (!Number.isSafeInteger(service.pid) || service.pid <= 0 || typeof service.startTime !== "string") {
+    throw new Error("Route origin has an invalid process identity");
+  }
+  const identity2 = probeProcessIdentity({ pid: service.pid, startTime: service.startTime });
+  if (identity2 !== "live")
+    return identity2;
+  try {
+    return (await inspectPort(service.pid, port)).ownerIsMember ? "live" : "dead";
+  } catch {
+    return "unknown";
+  }
+}
+async function probeLocalRouterTarget(target) {
+  const service = target.service;
+  const port = service?.publishedPort;
+  if (service === undefined || port === undefined || service.backend === "tunnel")
+    return "dead";
+  return service.backend === "docker" ? await probeDockerOrigin(target, port) : await probeProcOrigin(service, port);
+}
+async function verifyLocalRouterTarget(target) {
+  const port = target.service?.publishedPort;
+  try {
+    return port !== undefined && await probeLocalRouterTarget(target) === "live" ? port : null;
+  } catch {
+    return null;
+  }
+}
+async function verifyStackServiceOrigin(record, service, publishedPort = service.publishedPort) {
+  return await verifyLocalRouterTarget({
+    project: record.project,
+    service: { ...service, publishedPort }
+  }) !== null;
+}
+function resolveSharedContractOrigin(mirror, contractService) {
+  const endpoint = mirror.endpoints.find((candidate) => (candidate.alias ?? candidate.name) === contractService);
+  const service = mirror.services.find((candidate) => candidate.name === (endpoint?.workload ?? endpoint?.name));
+  const binding = service?.bindings?.find((candidate) => `${candidate.target}/${candidate.protocol}` === endpoint?.binding);
+  const publishedPort = binding?.publishedPort ?? service?.publishedPort;
+  return service === undefined || service.backend === "tunnel" || publishedPort === undefined ? undefined : { ...service, publishedPort };
+}
+async function probeSharedHolderOrigin(mirror, contractService) {
+  const service = resolveSharedContractOrigin(mirror, contractService);
+  if (service === undefined)
+    return "unknown";
+  return await probeLocalRouterTarget({ project: mirror.project, service });
+}
+var pexec6;
+var init_origin_liveness = __esm(() => {
+  init_pidfile();
+  init_ports();
+  pexec6 = promisify6(execFile7);
+});
+
+// packages/engine/src/router/local-http-router.ts
 import { Agent, createServer as createServer2, request as httpRequest } from "http";
 import { createConnection as createConnection2, createServer as createNetServer } from "net";
-import { promisify as promisify6 } from "util";
 import { existsSync as existsSync14, readFileSync as readFileSync14, readdirSync as readdirSync5 } from "fs";
 import { chmodSync as chmodSync5, lstatSync, mkdirSync as mkdirSync7, rmSync as rmSync9 } from "fs";
 import { tmpdir as tmpdir2 } from "os";
@@ -10430,55 +10679,6 @@ function forwardedHeaders(request, originPort) {
     headers["x-forwarded-for"] = remote;
   return headers;
 }
-async function verifyDockerRouteTarget(target, port) {
-  try {
-    const service = target.service;
-    const args = [
-      "ps",
-      "--no-trunc",
-      "--format",
-      "{{.ID}}\t{{.Ports}}",
-      "--filter",
-      `label=dev.hestia.stack=${target.project}`,
-      "--filter",
-      `label=com.docker.compose.service=${service.name}`
-    ];
-    const { stdout } = await pexec6("docker", args, { timeout: 2000 });
-    return stdout.split(`
-`).some((line) => {
-      const [id, ports = ""] = line.split("\t");
-      const identityMatches = service.containerId === undefined || id?.startsWith(service.containerId);
-      return identityMatches && new RegExp(`(?:127\\.0\\.0\\.1|0\\.0\\.0\\.0):${port}->`).test(ports);
-    });
-  } catch {
-    return false;
-  }
-}
-async function verifyLocalRouterTarget(target) {
-  const service = target.service;
-  const port = service?.publishedPort;
-  if (service === undefined || port === undefined || service.backend === "tunnel")
-    return null;
-  if (service.backend === "docker") {
-    return await verifyDockerRouteTarget(target, port) ? port : null;
-  }
-  if (service.pid === undefined || service.startTime === undefined)
-    return null;
-  if (!isLive({ pid: service.pid, startTime: service.startTime }))
-    return null;
-  try {
-    return (await inspectPort(service.pid, port)).ownerIsMember ? port : null;
-  } catch {
-    return null;
-  }
-}
-async function verifyStackServiceOrigin(record, service, publishedPort = service.publishedPort) {
-  return await verifyLocalRouterTarget({
-    hostname: "",
-    project: record.project,
-    service: { ...service, publishedPort }
-  }) !== null;
-}
 function targetIdentity(target) {
   const service = target.service;
   return [
@@ -10566,27 +10766,27 @@ class HestiaLocalHttpRouter {
   #sharedRoutes = new Map;
   #timer;
   async start() {
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve3, reject) => {
       this.#server.once("error", reject);
       this.#server.listen(0, "127.0.0.1", () => {
         this.#server.off("error", reject);
-        resolve2();
+        resolve3();
       });
     });
     prepareGatewaySocket(this.socketPath);
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve3, reject) => {
       this.#unixServer.once("error", reject);
       this.#unixServer.listen(this.socketPath, () => {
         this.#unixServer.off("error", reject);
         chmodSync5(this.socketPath, 384);
-        resolve2();
+        resolve3();
       });
     });
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve3, reject) => {
       this.#frontServer.once("error", reject);
       this.#frontServer.listen(0, "127.0.0.1", () => {
         this.#frontServer.off("error", reject);
-        resolve2();
+        resolve3();
       });
     });
     await this.refreshRoutes();
@@ -10675,14 +10875,12 @@ class HestiaLocalHttpRouter {
       let target;
       if (holder !== undefined) {
         const stack = records.find((record) => record.project === holder.project);
-        const endpoint = stack?.endpoints.find((candidate2) => (candidate2.alias ?? candidate2.name) === holder.service);
-        const service = stack?.services.find((candidate2) => candidate2.name === (endpoint?.workload ?? endpoint?.name));
-        const binding = service?.bindings?.find((candidate2) => `${candidate2.target}/${candidate2.protocol}` === endpoint?.binding);
-        const publishedPort = binding?.publishedPort ?? service?.publishedPort;
+        const service = stack === undefined ? undefined : resolveSharedContractOrigin(stack, holder.service);
         const candidate = {
           hostname,
           project: holder.project,
-          service: service === undefined || service.backend === "tunnel" || publishedPort === undefined ? undefined : { ...service, publishedPort }
+          sharedHolder: holder.project,
+          service
         };
         const previous = this.#sharedRoutes.get(hostname)?.find((entry) => entry.name === shared.name)?.target;
         target = previous !== undefined && targetIdentity(previous) === targetIdentity(candidate) ? previous : candidate;
@@ -10784,7 +10982,10 @@ Connection: close\r
         };
       }
       if (entry.target?.service?.publishedPort === undefined) {
-        return { status: 503, message: "Hestia route origin unavailable" };
+        return {
+          status: 503,
+          message: `Hestia route origin unavailable \u2014 held by ${entry.target?.project ?? "unknown"}`
+        };
       }
       return { target: entry.target };
     }
@@ -10806,7 +11007,8 @@ Connection: close\r
     const target = match.target;
     const port = target.service.publishedPort;
     if (await verifyLocalRouterTarget(target) !== port) {
-      return sendRouterResponse(response, 503, "Hestia route origin unavailable");
+      const suffix = target.sharedHolder === undefined ? "" : ` \u2014 held by ${target.sharedHolder}`;
+      return sendRouterResponse(response, 503, `Hestia route origin unavailable${suffix}`);
     }
     const proxy = httpRequest({
       hostname: "127.0.0.1",
@@ -10828,7 +11030,8 @@ Connection: close\r
     proxy.on("error", (error) => {
       if (!response.headersSent) {
         const ownershipFailure = error instanceof OriginOwnershipError;
-        sendRouterResponse(response, ownershipFailure ? 503 : 502, ownershipFailure ? "Hestia route origin unavailable" : "Hestia route origin failed");
+        const suffix = target.sharedHolder === undefined ? "" : ` \u2014 held by ${target.sharedHolder}`;
+        sendRouterResponse(response, ownershipFailure ? 503 : 502, ownershipFailure ? `Hestia route origin unavailable${suffix}` : "Hestia route origin failed");
       } else
         response.destroy();
     });
@@ -10905,16 +11108,14 @@ Connection: close\r
     socket.once("error", () => originSocket.destroy());
   }
 }
-var pexec6, ROUTE_REFRESH_MS = 1000, MAX_MIRROR_BYTES, MAX_REQUEST_HEADER_BYTES, HOP_BY_HOP_HEADERS, OriginOwnershipError;
+var ROUTE_REFRESH_MS = 1000, MAX_MIRROR_BYTES, MAX_REQUEST_HEADER_BYTES, HOP_BY_HOP_HEADERS, OriginOwnershipError;
 var init_local_http_router = __esm(() => {
   init_src();
-  init_pidfile();
-  init_ports();
   init_state();
   init_router_config();
   init_portless_adapter();
   init_shared();
-  pexec6 = promisify6(execFile7);
+  init_origin_liveness();
   MAX_MIRROR_BYTES = 2 * 1024 * 1024;
   MAX_REQUEST_HEADER_BYTES = 64 * 1024;
   HOP_BY_HOP_HEADERS = new Set([
@@ -10931,31 +11132,73 @@ var init_local_http_router = __esm(() => {
   };
 });
 
+// packages/engine/src/configured-workload-environment.ts
+import { readFileSync as readFileSync15 } from "fs";
+import { join as join18 } from "path";
+function endpointTemplateValue(endpoint, field) {
+  const value = endpoint[field];
+  if (value === undefined) {
+    throw new HestiaError("config-invalid", `endpoint template requests ${endpoint.name}.${field}, but that endpoint has no ${field}`);
+  }
+  return String(value);
+}
+function resolveEndpointTemplate(template, record) {
+  const resolved = template.replace(ENDPOINT_TEMPLATE, (_match, endpointName, field) => {
+    const endpoint = record.endpoints.find((candidate) => candidate.name === endpointName);
+    if (endpoint === undefined) {
+      throw new HestiaError("config-invalid", `endpoint template references ${JSON.stringify(endpointName)} before that endpoint is available`);
+    }
+    return endpointTemplateValue(endpoint, field);
+  });
+  if (resolved.includes("${endpoint:")) {
+    throw new HestiaError("config-invalid", `malformed endpoint template ${JSON.stringify(template)}`);
+  }
+  return resolved;
+}
+function readIgnoredEnvironmentFile(worktreeRoot, file) {
+  try {
+    return readFileSync15(join18(worktreeRoot, file), "utf8").replace(/\r?\n$/, "");
+  } catch (error) {
+    throw new HestiaError("config-invalid", `cannot read configured environment file ${file}: ${error.message}`, { path: join18(worktreeRoot, file) });
+  }
+}
+function resolveConfiguredEnvironment(worktreeRoot, configured, record) {
+  return Object.fromEntries(Object.entries(configured).map(([name, value]) => {
+    const raw = typeof value === "string" ? value : readIgnoredEnvironmentFile(worktreeRoot, value.file);
+    return [name, resolveEndpointTemplate(raw, record)];
+  }));
+}
+var ENDPOINT_TEMPLATE;
+var init_configured_workload_environment = __esm(() => {
+  init_src();
+  ENDPOINT_TEMPLATE = /\$\{endpoint:([^}]+)\.(host|port|url)\}/g;
+});
+
 // packages/engine/src/wrangler/adapter.ts
-import { existsSync as existsSync15, readFileSync as readFileSync15, statSync as statSync2 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync16, statSync as statSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname5, join as join18, relative as relative3 } from "path";
+import { dirname as dirname6, join as join19, relative as relative3 } from "path";
 import { connect } from "net";
 function privateRegistryDir(worktreeRoot) {
-  return join18(worktreeRoot, ".hestia", "wrangler-registry");
+  return join19(worktreeRoot, ".hestia", "wrangler-registry");
 }
 function globalRegistryDir() {
-  return process.env.WRANGLER_REGISTRY_PATH ?? join18(homedir3(), ".wrangler", "config", "registry");
+  return process.env.WRANGLER_REGISTRY_PATH ?? join19(homedir3(), ".wrangler", "config", "registry");
 }
 function tcpConnectable(address, timeoutMs = 500) {
   const [host, portStr] = address.split(":");
   const port = Number(portStr);
   if (!host || !Number.isFinite(port))
     return Promise.resolve(false);
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const sock = connect({ host, port, timeout: timeoutMs });
     sock.once("connect", () => {
       sock.destroy();
-      resolve2(true);
+      resolve3(true);
     });
     const dead = () => {
       sock.destroy();
-      resolve2(false);
+      resolve3(false);
     };
     sock.once("error", dead);
     sock.once("timeout", dead);
@@ -10968,14 +11211,14 @@ async function preflightForeignSessions(workers) {
   for (const w of workers) {
     if (w.name === null)
       continue;
-    const entryPath = join18(dir, w.name);
+    const entryPath = join19(dir, w.name);
     if (!existsSync15(entryPath))
       continue;
     const freshMs = Date.now() - statSync2(entryPath).mtimeMs;
     let live = freshMs < HEARTBEAT_FRESH_MS;
     if (!live) {
       try {
-        const entry = JSON.parse(readFileSync15(entryPath, "utf8"));
+        const entry = JSON.parse(readFileSync16(entryPath, "utf8"));
         live = entry.debugPortAddress ? await tcpConnectable(entry.debugPortAddress) : false;
       } catch {
         live = false;
@@ -10996,14 +11239,14 @@ async function planWorkers(worktreeRoot, opts) {
     throw new HestiaError("no-workers-found", opts.filter.length > 0 ? `no wrangler configs match --workers=${opts.filter.join(",")}` : `no wrangler.{jsonc,json,toml} found in ${worktreeRoot}`);
   }
   const wranglerBinFor = (configPath) => {
-    let dir = dirname5(configPath);
+    let dir = dirname6(configPath);
     for (;; ) {
-      const candidate = join18(dir, "node_modules", ".bin", "wrangler");
+      const candidate = join19(dir, "node_modules", ".bin", "wrangler");
       if (existsSync15(candidate))
         return candidate;
       if (dir === worktreeRoot)
         return null;
-      const parent = dirname5(dir);
+      const parent = dirname6(dir);
       if (parent === dir)
         return null;
       dir = parent;
@@ -11035,6 +11278,7 @@ async function planWorkers(worktreeRoot, opts) {
       throw new HestiaError("wrangler-missing", `no local wrangler for ${relative3(worktreeRoot, w.configPath)} ` + `(searched node_modules/.bin from the config dir up to the worktree ` + `root) \u2014 hestia never uses a global install`);
     }
     const inspectorPort = await allocatePort();
+    const workerCwd = dirname6(w.configPath);
     specs.push({
       name: w.name,
       argv: [
@@ -11052,9 +11296,10 @@ async function planWorkers(worktreeRoot, opts) {
         WRANGLER_REGISTRY_PATH: registry,
         MINIFLARE_REGISTRY_PATH: registry
       },
+      cwd: relative3(worktreeRoot, workerCwd),
       port: "auto",
       signal: "int",
-      varlock: opts.varlock,
+      varlock: opts.varlock && detectVarlock(worktreeRoot, workerCwd) !== null,
       backend: "wrangler",
       inspectorPort,
       configPath: w.configPath
@@ -11066,6 +11311,7 @@ var HEARTBEAT_FRESH_MS = 60000;
 var init_adapter = __esm(() => {
   init_src();
   init_ports();
+  init_resolver();
   init_discover();
 });
 
@@ -11105,12 +11351,12 @@ import { execFile as execFile8 } from "child_process";
 import { promisify as promisify7 } from "util";
 import { existsSync as existsSync17 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function cloudflaredHome() {
-  return process.env.HESTIA_CLOUDFLARED_HOME ?? join19(homedir4(), ".cloudflared");
+  return process.env.HESTIA_CLOUDFLARED_HOME ?? join20(homedir4(), ".cloudflared");
 }
 function credFilePath(uuid) {
-  return process.env.TUNNEL_CRED_FILE ?? join19(cloudflaredHome(), `${uuid}.json`);
+  return process.env.TUNNEL_CRED_FILE ?? join20(cloudflaredHome(), `${uuid}.json`);
 }
 async function run(args, timeoutMs = 30000) {
   try {
@@ -11157,8 +11403,8 @@ var init_cloudflared = __esm(() => {
 
 // packages/engine/src/tunnel/ingress.ts
 import { createHash as createHash6 } from "crypto";
-import { existsSync as existsSync18, readFileSync as readFileSync16 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync17 } from "fs";
+import { join as join21 } from "path";
 function hostnameFor(tunnelName, branch, service, zone) {
   const label = `${slug(tunnelName)}-${slug(branch)}-${slug(service)}`;
   if (label.length <= LABEL_MAX)
@@ -11176,12 +11422,12 @@ function inferZone(baseRules) {
   return zones.size === 1 ? [...zones][0] : undefined;
 }
 function importBaseRules(uuid, name) {
-  const p = join20(cloudflaredHome(), "config.yml");
+  const p = join21(cloudflaredHome(), "config.yml");
   if (!existsSync18(p))
     return [];
   let parsed;
   try {
-    parsed = $parse(readFileSync16(p, "utf8"));
+    parsed = $parse(readFileSync17(p, "utf8"));
   } catch {
     return [];
   }
@@ -11251,9 +11497,9 @@ var init_ingress = __esm(() => {
 
 // packages/engine/src/tunnel/orphans.ts
 import { execFileSync as execFileSync4 } from "child_process";
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 function hestiaTunnelMarker(uuid) {
-  return join21(hestiaHome(), "tunnel", uuid);
+  return join22(hestiaHome(), "tunnel", uuid);
 }
 function parseLocalHestiaConnectors(psOutput, marker) {
   const rows = [];
@@ -11376,18 +11622,18 @@ var POLL_MS4 = 300;
 import {
   existsSync as existsSync19,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   readdirSync as readdirSync7
 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 function tunnelDir(uuid) {
-  return join22(hestiaHome(), "tunnel", uuid);
+  return join23(hestiaHome(), "tunnel", uuid);
 }
 function configPath(uuid) {
-  return join22(tunnelDir(uuid), "config.yml");
+  return join23(tunnelDir(uuid), "config.yml");
 }
 function adoptedMarker(uuid) {
-  return join22(tunnelDir(uuid), "adopted.json");
+  return join23(tunnelDir(uuid), "adopted.json");
 }
 function isAdopted(uuid) {
   return existsSync19(adoptedMarker(uuid));
@@ -11398,7 +11644,7 @@ function readAdopted(uuid) {
     return null;
   let marker;
   try {
-    marker = JSON.parse(readFileSync17(p, "utf8"));
+    marker = JSON.parse(readFileSync18(p, "utf8"));
   } catch {
     marker = {};
   }
@@ -11406,14 +11652,14 @@ function readAdopted(uuid) {
     return { uuid, name: marker.name, credFile: marker.credFile, reconstructed: false };
   }
   let name;
-  const stacksDir = join22(hestiaHome(), "stacks");
+  const stacksDir = join23(hestiaHome(), "stacks");
   if (existsSync19(stacksDir)) {
     for (const project of readdirSync7(stacksDir)) {
-      const sp = join22(stacksDir, project, "stack.json");
+      const sp = join23(stacksDir, project, "stack.json");
       if (!existsSync19(sp))
         continue;
       try {
-        const record = parseStackRecord(readFileSync17(sp, "utf8"), sp);
+        const record = parseStackRecord(readFileSync18(sp, "utf8"), sp);
         if (record.tunnel?.uuid === uuid) {
           name = record.tunnel.name;
           break;
@@ -11429,24 +11675,24 @@ function readAdopted(uuid) {
   };
 }
 function listAdopted() {
-  const root = join22(hestiaHome(), "tunnel");
+  const root = join23(hestiaHome(), "tunnel");
   if (!existsSync19(root))
     return [];
   return readdirSync7(root).filter((uuid) => isAdopted(uuid));
 }
 function collectDynamicRules(uuid) {
-  const stacksDir = join22(hestiaHome(), "stacks");
+  const stacksDir = join23(hestiaHome(), "stacks");
   const rules = [];
   const dropped = [];
   if (!existsSync19(stacksDir))
     return { rules, dropped };
   for (const project of readdirSync7(stacksDir)) {
-    const p = join22(stacksDir, project, "stack.json");
+    const p = join23(stacksDir, project, "stack.json");
     if (!existsSync19(p))
       continue;
     let record;
     try {
-      record = parseStackRecord(readFileSync17(p, "utf8"), p);
+      record = parseStackRecord(readFileSync18(p, "utf8"), p);
     } catch {
       continue;
     }
@@ -11490,7 +11736,7 @@ async function reconcileTunnel(ref, opts) {
     if (reapedGroups > 0) {
       warnings.push(`reaped ${reapedGroups} orphan hestia connector process group(s) for this tunnel`);
     }
-    const currentConfig = existsSync19(cfgPath) ? readFileSync17(cfgPath, "utf8") : null;
+    const currentConfig = existsSync19(cfgPath) ? readFileSync18(cfgPath, "utf8") : null;
     if (live && currentConfig === nextConfig) {
       return { restarted: false, metricsPort: pf.port, ready: true, warnings };
     }
@@ -11657,7 +11903,7 @@ async function* composeLogLines(project, service, options = {}) {
     args.push("--follow");
   args.push(service);
   const child = spawn3("docker", args, { stdio: ["ignore", "pipe", "pipe"] });
-  const completion = new Promise((resolve2) => child.once("close", resolve2));
+  const completion = new Promise((resolve3) => child.once("close", resolve3));
   let stderr = "";
   let spawnErrorMessage;
   child.stderr.setEncoding("utf8");
@@ -11747,12 +11993,12 @@ function readLastLineEventsBeforeOffset(path, count, endOffset) {
 function waitForLogPoll(signal) {
   if (signal?.aborted)
     return Promise.resolve();
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const timer = setTimeout(done, LOG_POLL_MS);
     function done() {
       clearTimeout(timer);
       signal?.removeEventListener("abort", done);
-      resolve2();
+      resolve3();
     }
     signal?.addEventListener("abort", done, { once: true });
   });
@@ -11862,10 +12108,10 @@ class BoundedLogMergeQueue {
   }
   async push(item, signal) {
     while (!this.#closed && !signal?.aborted && this.#items.length >= this.capacity) {
-      await new Promise((resolve2) => {
+      await new Promise((resolve3) => {
         const done = () => {
           signal?.removeEventListener("abort", done);
-          resolve2();
+          resolve3();
         };
         this.#capacityWaiters.push(done);
         signal?.addEventListener("abort", done, { once: true });
@@ -11888,7 +12134,7 @@ class BoundedLogMergeQueue {
     }
     if (this.#closed)
       return Promise.resolve({ done: true });
-    return new Promise((resolve2) => this.#waiters.push(resolve2));
+    return new Promise((resolve3) => this.#waiters.push(resolve3));
   }
   close() {
     if (this.#closed)
@@ -12006,12 +12252,46 @@ var init_stream = __esm(() => {
 });
 
 // packages/engine/src/daemon/shared-arbiter.ts
+function probeMirrorProcessOccupancy(mirror) {
+  const identities = [];
+  let malformed = false;
+  for (const service of [...mirror.services, ...mirror.auxiliary ?? []].filter((candidate) => candidate.backend === "proc" || candidate.backend === "wrangler")) {
+    if (service.pid === undefined && service.startTime === undefined)
+      continue;
+    if (!Number.isSafeInteger(service.pid) || service.pid <= 0 || typeof service.startTime !== "string") {
+      malformed = true;
+      continue;
+    }
+    identities.push({ pid: service.pid, startTime: service.startTime });
+  }
+  const pidfileScan = scanPidfiles(mirrorProcsDir(mirror.project));
+  malformed ||= pidfileScan.errors.length > 0;
+  identities.push(...pidfileScan.pidfiles.filter((pidfile) => pidfile.backend !== "tunnel").map((pidfile) => ({ pid: pidfile.pid, startTime: pidfile.startTime })));
+  let unknown = false;
+  for (const identityRecord of identities) {
+    const identity2 = probeProcessIdentity(identityRecord);
+    if (identity2 === "live")
+      return "live";
+    if (identity2 === "unknown")
+      unknown = true;
+  }
+  if (unknown)
+    return "unknown";
+  if (malformed)
+    throw new Error("Shared holder mirror has an invalid process identity");
+  return "dead";
+}
+
 class SharedArbiter {
-  onChange;
   #mutex = Promise.resolve();
   #polls = new Map;
-  constructor(onChange) {
-    this.onChange = onChange;
+  #deadOriginStrikes = new Map;
+  #onChange;
+  #probeHolderOrigin;
+  constructor(onChangeOrOptions) {
+    const options = typeof onChangeOrOptions === "function" ? { onChange: onChangeOrOptions } : onChangeOrOptions;
+    this.#onChange = options?.onChange;
+    this.#probeHolderOrigin = options?.probeHolderOrigin ?? probeSharedHolderOrigin;
   }
   #locked(fn) {
     const next = this.#mutex.then(fn, fn);
@@ -12020,7 +12300,7 @@ class SharedArbiter {
   }
   async#notify() {
     try {
-      await this.onChange?.();
+      await this.#onChange?.();
     } catch {}
   }
   #result(record, granted) {
@@ -12043,7 +12323,8 @@ class SharedArbiter {
         delete next.holder;
         return next;
       }
-      if (readMirrorState(head.project) === null)
+      const mirror = readMirrorStateSafe(head.project);
+      if (mirror.status === "ok" && mirror.record === null)
         continue;
       return {
         ...record,
@@ -12101,11 +12382,11 @@ class SharedArbiter {
     }
     if (waitMs <= 0)
       return this.#result(outcome.record, false);
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const key = `${name}\x00${requester.project}`;
       const polls = this.#polls.get(key) ?? [];
       const poll = {
-        resolve: resolve2,
+        resolve: resolve3,
         timer: setTimeout(() => {
           const remaining = (this.#polls.get(key) ?? []).filter((candidate) => candidate !== poll);
           if (remaining.length === 0)
@@ -12113,7 +12394,7 @@ class SharedArbiter {
           else
             this.#polls.set(key, remaining);
           const record = readSharedHostname(name);
-          resolve2(record === null ? { granted: false, queued: [] } : this.#result(record, record.holder?.project === requester.project));
+          resolve3(record === null ? { granted: false, queued: [] } : this.#result(record, record.holder?.project === requester.project));
         }, waitMs)
       };
       polls.push(poll);
@@ -12195,47 +12476,150 @@ class SharedArbiter {
   }
   async sweep(occupied) {
     let changed = false;
+    const releases = [];
     for (const record of listSharedHostnames()) {
-      const holderDead = record.holder !== undefined && !occupied.has(record.holder.project) && readMirrorState(record.holder.project) === null;
-      const deadWaiters = (record.queue ?? []).filter((waiter) => readMirrorState(waiter.project) === null);
-      if (!holderDead && deadWaiters.length === 0)
+      const holder = record.holder;
+      const holderMirror = holder === undefined ? undefined : readMirrorStateSafe(holder.project);
+      const deadWaiterProjects = new Set((record.queue ?? []).flatMap((waiter) => {
+        const mirror = readMirrorStateSafe(waiter.project);
+        return mirror.status === "ok" && mirror.record === null ? [waiter.project] : [];
+      }));
+      const deadWaiters = (record.queue ?? []).filter((waiter) => deadWaiterProjects.has(waiter.project));
+      let releaseReason;
+      if (holder !== undefined && holderMirror !== undefined) {
+        const holderKey = `${holder.project}\x00${holder.at}`;
+        const holderOccupied = occupied.has(holder.project);
+        if (holderMirror.status === "error") {
+          if (this.#recordDeadStrike(record.name, holderKey))
+            releaseReason = "stack-dead";
+        } else {
+          try {
+            const mirror = holderMirror.record;
+            if (mirror === null) {
+              if (!holderOccupied)
+                releaseReason = "stack-gone";
+              else
+                this.#deadOriginStrikes.delete(record.name);
+            } else {
+              const protectedState = mirror.state === "starting" || mirror.state === "queued";
+              if (!protectedState && mirror.starter !== undefined && (typeof mirror.starter !== "object" || mirror.starter === null || !Number.isSafeInteger(mirror.starter.pid) || mirror.starter.pid <= 0 || typeof mirror.starter.startTime !== "string")) {
+                throw new Error("Shared holder mirror has an invalid starter identity");
+              }
+              const starterLiveness = protectedState || mirror.starter === undefined ? "dead" : probeProcessIdentity(mirror.starter);
+              const protectedStartup = protectedState || starterLiveness === "live";
+              if (protectedStartup) {
+                this.#deadOriginStrikes.delete(record.name);
+              } else if (starterLiveness === "unknown") {
+                this.#retainStrikeForHolder(record.name, holderKey);
+              } else if (!holderOccupied) {
+                const contractOrigin = resolveSharedContractOrigin(mirror, holder.service);
+                if (contractOrigin === undefined) {
+                  const processOccupancy = probeMirrorProcessOccupancy(mirror);
+                  if (processOccupancy === "live") {
+                    this.#deadOriginStrikes.delete(record.name);
+                  } else if (processOccupancy === "unknown") {
+                    this.#retainStrikeForHolder(record.name, holderKey);
+                  } else if (this.#recordDeadStrike(record.name, holderKey)) {
+                    releaseReason = "stack-dead";
+                  }
+                } else {
+                  const origin = await this.#probeHolderOrigin(mirror, holder.service);
+                  if (origin === "live") {
+                    this.#deadOriginStrikes.delete(record.name);
+                  } else if (origin === "dead") {
+                    if (this.#recordDeadStrike(record.name, holderKey))
+                      releaseReason = "stack-dead";
+                  } else {
+                    this.#retainStrikeForHolder(record.name, holderKey);
+                  }
+                }
+              } else {
+                const origin = await this.#probeHolderOrigin(mirror, holder.service);
+                if (origin === "live") {
+                  this.#deadOriginStrikes.delete(record.name);
+                } else if (origin === "dead") {
+                  if (this.#recordDeadStrike(record.name, holderKey))
+                    releaseReason = "origin-dead";
+                } else {
+                  this.#retainStrikeForHolder(record.name, holderKey);
+                }
+              }
+            }
+          } catch {
+            if (this.#recordDeadStrike(record.name, holderKey))
+              releaseReason = "stack-dead";
+          }
+        }
+      } else {
+        this.#deadOriginStrikes.delete(record.name);
+      }
+      if (releaseReason === undefined && deadWaiters.length === 0)
         continue;
+      let released = false;
       const updated = await this.#locked(() => updateSharedHostname(record.name, (candidate) => {
         const pruned = {
           ...candidate,
-          queue: (candidate.queue ?? []).filter((waiter) => readMirrorState(waiter.project) !== null)
+          queue: (candidate.queue ?? []).filter((waiter) => {
+            if (!deadWaiterProjects.has(waiter.project))
+              return true;
+            const freshMirror = readMirrorStateSafe(waiter.project);
+            return freshMirror.status === "error" || freshMirror.record !== null;
+          })
         };
-        const currentHolderDead = pruned.holder !== undefined && !occupied.has(pruned.holder.project) && readMirrorState(pruned.holder.project) === null;
-        return currentHolderDead ? this.#grantNext(pruned) : pruned;
+        const holderMatches = releaseReason !== undefined && pruned.holder?.project === holder?.project && pruned.holder?.at === holder?.at;
+        if (!holderMatches)
+          return pruned;
+        released = true;
+        return this.#grantNext(pruned);
       }));
       if (updated === null)
         continue;
-      changed = true;
+      changed ||= released || deadWaiters.length > 0;
+      if (released && holder !== undefined && releaseReason !== undefined) {
+        releases.push({ name: record.name, project: holder.project, reason: releaseReason });
+        this.#deadOriginStrikes.delete(record.name);
+      }
       if (updated.holder !== undefined && updated.holder.project !== record.holder?.project) {
         this.#wake(updated.name, updated.holder.project, this.#result(updated, true));
       }
     }
     if (changed)
       await this.#notify();
+    return releases;
+  }
+  #recordDeadStrike(name, holderKey) {
+    const previous = this.#deadOriginStrikes.get(name);
+    const strikes = previous?.holderKey === holderKey ? previous.strikes + 1 : 1;
+    this.#deadOriginStrikes.set(name, { holderKey, strikes });
+    return strikes >= ORIGIN_DEAD_RELEASE_STRIKES;
+  }
+  #retainStrikeForHolder(name, holderKey) {
+    const previous = this.#deadOriginStrikes.get(name);
+    if (previous?.holderKey !== holderKey) {
+      this.#deadOriginStrikes.set(name, { holderKey, strikes: 0 });
+    }
   }
 }
+var ORIGIN_DEAD_RELEASE_STRIKES = 3;
 var init_shared_arbiter = __esm(() => {
   init_src();
+  init_pidfile();
   init_state();
+  init_origin_liveness();
   init_shared();
 });
 
 // packages/engine/src/doctor.ts
-import { existsSync as existsSync20, readFileSync as readFileSync18, readdirSync as readdirSync8 } from "fs";
+import { existsSync as existsSync20, readFileSync as readFileSync19, readdirSync as readdirSync8 } from "fs";
 import { execFile as execFile9 } from "child_process";
-import { dirname as dirname6, join as join23 } from "path";
+import { dirname as dirname7, join as join24 } from "path";
 function row(check, level, detail) {
   return { check, level, detail };
 }
 async function bounded(check, fn, timeoutMs = CHECK_TIMEOUT_MS) {
   let timer;
-  const timeout = new Promise((resolve2) => {
-    timer = setTimeout(() => resolve2([row(check, "unknown", "timed out")]), timeoutMs);
+  const timeout = new Promise((resolve3) => {
+    timer = setTimeout(() => resolve3([row(check, "unknown", "timed out")]), timeoutMs);
   });
   try {
     return await Promise.race([fn(), timeout]);
@@ -12246,9 +12630,9 @@ async function bounded(check, fn, timeoutMs = CHECK_TIMEOUT_MS) {
   }
 }
 function exec(cmd, args, timeoutMs = CHECK_TIMEOUT_MS - 500) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     execFile9(cmd, args, { timeout: timeoutMs, encoding: "utf8" }, (err, stdout, stderr) => {
-      resolve2({
+      resolve3({
         ok: err === null,
         stdout: stdout ?? "",
         message: err !== null ? (stderr || err.message).trim().split(`
@@ -12269,21 +12653,21 @@ async function envChecks(ctx) {
   }
   if (ctx !== null) {
     const ignored = await exec("git", ["-C", ctx.worktreeRoot, "check-ignore", "-q", ".hestia/"]);
-    rows.push(ignored.ok ? row("state-ignore", "ok", ".hestia/ is ignored") : row("state-ignore", "error", `add the exact line ".hestia/" to ${join23(ctx.worktreeRoot, ".gitignore")}`));
-    const schema = existsSync20(join23(ctx.worktreeRoot, ".env.schema"));
+    rows.push(ignored.ok ? row("state-ignore", "ok", ".hestia/ is ignored") : row("state-ignore", "error", `add the exact line ".hestia/" to ${join24(ctx.worktreeRoot, ".gitignore")}`));
+    const schema = existsSync20(join24(ctx.worktreeRoot, ".env.schema"));
     if (schema) {
       rows.push(detectVarlock(ctx.worktreeRoot) !== null ? row("varlock", "ok", "local varlock found \u2014 worker env composition active") : row("varlock", "warn", ".env.schema present but no local varlock (bun install?)"));
     }
     const workers = discoverWorkers(ctx.worktreeRoot);
     if (workers.length > 0) {
       const missing = workers.filter((w) => {
-        let dir = dirname6(w.configPath);
+        let dir = dirname7(w.configPath);
         for (;; ) {
-          if (existsSync20(join23(dir, "node_modules", ".bin", "wrangler")))
+          if (existsSync20(join24(dir, "node_modules", ".bin", "wrangler")))
             return false;
-          if (dir === ctx.worktreeRoot || dirname6(dir) === dir)
+          if (dir === ctx.worktreeRoot || dirname7(dir) === dir)
             return true;
-          dir = dirname6(dir);
+          dir = dirname7(dir);
         }
       });
       rows.push(missing.length === 0 ? row("wrangler", "ok", `${workers.length} config(s), local binary reachable for all`) : row("wrangler", "error", `${missing.length}/${workers.length} config(s) have no local wrangler binary (install deps)`));
@@ -12338,10 +12722,10 @@ async function stateChecks(ctx) {
       rows.push(row(`exposure:${exp.service}`, "error", `ingress rule points at port ${exp.originPort} but the service owns ` + `${publishedPort} \u2014 a recycled port serves ANOTHER worktree; ` + `run any hestia command to resync, this should not persist`));
     }
   }
-  const lockPath2 = join23(hestiaDir(worktreeRoot), "lock");
+  const lockPath2 = join24(hestiaDir(worktreeRoot), "lock");
   if (existsSync20(lockPath2)) {
     try {
-      const holder = JSON.parse(readFileSync18(lockPath2, "utf8"));
+      const holder = JSON.parse(readFileSync19(lockPath2, "utf8"));
       if (!isLive(holder)) {
         rows.push(row("lock", "warn", "stale worktree lock (dead holder) \u2014 auto-broken on next command"));
       }
@@ -12349,7 +12733,7 @@ async function stateChecks(ctx) {
       rows.push(row("lock", "warn", "unreadable worktree lock file"));
     }
   }
-  const mirror = join23(hestiaHome(), "stacks", record.project, "stack.json");
+  const mirror = join24(hestiaHome(), "stacks", record.project, "stack.json");
   if (!existsSync20(mirror)) {
     rows.push(row("mirror", "warn", "no ~/.hestia mirror \u2014 `down --project` would not work after worktree deletion"));
   }
@@ -12357,16 +12741,16 @@ async function stateChecks(ctx) {
 }
 async function machineChecks() {
   const rows = [];
-  const stacksDir = join23(hestiaHome(), "stacks");
+  const stacksDir = join24(hestiaHome(), "stacks");
   const mirrored = new Set;
   if (existsSync20(stacksDir)) {
     for (const project of readdirSync8(stacksDir)) {
-      const p = join23(stacksDir, project, "stack.json");
+      const p = join24(stacksDir, project, "stack.json");
       if (!existsSync20(p))
         continue;
       mirrored.add(project);
       try {
-        const rec = parseStackRecord(readFileSync18(p, "utf8"), p);
+        const rec = parseStackRecord(readFileSync19(p, "utf8"), p);
         if (!existsSync20(rec.worktree)) {
           rows.push(row(`orphan-mirror:${project}`, "warn", `worktree ${rec.worktree} is gone \u2014 \`hestia down --project ${project}\` to clean up`));
         }
@@ -12467,7 +12851,7 @@ async function daemonChecks() {
   }
   const plist = plistPath();
   if (existsSync20(plist)) {
-    const content = readFileSync18(plist, "utf8");
+    const content = readFileSync19(plist, "utf8");
     const args = [...content.matchAll(/<string>([^<]+)<\/string>/g)].map((m) => m[1]);
     const paths = args.filter((a) => a.startsWith("/") && !a.includes(":"));
     const missing = paths.filter((p) => !existsSync20(p));
@@ -12539,8 +12923,8 @@ var init_doctor = __esm(() => {
 // packages/engine/src/daemon/fleet-monitor.ts
 import { execFile as execFile10 } from "child_process";
 import { promisify as promisify8 } from "util";
-import { existsSync as existsSync21, readFileSync as readFileSync19, readdirSync as readdirSync9 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync20, readdirSync as readdirSync9 } from "fs";
+import { join as join25 } from "path";
 
 class LatestFleetChannel {
   #pending;
@@ -12567,8 +12951,8 @@ class LatestFleetChannel {
     }
     if (this.#closed)
       return Promise.resolve({ value: undefined, done: true });
-    return new Promise((resolve2) => {
-      this.#waiter = resolve2;
+    return new Promise((resolve3) => {
+      this.#waiter = resolve3;
     });
   }
   close() {
@@ -12583,13 +12967,13 @@ class LatestFleetChannel {
 function readManagedMirrors() {
   const records = [];
   const warnings = [];
-  const stacksDirectory = join24(hestiaHome(), "stacks");
+  const stacksDirectory = join25(hestiaHome(), "stacks");
   if (!existsSync21(stacksDirectory))
     return { records, warnings };
   for (const project of readdirSync9(stacksDirectory).sort()) {
-    const path = join24(stacksDirectory, project, "stack.json");
+    const path = join25(stacksDirectory, project, "stack.json");
     try {
-      const source = readFileSync19(path);
+      const source = readFileSync20(path);
       if (source.byteLength > MAX_MIRROR_BYTES2) {
         warnings.push(`Fleet mirror too large for ${project}`);
         continue;
@@ -12971,7 +13355,7 @@ var init_fleet_monitor = __esm(() => {
 });
 
 // packages/engine/src/init-config.ts
-import { dirname as dirname7, relative as relative4 } from "path";
+import { dirname as dirname8, relative as relative4 } from "path";
 import { chmodSync as chmodSync6, mkdirSync as mkdirSync9 } from "fs";
 function validateName2(name, what) {
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(name)) {
@@ -12987,6 +13371,7 @@ function inferredWorkload(report, name) {
     composeService: workload.source === "compose" ? workload.name : undefined,
     dockerfile: workload.source === "dockerfile" && workload.definitionPath !== undefined ? relative4(report.repository.worktree, workload.definitionPath) : undefined,
     wranglerConfig: workload.source === "wrangler" && workload.definitionPath !== undefined ? relative4(report.repository.worktree, workload.definitionPath) : undefined,
+    env: {},
     endpoints: {}
   };
 }
@@ -13024,6 +13409,7 @@ function applyRequest(report, workloads, request) {
     command: request.kind === "proc" ? request.command : undefined,
     port: request.kind === "proc" ? request.port ?? "auto" : undefined,
     wranglerConfig: request.kind === "wrangler" ? request.file ?? "wrangler.toml" : undefined,
+    env: existing?.env ?? {},
     endpoints: existing?.endpoints ?? {}
   };
 }
@@ -13038,16 +13424,21 @@ async function initializeRepositoryConfig(cwd, request, scope, write) {
       version: 1,
       workloads: Object.fromEntries(Object.entries(layer.config.workloads).map(([name, workload]) => [
         name,
-        { ...workload, command: workload.command?.slice(), endpoints: { ...workload.endpoints } }
+        {
+          ...workload,
+          command: workload.command?.slice(),
+          env: { ...workload.env },
+          endpoints: { ...workload.endpoints }
+        }
       ]))
     };
     applyRequest(before, config.workloads, request);
     const proposed = renderRepositoryWorkloadConfig(config);
     parseRepositoryWorkloadConfig(proposed, path);
     if (write) {
-      mkdirSync9(dirname7(path), { recursive: true, mode: 448 });
+      mkdirSync9(dirname8(path), { recursive: true, mode: 448 });
       if (scope === "machine")
-        chmodSync6(dirname7(path), 448);
+        chmodSync6(dirname8(path), 448);
       writeAtomicTextFile(path, proposed, 384);
     }
     const discovery = write ? await discoverRepository(repo.worktreeRoot) : before;
@@ -13075,7 +13466,7 @@ var init_init_config = __esm(() => {
 import { existsSync as existsSync22, rmSync as rmSync10 } from "fs";
 import { execFile as execFile11 } from "child_process";
 import { promisify as promisify9 } from "util";
-import { join as join25, resolve as resolve2 } from "path";
+import { join as join26, resolve as resolve3 } from "path";
 import { createHash as createHash7 } from "crypto";
 import { resolve4, resolve6, resolveCname } from "dns/promises";
 function composeUnsupported(message) {
@@ -13185,7 +13576,7 @@ async function assertHestiaStateIgnored(worktreeRoot) {
   try {
     await pexec9("git", ["-C", worktreeRoot, "check-ignore", "-q", ".hestia/"], { timeout: 5000 });
   } catch {
-    throw new HestiaError("state-not-ignored", `.hestia is not ignored in ${worktreeRoot}; add the line ".hestia/" to ${join25(worktreeRoot, ".gitignore")}`, { remedy: `.hestia/`, path: join25(worktreeRoot, ".gitignore") });
+    throw new HestiaError("state-not-ignored", `.hestia is not ignored in ${worktreeRoot}; add the line ".hestia/" to ${join26(worktreeRoot, ".gitignore")}`, { remedy: `.hestia/`, path: join26(worktreeRoot, ".gitignore") });
   }
 }
 async function prepareCompose(worktreeRoot, project, repo, branch, opts, configuredBaseFile) {
@@ -13202,7 +13593,7 @@ async function prepareCompose(worktreeRoot, project, repo, branch, opts, configu
     services
   });
   ensureDir(hestiaDir(worktreeRoot));
-  const overridePath = join25(hestiaDir(worktreeRoot), OVERRIDE_FILE);
+  const overridePath = join26(hestiaDir(worktreeRoot), OVERRIDE_FILE);
   writeAtomicTextFile(overridePath, yaml);
   return {
     ctx: {
@@ -13235,7 +13626,7 @@ function writeDockerfileComposeModel(worktreeRoot, workloads, conventionalCompos
     ...conventionalComposeFile === undefined ? {} : { include: [{ path: conventionalComposeFile }] },
     services
   };
-  const path = join25(hestiaDir(worktreeRoot), DOCKERFILE_COMPOSE_FILE);
+  const path = join26(hestiaDir(worktreeRoot), DOCKERFILE_COMPOSE_FILE);
   writeAtomicTextFile(path, $stringify(model));
   return path;
 }
@@ -13255,9 +13646,9 @@ function freshRecord(project, repoId, repo, branch, worktree) {
   };
 }
 function assertCurrentStackIdentity(record, current) {
-  const path = join25(hestiaDir(current.worktreeRoot), "stack.json");
+  const path = join26(hestiaDir(current.worktreeRoot), "stack.json");
   assertMutableStackRecord(record, path);
-  const matches = record.repoId === current.repoId && record.repo === current.repo && record.branch === current.branch && resolve2(record.worktree) === resolve2(current.worktreeRoot) && record.project === projectName(current.repoId, current.repo, current.branch, current.worktreeRoot);
+  const matches = record.repoId === current.repoId && record.repo === current.repo && record.branch === current.branch && resolve3(record.worktree) === resolve3(current.worktreeRoot) && record.project === projectName(current.repoId, current.repo, current.branch, current.worktreeRoot);
   if (!matches) {
     throw new HestiaError("stack-identity-changed", `this checkout no longer matches stack ${record.project}; run hestia down before starting or changing it`, {
       recorded: {
@@ -13434,7 +13825,7 @@ function matchesExpectedStack(record, expected) {
   return record !== null && (record.repoId === undefined || record.repoId === expected.repoId) && record.worktree === expected.worktree && record.createdAt === expected.createdAt;
 }
 function projectMutationRoot(project) {
-  return join25(hestiaHome(), "project-locks", project);
+  return join26(hestiaHome(), "project-locks", project);
 }
 async function assertNamedTunnelDns(hostname, tunnelUuid) {
   const expected = `${tunnelUuid}.cfargotunnel.com`;
@@ -13691,12 +14082,25 @@ class ComposeEngine {
           }
         }
       }
+      applyConfiguredEndpoints(record, configuredWorkloads);
+      if (opts?.workers || configuredWorkers.length > 0) {
+        const configuredFilters = configuredWorkers.map(([name, workload]) => workload.wranglerConfig ?? name);
+        const explicitFilters = Array.isArray(opts?.workers) ? opts.workers : [];
+        await this.#upWorkers(worktreeRoot, record, configuredWorkloads, {
+          ...opts,
+          workers: opts?.workers === true ? true : [...new Set([...explicitFilters, ...configuredFilters])]
+        });
+      }
+      applyConfiguredEndpoints(record, configuredWorkloads);
       for (const [name, workload] of configuredProcs) {
-        const command = workload.command;
         const configuredSpec = {
           name,
-          argv: command,
+          argv: workload.command,
+          cwd: workload.cwd,
+          env: resolveConfiguredEnvironment(worktreeRoot, workload.env, record),
           port: workload.port ?? "auto",
+          varlock: workload.varlock,
+          healthPath: workload.healthPath,
           backend: "proc"
         };
         const clash = record.services.find((service) => service.name === name && service.backend === "docker");
@@ -13717,19 +14121,11 @@ class ComposeEngine {
         }
         const result = await startProc(worktreeRoot, configuredSpec, record.env, (pidfile2) => mirrorPidfile(record.project, pidfile2));
         recordProc(record, result.record);
+        applyConfiguredEndpoints(record, configuredWorkloads);
         writeState(worktreeRoot, record);
         if (result.error !== undefined)
           throw result.error;
       }
-      if (opts?.workers || configuredWorkers.length > 0) {
-        const configuredFilters = configuredWorkers.map(([name, workload]) => workload.wranglerConfig ?? name);
-        const explicitFilters = Array.isArray(opts?.workers) ? opts.workers : [];
-        await this.#upWorkers(worktreeRoot, record, {
-          ...opts,
-          workers: opts?.workers === true ? true : [...new Set([...explicitFilters, ...configuredFilters])]
-        });
-      }
-      applyConfiguredEndpoints(record, configuredWorkloads);
       record.state = "up";
       delete record.starter;
       setTunnelDirty(syncExposures(record));
@@ -13737,17 +14133,27 @@ class ComposeEngine {
       return record;
     }));
   }
-  async#upWorkers(worktreeRoot, record, opts) {
+  async#upWorkers(worktreeRoot, record, configuredWorkloads, opts) {
     const plan = await planWorkers(worktreeRoot, {
       filter: Array.isArray(opts.workers) ? opts.workers : [],
       allowRemote: opts.allowRemote ?? false,
       force: opts.force ?? false,
-      varlock: !opts.noVarlock && detectVarlock(worktreeRoot) !== null
+      varlock: !opts.noVarlock
     });
     for (const w of plan.warnings)
       process.stderr.write(`warning: ${w}
 `);
     for (const spec of plan.specs) {
+      const configured = Object.entries(configuredWorkloads).find(([name, workload]) => workload.source === "wrangler" && (name === spec.name || workload.wranglerConfig !== undefined && resolve3(worktreeRoot, workload.wranglerConfig) === spec.configPath))?.[1];
+      if (configured !== undefined && configured.source === "wrangler") {
+        spec.cwd = configured.cwd ?? spec.cwd;
+        spec.varlock = configured.varlock ?? spec.varlock;
+        spec.healthPath = configured.healthPath;
+        spec.env = {
+          ...spec.env,
+          ...resolveConfiguredEnvironment(worktreeRoot, configured.env, record)
+        };
+      }
       const clash = record.services.find((s) => s.name === spec.name && s.backend === "docker");
       if (clash !== undefined) {
         throw new HestiaError("name-conflict", `worker "${spec.name}" collides with a compose service name`);
@@ -14041,13 +14447,13 @@ class ComposeEngine {
       const composeFile = record?.composeFile ?? tryLoadConfig(worktreeRoot)?.composeFile;
       if (composeFile !== undefined) {
         const project2 = record?.project ?? projectName(repoId, repo, branch, worktreeRoot);
-        const overrideFile = record?.overrideFile ?? join25(hestiaDir(worktreeRoot), OVERRIDE_FILE);
+        const overrideFile = record?.overrideFile ?? join26(hestiaDir(worktreeRoot), OVERRIDE_FILE);
         if (existsSync22(overrideFile)) {
           await composeDown({ project: project2, baseFile: composeFile, overrideFile, cwd: worktreeRoot }, opts?.destroy ?? false);
         } else if (record?.composeFile !== undefined) {
           const rest = ["compose", "-p", project2, "down", "--remove-orphans"];
           if (opts?.destroy)
-            rest.push("-v");
+            rest.push("-v", "--rmi", "local");
           await pexec9("docker", rest, { timeout: 180000 });
         }
       }
@@ -14104,7 +14510,7 @@ class ComposeEngine {
       try {
         const rest = ["compose", "-p", project, "down", "--remove-orphans"];
         if (opts?.destroy)
-          rest.push("-v");
+          rest.push("-v", "--rmi", "local");
         await pexec9("docker", rest, { timeout: 180000 });
       } catch (err) {
         if (fresh?.composeFile !== undefined) {
@@ -14115,7 +14521,7 @@ class ComposeEngine {
     };
     if (record !== null && existsSync22(record.worktree)) {
       const info = await getRepoInfo(record.worktree);
-      const identityMatches = resolve2(info.worktreeRoot) === resolve2(record.worktree) && (record.repoId === undefined ? record.repo === info.repo : record.repoId === info.repoId);
+      const identityMatches = resolve3(info.worktreeRoot) === resolve3(record.worktree) && (record.repoId === undefined ? record.repo === info.repo : record.repoId === info.repoId);
       const localRecord = readState(record.worktree);
       if (identityMatches && localRecord?.project === record.project) {
         await this.down(record.worktree, opts);
@@ -14274,7 +14680,7 @@ class ComposeEngine {
         const alias = selection.endpoint.alias ?? selection.endpoint.name;
         const authority = internalEndpointAuthority(record.project, alias);
         const name = `aux-quick-${createHash7("sha256").update(alias).digest("hex").slice(0, 10)}`;
-        const quickCfg = join25(hestiaDir(worktreeRoot), `quick-${name}.yml`);
+        const quickCfg = join26(hestiaDir(worktreeRoot), `quick-${name}.yml`);
         writeAtomicTextFile(quickCfg, `ingress:
   - service: ${JSON.stringify(`unix:${publicGatewaySocketPath()}`)}
 ` + `    originRequest:
@@ -14660,7 +15066,8 @@ var init_src2 = __esm(() => {
   init_shutdown();
   init_ports();
   init_local_http_router();
-  init_resolver();
+  init_origin_liveness();
+  init_configured_workload_environment();
   init_adapter();
   init_verify();
   init_cloudflared();
@@ -14718,11 +15125,15 @@ class ReconnectLogDeduper {
   #capacity;
   #history = [];
   #reconnectBuffer = null;
+  #reconnectCandidates = null;
+  #completedOverlap = 0;
   constructor(capacity = 50) {
     this.#capacity = capacity;
   }
   beginReconnect() {
     this.#reconnectBuffer = [];
+    this.#reconnectCandidates = null;
+    this.#completedOverlap = 0;
   }
   push(line) {
     const entry = { signature: logLineSignature(line), line };
@@ -14732,30 +15143,26 @@ class ReconnectLogDeduper {
     }
     this.#reconnectBuffer.push(entry);
     const buffered = this.#reconnectBuffer;
-    const activeOverlapLengths = [];
-    const completedOverlapLengths = [];
-    for (let start = 0;start < this.#history.length; start += 1) {
-      const overlapLength = this.#history.length - start;
-      const compared = Math.min(buffered.length, overlapLength);
-      let matches = true;
-      for (let index = 0;index < compared; index += 1) {
-        if (buffered[index].signature !== this.#history[start + index].signature) {
-          matches = false;
-          break;
-        }
+    const index = buffered.length - 1;
+    const candidates = this.#reconnectCandidates ?? this.#history.map((_candidate, start) => start).filter((start) => this.#history[start].signature === entry.signature);
+    const active = candidates.filter((start) => {
+      const historyIndex = start + index;
+      if (historyIndex >= this.#history.length)
+        return false;
+      if (this.#history[historyIndex].signature !== entry.signature)
+        return false;
+      if (historyIndex === this.#history.length - 1) {
+        this.#completedOverlap = Math.max(this.#completedOverlap, this.#history.length - start);
       }
-      if (!matches)
-        continue;
-      if (buffered.length <= overlapLength)
-        activeOverlapLengths.push(overlapLength);
-      if (buffered.length >= overlapLength)
-        completedOverlapLengths.push(overlapLength);
-    }
-    if (activeOverlapLengths.length > 0)
+      return true;
+    });
+    this.#reconnectCandidates = active;
+    if (active.length > 0)
       return [];
-    const suppressed = Math.max(0, ...completedOverlapLengths);
-    const fresh = buffered.slice(suppressed);
+    const fresh = buffered.slice(this.#completedOverlap);
     this.#reconnectBuffer = null;
+    this.#reconnectCandidates = null;
+    this.#completedOverlap = 0;
     this.#remember(fresh);
     return fresh.map((candidate) => candidate.line);
   }
@@ -14788,12 +15195,12 @@ async function reconnectDelay(attempt, signal) {
   const delay = Math.min(4000, 250 * 2 ** Math.min(attempt, 4));
   if (signal.aborted)
     return;
-  await new Promise((resolve3) => {
+  await new Promise((resolve5) => {
     const timer = setTimeout(done, delay);
     function done() {
       clearTimeout(timer);
       signal.removeEventListener("abort", done);
-      resolve3();
+      resolve5();
     }
     signal.addEventListener("abort", done, { once: true });
   });
@@ -14833,7 +15240,7 @@ class DaemonFleetSource {
   async* logs(project, service, signal) {
     let attempt = 0;
     let connectedBefore = false;
-    const deduper = new ReconnectLogDeduper(50);
+    const deduper = new ReconnectLogDeduper(FLEET_LOG_BACKFILL_LINES);
     while (!signal.aborted && !this.#lifetime.signal.aborted) {
       const connectedAt = Date.now();
       try {
@@ -14842,7 +15249,7 @@ class DaemonFleetSource {
           deduper.beginReconnect();
         }
         connectedBefore = true;
-        for await (const line of streamDaemonServiceLogs(daemon.port, project, service, 50, signal)) {
+        for await (const line of streamDaemonServiceLogs(daemon.port, project, service, FLEET_LOG_BACKFILL_LINES, signal)) {
           if (!isLogLine(line))
             throw new Error("log protocol frame is invalid");
           for (const freshLine of deduper.push(line))
@@ -14879,7 +15286,7 @@ class DaemonFleetSource {
       return Promise.reject(new Error(`stack ${stack.project} has no stable incarnation timestamp`));
     }
     return engine.downProject(stack.project, {
-      destroy: false,
+      destroy: true,
       expectedStack: {
         repoId: stack.repoId,
         worktree: stack.worktree,
@@ -14891,6 +15298,7 @@ class DaemonFleetSource {
     this.#lifetime.abort();
   }
 }
+var FLEET_LOG_BACKFILL_LINES = 1000;
 var init_fleet_source = __esm(() => {
   init_src2();
 });
@@ -14911,6 +15319,8 @@ function createFleetUiState() {
     layout: "auto",
     filter: "",
     follow: true,
+    serviceOffset: 0,
+    serviceOffsetManual: false,
     logOffset: 0,
     unseenLines: 0,
     helpOpen: false,
@@ -14955,9 +15365,13 @@ function reduceFleetUiState(state, action) {
   switch (action.type) {
     case "reconcile":
       const visibleSnapshot = state.filter === "" ? action.snapshot : { ...action.snapshot, stacks: visibleFleetStacks(action.snapshot, state.filter) };
+      const selection = reconcileFleetSelection(state.selection, visibleSnapshot, action.preferredProject);
+      const selectionChanged = selection.project !== state.selection.project || selection.service !== state.selection.service || selection.endpoint !== state.selection.endpoint;
       return {
         ...state,
-        selection: reconcileFleetSelection(state.selection, visibleSnapshot, action.preferredProject)
+        selection,
+        serviceOffset: selection.project === state.selection.project ? state.serviceOffset : 0,
+        serviceOffsetManual: selectionChanged ? false : state.serviceOffsetManual
       };
     case "move-stack": {
       const stacks = visibleFleetStacks(action.snapshot, state.filter);
@@ -14970,6 +15384,8 @@ function reduceFleetUiState(state, action) {
           service: stack.services[0]?.name,
           endpoint: undefined
         },
+        serviceOffset: 0,
+        serviceOffsetManual: false,
         follow: true,
         logOffset: 0,
         unseenLines: 0
@@ -14988,6 +15404,7 @@ function reduceFleetUiState(state, action) {
           service: service.name,
           endpoint: undefined
         },
+        serviceOffsetManual: false,
         follow: true,
         logOffset: 0,
         unseenLines: 0
@@ -15003,6 +15420,8 @@ function reduceFleetUiState(state, action) {
           service: stack.services[0]?.name,
           endpoint: undefined
         },
+        serviceOffset: 0,
+        serviceOffsetManual: false,
         follow: true,
         logOffset: 0,
         unseenLines: 0
@@ -15020,6 +15439,7 @@ function reduceFleetUiState(state, action) {
           service: action.service,
           endpoint: undefined
         },
+        serviceOffsetManual: false,
         follow: true,
         logOffset: 0,
         unseenLines: 0
@@ -15033,7 +15453,8 @@ function reduceFleetUiState(state, action) {
       return {
         ...state,
         focus: "services",
-        selection: { ...state.selection, service: action.service, endpoint: action.endpoint }
+        selection: { ...state.selection, service: action.service, endpoint: action.endpoint },
+        serviceOffsetManual: false
       };
     }
     case "focus":
@@ -15047,10 +15468,14 @@ function reduceFleetUiState(state, action) {
         ...action.snapshot,
         stacks: visibleFleetStacks(action.snapshot, action.filter)
       };
+      const selection2 = reconcileFleetSelection(state.selection, visibleSnapshot2);
+      const selectionChanged2 = selection2.project !== state.selection.project || selection2.service !== state.selection.service || selection2.endpoint !== state.selection.endpoint;
       return {
         ...state,
         filter: action.filter,
-        selection: reconcileFleetSelection(state.selection, visibleSnapshot2)
+        selection: selection2,
+        serviceOffset: selection2.project === state.selection.project ? state.serviceOffset : 0,
+        serviceOffsetManual: selectionChanged2 ? false : state.serviceOffsetManual
       };
     }
     case "follow":
@@ -15060,6 +15485,12 @@ function reduceFleetUiState(state, action) {
         logOffset: action.follow ? 0 : state.logOffset,
         unseenLines: action.follow ? 0 : state.unseenLines
       };
+    case "scroll-services":
+      return {
+        ...state,
+        serviceOffset: Math.min(action.maxOffset, Math.max(0, state.serviceOffset + action.delta)),
+        serviceOffsetManual: true
+      };
     case "scroll-logs": {
       const offset = Math.min(action.maxOffset ?? Number.MAX_SAFE_INTEGER, Math.max(0, state.logOffset - action.delta));
       return action.delta > 0 && offset === 0 ? { ...state, follow: true, logOffset: 0, unseenLines: 0 } : { ...state, follow: action.delta > 0 ? state.follow : false, logOffset: offset };
@@ -15280,6 +15711,9 @@ var init_string_width = __esm(() => {
 });
 
 // packages/tui/src/fleet-text.ts
+function fleetTextWidth(text) {
+  return stringWidth(text);
+}
 function fitFleetText(text, width) {
   if (width <= 0)
     return "";
@@ -15456,6 +15890,18 @@ function isScrollTopKey(key) {
 function isDoctorKey(key) {
   return isShiftedKey(key, "d");
 }
+function isPageUpKey(key) {
+  return key.name.toLowerCase() === "pageup";
+}
+function isPageDownKey(key) {
+  return key.name.toLowerCase() === "pagedown";
+}
+function isHalfPageUpKey(key) {
+  return key.ctrl === true && key.name.toLowerCase() === "u";
+}
+function isHalfPageDownKey(key) {
+  return key.ctrl === true && key.name.toLowerCase() === "d";
+}
 
 // packages/tui/src/fleet-layout.ts
 function resolveFleetLayout(mode, terminalWidth) {
@@ -15520,6 +15966,43 @@ var init_fleet_log_rows = __esm(() => {
   wrapCache = new WeakMap;
 });
 
+// packages/tui/src/fleet-service-rows.ts
+function buildFleetServiceRows(stack) {
+  if (stack === undefined)
+    return [];
+  return stack.services.flatMap((service) => {
+    const endpoints = serviceEndpoints(service);
+    return [
+      { kind: "workload", service },
+      ...endpoints.map((endpoint, endpointIndex) => ({
+        kind: "endpoint",
+        service,
+        endpoint,
+        endpointIndex
+      }))
+    ];
+  });
+}
+function fleetServiceRowCount(stack) {
+  return buildFleetServiceRows(stack).length;
+}
+function selectedFleetServiceRowIndex(rows, serviceName, endpointName) {
+  return rows.findIndex((row2) => row2.service.name === serviceName && (endpointName === undefined ? row2.kind === "workload" : row2.kind === "endpoint" && row2.endpoint.name === endpointName));
+}
+function ensureFleetServiceRowVisible(offset, selectedIndex, viewportRows, rowCount) {
+  const maxOffset = Math.max(0, rowCount - viewportRows);
+  const clamped = Math.min(maxOffset, Math.max(0, offset));
+  if (selectedIndex < 0)
+    return clamped;
+  if (selectedIndex < clamped)
+    return selectedIndex;
+  if (selectedIndex >= clamped + viewportRows) {
+    return Math.min(maxOffset, selectedIndex - viewportRows + 1);
+  }
+  return clamped;
+}
+var init_fleet_service_rows = () => {};
+
 // packages/tui/src/fleet-format.ts
 function formatUptime(createdAt, now) {
   const born = Date.parse(createdAt);
@@ -15701,6 +16184,15 @@ var init_StackSidebar = __esm(() => {
   });
 });
 
+// packages/tui/src/fleet-scroll.ts
+function fleetMouseScrollDelta(event, rows = 3) {
+  if (event.scroll?.direction === "up")
+    return -rows;
+  if (event.scroll?.direction === "down")
+    return rows;
+  return;
+}
+
 // packages/tui/src/components/ServicePane.tsx
 import { memo as memo2 } from "react";
 import { jsxDEV as jsxDEV2, Fragment } from "@opentui/react/jsx-dev-runtime";
@@ -15711,6 +16203,7 @@ function portLabel(service) {
 }
 var ServicePane;
 var init_ServicePane = __esm(() => {
+  init_fleet_service_rows();
   init_fleet_text();
   init_fleet_theme();
   init_terminal_text();
@@ -15719,10 +16212,13 @@ var init_ServicePane = __esm(() => {
     uptime,
     selectedService,
     selectedEndpoint,
+    offset = 0,
+    viewportRows = 1,
     width = 80,
     focused = false,
     onSelectService,
-    onSelectEndpoint
+    onSelectEndpoint,
+    onScroll
   }) {
     const nameWidth = Math.min(24, Math.max(12, Math.floor(width * 0.28)));
     const backendWidth = 10;
@@ -15730,7 +16226,26 @@ var init_ServicePane = __esm(() => {
     const portWidth = 7;
     const title = stack === undefined ? "Workloads" : `Workloads \u2014 ${sanitizeFleetTerminalText(stack.branch)}`;
     const warning = stack?.warning === undefined ? undefined : sanitizeFleetTerminalText(stack.warning);
+    const rows = buildFleetServiceRows(stack);
+    const maxOffset = Math.max(0, rows.length - viewportRows);
+    const clampedOffset = Math.min(maxOffset, Math.max(0, offset));
+    const visibleRows = rows.slice(clampedOffset, clampedOffset + viewportRows);
+    const hiddenAbove = clampedOffset;
+    const hiddenBelow = Math.max(0, rows.length - clampedOffset - visibleRows.length);
+    const overflowIndicator = (index) => {
+      const first = index === 0 && hiddenAbove > 0 ? `\u2191 ${hiddenAbove} more` : undefined;
+      const last = index === visibleRows.length - 1 && hiddenBelow > 0 ? `\u2193 ${hiddenBelow} more` : undefined;
+      return [first, last].filter(Boolean).join(" \xB7 ") || undefined;
+    };
     return /* @__PURE__ */ jsxDEV2("box", {
+      onMouseScroll: (event) => {
+        const delta = fleetMouseScrollDelta(event);
+        if (delta === undefined)
+          return;
+        event.preventDefault();
+        event.stopPropagation();
+        onScroll?.(delta);
+      },
       style: {
         height: "100%",
         width: "100%",
@@ -15790,97 +16305,106 @@ var init_ServicePane = __esm(() => {
                 }, undefined, false, undefined, this)
               ]
             }, undefined, true, undefined, this),
-            stack.services.flatMap((service) => {
+            visibleRows.map((row2, visibleIndex) => {
+              const service = row2.service;
               const workloadSelected = service.name === selectedService && selectedEndpoint === undefined;
-              const endpoints = serviceEndpoints(service);
               const state = sanitizeFleetTerminalText(service.state);
               const workloadBg = workloadSelected ? fleetTheme.selectedBg : fleetTheme.background;
-              const workloadRow = /* @__PURE__ */ jsxDEV2("box", {
-                onMouseDown: (event) => {
-                  if (event.button !== 0)
-                    return;
-                  event.preventDefault();
-                  event.stopPropagation();
-                  onSelectService?.(service.name);
-                },
-                style: { height: 1, paddingRight: 1, flexDirection: "row", backgroundColor: workloadBg },
-                children: [
-                  /* @__PURE__ */ jsxDEV2("text", {
-                    fg: fleetTheme.stripe,
-                    children: workloadSelected ? "\u258E" : " "
-                  }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsxDEV2("text", {
-                    fg: serviceStateColor(service.state),
-                    children: [
-                      " ",
-                      serviceStateGlyph(service.state),
-                      " "
-                    ]
-                  }, undefined, true, undefined, this),
-                  /* @__PURE__ */ jsxDEV2("text", {
-                    fg: workloadSelected ? fleetTheme.bright : fleetTheme.text,
-                    children: padFleetText(sanitizeFleetTerminalText(service.name), nameWidth)
-                  }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsxDEV2("text", {
-                    fg: backendColor(service.backend),
-                    children: padFleetText(service.backend, backendWidth)
-                  }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsxDEV2("text", {
-                    fg: serviceStateColor(service.state),
-                    children: padFleetText(state, stateWidth)
-                  }, undefined, false, undefined, this),
-                  /* @__PURE__ */ jsxDEV2("text", {
-                    fg: fleetTheme.muted,
-                    children: padFleetText(portLabel(service), portWidth)
-                  }, undefined, false, undefined, this)
-                ]
-              }, `workload:${service.name}`, true, undefined, this);
-              const endpointRows = endpoints.map((endpoint, index) => {
-                const endpointSelected = service.name === selectedService && endpoint.name === selectedEndpoint;
-                const connector = index === endpoints.length - 1 ? "\u2514\u2500" : "\u251C\u2500";
-                const kind = (endpoint.kind ?? "http").toUpperCase();
-                const reach = sanitizeFleetTerminalText(endpointReach(endpoint));
-                const aliasWidth = Math.min(18, Math.max(10, Math.floor(width * 0.22)));
-                const pub = endpoint.publicUrl === undefined ? "" : " pub";
-                const endpointBg = endpointSelected ? fleetTheme.selectedBg : fleetTheme.background;
+              const indicator = overflowIndicator(visibleIndex);
+              if (row2.kind === "workload")
                 return /* @__PURE__ */ jsxDEV2("box", {
                   onMouseDown: (event) => {
                     if (event.button !== 0)
                       return;
                     event.preventDefault();
                     event.stopPropagation();
-                    onSelectEndpoint?.(service.name, endpoint.name);
+                    onSelectService?.(service.name);
                   },
-                  style: { height: 1, paddingRight: 1, flexDirection: "row", backgroundColor: endpointBg },
+                  style: { height: 1, paddingRight: 1, flexDirection: "row", backgroundColor: workloadBg },
                   children: [
                     /* @__PURE__ */ jsxDEV2("text", {
                       fg: fleetTheme.stripe,
-                      children: endpointSelected ? "\u258E" : " "
+                      children: workloadSelected ? "\u258E" : " "
                     }, undefined, false, undefined, this),
                     /* @__PURE__ */ jsxDEV2("text", {
-                      fg: fleetTheme.faint,
-                      children: `  ${connector} `
-                    }, undefined, false, undefined, this),
+                      fg: serviceStateColor(service.state),
+                      children: [
+                        " ",
+                        serviceStateGlyph(service.state),
+                        " "
+                      ]
+                    }, undefined, true, undefined, this),
                     /* @__PURE__ */ jsxDEV2("text", {
-                      fg: endpointSelected ? fleetTheme.bright : fleetTheme.accent,
-                      children: padFleetText(sanitizeFleetTerminalText(endpoint.name), aliasWidth)
+                      fg: workloadSelected ? fleetTheme.bright : fleetTheme.text,
+                      children: padFleetText(sanitizeFleetTerminalText(service.name), nameWidth)
                     }, undefined, false, undefined, this),
                     /* @__PURE__ */ jsxDEV2("text", {
-                      fg: fleetTheme.muted,
-                      children: padFleetText(kind, 6)
+                      fg: backendColor(service.backend),
+                      children: padFleetText(service.backend, backendWidth)
                     }, undefined, false, undefined, this),
                     /* @__PURE__ */ jsxDEV2("text", {
-                      fg: fleetTheme.text,
-                      children: fitFleetText(reach, Math.max(12, width - aliasWidth - 19 - pub.length))
+                      fg: serviceStateColor(service.state),
+                      children: padFleetText(state, stateWidth)
                     }, undefined, false, undefined, this),
                     /* @__PURE__ */ jsxDEV2("text", {
-                      fg: fleetTheme.publicBadge,
-                      children: pub
+                      fg: fleetTheme.muted,
+                      children: padFleetText(portLabel(service), portWidth)
+                    }, undefined, false, undefined, this),
+                    indicator === undefined ? null : /* @__PURE__ */ jsxDEV2("text", {
+                      fg: fleetTheme.faint,
+                      children: indicator
                     }, undefined, false, undefined, this)
                   ]
-                }, `endpoint:${service.name}:${endpoint.name}`, true, undefined, this);
-              });
-              return [workloadRow, ...endpointRows];
+                }, `workload:${service.name}`, true, undefined, this);
+              const endpoint = row2.endpoint;
+              const endpointSelected = service.name === selectedService && endpoint.name === selectedEndpoint;
+              const endpointCount = service.endpoints?.length ?? (service.endpoint === undefined ? 0 : 1);
+              const connector = row2.endpointIndex === endpointCount - 1 ? "\u2514\u2500" : "\u251C\u2500";
+              const kind = (endpoint.kind ?? "http").toUpperCase();
+              const reach = sanitizeFleetTerminalText(endpointReach(endpoint));
+              const aliasWidth = Math.min(18, Math.max(10, Math.floor(width * 0.22)));
+              const pub = endpoint.publicUrl === undefined ? "" : " pub";
+              const endpointBg = endpointSelected ? fleetTheme.selectedBg : fleetTheme.background;
+              return /* @__PURE__ */ jsxDEV2("box", {
+                onMouseDown: (event) => {
+                  if (event.button !== 0)
+                    return;
+                  event.preventDefault();
+                  event.stopPropagation();
+                  onSelectEndpoint?.(service.name, endpoint.name);
+                },
+                style: { height: 1, paddingRight: 1, flexDirection: "row", backgroundColor: endpointBg },
+                children: [
+                  /* @__PURE__ */ jsxDEV2("text", {
+                    fg: fleetTheme.stripe,
+                    children: endpointSelected ? "\u258E" : " "
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV2("text", {
+                    fg: fleetTheme.faint,
+                    children: `  ${connector} `
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV2("text", {
+                    fg: endpointSelected ? fleetTheme.bright : fleetTheme.accent,
+                    children: padFleetText(sanitizeFleetTerminalText(endpoint.name), aliasWidth)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV2("text", {
+                    fg: fleetTheme.muted,
+                    children: padFleetText(kind, 6)
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV2("text", {
+                    fg: fleetTheme.text,
+                    children: fitFleetText(reach, Math.max(12, width - aliasWidth - 19 - pub.length))
+                  }, undefined, false, undefined, this),
+                  /* @__PURE__ */ jsxDEV2("text", {
+                    fg: fleetTheme.publicBadge,
+                    children: pub
+                  }, undefined, false, undefined, this),
+                  indicator === undefined ? null : /* @__PURE__ */ jsxDEV2("text", {
+                    fg: fleetTheme.faint,
+                    children: indicator
+                  }, undefined, false, undefined, this)
+                ]
+              }, `endpoint:${service.name}:${endpoint.name}`, true, undefined, this);
             })
           ]
         }, undefined, true, undefined, this) : /* @__PURE__ */ jsxDEV2("box", {
@@ -15914,14 +16438,20 @@ function LogPane({
   const end = Math.max(0, rows.length - clamped);
   const start = Math.max(0, end - viewportRows);
   const visible = rows.slice(start, end);
-  const title = fitFleetText(`Logs \u2014 ${label}`, Math.max(8, width - 28));
+  const position = visible.length === 0 ? "0/0" : `${start + 1}\u2013${end}/${rows.length}`;
+  const rawStatus = follow ? "following" : `paused \xB7 ${position}${unseen > 0 ? ` \xB7 ${unseen} new` : ""}`;
+  const headerWidth = Math.max(1, width - 4);
+  const status = fitFleetText(rawStatus, Math.max(1, headerWidth - Math.min(8, headerWidth - 1)));
+  const titleWidth = Math.max(0, headerWidth - fleetTextWidth(status));
+  const title = fitFleetText(`Logs \u2014 ${label}`, titleWidth);
   return /* @__PURE__ */ jsxDEV3("box", {
     onMouseScroll: (event) => {
-      if (event.button !== 4 && event.button !== 5)
+      const delta = fleetMouseScrollDelta(event);
+      if (delta === undefined)
         return;
       event.preventDefault();
       event.stopPropagation();
-      onScroll?.(event.button === 4 ? -3 : 3);
+      onScroll?.(delta);
     },
     style: {
       height: "100%",
@@ -15937,11 +16467,11 @@ function LogPane({
         children: [
           /* @__PURE__ */ jsxDEV3("text", {
             fg: focused ? fleetTheme.accent : fleetTheme.text,
-            children: padFleetText(title, Math.max(1, width - 24))
+            children: padFleetText(title, titleWidth)
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsxDEV3("text", {
             fg: follow ? fleetTheme.healthy : fleetTheme.warning,
-            children: follow ? "following" : `paused${unseen > 0 ? ` \xB7 ${unseen} new` : ""}`
+            children: status
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
@@ -16058,9 +16588,6 @@ function emptySnapshot(repoId) {
 function selectedStack(snapshot, project) {
   return snapshot.stacks.find((stack) => stack.project === project);
 }
-function fleetServiceRowCount(stack) {
-  return stack?.services.reduce((count, service) => count + 1 + serviceEndpoints(service).length, 0) ?? 0;
-}
 function selectedFleetEndpoint(stack, serviceName, endpointName) {
   const service = stack?.services.find((candidate) => candidate.name === serviceName);
   const endpoints = service === undefined ? [] : serviceEndpoints(service);
@@ -16222,6 +16749,11 @@ function FleetApp({
   const svcRows = fleetServiceRowCount(stack) + warningRows;
   const stackedSidebarHeight = stackSidebarHeight(stacks.length);
   const svcPaneH = servicePaneHeight(svcRows, effectiveLayout === "split" ? 14 : 12);
+  const serviceViewportRows = Math.max(1, svcPaneH - 4 - warningRows);
+  const serviceRows = useMemo(() => buildFleetServiceRows(stack), [stack]);
+  const maxServiceOffset = Math.max(0, serviceRows.length - serviceViewportRows);
+  const selectedServiceRowIndex = selectedFleetServiceRowIndex(serviceRows, state.selection.service, state.selection.endpoint);
+  const effectiveServiceOffset = ensureFleetServiceRowVisible(state.serviceOffset, state.serviceOffsetManual ? -1 : selectedServiceRowIndex, serviceViewportRows, serviceRows.length);
   const logHeight = Math.max(5, terminal.height - headerRows - contextRows - footerRows - svcPaneH - (effectiveLayout === "stack" ? stackedSidebarHeight : 0));
   const logWidth = effectiveLayout === "split" ? paneWidths.main : terminal.width;
   const logViewportRows = Math.max(1, logHeight - 3);
@@ -16277,7 +16809,7 @@ function FleetApp({
         source.down(confirmed).then(() => {
           dispatch({ type: "down-pending", pending: false });
           dispatch({ type: "confirm-down" });
-          showToast(`${project} is down; named volumes retained`);
+          showToast(`${project} is down; volumes and project images removed`);
         }).catch((error) => {
           dispatch({ type: "down-pending", pending: false });
           showToast(`down failed: ${error.message}`);
@@ -16395,6 +16927,21 @@ function FleetApp({
     if (isScrollTopKey(key)) {
       return dispatch({ type: "scroll-logs", delta: -logRows.length, maxOffset: maxLogOffset });
     }
+    if (current.focus === "logs") {
+      if (isPageUpKey(key)) {
+        return dispatch({ type: "scroll-logs", delta: -logViewportRows, maxOffset: maxLogOffset });
+      }
+      if (isPageDownKey(key)) {
+        return dispatch({ type: "scroll-logs", delta: logViewportRows, maxOffset: maxLogOffset });
+      }
+      const halfPageRows = Math.max(1, Math.floor(logViewportRows / 2));
+      if (isHalfPageUpKey(key)) {
+        return dispatch({ type: "scroll-logs", delta: -halfPageRows, maxOffset: maxLogOffset });
+      }
+      if (isHalfPageDownKey(key)) {
+        return dispatch({ type: "scroll-logs", delta: halfPageRows, maxOffset: maxLogOffset });
+      }
+    }
     if (isDoctorKey(key)) {
       if (doctorRunning)
         return;
@@ -16471,10 +17018,17 @@ function FleetApp({
     uptime,
     selectedService: state.selection.service,
     selectedEndpoint: state.selection.endpoint,
+    offset: effectiveServiceOffset,
+    viewportRows: serviceViewportRows,
     width: logWidth,
     focused: state.focus === "services",
     onSelectService,
-    onSelectEndpoint
+    onSelectEndpoint,
+    onScroll: (delta) => dispatch({
+      type: "scroll-services",
+      delta: delta + effectiveServiceOffset - state.serviceOffset,
+      maxOffset: maxServiceOffset
+    })
   }, undefined, false, undefined, this);
   const sidebar = (width) => /* @__PURE__ */ jsxDEV5(StackSidebar, {
     stacks,
@@ -16814,7 +17368,7 @@ function FleetApp({
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsxDEV5("text", {
             fg: fleetTheme.warning,
-            children: "Named volumes are retained."
+            children: "Removes named volumes and project-built images (data loss)."
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsxDEV5("text", {
             fg: fleetTheme.danger,
@@ -16832,6 +17386,7 @@ var init_FleetApp = __esm(() => {
   init_fleet_text();
   init_fleet_theme();
   init_fleet_log_rows();
+  init_fleet_service_rows();
   init_fleet_format();
   init_fleet_status();
   init_StackSidebar();
@@ -16843,12 +17398,13 @@ var init_FleetApp = __esm(() => {
     ["j k \u2191\u2193", "move in focused pane \xB7 Tab cycles panes"],
     [", . [ ]", "previous / next stack \xB7 service"],
     ["/", "filter stacks (Esc clears, then exits)"],
-    ["f \xB7 g G", "pause/resume follow \xB7 top / bottom of logs"],
+    ["f \xB7 g G \xB7 PgUp PgDn", "follow \xB7 top / bottom \xB7 page logs"],
+    ["^U ^D", "scroll logs by half a page"],
     ["o", "open selected endpoint in browser"],
     ["y \xB7 Y", "yank endpoint URL \xB7 stack env block"],
     ["c l p", "yank direct / local / public URL"],
     ["s", "shared hostnames (claim, allow, deny, release)"],
-    ["D \xB7 d", "doctor report \xB7 down stack (volumes retained)"],
+    ["D \xB7 d", "doctor report \xB7 down stack (removes volumes + images)"],
     ["1 2 0", "split / stacked / auto layout"],
     ["q", "quit \xB7 mouse click and wheel work everywhere"]
   ];
@@ -16925,7 +17481,7 @@ async function runFleetTui(cwd = process.cwd()) {
     openConsoleOnError: false
   });
   const root = createRoot(renderer);
-  await new Promise((resolve3, reject) => {
+  await new Promise((resolve5, reject) => {
     let shuttingDown = false;
     let removeInterrupt = () => {};
     let removeSuspend = () => {};
@@ -16947,7 +17503,7 @@ async function runFleetTui(cwd = process.cwd()) {
       if (error !== undefined)
         reject(error);
       else
-        resolve3();
+        resolve5();
     };
     for (const signal of signals)
       process.once(signal, shutdown);
@@ -17011,9 +17567,9 @@ init_src2();
 init_src();
 import { execFileSync as execFileSync5 } from "child_process";
 import { existsSync as existsSync24 } from "fs";
-import { dirname as dirname8, join as join26 } from "path";
+import { dirname as dirname9, join as join27 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var CLI_VERSION = "1.2.0";
+var CLI_VERSION = "1.3.0";
 var PACKAGE_NAME = "@tridha643/hestia";
 function compareVersions(a, b) {
   const parse = (value) => {
@@ -17420,7 +17976,8 @@ usage:
         health. Exit 1 only on error-level rows; never mutates anything
   hestia stop <name> [--json]             stop one supervised proc (idempotent)
   hestia down [--destroy] [--project <name>] [--json]
-        tear down procs + containers (--destroy also removes volumes);
+        tear down procs + containers (--destroy also removes volumes
+        and project-built images);
         --project works from the mirror after the worktree is deleted
   hestia status [--json]                  show this worktree's stack
   hestia env  [--json]                    print the injected env (export lines)
@@ -17505,10 +18062,10 @@ async function main() {
       case "skill": {
         if (flags._[1] !== "path")
           fail("usage", "usage: hestia skill path", flags.json);
-        const packageRoot = dirname8(dirname8(fileURLToPath3(import.meta.url)));
+        const packageRoot = dirname9(dirname9(fileURLToPath3(import.meta.url)));
         const candidates = [
-          join26(packageRoot, "skills", "hestia", "SKILL.md"),
-          join26(process.cwd(), "skills", "hestia", "SKILL.md")
+          join27(packageRoot, "skills", "hestia", "SKILL.md"),
+          join27(process.cwd(), "skills", "hestia", "SKILL.md")
         ];
         const path = candidates.find(existsSync24);
         if (path === undefined)
@@ -18181,4 +18738,4 @@ export {
   compareVersions
 };
 
-//# debugId=E655EED0C9FC8A1364756E2164756E21
+//# debugId=EE213D14626327FC64756E2164756E21