@dotdrelle/wiki-manager 0.15.40 → 0.15.42

package/src/runtime/runner.test.js

@@ -1,7 +1,10 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
-import { ensurePlanProjection, evaluateRuntimeRun, finishRuntimeRun, materializeTaskInputs, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan, shouldUseParallelScheduler } from './runner.js';
+import { createAgentEvent, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
+import { tasksAwaitingApproval } from '../orchestrator/dependencyResolver.js';
+import { isTerminal } from '../orchestrator/taskStatuses.js';
+import { readyPlanTasks } from '../core/planPatch.js';
+import { skipImpossibleTasks, structuredPlanEvaluation, ensurePlanProjection, evaluateRuntimeRun, finishRuntimeRun, materializeTaskInputs, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan, shouldUseParallelScheduler } from './runner.js';
 
 test('ensurePlanProjection re-projects when the chained plan changes shape (step 2)', () => {
   const session = { agentEvents: [], agentProjection: null };
@@ -821,7 +824,17 @@ test('runRuntimeParallelPlan fails cleanly when scheduler budget is exceeded', a
   assert.equal(session.headlessPlan[0].status, 'cancelled');
 });
 
-test('runRuntimeParallelPlan does not wait for approval behind a failed dependency', async () => {
+/*
+ Ce test gardait l'ancien comportement : la tâche bloquée derrière un échec
+ laissait le run « stalled ». Ne pas attendre d'approbation était déjà acquis,
+ mais s'arrêter là déclenchait une replanification et laissait le run vivant.
+
+ Cas observé le 2026-08-04 (workspace juno) : dix fichiers à ingérer, neuf
+ réussis, un en échec sur du JSON malformé — le run n'est jamais retombé.
+ Une tâche qui ne deviendra jamais exécutable est donc marquée `skipped` avec
+ le nom de la dépendance fautive, et le run se termine sur un résultat partiel.
+*/
+test('runRuntimeParallelPlan skips work stuck behind a failed dependency instead of stalling', async () => {
   const session = {
     workspace: 'demo-workspace',
     mcp: { tools: {} },
@@ -844,11 +857,17 @@ test('runRuntimeParallelPlan does not wait for approval behind a failed dependen
     { runId: 'run-failed-dependency', timeoutMs: 1000, maxTurns: 1 },
   );
 
-  assert.equal(result.ok, false);
-  assert.equal(result.stalled, true);
-  assert.equal(result.reason, 'no_ready_plan_task');
+  // Plus de blocage : le run retombe au lieu de rester actif indéfiniment.
+  assert.notEqual(result.stalled, true);
+  assert.equal(session.headlessPlan[1].status, 'skipped');
+  assert.equal(session.headlessPlan[1].error?.code, 'dependency_failed');
+  // Le motif nomme la dépendance fautive : sans lui, l'utilisateur voit une
+  // tâche disparaître sans savoir pourquoi.
+  assert.match(session.headlessPlan[1].error.message, /\ba\b/);
   assert.equal(session.agentEvents.some((event) => event.type === 'assistant_message'
     && /Approbation requise/.test(event.payload?.content ?? '')), false);
+  assert.equal(session.agentEvents.some((event) => event.type === 'plan_step_updated'
+    && event.payload?.status === 'skipped'), true);
 });
 
 test('runRuntimeParallelPlan retries a retryable task on a fallback agent', async () => {
@@ -1083,3 +1102,131 @@ test('runtime runs are seeded with the chat that preceded them', async () => {
   assert.equal(clipped.length, 1);
   assert.equal(clipped[0].content.length, 2000);
 });
+
+test('skipImpossibleTasks propage un échec jusqu’au point fixe', () => {
+  /*
+   Marquer les seules tâches directement bloquées laissait un résidu : A en
+   échec rend B impossible, mais C dépend de B et serait resté en attente
+   d'une tâche désormais terminale sans succès. La propagation doit descendre
+   toute la chaîne en une fois.
+  */
+  const session = { workspace: 'demo-workspace', agentEvents: [] };
+  const steps = [
+    { id: 'a', step: 1, status: 'failed' },
+    { id: 'b', step: 2, status: 'pending', dependsOn: ['a'] },
+    { id: 'c', step: 3, status: 'pending', dependsOn: ['b'] },
+    { id: 'independent', step: 4, status: 'pending', dependsOn: [] },
+  ];
+  // Le plan passe par la projection, comme en production : chaque dépêche
+  // remplace session.headlessPlan, et c'est précisément ce qui rendait une
+  // référence capturée orpheline.
+  dispatchAgentEvent(session, createAgentEvent('plan_set', { origin: 'tool', payload: { steps } }));
+
+  const skipped = skipImpossibleTasks(session, 'run-fixpoint');
+
+  assert.equal(skipped, 2);
+  assert.equal(session.headlessPlan[1].status, 'skipped');
+  assert.equal(session.headlessPlan[2].status, 'skipped');
+  // La branche indépendante n'est pas touchée : c'est tout l'objet du
+  // correctif, laisser finir ce qui peut finir.
+  assert.equal(session.headlessPlan[3].status, 'pending');
+  assert.equal(session.agentEvents.filter((event) => event.payload?.status === 'skipped').length, 2);
+});
+
+test('skipImpossibleTasks s’arrête au lieu de tourner sans rien changer', () => {
+  // Sans garde-fou, une incohérence de statut se paierait en boucle infinie,
+  // c'est-à-dire en run figé — exactement ce que l'on répare.
+  const session = { workspace: 'demo-workspace', agentEvents: [] };
+  dispatchAgentEvent(session, createAgentEvent('plan_set', {
+    origin: 'tool',
+    payload: {
+      steps: [
+        { id: 'a', step: 1, status: 'failed' },
+        { id: 'b', step: 2, status: 'skipped', dependsOn: ['a'] },
+      ],
+    },
+  }));
+  const eventsBefore = session.agentEvents.length;
+
+  assert.equal(skipImpossibleTasks(session, 'run-guard', { maxPasses: 3 }), 0);
+  assert.equal(session.agentEvents.length, eventsBefore);
+});
+
+test('structuredPlanEvaluation compte séparément, sans fraction trompeuse', () => {
+  const task = (id, status) => ({
+    id, status, label: `Task ${id}`, requiredCapability: 'knowledge.update', operation: 'ingest',
+  });
+
+  const allDone = structuredPlanEvaluation([task('a', 'done'), task('b', 'succeeded')]);
+  assert.equal(allDone.ok, true);
+
+  const partial = structuredPlanEvaluation([
+    task('a', 'done'), task('b', 'failed'), task('c', 'skipped'),
+  ]);
+  assert.equal(partial.ok, false);
+  // Trois compteurs qui s'additionnent, pas un « 1/3 » dont le dénominateur
+  // mêlerait tâches métier et étapes techniques.
+  assert.match(partial.reason, /1 réussie\(s\)/);
+  assert.match(partial.reason, /1 en échec/);
+  assert.match(partial.reason, /1 ignorée\(s\)/);
+  assert.doesNotMatch(partial.reason, /\d+\/\d+/);
+
+  // Uniquement des ignorées : jamais un succès.
+  const onlySkipped = structuredPlanEvaluation([task('a', 'skipped')]);
+  assert.equal(onlySkipped.ok, false);
+
+  // Succès + ignorée sans échec : toujours pas un succès.
+  const doneAndSkipped = structuredPlanEvaluation([task('a', 'done'), task('b', 'skipped')]);
+  assert.equal(doneAndSkipped.ok, false);
+
+  // Statut actif ou inconnu : incomplet, jamais réussi.
+  for (const status of ['running', 'brouette']) {
+    const pending = structuredPlanEvaluation([task('a', 'done'), task('b', status)]);
+    assert.equal(pending.ok, false, status);
+    assert.match(pending.reason, /non terminée/);
+  }
+});
+
+test('une tâche ignorée est terminale pour la reprise et pour les approbations', () => {
+  /*
+   Vérifications transversales sur le nouveau statut : il ne suffit pas que
+   l'ordonnanceur le comprenne. S'il n'est pas terminal pour la reprise, le
+   redémarrage réattache un run fantôme ; s'il n'est pas terminal pour la
+   politique d'approbation, on demande un accord pour une tâche qui ne sera
+   jamais exécutée.
+  */
+  const skippedTask = {
+    id: 'ingest-b',
+    status: 'skipped',
+    requiresApproval: true,
+    requiredCapability: 'knowledge.update',
+    operation: 'ingest_apply',
+  };
+
+  assert.equal(isTerminal(skippedTask.status), true);
+  assert.deepEqual(tasksAwaitingApproval([skippedTask], { approvals: [] }), []);
+  assert.deepEqual(readyPlanTasks([skippedTask]).map((task) => task.id), []);
+});
+
+test('rejouer les événements redonne exactement les mêmes statuts', () => {
+  // La projection est reconstruite au démarrage à partir du journal : si le
+  // rejeu ne rendait pas le même état, une tâche ignorée pourrait réapparaître
+  // en attente et relancer un travail déjà abandonné.
+  const events = [
+    createAgentEvent('plan_set', { origin: 'tool', payload: { steps: ['A', 'B'] } }),
+    createAgentEvent('plan_step_updated', { origin: 'runtime', payload: { step: 1, status: 'failed' } }),
+    createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      payload: { step: 2, status: 'skipped', reason: 'dependency_failed:A' },
+    }),
+  ];
+
+  const first = reduceAgentEvents(events);
+  const replayed = reduceAgentEvents(events);
+
+  assert.deepEqual(
+    replayed.plan.map((step) => step.status),
+    first.plan.map((step) => step.status),
+  );
+  assert.deepEqual(replayed.plan.map((step) => step.status), ['failed', 'skipped']);
+});

package/src/runtime/server.test.js

@@ -76,6 +76,34 @@ test('interactive turns publish a fallback assistant message exactly once', () =
   assert.equal(published[0].payload.content, 'Réponse concise.');
 });
 
+test('a turn that produces nothing still ends with an assistant message', () => {
+  // C'est la condition de fin que serve attend : la bulle « Request received ·
+  // Donna is preparing… » n'est retirée qu'à l'arrivée d'un message assistant
+  // non vide. Sans message, le point d'attente tournait indéfiniment, sans
+  // erreur nulle part et sans autre issue qu'un rechargement de page.
+  const published = [];
+  const session = { agentEvents: [], _onAgentEvent: (event) => published.push(event) };
+
+  assert.equal(ensureInteractiveAssistantMessage(session, '', { turnId: 'turn-1', workspace: 'demo' }), true);
+
+  assert.equal(published.length, 1);
+  assert.equal(published[0].type, 'assistant_message');
+  assert.match(published[0].payload.content, /No answer was produced/);
+  // Le message doit dire quoi faire, pas seulement constater.
+  assert.match(published[0].payload.content, /\/agent/);
+});
+
+test('a turn whose loop already answered does not answer twice', () => {
+  const published = [];
+  const session = {
+    agentEvents: [{ type: 'assistant_message' }],
+    _onAgentEvent: (event) => published.push(event),
+  };
+
+  assert.equal(ensureInteractiveAssistantMessage(session, '', { turnId: 'turn-1' }), false);
+  assert.equal(published.length, 0);
+});
+
 test('runtime state rebuilds interactive conversation from persisted events', () => {
   const user = {
     ...createAgentEvent('user_message', { origin: 'runtime_turn', turnId: 'turn-1', workspace: 'demo', payload: { content: 'Bonjour' } }),

package/src/runtime/store.js

@@ -1,3 +1,12 @@
+/**
+ * @statuses-vocabulary
+ *
+ * RUN lifecycle statuses, not task statuses: a run can be `interrupted`,
+ * a task never is.
+ *
+ * Declared here rather than in a central exception list so the waiver
+ * travels with the code it excuses (see orchestrator/taskStatuses.test.js).
+ */
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -6,6 +15,8 @@ import { defaultRuntimeStateDir } from '../core/env.js';
 import { projectQueue } from '../core/jobQueue.js';
 import { projectWorkflow } from '../core/workflow.js';
 import { createCapabilityRegistry } from '../orchestrator/capabilityRegistry.js';
+import { isSuccessful } from '../orchestrator/taskStatuses.js';
+import { markPersistedAgentsStale } from '../orchestrator/agentRegistry.js';
 
 export { defaultRuntimeStateDir };
 
@@ -1121,7 +1132,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
 
   function attemptStatusForResult(status, eventType) {
     const normalized = String(status ?? '').toLowerCase();
-    if (['succeeded', 'success', 'done', 'complete', 'completed'].includes(normalized)) return 'done';
+    if (isSuccessful(normalized)) return 'done';
     if (['cancelled', 'canceled'].includes(normalized)) return 'cancelled';
     if (eventType === 'task.failed') return 'failed';
     return normalized || 'finished';
@@ -1265,6 +1276,10 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   function hydrateSession(session, { workspace = null } = {}) {
     const projection = replayEvents(session, { workspace });
     applyAgentProjectionToSession(session, projection);
+    // Le journal restitue les agents avec la santé qu'ils avaient à l'écriture
+    // de l'événement. Les reprendre tels quels les faisait réapparaître
+    // « disponibles » après un redémarrage, endpoint éteint compris.
+    markPersistedAgentsStale(session);
     session.jobQueue = listQueue({ workspace });
     return projection;
   }

package/src/runtime/store.test.js

@@ -6,6 +6,7 @@ import { DatabaseSync } from 'node:sqlite';
 import test from 'node:test';
 import { conversationEventSequences, createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { openRuntimeStore } from './store.js';
+import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
 
 function runtimeStateDir() {
   return join(mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-')), '.wiki', 'runtime');
@@ -1106,3 +1107,52 @@ test('deleteEventsAfter removes bookkeeping only for runs entirely produced by t
   assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM task_attempts').get().n, 1);
   store.close();
 });
+
+test('un agent restauré par hydrateSession n’est plus routable tant qu’aucun scan n’a réussi', () => {
+  /*
+   Validation à chaud du 2026-08-04 : après redémarrage, `cme-main` restait
+   `available` et `external-source.export` gardait un fournisseur, alors que
+   l'endpoint CME était arrêté. Le test précédent construisait `session.agents`
+   à la main et ratait donc le vrai chemin — celui où l'état vient du journal.
+
+   On hydrate ici depuis de véritables événements persistés, comme au
+   démarrage : hydrate → invalidate → discover, sans scan entre les deux
+   premiers.
+  */
+  const store = openRuntimeStore({ stateDir: mkdtempSync(join(tmpdir(), 'wiki-manager-agent-staleness-')) });
+  const writer = { agentEvents: [], workspace: 'juno' };
+  dispatchAgentEvent(writer, createAgentEvent('agent.registered', {
+    origin: 'runtime',
+    workspace: 'juno',
+    payload: {
+      agent: {
+        agentInstanceId: 'cme-main',
+        serverName: 'cme',
+        health: 'available',
+        description: {
+          agentType: 'cme',
+          contractVersion: '1',
+          agentInstanceId: 'cme-main',
+          capabilities: [{ id: 'external-source.export', version: '1' }],
+        },
+      },
+    },
+  }));
+  for (const event of writer.agentEvents) store.persistEvent(event);
+
+  // Redémarrage : une session neuve, aucun scan encore effectué.
+  const rebooted = { agentEvents: [], workspace: 'juno' };
+  store.hydrateSession(rebooted, { workspace: 'juno' });
+
+  const restored = [...(rebooted.agents ?? []), ...(rebooted.agentRegistrySnapshot ?? [])];
+  assert.ok(restored.length > 0, 'the agent must be restored, only not trusted');
+  for (const agent of restored) {
+    assert.equal(agent.health, 'unknown');
+    assert.equal(agent.stale, true);
+  }
+  // Le seul point qui compte vraiment : plus aucun fournisseur sélectionnable.
+  assert.deepEqual(
+    capabilityRegistryForSession(rebooted).providersFor('external-source.export'),
+    [],
+  );
+});

package/src/shell/repl.js

@@ -1,3 +1,4 @@
+import { isTerminal } from '../orchestrator/taskStatuses.js';
 import { createInterface } from 'node:readline';
 import { emitKeypressEvents } from 'node:readline';
 import { Transform } from 'node:stream';
@@ -344,7 +345,7 @@ function completionValuesFor(parts, inputBuffer, session) {
   // Vocabulaire de l'opérateur uniquement : `serviceChoices()` écarte les noms
   // Compose bruts que les alias désignent déjà. Ils restent tapables.
   if (command === '/start' && tokenIndex === 1) return ['all', 'agents', 'services', ...serviceChoices(), ...togglableAgents()];
-  if (command === '/stop' && tokenIndex === 1) return ['all', 'agents', 'services', ...serviceChoices(), ...togglableAgents()];
+  if (command === '/stop' && tokenIndex === 1) return ['all', 'everything', 'agents', 'services', ...serviceChoices(), ...togglableAgents()];
   if (command === '/logs' && tokenIndex === 1) return ['all', ...serviceChoices()];
   return [];
 }
@@ -582,7 +583,8 @@ export function completionDescription(value, parts) {
     return serviceDescription(value) ?? 'Start this Docker Compose service.';
   }
   if (command === '/stop') {
-    if (value === 'all') return 'Everything: workspace services AND external agents.';
+    if (value === 'all') return 'This workspace, agents included — unless another workspace still needs them.';
+    if (value === 'everything') return 'This workspace AND the shared agents, even if other workspaces are using them.';
     if (value === 'agents' || value === 'agent') return 'External agents only.';
     if (value === 'services') return 'Workspace services only.';
     if (togglableAgents().includes(value)) return `Stop only the ${value} agent, leaving the other agents running.`;
@@ -1006,7 +1008,7 @@ function productionActivityFromPayload(payload) {
     jobId: jobId ?? null,
     status,
     label: detail ? `Production: ${detail}` : `Production: ${status}`,
-    terminal: ['done', 'failed', 'cancelled'].includes(String(status)),
+    terminal: isTerminal(status),
     updatedAt: new Date().toISOString(),
   };
 }
@@ -1027,7 +1029,7 @@ export function applyRuntimeStateToShellSession(session, state) {
   const displayState = sanitizeRuntimeStateForDisplay(state);
   const terminalStateDismissed = session._dismissedTerminalRunId
     && state.runId === session._dismissedTerminalRunId
-    && ['done', 'error', 'failed', 'cancelled'].includes(String(displayState.status ?? '').toLowerCase());
+    && isTerminal(displayState.status);
   session._lastRuntimeRunId = state.runId ?? session._lastRuntimeRunId ?? null;
   session.agentProjection = {
     conversation: Array.isArray(displayState.conversation) ? displayState.conversation.map((message) => ({ ...message })) : [],
@@ -1324,9 +1326,7 @@ async function runAgentTurn(input, {
   session.packageJson = session.packageJson ?? {};
   if (
     session._lastRuntimeRunId
-    && ['done', 'error', 'failed', 'cancelled'].includes(
-      String(session.agentProjection?.status ?? '').toLowerCase(),
-    )
+    && isTerminal(session.agentProjection?.status)
   ) {
     session._dismissedTerminalRunId = session._lastRuntimeRunId;
   }
@@ -1472,7 +1472,7 @@ async function runAgentTurn(input, {
 // unitary actions only — it never plans or delegates, which is why the
 // orchestration tools are filtered out upstream. maxToolIterations caps the
 // loop.
-async function runChatToolLoop({ input, session, history, donnaMessage, onUpdate, onStep, allowedTools, openWikiPages, contextMessages = [] }) {
+async function runChatToolLoop({ input, session, history, donnaMessage, onUpdate, onStep, onTextDelta, onTextReset, allowedTools, openWikiPages, contextMessages = [] }) {
   const allowed = new Set(allowedTools.map((item) => item.function.name));
   // /chat only supplies the policy; the loop mechanic lives in runBoundedToolLoop.
   // executeCall enforces the allow-list and turns each call into a text result;
@@ -1504,6 +1504,8 @@ async function runChatToolLoop({ input, session, history, donnaMessage, onUpdate
     maxIterations: Math.min(8, Number(session?.chatAccess?.maxToolIterations) || 4),
     signal: session._abortSignal,
     onStep: (i, cap) => onStep?.(`Chat: consulting… [${i}/${cap}]`),
+    onTextDelta,
+    onTextReset,
   });
   donnaMessage.content = capped
     ? 'Je n’ai pas pu conclure dans la limite d’itérations du mode chat. Passe en /agent si besoin.'
@@ -1575,7 +1577,15 @@ async function runDirectChatTurn(input, { session, onUpdate, onStep }) {
 // implementation of chat access; it just returns the final text instead of
 // driving a live repl bubble. The caller must have seeded session.chatAccess
 // (and session.mcp) so chatAllowedTools can resolve the allow-listed tools.
-export async function runHeadlessChatTurn(session, input, { history = [], onStep, openWikiPages, openWikiPage } = {}) {
+/**
+ * @param onTextDelta fragments de la réponse au fil de la génération. Fourni
+ *   par le tour runtime, qui les publie en `assistant_delta` : le réducteur
+ *   fait grandir la dernière entrée de conversation, et les deux interfaces
+ *   affichent la réponse en train de s'écrire au lieu d'un point d'attente.
+ * @param onTextReset fragments à jeter (itération qui s'est terminée par des
+ *   appels d'outils plutôt que par une réponse).
+ */
+export async function runHeadlessChatTurn(session, input, { history = [], onStep, onTextDelta, onTextReset, openWikiPages, openWikiPage } = {}) {
   const donnaMessage = { role: 'donna', content: '' };
   const allowedTools = chatAllowedTools(session);
   // Keep the singular option as a compatibility input for older serve builds.
@@ -1591,7 +1601,7 @@ export async function runHeadlessChatTurn(session, input, { history = [], onStep
   ];
   const canUseTools = allowedTools.length > 0 && typeof session.llm?.completeWithTools === 'function';
   if (canUseTools) {
-    await runChatToolLoop({ input, session, history, donnaMessage, onStep, allowedTools, openWikiPages: selectedPages, contextMessages });
+    await runChatToolLoop({ input, session, history, donnaMessage, onStep, onTextDelta, onTextReset, allowedTools, openWikiPages: selectedPages, contextMessages });
     return donnaMessage.content;
   }
   if (typeof session.llm?.stream === 'function') {
@@ -1602,7 +1612,7 @@ export async function runHeadlessChatTurn(session, input, { history = [], onStep
       signal: session._abortSignal,
     })) {
       const clean = stripDsmlArtifacts(delta);
-      if (clean) content += clean;
+      if (clean) { content += clean; onTextDelta?.(clean); }
     }
     return stripDsmlArtifacts(content).trimEnd() || formatLlmUnavailableMessage('flux vide');
   }

package/src/shell/setupWizardModality.test.js

@@ -0,0 +1,55 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+// The shell renders in a terminal, so there is no DOM to drive and no
+// typechecker on these .tsx files (bun strips the types at run time). Source
+// assertions are the only mechanized guard available here — they are narrow on
+// purpose: each one names the exact invariant that broke.
+const tuiPath = fileURLToPath(new URL('./tui.tsx', import.meta.url));
+
+function tuiSource() {
+  return readFileSync(tuiPath, 'utf8');
+}
+
+test('the chat composer loses focus while a modal is open', () => {
+  const source = tuiSource();
+
+  // The setup wizard used to leave `chatFocused` true underneath itself, so
+  // every keystroke answering a wizard question was ALSO typed into the chat
+  // input at the bottom of the window — visible, and submitted on Enter.
+  assert.match(
+    source,
+    /chatFocused=\{!state\.activeEditor\(\) && screen\(\) === 'main'\}/,
+    'chatFocused must exclude every non-main screen, not just the file editor',
+  );
+  assert.doesNotMatch(
+    source,
+    /chatFocused=\{!state\.activeEditor\(\)\}/,
+    'the editor-only form of chatFocused lets wizard keystrokes reach the composer',
+  );
+});
+
+test('the setup wizard renders over an opaque backdrop', () => {
+  const source = tuiSource();
+  const setupBranch = source.slice(source.indexOf("{screen() === 'setup' ?"));
+
+  assert.ok(setupBranch, "the setup branch must exist in tui.tsx");
+  // Without a full-bleed backdrop the wizard floats over a live two-pane
+  // layout and the panes show through around its border.
+  assert.match(setupBranch, /position="absolute"[\s\S]{0,200}backgroundColor="#0B0D12"/);
+  assert.match(setupBranch, /width=\{dimensions\(\)\.width\}[\s\S]{0,120}height=\{dimensions\(\)\.height\}/);
+  // The backdrop must sit under the wizard dialog (zIndex 40 in SetupWizard).
+  const zIndex = setupBranch.match(/zIndex=\{(\d+)\}/);
+  assert.ok(zIndex, 'the backdrop must declare a zIndex');
+  assert.ok(Number(zIndex[1]) < 40, 'the backdrop must sit below the wizard dialog');
+});
+
+test('the global key handler ignores every screen but main', () => {
+  const source = tuiSource();
+
+  // Belt to the chatFocused braces: even if a future modal forgets the prop,
+  // the shared shortcuts (history, slash completion, Esc) stay out of it.
+  assert.match(source, /if \(screen\(\) !== 'main'\) return;/);
+});

package/src/shell/tui.tsx

@@ -381,7 +381,11 @@ function App(props: {
             input={state.input()}
             busy={state.busy()}
             chatMode={state.chatMode()}
-            chatFocused={!state.activeEditor()}
+            // The composer must lose focus for EVERY modal, not just the file
+            // editor. While the setup wizard was open the input stayed focused
+            // underneath it, so answering a wizard question also typed into the
+            // chat box at the bottom of the window.
+            chatFocused={!state.activeEditor() && screen() === 'main'}
             setInput={state.setInput}
             submit={submit}
             conversationRows={conversationRows()}
@@ -433,17 +437,33 @@ function App(props: {
             onSave={state.saveEditor}
             onCancel={state.closeEditor}
           />
+          {/*
+            Opaque backdrop, same treatment WizardApp gives the standalone
+            wizard. Without it the dialog floated over a live two-pane layout:
+            the panes showed through around its border and the whole thing read
+            as one garbled screen rather than as a modal.
+          */}
           {screen() === 'setup' ? (
-            <SetupWizard
-              mode="setup"
-              session={state.session}
+            <box
+              position="absolute"
+              left={0}
+              top={0}
               width={dimensions().width}
               height={dimensions().height}
-              initialRoute="workspace-name"
-              closeOnDone
-              onComplete={closeSetup}
-              onClose={closeSetup}
-            />
+              zIndex={39}
+              backgroundColor="#0B0D12"
+            >
+              <SetupWizard
+                mode="setup"
+                session={state.session}
+                width={dimensions().width}
+                height={dimensions().height}
+                initialRoute="workspace-name"
+                closeOnDone
+                onComplete={closeSetup}
+                onClose={closeSetup}
+              />
+            </box>
           ) : null}
         </box>
       }

package/wiki-workspace

@@ -70,13 +70,19 @@ parse_global_options() {
     export REQUESTS_CA_BUNDLE="$CACERT_PATH"
     export CURL_CA_BUNDLE="$CACERT_PATH"
   fi
-  set -- "${parsed[@]}"
+  # `${arr[@]}` on an EMPTY array is an unbound-variable error under `set -u`
+  # in bash <= 4.3 — which includes the /bin/bash 3.2 macOS still ships. Every
+  # optional array in this script therefore goes through the `${arr[@]+…}`
+  # guard (see compose_env_args, override_args, only_services…); these two were
+  # missed, so any invocation without a global option died on this line before
+  # reaching its subcommand.
+  set -- ${parsed[@]+"${parsed[@]}"}
   PARSED_ARGS=("$@")
 }
 
 PARSED_ARGS=()
 parse_global_options "$@"
-set -- "${PARSED_ARGS[@]}"
+set -- ${PARSED_ARGS[@]+"${PARSED_ARGS[@]}"}
 
 usage() {
   cat <<'EOF'
@@ -338,7 +344,7 @@ agents_compose() {
     logs)
       local log_args=()
       read_lines_into_array log_args logs_args "$@"
-      _agents_dc logs "${log_args[@]}"
+      _agents_dc logs ${log_args[@]+"${log_args[@]}"}
       ;;
     pull)
       [[ $# -eq 0 ]] || die "agents pull does not take arguments"
@@ -1452,7 +1458,7 @@ main() {
     logs)
       local log_args=()
       read_lines_into_array log_args logs_args "$@"
-      compose_for_workspace "$workspace" logs "${log_args[@]}" serve mcp-http production-mcp
+      compose_for_workspace "$workspace" logs ${log_args[@]+"${log_args[@]}"} serve mcp-http production-mcp
       ;;
     serve)
       local open_browser=0