@dotdrelle/wiki-manager 0.10.4 → 0.11.4

package/README.md

@@ -11,6 +11,12 @@ jobs, and run one-shot headless tasks.
 The manager does not implement the wiki engine or the external agents. It
 **orchestrates** them.
 
+Scope note: 0.11.0 is an industrialized single-user deployment baseline. The
+multi-user model is specified in `llm-wiki/docs/industrialisation.md` and
+planned for 0.12.0. Until then, do not expose the runtime as a shared write
+surface; it binds to `127.0.0.1` by default, and `--host 0.0.0.0` must be an
+explicit deployment choice with bearer-token and network protection.
+
 ---
 
 ## What it's for, in one sentence
@@ -538,6 +544,14 @@ Runtime split: the host manager/runtime uses Node.js 22+ for `node:sqlite`; the
 interactive OpenTUI shell uses Bun 1.2+; workspace Docker services run from the
 published images and do not depend on host `node_modules`.
 
+As of 0.11.4, the host runtime store carries a minimal format guard:
+`PRAGMA user_version = 1` in SQLite plus `.wiki/meta.json` with
+`schemaVersion: 1`. Unknown future versions stop startup with a clear error.
+On startup, terminal runs older than 30 days are deleted with their events and
+the database is vacuumed. The runtime test suite also includes a fixed-latency
+parallel scheduler guard asserting that two independent build tasks run under
+65% of the sequential duration.
+
 ```bash
 wiki-workspace list
 wiki-workspace agents up

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.10.4",
+  "version": "0.11.4",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "start": "bun ./bin/wiki-manager.js",
-    "test": "node --test src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/agentEvents.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/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/commands/slash.test.js src/shell/repl.test.js src/runtime/store.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/runner.test.js src/runtime/auth.test.js",
+    "test": "node --test src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/agentEvents.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/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/commands/slash.test.js src/shell/repl.test.js src/runtime/store.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/auth.test.js",
     "check-versions": "node scripts/check-versions.js",
     "prepack": "node scripts/check-versions.js",
     "prepublishOnly": "node scripts/check-versions.js",

package/src/cli/wiki-manager.js

@@ -281,7 +281,7 @@ async function runRuntime(argv, agent) {
       'Runs the local agentic runtime used by wiki-manager Shell and llm-wiki serve.',
       '',
       'Defaults:',
-      '  --host 0.0.0.0',
+      '  --host 127.0.0.1',
       '  --port 7788',
       '  --state-dir .wiki-manager',
     ].join('\n'));
@@ -295,7 +295,7 @@ async function runRuntime(argv, agent) {
   const { createApprovalManager } = await import('../runtime/approvals.js');
   const { runRuntimeAgenticWorkflow } = await import('../runtime/runner.js');
 
-  const host = valueAfter(argv, '--host') ?? process.env.WIKI_MANAGER_RUNTIME_HOST ?? '0.0.0.0';
+  const host = valueAfter(argv, '--host') ?? process.env.WIKI_MANAGER_RUNTIME_HOST ?? '127.0.0.1';
   const port = Number(valueAfter(argv, '--port') ?? process.env.WIKI_MANAGER_RUNTIME_PORT ?? 7788);
   const stateDir = valueAfter(argv, '--state-dir') ?? defaultRuntimeStateDir();
   const auth = resolveRuntimeAuthToken({ host, stateDir });

package/src/commands/slash.js

@@ -29,7 +29,12 @@ import {
   summarizeWikircConfig,
 } from '../core/wikirc.js';
 import { applySessionWikircProfile } from '../core/sessionConfig.js';
-import { deleteWorkspaceAndFiles, startAgents, stopAgents } from '../core/wikiSetup.js';
+import {
+  deleteWorkspaceAndFiles,
+  finalizeCreatedWorkspace,
+  startAgents,
+  stopAgents,
+} from '../core/wikiSetup.js';
 import {
   cleanDocumentUploads,
   convertPendingDocumentUploads,
@@ -454,6 +459,7 @@ async function createWorkspaceCommand(context, workspaceName, targetPath) {
   try {
     context.onStep?.(`Workspace: creating ${workspaceName}…`);
     const output = await createWorkspace(workspaceName, targetPath, { timeout: 600_000 });
+    finalizeCreatedWorkspace(workspaceName);
     return {
       output: [
         output,

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

package/src/core/wikiSetup.js

@@ -69,14 +69,19 @@ export async function stopAgents(options = {}) {
 export async function createNewWorkspace(name, targetPath) {
   try {
     const output = await createWorkspace(name, targetPath, { timeout: 600_000 });
-    const workspace = findWorkspace(name);
-    if (workspace) initializeWorkspaceWikirc(workspace);
+    const workspace = finalizeCreatedWorkspace(name);
     return { output, workspace };
   } catch (err) {
     throw wrapDockerError(err);
   }
 }
 
+export function finalizeCreatedWorkspace(name) {
+  const workspace = findWorkspace(name);
+  if (workspace) initializeWorkspaceWikirc(workspace);
+  return workspace;
+}
+
 export function initializeWorkspaceWikirc(workspace) {
   const accessKey = workspace?.env?.WIKI_MCP_AUTH_TOKEN;
   if (!workspace?.workspacePath || !accessKey) return null;

package/src/core/wikirc.test.js

@@ -1,11 +1,11 @@
 import assert from 'node:assert/strict';
-import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 import YAML from 'yaml';
 import { patchWikircProfile } from './wikirc.js';
-import { writeVectorConfig } from './wikiSetup.js';
+import { finalizeCreatedWorkspace, writeVectorConfig } from './wikiSetup.js';
 
 test('patchWikircProfile merges keys and preserves existing values', () => {
   const root = mkdtempSync(join(tmpdir(), 'wikirc-patch-'));
@@ -109,3 +109,41 @@ test('writeVectorConfig removes commented vector placeholders it replaces', () =
   assert.equal(parsed.retrieval.vector.baseUrl, 'http://localhost:7997/v1');
   assert.equal(parsed.retrieval.vector.apiKey, 'vector-key');
 });
+
+test('finalizeCreatedWorkspace copies generated wiki token into default wikirc', () => {
+  const root = mkdtempSync(join(tmpdir(), 'wikirc-workspace-token-'));
+  const registryRoot = join(root, 'registry');
+  const registryPath = join(registryRoot, 'demo');
+  const workspacePath = join(root, 'workspace');
+  const token = 'a'.repeat(64);
+  mkdirSync(registryPath, { recursive: true });
+  mkdirSync(workspacePath, { recursive: true });
+  writeFileSync(
+    join(registryPath, '.env'),
+    [
+      'WORKSPACE_NAME=demo',
+      `WIKI_WORKSPACE_PATH=${workspacePath}`,
+      `WIKI_MCP_AUTH_TOKEN=${token}`,
+      '',
+    ].join('\n'),
+    'utf8',
+  );
+  writeFileSync(
+    join(workspacePath, '.wikirc.yaml'),
+    ['language: en', 'mcp:', '  # accessKey: your-secret-key', ''].join('\n'),
+    'utf8',
+  );
+
+  const previousDir = process.env.WIKI_WORKSPACES_DIR;
+  process.env.WIKI_WORKSPACES_DIR = registryRoot;
+  try {
+    const workspace = finalizeCreatedWorkspace('demo');
+    const parsed = YAML.parse(readFileSync(join(workspacePath, '.wikirc.yaml'), 'utf8'));
+
+    assert.equal(workspace.name, 'demo');
+    assert.equal(parsed.mcp.accessKey, token);
+  } finally {
+    if (previousDir === undefined) delete process.env.WIKI_WORKSPACES_DIR;
+    else process.env.WIKI_WORKSPACES_DIR = previousDir;
+  }
+});

package/src/runtime/lifecycle.js

@@ -33,7 +33,7 @@ export async function assertRuntimeNode(executable = runtimeNodeExecutable()) {
 }
 
 export async function ensureRuntime({
-  host = process.env.WIKI_MANAGER_RUNTIME_HOST ?? '0.0.0.0',
+  host = process.env.WIKI_MANAGER_RUNTIME_HOST ?? '127.0.0.1',
   port = Number(process.env.WIKI_MANAGER_RUNTIME_PORT ?? 7788),
   stateDir = process.env.WIKI_MANAGER_STATE_DIR ?? defaultRuntimeStateDir(),
   url = process.env.WIKI_MANAGER_RUNTIME_URL ?? `http://127.0.0.1:${port}`,

