@aion0/forge 0.5.46 → 0.5.48

package/.forge/worktrees/pipeline-ecd7cb0f/src/types/index.ts

@@ -0,0 +1,129 @@
+export type MemoryStrategy = 'none' | 'sliding_window' | 'full' | 'full_with_summary' | 'external';
+
+export type SessionStatus = 'running' | 'idle' | 'paused' | 'archived' | 'error';
+
+export type ProviderName = 'anthropic' | 'google' | 'openai' | 'grok';
+
+export interface ProviderConfig {
+  name: ProviderName;
+  displayName: string;
+  apiKey?: string;
+  defaultModel: string;
+  models: string[];
+  enabled: boolean;
+}
+
+export interface MemoryConfig {
+  strategy: MemoryStrategy;
+  windowSize?: number;       // for sliding_window
+  compressAfter?: number;    // for full — compress after N messages
+  summaryModel?: string;     // model to use for summarization
+}
+
+export interface SessionTemplate {
+  id: string;
+  name: string;
+  description: string;
+  provider: ProviderName;
+  model?: string;
+  fallbackProvider?: ProviderName;
+  memory: MemoryConfig;
+  systemPrompt: string;
+  context?: {
+    files?: string[];
+  };
+  commands?: Record<string, { description: string; action: string; prompt?: string }>;
+  ui?: {
+    icon?: string;
+    color?: string;
+    pinned?: boolean;
+  };
+}
+
+export interface Message {
+  id: number;
+  sessionId: string;
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  provider: ProviderName;
+  model: string;
+  tokenCount?: number;
+  createdAt: string;
+}
+
+export interface Session {
+  id: string;
+  name: string;
+  templateId: string;
+  provider: ProviderName;
+  model: string;
+  status: SessionStatus;
+  memory: MemoryConfig;
+  systemPrompt: string;
+  messageCount: number;
+  createdAt: string;
+  updatedAt: string;
+  lastMessage?: string;
+}
+
+export interface UsageRecord {
+  provider: ProviderName;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  cost: number;
+  date: string;
+}
+
+export type TaskStatus = 'queued' | 'running' | 'done' | 'failed' | 'cancelled';
+export type TaskMode = 'prompt' | 'monitor' | 'shell';
+
+export interface WatchConfig {
+  condition: 'change' | 'idle' | 'complete' | 'error' | 'keyword';
+  keyword?: string;          // for 'keyword' condition
+  idleMinutes?: number;      // for 'idle' condition (default 10)
+  action: 'notify' | 'message' | 'task';
+  actionPrompt?: string;     // message to send or task prompt
+  actionProject?: string;    // for 'task' action
+  repeat?: boolean;          // keep watching after trigger (default false)
+  notifyIntervalSeconds?: number; // min seconds between notifications (default 60)
+}
+
+export interface Task {
+  id: string;
+  projectName: string;
+  projectPath: string;
+  prompt: string;
+  mode: TaskMode;
+  status: TaskStatus;
+  priority: number;
+  conversationId?: string;
+  watchConfig?: WatchConfig;
+  log: TaskLogEntry[];
+  resultSummary?: string;
+  gitDiff?: string;
+  gitBranch?: string;
+  costUSD?: number;
+  error?: string;
+  createdAt: string;
+  startedAt?: string;
+  completedAt?: string;
+  scheduledAt?: string;
+}
+
+export interface TaskLogEntry {
+  type: 'system' | 'assistant' | 'result';
+  subtype?: string;
+  content: string;
+  tool?: string;
+  timestamp: string;
+}
+
+export interface AppConfig {
+  dataDir: string;
+  providers: Record<ProviderName, ProviderConfig>;
+  server: {
+    host: string;
+    port: number;
+  };
+}

