create-claude-workspace 2.3.19 → 2.3.20

package/README.md

@@ -65,6 +65,15 @@ Write to `.claude/scheduler/inbox.json` while the scheduler is running:
 
 The scheduler reads the inbox every iteration and processes messages immediately.
 
+#### Proactive problem resolution
+
+Agents never dismiss problems as "pre-existing." The scheduler injects a `report_issue` MCP tool into every agent. When an agent discovers an out-of-scope problem:
+
+- **Non-blocker**: calls `report_issue(severity: 'non-blocker')` and continues working
+- **Blocker**: calls `report_issue(severity: 'blocker')`, wraps up, and returns
+
+The scheduler records the issue locally (`discovered.ndjson`) and creates a platform issue (GitHub/GitLab) if available. Discovered issues enter the task queue on the next iteration.
+
 ### npx Options
 
 ```bash

package/dist/scheduler/agents/worker-pool.mjs

@@ -42,6 +42,8 @@ export class WorkerPool {
             queryOptions.agent = opts.agent;
         if (opts.model)
             queryOptions.model = opts.model;
+        if (opts.mcpServers)
+            queryOptions.mcpServers = opts.mcpServers;
         if (opts.resume) {
             queryOptions.resume = opts.resume;
         }

package/dist/scheduler/git/issue-creator.mjs

@@ -0,0 +1,54 @@
+// ─── Platform issue creation (GitHub/GitLab) ───
+// Creates issues on the remote platform for discovered problems.
+// Non-fatal — returns null on failure (local record always exists).
+import { execFileSync } from 'node:child_process';
+const CLI_TIMEOUT = 30_000;
+function run(cmd, args, cwd) {
+    return execFileSync(cmd, args, { cwd, timeout: CLI_TIMEOUT, stdio: 'pipe', encoding: 'utf-8' }).trim();
+}
+/**
+ * Create an issue on the remote platform.
+ * Returns the created issue info, or null if creation failed (non-fatal).
+ */
+export function createPlatformIssue(cwd, platform, opts) {
+    try {
+        if (platform === 'github')
+            return createGitHubIssue(cwd, opts);
+        return createGitLabIssue(cwd, opts);
+    }
+    catch {
+        return null;
+    }
+}
+function createGitHubIssue(cwd, opts) {
+    const args = ['issue', 'create', '--title', opts.title, '--body', opts.body];
+    for (const label of opts.labels) {
+        args.push('--label', label);
+    }
+    if (opts.milestone)
+        args.push('--milestone', opts.milestone);
+    const output = run('gh', args, cwd);
+    // gh issue create prints the URL: https://github.com/owner/repo/issues/42
+    const urlMatch = output.match(/https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/);
+    if (!urlMatch)
+        return null;
+    return { number: parseInt(urlMatch[1], 10), url: urlMatch[0] };
+}
+function createGitLabIssue(cwd, opts) {
+    const args = ['issue', 'create', '--title', opts.title, '--description', opts.body];
+    if (opts.labels.length > 0) {
+        args.push('--label', opts.labels.join(','));
+    }
+    if (opts.milestone)
+        args.push('--milestone', opts.milestone);
+    const output = run('glab', args, cwd);
+    // glab outputs: Creating issue... or the URL
+    const urlMatch = output.match(/https:\/\/gitlab\.[^/]+\/[^/]+\/[^/]+\/-\/issues\/(\d+)/);
+    if (urlMatch)
+        return { number: parseInt(urlMatch[1], 10), url: urlMatch[0] };
+    // Fallback: look for issue number in output like "#42" or "issue #42"
+    const numMatch = output.match(/#(\d+)/);
+    if (numMatch)
+        return { number: parseInt(numMatch[1], 10), url: output };
+    return null;
+}

package/dist/scheduler/index.mjs

@@ -14,6 +14,7 @@ import { runIteration } from './loop.mjs';
 import { checkAuth } from './agents/health-checker.mjs';
 import { pollForNewWork } from './util/idle-poll.mjs';
 import { TUI } from './ui/tui.mjs';
+import { DiscoveredIssueStore } from './tools/report-issue.mjs';
 // ─── Args ───
 export function parseSchedulerArgs(argv) {
     const opts = { ...SCHEDULER_DEFAULTS };
@@ -281,6 +282,8 @@ export async function runScheduler(opts) {
     const onMessage = (msg) => tui.handleMessage(msg);
     const onSpawnStart = (name) => tui.pushAgent(name);
     const onSpawnEnd = () => tui.popAgent();
+    // Discovered issue store (shared across all agent spawns)
+    const discoveredIssueStore = new DiscoveredIssueStore();
     // Orchestrator client
     const orchestrator = new OrchestratorClient({
         pool,
@@ -317,6 +320,7 @@ export async function runScheduler(opts) {
                 state,
                 opts,
                 logger,
+                discoveredIssueStore,
                 onMessage,
                 onSpawnStart,
                 onSpawnEnd,

package/dist/scheduler/loop.mjs

@@ -15,6 +15,8 @@ import { detectCIPlatform, fetchFailureLogs } from './git/ci-watcher.mjs';
 import { createRelease } from './git/release.mjs';
 import { processInbox, addTaskMessageToTask } from './tasks/inbox.mjs';
 import { buildPlanPrompt, buildImplementPrompt, buildQAPrompt, buildReviewPrompt, buildReworkPrompt, buildCIFixPrompt, buildPRCommentPrompt, } from './agents/prompt-builder.mjs';
+import { discoveredIssueToTask } from './tools/report-issue.mjs';
+import { createSchedulerToolServer } from './tools/scheduler-tools.mjs';
 const MAX_REVIEW_CYCLES = 5;
 const MAX_BUILD_FIXES = 3;
 const MAX_CI_FIXES = 3;
@@ -28,15 +30,16 @@ export async function runIteration(deps) {
     // Rotate log if needed
     rotateLog(projectDir);
     // Process inbox — immediate, non-blocking
+    const inboxTasks = [];
     const inboxMessages = processInbox(projectDir);
     for (const msg of inboxMessages) {
         if (msg.type === 'add-task') {
             const addMsg = msg;
             const nextId = `inbox-${Date.now()}`;
             const newTask = addTaskMessageToTask(addMsg, state.currentPhase, nextId);
+            inboxTasks.push(newTask);
             logger.info(`[inbox] New task: ${newTask.title}`);
             appendEvent(projectDir, createEvent('task_started', { taskId: nextId, detail: `inbox: ${newTask.title}` }));
-            // Task will be picked up when we load tasks below
         }
         else if (msg.type === 'message') {
             const freeMsg = msg;
@@ -129,6 +132,18 @@ export async function runIteration(deps) {
             }
         }
     }
+    // Merge inbox tasks into loaded tasks
+    if (inboxTasks.length > 0) {
+        tasks.push(...inboxTasks);
+    }
+    // Drain discovered issues from agent report_issue tool calls (previous iteration)
+    const discovered = deps.discoveredIssueStore.drain();
+    for (const issue of discovered) {
+        const task = discoveredIssueToTask(issue, state.currentPhase);
+        tasks.push(task);
+        logger.info(`[discovered] ${issue.severity}: ${issue.title} (reported by ${issue.reportedBy})`);
+        appendEvent(projectDir, createEvent('issue_discovered', { taskId: task.id, detail: `${issue.severity}: ${issue.title}` }));
+    }
     // Reconcile task status with scheduler state (handles restart without --resume)
     for (const task of tasks) {
         if (state.completedTasks.includes(task.id) && task.status !== 'done') {
@@ -261,6 +276,7 @@ export async function runIteration(deps) {
                 issueMarker: taskId,
                 kitUpgrade: false,
                 lineNumber: 0,
+                source: 'todo',
                 status: 'in-progress',
                 changelog: 'changed',
             };
@@ -359,6 +375,10 @@ export async function runIteration(deps) {
 async function runTaskPipeline(task, workerId, agents, deps) {
     const { pool, orchestrator, state, opts, logger, onMessage, onSpawnStart, onSpawnEnd } = deps;
     const projectDir = opts.projectDir;
+    // Create per-pipeline MCP server with scheduler tools (report_issue, etc.)
+    const ciPlatform = detectCIPlatform(projectDir);
+    const mcpServer = createSchedulerToolServer(deps.discoveredIssueStore, task.id, projectDir, ciPlatform === 'none' ? 'none' : ciPlatform);
+    const mcpServers = { 'scheduler-tools': mcpServer };
     // Check for existing pipeline (recovered from previous run)
     const existing = state.pipelines[task.id];
     const resumeStep = existing?.step;
@@ -414,7 +434,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                 cwd: worktreePath,
                 prompt: buildPlanPrompt({ task, worktreePath, projectDir }),
                 model: getAgentModel(pipeline.assignedAgent, agents, task),
-            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
             if (!planResult.success) {
                 logger.error(`[${task.id}] Planning failed: ${planResult.error}`);
                 return false;
@@ -442,7 +462,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                     apiContract: pipeline.apiContract ?? undefined,
                 }),
                 model: getAgentModel(implAgent, agents, task),
-            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
             if (!implResult.success) {
                 logger.error(`[${task.id}] Implementation failed: ${implResult.error}`);
                 return false;
@@ -461,7 +481,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                     reviewFindings: 'This task was interrupted. The branch has existing work but may have build/lint failures, merge conflicts, or failing CI. Please:\n1. Run git fetch origin main && git rebase origin/main (resolve any conflicts)\n2. Run the build and lint scripts from package.json\n3. Fix any errors found\n4. Ensure all tests pass',
                 }),
                 model: getAgentModel(pipeline.assignedAgent, agents, task),
-            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+            }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
         }
         // STEP 3: QA (E2E tests, integration tests, acceptance criteria verification)
         // Only for tasks that need it — skip for pure refactoring, config changes, etc.
@@ -480,7 +500,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                         testingSection: pipeline.testingSection ?? undefined,
                     }),
                     model: getAgentModel(qaRouting.agent, agents, task),
-                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
                 if (!qaResult.success) {
                     pipeline.buildFixes++;
                     if (pipeline.buildFixes >= MAX_BUILD_FIXES) {
@@ -513,7 +533,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                         testingSection: pipeline.testingSection ?? undefined,
                     }),
                     model: getAgentModel(reviewRouting.agent, agents, task),
-                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
                 if (reviewResult.output.includes('**PASS**') || reviewResult.output.includes('PASS')) {
                     reviewPassed = true;
                 }
@@ -535,7 +555,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
                                 reviewFindings: pipeline.reviewFindings,
                             }),
                             model: getAgentModel(pipeline.assignedAgent, agents, task),
-                        }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd);
+                        }, state, task.id, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers);
                         pipeline.step = 're-review';
                     }
                 }
@@ -676,7 +696,7 @@ async function runTaskPipeline(task, workerId, agents, deps) {
     }
 }
 // ─── Helpers ───
-async function spawnAgent(pool, slotId, opts, state, taskId, logger, onMessage, onSpawnStart, onSpawnEnd) {
+async function spawnAgent(pool, slotId, opts, state, taskId, logger, onMessage, onSpawnStart, onSpawnEnd, mcpServers) {
     const agentName = opts.agent ?? 'claude';
     onSpawnStart?.(agentName);
     // Check for existing session (resume on crash)
@@ -685,6 +705,7 @@ async function spawnAgent(pool, slotId, opts, state, taskId, logger, onMessage,
         ...opts,
         resume: existingSession ?? undefined,
         onMessage,
+        mcpServers,
     });
     onSpawnEnd?.();
     // Record session for crash recovery
@@ -1052,6 +1073,7 @@ function loadTasksJson(path) {
             issueMarker: t.issueMarker ?? null,
             kitUpgrade: t.kitUpgrade ?? false,
             lineNumber: t.lineNumber ?? 0,
+            source: t.source ?? 'todo',
             changelog: t.changelog ?? 'added',
         })));
     }
@@ -1113,7 +1135,7 @@ async function checkPRWatch(taskId, pipeline, projectDir, agents, deps) {
                 const task = {
                     id: taskId, title: `Resolve merge conflict for ${taskId}`, phase: state.currentPhase,
                     type: 'fullstack', complexity: 'S', dependsOn: [], issueMarker: taskId,
-                    kitUpgrade: false, lineNumber: 0, status: 'in-progress', changelog: 'fixed',
+                    kitUpgrade: false, lineNumber: 0, source: 'todo', status: 'in-progress', changelog: 'fixed',
                 };
                 // Fetch the main branch into the worktree so agent can see what changed
                 try {
@@ -1240,7 +1262,7 @@ async function checkPRWatch(taskId, pipeline, projectDir, agents, deps) {
             const task = {
                 id: taskId, title: `Fix CI for ${taskId}`, phase: state.currentPhase,
                 type: 'fullstack', complexity: 'S', dependsOn: [], issueMarker: taskId,
-                kitUpgrade: false, lineNumber: 0, status: 'in-progress', changelog: 'fixed',
+                kitUpgrade: false, lineNumber: 0, source: 'todo', status: 'in-progress', changelog: 'fixed',
             };
             const fixResult = await spawnAgent(pool, slot.id, {
                 agent: pipeline.assignedAgent ?? undefined,
@@ -1272,7 +1294,7 @@ async function checkPRWatch(taskId, pipeline, projectDir, agents, deps) {
             const task = {
                 id: taskId, title: `Address PR comments for ${taskId}`, phase: state.currentPhase,
                 type: 'fullstack', complexity: 'S', dependsOn: [], issueMarker: taskId,
-                kitUpgrade: false, lineNumber: 0, status: 'in-progress', changelog: 'fixed',
+                kitUpgrade: false, lineNumber: 0, source: 'todo', status: 'in-progress', changelog: 'fixed',
             };
             const result = await spawnAgent(pool, slot.id, {
                 agent: pipeline.assignedAgent ?? undefined,

package/dist/scheduler/tasks/inbox.mjs

@@ -66,6 +66,7 @@ export function addTaskMessageToTask(msg, phase, nextId) {
         issueMarker: null,
         kitUpgrade: false,
         lineNumber: 0,
+        source: 'inbox',
         changelog: 'added',
     };
 }

package/dist/scheduler/tasks/issue-source.mjs

@@ -56,6 +56,7 @@ export function issueToTask(issue, fallbackPhase) {
         issueMarker: `#${issue.issueNumber}`,
         kitUpgrade: issue.labels.some(l => l.toLowerCase().includes('kit-upgrade')),
         lineNumber: 0, // not applicable for platform issues
