@dotdrelle/wiki-manager 0.15.97 → 0.15.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.97",
+  "version": "0.15.99",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   },
   "scripts": {
     "start": "bun ./bin/wiki-manager.js",
-    "test": "node --test src/core/skillInvocation.test.js src/core/skillCompiler.test.js src/runtime/skillRun.test.js src/runtime/controlDrain.test.js src/runtime/controlCancellation.test.js src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/agent/skillRecursion.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/profileServiceStatus.test.js src/core/workspaceProfile.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/skillChainView.test.js src/core/runtimeLog.test.js src/core/runtimeEventAdapter.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/otherWorkspacesRunning.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikiWorkspaceStart.test.js src/core/wikirc.test.js src/core/workspaceInherit.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/currentArtifact.test.js src/core/googleGrants.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/taskStatuses.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/orchestrator/providers/fakeRuntimeProvider.test.js src/orchestrator/providers/runtimeProviders.test.js src/orchestrator/providers/dispatcherExternalRuntime.test.js src/orchestrator/providers/deepAgentsProvider.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardModality.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/shell/setupWizardDiscovery.test.js src/shell/wrapText.test.js src/runtime/lifecycle.test.js src/runtime/store.test.js src/runtime/workspaceIsolation.test.js src/runtime/controlMessages.test.js src/runtime/deltaCoalescer.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/delegation.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/skillChain.e2e.test.js src/runtime/donna-contract.test.js src/runtime/approvals.test.js src/runtime/auth.test.js src/runtime/totp.test.js src/runtime/loginSession.test.js src/runtime/loginRoutes.test.js",
+    "test": "node --test src/core/skillInvocation.test.js src/core/skillCompiler.test.js src/runtime/skillRun.test.js src/runtime/controlDrain.test.js src/runtime/controlCancellation.test.js src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/agent/skillRecursion.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/profileServiceStatus.test.js src/core/workspaceProfile.test.js src/core/buildInfo.test.js src/core/testGate.test.js src/core/agentEvents.test.js src/core/skillChainView.test.js src/core/runtimeLog.test.js src/core/runtimeEventAdapter.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/mcpEndpoints.test.js src/core/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/otherWorkspacesRunning.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikiWorkspaceStart.test.js src/core/wikirc.test.js src/core/workspaceInherit.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/currentArtifact.test.js src/core/googleGrants.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/taskStatuses.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/proactiveReviewScheduler.test.js src/orchestrator/knowledgeSignals.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/orchestrator/providers/fakeRuntimeProvider.test.js src/orchestrator/providers/runtimeProviders.test.js src/orchestrator/providers/dispatcherExternalRuntime.test.js src/orchestrator/providers/deepAgentsProvider.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardModality.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/shell/setupWizardDiscovery.test.js src/shell/wrapText.test.js src/runtime/lifecycle.test.js src/runtime/store.test.js src/runtime/workspaceIsolation.test.js src/runtime/controlMessages.test.js src/runtime/controlClassify.test.js src/runtime/deltaCoalescer.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/delegation.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/skillChain.e2e.test.js src/runtime/donna-contract.test.js src/runtime/approvals.test.js src/runtime/auth.test.js src/runtime/totp.test.js src/runtime/loginSession.test.js src/runtime/loginRoutes.test.js",
     "check-versions": "node scripts/check-versions.js",
     "prepack": "node scripts/check-versions.js",
     "prepublishOnly": "node scripts/check-versions.js",

package/src/agent/graph.js

@@ -1905,7 +1905,11 @@ export function createAgentGraph(options = {}) {
     let terminalFailure = null;
     let skillLaunch = null;
 
-    for (const call of toolCalls) {
+    // The index is kept so a break can name the calls that never ran: every
+    // iteration pushes a tool result before it continues or completes, so
+    // everything AFTER the break is exactly the unexecuted set.
+    let stoppedAt = toolCalls.length;
+    for (const [callIndex, call] of toolCalls.entries()) {
       const resolved = resolveToolCallName(state.session.mcp, call.function.name, INTERNAL_TOOL_SERVERS);
       const { server, tool } = resolved;
       const argsSummary = summarizeToolArguments(call.function.arguments);
@@ -2031,10 +2035,17 @@ export function createAgentGraph(options = {}) {
                 ),
                 objectives: Number(skillResult.objectiveCount ?? skillResult.objectives ?? 1) || 1,
               };
-            } else if (skillResult?.ok === false) {
-              // A recoverable refusal (guessed skill, missing input): keep the
-              // turn alive so the model can correct itself or delegate, but do
-              // not let the progress note call it a success.
+            } else if (skillResult?.ok === false && skillResult?.needsInput !== true) {
+              // A recoverable refusal (a guessed skill that does not exist):
+              // keep the turn alive so the model can correct itself or
+              // delegate, but do not let the progress note call it a success.
+              //
+              // `needsInput` is excluded on purpose: "ask the user for the
+              // missing scope" is a conversational blocker, and marking it
+              // failed published `runtime__run_skill failed: {…}` into the
+              // progress surfaces while the turn was working exactly as
+              // intended. The `delegate` branch below already treats the
+              // identical case that way; the two must not disagree.
               ok = false;
             }
           }
@@ -2186,7 +2197,34 @@ export function createAgentGraph(options = {}) {
         tool_call_id: call.id,
         content: boundedResult,
       });
