opencastle 0.34.2 → 0.34.3

package/src/cli/run/adapters/copilot.test.ts

@@ -233,4 +233,89 @@ describe('copilot adapter — CLI mode', () => {
       token: 'abc',
     })
   })
+
+  it('extracts result from single-line JSON output', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"result":"# My PRD\\n\\nThe actual content"}')
+    })
+    const { execute } = await import('./copilot.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# My PRD\n\nThe actual content')
+  })
+
+  it('extracts result from JSONL output (last line has result)', async () => {
+    const jsonl = [
+      '{"type":"progress","content":"thinking..."}',
+      '{"type":"tool_use","tool":"read_file","args":{}}',
+      '{"type":"result","result":"# My PRD\\n\\nThe actual markdown content","usage":{"input_tokens":500,"output_tokens":1000}}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./copilot.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# My PRD\n\nThe actual markdown content')
+    expect(result.usage?.prompt_tokens).toBe(500)
+    expect(result.usage?.completion_tokens).toBe(1000)
+  })
+
+  it('scans JSONL and finds result line among non-result lines', async () => {
+    const jsonl = [
+      '{"type":"progress","content":"thinking..."}',
+      '{"type":"tool_use","tool":"edit","args":{}}',
+      '{"type":"result","result":"# Final Content","usage":{"input_tokens":100,"output_tokens":200}}',
+      '{"type":"done"}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./copilot.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# Final Content')
+  })
+
+  it('extracts content from Copilot-style assistant.message JSONL', async () => {
+    const jsonl = [
+      '{"type":"session.tools_updated","data":{"model":"claude-sonnet-4.6"}}',
+      '{"type":"user.message","data":{"content":"Generate a PRD"}}',
+      '{"type":"assistant.message","data":{"content":"# My PRD\\n\\nThe generated content","outputTokens":50}}',
+      '{"type":"assistant.turn_end","data":{"turnId":"0"}}',
+      '{"type":"result","sessionId":"abc","exitCode":0,"usage":{"premiumRequests":1}}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./copilot.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# My PRD\n\nThe generated content')
+  })
+
+  it('uses last assistant.message when multiple turns exist', async () => {
+    const jsonl = [
+      '{"type":"assistant.message","data":{"content":"Let me check..."}}',
+      '{"type":"assistant.message","data":{"content":"# Final PRD\\n\\nComplete document"}}',
+      '{"type":"result","sessionId":"abc","exitCode":0}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./copilot.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# Final PRD\n\nComplete document')
+  })
+
+  it('falls back to raw output when JSON has no result field', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"status":"ok","data":"something"}')
+    })
+    const { execute } = await import('./copilot.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('{"status":"ok","data":"something"}')
+  })
 })

package/src/cli/run/adapters/copilot.ts