+        source: 'platform',
         status,
         changelog: inferChangelog(issue.title, issue.labels),
     };

package/dist/scheduler/tasks/parser.mjs

@@ -111,6 +111,7 @@ export function parseTodoMd(content) {
             issueMarker: pendingTask.issueMarker,
             kitUpgrade: meta.kitUpgrade,
             lineNumber: pendingTask.lineNumber,
+            source: 'todo',
             changelog: inferChangelogCategory(title, pendingTask.status),
         });
         pendingTask = null;

package/dist/scheduler/tools/report-issue.mjs

@@ -0,0 +1,94 @@
+// ─── report_issue MCP tool for agents ───
+// Allows agents to report discovered issues outside their current task scope.
+// Handler runs in-process in the scheduler — records locally + creates platform issues.
+import { appendFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod/v4';
+import { createPlatformIssue } from '../git/issue-creator.mjs';
+// ─── In-memory store ───
+export class DiscoveredIssueStore {
+    issues = [];
+    add(issue) {
+        this.issues.push(issue);
+    }
+    /** Returns all issues and clears the store. */
+    drain() {
+        return this.issues.splice(0);
+    }
+    /** Read without clearing. */
+    peek() {
+        return this.issues;
+    }
+}
+// ─── Tool definition factory ───
+const DISCOVERED_NDJSON = '.claude/scheduler/discovered.ndjson';
+export function buildReportIssueTool(store, currentTaskId, projectDir, platform) {
+    return tool('report_issue', 'Report a discovered issue outside your current task scope. Use severity "non-blocker" for issues that don\'t prevent your work (then continue normally), or "blocker" for issues that prevent you from completing your task (then wrap up what you can and return).', {
+        title: z.string().describe('Concise issue title'),
+        type: z.enum(['frontend', 'backend', 'fullstack']).describe('Affected layer'),
+        complexity: z.enum(['S', 'M', 'L']).default('M').describe('Estimated complexity'),
+        severity: z.enum(['blocker', 'non-blocker']).describe('Whether this blocks your current task'),
+        description: z.string().describe('What is broken, where, and what the fix should look like'),
+        evidence: z.string().default('').describe('Error messages, file paths, stack traces'),
+    }, async (args) => {
+        const id = `discovered-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const issue = {
+            id,
+            title: args.title,
+            type: args.type,
+            complexity: args.complexity,
+            severity: args.severity,
+            description: args.description,
+            evidence: args.evidence,
+            reportedBy: currentTaskId,
+            timestamp: Date.now(),
+        };
+        // Record in memory (scheduler drains on next iteration)
+        store.add(issue);
+        // Persist for crash recovery
+        try {
+            const ndjsonPath = resolve(projectDir, DISCOVERED_NDJSON);
+            appendFileSync(ndjsonPath, JSON.stringify(issue) + '\n', 'utf-8');
+        }
+        catch { /* best-effort — in-memory store is primary */ }
+        // Create platform issue if available
+        if (platform !== 'none') {
+            try {
+                const labels = [`discovered`, `type::${args.type}`, `complexity::${args.complexity}`, 'status::todo'];
+                const created = createPlatformIssue(projectDir, platform, {
+                    title: args.title,
+                    body: `**Discovered during:** ${currentTaskId}\n**Severity:** ${args.severity}\n\n${args.description}\n\n**Evidence:**\n\`\`\`\n${args.evidence}\n\`\`\``,
+                    labels,
+                });
+                if (created) {
+                    issue.platformIssue = created;
+                }
+            }
+            catch { /* non-fatal */ }
+        }
+        const platformNote = issue.platformIssue
+            ? ` Platform issue: ${issue.platformIssue.url}`
+            : '';
+        return {
+            content: [{ type: 'text', text: `Issue recorded: ${args.title} (${id}).${platformNote}` }],
+        };
+    });
+}
+// ─── Convert discovered issue to Task ───
+export function discoveredIssueToTask(issue, currentPhase) {
+    return {
+        id: issue.id,
+        title: issue.title,
+        phase: currentPhase,
+        type: issue.type,
+        complexity: issue.complexity,
+        dependsOn: [],
+        issueMarker: issue.platformIssue ? `#${issue.platformIssue.number}` : null,
+        kitUpgrade: false,
+        lineNumber: 0,
+        source: 'discovered',
+        status: 'todo',
+        changelog: 'added',
+    };
+}