-      if (terminalFailure) break;
+      if (terminalFailure || skillLaunch) { stoppedAt = callIndex + 1; break; }
+    }
+
+    // A skill launch owns execution and ends the turn, so the rest of the
+    // batch is NOT executed — a companion runtime__delegate in the same batch
+    // used to start a second, independent run with nothing in the thread
+    // naming it. Every unexecuted call still gets its tool result: a provider
+    // that sees tool_calls without matching results on a replayed history
+    // rejects the conversation.
+    if (skillLaunch) {
+      const dropped = toolCalls.slice(stoppedAt);
+      const notRun = `Not executed: ${skillLaunch.publicInput} was launched earlier in this `
+        + 'turn and owns execution from here. Do not start a second run for the same objective.';
+      for (const call of dropped) {
+        emitAgentEvent(state.session, 'tool_call_result', 'tool', {
+          callId: call.id,
+          name: call.function?.name ?? 'tool',
+          ok: false,
+          result: notRun,
+          summary: 'skipped',
+        });
+        toolResultMessages.push({ role: 'tool', tool_call_id: call.id, content: notRun });
+      }
+      if (dropped.length > 0) {
+        state.session._onStep?.(
+          `${dropped.length} tool call(s) skipped: ${skillLaunch.publicInput} owns execution`,
+        );
+      }
     }
 
     if (terminalFailure) {
@@ -2205,7 +2243,7 @@ export function createAgentGraph(options = {}) {
       // language like the `/turn` skill path. No further model turn: the skill
       // is launched and owns execution, so nothing can contradict it.
       const response = await generateSkillAcknowledgment(state.session, skillLaunch).catch(
-        () => `Started ${skillLaunch.publicInput} — ${skillLaunch.objectives} step(s) in progress.`,
+        () => `Started ${skillLaunch.publicInput} — ${skillLaunch.objectives} step(s) queued.`,
       );
       return {
         messages: toolResultMessages,

package/src/agent/graph.test.js

@@ -678,6 +678,14 @@ test('a natural-language skill match cannot drop declared scope and fall back to
     const toolResult = session.agentEvents.find((event) => event.type === 'tool_call_result');
     assert.match(toolResult?.payload?.result ?? '', /missingParameters/);
     assert.match(toolResult?.payload?.result ?? '', /never replace a missing parameter with an unscoped/);
+    // "Ask the user for the missing scope" is a conversational blocker, not an
+    // execution failure — the turn is working exactly as intended. Marking it
+    // failed published `runtime__run_skill failed: {…}` into the progress and
+    // activity surfaces; the `delegate` branch handles the identical case as a
+    // non-failure, and the two must not disagree.
+    assert.equal(toolResult?.payload?.ok, true);
+    const progress = session.agentEvents.find((event) => event.type === 'assistant_progress');
+    assert.doesNotMatch(progress?.payload?.message ?? '', /failed/i);
   } finally {
     rmSync(root, { recursive: true, force: true });
   }
@@ -776,6 +784,43 @@ test('a recoverable skill refusal lets the delegate fallback run in the same tur
   assert.notEqual(result.terminalToolFailure, true);
 });
 
+test('an ACCEPTED skill launch stops the rest of the batch, and says what it dropped', async () => {
+  // The mirror of the test above: a refusal must let the fallback run, an
+  // acceptance must not. The skill owns execution from there, but the loop
+  // kept going — a companion runtime__delegate in the same batch started a
+  // second, independent run while only the skill was acknowledged, with
+  // nothing in the thread naming the delegated one.
+  let delegated = false;
+  const session = sessionBase({
+    runtime: { url: 'http://runtime.test' },
+    _runSkillWithinRun: async () => ({ accepted: true, skill: 'pipeline', objectiveCount: 1 }),
+    _delegateWithinRun: async () => { delegated = true; return { runId: 'run-2', summary: { tasks: 1 } }; },
+    llm: {
+      async completeWithTools({ tools }) {
+        if (tools.some((tool) => tool.function?.name === 'classify_action_request')) {
+          return { content: null, message: { role: 'assistant', content: null }, tool_calls: [{ id: 'classify', type: 'function', function: { name: 'classify_action_request', arguments: '{"action":true}' } }] };
+        }
+        return {
+          content: null, message: { role: 'assistant', content: null },
+          tool_calls: [
+            { id: 'skill', type: 'function', function: { name: 'runtime__run_skill', arguments: '{"skillName":"pipeline","selectionKind":"explicit_name"}' } },
+            { id: 'also', type: 'function', function: { name: 'runtime__delegate', arguments: '{"objective":"construire le livrable"}' } },
+          ],
+        };
+      },
+    },
+  });
+  await createAgentGraph().invoke({ input: '/pipeline', session });
+  assert.equal(delegated, false, 'the delegate must not start a second run behind the skill');
+  // …and the skipped call is announced rather than silently dropped, with a
+  // tool result so a replayed history is not missing one.
+  const skipped = session.agentEvents.find(
+    (event) => event.type === 'tool_call_result' && event.payload?.callId === 'also',
+  );
+  assert.equal(skipped?.payload?.summary, 'skipped');
+  assert.match(skipped?.payload?.result ?? '', /owns execution/);
+});
+
 test('tool argument normalization repairs only an unambiguous schema-compatible field name', () => {
   const schema = {
     type: 'object',

package/src/cli/wiki-manager.js

@@ -1725,6 +1725,13 @@ async function runRuntime(argv, agent) {
   async function executeInteractiveTurn(context, body, { signal, turnId } = {}) {
     const input = String(body.input ?? body.prompt ?? '').trim();
     if (!input) throw new Error('Missing input.');
+    // The reader's own words, when the caller augmented `input` with system
+    // facts (a status question gets the runtime's fact block appended for the
+    // model). The thread, the SSE stream and the replayed history must all
+    // show what was typed — publishing the fact block as the user's message
+    // put a raw English dump in their bubble and seeded every later turn with
+    // it.
+    const displayInput = String(body.displayInput ?? '').trim() || input;
     // The runtime may start while optional agents are still stopped. `/start
     // agents` happens in the shell process, so its refreshed MCP snapshot does
     // not mutate this long-lived runtime context. Re-probe only while at least
@@ -1776,7 +1783,7 @@ async function runRuntime(argv, agent) {
       origin: 'runtime_turn',
       turnId,
       workspace: context.workspace ?? null,
-      payload: { content: input },
+      payload: { content: displayInput },
     }));
     // Read-only chat turn: same chatAccess policy as the Shell UI's /chat, now
     // reachable over HTTP so `wiki serve` chat mode gets read tools without
@@ -1792,39 +1799,46 @@ async function runRuntime(argv, agent) {
       body.context?.openWikiPages ?? body.context?.openWikiPage,
     );
     let response;
-    if (chatMode) {
-      ephemeral.chatMode = true;
-      ephemeral.chatAccess = readChatAccessConfig();
-      const history = messages.length && messages[messages.length - 1]?.role === 'user'
-        ? messages.slice(0, -1)
-        : messages;
-      response = await runHeadlessChatTurn(ephemeral, input, {
-        history,
-        onStep: ephemeral._onStep,
-        // Fragments de réponse publiés au fil de l'eau, coalescés (voir
-        // deltaCoalescer ci-dessus). Le réducteur les agrège dans la dernière
-        // entrée de conversation (`assistant_delta`), que `assistant_message`
-        // vient ensuite figer : les deux interfaces voient la réponse s'écrire
-        // sans qu'un insert SQLite par token ne bloque le flux.
-        onTextDelta: (delta) => deltaCoalescer.push(delta),
-        onTextReset: () => {
-          deltaCoalescer.reset();
-          dispatchAgentEvent(ephemeral, createAgentEvent('assistant_delta_reset', {
-            origin: 'runtime_turn',
-            turnId,
-            workspace: context.workspace ?? null,
-            payload: {},
-          }));
-        },
-        openWikiPages,
-      });
-    } else {
-      ephemeral.openWikiPages = openWikiPages;
-      response = await runAgentTurn(agent, ephemeral, input, { messages, signal });
+    try {
+      if (chatMode) {
+        ephemeral.chatMode = true;
+        ephemeral.chatAccess = readChatAccessConfig();
+        const history = messages.length && messages[messages.length - 1]?.role === 'user'
+          ? messages.slice(0, -1)
+          : messages;
+        response = await runHeadlessChatTurn(ephemeral, input, {
+          history,
+          onStep: ephemeral._onStep,
+          // Fragments de réponse publiés au fil de l'eau, coalescés (voir
+          // deltaCoalescer ci-dessus). Le réducteur les agrège dans la dernière
+          // entrée de conversation (`assistant_delta`), que `assistant_message`
+          // vient ensuite figer : les deux interfaces voient la réponse s'écrire
+          // sans qu'un insert SQLite par token ne bloque le flux.
+          onTextDelta: (delta) => deltaCoalescer.push(delta),
+          onTextReset: () => {
+            deltaCoalescer.reset();
+            dispatchAgentEvent(ephemeral, createAgentEvent('assistant_delta_reset', {
+              origin: 'runtime_turn',
+              turnId,
+              workspace: context.workspace ?? null,
+              payload: {},
+            }));
+          },
+          openWikiPages,
+        });
+      } else {
+        ephemeral.openWikiPages = openWikiPages;
+        response = await runAgentTurn(agent, ephemeral, input, { messages, signal });
+      }
+    } finally {
+      // In a `finally`, not after the await: a throwing or aborted turn left
+      // the 80 ms timer armed, so a stray assistant_delta fired AFTER the
+      // "Runtime turn failed" message and appended orphan fragments to the
+      // wrong conversation entry — and the handle kept the session closure
+      // alive. Flush the tail first so ordering survives either way.
+      deltaCoalescer.flush();
+      deltaCoalescer.dispose();
     }
-    // Flush the tail before the turn is finalized, then stop the timer.
-    deltaCoalescer.flush();
-    deltaCoalescer.dispose();
     // Persist the artifact the turn may have opened/edited (template_write,
     // template_read, …) back onto the long-lived session, so the next /turn —
     // chat or agent — sees it. The ephemeral session is otherwise discarded.

package/src/commands/slash.js

@@ -9,7 +9,7 @@
  */
 import { isTerminal } from '../orchestrator/taskStatuses.js';
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { openExternalUrl } from '../shell/openExternal.js';
+import { openAppWindowUrl, openExternalUrl } from '../shell/openExternal.js';
 import { classifyCommandFailure, failureHint, rawFailureText } from '../core/commandFailure.js';
 import { basename, join, relative } from 'node:path';
 import { composeServices, listServices, otherWorkspacesRunning, runWikiCli, serviceLogs, serviceNames, serviceStates, startService, stopService } from '../core/compose.js';
@@ -845,7 +845,7 @@ ${helpPair('/upload <path>', 'Upload document', '/uploads', 'Uploaded docs')}
 ${helpPair('/upload convert pending', 'Convert pending', '/uploads clean', 'Clean uploads')}
 ${helpPair('/wiki', 'Run wiki index', '/wiki run <args>', 'Raw wiki CLI')}
 ${helpPair('/chat', 'Chat mode', '/agent [question]', 'Agent mode / one-shot')}
-${helpPair('/openui', 'Open web UI in browser', '', '')}
+${helpPair('/openui', 'Open web UI as a desktop window', '', '')}
 ${helpPair('/run status', 'Runtime status', '/run kill', 'Kill runtime run(s)')}
 ${helpPair('/run capability <id>', 'Deterministic capability run', '/approve', 'Grant pending approval')}
 ${helpPair('/cancel', 'Cancel active run', '', '')}
@@ -1770,6 +1770,11 @@ export async function handleSlashCommand(line, context) {
         // No readable session (gate off, or a custom state dir): plain URL.
       }
       const note = context.session.workspaceEnv ? '' : ' (no workspace loaded — using default port)';
+      // App-mode first: a chromeless Chrome/Edge window picks up serve's own
+      // manifest (name, icon, window-controls-overlay) with no prior "Install"
+      // step. Falls back to the plain default-browser tab when neither is
+      // found (Safari/Firefox-only machines).
+      if (openAppWindowUrl(openUrl)) return { output: `Opening web UI: ${url}${note}` };
       if (openExternalUrl(openUrl)) return { output: `Opening web UI: ${url}${note}` };
       return { output: `Web UI: ${url}${note}` };
     }

package/src/contracts/schemas.js

@@ -369,23 +369,14 @@ const runtimeEventSchema = {
   required: ['type'],
   additionalProperties: true,
   properties: {
-    type: {
-      type: 'string',
-      enum: [
-        'run_created',
-        'run_started',
-        'agent_thinking',
-        'tool_started',
-        'tool_finished',
-        'subagent_started',
-        'subagent_finished',
-        'message',
-        'approval_required',
-        'run_completed',
-        'run_failed',
-        'run_cancelled',
-      ],
-    },
+    // Deliberately OPEN: a gateway newer than the manager emits event types
+    // this version has never heard of, and a closed enum here threw inside
+    // `normalizeRuntimeEvent` before `runtimeEventAdapter` could decide what to
+    // do with them — the provider's catch swallowed the frame, so the whole
+    // activity contract was invisible in production while its unit tests
+    // passed. The adapter owns the vocabulary and journals an unknown type;
+    // the schema must let it see one.
+    type: { type: 'string' },
     runId: { type: 'string' },
     tool: { type: 'string' },
     durationMs: { type: 'number' },

package/src/contracts/schemas.test.js

@@ -250,3 +250,18 @@ test('capability status contract carries dynamic pending inputs without prescrib
   assert.equal(validateContract('capabilityStatus', status).ok, true);
   assert.equal(validateContract('capabilityStatus', { ...status, pendingInputs: [{ type: 'file' }] }).ok, false);
 });
+
+test('the runtime event contract tolerates a type this version does not know', () => {
+  // A newer gateway emits types this manager has never heard of. A closed enum
+  // made `normalizeRuntimeEvent` throw before the adapter could journal it, so
+  // the whole activity contract was silently invisible. The schema must let an
+  // unknown type through; deciding what to do with it belongs to the adapter.
+  for (const type of ['phase_started', 'progress', 'heartbeat', 'finding', 'degraded', 'notice', 'stream_epoch', 'a_future_type']) {
+    assert.equal(
+      validateContract('runtimeEvent', { type, runId: 'r1' }).ok,
+      true,
+      `${type} must be accepted`,
+    );
+  }
+  assert.equal(validateContract('runtimeEvent', { runId: 'r1' }).ok, false, 'a missing type is still refused');
+});

package/src/core/agentEvents.js

@@ -231,6 +231,10 @@ function createProjectionState() {
     agents: {},
     summary: null,
     status: 'idle',
+    // Liveness from the external runtime's heartbeat (lot 2). Display-only:
+    // never persisted, never in the conversation.
+    lastHeartbeatAt: null,
+    lastHeartbeatElapsedMs: 0,
   };
 }
 
@@ -263,6 +267,8 @@ function publicProjection(state) {
       .sort((a, b) => a.agentInstanceId.localeCompare(b.agentInstanceId)),
     summary: state.summary,
     status: state.status,
+    lastHeartbeatAt: state.lastHeartbeatAt ?? null,
+    lastHeartbeatElapsedMs: state.lastHeartbeatElapsedMs ?? 0,
   };
   return {
     ...projection,
@@ -292,6 +298,21 @@ export function applyAgentProjectionToSession(session, projection) {
   } : session.productionActivity ?? null;
 }
 
+/**
+ * Clears the `pending_approval` latch once no approval is outstanding.
+ *
+ * Called after EVERY approval decision, granted or rejected. Only `granted`
+ * used to clear it, so a refusal left the projection reporting
+ * `pending_approval` for the rest of the run: both UIs kept asking for a
+ * decision already made, while `explainControlState` found nothing pending and
+ * answered "run is active". One function so the two verdicts cannot drift.
+ */
+function releaseApprovalLatch(state) {
+  if (state.status !== 'pending_approval') return;
+  if ((state.approvals ?? []).some((approval) => approval.status === 'pending_approval')) return;
+  state.status = 'running';
+}
+
 function hasRunningPlanStep(state) {
   return (Array.isArray(state.plan) ? state.plan : [])
     .some((step) => isActive(step?.status));
@@ -318,8 +339,17 @@ function applyEvent(state, event) {
       state.planPatches = [];
       state.summary = null;
       state.subagents = [];
+      state.lastHeartbeatAt = null;
+      state.lastHeartbeatElapsedMs = 0;
       pruneTerminalControlItems(state.controlQueue);
       return;
+    case 'runtime_heartbeat':
+      // Liveness only: the external runtime saying "still working" during a
+      // long, tool-less phase. A timestamp the run strip reads; never a
+      // conversation entry, never persisted (store.js NON_PERSISTED_EVENT_TYPES).
+      state.lastHeartbeatAt = event.ts ?? new Date().toISOString();
+      state.lastHeartbeatElapsedMs = Number(event.payload?.elapsedMs) || 0;
+      return;
     case 'user_message':
       state.conversation.push({ role: 'user', content: String(event.payload?.content ?? '') });
       return;
@@ -450,6 +480,15 @@ function applyEvent(state, event) {
     case 'task.failed':
       appendLog(state, taskLogLine(state, event, 'failed'));
       return;
+    // Stable business facts: a workspace's knowledge changed. They are
+    // published for the proactive scheduler and shown as one journal line.
+    case 'knowledge.ingested':
+    case 'knowledge.rebuilt': {
+      const workspace = String(event.payload?.workspace ?? 'workspace');
+      const version = String(event.payload?.sourceVersion ?? 'unknown version');
+      appendLog(state, `${logTime(event.ts)} ${event.type} — ${workspace} (${version})`.trim());
+      return;
+    }
     case 'plan.revision_changed':
       if (Array.isArray(event.payload?.tasks)) {
         state.plan = normalizePlan(event.payload.tasks, { owner: 'orchestrator', planRevision: state.planRevision });
@@ -629,13 +668,7 @@ function applyEvent(state, event) {
       };
       upsertApproval(state, grant);
       markCoveredApprovalsApproved(state.approvals, grant, event.ts);
-      // The decision is in: the run goes back to running unless another
-      // approval is still outstanding (a run-scoped grant clears its covered
-      // ones, markCoveredApprovalsApproved above).
-      if (state.status === 'pending_approval'
-        && !(state.approvals ?? []).some((approval) => approval.status === 'pending_approval')) {
-        state.status = 'running';
-      }
+      releaseApprovalLatch(state);
       return;
     }
     case 'approval.rejected':
@@ -654,6 +687,7 @@ function applyEvent(state, event) {
         reason: event.payload?.reason ?? null,
         rejectedAt: event.ts,
       });
+      releaseApprovalLatch(state);
       return;
     case 'run_done':
       state.status = 'done';
@@ -720,6 +754,10 @@ function applyEvent(state, event) {
           : {}),
         ...(event.payload?.selectionKind ? { selectionKind: event.payload.selectionKind } : {}),
         ...(Number.isInteger(event.payload?.chainSequence) ? { chainSequence: event.payload.chainSequence } : {}),
+        // A proactive review's identity must survive projection and replay: the
+        // drain hands it back to the run it starts, which is what lets the
+        // result be filed as a review rather than lost as an anonymous audit.
+        ...(event.payload?.proactiveReview ? { proactiveReview: event.payload.proactiveReview } : {}),
         optional: event.payload?.optional === true,
         continueOnFailure: event.payload?.continueOnFailure === true,
       });

package/src/core/agentEvents.test.js

@@ -151,6 +151,31 @@ test('reduceAgentEvents: granting the approval puts the run back to running', ()
   assert.equal(projection.status, 'running');
 });
 
+test('reduceAgentEvents: REJECTING the approval also puts the run back to running', () => {
+  // A refusal is a decision. Only `granted` cleared the latch, so a rejected
+  // approval left both UIs asking for a decision already made, for the rest of
+  // the run.
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime' }),
+    createAgentEvent('plan_set', { origin: 'tool', payload: { steps: ['Rebuild the concepts'] } }),
+    createAgentEvent('plan_step_updated', { origin: 'runtime', payload: { step: 1, status: 'waiting_approval' } }),
+    createAgentEvent('approval.requested', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't1' } }),
+    createAgentEvent('approval.rejected', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't1' } }),
+  ]);
+  assert.equal(projection.status, 'running');
+});
+
+test('reduceAgentEvents: rejecting one of two approvals keeps the run blocked', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime' }),
+    createAgentEvent('plan_set', { origin: 'tool', payload: { steps: ['Export', 'Build'] } }),
+    createAgentEvent('approval.requested', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't1' } }),
+    createAgentEvent('approval.requested', { origin: 'runtime', payload: { id: 'a2', scope: 'task', taskId: 't2' } }),
+    createAgentEvent('approval.rejected', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't1' } }),
+  ]);
+  assert.equal(projection.status, 'pending_approval');
+});
+
 test('reduceAgentEvents: an approval request does not hide a genuinely running task', () => {
   const projection = reduceAgentEvents([
     createAgentEvent('run_started', { origin: 'runtime' }),
@@ -874,3 +899,43 @@ test('subagent_started/finished track the collective timeline, reset per run', (
   dispatchAgentEvent(session, createAgentEvent('run_started', { origin: 'runtime', runId: 'r2', payload: {} }));
   assert.equal(session.agentProjection.subagents.length, 0, 'a new run starts a fresh timeline');
 });
+
+test('a runtime heartbeat sets liveness only, and a new run clears it', () => {
+  const session = {};
+  dispatchAgentEvent(session, createAgentEvent('run_started', { origin: 'runtime', runId: 'r1', payload: {} }));
+  dispatchAgentEvent(session, createAgentEvent('runtime_heartbeat', {
+    origin: 'runtime_provider', runId: 'r1', payload: { elapsedMs: 30_000 },
+  }));
+
+  assert.ok(session.agentProjection.lastHeartbeatAt, 'the beat is visible to the strip');
+  assert.equal(session.agentProjection.lastHeartbeatElapsedMs, 30_000);
+  // A heartbeat is not an event the conversation projection can seed from.
+  assert.equal(session.agentProjection.conversation.length, 0);
+
+  dispatchAgentEvent(session, createAgentEvent('run_started', { origin: 'runtime', runId: 'r2', payload: {} }));
+  assert.equal(session.agentProjection.lastHeartbeatAt, null, 'a new run starts with no stale beat');
+});
+
+test('a queued control item keeps its proactive-review marker across projection', () => {
+  const session = {};
+  const marker = { id: 'review-1', workspace: 'docs', trigger: 'knowledge.ingested', sourceVersion: 'v1' };
+  dispatchAgentEvent(session, createAgentEvent('control_enqueued', {
+    origin: 'runtime',
+    workspace: 'docs',
+    payload: { id: 'control-1', workspace: 'docs', input: 'audit the workspace', proactiveReview: marker },
+  }));
+
+  assert.deepEqual(session.agentProjection.controlQueue[0].proactiveReview, marker);
+});
+
+test('streamed deltas are replaced by the final message, never duplicated', () => {
+  const session = {};
+  dispatchAgentEvent(session, createAgentEvent('assistant_delta', { origin: 'runtime', payload: { delta: 'Hello ' } }));
+  dispatchAgentEvent(session, createAgentEvent('assistant_delta', { origin: 'runtime', payload: { delta: 'world' } }));
+  assert.equal(session.agentProjection.conversation.at(-1).content, 'Hello world');
+
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', { origin: 'runtime', payload: { content: 'Hello world' } }));
+  assert.equal(session.agentProjection.conversation.length, 1, 'the final message replaces the streamed one');
+  assert.equal(session.agentProjection.conversation[0].content, 'Hello world');
+  assert.ok(!session.agentProjection.conversation[0].streaming);
+});

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.97",
-  "commit": "b90e735"
+  "version": "0.15.99",
+  "commit": "8a91b62"
 }

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.15.97';
+const WIKI_MANAGER_VERSION = '0.15.99';
 
 function envValue(key) {
   const filePath = managerEnvFile();