package/src/runtime/runner.e2e.test.js

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { runRuntimeParallelPlan } from './runner.js';
+
+// Regression guard for plan-0.11.4-stabilisation.md §3: build de 2 templates
+// en séquentiel -> T1, en multi-agent -> T2, assert T2 < 0.65*T1. Exercises
+// the scheduler (runRuntimeParallelPlan) directly with mocked, fixed-latency
+// tasks — it proves the scheduler itself parallelizes ready tasks, not that a
+// real llm-wiki build/provider round-trip shows the same margin.
+const SIMULATED_BUILD_LATENCY_MS = 150;
+const MAX_PARALLEL_TO_SEQUENTIAL_RATIO = 0.65;
+
+function buildTwoTemplatePlan() {
+  return [
+    { step: 1, id: 'template-a', description: 'Build template A', status: 'pending', dependsOn: [] },
+    { step: 2, id: 'template-b', description: 'Build template B', status: 'pending', dependsOn: [] },
+  ];
+}
+
+function latencyAgent() {
+  return {
+    async invoke() {
+      await new Promise((resolve) => setTimeout(resolve, SIMULATED_BUILD_LATENCY_MS));
+      return { response: 'done' };
+    },
+  };
+}
+
+async function timedRun(concurrency, runId) {
+  const session = { activities: {}, headlessPlan: buildTwoTemplatePlan() };
+  const startedAt = Date.now();
+  const result = await runRuntimeParallelPlan(latencyAgent(), session, 'Build 2 templates', {
+    runId,
+    timeoutMs: 10_000,
+    maxTurns: 1,
+    concurrency,
+  });
+  return { result, durationMs: Date.now() - startedAt };
+}
+
+test('multi-agent scheduler beats sequential on 2 independent build tasks by the required margin (plan 0.11.4 §3 guard)', async () => {
+  const { result: sequentialResult, durationMs: sequentialDurationMs } = await timedRun(1, 'e2e-accel-sequential');
+  const { result: parallelResult, durationMs: parallelDurationMs } = await timedRun(2, 'e2e-accel-parallel');
+
+  assert.equal(sequentialResult.ok, true);
+  assert.equal(parallelResult.ok, true);
+  const thresholdMs = MAX_PARALLEL_TO_SEQUENTIAL_RATIO * sequentialDurationMs;
+  assert.ok(
+    parallelDurationMs < thresholdMs,
+    `expected multi-agent duration (${parallelDurationMs}ms) under ${MAX_PARALLEL_TO_SEQUENTIAL_RATIO * 100}% of sequential duration (${sequentialDurationMs}ms, threshold ${thresholdMs}ms)`,
+  );
+});

