create-claude-workspace 1.1.80 → 1.1.82

package/dist/scripts/lib/agent-tag.integration.spec.js

@@ -0,0 +1,193 @@
+// ─── Integration tests: agent tag + color in real Claude CLI stream ───
+// Spawns actual `claude` process and verifies agent tags appear in formatted output.
+import { describe, it, expect, beforeEach } from 'vitest';
+import { execSync, spawn } from 'node:child_process';
+import { resetStreamState, setAgentTag, simplifyModelName, colorizeAgent, formatStreamEvent, formatStreamEventTracked, } from './claude-runner.mjs';
+// ─── ANSI helpers ───
+function stripAnsi(s) {
+    return s.replace(/\x1b\[\d+m/g, '');
+}
+// ─── Check if claude CLI is available ───
+function claudeAvailable() {
+    try {
+        execSync('claude --version', { stdio: 'pipe', timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const hasClaude = claudeAvailable();
+function spawnClaude(prompt, maxTurns, extraFlags = []) {
+    const isWin = process.platform === 'win32';
+    const flags = [
+        '-p',
+        '--output-format', 'stream-json',
+        '--verbose',
+        '--include-partial-messages',
+        '--max-turns', String(maxTurns),
+        ...extraFlags,
+    ];
+    const child = isWin
+        ? spawn(process.env.ComSpec ?? 'cmd.exe', ['/c', 'claude', ...flags], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            windowsHide: true,
+        })
+        : spawn('claude', [...flags, prompt], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+    if (isWin && child.stdin) {
+        child.stdin.write(prompt);
+        child.stdin.end();
+    }
+    setAgentTag('orchestrator');
+    const rawEvents = [];
+    const formattedLines = [];
+    let detectedModel = '';
+    return new Promise((resolve) => {
+        let buffer = '';
+        child.stdout.on('data', (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+            for (const rawLine of lines) {
+                const line = rawLine.replace(/\r/g, '');
+                if (!line.trim())
+                    continue;
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                rawEvents.push(event);
+                if (event.type === 'system' && typeof event.model === 'string') {
+                    detectedModel = simplifyModelName(event.model);
+                    setAgentTag('orchestrator', detectedModel);
+                }
+                const formatted = formatStreamEventTracked(event);
+                if (formatted) {
+                    formattedLines.push(formatted);
+                    process.stdout.write(formatted);
+                }
+            }
+        });
+        child.stderr.on('data', () => { });
+        child.on('close', () => resolve({ rawEvents, formattedLines, detectedModel }));
+    });
+}
+// ─── Tests ───
+describe('agent tag integration: real Claude CLI', () => {
+    beforeEach(() => {
+        resetStreamState();
+    });
+    it.skipIf(!hasClaude)('spawns claude and verifies agent tag in stream output', async () => {
+        const result = await spawnClaude('Respond with exactly: ok', 1);
+        // System event with model
+        const systemEvent = result.rawEvents.find(e => e.type === 'system');
+        expect(systemEvent, 'system event should be present').toBeDefined();
+        expect(systemEvent.model, 'system event should contain model').toBeDefined();
+        console.log(`\nDetected model: ${systemEvent.model} → simplified: ${result.detectedModel}`);
+        // Model simplified correctly
+        expect(result.detectedModel).toMatch(/^\w+-\d+(\.\d+)?$/);
+        // Formatted output contains agent tag with model
+        const allPlain = result.formattedLines.map(stripAnsi).join('');
+        expect(allPlain).toContain('orchestrator');
+        expect(allPlain).toContain(result.detectedModel);
+        // At least one line has full tag format
+        const hasFullTag = result.formattedLines.some(line => stripAnsi(line).includes(`orchestrator/${result.detectedModel}`));
+        expect(hasFullTag, `expected "orchestrator/${result.detectedModel}" in output`).toBe(true);
+        console.log(`\n═══ ${result.rawEvents.length} events, ${result.formattedLines.length} formatted lines ═══`);
+        console.log(`Event types: ${[...new Set(result.rawEvents.map(e => e.type))].join(', ')}`);
+    }, 60_000);
+    it.skipIf(!hasClaude)('shows sub-agent name when Agent tool is used', async () => {
+        // Use a custom agent defined in .claude/agents/test-dummy.md
+        // This mirrors how orchestrator delegates: subagent_type="test-dummy"
+        const prompt = [
+            'You MUST use the Agent tool exactly once.',
+            'Call it with: subagent_type "test-dummy", description "find ts files",',
+            'prompt "Use Glob with pattern **/*.mts to find TypeScript files. Return the list."',
+            'After the Agent tool returns, respond with: done',
+        ].join(' ');
+        const result = await spawnClaude(prompt, 5, ['--dangerously-skip-permissions']);
+        // Find assistant events with Agent tool_use
+        const agentToolEvents = result.rawEvents.filter(e => {
+            if (e.type !== 'assistant')
+                return false;
+            const msg = e.message;
+            if (!msg || typeof msg === 'string')
+                return false;
+            const content = msg.content;
+            return content?.some(b => b.type === 'tool_use' && b.name === 'Agent');
+        });
+        console.log(`\n═══ Sub-agent test: ${result.rawEvents.length} events, ${agentToolEvents.length} Agent tool calls ═══`);
+        // Verify Agent tool was called
+        expect(agentToolEvents.length, 'expected at least one Agent tool_use event').toBeGreaterThanOrEqual(1);
+        // Verify formatted output contains the robot icon and sub-agent identifier
+        const allPlain = result.formattedLines.map(stripAnsi).join('');
+        expect(allPlain, 'expected 🤖 icon for Agent tool call').toContain('🤖');
+        expect(allPlain, 'expected → arrow for sub-agent delegation').toContain('→');
+        // Verify the delegation line shows orchestrator (parent) + agent name
+        const agentLine = result.formattedLines.find(l => stripAnsi(l).includes('🤖'));
+        expect(agentLine, 'expected a formatted line with 🤖').toBeDefined();
+        const agentLinePlain = stripAnsi(agentLine);
+        console.log(`Delegation line: ${agentLinePlain.trim()}`);
+        // Delegation line should show orchestrator as the caller
+        expect(agentLinePlain).toContain(`orchestrator/${result.detectedModel}`);
+        // Should contain the agent name "test-dummy"
+        expect(agentLinePlain, 'expected agent name "test-dummy" in delegation line')
+            .toContain('test-dummy');
+        // Verify sub-agent's internal tool calls show sub-agent name (not orchestrator)
+        const plainLines = result.formattedLines.map(stripAnsi);
+        const delegationIdx = plainLines.findIndex(l => l.includes('🤖'));
+        const subAgentLines = plainLines.slice(delegationIdx + 1).filter(l => l.includes('▶') || l.includes('💭'));
+        if (subAgentLines.length > 0) {
+            console.log(`Sub-agent internal tool calls (${subAgentLines.length}):`);
+            for (const line of subAgentLines) {
+                console.log(`  ${line.trim()}`);
+                // Internal tool calls should show "test-dummy", NOT "orchestrator"
+                expect(line, 'sub-agent tool call should show test-dummy, not orchestrator')
+                    .toContain('test-dummy');
+                expect(line, 'sub-agent tool call should NOT show orchestrator')
+                    .not.toContain(`orchestrator/${result.detectedModel}`);
+            }
+        }
+        // After Agent returns, verify orchestrator tag is restored
+        const postAgentLines = plainLines.slice(delegationIdx + 1).filter(l => !l.includes('▶') && !l.includes('💭') && !l.includes('✓') && !l.includes('⏳') && l.trim());
+        if (postAgentLines.length > 0) {
+            const lastLine = postAgentLines[postAgentLines.length - 1];
+            console.log(`Post-agent line: ${lastLine.trim()}`);
+            expect(lastLine, 'after Agent returns, orchestrator tag should be restored')
+                .toContain(`orchestrator/${result.detectedModel}`);
+        }
+        console.log(`Event types: ${[...new Set(result.rawEvents.map(e => e.type))].join(', ')}`);
+        console.log('═══ End ═══\n');
+    }, 120_000);
+    it.skipIf(!hasClaude)('agent colors are visible in real formatted output', () => {
+        const agents = [
+            'orchestrator', 'ui-engineer', 'backend-ts-architect',
+            'senior-code-reviewer', 'test-engineer', 'product-owner',
+            'technical-planner', 'devops-integrator', 'deployment-engineer',
+            'project-initializer',
+        ];
+        console.log('\n═══ Agent colors (visual check) ═══');
+        for (const agent of agents) {
+            setAgentTag(agent, 'opus-4.6');
+            const line = formatStreamEvent({
+                type: 'assistant',
+                message: { content: [{ type: 'text', text: `Working on task #42...` }] },
+            });
+            process.stdout.write(line);
+            resetStreamState();
+        }
+        console.log('═══ End of agent colors ═══\n');
+        const orchColor = colorizeAgent('orchestrator').match(/\x1b\[\d+m/)?.[0];
+        for (const agent of agents.slice(1)) {
+            const color = colorizeAgent(agent).match(/\x1b\[\d+m/)?.[0];
+            if (agent !== 'devops-integrator') {
+                expect(color, `${agent} should differ from orchestrator`).not.toBe(orchColor);
+            }
+        }
+    });
+});

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

@@ -18,17 +18,74 @@ const RESULT_SCHEMA = JSON.stringify({
 const TC = {
     dim: '\x1b[2m', reset: '\x1b[0m',
     cyan: '\x1b[36m', yellow: '\x1b[33m', green: '\x1b[32m', red: '\x1b[31m',
+    blue: '\x1b[34m', magenta: '\x1b[35m',
+    brightCyan: '\x1b[96m', brightYellow: '\x1b[93m',
+    brightGreen: '\x1b[92m', brightMagenta: '\x1b[95m', brightBlue: '\x1b[94m',
 };
 function ts() {
-    return `[${new Date().toLocaleTimeString('en-GB', { hour12: false })}] `;
+    return `[${new Date().toLocaleTimeString('en-GB', { hour12: false })}] ${_agentTag}`;
 }
 const MAX_BUFFER = 1024 * 1024; // 1MB stdout buffer cap
 const MAX_STDERR = 64 * 1024; // 64KB stderr cap
 // ─── Stream event formatting ───
-// Mutable state for partial message dedup — reset per runClaude call
+// Mutable state for partial message dedup + agent tag — reset per runClaude call
 let _lastAssistantText = '';
+let _agentTag = '';
+let _agentTagStack = [];
+let _agentReturnDepths = [];
+let _formatToolDepth = 0;
 export function resetStreamState() {
     _lastAssistantText = '';
+    _agentTag = '';
+    _agentTagStack = [];
+    _agentReturnDepths = [];
+    _formatToolDepth = 0;
+}
+export function setAgentTag(name, model) {
+    const colored = colorizeAgent(name);
+    _agentTag = model
+        ? `${colored}${TC.dim}/${model}${TC.reset} `
+        : `${colored} `;
+}
+export function simplifyModelName(raw) {
+    // Strip non-alphanumeric suffixes like "[1m]" (context window indicator)
+    const model = raw.replace(/\[.*$/, '');
+    // "claude-opus-4-6-20250514" → "opus-4.6" (major-minor before date)
+    const m = model.match(/claude-(\w+)-(\d{1,2})-(\d{1,2})-\d{8}/);
+    if (m)
+        return `${m[1]}-${m[2]}.${m[3]}`;
+    // "claude-opus-4-6" → "opus-4.6" (major-minor, no date)
+    const m1b = model.match(/claude-(\w+)-(\d{1,2})-(\d{1,2})$/);
+    if (m1b)
+        return `${m1b[1]}-${m1b[2]}.${m1b[3]}`;
+    // "claude-sonnet-4-20250514" → "sonnet-4" (major only before date)
+    const m2 = model.match(/claude-(\w+)-(\d{1,2})-\d{8}/);
+    if (m2)
+        return `${m2[1]}-${m2[2]}`;
+    // "claude-opus-4" → "opus-4" (no date suffix)
+    const m3 = model.match(/claude-(\w+)-(\d+)/);
+    if (m3)
+        return `${m3[1]}-${m3[2]}`;
+    return model;
+}
+// ─── Agent color coding ───
+const AGENT_COLORS = {
+    orchestrator: TC.cyan,
+    'ui-engineer': TC.magenta,
+    'backend-ts-architect': TC.blue,
+    'senior-code-reviewer': TC.yellow,
+    'test-engineer': TC.green,
+    'product-owner': TC.brightMagenta,
+    'technical-planner': TC.brightBlue,
+    'devops-integrator': TC.brightCyan,
+    'deployment-engineer': TC.brightYellow,
+    'project-initializer': TC.brightGreen,
+};
+const FALLBACK_COLORS = [TC.cyan, TC.magenta, TC.blue, TC.yellow, TC.green, TC.brightCyan];
+export function colorizeAgent(name) {
+    const color = AGENT_COLORS[name]
+        ?? FALLBACK_COLORS[Math.abs([...name].reduce((h, c) => (h * 31 + c.charCodeAt(0)) | 0, 0)) % FALLBACK_COLORS.length];
+    return `${color}${name}${TC.reset}`;
 }
 const SILENT_EVENTS = new Set(['system', 'ping', 'result']);
 function formatRateLimit(event) {
@@ -47,6 +104,14 @@ function getContentBlocks(event) {
 }
 function formatToolUse(block) {
     const input = block.input ?? {};
+    // Special formatting for Agent tool — show sub-agent with color
+    if (block.name === 'Agent') {
+        const agentType = input.subagent_type ?? '';
+        const desc = input.description ?? '';
+        const label = agentType || desc || 'sub-agent';
+        const colored = colorizeAgent(label);
+        return `${ts()}🤖 → ${colored}${desc && agentType ? ` ${TC.dim}${desc}${TC.reset}` : ''}`;
+    }
     const detail = input.command ?? input.file_path ?? input.pattern ?? input.query ?? '';
     const short = detail.slice(0, 120);
     return `${ts()}${TC.cyan}▶ ${block.name ?? 'tool'}${TC.reset}${short ? ` ${TC.dim}${short}${TC.reset}` : ''}`;
@@ -115,6 +180,48 @@ export function formatStreamEvent(event) {
         return null;
     return EVENT_FORMATTERS[event.type]?.(event) ?? null;
 }
+/**
+ * Wrapper that switches the agent tag around formatting:
+ * - user tool_result: restores parent tag BEFORE formatting (so Agent result shows parent)
+ * - assistant Agent tool_use: switches to sub-agent AFTER formatting (so delegation line shows parent)
+ */
+export function formatStreamEventTracked(event) {
+    // Before format: restore parent tag when Agent tool_result arrives
+    if (event.type === 'user') {
+        const blocks = getContentBlocks(event);
+        if (blocks) {
+            for (const block of blocks) {
+                if (block.type === 'tool_result') {
+                    if (_agentReturnDepths.length > 0 && _formatToolDepth === _agentReturnDepths[_agentReturnDepths.length - 1]) {
+                        _agentReturnDepths.pop();
+                        _agentTag = _agentTagStack.pop() ?? '';
+                    }
+                    _formatToolDepth = Math.max(0, _formatToolDepth - 1);
+                }
+            }
+        }
+    }
+    const result = formatStreamEvent(event);
+    // After format: switch to sub-agent tag when Agent tool_use is seen
+    if (event.type === 'assistant') {
+        const blocks = getContentBlocks(event);
+        if (blocks) {
+            for (const block of blocks) {
+                if (block.type === 'tool_use') {
+                    _formatToolDepth++;
+                    if (block.name === 'Agent') {
+                        _agentTagStack.push(_agentTag);
+                        _agentReturnDepths.push(_formatToolDepth);
+                        const input = block.input ?? {};
+                        const name = input.subagent_type || input.description || 'sub-agent';
+                        _agentTag = `${colorizeAgent(name)} `;
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
 // ─── Schema validation ───
 const VALID_STATUSES = new Set(['completed', 'needs_input', 'blocked', 'error']);
 export function validateResult(obj) {
@@ -193,8 +300,9 @@ export function runClaude(opts, log, runOpts = {}) {
         }
         if (opts.skipPermissions)
             flags.push('--dangerously-skip-permissions');
-        // Reset stream state for this invocation
+        // Reset stream state for this invocation and set initial agent tag
         resetStreamState();
+        setAgentTag('orchestrator');
         // Spawn WITHOUT detached — child stays in the same process group as parent.
         // When user presses Ctrl+C, BOTH parent and child receive the signal from the OS.
         // Parent's SIGINT handler kills child (backup) and calls process.exit().
@@ -230,6 +338,7 @@ export function runClaude(opts, log, runOpts = {}) {
         let isAuthServerError = false;
         let isUsageLimit = false;
         let resultReceived = false;
+        let pendingToolCalls = 0;
         let buffer = '';
         let killed = false;
         let killReason = null;
@@ -249,9 +358,18 @@ export function runClaude(opts, log, runOpts = {}) {
             if (AUTH_SERVER_RE.test(msg) && /auth/i.test(msg))
                 isAuthServerError = true;
         }
+        let usageLimitKilled = false;
         function detectTextSignals(lower) {
-            if (USAGE_LIMIT_RE.test(lower))
+            if (USAGE_LIMIT_RE.test(lower)) {
                 isUsageLimit = true;
+                // Kill immediately on usage limit — Claude CLI retries internally and spams
+                // the message dozens of times. No point waiting for it to exit on its own.
+                if (!usageLimitKilled && !killed) {
+                    usageLimitKilled = true;
+                    log.warn('Usage limit detected — killing process to prevent spam.');
+                    killChild('process_timeout');
+                }
+            }
             if (RATE_LIMIT_RE.test(lower))
                 isRateLimit = true;
             if (AUTH_ERROR_RE.test(lower))
@@ -289,6 +407,11 @@ export function runClaude(opts, log, runOpts = {}) {
             lastOutputTime = Date.now();
             if (activityTimer)
                 clearTimeout(activityTimer);
+            // While a tool is executing (tool_use without tool_result), skip activity timeout entirely.
+            // Long-running tools (nx build, test suites) can run 20+ min with no output.
+            // The process timeout (2h) is the safety net.
+            if (pendingToolCalls > 0)
+                return;
             const timeout = resultReceived ? opts.postResultTimeout : opts.activityTimeout;
             activityTimer = setTimeout(() => killChild('activity_timeout'), timeout);
         }
@@ -333,6 +456,12 @@ export function runClaude(opts, log, runOpts = {}) {
                 // Extract session ID
                 if (event.session_id && !sessionId)
                     sessionId = event.session_id;
+                // Extract model from system event and update agent tag
+                if (event.type === 'system' && event.model) {
+                    const model = simplifyModelName(event.model);
+                    setAgentTag('orchestrator', model);
+                    process.stdout.write(`${ts()}${TC.green}Session started${TC.reset} ${TC.dim}(${event.model})${TC.reset}\n`);
+                }
                 // Extract structured result
                 if (event.type === 'result' && event.subtype !== 'tool_result') {
                     resultReceived = true;
@@ -351,19 +480,34 @@ export function runClaude(opts, log, runOpts = {}) {
                 if (event.type === 'rate_limit_event')
                     isRateLimit = true;
                 detectErrorSignals(event);
-                // Detect error signals in assistant text content (e.g. "You've hit your limit" as text, not error event)
+                // Track pending tool calls — tool_use in assistant, tool_result in user
                 if (event.type === 'assistant') {
                     const blocks = getContentBlocks(event);
                     if (blocks) {
                         for (const block of blocks) {
+                            if (block.type === 'tool_use')
+                                pendingToolCalls++;
+                            // Detect error signals in assistant text content (e.g. "You've hit your limit" as text, not error event)
                             if (block.type === 'text' && block.text) {
                                 detectTextSignals(block.text.toLowerCase());
                             }
                         }
                     }
                 }
-                // Display
-                const formatted = formatStreamEvent(event);
+                if (event.type === 'user') {
+                    const blocks = getContentBlocks(event);
+                    if (blocks) {
+                        for (const block of blocks) {
+                            if (block.type === 'tool_result')
+                                pendingToolCalls = Math.max(0, pendingToolCalls - 1);
+                        }
+                        // All tools finished — re-arm activity timer (was suspended while tools ran)
+                        if (pendingToolCalls <= 0)
+                            resetActivityTimer();
+                    }
+                }
+                // Display (tracked version switches agent tag for sub-agent calls)
+                const formatted = formatStreamEventTracked(event);
                 if (formatted)
                     process.stdout.write(formatted);
             }
@@ -405,7 +549,7 @@ export function runClaude(opts, log, runOpts = {}) {
                 }
                 catch { /* already dead — expected */ }
             }
-            // Flush remaining buffer
+            // Flush remaining buffer (last line without trailing \n)
             if (buffer.trim()) {
                 const cleaned = buffer.replace(/\r/g, '');
                 const event = parseStreamEvent(cleaned);
@@ -416,6 +560,11 @@ export function runClaude(opts, log, runOpts = {}) {
                         structuredResult = validateResult(event.structured_output) ?? structuredResult;
                         resultReceived = true;
                     }
+                    detectErrorSignals(event);
+                    // Display the flushed event (was silently swallowed before)
+                    const formatted = formatStreamEventTracked(event);
+                    if (formatted)
+                        process.stdout.write(formatted);
                 }
                 else {
                     // Non-JSON buffer (e.g. "You've hit your limit" without trailing newline)

package/dist/scripts/lib/claude-runner.spec.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { resetStreamState, validateResult, formatStreamEvent, killProcessTree } from './claude-runner.mjs';
+import { resetStreamState, setAgentTag, simplifyModelName, colorizeAgent, validateResult, formatStreamEvent, formatStreamEventTracked, killProcessTree } from './claude-runner.mjs';
 import { spawn, execSync } from 'node:child_process';
 describe('validateResult', () => {
     it('returns valid result for complete object', () => {
@@ -237,6 +237,208 @@ describe('resetStreamState', () => {
         resetStreamState(); // should not throw
     });
 });
+// ─── simplifyModelName ───
+describe('simplifyModelName', () => {
+    it('simplifies full model ID with minor version', () => {
+        expect(simplifyModelName('claude-opus-4-6-20250514')).toBe('opus-4.6');
+    });
+    it('simplifies model ID without minor version', () => {
+        expect(simplifyModelName('claude-sonnet-4-20250514')).toBe('sonnet-4');
+    });
+    it('simplifies haiku model', () => {
+        expect(simplifyModelName('claude-haiku-4-5-20251001')).toBe('haiku-4.5');
+    });
+    it('strips context window suffix like [1m]', () => {
+        expect(simplifyModelName('claude-opus-4-6[1m]')).toBe('opus-4.6');
+        expect(simplifyModelName('claude-sonnet-4-6[1m]')).toBe('sonnet-4.6');
+    });
+    it('handles model ID without date and without suffix', () => {
+        expect(simplifyModelName('claude-opus-4-6')).toBe('opus-4.6');
+    });
+    it('returns original string for unrecognized format', () => {
+        expect(simplifyModelName('some-custom-model')).toBe('some-custom-model');
+    });
+});
+// ─── colorizeAgent ───
+describe('colorizeAgent', () => {
+    it('wraps agent name with ANSI color codes', () => {
+        const result = colorizeAgent('orchestrator');
+        expect(result).toContain('orchestrator');
+        expect(result).toContain('\x1b['); // has ANSI escape
+        expect(result).toContain('\x1b[0m'); // has reset
+    });
+    it('uses distinct colors for different known agents', () => {
+        const orch = colorizeAgent('orchestrator');
+        const ui = colorizeAgent('ui-engineer');
+        // Extract color code (first escape sequence)
+        const colorOf = (s) => s.match(/\x1b\[\d+m/)?.[0];
+        expect(colorOf(orch)).not.toBe(colorOf(ui));
+    });
+    it('handles unknown agent names with fallback color', () => {
+        const result = colorizeAgent('custom-agent');
+        expect(result).toContain('custom-agent');
+        expect(result).toContain('\x1b[');
+    });
+});
+// ─── setAgentTag + formatted output ───
+describe('setAgentTag', () => {
+    beforeEach(() => {
+        resetStreamState();
+    });
+    it('adds agent name to formatted output', () => {
+        setAgentTag('orchestrator');
+        const result = formatStreamEvent({
+            type: 'assistant',
+            message: { content: [{ type: 'text', text: 'Hello' }] },
+        });
+        expect(result).toContain('orchestrator');
+    });
+    it('adds agent name and model to formatted output', () => {
+        setAgentTag('orchestrator', 'opus-4.6');
+        const result = formatStreamEvent({
+            type: 'assistant',
+            message: { content: [{ type: 'text', text: 'Hello' }] },
+        });
+        expect(result).toContain('orchestrator');
+        expect(result).toContain('opus-4.6');
+    });
+    it('resets tag on resetStreamState', () => {
+        setAgentTag('orchestrator', 'opus-4.6');
+        resetStreamState();
+        const result = formatStreamEvent({
+            type: 'assistant',
+            message: { content: [{ type: 'text', text: 'Hello' }] },
+        });
+        expect(result).not.toContain('orchestrator');
+    });
+});
+// ─── Agent tool_use formatting ───
+describe('formatStreamEvent with Agent tool', () => {
+    beforeEach(() => {
+        resetStreamState();
+    });
+    it('formats Agent tool_use with robot icon and sub-agent type', () => {
+        const result = formatStreamEvent({
+            type: 'assistant',
+            message: {
+                content: [{
+                        type: 'tool_use',
+                        name: 'Agent',
+                        input: { subagent_type: 'ui-engineer', description: 'plan frontend' },
+                    }],
+            },
+        });
+        expect(result).toContain('🤖');
+        expect(result).toContain('ui-engineer');
+    });
+    it('falls back to description when no subagent_type', () => {
+        const result = formatStreamEvent({
+            type: 'assistant',
+            message: {
+                content: [{
+                        type: 'tool_use',
+                        name: 'Agent',
+                        input: { description: 'explore codebase' },
+                    }],
+            },
+        });
+        expect(result).toContain('🤖');
+        expect(result).toContain('explore codebase');
+    });
+    it('shows "sub-agent" when no type or description', () => {
+        const result = formatStreamEvent({
+            type: 'assistant',
+            message: {
+                content: [{
+                        type: 'tool_use',
+                        name: 'Agent',
+                        input: {},
+                    }],
+            },
+        });
+        expect(result).toContain('🤖');
+        expect(result).toContain('sub-agent');
+    });
+});
+// ─── formatStreamEventTracked: agent tag switching ───
+describe('formatStreamEventTracked', () => {
+    function stripAnsi(s) {
+        return s.replace(/\x1b\[\d+m/g, '');
+    }
+    beforeEach(() => {
+        resetStreamState();
+        setAgentTag('orchestrator', 'opus-4.6');
+    });
+    it('switches tag to sub-agent after Agent tool_use, restores on tool_result', () => {
+        // 1. Agent tool_use — should show orchestrator (parent delegates)
+        const delegation = formatStreamEventTracked({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'ui-engineer', description: 'plan' } }] },
+        });
+        expect(stripAnsi(delegation)).toContain('orchestrator/opus-4.6');
+        expect(stripAnsi(delegation)).toContain('🤖');
+        // 2. Sub-agent's internal tool call — should show ui-engineer
+        const subTool = formatStreamEventTracked({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: 'src/main.ts' } }] },
+        });
+        expect(stripAnsi(subTool)).toContain('ui-engineer');
+        expect(stripAnsi(subTool)).not.toContain('orchestrator');
+        // 3. Sub-agent's tool result — still sub-agent context
+        const subResult = formatStreamEventTracked({
+            type: 'user',
+            message: { content: [{ type: 'tool_result', content: 'file contents' }] },
+        });
+        expect(stripAnsi(subResult)).toContain('ui-engineer');
+        // 4. Agent tool result — restores orchestrator
+        const agentResult = formatStreamEventTracked({
+            type: 'user',
+            message: { content: [{ type: 'tool_result', content: 'plan completed' }] },
+        });
+        expect(stripAnsi(agentResult)).toContain('orchestrator/opus-4.6');
+        // 5. Next tool call — should be orchestrator again
+        const nextTool = formatStreamEventTracked({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Bash', input: { command: 'npm test' } }] },
+        });
+        expect(stripAnsi(nextTool)).toContain('orchestrator/opus-4.6');
+    });
+    it('handles nested Agent calls (agent within agent)', () => {
+        // orchestrator → backend-ts-architect → (inner tool)
+        formatStreamEventTracked({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'backend-ts-architect' } }] },
+        });
+        // backend-ts-architect calls Agent (hypothetical nested delegation)
+        formatStreamEventTracked({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'Explore' } }] },
+        });
+        // Inner agent's tool
+        const innerTool = formatStreamEventTracked({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Grep', input: { pattern: 'TODO' } }] },
+        });
+        expect(stripAnsi(innerTool)).toContain('Explore');
+        // Inner agent's tool result
+        formatStreamEventTracked({
+            type: 'user',
+            message: { content: [{ type: 'tool_result', content: 'found' }] },
+        });
+        // Inner Agent result → back to backend-ts-architect
+        const innerAgentResult = formatStreamEventTracked({
+            type: 'user',
+            message: { content: [{ type: 'tool_result', content: 'explore done' }] },
+        });
+        expect(stripAnsi(innerAgentResult)).toContain('backend-ts-architect');
+        // Outer Agent result → back to orchestrator
+        const outerAgentResult = formatStreamEventTracked({
+            type: 'user',
+            message: { content: [{ type: 'tool_result', content: 'architect done' }] },
+        });
+        expect(stripAnsi(outerAgentResult)).toContain('orchestrator/opus-4.6');
+    });
+});
 // ─── killProcessTree integration tests ───
 // Verifies that killProcessTree actually kills child process trees immediately
 // (SIGKILL on Unix, taskkill /T /F on Windows — no 5s SIGTERM grace period).

package/dist/scripts/lib/utils.mjs

@@ -7,17 +7,18 @@ import { createInterface } from 'node:readline';
 // Node.js runtime accepts `true` for shell but @types expects string
 const SHELL = process.platform === 'win32' ? 'cmd.exe' : '/bin/sh';
 // ─── Usage limit reset time parser ───
-/** Parse "resets Xpm (UTC)" / "resets X:XX AM" / "resets 3am" from stderr text.
+/** Parse "resets Xpm (UTC)" / "resets 12pm (Europe/Prague)" / "resets 3am" from stderr text.
  *  Returns milliseconds to wait, or null if unparseable.
- *  Accepts with or without (UTC) — assumes UTC when timezone not specified. */
+ *  Supports IANA timezones, UTC, and bare times (assumes UTC). */
 export function parseUsageLimitResetMs(text) {
-    // Match patterns: "resets 6pm (UTC)", "resets 6:30pm", "resets 18:00 (UTC)", "resets 6 PM", "resets 3am"
-    const match = text.match(/resets\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?(?:\s*\(UTC\))?/i);
+    // Match: "resets 6pm (UTC)", "resets 12pm (Europe/Prague)", "resets 6:30pm", "resets 18:00 (UTC)", "resets 3am"
+    const match = text.match(/resets\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)?(?:\s*\(([^)]+)\))?/i);
     if (!match)
         return null;
     let hours = parseInt(match[1], 10);
     const minutes = match[2] ? parseInt(match[2], 10) : 0;
     const ampm = match[3]?.toLowerCase();
+    const tz = match[4]?.trim() || 'UTC';
     if (ampm === 'pm' && hours < 12)
         hours += 12;
     if (ampm === 'am' && hours === 12)
@@ -25,14 +26,48 @@ export function parseUsageLimitResetMs(text) {
     if (hours > 23 || minutes > 59)
         return null;
     const now = new Date();
-    const reset = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), hours, minutes, 0, 0));
-    // If reset time is in the past, it's tomorrow
-    if (reset.getTime() <= now.getTime()) {
-        reset.setUTCDate(reset.getUTCDate() + 1);
+    let resetMs;
+    try {
+        // Resolve timezone offset using Intl (works for UTC, IANA like "Europe/Prague", etc.)
+        // Strategy: find the UTC offset for the given timezone at "now", then compute reset time
+        const tzName = tz === 'UTC' ? 'UTC' : tz;
+        // Get current time in target timezone to determine today's date there
+        const dtf = new Intl.DateTimeFormat('en-CA', {
+            timeZone: tzName, year: 'numeric', month: '2-digit', day: '2-digit',
+            hour: '2-digit', minute: '2-digit', hour12: false,
+        });
+        const parts = dtf.formatToParts(now);
+        const pv = (t) => parts.find(p => p.type === t).value;
+        const tzDate = `${pv('year')}-${pv('month')}-${pv('day')}`;
+        // Construct the reset datetime as if it were UTC, then find the real offset
+        const timeStr = `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:00`;
+        const resetAsUtc = new Date(`${tzDate}T${timeStr}Z`);
+        // Find what hour resetAsUtc maps to in the target TZ
+        const inTz = new Intl.DateTimeFormat('en-CA', {
+            timeZone: tzName, hour: '2-digit', minute: '2-digit', hour12: false,
+        }).format(resetAsUtc);
+        const [tzH, tzM] = inTz.split(':').map(Number);
+        const offsetMin = (tzH * 60 + tzM) - (resetAsUtc.getUTCHours() * 60 + resetAsUtc.getUTCMinutes());
+        // Handle day wrap (e.g. tzH=23 but utcH=1 → offset should be negative, not +1320)
+        const correctedOffset = offsetMin > 720 ? offsetMin - 1440 : offsetMin < -720 ? offsetMin + 1440 : offsetMin;
+        // Reset time in UTC = local time - offset
+        const resetUtc = new Date(resetAsUtc.getTime() - correctedOffset * 60_000);
+        if (resetUtc.getTime() <= now.getTime()) {
+            resetUtc.setUTCDate(resetUtc.getUTCDate() + 1);
+        }
+        resetMs = resetUtc.getTime();
+    }
+    catch {
+        // Invalid timezone — fall back to treating as UTC
+        const reset = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), hours, minutes, 0, 0));
+        if (reset.getTime() <= now.getTime()) {
+            reset.setUTCDate(reset.getUTCDate() + 1);
+        }
+        resetMs = reset.getTime();
     }
-    const waitMs = reset.getTime() - now.getTime();
-    // Sanity: max 24 hours
-    if (waitMs > 24 * 60 * 60_000)
+    const waitMs = resetMs - now.getTime();
+    // Sanity: max 24 hours, min 0
+    if (waitMs > 24 * 60 * 60_000 || waitMs < 0)
         return null;
     return waitMs;
 }

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

@@ -139,6 +139,22 @@ describe('parseUsageLimitResetMs', () => {
         expect(ms).toBeTypeOf('number');
         expect(ms).toBeGreaterThan(0);
     });
+    it('parses "resets 12pm (Europe/Prague)" IANA timezone', () => {
+        const ms = parseUsageLimitResetMs("You've hit your limit · resets 12pm (Europe/Prague)");
+        expect(ms).toBeTypeOf('number');
+        expect(ms).toBeGreaterThan(0);
+        expect(ms).toBeLessThanOrEqual(24 * 60 * 60_000);
+    });
+    it('parses "resets 3am (America/New_York)" IANA timezone', () => {
+        const ms = parseUsageLimitResetMs("resets 3am (America/New_York)");
+        expect(ms).toBeTypeOf('number');
+        expect(ms).toBeGreaterThan(0);
+    });
+    it('falls back to UTC for invalid timezone', () => {
+        const ms = parseUsageLimitResetMs("resets 6pm (Invalid/Zone)");
+        expect(ms).toBeTypeOf('number');
+        expect(ms).toBeGreaterThan(0);
+    });
     it('result is always positive (wraps to next day if time passed)', () => {
         // Use a time that's definitely in the past today (1am UTC if test runs after 1am)
         const ms = parseUsageLimitResetMs('resets 1am (UTC)');

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

@@ -1,23 +1,6 @@
 ---
 name: deployment-engineer
-description: "Use this agent to set up deployment pipelines, CI/CD configuration, preview deployments, production deploys, rollbacks, and smoke tests. Supports: Cloudflare Pages/Workers, Vercel, Netlify, VPS (SSH), Docker. Runs a deployment interview, generates CI/CD config, and adds a Deployment section to CLAUDE.md.
-
-Examples:
-
-<example>
-user: \"Set up deployment for this project\"
-assistant: \"I'll use the deployment-engineer agent to configure CI/CD and deployment pipelines.\"
-</example>
-
-<example>
-user: \"Add preview deployments for merge requests\"
-assistant: \"Let me use the deployment-engineer agent to set up preview deploys.\"
-</example>
-
-<example>
-user: \"Deploy to production\"
-assistant: \"I'll use the deployment-engineer agent to run the production deployment.\"
-</example>"
+description: "Use this agent to set up deployment pipelines, CI/CD configuration, preview deployments, production deploys, rollbacks, and smoke tests. Supports: Cloudflare Pages/Workers, Vercel, Netlify, VPS (SSH), Docker. Runs a deployment interview, generates CI/CD config, and adds a Deployment section to CLAUDE.md.\n\nExamples:\n\n<example>\nuser: \"Set up deployment for this project\"\nassistant: \"I'll use the deployment-engineer agent to configure CI/CD and deployment pipelines.\"\n</example>\n\n<example>\nuser: \"Add preview deployments for merge requests\"\nassistant: \"Let me use the deployment-engineer agent to set up preview deploys.\"\n</example>\n\n<example>\nuser: \"Deploy to production\"\nassistant: \"I'll use the deployment-engineer agent to run the production deployment.\"\n</example>"
 model: sonnet
 ---
 

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

@@ -1,23 +1,6 @@
 ---
 name: ui-engineer
-description: "Use this agent for frontend development tasks: component creation, UI implementation, styling, state management, accessibility, or frontend code reviews. Adapts to the project's frontend framework (Angular, React, Vue, Svelte, etc.) based on `.claude/profiles/frontend.md`.
-
-Examples:
-
-<example>
-user: \"Create a card component for displaying items\"
-assistant: \"I'll use the ui-engineer agent to design and implement this component following our frontend patterns.\"
-</example>
-
-<example>
-user: \"Review the dashboard components I just created\"
-assistant: \"Let me use the ui-engineer agent to review these components for quality and alignment with our standards.\"
-</example>
-
-<example>
-user: \"I need a multi-step form with validation\"
-assistant: \"I'll engage the ui-engineer agent to architect and implement this form with proper patterns.\"
-</example>"
+description: "Use this agent for frontend development tasks: component creation, UI implementation, styling, state management, accessibility, or frontend code reviews. Adapts to the project's frontend framework (Angular, React, Vue, Svelte, etc.) based on `.claude/profiles/frontend.md`.\n\nExamples:\n\n<example>\nuser: \"Create a card component for displaying items\"\nassistant: \"I'll use the ui-engineer agent to design and implement this component following our frontend patterns.\"\n</example>\n\n<example>\nuser: \"Review the dashboard components I just created\"\nassistant: \"Let me use the ui-engineer agent to review these components for quality and alignment with our standards.\"\n</example>\n\n<example>\nuser: \"I need a multi-step form with validation\"\nassistant: \"I'll engage the ui-engineer agent to architect and implement this form with proper patterns.\"\n</example>"
 model: opus
 ---
 

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

@@ -29,10 +29,8 @@ RUN GLAB_VER=$(curl -fsSL "https://gitlab.com/api/v4/projects/34675721/releases/
       -o /tmp/glab.deb && \
     dpkg -i /tmp/glab.deb && rm /tmp/glab.deb
 
-# Install bun
-RUN curl -fsSL https://bun.sh/install | bash && \
-    ln -s /root/.bun/bin/bun /usr/local/bin/bun && \
-    ln -s /root/.bun/bin/bunx /usr/local/bin/bunx
+# Install bun (system-wide so non-root claude user can access it)
+RUN BUN_INSTALL=/usr/local curl -fsSL https://bun.sh/install | bash
 
 # Install Claude Code natively as the claude user
 RUN gosu claude bash -c 'curl -fsSL https://claude.ai/install.sh | bash'

package/package.json

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