@happier-dev/stack 0.1.0 → 0.2.0-preview.1775370152.55749

package/scripts/stack/run_script_with_stack_env.mjs

@@ -7,13 +7,14 @@ import { findExistingStackCredentialPath } from '../utils/auth/credentials_paths
 import { ensureDir } from '../utils/fs/ops.mjs';
 import { readLastLines } from '../utils/fs/tail.mjs';
 import { isTcpPortFree, listListenPids, pickNextFreeTcpPort } from '../utils/net/ports.mjs';
-import { resolveStackEnvPath } from '../utils/paths/paths.mjs';
+import { getComponentDir, resolveStackEnvPath } from '../utils/paths/paths.mjs';
 import { resolveLocalhostHost } from '../utils/paths/localhost_host.mjs';
 import { killProcessGroupOwnedByStack } from '../utils/proc/ownership.mjs';
 import { run } from '../utils/proc/proc.mjs';
 import { coercePort } from '../utils/server/port.mjs';
 import { waitForHttpOk } from '../utils/server/server.mjs';
 import { getCliHomeDirFromEnvOrDefault } from '../utils/stack/dirs.mjs';
+import { findRunningExpoStateInRoot, looksLikeExpoMetro } from '../utils/expo/expo.mjs';
 import {
   deleteStackRuntimeStateFile,
   getStackRuntimeStatePath,
@@ -27,6 +28,7 @@ import { openUrlInBrowser } from '../utils/ui/browser.mjs';
 
 import { collectReservedStackPorts, getDefaultPortStart } from './port_reservation.mjs';
 import { withStackEnv } from './stack_environment.mjs';
+import { resolveStackRuntimeLaunchContext } from '../runtime/launch/resolveStackRuntimeLaunchContext.mjs';
 
 export function hasRecordedRuntimePortsForRestart(runtimeState = null) {
   const ports = runtimeState?.ports && typeof runtimeState.ports === 'object' ? runtimeState.ports : null;
@@ -37,11 +39,94 @@ export function shouldReuseRuntimePortsOnRestart({ wantsRestart = false, runtime
   return Boolean(wantsRestart && (wasRunning || hasRecordedRuntimePortsForRestart(runtimeState)));
 }
 
+export async function inspectExistingStartLikeRuntime({
+  stackName = '',
+  envPath = '',
+  baseDir = '',
+  expectedUiDir = '',
+  scriptPath,
+  args = [],
+  runtimeState = null,
+} = {}) {
+  const existingOwnerPid = Number(runtimeState?.ownerPid);
+  const existingServerPid = Number(runtimeState?.processes?.serverPid);
+  const existingExpoPid = Number(runtimeState?.processes?.expoPid);
+  const existingForwarderPid = Number(runtimeState?.processes?.expoTailscaleForwarderPid);
+  const existingServerPort = Number(runtimeState?.ports?.server);
+  const existingExpoPort = Number(runtimeState?.expo?.port ?? runtimeState?.expo?.webPort ?? runtimeState?.expo?.mobilePort);
+
+  const wantsUi = scriptPath === 'dev.mjs' && !args.includes('--no-ui');
+  const wantsMobile = scriptPath === 'dev.mjs' && (args.includes('--mobile') || args.includes('--with-mobile'));
+
+  const ownerRunning = Number.isFinite(existingOwnerPid) && existingOwnerPid > 1 ? isPidAlive(existingOwnerPid) : false;
+  const serverPidRunning = Number.isFinite(existingServerPid) && existingServerPid > 1 ? isPidAlive(existingServerPid) : false;
+  const expoPidRunning = Number.isFinite(existingExpoPid) && existingExpoPid > 1 ? isPidAlive(existingExpoPid) : false;
+  const forwarderRunning =
+    Number.isFinite(existingForwarderPid) && existingForwarderPid > 1 ? isPidAlive(existingForwarderPid) : false;
+  const serverPortListening =
+    Number.isFinite(existingServerPort) && existingServerPort > 0
+      ? !(await isTcpPortFree(existingServerPort, { host: '127.0.0.1' }).catch(() => true))
+      : false;
+  const serverRunning = serverPortListening || serverPidRunning;
+
+  let uiRunning = false;
+  let uiPort = null;
+  if (wantsUi || wantsMobile) {
+    const base = String(baseDir ?? '').trim();
+    if (base) {
+      const res = await findRunningExpoStateInRoot({
+        expoDevRoot: join(base, 'expo-dev'),
+        requireWeb: wantsUi,
+        expectedProjectDir: expectedUiDir,
+      });
+      const p = Number(res?.state?.port);
+      if (res && Number.isFinite(p) && p > 0) {
+        uiRunning = true;
+        uiPort = p;
+      }
+    } else if (Number.isFinite(existingExpoPort) && existingExpoPort > 0) {
+      uiRunning = await looksLikeExpoMetro({ port: existingExpoPort, timeoutMs: 900 });
+      uiPort = uiRunning ? existingExpoPort : null;
+    }
+  }
+
+  const wasRunning = ownerRunning || serverRunning || uiRunning || serverPidRunning || expoPidRunning || forwarderRunning;
+  const canShortCircuit =
+    scriptPath === 'dev.mjs'
+      ? serverRunning && (!wantsUi || uiRunning) && (!wantsMobile || uiRunning)
+      : wasRunning;
+
+  return {
+    ownerRunning,
+    serverRunning,
+    uiRunning,
+    uiPort,
+    wasRunning,
+    canShortCircuit,
+    wantsUi,
+    wantsMobile,
+  };
+}
+
+export function shouldAdoptOccupiedRuntimePortsForRecovery(existingRuntimeStatus = null) {
+  return Boolean(
+    existingRuntimeStatus &&
+      existingRuntimeStatus.serverRunning &&
+      !existingRuntimeStatus.canShortCircuit &&
+      (existingRuntimeStatus.wantsUi || existingRuntimeStatus.wantsMobile)
+  );
+}
+
 export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPath, args, extraEnv = {}, background = false }) {
   await withStackEnv({
     stackName,
     extraEnv,
     fn: async ({ env, envPath, stackEnv, runtimeStatePath, runtimeState }) => {
+      const runtimeLaunchContext =
+        scriptPath === 'run.mjs'
+          ? await resolveStackRuntimeLaunchContext({ argv: args, env })
+          : { snapshot: null };
+      const runtimeSnapshotId = runtimeLaunchContext.snapshot?.snapshotId ?? null;
       const isStartLike = scriptPath === 'dev.mjs' || scriptPath === 'run.mjs';
       if (!isStartLike) {
         await run(process.execPath, [join(rootDir, 'scripts', scriptPath), ...args], { cwd: rootDir, env });
@@ -56,23 +141,24 @@ export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPat
         serverComponent === 'happier-server'
           ? (stackEnv.HAPPIER_STACK_MANAGED_INFRA ?? '1').toString().trim() !== '0'
           : false;
+      const { baseDir } = resolveStackEnvPath(stackName, env);
+      const expectedUiDir = getComponentDir(rootDir, 'happier-ui', env);
 
       // If this is an ephemeral-port stack and it's already running, avoid spawning a second copy.
       const existingOwnerPid = Number(runtimeState?.ownerPid);
       const existingPort = Number(runtimeState?.ports?.server);
       const existingUiPort = Number(runtimeState?.expo?.webPort);
       const existingPorts = runtimeState?.ports && typeof runtimeState.ports === 'object' ? runtimeState.ports : null;
-      const infraRuntimePids = [
-        Number(runtimeState?.processes?.serverPid),
-        Number(runtimeState?.processes?.expoPid),
-        Number(runtimeState?.processes?.expoTailscaleForwarderPid),
-      ].filter((pid) => Number.isFinite(pid) && pid > 1);
-      const infraPidAlive = infraRuntimePids.some((pid) => isPidAlive(pid));
-      const serverPortOccupied =
-        Number.isFinite(existingPort) && existingPort > 0
-          ? !(await isTcpPortFree(existingPort, { host: '127.0.0.1' }).catch(() => true))
-          : false;
-      const wasRunning = isPidAlive(existingOwnerPid) || infraPidAlive || serverPortOccupied;
+      const existingRuntimeStatus = await inspectExistingStartLikeRuntime({
+        stackName,
+        envPath,
+        baseDir,
+        expectedUiDir,
+        scriptPath,
+        args,
+        runtimeState,
+      });
+      const wasRunning = existingRuntimeStatus.wasRunning;
       // True restart = there was an active runner for this stack. If the stack is not running,
       // `--restart` should behave like a normal start (allocate new ephemeral ports if needed).
       const isTrueRestart = shouldReuseRuntimePortsOnRestart({ wantsRestart, runtimeState, wasRunning });
@@ -99,11 +185,15 @@ export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPat
         }
         await deleteStackRuntimeStateFile(runtimeStatePath).catch(() => {});
       }
-      if (wasRunning) {
+      if (existingRuntimeStatus.canShortCircuit) {
         if (!wantsRestart) {
           const serverPart = Number.isFinite(existingPort) && existingPort > 0 ? ` server=${existingPort}` : '';
           const uiPart =
-            scriptPath === 'dev.mjs' && Number.isFinite(existingUiPort) && existingUiPort > 0 ? ` ui=${existingUiPort}` : '';
+            scriptPath === 'dev.mjs' && Number.isFinite(existingRuntimeStatus.uiPort) && existingRuntimeStatus.uiPort > 0
+              ? ` ui=${existingRuntimeStatus.uiPort}`
+              : scriptPath === 'dev.mjs' && Number.isFinite(existingUiPort) && existingUiPort > 0
+              ? ` ui=${existingUiPort}`
+              : '';
           console.log(`[stack] ${stackName}: already running (pid=${existingOwnerPid}${serverPart}${uiPart})`);
 
           const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
@@ -176,6 +266,7 @@ export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPat
         const hasRecordedPorts = hasRecordedRuntimePortsForRestart(runtimeState);
         const wantsSoftReuse = !wantsRestart && hasRecordedPorts && existingPorts;
         const wantsHardReuse = isTrueRestart;
+        const adoptOccupiedRuntimePorts = shouldAdoptOccupiedRuntimePortsForRecovery(existingRuntimeStatus);
 
         const candidatePorts =
           (wantsHardReuse || wantsSoftReuse) && existingPorts
@@ -196,7 +287,7 @@ export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPat
           (!managedInfra || (candidatePorts.pg && candidatePorts.redis && candidatePorts.minio && candidatePorts.minioConsole));
 
         // Soft reuse: if previously recorded ports are occupied, fall back to allocating new ports.
-        if (canReuse && wantsSoftReuse && !wantsHardReuse) {
+        if (canReuse && wantsSoftReuse && !wantsHardReuse && !adoptOccupiedRuntimePorts) {
           const toCheck = Object.values(candidatePorts)
             .map((n) => Number(n))
             .filter((n) => Number.isFinite(n) && n > 0);
@@ -228,6 +319,9 @@ export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPat
           for (const p of toCheck) {
             // eslint-disable-next-line no-await-in-loop
             if (!(await isTcpPortFree(p))) {
+              if (adoptOccupiedRuntimePorts) {
+                continue;
+              }
               if (isTrueRestart && !wantsJson) {
                 // Try one more safe cleanup of stack-owned processes and re-check.
                 const baseDir = resolveStackEnvPath(stackName).baseDir;
@@ -291,7 +385,7 @@ export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPat
         }
 
         // Sanity: if somehow the server port is now occupied, fail closed (avoids killPortListeners nuking random processes).
-        if (!(await isTcpPortFree(Number(ports.server)))) {
+        if (!adoptOccupiedRuntimePorts && !(await isTcpPortFree(Number(ports.server)))) {
           throw new Error(`[stack] ${stackName}: picked server port ${ports.server} but it is not free`);
         }
 
@@ -378,6 +472,7 @@ export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPat
           ephemeral: true,
           ownerPid: child.pid,
           ports,
+          runtimeSnapshotId,
           ...(background ? { logs: { runner: logPath } } : {}),
         }).catch(() => {});
 
@@ -552,6 +647,7 @@ export async function runStackScriptWithStackEnv({ rootDir, stackName, scriptPat
           ephemeral: false,
           ownerPid: child.pid,
           ports: { server: pinnedPort },
+          runtimeSnapshotId,
           logs: { runner: logPath },
         }).catch(() => {});
 

package/scripts/stack/stack_daemon_command.mjs

@@ -10,10 +10,14 @@ import { getComponentDir, resolveStackEnvPath } from '../utils/paths/paths.mjs';
 import { run } from '../utils/proc/proc.mjs';
 import { resolveServerPortFromEnv, resolveServerUrls } from '../utils/server/urls.mjs';
 import { parseCliIdentityOrThrow, resolveCliHomeDirForIdentity } from '../utils/stack/cli_identities.mjs';
-import { readStackRuntimeStateFile, recordStackRuntimeUpdate, isPidAlive } from '../utils/stack/runtime_state.mjs';
+import { readStackRuntimeStateFile, isPidAlive } from '../utils/stack/runtime_state.mjs';
+import { syncStackRuntimeDaemonPidFromDaemonState } from '../utils/stack/runtime_daemon_state.mjs';
 import { withStackEnv } from './stack_environment.mjs';
 import { banner, cmd as cmdFmt, sectionTitle } from '../utils/ui/layout.mjs';
 import { cyan, green } from '../utils/ui/ansi.mjs';
+import { resolveStackRuntimeLaunchContext } from '../runtime/launch/resolveStackRuntimeLaunchContext.mjs';
+import { resolveCliRuntimeLaunchSpec } from '../runtime/launch/resolveCliRuntimeLaunchSpec.mjs';
+import { applyStackActiveServerScopeEnv } from '../utils/auth/stable_scope_id.mjs';
 
 export async function runStackDaemonCommand({ rootDir, stackName, argv, json }) {
   const { flags, kv } = parseArgs(argv);
@@ -62,8 +66,15 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
   const res = await withStackEnv({
     stackName,
     fn: async ({ env }) => {
-      const cliDir = getComponentDir(rootDir, 'happier-cli', env);
+      const runtimeLaunchContext = await resolveStackRuntimeLaunchContext({ argv, env });
+      const runtimeSnapshot = runtimeLaunchContext.snapshot;
+      const cliLaunchSpec = runtimeSnapshot ? resolveCliRuntimeLaunchSpec({ snapshot: runtimeSnapshot }) : null;
+      const cliDir = cliLaunchSpec?.cliDir ?? getComponentDir(rootDir, 'happier-cli', env);
       const cliBin = join(cliDir, 'bin', 'happier.mjs');
+      const cliEntrypoint = cliLaunchSpec?.entrypoint ?? '';
+      const cliNodeEntrypoint = cliLaunchSpec?.nodeEntrypoint ?? '';
+      const cliCommand = cliLaunchSpec?.command ?? '';
+      const cliCommandArgs = cliLaunchSpec?.args ?? [];
       const baseCliHomeDir = (env.HAPPIER_STACK_CLI_HOME_DIR ?? join(resolveStackEnvPath(stackName).baseDir, 'cli')).toString();
       const cliHomeDir = resolveCliHomeDirForIdentity({ cliHomeDir: baseCliHomeDir, identity });
 
@@ -94,20 +105,13 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
             }
           : {}),
       };
+      const scopedEnvForIdentity = applyStackActiveServerScopeEnv({
+        env: envForIdentity,
+        stackName,
+        cliIdentity: identity,
+      });
       await mkdir(cliHomeDir, { recursive: true }).catch(() => {});
 
-      const maybeRecordDaemonPid = async ({ pid, clear = false } = {}) => {
-        const path = (runtimePath ?? '').toString().trim();
-        if (!path) return;
-        if (clear) {
-          await recordStackRuntimeUpdate(path, { processes: { daemonPid: null } }).catch(() => {});
-          return;
-        }
-        const n = Number(pid);
-        if (!Number.isFinite(n) || n <= 1) return;
-        await recordStackRuntimeUpdate(path, { processes: { daemonPid: n } }).catch(() => {});
-      };
-
       if (action === 'start' || action === 'restart') {
         // UX: if this identity is not authenticated yet and we're in a real TTY, offer to run the
         // guided login flow inline (instead of failing or asking for a second terminal).
@@ -116,7 +120,7 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
         const hasCreds = Boolean(findExistingStackCredentialPath({
           cliHomeDir,
           serverUrl: internalServerUrl,
-          env: envForIdentity,
+          env: scopedEnvForIdentity,
         }));
 
         if (!hasCreds) {
@@ -147,7 +151,7 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
               ];
               await run(process.execPath, [join(rootDir, 'scripts', 'auth.mjs'), ...authArgs], {
                 cwd: rootDir,
-                env: envForIdentity,
+                env: scopedEnvForIdentity,
                 stdio: 'inherit',
               });
             } else {
@@ -159,9 +163,14 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
 
         await startLocalDaemonWithAuth({
           cliBin,
+          cliEntrypoint,
+          cliNodeEntrypoint,
+          cliCommand,
+          cliCommandArgs,
           cliHomeDir,
           internalServerUrl,
           publicServerUrl,
+          runtimeStatePath: runtimePath,
           isShuttingDown: () => false,
           forceRestart: action === 'restart',
           env: envForIdentity,
@@ -169,15 +178,12 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
           cliIdentity: identity,
         });
 
-        // Record the daemon PID in stack.runtime.json so `hstack tui` and other tools can
-        // display correct daemon state even when the daemon is started outside `hstack dev`.
-        const state = checkDaemonState(cliHomeDir, { serverUrl: internalServerUrl, env: envForIdentity });
-        if ((state?.status === 'running' || state?.status === 'starting') && typeof state?.pid === 'number') {
-          await maybeRecordDaemonPid({ pid: state.pid });
-        }
-
         const status = await daemonStatusSummary({
           cliBin,
+          cliEntrypoint,
+          cliNodeEntrypoint,
+          cliCommand,
+          cliCommandArgs,
           cliHomeDir,
           internalServerUrl,
           publicServerUrl,
@@ -191,16 +197,24 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
       if (action === 'stop') {
         await stopLocalDaemon({
           cliBin,
+          cliEntrypoint,
+          cliNodeEntrypoint,
+          cliCommand,
+          cliCommandArgs,
           internalServerUrl,
           publicServerUrl,
           cliHomeDir,
+          runtimeStatePath: runtimePath,
           env: envForIdentity,
           stackName,
           cliIdentity: identity,
         });
-        await maybeRecordDaemonPid({ clear: true });
         const status = await daemonStatusSummary({
           cliBin,
+          cliEntrypoint,
+          cliNodeEntrypoint,
+          cliCommand,
+          cliCommandArgs,
           cliHomeDir,
           internalServerUrl,
           publicServerUrl,
@@ -213,6 +227,10 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
 
       const status = await daemonStatusSummary({
         cliBin,
+        cliEntrypoint,
+        cliNodeEntrypoint,
+        cliCommand,
+        cliCommandArgs,
         cliHomeDir,
         internalServerUrl,
         publicServerUrl,
@@ -223,10 +241,15 @@ export async function runStackDaemonCommand({ rootDir, stackName, argv, json })
 
       // Best-effort: when someone runs `status`, persist the observed PID so the TUI can show
       // "running" even if the daemon was started outside of stack orchestration.
-      const state = checkDaemonState(cliHomeDir, { serverUrl: internalServerUrl, env: envForIdentity });
-      if ((state?.status === 'running' || state?.status === 'starting') && typeof state?.pid === 'number') {
-        await maybeRecordDaemonPid({ pid: state.pid });
-      }
+      await syncStackRuntimeDaemonPidFromDaemonState(
+        {
+          runtimeStatePath: runtimePath,
+          cliHomeDir,
+          internalServerUrl,
+          env: envForIdentity,
+        },
+        { checkDaemonStateImpl: checkDaemonState },
+      ).catch(() => {});
 
       return { ok: true, action, cliIdentity: identity, cliHomeDir, status: status.trim() };
     },

package/scripts/stack/stack_environment.mjs

@@ -7,6 +7,8 @@ import { stackExistsSync } from '../utils/stack/stacks.mjs';
 import { STACK_WRAPPER_PRESERVE_KEYS, scrubHappierStackEnv } from '../utils/env/scrub_env.mjs';
 import { applyStackActiveServerScopeEnv } from '../utils/auth/stable_scope_id.mjs';
 import { getStackRuntimeStatePath, isPidAlive, readStackRuntimeStateFile } from '../utils/stack/runtime_state.mjs';
+import { readStackRuntimeStateWithDaemonSync } from '../utils/stack/runtime_daemon_state.mjs';
+import { checkDaemonState } from '../daemon.mjs';
 
 const readExistingEnv = readTextOrEmpty;
 const STACK_WRAPPER_CLEAR_UNPREFIXED_KEYS = [
@@ -83,7 +85,7 @@ export async function withStackEnv({ stackName, fn, extraEnv = {} }) {
   const stackEnv = parseEnvToObject(raw);
 
   const runtimeStatePath = getStackRuntimeStatePath(stackName);
-  const runtimeState = await readStackRuntimeStateFile(runtimeStatePath);
+  const initialRuntimeState = await readStackRuntimeStateFile(runtimeStatePath);
 
   let env = {
     ...cleaned,
@@ -102,6 +104,22 @@ export async function withStackEnv({ stackName, fn, extraEnv = {} }) {
     cliIdentity: (env.HAPPIER_STACK_CLI_IDENTITY ?? '').toString().trim() || 'default',
   });
 
+  const runtimePortCandidate =
+    Number(env.HAPPIER_STACK_SERVER_PORT) > 0
+      ? Number(env.HAPPIER_STACK_SERVER_PORT)
+      : Number(initialRuntimeState?.ports?.server) > 0
+        ? Number(initialRuntimeState?.ports?.server)
+        : null;
+  const runtimeState = await readStackRuntimeStateWithDaemonSync({
+    runtimeStatePath,
+    cliHomeDir: (env.HAPPIER_STACK_CLI_HOME_DIR ?? join(resolveStackEnvPath(stackName).baseDir, 'cli')).toString(),
+    internalServerUrl:
+      Number.isFinite(runtimePortCandidate) && runtimePortCandidate > 0 ? `http://127.0.0.1:${runtimePortCandidate}` : '',
+    env,
+  }, {
+    checkDaemonStateImpl: checkDaemonState,
+  });
+
   // Runtime-only port overlay (ephemeral stacks): prefer stack.runtime.json ports when the stack
   // is still running, even if the original "owner" process is gone (common during dev restarts).
   const ownerPid = Number(runtimeState?.ownerPid);

package/scripts/stack/stack_environment.sanitization.test.mjs

@@ -118,3 +118,28 @@ test('withStackEnv clears leaked unprefixed server/home env vars from caller sco
     }
   });
 });
+
+test('withStackEnv preserves explicit local stack runtime override env vars from caller scope', async () => {
+  await withTempStackEnvFixture(async ({ stackName }) => {
+    const previousCliBuild = process.env.HAPPIER_STACK_CLI_BUILD;
+    const previousSkipRefreshDeps = process.env.HAPPIER_STACK_SKIP_REFRESH_DEPS;
+
+    process.env.HAPPIER_STACK_CLI_BUILD = '0';
+    process.env.HAPPIER_STACK_SKIP_REFRESH_DEPS = '1';
+
+    try {
+      await withStackEnv({
+        stackName,
+        fn: async ({ env }) => {
+          assert.equal(env.HAPPIER_STACK_CLI_BUILD, '0');
+          assert.equal(env.HAPPIER_STACK_SKIP_REFRESH_DEPS, '1');
+        },
+      });
+    } finally {
+      if (typeof previousCliBuild === 'undefined') delete process.env.HAPPIER_STACK_CLI_BUILD;
+      else process.env.HAPPIER_STACK_CLI_BUILD = previousCliBuild;
+      if (typeof previousSkipRefreshDeps === 'undefined') delete process.env.HAPPIER_STACK_SKIP_REFRESH_DEPS;
+      else process.env.HAPPIER_STACK_SKIP_REFRESH_DEPS = previousSkipRefreshDeps;
+    }
+  });
+});

package/scripts/stack/stack_info_snapshot.mjs

@@ -7,6 +7,12 @@ import { getStackRuntimeStatePath, isPidAlive, readStackRuntimeStateFile } from
 import { isTcpPortFree } from '../utils/net/ports.mjs';
 import { readTextOrEmpty } from '../utils/fs/ops.mjs';
 import { resolveDefaultRepoEnv } from './stack_environment.mjs';
+import { resolveStackRuntimeMode } from '../runtime/shared/runtime_mode.mjs';
+import { inspectActiveRuntimeSnapshot } from '../runtime/launch/inspectActiveRuntimeSnapshot.mjs';
+import { getObservedStackDaemon, readStackRuntimeStateWithDaemonSync } from '../utils/stack/runtime_daemon_state.mjs';
+import { applyStackActiveServerScopeEnv } from '../utils/auth/stable_scope_id.mjs';
+import { join } from 'node:path';
+import { checkDaemonState } from '../daemon.mjs';
 
 const readExistingEnv = readTextOrEmpty;
 
@@ -16,13 +22,34 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
   const envRaw = await readExistingEnv(envPath);
   const stackEnv = envRaw ? parseEnvToObject(envRaw) : {};
   const runtimeStatePath = getStackRuntimeStatePath(stackName);
-  const runtimeState = await readStackRuntimeStateFile(runtimeStatePath);
 
   const serverComponent = getEnvValueAny(stackEnv, ['HAPPIER_STACK_SERVER_COMPONENT']) || 'happier-server-light';
   const stackRemote = getEnvValueAny(stackEnv, ['HAPPIER_STACK_STACK_REMOTE']) || 'upstream';
 
   const pinnedServerPortRaw = getEnvValueAny(stackEnv, ['HAPPIER_STACK_SERVER_PORT']);
   const pinnedServerPort = pinnedServerPortRaw ? Number(pinnedServerPortRaw) : null;
+  const stackScopedEnv = applyStackActiveServerScopeEnv({
+    env: { ...process.env, ...stackEnv },
+    stackName,
+    cliIdentity: 'default',
+  });
+  const initialRuntimeState = await readStackRuntimeStateFile(runtimeStatePath);
+  const initialRuntimePorts =
+    initialRuntimeState?.ports && typeof initialRuntimeState.ports === 'object' ? initialRuntimeState.ports : {};
+  const syncServerPort =
+    Number.isFinite(pinnedServerPort) && pinnedServerPort > 0
+      ? pinnedServerPort
+      : Number(initialRuntimePorts?.server) > 0
+        ? Number(initialRuntimePorts.server)
+        : null;
+  const runtimeState = await readStackRuntimeStateWithDaemonSync({
+    runtimeStatePath,
+    cliHomeDir: join(baseDir, 'cli'),
+    internalServerUrl: Number.isFinite(syncServerPort) && syncServerPort > 0 ? `http://127.0.0.1:${syncServerPort}` : '',
+    env: stackScopedEnv,
+  }, {
+    checkDaemonStateImpl: checkDaemonState,
+  });
 
   const runtimePorts = runtimeState?.ports && typeof runtimeState.ports === 'object' ? runtimeState.ports : {};
   const serverPort =
@@ -44,6 +71,17 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
   const serverPid = Number(runtimeState?.processes?.serverPid);
   const expoPid = Number(runtimeState?.processes?.expoPid);
   const expoTailscaleForwarderPid = Number(runtimeState?.processes?.expoTailscaleForwarderPid);
+  const daemonExpected = String(getEnvValueAny(stackEnv, ['HAPPIER_STACK_DAEMON']) ?? '1').trim() !== '0';
+  const observedDaemon = getObservedStackDaemon({
+    cliHomeDir: join(baseDir, 'cli'),
+    internalServerUrl: Number.isFinite(serverPort) && serverPort > 0 ? `http://127.0.0.1:${serverPort}` : '',
+    runtimeDaemonPid: runtimeState?.processes?.daemonPid ?? null,
+    env: stackScopedEnv,
+  }, {
+    checkDaemonStateImpl: checkDaemonState,
+  });
+  const daemonPid = Number(observedDaemon.pid);
+  const daemonRunning = observedDaemon.running === true;
 
   const ownerAlive = Number.isFinite(ownerPid) && ownerPid > 1 ? isPidAlive(ownerPid) : false;
   const serverPidAlive = Number.isFinite(serverPid) && serverPid > 1 ? isPidAlive(serverPid) : false;
@@ -70,10 +108,10 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
     Number.isFinite(uiPort) && uiPort > 0
       ? uiPortListening
       : expoPidAlive;
-  const candidateRuntimePids = [ownerPid, serverPid, expoPid, expoTailscaleForwarderPid]
+  const candidateRuntimePids = [ownerPid, serverPid, expoPid, expoTailscaleForwarderPid, daemonPid]
     .filter((pid) => Number.isFinite(pid) && pid > 1);
   const runningPid = candidateRuntimePids.find((pid) => isPidAlive(pid)) ?? null;
-  const running = ownerAlive || serverRunning || uiRunning || serverPidAlive || expoPidAlive || expoForwarderAlive;
+  const running = ownerAlive || serverRunning || uiRunning || daemonRunning || serverPidAlive || expoPidAlive || expoForwarderAlive;
 
   const healthIssues = [];
   if (Number.isFinite(serverPort) && serverPort > 0 && !serverRunning) {
@@ -82,6 +120,9 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
   if (Number.isFinite(uiPort) && uiPort > 0 && !uiRunning) {
     healthIssues.push('ui_down');
   }
+  if (daemonExpected && running && !daemonRunning) {
+    healthIssues.push('daemon_down');
+  }
   const healthStatus = !running ? 'stopped' : healthIssues.length > 0 ? 'degraded' : 'healthy';
 
   const host = resolveLocalhostHost({ stackMode: true, stackName });
@@ -91,6 +132,8 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
 
   const repoDir = getEnvValueAny(stackEnv, ['HAPPIER_STACK_REPO_DIR']) || resolveDefaultRepoEnv({ rootDir }).HAPPIER_STACK_REPO_DIR;
   const repoWorktreeSpec = repoDir ? worktreeSpecFromDir({ rootDir, component: 'happier-ui', dir: repoDir }) || null : null;
+  const runtimeMode = resolveStackRuntimeMode({ argv: [], env: stackEnv }).mode;
+  const runtimeInspection = await inspectActiveRuntimeSnapshot({ stackBaseDir: baseDir });
   const dirs = {
     repoDir,
     uiDir: getComponentDir(rootDir, 'happier-ui', { ...process.env, ...stackEnv }),
@@ -119,6 +162,12 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
           pid: Number.isFinite(ownerPid) && ownerPid > 1 ? ownerPid : null,
           running: ownerAlive,
         },
+        daemon: {
+          pid: Number.isFinite(daemonPid) && daemonPid > 1 ? daemonPid : null,
+          running: daemonRunning,
+          status: observedDaemon.status,
+          source: observedDaemon.source,
+        },
         server: {
           pid: Number.isFinite(serverPid) && serverPid > 1 ? serverPid : null,
           running: serverRunning,
@@ -145,6 +194,13 @@ export async function readStackInfoSnapshot({ rootDir, stackName }) {
       processes: runtimeState?.processes ?? null,
       startedAt: runtimeState?.startedAt ?? null,
       updatedAt: runtimeState?.updatedAt ?? null,
+      mode: runtimeMode,
+      activeSnapshotId: runtimeInspection.activeSnapshotId,
+      snapshotPath: runtimeInspection.snapshotPath,
+      sourceFingerprint: runtimeInspection.sourceFingerprint,
+      valid: runtimeInspection.valid,
+      errors: runtimeInspection.errors,
+      snapshotComponents: runtimeInspection.manifest?.components ?? null,
     },
     urls: {
       host,