@dotdrelle/wiki-manager 0.14.12 → 0.14.16

package/src/core/agentEvents.js

@@ -122,13 +122,22 @@ export function resetSessionProjection(session) {
 
 function withSessionRunIdentity(event, session) {
   const identity = session?._currentRunIdentity;
-  if (!identity) return event;
+  // The workspace must be attached even OUTSIDE a run identity: the SSE
+  // publisher drops events whose workspace does not match the (always
+  // workspace-scoped) serve UI client. Events dispatched between chained
+  // executions — e.g. the plan_set of the next action, run evaluation,
+  // assistant messages — used to leave with workspace=null and never reached
+  // the UI, which then displayed a stale plan from the previous action.
+  const workspace = event.workspace ?? identity?.workspace ?? session?.workspace ?? null;
+  if (!identity) {
+    return workspace === (event.workspace ?? null) ? event : { ...event, workspace };
+  }
   return {
     ...event,
     runId: event.runId ?? identity.runId ?? null,
     turnId: event.turnId ?? identity.turnId ?? null,
     taskId: event.taskId ?? identity.taskId ?? null,
-    workspace: event.workspace ?? identity.workspace ?? null,
+    workspace,
   };
 }
 

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.14.12",
-  "commit": "621830d"
+  "version": "0.14.16",
+  "commit": "a603298"
 }

package/src/core/dockerCompose.test.js