package/dist/scheduler/tools/scheduler-tools.mjs

@@ -0,0 +1,17 @@
+// ─── In-process MCP server with scheduler-provided tools ───
+// Creates a per-agent MCP server instance injected into query() options.
+// Each agent gets its own server (currentTaskId differs per spawn).
+import { createSdkMcpServer } from '@anthropic-ai/claude-agent-sdk';
+import { buildReportIssueTool } from './report-issue.mjs';
+/**
+ * Create an in-process MCP server with scheduler tools for a specific agent.
+ * Returns a config that can be passed to query() via options.mcpServers.
+ */
+export function createSchedulerToolServer(store, currentTaskId, projectDir, platform) {
+    const reportIssueTool = buildReportIssueTool(store, currentTaskId, projectDir, platform);
+    return createSdkMcpServer({
+        name: 'scheduler-tools',
+        version: '1.0.0',
+        tools: [reportIssueTool],
+    });
+}

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

@@ -561,4 +561,8 @@ When reviewing Angular code, check:
 - @defer for heavy below-fold components
 - Naming: PascalCase components, lib- selectors, kebab-case files
 - i18n: ALL user-facing text has `i18n` attribute (templates) or `$localize` (TS) — no bare text
-- VRT: new pages/routes have corresponding `*.vrt.spec.ts` with 3-viewport coverage (375px, 768px, 1280px), baseline snapshots committed
+- VRT: new pages/routes have corresponding `*.vrt.spec.ts` with 3-viewport coverage (375px, 768px, 1280px), baseline snapshots committed
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

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

