@dotdrelle/wiki-manager 0.12.0 → 0.12.7

package/src/runtime/store.js

@@ -279,6 +279,11 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     SET status = 'interrupted', updated_at = ?
     WHERE workspace = ? AND status IN (${RECOVERABLE_RUN_STATUSES.map(() => '?').join(', ')})
   `);
+  const interruptRunByIdStatement = db.prepare(`
+    UPDATE runs
+    SET status = 'interrupted', updated_at = ?
+    WHERE id = ? AND (? IS NULL OR workspace = ?) AND status IN (${RECOVERABLE_RUN_STATUSES.map(() => '?').join(', ')})
+  `);
   const upsertQueueItem = db.prepare(`
     INSERT INTO queue_items (
       id, workspace, server, tool, args, lock_key, status, reason, job_id, activity_key,
@@ -413,6 +418,25 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   `);
   const deleteTaskDependenciesStatement = db.prepare('DELETE FROM task_dependencies WHERE run_id = ? AND task_id = ?');
   const updateTaskStatusStatement = db.prepare('UPDATE tasks SET status = ?, declaration = ?, updated_at = ? WHERE run_id = ? AND id = ?');
+  const listActiveTasksForInterruptedRunsStatement = db.prepare(`
+    SELECT tasks.*
+    FROM tasks
+    JOIN runs ON runs.id = tasks.run_id
+    WHERE runs.workspace = ?
+      AND runs.status = 'interrupted'
+      AND tasks.status IN ('pending', 'pending_approval', 'waiting_approval', 'running', 'starting', 'blocked')
+    ORDER BY tasks.run_id ASC, tasks.id ASC
+  `);
+  const listActiveTasksForInterruptedRunByIdStatement = db.prepare(`
+    SELECT tasks.*
+    FROM tasks
+    JOIN runs ON runs.id = tasks.run_id
+    WHERE runs.id = ?
+      AND (? IS NULL OR runs.workspace = ?)
+      AND runs.status = 'interrupted'
+      AND tasks.status IN ('pending', 'pending_approval', 'waiting_approval', 'running', 'starting', 'blocked')
+    ORDER BY tasks.run_id ASC, tasks.id ASC
+  `);
   const insertTaskDependencyStatement = db.prepare(`
     INSERT OR IGNORE INTO task_dependencies (run_id, task_id, depends_on_task_id, created_at)
     VALUES (?, ?, ?, ?)
@@ -619,13 +643,33 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
       .map((row) => row.workspace);
   }
 