@@ -190,14 +190,11 @@ async function executeViaCli(task: Task, options: ExecuteOptions = {}): Promise<
       let textOutput = [stdout, stderr].filter(Boolean).join('\n')
       let usage: TokenUsage | undefined
       try {
+        // Try single JSON object first (claude CLI)
         const parsedJson = JSON.parse(stdout) as Record<string, unknown>
-
-        // Extract the actual AI text response from the JSON envelope
-        const result = parsedJson.result as string | undefined
-        if (typeof result === 'string') {
-          textOutput = result
+        if (typeof parsedJson.result === 'string') {
+          textOutput = parsedJson.result
         }
-
         const u = parsedJson?.usage as Record<string, number> | undefined
         if (u) {
           const promptTokens = (u.input_tokens ?? u.prompt_tokens) as number | undefined
@@ -205,7 +202,44 @@ async function executeViaCli(task: Task, options: ExecuteOptions = {}): Promise<
           const total = ((promptTokens ?? 0) + (completionTokens ?? 0)) || undefined
           usage = { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: total }
         }
-      } catch { /* not JSON or no usage — graceful degradation */ }
+      } catch {
+        // Fallback: parse JSONL (one JSON object per line)
+        // Claude CLI uses {"result": "text"}, Copilot CLI uses
+        // {"type":"assistant.message","data":{"content":"text"}} for the AI
+        // response and a separate {"type":"result"} line for session metadata.
+        const lines = stdout.split('\n')
+        let lastAssistantContent: string | undefined
+        for (const rawLine of lines) {
+          const line = rawLine.trim()
+          if (!line) continue
+          try {
+            const parsed = JSON.parse(line) as Record<string, unknown>
+            // Claude-style: result text in the result line
+            if (typeof parsed.result === 'string' && parsed.result) {
+              textOutput = parsed.result
+              const u = parsed?.usage as Record<string, number> | undefined
+              if (u) {
+                const promptTokens = (u.input_tokens ?? u.prompt_tokens) as number | undefined
+                const completionTokens = (u.output_tokens ?? u.completion_tokens) as number | undefined
+                const total = ((promptTokens ?? 0) + (completionTokens ?? 0)) || undefined
+                usage = { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: total }
+              }
+              lastAssistantContent = undefined // prefer explicit result field
+              break
+            }
+            // Copilot-style: AI response in assistant.message events
+            if (parsed.type === 'assistant.message') {
+              const data = parsed.data as Record<string, unknown> | undefined
+              if (data && typeof data.content === 'string') {
+                lastAssistantContent = data.content
+              }
+            }
+          } catch { /* skip non-JSON lines */ }
+        }
+        if (lastAssistantContent !== undefined) {
+          textOutput = lastAssistantContent
+        }
+      }
       resolve({
         success: code === 0,
         output: textOutput.slice(0, 500_000),

package/src/cli/run/adapters/cursor.test.ts

@@ -157,4 +157,89 @@ describe('cursor adapter — MCP support', () => {
     expect(capturedArgs).toContain('--approve-mcps')
     expect(existsSync(join(tmpDir, 'mcp.json'))).toBe(false)
   })
+
+  it('extracts result from single-line JSON output', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"result":"# My PRD\\n\\nThe actual content"}')
+    })
+    const { execute } = await import('./cursor.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# My PRD\n\nThe actual content')
+  })
+
+  it('extracts result from JSONL output (last line has result)', async () => {
+    const jsonl = [
+      '{"type":"progress","content":"thinking..."}',
+      '{"type":"tool_use","tool":"read_file","args":{}}',
+      '{"type":"result","result":"# My PRD\\n\\nThe actual markdown content","usage":{"input_tokens":500,"output_tokens":1000}}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./cursor.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# My PRD\n\nThe actual markdown content')
+    expect(result.usage?.prompt_tokens).toBe(500)
+    expect(result.usage?.completion_tokens).toBe(1000)
+  })
+
+  it('scans JSONL and finds result line among non-result lines', async () => {
+    const jsonl = [
+      '{"type":"progress","content":"thinking..."}',
+      '{"type":"tool_use","tool":"edit","args":{}}',
+      '{"type":"result","result":"# Final Content","usage":{"input_tokens":100,"output_tokens":200}}',
+      '{"type":"done"}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./cursor.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# Final Content')
+  })
+
+  it('extracts content from Copilot-style assistant.message JSONL', async () => {
+    const jsonl = [
+      '{"type":"session.tools_updated","data":{"model":"claude-sonnet-4.6"}}',
+      '{"type":"user.message","data":{"content":"Generate a PRD"}}',
+      '{"type":"assistant.message","data":{"content":"# My PRD\\n\\nThe generated content","outputTokens":50}}',
+      '{"type":"assistant.turn_end","data":{"turnId":"0"}}',
+      '{"type":"result","sessionId":"abc","exitCode":0,"usage":{"premiumRequests":1}}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./cursor.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# My PRD\n\nThe generated content')
+  })
+
+  it('uses last assistant.message when multiple turns exist', async () => {
+    const jsonl = [
+      '{"type":"assistant.message","data":{"content":"Let me check..."}}',
+      '{"type":"assistant.message","data":{"content":"# Final PRD\\n\\nComplete document"}}',
+      '{"type":"result","sessionId":"abc","exitCode":0}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./cursor.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# Final PRD\n\nComplete document')
+  })
+
+  it('falls back to raw output when JSON has no result field', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"status":"ok","data":"something"}')
+    })
+    const { execute } = await import('./cursor.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('{"status":"ok","data":"something"}')
+  })
 })

