@happier-dev/stack 0.2.1-preview.1775586714.26562 → 0.2.12-preview.1

package/scripts/utils/stack/stop_lock_timeout.test.mjs

@@ -0,0 +1,13 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { resolveStackCleanupExecutorLockTimeoutMs } from './stop.mjs';
+
+test('attended TUI cleanup lock waits use checkpoints instead of a terminal deadline', () => {
+  assert.equal(resolveStackCleanupExecutorLockTimeoutMs({ env: { HAPPIER_STACK_TUI: '1' } }), Infinity);
+  assert.equal(resolveStackCleanupExecutorLockTimeoutMs({ env: {} }), 300_000);
+  assert.equal(resolveStackCleanupExecutorLockTimeoutMs(
+    { env: { HAPPIER_STACK_TUI: '1' } },
+    { timeoutMs: 12_345 },
+  ), 12_345);
+});

package/scripts/utils/tauri/desktop_install.mjs

@@ -0,0 +1,81 @@
+import { cp, mkdir, rename, rm, stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+function sanitizeMacAppName(productName) {
+  const value = String(productName ?? '').trim() || 'Happier';
+  return value.replace(/[/:]/g, '-');
+}
+
+export function resolveMacOsDesktopInstallPlan({
+  productName,
+  sourceAppPath,
+  installDir = '',
+  env = process.env,
+  homeDir = homedir(),
+} = {}) {
+  const resolvedInstallDir =
+    String(installDir || env.HAPPIER_STACK_DESKTOP_INSTALL_DIR || '').trim() ||
+    join(homeDir, 'Applications');
+  const appName = `${sanitizeMacAppName(productName)}.app`;
+  return {
+    productName: sanitizeMacAppName(productName),
+    sourceAppPath: String(sourceAppPath ?? '').trim(),
+    installDir: resolvedInstallDir,
+    targetAppPath: join(resolvedInstallDir, appName),
+  };
+}
+
+export async function installMacOsDesktopApp({
+  productName,
+  sourceAppPath,
+  installDir = '',
+  env = process.env,
+  homeDir = homedir(),
+} = {}) {
+  const plan = resolveMacOsDesktopInstallPlan({ productName, sourceAppPath, installDir, env, homeDir });
+  if (!plan.sourceAppPath) {
+    throw new Error('[stack install] missing desktop app source path.');
+  }
+
+  let sourceStats;
+  try {
+    sourceStats = await stat(plan.sourceAppPath);
+  } catch {
+    throw new Error(`[stack install] desktop app bundle not found: ${plan.sourceAppPath}`);
+  }
+  if (!sourceStats.isDirectory()) {
+    throw new Error(`[stack install] desktop app source is not an app bundle directory: ${plan.sourceAppPath}`);
+  }
+
+  await mkdir(plan.installDir, { recursive: true });
+  const suffix = `${process.pid}-${Date.now()}`;
+  const tmpAppPath = join(plan.installDir, `.${plan.productName}.tmp-${suffix}.app`);
+  const backupAppPath = join(plan.installDir, `.${plan.productName}.backup-${suffix}.app`);
+  await rm(tmpAppPath, { recursive: true, force: true });
+  await cp(plan.sourceAppPath, tmpAppPath, { recursive: true, force: true });
+
+  let movedExistingToBackup = false;
+  try {
+    if (existsSync(plan.targetAppPath)) {
+      await rm(backupAppPath, { recursive: true, force: true });
+      await rename(plan.targetAppPath, backupAppPath);
+      movedExistingToBackup = true;
+    }
+    await rename(tmpAppPath, plan.targetAppPath);
+    if (movedExistingToBackup) {
+      await rm(backupAppPath, { recursive: true, force: true });
+    }
+  } catch (error) {
+    await rm(tmpAppPath, { recursive: true, force: true }).catch(() => {});
+    if (movedExistingToBackup && !existsSync(plan.targetAppPath) && existsSync(backupAppPath)) {
+      await rename(backupAppPath, plan.targetAppPath).catch(() => {});
+    }
+    throw error;
+  }
+
+  return {
+    ok: true,
+    ...plan,
+  };
+}

package/scripts/utils/tauri/desktop_install.test.mjs

@@ -0,0 +1,43 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { installMacOsDesktopApp, resolveMacOsDesktopInstallPlan } from './desktop_install.mjs';
+
+test('installMacOsDesktopApp replaces an existing stack-scoped macOS app bundle', async (t) => {
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-desktop-install-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true });
+  });
+
+  const sourceApp = join(tmp, 'build', 'Happier (local-prod).app');
+  const installDir = join(tmp, 'Applications');
+  const targetApp = join(installDir, 'Happier (local-prod).app');
+  await mkdir(join(sourceApp, 'Contents'), { recursive: true });
+  await mkdir(join(targetApp, 'Contents'), { recursive: true });
+  await writeFile(join(sourceApp, 'Contents', 'marker.txt'), 'new-build', 'utf-8');
+  await writeFile(join(targetApp, 'Contents', 'marker.txt'), 'old-build', 'utf-8');
+
+  const result = await installMacOsDesktopApp({
+    productName: 'Happier (local-prod)',
+    sourceAppPath: sourceApp,
+    installDir,
+  });
+
+  assert.equal(result.targetAppPath, targetApp);
+  assert.equal(await readFile(join(targetApp, 'Contents', 'marker.txt'), 'utf-8'), 'new-build');
+});
+
+test('resolveMacOsDesktopInstallPlan sanitizes app bundle path separators', () => {
+  const plan = resolveMacOsDesktopInstallPlan({
+    productName: 'Happier: local/prod',
+    sourceAppPath: '/tmp/source.app',
+    homeDir: '/Users/alice',
+    env: {},
+  });
+
+  assert.equal(plan.productName, 'Happier- local-prod');
+  assert.equal(plan.targetAppPath, '/Users/alice/Applications/Happier- local-prod.app');
+});

