@dotdrelle/wiki-manager 0.15.93 → 0.15.96

package/src/commands/slash.js

@@ -109,6 +109,26 @@ export function compactBaseUrl(value) {
   }
 }
 
+/*
+ The web UI URL `/openui` opens. The runtime sets the `wiki_session` cookie on
+ its own origin when the ShellUI logs in, and cookies ignore the port, so we
+ reuse the runtime's loopback hostname: serve on that same host then validates
+ the shared session instead of asking for a second TOTP code. A non-loopback
+ runtime (remote deployment) shares no cookie with the local browser, so we
+ keep the plain `localhost` URL there — behaving exactly as before.
+*/
+export function webUiUrl(port, runtimeUrl) {
+  let runtimeHost = null;
+  try {
+    if (runtimeUrl) runtimeHost = new URL(runtimeUrl).hostname || null;
+  } catch {
+    runtimeHost = null;
+  }
+  const loopback = runtimeHost === 'localhost' || runtimeHost === '::1' || /^127\./.test(runtimeHost ?? '');
+  const host = loopback ? runtimeHost : 'localhost';
+  return `http://${host}:${port}`;
+}
+
 function commandLabel(value) {
   return `${styles.bold}${styles.cyan}${value}${styles.reset}`;
 }
@@ -726,8 +746,8 @@ async function statusText(session) {
   const runtimesColumn = runtimeProvidersSection(session);
   const stats = workspaceStatsColumns(workspaceStats, session);
 
-  const wikiColumnAll = [workspaceColumn, stats.wiki, runtimeColumn].filter(Boolean).join('\n\n');
-  const configColumnAll = [configColumn, stats.tuning, mcpColumn, runtimesColumn].filter(Boolean).join('\n\n');
+  const wikiColumnAll = [workspaceColumn, stats.wiki, runtimeColumn, mcpColumn].filter(Boolean).join('\n\n');
+  const configColumnAll = [configColumn, stats.tuning, runtimesColumn].filter(Boolean).join('\n\n');
 
   // Leading/trailing blank row so the boxed pair doesn't butt directly against
   // the pane border when the view is scrolled to show the tail. It is padding,
@@ -1734,9 +1754,23 @@ export async function handleSlashCommand(line, context) {
     }
     case 'openui': {
       const port = context.session.workspaceEnv?.WIKI_SERVE_PORT ?? '3100';
-      const url = `http://localhost:${port}`;
+      const url = webUiUrl(port, context.runtime?.url ?? context.session?.runtime?.url ?? null);
+      // Hand the ShellUI session to the browser so serve opens without a second
+      // TOTP code: the token rides in the URL fragment (never sent to the
+      // server, so it stays out of logs), and serve's login page exchanges it
+      // for its cookie on load. Open `/login` directly rather than the root so
+      // the fragment never has to survive a redirect. The printed line never
+      // carries the token.
+      let openUrl = url;
+      try {
+        const { currentSessionToken } = await import('../runtime/loginSession.js');
+        const token = currentSessionToken();
+        if (token) openUrl = `${url}/login#t=${encodeURIComponent(token)}`;
+      } catch {
+        // No readable session (gate off, or a custom state dir): plain URL.
+      }
       const note = context.session.workspaceEnv ? '' : ' (no workspace loaded — using default port)';
-      if (openExternalUrl(url)) return { output: `Opening web UI: ${url}${note}` };
+      if (openExternalUrl(openUrl)) return { output: `Opening web UI: ${url}${note}` };
       return { output: `Web UI: ${url}${note}` };
     }
     case 'clear': {

package/src/commands/slash.test.js

@@ -4,7 +4,7 @@ import { mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
-import { agentConcurrencySections, compactBaseUrl, compactMcpStatus, handleSlashCommand, localizedOperationResult, refreshMcpRuntimeStatus } from './slash.js';
+import { agentConcurrencySections, compactBaseUrl, compactMcpStatus, handleSlashCommand, localizedOperationResult, refreshMcpRuntimeStatus, webUiUrl } from './slash.js';
 import { completionContext } from '../shell/repl.js';
 
 test('deterministic operation results ask Donna to localize compact facts without leaking commands', () => {
@@ -52,6 +52,16 @@ test('/status base URL displays only its domain while retaining the full link',
   assert.equal(compactBaseUrl(undefined), '-');
 });
 
+test('/openui reuses the loopback runtime host so serve shares the TOTP session', () => {
+  // The runtime sets wiki_session on its own origin and cookies ignore the
+  // port: opening serve on the same host avoids a second login. Non-loopback
+  // runtimes share no cookie, so the plain localhost URL stays.
+  assert.equal(webUiUrl('3200', 'http://127.0.0.1:7788'), 'http://127.0.0.1:3200');
+  assert.equal(webUiUrl('3200', 'http://localhost:7788'), 'http://localhost:3200');
+  assert.equal(webUiUrl('3200', null), 'http://localhost:3200');
+  assert.equal(webUiUrl('3200', 'https://manager.example.com'), 'http://localhost:3200');
+});
+
 test('/status replaces Internal and Hints with effective agent concurrency', () => {
   const sections = agentConcurrencySections({
     agentRegistrySnapshot: [

package/src/core/agentEvents.js

@@ -1,4 +1,5 @@
 import { normalizeActivity } from './activity.js';
+import { cloneJson } from './json.js';
 import { attachActivityToExistingPlan, syncActivitiesToPlan } from './plan.js';
 import { applyPlanPatch, normalizePlanPatch, normalizePlanRevision, rebasePlanPatch } from './planPatch.js';
 import { formatRuntimeLogPayload, isDispatchPlumbingLine, normalizeRuntimeLog, shortTaskLabel } from './runtimeLog.js';
@@ -215,6 +216,8 @@ export function conversationEventSequences(events = []) {
 function createProjectionState() {
   return {
     conversation: [],
+    conversationSeedStart: 0,
+    conversationSummary: null,
     chain: [],
     plan: null,
     activities: {},
@@ -234,6 +237,8 @@ function createProjectionState() {
 function publicProjection(state) {
   const projection = {
     conversation: state.conversation.map((message) => ({ ...message })),
+    conversationSeedStart: state.conversationSeedStart ?? 0,
+    conversationSummary: state.conversationSummary ?? null,
     chain: state.chain.map((step) => ({ ...step })),
     plan: state.plan ? state.plan.map((step) => ({ ...step })) : null,
     activities: sortedActivities(state.activities).map((activity) => ({ ...activity })),
@@ -313,6 +318,25 @@ function applyEvent(state, event) {
     case 'user_message':
       state.conversation.push({ role: 'user', content: String(event.payload?.content ?? '') });
       return;
+    case 'conversation_reset':
+      // A deliberate user action (the served chat's memory gauge): everything
+      // said before this point stops feeding conversationSeed's LLM context,
+      // WITHOUT touching the displayed conversation — the thread stays visible
+      // everywhere (ShellUI and serve), only what Donna is told going forward
+      // is reset. Nothing is removed from the event log. Marking the boundary
+      // (length at reset time) instead of clearing state.conversation is what
+      // keeps the two concerns apart: the gauge/seed read conversationSeedStart,
+      // the display reads conversation.
+      state.conversationSeedStart = state.conversation.length;
+      // The summary is best-effort (an LLM call the compact route makes before
+      // dispatching this event): when it succeeds it REPLACES the previous one
+      // — it is a rolling summary of "everything before this point", not an
+      // accumulating log — and when it fails or is skipped (no LLM configured)
+      // the previous summary survives rather than being wiped by an empty one.
+      if (typeof event.payload?.summary === 'string' && event.payload.summary.trim()) {
+        state.conversationSummary = event.payload.summary.trim();
+      }
+      return;
     case 'assistant_message':
       finalizeAssistantMessage(state, String(event.payload?.content ?? ''));
       return;
@@ -1217,6 +1241,3 @@ function sortedActivities(activities) {
     .sort((a, b) => String(a.updatedAt ?? '').localeCompare(String(b.updatedAt ?? '')));
 }
 
-function cloneJson(value) {
-  return value == null ? value : JSON.parse(JSON.stringify(value));
-}

package/src/core/agentEvents.test.js

@@ -39,6 +39,43 @@ test('a streamed reply keeps the sequence of the delta that created it', () => {
   assert.deepEqual(conversationEventSequences(events), [1, 2]);
 });
 
+test('conversation_reset marks a seed boundary and keeps the displayed thread', () => {
+  const events = sequenced([
+    createAgentEvent('user_message', { origin: 'user', payload: { content: 'avant' } }),
+    createAgentEvent('assistant_message', { origin: 'runtime', payload: { content: 'réponse avant' } }),
+    createAgentEvent('conversation_reset', { origin: 'user', payload: {} }),
+    createAgentEvent('user_message', { origin: 'user', payload: { content: 'après' } }),
+  ]);
+
+  const projection = reduceAgentEvents(events);
+  // The thread stays whole — compacting must not erase what the reader sees…
+  assert.deepEqual(projection.conversation.map((message) => message.content), ['avant', 'réponse avant', 'après']);
+  // …only the grounding boundary moves.
+  assert.equal(projection.conversationSeedStart, 2);
+});
+
+test('conversation_reset stores the summary it carries and keeps it through a later compact with none', () => {
+  const events = sequenced([
+    createAgentEvent('user_message', { origin: 'user', payload: { content: 'avant' } }),
+    createAgentEvent('conversation_reset', { origin: 'user', payload: { summary: 'Résumé 1' } }),
+    createAgentEvent('user_message', { origin: 'user', payload: { content: 'entre' } }),
+    // A summary is best-effort (an LLM call): a compact with no summary (LLM
+    // unavailable, or nothing worth summarizing) must not erase the last one.
+    createAgentEvent('conversation_reset', { origin: 'user', payload: {} }),
+  ]);
+  const projection = reduceAgentEvents(events);
+  assert.equal(projection.conversationSummary, 'Résumé 1');
+});
+
+test('a later compact with a new summary replaces the previous one', () => {
+  const events = sequenced([
+    createAgentEvent('conversation_reset', { origin: 'user', payload: { summary: 'Résumé 1' } }),
+    createAgentEvent('conversation_reset', { origin: 'user', payload: { summary: 'Résumé 2' } }),
+  ]);
+  const projection = reduceAgentEvents(events);
+  assert.equal(projection.conversationSummary, 'Résumé 2');
+});
+
 test('an independent queued skill invocation never inherits the active run identity', () => {
   const session = {
     workspace: 'docs',

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.93",
-  "commit": "c83cc8e"
+  "version": "0.15.96",
+  "commit": "fbeddf2"
 }

package/src/core/dockerCompose.test.js

@@ -27,6 +27,20 @@ test('workspace production agent enables restore by default', async () => {
   assert.match(String(allowed), /(?:^|,)restore(?:,|})/);
 });
 
+test('the manager allowlist carries the new knowledge steps, not only the agent default', async () => {
+  // This env OVERRIDES agent-production's own default: a value missing
+  // ingest_rebuild/lint silently filters knowledge.rebuild/knowledge.check out
+  // of agent_describe (the capability is published only if one of its steps
+  // survives). That is exactly what made the wiki-row rebuild button run a
+  // plain ingest from raw/untracked instead of re-filing raw/ingested.
+  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
+  const compose = YAML.parse(raw);
+  const allowed = String(compose.services['production-mcp'].environment
+    .find((entry) => String(entry).startsWith('PRODUCTION_ALLOWED_STEPS=')));
+  assert.match(allowed, /(?:^|,)ingest_rebuild(?:,|})/);
+  assert.match(allowed, /(?:^|,)lint(?:,|})/);
+});
+
 test('the shipped default carries no step the engine retired in 0.15.66', async () => {
   /*
    0.15.66 a retiré du moteur llm-wiki les commandes `wiki concepts`,

package/src/core/googleGrants.js

@@ -33,6 +33,3 @@ export function defaultGoogleGrants() {
   return [...GOOGLE_GRANTS];
 }
 
-export function describeGoogleGrant(grant) {
-  return GOOGLE_GRANT_LABELS[grant] ?? null;
-}

package/src/core/json.js

@@ -0,0 +1,9 @@
+/*
+ * Deep clone via a JSON round-trip; `null`/`undefined` pass through.
+ *
+ * Three modules had grown their own byte-identical copy (agentEvents,
+ * agentRegistry, planValidator). One implementation, imported.
+ */
+export function cloneJson(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}

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.93';
+const WIKI_MANAGER_VERSION = '0.15.96';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/plan.js

@@ -48,10 +48,6 @@ export function extractHeadlessPlan(text) {
   return steps;
 }
 
-export function matchCompletedToPlan(plan, completed) {
-  if (!plan) return;
-  syncActivitiesToPlan(plan, completed.filter((activity) => activity.terminal));
-}
 
 export function syncActivitiesToPlan(plan, activities) {
   if (!plan) return;

package/src/core/progressNotes.js

@@ -48,7 +48,3 @@ export function toolResultNote(name, ok, detail) {
   return reason ? `${tool} done: ${reason}` : `${tool} done.`;
 }
 
-export function turnDoneNote(steps) {
-  if (!steps) return 'Done.';
-  return `Done — ${steps} step${steps > 1 ? 's' : ''}.`;
-}

package/src/core/skillChainView.js

@@ -7,6 +7,8 @@
  * which is why the shaping lives here and not in either renderer.
  */
 
+import { TERMINAL_STATUS_SET } from '../orchestrator/taskStatuses.js';
+
 const SYMBOLS = {
   done: '✓',
   running: '●',
@@ -29,7 +31,7 @@ export function selectionKindLabel(selectionKind) {
   return SELECTION_KIND_LABELS[selectionKind] ?? selectionKind ?? null;
 }
 
-export const TERMINAL = new Set(['done', 'failed', 'cancelled', 'skipped']);
+export const TERMINAL = TERMINAL_STATUS_SET;
 
 // Objectives are whole paragraphs; a chain view needs a line. Keep the first
 // sentence, drop the parameter block the compiler appends, and never cut a word

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 };
+  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 };
   // 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
@@ -47,6 +47,26 @@ test('every shipped scaffold skill compiles to a single intention, deterministic
   }
 });
 
+test('the shipped wiki-rebuild skill resolves through the deterministic alias path only', async () => {
+  // The objective resolver's fast path fires only when EXACTLY ONE capability
+  // alias phrase matches the objective. Bare words other agents alias ('build',
+  // 'rebuild', 'ingest', 'check', 'export'…) would make the LLM resolver decide
+  // instead. The shipped body is worded to stay on the deterministic path: it
+  // must carry the agent-production knowledge.rebuild alias phrase and none of
+  // the colliding words — verified against the alias lists actually shipped in
+  // agent-production (knowledge.rebuild / knowledge.check) and the other
+  // agents (cme: 'export sources'…, gateway: 'check'…).
+  const raw = readFileSync(resolve('../llm-wiki/scaffold/workspace/.wiki/skills', 'wiki-rebuild.md'), 'utf8');
+  const { body } = parseFrontmatter(raw);
+  const objectives = await compileSkillObjectives({ body }, {});
+  assert.equal(objectives.length, 1);
+  const text = objectives[0].text;
+  assert.match(text, /file the archived sources/i);
+  for (const word of ['ingest', 'build', 'rebuild', 'export', 'publish', 'okf', 'frontmatter', 'diagnose', 'restore', 'pipeline', 'check', 'audit', 'review', 'analyze', 'compare']) {
+    assert.doesNotMatch(text, new RegExp(`\\b${word}\\b`, 'i'), `word "${word}" must not appear in the objective`);
+  }
+});
+
 test('every orchestrated scaffold skill declares the capability it targets', () => {
   // Without a declaration the capability is inferred from the body's prose by
   // alias matching, which any runtime added to agent-runtimes.json can break by

package/src/core/toolLoop.js

@@ -38,7 +38,15 @@ export async function runBoundedToolLoop({
   // livre le texte au fil de l'eau. Sans lui, la réponse finale n'apparaissait
   // qu'une fois complète — le tour paraissait figé pendant toute sa durée.
   const canStream = typeof onTextDelta === 'function' && typeof llm?.streamWithTools === 'function';
+  // The exact same tool + arguments called again is a loop, not progress: a
+  // model that keeps re-issuing `search("x")` will never finish, and burning
+  // the whole iteration cap on it only produced "could not finish". Track the
+  // signatures and stop as soon as a turn repeats one already executed.
+  const seen = new Set();
+  const signature = (call) => `${call?.function?.name ?? ''}\u0000${String(call?.function?.arguments ?? '')}`;
+  let iterations = 0;
   for (let i = 0; i < cap; i += 1) {
+    iterations = i + 1;
     onStep?.(i + 1, cap);
     let streamedText = false;
     const result = canStream
@@ -62,10 +70,12 @@ export async function runBoundedToolLoop({
     if (calls.length === 0) {
       return {
         content: result?.content ?? result?.message?.content ?? '',
-        iterations: i + 1,
+        iterations,
         capped: false,
       };
     }
+    if (calls.every((call) => seen.has(signature(call)))) break;
+    for (const call of calls) seen.add(signature(call));
     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.
@@ -77,5 +87,49 @@ export async function runBoundedToolLoop({
       convo.push({ role: 'tool', tool_call_id: outcome.tool_call_id, content: outcome.content });
     }
   }
-  return { content: '', iterations: cap, capped: true };
+  // Cap reached or a loop detected: ask once more WITHOUT tools for the best
+  // answer the results gathered so far support. Returning '' here is what made
+  // a long search end in a dead-end instead of the partial answer it had
+  // already collected.
+  const content = await finalAnswerWithoutTools({ llm, system, convo, canStream, onTextDelta, onTextReset, signal });
+  return { content, iterations, capped: true };
+}
+
+async function finalAnswerWithoutTools({
+  llm,
+  system,
+  convo,
+  canStream,
+  onTextDelta,
+  onTextReset,
+  signal,
+}) {
+  try {
+    if (canStream) {
+      let text = '';
+      const result = await llm.streamWithTools({
+        system,
+        tools: [],
+        messages: convo,
+        toolChoice: 'auto',
+        onTextDelta: (delta) => { text += delta; onTextDelta(delta); },
+        signal,
+      });
+      // A tool call despite the empty toolset is not an answer: drop whatever
+      // it streamed and let the caller fall back to its own message.
+      if (result?.tool_calls?.length) { onTextReset?.(); return ''; }
+      return String(result?.content ?? text ?? '').trim();
+    }
+    const result = await llm.completeWithTools({
+      system,
+      tools: [],
+      messages: convo,
+      toolChoice: 'auto',
+      signal,
+    });
+    if (result?.tool_calls?.length) return '';
+    return String(result?.content ?? result?.message?.content ?? '').trim();
+  } catch {
+    return '';
+  }
 }

package/src/core/toolLoop.test.js

@@ -61,16 +61,47 @@ test('runs concurrent tool calls and replays results in call order', async () =>
   assert.deepEqual(order, ['a', 'b']); // preserved model call order
 });
 
-test('reports capped when the model keeps calling tools past the cap', async () => {
+test('stops on a repeated identical tool call instead of burning the cap', async () => {
   const llm = {
-    async completeWithTools() {
+    async completeWithTools({ tools }) {
+      if (tools.length === 0) return { content: 'Synthèse des résultats.', tool_calls: [] };
       const calls = [toolCall('x', 's__status')];
       return { message: { role: 'assistant', content: '', tool_calls: calls }, tool_calls: calls };
     },
   };
-  const out = await runBoundedToolLoop({ llm, tools: [], executeCall: async () => 'r', maxIterations: 3 });
+  const out = await runBoundedToolLoop({
+    llm,
+    tools: [{ function: { name: 's__status' } }],
+    executeCall: async () => 'r',
+    maxIterations: 8,
+  });
+  assert.equal(out.capped, true);
+  // The same call twice is a loop: it stopped well before the cap.
+  assert.ok(out.iterations < 8, `expected an early stop, got ${out.iterations}`);
+  // And the turn still answers from what it gathered instead of a dead-end.
+  assert.equal(out.content, 'Synthèse des résultats.');
+});
+
+test('answers from the gathered results when the cap is reached', async () => {
+  let round = 0;
+  const llm = {
+    async completeWithTools({ tools }) {
+      round += 1;
+      if (round <= 2 && tools.length > 0) {
+        const calls = [toolCall('x', 's__search', `{"q":"${round}"}`)];
+        return { message: { role: 'assistant', content: '', tool_calls: calls }, tool_calls: calls };
+      }
+      return { content: "Voici ce que j'ai trouvé.", tool_calls: [] };
+    },
+  };
+  const out = await runBoundedToolLoop({
+    llm,
+    tools: [{ function: { name: 's__search' } }],
+    executeCall: async () => 'r',
+    maxIterations: 2,
+  });
   assert.equal(out.capped, true);
-  assert.equal(out.iterations, 3);
+  assert.equal(out.content, "Voici ce que j'ai trouvé.");
 });
 
 test('propagates an abort thrown by executeCall', async () => {

package/src/orchestrator/agentRegistry.js

@@ -1,5 +1,6 @@
 import { createAgentEvent, dispatchAgentEvent, dispatchRuntimeLog } from '../core/agentEvents.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
+import { cloneJson } from '../core/json.js';
 import { assertContract } from '../contracts/schemas.js';
 
 const AVAILABLE = 'available';
@@ -320,6 +321,3 @@ function cloneAgent(agent) {
   };
 }
 
-function cloneJson(value) {
-  return value == null ? value : JSON.parse(JSON.stringify(value));
-}

package/src/orchestrator/dependencyResolver.js

@@ -174,6 +174,3 @@ function taskId(task) {
   return String(task?.id ?? task?.step);
 }
 
-export function isTerminalTask(task) {
-  return isTerminal(statusOf(task));
-}

package/src/orchestrator/objectiveResolver.test.js

@@ -108,6 +108,33 @@ test('resolveObjective resolves an ingest objective deterministically despite no
   assert.equal(result.operation, 'ingest');
 });
 
+test('"rebuild" resolves to knowledge.rebuild, not document.build', async () => {
+  // document.build used to alias "rebuild" too, so the wiki row's rebuild
+  // button ran a template build instead of re-filing the archive. The alias is
+  // unique to knowledge.rebuild now, and the bare /wiki-rebuild invocation must
+  // resolve deterministically (no LLM) to ingest_rebuild.
+  const knowledgeRebuild = makeCapability('knowledge.rebuild', {
+    operations: ['ingest_rebuild'],
+    aliases: ['file the archived sources', 'archived sources into the wiki', 'concept pages from the archive', 'rebuild', 'rebuild concepts'],
+    description: 'Re-file the archived sources into their concept folders.',
+  });
+  const documentBuild = makeCapability('document.build', {
+    operations: ['build'],
+    aliases: ['build', 'generate deliverable'],
+    description: 'Build llm-wiki deliverables from templates.',
+  });
+  const session = sessionWith([
+    provider('production-1', knowledgeRebuild),
+    provider('production-1', documentBuild),
+  ]);
+  session.llm.completeWithTools = async () => {
+    throw new Error('the rebuild alias must resolve without the LLM');
+  };
+  const result = await resolveObjective('/wiki-rebuild', session);
+  assert.equal(result.capability, 'knowledge.rebuild');
+  assert.equal(result.operation, 'ingest_rebuild');
+});
+
 test('resolveObjective resolves diagnose via alias despite the notification "send"', async () => {
   const session = sessionWith([
     provider('production-1', diagnose),

package/src/orchestrator/planValidator.js

@@ -1,4 +1,5 @@
 import { validateContract } from '../contracts/schemas.js';
+import { cloneJson } from '../core/json.js';
 
 const SUPPORTED_CONTRACT_VERSIONS = new Set(['1']);
 const MUTATING_OPERATIONS = new Set([
@@ -529,6 +530,3 @@ function issue(code, message, details = {}) {
   return { code, message, details };
 }
 
-function cloneJson(value) {
-  return value == null ? value : JSON.parse(JSON.stringify(value));
-}

package/src/orchestrator/providers/runtimeProvider.js

@@ -43,20 +43,6 @@ import { assertContract } from '../../contracts/schemas.js';
 
 export const RUNTIME_PROTOCOL_VERSION = '1';
 
-export const RUNTIME_EVENT_TYPES = [
-  'run_created',
-  'run_started',
-  'agent_thinking',
-  'tool_started',
-  'tool_finished',
-  'subagent_started',
-  'subagent_finished',
-  'message',
-  'approval_required',
-  'run_completed',
-  'run_failed',
-  'run_cancelled',
-];
 
 export class RuntimeProviderUnavailableError extends Error {
   constructor(runtime, reason) {

package/src/orchestrator/taskStatuses.js

@@ -28,6 +28,14 @@ export const PENDING_STATUSES_LIST = Object.freeze(['pending', 'pending_approval
 /** En cours : un agent y travaille en ce moment. */
 export const ACTIVE_STATUSES = Object.freeze(['running', 'in_progress', 'started', 'starting']);
 
+/**
+ * Terminal, réduit à ses quatre formes canoniques (les alias sont normalisés
+ * avant comparaison). Les modules qui recopiaient `['done','failed',
+ * 'cancelled','skipped']` dans un `Set` importent celui-ci à la place.
+ */
+export const TERMINAL_STATUSES = Object.freeze(['done', 'failed', 'cancelled', 'skipped']);
+export const TERMINAL_STATUS_SET = new Set(TERMINAL_STATUSES);
+
 const ALIASES = new Map([
   ...SUCCESS_STATUSES.map((status) => [status, 'done']),
   ...FAILURE_STATUSES.map((status) => [status, 'failed']),

package/src/runtime/client.js

@@ -238,19 +238,6 @@ export async function postRuntimeShutdown({
   return response.json();
 }
 
-export async function postRuntimeResume({
-  url = runtimeUrlFromEnv(),
-  token = runtimeToken(),
-  workspace = null,
-} = {}) {
-  const response = await fetch(runtimeEndpoint(url, '/resume', workspace), {
-    method: 'POST',
-    headers: runtimeHeaders(token),
-  });
-  if (!response.ok) throw new Error(`Runtime resume failed: HTTP ${response.status}`);
-  return response.json();
-}
-
 export async function postRuntimeApprove({
   url = runtimeUrlFromEnv(),
   token = runtimeToken(),
@@ -331,6 +318,3 @@ export async function* streamRuntimeEvents({
   }
 }
 
-export function runtimeFetchOptions(token = runtimeToken()) {
-  return { headers: runtimeHeaders(token) };
-}

package/src/runtime/controlDrain.js

@@ -1,10 +1,13 @@
 /**
  * @statuses-vocabulary
  * Control items are queued run requests, not orchestrator tasks. Their
- * terminal vocabulary deliberately includes chain-level `skipped` and is
- * projected by core/agentEvents.js rather than taskStatuses.js.
+ * terminal vocabulary is the same four canonical statuses as a task's
+ * (`TERMINAL_STATUS_SET`), including chain-level `skipped`; the projection is
+ * still done by core/agentEvents.js, this only shares the vocabulary.
  */
-const TERMINAL = new Set(['done', 'failed', 'cancelled', 'skipped']);
+import { TERMINAL_STATUS_SET } from '../orchestrator/taskStatuses.js';
+
+const TERMINAL = TERMINAL_STATUS_SET;
 
 export function reconcileControlQueue(context, { startItem, skipItem } = {}) {
   if (!context?.session || context.running || context.controlDrainActive) return false;