package/src/cli/run/adapters/cursor.ts

@@ -88,14 +88,11 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
       let textOutput = [stdout, stderr].filter(Boolean).join('\n')
       let usage: TokenUsage | undefined
       try {
+        // Try single JSON object first (claude CLI)
         const parsed = JSON.parse(stdout) as Record<string, unknown>
-
-        // Extract the actual AI text response from the JSON envelope
-        const result = parsed.result as string | undefined
-        if (typeof result === 'string') {
-          textOutput = result
+        if (typeof parsed.result === 'string') {
+          textOutput = parsed.result
         }
-
         const u = parsed?.usage as Record<string, number> | undefined
         if (u) {
           const promptTokens = (u.input_tokens ?? u.prompt_tokens) as number | undefined
@@ -103,7 +100,44 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
           const total = ((promptTokens ?? 0) + (completionTokens ?? 0)) || undefined
           usage = { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: total }
         }
-      } catch { /* not JSON or no usage — graceful degradation */ }
+      } catch {
+        // Fallback: parse JSONL (one JSON object per line)
+        // Claude CLI uses {"result": "text"}, Copilot CLI uses
+        // {"type":"assistant.message","data":{"content":"text"}} for the AI
+        // response and a separate {"type":"result"} line for session metadata.
+        const lines = stdout.split('\n')
+        let lastAssistantContent: string | undefined
+        for (const rawLine of lines) {
+          const line = rawLine.trim()
+          if (!line) continue
+          try {
+            const parsed = JSON.parse(line) as Record<string, unknown>
+            // Claude-style: result text in the result line
+            if (typeof parsed.result === 'string' && parsed.result) {
+              textOutput = parsed.result
+              const u = parsed?.usage as Record<string, number> | undefined
+              if (u) {
+                const promptTokens = (u.input_tokens ?? u.prompt_tokens) as number | undefined
+                const completionTokens = (u.output_tokens ?? u.completion_tokens) as number | undefined
+                const total = ((promptTokens ?? 0) + (completionTokens ?? 0)) || undefined
+                usage = { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: total }
+              }
+              lastAssistantContent = undefined // prefer explicit result field
+              break
+            }
+            // Copilot-style: AI response in assistant.message events
+            if (parsed.type === 'assistant.message') {
+              const data = parsed.data as Record<string, unknown> | undefined
+              if (data && typeof data.content === 'string') {
+                lastAssistantContent = data.content
+              }
+            }
+          } catch { /* skip non-JSON lines */ }
+        }
+        if (lastAssistantContent !== undefined) {
+          textOutput = lastAssistantContent
+        }
+      }
       resolve({
         success: code === 0,
         output: textOutput.slice(0, 500_000),

package/src/cli/run/adapters/opencode.test.ts

@@ -130,6 +130,7 @@ describe('opencode adapter — MCP support', () => {
     })
     const { execute } = await import('./opencode.js')
     await execute(makeTask(), { cwd: tmpDir })
+    expect(capturedArgs).toContain('run')
     expect(capturedArgs).not.toContain('--mcp-config')
   })
 
@@ -156,4 +157,89 @@ describe('opencode adapter — MCP support', () => {
     await execute(makeTask(), { cwd: tmpDir })
     expect(capturedArgs).not.toContain('--approve-mcps')
   })
