@dotdrelle/wiki-manager 0.15.98 → 0.15.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.98",
+  "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/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/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",
+    "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);
@@ -2193,7 +2197,7 @@ export function createAgentGraph(options = {}) {
         tool_call_id: call.id,
         content: boundedResult,
       });
-      if (terminalFailure || skillLaunch) break;
+      if (terminalFailure || skillLaunch) { stoppedAt = callIndex + 1; break; }
     }
 
     // A skill launch owns execution and ends the turn, so the rest of the
@@ -2203,8 +2207,7 @@ export function createAgentGraph(options = {}) {
     // that sees tool_calls without matching results on a replayed history
     // rejects the conversation.
     if (skillLaunch) {
-      const executed = new Set(toolResultMessages.map((message) => message.tool_call_id));
-      const dropped = toolCalls.filter((call) => !executed.has(call.id));
+      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) {

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,17 +687,7 @@ function applyEvent(state, event) {
         reason: event.payload?.reason ?? null,
         rejectedAt: event.ts,
       });
-      // Same latch release as `approval.granted`: a refusal IS a decision. Only
-      // `granted` cleared the status, so a rejected approval left the
-      // projection reporting `pending_approval` for the rest of the run —
-      // both UIs kept asking for a decision the user had already made, while
-      // `explainControlState` found no pending approval and answered "run is
-      // active". The two surfaces disagreed until some later run_done
-      // overwrote it.
-      if (state.status === 'pending_approval'
-        && !(state.approvals ?? []).some((approval) => approval.status === 'pending_approval')) {
-        state.status = 'running';
-      }
+      releaseApprovalLatch(state);
       return;
     case 'run_done':
       state.status = 'done';
@@ -731,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

@@ -899,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.98",
-  "commit": "acf1986"
+  "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.98';
+const WIKI_MANAGER_VERSION = '0.15.99';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/runtimeEventAdapter.js

@@ -23,6 +23,19 @@ export function mapRuntimeEvent(event) {
       const content = String(event?.content ?? event?.message ?? '').trim();
       return content ? [{ type: 'assistant_message', payload: { content } }] : [];
     }
+    // Progressive final stream (lot 7). The gateway only streams the MAIN
+    // assembly, never a role, so a delta can only belong to the answer. The
+    // reducer replaces the streamed text with the final `assistant_message`
+    // (finalizeAssistantMessage), so streaming cannot duplicate it.
+    case 'assistant_delta': {
+      const delta = String(event?.delta ?? '');
+      return delta ? [{ type: 'assistant_delta', payload: { delta } }] : [];
+    }
+    // A tool call interrupted the streamed answer: the text so far was
+    // reasoning, not the answer — discard it (the reducer empties, never pops,
+    // the streaming entry).
+    case 'assistant_delta_reset':
+      return [{ type: 'assistant_delta_reset', payload: {} }];
     case 'tool_started':
       return log(`tool ${toolLabel(event)} started`);
     case 'tool_finished': {
@@ -60,17 +73,102 @@ export function mapRuntimeEvent(event) {
         },
       }];
     }
