@happier-dev/stack 0.1.0-preview.74.1

package/scripts/stack_stop_sweeps_when_runtime_missing.integration.test.mjs

@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { isAlive, setupStackStopSweepFixture, spawnOwnedSleep, waitForProcessAlive, waitForProcessExit } from './testkit/stack_stop_sweeps_testkit.mjs';
+
+test('hstack stack stop sweeps owned processes when stack.runtime.json is missing', async (t) => {
+  const fixture = await setupStackStopSweepFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'hstack-stack-stop-sweep-',
+  });
+
+  const owned = fixture.trackChild(spawnOwnedSleep({
+    env: {
+      ...process.env,
+      HAPPIER_STACK_STACK: fixture.stackName,
+      HAPPIER_STACK_ENV_FILE: fixture.envPath,
+      HAPPIER_STACK_PROCESS_KIND: 'infra',
+    },
+  }));
+  assert.ok(Number(owned.pid) > 1, 'expected child pid');
+  await waitForProcessAlive({ pid: owned.pid, timeoutMs: 2_000, intervalMs: 25, label: 'infra process (pre-stop)' });
+  assert.ok(isAlive(owned.pid), 'expected owned child to be alive');
+
+  const sessionLike = fixture.trackChild(spawnOwnedSleep({
+    env: {
+      ...process.env,
+      HAPPIER_STACK_STACK: fixture.stackName,
+      HAPPIER_STACK_ENV_FILE: fixture.envPath,
+      HAPPIER_STACK_PROCESS_KIND: 'session',
+    },
+  }));
+  assert.ok(Number(sessionLike.pid) > 1, 'expected session-like child pid');
+  await waitForProcessAlive({ pid: sessionLike.pid, timeoutMs: 2_000, intervalMs: 25, label: 'session-like process (pre-stop)' });
+  assert.ok(isAlive(sessionLike.pid), 'expected session-like child to be alive');
+
+  const res = await fixture.runStackStop(['--json']);
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  await waitForProcessExit({ pid: owned.pid, timeoutMs: 10_000, intervalMs: 50, label: 'infra process' });
+  assert.ok(!isAlive(owned.pid), `expected owned pid ${owned.pid} to be stopped`);
+  assert.ok(isAlive(sessionLike.pid), `expected session-like pid ${sessionLike.pid} to still be alive`);
+});

package/scripts/stack_stop_sweeps_when_runtime_stale.integration.test.mjs

@@ -0,0 +1,50 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { isAlive, setupStackStopSweepFixture, spawnOwnedSleep, waitForProcessAlive, waitForProcessExit } from './testkit/stack_stop_sweeps_testkit.mjs';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+test('hstack stack stop sweeps infra when stack.runtime.json exists but ownerPid is stale', async (t) => {
+  const fixture = await setupStackStopSweepFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'hstack-stack-stop-sweep-stale-',
+  });
+
+  await writeFile(
+    join(fixture.baseDir, 'stack.runtime.json'),
+    JSON.stringify({ version: 1, stackName: fixture.stackName, ownerPid: 999999, processes: {} }),
+    'utf-8'
+  );
+
+  const infra = fixture.trackChild(spawnOwnedSleep({
+    env: {
+      ...process.env,
+      HAPPIER_STACK_STACK: fixture.stackName,
+      HAPPIER_STACK_ENV_FILE: fixture.envPath,
+      HAPPIER_STACK_PROCESS_KIND: 'infra',
+    },
+  }));
+  assert.ok(Number(infra.pid) > 1, 'expected infra pid');
+  await waitForProcessAlive({ pid: infra.pid, timeoutMs: 2_000, intervalMs: 25, label: 'infra process (pre-stop)' });
+  assert.ok(isAlive(infra.pid), 'expected infra child to be alive');
+
+  const sessionLike = fixture.trackChild(spawnOwnedSleep({
+    env: {
+      ...process.env,
+      HAPPIER_STACK_STACK: fixture.stackName,
+      HAPPIER_STACK_ENV_FILE: fixture.envPath,
+      HAPPIER_STACK_PROCESS_KIND: 'session',
+    },
+  }));
+  assert.ok(Number(sessionLike.pid) > 1, 'expected session-like child pid');
+  await waitForProcessAlive({ pid: sessionLike.pid, timeoutMs: 2_000, intervalMs: 25, label: 'session-like process (pre-stop)' });
+  assert.ok(isAlive(sessionLike.pid), 'expected session-like child to be alive');
+
+  const res = await fixture.runStackStop(['--json']);
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  await waitForProcessExit({ pid: infra.pid, timeoutMs: 10_000, intervalMs: 50, label: 'infra process (stale runtime)' });
+  assert.ok(!isAlive(infra.pid), `expected infra pid ${infra.pid} to be stopped`);
+  assert.ok(isAlive(sessionLike.pid), `expected session-like pid ${sessionLike.pid} to still be alive`);
+});

