@winspan/claude-forge 8.53.2 → 8.54.4

package/src/web/routes/skills.ts

@@ -1,350 +0,0 @@
-import type { Application } from 'express';
-import fs from 'fs';
-import path from 'path';
-import { homedir } from 'os';
-import { logger } from '../../core/utils/logger.js';
-import type { RouteContext } from './types.js';
-import { FORGE_PATHS } from '../../core/constants.js';
-
-/**
- * /api/skills/* — list, read, update, version, rollback.
- *
- * Supports both flat `<name>.md` and directory-style `<name>/SKILL.md` layouts.
- * Prefers the registry when available so built-in skills resolve correctly.
- */
-export function registerSkillsRoutes(app: Application, ctx: RouteContext): void {
-  const skillRegistry = ctx.skillRegistry;
-
-  // GET /api/skills — list all skills (official + user; supports flat & directory formats)
-  app.get('/api/skills', (_req, res) => {
-    try {
-      if (skillRegistry) {
-        // Preferred path: reuse SkillRegistry (handles flat .md and <name>/SKILL.md)
-        const skills = skillRegistry.getAll().map(s => ({
-          name: s.name,
-          id: s.id,
-          description: s.description ?? '',
-          keywords: s.keywords,
-          path: s.path,
-          isOfficial: s.isOfficial === true,
-          source: s.isOfficial ? 'official' : 'user',
-        }));
-        res.json({ skills });
-        return;
-      }
-
-      // Fallback: scan directly if registry not injected
-      const skillsDir = path.join(homedir(), '.claude', 'skills');
-      const skills: Array<{
-        name: string;
-        id: string;
-        description: string;
-        keywords: string[];
-        path: string;
-        isOfficial: boolean;
-        source: 'official' | 'user';
-      }> = [];
-
-      if (fs.existsSync(skillsDir)) {
-        const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
-        for (const entry of entries) {
-          let filePath: string | null = null;
-          let id: string;
-
-          if (entry.isFile() && entry.name.endsWith('.md')) {
-            filePath = path.join(skillsDir, entry.name);
-            id = entry.name.replace(/\.md$/, '');
-          } else if (entry.isDirectory() || entry.isSymbolicLink()) {
-            const skillMd = path.join(skillsDir, entry.name, 'SKILL.md');
-            if (!fs.existsSync(skillMd)) continue;
-            filePath = skillMd;
-            id = entry.name;
-          } else {
-            continue;
-          }
-
-          try {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const match = content.match(/^---\n([\s\S]*?)\n---/);
-            let description = '';
-            const keywords: string[] = [];
-            if (match) {
-              const fm = match[1];
-              const descMatch = fm.match(/description:\s*["']?([^"'\n]+)["']?/);
-              description = descMatch?.[1]?.trim() || '';
-            }
-            skills.push({
-              name: id,
-              id,
-              description,
-              keywords,
-              path: filePath,
-              isOfficial: false,
-              source: 'user',
-            });
-          } catch (err) {
-            logger.warn(`[Web] Failed to read skill ${id}: ${err}`);
-          }
-        }
-      }
-
-      res.json({ skills });
-    } catch (err) {
-      logger.warn(`[Web] Failed to list skills: ${err}`);
-      res.status(500).json({ error: String(err) });
-    }
-  });
-
-  // GET /api/skills/:name — get skill details (supports flat & directory formats)
-  app.get('/api/skills/:name', (req, res) => {
-    try {
-      const { name } = req.params;
-
-      // Security: prevent path traversal attacks
-      if (!name || name.includes('/') || name.includes('\\') || name.includes('..')) {
-        res.status(400).json({ error: 'Invalid skill name' });
-        return;
-      }
-
-      if (skillRegistry) {
-        const skill = skillRegistry.getAll().find(s => s.id === name || s.name === name);
-        if (skill) {
-          if (skill.path === '<built-in>') {
-            res.json({
-              name: skill.name,
-              id: skill.id,
-              description: skill.description ?? '',
-              keywords: skill.keywords,
-              isOfficial: true,
-              source: 'official',
-              content: skill.content,
-            });
-            return;
-          }
-          // For user skills, fall through to disk read so edits show latest content
-          if (fs.existsSync(skill.path)) {
-            const content = fs.readFileSync(skill.path, 'utf-8');
-            res.json({
-              name: skill.name,
-              id: skill.id,
-              description: skill.description ?? '',
-              keywords: skill.keywords,
-              isOfficial: false,
-              source: 'user',
-              path: skill.path,
-              content,
-            });
-            return;
-          }
-        }
-      }
-
-      // Fallback: try flat .md then <name>/SKILL.md
-      const skillsDir = path.join(homedir(), '.claude', 'skills');
-      const flatPath = path.join(skillsDir, `${name}.md`);
-      const dirPath = path.join(skillsDir, name, 'SKILL.md');
-      const filePath = fs.existsSync(flatPath)
-        ? flatPath
-        : fs.existsSync(dirPath)
-          ? dirPath
-          : null;
-
-      if (!filePath) {
-        res.status(404).json({ error: 'Skill not found' });
-        return;
-      }
-
-      const content = fs.readFileSync(filePath, 'utf-8');
-      const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-      if (!match) {
-        res.json({ name, id: name, content, path: filePath });
-        return;
-      }
-
-      const fm = match[1];
-      const descMatch = fm.match(/description:\s*["']?([^"'\n]+)["']?/);
-      const verMatch = fm.match(/version:\s*["']?([^"'\n]+)["']?/);
-      const sourceMatch = fm.match(/source:\s*["']?([^"'\n]+)["']?/);
-
-      res.json({
-        name,
-        id: name,
-        description: descMatch?.[1]?.trim() || '',
-        version: verMatch?.[1],
-        source: sourceMatch?.[1] || 'user',
-        path: filePath,
-        content,
-      });
-    } catch (err) {
-      logger.warn(`[Web] Failed to get skill ${req.params.name}: ${err}`);
-      res.status(500).json({ error: String(err) });
-    }
-  });
-
-  // PUT /api/skills/:name — update skill content
-  app.put('/api/skills/:name', (req, res) => {
-    try {
-      const { name } = req.params;
-      const { content } = req.body;
-
-      // Security: prevent path traversal attacks
-      if (!name || name.includes('/') || name.includes('\\') || name.includes('..')) {
-        res.status(400).json({ error: 'Invalid skill name' });
-        return;
-      }
-
-      if (!content || typeof content !== 'string') {
-        res.status(400).json({ error: 'Missing content' });
-        return;
-      }
-
-      const skillsDir = path.join(homedir(), '.claude', 'skills');
-      const filePath = path.join(skillsDir, `${name}.md`);
-
-      if (!fs.existsSync(filePath)) {
-        res.status(404).json({ error: 'Skill not found' });
-        return;
-      }
-
-      const backupDir = FORGE_PATHS.backups('skills');
-      fs.mkdirSync(backupDir, { recursive: true });
-      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-      const backupPath = path.join(backupDir, `${name}-${timestamp}.md`);
-      fs.copyFileSync(filePath, backupPath);
-
-      fs.writeFileSync(filePath, content, 'utf-8');
-      logger.info(`[Web] Updated skill ${name} (backup: ${backupPath})`);
-
-      res.json({ success: true, backup: backupPath });
-    } catch (err) {
-      logger.warn(`[Web] Failed to update skill ${req.params.name}: ${err}`);
-      res.status(500).json({ error: String(err) });
-    }
-  });
-
-  // GET /api/skills/:name/versions — list backup versions
-  app.get('/api/skills/:name/versions', (req, res) => {
-    try {
-      const { name } = req.params;
-
-      // Security: prevent path traversal attacks
-      if (!name || name.includes('/') || name.includes('\\') || name.includes('..')) {
-        res.status(400).json({ error: 'Invalid skill name' });
-        return;
-      }
-
-      const backupDir = FORGE_PATHS.backups('skills');
-
-      if (!fs.existsSync(backupDir)) {
-        res.json({ versions: [] });
-        return;
-      }
-
-      const files = fs.readdirSync(backupDir)
-        .filter(f => f.startsWith(`${name}-`) && f.endsWith('.md'))
-        .map(f => {
-          const filePath = path.join(backupDir, f);
-          const stats = fs.statSync(filePath);
-          const timestampMatch = f.match(/-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)\.md$/);
-          return {
-            filename: f,
-            timestamp: timestampMatch ? timestampMatch[1].replace(/-/g, ':').replace(/T(\d{2}):(\d{2}):(\d{2})/, 'T$1:$2:$3') : '',
-            size: stats.size,
-            mtime: stats.mtime.toISOString(),
-          };
-        })
-        .sort((a, b) => new Date(b.mtime).getTime() - new Date(a.mtime).getTime());
-
-      res.json({ versions: files });
-    } catch (err) {
-      logger.warn(`[Web] Failed to list skill versions: ${err}`);
-      res.status(500).json({ error: String(err) });
-    }
-  });
-
-  // GET /api/skills/:name/versions/:timestamp — get specific version content
-  app.get('/api/skills/:name/versions/:timestamp', (req, res) => {
-    try {
-      const { name, timestamp } = req.params;
-
-      // Security: prevent path traversal attacks
-      if (!name || name.includes('/') || name.includes('\\') || name.includes('..')) {
-        res.status(400).json({ error: 'Invalid skill name' });
-        return;
-      }
-      if (!timestamp || timestamp.includes('/') || timestamp.includes('\\') || timestamp.includes('..')) {
-        res.status(400).json({ error: 'Invalid timestamp' });
-        return;
-      }
-
-      const backupDir = FORGE_PATHS.backups('skills');
-      const filename = `${name}-${timestamp}.md`;
-      const filePath = path.join(backupDir, filename);
-
-      if (!fs.existsSync(filePath)) {
-        res.status(404).json({ error: 'Version not found' });
-        return;
-      }
-
-      const content = fs.readFileSync(filePath, 'utf-8');
-      res.json({ content });
-    } catch (err) {
-      logger.warn(`[Web] Failed to get skill version: ${err}`);
-      res.status(500).json({ error: String(err) });
-    }
-  });
-
-  // POST /api/skills/:name/rollback — rollback to a specific version
-  app.post('/api/skills/:name/rollback', (req, res) => {
-    try {
-      const { name } = req.params;
-      const { timestamp } = req.body;
-
-      // Security: prevent path traversal attacks
-      if (!name || name.includes('/') || name.includes('\\') || name.includes('..')) {
-        res.status(400).json({ error: 'Invalid skill name' });
-        return;
-      }
-
-      if (!timestamp) {
-        res.status(400).json({ error: 'Missing timestamp' });
-        return;
-      }
-
-      // Security: validate timestamp format
-      if (timestamp.includes('/') || timestamp.includes('\\') || timestamp.includes('..')) {
-        res.status(400).json({ error: 'Invalid timestamp' });
-        return;
-      }
-
-      const skillsDir = path.join(homedir(), '.claude', 'skills');
-      const currentPath = path.join(skillsDir, `${name}.md`);
-      const backupDir = FORGE_PATHS.backups('skills');
-      const versionPath = path.join(backupDir, `${name}-${timestamp}.md`);
-
-      if (!fs.existsSync(currentPath)) {
-        res.status(404).json({ error: 'Skill not found' });
-        return;
-      }
-
-      if (!fs.existsSync(versionPath)) {
-        res.status(404).json({ error: 'Version not found' });
-        return;
-      }
-
-      fs.mkdirSync(backupDir, { recursive: true });
-      const rollbackTimestamp = new Date().toISOString().replace(/[:.]/g, '-');
-      const rollbackBackupPath = path.join(backupDir, `${name}-${rollbackTimestamp}.md`);
-      fs.copyFileSync(currentPath, rollbackBackupPath);
-
-      const versionContent = fs.readFileSync(versionPath, 'utf-8');
-      fs.writeFileSync(currentPath, versionContent, 'utf-8');
-
-      logger.info(`[Web] Rolled back skill ${name} to ${timestamp} (backup: ${rollbackBackupPath})`);
-      res.json({ success: true, backup: rollbackBackupPath });
-    } catch (err) {
-      logger.warn(`[Web] Failed to rollback skill: ${err}`);
-      res.status(500).json({ error: String(err) });
-    }
-  });
-}