+
+  it('extracts result from single-line JSON output', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"result":"# My PRD\\n\\nThe actual content"}')
+    })
+    const { execute } = await import('./opencode.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# My PRD\n\nThe actual content')
+  })
+
+  it('extracts result from JSONL output (last line has result)', async () => {
+    const jsonl = [
+      '{"type":"progress","content":"thinking..."}',
+      '{"type":"tool_use","tool":"read_file","args":{}}',
+      '{"type":"result","result":"# My PRD\\n\\nThe actual markdown content","usage":{"input_tokens":500,"output_tokens":1000}}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./opencode.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# My PRD\n\nThe actual markdown content')
+    expect(result.usage?.prompt_tokens).toBe(500)
+    expect(result.usage?.completion_tokens).toBe(1000)
+  })
+
+  it('scans JSONL and finds result line among non-result lines', async () => {
+    const jsonl = [
+      '{"type":"progress","content":"thinking..."}',
+      '{"type":"tool_use","tool":"edit","args":{}}',
+      '{"type":"result","result":"# Final Content","usage":{"input_tokens":100,"output_tokens":200}}',
+      '{"type":"done"}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./opencode.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# Final Content')
+  })
+
+  it('extracts content from Copilot-style assistant.message JSONL', async () => {
+    const jsonl = [
+      '{"type":"session.tools_updated","data":{"model":"claude-sonnet-4.6"}}',
+      '{"type":"user.message","data":{"content":"Generate a PRD"}}',
+      '{"type":"assistant.message","data":{"content":"# My PRD\\n\\nThe generated content","outputTokens":50}}',
+      '{"type":"assistant.turn_end","data":{"turnId":"0"}}',
+      '{"type":"result","sessionId":"abc","exitCode":0,"usage":{"premiumRequests":1}}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./opencode.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# My PRD\n\nThe generated content')
+  })
+
+  it('uses last assistant.message when multiple turns exist', async () => {
+    const jsonl = [
+      '{"type":"assistant.message","data":{"content":"Let me check..."}}',
+      '{"type":"assistant.message","data":{"content":"# Final PRD\\n\\nComplete document"}}',
+      '{"type":"result","sessionId":"abc","exitCode":0}',
+    ].join('\n')
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, jsonl)
+    })
+    const { execute } = await import('./opencode.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('# Final PRD\n\nComplete document')
+  })
+
+  it('falls back to raw output when JSON has no result field', async () => {
+    mockSpawn.mockImplementation((cmd: string) => {
+      if (cmd === 'which') return makeMockProc(0, '')
+      return makeMockProc(0, '{"status":"ok","data":"something"}')
+    })
+    const { execute } = await import('./opencode.js')
+    const result = await execute(makeTask(), { cwd: tmpDir })
+    expect(result.output).toBe('{"status":"ok","data":"something"}')
+  })
 })

package/src/cli/run/adapters/opencode.ts

@@ -28,7 +28,7 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
     prompt += `\n\nOnly modify files under: ${task.files.join(', ')}`
   }
 
-  const args = ['--headless', '-p', prompt, '--output-format', 'json']
+  const args = ['run', prompt, '--format', 'json']
 
   const cwd = options?.cwd ?? process.cwd()
   const mcpJsonPath = join(cwd, 'mcp.json')
