create-claude-workspace 1.1.14 → 1.1.16

package/dist/template/.claude/agents/devops-integrator.md

@@ -22,11 +22,13 @@ Determine which platform to use:
 - **GitHub (`gh`)**:
   - Windows: `winget install GitHub.cli`
   - macOS: `brew install gh`
-  - Linux: `sudo apt install gh` / `sudo dnf install gh`
+  - Linux/Docker: `curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo tee /usr/share/keyrings/githubcli-archive-keyring.gpg > /dev/null && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null && sudo apt-get update && sudo apt-get install -y gh`
 - **GitLab (`glab`)**:
   - Windows: `winget install GLab.GLab`
   - macOS: `brew install glab`
-  - Linux: `sudo apt install glab` / `sudo dnf install glab`
+  - Linux/Docker: `curl -fsSL "https://packages.gitlab.com/install/repositories/gitlab/glab/script.deb.sh" | sudo bash && sudo apt-get install -y glab`
+
+**Docker note:** In Docker containers, install the CLI for the detected platform on first use. The installed binary persists in the `claude-home` volume across container restarts if installed to `~/.local/bin`.
 
 ## Operations
 

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

@@ -475,6 +475,26 @@ NEVER stay stuck. Escalation order:
 **C: DECIDE** — Pick best approach, log to MEMORY.md
 **D: SKIP (last resort)** — Only if blocker is objectively unresolvable. Revert changes (`git stash --include-untracked -m "REVERTED: [task title]"`), return to main (`git checkout main 2>/dev/null || git checkout master`), delete orphaned branch (`git branch -D feat/{slug}`). Then log everything in MEMORY.md Blockers section, mark task as `[~]` SKIPPED in TODO.md with reason, commit tracking on main (`git add TODO.md MEMORY.md && git commit -m "chore: mark task as skipped"`, push only if remote exists), move to next task.
 
+## End-of-Iteration Output
+
+When running in autonomous mode (detected by the UNATTENDED prompt), your FINAL message MUST clearly convey the iteration outcome. The `--json-schema` flag enforces the structure — just write naturally and include:
+
+- **status** — one of:
+  - `completed` — task finished successfully (committed, pushed, tracking updated)
+  - `needs_input` — cannot proceed without user-provided information (missing token, ambiguous requirement, auth expired). Specify what is needed in `action`.
+  - `blocked` — external blocker (CI failure, merge conflict needing human resolution, dependency unavailable). The loop will retry next iteration.
+  - `error` — unrecoverable error (all fix attempts exhausted, agent failures)
+- **action** — what should happen next: `continue`, `needs_gitlab_token`, `needs_github_token`, `needs_user_decision`, `needs_api_key`, `retry_after_cooldown`, `auth_expired`, etc.
+- **message** — human-readable summary of what happened (1-2 sentences)
+- **task_completed** — the task name/ID if completed, or null
+- **next_task** — the next task to pick up, or null
+
+Examples:
+- Task completed: `status: completed, action: continue, message: "Implemented user auth flow and pushed MR #42", task_completed: "#42 User auth", next_task: "#43 Dashboard"`
+- Missing token: `status: needs_input, action: needs_gitlab_token, message: "git push failed — GITLAB_TOKEN is missing or expired. Please provide a valid token."`
+- Build stuck: `status: error, action: retry_after_cooldown, message: "Build failed 3 times on dependency resolution. Exhausted fix attempts."`
+- Blocked: `status: blocked, action: needs_user_decision, message: "Task #15 requires API design decision — REST vs GraphQL. Cannot proceed without guidance."`
+
 ## Rules
 
 - You are an ORCHESTRATOR — delegate to specialist agents, do not bypass them
@@ -489,3 +509,5 @@ NEVER stay stuck. Escalation order:
 - Priority: working code > perfect code. Production quality, not hacks.
 - **Token safety**: NEVER echo, log, cat, or write secrets (NPM_TOKEN, API keys, etc.) to terminal output, MEMORY.md, CLAUDE.md, or any tracked file. Tokens are read from `~/.npmrc` or environment variables automatically by tools — never handle them directly.
 - For independent tasks within the same phase, consider running architect agents in parallel (STEP 2) — but ONLY for tasks that don't share API contracts