package/.forge/worktrees/pipeline-ecd7cb0f/start.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+# start.sh — Start Forge locally (kill old processes, build, start)
+#
+# Usage:
+#   ./start.sh          # production mode
+#   ./start.sh dev      # dev mode (hot-reload)
+
+# Kill all old forge processes
+pkill -f 'telegram-standalone' 2>/dev/null
+pkill -f 'terminal-standalone' 2>/dev/null
+pkill -f 'workspace-standalone' 2>/dev/null
+pkill -f 'cloudflared tunnel' 2>/dev/null
+# Wait for workspace daemon port to be released
+for i in 1 2 3; do
+  lsof -ti:${WORKSPACE_PORT:-8405} >/dev/null 2>&1 || break
+  sleep 1
+done
+pkill -f 'next-server' 2>/dev/null
+pkill -f 'next start' 2>/dev/null
+pkill -f 'next dev' 2>/dev/null
+sleep 1
+
+export PORT=${PORT:-8403}
+export TERMINAL_PORT=${TERMINAL_PORT:-8404}
+export WORKSPACE_PORT=${WORKSPACE_PORT:-8405}
+
+if [ "$1" = "dev" ]; then
+  pnpm dev
+else
+  pnpm build && pnpm start
+fi

package/.forge/worktrees/pipeline-ecd7cb0f/templates/smith-lead.json