package/scripts/stack_wt_list.test.mjs

@@ -0,0 +1,117 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { runNodeCapture } from './testkit/stack_script_command_testkit.mjs';
+
+async function touchWorktree(dir) {
+  await mkdir(dir, { recursive: true });
+  // In a git worktree, ".git" is often a file; our detection treats either file or dir as truthy.
+  await writeFile(join(dir, '.git'), 'gitdir: /dev/null\n', 'utf-8');
+}
+
+async function setupStackWtListFixture({ importMetaUrl, t, tmpPrefix }) {
+  const scriptsDir = dirname(fileURLToPath(importMetaUrl));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), tmpPrefix));
+
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true }).catch(() => {});
+  });
+
+  const storageDir = join(tmp, 'storage');
+  const homeDir = join(tmp, 'home');
+  const workspaceDir = join(tmp, 'workspace');
+  const stackName = 'exp-test';
+
+  const wtRoot = join(workspaceDir, 'pr');
+  const monoActive = join(wtRoot, 'active-branch');
+  const monoOther = join(wtRoot, 'other-branch');
+  await touchWorktree(monoActive);
+  await touchWorktree(monoOther);
+
+  for (const monorepoRoot of [monoActive, monoOther]) {
+    await mkdir(join(monorepoRoot, 'apps', 'ui'), { recursive: true });
+    await mkdir(join(monorepoRoot, 'apps', 'cli'), { recursive: true });
+    await mkdir(join(monorepoRoot, 'apps', 'server'), { recursive: true });
+    await writeFile(join(monorepoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monorepoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monorepoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+  }
+
+  const envDir = join(storageDir, stackName);
+  const envPath = join(envDir, 'env');
+  await mkdir(envDir, { recursive: true });
+  await writeFile(
+    envPath,
+    [
+      `HAPPIER_STACK_STACK=${stackName}`,
+      `HAPPIER_STACK_REPO_DIR=${monoActive}`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  const baseEnv = {
+    ...process.env,
+    // Prevent loading the user's real ~/.happier-stack/.env via canonical discovery.
+    HAPPIER_STACK_HOME_DIR: homeDir,
+    HAPPIER_STACK_STORAGE_DIR: storageDir,
+    HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+  };
+
+  async function runStackWtList(extraArgs = []) {
+    return await runNodeCapture([join(rootDir, 'scripts', 'stack.mjs'), 'wt', stackName, '--', 'list', ...extraArgs], {
+      cwd: rootDir,
+      env: baseEnv,
+    });
+  }
+
+  return {
+    monoActive,
+    monoOther,
+    runStackWtList,
+  };
+}
+
+test('hstack stack wt <stack> -- list defaults to active-only (no exhaustive enumeration)', async (t) => {
+  const fixture = await setupStackWtListFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'happy-stacks-stack-wt-list-',
+  });
+
+  const res = await fixture.runStackWtList();
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  assert.ok(
+    res.stdout.includes(`- active: ${fixture.monoActive}`),
+    `expected happy active in output\n${res.stdout}`
+  );
+
+  // Should NOT enumerate other worktrees unless --all was passed.
+  assert.ok(!res.stdout.includes(`- ${fixture.monoOther}`), `expected other to be omitted\n${res.stdout}`);
+});
+
+test('hstack stack wt <stack> -- list --all shows all worktrees (opt-in)', async (t) => {
+  const fixture = await setupStackWtListFixture({
+    importMetaUrl: import.meta.url,
+    t,
+    tmpPrefix: 'happy-stacks-stack-wt-list-all-',
+  });
+
+  const res = await fixture.runStackWtList(['--all']);
+  assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+
+  assert.ok(
+    res.stdout.includes(`- active: ${fixture.monoActive}`),
+    `expected happy active in output\n${res.stdout}`
+  );
+  assert.ok(
+    res.stdout.includes(`- ${fixture.monoOther}`),
+    `expected happy other to be listed with --all\n${res.stdout}`
+  );
+});

package/scripts/start_ui_required_default.test.mjs

@@ -0,0 +1,63 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function runNode(args, { cwd, env }) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(process.execPath, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => (stdout += String(d)));
+    proc.stderr.on('data', (d) => (stderr += String(d)));
+    proc.on('error', reject);
+    proc.on('exit', (code, signal) => resolve({ code, signal, stdout, stderr }));
+  });
+}
+
+test('hstack start fails closed when UI serving is enabled and index.html is missing (default uiRequired)', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-start-ui-required-'));
+  try {
+    const monoRoot = join(tmp, 'happier');
+
+    await mkdir(join(monoRoot, 'apps', 'ui'), { recursive: true });
+    await mkdir(join(monoRoot, 'apps', 'cli'), { recursive: true });
+    await mkdir(join(monoRoot, 'apps', 'server'), { recursive: true });
+    await writeFile(join(monoRoot, 'apps', 'ui', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monoRoot, 'apps', 'cli', 'package.json'), '{}\n', 'utf-8');
+    await writeFile(join(monoRoot, 'apps', 'server', 'package.json'), '{}\n', 'utf-8');
+
+    const uiBuildDir = join(tmp, 'ui');
+    await mkdir(uiBuildDir, { recursive: true });
+    await writeFile(join(uiBuildDir, 'canvaskit.wasm'), 'stub\n', 'utf-8');
+
+    const env = {
+      ...process.env,
+      HAPPIER_STACK_REPO_DIR: monoRoot,
+      HAPPIER_STACK_SERVE_UI: '1',
+      HAPPIER_STACK_UI_BUILD_DIR: uiBuildDir,
+      // Ensure we do not spawn real services during this test.
+      HAPPIER_STACK_CLI_ROOT_DISABLE: '1',
+      HAPPIER_STACK_TAILSCALE_SERVE: '0',
+    };
+
+    const res = await runNode([join(rootDir, 'scripts', 'run.mjs'), '--json'], { cwd: rootDir, env });
+    assert.ok(
+      res.code === 0 && !res.signal,
+      `sanity: --json should exit cleanly\ncode: ${res.code}\nsignal: ${res.signal}\nstderr:\n${res.stderr}`
+    );
+
+    const res2 = await runNode([join(rootDir, 'scripts', 'run.mjs')], { cwd: rootDir, env });
+    assert.ok(res2.code !== 0 || Boolean(res2.signal), `expected non-zero exit\ncode: ${res2.code}\nsignal: ${res2.signal}`);
+    assert.match(res2.stderr + res2.stdout, /index\.html/i);
+    assert.match(res2.stderr + res2.stdout, /hstack build/i);
+  } finally {
+    await rm(tmp, { recursive: true, force: true });
+  }
+});