package/scripts/utils/tauri/dev_runtime.mjs

@@ -19,6 +19,15 @@ function mergeTauriConfig(baseValue, overlayValue) {
   return out;
 }
 
+function applyHtml5FileDragDropWindowPolicy(config) {
+  if (!Array.isArray(config?.app?.windows)) return config;
+  config.app.windows = config.app.windows.map((windowConfig) => ({
+    ...windowConfig,
+    dragDropEnabled: false,
+  }));
+  return config;
+}
+
 export function resolveStackTauriDevUrl({ runtimeState, defaultPort = 8081 } = {}) {
   const expo = runtimeState && typeof runtimeState === 'object' ? runtimeState.expo : null;
   const port = Number(expo?.webPort ?? expo?.port ?? defaultPort);
@@ -41,5 +50,5 @@ export function buildStackTauriDevConfig({ baseConfig, overlayConfig, devUrl, en
   if (hasExplicitStackOverride) {
     applyStackTauriOverrides({ tauriConfig: merged, env });
   }
-  return merged;
+  return applyHtml5FileDragDropWindowPolicy(merged);
 }

package/scripts/utils/tauri/dev_runtime.test.mjs

@@ -31,7 +31,7 @@ test('buildStackTauriDevConfig disables beforeDevCommand and points Tauri at the
         externalBin: ['binaries/hsetup'],
       },
       app: {
-        windows: [{ title: 'Happier' }],
+        windows: [{ title: 'Happier', dragDropEnabled: false }],
       },
     },
     overlayConfig: {
@@ -52,6 +52,7 @@ test('buildStackTauriDevConfig disables beforeDevCommand and points Tauri at the
   assert.equal(config.build.beforeBuildCommand, '');
   assert.deepEqual(config.bundle.externalBin, ['binaries/hsetup']);
   assert.equal(config.app.windows[0]?.title, 'Happier (dev)');
+  assert.equal(config.app.windows[0]?.dragDropEnabled, false);
 });
 
 test('buildStackTauriDevConfig applies explicit stack overrides after merging configs', () => {

package/scripts/utils/tauri/stack_overrides.mjs

@@ -4,14 +4,38 @@ function getTrimmedEnv(env, key) {
   return String(raw).trim();
 }
 
+export function normalizeStackTauriSlug(rawValue) {
+  const slug = String(rawValue ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .replace(/-{2,}/g, '-');
+  return slug || '';
+}
+
+export function resolveStackTauriIdentity({ env = {}, baseProductName = 'Happier' } = {}) {
+  const stackSlug = normalizeStackTauriSlug(getTrimmedEnv(env, 'HAPPIER_STACK_STACK'));
+  const explicitIdentifier = getTrimmedEnv(env, 'HAPPIER_STACK_TAURI_IDENTIFIER');
+  const explicitProductName = getTrimmedEnv(env, 'HAPPIER_STACK_TAURI_PRODUCT_NAME');
+  const shouldScope = stackSlug && stackSlug !== 'main';
+  return {
+    stackSlug,
+    identifier: explicitIdentifier || (shouldScope ? `com.happier.stack.${stackSlug}` : 'com.happier.stack'),
+    productName: explicitProductName || (shouldScope ? `${baseProductName || 'Happier'} (${stackSlug})` : baseProductName || 'Happier'),
+  };
+}
+
 export function applyStackTauriOverrides({ tauriConfig, env }) {
-  const identifierOverride = getTrimmedEnv(env, 'HAPPIER_STACK_TAURI_IDENTIFIER');
-  const productNameOverride = getTrimmedEnv(env, 'HAPPIER_STACK_TAURI_PRODUCT_NAME');
   const createUpdaterArtifactsOverride = getTrimmedEnv(env, 'HAPPIER_STACK_TAURI_CREATE_UPDATER_ARTIFACTS');
   const signingPrivateKey = getTrimmedEnv(env, 'TAURI_SIGNING_PRIVATE_KEY');
+  const identity = resolveStackTauriIdentity({
+    env,
+    baseProductName: tauriConfig.productName || 'Happier',
+  });
 
-  tauriConfig.identifier = identifierOverride || 'com.happier.stack';
-  tauriConfig.productName = productNameOverride || tauriConfig.productName || 'Happier';
+  tauriConfig.identifier = identity.identifier;
+  tauriConfig.productName = identity.productName;
 
   if (tauriConfig.app?.windows?.length) {
     tauriConfig.app.windows = tauriConfig.app.windows.map((w) => ({

package/scripts/utils/tauri/stack_overrides.test.mjs

@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { applyStackTauriOverrides } from './stack_overrides.mjs';
+
+test('applyStackTauriOverrides derives stack-scoped app identity when no explicit override is provided', () => {
+  const config = applyStackTauriOverrides({
+    tauriConfig: {
+      productName: 'Happier',
+      identifier: 'dev.happier.app',
+      app: {
+        windows: [{ title: 'Happier' }],
+      },
+      bundle: {
+        createUpdaterArtifacts: true,
+      },
+    },
+    env: {
+      HAPPIER_STACK_STACK: 'local-prod',
+    },
+  });
+
+  assert.equal(config.identifier, 'com.happier.stack.local-prod');
+  assert.equal(config.productName, 'Happier (local-prod)');
+  assert.equal(config.app.windows[0]?.title, 'Happier (local-prod)');
+  assert.equal(config.bundle.createUpdaterArtifacts, false);
+});

package/scripts/utils/test/test_env.mjs

@@ -1,3 +1,5 @@
+import { join } from 'node:path';
+
 export function readBooleanEnvFlag(env, name, fallback = false) {
   const raw = env && typeof env === 'object' ? env[name] : undefined;
   const value = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
@@ -15,3 +17,45 @@ export function sanitizeDefinedEnv(env = {}) {
   }
   return cleanEnv;
 }
+
+const STACK_TEST_RUNNER_ENV_DENY_KEYS = new Set([
+  'HAPPIER_ACTIVE_SERVER_ID',
+  'HAPPIER_DAEMON_LIFECYCLE_SCOPE_ID',
+  'HAPPIER_DAEMON_SERVICE_LABEL',
+  'HAPPIER_DAEMON_STARTUP_SOURCE',
+  'HAPPIER_CLI_SUBPROCESS_DAEMON_DIST_CLOSURE_FINGERPRINT',
+  'HAPPIER_CLI_SUBPROCESS_DIST_ENTRYPOINT',
+  'HAPPIER_CLI_SUBPROCESS_RUNTIME_BACKED',
+  'HAPPIER_CLI_SUBPROCESS_STACK_RUNTIME_STATE_PATH',
+  'HAPPIER_HOME_DIR',
+  'HAPPIER_SERVER_URL',
+  'HAPPIER_WEBAPP_URL',
+]);
+const STACK_TEST_ISOLATED_ROOT_MARKER = 'HAPPIER_STACK_TEST_ISOLATED_ROOT';
+const STACK_TEST_REPO_DIR_MARKER = 'HAPPIER_STACK_TEST_REPO_DIR';
+
+export function sanitizeStackTestRunnerEnv(env = {}, { isolatedStackRoot = '', repoDir = '' } = {}) {
+  const cleanEnv = sanitizeDefinedEnv(env);
+  const inheritedIsolatedStackRoot = String(cleanEnv[STACK_TEST_ISOLATED_ROOT_MARKER] ?? '').trim();
+  const inheritedRepoDir = String(cleanEnv[STACK_TEST_REPO_DIR_MARKER] ?? '').trim();
+  for (const key of Object.keys(cleanEnv)) {
+    if (STACK_TEST_RUNNER_ENV_DENY_KEYS.has(key) || key.startsWith('HAPPIER_STACK_')) {
+      delete cleanEnv[key];
+    }
+  }
+  const root = String(isolatedStackRoot ?? '').trim() || inheritedIsolatedStackRoot;
+  if (root) {
+    cleanEnv[STACK_TEST_ISOLATED_ROOT_MARKER] = root;
+    cleanEnv.HAPPIER_STACK_CANONICAL_HOME_DIR = join(root, 'canonical-home');
+    cleanEnv.HAPPIER_STACK_HOME_DIR = join(root, 'home');
+    cleanEnv.HAPPIER_STACK_STORAGE_DIR = join(root, 'stacks');
+    cleanEnv.HAPPIER_STACK_WORKSPACE_DIR = join(root, 'workspace');
+    cleanEnv.HAPPIER_STACK_RUNTIME_DIR = join(root, 'runtime');
+  }
+  const repo = String(repoDir ?? '').trim() || inheritedRepoDir;
+  if (repo) {
+    cleanEnv[STACK_TEST_REPO_DIR_MARKER] = repo;
+    cleanEnv.HAPPIER_STACK_REPO_DIR = repo;
+  }
+  return cleanEnv;
+}

package/scripts/utils/test/test_env.test.mjs

@@ -0,0 +1,99 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { join } from 'node:path';
+
+import { sanitizeStackTestRunnerEnv } from './test_env.mjs';
+
+test('sanitizeStackTestRunnerEnv removes live stack and server scope from inherited test env', () => {
+  const env = sanitizeStackTestRunnerEnv({
+    PATH: '/bin',
+    HOME: '/Users/alice',
+    HAPPIER_STACK_STACK: 'repo-live',
+    HAPPIER_STACK_ENV_FILE: '/Users/alice/.happier/stacks/repo-live/env',
+    HAPPIER_STACK_SERVER_PORT: '52753',
+    HAPPIER_HOME_DIR: '/Users/alice/.happier/stacks/repo-live/cli',
+    HAPPIER_SERVER_URL: 'http://127.0.0.1:52753',
+    HAPPIER_WEBAPP_URL: 'http://happier-repo-live.localhost:18829',
+    HAPPIER_ACTIVE_SERVER_ID: 'stack_repo_live__id_default',
+    HAPPIER_DAEMON_LIFECYCLE_SCOPE_ID: 'stack_repo_live__id_default',
+    HAPPIER_CLI_SUBPROCESS_DIST_ENTRYPOINT: '/Users/alice/live-stack-repo/apps/cli/dist/index.mjs',
+    HAPPIER_CLI_SUBPROCESS_STACK_RUNTIME_STATE_PATH: '/Users/alice/.happier/stacks/repo-live/stack.runtime.json',
+    HAPPIER_CLI_SUBPROCESS_DAEMON_DIST_CLOSURE_FINGERPRINT: 'live-fingerprint',
+    HAPPIER_CLI_SUBPROCESS_RUNTIME_BACKED: '1',
+    HAPPIER_FEATURE_POLICY_ENV: '',
+    HAPPIER_TEST_FEATURES_DENY: 'voice',
+  });
+
+  assert.deepEqual(env, {
+    PATH: '/bin',
+    HOME: '/Users/alice',
+    HAPPIER_FEATURE_POLICY_ENV: '',
+    HAPPIER_TEST_FEATURES_DENY: 'voice',
+  });
+  assert.equal(env.HAPPIER_STACK_TEST_ISOLATED_ROOT, undefined);
+  assert.equal(env.HAPPIER_STACK_TEST_REPO_DIR, undefined);
+});
+
+test('sanitizeStackTestRunnerEnv can seed isolated stack roots for runner subprocesses', () => {
+  const env = sanitizeStackTestRunnerEnv(
+    {
+      PATH: '/bin',
+      HOME: '/Users/alice',
+      HAPPIER_STACK_CANONICAL_HOME_DIR: '/Users/alice/.happier-stack',
+      HAPPIER_STACK_HOME_DIR: '/Users/alice/.happier-stack',
+      HAPPIER_STACK_STORAGE_DIR: '/Users/alice/.happier/stacks',
+    },
+    {
+      isolatedStackRoot: '/tmp/happier-stack-test-root',
+    },
+  );
+
+  assert.equal(env.HAPPIER_STACK_HOME_DIR, '/tmp/happier-stack-test-root/home');
+  assert.equal(env.HAPPIER_STACK_STORAGE_DIR, '/tmp/happier-stack-test-root/stacks');
+  assert.equal(env.HAPPIER_STACK_WORKSPACE_DIR, '/tmp/happier-stack-test-root/workspace');
+  assert.equal(env.HAPPIER_STACK_RUNTIME_DIR, '/tmp/happier-stack-test-root/runtime');
+  assert.equal(env.HAPPIER_STACK_CANONICAL_HOME_DIR, '/tmp/happier-stack-test-root/canonical-home');
+  assert.equal(env.HOME, '/Users/alice');
+});
+
+test('sanitizeStackTestRunnerEnv can seed the repo checkout without restoring live stack scope', () => {
+  const env = sanitizeStackTestRunnerEnv(
+    {
+      PATH: '/bin',
+      HAPPIER_STACK_STACK: 'repo-live',
+      HAPPIER_STACK_REPO_DIR: '/Users/alice/live-stack-repo',
+    },
+    {
+      isolatedStackRoot: '/tmp/happier-stack-test-root',
+      repoDir: '/workspace/happier',
+    },
+  );
+
+  assert.equal(env.HAPPIER_STACK_STACK, undefined);
+  assert.equal(env.HAPPIER_STACK_REPO_DIR, '/workspace/happier');
+});
+
+test('sanitizeStackTestRunnerEnv preserves sanitizer-owned isolation across nested calls', () => {
+  const root = '/tmp/happier-stack-nested-root';
+  const first = sanitizeStackTestRunnerEnv(
+    {
+      HOME: '/Users/alice',
+      HAPPIER_STACK_CANONICAL_HOME_DIR: '/Users/alice/.happier-stack',
+      HAPPIER_STACK_HOME_DIR: '/Users/alice/.happier-stack',
+      HAPPIER_STACK_STORAGE_DIR: '/Users/alice/.happier/stacks',
+      HAPPIER_STACK_RUNTIME_DIR: '/Users/alice/.happier-stack/runtime',
+      HAPPIER_STACK_REPO_DIR: '/Users/alice/live-repo',
+    },
+    { isolatedStackRoot: root, repoDir: '/workspace/happier' },
+  );
+
+  const nested = sanitizeStackTestRunnerEnv(first);
+
+  assert.equal(nested.HAPPIER_STACK_CANONICAL_HOME_DIR, join(root, 'canonical-home'));
+  assert.equal(nested.HAPPIER_STACK_HOME_DIR, join(root, 'home'));
+  assert.equal(nested.HAPPIER_STACK_STORAGE_DIR, join(root, 'stacks'));
+  assert.equal(nested.HAPPIER_STACK_WORKSPACE_DIR, join(root, 'workspace'));
+  assert.equal(nested.HAPPIER_STACK_RUNTIME_DIR, join(root, 'runtime'));
+  assert.equal(nested.HAPPIER_STACK_REPO_DIR, '/workspace/happier');
+  assert.equal(nested.HOME, '/Users/alice');
+});

package/scripts/utils/tui/actions.mjs

@@ -6,17 +6,8 @@ export function buildTuiAuthArgs({ happysBin, stackName, force = false } = {}) {
   return [bin, 'stack', 'auth', name, 'login', ...(force ? ['--force'] : [])];
 }
 
-export function buildTuiDaemonStartArgs({ happysBin, stackName } = {}) {
-  const bin = String(happysBin ?? '').trim();
-  const name = String(stackName ?? '').trim();
-  if (!bin) throw new Error('buildTuiDaemonStartArgs: happysBin is required');
-  if (!name) throw new Error('buildTuiDaemonStartArgs: stackName is required');
-  return [bin, 'stack', 'daemon', name, 'start'];
+export function buildTuiAuthExitNotice({ code, signal } = {}) {
+  if (!signal && Number(code) === 0) return null;
+  const status = signal ? `signal=${signal}` : `code=${code ?? 'unknown'}`;
+  return `auth: failed (${status}); press a to retry or A to force re-authentication`;
 }
-
-export function shouldHoldAfterAuthExit({ code, signal } = {}) {
-  // Success should return immediately to the TUI. Failures should hold so users can read the error output.
-  if (signal) return true;
-  return Number(code) !== 0;
-}
-

package/scripts/utils/tui/actions.test.mjs

@@ -1,7 +1,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 
-import { buildTuiAuthArgs, buildTuiDaemonStartArgs, shouldHoldAfterAuthExit } from './actions.mjs';
+import { buildTuiAuthArgs, buildTuiAuthExitNotice } from './actions.mjs';
 
 test('buildTuiAuthArgs builds stack-scoped auth login args', () => {
   assert.deepEqual(buildTuiAuthArgs({ happysBin: 'bin/hstack.mjs', stackName: 'main', force: false }), [
@@ -21,19 +21,8 @@ test('buildTuiAuthArgs builds stack-scoped auth login args', () => {
   ]);
 });
 
-test('buildTuiDaemonStartArgs builds stack-scoped daemon start args', () => {
-  assert.deepEqual(buildTuiDaemonStartArgs({ happysBin: 'bin/hstack.mjs', stackName: 'main' }), [
-    'bin/hstack.mjs',
-    'stack',
-    'daemon',
-    'main',
-    'start',
-  ]);
+test('buildTuiAuthExitNotice reports failures in the TUI instead of holding stdin', () => {
+  assert.equal(buildTuiAuthExitNotice({ code: 0, signal: null }), null);
+  assert.match(buildTuiAuthExitNotice({ code: 1, signal: null }), /auth: failed.*code=1/);
+  assert.match(buildTuiAuthExitNotice({ code: 0, signal: 'SIGINT' }), /auth: failed.*signal=SIGINT/);
 });
-
-test('shouldHoldAfterAuthExit holds on failure but not on success', () => {
-  assert.equal(shouldHoldAfterAuthExit({ code: 0, signal: null }), false);
-  assert.equal(shouldHoldAfterAuthExit({ code: 1, signal: null }), true);
-  assert.equal(shouldHoldAfterAuthExit({ code: 0, signal: 'SIGINT' }), true);
-});
-

package/scripts/utils/tui/args.mjs

@@ -1,3 +1,5 @@
+import { findRestartControlOnlyArg } from '../stack/restart_args.mjs';
+
 export function isTuiHelpRequest(argv) {
   if (!Array.isArray(argv)) return false;
   if (argv.length === 1 && (argv[0] === '--help' || argv[0] === 'help')) return true;
@@ -19,10 +21,14 @@ export function normalizeTuiForwardedArgs(argv) {
 export function extractTuiLaunchOptions(argv) {
   const forwardedArgs = normalizeTuiForwardedArgs(argv);
   const withTauri = forwardedArgs.some((arg) => arg === '--tauri' || arg === '--with-tauri');
-  const childArgs = forwardedArgs.filter((arg) => arg !== '--tauri' && arg !== '--with-tauri');
+  const rescue = forwardedArgs.some((arg) => arg === '--rescue');
+  const childArgs = forwardedArgs.filter(
+    (arg) => arg !== '--tauri' && arg !== '--with-tauri' && arg !== '--rescue',
+  );
 
   return {
     forwardedArgs: childArgs.length > 0 ? childArgs : ['dev'],
+    rescue,
     withTauri,
   };
 }
@@ -56,5 +62,5 @@ export function isTuiStartLikeForwardedArgs(argv) {
 export function isTuiRestartableForwardedArgs(argv) {
   // Today we only support restart for long-lived stack processes (dev/start).
   // Keeping this as a separate predicate avoids expanding restart support by accident.
-  return isTuiStartLikeForwardedArgs(argv);
+  return isTuiStartLikeForwardedArgs(argv) && findRestartControlOnlyArg(argv) == null;
 }

package/scripts/utils/tui/args.test.mjs

@@ -26,20 +26,29 @@ test('normalizeTuiForwardedArgs preserves explicit args', () => {
 test('extractTuiLaunchOptions strips Tauri flags from child args and preserves forwarded commands', () => {
   assert.deepEqual(extractTuiLaunchOptions([]), {
     forwardedArgs: ['dev'],
+    rescue: false,
     withTauri: false,
   });
   assert.deepEqual(extractTuiLaunchOptions(['--tauri']), {
     forwardedArgs: ['dev'],
+    rescue: false,
     withTauri: true,
   });
   assert.deepEqual(extractTuiLaunchOptions(['--tauri', '--mobile']), {
     forwardedArgs: ['dev', '--mobile'],
+    rescue: false,
     withTauri: true,
   });
   assert.deepEqual(extractTuiLaunchOptions(['stack', 'dev', 'exp1', '--with-tauri']), {
     forwardedArgs: ['stack', 'dev', 'exp1'],
+    rescue: false,
     withTauri: true,
   });
+  assert.deepEqual(extractTuiLaunchOptions(['--rescue', '--mobile']), {
+    forwardedArgs: ['dev', '--mobile'],
+    rescue: true,
+    withTauri: false,
+  });
 });
 
 test('isTuiHelpRequest only matches explicit help', () => {
@@ -77,12 +86,16 @@ test('isTuiStartLikeForwardedArgs matches plain dev/start forms', () => {
   assert.equal(isTuiStartLikeForwardedArgs(['stop']), false);
 });
 
-test('isTuiRestartableForwardedArgs only allows restart for start-like commands', () => {
+test('isTuiRestartableForwardedArgs only allows long-lived start-like commands', () => {
   assert.equal(isTuiRestartableForwardedArgs(['stack', 'dev', 'x']), true);
   assert.equal(isTuiRestartableForwardedArgs(['stack', 'start', 'x']), true);
   assert.equal(isTuiRestartableForwardedArgs(['dev']), true);
   assert.equal(isTuiRestartableForwardedArgs(['start']), true);
 
+  assert.equal(isTuiRestartableForwardedArgs(['dev', '--json']), false);
+  assert.equal(isTuiRestartableForwardedArgs(['stack', 'start', 'x', '--json']), false);
+  assert.equal(isTuiRestartableForwardedArgs(['dev', '--help']), false);
+  assert.equal(isTuiRestartableForwardedArgs(['stack', 'start', 'x', '-h']), false);
   assert.equal(isTuiRestartableForwardedArgs(['stack', 'auth', 'x', 'login']), false);
   assert.equal(isTuiRestartableForwardedArgs(['stack', 'daemon', 'x', 'start']), false);
   assert.equal(isTuiRestartableForwardedArgs(['stack', 'summary', 'x']), false);

package/scripts/utils/tui/cleanup.mjs

@@ -13,9 +13,21 @@ async function readEnvObject(envPath) {
   }
 }
 
-export async function stopStackForTuiExit({ rootDir, stackName, json = false, noDocker = false, env: outerEnv = process.env }) {
+export async function stopStackForTuiExit({
+  rootDir,
+  stackName,
+  json = false,
+  noDocker = false,
+  env: outerEnv = process.env,
+  expectedRuntimeOwner = null,
+}) {
   const { envPath, baseDir } = resolveStackEnvPath(stackName, outerEnv);
   const stackEnv = await readEnvObject(envPath);
+  const expectedOwnerPid = Number(expectedRuntimeOwner?.ownerPid);
+  const expectedOwnerStartedAt = String(expectedRuntimeOwner?.startedAt ?? '').trim();
+  const hasExpectedRuntimeOwner = Number.isInteger(expectedOwnerPid)
+    && expectedOwnerPid > 1
+    && expectedOwnerStartedAt;
 
   const env = {
     ...(outerEnv ?? process.env),
@@ -34,5 +46,8 @@ export async function stopStackForTuiExit({ rootDir, stackName, json = false, no
     aggressive: false,
     sweepOwned: false,
     autoSweep: true,
+    ...(hasExpectedRuntimeOwner
+      ? { expectedOwnerPid, expectedOwnerStartedAt }
+      : {}),
   });
 }

package/scripts/utils/tui/daemon_pane_reconcile.mjs

@@ -5,6 +5,32 @@ function looksLikeDaemonAuthNoticeFirstLine(line) {
   return first === 'sign-in required' || first === 'daemon status pending' || first === 'daemon not running';
 }
 
+function normalizeDaemonPaneLine(line) {
+  return stripAnsi(String(line ?? ''))
+    .trim()
+    .replace(/^\[daemon\]\s*/i, '')
+    .toLowerCase();
+}
+
+function looksLikeStaleDaemonStartLine(line) {
+  const text = normalizeDaemonPaneLine(line);
+  return (
+    text === 'another running daemon is already using the selected relay.' ||
+    text === 'current release channel: unknown' ||
+    text === 'current cli version: unknown' ||
+    text === 'started by: unknown' ||
+    text.startsWith('stop the current daemon before starting another one.') ||
+    text.startsWith('exited (code=') ||
+    text.startsWith('daemon start failed before the relay came up;') ||
+    text.startsWith('installed background service conflict detected;')
+  );
+}
+
+function hasStaleDaemonStartLines(lines) {
+  if (!Array.isArray(lines)) return false;
+  return lines.slice(0, 12).some((line) => looksLikeStaleDaemonStartLine(line));
+}
+
 function looksLikeNoticeTitle(title) {
   const t = String(title ?? '').trim();
   return (
@@ -34,7 +60,7 @@ export function reconcileDaemonPaneAfterDaemonStarts({ title, lines, daemonPid,
 
   const nextTitle = looksLikeNoticeTitle(title) ? 'daemon (RUNNING)' : title;
   const hasNoticeFirstLine = looksLikeDaemonAuthNoticeFirstLine(Array.isArray(lines) ? lines[0] : '');
-  if (!hasNoticeFirstLine) {
+  if (!hasNoticeFirstLine && !hasStaleDaemonStartLines(lines)) {
     return { title: nextTitle, lines };
   }
 

package/scripts/utils/tui/daemon_pane_reconcile.test.mjs

@@ -43,3 +43,21 @@ test('reconcileDaemonPaneAfterDaemonStarts clears stale notice when caller knows
   assert.equal(out.title, 'daemon (RUNNING)');
   assert.deepEqual(out.lines, ['Daemon is running']);
 });
+
+test('reconcileDaemonPaneAfterDaemonStarts clears stale start-conflict output after daemon recovers', () => {
+  const out = reconcileDaemonPaneAfterDaemonStarts({
+    title: 'daemon (NOT RUNNING)',
+    lines: [
+      '[daemon] Current release channel: unknown',
+      '[daemon] Current CLI version: unknown',
+      '[daemon] Stop the current daemon before starting another one.',
+      '[daemon] exited (code=1, sig=null)',
+      '[daemon] Another running daemon is already using the selected relay.',
+      '[daemon] daemon start failed before the relay came up; keeping TUI running.',
+    ],
+    daemonPid: 10874,
+    daemonRunning: true,
+  });
+  assert.equal(out.title, 'daemon (RUNNING)');
+  assert.deepEqual(out.lines, ['Daemon is running', 'PID: 10874']);
+});

package/scripts/utils/tui/dev_target_panes.mjs

@@ -0,0 +1,22 @@
+function paneToken(name) {
+  return String(name ?? '').trim().toLowerCase().replace(/[^a-z0-9._-]+/g, '-');
+}
+
+export function createDevTargetPaneSpecs(targets) {
+  if (!Array.isArray(targets) || targets.length === 0) return [];
+  return [
+    { id: 'mutagen', title: 'mutagen sync', visible: true, kind: 'log' },
+    ...targets.map((target) => {
+      const name = paneToken(target.name);
+      return { id: `remote-${name}`, title: `remote ${name}`, visible: true, kind: 'log' };
+    }),
+  ];
+}
+
+export function routeDevTargetLogPaneId(normalizedLabel, configuredTargetNames) {
+  const label = String(normalizedLabel ?? '').trim().toLowerCase();
+  if (label === 'mutagen') return 'mutagen';
+  if (!label.startsWith('remote:')) return null;
+  const targetName = paneToken(label.slice('remote:'.length));
+  return configuredTargetNames?.has(targetName) ? `remote-${targetName}` : null;
+}