@@ -0,0 +1,45 @@
+{
+  "name": "Lead",
+  "icon": "👑",
+  "description": "Primary coordinator — SOP-driven requirement intake, delegation, gap coverage, and quality gate",
+  "config": {
+    "label": "Lead",
+    "icon": "👑",
+    "backend": "cli",
+    "agentId": "claude",
+    "primary": true,
+    "persistentSession": true,
+    "workDir": "./",
+    "outputs": ["docs/lead/"],
+    "plugins": ["playwright", "shell-command"],
+    "role": "You are the Lead — primary coordinator of this workspace.\n\nYour context automatically includes a \"Workspace Team\" section showing all agents, their roles, status, and missing standard roles. Read it before every action.\n\n## SOP: Requirement Intake\n\nWhen you receive a requirement (from user input or inbox message):\n\n```\n1. Read the Workspace Team section in your context\n2. Classify the requirement:\n   - Single task → one request document\n   - Multi-module → break into independent request documents, group in a batch\n3. Route based on available roles:\n\n   HAS Architect?\n   └─ YES → create_request with full description → Architect breaks it down further\n   └─ NO → you break it down yourself, then:\n\n        HAS Engineer?\n        └─ YES → create_request for each module (status: open)\n                 Engineers claim via claim_request\n        └─ NO → implement it yourself in src/\n                 Record files_changed in docs/lead/impl-notes.md\n\n4. After implementation (by you or Engineer):\n\n   HAS QA?\n   └─ YES → update_response(section: engineer) triggers auto-notify to QA\n   └─ NO → you test it:\n          - Read acceptance_criteria from the request\n          - Write tests in tests/ or run manually\n          - Record results: update_response(section: qa, result: passed/failed)\n\n5. After testing:\n\n   HAS Reviewer?\n   └─ YES → auto-notified when QA passes\n   └─ NO → you review it:\n          - Check code quality, security, PRD compliance\n          - Record: update_response(section: review, result: approved/changes_requested)\n          - If changes_requested → send_message to Engineer or fix yourself\n```\n\n## SOP: Monitoring & Coordination\n\nWhile work is in progress:\n\n```\n1. get_status → check all agents' smith/task status\n2. list_requests → check request progress\n\nIF agent taskStatus = failed:\n   → Read their error from get_status\n   → send_message asking what went wrong\n   → If no response or unfixable: handle the request yourself\n\nIF agent taskStatus = running for too long:\n   → send_message to check progress\n\nIF request stuck in one status:\n   → Check which agent should be handling it\n   → send_message to nudge, or cover it yourself\n\nIF multiple Engineers exist and request unclaimed:\n   → send_message to available Engineer suggesting they claim_request\n```\n\n## SOP: Quality Gate (before declaring done)\n\n```\n1. list_requests(batch: current_batch)\n2. ALL requests status = done?\n   └─ NO → identify stuck ones, apply Monitoring SOP\n   └─ YES → continue\n3. Any request with review.result = changes_requested?\n   └─ YES → verify changes were made, re-review if no Reviewer\n4. Any request with qa.result = failed?\n   └─ YES → verify fix was applied, re-test if no QA\n5. Write summary to docs/lead/delivery-summary.md:\n   - Requirements covered\n   - Requests created and their final status\n   - Roles you covered due to gaps\n   - Any open issues\n```\n\n## Gap Coverage Reference\n\nWhen you cover a missing role, follow that role's standards:\n\n| Missing Role | What You Do | Output |\n|---|---|---|\n| PM/Architect | Break requirements into modules with acceptance_criteria | request documents via create_request |\n| Engineer | Read request → implement in src/ → update_response(section: engineer) | source code + files_changed |\n| QA | Read acceptance_criteria → write/run tests → update_response(section: qa) | test results in tests/ or docs/qa/ |\n| Reviewer | Read code changes → check quality/security → update_response(section: review) | review findings |\n\n## Rules\n\n- Workspace Team is in your context — don't call get_agents redundantly at start, just read it\n- DO call get_agents/get_status when you need live status updates mid-task\n- Every delegated task MUST go through request documents (create_request) — never just send_message with vague instructions\n- Each request needs concrete acceptance_criteria that QA can verify\n- Do NOT duplicate work an active agent is already doing — check status first\n- When covering a gap, be thorough — don't half-do it just because it's not your \"main\" role",
+    "steps": [
+      {
+        "id": "intake",
+        "label": "Intake & Analyze",
+        "prompt": "Read the Workspace Team section in your context. Identify: (1) which standard roles are present and missing, (2) incoming requirements from upstream input or inbox. For each requirement, decide scope: single task or multi-module. List what you will delegate vs handle yourself."
+      },
+      {
+        "id": "delegate",
+        "label": "Create Requests & Route",
+        "prompt": "For each module/task: create_request with title, description, acceptance_criteria, and batch name. If Architect exists, create high-level requests for them to break down. If only Engineers exist, create implementation-ready requests. If no one to delegate to, note which requests you will implement yourself. Verify with list_requests that all were created."
+      },
+      {
+        "id": "cover-gaps",
+        "label": "Cover Missing Roles",
+        "prompt": "Handle all work for missing roles. If no Engineer: implement code, then update_response(section: engineer). If no QA: write/run tests against acceptance_criteria, then update_response(section: qa). If no Reviewer: review code changes for quality and security, then update_response(section: review). Use get_status between tasks to check if other agents have completed their work."
+      },
+      {
+        "id": "monitor",
+        "label": "Monitor & Unblock",
+        "prompt": "Run get_status and list_requests. For each stuck/failed agent: diagnose and send_message to unblock, or take over the request yourself. For unclaimed requests: nudge available agents. Continue until all requests show progress."
+      },
+      {
+        "id": "gate",
+        "label": "Quality Gate & Summary",
+        "prompt": "list_requests for the current batch. Verify ALL requests are status=done with review.result=approved and qa.result=passed. If any are not: apply gap coverage. Write docs/lead/delivery-summary.md with: requirements covered, request statuses, roles you covered, open issues."
+      }
+    ]
+  },
+  "exportedAt": 1743724800000
+}

package/.forge/worktrees/pipeline-ecd7cb0f/tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": [
+        "./*"
+      ]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    ".next/dev/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

package/CLAUDE.md

@@ -104,6 +104,7 @@ When adding or changing a feature, check if `lib/help-docs/` needs updating. Eac
 - `10-troubleshooting.md` — common issues
 - `11-workspace.md` — multi-agent workspace (smiths, daemon, request docs)
 - `12-usage.md` — token usage analytics and cost tracking
