create-claude-workspace 1.1.103 → 1.1.105

package/dist/scripts/autonomous.mjs

@@ -148,7 +148,7 @@ Options:
   --max-turns <n>              Max turns per Claude invocation (default: 50)
   --delay <ms>                 Pause between tasks (default: 5000)
   --cooldown <ms>              Wait after error (default: 60000)
-  --process-timeout <ms>       Max wall-clock time per invocation (default: 7200000 = 2h)
+  --process-timeout <ms>       Max wall-clock time per invocation (default: 14400000 = 4h)
   --activity-timeout <ms>      Max silence before kill (default: 900000 = 15min)
   --post-result-timeout <ms>   Max wait after result (default: 30000 = 30s)
   --project-dir <path>         Project directory (default: cwd)

package/dist/scripts/lib/errors.mjs

@@ -21,21 +21,22 @@ export function classifyError(signals) {
         return 'auth_expired';
     if (signals.isAuthServerError)
         return 'auth_server_error';
-    // Usage limit (account quota) takes priority over rate limit — it's hours, not seconds
-    if (signals.isUsageLimit)
-        return 'usage_limit';
-    if (signals.isRateLimit)
-        return 'rate_limited';
+    // Timeouts take priority over rate limit — timeout is the actual kill reason,
+    // rate limit is just a transient event that may have occurred during a 2h+ run.
+    // Without this, a normal process_timeout gets misclassified as rate_limited.
     if (signals.timedOut) {
-        // Double-check stderr for auth errors (may not have been caught by stream events)
         if (/authentication_error|failed to authenticate|api error: 401|oauth token has expired/i.test(signals.stderr)) {
             return 'auth_expired';
         }
         return 'process_timeout';
     }
-    // Activity timeout after result = success (process just hung after finishing)
     if (signals.activityTimedOut)
         return signals.hasResult ? 'none' : 'activity_timeout';
+    // Usage limit (account quota) takes priority over rate limit — it's hours, not seconds
+    if (signals.isUsageLimit)
+        return 'usage_limit';
+    if (signals.isRateLimit)
+        return 'rate_limited';
     // Clean exit
     if (signals.code === 0)
         return 'none';

package/dist/scripts/lib/errors.spec.js

@@ -78,9 +78,15 @@ describe('classifyError', () => {
     it('flag priority: auth flag wins over stderr patterns', () => {
         expect(classifyError({ ...base, isAuthError: true, stderr: 'rate limit' })).toBe('auth_expired');
     });
-    it('flag priority: rate limit flag wins over timeout', () => {
+    it('flag priority: rate limit flag detected when not timed out', () => {
         expect(classifyError({ ...base, isRateLimit: true, timedOut: false })).toBe('rate_limited');
     });
+    it('flag priority: timeout wins over rate limit (rate limit is transient during long run)', () => {
+        expect(classifyError({ ...base, isRateLimit: true, timedOut: true })).toBe('process_timeout');
+    });
+    it('flag priority: activity timeout wins over rate limit', () => {
+        expect(classifyError({ ...base, isRateLimit: true, activityTimedOut: true })).toBe('activity_timeout');
+    });
     it('returns none when clean exit with result despite transient rate limit', () => {
         expect(classifyError({ ...base, code: 0, hasResult: true, isRateLimit: true })).toBe('none');
     });

package/dist/scripts/lib/loop-integration.spec.js

@@ -659,8 +659,8 @@ describe('Loop integration: classifyError → getErrorAction → checkpoint', ()
         it('auth error beats auth server error', () => {
             expect(classifyError({ ...base, isAuthError: true, isAuthServerError: true })).toBe('auth_expired');
         });
-        it('rate limit beats process timeout on non-zero exit', () => {
-            expect(classifyError({ ...base, code: 1, isRateLimit: true, timedOut: true })).toBe('rate_limited');
+        it('process timeout beats rate limit (timeout is actual kill reason, rate limit is transient)', () => {
+            expect(classifyError({ ...base, code: 1, isRateLimit: true, timedOut: true })).toBe('process_timeout');
         });
         it('process timeout beats activity timeout', () => {
             expect(classifyError({ ...base, timedOut: true, activityTimedOut: true })).toBe('process_timeout');

package/dist/scripts/lib/types.mjs

@@ -7,7 +7,7 @@ export const DEFAULTS = {
     projectDir: process.cwd(),
     skipPermissions: false,
     resumeSession: null,
-    processTimeout: 2 * 60 * 60_000,
+    processTimeout: 4 * 60 * 60_000,
     activityTimeout: 15 * 60_000,
     postResultTimeout: 30_000,
     logFile: '.claude/autonomous.log',

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

@@ -69,6 +69,7 @@ Always prefer `@cibule/*` packages over custom implementations:
   - Worker entry: exports `default { fetch }` with Hono app + D1 bindings → imports `infrastructure-d1`
   - Node entry: `serve()` with Hono app + SQLite/better-sqlite3 bindings → imports `infrastructure-sqlite`
 - When planning, always structure FILES to keep platform-specific code in separate libraries per platform
+- **Local development ALWAYS via Node.js entry point (STRICT):** `wrangler dev` is NOT used for local development — Nx `serve` target uses `@nx/js:node` executor pointing at the Node.js entry point (`main.ts`). Wrangler is deployment-only (handled by deployment-engineer). NEVER put `wrangler` commands in project.json targets.
 
 ## Task Approach
 
@@ -122,11 +123,12 @@ List of all files to create/modify, with full paths.
 - **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.
 - **NEVER use `nx:run-commands` executor** in project.json targets. Always use the proper built-in Nx executor for each target type:
-  - serve: `@nx/js:node` (Node.js backend)
+  - serve: `@nx/js:node` (Node.js backend) — points at Node.js entry point, NOT wrangler
   - build: `@nx/js:tsc`, `@nx/vite:build`, `@nx/esbuild:esbuild`
   - test: `@nx/vitest:test` (Vitest), `@nx/jest:jest`
   - lint: `@nx/eslint:lint`
   - `nx:run-commands` is an escape hatch, not a default. Built-in executors handle watch mode, HMR, process management, and Nx dependency graph integration.
+  - **NEVER wrap `wrangler` in Nx targets** — wrangler is for deployment only (deployment-engineer handles it). Local dev always uses Node.js.
 
 ### IMPLEMENTATION ORDER
 Numbered steps in the exact order the orchestrator should implement them.

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

@@ -78,6 +78,13 @@ 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
 - **Load `.env`**: If `.env` exists in the project root, source it to load tokens (`GITLAB_TOKEN`, `GH_TOKEN`, `CLICKUP_API_TOKEN`, etc.): `set -a && [ -f .env ] && . ./.env && set +a`
+- **Refresh CLI auth from `.env`**: Each Bash tool call is an isolated shell session — env vars loaded above don't persist. To ensure CLI tools use the latest tokens from `.env`, re-authenticate in a single command:
+  ```bash
+  set -a && [ -f .env ] && . ./.env && set +a && \
+  if [ -n "$GITLAB_TOKEN" ]; then glab auth login --hostname gitlab.com --token "$GITLAB_TOKEN" 2>/dev/null && echo "glab: re-authenticated from .env"; fi && \
+  if [ -n "$GH_TOKEN" ]; then echo "$GH_TOKEN" | gh auth login --with-token 2>/dev/null && echo "gh: re-authenticated from .env"; fi
+  ```
+  This overwrites any stale tokens stored in CLI config files (e.g., from Docker entrypoint at container creation).
 
 ### 1b. Detect resumed development on completed project
 If MEMORY.md indicates "Project complete" (Current Phase contains "PROJECT COMPLETE" or Next says "project complete"):

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

@@ -349,7 +349,7 @@ Key rules enforced (do NOT weaken):
 - Entry points handle platform wiring:
   - `apps/api/src/main.ts` — Node.js entry (optional, for local dev)
   - `apps/api/src/index.ts` — Cloudflare Worker entry (production)
-- Default deployment: **Cloudflare Workers** (production), **Node.js** (local development via `wrangler dev` or direct)
+- Default deployment: **Cloudflare Workers** (production), **Node.js** (local development via `@nx/js:node` executor + Node.js entry point). Wrangler is deployment-only — NEVER used for local dev or in Nx targets.
 
 ### Project-Specific Details
 

package/package.json

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