package/scripts/stop.mjs

@@ -0,0 +1,190 @@
+import './utils/env/env.mjs';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+import { parseArgs } from './utils/cli/args.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { run, runCapture } from './utils/proc/proc.mjs';
+import { getRootDir, resolveStackEnvPath } from './utils/paths/paths.mjs';
+import { banner, bullets, cmd, kv, sectionTitle } from './utils/ui/layout.mjs';
+import { dim, green, yellow } from './utils/ui/ansi.mjs';
+
+function usage() {
+  return [
+    '',
+    banner('stop', { subtitle: 'Stop stacks safely (bulk).' }),
+    '',
+    sectionTitle('Usage'),
+    bullets([
+      `${dim('stop all (non-interactive):')} ${cmd('hstack stop --yes')}`,
+      `${dim('exclude some stacks:')} ${cmd('hstack stop --except-stacks=main,exp1 --yes')}`,
+      `${dim('aggressive:')} ${cmd('hstack stop --yes --aggressive')} ${dim('(also stops daemon-tracked sessions)')}`,
+      `${dim('sweep-owned:')} ${cmd('hstack stop --yes --sweep-owned')} ${dim('(final owned-process sweep)')}`,
+      `${dim('no docker:')} ${cmd('hstack stop --yes --no-docker')}`,
+      `${dim('no service:')} ${cmd('hstack stop --yes --no-service')}`,
+      `${dim('json:')} ${cmd('hstack stop --yes --json')}`,
+    ]),
+    '',
+    sectionTitle('What it does'),
+    bullets([dim('Stops stacks and related local processes (server, daemon, Expo, managed infra) using stack-scoped commands.')]),
+  ].join('\n');
+}
+
+function parseCsv(raw) {
+  const s = String(raw ?? '').trim();
+  if (!s) return [];
+  return s
+    .split(',')
+    .map((p) => p.trim())
+    .filter(Boolean);
+}
+
+async function listAllStackNames() {
+  try {
+    // Reuse stack.mjs for enumeration (avoids duplicating legacy/new stack dir logic).
+    // Note: `stack list` intentionally omits `main`, so we add it back.
+    const rootDir = getRootDir(import.meta.url);
+    const out = await runCapture(process.execPath, [join(rootDir, 'scripts', 'stack.mjs'), 'list', '--json'], { cwd: rootDir });
+    const parsed = JSON.parse(out);
+    const stacks = Array.isArray(parsed?.stacks) ? parsed.stacks : [];
+    const all = ['main', ...stacks.filter((s) => s !== 'main')];
+    return all.sort();
+  } catch {
+    return ['main'];
+  }
+}
+
+async function main() {
+  const rootDir = getRootDir(import.meta.url);
+  const argv = process.argv.slice(2);
+  const { flags, kv } = parseArgs(argv);
+  const json = wantsJson(argv, { flags });
+
+  if (wantsHelp(argv, { flags })) {
+    printResult({ json, data: { ok: true }, text: usage() });
+    return;
+  }
+
+  const exceptStacks = new Set(parseCsv(kv.get('--except-stacks')));
+  const yes = flags.has('--yes');
+  const aggressive = flags.has('--aggressive');
+  const sweepOwned = flags.has('--sweep-owned');
+  const noDocker = flags.has('--no-docker');
+  const noService = flags.has('--no-service');
+
+  const stacks = await listAllStackNames();
+  const targets = stacks.filter((n) => !exceptStacks.has(n));
+
+  if (!targets.length) {
+    printResult({ json, data: { ok: true, stopped: [], skipped: stacks }, text: '[stop] nothing to do (all stacks excluded)' });
+    return;
+  }
+
+  if (!yes && !(process.stdin.isTTY && process.stdout.isTTY)) {
+    throw new Error('[stop] refusing to stop stacks without --yes in non-interactive mode');
+  }
+
+  if (!yes) {
+    // Simple confirm prompt (avoid importing wizard/rl here).
+    // eslint-disable-next-line no-console
+    console.log('');
+    console.log(banner('stop', { subtitle: 'Confirmation required (TTY).' }));
+    console.log('');
+    console.log(sectionTitle('Will stop'));
+    console.log(bullets([kv('stacks:', targets.join(', '))]));
+    console.log('');
+    console.log(sectionTitle('Proceed'));
+    // eslint-disable-next-line no-console
+    console.log(bullets([`${dim('re-run:')} ${cmd('hstack stop --yes')}`]));
+    process.exit(1);
+  }
+
+  const results = [];
+  const errors = [];
+  const skipped = [];
+
+  for (const stackName of targets) {
+    if (stackName !== 'main') {
+      const { envPath } = resolveStackEnvPath(stackName);
+      // Stack name might appear in directory listings, but if it has no env file, treat it as non-existent.
+      if (!existsSync(envPath)) {
+        skipped.push({ stackName, reason: 'missing_env', envPath });
+        continue;
+      }
+    }
+    try {
+      if (!noService) {
+        // Best-effort: stop autostart service for the stack so it doesn't restart what we just stopped.
+        // eslint-disable-next-line no-await-in-loop
+        await run(process.execPath, [join(rootDir, 'scripts', 'stack.mjs'), 'service', stackName, 'stop'], { cwd: rootDir }).catch(() => {});
+      }
+
+      const args = [
+        join(rootDir, 'scripts', 'stack.mjs'),
+        'stop',
+        stackName,
+        ...(aggressive ? ['--aggressive'] : []),
+        ...(sweepOwned ? ['--sweep-owned'] : []),
+        ...(noDocker ? ['--no-docker'] : []),
+      ];
+      if (json) {
+        // eslint-disable-next-line no-await-in-loop
+        const out = await runCapture(process.execPath, [...args, '--json'], { cwd: rootDir });
+        results.push({ stackName, out: JSON.parse(out) });
+      } else {
+        // eslint-disable-next-line no-await-in-loop
+        await run(process.execPath, args, { cwd: rootDir });
+        results.push({ stackName, ok: true });
+      }
+    } catch (e) {
+      errors.push({ stackName, error: e instanceof Error ? e.message : String(e) });
+    }
+  }
+
+  if (json) {
+    printResult({
+      json,
+      data: { ok: errors.length === 0, stopped: results, skipped, errors, exceptStacks: Array.from(exceptStacks) },
+    });
+    return;
+  }
+
+  // eslint-disable-next-line no-console
+  console.log('');
+  // eslint-disable-next-line no-console
+  console.log(banner('stop', { subtitle: 'Complete.' }));
+  // eslint-disable-next-line no-console
+  console.log(
+    bullets([
+      kv('stopped:', String(results.length)),
+      kv('skipped:', String(skipped.length)),
+      kv('errors:', String(errors.length)),
+    ])
+  );
+  if (skipped.length) {
+    // eslint-disable-next-line no-console
+    console.log('');
+    // eslint-disable-next-line no-console
+    console.log(sectionTitle('Skipped'));
+    for (const s of skipped) {
+      // eslint-disable-next-line no-console
+      console.log(`- ${s.stackName}: ${s.reason}${s.envPath ? ` ${dim(`(${s.envPath})`)}` : ''}`);
+    }
+  }
+  if (errors.length) {
+    // eslint-disable-next-line no-console
+    console.log('');
+    // eslint-disable-next-line no-console
+    console.log(sectionTitle('Errors'));
+    for (const e of errors) {
+      // eslint-disable-next-line no-console
+      console.warn(`- ${e.stackName}: ${e.error}`);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error('[stop] failed:', err);
+  process.exit(1);
+});
+

package/scripts/stopStackWithEnv_no_autosweep_when_runtime_missing.integration.test.mjs

@@ -0,0 +1,95 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { stopStackWithEnv } from './utils/stack/stop.mjs';
+import { isAlive, spawnOwnedSleep, waitForProcessAlive } from './testkit/stack_stop_sweeps_testkit.mjs';
+
+test('stopStackWithEnv does not auto-sweep when autoSweep=false and stack.runtime.json is missing', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+
+  const tmp = await mkdtemp(join(tmpdir(), 'hstack-stop-no-autosweep-'));
+  const homeDir = join(tmp, 'home');
+  const storageDir = join(tmp, 'storage');
+  const workspaceDir = join(tmp, 'workspace');
+  const repoDir = dirname(rootDir);
+
+  await mkdir(homeDir, { recursive: true });
+  await mkdir(storageDir, { recursive: true });
+  await mkdir(workspaceDir, { recursive: true });
+
+  const stackName = 'exp1';
+  const baseDir = join(storageDir, stackName);
+  const envPath = join(baseDir, 'env');
+  await mkdir(baseDir, { recursive: true });
+
+  await writeFile(
+    envPath,
+    [
+      `HAPPIER_STACK_STACK=${stackName}`,
+      `HAPPIER_STACK_SERVER_COMPONENT=happier-server-light`,
+      `HAPPIER_STACK_UI_BUILD_DIR=${join(baseDir, 'ui')}`,
+      `HAPPIER_STACK_CLI_HOME_DIR=${join(baseDir, 'cli')}`,
+      `HAPPIER_STACK_REPO_DIR=${repoDir}`,
+      '',
+    ].join('\n'),
+    'utf-8'
+  );
+
+  /** @type {ReturnType<typeof spawnOwnedSleep> | null} */
+  let owned = null;
+  t.after(async () => {
+    const pid = owned?.pid;
+    if (pid) {
+      try {
+        process.kill(-pid, 'SIGKILL');
+      } catch {
+        // ignore
+      }
+    }
+
+    try {
+      await rm(tmp, { recursive: true, force: true });
+    } catch {
+      // ignore
+    }
+  });
+
+  owned = spawnOwnedSleep({
+    env: {
+      ...process.env,
+      HAPPIER_STACK_STACK: stackName,
+      HAPPIER_STACK_ENV_FILE: envPath,
+    },
+  });
+  assert.ok(Number(owned.pid) > 1, 'expected child pid');
+  assert.ok(isAlive(owned.pid), 'expected owned child to be alive');
+
+  const actions = await stopStackWithEnv({
+    rootDir,
+    stackName,
+    baseDir,
+    env: {
+      ...process.env,
+      HAPPIER_STACK_STACK: stackName,
+      HAPPIER_STACK_ENV_FILE: envPath,
+      HAPPIER_STACK_REPO_DIR: repoDir,
+      HAPPIER_STACK_HOME_DIR: homeDir,
+      HAPPIER_STACK_STORAGE_DIR: storageDir,
+      HAPPIER_STACK_WORKSPACE_DIR: workspaceDir,
+    },
+    json: true,
+    noDocker: true,
+    aggressive: false,
+    sweepOwned: false,
+    autoSweep: false,
+  });
+
+  assert.ok(!actions?.sweep, 'expected no sweep field when autoSweep=false');
+  await waitForProcessAlive({ pid: owned.pid, timeoutMs: 2_000, intervalMs: 25, label: 'owned process (no autosweep)' });
+  assert.ok(isAlive(owned.pid), `expected owned pid ${owned.pid} to still be alive`);
+});