+- `14-migration.md` — API migration cockpit (legacy ↔ new parity testing)
 
 If a feature change affects user-facing behavior, update the corresponding help doc in the same commit. These docs are also served to the in-app Help AI — `lib/help-docs/CLAUDE.md` is its system prompt.
 

package/RELEASE_NOTES.md

@@ -1,8 +1,8 @@
-# Forge v0.5.46
+# Forge v0.5.48
 
-Released: 2026-04-26
+Released: 2026-04-27
 
-## Changes since v0.5.45
+## Changes since v0.5.47
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.45...v0.5.46
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.47...v0.5.48

package/app/api/migration/config/route.ts

@@ -0,0 +1,19 @@
+import { NextResponse } from 'next/server';
+import { loadConfig, saveConfig } from '@/lib/migration/store';
+import type { MigrationConfig } from '@/lib/migration/types';
+
+// GET /api/migration/config?projectPath=...
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const projectPath = url.searchParams.get('projectPath');
+  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
+  return NextResponse.json(loadConfig(projectPath));
+}
+
+// POST /api/migration/config — body: { projectPath, config }
+export async function POST(req: Request) {
+  const { projectPath, config } = await req.json() as { projectPath: string; config: MigrationConfig };
+  if (!projectPath || !config) return NextResponse.json({ error: 'projectPath + config required' }, { status: 400 });
+  saveConfig(projectPath, config);
+  return NextResponse.json({ ok: true });
+}

package/app/api/migration/discover/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from 'next/server';
+import { discoverEndpoints } from '@/lib/migration/discoverer';
+import { loadConfig, saveEndpoints, loadEndpoints } from '@/lib/migration/store';
+
+// GET /api/migration/discover?projectPath=...  → return cached endpoints
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const projectPath = url.searchParams.get('projectPath');
+  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
+  return NextResponse.json({ endpoints: loadEndpoints(projectPath) });
+}
+
+// POST /api/migration/discover — body: { projectPath } → re-scan docs
+export async function POST(req: Request) {
+  const { projectPath } = await req.json() as { projectPath: string };
+  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
+  const config = loadConfig(projectPath);
+  const result = discoverEndpoints(projectPath, config);
+  saveEndpoints(projectPath, result.endpoints);
+  return NextResponse.json({
+    endpoints: result.endpoints,
+    warnings: result.warnings,
+    sources: result.sources,
+    total: result.endpoints.length,
+  });
+}

package/app/api/migration/failures/route.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from 'next/server';
+import { loadFailures } from '@/lib/migration/store';
+import type { Failure, FailureCluster } from '@/lib/migration/types';
+
+function cluster(failures: Failure[]): FailureCluster[] {
+  const byType = new Map<string, Map<string, Failure[]>>();
+  for (const f of failures) {
+    let m = byType.get(f.errorType);
+    if (!m) { m = new Map(); byType.set(f.errorType, m); }
+    let arr = m.get(f.controller);
+    if (!arr) { arr = []; m.set(f.controller, arr); }
+    arr.push(f);
+  }
+  const out: FailureCluster[] = [];
+  for (const [errorType, ctrlMap] of byType) {
+    const controllers = [...ctrlMap.entries()].map(([controller, failures]) => ({ controller, failures }));
+    controllers.sort((a, b) => b.failures.length - a.failures.length);
+    out.push({
+      errorType,
+      count: controllers.reduce((sum, c) => sum + c.failures.length, 0),
+      controllers,
+    });
+  }
+  out.sort((a, b) => b.count - a.count);
+  return out;
+}
+
+// GET /api/migration/failures?projectPath=...
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const projectPath = url.searchParams.get('projectPath');
+  if (!projectPath) return NextResponse.json({ error: 'projectPath required' }, { status: 400 });
+  const failures = loadFailures(projectPath);
+  return NextResponse.json({ failures, clusters: cluster(failures) });
+}

package/app/api/migration/fix/route.ts