package/src/web/routes/static.ts

@@ -1,67 +0,0 @@
-import express from 'express';
-import type { Application } from 'express';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { logger } from '../../core/utils/logger.js';
-import type { RouteContext } from './types.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-function findStaticDir(): string | null {
-  const candidates = [
-    path.join(__dirname, '..', 'static'),           // dist/web/routes -> dist/web/static
-    path.join(__dirname, '../../..', 'src/web/static'), // dev: src/web/routes -> src/web/static
-  ];
-  return candidates.find(d => fs.existsSync(d)) ?? null;
-}
-
-/**
- * Static assets — Vite-built UI + cache headers + SPA fallback.
- *
- * index.html: no-cache (always fetch latest, avoids stale UI after deploy)
- * /assets/*:  immutable, content-hashed, safe to cache for a year.
- *
- * SPA fallback MUST be registered last so it doesn't shadow any API route;
- * that constraint is enforced by splitting into `registerStaticAssets` (runs
- * early, sets up express.static) and `registerStaticFallback` (runs last).
- */
-export function registerStaticAssets(app: Application, _ctx: RouteContext): void {
-  const staticDir = findStaticDir();
-  if (!staticDir) {
-    logger.warn('[Web] Static directory not found; UI will not be served.');
-    return;
-  }
-
-  app.use(express.static(staticDir, {
-    setHeaders: (res, filePath) => {
-      if (filePath.endsWith('index.html')) {
-        res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
-        res.setHeader('Pragma', 'no-cache');
-        res.setHeader('Expires', '0');
-      } else if (filePath.includes('/assets/')) {
-        res.setHeader('Cache-Control', 'public, max-age=31536000, immutable');
-      }
-    },
-  }));
-
-  app.get('/', (_req, res) => {
-    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
-    res.sendFile('index.html', { root: staticDir });
-  });
-
-  logger.info(`[Web] Serving static files from ${staticDir}`);
-}
-
-/**
- * SPA catch-all — must be registered last. Routes any non-/api path to
- * index.html so the frontend router handles deep links on refresh.
- */
-export function registerStaticFallback(app: Application, _ctx: RouteContext): void {
-  const staticDir = findStaticDir();
-  if (!staticDir) return;
-  app.get(/^(?!\/api).*$/, (_req, res) => {
-    res.setHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
-    res.sendFile('index.html', { root: staticDir });
-  });
-}