+    // ── Activity (lot 2) ────────────────────────────────────────────────────
+    //
+    // The runtime's phases enrich the EXISTING business activity line; they do
+    // not open a second axis of "phases" beside `projectWorkflow`. That is why
+    // they travel as runtime_log here and are aggregated downstream, rather
+    // than minting a new event type the reducer would have to reconcile.
+    case 'phase_started':
+      return log(`phase ${phaseLabel(event)} started`);
+    case 'phase_finished': {
+      const counters = phaseCounters(event);
+      const outcome = event?.ok === false ? 'interrupted' : 'done';
+      return log(`phase ${phaseLabel(event)} ${outcome}${counters}`);
+    }
+    case 'progress': {
+      const label = String(event?.label ?? event?.phase ?? '').trim();
+      return label ? log(`progress ${label}${phaseCounters(event)}`) : [];
+    }
+    // A heartbeat is liveness, not history: it proves the run is alive to
+    // whoever is watching right now. It travels as its own NON-persisted event
+    // so the run strip can read it, but it never reaches the journal — one
+    // line per beat would bury what actually happened. Persisting is the
+    // store's decision (NON_PERSISTED_EVENT_TYPES); dropping it here would
+    // leave the strip with no liveness signal at all.
+    case 'heartbeat':
+      return [{
+        type: 'runtime_heartbeat',
+        payload: { elapsedMs: Number(event?.elapsedMs) || 0 },
+      }];
+    case 'finding': {
+      const severity = String(event?.severity ?? '').trim();
+      const summary = String(event?.summary ?? '').trim();
+      if (!summary) return [];
+      const path = String(event?.path ?? '').trim();
+      const where = path ? ` at ${path}` : '';
+      return log(`finding${severity ? ` [${severity}]` : ''} from ${String(event?.role ?? 'runtime')}${where}: ${summary}`);
+    }
+    // Maintenance the gateway performed on its own memory (eviction of an
+    // inactive workspace, compaction of a thread). Not a failure — a notice,
+    // so a reader can tell "the agent forgot an old workspace" from "the
+    // agent broke".
+    case 'notice': {
+      const topic = String(event?.topic ?? 'notice').trim();
+      const detail = String(event?.detail ?? '').trim();
+      return log(`notice ${topic}${detail ? `: ${detail}` : ''}`);
+    }
+    // A degradation must announce itself — that is the whole contract. It is
+    // never filtered, whatever else this adapter decides to keep quiet.
+    case 'degraded': {
+      const capability = String(event?.capability ?? 'capability').trim();
+      const cause = String(event?.cause ?? 'unknown cause').trim();
+      const fallback = String(event?.fallback ?? '').trim();
+      return log(`degraded ${capability}: ${cause}${fallback ? ` — ${fallback}` : ''}`);
+    }
     case 'run_started':
     case 'run_created':
     case 'agent_thinking':
     case 'run_completed':
     case 'run_failed':
     case 'run_cancelled':
-    default:
+      // Deliberately silent, and listed BY NAME so the silence is a decision
+      // rather than a default: `agent_thinking` is private reasoning the chat
+      // never shows, and the terminal events are already carried by the
+      // dispatcher's own `status()` poll.
       return [];
+    default:
+      // Everything else is a type this manager does not know — most likely a
+      // newer gateway talking to an older manager. Dropping it made that
+      // version skew invisible: the events simply never arrived, and nothing
+      // said so. One bounded line is the cost of knowing.
+      return log(`unrecognized runtime event "${type || 'unnamed'}"${unknownDetail(event)}`);
   }
 }
 
+function phaseLabel(event) {
+  return String(event?.phase ?? event?.label ?? 'unnamed');
+}
+
+function phaseCounters(event) {
+  const parts = [];
+  const tools = Number(event?.tools);
+  const pages = Number(event?.pages);
+  if (Number.isFinite(tools) && tools > 0) parts.push(`${tools} tool(s)`);
+  if (Number.isFinite(pages) && pages > 0) parts.push(`${pages} page(s) read`);
+  return parts.length > 0 ? ` — ${parts.join(', ')}` : '';
+}
+
+// Bounded on purpose: this is a diagnostic breadcrumb for a version skew, not
+// a channel for an unknown payload to reach the journal whole.
+const UNKNOWN_EVENT_DETAIL_MAX = 200;
+function unknownDetail(event) {
+  const keys = Object.keys(event ?? {})
+    .filter((key) => !['type', 'runId', 'ts', 'sequence'].includes(key));
+  if (keys.length === 0) return '';
+  return ` (fields: ${keys.join(', ')})`.slice(0, UNKNOWN_EVENT_DETAIL_MAX);
+}
+
 function log(message) {
   return [{ type: 'runtime_log', payload: { message } }];
 }

package/src/core/runtimeEventAdapter.test.js

@@ -61,6 +61,96 @@ test('private reasoning and terminal events are never re-emitted', () => {
   assert.deepEqual(mapRuntimeEvent({ type: 'run_cancelled' }), []);
 });
 