-  function interruptRuns({ workspace, reason = 'Runtime restart recovery failed.' } = {}) {
-    if (!workspace) return 0;
+  function interruptRuns({ workspace, runId = null, reason = 'Runtime restart recovery failed.' } = {}) {
+    if (!workspace && !runId) return 0;
     const now = new Date().toISOString();
-    const result = interruptRunsStatement.run(now, workspace, ...RECOVERABLE_RUN_STATUSES);
+    const result = runId
+      ? interruptRunByIdStatement.run(now, String(runId), workspace ?? null, workspace ?? null, ...RECOVERABLE_RUN_STATUSES)
+      : interruptRunsStatement.run(now, workspace, ...RECOVERABLE_RUN_STATUSES);
     return Number(result.changes ?? 0);
   }
 
+  function cancelActiveTasksForInterruptedRuns({ workspace = null, runId = null } = {}) {
+    if (!workspace && !runId) return 0;
+    const now = new Date().toISOString();
+    const tasks = runId
+      ? listActiveTasksForInterruptedRunByIdStatement.all(String(runId), workspace ?? null, workspace ?? null).map(rowToTask)
+      : listActiveTasksForInterruptedRunsStatement.all(workspace).map(rowToTask);
+    for (const task of tasks) {
+      updateTaskStatusStatement.run(
+        'cancelled',
+        JSON.stringify({ ...task.declaration, status: 'cancelled' }),
+        now,
+        task.runId,
+        task.id,
+      );
+    }
+    return tasks.length;
+  }
+
   function saveQueue(queue = [], { workspace = null } = {}) {
     const items = Array.isArray(queue) ? queue : [];
     const now = new Date().toISOString();
@@ -1121,6 +1165,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     listRecoverableRuns,
     listRecoverableWorkspaces,
     interruptRuns,
+    cancelActiveTasksForInterruptedRuns,
     saveQueue,
     listQueue,
     listTasks,

package/src/runtime/store.test.js

@@ -281,8 +281,8 @@ test('runtime store persists duplicate events idempotently', () => {
     origin: 'test',
     runId: 'run-1',
     turnId: 'run-1:turn-0',
-    workspace: 'juno',
-    payload: { input: 'build wiki', workspace: 'juno' },
+    workspace: 'acme',
+    payload: { input: 'build wiki', workspace: 'acme' },
   });
 
   store.persistEvent(event);
@@ -292,7 +292,7 @@ test('runtime store persists duplicate events idempotently', () => {
   assert.equal(store.listEvents()[0].sequence, 1);
   assert.equal(store.getState().eventsCursor, 1);
   assert.equal(store.listRuns()[0].id, 'run-1');
-  assert.equal(store.listRuns()[0].workspace, 'juno');
+  assert.equal(store.listRuns()[0].workspace, 'acme');
   assert.equal(store.listRuns()[0].status, 'running');
   store.close();
 });
@@ -590,22 +590,54 @@ test('runtime store persists cancelled run status', () => {
     origin: 'test',
     runId: 'run-1',
     turnId: 'run-1:turn-0',
-    workspace: 'juno',
-    payload: { input: 'build wiki', workspace: 'juno' },
+    workspace: 'acme',
+    payload: { input: 'build wiki', workspace: 'acme' },
   }));
   store.persistEvent(createAgentEvent('run_cancelled', {
     origin: 'test',
     runId: 'run-1',
     turnId: 'run-1:turn-1',
-    workspace: 'juno',
-    payload: { runId: 'run-1', workspace: 'juno' },
+    workspace: 'acme',
+    payload: { runId: 'run-1', workspace: 'acme' },
   }));
 
   assert.equal(store.listRuns()[0].status, 'cancelled');
-  assert.equal(store.listRuns()[0].workspace, 'juno');
+  assert.equal(store.listRuns()[0].workspace, 'acme');
   store.close();
 });
 
