@dotdrelle/wiki-manager 0.14.13 → 0.14.20

package/src/runtime/server.test.js

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { createInteractiveSession, ensureInteractiveAssistantMessage } from '../cli/wiki-manager.js';
-import { runtimeState, startRuntimeServer as startRuntimeServerImpl } from './server.js';
+import { approvalRequestFromStatus, runtimeState, startRuntimeServer as startRuntimeServerImpl } from './server.js';
 
 // Most server tests exercise endpoint behavior rather than authentication. Keep
 // them independent from a developer's WIKI_MANAGER_RUNTIME_TOKEN environment;
@@ -11,6 +11,35 @@ function startRuntimeServer(options) {
   return startRuntimeServerImpl({ token: '', ...options });
 }
 
+test('approval fallback derives classes from waiting tasks when the approval queue is missing', () => {
+  const request = approvalRequestFromStatus({
+    workspace: 'acme',
+    runId: 'run-1',
+    planRevision: 4,
+    approvals: [],
+    plan: [
+      { id: 'apply', status: 'waiting_approval', requiresApproval: true, approvalClass: 'mutation' },
+      { id: 'export', status: 'waiting_approval', requiresApproval: true, approvalClass: 'external-write' },
+    ],
+  });
+
+  assert.deepEqual(request.approvalClasses, ['mutation', 'external-write']);
+  assert.equal(request.scope, 'run');
+  assert.equal(request.planRevision, 4);
+});
+
+test('approval fallback excludes tasks blocked by failed dependencies', () => {
+  const request = approvalRequestFromStatus({
+    workspace: 'acme', runId: 'run-1', planRevision: 4, approvals: [],
+    plan: [
+      { id: 'failed-source', status: 'failed' },
+      { id: 'blocked-write', status: 'waiting_approval', requiresApproval: true, approvalClass: 'external-write', dependsOn: ['failed-source'] },
+    ],
+  });
+
+  assert.deepEqual(request.approvalClasses, ['default']);
+});
+
 test('interactive runtime sessions isolate canonical run state', () => {
   const mcp = { wiki: { status: 'connected' } };
   const session = createInteractiveSession({ session: {

package/src/runtime/store.js

@@ -541,6 +541,12 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   const listApprovalGrantsByRunStatement = db.prepare(`
     SELECT * FROM approval_grants WHERE run_id = ? ORDER BY created_at ASC, id ASC
   `);
+  const listPendingApprovalGrantsByRunStatement = db.prepare(`
+    SELECT * FROM approval_grants WHERE run_id = ? AND status = 'pending_approval'
+  `);
+  const markApprovalGrantApprovedStatement = db.prepare(`
+    UPDATE approval_grants SET status = 'approved', granted_at = ? WHERE id = ?
+  `);
 
   function persistEvent(event) {
     if (NON_PERSISTED_EVENT_TYPES.has(event.type)) return event;
@@ -687,10 +693,12 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
       const delResults = db.prepare('DELETE FROM task_results WHERE task_id IN (SELECT id FROM tasks WHERE run_id = ?)');
       const delAssignments = db.prepare('DELETE FROM task_assignments WHERE task_id IN (SELECT id FROM tasks WHERE run_id = ?)');
       const delAttempts = db.prepare('DELETE FROM task_attempts WHERE run_id = ?');
+      const delApprovals = db.prepare('DELETE FROM approval_grants WHERE run_id = ?');
       for (const runId of runIds) {
         delResults.run(runId);
         delAssignments.run(runId);
         delAttempts.run(runId);
+        delApprovals.run(runId);
       }
       const events = (workspace
         ? db.prepare('DELETE FROM events WHERE workspace = ?').run(workspace)
@@ -1020,6 +1028,29 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
       status === 'approved' ? (payload.grantedAt ?? event.ts) : null,
       status === 'rejected' ? (payload.rejectedAt ?? event.ts) : null,
     );
+    // Mirror the in-memory projection's markCoveredApprovalsApproved into the
+    // persisted table: a broad (run/group) grant covers the per-task
+    // pending_approval requests, so mark them approved here too. Without this,
+    // the scheduler proceeds (the projection knows they're covered) but the
+    // approval_grants table keeps them pending_approval forever — orphaned rows
+    // that pile up (32 per run observed) and survive run purges.
+    if (status === 'approved') {
+      const grantedAt = payload.grantedAt ?? event.ts;
+      const grant = {
+        scope: String(payload.scope ?? 'run'),
+        runId: String(runId),
+        workspaceId: event.workspace ?? payload.workspaceId ?? payload.workspace ?? null,
+        planRevision: payload.planRevision == null ? null : Number(payload.planRevision),
+        groupId: payload.groupId ?? null,
+        approvalClasses: normalizeApprovalClasses(payload.approvalClasses ?? payload.approvalClass),
+        ids: new Set([payload.taskId, payload.itemId, payload.approvalId, payload.id, event.taskId]
+          .filter(Boolean).map(String)),
+      };
+      for (const row of listPendingApprovalGrantsByRunStatement.all(String(runId))) {
+        if (String(row.id) === String(id)) continue;
+        if (persistedGrantCovers(grant, row)) markApprovalGrantApprovedStatement.run(grantedAt, row.id);
+      }
+    }
   }
 
   function lifecycleTaskId(event) {
@@ -1177,6 +1208,10 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     return {
       ...baseState,
       runs,
+      // Resolved scheduler concurrency for the live run (display-only). Null for
+      // replayed/historical state — the UIs then fall back to the plan-derived
+      // value. Never consumed by scheduling.
+      concurrency: session?._runConcurrency ?? null,
       workflow: projectWorkflow({ ...baseState, runs, workspace }, events ?? session?.agentEvents ?? []),
     };
   }
@@ -1281,9 +1316,11 @@ function purgeOldTerminalRuns(db, now = new Date()) {
   db.exec('BEGIN');
   try {
     const deleteEvents = db.prepare('DELETE FROM events WHERE run_id = ? OR json_extract(payload, \'$.runId\') = ?');
+    const deleteApprovals = db.prepare('DELETE FROM approval_grants WHERE run_id = ?');
     const deleteRun = db.prepare('DELETE FROM runs WHERE id = ?');
     for (const runId of oldRuns) {
       deleteEvents.run(runId, runId);
+      deleteApprovals.run(runId);
       deleteRun.run(runId);
     }
     db.exec('COMMIT');
@@ -1403,6 +1440,23 @@ function normalizeApprovalClasses(value) {
   return [...new Set(values.map((item) => String(item).trim()).filter(Boolean))];
 }
 
+// Persisted-table twin of markCoveredApprovalsApproved (core/agentEvents.js):
+// does `grant` (already-approved) cover the pending approval_grants `row`?
+// Kept in sync with that reducer so the DB never disagrees with the projection.
+function persistedGrantCovers(grant, row) {
+  if (grant.runId != null && row.run_id != null && String(grant.runId) !== String(row.run_id)) return false;
+  if (grant.workspaceId != null && row.workspace_id != null && String(grant.workspaceId) !== String(row.workspace_id)) return false;
+  if (grant.planRevision != null && row.plan_revision != null && Number(grant.planRevision) !== Number(row.plan_revision)) return false;
+  const rowClasses = row.approval_classes ? normalizeApprovalClasses(parseJsonMaybe(row.approval_classes)) : [];
+  if (grant.approvalClasses.length > 0 && rowClasses.length > 0 && !rowClasses.some((item) => grant.approvalClasses.includes(item))) return false;
+  if (grant.scope === 'group' && String(grant.groupId ?? '') !== String(row.group_id ?? '')) return false;
+  if (grant.scope === 'task' || grant.scope === 'tool') {
+    const rowIds = [row.task_id, row.id].filter(Boolean).map(String);
+    if (!rowIds.some((id) => grant.ids.has(id))) return false;
+  }
+  return true;
+}
+
 function parseJsonMaybe(value) {
   try {
     return JSON.parse(value);

package/src/runtime/store.test.js

@@ -540,6 +540,48 @@ test('runtime store persists bounded approval grants', () => {
   store.close();
 });
 
+test('runtime store: a run-scope grant marks covered task grants approved (no orphans)', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  // Two per-task approval requests for the same run.
+  for (const taskId of ['run-x:ingest-a', 'run-x:ingest-b']) {
+    store.persistEvent(createAgentEvent('approval.requested', {
+      origin: 'runtime',
+      runId: 'run-x',
+      workspace: 'docs',
+      taskId,
+      payload: { id: `approval:${taskId}`, scope: 'task', runId: 'run-x', workspaceId: 'docs', taskId },
+    }));
+  }
+  assert.equal(store.listApprovalGrants({ runId: 'run-x' }).filter((g) => g.status === 'pending_approval').length, 2);
+
+  // A single run-scope grant covers both.
+  store.persistEvent(createAgentEvent('approval.granted', {
+    origin: 'runtime',
+    runId: 'run-x',
+    workspace: 'docs',
+    payload: { id: 'grant-run-x', scope: 'run', runId: 'run-x', workspaceId: 'docs' },
+  }));
+  const grants = store.listApprovalGrants({ runId: 'run-x' });
+  assert.equal(grants.filter((g) => g.status === 'pending_approval').length, 0, 'no task grant left pending');
+  assert.equal(grants.filter((g) => g.status === 'approved').length, 3, 'both tasks + run grant approved');
+  store.close();
+});
+
+test('runtime store: clearWorkspaceState removes approval grants', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('run_started', { origin: 'runtime', runId: 'run-y', workspace: 'docs', payload: { runId: 'run-y' } }));
+  store.persistEvent(createAgentEvent('approval.requested', {
+    origin: 'runtime', runId: 'run-y', workspace: 'docs', taskId: 'run-y:t',
+    payload: { id: 'approval:run-y:t', scope: 'task', runId: 'run-y', workspaceId: 'docs', taskId: 'run-y:t' },
+  }));
+  assert.equal(store.listApprovalGrants({ runId: 'run-y' }).length, 1);
+  store.clearWorkspaceState({ workspace: 'docs' });
+  assert.equal(store.listApprovalGrants({ runId: 'run-y' }).length, 0);
+  store.close();
+});
+
 test('runtime store orders events by durable sequence', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });

package/src/shell/FileEditorDialog.tsx

@@ -83,9 +83,9 @@ export function FileEditorDialog(props: {
             {(message) => <text height={1} fg="#F87171">{message()}</text>}
           </Show>
           <box height={1} flexDirection="row">
-            <text fg="#111318" bg="#8BD5CA"> Save Ctrl+S </text>
+            <text fg="#111318" bg="#8BD5CA" onMouseUp={save}> Save Ctrl+S </text>
             <text fg="#7F8C8D">  </text>
-            <text fg="#D6DEE8" bg="#4B5563"> Cancel Esc </text>
+            <text fg="#D6DEE8" bg="#4B5563" onMouseUp={props.onCancel}> Cancel Esc </text>
           </box>
         </box>
       )}

package/src/shell/LeftPane.tsx

@@ -1,5 +1,6 @@
 /** @jsxImportSource @opentui/solid */
 import { For, createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
+import { StyledText, bg as styledBg, fg as styledFg, link as styledLink } from '@opentui/core';
 import { colorForRenderedLine, helpCommandParts, keyValueParts, renderPlainMarkdown } from './renderer';
 import { httpLinkParts, wrapHttpLinks } from './externalLinks.js';
 
@@ -49,8 +50,20 @@ function wrapLine(line: string, width: number) {
 }
 
 type Segment = { text: string; color: string; width?: number; bg?: string; url?: string };
+
+function styledSegments(segments: Segment[]) {
+  return new StyledText(segments.map((segment) => {
+    const text = segment.width ? segment.text.padEnd(segment.width) : segment.text;
+    let chunk = styledFg(segment.color)(text);
+    if (segment.bg) chunk = styledBg(segment.bg)(chunk);
+    if (segment.url) chunk = styledLink(segment.url)(chunk);
+    return chunk;
+  }));
+}
 type RenderedLine = {
   segments: Segment[];
+  role?: string;
+  userBubbleWidth?: number;
   status?: boolean;
   statusLeft?: string;
   statusRight?: string;
@@ -376,19 +389,35 @@ function statusColumns(line: string): { left: string; right: string } {
   return { left: left || ' ', right };
 }
 
+// Consecutive messages that render under the same header ([shell]/[user]/
+// [donna]) are grouped: only the first one shows the label + separator, so a
+// run of same-type messages doesn't repeat the header on every entry.
+function headerGroupKey(role: string) {
+  return isDonnaRole(role) ? 'donna' : roleLabel(role);
+}
+
 function conversationLines(messages: Array<{ role: string; content: string }>, columns: number): RenderedLine[] {
-  return messages.flatMap((message) => {
+  return messages.flatMap((message, index) => {
     const raw = String(message.content || '');
+    const previous = index > 0 ? messages[index - 1] : null;
+    const showHeader = !previous || headerGroupKey(previous.role) !== headerGroupKey(message.role);
+    const headerLines: RenderedLine[] = showHeader
+      ? [
+          { segments: messageHeaderSegments(message.role, columns), copyContent: raw },
+          { segments: [{ text: ' ', color: '#D6DEE8' }] },
+        ]
+      : [];
+    const contentColumns = message.role === 'user' ? Math.max(12, Math.floor(columns * 0.6) - 2) : columns;
     if (isStatusOutput(message)) {
-      return [
-        { segments: messageHeaderSegments(message.role, columns), copyContent: raw },
-        { segments: [{ text: ' ', color: '#D6DEE8' }] },
+      const statusLines: RenderedLine[] = [
+        ...headerLines,
         ...raw.split('\n').map((line) => {
           const { left, right } = statusColumns(line || ' ');
           return { status: true, statusLeft: left, statusRight: right, segments: [] };
         }),
         { segments: [{ text: ' ', color: '#D6DEE8' }] },
       ];
+      return statusLines.map((line) => ({ ...line, role: message.role }));
     }
     let inFence = false;
     const lines: Array<{ text: string; isCode: boolean }> = [];
@@ -399,12 +428,19 @@ function conversationLines(messages: Array<{ role: string; content: string }>, c
       if (/^\s*(`{3,}|~{3,})/.test(line)) { inFence = !inFence; continue; }
       lines.push({ text: line, isCode: inFence });
     }
-    return [
-      { segments: messageHeaderSegments(message.role, columns), copyContent: raw },
-      { segments: [{ text: ' ', color: '#D6DEE8' }] },
-      ...renderMarkdownLines(lines, message.role, columns),
+    const renderedBody = renderMarkdownLines(lines, message.role, contentColumns);
+    const userBubbleWidth = message.role === 'user'
+      ? Math.min(
+          Math.max(1, ...renderedBody.map((line) => line.segments.reduce((sum, segment) => sum + segment.text.length, 0))) + 2,
+          Math.max(12, Math.floor(columns * 0.6)),
+        )
+      : undefined;
+    const bodyLines: RenderedLine[] = [
+      ...headerLines,
+      ...renderedBody.map((line) => ({ ...line, userBubbleWidth })),
       { segments: [{ text: ' ', color: '#D6DEE8' }] },
     ];
+    return bodyLines.map((line) => ({ ...line, role: message.role }));
   });
 }
 
@@ -462,6 +498,21 @@ export function ConversationView(props: {
               </For>
               <text fg="#4B5563" content={COPY_BTN} onMouseUp={() => props.onCopy?.(line.copyContent!)} />
             </box>
+          ) : line.role === 'user' && line.userBubbleWidth ? (
+            <box height={1} flexDirection="row" overflow="hidden">
+              <box flexGrow={1} />
+              <box
+                width={line.userBubbleWidth}
+                height={1}
+                flexDirection="row"
+                flexShrink={1}
+                justifyContent="flex-start"
+                paddingX={1}
+                overflow="hidden"
+              >
+                <text>{styledSegments(line.segments)}</text>
+              </box>
+            </box>
           ) : line.status ? (
             <box height={1} flexDirection="row" gap={2} overflow="hidden">
               <box
@@ -499,13 +550,7 @@ export function ConversationView(props: {
             </box>
           ) : (
             <box height={1} flexDirection="row" overflow="hidden">
-              <For each={line.segments}>
-                {(seg: Segment) => (
-                  <text width={seg.width} fg={seg.color} bg={seg.bg}>
-                    {seg.url ? <a href={seg.url}>{seg.text}</a> : seg.text}
-                  </text>
-                )}
-              </For>
+              <text>{styledSegments(line.segments)}</text>
             </box>
           )
         )}