create-claude-workspace 1.1.82 → 1.1.84

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

@@ -102,11 +102,11 @@ describe('agent tag integration: real Claude CLI', () => {
         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"
+        // Use a custom agent defined in .claude/agents/test-dummy.md (model: haiku)
+        // This mirrors how orchestrator delegates: subagent_type="test-dummy", model="haiku"
         const prompt = [
             'You MUST use the Agent tool exactly once.',
-            'Call it with: subagent_type "test-dummy", description "find ts files",',
+            'Call it with: subagent_type "test-dummy", model "haiku", 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(' ');
@@ -135,10 +135,12 @@ describe('agent tag integration: real Claude CLI', () => {
         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')
+        // Should contain agent name "test-dummy" with model "haiku"
+        expect(agentLinePlain, 'expected "test-dummy" in delegation line')
             .toContain('test-dummy');
-        // Verify sub-agent's internal tool calls show sub-agent name (not orchestrator)
+        expect(agentLinePlain, 'expected "haiku" model in delegation line')
+            .toContain('haiku');
+        // Verify sub-agent's internal tool calls show sub-agent name + model (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('💭'));
@@ -146,9 +148,11 @@ describe('agent tag integration: real Claude CLI', () => {
             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')
+                // Internal tool calls should show "test-dummy/haiku", NOT "orchestrator"
+                expect(line, 'sub-agent tool call should show test-dummy')
                     .toContain('test-dummy');
+                expect(line, 'sub-agent tool call should show haiku model')
+                    .toContain('haiku');
                 expect(line, 'sub-agent tool call should NOT show orchestrator')
                     .not.toContain(`orchestrator/${result.detectedModel}`);
             }

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

@@ -104,13 +104,15 @@ function getContentBlocks(event) {
 }
 function formatToolUse(block) {
     const input = block.input ?? {};
-    // Special formatting for Agent tool — show sub-agent with color
+    // Special formatting for Agent tool — show sub-agent with color + model
     if (block.name === 'Agent') {
         const agentType = input.subagent_type ?? '';
         const desc = input.description ?? '';
+        const model = input.model ?? '';
         const label = agentType || desc || 'sub-agent';
         const colored = colorizeAgent(label);
-        return `${ts()}🤖 → ${colored}${desc && agentType ? ` ${TC.dim}${desc}${TC.reset}` : ''}`;
+        const modelSuffix = model ? `${TC.dim}/${model}${TC.reset}` : '';
+        return `${ts()}🤖 → ${colored}${modelSuffix}${desc && agentType ? ` ${TC.dim}${desc}${TC.reset}` : ''}`;
     }
     const detail = input.command ?? input.file_path ?? input.pattern ?? input.query ?? '';
     const short = detail.slice(0, 120);
@@ -214,7 +216,10 @@ export function formatStreamEventTracked(event) {
                         _agentReturnDepths.push(_formatToolDepth);
                         const input = block.input ?? {};
                         const name = input.subagent_type || input.description || 'sub-agent';
-                        _agentTag = `${colorizeAgent(name)} `;
+                        const model = input.model ?? '';
+                        _agentTag = model
+                            ? `${colorizeAgent(name)}${TC.dim}/${model}${TC.reset} `
+                            : `${colorizeAgent(name)} `;
                     }
                 }
             }

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

@@ -317,19 +317,37 @@ describe('formatStreamEvent with Agent tool', () => {
     beforeEach(() => {
         resetStreamState();
     });
-    it('formats Agent tool_use with robot icon and sub-agent type', () => {
+    it('formats Agent tool_use with robot icon, sub-agent type, and model', () => {
         const result = formatStreamEvent({
             type: 'assistant',
             message: {
                 content: [{
                         type: 'tool_use',
                         name: 'Agent',
-                        input: { subagent_type: 'ui-engineer', description: 'plan frontend' },
+                        input: { subagent_type: 'ui-engineer', description: 'plan frontend', model: 'opus' },
                     }],
             },
         });
         expect(result).toContain('🤖');
         expect(result).toContain('ui-engineer');
+        expect(result).toContain('opus');
+    });
+    it('formats Agent tool_use without model when not specified', () => {
+        const result = formatStreamEvent({
+            type: 'assistant',
+            message: {
+                content: [{
+                        type: 'tool_use',
+                        name: 'Agent',
+                        input: { subagent_type: 'Explore', description: 'find files' },
+                    }],
+            },
+        });
+        expect(result).toContain('🤖');
+        expect(result).toContain('Explore');
+        // No /model suffix when model not specified
+        const stripped = result.replace(/\x1b\[\d+m/g, '');
+        expect(stripped).not.toMatch(/Explore\//);
     });
     it('falls back to description when no subagent_type', () => {
         const result = formatStreamEvent({
@@ -370,26 +388,27 @@ describe('formatStreamEventTracked', () => {
         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)
+        // 1. Agent tool_use — should show orchestrator (parent delegates) + sub-agent with model
         const delegation = formatStreamEventTracked({
             type: 'assistant',
-            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'ui-engineer', description: 'plan' } }] },
+            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'ui-engineer', description: 'plan', model: 'opus' } }] },
         });
         expect(stripAnsi(delegation)).toContain('orchestrator/opus-4.6');
         expect(stripAnsi(delegation)).toContain('🤖');
-        // 2. Sub-agent's internal tool call — should show ui-engineer
+        expect(stripAnsi(delegation)).toContain('ui-engineer/opus');
+        // 2. Sub-agent's internal tool call — should show ui-engineer/opus
         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)).toContain('ui-engineer/opus');
         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');
+        expect(stripAnsi(subResult)).toContain('ui-engineer/opus');
         // 4. Agent tool result — restores orchestrator
         const agentResult = formatStreamEventTracked({
             type: 'user',
@@ -404,33 +423,33 @@ describe('formatStreamEventTracked', () => {
         expect(stripAnsi(nextTool)).toContain('orchestrator/opus-4.6');
     });
     it('handles nested Agent calls (agent within agent)', () => {
-        // orchestrator → backend-ts-architect → (inner tool)
+        // orchestrator → backend-ts-architect/opus → (inner tool)
         formatStreamEventTracked({
             type: 'assistant',
-            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'backend-ts-architect' } }] },
+            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'backend-ts-architect', model: 'opus' } }] },
         });
         // backend-ts-architect calls Agent (hypothetical nested delegation)
         formatStreamEventTracked({
             type: 'assistant',
-            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'Explore' } }] },
+            message: { content: [{ type: 'tool_use', name: 'Agent', input: { subagent_type: 'Explore', model: 'haiku' } }] },
         });