package/scripts/swiftbar_git_monorepo_cmd.test.mjs

@@ -0,0 +1,75 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function run(cmd, args, { cwd, env } = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(cmd, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => (stdout += String(d)));
+    proc.stderr.on('data', (d) => (stderr += String(d)));
+    proc.on('error', reject);
+    proc.on('exit', (code, signal) => resolve({ code: code ?? (signal ? 1 : 0), signal: signal ?? null, stdout, stderr }));
+  });
+}
+
+async function runOrThrow(cmd, args, { cwd, env } = {}) {
+  const res = await run(cmd, args, { cwd, env });
+  assert.equal(res.code, 0, `${cmd} ${args.join(' ')} failed\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+  return res;
+}
+
+test('swiftbar git cache treats monorepo package dirs as git repos', async (t) => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const rootDir = dirname(scriptsDir);
+  const tmp = await mkdtemp(join(tmpdir(), 'happier-stack-swiftbar-git-'));
+  t.after(async () => {
+    await rm(tmp, { recursive: true, force: true }).catch(() => {});
+  });
+
+  const repoRoot = join(tmp, 'repo');
+  await mkdir(repoRoot, { recursive: true });
+  await mkdir(join(repoRoot, 'apps', 'ui'), { recursive: true });
+  await writeFile(join(repoRoot, 'apps', 'ui', 'README.md'), 'hello\n', 'utf-8');
+
+  // Create a minimal git repo with one commit.
+  await runOrThrow('git', ['init'], { cwd: repoRoot });
+  await runOrThrow('git', ['add', '.'], { cwd: repoRoot });
+  await runOrThrow(
+    'git',
+    ['-c', 'user.name=test', '-c', 'user.email=test@example.com', 'commit', '-m', 'init'],
+    { cwd: repoRoot }
+  );
+
+  const stacksHome = join(tmp, 'happier-stack-home');
+  const env = {
+    ...process.env,
+    HAPPIER_STACK_HOME_DIR: stacksHome,
+    HAPPIER_STACK_CANONICAL_HOME_DIR: stacksHome,
+  };
+
+  const bashScript = [
+    `set -euo pipefail`,
+    `source "${rootDir}/extras/swiftbar/lib/utils.sh"`,
+    `source "${rootDir}/extras/swiftbar/lib/git.sh"`,
+    `active_dir="${repoRoot}/apps/ui"`,
+    `git_cache_refresh_one main main happier "$active_dir" >/dev/null 2>&1 || true`,
+    `key="$(git_cache_key main main happier "$active_dir")"`,
+    `IFS=$'\\t' read -r meta info wts <<<"$(git_cache_paths "$key")"`,
+    `if [[ ! -f "$info" ]]; then echo "missing-info"; exit 2; fi`,
+    `head -n 1 "$info"`,
+  ].join('\n');
+
+  const res = await run('bash', ['-lc', bashScript], { env });
+  assert.equal(
+    res.code,
+    0,
+    `expected bash exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`
+  );
+  assert.match(res.stdout, /^ok\t/, `expected info.tsv to start with ok\\t, got:\n${res.stdout}`);
+});