create-claude-workspace 2.3.32 → 2.3.34

package/README.md

@@ -28,9 +28,11 @@ Answer the discovery questions (non-technical). Claude generates the full pipeli
 ### Start Autonomous Development
 
 ```bash
-npx create-claude-workspace scheduler                    # start (1 agent)
-npx create-claude-workspace scheduler --concurrency 3    # 3 parallel agents
-npx create-claude-workspace scheduler --resume           # resume from saved state
+npx create-claude-workspace run                          # start (1 agent)
+npx create-claude-workspace run --concurrency 3          # 3 parallel agents
+npx create-claude-workspace run -i                       # interactive mode (user input only)
+npx create-claude-workspace run --task-mode local        # force local task mode
+npx create-claude-workspace run --resume                 # resume from saved state
 ```
 
 Or interactively: `claude --agent orchestrator`, then `/ralph-loop:ralph-loop Continue autonomous development according to CLAUDE.md`
@@ -45,12 +47,27 @@ The scheduler replaces the single-orchestrator model with parallel agent executi
 - **N agents in parallel** — independent tasks run concurrently in separate git worktrees
 
 ```bash
-npx create-claude-workspace scheduler                    # start (1 agent)
-npx create-claude-workspace scheduler --concurrency 3    # 3 parallel agents
-npx create-claude-workspace scheduler --resume           # resume from saved state
-npx create-claude-workspace scheduler --help             # all options
+npx create-claude-workspace run                          # start (1 agent)
+npx create-claude-workspace run --concurrency 3          # 3 parallel agents
+npx create-claude-workspace run -i                       # interactive mode
+npx create-claude-workspace run --task-mode local        # force local mode
+npx create-claude-workspace run --help                   # all options
 ```
 
+#### Task modes
+
+The scheduler supports three task modes (`--task-mode`):
+
+| Mode | Source | Use case |
+|------|--------|----------|
+| **local** | `TODO.md` / `tasks.json` | Solo development, no issue tracker |
+| **platform** | GitHub/GitLab issues | Team workflows with issue tracking |
+| **interactive** | User TUI input only | Ad-hoc tasks, exploration, prototyping |
+
+Auto-detected at startup: if the repo has a remote with `status::` labeled issues → `platform`, otherwise → `local`. Override with `--task-mode` flag or set `Task Platform` in CLAUDE.md via `project-initializer`.
+
+The `--interactive` (`-i`) flag implies `--task-mode interactive`. Type task descriptions directly in the TUI — each becomes a task that goes through the full pipeline (plan → implement → test → review → commit). Pending tasks are shown in the status bar queue.
+
 #### Communicate at runtime
 
 Write to `.claude/scheduler/inbox.json` while the scheduler is running:

package/dist/index.js

@@ -70,6 +70,8 @@ ${C.b}Scheduler options:${C.n}
   --concurrency <n>            Parallel agents (default: 1)
   --max-iterations <n>         Max iterations (default: 50)
   --max-turns <n>              Max turns per agent invocation (default: 50)
+  --task-mode <mode>           Task source: local, platform, or interactive
+  --interactive, -i            Interactive mode — tasks from user input only
   --resume                     Resume from saved state
   --dry-run                    Validate prerequisites only
   See 'npx create-claude-workspace run --help' for all options.
@@ -78,6 +80,8 @@ ${C.b}Examples:${C.n}
   npx create-claude-workspace                          # scaffold in current directory
   npx create-claude-workspace run                      # start scheduler
   npx create-claude-workspace run --concurrency 3      # 3 parallel agents
+  npx create-claude-workspace run -i                   # interactive mode (user input only)
+  npx create-claude-workspace run --task-mode local    # force local task mode
   npx create-claude-workspace run --resume             # resume from state
   npx create-claude-workspace validate                 # check prerequisites
 