@@ -136,3 +136,7 @@ When called for **direct implementation**, provide complete production-ready cod
 - Explain architectural decisions and trade-offs
 - Proactively identify potential issues
 - No fluff — every word serves a purpose
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

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

@@ -870,70 +870,18 @@ If a merge conflict occurs:
 4. Push: `git push origin HEAD`
 5. Then clean up: `git worktree remove .worktrees/feat/{slug} && git branch -d feat/{slug}`
 
-## DISCOVERED ISSUES Protocol
+## Proactive Problem Resolution
 
-Agents encounter problems outside their current scope during work. This protocol gives them a structured way to report issues without breaking their flow, and ensures the orchestrator processes every report.
+All agents have access to a `report_issue` tool provided by the scheduler. When an agent encounters a problem outside its current task scope, it calls this tool to create a tracked issue. The scheduler picks it up on the next iteration and routes it through the normal pipeline.
 
-### Agent-side: How agents report issues
+**Agent behavior:**
+- **In-scope problem** → fix it directly (it's the agent's job)
+- **Out-of-scope, non-blocking** → call `report_issue` with `severity: 'non-blocker'`, then continue working
+- **Out-of-scope, blocking** → call `report_issue` with `severity: 'blocker'`, finish what's possible, then return
+- **Warnings are actionable** — unless they originate from inside a third-party package's own source code
+- **Never dismiss** — "pre-existing" and "not in scope" are not valid reasons to ignore a problem
 