@@ -82,14 +82,11 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
       let textOutput = [stdout, stderr].filter(Boolean).join('\n')
       let usage: TokenUsage | undefined
       try {
+        // Try single JSON object first (claude CLI)
         const parsed = JSON.parse(stdout) as Record<string, unknown>
-
-        // Extract the actual AI text response from the JSON envelope
-        const result = parsed.result as string | undefined
-        if (typeof result === 'string') {
-          textOutput = result
+        if (typeof parsed.result === 'string') {
+          textOutput = parsed.result
         }
-
         const u = parsed?.usage as Record<string, number> | undefined
         if (u) {
           const promptTokens = (u.input_tokens ?? u.prompt_tokens) as number | undefined
@@ -97,7 +94,44 @@ export async function execute(task: Task, options: ExecuteOptions = {}): Promise
           const total = ((promptTokens ?? 0) + (completionTokens ?? 0)) || undefined
           usage = { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: total }
         }
-      } catch { /* not JSON or no usage — graceful degradation */ }
+      } catch {
+        // Fallback: parse JSONL (one JSON object per line)
+        // Claude CLI uses {"result": "text"}, Copilot CLI uses
+        // {"type":"assistant.message","data":{"content":"text"}} for the AI
+        // response and a separate {"type":"result"} line for session metadata.
+        const lines = stdout.split('\n')
+        let lastAssistantContent: string | undefined
+        for (const rawLine of lines) {
+          const line = rawLine.trim()
+          if (!line) continue
+          try {
+            const parsed = JSON.parse(line) as Record<string, unknown>
+            // Claude-style: result text in the result line
+            if (typeof parsed.result === 'string' && parsed.result) {
+              textOutput = parsed.result
+              const u = parsed?.usage as Record<string, number> | undefined
+              if (u) {
+                const promptTokens = (u.input_tokens ?? u.prompt_tokens) as number | undefined
+                const completionTokens = (u.output_tokens ?? u.completion_tokens) as number | undefined
+                const total = ((promptTokens ?? 0) + (completionTokens ?? 0)) || undefined
+                usage = { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: total }
+              }
+              lastAssistantContent = undefined // prefer explicit result field
+              break
+            }
+            // Copilot-style: AI response in assistant.message events
+            if (parsed.type === 'assistant.message') {
+              const data = parsed.data as Record<string, unknown> | undefined
+              if (data && typeof data.content === 'string') {
+                lastAssistantContent = data.content
+              }
+            }
+          } catch { /* skip non-JSON lines */ }
+        }
+        if (lastAssistantContent !== undefined) {
+          textOutput = lastAssistantContent
+        }
+      }
       resolve({
         success: code === 0,
         output: textOutput.slice(0, 500_000),

package/src/dashboard/dist/data/convoys/demo-api-v2.json

@@ -51,21 +51,21 @@
       "name": "docs/api-v2-contract.json",
       "type": "json",
       "task_id": "api-t1",
-      "created_at": "2026-04-10T09:30:29.641Z"
-    },
-    {
-      "id": "artifact-demo-api-v2-reports-security-gate-failure-md",
-      "name": "reports/security-gate-failure.md",
-      "type": "summary",
-      "task_id": "api-t3",
-      "created_at": "2026-04-10T09:30:29.641Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
     },
     {
       "id": "artifact-demo-api-v2-src-api-rate-limiter-ts",
       "name": "src/api/rate-limiter.ts",
       "type": "file",
       "task_id": "api-t2",
-      "created_at": "2026-04-10T09:30:29.641Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
+    },
+    {
+      "id": "artifact-demo-api-v2-reports-security-gate-failure-md",
+      "name": "reports/security-gate-failure.md",
+      "type": "summary",
+      "task_id": "api-t3",
+      "created_at": "2026-04-10T12:41:00.578Z"
     }
   ],
   "has_more_events": false,

package/src/dashboard/dist/data/convoys/demo-auth-revamp.json

@@ -42,28 +42,28 @@
       "name": "libs/auth/src/jwt-middleware.ts",
       "type": "file",
       "task_id": "auth-t2",
-      "created_at": "2026-04-10T09:30:29.640Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
     },
     {
       "id": "artifact-demo-auth-revamp-libs-auth-src-rls-policies-sql",
       "name": "libs/auth/src/rls-policies.sql",
       "type": "file",
       "task_id": "auth-t3",
-      "created_at": "2026-04-10T09:30:29.640Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
     },
     {
       "id": "artifact-demo-auth-revamp-reports-auth-review-summary-md",
       "name": "reports/auth-review-summary.md",
       "type": "summary",
       "task_id": "auth-t5",
-      "created_at": "2026-04-10T09:30:29.640Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
     },
     {
       "id": "artifact-demo-auth-revamp-tests-auth-integration-test-ts",
       "name": "tests/auth/integration.test.ts",
       "type": "file",
       "task_id": "auth-t4",
-      "created_at": "2026-04-10T09:30:29.640Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
     }
   ],
   "has_more_events": false,