-test('an unknown event type produces nothing', () => {
-  assert.deepEqual(mapRuntimeEvent({ type: 'made_up' }), []);
+// (An unknown type used to produce nothing. It now produces one journal line —
+// see "an unknown event type is journalled instead of vanishing" below. The
+// old assertion pinned the silence that hid a version skew.)
+
+// ── Activity events (lot 2) ──────────────────────────────────────────────────
+
+test('phase and progress events enrich the journal with bounded counters', () => {
+  assert.deepEqual(
+    mapRuntimeEvent({ type: 'phase_started', phase: 'discover' }),
+    [{ type: 'runtime_log', payload: { message: 'phase discover started' } }],
+  );
+  const [finished] = mapRuntimeEvent({
+    type: 'phase_finished', phase: 'discover', ok: true, tools: 7, pages: 4,
+  });
+  assert.match(finished.payload.message, /phase discover done — 7 tool\(s\), 4 page\(s\) read/);
+
+  const [interrupted] = mapRuntimeEvent({ type: 'phase_finished', phase: 'critique', ok: false });
+  assert.match(interrupted.payload.message, /phase critique interrupted/);
+});
+
+// A beat proves the run is alive to whoever watches NOW. It still travels — as
+// its own non-persisted event, so the run strip can read it — but one journal
+// line per beat would bury what actually happened under "still alive".
+test('a heartbeat becomes a non-persisted liveness event, not a journal line', () => {
+  assert.deepEqual(
+    mapRuntimeEvent({ type: 'heartbeat', elapsedMs: 30_000 }),
+    [{ type: 'runtime_heartbeat', payload: { elapsedMs: 30_000 } }],
+  );
+});
+
+test('a finding carries its severity, its author and its path', () => {
+  const [entry] = mapRuntimeEvent({
+    type: 'finding',
+    role: 'critique',
+    severity: 'blocking',
+    path: 'wiki/concepts/demo/a.md',
+    summary: 'cites no source',
+  });
+  assert.match(
+    entry.payload.message,
+    /finding \[blocking\] from critique at wiki\/concepts\/demo\/a\.md: cites no source/,
+  );
+});
+
+test('a degradation is never filtered', () => {
+  const [entry] = mapRuntimeEvent({
+    type: 'degraded',
+    capability: 'role:critique',
+    cause: 'model timeout',
+    fallback: 'the run continues without this role',
+  });
+  assert.match(entry.payload.message, /degraded role:critique: model timeout — the run continues/);
+});
+
+/*
+ The version-skew guard. A newer gateway talking to an older manager used to
+ lose EVERY new event here, silently — the adapter ended on `default: return []`.
+ The deliberate silences stay silent, but they are now listed by name, so the
+ difference between "we chose not to show this" and "we did not recognise it"
+ is visible in the journal instead of being the same thing.
+*/
+test('an unknown event type is journalled instead of vanishing', () => {
+  const [entry] = mapRuntimeEvent({ type: 'sub_phase_started', detail: 'x', weight: 2 });
+  assert.equal(entry.type, 'runtime_log');
+  assert.match(entry.payload.message, /unrecognized runtime event "sub_phase_started"/);
+  assert.match(entry.payload.message, /fields: detail, weight/);
+});
+
+test('the deliberate silences stay silent', () => {
+  for (const type of ['agent_thinking', 'run_started', 'run_completed', 'run_failed', 'run_cancelled']) {
+    assert.deepEqual(mapRuntimeEvent({ type }), [], `${type} must stay silent`);
+  }
+});
+
+test('a memory notice is journalled as maintenance, not as a failure', () => {
+  const [entry] = mapRuntimeEvent({
+    type: 'notice', topic: 'memory.evicted', detail: 'old-workspace',
+  });
+  assert.equal(entry.type, 'runtime_log');
+  assert.match(entry.payload.message, /^notice memory\.evicted: old-workspace$/);
+});
+
+test('the final stream maps as deltas, and a reset clears them', () => {
+  assert.deepEqual(
+    mapRuntimeEvent({ type: 'assistant_delta', delta: 'Hi' }),
+    [{ type: 'assistant_delta', payload: { delta: 'Hi' } }],
+  );
+  assert.deepEqual(
+    mapRuntimeEvent({ type: 'assistant_delta_reset' }),
+    [{ type: 'assistant_delta_reset', payload: {} }],
+  );
+  assert.deepEqual(mapRuntimeEvent({ type: 'assistant_delta', delta: '' }), []);
 });

package/src/core/skillCompiler.test.js

@@ -31,7 +31,7 @@ test('validation rejects technical routing details', () => {
 });
 
 test('every shipped scaffold skill compiles to a single intention, deterministically', async () => {
-  const expected = { pipeline: 1, 'wiki-sync': 1, 'wiki-ingest': 1, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1, 'wiki-rebuild': 1 };
+  const expected = { pipeline: 1, 'wiki-sync': 1, 'wiki-ingest': 1, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1, 'wiki-rebuild': 1, curate: 1 };
   // Passing no llmFallback used to make this test assert the one path
   // production never takes: an ambiguous body silently returns the safe
   // mono-intention fallback, so the count was 1 and the test was green while

package/src/core/toolLoop.js

@@ -1,3 +1,5 @@
+import { truncateToolResult } from './mcp.js';
+
 // Minimal, side-effect-free bounded tool-use loop.
 //
 // This is the shared mechanic of "ask the LLM with a tool set, run the tool
@@ -79,9 +81,13 @@ export async function runBoundedToolLoop({
     convo.push(result.message ?? { role: 'assistant', content: result.content ?? '', tool_calls: calls });
     // Tool calls within one turn are independent: dispatch concurrently, then
     // replay results in the model's call order so the transcript stays stable.
+    // Bound what enters the LLM context, exactly like the /agent loop
+    // (graph.js). Without it a wide read — a CME Confluence search at limit 50
+    // can weigh ~35 kB — is re-sent on every iteration (up to the cap), and the
+    // chat answer pays for tokens the model never needed.
     const outcomes = await Promise.all(calls.map(async (call) => ({
       tool_call_id: call.id,
-      content: await executeCall(call),
+      content: truncateToolResult(await executeCall(call)),
     })));
     for (const outcome of outcomes) {
       convo.push({ role: 'tool', tool_call_id: outcome.tool_call_id, content: outcome.content });

package/src/core/toolLoop.test.js

@@ -104,6 +104,34 @@ test('answers from the gathered results when the cap is reached', async () => {
   assert.equal(out.content, "Voici ce que j'ai trouvé.");
 });
 
+test('bounds a wide tool result before it enters the LLM context', async () => {
+  // A CME Confluence search at limit 50 can weigh ~35 kB and would otherwise be
+  // re-sent on every iteration. The /agent loop already truncates at 16 kB
+  // (graph.js); the chat loop must not be the one unbounded path.
+  let round = 0;
+  let toolContent = '';
+  const llm = {
+    async completeWithTools({ messages }) {
+      round += 1;
+      if (round === 1) {
+        const calls = [toolCall('c1', 'cme__cme_confluence_search')];
+        return { message: { role: 'assistant', content: '', tool_calls: calls }, tool_calls: calls };
+      }
+      toolContent = messages.find((m) => m.role === 'tool')?.content ?? '';
+      return { content: 'ok', tool_calls: [] };
+    },
+  };
+  const wide = 'x'.repeat(50000);
+  await runBoundedToolLoop({
+    llm,
+    tools: [{ function: { name: 'cme__cme_confluence_search' } }],
+    executeCall: async () => wide,
+  });
+  assert.ok(toolContent.length < wide.length, 'the result must be bounded');
+  assert.ok(toolContent.length <= 16200, `bounded length was ${toolContent.length}`);
+  assert.match(toolContent, /tronqu/);
+});
+
 test('propagates an abort thrown by executeCall', async () => {
   const llm = {
     async completeWithTools() {

package/src/orchestrator/dispatcher.js

@@ -255,6 +255,7 @@ async function executeExternalRuntime(task, assignment, {
       capability: task.requiredCapability ?? null,
       arguments: task.arguments && typeof task.arguments === 'object' ? task.arguments : {},
       workspace: workspaceRequest(session),
+      memoryScope: memoryScopeRequest(session),
       model: activeProfileModel(session),
       language: session?.language ?? session?.wikircConfig?.language ?? null,
       mcp: mcpPool,
@@ -471,6 +472,24 @@ function executeRequest(task, session, runId, assignment) {
   };
 }
 
+/**
+ * Which past conversation this run resumes, on the external runtime.
+ *
+ * The workspace alone today. The multi-user lot turns this into
+ * `<workspace>:<actorId>` — the shape is already the one the gateway accepts,
+ * so identity lands here and nowhere else. Returning null is legitimate and
+ * silent: the gateway then scopes to the workspace it resolved itself.
+ *
+ * Never a value a caller supplied: the runtime treats the scope as a read
+ * capability and refuses one that leaves its own workspace.
+ */
+function memoryScopeRequest(session) {
+  const actorId = session?._currentRunIdentity?.actorId ?? session?.actorId ?? null;
+  if (!actorId) return null;
+  const workspace = workspaceRequest(session)?.name;
+  return workspace ? `${workspace}:${String(actorId)}` : null;
+}
+
 function workspaceRequest(session) {
   const workspace = session.workspace ?? session._currentRunIdentity?.workspace;
   if (workspace && typeof workspace === 'object' && !Array.isArray(workspace)) return { ...workspace };