create-claude-workspace 1.1.97 → 1.1.99

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

@@ -364,6 +364,7 @@ export function runClaude(opts, log, runOpts = {}) {
                 isAuthServerError = true;
         }
         let usageLimitKilled = false;
+        let authErrorKilled = false;
         function detectTextSignals(lower) {
             if (USAGE_LIMIT_RE.test(lower)) {
                 isUsageLimit = true;
@@ -377,8 +378,17 @@ export function runClaude(opts, log, runOpts = {}) {
             }
             if (RATE_LIMIT_RE.test(lower))
                 isRateLimit = true;
-            if (AUTH_ERROR_RE.test(lower))
+            if (AUTH_ERROR_RE.test(lower)) {
                 isAuthError = true;
+                authErrorCount++;
+                // Kill on auth error burst — Claude CLI retries internally and spams
+                // "does not have access" / "authentication_error" dozens of times.
+                if (authErrorCount >= 3 && !authErrorKilled && !killed) {
+                    authErrorKilled = true;
+                    log.warn(`Auth error burst detected (${authErrorCount} errors) — killing process.`);
+                    killChild('process_timeout');
+                }
+            }
             if (AUTH_SERVER_RE.test(lower) && /auth/i.test(lower))
                 isAuthServerError = true;
         }
@@ -487,6 +497,11 @@ export function runClaude(opts, log, runOpts = {}) {
                 detectErrorSignals(event);
                 // Track pending tool calls — tool_use in assistant, tool_result in user
                 if (event.type === 'assistant') {
+                    // Reset resultReceived — Claude is still actively working, so any earlier
+                    // result event (e.g. from a sub-agent with --include-partial-messages) was
+                    // not the final one. Without this, postResultTimeout (30s) kills the process
+                    // while Claude is thinking before its next tool call.
+                    resultReceived = false;
                     const blocks = getContentBlocks(event);
                     if (blocks) {
                         for (const block of blocks) {
@@ -528,15 +543,6 @@ export function runClaude(opts, log, runOpts = {}) {
             }
             const lower = text.toLowerCase();
             detectTextSignals(lower);
-            // Kill on auth error burst (e.g. expired token causing infinite retry loop)
-            if (AUTH_ERROR_RE.test(lower)) {
-                authErrorCount++;
-                if (authErrorCount >= 3 && !killed) {
-                    log.warn(`Auth error burst detected (${authErrorCount} errors) — killing process.`);
-                    killChild('process_timeout');
-                    return;
-                }
-            }
             process.stderr.write(text);
         });
         // ─── Close ───

package/dist/template/.claude/agents/backend-ts-architect.md

@@ -114,7 +114,10 @@ What this task covers and what it does NOT cover.
 ### FILES
 List of all files to create/modify, with full paths.
 **Feature-first library organization (STRICT):** Every distinct feature/domain MUST have its own library group (`libs/[feature]/domain/`, `libs/[feature]/business/`, `libs/[feature]/infrastructure/`, etc.). NEVER put multiple features' types/logic into a single shared library (e.g. `shared/types` with `scan.ts`, `streak.ts`, `achievement.ts` is WRONG — each gets `libs/scan/domain/`, `libs/streak/domain/`, `libs/achievement/domain/`). `libs/shared/` is ONLY for truly cross-domain code (generic utilities, DI infrastructure).
-**For new libraries**: specify the `nx generate` command (e.g., `nx g @nx/js:library --directory=libs/auth/domain --no-interactive`).
+**For new libraries**: prefer `@cibule/devkit` generators for onion architecture scaffolding — they create correctly layered libraries with proper DI wiring:
+- **New workspace** (Phase 0): `nx g @cibule/devkit:preset {orgName}` — initializes workspace with onion layers, shared infrastructure, and DI tokens.
+- **New domain scope**: `nx g @cibule/devkit:scope {scopeName}` — creates `libs/{scope}/domain/`, `libs/{scope}/business/`, `libs/{scope}/api/`, `libs/{scope}/infrastructure-*/` with correct dependencies. Add `--frontend` flag if the scope includes a UI library.
+- **Fallback** (non-onion or simple libraries): `nx g @nx/js:library --directory=libs/{path} --no-interactive`.
 - **Internal monorepo libs** (consumed only within the workspace): omit `--bundler` — they don't need a build step. TypeScript path aliases handle resolution.
 - **Publishable libs** (npm packages): use `--bundler=tsc` (or `--bundler=esbuild`/`--bundler=rollup` if needed) + `--publishable --importPath=@scope/name`. The generator creates the build target.
 - **NEVER manually configure build tools** (tsup, esbuild, rollup, webpack). Do NOT create `tsup.config.ts`, `esbuild.config.js`, `rollup.config.js`, or similar files — Nx generators handle build configuration. Use `nx build [lib]` to build.

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

@@ -413,8 +413,9 @@ 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): `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
+  - **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`. After workspace creation, run `nx g @cibule/devkit:preset {orgName}` to initialize onion architecture layers.
+  - **Domain scopes**: `nx g @cibule/devkit:scope {scopeName}` — creates layered library group (domain, business, api, infrastructure). Add `--frontend` for scopes with UI.
+  - **Libraries/components/apps**: `nx generate` — see CLAUDE.md "Nx Generators" section. Prefer `@cibule/devkit` generators for backend onion architecture over plain `@nx/js:library`.
   - **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
   - **Backend runtimes**: `wrangler init` (Workers), runtime-specific CLIs

package/dist/template/.claude/agents/technical-planner.md

@@ -40,6 +40,8 @@ If the codebase has no `nx.json` or `package.json` (brand new project), YOU must
 
 Document these decisions in the `## Architecture Decisions` section of TODO.md AND include them in the Phase 0 scaffolding task description so the architect knows exactly what to scaffold.
 
+**@cibule/devkit generators**: For projects with a backend, Phase 0 scaffolding tasks MUST include `@cibule/devkit:preset` initialization and `@cibule/devkit:scope` for each domain scope. Mention these explicitly in the task description so the architect uses them instead of manually creating onion architecture libraries.
+
 After Phase 0 scaffolding completes, the orchestrator will update CLAUDE.md with the full tech stack.
 
 ### 3. Analyze

package/package.json

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