package/src/web/routes/stats.ts

@@ -1,50 +0,0 @@
-import type { Application } from 'express';
-import type { RouteContext } from './types.js';
-
-/**
- * /api/stats — System-wide statistics for the Dashboard.
- *
- * H2 Phase 3: 替换原 db.prepare 直写 SQL 为 SQLiteStorage facade 聚合方法。
- * 响应 shape 保持不变（前端契约）：totalSessions / totalEvents / toolUsage /
- * dailyActivity / skillInvocations。
- */
-export function registerStatsRoutes(app: Application, ctx: RouteContext): void {
-  const { storage } = ctx;
-
-  app.get('/api/stats', (_req, res) => {
-    const totalEvents = storage.countAllEvents();
-    const totalSessions = storage.countAllSessions();
-
-    // Tool usage distribution (top 15)
-    const toolRows = storage.aggregateToolUsage({ limit: 15 });
-    const toolUsage: Record<string, number> = {};
-    for (const r of toolRows) {
-      toolUsage[r.tool_name] = r.count;
-    }
-
-    // Daily activity (last 7 days)
-    // 旧 SQL: timestamp >= date('now', '-7 days')
-    // 新口径：调用方计算 ISO 字符串，传给 facade。
-    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
-    const dailyRows = storage.aggregateDailyEventCounts({ since: sevenDaysAgo });
-    const sessionDailyRows = storage.aggregateDailySessionCounts({ since: sevenDaysAgo });
-
-    const sessionMap = new Map(sessionDailyRows.map(r => [r.date, r.count]));
-    const dailyActivity = dailyRows.map(r => ({
-      date: r.date,
-      eventCount: r.count,
-      sessionCount: sessionMap.get(r.date) || 0,
-    }));
-
-    // Skill invocation count
-    const skillCount = storage.countAllSkillInvocations();
-
-    res.json({
-      totalSessions,
-      totalEvents,
-      toolUsage,
-      dailyActivity,
-      skillInvocations: skillCount,
-    });
-  });
-}