@@ -0,0 +1,82 @@
+import { NextResponse } from 'next/server';
+import { execSync } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadEndpoints } from '@/lib/migration/store';
+import { createTask } from '@/lib/task-manager';
+import type { Failure } from '@/lib/migration/types';
+
+interface FixRequest {
+  projectPath: string;
+  projectName?: string;
+  mode: 'inject' | 'task';
+  endpointIds?: string[];           // single or batch
+  failures?: Failure[];             // optional pre-clustered failures
+  sessionName?: string;             // tmux session for inject mode
+  customPrompt?: string;
+}
+
+function buildPrompt(eps: any[], failures?: Failure[], custom?: string): string {
+  const lines: string[] = [];
+  lines.push('# API parity fix request');
+  lines.push('');
+  lines.push('The following endpoints in the new web-server module produce results that differ from the legacy module. The legacy code MUST NOT be changed — fix the new module so its output matches.');
+  lines.push('');
+  if (failures && failures.length > 0) {
+    lines.push('## Failures');
+    for (const f of failures) {
+      lines.push(`- \`${f.method} ${f.path}\` (${f.controller}) — ${f.errorType}: ${f.errorMessage}`);
+    }
+  } else if (eps.length > 0) {
+    lines.push('## Endpoints');
+    for (const e of eps) {
+      lines.push(`- \`${e.method} ${e.path}\` — controller: ${e.controller}, status: ${e.status}${e.notes ? `, notes: ${e.notes}` : ''}`);
+    }
+  }
+  lines.push('');
+  lines.push('## Approach');
+  lines.push('1. Read .forge/migration/runs/*.json for the latest run output and diffs.');
+  lines.push('2. Identify the controller class in the new web-server module.');
+  lines.push('3. Compare to the legacy implementation — focus on response shape, status codes, field names.');
+  lines.push('4. Apply minimal fix; do not change unrelated code.');
+  lines.push('5. Re-run the migration cockpit batch test for these endpoints.');
+  if (custom) {
+    lines.push('');
+    lines.push('## Additional context');
+    lines.push(custom);
+  }
+  return lines.join('\n');
+}
+
+export async function POST(req: Request) {
+  const body = await req.json() as FixRequest;
+  const { projectPath, projectName, mode, endpointIds, failures, sessionName, customPrompt } = body;
+  if (!projectPath || !mode) return NextResponse.json({ error: 'projectPath + mode required' }, { status: 400 });
+
+  const all = loadEndpoints(projectPath);
+  const ids = new Set(endpointIds || []);
+  const eps = ids.size > 0 ? all.filter(e => ids.has(e.id)) : [];
+  const prompt = buildPrompt(eps, failures, customPrompt);
+
+  if (mode === 'task') {
+    const name = projectName || projectPath.split('/').filter(Boolean).pop() || 'project';
+    const task = createTask({ projectName: name, projectPath, prompt });
+    return NextResponse.json({ ok: true, mode: 'task', taskId: task.id });
+  }
+
+  if (mode === 'inject') {
+    if (!sessionName) return NextResponse.json({ error: 'sessionName required for inject mode' }, { status: 400 });
+    try {
+      const buf = join(tmpdir(), `forge-migration-fix-${Date.now()}.txt`);
+      writeFileSync(buf, prompt);
+      execSync(`tmux load-buffer -t "${sessionName}" "${buf}" && tmux paste-buffer -t "${sessionName}" && sleep 0.2 && tmux send-keys -t "${sessionName}" Enter`, { timeout: 5000 });
+      try { unlinkSync(buf); } catch {}
+      return NextResponse.json({ ok: true, mode: 'inject', sessionName });
+    } catch (e: any) {
+      return NextResponse.json({ error: e?.message || String(e) }, { status: 500 });
+    }
+  }
+
+  return NextResponse.json({ error: 'invalid mode' }, { status: 400 });
+}