-        // Inner agent's tool
+        // Inner agent's tool — should show Explore/haiku
         const innerTool = formatStreamEventTracked({
             type: 'assistant',
             message: { content: [{ type: 'tool_use', name: 'Grep', input: { pattern: 'TODO' } }] },
         });
-        expect(stripAnsi(innerTool)).toContain('Explore');
+        expect(stripAnsi(innerTool)).toContain('Explore/haiku');
         // Inner agent's tool result
         formatStreamEventTracked({
             type: 'user',
             message: { content: [{ type: 'tool_result', content: 'found' }] },
         });
-        // Inner Agent result → back to backend-ts-architect
+        // Inner Agent result → back to backend-ts-architect/opus
         const innerAgentResult = formatStreamEventTracked({
             type: 'user',
             message: { content: [{ type: 'tool_result', content: 'explore done' }] },
         });
-        expect(stripAnsi(innerAgentResult)).toContain('backend-ts-architect');
+        expect(stripAnsi(innerAgentResult)).toContain('backend-ts-architect/opus');
         // Outer Agent result → back to orchestrator
         const outerAgentResult = formatStreamEventTracked({
             type: 'user',

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

@@ -106,7 +106,8 @@ At the beginning of EVERY session (including every Ralph Loop iteration):
 ### 5. Reconcile working state
 Before doing anything, check for unexpected state from user intervention or previous session:
 - **Worktree recovery**: Read MEMORY.md `Current Worktree`. If set, check if the worktree directory exists:
-  - Worktree exists + `Current Step` is set → resume from that step (continue working in the worktree)
+  - Worktree exists + `Current Step` is set → resume using the rules below:
+  - **Crash recovery for STEPs 1-10** (planning/implementation/review phase): The architect's plan from the previous session is LOST (it was only in context). You MUST re-delegate to the architect agent (STEP 2) before continuing. The architect will see the existing implementation in the worktree and produce a plan covering only the remaining work. Then continue from STEP 3. **Do NOT attempt to assess, read, or continue implementation yourself without a fresh architect plan.**
   - **Crash recovery for STEP 11**: If `Current Step` contains `11 —` (exactly `11 — COMMIT`, not `11b`):
     - Check `git -C {worktree} status` for uncommitted changes. If present, the STEP 11 commit was incomplete — re-stage all task files + TODO.md + MEMORY.md in the worktree and commit.
     - If worktree is clean, the commit succeeded. Proceed to STEP 11b (CI watch) if git integration active, otherwise STEP 12.
@@ -119,8 +120,7 @@ Before doing anything, check for unexpected state from user intervention or prev
   - **Crash recovery for STEP 12**: If `Current Step` contains `12`:
     - Check if the feature branch has commits ahead of main. If yes, proceed to STEP 12 (merge from main).
     - If already merged: clean up worktree and branch, clear `Current Worktree` from MEMORY.md.
-  - **Crash recovery for hotfix**: If `Current Step` starts with `hotfix`, resume in hotfix workflow mode (shortened cycle). Use the STEP number after `hotfix —` to determine where to continue.
-  - Worktree has uncommitted changes matching current task → continue from recorded step
+  - **Crash recovery for hotfix**: If `Current Step` starts with `hotfix`, resume in hotfix workflow mode (shortened cycle). Re-delegate to architect (same as STEPs 1-10 recovery above), then continue from the hotfix step.
   - `Current Worktree` is set but directory doesn't exist → orphaned reference. Check if the branch was merged (in `git log main`). If merged: clear `Current Worktree` and `Current Task` from MEMORY.md. If not merged but branch exists: recreate worktree `git worktree add {path} {branch}` and resume. If branch is gone: clear tracking, move to next task.
 - **Orphaned worktrees**: `git worktree list` — if there are worktrees not referenced by MEMORY.md `Current Worktree`:
   - `git worktree remove --force {path}` + `git branch -D {branch}` if the branch is not merged

package/package.json

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