-Every agent (architect, implementer, reviewer, test-engineer) MAY include a `## DISCOVERED ISSUES` section at the END of their response. Format:
-
-```
-## DISCOVERED ISSUES
-
-### [NON-BLOCKER] Title describing the problem
-- **Scope**: which agent should handle this (e.g., `deployment-engineer`, `backend-ts-architect`)
-- **Type**: frontend | backend | fullstack | devops
-- **Complexity**: S | M
-- **Description**: What is broken, where, and what the fix should look like
-- **Evidence**: error message, file:line, warning output
-
-### [BLOCKER] Title describing the blocking problem
-- **Scope**: which agent should handle this
-- **Type**: frontend | backend | fullstack | devops
-- **Complexity**: S | M
-- **Description**: What is broken and why it blocks the current task
-- **Evidence**: error message, file:line, warning output
-- **Impact**: What cannot proceed until this is resolved
-```
-
-**Agent rules:**
-- **In-scope problem** → fix it directly, do NOT add to DISCOVERED ISSUES (it's your job)
-- **Out-of-scope, non-blocking** → add as `[NON-BLOCKER]`, then **continue and deliver your task**
-- **Out-of-scope, blocking** → add as `[BLOCKER]`, finish what you can, then return. The orchestrator will handle delegation
-- **Warnings count** — treat project warnings as issues unless they originate from inside a third-party package's own source code. Misconfiguration or misuse of a third-party tool is a project problem.
-- **"Third-party issue" is narrow** — only valid when the bug is in the third-party package's source code itself
-- **Never dismiss** — if you see a problem, either fix it or report it. "Pre-existing" and "not in scope" are not valid reasons to ignore a problem.
-
-### Orchestrator-side: Processing DISCOVERED ISSUES
-
-**After EVERY agent delegation** (STEP 2, 3, 4, 5, 6, 7, 8), scan the agent's response for a `## DISCOVERED ISSUES` section. If present:
-
-#### NON-BLOCKER items → create tasks, continue current workflow
-1. **Local mode**: Add each item to TODO.md in the CURRENT phase (after the current task). Format:
-   ```
-   - [ ] **[Title from DISCOVERED ISSUES]** — [Description]. Discovered during #[current-task-id] (Complexity: [S|M], Type: [type])
-   ```
-2. **Platform mode**: Delegate to `devops-integrator`: "Create issues for these discovered problems: [list items]. Label: `status::todo`, `discovered`. Milestone: current phase. Do NOT perform git operations."
-3. **Continue with the current task** — non-blockers do NOT interrupt the workflow.
-
-#### BLOCKER items → resolve before continuing
-1. **Assess if truly blocking**: Can the current task still be completed without resolving this? If the agent completed their deliverable despite reporting `[BLOCKER]`, reclassify as `[NON-BLOCKER]` and process accordingly.
-2. **If blocking and in another agent's scope**: Delegate to the appropriate agent IMMEDIATELY (before continuing the current step). Include the evidence and description from the DISCOVERED ISSUES entry. This is an interruption to the current workflow — resume the current step after the blocker is resolved.
-3. **If blocking and unfixable now** (requires human action, external dependency, missing credentials): Mark the current task as `[~]` SKIPPED with reason referencing the blocker. Create the task for the blocker issue. Move to next task.
-4. **Max 1 blocker delegation per step** — if resolving a blocker reveals another blocker, skip the current task and create tasks for both blockers.
-
-#### Deduplication
-Before creating a task from a discovered issue:
-- Check TODO.md / platform issues for existing tasks with similar title or description
-- Check if the issue was already reported in a previous iteration (grep TODO.md for keywords)
-- Skip duplicates — do NOT create redundant tasks
-
-### Including the protocol in delegation prompts
-
-**Add this paragraph to ALL agent delegation prompts** (STEP 2, 3, 4, 6 — all Agent tool calls to specialist agents):
-
-> "If you encounter any problems, warnings, or broken infrastructure outside the scope of this task, include a `## DISCOVERED ISSUES` section at the end of your response. Use `[NON-BLOCKER]` for issues that don't prevent you from completing this task, `[BLOCKER]` for issues that do. Format: title, scope (which agent), type (frontend/backend/fullstack/devops), complexity (S/M), description, evidence. Do not dismiss issues as pre-existing — report everything you find."
+**Orchestrator does NOT process discovered issues.** The scheduler handles everything — creating tasks from `report_issue` calls, creating platform issues, and routing them to the right agent via the normal task queue. The orchestrator just picks tasks and delegates as usual.
 
 ## When Stuck
 

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

@@ -393,3 +393,7 @@ When reviewing React code, check:
 - No unstable nested component definitions (components defined inside render)
 - `React.memo` only on components with measured re-render cost — not as a default
 - VRT: new pages/routes have corresponding `*.vrt.spec.ts` with 3-viewport coverage (375px, 768px, 1280px), baseline snapshots committed
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

package/dist/template/.claude/agents/senior-code-reviewer.md

@@ -195,3 +195,7 @@ What is done well. Correct patterns, clean code, good decisions. Be specific.
 4. **Prioritize impact** — security > correctness > performance > style
 5. **Respect project standards** — align with CLAUDE.md conventions
 6. **Don't offer to fix** — this is not interactive, the user cannot respond
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

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

@@ -394,3 +394,7 @@ When reviewing Svelte code, check:
 - Callback props for outputs (not `createEventDispatcher` — that's Svelte 4)
 - Resource cleanup in `onDestroy` or `$effect` return for manual subscriptions
 - VRT: new pages/routes have corresponding `*.vrt.spec.ts` with 3-viewport coverage (375px, 768px, 1280px), baseline snapshots committed
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

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

@@ -538,3 +538,7 @@ Tests should be easy to write. If they are not, the production code needs refact
 - **No flaky tests** — if a test fails intermittently, fix it or delete it
 - **Test public API** — don't test private methods directly
 - **Pure functions are easy to test** — prefer pure transformations over stateful operations. If a function is hard to test, it likely has too many responsibilities or side effects.
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

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

@@ -144,4 +144,8 @@ When called for **direct implementation**, provide:
 - TypeScript interfaces and types
 - Follow project conventions from CLAUDE.md (App Separation Principle, Onion Architecture layers)
 - Monorepo-compatible solutions for shared functionality
-- When uncertain about approach, ask for clarification before proceeding
+- When uncertain about approach, ask for clarification before proceeding
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

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

@@ -423,3 +423,7 @@ When reviewing Vue code, check:
 - Naming: PascalCase components, `Base` prefix for atoms, `use` prefix for composables
 - i18n: ALL user-facing text goes through `$t()` / `t()` — no bare strings in templates or script
 - VRT: new pages/routes have corresponding `*.vrt.spec.ts` with 3-viewport coverage (375px, 768px, 1280px), baseline snapshots committed
+
+## Out-of-Scope Issues
+
+If you discover problems outside your current task (broken infrastructure, misconfigurations, deprecated APIs in other code), use the `report_issue` tool to create a tracked issue. Set `severity: 'non-blocker'` and continue your work, or `severity: 'blocker'` if the problem prevents you from completing your task — in that case, finish what you can and return. Never dismiss problems as "pre-existing."

package/package.json

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