@@ -11,6 +11,10 @@ test('workspace compose does not start a per-workspace agent runtime', async ()
   assert.equal(compose.services['agent-runtime'], undefined);
   assert.deepEqual(aliases.all.targets, ['serve', 'mcp-http', 'production-mcp']);
   assert.equal(aliases.runtime, undefined);
+  assert.equal(
+    compose.services.serve.environment.includes('WIKI_MANAGER_RUNTIME_URL=http://host.docker.internal:${WIKI_MANAGER_RUNTIME_PORT:-7788}'),
+    true,
+  );
 });
 
 test('agent compose services run as the host uid and gid', async () => {

package/src/core/env.js

@@ -98,14 +98,26 @@ export function ensureManagerScaffold({ log = () => {} } = {}) {
   return created;
 }
 
+// Mirrors workspacesDir() in core/workspaces.js (which imports this module,
+// so it cannot be imported here without a cycle).
+function workspacesRootDir() {
+  return process.env.WIKI_WORKSPACES_DIR
+    ? resolve(process.env.WIKI_WORKSPACES_DIR)
+    : join(userManagerDir(), 'workspaces');
+}
+
 // Single source of truth for where `.agents-data` lives, shared by the
-// manager's own document intake and by the host path it mounts into agent
-// containers — keeping them in sync avoids the two silently drifting apart.
+// manager's own document intake, the per-workspace serve stack, and the
+// GLOBAL agents stack (documents/cme containers). All three must resolve the
+// same host directory: serve writes an upload into its mount and the
+// documents container must find it under the identical path — a divergence
+// here is exactly the clean-install "Input file does not exist" bug.
+// Canonical location: `<workspaces root>/.agents-data`, session or not.
 export function resolveAgentsDataDir(session = null) {
   const configured = process.env.AGENTS_DATA_DIR;
-  if (configured) return isAbsolute(configured) ? configured : resolve(defaultRuntimeStateDir(), configured);
+  if (configured) return isAbsolute(configured) ? configured : resolve(managerStateDir(), configured);
   if (session?.workspacePath) return resolve(dirname(session.workspacePath), '.agents-data');
-  return resolve(defaultRuntimeStateDir(), 'agents-data');
+  return resolve(workspacesRootDir(), '.agents-data');
 }
 
 function parseEnvValue(value) {

package/src/core/env.test.js

@@ -29,6 +29,9 @@ test('scaffold copies the packaged examples into a fresh directory', () => {
     const endpoints = JSON.parse(readFileSync(join(dir, 'mcp.endpoints.json'), 'utf8'));
     assert.ok(endpoints.mcpServers);
     assert.ok(endpoints.chatAccess);
+    const env = readFileSync(join(dir, '.env'), 'utf8');
+    assert.match(env, /^# WIKI_MANAGER_RUNTIME_HOST=0\.0\.0\.0$/m);
+    assert.match(env, /^# WIKI_MANAGER_RUNTIME_PORT=7788$/m);
   });
 });
 

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

package/src/core/wikiSetup.js

@@ -6,7 +6,7 @@ import { promisify } from 'node:util';
 import YAML from 'yaml';
 import { checkMissingDockerImages } from './dockerImages.js';
 import { patchWikircProfile } from './wikirc.js';
-import { managerEnvFile, managerMcpEndpointsFile } from './env.js';
+import { managerEnvFile, managerMcpEndpointsFile, resolveAgentsDataDir } from './env.js';
 import { createWorkspace, findWorkspace, isValidWorkspaceName, listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
 
 const execFileAsync = promisify(execFile);
@@ -68,6 +68,12 @@ export async function startAgents(options = {}) {
         // user's .env stayed empty on a fresh install.
         WIKI_MANAGER_ENV_FILE: managerEnvFile(),
         WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile(),
+        // Same pinning for .agents-data: without it the script defaults to
+        // $PWD/.agents-data (the PACKAGE directory), while the serve stack
+        // mounts the workspace-root .agents-data — the documents container
+        // then reads an empty input dir and every conversion fails with
+        // "Input file does not exist" on a clean install.
+        AGENTS_DATA_DIR: resolveAgentsDataDir(),
       },
       timeout: options.timeout ?? 180_000,
       maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
@@ -88,6 +94,7 @@ export async function stopAgents(options = {}) {
       env: {
         ...process.env,
         WIKI_WORKSPACES_DIR: workspacesDir(),
+        AGENTS_DATA_DIR: resolveAgentsDataDir(),
       },
       timeout: options.timeout ?? 120_000,
       maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
@@ -98,6 +105,41 @@ export async function stopAgents(options = {}) {
   }
 }
 
+export async function refreshRunningContainers(options = {}) {
+  if (process.env.WIKI_MANAGER_AUTO_UPDATE === '0') {
+    return { skipped: true, refreshed: [] };
+  }
+  const script = join(managerRoot(), 'wiki-workspace');
+  const common = {
+    cwd: dirname(managerEnvFile()),
+    env: {
+      ...process.env,
+      WIKI_WORKSPACES_DIR: workspacesDir(),
+      WIKI_MANAGER_ENV_FILE: managerEnvFile(),
+      WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile(),
+      AGENTS_DATA_DIR: resolveAgentsDataDir(),
+    },
+    timeout: options.timeout ?? 600_000,
+    maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
+  };
+  const targets = [['agents', 'refresh'], ...listWorkspaces().map((workspace) => ['wiki', workspace.name, 'refresh'])];
+  // Each target is an independent Compose project (its own agents/workspace
+  // stack) — refresh them concurrently instead of summing every target's
+  // pull/restart time into one sequential wait.
+  const results = await Promise.all(targets.map(async (args) => {
+    options.onStep?.(`Images: checking ${args[0] === 'agents' ? 'running agents' : `workspace ${args[1]}`}…`);
+    try {
+      const { stdout, stderr } = await execFileAsync(script, args, common);
+      return { ok: true, output: [stdout, stderr].filter(Boolean).join('\n').trim() };
+    } catch (err) {
+      return { ok: false, error: wrapDockerError(err).message };
+    }
+  }));
+  const refreshed = results.filter((result) => result.ok).map((result) => result.output).filter(Boolean);
+  const errors = results.filter((result) => !result.ok).map((result) => result.error);
+  return { skipped: false, refreshed, errors };
+}
+
 export async function createNewWorkspace(name, targetPath) {
   try {
     const output = await createWorkspace(name, targetPath, { timeout: 600_000 });

package/src/core/wikiWorkspace.test.js

@@ -31,3 +31,23 @@ test('wiki-workspace regenerates CA compose overrides instead of retaining remov
   assert.match(script, /mv "\$tmp_override" "\$override_path"/);
   assert.match(script, /Changes are overwritten on the next compose command/);
 });
+
+test('workspace creation keeps mutable manager files outside the installed package', async () => {
+  const source = await readFile(new URL('./workspaces.js', import.meta.url), 'utf8');
+
+  assert.match(source, /const stateDir = dirname\(managerEnvFile\(\)\)/);
+  assert.match(source, /cwd: stateDir/);
+  assert.match(source, /WIKI_MANAGER_ENV_FILE: managerEnvFile\(\)/);
+  assert.match(source, /WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile\(\)/);
+});
+
+test('container refresh pulls and renews only services that are already running', async () => {
+  const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
+
+  assert.match(script, /refresh_running_services\(\) \{/);
+  assert.match(script, /\[\[ -n "\$\{line\/\/\[\[:space:\]\]\/\}" \]\] \|\| continue/);
+  assert.match(script, /ps --status running --services/);
+  assert.match(script, /"\$@" pull "\$\{running_services\[@\]\}"/);
+  assert.match(script, /refresh_running_services 'No running external agent containers to refresh' 'Refreshed running agents: %s' _agents_dc/);
+  assert.match(script, /refresh_running_services "No running workspace containers to refresh: \$workspace" "Refreshed running workspace containers: \$workspace \(%s\)" compose_for_workspace "\$workspace"/);
+});

package/src/core/workspaces.js

@@ -3,7 +3,7 @@ import { existsSync, readdirSync, realpathSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
-import { managerEnvFile, readEnvFile, userManagerDir } from './env.js';
+import { managerEnvFile, managerMcpEndpointsFile, readEnvFile, userManagerDir } from './env.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolve(__dirname, '../..');
@@ -70,15 +70,23 @@ export async function createWorkspace(name, targetPath = null, options = {}) {
   }
   const args = ['config', name];
   if (targetPath) args.push(targetPath);
+  const stateDir = dirname(managerEnvFile());
   const { stdout, stderr } = await execFileAsync(
     join(managerRoot(), 'wiki-workspace'),
     args,
     {
-      cwd: managerRoot(),
+      // Relative Compose mounts and default scaffold paths must resolve from
+      // the user's manager state, never from the globally installed package.
+      cwd: stateDir,
       env: {
         ...process.env,
         WIKI_WORKSPACES_DIR: workspacesDir(),
         WIKI_MANAGER_ENV_FILE: managerEnvFile(),
+        // The script runs from the installed package directory so it can find
+        // its Compose templates. Pin mutable manager state to the user's
+        // launch directory; a global npm package is commonly owned by root
+        // and must never become the destination for this scaffold.
+        WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile(),
       },
       maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
       timeout: options.timeout ?? 600_000,

package/src/orchestrator/dependencyResolver.js

@@ -3,6 +3,9 @@ import { approvalCovered } from './approvalPolicy.js';
 
 const DONE_STATUSES = new Set(['done', 'completed', 'complete', 'success', 'succeeded']);
 const TERMINAL_STATUSES = new Set([...DONE_STATUSES, 'failed', 'cancelled', 'canceled', 'skipped']);
+// A task in one of these statuses hasn't run yet but could become ready —
+// shared with runner.js's scheduler-stall check so the two can't drift apart.
+export const PENDING_STATUSES = new Set(['pending', 'pending_approval', 'waiting_approval']);
 
 export function readyTasks(dag, {
   registry = null,
@@ -18,7 +21,7 @@ export function readyTasks(dag, {
     .filter((task) => {
       const status = statusOf(task);
       return status === 'pending'
-        || ((status === 'waiting_approval' || status === 'pending_approval')
+        || (PENDING_STATUSES.has(status)
           && approvalCovered(task, approvals, {
             runId: task?.runId ?? dag?.runId ?? null,
             workspaceId: dag?.workspace ?? null,
@@ -35,6 +38,21 @@ export function readyTasks(dag, {
     .sort(compareTaskPriority);
 }
 
+export function tasksAwaitingApproval(dag, { approvals = [] } = {}) {
+  const tasks = normalizeTasks(dag);
+  const done = new Set(tasks.filter((task) => DONE_STATUSES.has(statusOf(task))).map(taskId));
+  return tasks
+    .filter((task) => PENDING_STATUSES.has(statusOf(task)))
+    .filter((task) => task?.requiresApproval === true)
+    .filter((task) => !approvalCovered(task, approvals, {
+      runId: task?.runId ?? dag?.runId ?? null,
+      workspaceId: dag?.workspace ?? null,
+      planRevision: dag?.planRevision ?? null,
+    }))
+    .filter((task) => dependenciesDone(task, done))
+    .filter((task) => groupBarrierSatisfied(task, tasks));
+}
+
 function normalizeTasks(dag) {
   if (Array.isArray(dag)) return dag;
   if (Array.isArray(dag?.tasks)) return dag.tasks;

package/src/orchestrator/objectiveResolver.js

@@ -1,6 +1,8 @@
 export async function resolveObjective(objective, session) {
   const candidates = capabilityCandidates(session);
   if (candidates.length === 0) throw new Error('No orchestrable capability is currently available.');
+  const deterministic = resolveMentionedRegistryOperation(objective, candidates);
+  if (deterministic) return selectionWithProvider(session, deterministic, candidates);
   const llm = session?.llm;
   if (!llm?.completeWithTools) throw new Error('Objective resolution requires the configured workspace LLM.');
 
@@ -25,6 +27,28 @@ export async function resolveObjective(objective, session) {
   if (!candidate.operations.includes(operation)) {
     throw new Error(`Objective resolver selected unsupported operation "${operation}" for ${capability}.`);
   }
+  return selectionWithProvider(session, { capability, operation }, candidates);
+}
+
+// Prefer an operation explicitly named by the user when that name resolves to
+// exactly one entry in the live registry. This is deliberately generic: the
+// resolver knows neither capability ids nor business verbs. Prefix matching
+// covers natural inflections such as an operation name followed by a suffix.
+function resolveMentionedRegistryOperation(objective, candidates) {
+  const words = String(objective ?? '')
+    .normalize('NFKD')
+    .replace(/\p{Diacritic}/gu, '')
+    .toLowerCase()
+    .match(/[a-z0-9]+/g) ?? [];
+  const matches = candidates.flatMap((candidate) => candidate.operations
+    .filter((operation) => String(operation).split(/[._-]+/).some((token) =>
+      token.length >= 4 && words.some((word) => word.startsWith(token))))
+    .map((operation) => ({ capability: candidate.id, operation })));
+  return matches.length === 1 ? matches[0] : null;
+}
+
+function selectionWithProvider(session, selection, candidates) {
+  const { capability, operation } = selection;
   const providers = providersFor(session, capability)
     .filter((provider) => !operation || (provider.capability?.supportedOperations ?? []).includes(operation))
     .sort((a, b) => String(a.agentInstanceId).localeCompare(String(b.agentInstanceId)));

package/src/orchestrator/objectiveResolver.test.js

@@ -42,9 +42,31 @@ test('resolveObjective selects and validates one real provider', async () => {
   assert.equal(result.provider.agentInstanceId, 'production-1');
 });
 
+test('resolveObjective uses an unambiguously mentioned registry operation without asking the LLM', async () => {
+  const session = sessionWithSelection({ capability: 'external-source.export', operation: 'export' });
+  session.capabilityRegistry.snapshot = () => ({
+    'knowledge.update@1': [sessionWithSelection({}).capabilityRegistry.snapshot()['knowledge.update@1'][0]],
+    'external-source.export@1': [{
+      agentInstanceId: 'cme-1',
+      serverName: 'cme',
+      capability: { id: 'external-source.export', version: '1', supportedOperations: ['export'] },
+    }],
+  });
+  session.capabilityRegistry.providersFor = (capability) =>
+    session.capabilityRegistry.snapshot()[`${capability}@1`] ?? [];
+  session.llm.completeWithTools = async () => {
+    throw new Error('the explicit operation must not depend on LLM selection');
+  };
+
+  const result = await resolveObjective("lance l'ingestion", session);
+  assert.equal(result.capability, 'knowledge.update');
+  assert.equal(result.operation, 'ingest');
+  assert.equal(result.provider.agentInstanceId, 'production-1');
+});
+
 test('resolveObjective rejects invented capability and operation', async () => {
   await assert.rejects(
-    resolveObjective('Ingère tout', sessionWithSelection({ capability: 'ingest', operation: 'ingest_all_pending' })),
+    resolveObjective('Traite tout', sessionWithSelection({ capability: 'ingest', operation: 'ingest_all_pending' })),
     /unknown capability "ingest"/,
   );
 });

package/src/orchestrator/scheduler.test.js

@@ -4,7 +4,7 @@ import { join } from 'node:path';
 import test from 'node:test';
 
 import { createBudgetManager } from './budgetManager.js';
-import { readyTasks } from './dependencyResolver.js';
+import { readyTasks, tasksAwaitingApproval } from './dependencyResolver.js';
 import { createLockManager } from './lockManager.js';
 import {
   effectiveConcurrency,
@@ -60,6 +60,27 @@ test('dependencyResolver releases a waiting task when a run grant covers it', ()
   }).map((item) => item.id), ['ingest']);
 });
 
+test('dependencyResolver does not request approval for a task blocked by a failed dependency', () => {
+  const plan = {
+    runId: 'run-1',
+    workspace: 'test4',
+    planRevision: 1,
+    tasks: [
+      task('plan', { status: 'failed' }),
+      task('apply', {
+        status: 'waiting_approval',
+        dependsOn: ['plan'],
+        requiresApproval: true,
+        approvalClass: 'mutation',
+      }),
+    ],
+  };
+
+  assert.deepEqual(tasksAwaitingApproval(plan), []);
+  plan.tasks[0].status = 'done';
+  assert.deepEqual(tasksAwaitingApproval(plan).map((item) => item.id), ['apply']);
+});
+
 test('dependencyResolver skips tasks whose locks are not free and keeps other ready work moving', () => {
   const lockManager = createLockManager();
   const held = lockManager.acquire(['deliverable:a.md']);

package/src/runtime/auth.test.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 import { resolveRuntimeAuthToken } from './auth.js';
-import { assertRuntimeNode, runtimeNodeExecutable } from './lifecycle.js';
+import { assertRuntimeNode, runtimeNodeExecutable, shutdownOwnedRuntime } from './lifecycle.js';
 
 test('resolveRuntimeAuthToken: loopback host does not require token', () => {
   const result = resolveRuntimeAuthToken({ host: '127.0.0.1', explicitToken: null });
@@ -27,3 +27,67 @@ test('runtime lifecycle uses a Node executable with node:sqlite support', async
   assert.ok(runtimeNode.executable);
   assert.ok(Number(runtimeNode.version.split('.')[0]) >= 22);
 });
+
+test('shutdownOwnedRuntime reports progress and stops an idle owned runtime', async () => {
+  const originalFetch = globalThis.fetch;
+  const calls = [];
+  const logs = [];
+  globalThis.fetch = async (url, options = {}) => {
+    calls.push({ url: String(url), method: options.method ?? 'GET' });
+    return new Response(JSON.stringify(calls.length === 1 ? { activeRuns: [] } : { shutdown: true }), {
+      status: calls.length === 1 ? 200 : 202,
+      headers: { 'content-type': 'application/json' },
+    });
+  };
+  try {
+    const result = await shutdownOwnedRuntime(
+      { url: 'http://127.0.0.1:7788', started: true, token: null },
+      { log: (message) => logs.push(message), timeoutMs: 100 },
+    );
+    assert.equal(result.action, 'shutdown');
+    assert.deepEqual(calls.map((call) => call.method), ['GET', 'POST']);
+    assert.match(logs.join('\n'), /runtime arrêté/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('shutdownOwnedRuntime also stops an idle reused runtime', async () => {
+  const originalFetch = globalThis.fetch;
+  const calls = [];
+  globalThis.fetch = async (_url, options = {}) => {
+    calls.push(options.method ?? 'GET');
+    return new Response(JSON.stringify(calls.length === 1 ? { activeRuns: [] } : { shutdown: true }), {
+      status: calls.length === 1 ? 200 : 202,
+      headers: { 'content-type': 'application/json' },
+    });
+  };
+  try {
+    const result = await shutdownOwnedRuntime(
+      { url: 'http://127.0.0.1:7788', started: false, token: null },
+      { timeoutMs: 100 },
+    );
+    assert.equal(result.action, 'shutdown');
+    assert.deepEqual(calls, ['GET', 'POST']);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('shutdownOwnedRuntime bounds an unresponsive shutdown', async () => {
+  const originalFetch = globalThis.fetch;
+  const logs = [];
+  globalThis.fetch = async (_url, { signal } = {}) => new Promise((_resolve, reject) => {
+    signal?.addEventListener('abort', () => reject(new DOMException('aborted', 'AbortError')), { once: true });
+  });
+  try {
+    const result = await shutdownOwnedRuntime(
+      { url: 'http://127.0.0.1:7788', started: true, token: null },
+      { log: (message) => logs.push(message), timeoutMs: 5 },
+    );
+    assert.equal(result.action, 'timeout');
+    assert.match(logs.join('\n'), /délai de fermeture/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});

package/src/runtime/client.js

@@ -38,9 +38,11 @@ export async function checkRuntimeHealth({
   url = runtimeUrlFromEnv(),
   token = runtimeToken(),
   workspace = null,
+  signal = null,
 } = {}) {
   const response = await fetch(runtimeEndpoint(url, '/health', workspace), {
     headers: runtimeHeaders(token),
+    signal,
   });
   if (!response.ok) return null;
   return response.json();
@@ -143,10 +145,12 @@ export async function postRuntimeKill({
 export async function postRuntimeShutdown({
   url = runtimeUrlFromEnv(),
   token = runtimeToken(),
+  signal = null,
 } = {}) {
   const response = await fetch(runtimeEndpoint(url, '/shutdown'), {
     method: 'POST',
     headers: runtimeHeaders(token),
+    signal,
   });
   if (!response.ok) throw new Error(`Runtime shutdown failed: HTTP ${response.status}`);
   return response.json();

package/src/runtime/donna-contract.test.js

@@ -259,6 +259,8 @@ test('CME export is dispatched only from an approved DAG task', async () => {
   assert.equal(result.reason, 'awaiting_approval');
   assert.equal(executeCalls, 0);
   assert.equal(session.headlessPlan[0].status, 'waiting_approval');
+  assert.ok(session.agentEvents.some((event) => event.type === 'approval.requested'
+    && event.taskId === session.headlessPlan[0].id));
 });
 
 function buildSingleTaskAgent({ taskId, description, finalResponse }) {

package/src/runtime/lifecycle.js

@@ -127,22 +127,25 @@ async function waitForRuntimeShutdown(url, token, timeoutMs) {
   }
 }
 
-export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = runtimeTokenFromEnv()) {
+export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = runtimeTokenFromEnv(), signal = null) {
   try {
-    return await checkRuntimeHealth({ url, token });
-  } catch {
+    return await checkRuntimeHealth({ url, token, signal });
+  } catch (err) {
+    if (signal?.aborted) throw err;
     return null;
   }
 }
 
-// Contract with the user: the shell OWNS the runtime it started — leaving it
-// alive after exit produced zombie runtimes running yesterday's code and
-// yesterday's endpoints. Nuance preserved: if a run is active anywhere, the
-// runtime is left alive so the run survives the shell (that promise stays).
-export async function shutdownOwnedRuntime(runtime, { log = (_message) => {} } = {}) {
-  if (!runtime?.url || !runtime?.started) return { action: 'kept', reason: 'not_owned' };
+// Close the runtime attached to the shell when it is idle, including a process
+// reused at startup. Restricting cleanup to `started: true` left ownerless
+// runtimes occupying port 7788 with another manager directory/token.
+// An active run still survives the shell.
+export async function shutdownOwnedRuntime(runtime, { log = (_message) => {}, timeoutMs = 3000 } = {}) {
+  if (!runtime?.url) return { action: 'kept', reason: 'unavailable' };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), Math.max(1, Number(timeoutMs) || 3000));
   try {
-    const health = await runtimeHealthOrNull(runtime.url, runtime.token);
+    const health = await runtimeHealthOrNull(runtime.url, runtime.token, controller.signal);
     if (!health) return { action: 'kept', reason: 'unreachable' };
     const activeRuns = Array.isArray(health.activeRuns) ? health.activeRuns : [];
     if (activeRuns.length > 0) {
@@ -152,10 +155,16 @@ export async function shutdownOwnedRuntime(runtime, { log = (_message) => {} } =
       log(`runtime laissé actif : run en cours (${labels}) — il survivra à ce shell ; relance wiki-manager pour le retrouver.`);
       return { action: 'kept', reason: 'run_active', activeRuns };
     }
-    await postRuntimeShutdown({ url: runtime.url, token: runtime.token });
-    log('runtime arrêté (démarré par ce shell, aucun run en cours).');
+    await postRuntimeShutdown({ url: runtime.url, token: runtime.token, signal: controller.signal });
+    log('runtime arrêté (aucun run en cours).');
     return { action: 'shutdown' };
   } catch (err) {
+    if (controller.signal.aborted) {
+      log('délai de fermeture du runtime dépassé — le shell termine sans attendre davantage.');
+      return { action: 'timeout', reason: 'shutdown_timeout' };
+    }
     return { action: 'error', reason: err instanceof Error ? err.message : String(err) };
+  } finally {
+    clearTimeout(timeout);
   }
 }