package/src/runtime/runner.js

@@ -199,11 +199,16 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   const locks = new Set();
   const failures = [];
   const previousIdentity = session._currentRunIdentity;
+  const previousPlanUpdate = session._onPlanUpdate;
   session._currentRunIdentity = {
     ...(previousIdentity ?? {}),
     runId,
     workspace: session.workspace ?? previousIdentity?.workspace ?? null,
   };
+  session._onPlanUpdate = () => {
+    previousPlanUpdate?.();
+    abortCancelledActiveTasks(session, active);
+  };
   ensurePlanProjection(session, runId);
   emitRuntimeLog(session, `scheduler: parallel plan enabled (concurrency ${limit})`);
 
@@ -238,11 +243,15 @@ export async function runRuntimeParallelPlan(agent, session, input, {
       }
 
       const settled = await Promise.race([...active.values()].map((entry) => entry.promise));
+      const activeEntry = active.get(settled.taskId);
       active.delete(settled.taskId);
+      activeEntry?.cleanup?.();
       for (const lock of settled.locks) locks.delete(lock);
       if (settled.cancelled) {
-        await drainActive(active, locks);
-        throwIfAborted(signal, 'Runtime run cancelled.');
+        if (signal?.aborted) {
+          await drainActive(active, locks);
+          throwIfAborted(signal, 'Runtime run cancelled.');
+        }
         continue;
       }
       if (!settled.ok) failures.push(settled);
@@ -250,16 +259,29 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   } finally {
     if (previousIdentity) session._currentRunIdentity = previousIdentity;
     else delete session._currentRunIdentity;
+    if (previousPlanUpdate) session._onPlanUpdate = previousPlanUpdate;
+    else delete session._onPlanUpdate;
   }
 }
 
 async function drainActive(active, locks) {
   if (active.size === 0) return;
-  await Promise.all([...active.values()].map((entry) => entry.promise));
+  const entries = [...active.values()];
+  await Promise.all(entries.map((entry) => entry.promise));
+  for (const entry of entries) entry.cleanup?.();
   active.clear();
   locks.clear();
 }
 
+function abortCancelledActiveTasks(session, active) {
+  for (const [taskId, entry] of active.entries()) {
+    const current = (session.headlessPlan ?? []).find((step) => planTaskId(step) === taskId);
+    if (current?.status === 'cancelled' && !entry.signal?.aborted) {
+      entry.controller?.abort();
+    }
+  }
+}
+
 // Scope the evaluator/replanner's view of "completed" activities to the
 // tasks that actually failed, instead of every activity the whole run has
 // ever recorded — a long-running sibling's stale (or unrelated, already
@@ -323,20 +345,44 @@ function startReadyTasks(agent, session, input, {
       payload: { taskId, status: 'running' },
     }));
     emitRuntimeLog(session, `scheduler: starting task ${taskId}`);
+    const taskAbort = createTaskAbortSignal(signal);
     const promise = runParallelTask(agent, session, input, task, {
-      signal,
+      signal: taskAbort.signal,
       timeoutMs,
       maxTurns,
       runId,
       pollBusy,
       locks: taskLocks,
     });
-    active.set(taskId, { taskId, locks: taskLocks, promise });
+    active.set(taskId, {
+      taskId,
+      locks: taskLocks,
+      promise,
+      controller: taskAbort.controller,
+      signal: taskAbort.signal,
+      cleanup: taskAbort.cleanup,
+    });
     started += 1;
   }
   return started;
 }
 
+function createTaskAbortSignal(parentSignal) {
+  const controller = new AbortController();
+  if (!parentSignal) return { controller, signal: controller.signal, cleanup: null };
+  if (parentSignal.aborted) {
+    controller.abort();
+    return { controller, signal: controller.signal, cleanup: null };
+  }
+  const abort = () => controller.abort();
+  parentSignal.addEventListener('abort', abort, { once: true });
+  return {
+    controller,
+    signal: controller.signal,
+    cleanup: () => parentSignal.removeEventListener('abort', abort),
+  };
+}
+
 async function runParallelTask(agent, parentSession, input, task, {
   signal,
   timeoutMs,
@@ -364,6 +410,9 @@ async function runParallelTask(agent, parentSession, input, task, {
       }));
       return { ok: false, taskId, locks, result };
     }
