@bamptee/aia-code 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bamptee/aia-code",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "AI Architecture Assistant - orchestrate AI-assisted development workflows via CLI tools (Claude, Codex, Gemini)",
   "type": "module",
   "license": "MIT",

package/src/commands/quick.js

@@ -1,58 +1,20 @@
 import chalk from 'chalk';
-import fs from 'fs-extra';
-import path from 'node:path';
-import yaml from 'yaml';
-import { AIA_DIR, FEATURE_STEPS, QUICK_STEPS, STEP_STATUS } from '../constants.js';
-import { createFeature, validateFeatureName } from '../services/feature.js';
-import { runStep } from '../services/runner.js';
-
-async function skipEarlySteps(feature, root) {
-  const statusFile = path.join(root, AIA_DIR, 'features', feature, 'status.yaml');
-  const raw = await fs.readFile(statusFile, 'utf-8');
-  const status = yaml.parse(raw);
-
-  for (const step of FEATURE_STEPS) {
-    if (!QUICK_STEPS.includes(step)) {
-      status.steps[step] = STEP_STATUS.DONE;
-    }
-  }
-  status.current_step = QUICK_STEPS[0];
-
-  await fs.writeFile(statusFile, yaml.stringify(status), 'utf-8');
-}
+import { runQuick } from '../services/quick.js';
+import { QUICK_STEPS } from '../constants.js';
 
 export function registerQuickCommand(program) {
   program
     .command('quick <name> [description]')
-    .description('Quick story/ticket: create feature then run dev-plan → implement → review')
+    .description(`Quick story/ticket: create feature then run ${QUICK_STEPS.join(' \u2192 ')}`)
     .option('-v, --verbose', 'Show AI thinking/tool usage')
     .option('-a, --apply', 'Force agent mode (file editing) for all steps')
     .action(async (name, description, opts) => {
       try {
-        validateFeatureName(name);
-
-        const root = process.cwd();
-        const featureDir = path.join(root, AIA_DIR, 'features', name);
-
-        if (!(await fs.pathExists(featureDir))) {
-          await createFeature(name, root);
-          console.log(chalk.green(`Feature "${name}" created.`));
-          const initPath = path.join(AIA_DIR, 'features', name, 'init.md');
-          console.log(chalk.gray(`Using ${initPath} as input.`));
-        }
-
-        await skipEarlySteps(name, root);
-
-        for (const step of QUICK_STEPS) {
-          console.log(chalk.cyan(`\n--- Running ${step} ---\n`));
-          await runStep(step, name, {
-            description,
-            verbose: opts.verbose,
-            apply: opts.apply,
-            root,
-          });
-        }
-
+        await runQuick(name, {
+          description,
+          verbose: opts.verbose,
+          apply: opts.apply,
+        });
         console.log(chalk.green(`\nQuick pipeline completed for "${name}".`));
       } catch (err) {
         console.error(chalk.red(err.message));

package/src/providers/anthropic.js

@@ -1,6 +1,6 @@
 import { runCli } from './cli-runner.js';
 
-export async function generate(prompt, model, { verbose = false, apply = false } = {}) {
+export async function generate(prompt, model, { verbose = false, apply = false, onData } = {}) {
   const args = ['-p'];
   if (model) {
     args.push('--model', model);
@@ -13,5 +13,5 @@ export async function generate(prompt, model, { verbose = false, apply = false }
   }
   args.push('-');
 
-  return runCli('claude', args, { stdin: prompt, verbose: verbose || apply, apply });
+  return runCli('claude', args, { stdin: prompt, verbose: verbose || apply, apply, onData });
 }

package/src/providers/cli-runner.js

@@ -4,7 +4,7 @@ import chalk from 'chalk';
 const DEFAULT_IDLE_TIMEOUT_MS = 180_000;
 const AGENT_IDLE_TIMEOUT_MS = 600_000;
 
-export function runCli(command, args, { stdin: stdinData, verbose = false, apply = false, idleTimeoutMs } = {}) {
+export function runCli(command, args, { stdin: stdinData, verbose = false, apply = false, idleTimeoutMs, onData } = {}) {
   if (!idleTimeoutMs) {
     idleTimeoutMs = apply ? AGENT_IDLE_TIMEOUT_MS : DEFAULT_IDLE_TIMEOUT_MS;
   }
@@ -41,6 +41,7 @@ export function runCli(command, args, { stdin: stdinData, verbose = false, apply
       const text = data.toString();
       process.stdout.write(text);
       chunks.push(text);
+      if (onData) onData({ type: 'stdout', text });
       resetTimer();
     });
 
@@ -50,6 +51,7 @@ export function runCli(command, args, { stdin: stdinData, verbose = false, apply
       if (verbose) {
         process.stderr.write(chalk.gray(text));
       }
+      if (onData) onData({ type: 'stderr', text });
       resetTimer();
     });
 

package/src/providers/gemini.js

@@ -1,6 +1,6 @@
 import { runCli } from './cli-runner.js';
 
-export async function generate(prompt, model, { verbose = false, apply = false } = {}) {
+export async function generate(prompt, model, { verbose = false, apply = false, onData } = {}) {
   const args = [];
   if (model) {
     args.push('-m', model);
@@ -10,5 +10,5 @@ export async function generate(prompt, model, { verbose = false, apply = false }
   }
   args.push('-');
 
-  return runCli('gemini', args, { stdin: prompt, verbose: verbose || apply, apply });
+  return runCli('gemini', args, { stdin: prompt, verbose: verbose || apply, apply, onData });
 }

package/src/providers/openai.js

@@ -1,6 +1,6 @@
 import { runCli } from './cli-runner.js';
 
-export async function generate(prompt, model, { verbose = false, apply = false } = {}) {
+export async function generate(prompt, model, { verbose = false, apply = false, onData } = {}) {
   const args = ['exec'];
   if (model) {
     args.push('-c', `model="${model}"`);
@@ -10,5 +10,5 @@ export async function generate(prompt, model, { verbose = false, apply = false }
   }
   args.push('-');
 
-  return runCli('codex', args, { stdin: prompt, verbose: verbose || apply, apply });
+  return runCli('codex', args, { stdin: prompt, verbose: verbose || apply, apply, onData });
 }

package/src/services/model-call.js

@@ -1,12 +1,12 @@
 import chalk from 'chalk';
 import { resolveModelAlias } from '../providers/registry.js';
 
-export async function callModel(model, prompt, { verbose = false, apply = false } = {}) {
+export async function callModel(model, prompt, { verbose = false, apply = false, onData } = {}) {
   const resolved = resolveModelAlias(model);
   const displayName = resolved.model ?? `${model} (CLI default)`;
   const mode = apply ? 'agent' : 'print';
 
   console.log(chalk.yellow(`[AI] Calling ${displayName} (${mode} mode)...`));
 
-  return resolved.provider.generate(prompt, resolved.model, { verbose, apply });
+  return resolved.provider.generate(prompt, resolved.model, { verbose, apply, onData });
 }

package/src/services/quick.js

@@ -0,0 +1,40 @@
+import path from 'node:path';
+import fs from 'fs-extra';
+import yaml from 'yaml';
+import { AIA_DIR, FEATURE_STEPS, QUICK_STEPS, STEP_STATUS } from '../constants.js';
+import { createFeature, validateFeatureName } from './feature.js';
+import { runStep } from './runner.js';
+
+export async function skipEarlySteps(feature, root) {
+  const statusFile = path.join(root, AIA_DIR, 'features', feature, 'status.yaml');
+  const raw = await fs.readFile(statusFile, 'utf-8');
+  const status = yaml.parse(raw);
+
+  for (const step of FEATURE_STEPS) {
+    if (!QUICK_STEPS.includes(step)) {
+      status.steps[step] = STEP_STATUS.DONE;
+    }
+  }
+  status.current_step = QUICK_STEPS[0];
+
+  await fs.writeFile(statusFile, yaml.stringify(status), 'utf-8');
+}
+
+export async function runQuick(name, { description, verbose = false, apply = false, root = process.cwd(), onData } = {}) {
+  validateFeatureName(name);
+
+  const featureDir = path.join(root, AIA_DIR, 'features', name);
+  const created = !(await fs.pathExists(featureDir));
+
+  if (created) {
+    await createFeature(name, root);
+  }
+
+  await skipEarlySteps(name, root);
+
+  for (const step of QUICK_STEPS) {
+    await runStep(step, name, { description, verbose, apply, root, onData });
+  }
+
+  return { created };
+}

package/src/services/runner.js

@@ -8,7 +8,7 @@ import { callModel } from './model-call.js';
 import { loadStatus, updateStepStatus } from './status.js';
 import { logExecution } from '../logger.js';
 
-export async function runStep(step, feature, { description, verbose = false, apply = false, root = process.cwd() } = {}) {
+export async function runStep(step, feature, { description, verbose = false, apply = false, root = process.cwd(), onData } = {}) {
   if (!FEATURE_STEPS.includes(step)) {
     throw new Error(`Unknown step "${step}". Valid steps: ${FEATURE_STEPS.join(', ')}`);
   }
@@ -30,7 +30,7 @@ export async function runStep(step, feature, { description, verbose = false, app
     const prompt = await buildPrompt(feature, step, { description, root });
 
     const start = performance.now();
-    const output = await callModel(model, prompt, { verbose, apply: shouldApply });
+    const output = await callModel(model, prompt, { verbose, apply: shouldApply, onData });
     const duration = performance.now() - start;
 
     const outputPath = path.join(root, AIA_DIR, 'features', feature, `${step}.md`);

package/src/ui/api/features.js

@@ -4,8 +4,22 @@ import { AIA_DIR } from '../../constants.js';
 import { loadStatus, updateStepStatus, resetStep } from '../../services/status.js';
 import { createFeature, validateFeatureName } from '../../services/feature.js';
 import { runStep } from '../../services/runner.js';
+import { runQuick } from '../../services/quick.js';
 import { json, error } from '../router.js';
 
+function sseHeaders(res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'Access-Control-Allow-Origin': '*',
+  });
+}
+
+function sseSend(res, event, data) {
+  res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+}
+
 export function registerFeatureRoutes(router) {
   // List all features
   router.get('/api/features', async (req, res, { root }) => {
@@ -70,20 +84,77 @@ export function registerFeatureRoutes(router) {
     }
   });
 
-  // Run a step (blocking - returns when done)
+  // Run a step with SSE streaming
   router.post('/api/features/:name/run/:step', async (req, res, { params, root, parseBody }) => {
     const body = await parseBody();
+    sseHeaders(res);
+    sseSend(res, 'status', { step: params.step, status: 'started' });
+
+    const onData = ({ type, text }) => {
+      try { sseSend(res, 'log', { type, text }); } catch {}
+    };
+
     try {
       const output = await runStep(params.step, params.name, {
         description: body.description,
-        verbose: false,
+        verbose: true,
         apply: body.apply || false,
         root,
+        onData,
       });
-      json(res, { ok: true, output });
+      sseSend(res, 'done', { step: params.step, output: output.slice(0, 500) });
     } catch (err) {
-      error(res, err.message, 400);
+      sseSend(res, 'error', { message: err.message });
+    }
+    res.end();
+  });
+
+  // Quick ticket with SSE streaming (dev-plan -> implement -> review)
+  router.post('/api/features/:name/quick', async (req, res, { params, root, parseBody }) => {
+    const body = await parseBody();
+    sseHeaders(res);
+    sseSend(res, 'status', { status: 'started', mode: 'quick' });
+
+    const onData = ({ type, text }) => {
+      try { sseSend(res, 'log', { type, text }); } catch {}
+    };
+
+    try {
+      await runQuick(params.name, {
+        description: body.description,
+        apply: body.apply || false,
+        root,
+        onData,
+      });
+      sseSend(res, 'done', { status: 'completed' });
+    } catch (err) {
+      sseSend(res, 'error', { message: err.message });
+    }
+    res.end();
+  });
+
+  // Quick ticket with SSE streaming (create + run)
+  router.post('/api/quick', async (req, res, { root, parseBody }) => {
+    const body = await parseBody();
+    sseHeaders(res);
+    sseSend(res, 'status', { status: 'started', mode: 'quick', name: body.name });
+
+    const onData = ({ type, text }) => {
+      try { sseSend(res, 'log', { type, text }); } catch {}
+    };
+
+    try {
+      await runQuick(body.name, {
+        description: body.description,
+        apply: body.apply || false,
+        root,
+        onData,
+      });
+      sseSend(res, 'done', { status: 'completed', name: body.name });
+    } catch (err) {
+      sseSend(res, 'error', { message: err.message });
     }
+    res.end();
   });
 
   // Reset a step

package/src/ui/public/components/dashboard.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { api } from '/main.js';
+import { api, streamPost } from '/main.js';
 
 const STATUS_CLASSES = {
   done: 'step-done',
@@ -79,6 +79,94 @@ function NewFeatureForm({ onCreated }) {
   );
 }
 
+function LogViewer({ logs }) {
+  const ref = React.useRef(null);
+  React.useEffect(() => {
+    if (ref.current) ref.current.scrollTop = ref.current.scrollHeight;
+  }, [logs]);
+
+  if (!logs.length) return null;
+  return React.createElement('pre', {
+    ref,
+    className: 'bg-black/50 border border-aia-border rounded p-3 text-xs text-slate-400 overflow-auto max-h-48 whitespace-pre-wrap',
+  }, logs.join(''));
+}
+
+function QuickTicketForm({ onDone }) {
+  const [name, setName] = React.useState('');
+  const [description, setDescription] = React.useState('');
+  const [apply, setApply] = React.useState(false);
+  const [running, setRunning] = React.useState(false);
+  const [err, setErr] = React.useState('');
+  const [logs, setLogs] = React.useState([]);
+
+  async function handleSubmit(e) {
+    e.preventDefault();
+    setErr('');
+    setRunning(true);
+    setLogs([]);
+
+    const res = await streamPost('/quick', { name, description, apply }, {
+      onLog: (text) => setLogs(prev => [...prev, text]),
+      onStatus: (data) => setLogs(prev => [...prev, `[${data.status}] ${data.name || ''}\n`]),
+    });
+
+    if (res.ok) {
+      setName('');
+      setDescription('');
+      setLogs([]);
+      onDone();
+    } else {
+      setErr(res.error);
+    }
+    setRunning(false);
+  }
+
+  return React.createElement('form', {
+    onSubmit: handleSubmit,
+    className: 'bg-aia-card border border-amber-500/30 rounded-lg p-4 space-y-3',
+  },
+    React.createElement('h3', { className: 'text-sm font-semibold text-amber-400' }, 'Quick Ticket'),
+    React.createElement('p', { className: 'text-xs text-slate-500' }, 'dev-plan \u2192 implement \u2192 review'),
+    React.createElement('div', { className: 'flex gap-2' },
+      React.createElement('input', {
+        type: 'text',
+        value: name,
+        onChange: e => setName(e.target.value),
+        placeholder: 'ticket-name',
+        disabled: running,
+        className: 'bg-slate-900 border border-aia-border rounded px-3 py-1.5 text-sm text-slate-200 placeholder-slate-500 focus:border-amber-400 focus:outline-none flex-shrink-0',
+      }),
+      React.createElement('input', {
+        type: 'text',
+        value: description,
+        onChange: e => setDescription(e.target.value),
+        placeholder: 'Short description (optional)',
+        disabled: running,
+        className: 'bg-slate-900 border border-aia-border rounded px-3 py-1.5 text-sm text-slate-200 placeholder-slate-500 focus:border-amber-400 focus:outline-none flex-1',
+      }),
+    ),
+    React.createElement('div', { className: 'flex items-center gap-4' },
+      React.createElement('label', { className: 'flex items-center gap-2 text-xs text-slate-400 cursor-pointer' },
+        React.createElement('input', {
+          type: 'checkbox',
+          checked: apply,
+          onChange: e => setApply(e.target.checked),
+          disabled: running,
+        }),
+        'Agent mode (--apply)'
+      ),
+      React.createElement('button', {
+        type: 'submit',
+        disabled: running || !name,
+        className: 'bg-amber-500/20 text-amber-400 border border-amber-500/30 rounded px-4 py-1.5 text-sm hover:bg-amber-500/30 disabled:opacity-40',
+      }, running ? 'Running...' : 'Run Quick Ticket'),
+    ),
+    React.createElement(LogViewer, { logs }),
+    err && React.createElement('p', { className: 'text-red-400 text-xs' }, err),
+  );
+}
+
 export function Dashboard() {
   const [features, setFeatures] = React.useState([]);
   const [loading, setLoading] = React.useState(true);
@@ -93,11 +181,15 @@ export function Dashboard() {
 
   React.useEffect(() => { load(); }, []);
 
-  return React.createElement('div', null,
-    React.createElement('div', { className: 'flex items-center justify-between mb-6' },
+  return React.createElement('div', { className: 'space-y-6' },
+    React.createElement('div', { className: 'flex items-center justify-between' },
       React.createElement('h1', { className: 'text-xl font-bold text-slate-100' }, 'Features'),
       React.createElement(NewFeatureForm, { onCreated: load }),
     ),
+
+    // Quick ticket
+    React.createElement(QuickTicketForm, { onDone: load }),
+
     loading
       ? React.createElement('p', { className: 'text-slate-500' }, 'Loading...')
       : features.length === 0

package/src/ui/public/components/feature-detail.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { api } from '/main.js';
+import { api, streamPost } from '/main.js';
 
 const STATUS_CLASSES = {
   done: 'step-done',
@@ -65,23 +65,103 @@ function FileEditor({ name, filename, onSaved }) {
   );
 }
 
+function QuickRunButton({ name, onDone }) {
+  const [running, setRunning] = React.useState(false);
+  const [description, setDescription] = React.useState('');
+  const [expanded, setExpanded] = React.useState(false);
+  const [err, setErr] = React.useState(null);
+  const [logs, setLogs] = React.useState([]);
+
+  async function run() {
+    setRunning(true);
+    setErr(null);
+    setLogs([]);
+
+    const res = await streamPost(`/features/${name}/quick`, { description }, {
+      onLog: (text) => setLogs(prev => [...prev, text]),
+      onStatus: (data) => setLogs(prev => [...prev, `[${data.status}] ${data.mode || ''}\n`]),
+    });
+
+    if (res.ok) {
+      if (onDone) onDone();
+    } else {
+      setErr(res.error);
+    }
+    setRunning(false);
+  }
+
+  if (!expanded) {
+    return React.createElement('button', {
+      onClick: () => setExpanded(true),
+      className: 'bg-amber-500/20 text-amber-400 border border-amber-500/30 rounded px-3 py-1.5 text-xs hover:bg-amber-500/30',
+    }, 'Quick Ticket (dev-plan \u2192 implement \u2192 review)');
+  }
+
+  return React.createElement('div', { className: 'bg-slate-900 border border-amber-500/30 rounded p-4 space-y-3' },
+    React.createElement('h4', { className: 'text-sm font-semibold text-amber-400' }, 'Quick Ticket'),
+    React.createElement('p', { className: 'text-xs text-slate-500' }, 'Skips early steps, runs dev-plan \u2192 implement \u2192 review'),
+    React.createElement('input', {
+      type: 'text',
+      value: description,
+      onChange: e => setDescription(e.target.value),
+      placeholder: 'Optional description...',
+      disabled: running,
+      className: 'w-full bg-aia-card border border-aia-border rounded px-3 py-1.5 text-sm text-slate-200 placeholder-slate-500 focus:border-amber-400 focus:outline-none',
+    }),
+    React.createElement('div', { className: 'flex gap-2' },
+      React.createElement('button', {
+        onClick: run,
+        disabled: running,
+        className: 'bg-amber-500/20 text-amber-400 border border-amber-500/30 rounded px-4 py-1.5 text-sm hover:bg-amber-500/30 disabled:opacity-40',
+      }, running ? 'Running...' : 'Run Quick'),
+      React.createElement('button', {
+        onClick: () => setExpanded(false),
+        disabled: running,
+        className: 'text-slate-500 hover:text-slate-300 text-xs',
+      }, 'Cancel'),
+    ),
+    React.createElement(LogViewer, { logs }),
+    err && React.createElement('p', { className: 'text-red-400 text-xs' }, err),
+  );
+}
+
+function LogViewer({ logs }) {
+  const ref = React.useRef(null);
+  React.useEffect(() => {
+    if (ref.current) ref.current.scrollTop = ref.current.scrollHeight;
+  }, [logs]);
+
+  if (!logs.length) return null;
+  return React.createElement('pre', {
+    ref,
+    className: 'bg-black/50 border border-aia-border rounded p-3 text-xs text-slate-400 overflow-auto max-h-64 whitespace-pre-wrap',
+  }, logs.join(''));
+}
+
 function RunPanel({ name, step, onDone }) {
   const [description, setDescription] = React.useState('');
   const [apply, setApply] = React.useState(false);
   const [running, setRunning] = React.useState(false);
   const [result, setResult] = React.useState(null);
-  const [error, setError] = React.useState(null);
+  const [err, setErr] = React.useState(null);
+  const [logs, setLogs] = React.useState([]);
 
   async function run() {
     setRunning(true);
     setResult(null);
-    setError(null);
-    try {
-      const data = await api.post(`/features/${name}/run/${step}`, { description, apply });
+    setErr(null);
+    setLogs([]);
+
+    const res = await streamPost(`/features/${name}/run/${step}`, { description, apply }, {
+      onLog: (text) => setLogs(prev => [...prev, text]),
+      onStatus: (data) => setLogs(prev => [...prev, `[${data.status}] ${data.step || ''}\n`]),
+    });
+
+    if (res.ok) {
       setResult('Step completed.');
       if (onDone) onDone();
-    } catch (e) {
-      setError(e.message);
+    } else {
+      setErr(res.error);
     }
     setRunning(false);
   }
@@ -91,7 +171,7 @@ function RunPanel({ name, step, onDone }) {
       await api.post(`/features/${name}/reset/${step}`);
       if (onDone) onDone();
     } catch (e) {
-      setError(e.message);
+      setErr(e.message);
     }
   }
 
@@ -102,6 +182,7 @@ function RunPanel({ name, step, onDone }) {
       value: description,
       onChange: e => setDescription(e.target.value),
       placeholder: 'Optional description...',
+      disabled: running,
       className: 'w-full bg-aia-card border border-aia-border rounded px-3 py-1.5 text-sm text-slate-200 placeholder-slate-500 focus:border-aia-accent focus:outline-none',
     }),
     React.createElement('div', { className: 'flex items-center gap-4' },
@@ -110,6 +191,7 @@ function RunPanel({ name, step, onDone }) {
           type: 'checkbox',
           checked: apply,
           onChange: e => setApply(e.target.checked),
+          disabled: running,
           className: 'rounded',
         }),
         'Agent mode (--apply)'
@@ -125,9 +207,9 @@ function RunPanel({ name, step, onDone }) {
         className: 'text-slate-500 hover:text-slate-300 text-xs',
       }, 'Reset'),
     ),
-    running && React.createElement('p', { className: 'text-amber-400 text-xs animate-pulse' }, 'Step is running... This may take a few minutes.'),
+    React.createElement(LogViewer, { logs }),
     result && React.createElement('p', { className: 'text-emerald-400 text-xs' }, result),
-    error && React.createElement('p', { className: 'text-red-400 text-xs' }, error),
+    err && React.createElement('p', { className: 'text-red-400 text-xs' }, err),
   );
 }
 
@@ -160,6 +242,9 @@ export function FeatureDetail({ name }) {
       feature.current_step && React.createElement('span', { className: 'text-xs bg-aia-accent/20 text-aia-accent px-2 py-0.5 rounded' }, feature.current_step),
     ),
 
+    // Quick run
+    React.createElement(QuickRunButton, { name, onDone: load }),
+
     // Pipeline
     React.createElement('div', { className: 'flex flex-wrap gap-2' },
       ...Object.entries(steps).map(([step, status]) =>

package/src/ui/public/main.js

@@ -31,6 +31,53 @@ export const api = {
   },
 };
 
+// --- SSE stream helper ---
+// POST with SSE response. Calls onLog(text) for each log chunk, returns { ok, error }.
+export async function streamPost(path, body, { onLog, onStatus }) {
+  const res = await fetch(`/api${path}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let result = { ok: true };
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+
+    const lines = buffer.split('\n');
+    buffer = lines.pop(); // keep incomplete line
+
+    let eventType = null;
+    for (const line of lines) {
+      if (line.startsWith('event: ')) {
+        eventType = line.slice(7);
+      } else if (line.startsWith('data: ') && eventType) {
+        try {
+          const data = JSON.parse(line.slice(6));
+          if (eventType === 'log' && onLog) {
+            onLog(data.text, data.type);
+          } else if (eventType === 'status' && onStatus) {
+            onStatus(data);
+          } else if (eventType === 'error') {
+            result = { ok: false, error: data.message };
+          } else if (eventType === 'done') {
+            result = { ok: true, ...data };
+          }
+        } catch {}
+        eventType = null;
+      }
+    }
+  }
+
+  return result;
+}
+
 // --- Simple hash router ---
 function useHashRoute() {
   const [route, setRoute] = React.useState(window.location.hash || '#/');