create-claude-workspace 1.1.50 → 1.1.52

package/dist/scripts/autonomous.mjs

@@ -216,9 +216,10 @@ function setupSignals(opts, log, checkpoint) {
             finalCleanup(opts, checkpoint, log);
             process.exit(1);
         }
-        log.info(`${label}. Stopping after current iteration (Ctrl+C again to force)...`);
+        log.info(`${label}. Killing child process and stopping (Ctrl+C again to force exit)...`);
         stopping = true;
         stoppingRef.value = true;
+        currentChild?.kill();
     };
     process.on('SIGINT', () => gracefulStop('SIGINT'));
     process.on('SIGTERM', () => gracefulStop('SIGTERM'));

package/dist/scripts/lib/claude-runner.mjs

@@ -144,7 +144,7 @@ function parseStreamEvent(json) {
     }
 }
 // ─── Process tree kill (cross-platform) ───
-function killProcessTree(pid, isWin) {
+export function killProcessTree(pid, isWin) {
     if (isWin) {
         try {
             execSync(`taskkill /PID ${pid} /T /F`, { stdio: 'ignore' });

package/dist/scripts/lib/claude-runner.spec.js

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { resetStreamState, validateResult, formatStreamEvent } from './claude-runner.mjs';
+import { resetStreamState, validateResult, formatStreamEvent, killProcessTree } from './claude-runner.mjs';
+import { spawn, execSync } from 'node:child_process';
 describe('validateResult', () => {
     it('returns valid result for complete object', () => {
         const input = { status: 'completed', action: 'commit', message: 'Done task #1' };
@@ -236,3 +237,110 @@ describe('resetStreamState', () => {
         resetStreamState(); // should not throw
     });
 });
+// ─── killProcessTree integration tests ───
+// Verifies that Ctrl+C (killProcessTree) actually kills child processes.
+const isWin = process.platform === 'win32';
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0); // signal 0 = existence check
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function spawnLongRunning() {
+    const script = 'setTimeout(()=>{},60000)';
+    if (isWin) {
+        return spawn(process.env.ComSpec ?? 'cmd.exe', ['/c', 'node', '-e', script], {
+            stdio: 'ignore',
+            detached: true,
+            windowsHide: true,
+        });
+    }
+    return spawn('node', ['-e', script], {
+        stdio: 'ignore',
+        detached: true,
+    });
+}
+/** Spawn a nested process tree: parent node → child node (simulates cmd.exe → claude) */
+function spawnNestedTree() {
+    // Parent spawns a child that also sleeps — simulates cmd.exe → claude process tree
+    const innerScript = `
+    const { spawn } = require('child_process');
+    const child = spawn('node', ['-e', 'setTimeout(()=>{},60000)'], { stdio: 'ignore' });
+    child.unref();
+    setTimeout(()=>{},60000);
+  `.replace(/\n/g, ' ');
+    if (isWin) {
+        return spawn(process.env.ComSpec ?? 'cmd.exe', ['/c', 'node', '-e', innerScript], {
+            stdio: 'ignore',
+            detached: true,
+            windowsHide: true,
+        });
+    }
+    return spawn('node', ['-e', innerScript], {
+        stdio: 'ignore',
+        detached: true,
+    });
+}
+describe('killProcessTree', () => {
+    it('kills a simple child process', async () => {
+        const child = spawnLongRunning();
+        const pid = child.pid;
+        expect(pid).toBeGreaterThan(0);
+        // Give process time to start
+        await new Promise(r => setTimeout(r, 500));
+        expect(isProcessAlive(pid)).toBe(true);
+        // Kill it
+        killProcessTree(pid, isWin);
+        // Wait for process to die
+        await new Promise(r => setTimeout(r, isWin ? 2000 : 1000));
+        expect(isProcessAlive(pid)).toBe(false);
+    }, 10_000);
+    it('kills a nested process tree (simulates cmd.exe → claude)', async () => {
+        const parent = spawnNestedTree();
+        const parentPid = parent.pid;
+        expect(parentPid).toBeGreaterThan(0);
+        // Give tree time to start
+        await new Promise(r => setTimeout(r, 1500));
+        expect(isProcessAlive(parentPid)).toBe(true);
+        // Kill the tree
+        killProcessTree(parentPid, isWin);
+        // Wait for tree to die
+        await new Promise(r => setTimeout(r, isWin ? 3000 : 2000));
+        expect(isProcessAlive(parentPid)).toBe(false);
+        // On Windows, verify no orphan node.exe children from our tree
+        if (isWin) {
+            // tasklist can't reliably check by parent PID after parent is dead,
+            // but the /T flag in taskkill should have killed all children
+            try {
+                const taskInfo = execSync(`tasklist /FI "PID eq ${parentPid}" /NH`, {
+                    encoding: 'utf-8', stdio: 'pipe', timeout: 3000,
+                });
+                expect(taskInfo).not.toContain(String(parentPid));
+            }
+            catch { /* process dead, expected */ }
+        }
+    }, 15_000);
+    it('does not throw when killing already-dead process', () => {
+        // PID 999999 is almost certainly not a real process
+        expect(() => killProcessTree(999999, isWin)).not.toThrow();
+    });
+    it('kills process fast enough for interactive use (< 3s)', async () => {
+        const child = spawnLongRunning();
+        const pid = child.pid;
+        await new Promise(r => setTimeout(r, 500));
+        const start = Date.now();
+        killProcessTree(pid, isWin);
+        // Poll until dead or timeout
+        let alive = true;
+        while (alive && Date.now() - start < 3000) {
+            await new Promise(r => setTimeout(r, 100));
+            alive = isProcessAlive(pid);
+        }
+        const elapsed = Date.now() - start;
+        expect(alive).toBe(false);
+        expect(elapsed).toBeLessThan(3000);
+    }, 10_000);
+});

package/dist/template/.claude/agents/deployment-engineer.md

@@ -380,7 +380,7 @@ vercel rollback
 **VPS (SSH):**
 ```bash
 # If using PM2 + git:
-ssh deploy@host "cd /var/www/myapp && git checkout <previous-release-tag-or-hash> && npm install && pm2 restart all"
+ssh deploy@host "cd /var/www/myapp && git checkout <previous-release-tag-or-hash> && [PKG] install && pm2 restart all"
 # If using Docker:
 ssh deploy@host "docker compose -f docker-compose.prod.yml pull && docker compose -f docker-compose.prod.yml up -d"
 # (redeploy previous image tag — update docker-compose.prod.yml or .env with previous tag first)

package/dist/template/.claude/agents/orchestrator.md

@@ -72,11 +72,20 @@ At the beginning of EVERY session (including every Ralph Loop iteration):
 ### 1. Read state
 - Read MEMORY.md — find where you left off, what is done, what is next, what phase you're in
 
-### 2. Resolve app names
-- Read CLAUDE.md — find app name(s) from the Architecture/Tech Stack section
+### 2. Resolve app names and package manager
+- Read CLAUDE.md — find app name(s) and package manager from the Architecture/Tech Stack section
 - Store app names for use in build/test/lint commands:
   - `FRONTEND_APP` = the frontend app name (e.g., `my-app`)
   - `BACKEND_APP` = the API app name (e.g., `api`) — may not exist
+- **Resolve package manager** — use the FIRST match:
+  1. CLAUDE.md Tech Stack `[PKG] as package manager` field (authoritative if set)
+  2. Lockfile detection: `bun.lock` or `bun.lockb` → bun, `pnpm-lock.yaml` → pnpm, `yarn.lock` → yarn, `package-lock.json` → npm
+  3. Default: npm
+- Store as `PKG` in MEMORY.md Session Config (e.g., `PKG: bun`). **All commands in all steps MUST use this value** — never hardcode npm/pnpm/yarn/bun.
+  - Install: `{PKG} install` (bun: `bun install`, npm: `npm ci`, pnpm: `pnpm install --frozen-lockfile`, yarn: `yarn install --frozen-lockfile`)
+  - Run script: `{PKG} run [script]` (bun: `bun run`, npm: `npm run`)
+  - Add package: `{PKG} add [pkg]` (npm: `npm install [pkg]`)
+  - Execute binary: `bunx` / `npx` / `pnpm exec` / `yarn dlx`
 - Also note: workflow mode from CLAUDE.md — `Workflow: solo` or `Workflow: team` (default: solo)
 - Store these in MEMORY.md under a `## Session Config` section if not already present
 - **If Session Config has "TBD" values** (new project before Phase 0): scan `apps/` directory. If apps now exist (Phase 0 completed), update the values. If still empty, keep "TBD" — Phase 0 scaffolding will create them.
@@ -236,14 +245,13 @@ To determine if a task is frontend, backend, or fullstack, use this heuristic:
 - **Phase transition check**: If this is the FIRST task of a new phase (all previous phase tasks done):
   - **CI/CD generation (Phase 0 → Phase 1 only):** If Phase 0 just completed AND CLAUDE.md has a `## Deployment` section (deployment interview was done during setup) AND no CI/CD config files exist yet (`.gitlab-ci.yml`, `.github/workflows/`): delegate to `deployment-engineer`: "Phase 0 (workspace scaffolding) is complete — the project now has package.json and source code. Read CLAUDE.md ## Deployment section for deployment config collected during setup. Generate CI/CD config files now. [If CLAUDE.md has Distribution: npm:] Also generate CI publish jobs — read MEMORY.md NPM_REGISTRY/NPM_CI_AUTH for registry config."
   - **Dependency freshness check** (skip at Phase 0 → Phase 1 — deps were just installed during scaffolding):
-    1. Detect package manager from lockfile (`package-lock.json` → npm, `yarn.lock` → yarn, `pnpm-lock.yaml` → pnpm, `bun.lock` → bun). Default to npm.
+    1. Use `PKG` from MEMORY.md Session Config (resolved in health check step 2).
     2. Run outdated check — capture output, then validate. Note: `npm outdated` exits with code 1 when outdated packages exist (this is normal, not an error):
        ```bash
-       # npm
-       OUTDATED=$(npm outdated --json 2>&1) || true
-       # yarn: yarn outdated --json 2>&1 || true
-       # pnpm: pnpm outdated --format json 2>&1 || true
-       # bun: bun outdated 2>&1 || true
+       # npm:  OUTDATED=$(npm outdated --json 2>&1) || true
+       # pnpm: OUTDATED=$(pnpm outdated --format json 2>&1) || true
+       # yarn: OUTDATED=$(yarn outdated --json 2>&1) || true
+       # bun:  OUTDATED=$(bun outdated 2>&1) || true
        ```
        If the output is not valid JSON (network failure, corrupt lockfile), log warning in MEMORY.md Notes and skip.
     3. Skip if no outdated dependencies found (empty JSON object `{}`).
@@ -251,12 +259,12 @@ To determine if a task is frontend, backend, or fullstack, use this heuristic:
        - **Patch** (e.g., `1.2.3` → `1.2.5`): safe, auto-upgrade
        - **Minor** (e.g., `1.2.3` → `1.3.0`): likely safe, auto-upgrade
        - **Major** (e.g., `1.2.3` → `2.0.0`): breaking changes — do NOT auto-upgrade
-    5. **Auto-upgrade patch + minor:** Run `npm update` (respects semver ranges in package.json). If package.json pins exact versions or ranges exclude the available update, use `npm install [pkg]@[wanted]` for each outdated package where wanted ≤ latest within the semver range. For other package managers: `yarn upgrade`, `pnpm update`, `bun update`.
+    5. **Auto-upgrade patch + minor:** Run `{PKG} update` (e.g., `bun update`, `npm update`, `pnpm update`, `yarn upgrade`). If package.json pins exact versions or ranges exclude the available update, use `{PKG} add [pkg]@[wanted]` (npm: `npm install [pkg]@[wanted]`) for each outdated package where wanted ≤ latest within the semver range.
     6. **Verify:** Run full workspace build, lint, and test from the project root on main (not scoped to a specific project — there is no active task or worktree at this point). If ANY fail:
        - Revert files AND restore node_modules to match:
          ```bash
          git restore package.json [lockfile]
-         npm ci    # or: yarn install --frozen-lockfile / pnpm install --frozen-lockfile / bun install --frozen-lockfile
+         {PKG} install    # bun install / npm ci / pnpm install --frozen-lockfile / yarn install --frozen-lockfile
          ```
        - Log failed upgrade in MEMORY.md Notes: "Dependency upgrade failed at phase transition — [error summary]. Skipped."
        - Do NOT block phase transition — continue with current versions.
@@ -314,7 +322,7 @@ To determine if a task is frontend, backend, or fullstack, use this heuristic:
 - Update MEMORY.md (on main): set `Current Step: 3 — IMPLEMENT`
 - **All file operations in the worktree** (`Current Worktree` from MEMORY.md). Use absolute paths for Read/Edit/Write and `cd {worktree}` for Bash commands.
 - **CLI commands and Nx Generators FIRST**: Always prioritize using CLI commands and `nx generate` over manual file creation. NEVER manually create `project.json`, `tsconfig.*`, or configure build/test/lint targets — generators and CLI tools handle this correctly. NEVER manually install or configure build tools (tsup, esbuild, rollup, webpack) — Nx generators handle build configuration. Internal libs don't need a build step; publishable libs get `--bundler` from the generator. This includes:
-  - **Workspace scaffolding** (Phase 0): `npx create-nx-workspace` — architect decides preset and flags
+  - **Workspace scaffolding** (Phase 0): `create-nx-workspace` via the detected package manager runner (`bunx` / `npx` / `pnpm dlx` / `yarn dlx`) — architect decides preset and flags. If PKG is bun, use `bunx create-nx-workspace` and pass `--packageManager=bun`.
   - **Libraries/components/apps**: `nx generate` — see CLAUDE.md "Nx Generators" section
   - **Plugins**: `nx add` (e.g., `nx add @nx/playwright`, `nx add @nx/eslint`)
   - **Code quality setup**: install via package manager, configure via CLI where possible

package/dist/template/.claude/agents/project-initializer.md

@@ -147,6 +147,7 @@ Create a **minimal** CLAUDE.md in the project root by filling what is KNOWN from
 - Fill in: project name, description, workflow (solo/team)
 - If user answered "yes" to npm publishing (question 6), add `- **Distribution**: npm ([registry], [public/restricted])` to Tech Stack section (details collected in Step 2b)
 - Fill in Tech Stack ONLY for what is already detected in the codebase (existing package.json, nx.json, etc.)
+- **Detect package manager** from lockfile: `bun.lock` or `bun.lockb` → bun, `pnpm-lock.yaml` → pnpm, `yarn.lock` → yarn, `package-lock.json` → npm. If no lockfile, check `package.json` `packageManager` field. Fill `[PKG]` in the template with the detected value. This is critical — all agents use this value for install/run/add commands.
 - For NEW projects (empty codebase): leave Tech Stack minimal — just project type and package manager if known. Architecture decisions will be made by architect agents in TODO.md Phase 0.
 - **Remove all backend sections** if no backend is mentioned
 - Remove placeholder comments and unresolved `[PLACEHOLDER]` values

package/dist/template/.claude/agents/test-engineer.md

@@ -179,7 +179,7 @@ Before writing E2E tests, detect existing config:
    ```bash
    nx add @nx/playwright
    ```
-   If not using Nx, install Playwright directly: `npm init playwright@latest`
+   If not using Nx, install Playwright directly: `{PKG} init playwright@latest` (bun: `bun create playwright`, npm: `npm init playwright@latest`). Read CLAUDE.md Tech Stack for the project's package manager.
    NEVER manually create `project.json` for E2E projects — the generator configures targets, config files, and directory structure correctly.
 
 4. E2E tests live in `apps/[APP]-e2e/src/` (Nx) or `e2e/` (standalone) — NOT next to unit tests

package/dist/template/.claude/templates/PLAN.md

@@ -10,7 +10,7 @@
 - Repository URL:
 - Primary language: TypeScript
 - Framework(s):
-- Package manager: npm | pnpm | yarn | bun
+- Package manager: bun | npm | pnpm | yarn
 - Monorepo: no
 
 ## Product Vision

package/dist/template/.claude/templates/claude-md.md

@@ -34,7 +34,7 @@ When running in autonomous/unattended mode (via `autonomous.mjs` or non-interact
 
 [Generate based on detected project type. Include only lines relevant to this project:]
 - **Project type**: [Angular app / TS library monorepo / Fullstack app / Backend only]
-- **Build**: Nx monorepo, [PKG] as package manager
+- **Build**: Nx monorepo, [PKG] as package manager (CRITICAL: detect from lockfile — `bun.lock`/`bun.lockb` → bun, `pnpm-lock.yaml` → pnpm, `yarn.lock` → yarn, `package-lock.json` → npm)
 - **Testing**: Vitest
 - **Deployment**: Cloudflare (Pages + Workers) — default
 - **Workflow**: solo / team (solo = direct merge to main, team = MR/PR review required)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-workspace",
-  "version": "1.1.50",
+  "version": "1.1.52",
   "description": "Scaffold a project with Claude Code agents for autonomous AI-driven development",
   "type": "module",
   "bin": {