package/src/web/routes/status.ts

@@ -1,30 +0,0 @@
-import type { Application } from 'express';
-import type { RouteContext } from './types.js';
-
-/**
- * Status / health endpoints for the daemon and background worker.
- */
-export function registerStatusRoutes(app: Application, ctx: RouteContext): void {
-  const { storage } = ctx;
-
-  // Worker auth probe: legacy endpoint kept for UI backwards-compat.
-  // The background worker subsystem was removed alongside the methodology
-  // system (v8.36.0 hard deprecation B.1); the probe now always reports
-  // unavailable so the UI hides background-mode affordances.
-  app.get('/api/worker-auth-status', (_req, res) => {
-    res.json({
-      available: false,
-      reason: 'background worker subsystem removed (methodology deprecation)',
-    });
-  });
-
-  // Dashboard: daemon status
-  app.get('/api/status', (_req, res) => {
-    res.json({
-      pid: process.pid,
-      uptime: process.uptime(),
-      memory: process.memoryUsage(),
-      eventCount: storage.countEvents(),
-    });
-  });
-}

package/src/web/routes/tasks.ts

@@ -1,193 +0,0 @@
-import { z } from 'zod';
-import type { Application } from 'express';
-import type { RouteContext } from './types.js';
-import { truncateField } from './_helpers.js';
-import { getFilePath, getUserPrompt } from '../../core/event-fields.js';
-
-/**
- * /api/tasks — Task execution view.
- *
- * Provides a complete view of a task's execution process:
- *   - GET /api/tasks          — list + filter + paginate tasks
- *   - GET /api/tasks/projects — distinct project paths that have tasks
- *   - GET /api/tasks/:taskId  — full execution detail for a single task
- */
-
-const TaskListQuery = z.object({
-  limit:   z.coerce.number().int().min(1).default(50).transform(v => Math.min(v, 200)),
-  offset:  z.coerce.number().int().min(0).default(0),
-  /** multi-value: ?project=/a&project=/b  OR  ?project=/a */
-  project: z.union([z.string(), z.array(z.string())]).optional(),
-  from:    z.string().optional(),
-  to:      z.string().optional(),
-  search:  z.string().max(100).optional(),
-  session: z.string().optional(),
-});
-
-export function registerTasksRoutes(app: Application, ctx: RouteContext): void {
-  const { storage } = ctx;
-
-  // ── GET /api/tasks/projects — distinct project paths ──────────────────────
-  // Must be registered BEFORE /:taskId to avoid 'projects' being treated as an id.
-  app.get('/api/tasks/projects', (_req, res) => {
-    const projects = storage.queryTaskProjects();
-    res.json(projects);
-  });
-
-  // ── GET /api/tasks — paginated + filtered list ─────────────────────────────
-  app.get('/api/tasks', (req, res) => {
-    const parsed = TaskListQuery.safeParse(req.query);
-    if (!parsed.success) {
-      res.status(400).json({ error: 'Invalid query parameters', details: parsed.error.flatten() });
-      return;
-    }
-
-    const { limit, offset, project, from, to, search, session } = parsed.data;
-
-    const result = storage.queryTasksFiltered({
-      limit,
-      offset,
-      project,
-      from,
-      to,
-      search,
-      session_id: session,
-    });
-
-    res.json(result);
-  });
-
-  // ── GET /api/tasks/:taskId — full execution detail ─────────────────────────
-  app.get('/api/tasks/:taskId', (req, res) => {
-    const taskId = req.params.taskId;
-
-    // H1: PK direct fetch (was: queryTasks({limit:5000}).find)
-    const task = storage.getTask(taskId);
-    if (!task) {
-      res.status(404).json({ error: 'Task not found' });
-      return;
-    }
-
-    // H1: JOIN task_events (was: queryEvents({limit:5000}) + Set.has filter)
-    const taskEvents = storage.queryEventsByTaskId(taskId, { limit: 5000 });
-
-    // ── Injections ──────────────────────────────────────────────────────
-    // H1: JOIN task_events (was: queryInjections({limit:500}) + Set.has filter)
-    const allInjections = storage.queryInjectionsByTaskId(taskId);
-    const injections = allInjections
-      .map(inj => ({
-        id: inj.id,
-        timestamp: inj.timestamp,
-        source_handler: inj.source_handler,
-        injection_type: inj.injection_type,
-        content: inj.content.slice(0, 1000),
-        content_length: inj.content.length,
-        truncated: inj.content.length > 1000,
-      }));
-
-    // ── Timeline ────────────────────────────────────────────────────────
-    const timeline = taskEvents
-      .filter(e => e.tool_name && (e.hook_type === 'PreToolUse' || e.hook_type === 'PostToolUse'))
-      .reduce<Array<{
-        timestamp: string;
-        tool_name: string;
-        hook_type: string;
-        input: unknown;
-        output: unknown;
-        is_agent_call: boolean;
-        agent_detail?: { subagent_type?: string; name?: string; prompt?: string };
-      }>>((acc, e) => {
-        // Deduplicate: only keep PreToolUse entries (PostToolUse is supplementary)
-        if (e.hook_type === 'PostToolUse') {
-          // Attach output to the matching PreToolUse entry if exists
-          const pre = acc.find(
-            a => a.tool_name === e.tool_name && !a.output && a.timestamp <= e.timestamp,
-          );
-          if (pre) {
-            pre.output = truncateField(e.tool_output);
-          }
-          return acc;
-        }
-
-        const toolInput = e.tool_input ?? null;
-        const isAgentCall = e.tool_name === 'Agent' || e.tool_name === 'Task';
-
-        const entry: (typeof acc)[number] = {
-          timestamp: e.timestamp,
-          tool_name: e.tool_name!,
-          hook_type: e.hook_type,
-          input: truncateField(toolInput),
-          output: truncateField(e.tool_output),
-          is_agent_call: isAgentCall,
-        };
-
-        if (isAgentCall && toolInput) {
-          entry.agent_detail = {
-            subagent_type: typeof toolInput.subagent_type === 'string' ? toolInput.subagent_type : undefined,
-            name: typeof toolInput.name === 'string' ? toolInput.name : undefined,
-            prompt: typeof toolInput.prompt === 'string'
-              ? toolInput.prompt
-              : undefined,
-          };
-        }
-
-        acc.push(entry);
-        return acc;
-      }, []);
-
-    // ── Skill Invocations ───────────────────────────────────────────────
-    // H1: SQL window filter (was: querySkillInvocations({limit:200}) + JS time filter)
-    const allSkillInvocations = storage.querySkillInvocationsByTaskWindow(taskId);
-
-    const skillInvocations = allSkillInvocations
-      .map(si => ({
-        id: si.id,
-        skill_id: si.skill_id,
-        agent_id: si.agent_id,
-        invocation_type: si.invocation_type,
-        reason: si.reason,
-        workflow: si.workflow,
-        phase: si.phase,
-        feature_slug: si.feature_slug,
-        success: si.success === 1,
-        error: si.error,
-        timestamp: si.timestamp,
-      }));
-
-    // ── Artifacts ───────────────────────────────────────────────────────
-    const artifacts = [...new Set(
-      taskEvents
-        .filter(e =>
-          (e.tool_name === 'Edit' || e.tool_name === 'Write') &&
-          getFilePath(e),
-        )
-        .map(e => getFilePath(e)!),
-    )];
-
-    // ── User Prompts ────────────────────────────────────────────────────
-    const userPrompts = taskEvents
-      .filter(e => e.hook_type === 'UserPromptSubmit' && getUserPrompt(e))
-      .map(e => ({
-        timestamp: e.timestamp,
-        content: getUserPrompt(e),
-      }));
-
-    res.json({
-      task: {
-        id: task.id,
-        session_id: task.session_id,
-        title: task.title,
-        description: task.description,
-        start_time: task.start_time,
-        end_time: task.end_time,
-        status: task.status,
-        event_count: task.event_count,
-      },
-      userPrompts,
-      injections,
-      timeline,
-      skillInvocations,
-      artifacts,
-    });
-  });
-}