+- When running in UNATTENDED mode, your final message MUST clearly state the outcome status, what was completed, and what comes next — the CLI extracts this into structured JSON automatically
+- If you detect auth/token issues (git push 401, npm 403, etc.), return `needs_input` status with the specific token/action needed — do NOT retry silently

package/dist/template/.claude/docker/Dockerfile

@@ -4,18 +4,6 @@ RUN apt-get update && \
     apt-get install -y --no-install-recommends git ca-certificates curl gosu && \
     apt-get clean && rm -rf /var/lib/apt/lists/*
 
-# GitHub CLI (gh)
-RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg \
-      -o /usr/share/keyrings/githubcli-archive-keyring.gpg && \
-    echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" \
-      > /etc/apt/sources.list.d/github-cli.list && \
-    apt-get update && apt-get install -y --no-install-recommends gh && \
-    apt-get clean && rm -rf /var/lib/apt/lists/*
-
-# GitLab CLI (glab)
-RUN curl -fsSL "https://gitlab.com/gitlab-org/cli/-/releases/permalink/latest/downloads/glab_$(dpkg --print-architecture).deb" \
-      -o /tmp/glab.deb && \
-    dpkg -i /tmp/glab.deb && rm /tmp/glab.deb
 
 # Non-root user — Claude Code refuses --dangerously-skip-permissions as root
 RUN useradd -m -s /bin/bash claude && \

package/dist/template/.claude/scripts/autonomous.mjs

@@ -1,46 +1,75 @@
 #!/usr/bin/env node
 
 /**
- * Autonomous development loop — runs Claude Code repeatedly with clean context.
- * Each invocation reads MEMORY.md to resume from where it left off.
+ * Autonomous development loop — runs Claude Code in headless mode with
+ * structured JSON communication. Each invocation streams real-time events
+ * and returns a structured result for the script to evaluate.
  *
  * Usage:
  *   node .claude/scripts/autonomous.mjs [options]
  *
  * Options:
- *   --max-iterations <n>   Max iterations before stopping (default: 50)
- *   --max-turns <n>        Max turns per Claude invocation (default: 50)
- *   --delay <ms>           Delay between iterations in ms (default: 5000)
- *   --cooldown <ms>        Delay after error (default: 60000)
- *   --project-dir <path>   Project directory (default: cwd)
- *   --skip-permissions     Add --dangerously-skip-permissions to claude (required for unattended)
- *   --help                 Show this help message
+ *   --max-iterations <n>     Max iterations before stopping (default: 50)
+ *   --max-turns <n>          Max turns per Claude invocation (default: 50)
+ *   --delay <ms>             Delay between iterations in ms (default: 5000)
+ *   --cooldown <ms>          Delay after error (default: 60000)
+ *   --project-dir <path>     Project directory (default: cwd)
+ *   --skip-permissions       Add --dangerously-skip-permissions to claude
+ *   --resume-session <id>    Resume a specific session by ID
+ *   --help                   Show this help message
  */
 
 import { execSync, spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
 import { readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 
 const PROMPT = 'Continue autonomous development according to CLAUDE.md. You are running in UNATTENDED autonomous mode — there is no human to respond. NEVER ask for confirmation or permission. Proceed with all actions autonomously. Create, modify, and delete files as needed without asking.';
 
+const RESULT_SCHEMA = JSON.stringify({
+  type: 'object',
+  properties: {
+    status: { type: 'string', enum: ['completed', 'needs_input', 'blocked', 'error'] },
+    action: { type: 'string', description: 'What action is needed: continue, needs_gitlab_token, needs_user_decision, retry_after_cooldown, etc.' },
+    message: { type: 'string', description: 'Human-readable summary of what happened this iteration' },
+    task_completed: { type: ['string', 'null'], description: 'Name/ID of the completed task' },
+    next_task: { type: ['string', 'null'], description: 'Name/ID of the next task to pick up' },
+  },
+  required: ['status', 'action', 'message'],
+});
+
+// ─── Terminal colors ───
+
+const C = {
+  dim: '\x1b[2m', bold: '\x1b[1m', reset: '\x1b[0m',
+  cyan: '\x1b[36m', yellow: '\x1b[33m', green: '\x1b[32m', red: '\x1b[31m', magenta: '\x1b[35m',
+};
+
+// ─── Helpers ───
+
 function printHelp() {
   console.log(`
-Autonomous development loop for Claude Code.
+Autonomous development loop for Claude Code (headless mode).
+
+Uses structured JSON communication — Claude streams real-time events
+and returns a structured result that the script evaluates.
 
 Usage: node .claude/scripts/autonomous.mjs [options]
 
 Options:
-  --max-iterations <n>   Max task iterations (default: 50)
-  --max-turns <n>        Max turns per Claude invocation (default: 50)
-  --delay <ms>           Pause between tasks in ms (default: 5000)
-  --cooldown <ms>        Wait after error in ms (default: 60000)
-  --project-dir <path>   Target project directory (default: cwd)
-  --skip-permissions     Run claude with --dangerously-skip-permissions
-  --help                 Show this message
+  --max-iterations <n>     Max task iterations (default: 50)
+  --max-turns <n>          Max turns per Claude invocation (default: 50)
+  --delay <ms>             Pause between tasks in ms (default: 5000)
+  --cooldown <ms>          Wait after error in ms (default: 60000)
+  --project-dir <path>     Target project directory (default: cwd)
+  --skip-permissions       Run claude with --dangerously-skip-permissions
+  --resume-session <id>    Resume a previous session by ID
+  --help                   Show this message
 
 Examples:
   node .claude/scripts/autonomous.mjs --skip-permissions
-  node .claude/scripts/autonomous.mjs --skip-permissions --max-iterations 20 --delay 10000
+  node .claude/scripts/autonomous.mjs --skip-permissions --max-iterations 20
+  node .claude/scripts/autonomous.mjs --resume-session abc123
 `);
 }
 
@@ -53,6 +82,7 @@ function parseArgs() {
     cooldown: 60_000,
     projectDir: process.cwd(),
     skipPermissions: false,
+    resumeSession: null,
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -66,7 +96,8 @@ function parseArgs() {
       case '--max-turns':
       case '--delay':
       case '--cooldown':
-      case '--project-dir': {
+      case '--project-dir':
+      case '--resume-session': {
         const flag = args[i];
         if (i + 1 >= args.length || args[i + 1].startsWith('--')) {
           console.error(`Error: ${flag} requires a value`);
@@ -74,6 +105,7 @@ function parseArgs() {
         }
         const val = args[++i];
         if (flag === '--project-dir') { opts.projectDir = resolve(val); break; }
+        if (flag === '--resume-session') { opts.resumeSession = val; break; }
         const key = flag.slice(2).replace(/-([a-z])/g, (_, c) => c.toUpperCase());
         opts[key] = parseInt(val, 10);
         break;
@@ -118,7 +150,7 @@ function formatDuration(ms) {
 async function readMemory(projectDir) {
   try {
     const content = await readFile(resolve(projectDir, 'MEMORY.md'), 'utf-8');
-    return content.replace(/\r\n/g, '\n'); // normalize CRLF for Windows
+    return content.replace(/\r\n/g, '\n');
   } catch {
     return null;
   }
@@ -149,7 +181,6 @@ function isProjectComplete(memory) {
 
 function getMemoryField(memory, field) {
   if (!memory) return null;
-  // Match "## Field\nvalue" or "**Field:** value" or "- Field: value"
   const patterns = [
     new RegExp(`## ${field}\\s*\\n+\\s*(.+)`),
     new RegExp(`\\*\\*${field}:?\\*\\*:?\\s*(.+)`),
@@ -170,6 +201,18 @@ function getCurrentPhase(memory) {
   return getMemoryField(memory, 'Current Phase') ?? 'unknown';
 }
 
+function promptUser(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`\n${C.yellow}[INPUT NEEDED]${C.reset} ${question}\n> `, (answer) => {
+      rl.close();
+      resolve(answer);
+    });
+  });
+}
+
+// ─── Signal handling ───
+
 let currentChild = null;
 let stopping = false;
 
@@ -188,27 +231,85 @@ process.on('SIGTERM', () => {
   stopping = true;
 });
 
-// ─── Run Claude ───
+// ─── Stream event display ───
 
-function runClaude(projectDir, opts) {
+function formatStreamEvent(event) {
+  // Handle stream_event wrapper (from --include-partial-messages)
+  if (event.type === 'stream_event') {
+    const inner = event.event ?? event;
+    const delta = inner.delta;
+    if (delta?.type === 'text_delta' && delta.text) {
+      return delta.text; // raw text fragment for streaming display
+    }
+    return null;
+  }
+
+  // Assistant message
+  if (event.type === 'assistant') {
+    const msg = event.message;
+    if (!msg) return null;
+    if (msg.type === 'tool_use' || msg.tool) {
+      const name = msg.name ?? msg.tool ?? 'tool';
+      const input = msg.input ?? {};
+      const detail = input.command ?? input.file_path ?? input.pattern ?? input.query ?? '';
+      const short = typeof detail === 'string' ? detail.slice(0, 120) : '';
+      return `${C.cyan}▶ ${name}${C.reset}${short ? ` ${C.dim}${short}${C.reset}` : ''}\n`;
+    }
+    if (typeof msg.content === 'string' && msg.content) {
+      return `${C.bold}${msg.content}${C.reset}\n`;
+    }
+    return null;
+  }
+
+  // Tool result
+  if (event.type === 'result' && event.subtype === 'tool_result') {
+    const isErr = event.is_error;
+    const icon = isErr ? `${C.red}✗` : `${C.green}✓`;
+    const content = typeof event.content === 'string' ? event.content : '';
+    const preview = content.slice(0, 150).replace(/\n/g, ' ');
+    return `${icon} ${C.dim}${preview}${C.reset}\n`;
+  }
+
+  return null;
+}
+
+// ─── Run Claude (headless structured mode) ───
+
+function runClaude(projectDir, opts, { resumeSessionId = null, resumePrompt = null } = {}) {
   return new Promise((resolvePromise) => {
-    let child;
     const isWin = process.platform === 'win32';
+    const prompt = resumePrompt ?? PROMPT;
+    let child;
+
+    // Build CLI flags
+    const baseFlags = [];
+    baseFlags.push('-p');
+    baseFlags.push('--output-format', 'stream-json');
+    baseFlags.push('--verbose');
+    baseFlags.push('--max-turns', String(opts.maxTurns));
+    baseFlags.push('--json-schema', RESULT_SCHEMA);
+
+    if (resumeSessionId) {
+      baseFlags.push('--resume', resumeSessionId);
+    } else {
+      baseFlags.push('--agent', 'orchestrator');
+    }
+
+    if (opts.skipPermissions) baseFlags.push('--dangerously-skip-permissions');
 
     if (isWin) {
       // Windows: claude is a .cmd shim requiring shell execution.
-      // cmd.exe mangles quoted arguments, so pipe prompt via stdin instead.
-      const permFlag = opts.skipPermissions ? ' --dangerously-skip-permissions' : '';
-      child = spawn(`claude -p --agent orchestrator --max-turns ${opts.maxTurns}${permFlag}`, [], {
+      // Build command string; prompt piped via stdin to avoid cmd.exe quoting issues.
+      const flagStr = baseFlags.join(' ');
+      child = spawn(`claude ${flagStr}`, [], {
         cwd: projectDir,
         stdio: ['pipe', 'pipe', 'pipe'],
         shell: true,
       });
-      child.stdin.write(PROMPT);
+      child.stdin.write(prompt);
       child.stdin.end();
     } else {
-      const args = ['-p', PROMPT, '--agent', 'orchestrator', '--max-turns', String(opts.maxTurns)];
-      if (opts.skipPermissions) args.push('--dangerously-skip-permissions');
+      const args = [...baseFlags, prompt];
       child = spawn('claude', args, {
         cwd: projectDir,
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -217,36 +318,92 @@ function runClaude(projectDir, opts) {
 
     currentChild = child;
     let stderr = '';
+    let sessionId = null;
+    let structuredResult = null;
+    let isRateLimit = false;
+    let buffer = '';
+
+    child.stdout.on('data', (chunk) => {
+      buffer += chunk.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop(); // keep incomplete last line
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+
+          // Extract session ID
+          if (event.session_id && !sessionId) {
+            sessionId = event.session_id;
+          }
 
-    child.stdout.on('data', chunk => {
-      process.stdout.write(chunk);
+          // Extract structured result from final event
+          if (event.type === 'result' && event.subtype !== 'tool_result') {
+            if (event.structured_output) {
+              structuredResult = event.structured_output;
+            } else if (event.result && typeof event.result === 'string') {
+              // Try to parse result text as JSON (fallback for non-schema mode)
+              try { structuredResult = JSON.parse(event.result); } catch { /* not JSON */ }
+            }
+            // Session ID also in final result
+            if (event.session_id) sessionId = event.session_id;
+          }
+
+          // Rate limit detection from stream events
+          if (event.type === 'error') {
+            const msg = (event.error?.message ?? event.message ?? '').toLowerCase();
+            if (msg.includes('rate limit') || msg.includes('rate_limit') || msg.includes('overloaded')) {
+              isRateLimit = true;
+            }
+          }
+
+          // Display formatted event
+          const formatted = formatStreamEvent(event);
+          if (formatted) process.stdout.write(formatted);
+        } catch {
+          // Non-JSON line — display as-is
+          process.stdout.write(line + '\n');
+        }
+      }
     });
 
-    child.stderr.on('data', chunk => {
+    child.stderr.on('data', (chunk) => {
       const text = chunk.toString();
       stderr += text;
+      // Check stderr for rate limits too (belt and suspenders)
+      const lower = text.toLowerCase();
+      if (lower.includes('rate limit') || lower.includes('rate_limit') || lower.includes('overloaded')) {
+        isRateLimit = true;
+      }
       process.stderr.write(text);
     });
 
-    child.on('close', code => {
+    child.on('close', (code) => {
+      // Flush remaining buffer
+      if (buffer.trim()) {
+        try {
+          const event = JSON.parse(buffer);
+          if (event.session_id && !sessionId) sessionId = event.session_id;
+          if (event.type === 'result' && event.structured_output) {
+            structuredResult = event.structured_output;
+          }
+          const formatted = formatStreamEvent(event);
+          if (formatted) process.stdout.write(formatted);
+        } catch { /* ignore */ }
+      }
       currentChild = null;
-      resolvePromise({ code, stderr });
+      resolvePromise({ code, stderr, sessionId, result: structuredResult, isRateLimit });
     });
 
-    child.on('error', err => {
+    child.on('error', (err) => {
       currentChild = null;
-      resolvePromise({ code: 1, stderr: err.message });
+      resolvePromise({ code: 1, stderr: err.message, sessionId: null, result: null, isRateLimit: false });
     });
   });
 }
 
-function detectRateLimit(output) {
-  const stderr = output.stderr.toLowerCase();
-  return stderr.includes('rate limit') ||
-    stderr.includes('rate_limit') ||
-    stderr.includes('too many requests') ||
-    stderr.includes('overloaded');
-}
+// ─── Main loop ───
 
 async function main() {
   const opts = parseArgs();
@@ -260,12 +417,15 @@ async function main() {
   }
 
   const workDir = opts.projectDir;
+  let resumeSessionId = opts.resumeSession;
+  let resumePrompt = null;
 
-  log('Autonomous development loop started');
+  log('Autonomous development loop started (headless structured mode)');
   log(`Project: ${workDir}`);
   log(`Max iterations: ${opts.maxIterations} | Max turns/iteration: ${opts.maxTurns}`);
   log(`Delay: ${opts.delay}ms | Cooldown: ${opts.cooldown}ms`);
   if (opts.skipPermissions) log('Permissions: skipped (--dangerously-skip-permissions)');
+  if (resumeSessionId) log(`Resuming session: ${resumeSessionId}`);
   log('---');
 
   for (let i = 1; i <= opts.maxIterations; i++) {
@@ -282,62 +442,115 @@ async function main() {
     }
 
     // Reset complexity counter — each invocation is a fresh context
-    await resetComplexityCounter(workDir);
+    if (!resumeSessionId) await resetComplexityCounter(workDir);
 
     const phase = getCurrentPhase(memory);
     const task = getCurrentTask(memory);
     log(`Iteration ${i}/${opts.maxIterations} | Phase: ${phase} | Task: ${task}`);
 
-    const result = await runClaude(workDir, opts);
+    const output = await runClaude(workDir, opts, { resumeSessionId, resumePrompt });
+    resumeSessionId = null;
+    resumePrompt = null;
 
     if (stopping) {
       log('Stopped by user signal.');
       break;
     }
 
-    // Rate limit — wait with exponential backoff, retry indefinitely (don't count as iteration)
-    if (detectRateLimit(result)) {
+    // ─── Rate limit handling ───
+    if (output.isRateLimit) {
       let backoff = opts.cooldown;
-      const maxBackoff = 30 * 60_000; // cap at 30 minutes
+      const maxBackoff = 30 * 60_000;
       while (!stopping) {
         log(`Rate limited. Waiting ${formatDuration(backoff)}...`);
         await sleep(backoff);
         if (stopping) break;
-        // Probe with a short invocation to check if limit is lifted
         log('Checking if rate limit has cleared...');
         const probe = await runClaude(workDir, opts);
-        if (!detectRateLimit(probe)) {
+        if (!probe.isRateLimit) {
           log('Rate limit cleared. Resuming.');
-          // Process probe result as a normal iteration
-          if (probe.code === 0) {
-            log(`Iteration ${i} complete.`);
-          } else {
-            log(`Claude exited with code ${probe.code}.`);
-          }
           break;
         }
         backoff = Math.min(backoff * 2, maxBackoff);
       }
-      if (stopping) {
-        log('Stopped by user signal.');
-        break;
-      }
+      if (stopping) { log('Stopped by user signal.'); break; }
       if (i < opts.maxIterations) {
         log(`Next iteration in ${opts.delay / 1000}s...`);
         await sleep(opts.delay);
       }
+      i--; // don't count rate-limited iteration
       continue;
     }
 
-    if (result.code !== 0) {
-      log(`Claude exited with code ${result.code}. Cooling down ${opts.cooldown / 1000}s...`);
-      await sleep(opts.cooldown);
+    // ─── Evaluate structured result ───
+    const result = output.result;
+
+    if (!result) {
+      // No structured result — fall back to exit code
+      if (output.code !== 0) {
+        log(`Claude exited with code ${output.code} (no structured result). Cooling down...`);
+        await sleep(opts.cooldown);
+        continue;
+      }
+      log(`Iteration ${i} complete (no structured result — legacy mode).`);
+      if (i < opts.maxIterations) {
+        log(`Next iteration in ${opts.delay / 1000}s...`);
+        await sleep(opts.delay);
+      }
       continue;
     }
 
-    log(`Iteration ${i} complete.`);
+    // Structured result available
+    log(`Status: ${result.status} | Action: ${result.action}`);
+    log(`Message: ${result.message}`);
+    if (result.task_completed) log(`Completed: ${result.task_completed}`);
+    if (result.next_task) log(`Next task: ${result.next_task}`);
+
+    switch (result.status) {
+      case 'completed':
+        log(`Iteration ${i} complete.`);
+        break;
+
+      case 'needs_input':
+        log(`${C.yellow}Input required: ${result.action}${C.reset}`);
+        if (process.stdin.isTTY) {
+          const userInput = await promptUser(result.message);
+          if (userInput.trim()) {
+            resumeSessionId = output.sessionId;
+            resumePrompt = userInput;
+            log(`Resuming session ${output.sessionId} with user input...`);
+            i--; // don't count as iteration — we're continuing the same task
+          } else {
+            log('Empty input. Skipping to next iteration.');
+          }
+        } else {
+          log('Non-interactive mode. Cannot prompt for input.');
+          if (output.sessionId) {
+            log(`To resume manually: node .claude/scripts/autonomous.mjs --resume-session ${output.sessionId}`);
+          }
+          await sleep(opts.cooldown);
+        }
+        break;
+
+      case 'blocked':
+        log(`${C.red}BLOCKED: ${result.action}${C.reset}`);
+        log('Waiting for resolution...');
+        if (output.sessionId) {
+          log(`Session: ${output.sessionId}`);
+        }
+        await sleep(opts.cooldown);
+        break;
+
+      case 'error':
+        log(`${C.red}Error: ${result.action}${C.reset}`);
+        await sleep(opts.cooldown);
+        continue;
+
+      default:
+        log(`Unknown status: ${result.status}. Continuing...`);
+    }
 
-    if (i < opts.maxIterations) {
+    if (i < opts.maxIterations && result.status !== 'needs_input') {
       log(`Next iteration in ${opts.delay / 1000}s...`);
       await sleep(opts.delay);
     }

package/dist/template/.claude/scripts/docker-run.mjs

@@ -92,7 +92,7 @@ function parseArgs() {
   const args = process.argv.slice(2);
   const opts = {
     shell: false, rebuild: false, login: false, help: false,
-    maxIterations: '', maxTurns: '', delay: '', cooldown: '',
+    maxIterations: '', maxTurns: '', delay: '', cooldown: '', resumeSession: '',
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -101,7 +101,7 @@ function parseArgs() {
       case '--shell': opts.shell = true; break;
       case '--rebuild': opts.rebuild = true; break;
       case '--login': opts.login = true; break;
-      case '--max-iterations': case '--max-turns': case '--delay': case '--cooldown': {
+      case '--max-iterations': case '--max-turns': case '--delay': case '--cooldown': case '--resume-session': {
         const flag = args[i];
         if (i + 1 >= args.length || args[i + 1].startsWith('--')) {
           error(`${flag} requires a value`); process.exit(1);
@@ -133,9 +133,10 @@ Options:
   --max-turns <n>      Max turns per iteration (default: 50)
   --delay <ms>         Pause between tasks (default: 5000)
   --cooldown <ms>      Wait after rate limit (default: 60000)
-  --rebuild            Force rebuild Docker image
-  --login              Run 'claude auth login' on host before starting container
-  --help, -h           Show this help
+  --rebuild              Force rebuild Docker image
+  --login                Run 'claude auth login' on host before starting container
+  --resume-session <id>  Resume a previous Claude session by ID
+  --help, -h             Show this help
 
 Authentication:
   The container uses your HOST machine's Claude auth automatically.
@@ -358,6 +359,7 @@ if (opts.shell) {
   if (opts.maxTurns)      autoArgs += ` --max-turns ${opts.maxTurns}`;
   if (opts.delay)         autoArgs += ` --delay ${opts.delay}`;
   if (opts.cooldown)      autoArgs += ` --cooldown ${opts.cooldown}`;
+  if (opts.resumeSession) autoArgs += ` --resume-session ${opts.resumeSession}`;
   console.log('');
   info('Autonomous mode — isolated in Docker, --skip-permissions is safe.');
   info('Press Ctrl+C to stop after current iteration.');

package/package.json

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