@dotdrelle/wiki-manager 0.15.38 → 0.15.40

package/README.md

@@ -771,6 +771,11 @@ capabilityRouting:
     allowedAgents: [connectors]
 ```
 
+The production agent also advertises `workspace.restore` for Git-backed
+rollback. It is workspace-scoped and remains subject to the normal runtime
+approval and lock checks; it can be pinned in the same way when several agents
+provide that capability.
+
 #### Compose overrides — optional agents, proxies, local fixes
 
 Two override files sit under **`.wiki/compose/`**, one per stack:

package/docker-compose.yml

@@ -124,7 +124,7 @@ services:
       - WORKSPACE_NAME=${WORKSPACE_NAME:-workspace}
       - WIKI_WORKSPACE_PATH=/workspace
       - WIKI_CONFIG_PATH=${WIKI_CONFIG_PATH:-}
-      - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,ingest,ingest_plan,ingest_apply,build,export,polish,pipeline}
+      - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,ingest,ingest_plan,ingest_apply,build,export,polish,restore,pipeline}
       - PRODUCTION_REQUIRE_CONFIRMATION=${PRODUCTION_REQUIRE_CONFIRMATION:-false}
       # Parallelism levers — effective concurrency ≈ recommendedConcurrency.
       # Intermediate defaults (4/8). Low profile 2/4, high profile 8/16.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.38",
+  "version": "0.15.40",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/cli/wiki-manager.js

@@ -1231,9 +1231,11 @@ async function runRuntime(argv, agent) {
             ),
             requireApprovalForMutations: body.capabilityPlan.requireApproval !== false,
           },
-          ...(Array.isArray(body.capabilityPlan.inputs) && body.capabilityPlan.inputs.length > 0
-            ? { arguments: { inputs: body.capabilityPlan.inputs } }
-            : {}),
+          ...(body.capabilityPlan.arguments && typeof body.capabilityPlan.arguments === 'object'
+            ? { arguments: body.capabilityPlan.arguments }
+            : Array.isArray(body.capabilityPlan.inputs) && body.capabilityPlan.inputs.length > 0
+              ? { arguments: { inputs: body.capabilityPlan.inputs } }
+              : {}),
         })));
         if (!Array.isArray(fragment?.tasks) || fragment.tasks.length === 0) {
           dispatchAgentEvent(session, createAgentEvent('assistant_message', {

package/src/core/agentEvents.js

@@ -556,6 +556,7 @@ function applyEvent(state, event) {
         status: 'queued',
         createdAt: event.payload?.createdAt ?? event.ts,
         updatedAt: event.ts,
+        ...(event.payload?.capabilityPlan !== undefined ? { capabilityPlan: event.payload.capabilityPlan } : {}),
       });
       return;
     case 'control_started':

package/src/core/agentEvents.test.js

@@ -364,6 +364,38 @@ test('reduceAgentEvents: control queue is event sourced and follows run status',
   assert.equal(projection.controlQueue[1].status, 'cancelled');
 });
 
+test('reduceAgentEvents: control_enqueued preserves a structured capabilityPlan across replay', () => {
+  const capabilityPlan = {
+    capability: 'workspace.restore',
+    operation: 'restore',
+    arguments: { run: 'abc123' },
+    requireApproval: true,
+  };
+  const projection = reduceAgentEvents([
+    createAgentEvent('control_enqueued', {
+      origin: 'runtime',
+      workspace: 'docs',
+      payload: {
+        id: 'control-restore',
+        workspace: 'docs',
+        input: 'restore',
+        createdAt: '2026-01-01T00:00:00.000Z',
+        capabilityPlan,
+      },
+    }),
+    createAgentEvent('control_started', {
+      origin: 'runtime',
+      runId: 'run-control-restore',
+      workspace: 'docs',
+      payload: { id: 'control-restore', runId: 'run-control-restore' },
+    }),
+  ]);
+
+  const item = projection.controlQueue.find((entry) => entry.id === 'control-restore');
+  assert.deepEqual(item.capabilityPlan, capabilityPlan);
+  assert.equal(item.status, 'running');
+});
+
 test('reduceAgentEvents: activity-owned plan is used when no orchestrator plan exists', () => {
   const projection = reduceAgentEvents([
     createAgentEvent('activity_upserted', {

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.38",
-  "commit": "abf8356"
+  "version": "0.15.40",
+  "commit": "49ea8ff"
 }

package/src/core/dockerCompose.test.js

@@ -19,6 +19,14 @@ test('workspace compose does not start a per-workspace agent runtime', async ()
   );
 });
 
+test('workspace production agent enables restore by default', async () => {
+  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
+  const compose = YAML.parse(raw);
+  const allowed = compose.services['production-mcp'].environment
+    .find((entry) => String(entry).startsWith('PRODUCTION_ALLOWED_STEPS='));
+  assert.match(String(allowed), /(?:^|,)restore(?:,|})/);
+});
+
 test('shipped compose files never carry a build context', async () => {
   // Ces deux fichiers partent dans le paquet npm, où les dépôts frères
   // (`../agent-external/…`) n'existent pas : un `build:` y rend toute commande

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

package/src/orchestrator/dispatcher.js

@@ -53,7 +53,7 @@ export async function execute(task, assignment, {
       session.mcp,
       serverName,
       executeTool,
-      executeRequest(task, session),
+      executeRequest(task, session, runId),
       signal,
     ));
     if (accepted?.accepted === false || accepted?.ok === false) {
@@ -157,9 +157,11 @@ export async function execute(task, assignment, {
   }
 }
 
-function executeRequest(task, session) {
+function executeRequest(task, session, runId) {
   return {
     taskId: String(task.id ?? task.step),
+    ...(runId ? { runId: String(runId) } : {}),
+    ...(task.requiredCapability ? { capability: String(task.requiredCapability) } : {}),
     idempotencyKey: task.idempotencyKey ?? undefined,
     operation: task.operation,
     workspace: workspaceRequest(session),

package/src/orchestrator/dispatcher.test.js

@@ -33,6 +33,39 @@ test('dispatcher returns a retryable logical failure when agent_execute reports
   assert.equal(result.error.retryable, true);
 });
 
+test('dispatcher forwards the orchestration run and required capability to agent_execute', async () => {
+  let executeArgs;
+  const session = {
+    workspace: 'test',
+    mcp: {
+      production: {
+        tools: [{ name: 'agent_execute' }, { name: 'agent_status' }, { name: 'agent_cancel' }],
+      },
+    },
+    activities: {},
+  };
+  const dispatcher = createDispatcher({
+    session,
+    pollIntervalMs: 1,
+    callTool: async (_mcp, _server, tool, args) => {
+      if (tool === 'agent_execute') {
+        executeArgs = args;
+        return { accepted: true, jobId: 'job-build', status: 'queued' };
+      }
+      return { jobId: 'job-build', status: 'succeeded', terminal: true, result: { status: 'succeeded' } };
+    },
+  });
+
+  await dispatcher.execute(
+    { id: 'build-a', requiredCapability: 'document.build', operation: 'build', arguments: {} },
+    { serverName: 'production', agentInstanceId: 'production-main' },
+    { runId: 'run-donna-1', attempt: { attemptId: 'build-a:attempt-1', locks: [], release() {} } },
+  );
+
+  assert.equal(executeArgs.runId, 'run-donna-1');
+  assert.equal(executeArgs.capability, 'document.build');
+});
+
 test('dispatcher completes when an executor-only agent reports succeeded', async () => {
   const session = {
     workspace: 'test',

package/src/runtime/server.js

@@ -283,6 +283,27 @@ export function startRuntimeServer({
           }
           validateContractInDev('runRequest', { ...body, input });
           if (context.running) {
+            // A structured capability plan must never degrade into a free-text
+            // control message: its exact arguments and approval policy would
+            // otherwise be discarded by the control lane. It can still be
+            // queued as a future run when the caller explicitly opts in via
+            // intent: 'enqueue' — the control queue carries capabilityPlan
+            // through untouched (see enqueueControlRequest/
+            // startNextControlRequest) instead of collapsing it to text.
+            if (body.capabilityPlan) {
+              if (body.intent === 'enqueue') {
+                const item = enqueueControlRequest(context, input, { capabilityPlan: body.capabilityPlan });
+                void startNextControlRequest(context);
+                sendJson(response, 202, {
+                  accepted: true,
+                  item,
+                  ...controlStatus(context, store),
+                });
+                return;
+              }
+              sendJson(response, 409, { error: 'run_active' });
+              return;
+            }
             // Blind enqueueing made every message typed during a run
             // invisible until the run ended (serve UI symptom: "no result
             // until the job finished or was stopped"). Classify instead:
@@ -630,6 +651,7 @@ export function startRuntimeServer({
     startRuntimeRun(context, {
       input: item.input,
       workspace: item.workspace ?? context.workspace ?? null,
+      ...(item.capabilityPlan !== undefined ? { capabilityPlan: item.capabilityPlan } : {}),
     }, { controlItemId: item.id });
     return true;
   }
@@ -843,7 +865,7 @@ async function handleControlMessage(context, store, input, { intent = null, star
     : controlMessage(context?.session, 'converse_while_idle'));
 }
 
-function enqueueControlRequest(context, input) {
+function enqueueControlRequest(context, input, { capabilityPlan } = {}) {
   const now = new Date().toISOString();
   const item = {
     id: `control-${randomUUID()}`,
@@ -853,6 +875,7 @@ function enqueueControlRequest(context, input) {
     status: 'queued',
     createdAt: now,
     updatedAt: now,
+    ...(capabilityPlan !== undefined ? { capabilityPlan } : {}),
   };
   dispatchAgentEvent(context.session, createAgentEvent('control_enqueued', {
     origin: 'runtime',

package/src/runtime/server.test.js

@@ -347,6 +347,119 @@ test('runtime server accepts only one active run', async (t) => {
   }
 });
 
+test('runtime server rejects a structured capability plan while a run is active', async (t) => {
+  let releaseRun;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      session: {},
+      run: async () => new Promise((resolve) => { releaseRun = resolve; }),
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const url = `http://127.0.0.1:${handle.port}/run`;
+    const first = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'active build' }),
+    });
+    assert.equal(first.status, 202);
+
+    const restore = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        input: 'restore',
+        capabilityPlan: {
+          capability: 'workspace.restore',
+          operation: 'restore',
+          arguments: { run: 'abc123' },
+          requireApproval: true,
+        },
+      }),
+    });
+    assert.equal(restore.status, 409);
+    assert.deepEqual(await restore.json(), { error: 'run_active' });
+  } finally {
+    releaseRun?.();
+    await handle.close();
+  }
+});
+
+test('runtime server queues a structured capability plan when intent is enqueue', async (t) => {
+  let releaseRun;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      session: {},
+      run: async () => new Promise((resolve) => { releaseRun = resolve; }),
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const url = `http://127.0.0.1:${handle.port}/run`;
+    const first = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'active build' }),
+    });
+    assert.equal(first.status, 202);
+
+    const capabilityPlan = {
+      capability: 'workspace.restore',
+      operation: 'restore',
+      arguments: { run: 'abc123' },
+      requireApproval: true,
+    };
+    const restore = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'restore', intent: 'enqueue', capabilityPlan }),
+    });
+    assert.equal(restore.status, 202);
+    const restoreBody = await restore.json();
+    assert.equal(restoreBody.accepted, true);
+    assert.deepEqual(restoreBody.item.capabilityPlan, capabilityPlan);
+    assert.equal(restoreBody.item.status, 'queued');
+
+    const status = await fetch(`http://127.0.0.1:${handle.port}/control`);
+    const statusBody = await status.json();
+    const queued = statusBody.controlQueue.find((item) => item.id === restoreBody.item.id);
+    assert.ok(queued, 'queued item should be visible in control status');
+    assert.deepEqual(queued.capabilityPlan, capabilityPlan);
+  } finally {
+    releaseRun?.();
+    await handle.close();
+  }
+});
+
 test('runtime server returns the accepted run id and passes it to the runner', async (t) => {
   let receivedBody = null;
   let handle;