+    if ((parentSession.headlessPlan ?? []).find((step) => planTaskId(step) === taskId)?.status === 'cancelled') {
+      return { ok: false, taskId, locks, cancelled: true };
+    }
     dispatchAgentEvent(parentSession, createAgentEvent('plan_step_updated', {
       origin: 'runtime',
       runId,

package/src/runtime/runner.test.js

@@ -337,6 +337,232 @@ test('runRuntimeParallelPlan executes ready tasks concurrently in one parent run
   assert.ok(session.agentEvents.some((event) => event.taskId === 'b'));
 });
 
+test('runRuntimeParallelPlan schedules a plan patch applied during an active parallel run', async () => {
+  const started = [];
+  const release = {};
+  const session = {
+    activities: {},
+    headlessPlan: [
+      { step: 1, id: 'a', description: 'Task A', status: 'pending', dependsOn: [] },
+      { step: 2, id: 'b', description: 'Task B', status: 'pending', dependsOn: [] },
+    ],
+  };
+  const agent = {
+    async invoke({ input }) {
+      const id = input.match(/Task id: ([^\n]+)/)?.[1];
+      started.push(id);
+      if (id === 'a' || id === 'b') {
+        await new Promise((resolve) => { release[id] = resolve; });
+      }
+      return { response: `done ${id}` };
+    },
+  };
+
+  const running = runRuntimeParallelPlan(agent, session, 'Do patched work', {
+    runId: 'run-patch-active',
+    timeoutMs: 1000,
+    maxTurns: 1,
+    concurrency: 2,
+  });
+  await waitFor(() => started.includes('a') && started.includes('b'));
+  const patch = {
+    targetRunId: 'run-patch-active',
+    basePlanRevision: session.agentProjection.planRevision,
+    operations: [
+      {
+        op: 'add_task',
+        task: {
+          id: 'c',
+          description: 'Task C added during run',
+          status: 'pending',
+          dependsOn: ['a'],
+          executor: null,
+          outputRefs: [],
+        },
+      },
+    ],
+  };
+  dispatchAgentEvent(session, createAgentEvent('plan_patch_proposed', {
+    origin: 'runtime',
+    runId: 'run-patch-active',
+    payload: { id: 'patch-active', patch },
+  }));
+  dispatchAgentEvent(session, createAgentEvent('plan_patch_approved', {
+    origin: 'runtime',
+    runId: 'run-patch-active',
+    payload: { patchId: 'patch-active' },
+  }));
+  dispatchAgentEvent(session, createAgentEvent('plan_patch_applied', {
+    origin: 'runtime',
+    runId: 'run-patch-active',
+    payload: { patchId: 'patch-active', patch },
+  }));
+
+  assert.deepEqual(session.headlessPlan.map((step) => step.id), ['a', 'b', 'c']);
+  release.a();
+  await waitFor(() => started.includes('c'));
+  release.b();
+
+  const result = await running;
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(started, ['a', 'b', 'c']);
+  assert.deepEqual(session.headlessPlan.map((step) => step.status), ['done', 'done', 'done']);
+  assert.equal(session.headlessPlan.find((step) => step.id === 'c').dependsOn[0], 'a');
+});
+
+test('runRuntimeParallelPlan rejects a stale patch during an active parallel run without silently applying it', async () => {
+  const release = {};
+  const session = {
+    activities: {},
+    headlessPlan: [
+      { step: 1, id: 'a', description: 'Task A', status: 'pending', dependsOn: [] },
+      { step: 2, id: 'b', description: 'Task B', status: 'pending', dependsOn: [] },
+    ],
+  };
+  const agent = {
+    async invoke({ input }) {
+      const id = input.match(/Task id: ([^\n]+)/)?.[1];
+      await new Promise((resolve) => { release[id] = resolve; });
+      return { response: `done ${id}` };
+    },
+  };
+
+  const running = runRuntimeParallelPlan(agent, session, 'Do stale patch work', {
+    runId: 'run-stale-patch',
+    timeoutMs: 1000,
+    maxTurns: 1,
+    concurrency: 2,
+  });
+  await waitFor(() => release.a && release.b);
+  const patch = {
+    targetRunId: 'run-stale-patch',
+    basePlanRevision: session.agentProjection.planRevision + 99,
+    operations: [
+      { op: 'add_task', task: { id: 'c', description: 'Should not apply', dependsOn: ['a'] } },
+    ],
+  };
+  dispatchAgentEvent(session, createAgentEvent('plan_patch_proposed', {
+    origin: 'runtime',
+    runId: 'run-stale-patch',
+    payload: { id: 'patch-stale', patch },
+  }));
+  dispatchAgentEvent(session, createAgentEvent('plan_patch_applied', {
+    origin: 'runtime',
+    runId: 'run-stale-patch',
+    payload: { patchId: 'patch-stale', patch },
+  }));
+
+  assert.deepEqual(session.headlessPlan.map((step) => step.id), ['a', 'b']);
+  assert.equal(session.agentProjection.planPatches.find((item) => item.id === 'patch-stale').status, 'rejected');
+  assert.equal(session.agentProjection.planPatches.find((item) => item.id === 'patch-stale').rejectionReason, 'revision_mismatch');
+  release.a();
+  release.b();
+
+  const result = await running;
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(session.headlessPlan.map((step) => step.status), ['done', 'done']);
+});
+
+test('runRuntimeParallelPlan aborts a running child task cancelled by plan patch without stopping siblings', async () => {
+  const started = [];
+  let bAborted = false;
+  const session = {
+    activities: {},
+    headlessPlan: [
+      { step: 1, id: 'a', description: 'Task A', status: 'pending', dependsOn: [] },
+      { step: 2, id: 'b', description: 'Task B', status: 'pending', dependsOn: [] },
+    ],
+  };
+  const agent = {
+    async invoke({ input, signal }) {
+      const id = input.match(/Task id: ([^\n]+)/)?.[1];
+      started.push(id);
+      if (id === 'b') {
+        await new Promise((resolve, reject) => {
+          signal.addEventListener('abort', () => {
+            bAborted = true;
+            const err = new Error('cancelled');
+            err.name = 'AbortError';
+            reject(err);
+          }, { once: true });
+        });
+      }
+      return { response: `done ${id}` };
+    },
+  };
+
+  const running = runRuntimeParallelPlan(agent, session, 'Cancel one child', {
+    runId: 'run-cancel-task',
+    timeoutMs: 1000,
+    maxTurns: 1,
+    concurrency: 2,
+  });
+  await waitFor(() => started.includes('a') && started.includes('b'));
+  await waitFor(() => session.headlessPlan.find((step) => step.id === 'a')?.status === 'done');
+  const patch = {
+    targetRunId: 'run-cancel-task',
+    basePlanRevision: session.agentProjection.planRevision,
+    operations: [{ op: 'cancel_task', taskId: 'b' }],
+  };
+  dispatchAgentEvent(session, createAgentEvent('plan_patch_applied', {
+    origin: 'runtime',
+    runId: 'run-cancel-task',
+    payload: { patchId: 'patch-cancel-b', patch },
+  }));
+
+  const result = await running;
+
+  assert.equal(result.ok, true);
+  assert.equal(bAborted, true);
+  assert.deepEqual(session.headlessPlan.map((step) => step.status), ['done', 'cancelled']);
+  assert.equal(session.agentProjection.planPatches.find((item) => item.id === 'patch-cancel-b').status, 'applied');
+});
+
+test('runRuntimeParallelPlan never exceeds the configured concurrency with twice the limit ready', async () => {
+  let active = 0;
+  let maxActive = 0;
+  const release = {};
+  const session = {
+    activities: {},
+    headlessPlan: Array.from({ length: 6 }, (_, index) => ({
+      step: index + 1,
+      id: `task-${index + 1}`,
+      description: `Task ${index + 1}`,
+      status: 'pending',
+      dependsOn: [],
+    })),
+  };
+  const agent = {
+    async invoke({ input }) {
+      const id = input.match(/Task id: ([^\n]+)/)?.[1];
+      active += 1;
+      maxActive = Math.max(maxActive, active);
+      await new Promise((resolve) => { release[id] = resolve; });
+      active -= 1;
+      return { response: `done ${id}` };
+    },
+  };
+
+  const running = runRuntimeParallelPlan(agent, session, 'Respect limit', {
+    runId: 'run-limit',
+    timeoutMs: 1000,
+    maxTurns: 1,
+    concurrency: 3,
+  });
+  for (let batch = 0; batch < 2; batch += 1) {
+    await waitFor(() => Object.keys(release).length >= (batch + 1) * 3);
+    for (const id of Object.keys(release).slice(batch * 3, (batch + 1) * 3)) release[id]();
+  }
+
+  const result = await running;
+
+  assert.equal(result.ok, true);
+  assert.equal(maxActive, 3);
+  assert.deepEqual(session.headlessPlan.map((step) => step.status), ['done', 'done', 'done', 'done', 'done', 'done']);
+});
+
 test('runRuntimeParallelPlan serializes conflicting write locks', async () => {
   let active = 0;
   let maxActive = 0;
@@ -441,6 +667,52 @@ test('runRuntimeParallelPlan propagates parent cancellation to child tasks', asy
   assert.equal(session.headlessPlan[0].status, 'cancelled');
 });
 
+test('runRuntimeParallelPlan aborts every active child on parent cancellation and records terminal updates after running updates', async () => {
+  const controller = new AbortController();
+  const aborted = [];
+  const session = {
+    activities: {},
+    headlessPlan: [
+      { step: 1, id: 'a', description: 'Task A', status: 'pending', dependsOn: [] },
+      { step: 2, id: 'b', description: 'Task B', status: 'pending', dependsOn: [] },
+      { step: 3, id: 'c', description: 'Task C', status: 'pending', dependsOn: [] },
+    ],
+  };
+  const agent = {
+    async invoke({ input, signal }) {
+      const id = input.match(/Task id: ([^\n]+)/)?.[1];
+      await new Promise((resolve, reject) => {
+        signal.addEventListener('abort', () => {
+          aborted.push(id);
+          const err = new Error('cancelled');
+          err.name = 'AbortError';
+          reject(err);
+        }, { once: true });
+      });
+      return { response: `done ${id}` };
+    },
+  };
+
+  const running = runRuntimeParallelPlan(agent, session, 'Cancel all children', {
+    runId: 'run-cancel-all',
+    signal: controller.signal,
+    timeoutMs: 1000,
+    maxTurns: 1,
+    concurrency: 3,
+  });
+  await waitFor(() => session.headlessPlan.every((step) => step.status === 'running'));
+  controller.abort();
+
+  await assert.rejects(running, { name: 'AbortError' });
+  assert.deepEqual(aborted.sort(), ['a', 'b', 'c']);
+  assert.deepEqual(session.headlessPlan.map((step) => step.status), ['cancelled', 'cancelled', 'cancelled']);
+  const updates = session.agentEvents
+    .filter((event) => event.type === 'plan_step_updated')
+    .map((event) => `${event.taskId}:${event.payload.status}`);
+  assert.deepEqual(updates.slice(0, 3).sort(), ['a:running', 'b:running', 'c:running']);
+  assert.deepEqual(updates.slice(3).sort(), ['a:cancelled', 'b:cancelled', 'c:cancelled']);
+});
+
 test('runRuntimeAgenticWorkflow hands off to the parallel scheduler when turn 1 sets a multi-task ready plan', async () => {
   const session = {
     activities: {},

package/src/runtime/server.js

@@ -6,7 +6,7 @@ import { validateContractInDev } from '../contracts/schemas.js';
 import { runtimeTokenFromEnv } from './auth.js';
 
 export function startRuntimeServer({
-  host = '0.0.0.0',
+  host = '127.0.0.1',
   port = 7788,
   token = runtimeTokenFromEnv(),
   store,

package/src/runtime/store.js

@@ -1,4 +1,4 @@
-import { mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { applyAgentProjectionToSession, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
@@ -9,6 +9,9 @@ import { projectWorkflow } from '../core/workflow.js';
 export { defaultRuntimeStateDir };
 
 const NON_PERSISTED_EVENT_TYPES = new Set(['runtime_log']);
+export const RUNTIME_STORE_SCHEMA_VERSION = 1;
+const RUNTIME_RETENTION_DAYS = 30;
+const TERMINAL_RUN_STATUSES = ['done', 'error', 'cancelled', 'interrupted'];
 
 const RUN_STATUS_BY_EVENT = {
   run_done: 'done',
@@ -21,13 +24,20 @@ const RUN_STATUS_BY_EVENT = {
 const RECOVERABLE_RUN_STATUSES = ['running', 'waiting', 'pending_approval'];
 export const RECOVERABLE_QUEUE_STATUSES = ['waiting', 'queued', 'starting', 'running', 'blocked', 'pending_approval'];
 
-export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName = 'runtime.db' } = {}) {
+export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName = 'runtime.db', metaPath = null } = {}) {
   const resolvedStateDir = resolve(stateDir);
   mkdirSync(resolvedStateDir, { recursive: true });
   const dbPath = join(resolvedStateDir, fileName);
   const db = new DatabaseSync(dbPath);
   db.exec('PRAGMA journal_mode = WAL');
   db.exec('PRAGMA foreign_keys = ON');
+  try {
+    ensureKnownStoreVersion(db, dbPath);
+    ensureRuntimeMeta(metaPath ?? defaultRuntimeMetaPath(resolvedStateDir));
+  } catch (error) {
+    db.close();
+    throw error;
+  }
   db.exec(`
     CREATE TABLE IF NOT EXISTS events (
       sequence INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -76,6 +86,8 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   backfillEventSequence(db);
   db.exec('CREATE INDEX IF NOT EXISTS idx_events_workspace ON events(workspace)');
   db.exec('CREATE INDEX IF NOT EXISTS idx_events_sequence ON events(sequence)');
+  db.exec(`PRAGMA user_version = ${RUNTIME_STORE_SCHEMA_VERSION}`);
+  purgeOldTerminalRuns(db);
 
   let lastEventId = null;
   let lastEventSequence = null;
@@ -423,6 +435,64 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   };
 }
 
+function defaultRuntimeMetaPath(stateDir) {
+  return join(dirname(stateDir), '.wiki', 'meta.json');
+}
+
+function ensureKnownStoreVersion(db, dbPath) {
+  const row = db.prepare('PRAGMA user_version').get();
+  const version = Number(row?.user_version ?? 0);
+  if (version > RUNTIME_STORE_SCHEMA_VERSION) {
+    throw new Error(`Unsupported runtime store schema version ${version} in ${dbPath}; this manager supports version ${RUNTIME_STORE_SCHEMA_VERSION}. Upgrade llm-wiki-manager before opening this runtime store.`);
+  }
+}
+
+function ensureRuntimeMeta(metaPath) {
+  mkdirSync(dirname(metaPath), { recursive: true });
+  if (!existsSync(metaPath)) {
+    writeFileSync(metaPath, `${JSON.stringify({ schemaVersion: RUNTIME_STORE_SCHEMA_VERSION }, null, 2)}\n`, 'utf8');
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(metaPath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Invalid runtime metadata file ${metaPath}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const version = Number(parsed?.schemaVersion ?? 0);
+  if (version > RUNTIME_STORE_SCHEMA_VERSION) {
+    throw new Error(`Unsupported runtime metadata schemaVersion ${version} in ${metaPath}; this manager supports version ${RUNTIME_STORE_SCHEMA_VERSION}. Upgrade llm-wiki-manager before opening this runtime state.`);
+  }
+  if (!version) {
+    writeFileSync(metaPath, `${JSON.stringify({ ...parsed, schemaVersion: RUNTIME_STORE_SCHEMA_VERSION }, null, 2)}\n`, 'utf8');
+  }
+}
+
+function purgeOldTerminalRuns(db, now = new Date()) {
+  const cutoff = new Date(now.getTime() - RUNTIME_RETENTION_DAYS * 24 * 60 * 60 * 1000).toISOString();
+  const placeholders = TERMINAL_RUN_STATUSES.map(() => '?').join(', ');
+  const oldRuns = db
+    .prepare(`SELECT id FROM runs WHERE status IN (${placeholders}) AND updated_at < ?`)
+    .all(...TERMINAL_RUN_STATUSES, cutoff)
+    .map((row) => row.id);
+  if (oldRuns.length === 0) return 0;
+  db.exec('BEGIN');
+  try {
+    const deleteEvents = db.prepare('DELETE FROM events WHERE run_id = ? OR json_extract(payload, \'$.runId\') = ?');
+    const deleteRun = db.prepare('DELETE FROM runs WHERE id = ?');
+    for (const runId of oldRuns) {
+      deleteEvents.run(runId, runId);
+      deleteRun.run(runId);
+    }
+    db.exec('COMMIT');
+  } catch (error) {
+    db.exec('ROLLBACK');
+    throw error;
+  }
+  db.exec('VACUUM');
+  return oldRuns.length;
+}
+
 function rowToEvent(row) {
   return {
     sequence: row.sequence ?? null,

package/src/runtime/store.test.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { mkdtempSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -7,6 +7,10 @@ import test from 'node:test';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { openRuntimeStore } from './store.js';
 
+function runtimeStateDir() {
+  return join(mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-')), '.wiki-manager');
+}
+
 test('runtime store persists and replays agent events into a projection', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
@@ -29,6 +33,43 @@ test('runtime store persists and replays agent events into a projection', () =>
   reopened.close();
 });
 
+test('runtime store writes schema versions to sqlite and meta file', () => {
+  const root = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const stateDir = join(root, '.wiki-manager');
+  const store = openRuntimeStore({ stateDir });
+  const version = store.db.prepare('PRAGMA user_version').get().user_version;
+  const meta = JSON.parse(readFileSync(join(root, '.wiki', 'meta.json'), 'utf8'));
+
+  assert.equal(version, 1);
+  assert.equal(meta.schemaVersion, 1);
+  store.close();
+});
+
+test('runtime store refuses unknown sqlite schema versions', () => {
+  const stateDir = runtimeStateDir();
+  mkdirSync(stateDir, { recursive: true });
+  const db = new DatabaseSync(join(stateDir, 'runtime.db'));
+  db.exec('PRAGMA user_version = 99');
+  db.close();
+
+  assert.throws(
+    () => openRuntimeStore({ stateDir }),
+    /Unsupported runtime store schema version 99/,
+  );
+});
+
+test('runtime store refuses unknown runtime metadata versions', () => {
+  const root = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const stateDir = join(root, '.wiki-manager');
+  mkdirSync(join(root, '.wiki'), { recursive: true });
+  writeFileSync(join(root, '.wiki', 'meta.json'), '{"schemaVersion":99}\n', 'utf8');
+
+  assert.throws(
+    () => openRuntimeStore({ stateDir }),
+    /Unsupported runtime metadata schemaVersion 99/,
+  );
+});
+
 test('runtime store persists duplicate events idempotently', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
@@ -52,6 +93,50 @@ test('runtime store persists duplicate events idempotently', () => {
   store.close();
 });
 
+test('runtime store purges terminal runs older than thirty days on open', () => {
+  const stateDir = runtimeStateDir();
+  const first = openRuntimeStore({ stateDir });
+  for (const runId of ['old-done', 'recent-done', 'old-running']) {
+    first.persistEvent(createAgentEvent('run_started', {
+      origin: 'test',
+      runId,
+      turnId: `${runId}:turn-0`,
+      workspace: 'docs',
+      payload: { input: runId, workspace: 'docs' },
+    }));
+  }
+  first.persistEvent(createAgentEvent('run_done', {
+    origin: 'test',
+    runId: 'old-done',
+    workspace: 'docs',
+    payload: { runId: 'old-done', workspace: 'docs' },
+  }));
+  first.persistEvent(createAgentEvent('assistant_message', {
+    origin: 'test',
+    runId: 'old-done',
+    workspace: 'docs',
+    payload: { runId: 'old-done', content: 'old related event' },
+  }));
+  first.persistEvent(createAgentEvent('run_done', {
+    origin: 'test',
+    runId: 'recent-done',
+    workspace: 'docs',
+    payload: { runId: 'recent-done', workspace: 'docs' },
+  }));
+  first.close();
+
+  const db = new DatabaseSync(join(stateDir, 'runtime.db'));
+  db.prepare("UPDATE runs SET updated_at = '2000-01-01T00:00:00.000Z' WHERE id IN ('old-done', 'old-running')").run();
+  db.close();
+
+  const reopened = openRuntimeStore({ stateDir });
+  assert.deepEqual(reopened.listRuns().map((run) => run.id).sort(), ['old-running', 'recent-done']);
+  assert.equal(reopened.listEvents().some((event) => event.runId === 'old-done'), false);
+  assert.equal(reopened.listEvents().some((event) => event.runId === 'recent-done'), true);
+  assert.equal(reopened.listEvents().some((event) => event.runId === 'old-running'), true);
+  reopened.close();
+});
+
 test('runtime store persists run identity fields on events', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
@@ -483,6 +568,118 @@ test('runtime store persists and replays control queue events without mixing MCP
   reopened.close();
 });
 
+test('runtime store replays a parallel run into a deterministic workflow projection', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  const events = [
+    createAgentEvent('run_started', {
+      origin: 'runtime',
+      runId: 'run-parallel-replay',
+      workspace: 'docs',
+      payload: { input: 'parallel build', workspace: 'docs' },
+    }),
+    createAgentEvent('plan_set', {
+      origin: 'runtime',
+      runId: 'run-parallel-replay',
+      workspace: 'docs',
+      payload: {
+        steps: [
+          { step: 1, id: 'a', description: 'Task A', status: 'pending', dependsOn: [] },
+          { step: 2, id: 'b', description: 'Task B', status: 'pending', dependsOn: [] },
+          { step: 3, id: 'join', description: 'Join', status: 'pending', dependsOn: ['a', 'b'] },
+        ],
+      },
+    }),
+    createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      runId: 'run-parallel-replay',
+      taskId: 'a',
+      workspace: 'docs',
+      payload: { taskId: 'a', status: 'running' },
+    }),
+    createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      runId: 'run-parallel-replay',
+      taskId: 'b',
+      workspace: 'docs',
+      payload: { taskId: 'b', status: 'running' },
+    }),
+    createAgentEvent('activity_upserted', {
+      origin: 'tool',
+      runId: 'run-parallel-replay',
+      taskId: 'a',
+      workspace: 'docs',
+      payload: {
+        activity: {
+          id: 'job-a',
+          source: 'production',
+          label: 'Task A job',
+          status: 'done',
+          terminal: true,
+          startedAt: '2026-07-04T10:00:00.000Z',
+          updatedAt: '2026-07-04T10:00:01.000Z',
+          progress: {},
+          outputRefs: ['deliverables/a.md'],
+        },
+      },
+    }),
+    createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      runId: 'run-parallel-replay',
+      taskId: 'a',
+      workspace: 'docs',
+      payload: { taskId: 'a', status: 'done' },
+    }),
+    createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      runId: 'run-parallel-replay',
+      taskId: 'b',
+      workspace: 'docs',
+      payload: { taskId: 'b', status: 'done' },
+    }),
+    createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      runId: 'run-parallel-replay',
+      taskId: 'join',
+      workspace: 'docs',
+      payload: { taskId: 'join', status: 'running' },
+    }),
+    createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      runId: 'run-parallel-replay',
+      taskId: 'join',
+      workspace: 'docs',
+      payload: { taskId: 'join', status: 'done' },
+    }),
+    createAgentEvent('run_done', {
+      origin: 'runtime',
+      runId: 'run-parallel-replay',
+      workspace: 'docs',
+      payload: { runId: 'run-parallel-replay' },
+    }),
+  ];
+  for (const event of events) store.persistEvent(event);
+  store.close();
+
+  const first = openRuntimeStore({ stateDir });
+  const firstSession = { activities: {}, headlessPlan: null };
+  first.hydrateSession(firstSession, { workspace: 'docs' });
+  const firstWorkflow = first.getState(firstSession, { workspace: 'docs' }).workflow;
+  first.close();
+
+  const second = openRuntimeStore({ stateDir });
+  const secondSession = { activities: {}, headlessPlan: null };
+  second.hydrateSession(secondSession, { workspace: 'docs' });
+  const secondWorkflow = second.getState(secondSession, { workspace: 'docs' }).workflow;
+
+  assert.deepEqual(secondWorkflow, firstWorkflow);
+  assert.deepEqual(secondWorkflow.relations.filter((relation) => relation.type === 'depends_on'), [
+    { type: 'depends_on', from: 'task:join', to: 'task:a' },
+    { type: 'depends_on', from: 'task:join', to: 'task:b' },
+  ]);
+  second.close();
+});
+
 test('runtime store identifies recoverable workspaces and interrupts stale runs', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });