@dotdrelle/wiki-manager 0.15.40 → 0.15.42

package/src/core/agentLoop.js

@@ -3,6 +3,11 @@ import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
 import { activitySnapshot, newNonTerminalActivities } from './activity.js';
 import { formatCompletedActivities, formatPlanStatus } from './plan.js';
 import { formatReadyTaskPrompt, nextReadyPlanTask, readyPlanTasks, sanitizePlanForExecution } from './planPatch.js';
+import { isActive, isPending, normalizeTaskStatus } from '../orchestrator/taskStatuses.js';
+
+// Les deux formes d'attente d'un accord humain. Distinguées de `pending` :
+// approuver ne les rend pas prêtes de la même manière.
+const isPendingApproval = (status) => ['pending_approval', 'waiting_approval'].includes(normalizeTaskStatus(status));
 
 export function abortError(message = 'Agent run cancelled.') {
   const err = new Error(message);
@@ -111,19 +116,40 @@ export async function runAgenticLoop(agent, session, initialInput, {
     // integrated agent_plan fragment. Prose stays prose.
     sanitizeSessionPlan(session, { runId });
 
+    /*
+     Une décision prise arrête la conversation.
+
+     Dès qu'un fragment structuré est intégré pendant ce tour — Donna vient de
+     déléguer —, la boucle conversationnelle n'a plus rien à décider : le plan
+     existe, validé par l'agent qui l'exécutera. Elle rendait pourtant la main
+     au modèle, parce que le seul critère de bascule était « au moins deux
+     tâches PRÊTES » et qu'un plan intégralement en attente d'approbation n'en
+     compte aucune. Le modèle repartait donc, l'évaluateur jugeait le plan
+     incomplet, le replanificateur relançait une délégation : cinq tâches,
+     puis dix, puis quinze, à l'identique.
+
+     L'attente d'approbation et l'exécution appartiennent au planificateur
+     parallèle, qui sait faire les deux. On lui rend la main tout de suite.
+    */
+    if (parallelHandoff && session._structuredPlanIntegrated) {
+      session._structuredPlanIntegrated = false;
+      return { ok: true, handoff: true };
+    }
+
     const newPending = newNonTerminalActivities(snapshot, session);
     if (newPending.length === 0) {
-      // pending_approval is unfinished work too (a request_approval patch op
-      // sets it) — it must not be treated as "nothing left to do" just
-      // because no step is literally 'pending' anymore.
-      const pending = (session.headlessPlan ?? []).filter((step) => step.status === 'pending' || step.status === 'pending_approval');
+      // Toute attente est du travail inachevé — approbation comprise. La liste
+      // énumérait `pending` et `pending_approval` mais oubliait
+      // `waiting_approval`, que produit justement l'intégration d'un fragment
+      // délégué : un plan entier en attente se lisait « plus rien à faire ».
+      const pending = (session.headlessPlan ?? []).filter((step) => isPending(step.status));
       const pendingSteps = readyPlanTasks(session.headlessPlan);
       if (pending.length === 0) {
         onComplete?.();
         return { ok: true };
       }
       if (pendingSteps.length === 0) {
-        const reason = pending.every((step) => step.status === 'pending_approval') ? 'awaiting_approval' : 'no_ready_plan_task';
+        const reason = pending.every((step) => isPendingApproval(step.status)) ? 'awaiting_approval' : 'no_ready_plan_task';
         onPendingSteps?.({ pendingSteps: pending, blocked: true });
         return { ok: false, stalled: true, reason };
       }
@@ -150,7 +176,7 @@ export async function runAgenticLoop(agent, session, initialInput, {
     const summary = formatCompletedActivities(completed);
     onActivitiesCompleted?.({ completed, summary });
     const unfinished = (session.headlessPlan ?? []).some((step) =>
-      ['pending', 'pending_approval', 'running', 'starting', 'queued'].includes(String(step.status ?? '').toLowerCase()));
+      isPending(step.status) || isActive(step.status));
     if (deterministicTerminalSummary && !unfinished) {
       return { ok: true, completed, summary, deterministicSummary: true };
     }

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.40",
-  "commit": "49ea8ff"
+  "version": "0.15.42",
+  "commit": "d0180aa"
 }

package/src/core/compose.js

@@ -321,6 +321,38 @@ export async function serviceStates(session) {
   return states;
 }
 
+/**
+ * Names of OTHER registered workspaces that still have containers running.
+ *
+ * The external agents (cme, documents, connectors, mailer) are a single
+ * stack shared by every workspace — one Compose project, one set of
+ * containers. `/stop all` took them down unconditionally, so stopping one
+ * workspace silently cut the agents out from under all the others.
+ *
+ * Best effort by design: a workspace whose Compose project cannot be queried
+ * (registry entry pointing at a path that no longer exists, docker refusing)
+ * is reported as NOT running. Erring the other way would make the agents
+ * impossible to stop as soon as one stale registry entry existed.
+ */
+export async function otherWorkspacesRunning(session, workspaces = []) {
+  const current = session?.workspace ?? null;
+  const others = workspaces.filter((workspace) => workspace?.name && workspace.name !== current);
+  const results = await Promise.all(others.map(async (workspace) => {
+    try {
+      const states = await serviceStates({
+        workspace: workspace.name,
+        workspacePath: workspace.workspacePath,
+        workspaceEnvFile: workspace.envFile,
+        workspaceEnv: workspace.env,
+      });
+      return Object.values(states).some((state) => state.running) ? workspace.name : null;
+    } catch {
+      return null;
+    }
+  }));
+  return results.filter(Boolean);
+}
+
 export async function missingServiceImages(service) {
   const aliases = serviceAliases();
   const targets = service ? (aliases[service] ?? [service]) : COMPOSE_SERVICES;

package/src/core/dockerCompose.test.js

@@ -150,3 +150,35 @@ test('missing-image checks ignore agents behind inactive Compose profiles', () =
     ['example/cme:latest', 'example/connectors:latest'],
   );
 });
+
+// Trois variables DOCUMENT_* pour deux conteneurs, chacun n'en déclarant que
+// deux : la question « à quoi ça sert » revient à chaque lecture. Ce test fige
+// le partage pour que la doc reste vraie.
+test('the document handoff keeps input shared and the rest separate', async () => {
+  const workspace = YAML.parse(await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8'));
+  const agents = YAML.parse(await readFile(new URL('../../agents.docker-compose.yml', import.meta.url), 'utf8'));
+  const envOf = (service) => Object.fromEntries(
+    (service.environment ?? []).map((entry) => String(entry).split('=', 2)),
+  );
+
+  const serve = envOf(workspace.services.serve);
+  const documents = envOf(agents.services.documents);
+
+  // `input` est le point de passage : serve y écrit, l'agent y lit.
+  assert.equal(serve.DOCUMENT_INPUT_DIR, '/documents/input');
+  assert.equal(documents.DOCUMENT_INPUT_DIR, '/documents/input');
+  assert.ok(workspace.services.serve.volumes.some((v) => String(v).endsWith(':/documents/input')));
+  assert.ok(agents.services.documents.volumes.some((v) => String(v).endsWith(':/documents/input')));
+
+  // Le manifeste des téléversements n'appartient qu'à serve ; la sortie de
+  // conversion n'appartient qu'à l'agent. Déclarer l'un chez l'autre laisserait
+  // croire à un partage qui n'existe pas.
+  assert.equal(serve.DOCUMENT_UPLOADS_DIR, '/documents/uploads');
+  assert.equal(documents.DOCUMENT_UPLOADS_DIR, undefined);
+  assert.equal(documents.DOCUMENT_OUTPUT_DIR, '/documents/output');
+  assert.equal(serve.DOCUMENT_OUTPUT_DIR, undefined);
+
+  // Le plafond est vérifié des deux côtés, donc déclaré des deux côtés.
+  assert.ok(serve.DOCUMENT_MAX_UPLOAD_BYTES);
+  assert.ok(documents.DOCUMENT_MAX_UPLOAD_BYTES);
+});

package/src/core/jobQueue.js

@@ -1,3 +1,12 @@
+/**
+ * @statuses-vocabulary
+ *
+ * JOB queue statuses. A queued job has its own lifecycle, independent of
+ * the task that may have enqueued it.
+ *
+ * Declared here rather than in a central exception list so the waiver
+ * travels with the code it excuses (see orchestrator/taskStatuses.test.js).
+ */
 import { randomUUID } from 'node:crypto';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { extractActivity, parseJsonText, sessionActivities } from './activity.js';

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

package/src/core/otherWorkspacesRunning.test.js

@@ -0,0 +1,51 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { otherWorkspacesRunning } from './compose.js';
+
+// `otherWorkspacesRunning` shells out to `docker compose ps` per workspace.
+// Docker is not available in the test environment, so every probe throws —
+// which is itself the behaviour worth pinning: a workspace that cannot be
+// queried must read as NOT running, or one stale registry entry would make
+// the shared agents impossible to stop for good.
+
+function workspaceEntry(root, name) {
+  const registryPath = join(root, name);
+  mkdirSync(registryPath, { recursive: true });
+  const envFile = join(registryPath, '.env');
+  writeFileSync(envFile, `WORKSPACE_NAME=${name}\nWIKI_WORKSPACE_PATH=${registryPath}\n`, 'utf8');
+  return {
+    name,
+    registryPath,
+    envFile,
+    workspacePath: registryPath,
+    env: { WORKSPACE_NAME: name, WIKI_WORKSPACE_PATH: registryPath },
+  };
+}
+
+test('the current workspace is never counted as another one', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'ws-running-self-'));
+  const acpi = workspaceEntry(root, 'acpi');
+
+  const busy = await otherWorkspacesRunning({ workspace: 'acpi' }, [acpi]);
+
+  assert.deepEqual(busy, [], 'stopping a workspace must not be blocked by itself');
+});
+
+test('an unqueryable workspace does not hold the shared agents hostage', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'ws-running-unknown-'));
+  const workspaces = [workspaceEntry(root, 'acpi'), workspaceEntry(root, 'stale')];
+
+  const busy = await otherWorkspacesRunning({ workspace: 'acpi' }, workspaces);
+
+  assert.deepEqual(busy, []);
+});
+
+test('a single workspace, or none at all, never blocks', async () => {
+  assert.deepEqual(await otherWorkspacesRunning({ workspace: 'acpi' }, []), []);
+  assert.deepEqual(await otherWorkspacesRunning({}, []), []);
+  // Entries without a name are registry noise, not workspaces.
+  assert.deepEqual(await otherWorkspacesRunning({ workspace: 'acpi' }, [{}, null]), []);
+});

package/src/core/plan.js

@@ -1,3 +1,4 @@
+import { isUnsuccessfulTerminal } from '../orchestrator/taskStatuses.js';
 export function ensurePlanFromActivity(session, activity) {
   if (!activity) return;
   const actKey = activity.key ?? null;
@@ -57,7 +58,7 @@ export function syncActivitiesToPlan(plan, activities) {
   const contractTaskPlan = isContractTaskPlan(plan);
   for (const activity of activities ?? []) {
     const terminal = Boolean(activity.terminal);
-    const failed = ['failed', 'error', 'cancelled', 'canceled'].includes(String(activity.status).toLowerCase());
+    const failed = isUnsuccessfulTerminal(activity.status);
     const actKey = activity.key ?? activity.id ?? activity.jobId ?? null;
     const structuredMatch = findMatchingPlanStepByStructure(plan, activity);
     const matched = structuredMatch ?? findMatchingPlanStep(plan, activity);
@@ -244,7 +245,7 @@ export function attachActivityToExistingPlan(plan, activity) {
   if (!matched) return;
   matched.activityKey = actKey;
   if (!matched.ownerActivityKey) matched.ownerActivityKey = actKey;
-  const failed = ['failed', 'error', 'cancelled', 'canceled'].includes(String(activity.status).toLowerCase());
+  const failed = isUnsuccessfulTerminal(activity.status);
   if (activity.terminal) {
     matched.status = failed ? 'failed' : 'done';
     return;

package/src/core/planPatch.js

@@ -1,4 +1,5 @@
 import { validateContractInDev } from '../contracts/schemas.js';
+import { isUnsuccessfulTerminal } from '../orchestrator/taskStatuses.js';
 
 const PATCH_OPS = new Set([
   'add_task',
@@ -164,7 +165,7 @@ export function sanitizePlanForExecution(plan) {
   const done = new Set(tasks.filter((task) => task.status === 'done').map(taskId));
   const terminalBlocked = new Set(
     tasks
-      .filter((task) => ['failed', 'cancelled', 'canceled'].includes(String(task.status).toLowerCase()))
+      .filter((task) => isUnsuccessfulTerminal(task.status))
       .map(taskId),
   );
   const hasReady = pending.some((task) => task.dependsOn.every((dep) => done.has(String(dep))));

package/src/core/profileServiceStatus.test.js

@@ -82,8 +82,32 @@ test('"all" means the same thing to start and to stop', () => {
   // `/start all` démarrait les agents, `/stop all` ne les arrêtait pas : la
   // séquence start/stop ne revenait donc pas à l'état de départ.
   assert.match(slash, /const startsAgents = service === 'all';/);
-  assert.match(slash, /const stopsAgents = service === 'all';/);
-  assert.match(slash, /if \(stopsAgents\) \{\s*\n\s*const agentsResult = await runAgentCommand\(stopAgents, 'stop'\);/);
+  assert.match(slash, /const stopsAgents = service === 'all' \|\| stopsEverything;/);
+});
+
+test('stopping one workspace never takes the shared agents from another', () => {
+  const slash = readFileSync(fileURLToPath(new URL('../commands/slash.js', import.meta.url)), 'utf8');
+  // Les agents externes sont UNE pile partagée. `/stop all` les arrêtait sans
+  // condition : couper un workspace coupait tous les autres, qui ne voyaient
+  // qu'une panne.
+  assert.match(slash, /await otherWorkspacesRunning\(context\.session, listWorkspaces\(\)\)/);
+  assert.match(slash, /if \(busy\.length > 0\) \{/);
+  // Le renoncement doit se dire : un saut silencieux ressemble exactement au
+  // bug d'origine.
+  assert.match(slash, /agents left running for \$\{busy\.join\(', '\)\}/);
+  assert.match(slash, /use \/stop everything to stop them anyway/);
+  // `everything` court-circuite la garde, et c'est son seul intérêt.
+  assert.match(slash, /const busy = stopsEverything\s*\n\s*\? \[\]/);
+});
+
+test('the everything escape hatch is discoverable', () => {
+  const slash = readFileSync(fileURLToPath(new URL('../commands/slash.js', import.meta.url)), 'utf8');
+  const repl = readFileSync(fileURLToPath(new URL('../shell/repl.js', import.meta.url)), 'utf8');
+  // Une porte de sortie qui n'apparaît ni dans l'aide ni dans la complétion
+  // n'existe pas pour l'opérateur qui en a besoin.
+  assert.match(slash, /\/stop \[all\|everything\|service\|agents\]/);
+  assert.match(repl, /command === '\/stop' && tokenIndex === 1\) return \['all', 'everything'/);
+  assert.match(repl, /if \(value === 'everything'\)/);
 });
 
 test('the addressable agents are read from the compose file, never hard-coded', async () => {

package/src/core/toolLoop.js

@@ -12,6 +12,13 @@
 //
 // `executeCall` may throw to abort the whole loop (e.g. an AbortError on
 // cancel); anything it returns is treated as the tool result for that call.
+/**
+ * @param onTextDelta appelé au fil de la génération. Une itération qui finit
+ *   par des appels d'outils ne produit pas de réponse lisible : ses fragments
+ *   sont donc rejetés a posteriori via `onTextReset`, pour ne pas afficher un
+ *   raisonnement intermédiaire que le tour suivant remplacera.
+ * @param onTextReset appelé quand les fragments déjà émis sont à jeter.
+ */
 export async function runBoundedToolLoop({
   llm,
   system,
@@ -21,19 +28,37 @@ export async function runBoundedToolLoop({
   maxIterations = 4,
   signal,
   onStep,
+  onTextDelta,
+  onTextReset,
 } = {}) {
   const cap = Math.max(1, Math.floor(maxIterations) || 1);
   const convo = [...(messages ?? [])];
+  // `streamWithTools` accumule les appels d'outils exactement comme
+  // `completeWithTools` et renvoie la même forme : le seul écart est qu'il
+  // 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';
   for (let i = 0; i < cap; i += 1) {
     onStep?.(i + 1, cap);
-    const result = await llm.completeWithTools({
-      system,
-      tools,
-      messages: convo,
-      toolChoice: 'auto',
-      signal,
-    });
+    let streamedText = false;
+    const result = canStream
+      ? await llm.streamWithTools({
+          system,
+          tools,
+          messages: convo,
+          toolChoice: 'auto',
+          onTextDelta: (delta) => { streamedText = true; onTextDelta(delta); },
+          signal,
+        })
+      : await llm.completeWithTools({
+          system,
+          tools,
+          messages: convo,
+          toolChoice: 'auto',
+          signal,
+        });
     const calls = result?.tool_calls ?? [];
+    if (calls.length > 0 && streamedText) onTextReset?.();
     if (calls.length === 0) {
       return {
         content: result?.content ?? result?.message?.content ?? '',

package/src/core/toolLoop.test.js

@@ -86,3 +86,98 @@ test('propagates an abort thrown by executeCall', async () => {
     /aborted/,
   );
 });
+
+// Le tour paraissait figé pendant toute sa durée : la réponse n'apparaissait
+// qu'une fois complète, parce que la boucle n'appelait que completeWithTools.
+test('streams the answer when the caller asks for deltas', async () => {
+  const deltas = [];
+  const llm = {
+    async completeWithTools() { throw new Error('streamWithTools devait être préféré'); },
+    async streamWithTools({ onTextDelta }) {
+      onTextDelta('Le wiki ');
+      onTextDelta('contient 12 pages.');
+      return { content: 'Le wiki contient 12 pages.', tool_calls: [] };
+    },
+  };
+
+  const out = await runBoundedToolLoop({
+    llm,
+    tools: [],
+    executeCall: async () => 'unused',
+    onTextDelta: (delta) => deltas.push(delta),
+  });
+
+  assert.deepEqual(deltas, ['Le wiki ', 'contient 12 pages.']);
+  assert.equal(out.content, 'Le wiki contient 12 pages.');
+});
+
+test('keeps the non-streaming path when no delta callback is given', async () => {
+  let streamed = false;
+  const llm = {
+    async completeWithTools() { return { content: 'plain', tool_calls: [] }; },
+    async streamWithTools() { streamed = true; return { content: 'streamed', tool_calls: [] }; },
+  };
+
+  const out = await runBoundedToolLoop({ llm, tools: [], executeCall: async () => 'unused' });
+
+  assert.equal(streamed, false, 'sans onTextDelta, rien ne doit changer');
+  assert.equal(out.content, 'plain');
+});
+
+test('discards text emitted by an iteration that ends in tool calls', async () => {
+  // Un modèle peut écrire un raisonnement puis décider d'appeler un outil. Ce
+  // texte est remplacé par le tour suivant : le laisser afficherait des
+  // paragraphes qui disparaissent, pire que pas de streaming du tout.
+  let round = 0;
+  const deltas = [];
+  let resets = 0;
+  const llm = {
+    async streamWithTools({ onTextDelta }) {
+      round += 1;
+      if (round === 1) {
+        onTextDelta('Je vais regarder…');
+        const calls = [toolCall('c1', 'wiki__wiki_list_pages')];
+        return { message: { role: 'assistant', content: '', tool_calls: calls }, tool_calls: calls };
+      }
+      onTextDelta('12 pages.');
+      return { content: '12 pages.', tool_calls: [] };
+    },
+  };
+
+  const out = await runBoundedToolLoop({
+    llm,
+    tools: [],
+    executeCall: async () => 'ok',
+    onTextDelta: (delta) => deltas.push(delta),
+    onTextReset: () => { resets += 1; },
+  });
+
+  assert.deepEqual(deltas, ['Je vais regarder…', '12 pages.']);
+  assert.equal(resets, 1, 'le texte intermédiaire doit être annulé, une fois');
+  assert.equal(out.content, '12 pages.');
+});
+
+test('never asks to discard text that was never emitted', async () => {
+  let resets = 0;
+  let round = 0;
+  const llm = {
+    async streamWithTools() {
+      round += 1;
+      if (round === 1) {
+        const calls = [toolCall('c1', 'wiki__wiki_list_pages')];
+        return { message: { role: 'assistant', content: '', tool_calls: calls }, tool_calls: calls };
+      }
+      return { content: 'fini', tool_calls: [] };
+    },
+  };
+
+  await runBoundedToolLoop({
+    llm,
+    tools: [],
+    executeCall: async () => 'ok',
+    onTextDelta: () => {},
+    onTextReset: () => { resets += 1; },
+  });
+
+  assert.equal(resets, 0);
+});

package/src/core/wikiSetup.js

@@ -5,7 +5,8 @@ import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 import YAML from 'yaml';
 import { checkMissingDockerImages } from './dockerImages.js';
-import { patchWikircProfile } from './wikirc.js';
+import { loadWikircProfile, patchWikircProfile } from './wikirc.js';
+import { buildInheritedWikircPatch, copyCmeCredentials } from './workspaceInherit.js';
 import { resolveAgentsComposeContext } from './agentsCompose.js';
 import { managerEnvFile, managerMcpEndpointsFile, resolveAgentsDataDir } from './env.js';
 import { createWorkspace, findWorkspace, isValidWorkspaceName, listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
@@ -208,20 +209,62 @@ export async function refreshRunningContainers(options = {}) {
   return { skipped: false, refreshed, errors };
 }
 
-export async function createNewWorkspace(name, targetPath) {
+export async function createNewWorkspace(name, targetPath, options = {}) {
   try {
     const output = await createWorkspace(name, targetPath, { timeout: 600_000 });
-    const workspace = finalizeCreatedWorkspace(name);
-    return { output, workspace };
+    const { workspace, inherited } = await finalizeCreatedWorkspace(name, options);
+    return { output, workspace, inherited };
   } catch (err) {
     throw wrapDockerError(err);
   }
 }
 
-export function finalizeCreatedWorkspace(name) {
+/**
+ * @param options.inheritFrom name of the workspace to copy LLM config and CME
+ *   credentials from — normally the session's current workspace. Omitted, or
+ *   unknown, means "scaffold defaults only", the previous behaviour.
+ */
+export async function finalizeCreatedWorkspace(name, options = {}) {
   const workspace = findWorkspace(name);
-  if (workspace) initializeWorkspaceWikirc(workspace);
-  return workspace;
+  if (!workspace) return { workspace: null, inherited: [] };
+  // Order matters: the access key is this workspace's own credential and must
+  // land before anything else touches the file.
+  initializeWorkspaceWikirc(workspace);
+  const inherited = await inheritWorkspaceSetup(workspace, options.inheritFrom ?? null);
+  return { workspace, inherited };
+}
+
+/**
+ * Carry an existing workspace's proven setup over to a new one. Best effort by
+ * design: a workspace that exists and works must never fail to be created
+ * because the workspace next door has an unreadable config.
+ */
+export async function inheritWorkspaceSetup(workspace, sourceName) {
+  if (!workspace?.workspacePath || !sourceName || sourceName === workspace.name) return [];
+  const source = findWorkspace(sourceName);
+  if (!source?.workspacePath) return [];
+
+  const inherited = [];
+  try {
+    const { config: sourceConfig } = loadWikircProfile(source.workspacePath, 'default');
+    const { config: targetConfig } = loadWikircProfile(workspace.workspacePath, 'default');
+    const { patch, inherited: keys } = buildInheritedWikircPatch(sourceConfig, targetConfig);
+    if (keys.length > 0) {
+      patchWikircProfile(workspace.workspacePath, 'default', patch);
+      inherited.push(...keys);
+    }
+  } catch {
+    // Unreadable or absent profile on either side — nothing to inherit.
+  }
+
+  try {
+    const copied = await copyCmeCredentials(resolveAgentsDataDir(), source.name, workspace.name);
+    if (copied) inherited.push('cme.app_data.json');
+  } catch {
+    // Credentials are a convenience, not a prerequisite.
+  }
+
+  return inherited;
 }
 
 export function initializeWorkspaceWikirc(workspace) {

package/src/core/wikiWorkspace.test.js

@@ -105,3 +105,33 @@ test('container refresh pulls and renews only services that are already running'
   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"/);
 });
+
+// `${arr[@]}` on an empty array is an unbound-variable error under `set -u` in
+// bash <= 4.3, and macOS still ships /bin/bash 3.2. `parse_global_options`
+// tripped on it, so `wiki-workspace` with no global option died before reaching
+// any subcommand.
+//
+// The execution check below cannot catch a regression on a CI running bash 5,
+// where an empty array is legal — hence the source assertion that every
+// optional array keeps the `${arr[@]+"${arr[@]}"}` guard. Both are needed.
+test('optional arrays keep the empty-array guard required by bash 3.2', async () => {
+  const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
+
+  for (const name of ['parsed', 'PARSED_ARGS', 'log_args']) {
+    const unguarded = new RegExp(String.raw`(?<!\+)"\$\{${name}\[@\]\}"`);
+    assert.doesNotMatch(script, unguarded, `${name}[@] must use the \${name[@]+"..."} guard`);
+  }
+  assert.match(script, /set -- \$\{parsed\[@\]\+"\$\{parsed\[@\]\}"\}/);
+  assert.match(script, /set -- \$\{PARSED_ARGS\[@\]\+"\$\{PARSED_ARGS\[@\]\}"\}/);
+});
+
+test('wiki-workspace reaches its usage text with no arguments', async () => {
+  const { spawnSync } = await import('node:child_process');
+  const scriptPath = new URL('../../wiki-workspace', import.meta.url).pathname;
+
+  const result = spawnSync('bash', [scriptPath], { encoding: 'utf8' });
+
+  assert.doesNotMatch(`${result.stdout}${result.stderr}`, /unbound variable/);
+  assert.match(result.stdout, /^Usage:/);
+  assert.equal(result.status, 2);
+});