package/src/dashboard/dist/data/convoys/demo-dashboard-ui.json

@@ -46,47 +46,47 @@
   ],
   "artifact_count": 6,
   "artifacts": [
-    {
-      "id": "artifact-demo-dashboard-ui-src-components-design-tokens-ts",
-      "name": "src/components/design-tokens.ts",
-      "type": "file",
-      "task_id": "ui-t1",
-      "created_at": "2026-04-10T09:30:29.640Z"
-    },
     {
       "id": "artifact-demo-dashboard-ui-reports-panel-review-dashboard-md",
       "name": "reports/panel-review-dashboard.md",
       "type": "summary",
       "task_id": "ui-t7",
-      "created_at": "2026-04-10T09:30:29.641Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
     },
     {
       "id": "artifact-demo-dashboard-ui-reports-visual-regression-json",
       "name": "reports/visual-regression.json",
       "type": "json",
       "task_id": "ui-t6",
-      "created_at": "2026-04-10T09:30:29.641Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
     },
     {
       "id": "artifact-demo-dashboard-ui-src-components-DonutChart-tsx",
       "name": "src/components/DonutChart.tsx",
       "type": "file",
       "task_id": "ui-t3",
-      "created_at": "2026-04-10T09:30:29.641Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
     },
     {
       "id": "artifact-demo-dashboard-ui-src-components-KpiCard-tsx",
       "name": "src/components/KpiCard.tsx",
       "type": "file",
       "task_id": "ui-t2",
-      "created_at": "2026-04-10T09:30:29.641Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
+    },
+    {
+      "id": "artifact-demo-dashboard-ui-src-components-design-tokens-ts",
+      "name": "src/components/design-tokens.ts",
+      "type": "file",
+      "task_id": "ui-t1",
+      "created_at": "2026-04-10T12:41:00.577Z"
     },
     {
       "id": "artifact-demo-dashboard-ui-src-styles-animations-css",
       "name": "src/styles/animations.css",
       "type": "file",
       "task_id": "ui-t4",
-      "created_at": "2026-04-10T09:30:29.641Z"
+      "created_at": "2026-04-10T12:41:00.577Z"
     }
   ],
   "has_more_events": false,

package/src/dashboard/dist/data/convoys/demo-data-pipeline.json

@@ -42,21 +42,21 @@
       "name": "src/etl/pipeline.ts",
       "type": "file",
       "task_id": "etl-t2",
-      "created_at": "2026-04-10T09:30:29.642Z"
+      "created_at": "2026-04-10T12:41:00.578Z"
     },
     {
       "id": "artifact-demo-data-pipeline-src-etl-schema-ts",
       "name": "src/etl/schema.ts",
       "type": "file",
       "task_id": "etl-t1",
-      "created_at": "2026-04-10T09:30:29.642Z"
+      "created_at": "2026-04-10T12:41:00.578Z"
     },
     {
       "id": "artifact-demo-data-pipeline-tests-etl-pipeline-test-ts",
       "name": "tests/etl/pipeline.test.ts",
       "type": "file",
       "task_id": "etl-t3",
-      "created_at": "2026-04-10T09:30:29.642Z"
+      "created_at": "2026-04-10T12:41:00.578Z"
     }
   ],
   "has_more_events": false,

package/src/dashboard/dist/data/convoys/demo-deploy-ci.json

@@ -51,7 +51,7 @@
       "name": ".github/workflows/ci.yml",
       "type": "file",
       "task_id": "ci-t1",
-      "created_at": "2026-04-10T09:30:29.642Z"
+      "created_at": "2026-04-10T12:41:00.578Z"
     }
   ],
   "has_more_events": false,