+test('runtime store interrupts runs by runId and does not recover killed runs after reopen', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  for (const runId of ['run-kill', 'run-keep']) {
+    store.persistEvent(createAgentEvent('run_started', {
+      origin: 'test',
+      runId,
+      workspace: 'docs',
+      payload: { input: runId, workspace: 'docs' },
+    }));
+    store.persistEvent(createAgentEvent('task.created', {
+      origin: 'test',
+      runId,
+      taskId: `${runId}:task`,
+      workspace: 'docs',
+      payload: { runId, task: { ...plannedTask(`${runId}:task`), status: 'running' } },
+    }));
+  }
+
+  assert.equal(store.interruptRuns({ workspace: 'docs', runId: 'run-kill' }), 1);
+  assert.equal(store.cancelActiveTasksForInterruptedRuns({ workspace: 'docs', runId: 'run-kill' }), 1);
+  assert.equal(store.listRuns().find((run) => run.id === 'run-kill').status, 'interrupted');
+  assert.equal(store.listRuns().find((run) => run.id === 'run-keep').status, 'running');
+  assert.equal(store.listTasks({ runId: 'run-kill' })[0].status, 'cancelled');
+  assert.equal(store.listTasks({ runId: 'run-keep' })[0].status, 'running');
+  store.close();
+
+  const reopened = openRuntimeStore({ stateDir });
+  assert.deepEqual(reopened.listRecoverableRuns({ workspace: 'docs' }).map((run) => run.id), ['run-keep']);
+  reopened.close();
+});
+
 test('runtime store migrates legacy databases without workspace columns', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const db = new DatabaseSync(join(stateDir, 'runtime.db'));
@@ -724,10 +756,10 @@ test('runtime store filters events runs and queue by workspace', () => {
   const store = openRuntimeStore({ stateDir });
   store.persistEvent(createAgentEvent('run_started', {
     origin: 'test',
-    runId: 'run-juno',
-    turnId: 'run-juno:turn-0',
-    workspace: 'juno',
-    payload: { input: 'juno', workspace: 'juno' },
+    runId: 'run-acme',
+    turnId: 'run-acme:turn-0',
+    workspace: 'acme',
+    payload: { input: 'acme', workspace: 'acme' },
   }));
   store.persistEvent(createAgentEvent('run_started', {
     origin: 'test',
@@ -736,12 +768,12 @@ test('runtime store filters events runs and queue by workspace', () => {
     workspace: 'docs',
     payload: { input: 'docs', workspace: 'docs' },
   }));
-  store.saveQueue([{ id: 'q-juno', workspace: 'juno', status: 'waiting' }], { workspace: 'juno' });
+  store.saveQueue([{ id: 'q-acme', workspace: 'acme', status: 'waiting' }], { workspace: 'acme' });
   store.saveQueue([{ id: 'q-docs', workspace: 'docs', status: 'waiting' }], { workspace: 'docs' });
 
-  assert.deepEqual(store.listEvents({ workspace: 'juno' }).map((event) => event.runId), ['run-juno']);
+  assert.deepEqual(store.listEvents({ workspace: 'acme' }).map((event) => event.runId), ['run-acme']);
   assert.deepEqual(store.listRuns({ workspace: 'docs' }).map((run) => run.id), ['run-docs']);
-  assert.deepEqual(store.listQueue({ workspace: 'juno' }).map((item) => item.id), ['q-juno']);
+  assert.deepEqual(store.listQueue({ workspace: 'acme' }).map((item) => item.id), ['q-acme']);
 
   const session = { activities: {}, headlessPlan: null };
   store.hydrateSession(session, { workspace: 'docs' });
@@ -794,8 +826,8 @@ test('runtime store persists and replays control queue events without mixing MCP
   }));
   store.persistEvent(createAgentEvent('control_enqueued', {
     origin: 'runtime',
-    workspace: 'juno',
-    payload: { id: 'control-juno', workspace: 'juno', input: 'other' },
+    workspace: 'acme',
+    payload: { id: 'control-acme', workspace: 'acme', input: 'other' },
   }));
   store.close();
 
@@ -925,10 +957,10 @@ test('runtime store identifies recoverable workspaces and interrupts stale runs'
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
   store.persistRun({
-    id: 'run-juno',
-    workspace: 'juno',
+    id: 'run-acme',
+    workspace: 'acme',
     status: 'running',
-    input: 'build juno',
+    input: 'build acme',
   });
   store.persistRun({
     id: 'run-done',
@@ -938,9 +970,9 @@ test('runtime store identifies recoverable workspaces and interrupts stale runs'
   });
   store.saveQueue([{ id: 'q-docs', workspace: 'docs', status: 'waiting' }], { workspace: 'docs' });
 
-  assert.deepEqual(store.listRecoverableWorkspaces(), ['docs', 'juno']);
-  assert.deepEqual(store.listRecoverableRuns({ workspace: 'juno' }).map((run) => run.id), ['run-juno']);
-  assert.equal(store.interruptRuns({ workspace: 'juno' }), 1);
-  assert.equal(store.listRuns({ workspace: 'juno' })[0].status, 'interrupted');
+  assert.deepEqual(store.listRecoverableWorkspaces(), ['acme', 'docs']);
+  assert.deepEqual(store.listRecoverableRuns({ workspace: 'acme' }).map((run) => run.id), ['run-acme']);
+  assert.equal(store.interruptRuns({ workspace: 'acme' }), 1);
+  assert.equal(store.listRuns({ workspace: 'acme' })[0].status, 'interrupted');
   store.close();
 });

package/src/runtime/supervisor.js

@@ -98,8 +98,55 @@ export async function pollActivitiesOnce(session, {
           payload: { activity: polledActivity },
         }));
         syncQueueWithActivity(session, polledActivity);
-        emitRuntimeLog(session, `activity: ${polledActivity.label} -> ${polledActivity.status}`);
+        // Only log when something actually changed: the poll fires every
+        // second and an unchanged "activity: X -> running" line repeated
+        // dozens of times drowned Logs/Trace and looked like a frozen system.
+        // The line itself carries the operational signal (current file,
+        // percent, batch, last trace event, retry/backoff) so the panel
+        // reads as a narrative of the job, not a heartbeat.
+        const progress = payload?.progress ?? polledActivity.progress ?? {};
+        const percent = Number(progress.percent ?? polledActivity.progress?.percent);
+        const detail = progress.detail ?? progress.step ?? '';
+        // The trace's batchIndex is 0-based and the human detail already says
+        // "Batch 1/2" — printing both gave "Batch 1/2 · batch 0/2". Display
+        // 1-based, and only when the detail doesn't already carry it.
+        const batch = progress.batchIndex != null && progress.batchCount != null && !/batch/i.test(String(detail))
+          ? `batch ${Number(progress.batchIndex) + 1}/${progress.batchCount}`
+          : null;
+        const lastEvent = progress.lastEvent ? String(progress.lastEvent) : null;
+        const retry = progress.retryAt
+          ? `retry ${progress.retryAt}`
+          : (progress.waitMs ? `wait ${progress.waitMs}ms` : null);
+        const progressKey = `${polledActivity.status}:${Number.isFinite(percent) ? Math.round(percent) : ''}:${detail}:${batch ?? ''}:${lastEvent ?? ''}:${retry ?? ''}`;
+        session._activityLogKeys ??= {};
+        if (session._activityLogKeys[key] !== progressKey) {
+          session._activityLogKeys[key] = progressKey;
+          const progressLabel = [
+            Number.isFinite(percent) ? `${Math.round(percent)}%` : null,
+            detail ? String(detail) : null,
+            batch,
+            lastEvent,
+            retry,
+          ].filter(Boolean).join(' · ');
+          emitRuntimeLog(session, `activity: ${polledActivity.label} -> ${polledActivity.status}${progressLabel ? ` (${progressLabel})` : ''}`);
+        }
+        // Stream NEW job-log lines into Logs/Trace: document names, chunking,
+        // LLM call/token summaries and errors live in the job log, not in the
+        // status fields. Diff against the last line already shown.
+        const logTail = Array.isArray(payload?.logTail) ? payload.logTail.map(String) : [];
+        if (logTail.length > 0) {
+          session._activityLogCursors ??= {};
+          const lastSeen = session._activityLogCursors[key];
+          const lastIndex = lastSeen ? logTail.lastIndexOf(lastSeen) : -1;
+          for (const line of logTail.slice(lastIndex + 1)) {
+            const clean = line.trim();
+            if (clean) emitRuntimeLog(session, `job ${polledActivity.id ?? key}: ${clean}`);
+          }
+          session._activityLogCursors[key] = logTail.at(-1);
+        }
         if (polledActivity.terminal) {
+          delete session._activityLogKeys[key];
+          delete session._activityLogCursors?.[key];
           await startNextQueuedJob(session, {
             addLog: (message) => emitRuntimeLog(session, message),
           });
@@ -134,3 +181,32 @@ function registryIntervalFromEnv() {
   const value = Number(process.env.WIKI_MANAGER_AGENT_REGISTRY_INTERVAL_MS);
   return Number.isFinite(value) && value >= 0 ? Math.floor(value) : 60000;
 }
+
+// Cancelling a runtime run must also cancel the asynchronous jobs it started:
+// the run's abort only stopped the manager-side loop while the agent kept
+// executing (an ingest subprocess ran on for minutes after "cancel requested",
+// with the panels frozen on its last known state). Best effort: prefer the
+// orchestration contract's agent_cancel, fall back to legacy *_cancel_job.
+export async function cancelActiveActivityJobs(session, { callTool = callMcpTool } = {}) {
+  const cancelled = [];
+  for (const activity of sessionActivities(session)) {
+    if (activity.terminal || !activity.poll) continue;
+    const jobId = activity.poll.args?.jobId ?? activity.id ?? null;
+    const server = activity.poll.server;
+    const endpoint = session.mcp?.[server];
+    if (!jobId || !endpoint || endpoint.status !== 'connected') continue;
+    const names = (endpoint.tools ?? []).map((tool) => String(tool.name ?? ''));
+    const cancelTool = names.find((name) => /(^|__)agent_cancel$/.test(name))
+      ?? names.find((name) => /_cancel_job$/.test(name))
+      ?? names.find((name) => /(^|__)[a-z]*_?cancel$/.test(name));
+    if (!cancelTool) continue;
+    try {
+      await callTool(session.mcp, server, cancelTool, { jobId });
+      emitRuntimeLog(session, `cancel: requested ${server}.${cancelTool} for job ${jobId}`);
+      cancelled.push({ server, jobId });
+    } catch (err) {
+      emitRuntimeLog(session, `cancel: ${server}.${cancelTool} failed for ${jobId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return cancelled;
+}

package/src/shell/RightPane.tsx

@@ -16,7 +16,9 @@ type QueueItem = {
 type QueueInfo = { active: number; current: number; frozen: number };
 type LogLineParts = { time: string | null; message: string };
 
-const ACTIVITY_SLOTS = Array.from({ length: 6 }, (_, index) => index);
+// 4 slots (was 6): items can now span up to 5 lines each (wrapped label +
+// wrapped status/error), so fewer, readable entries beat more, truncated ones.
+const ACTIVITY_SLOTS = Array.from({ length: 4 }, (_, index) => index);
 const LOG_SLOTS = Array.from({ length: 24 }, (_, index) => index);
 
 function wrapLine(value: string, width: number) {
@@ -70,7 +72,18 @@ function queueColor(status: string) {
 function activityLine(activity: any) {
   const detail = activity?.progress?.detail ?? null;
   const phase = activity?.progress?.step ?? activity?.progress?.phase ?? activity?.progress?.currentStep ?? null;
-  return [activity?.status ?? 'unknown', detail ?? phase].filter(Boolean).join(' · ');
+  // On failure the error message is the information that matters — surface
+  // it instead of repeating the bare status the label color already conveys.
+  const error = activityErrorText(activity);
+  return [activity?.status ?? 'unknown', error ?? detail ?? phase].filter(Boolean).join(' · ');
+}
+
+function activityErrorText(activity: any): string | null {
+  const status = String(activity?.status ?? '').toLowerCase();
+  if (!['failed', 'error', 'cancelled', 'canceled'].includes(status)) return null;
+  const error = activity?.error ?? activity?.result?.error ?? activity?.progress?.detail ?? null;
+  const text = error == null ? '' : String(error).replace(/\s+/g, ' ').trim();
+  return text || null;
 }
 
 function activityPercentBadge(activity: any): { text: string; bg: string; fg: string } | null {
@@ -127,13 +140,19 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
     <box flexShrink={0} flexDirection="column" padding={1}>
       <text width={lineWidth()} fg="#D6DEE8" content={fit(title(), lineWidth())} />
       <Index each={props.plan}>
-        {(step) => (
-          <text
-            width={lineWidth()}
-            fg={planStepColor(step(), firstPending())}
-            content={fit(`${icon(step().status)} ${step().step}. ${step().description}`, lineWidth())}
-          />
-        )}
+        {(step) => {
+          // Wrap step descriptions over up to 2 lines instead of truncating —
+          // "Ingest des 39 documents raw/untrac…" hid the actual target.
+          const lines = () => wrapLine(`${icon(step().status)} ${step().step}. ${step().description}`, lineWidth()).slice(0, 2);
+          return (
+            <box flexDirection="column">
+              <text width={lineWidth()} fg={planStepColor(step(), firstPending())} content={lines()[0]} />
+              <Show when={lines()[1]}>
+                <text width={lineWidth()} fg={planStepColor(step(), firstPending())} content={`    ${fit(lines()[1], Math.max(8, lineWidth() - 4))}`} />
+              </Show>
+            </box>
+          );
+        }}
       </Index>
     </box>
   );
@@ -141,7 +160,7 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
 
 export function ActivityPanel(props: { activities: any[]; width: number }) {
   const lineWidth = () => Math.max(8, props.width - 2);
-  const visible = () => props.activities.slice(-6).reverse();
+  const visible = () => props.activities.slice(-ACTIVITY_SLOTS.length).reverse();
   const activityAt = (index: number) => visible()[index] ?? null;
   return (
     <box flexShrink={0} flexDirection="column" padding={1}>
@@ -150,21 +169,39 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
         <Index each={ACTIVITY_SLOTS}>
           {(slot) => {
             const activity = () => activityAt(slot());
-            const label = () => {
+            // Wrap instead of hard-truncating: a 40-column pane cut labels to
+            // "Appliquer la config recommandée (doct…" and hid the one thing
+            // that mattered. Labels get up to 2 lines, the status/error line
+            // up to 2 lines; empty continuation lines are not rendered.
+            const labelLines = () => {
               const item = activity();
-              if (!item) return '';
-              return fit(item.progress?.label ?? item.label ?? `${item.source ?? 'mcp'} ${item.kind ?? 'job'}`, lineWidth());
+              if (!item) return [''];
+              const label = String(item.progress?.label ?? item.label ?? `${item.source ?? 'mcp'} ${item.kind ?? 'job'}`);
+              const lines = wrapLine(label, lineWidth()).slice(0, 2);
+              if (lines.length === 2 && String(label).length > lines[0].length + lines[1].length) {
+                lines[1] = fit(lines[1], lineWidth());
+              }
+              return lines;
             };
             const badge = () => activityPercentBadge(activity());
             const badgeLen = () => badge()?.text.length ?? 0;
+            const statusLines = () => {
+              const item = activity();
+              if (!item) return [''];
+              return wrapLine(activityLine(item), Math.max(8, lineWidth() - badgeLen())).slice(0, 2);
+            };
+            const statusColor = () => (activityErrorText(activity()) ? '#F38BA8' : '#AAB7C4');
             return (
               <box flexDirection="column" marginTop={slot() === 0 ? 1 : 0}>
-                <text width={lineWidth()} fg={activityColor(activity()?.status)} content={label()} />
+                <text width={lineWidth()} fg={activityColor(activity()?.status)} content={labelLines()[0]} />
+                <Show when={labelLines()[1]}>
+                  <text width={lineWidth()} fg={activityColor(activity()?.status)} content={labelLines()[1]} />
+                </Show>
                 <box height={1} flexDirection="row">
                   <text
                     width={lineWidth() - badgeLen()}
-                    fg="#AAB7C4"
-                    content={activity() ? fit(activityLine(activity()), lineWidth() - badgeLen()) : ''}
+                    fg={statusColor()}
+                    content={activity() ? fit(statusLines()[0], lineWidth() - badgeLen()) : ''}
                   />
                   <text
                     width={badgeLen()}
@@ -173,6 +210,9 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
                     content={badge()?.text ?? ''}
                   />
                 </box>
+                <Show when={statusLines()[1]}>
+                  <text width={lineWidth()} fg={statusColor()} content={fit(statusLines()[1], lineWidth())} />
+                </Show>
                 <text width={lineWidth()} fg="#7F8C8D" content={activity() ? fit(updatedLine(activity()), lineWidth()) : ''} />
               </box>
             );
@@ -183,31 +223,84 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
   );
 }
 
+type LogSegment = { text: string; fg: string };
+
+// Per-line coloring: 'runtime' source tag in violet, HH:MM:SS in blue,
+// message tinted by nature (errors red, warnings amber, activity teal).
+// Continuation lines of a wrapped entry are indented and dimmed so each
+// entry reads as one visual block instead of an undifferentiated wall.
+function logMessageColor(message: string): string {
+  if (/\b(error|failed|exception|unavailable|introuvable|HTTP 4\d\d|HTTP 5\d\d)\b/i.test(message)) return '#F38BA8';
+  if (/\b(warn|warning|avertissement|fallback|retry|expired|stale)\b/i.test(message)) return '#FBBF24';
+  if (/^(activity|job)\b/i.test(message)) return '#8BD5CA';
+  return '#AAB7C4';
+}
+
+function logRenderLines(logs: string[], width: number): LogSegment[][] {
+  // Newest entry FIRST (descending): the freshest information belongs at the
+  // top of the pane. Wrapped continuation lines stay attached below their
+  // entry's first line.
+  const blocks: LogSegment[][][] = [];
+  for (const raw of logs) {
+    blocks.push(logEntryLines(raw, width));
+  }
+  return blocks.reverse().flat();
+}
+
+function logEntryLines(raw: string, width: number): LogSegment[][] {
+  const out: LogSegment[][] = [];
+  for (const item of [raw]) {
+    const rawLine = item;
+    const sourceMatch = String(rawLine).match(/^(runtime)\s+(.*)$/);
+    const source = sourceMatch ? sourceMatch[1] : null;
+    const rest = sourceMatch ? sourceMatch[2] : String(rawLine);
+    const parts = logLineParts(rest);
+    const prefix: LogSegment[] = [];
+    if (source) prefix.push({ text: `${source} `, fg: '#C6A0F6' });
+    if (parts.time) prefix.push({ text: `${parts.time} `, fg: '#89B4FA' });
+    const prefixLength = prefix.reduce((total, segment) => total + segment.text.length, 0);
+    const messageColor = logMessageColor(parts.message);
+    const wrapped = wrapLine(parts.message, Math.max(8, width - prefixLength));
+    wrapped.forEach((text, index) => {
+      if (index === 0) {
+        out.push([...prefix, { text, fg: messageColor }]);
+      } else {
+        const indent = ' '.repeat(Math.min(prefixLength, 4));
+        out.push([{ text: `${indent}${text}`, fg: messageColor === '#F38BA8' ? messageColor : '#7F8C8D' }]);
+      }
+    });
+  }
+  return out;
+}
+
 export function LogPanel(props: { logs: string[]; width: number; filter?: string }) {
   const lineWidth = () => Math.max(8, props.width - 2);
   const filteredLogs = () => filterRuntimeLogs(props.logs, props.filter ?? '');
-  const visibleLines = () => filteredLogs().flatMap((line) => wrapLine(line, lineWidth())).slice(-24);
-  const logLineAt = (index: number) => visibleLines()[index] ?? '';
+  const visibleLines = createMemo(() => logRenderLines(filteredLogs(), lineWidth()).slice(0, 24));
+  const segmentsAt = (index: number): LogSegment[] => visibleLines()[index] ?? [];
   return (
     <box flexGrow={1} flexDirection="column" padding={1}>
       <text width={lineWidth()} fg="#D6DEE8" content="Logs / Trace" />
       <box flexGrow={1} flexDirection="column" overflow="hidden">
         <Index each={LOG_SLOTS}>
           {(slot) => {
-            const line = () => logLineAt(slot());
-            const parts = createMemo(() => logLineParts(line()));
-            const timeWidth = () => parts().time ? Math.min(parts().time!.length + 1, lineWidth()) : 0;
-            const messageWidth = () => Math.max(1, lineWidth() - timeWidth());
+            const segments = () => segmentsAt(slot());
+            const segmentAt = (position: number): LogSegment => segments()[position] ?? { text: '', fg: '#AAB7C4' };
+            const usedWidth = (upTo: number) => segments().slice(0, upTo).reduce((total, segment) => total + segment.text.length, 0);
+            const widthFor = (position: number) => {
+              const segment = segmentAt(position);
+              if (!segment.text) return 0;
+              // Last visible segment absorbs the remaining width.
+              return position === segments().length - 1
+                ? Math.max(1, lineWidth() - usedWidth(position))
+                : Math.min(segment.text.length, lineWidth() - usedWidth(position));
+            };
             return (
-              <Show
-                when={parts().time}
-                fallback={<text width={lineWidth()} fg="#AAB7C4" content={line()} />}
-              >
-                <box height={1} flexDirection="row" overflow="hidden">
-                  <text width={timeWidth()} fg="#89B4FA" content={`${parts().time} `} />
-                  <text width={messageWidth()} fg="#AAB7C4" content={parts().message} />
-                </box>
-              </Show>
+              <box height={1} flexDirection="row" overflow="hidden">
+                <text width={widthFor(0)} fg={segmentAt(0).fg} content={segmentAt(0).text} />
+                <text width={widthFor(1)} fg={segmentAt(1).fg} content={segmentAt(1).text} />
+                <text width={widthFor(2)} fg={segmentAt(2).fg} content={segmentAt(2).text} />
+              </box>
             );
           }}
         </Index>

package/src/shell/SetupWizard.tsx

@@ -1,7 +1,7 @@
 /** @jsxImportSource @opentui/solid */
 import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
-import { useKeyboard } from '@opentui/solid';
+import { useKeyboard, usePaste } from '@opentui/solid';
 import { createEffect, createMemo, createSignal, For, Show } from 'solid-js';
 import { fallbackModels, normalizeProvider } from '../core/modelFetch.js';
 import {
@@ -606,6 +606,18 @@ export function SetupWizard(props: {
     } catch { return ''; }
   }
 
+  // Terminal paste (Cmd+V/middle-click) arrives as a bracketed-paste block.
+  // openTUI's key parser swallows the \x1b[200~/\x1b[201~ markers and emits a
+  // dedicated `paste` event instead of key events — the text NEVER reaches
+  // useKeyboard, so the legacy bracketed-paste branch below can't fire.
+  usePaste((event: any) => {
+    if (busy() || step().kind !== 'text') return;
+    const raw = event?.text
+      ?? (event?.bytes != null ? Buffer.from(event.bytes).toString('utf8') : '');
+    const pasted = String(raw).replace(/\r\n?/g, '\n').replace(/\n+$/, '').split('\n').join(' ');
+    if (pasted) setInput((value) => value + pasted);
+  });
+
   useKeyboard((key: any) => {
     if (busy()) return;
     const s = step();