@happier-dev/stack 0.1.0 → 0.2.0

package/scripts/root_package_repo_local_scripts.test.mjs

@@ -19,7 +19,13 @@ test('repo root package.json exposes repo-local hstack scripts', async () => {
   assert.equal(scripts.start, 'node ./apps/stack/scripts/repo_local.mjs start');
   assert.equal(scripts.build, 'node ./apps/stack/scripts/repo_local.mjs build');
   assert.equal(scripts.tui, 'node ./apps/stack/scripts/repo_local.mjs tui');
+  assert.equal(scripts['tui:with-tauri'], 'node ./apps/stack/scripts/repo_local.mjs tui --tauri');
+  assert.equal(scripts['tui:with-mobile-tauri'], 'node ./apps/stack/scripts/repo_local.mjs tui --tauri --mobile');
   assert.equal(scripts['tui:with-mobile'], 'node ./apps/stack/scripts/repo_local.mjs tui dev --mobile');
+  assert.equal(scripts['tauri:qa'], 'yarn --cwd apps/ui tauri:qa');
+  assert.equal(scripts['tauri:mcp:server'], 'yarn --cwd apps/ui tauri:mcp:server');
+  assert.equal(scripts['tauri:mcp:cli'], 'yarn --cwd apps/ui tauri:mcp:cli');
+  assert.equal(scripts['tauri:mcp:session:start'], 'yarn --cwd apps/ui tauri:mcp:session:start');
   assert.equal(scripts['cli:activate'], 'node ./apps/stack/scripts/repo_cli_activate.mjs');
   assert.equal(scripts['cli:activate:path'], 'node ./apps/stack/scripts/repo_cli_activate.mjs --install-path');
   assert.equal(scripts.auth, 'node ./apps/stack/scripts/repo_local.mjs auth');
@@ -32,7 +38,7 @@ test('repo root package.json exposes repo-local hstack scripts', async () => {
   assert.equal(scripts.providers, 'node ./apps/stack/scripts/repo_local.mjs providers');
   assert.equal(scripts['self-host'], 'node ./apps/stack/scripts/repo_local.mjs self-host');
   assert.equal(scripts.remote, 'node ./apps/stack/scripts/repo_local.mjs remote');
-  assert.equal(scripts.setup, 'node ./apps/stack/scripts/repo_local.mjs setup');
+  assert.equal(scripts.setup, 'node ./apps/stack/scripts/repo_local.mjs setup-from-source');
   assert.equal(scripts.service, 'node ./apps/stack/scripts/repo_local.mjs service');
   assert.equal(scripts.logs, 'node ./apps/stack/scripts/repo_local.mjs logs --follow');
   assert.equal(scripts['logs:all'], 'node ./apps/stack/scripts/repo_local.mjs logs --follow --component=all');
@@ -43,4 +49,5 @@ test('repo root package.json exposes repo-local hstack scripts', async () => {
   assert.equal(scripts['logs:service'], 'node ./apps/stack/scripts/repo_local.mjs logs --follow --component=service');
   assert.equal(scripts.tailscale, 'node ./apps/stack/scripts/repo_local.mjs tailscale');
   assert.equal(scripts.env, 'node ./apps/stack/scripts/repo_local.mjs env');
+  assert.equal(scripts['ui:tauri'], 'node ./apps/stack/scripts/tauri_dev.mjs');
 });

package/scripts/run.mjs

@@ -7,6 +7,7 @@ import { killPortListeners } from './utils/net/ports.mjs';
 import { getServerComponentName, isHappierServerRunning, waitForServerReady } from './utils/server/server.mjs';
 import { ensureCliBuilt, ensureDepsInstalled, pmExecBin, pmSpawnScript, requireDir } from './utils/proc/pm.mjs';
 import { join } from 'node:path';
+import { statSync } from 'node:fs';
 import { setTimeout as delay } from 'node:timers/promises';
 import { maybeResetTailscaleServe } from './tailscale.mjs';
 import { checkDaemonState, getDaemonEnv, isDaemonRunning, startLocalDaemonWithAuth, stopLocalDaemon } from './daemon.mjs';
@@ -15,8 +16,13 @@ import { assertServerComponentDirMatches, assertServerPrismaProviderMatches } fr
 import { resolveServerStartScript } from './utils/server/flavor_scripts.mjs';
 import { applyHappyServerMigrations, ensureHappyServerManagedInfra } from './utils/server/infra/happy_server_infra.mjs';
 import { applyServerLightEnvDefaults } from './utils/server/apply_server_light_env_defaults.mjs';
-import { getAccountCountForServerComponent, prepareDaemonAuthSeedIfNeeded, resolveAutoCopyFromMainEnabled } from './utils/stack/startup.mjs';
-import { recordStackRuntimeStart, recordStackRuntimeUpdate } from './utils/stack/runtime_state.mjs';
+import {
+  getAccountCountForServerComponent,
+  prepareDaemonAuthSeedIfNeeded,
+  probeExistingAccountCountForServerComponent,
+  resolveAutoCopyFromMainEnabled,
+} from './utils/stack/startup.mjs';
+import { readStackRuntimeStateFile, recordStackRuntimeStart, recordStackRuntimeUpdate } from './utils/stack/runtime_state.mjs';
 import { resolveStackContext } from './utils/stack/context.mjs';
 import { getPublicServerUrlEnvOverride, resolveServerUrls } from './utils/server/urls.mjs';
 import { preferStackLocalhostUrl } from './utils/paths/localhost_host.mjs';
@@ -25,15 +31,25 @@ import { ensureDevExpoServer, resolveExpoTailscaleEnabled } from './utils/dev/ex
 import { maybeRunInteractiveStackAuthSetup } from './utils/auth/interactive_stack_auth.mjs';
 import { getInvokedCwd, inferComponentFromCwd } from './utils/cli/cwd_scope.mjs';
 import { daemonStartGate, formatDaemonAuthRequiredError } from './utils/auth/daemon_gate.mjs';
+import { applyStackActiveServerScopeEnv } from './utils/auth/stable_scope_id.mjs';
 import { resolveServerUiEnv } from './utils/server/ui_env.mjs';
 import { applyBindModeToEnv, resolveBindModeFromArgs } from './utils/net/bind_mode.mjs';
 import { cmd, sectionTitle } from './utils/ui/layout.mjs';
+import { renderTerminalUsageInstructions } from './utils/stack/terminal_usage_instructions.mjs';
+import { resolveStackActiveServerId } from './utils/auth/stable_scope_id.mjs';
 import { cyan, dim, green, yellow } from './utils/ui/ansi.mjs';
 import { isSandboxed } from './utils/env/sandbox.mjs';
 import { installExitCleanup } from './utils/proc/exit_cleanup.mjs';
 import { expandHome } from './utils/paths/canonical_home.mjs';
 import { validateUiServingConfig } from './utils/server/ui_build_check.mjs';
 import { resolveLocalServerPortForStack } from './utils/server/resolve_stack_server_port.mjs';
+import { findExistingStackCredentialPath } from './utils/auth/credentials_paths.mjs';
+import { createServiceDaemonAutostarter } from './utils/service/daemon_autostart.mjs';
+import { applyRuntimeServerLightSqliteEnv } from './utils/server/apply_runtime_server_light_sqlite_env.mjs';
+import { resolveStackRuntimeLaunchContext } from './runtime/launch/resolveStackRuntimeLaunchContext.mjs';
+import { resolveCliRuntimeLaunchSpec } from './runtime/launch/resolveCliRuntimeLaunchSpec.mjs';
+import { resolveServerRuntimeLaunchSpec } from './runtime/launch/resolveServerRuntimeLaunchSpec.mjs';
+import { spawnStackOwnerDeathWatchdog } from './utils/stack/owner_death_watchdog.mjs';
 
 /**
  * Run the local stack in "production-like" mode:
@@ -126,6 +142,13 @@ async function main() {
   if (serverComponentName === 'both') {
     throw new Error(`[local] --server=both is not supported for run (pick one: happier-server-light or happier-server)`);
   }
+  const runtimeLaunchContext = await resolveStackRuntimeLaunchContext({ argv, env: process.env });
+  const runtimeSnapshot = runtimeLaunchContext.snapshot;
+  const runtimeBackedStart = Boolean(runtimeSnapshot);
+  const cliLaunchSpec = runtimeSnapshot ? resolveCliRuntimeLaunchSpec({ snapshot: runtimeSnapshot }) : null;
+  const serverLaunchSpec = runtimeSnapshot
+    ? resolveServerRuntimeLaunchSpec({ serverComponent: serverComponentName, snapshot: runtimeSnapshot })
+    : null;
 
   const startDaemon = !flags.has('--no-daemon') && (process.env.HAPPIER_STACK_DAEMON ?? '1') !== '0';
   const serveUiWanted = !flags.has('--no-ui') && (process.env.HAPPIER_STACK_SERVE_UI ?? '1') !== '0';
@@ -139,17 +162,23 @@ async function main() {
   const noBrowser = flags.has('--no-browser') || (process.env.HAPPIER_STACK_NO_BROWSER ?? '').toString().trim() === '1';
   const uiPrefix = process.env.HAPPIER_STACK_UI_PREFIX?.trim() ? process.env.HAPPIER_STACK_UI_PREFIX.trim() : '/';
   const autostart = getDefaultAutostartPaths();
-  const uiBuildDir = process.env.HAPPIER_STACK_UI_BUILD_DIR?.trim()
-    ? process.env.HAPPIER_STACK_UI_BUILD_DIR.trim()
-    : join(autostart.baseDir, 'ui');
+  const uiBuildDir = runtimeSnapshot
+    ? join(runtimeSnapshot.launchPath ?? runtimeSnapshot.snapshotPath, 'ui')
+    : process.env.HAPPIER_STACK_UI_BUILD_DIR?.trim()
+      ? process.env.HAPPIER_STACK_UI_BUILD_DIR.trim()
+      : join(autostart.baseDir, 'ui');
 
   const enableTailscaleServe = (process.env.HAPPIER_STACK_TAILSCALE_SERVE ?? '0') === '1';
 
-  const serverDir = getComponentDir(rootDir, serverComponentName);
-  const cliDir = getComponentDir(rootDir, 'happier-cli');
+  const sourceServerDir = getComponentDir(rootDir, serverComponentName);
+  const serverDir = serverLaunchSpec?.serverDir ?? sourceServerDir;
+  const cliDir = cliLaunchSpec?.cliDir ?? getComponentDir(rootDir, 'happier-cli');
   const uiDir = getComponentDir(rootDir, 'happier-ui');
 
   const cliBin = join(cliDir, 'bin', 'happier.mjs');
+  const cliNodeEntrypoint = cliLaunchSpec?.nodeEntrypoint ?? '';
+  const cliCommand = cliLaunchSpec?.command ?? '';
+  const cliCommandArgs = cliLaunchSpec?.args ?? [];
 
   const cliHomeDir = process.env.HAPPIER_STACK_CLI_HOME_DIR?.trim()
     ? expandHome(process.env.HAPPIER_STACK_CLI_HOME_DIR.trim())
@@ -175,18 +204,24 @@ async function main() {
         uiPrefix,
         uiBuildDir,
         cliHomeDir,
+        launchMode: runtimeSnapshot ? 'runtime' : 'source',
+        runtimeSnapshotId: runtimeSnapshot?.snapshotId ?? null,
       },
     });
     return;
   }
 
-  const serverStartScript = resolveServerStartScript({ serverComponentName, serverDir });
+  const serverStartScript = runtimeSnapshot ? null : resolveServerStartScript({ serverComponentName, serverDir });
 
-  assertServerComponentDirMatches({ rootDir, serverComponentName, serverDir });
-  assertServerPrismaProviderMatches({ serverComponentName, serverDir });
+  if (!runtimeSnapshot) {
+    assertServerComponentDirMatches({ rootDir, serverComponentName, serverDir });
+    assertServerPrismaProviderMatches({ serverComponentName, serverDir });
+  }
 
-  await requireDir(serverComponentName, serverDir);
-  await requireDir('happier-cli', cliDir);
+  if (!runtimeSnapshot) {
+    await requireDir(serverComponentName, serverDir);
+    await requireDir('happier-cli', cliDir);
+  }
   if (startMobile) {
     await requireDir('happier-ui', uiDir);
   }
@@ -214,10 +249,12 @@ async function main() {
 	  const children = [];
 	  let shuttingDown = false;
 	  let ownedDaemonPid = null;
+	  let daemonAutostarter = null;
 	  installExitCleanup({ label: 'local', children });
 	  const baseEnv = { ...process.env };
 	  const stackCtx = resolveStackContext({ env: baseEnv, autostart });
 	  const { stackMode, runtimeStatePath, stackName, envPath, ephemeral } = stackCtx;
+	  const daemonScopeEnv = applyStackActiveServerScopeEnv({ env: baseEnv, stackName, cliIdentity: 'default' });
 
   serverPort = await resolveLocalServerPortForStack({
     env: baseEnv,
@@ -236,10 +273,14 @@ async function main() {
 
   // Ensure happier-cli is install+build ready before starting the daemon.
   const buildCli = (baseEnv.HAPPIER_STACK_CLI_BUILD ?? '1').toString().trim() !== '0';
-  await ensureCliBuilt(cliDir, { buildCli });
+  if (!runtimeSnapshot) {
+    await ensureCliBuilt(cliDir, { buildCli });
+  }
 
   // Ensure server deps exist before any Prisma/docker work.
-  await ensureDepsInstalled(serverDir, serverComponentName);
+  if (!runtimeSnapshot) {
+    await ensureDepsInstalled(serverDir, serverComponentName);
+  }
   if (startMobile) {
     await ensureDepsInstalled(uiDir, 'happier-ui');
   }
@@ -263,7 +304,9 @@ async function main() {
   }
 
   const serverAlreadyRunning = await isHappierServerRunning(internalServerUrl);
-  const daemonAlreadyRunning = startDaemon ? isDaemonRunning(cliHomeDir) : false;
+  const daemonAlreadyRunning = startDaemon
+    ? isDaemonRunning(cliHomeDir, { serverUrl: internalServerUrl, env: daemonScopeEnv })
+    : false;
   if (!restart && serverAlreadyRunning && (!startDaemon || daemonAlreadyRunning)) {
     console.log(
       `${green('✓')} start: already running ${dim('(')}` +
@@ -282,7 +325,17 @@ async function main() {
       ephemeral,
       ownerPid: process.pid,
       ports: { server: serverPort },
+      runtimeSnapshotId: runtimeSnapshot?.snapshotId ?? null,
     }).catch(() => {});
+    spawnStackOwnerDeathWatchdog({
+      rootDir,
+      stackName,
+      baseDir: autostart.baseDir,
+      envPath,
+      runtimeStatePath,
+      ownerPid: process.pid,
+      env: baseEnv,
+    });
   }
 
   // Server
@@ -308,16 +361,27 @@ async function main() {
   let happierServerAccountCount = null;
   if (serverComponentName === 'happier-server-light') {
     applyServerLightEnvDefaults({ baseEnv, serverEnv, baseDir: autostart.baseDir });
+    if (runtimeBackedStart) {
+      applyRuntimeServerLightSqliteEnv({ env: serverEnv, serverDir });
+    }
 
-    // Reliability: ensure DB schema exists before daemon hits /v1/machines (health checks don't cover DB readiness).
-    // If the server is already running and we are not restarting, skip migrations/probes (pglite is single-connection).
-    const acct = await getAccountCountForServerComponent({
-      serverComponentName,
-      serverDir,
-      env: serverEnv,
-      bestEffort: Boolean(serverAlreadyRunning && !restart),
-    });
-    serverLightAccountCount = typeof acct.accountCount === 'number' ? acct.accountCount : null;
+    if (!runtimeBackedStart) {
+      // Source-backed starts ensure the light DB schema exists before daemon startup.
+      const acct = await getAccountCountForServerComponent({
+        serverComponentName,
+        serverDir: sourceServerDir,
+        env: serverEnv,
+        bestEffort: Boolean(serverAlreadyRunning && !restart),
+      });
+      serverLightAccountCount = typeof acct.accountCount === 'number' ? acct.accountCount : null;
+    } else {
+      const acct = await probeExistingAccountCountForServerComponent({
+        serverComponentName,
+        serverDir,
+        env: serverEnv,
+      });
+      serverLightAccountCount = typeof acct.accountCount === 'number' ? acct.accountCount : null;
+    }
   }
   let effectiveInternalServerUrl = internalServerUrl;
   if (serverComponentName === 'happier-server') {
@@ -342,20 +406,23 @@ async function main() {
       }
 
       const backendEnv = { ...serverEnv, ...infra.env, PORT: String(backendPort) };
-      const autoMigrate = (baseEnv.HAPPIER_STACK_PRISMA_MIGRATE ?? '1') !== '0';
-      if (autoMigrate) {
-        await applyHappyServerMigrations({ serverDir, env: backendEnv });
+      if (!runtimeBackedStart) {
+        const autoMigrate = (baseEnv.HAPPIER_STACK_PRISMA_MIGRATE ?? '1') !== '0';
+        if (autoMigrate) {
+          await applyHappyServerMigrations({ serverDir: sourceServerDir, env: backendEnv });
+        }
+        // Account probe should use the *actual* DATABASE_URL/infra env (ephemeral stacks do not persist it in env files).
+        const acct = await getAccountCountForServerComponent({
+          serverComponentName,
+          serverDir: sourceServerDir,
+          env: backendEnv,
+          bestEffort: true,
+        });
+        happierServerAccountCount = typeof acct.accountCount === 'number' ? acct.accountCount : null;
       }
-      // Account probe should use the *actual* DATABASE_URL/infra env (ephemeral stacks do not persist it in env files).
-      const acct = await getAccountCountForServerComponent({
-        serverComponentName,
-        serverDir,
-        env: backendEnv,
-        bestEffort: true,
-      });
-      happierServerAccountCount = typeof acct.accountCount === 'number' ? acct.accountCount : null;
-
-      const backend = await pmSpawnScript({ label: 'server', dir: serverDir, script: 'start', env: backendEnv });
+      const backend = runtimeSnapshot
+        ? spawnProc('server', serverLaunchSpec.command, serverLaunchSpec.args, backendEnv, { cwd: serverDir })
+        : await pmSpawnScript({ label: 'server', dir: serverDir, script: 'start', env: backendEnv });
       children.push(backend);
       if (stackMode && runtimeStatePath) {
         await recordStackRuntimeUpdate(runtimeStatePath, {
@@ -393,7 +460,9 @@ async function main() {
   // Default server start (happier-server-light, or happier-server without managed infra).
   if (!(serverComponentName === 'happier-server' && (baseEnv.HAPPIER_STACK_MANAGED_INFRA ?? '1') !== '0')) {
     if (!serverAlreadyRunning || restart) {
-      const server = await pmSpawnScript({ label: 'server', dir: serverDir, script: serverStartScript, env: serverEnv });
+      const server = runtimeSnapshot
+        ? spawnProc('server', serverLaunchSpec.command, serverLaunchSpec.args, serverEnv, { cwd: serverDir })
+        : await pmSpawnScript({ label: 'server', dir: serverDir, script: serverStartScript, env: serverEnv });
       children.push(server);
       if (stackMode && runtimeStatePath) {
         await recordStackRuntimeUpdate(runtimeStatePath, { processes: { serverPid: server.pid } }).catch(() => {});
@@ -432,11 +501,13 @@ async function main() {
     }
 
     console.log('');
-    console.log(sectionTitle('Terminal usage'));
-    console.log(dim(`To run ${cyan('happier')} against this stack (and have sessions appear in the UI), export:`));
-    console.log(cmd(`export HAPPIER_SERVER_URL="${effectiveInternalServerUrl}"`));
-    console.log(cmd(`export HAPPIER_HOME_DIR="${cliHomeDir}"`));
-    console.log(cmd(`export HAPPIER_WEBAPP_URL="${publicServerUrl}"`));
+    console.log(renderTerminalUsageInstructions({
+      internalServerUrl: effectiveInternalServerUrl,
+      cliHomeDir,
+      publicServerUrl,
+      activeServerId: resolveStackActiveServerId({ env: baseEnv, stackName: autostart.stackName }),
+      stackName: autostart.stackName,
+    }).join('\n'));
 
     // Auto-open UI (interactive only) using the stack-scoped hostname when applicable.
     const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
@@ -452,12 +523,81 @@ async function main() {
 
   // Daemon
   if (startDaemon) {
-    const gate = daemonStartGate({ env: baseEnv, cliHomeDir, serverUrl: effectiveInternalServerUrl });
+    const gate = daemonStartGate({ env: daemonScopeEnv, cliHomeDir, serverUrl: effectiveInternalServerUrl });
     if (!gate.ok) {
       const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
       // In orchestrated auth flows, keep server/UI up and let the orchestrator start daemon post-auth.
       if (gate.reason === 'auth_flow_missing_credentials') {
         console.log('[local] auth flow: skipping daemon start until credentials exist');
+        const serviceMode = (daemonScopeEnv.HAPPIER_STACK_SERVICE_MODE ?? '').toString().trim() === '1';
+        if (serviceMode) {
+          const pollMs = daemonScopeEnv.HAPPIER_STACK_SERVICE_DAEMON_AUTOSTART_POLL_MS ?? '';
+          const maxAttemptsPerCredentials =
+            daemonScopeEnv.HAPPIER_STACK_SERVICE_DAEMON_AUTOSTART_MAX_ATTEMPTS_PER_CREDENTIALS ?? '';
+          const retryBaseMs = daemonScopeEnv.HAPPIER_STACK_SERVICE_DAEMON_AUTOSTART_RETRY_BASE_MS ?? '';
+          const retryMaxMs = daemonScopeEnv.HAPPIER_STACK_SERVICE_DAEMON_AUTOSTART_RETRY_MAX_MS ?? '';
+
+          const getCredentialFingerprint = async () => {
+            const path = findExistingStackCredentialPath({
+              cliHomeDir,
+              serverUrl: effectiveInternalServerUrl,
+              env: daemonScopeEnv,
+            });
+            if (!path) return null;
+            try {
+              const st = statSync(path);
+              const mtime = Number(st?.mtimeMs) || 0;
+              const size = Number(st?.size) || 0;
+              return `${path}:${mtime}:${size}`;
+            } catch {
+              return String(path);
+            }
+          };
+
+          const startDaemonAndRecord = async () => {
+            await startLocalDaemonWithAuth({
+              cliBin,
+              cliEntrypoint: cliLaunchSpec?.entrypoint ?? '',
+              cliNodeEntrypoint,
+              cliCommand,
+              cliCommandArgs,
+              cliHomeDir,
+              internalServerUrl: effectiveInternalServerUrl,
+              publicServerUrl,
+              runtimeStatePath,
+              isShuttingDown: () => shuttingDown,
+              forceRestart: restart,
+              env: daemonScopeEnv,
+              stackName,
+              cliIdentity: 'default',
+            });
+            const daemonEnvForState = getDaemonEnv({
+              baseEnv: daemonScopeEnv,
+              cliHomeDir,
+              internalServerUrl: effectiveInternalServerUrl,
+              publicServerUrl: publicServerUrl || effectiveInternalServerUrl,
+              stackName,
+              cliIdentity: 'default',
+            });
+            const daemonState = checkDaemonState(cliHomeDir, { serverUrl: effectiveInternalServerUrl, env: daemonEnvForState });
+            ownedDaemonPid = typeof daemonState?.pid === 'number' ? daemonState.pid : null;
+          };
+
+          daemonAutostarter = createServiceDaemonAutostarter({
+            enabled: true,
+            isShuttingDown: () => shuttingDown,
+            isServerReady: async () => await isHappierServerRunning(effectiveInternalServerUrl),
+            pollMs,
+            maxAttemptsPerCredentials,
+            retryBaseMs,
+            retryMaxMs,
+            getCredentialFingerprint,
+            isDaemonRunning: () => isDaemonRunning(cliHomeDir, { serverUrl: effectiveInternalServerUrl, env: daemonScopeEnv }),
+            startDaemon: startDaemonAndRecord,
+            logger: console,
+          });
+          daemonAutostarter.start();
+        }
       } else if (!isInteractive) {
         throw new Error(
           formatDaemonAuthRequiredError({
@@ -469,10 +609,10 @@ async function main() {
       }
     } else {
       const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-      if (serverComponentName === 'happier-server' && happierServerAccountCount == null) {
+      if (!runtimeBackedStart && serverComponentName === 'happier-server' && happierServerAccountCount == null) {
         const acct = await getAccountCountForServerComponent({
           serverComponentName,
-          serverDir,
+          serverDir: sourceServerDir,
           env: serverEnv,
           bestEffort: true,
         });
@@ -480,11 +620,11 @@ async function main() {
       }
       const accountCount =
         serverComponentName === 'happier-server-light' ? serverLightAccountCount : happierServerAccountCount;
-      const autoSeedEnabled = resolveAutoCopyFromMainEnabled({ env: baseEnv, stackName: autostart.stackName, isInteractive });
+      const autoSeedEnabled = resolveAutoCopyFromMainEnabled({ env: daemonScopeEnv, stackName, isInteractive });
       await maybeRunInteractiveStackAuthSetup({
         rootDir,
-        env: baseEnv,
-        stackName: autostart.stackName,
+        env: daemonScopeEnv,
+        stackName,
         cliHomeDir,
         accountCount,
         isInteractive,
@@ -492,26 +632,31 @@ async function main() {
       });
       await prepareDaemonAuthSeedIfNeeded({
       rootDir,
-      env: baseEnv,
-      stackName: autostart.stackName,
+      env: daemonScopeEnv,
+      stackName,
       cliHomeDir,
       startDaemon,
       isInteractive,
       accountCount,
       quiet: false,
     });
-	    await startLocalDaemonWithAuth({
-	      cliBin,
-	      cliHomeDir,
-	      internalServerUrl: effectiveInternalServerUrl,
-	      publicServerUrl,
-	      isShuttingDown: () => shuttingDown,
-	      forceRestart: restart,
-	        env: baseEnv,
-	        stackName: autostart.stackName,
+		    await startLocalDaemonWithAuth({
+		      cliBin,
+          cliEntrypoint: cliLaunchSpec?.entrypoint ?? '',
+          cliNodeEntrypoint,
+          cliCommand,
+          cliCommandArgs,
+		      cliHomeDir,
+		      internalServerUrl: effectiveInternalServerUrl,
+		      publicServerUrl,
+		      runtimeStatePath,
+		      isShuttingDown: () => shuttingDown,
+		      forceRestart: restart,
+		        env: daemonScopeEnv,
+	        stackName,
 	    });
 	      const daemonEnvForState = getDaemonEnv({
-	        baseEnv,
+	        baseEnv: daemonScopeEnv,
 	        cliHomeDir,
 	        internalServerUrl: effectiveInternalServerUrl,
 	        publicServerUrl: publicServerUrl || effectiveInternalServerUrl,
@@ -545,32 +690,65 @@ async function main() {
     }
   }
 
-  const shutdown = async () => {
+  const shutdown = async ({ signal = 'SIGTERM' } = {}) => {
     if (shuttingDown) {
       return;
     }
     shuttingDown = true;
-    console.log('\n[local] shutting down...');
+    let shutdownRequest = null;
+    if (runtimeStatePath) {
+      shutdownRequest = (await readStackRuntimeStateFile(runtimeStatePath).catch(() => null))?.stopRequest ?? null;
+    }
+    console.log(`\n[local] shutting down (${signal})...`);
+    if (shutdownRequest) {
+      const requestedBy = String(shutdownRequest.requestedBy ?? '').trim();
+      const reason = String(shutdownRequest.reason ?? '').trim();
+      const requestedAt = String(shutdownRequest.requestedAt ?? '').trim();
+      console.log(
+        `[local] shutdown request: ` +
+          [
+            requestedBy ? `requestedBy=${requestedBy}` : null,
+            reason ? `reason=${reason}` : null,
+            requestedAt ? `requestedAt=${requestedAt}` : null,
+          ]
+            .filter(Boolean)
+            .join(' ')
+      );
+    }
+
+    try {
+      daemonAutostarter?.stop?.();
+    } catch {
+      // ignore
+    }
 
 	    if (startDaemon) {
 	      if (ownedDaemonPid && Number.isFinite(ownedDaemonPid) && ownedDaemonPid > 0) {
-	        await stopLocalDaemon({
-	          cliBin,
-	          internalServerUrl: effectiveInternalServerUrl,
-	          cliHomeDir,
-	          expectedPid: ownedDaemonPid,
-	          env: baseEnv,
-	          stackName,
+		        await stopLocalDaemon({
+		          cliBin,
+              cliNodeEntrypoint,
+              cliCommand,
+              cliCommandArgs,
+		          internalServerUrl: effectiveInternalServerUrl,
+		          cliHomeDir,
+		          runtimeStatePath,
+		          expectedPid: ownedDaemonPid,
+		          env: daemonScopeEnv,
+		          stackName,
 	          cliIdentity: 'default',
 	        });
 	      } else {
-	        await stopLocalDaemon({
-	          cliBin,
-	          internalServerUrl: effectiveInternalServerUrl,
-	          cliHomeDir,
-	          env: baseEnv,
-	          stackName,
-	          cliIdentity: 'default',
+		        await stopLocalDaemon({
+		          cliBin,
+              cliNodeEntrypoint,
+              cliCommand,
+              cliCommandArgs,
+		          internalServerUrl: effectiveInternalServerUrl,
+		          cliHomeDir,
+		          runtimeStatePath,
+		          env: daemonScopeEnv,
+		          stackName,
+		          cliIdentity: 'default',
 	        });
 	      }
 	    }
@@ -591,8 +769,8 @@ async function main() {
     await maybeResetTailscaleServe();
   };
 
-  process.on('SIGINT', () => shutdown().then(() => process.exit(0)));
-  process.on('SIGTERM', () => shutdown().then(() => process.exit(0)));
+  process.on('SIGINT', () => shutdown({ signal: 'SIGINT' }).then(() => process.exit(0)));
+  process.on('SIGTERM', () => shutdown({ signal: 'SIGTERM' }).then(() => process.exit(0)));
 
   // Keep running
   await new Promise(() => {});