@@ -244,6 +248,9 @@ async function main() {
         console.log(`  ${C.d}# Multi-agent scheduler${C.n}`);
         console.log(`  npx create-claude-workspace run`);
         console.log('');
+        console.log(`  ${C.d}# Interactive mode (tasks from user input)${C.n}`);
+        console.log(`  npx create-claude-workspace run -i`);
+        console.log('');
         console.log(`  ${C.d}# With parallel agents${C.n}`);
         console.log(`  npx create-claude-workspace run --concurrency 3`);
         console.log('');

package/dist/scheduler/index.mjs

@@ -2,7 +2,7 @@
 // ─── Multi-agent scheduler entry point ───
 // Replaces the single-orchestrator autonomous loop with parallel agent execution.
 import { resolve } from 'node:path';
-import { existsSync, mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { config as dotenvConfig } from '@dotenvx/dotenvx';
 import { SCHEDULER_DEFAULTS } from './types.mjs';
 import { detectCIPlatform, checkPlatformCLI, installPlatformCLI } from './git/ci-watcher.mjs';
@@ -147,10 +147,32 @@ export function parseSchedulerArgs(argv) {
     }
     return opts;
 }
+function readTaskPlatformFromClaudeMd(projectDir) {
+    for (const p of ['CLAUDE.md', '.claude/CLAUDE.md']) {
+        const fp = resolve(projectDir, p);
+        if (!existsSync(fp))
+            continue;
+        try {
+            const content = readFileSync(fp, 'utf-8');
+            const match = content.match(/^\s*-\s*\*\*Task Platform\*\*:\s*(\S+)/m);
+            if (match)
+                return match[1].toLowerCase();
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
 function detectTaskMode(projectDir) {
+    // Respect explicit Task Platform setting from CLAUDE.md
+    const claudeMdPlatform = readTaskPlatformFromClaudeMd(projectDir);
+    if (claudeMdPlatform === 'local')
+        return 'local';
     const platform = detectCIPlatform(projectDir);
     if (platform === 'none')
         return 'local';
+    // CLAUDE.md says github/gitlab → platform mode
+    if (claudeMdPlatform === 'github' || claudeMdPlatform === 'gitlab')
+        return 'platform';
     try {
         const issues = fetchOpenIssues(projectDir, platform);
         if (issues.length === 0)
@@ -231,7 +253,7 @@ export async function runScheduler(opts) {
     if (opts.interactive) {
         tui.setInputHandler((text) => {
             writeToInbox(opts.projectDir, [{ type: 'add-task', title: text }]);
-            tui.info(`Task queued: ${text}`);
+            tui.addPendingInput(text); // tracks in status bar queue + logs "Queued: text"
         });
     }
     const logger = {
@@ -407,17 +429,19 @@ export async function runScheduler(opts) {
                 onMessage,
                 onSpawnStart,
                 onSpawnEnd,
+                onInboxTaskPicked: opts.interactive ? () => tui.consumePendingInput() : undefined,
             });
             if (!workDone) {
                 if (state.taskMode === 'interactive') {
                     // Interactive mode: wait for user input (no external polling)
-                    logger.info('Waiting for input...');
+                    tui.setIdle(true);
                     while (!stopping) {
                         const pending = readInbox(opts.projectDir);
                         if (pending.length > 0 || discoveredIssueStore.peek().length > 0)
                             break;
                         await sleep(500, stoppingRef);
                     }
+                    tui.setIdle(false);
                 }
                 else {
                     // No work → idle polling (platform/local)

package/dist/scheduler/loop.mjs

@@ -40,6 +40,7 @@ export async function runIteration(deps) {
             const newTask = addTaskMessageToTask(addMsg, state.currentPhase, nextId);
             inboxTasks.push(newTask);
             logger.info(`[inbox] New task: ${newTask.title}`);
+            deps.onInboxTaskPicked?.(newTask.title);
             appendEvent(projectDir, createEvent('task_started', { taskId: nextId, detail: `inbox: ${newTask.title}` }));
         }
         else if (msg.type === 'message') {

package/dist/scheduler/ui/tui.mjs

@@ -52,7 +52,7 @@ export class TUI {
         this.state = {
             iteration: 0, maxIter: 0, loopStart: Date.now(), iterStart: 0,
             tools: 0, tokensIn: 0, tokensOut: 0, agents: [], taskName: '',
-            tasksDone: 0, tasksTotal: 0, paused: false, inputBuf: '',
+            tasksDone: 0, tasksTotal: 0, paused: false, idle: false, inputBuf: '',
             pendingInputs: [],
         };
         if (this.interactive) {
@@ -157,13 +157,13 @@ export class TUI {
     isPaused() { return this.state.paused; }
     addPendingInput(text) {
         this.state.pendingInputs.push(text);
-        this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.magenta}▲${RESET}  ${ANSI_COLORS.white}Queued:${RESET} ${text}`);
+        this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.magenta}${BOLD}▶ USER${RESET}  ${ANSI_COLORS.white}${text}${RESET}  ${ANSI_COLORS.gray}[queued #${this.state.pendingInputs.length}]${RESET}`, `  ${ts()}  ▶ USER  ${text}  [queued #${this.state.pendingInputs.length}]`);
         this.renderStatusBar();
     }
     consumePendingInput() {
         const item = this.state.pendingInputs.shift();
         if (item) {
-            this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.green}▼${RESET}  ${ANSI_COLORS.white}Processing:${RESET} ${item}`);
+            this.log(`  ${ANSI_COLORS.gray}${ts()}${RESET}  ${ANSI_COLORS.green}${BOLD}▶ START${RESET}  ${ANSI_COLORS.white}${item}${RESET}`, `  ${ts()}  ▶ START  ${item}`);
             this.renderStatusBar();
         }
         return item;
@@ -194,24 +194,36 @@ export class TUI {
             lines.push(` ${ANSI_COLORS.gray}› type to send input${RESET}`);
         }
         // Line 3: Status bar (stats)
-        const elapsed = fmtDur(Date.now() - s.loopStart);
-        const iterTime = s.iterStart ? fmtDur(Date.now() - s.iterStart) : '—';
-        const pct = s.maxIter > 0 ? Math.round((s.iteration / s.maxIter) * 100) : 0;
-        const filled = Math.round((pct / 100) * 8);
-        const bar = `${ANSI_COLORS.green}${'\u2588'.repeat(filled)}${ANSI_COLORS.gray}${'\u2591'.repeat(8 - filled)}${RESET}`;
-        const tok = fmtTok(s.tokensIn + s.tokensOut);
-        const cur = s.agents.length > 0 ? s.agents[s.agents.length - 1] : '';
-        let stats = `\x1b[7m ${elapsed} | Iter ${s.iteration}/${s.maxIter} \x1b[27m ${bar} \x1b[7m ${iterTime} | ${ANSI_COLORS.cyan}${s.tools}${RESET}\x1b[7m tools | ${ANSI_COLORS.yellow}${tok}${RESET}\x1b[7m tok`;
-        if (cur) {
-            const col = ANSI_COLORS[agentColor(cur)] || '';
-            stats += ` | ${col}${BOLD}${cur}${RESET}\x1b[7m`;
+        if (s.idle) {
+            // Idle: static bar, no running timers
+            let stats = `\x1b[7m ${ANSI_COLORS.gray}IDLE${RESET}\x1b[7m — waiting for input`;
+            if (s.pendingInputs.length > 0)
+                stats += ` | ${ANSI_COLORS.magenta}${s.pendingInputs.length} queued${RESET}\x1b[7m`;
+            if (s.paused)
+                stats += ` | ${ANSI_COLORS.yellow}⏸ PAUSED${RESET}\x1b[7m`;
+            stats += ` ${RESET}`;
+            lines.push(stats);
+        }
+        else {
+            const elapsed = fmtDur(Date.now() - s.loopStart);
+            const iterTime = s.iterStart ? fmtDur(Date.now() - s.iterStart) : '—';
+            const pct = s.maxIter > 0 ? Math.round((s.iteration / s.maxIter) * 100) : 0;
+            const filled = Math.round((pct / 100) * 8);
+            const bar = `${ANSI_COLORS.green}${'\u2588'.repeat(filled)}${ANSI_COLORS.gray}${'\u2591'.repeat(8 - filled)}${RESET}`;
+            const tok = fmtTok(s.tokensIn + s.tokensOut);
+            const cur = s.agents.length > 0 ? s.agents[s.agents.length - 1] : '';
+            let stats = `\x1b[7m ${elapsed} | Iter ${s.iteration}/${s.maxIter} \x1b[27m ${bar} \x1b[7m ${iterTime} | ${ANSI_COLORS.cyan}${s.tools}${RESET}\x1b[7m tools | ${ANSI_COLORS.yellow}${tok}${RESET}\x1b[7m tok`;
+            if (cur) {
+                const col = ANSI_COLORS[agentColor(cur)] || '';
+                stats += ` | ${col}${BOLD}${cur}${RESET}\x1b[7m`;
+            }
+            if (s.taskName)
+                stats += ` | ${ANSI_COLORS.cyan}${statusTrunc(s.taskName, 30)}${RESET}\x1b[7m`;
+            if (s.paused)
+                stats += ` | ${ANSI_COLORS.yellow}⏸ PAUSED${RESET}\x1b[7m`;
+            stats += ` ${RESET}`;
+            lines.push(stats);
         }
-        if (s.taskName)
-            stats += ` | ${ANSI_COLORS.cyan}${statusTrunc(s.taskName, 30)}${RESET}\x1b[7m`;
-        if (s.paused)
-            stats += ` | ${ANSI_COLORS.yellow}⏸ PAUSED${RESET}\x1b[7m`;
-        stats += ` ${RESET}`;
-        lines.push(stats);
         return lines;
     }
     /** Plain-text version for testing / non-ANSI contexts. */
@@ -224,21 +236,31 @@ export class TUI {
             lines.push(` [${s.pendingInputs.length} queued] ${items}${more}`);
         }
         lines.push(s.inputBuf ? ` › ${s.inputBuf}` : ' › type to send input');
-        const elapsed = fmtDur(Date.now() - s.loopStart);
-        const iterTime = s.iterStart ? fmtDur(Date.now() - s.iterStart) : '—';
-        const pct = s.maxIter > 0 ? Math.round((s.iteration / s.maxIter) * 100) : 0;
-        const filled = Math.round((pct / 100) * 8);
-        const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(8 - filled);
-        const tok = fmtTok(s.tokensIn + s.tokensOut);
-        const cur = s.agents.length > 0 ? s.agents[s.agents.length - 1] : '';
-        let stats = ` ${elapsed} | Iter ${s.iteration}/${s.maxIter} ${bar} | ${iterTime} | ${s.tools} tools | ${tok} tok`;
-        if (cur)
-            stats += ` | ${cur}`;
-        if (s.taskName)
-            stats += ` | ${statusTrunc(s.taskName, 30)}`;
-        if (s.paused)
-            stats += ' | PAUSED';
-        lines.push(stats);
+        if (s.idle) {
+            let stats = ' IDLE — waiting for input';
+            if (s.pendingInputs.length > 0)
+                stats += ` | ${s.pendingInputs.length} queued`;
+            if (s.paused)
+                stats += ' | PAUSED';
+            lines.push(stats);
+        }
+        else {
+            const elapsed = fmtDur(Date.now() - s.loopStart);
+            const iterTime = s.iterStart ? fmtDur(Date.now() - s.iterStart) : '—';
+            const pct = s.maxIter > 0 ? Math.round((s.iteration / s.maxIter) * 100) : 0;
+            const filled = Math.round((pct / 100) * 8);
+            const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(8 - filled);
+            const tok = fmtTok(s.tokensIn + s.tokensOut);
+            const cur = s.agents.length > 0 ? s.agents[s.agents.length - 1] : '';
+            let stats = ` ${elapsed} | Iter ${s.iteration}/${s.maxIter} ${bar} | ${iterTime} | ${s.tools} tools | ${tok} tok`;
+            if (cur)
+                stats += ` | ${cur}`;
+            if (s.taskName)
+                stats += ` | ${statusTrunc(s.taskName, 30)}`;
+            if (s.paused)
+                stats += ' | PAUSED';
+            lines.push(stats);
+        }
         return lines;
     }
     clearStatusArea() {
@@ -321,6 +343,10 @@ export class TUI {
         this.log(`  ${BOLD}━━━ Iteration ${i}/${max}  ${pct}%  │ ${elapsed} elapsed ━━━${RESET}`);
         this.log('');
     }
+    setIdle(idle) {
+        this.state.idle = idle;
+        this.renderStatusBar();
+    }
     setTask(name, done, total) {
         this.state.taskName = name;
         this.state.tasksDone = done;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-claude-workspace",
-  "version": "2.3.32",
+  "version": "2.3.34",
   "author": "",
   "repository": {
     "type": "git",