happy-stacks 0.6.11 → 0.6.13

package/scripts/utils/review/runners/coderabbit.test.mjs

@@ -1,59 +1,26 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { join } from 'node:path';
 
-import { buildCodeRabbitEnv, buildCodeRabbitReviewArgs } from './coderabbit.mjs';
+import { parseCodeRabbitRateLimitRetryMs } from './coderabbit.mjs';
 
-test('buildCodeRabbitReviewArgs builds committed review args by default', () => {
-  const repoDir = '/tmp/repo';
-  const args = buildCodeRabbitReviewArgs({ repoDir, baseRef: 'upstream/main', type: undefined, configFiles: [] });
-  assert.deepEqual(args, ['review', '--plain', '--no-color', '--type', 'committed', '--cwd', repoDir, '--base', 'upstream/main']);
+test('parseCodeRabbitRateLimitRetryMs returns null when no rate limit message is present', () => {
+  assert.equal(parseCodeRabbitRateLimitRetryMs('Review completed ✔'), null);
 });
 
-test('buildCodeRabbitReviewArgs uses --base-commit when provided', () => {
-  const repoDir = '/tmp/repo';
-  const args = buildCodeRabbitReviewArgs({ repoDir, baseCommit: 'abc123', type: 'committed', configFiles: [] });
-  assert.deepEqual(args, ['review', '--plain', '--no-color', '--type', 'committed', '--cwd', repoDir, '--base-commit', 'abc123']);
-});
-
-test('buildCodeRabbitReviewArgs rejects providing both baseRef and baseCommit', () => {
-  assert.throws(
-    () => buildCodeRabbitReviewArgs({ repoDir: '/tmp/repo', baseRef: 'upstream/main', baseCommit: 'abc123', type: 'committed', configFiles: [] }),
-    /mutually exclusive/
+test('parseCodeRabbitRateLimitRetryMs parses the suggested retry delay', () => {
+  const ms = parseCodeRabbitRateLimitRetryMs(
+    '[2026-01-25T22:29:41.623Z] ❌ ERROR: Error: Rate limit exceeded, please try after 3 minutes and 2 seconds'
   );
+  assert.ok(ms);
+  // Allow +1s padding.
+  assert.equal(ms, (3 * 60 + 2 + 1) * 1000);
 });
 
-test('buildCodeRabbitReviewArgs includes --config when files are provided', () => {
-  const repoDir = '/tmp/repo';
-  const args = buildCodeRabbitReviewArgs({
-    repoDir,
-    baseRef: 'upstream/main',
-    type: 'committed',
-    configFiles: ['/tmp/a.md', '/tmp/b.md'],
-  });
-  assert.deepEqual(args, [
-    'review',
-    '--plain',
-    '--no-color',
-    '--type',
-    'committed',
-    '--cwd',
-    repoDir,
-    '--base',
-    'upstream/main',
-    '--config',
-    '/tmp/a.md',
-    '/tmp/b.md',
-  ]);
+test('parseCodeRabbitRateLimitRetryMs supports seconds-only windows', () => {
+  const ms = parseCodeRabbitRateLimitRetryMs(
+    '[2026-01-26T00:27:23.067Z] ❌ ERROR: Error: Rate limit exceeded, please try after 0 minutes and 31 seconds'
+  );
+  assert.ok(ms);
+  assert.equal(ms, (31 + 1) * 1000);
 });
 
-test('buildCodeRabbitEnv overrides HOME/XDG paths when a homeDir is provided', () => {
-  const env = buildCodeRabbitEnv({ env: { PATH: '/bin' }, homeDir: '/tmp/cr-home' });
-  assert.equal(env.PATH, '/bin');
-  assert.equal(env.HOME, '/tmp/cr-home');
-  assert.equal(env.CODERABBIT_HOME, join('/tmp/cr-home', '.coderabbit'));
-  assert.equal(env.XDG_CONFIG_HOME, join('/tmp/cr-home', '.config'));
-  assert.equal(env.XDG_CACHE_HOME, join('/tmp/cr-home', '.cache'));
-  assert.equal(env.XDG_STATE_HOME, join('/tmp/cr-home', '.local', 'state'));
-  assert.equal(env.XDG_DATA_HOME, join('/tmp/cr-home', '.local', 'share'));
-});

package/scripts/utils/review/sliced_runner.mjs

@@ -0,0 +1,39 @@
+import { runWithConcurrencyLimit } from '../proc/parallel.mjs';
+
+/**
+ * Run a list of "slice jobs" with:
+ * - a mandatory sequential first job (preflight)
+ * - parallel execution for the remainder (bounded by `limit`)
+ * - stable, input-order results
+ * - optional early-abort after the first job (e.g. auth/credits missing)
+ */
+export async function runSlicedJobs({ items, limit = 1, run, shouldAbortEarly } = {}) {
+  const list = Array.isArray(items) ? items : [];
+  if (!list.length) return [];
+  if (typeof run !== 'function') throw new Error('[review] runSlicedJobs: missing run()');
+
+  const concurrency = Number.isFinite(limit) && limit > 0 ? Math.floor(limit) : 1;
+
+  const out = [];
+  // Always run the first item sequentially so we can fail fast on auth/credits problems
+  // before spinning up many long-running review jobs.
+  // eslint-disable-next-line no-await-in-loop
+  const firstRes = await run(list[0]);
+  out.push(firstRes);
+  if (typeof shouldAbortEarly === 'function' && shouldAbortEarly(firstRes)) {
+    return out;
+  }
+
+  if (list.length === 1) return out;
+
+  const rest = list.slice(1);
+  const restRes = await runWithConcurrencyLimit({
+    items: rest,
+    limit: concurrency,
+    fn: async (item) => await run(item),
+  });
+
+  // Preserve input order.
+  return [...out, ...restRes];
+}
+

package/scripts/utils/review/sliced_runner.test.mjs

@@ -0,0 +1,47 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { runSlicedJobs } from './sliced_runner.mjs';
+
+test('runSlicedJobs preserves order and respects concurrency', async () => {
+  const items = Array.from({ length: 7 }, (_, i) => ({ index: i + 1 }));
+
+  let active = 0;
+  let maxActive = 0;
+
+  const results = await runSlicedJobs({
+    items,
+    limit: 2,
+    run: async (item) => {
+      active += 1;
+      maxActive = Math.max(maxActive, active);
+      await new Promise((r) => setTimeout(r, 20));
+      active -= 1;
+      return { index: item.index };
+    },
+  });
+
+  assert.equal(maxActive, 2);
+  assert.deepEqual(
+    results.map((r) => r.index),
+    items.map((i) => i.index)
+  );
+});
+
+test('runSlicedJobs can abort early after the first item', async () => {
+  const items = Array.from({ length: 5 }, (_, i) => ({ index: i + 1 }));
+  const seen = [];
+
+  const results = await runSlicedJobs({
+    items,
+    limit: 3,
+    run: async (item) => {
+      seen.push(item.index);
+      return { index: item.index, abort: item.index === 1 };
+    },
+    shouldAbortEarly: (res) => Boolean(res?.abort),
+  });
+
+  assert.deepEqual(seen, [1]);
+  assert.deepEqual(results.map((r) => r.index), [1]);
+});
+

package/scripts/utils/review/tool_home_seed.mjs

@@ -0,0 +1,99 @@
+import { copyFile, cp, mkdir, stat } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+async function mergeCopyDir({ srcDir, destDir }) {
+  if (!existsSync(srcDir)) return;
+  await mkdir(destDir, { recursive: true });
+  await cp(srcDir, destDir, { recursive: true, force: false, errorOnExist: false });
+}
+
+async function copyFileIfNewer({ srcFile, destFile }) {
+  if (!existsSync(srcFile)) return;
+  try {
+    const srcStat = await stat(srcFile);
+    let destStat = null;
+    try {
+      destStat = await stat(destFile);
+    } catch {
+      destStat = null;
+    }
+    if (!destStat || srcStat.mtimeMs > destStat.mtimeMs) {
+      await mkdir(join(destFile, '..'), { recursive: true });
+      await copyFile(srcFile, destFile);
+    }
+  } catch {
+    // best-effort
+  }
+}
+
+/**
+ * Best-effort: seed CodeRabbit auth/config into an isolated home directory.
+ *
+ * We do not read or print any auth contents; we only copy the on-disk state when present.
+ */
+export async function seedCodeRabbitHomeFromRealHome({ realHomeDir, isolatedHomeDir } = {}) {
+  const real = String(realHomeDir ?? '').trim();
+  const isolated = String(isolatedHomeDir ?? '').trim();
+  if (!real || !isolated || real === isolated) return;
+
+  // Common CodeRabbit state locations:
+  // - ~/.coderabbit/
+  // - ~/.config/coderabbit/ (XDG config)
+  // - ~/.cache/coderabbit/ (XDG cache)
+  // - ~/.local/share/coderabbit/ (XDG data)
+  // - ~/.local/state/coderabbit/ (XDG state)
+  //
+  // We merge-copy without overwriting existing files so a user can explicitly
+  // auth in the isolated dir and we won't clobber it.
+  await mergeCopyDir({ srcDir: join(real, '.coderabbit'), destDir: join(isolated, '.coderabbit') });
+  await mergeCopyDir({ srcDir: join(real, '.config', 'coderabbit'), destDir: join(isolated, '.config', 'coderabbit') });
+  await mergeCopyDir({ srcDir: join(real, '.cache', 'coderabbit'), destDir: join(isolated, '.cache', 'coderabbit') });
+  await mergeCopyDir({ srcDir: join(real, '.local', 'share', 'coderabbit'), destDir: join(isolated, '.local', 'share', 'coderabbit') });
+  await mergeCopyDir({ srcDir: join(real, '.local', 'state', 'coderabbit'), destDir: join(isolated, '.local', 'state', 'coderabbit') });
+
+  // If the user re-authenticated recently, refresh auth.json even when it already exists.
+  await copyFileIfNewer({
+    srcFile: join(real, '.coderabbit', 'auth.json'),
+    destFile: join(isolated, '.coderabbit', 'auth.json'),
+  });
+}
+
+/**
+ * Best-effort: seed Codex auth/config into an isolated CODEX_HOME directory.
+ *
+ * Codex stores auth/config under `CODEX_HOME` (default: ~/.codex). In stack review runs we
+ * use a per-repo isolated home (e.g. .project/codex-home) to avoid polluting ~/.codex and
+ * to keep sandboxed runs self-contained.
+ *
+ * We do not read or print any auth contents; we only copy the on-disk state when present.
+ */
+export async function seedCodexHomeFromRealHome({ realHomeDir, isolatedHomeDir } = {}) {
+  const real = String(realHomeDir ?? '').trim();
+  const isolated = String(isolatedHomeDir ?? '').trim();
+  if (!real || !isolated || real === isolated) return;
+
+  // Codex uses CODEX_HOME/{auth.json,config.toml,...}
+  await copyFileIfNewer({ srcFile: join(real, '.codex', 'auth.json'), destFile: join(isolated, 'auth.json') });
+  await copyFileIfNewer({ srcFile: join(real, '.codex', 'config.toml'), destFile: join(isolated, 'config.toml') });
+}
+
+/**
+ * Best-effort: seed Auggie (Augment CLI) auth/config into an isolated cache directory.
+ *
+ * Auggie uses `~/.augment` by default (see `--augment-cache-dir`), and supports
+ * providing session auth via `AUGMENT_SESSION_AUTH` (same format as `~/.augment/session.json`).
+ *
+ * We do not read or print any auth contents; we only copy the on-disk state when present.
+ */
+export async function seedAugmentHomeFromRealHome({ realHomeDir, isolatedHomeDir } = {}) {
+  const real = String(realHomeDir ?? '').trim();
+  const isolated = String(isolatedHomeDir ?? '').trim();
+  if (!real || !isolated || real === isolated) return;
+
+  // Copy ~/.augment/* into the isolated cache dir.
+  await mergeCopyDir({ srcDir: join(real, '.augment'), destDir: isolated });
+
+  // Refresh session.json when it is newer.
+  await copyFileIfNewer({ srcFile: join(real, '.augment', 'session.json'), destFile: join(isolated, 'session.json') });
+}

package/scripts/utils/review/tool_home_seed.test.mjs

@@ -0,0 +1,113 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { seedAugmentHomeFromRealHome, seedCodeRabbitHomeFromRealHome, seedCodexHomeFromRealHome } from './tool_home_seed.mjs';
+
+test('seedCodeRabbitHomeFromRealHome copies coderabbit state into isolated home when missing', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'happy-stacks-coderabbit-seed-'));
+  const realHome = join(root, 'real');
+  const isolatedHome = join(root, 'isolated');
+
+  try {
+    await mkdir(join(realHome, '.coderabbit'), { recursive: true });
+    await mkdir(join(realHome, '.config', 'coderabbit'), { recursive: true });
+    await writeFile(join(realHome, '.coderabbit', 'auth.json'), 'secret-ish\n', 'utf-8');
+    await writeFile(join(realHome, '.config', 'coderabbit', 'config.toml'), 'cfg\n', 'utf-8');
+
+    await mkdir(isolatedHome, { recursive: true });
+
+    await seedCodeRabbitHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: isolatedHome });
+
+    assert.equal(await readFile(join(isolatedHome, '.coderabbit', 'auth.json'), 'utf-8'), 'secret-ish\n');
+    assert.equal(await readFile(join(isolatedHome, '.config', 'coderabbit', 'config.toml'), 'utf-8'), 'cfg\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('seedCodeRabbitHomeFromRealHome does not overwrite existing isolated state', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'happy-stacks-coderabbit-seed-'));
+  const realHome = join(root, 'real');
+  const isolatedHome = join(root, 'isolated');
+
+  try {
+    await mkdir(join(realHome, '.coderabbit'), { recursive: true });
+    await writeFile(join(realHome, '.coderabbit', 'auth.json'), 'from-real\n', 'utf-8');
+
+    await mkdir(join(isolatedHome, '.coderabbit'), { recursive: true });
+    await writeFile(join(isolatedHome, '.coderabbit', 'auth.json'), 'already\n', 'utf-8');
+
+    await seedCodeRabbitHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: isolatedHome });
+
+    assert.equal(await readFile(join(isolatedHome, '.coderabbit', 'auth.json'), 'utf-8'), 'already\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('seedCodeRabbitHomeFromRealHome refreshes auth.json when the real home has a newer one', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'happy-stacks-coderabbit-seed-'));
+  const realHome = join(root, 'real');
+  const isolatedHome = join(root, 'isolated');
+
+  try {
+    await mkdir(join(realHome, '.coderabbit'), { recursive: true });
+    await mkdir(join(isolatedHome, '.coderabbit'), { recursive: true });
+
+    await writeFile(join(isolatedHome, '.coderabbit', 'auth.json'), 'old\n', 'utf-8');
+    // Ensure a later mtime for the real auth.
+    await new Promise((r) => setTimeout(r, 15));
+    await writeFile(join(realHome, '.coderabbit', 'auth.json'), 'new\n', 'utf-8');
+
+    await seedCodeRabbitHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: isolatedHome });
+
+    assert.equal(await readFile(join(isolatedHome, '.coderabbit', 'auth.json'), 'utf-8'), 'new\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('seedCodexHomeFromRealHome refreshes auth/config when the real home has newer ones', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'happy-stacks-codex-seed-'));
+  const realHome = join(root, 'real');
+  const isolatedHome = join(root, 'isolated');
+
+  try {
+    await mkdir(join(realHome, '.codex'), { recursive: true });
+    await mkdir(isolatedHome, { recursive: true });
+
+    await writeFile(join(isolatedHome, 'auth.json'), 'old-auth\n', 'utf-8');
+    await writeFile(join(isolatedHome, 'config.toml'), 'old-cfg\n', 'utf-8');
+
+    await new Promise((r) => setTimeout(r, 15));
+    await writeFile(join(realHome, '.codex', 'auth.json'), 'new-auth\n', 'utf-8');
+    await writeFile(join(realHome, '.codex', 'config.toml'), 'new-cfg\n', 'utf-8');
+
+    await seedCodexHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: isolatedHome });
+
+    assert.equal(await readFile(join(isolatedHome, 'auth.json'), 'utf-8'), 'new-auth\n');
+    assert.equal(await readFile(join(isolatedHome, 'config.toml'), 'utf-8'), 'new-cfg\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test('seedAugmentHomeFromRealHome copies session.json into isolated cache dir', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'happy-stacks-augment-seed-'));
+  const realHome = join(root, 'real');
+  const isolatedHome = join(root, 'isolated');
+
+  try {
+    await mkdir(join(realHome, '.augment'), { recursive: true });
+    await writeFile(join(realHome, '.augment', 'session.json'), '{"ok":true}\n', 'utf-8');
+    await mkdir(isolatedHome, { recursive: true });
+
+    await seedAugmentHomeFromRealHome({ realHomeDir: realHome, isolatedHomeDir: isolatedHome });
+
+    assert.equal(await readFile(join(isolatedHome, 'session.json'), 'utf-8'), '{"ok":true}\n');
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/scripts/utils/stack/cli_identities.mjs

@@ -0,0 +1,29 @@
+import { dirname, join } from 'node:path';
+
+const IDENTITY_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/;
+
+export function parseCliIdentityOrThrow(raw) {
+  const v = (raw ?? '').toString().trim();
+  if (!v || v === 'default') return 'default';
+  if (!IDENTITY_RE.test(v)) {
+    throw new Error(
+      `[stack] invalid --identity=${JSON.stringify(v)}. ` +
+        `Expected: "default" or a short name matching ${IDENTITY_RE} (max 64 chars).`
+    );
+  }
+  return v;
+}
+
+export function resolveCliHomeDirForIdentity({ cliHomeDir, identity }) {
+  const id = parseCliIdentityOrThrow(identity);
+  if (id === 'default') return cliHomeDir;
+
+  // Keep identities adjacent to the stack's default cli home dir:
+  //   <...>/<stack>/cli              (default)
+  //   <...>/<stack>/cli-identities/<id>
+  //
+  // If the stack overrides cliHomeDir to a custom path, we keep the same layout
+  // relative to that path's parent directory.
+  const baseDir = dirname(cliHomeDir);
+  return join(baseDir, 'cli-identities', id);
+}

package/scripts/utils/stack/startup.mjs

@@ -16,6 +16,11 @@ function looksLikeAlreadyExistsError(msg) {
   return s.includes('already exists') || s.includes('duplicate') || s.includes('constraint failed');
 }
 
+function looksLikeDatabaseLockedError(msg) {
+  const s = String(msg ?? '').toLowerCase();
+  return s.includes('database is locked') || s.includes('sqlite database error');
+}
+
 function looksLikeMissingGeneratedSqliteClientError(err) {
   const code = err && typeof err === 'object' ? err.code : '';
   if (code !== 'ERR_MODULE_NOT_FOUND') return false;
@@ -123,7 +128,7 @@ export function resolveAuthSeedFromEnv(env) {
   return seed || 'main';
 }
 
-export async function ensureServerLightSchemaReady({ serverDir, env }) {
+export async function ensureServerLightSchemaReady({ serverDir, env, bestEffort = false }) {
   await ensureDepsInstalled(serverDir, 'happy-server-light', { env });
 
   const dataDir = (env?.HAPPY_SERVER_LIGHT_DATA_DIR ?? '').toString().trim();
@@ -151,11 +156,19 @@ export async function ensureServerLightSchemaReady({ serverDir, env }) {
   // Unified server-light (monorepo): ensure deterministic migrations are applied (idempotent).
   // Legacy server-light (single schema.prisma with db push): do NOT run `prisma migrate deploy`,
   // because it commonly fails with P3005 when the DB was created by `prisma db push` and no migrations exist.
-  if (isUnified) {
+  //
+  // IMPORTANT:
+  // In dev/start flows the server process may already be running and holding the SQLite DB open.
+  // Running `prisma migrate deploy` concurrently will fail with "database is locked".
+  // When bestEffort=true (used for auth seeding heuristics), skip migrations and only probe.
+  if (isUnified && !bestEffort) {
     try {
       await pmExecBin({ dir: serverDir, bin: 'prisma', args: resolveServerLightPrismaMigrateDeployArgs({ serverDir }), env });
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
+      if (looksLikeDatabaseLockedError(msg) && bestEffort) {
+        return { ok: false, migrated: true, accountCount: null, error: msg };
+      }
       // If the SQLite DB was created before migrations existed (historical db push era),
       // `migrate deploy` can fail because tables already exist. Best-effort: baseline-resolve
       // the first migration, then retry deploy.
@@ -185,13 +198,27 @@ export async function ensureServerLightSchemaReady({ serverDir, env }) {
   } catch (e) {
     if (looksLikeMissingGeneratedSqliteClientError(e)) {
       await pmExecBin({ dir: serverDir, bin: 'prisma', args: ['generate', ...schemaArgs], env });
-      const accountCount = await probe();
-      return { ok: true, migrated: isUnified, accountCount };
+      try {
+        const accountCount = await probe();
+        return { ok: true, migrated: isUnified, accountCount };
+      } catch (e2) {
+        const msg = e2 instanceof Error ? e2.message : String(e2);
+        if (bestEffort && looksLikeDatabaseLockedError(msg)) {
+          return { ok: false, migrated: isUnified, accountCount: null, error: msg };
+        }
+        throw e2;
+      }
     }
     const msg = e instanceof Error ? e.message : String(e);
+    if (bestEffort && looksLikeDatabaseLockedError(msg)) {
+      return { ok: false, migrated: isUnified, accountCount: null, error: msg };
+    }
     if (looksLikeMissingTableError(msg)) {
       if (isUnified) {
-        // Tables still missing after migrate deploy; fail closed with a clear error.
+        // Tables still missing after migrate deploy (or probe without migrations); fail closed unless best-effort.
+        if (bestEffort) {
+          return { ok: false, migrated: true, accountCount: null, error: 'sqlite schema not ready (missing tables)' };
+        }
         throw new Error(`[server-light] sqlite schema not ready after prisma migrate deploy (missing tables).`);
       }
       // Legacy server-light: schema is typically applied via `prisma db push` in the component's dev/start scripts.
@@ -202,6 +229,9 @@ export async function ensureServerLightSchemaReady({ serverDir, env }) {
       // Legacy server-light: probing is best-effort (don't make stack dev fail closed here).
       return { ok: true, migrated: false, accountCount: 0 };
     }
+    if (bestEffort) {
+      return { ok: false, migrated: true, accountCount: null, error: msg };
+    }
     throw e;
   }
 }
@@ -226,8 +256,16 @@ export async function ensureHappyServerSchemaReady({ serverDir, env }) {
 
 export async function getAccountCountForServerComponent({ serverComponentName, serverDir, env, bestEffort = false }) {
   if (serverComponentName === 'happy-server-light') {
-    const ready = await ensureServerLightSchemaReady({ serverDir, env });
-    return { ok: true, accountCount: Number.isFinite(ready.accountCount) ? ready.accountCount : 0 };
+    try {
+      const ready = await ensureServerLightSchemaReady({ serverDir, env, bestEffort });
+      if (!ready?.ok) {
+        return { ok: false, accountCount: null, error: String(ready?.error ?? 'server-light schema probe failed') };
+      }
+      return { ok: true, accountCount: Number.isFinite(ready.accountCount) ? ready.accountCount : 0 };
+    } catch (e) {
+      if (!bestEffort) throw e;
+      return { ok: false, accountCount: null, error: e instanceof Error ? e.message : String(e) };
+    }
   }
   if (serverComponentName === 'happy-server') {
     try {

package/scripts/worktrees.mjs

@@ -26,6 +26,7 @@ import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 import { ensureEnvLocalUpdated } from './utils/env/env_local.mjs';
 import { ensureEnvFilePruned, ensureEnvFileUpdated } from './utils/env/env_file.mjs';
 import { isSandboxed } from './utils/env/sandbox.mjs';
+import { applyStackCacheEnv } from './utils/proc/pm.mjs';
 import { existsSync } from 'node:fs';
 import { getHomeEnvLocalPath, getHomeEnvPath, resolveUserConfigEnvPath } from './utils/env/config.mjs';
 import { detectServerComponentDirMismatch } from './utils/server/validate.mjs';
@@ -417,6 +418,8 @@ async function installDependencies({ dir }) {
     return { installed: false, reason: 'no package manager detected (no package.json)' };
   }
 
+  const env = await applyStackCacheEnv(process.env);
+
   // IMPORTANT:
   // When a caller requests --json, stdout must be reserved for JSON output only.
   // Package managers (especially Yarn) write progress to stdout, which would corrupt JSON parsing
@@ -424,7 +427,7 @@ async function installDependencies({ dir }) {
   const jsonMode = Boolean((process.argv ?? []).includes('--json'));
   const runForJson = async (cmd, args) => {
     try {
-      const out = await runCapture(cmd, args, { cwd: dir });
+      const out = await runCapture(cmd, args, { cwd: dir, env });
       if (out) process.stderr.write(out);
     } catch (e) {
       const out = String(e?.out ?? '');
@@ -439,7 +442,7 @@ async function installDependencies({ dir }) {
     if (jsonMode) {
       await runForJson('pnpm', ['install', '--frozen-lockfile']);
     } else {
-      await run('pnpm', ['install', '--frozen-lockfile'], { cwd: dir });
+      await run('pnpm', ['install', '--frozen-lockfile'], { cwd: dir, env });
     }
     return { installed: true, reason: null };
   }
@@ -448,7 +451,7 @@ async function installDependencies({ dir }) {
     if (jsonMode) {
       await runForJson('yarn', ['install', '--frozen-lockfile']);
     } else {
-      await run('yarn', ['install', '--frozen-lockfile'], { cwd: dir });
+      await run('yarn', ['install', '--frozen-lockfile'], { cwd: dir, env });
     }
     return { installed: true, reason: null };
   }
@@ -457,13 +460,13 @@ async function installDependencies({ dir }) {
     if (jsonMode) {
       await runForJson('npm', ['ci']);
     } else {
-      await run('npm', ['ci'], { cwd: dir });
+      await run('npm', ['ci'], { cwd: dir, env });
     }
   } else {
     if (jsonMode) {
       await runForJson('npm', ['install']);
     } else {
-      await run('npm', ['install'], { cwd: dir });
+      await run('npm', ['install'], { cwd: dir, env });
     }
   }
   return { installed: true, reason: null };