package/app/api/migration/run/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from 'next/server';
+import { loadConfig, loadEndpoints, saveRun } from '@/lib/migration/store';
+import { runEndpoint } from '@/lib/migration/runner';
+import { loadOpenApi } from '@/lib/migration/openapi';
+
+// POST /api/migration/run — body: { projectPath, endpointId }
+export async function POST(req: Request) {
+  const { projectPath, endpointId } = await req.json() as { projectPath: string; endpointId: string };
+  if (!projectPath || !endpointId) return NextResponse.json({ error: 'projectPath + endpointId required' }, { status: 400 });
+
+  const eps = loadEndpoints(projectPath);
+  const ep = eps.find(e => e.id === endpointId);
+  if (!ep) return NextResponse.json({ error: 'endpoint not found' }, { status: 404 });
+
+  const config = loadConfig(projectPath);
+  const openApi = config.endpointSource.openApiSpec
+    ? loadOpenApi(projectPath, config.endpointSource.openApiSpec)
+    : null;
+  const result = await runEndpoint(ep, config, openApi);
+  saveRun(projectPath, [result]);
+  return NextResponse.json(result);
+}

package/app/api/migration/run-batch/route.ts

@@ -0,0 +1,86 @@
+import { loadConfig, loadEndpoints, saveRun, saveFailures } from '@/lib/migration/store';
+import { runEndpoints } from '@/lib/migration/runner';
+import type { Endpoint, RunResult, Failure } from '@/lib/migration/types';
+
+export const dynamic = 'force-dynamic';
+
+// POST /api/migration/run-batch — body: { projectPath, endpointIds?, onlyStatus?, concurrency? }
+// Returns SSE stream with progress and final result.
+export async function POST(req: Request) {
+  const { projectPath, endpointIds, onlyStatus, concurrency } = await req.json() as {
+    projectPath: string;
+    endpointIds?: string[];
+    onlyStatus?: string[];
+    concurrency?: number;
+  };
+  if (!projectPath) return new Response(JSON.stringify({ error: 'projectPath required' }), { status: 400 });
+
+  const config = loadConfig(projectPath);
+  const all = loadEndpoints(projectPath);
+  let toRun: Endpoint[] = all;
+  if (endpointIds && endpointIds.length > 0) {
+    const ids = new Set(endpointIds);
+    toRun = all.filter(e => ids.has(e.id));
+  } else if (onlyStatus && onlyStatus.length > 0) {
+    const s = new Set(onlyStatus);
+    toRun = all.filter(e => s.has(e.status));
+  }
+
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const send = (event: string, data: any) => {
+        controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
+      };
+      send('start', { total: toRun.length });
+
+      try {
+        const results = await runEndpoints(toRun, config, {
+          concurrency: concurrency ?? 4,
+          projectPath,
+          onProgress: (done, total, last) => {
+            send('progress', { done, total, result: last });
+          },
+        });
+        saveRun(projectPath, results);
+
+        const failures: Failure[] = results
+          .filter(r => r.match === 'fail' || r.match === 'error')
+          .map(r => {
+            const ep = toRun.find(e => e.id === r.endpointId)!;
+            return {
+              endpointId: r.endpointId,
+              controller: ep.controller,
+              method: ep.method,
+              path: ep.path,
+              errorType: r.errorType || 'unknown',
+              errorMessage: r.errorMessage || '',
+              lastSeenAt: r.startedAt,
+            };
+          });
+        saveFailures(projectPath, failures);
+
+        send('done', {
+          total: results.length,
+          pass: results.filter(r => r.match === 'pass').length,
+          fail: results.filter(r => r.match === 'fail').length,
+          stubOk: results.filter(r => r.match === 'stub-ok').length,
+          error: results.filter(r => r.match === 'error').length,
+          failures: failures.length,
+        });
+      } catch (e: any) {
+        send('error', { message: e?.message || String(e) });
+      } finally {
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    },
+  });
+}

package/cli/mw.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env npx tsx
+#!/usr/bin/env -S npx tsx
 /**
  * forge — Forge CLI
  *