@dotdrelle/wiki-manager 0.15.54 → 0.15.57

package/mcp.endpoints.example.json

@@ -29,7 +29,7 @@
   "chatAccess": {
     "maxToolIterations": 8,
     "servers": {
-      "llm-wiki":         { "allow": ["help_list", "help_read", "help_search", "wiki_workspace_status", "wiki_list_pages", "wiki_read_page", "wiki_read_pages", "wiki_search_context", "wiki_collect_context", "wiki_read_ingested_source", "wiki_outline", "template_read", "template_write", "build_context_write"] },
+      "llm-wiki":         { "allow": ["help_list", "help_read", "help_search", "wiki_workspace_status", "wiki_list_pages", "wiki_read_page", "wiki_read_pages", "wiki_search_context", "wiki_collect_context", "wiki_read_ingested_source", "wiki_outline", "template_read", "template_write", "build_context_write", "wiki_read_deliverable"] },
       "wiki-production":  { "allow": ["production_job_status", "production_jobs_list"] },
       "cme":              { "allow": ["cme_status", "cme_sources_list", "cme_export_status"] }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.54",
+  "version": "0.15.57",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   },
   "scripts": {
     "start": "bun ./bin/wiki-manager.js",
-    "test": "node --test src/core/skillInvocation.test.js src/core/skillCompiler.test.js src/runtime/skillRun.test.js src/runtime/controlDrain.test.js src/runtime/controlCancellation.test.js src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/agent/skillRecursion.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/profileServiceStatus.test.js src/core/workspaceProfile.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/skillChainView.test.js src/core/runtimeLog.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.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/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/otherWorkspacesRunning.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/workspaceInherit.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/googleGrants.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/taskStatuses.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardModality.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/shell/setupWizardDiscovery.test.js src/shell/wrapText.test.js src/runtime/lifecycle.test.js src/runtime/store.test.js src/runtime/workspaceIsolation.test.js src/runtime/controlMessages.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/delegation.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/skillChain.e2e.test.js src/runtime/donna-contract.test.js src/runtime/approvals.test.js src/runtime/auth.test.js",
+    "test": "node --test src/core/skillInvocation.test.js src/core/skillCompiler.test.js src/runtime/skillRun.test.js src/runtime/controlDrain.test.js src/runtime/controlCancellation.test.js src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/agent/skillRecursion.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/profileServiceStatus.test.js src/core/workspaceProfile.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/skillChainView.test.js src/core/runtimeLog.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.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/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/otherWorkspacesRunning.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/workspaceInherit.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/currentArtifact.test.js src/core/googleGrants.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/taskStatuses.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardModality.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/shell/setupWizardDiscovery.test.js src/shell/wrapText.test.js src/runtime/lifecycle.test.js src/runtime/store.test.js src/runtime/workspaceIsolation.test.js src/runtime/controlMessages.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/delegation.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/skillChain.e2e.test.js src/runtime/donna-contract.test.js src/runtime/approvals.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/agent/graph.js

@@ -25,6 +25,7 @@ import { extractActivity, formatActivitySummary, parseJsonText, sessionActivitie
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { enqueueProductionJob, ensureJobQueue, formatQueue, productionLockBusy } from '../core/jobQueue.js';
 import { loadWorkspaceProfile, updateWorkspaceProfilePreference } from '../core/profile.js';
+import { artifactFromToolCall, currentArtifactFor, currentArtifactPromptLine, rememberArtifact } from '../core/currentArtifact.js';
 import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
 import { fetchRuntimeState, postRuntimeCancel, postRuntimeControl, postRuntimeDelegate, postRuntimeKill, postRuntimeSkill } from '../runtime/client.js';
 import { controlLanguage } from '../runtime/controlMessages.js';
@@ -1025,11 +1026,18 @@ export function connectorConfigurationTarget(session, objective) {
     .filter((message) => message?.role === 'user')
     .map((message) => String(message?.content ?? ''))
     .join(' ');
-  const text = `${recentContext} ${String(objective ?? '')}`.trim().toLowerCase();
-  // `connect` used to match the noun "connector" as a substring. Production
-  // skills mention an optional messaging connector, so that broad match could
-  // misclassify a business run as connector setup and reject delegation.
-  if (!/(?:configur|\bconnect(?:ed|ing|ion|ions)?\b|authent|oauth|setup|sign[ -]?in|\bpat\b|api[ _-]?token|credential|identifiant|mot de passe|password)/i.test(text)) return null;
+  const objectiveText = String(objective ?? '').trim().toLowerCase();
+  // The configuration keyword must describe the objective being delegated NOW,
+  // not something the user said earlier in the session. Matching it against
+  // recent conversation context made a stale "configurer le CME" message poison
+  // every later delegation — an unrelated `/wiki-ingest` objective was rejected
+  // as connector setup. Recent context is used only to resolve WHICH connector
+  // the current objective refers to. (`connect` used to match the noun
+  // "connector" as a substring, and production skills mention an optional
+  // messaging connector; the narrowed word-boundary form keeps that from
+  // misclassifying a business run as connector setup.)
+  if (!/(?:configur|\bconnect(?:ed|ing|ion|ions)?\b|authent|oauth|setup|sign[ -]?in|\bpat\b|api[ _-]?token|credential|identifiant|mot de passe|password)/i.test(objectiveText)) return null;
+  const contextText = `${recentContext} ${objectiveText}`.trim().toLowerCase();
   for (const [serverName, server] of Object.entries(session?.mcp ?? {})) {
     if (server?.status !== 'connected' || !Array.isArray(server.tools) || server.tools.length === 0) continue;
     const genericAliasParts = new Set([
@@ -1042,7 +1050,7 @@ export function connectorConfigurationTarget(session, objective) {
     ]
       .flatMap((value) => String(value).toLowerCase().split(/[^a-z0-9]+/))
       .filter((part) => part.length >= 3 && !genericAliasParts.has(part));
-    if (!aliases.some((alias) => text.includes(alias))) continue;
+    if (!aliases.some((alias) => contextText.includes(alias))) continue;
     const setupTool = server.tools.find((tool) => {
       const name = String(tool?.name ?? '').toLowerCase();
       const description = String(tool?.description ?? '').toLowerCase();
@@ -1181,7 +1189,7 @@ export function buildAgentSystemPrompt(state) {
     skills,
     '</skill_catalog>',
     runningSkillStack.length > 0
-      ? `You are already executing the compiled objective of workspace skill ${JSON.stringify(runningSkillStack.at(-1))}. Execute the objective in the current user message with the available direct tools${runningSkillExecution === 'direct' ? ' and stop after its requested direct mutation; delegation and nested skills are forbidden for this workflow' : ' or capability delegation'}. Do not select or call that skill again, with or without a leading slash. A skill run is not successful until its requested mutation has an affirmative tool result; never infer success from the runtime merely becoming idle or done.`
+      ? `You are already executing the compiled objective of workspace skill ${JSON.stringify(runningSkillStack.at(-1))}. The current user message IS that objective: execute it directly${runningSkillExecution === 'direct' ? ' and stop after its requested direct mutation; delegation and nested skills are forbidden for this workflow' : ' by delegating it with runtime__delegate (or a matching direct tool)'}. Do not select or call that skill again, with or without a leading slash — the runtime refuses the re-invocation with skill_recursion_blocked, and that refusal means act on the objective yourself, not report an error. A skill run is not successful until its requested mutation has an affirmative tool result; never infer success from the runtime merely becoming idle or done, and never end the run with an empty reply or a bare "{}".`
       : null,
     'In interactive agent mode, call only tools actually provided to you. Any directly offered tool stays direct; never substitute an orchestration-contract tool yourself.',
     'When the user asks for an action that can be performed with connected MCP tools or safe primitives, do not answer with future intent such as "I will call...", "I am going to run...", or "launching..." unless you also call the tool in the same turn. Either call the tool now, ask for the exact missing required arguments, or explain the concrete blocker.',
@@ -1218,6 +1226,7 @@ export function buildAgentSystemPrompt(state) {
     'When an action fails or is refused for lack of an authorization grant or scope (rather than a missing capability), say exactly that and name the primitive that grants it. Do not describe the feature as unavailable.',
     'For an action with no matching direct tool, call runtime__delegate with the user objective only. The runtime chooses the capability, operation, agent and plan, including a validated single task for executor-only agents. Never choose those identifiers yourself. Never call <provider>__agent_plan, <provider>__agent_execute, legacy production__production_start_job, wiki__plan_set, or wiki__plan_done from interactive chat.',
     'Do not ask the user which sources, files, connectors, or templates to use for an ingest, build, or export: the specialized agent discovers them from the workspace. When the objective is clear (e.g. "lance une ingestion"), delegate it as stated, without a clarifying question.',
+    'Templates are instruction-only specs and deliverables are regenerated from them. When asked to change what a generated document says, edit the underlying wiki content (wiki_write_page) or the template\'s [[INSTRUCTION: ...]] sections — never write finished prose into a template, because a build copies it verbatim and it can no longer be refreshed from the wiki. template_write refuses prose outside an instruction block, so keep every sentence inside one.',
     'Promise only what the resolved capability actually exposes in its declared contract (the input schema the specialized agent publishes for that capability). When the user requests an execution parameter — a batch or chunk size, a count "N at a time", concurrency, ordering, priority, or any tuning knob — apply it only if that parameter exists in the target capability\'s published input schema. Otherwise do not confirm or promise it: delegate the objective, and if the user explicitly asked for that parameter, say plainly in one line that you started the work but do not control that aspect (the runtime and the specialized agent decide it). Never state or imply a parameter was applied when the agent contract cannot enforce it.',
     'If runtime__delegate returns a blocker or no specialized provider is available, report only that concrete blocker concisely. Never replace the missing execution path with a suggested slash command, skill, MCP tool name, manual file move, administrator escalation, or alternative workflow unless the user explicitly asks for alternatives.',
     'For workspace inventory and page listings, use the connected wiki MCP read tools. Never invent or call a /wiki shell command through shell__run_command. Use /workspace init <name> [path] for low-level non-interactive workspace creation; in the interactive TUI, /new <name> opens the setup wizard.',
@@ -1235,6 +1244,7 @@ export function buildAgentSystemPrompt(state) {
     workspaceProfile
       ? `Workspace profile (.wiki/profile.md) — durable user preferences, apply these to every reply (tone, tutoiement/vouvoiement, formatting, etc.):\n${workspaceProfile}`
       : null,
+    currentArtifactPromptLine(currentArtifactFor(state.session)),
     'Runtime control: you have runtime__status, runtime__cancel, runtime__kill and runtime__enqueue. When the user asks to stop, remove, clean or kill the current run, its jobs or the queue ("supprime le job et la queue", "arr\u00eate tout"), call runtime__kill (or runtime__cancel for a soft stop of just the run) and confirm what was stopped. When the user explicitly asks to delete, reset, abandon or replace the current plan, call runtime__kill with purge=true; never set purge=true for a simple stop. For questions about what is running or queued, call runtime__status and answer from its data. You have no approval tool: a pending approval is granted only by the user through the approval button or the /approve command. Never grant, claim or report an approval yourself; when the user asks to proceed with pending mutations, tell them to use those controls. When the user asks for a NEW action while a run is active, do not execute it: propose runtime__enqueue (run it after) or, if they insist it replaces the current work, runtime__kill then the new action.',
     'When the user asks to refresh, show, or update the displayed plan or status, call runtime__status. This is a state refresh request, not a new business capability, and must never be delegated.',
     'Report every runtime control outcome exactly as the tool returned it \u2014 never embellish. If runtime__kill reports 0 run(s)/0 task(s)/0 purged, say there was nothing active to stop or purge; do NOT claim a run, plan, pending approval or queue item was removed. If runtime__status returns an error or could not be read, say the runtime state could not be retrieved and do not describe a state you never obtained. Never assert that something was cleaned, cancelled, approved or purged unless that specific tool result confirms it.',
@@ -1940,6 +1950,10 @@ export function createAgentGraph(options = {}) {
             args = withActiveWorkspaceForExternalTool(state.session, server, tool, args);
             const result = await callMcpTool(state.session.mcp, server, tool, args, state.session._abortSignal);
             resultText = formatMcpToolResult(result);
+            const artifact = artifactFromToolCall(tool, args);
+            if (artifact) {
+              rememberArtifact(state.session, artifact);
+            }
           }
         }
         {

package/src/agent/graph.test.js

@@ -62,6 +62,27 @@ test('a connection problem still routes to connector configuration', () => {
   assert.deepEqual(target, { serverName: 'acme', setupTool: 'acme_auth' });
 });
 
+test('a stale configure-connector message does not poison a later business delegation', () => {
+  const target = connectorConfigurationTarget({
+    agentProjection: {
+      conversation: [
+        { role: 'user', content: 'donne moi la config du cme' },
+        { role: 'user', content: 'liste les pages wiki configurer pour l’agent cme' },
+      ],
+    },
+    mcp: {
+      cme: {
+        status: 'connected',
+        tools: [
+          { name: 'cme_setup', description: 'Configure Confluence credentials.' },
+          { name: 'cme_export_run', description: 'Run export.' },
+        ],
+      },
+    },
+  }, 'Ingest pending staged Markdown files from raw/untracked into the wiki.');
+  assert.equal(target, null);
+});
+
 test('Donna cannot answer an explicit action with manual instructions instead of delegating', async () => {
   const originalFetch = globalThis.fetch;
   let delegated = false;

package/src/cli/wiki-manager.js

@@ -32,6 +32,7 @@ import { resolveCapabilityConcurrency } from '../orchestrator/scheduler.js';
 import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
 import { listWorkspaces } from '../core/workspaces.js';
 import { findSkill } from '../core/skills.js';
+import { rememberArtifact } from '../core/currentArtifact.js';
 // Runtime modules use node:sqlite (Node.js built-in unavailable in Bun).
 // They are imported dynamically so the shell / TUI path never loads them.
 
@@ -245,6 +246,21 @@ export function missingRequiredArguments(schema, args) {
   });
 }
 
+// After a delegated document.build, remember the targeted template as the
+// current artifact so the next "améliore cette slide" / "relance le build"
+// resolves the file without re-discovery. Best effort: a build of every
+// template (no `templates` argument) leaves the artifact untouched.
+function rememberBuildTemplateArtifact(session, selection, args) {
+  if (selection?.capability !== 'document.build') return;
+  const templates = Array.isArray(args?.templates) ? args.templates : [];
+  if (templates.length !== 1) return;
+  const name = String(templates[0] ?? '').trim().replace(/\\/g, '/');
+  if (!name) return;
+  const withExt = name.toLowerCase().endsWith('.md') ? name : `${name}.md`;
+  const pathValue = withExt.startsWith('templates/') ? withExt : `templates/${withExt.replace(/^\.?\//, '')}`;
+  rememberArtifact(session, { path: pathValue, kind: 'template' });
+}
+
 function safeParseArgumentObject(text) {
   const cleaned = String(text ?? '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
   if (!cleaned) return null;
@@ -297,7 +313,7 @@ export function createInteractiveSession(context, { runtimeUrl, turnId, signal =
     'workspace', 'workspacePath', 'workspaceEnvFile', 'workspaceEnv',
     'wikirc', 'wikircConfig', 'language', 'llm', 'mcp', 'commands',
     'packageJson', 'queueStore', 'systemPrompt',
-    '_runSkillWithinRun',
+    '_runSkillWithinRun', 'currentArtifact',
   ]) {
     if (source[key] !== undefined) session[key] = source[key];
   }
@@ -1249,6 +1265,7 @@ async function runRuntime(argv, agent) {
           workspace: session.workspace ?? context.workspace ?? '',
           signal: session._abortSignal,
         });
+        rememberBuildTemplateArtifact(session, selection, extractedArguments);
         planResult = await callMcpTool(
           session.mcp,
           provider.serverName,
@@ -1649,6 +1666,12 @@ async function runRuntime(argv, agent) {
     } else {
       response = await runAgentTurn(agent, ephemeral, input, { messages, signal });
     }
+    // Persist the artifact the turn may have opened/edited (template_write,
+    // template_read, …) back onto the long-lived session, so the next /turn —
+    // chat or agent — sees it. The ephemeral session is otherwise discarded.
+    if (ephemeral.currentArtifact) {
+      context.session.currentArtifact = ephemeral.currentArtifact;
+    }
     ensureInteractiveAssistantMessage(ephemeral, response, {
       turnId,
       workspace: context.workspace ?? null,

package/src/commands/slash.js

@@ -29,6 +29,7 @@ import { createWorkspace, findWorkspace, listWorkspaces } from '../core/workspac
 import { findSkill, inspectSkills, listSkills } from '../core/skills.js';
 import { extractActivity, formatActivityError, formatActivityLine, formatActivitySummary, parseJsonText } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { emitRuntimeLog } from '../runtime/supervisor.js';
 import {
   cancelQueueItem,
   clearFinishedQueueItems,
@@ -612,20 +613,53 @@ function publishDocumentActivity(session, activity) {
   return publishPayloadActivity(session, { _activity: activity }, { server: 'documents', tool: 'documents_convert_to_markdown' });
 }
 
-export async function refreshMcpRuntimeStatus(session) {
-  session.mcp = buildMcpStatus(session);
-  if (!session.workspacePath) return null;
+export async function refreshMcpRuntimeStatus(session, deps = {}) {
+  const getStates = deps.serviceStates ?? serviceStates;
+  const discover = deps.discoverMcpTools ?? discoverMcpTools;
+  const previousMcp = session.mcp;
+  const base = buildMcpStatus(session);
+  if (!session.workspacePath) {
+    session.mcp = base;
+    return null;
+  }
+  // Build the next status in local variables and assign `session.mcp` only at
+  // the end. Assigning `buildMcpStatus` first (status "configured", no tools)
+  // and then awaiting `serviceStates`/`discoverMcpTools` exposed a window in
+  // which a background re-scan had downgraded `production` to "configured",
+  // and the dispatcher — reading `session.mcp` mid-refresh — refused the next
+  // `agent_execute` with "MCP is not connected: production" while the agent
+  // was actually up.
   try {
-    const states = await serviceStates(session);
-    session.mcp = applyMcpRuntimeStatus(session.mcp, states);
-    session.mcp = await discoverMcpTools(session.mcp);
+    const states = await getStates(session);
+    session.mcp = await discover(applyMcpRuntimeStatus(base, states), previousMcp);
+    reportNewlyDegradedMcp(session, previousMcp);
     return states;
   } catch {
-    session.mcp = await discoverMcpTools(session.mcp);
+    session.mcp = await discover(base, previousMcp);
+    reportNewlyDegradedMcp(session, previousMcp);
     return null;
   }
 }
 
+/**
+ * "Degraded" (`discoverMcpTools`, mcp.js) means an endpoint is reporting
+ * "connected" only because a prior cycle was, not because Docker or the
+ * latest probe confirm it now — the preservation that endpoint's
+ * `keepConnected` branch exists for, deliberately not reverted here since a
+ * transient probe blip must not flip a live run's endpoint away. But
+ * preserving it in silence is exactly the "stale status kept forever"
+ * pattern already fixed once in agentRegistry.js: report it, edge-triggered
+ * on the transition into the degraded state, so it does not repeat every
+ * re-scan while it persists.
+ */
+function reportNewlyDegradedMcp(session, previousMcp) {
+  for (const [name, entry] of Object.entries(session.mcp ?? {})) {
+    if (!entry?.degraded || previousMcp?.[name]?.degraded) continue;
+    emitRuntimeLog(session, `mcp: ${name} still reports "connected" only from a prior probe`
+      + ` (${entry.toolError ?? 'no detail'}); Docker/the latest probe no longer confirm it.`);
+  }
+}
+
 async function statusText(session) {
   const states = await refreshMcpRuntimeStatus(session);
   const workspaceStats = collectWorkspaceStats(session);
@@ -1557,7 +1591,12 @@ export async function handleSlashCommand(line, context) {
           const wikiArgs = args.slice(2);
           if (wikiArgs.length === 0) return { output: 'Usage: /wiki run <args...>' };
           step(`Wiki: running ${wikiArgs.join(' ')}…`);
+          // Steps that drive LLM work (taxonomy, build, ingest, export, polish)
+          // legitimately run for minutes: the production agent gives them a
+          // 600s LLM timeout, so the raw hatch must not cut them at 180s.
+          const longRunning = new Set(['taxonomy', 'build', 'ingest', 'export', 'polish', 'pipeline']);
           const output = await runWikiCli(context.session, wikiArgs, {
+            timeout: longRunning.has(wikiArgs[0] ?? '') ? 600_000 : 180_000,
             onOutput: (line) => step(`Wiki: ${line}`),
           });
           const activity = formatActivitySummary('wiki', wikiArgs[0] ?? 'run', output);

package/src/commands/slash.test.js

@@ -4,7 +4,7 @@ import { mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
-import { agentConcurrencySections, compactBaseUrl, compactMcpStatus, handleSlashCommand, localizedOperationResult } from './slash.js';
+import { agentConcurrencySections, compactBaseUrl, compactMcpStatus, handleSlashCommand, localizedOperationResult, refreshMcpRuntimeStatus } from './slash.js';
 import { completionContext } from '../shell/repl.js';
 
 test('deterministic operation results ask Donna to localize compact facts without leaking commands', () => {
@@ -437,3 +437,59 @@ test('/queue cancel reports unknown ids that are not runtime-managed', async ()
   });
   assert.match(result.output ?? '', /Unknown queue item/i);
 });
+
+test('refreshMcpRuntimeStatus does not expose an intermediate configured status', async () => {
+  const session = {
+    workspacePath: '/tmp/ws',
+    workspaceEnv: { PRODUCTION_MCP_PORT: '3202', PRODUCTION_MCP_AUTH_TOKEN: 'token' },
+    wikircConfig: {},
+    mcp: { production: { status: 'connected', tools: [{ name: 'production__agent_execute' }] } },
+  };
+  const originalMcp = session.mcp;
+  let resolveStates;
+  const statesPromise = new Promise((resolve) => { resolveStates = resolve; });
+  const pending = refreshMcpRuntimeStatus(session, {
+    serviceStates: () => statesPromise,
+    discoverMcpTools: async (mcp) => mcp,
+  });
+  // While serviceStates is still in flight, the dispatcher-facing status must
+  // keep the previous connected snapshot — never the fresh "configured" base.
+  assert.equal(session.mcp, originalMcp, 'session.mcp reassigned mid-refresh');
+  resolveStates({ 'production-mcp': { running: true } });
+  await pending;
+  assert.equal(session.mcp.production.status, 'connected');
+});
+
+test('refreshMcpRuntimeStatus reports a degraded MCP endpoint once, not on every re-scan', async () => {
+  const session = {
+    workspacePath: '/tmp/ws',
+    workspaceEnv: { PRODUCTION_MCP_PORT: '3202', PRODUCTION_MCP_AUTH_TOKEN: 'token' },
+    wikircConfig: {},
+    mcp: { production: { status: 'connected', tools: [] } },
+  };
+  const degradedRuns = (n) => async () => ({
+    production: { status: 'connected', tools: [], toolError: `probe ${n} failed`, degraded: true },
+  });
+  const deps = { serviceStates: async () => ({}) };
+
+  await refreshMcpRuntimeStatus(session, { ...deps, discoverMcpTools: degradedRuns(1) });
+  await refreshMcpRuntimeStatus(session, { ...deps, discoverMcpTools: degradedRuns(2) });
+  await refreshMcpRuntimeStatus(session, { ...deps, discoverMcpTools: degradedRuns(3) });
+
+  const reports = (session.agentEvents ?? []).filter((event) => event.type === 'runtime_log'
+    && String(event.payload?.message ?? '').includes('mcp: production'));
+  assert.equal(reports.length, 1, 'a degraded endpoint is reported once, not once per re-scan');
+
+  // Recovers, then degrades again: reported a second time.
+  await refreshMcpRuntimeStatus(session, {
+    ...deps,
+    discoverMcpTools: async () => ({ production: { status: 'connected', tools: [], degraded: false } }),
+  });
+  await refreshMcpRuntimeStatus(session, { ...deps, discoverMcpTools: degradedRuns(4) });
+  assert.equal(
+    (session.agentEvents ?? []).filter((event) => event.type === 'runtime_log'
+      && String(event.payload?.message ?? '').includes('mcp: production')).length,
+    2,
+  );
+});
+

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.54",
-  "commit": "7a84126"
+  "version": "0.15.57",
+  "commit": "8c83b75"
 }

package/src/core/currentArtifact.js

@@ -0,0 +1,49 @@
+/**
+ * Le « contexte d'artefact courant » — la boucle documentaire continue.
+ *
+ * Quand Donna édite ou ouvre un artefact éditable (template, build-context,
+ * page wiki), on mémorise ce chemin au niveau de la session, comme la
+ * conversation, pour qu'un tour suivant puisse dire « améliore cette slide »
+ * sans que le modèle doive deviner quel fichier est concerné.
+ *
+ * Seuls les artefacts *éditables* sont suivis : templates/, build-context/ et
+ * wiki/. Les livrables générés (deliverables/) ne le sont pas — on les régénère,
+ * on ne les édite pas.
+ */
+
+const ARTIFACT_KIND_BY_TOOL = {
+  template_write: 'template',
+  template_read: 'template',
+  build_context_write: 'build-context',
+  wiki_write_page: 'wiki page',
+};
+
+export function artifactFromToolCall(tool, args) {
+  const kind = ARTIFACT_KIND_BY_TOOL[String(tool ?? '')];
+  if (!kind) return null;
+  const pathValue = args && typeof args === 'object' ? args.path : null;
+  if (typeof pathValue !== 'string' || !pathValue.trim()) return null;
+  return { path: pathValue.trim(), kind };
+}
+
+export function currentArtifactFor(session) {
+  const artifact = session?.currentArtifact;
+  if (!artifact || !artifact.path) return null;
+  if (artifact.workspace && session?.workspace && artifact.workspace !== session.workspace) return null;
+  return artifact;
+}
+
+export function rememberArtifact(session, { path, kind }) {
+  if (!session || typeof path !== 'string' || !path.trim()) return;
+  session.currentArtifact = {
+    workspace: session.workspace ?? null,
+    path: path.trim(),
+    kind,
+    at: Date.now(),
+  };
+}
+
+export function currentArtifactPromptLine(artifact) {
+  if (!artifact) return null;
+  return `Current artifact: the user is working on ${artifact.path} (${artifact.kind}). When the user refers to "this document", "this slide", "the template", "the page", or the document without naming the file, treat ${artifact.path} as the artifact being edited: read it first, then apply the requested edit and save it with the matching write tool.`;
+}

package/src/core/currentArtifact.test.js

@@ -0,0 +1,62 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  artifactFromToolCall,
+  currentArtifactFor,
+  currentArtifactPromptLine,
+  rememberArtifact,
+} from './currentArtifact.js';
+
+test('artifactFromToolCall records editable write tools with a path', () => {
+  assert.deepEqual(artifactFromToolCall('template_write', { path: 'templates/notes/basic.md', confirm: true }), {
+    path: 'templates/notes/basic.md',
+    kind: 'template',
+  });
+  assert.deepEqual(artifactFromToolCall('build_context_write', { path: 'build-context/rules/citations.md' }), {
+    path: 'build-context/rules/citations.md',
+    kind: 'build-context',
+  });
+  assert.deepEqual(artifactFromToolCall('wiki_write_page', { path: 'wiki/flux/ingestion.md' }), {
+    path: 'wiki/flux/ingestion.md',
+    kind: 'wiki page',
+  });
+});
+
+test('artifactFromToolCall records template_read only when a path is given', () => {
+  assert.deepEqual(artifactFromToolCall('template_read', { path: 'templates/notes/basic.md' }), {
+    path: 'templates/notes/basic.md',
+    kind: 'template',
+  });
+  assert.equal(artifactFromToolCall('template_read', {}), null);
+});
+
+test('artifactFromToolCall ignores read tools and tools without a path', () => {
+  assert.equal(artifactFromToolCall('wiki_read_page', { path: 'wiki/page.md' }), null);
+  assert.equal(artifactFromToolCall('wiki_search_context', { query: 'x' }), null);
+  assert.equal(artifactFromToolCall('template_write', {}), null);
+  assert.equal(artifactFromToolCall('unknown_tool', { path: 'templates/x.md' }), null);
+});
+
+test('currentArtifactFor is workspace-scoped', () => {
+  const artifact = { workspace: 'acpi', path: 'templates/notes/basic.md', kind: 'template' };
+  assert.equal(currentArtifactFor({ workspace: 'acpi', currentArtifact: artifact }), artifact);
+  assert.equal(currentArtifactFor({ workspace: 'other', currentArtifact: artifact }), null);
+  assert.equal(currentArtifactFor({ workspace: 'acpi' }), null);
+});
+
+test('currentArtifactPromptLine names the artifact for follow-up edits', () => {
+  const line = currentArtifactPromptLine({ path: 'templates/presentation/presentation.md', kind: 'template' });
+  assert.match(line, /templates\/presentation\/presentation\.md/);
+  assert.match(line, /this slide/);
+  assert.equal(currentArtifactPromptLine(null), null);
+});
+
+test('rememberArtifact records a workspace-scoped artifact and ignores empty paths', () => {
+  const session = { workspace: 'acpi' };
+  rememberArtifact(session, { path: 'templates/notes/basic.md', kind: 'template' });
+  assert.equal(session.currentArtifact.path, 'templates/notes/basic.md');
+  assert.equal(session.currentArtifact.workspace, 'acpi');
+  assert.equal(session.currentArtifact.kind, 'template');
+  rememberArtifact(session, { path: '   ', kind: 'template' });
+  assert.equal(session.currentArtifact.path, 'templates/notes/basic.md');
+});

package/src/core/env.js

@@ -9,6 +9,7 @@ const LEGACY_DEFAULT_WIKI_CHAT_TOOLS = [
 ];
 const TEMPLATE_AUTHORING_CHAT_TOOLS = [
   'wiki_outline', 'template_read', 'template_write', 'build_context_write',
+  'wiki_read_deliverable',
 ];
 
 export function userManagerDir() {

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.54';
+const WIKI_MANAGER_VERSION = '0.15.57';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -585,7 +585,7 @@ function retryDelay(ms, signal) {
   });
 }
 
-export async function discoverMcpTools(mcpStatus) {
+export async function discoverMcpTools(mcpStatus, previous = null) {
   const next = {};
   await Promise.all(Object.entries(mcpStatus ?? {}).map(async ([name, value]) => {
     if (value.status === 'missing') {
@@ -607,11 +607,26 @@ export async function discoverMcpTools(mcpStatus) {
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
+      // A transient probe failure during a background re-scan must not degrade
+      // a live endpoint. Docker service state (applyMcpRuntimeStatus) is the
+      // authority on whether the container is up; this probe is only a tool
+      // refresh, so keep last-known-good status and tools instead of flipping
+      // an in-flight run's endpoint to "not connected".
+      const prior = previous?.[name];
+      const freshlyConnected = value.status === 'connected';
+      const keepConnected = freshlyConnected || prior?.status === 'connected';
+      // `degraded` marks the case Docker itself no longer confirms as
+      // connected (freshlyConnected is false) and only prior history keeps
+      // this endpoint reporting "connected" — the preservation this whole
+      // branch exists for, worth surfacing rather than masking indefinitely.
+      // `refreshMcpRuntimeStatus` (slash.js) owns the edge-triggered log, by
+      // comparing this flag against the previous cycle's.
       next[name] = {
         ...value,
-        status: value.status === 'connected' ? 'configured' : value.status,
-        tools: [],
+        status: keepConnected ? 'connected' : value.status,
+        tools: keepConnected ? (prior?.tools ?? []) : [],
         toolError: message,
+        degraded: keepConnected && !freshlyConnected,
       };
     }
   }));

package/src/core/mcp.test.js

@@ -501,7 +501,7 @@ test('resolveRetryPolicy supports endpoint and tool overrides', () => {
   assert.deepEqual(policy, { maxAttempts: 4, backoffMs: 100 });
 });
 
-test('discoverMcpTools downgrades connected endpoint when tool discovery fails', async () => {
+test('discoverMcpTools keeps a connected endpoint connected when tool discovery fails', async () => {
   const originalFetch = globalThis.fetch;
   globalThis.fetch = async () => ({
     ok: false,
@@ -519,7 +519,7 @@ test('discoverMcpTools downgrades connected endpoint when tool discovery fails',
       },
     });
 
-    assert.equal(status.wiki.status, 'configured');
+    assert.equal(status.wiki.status, 'connected');
     assert.equal(status.wiki.tools.length, 0);
     assert.match(status.wiki.toolError, /401/);
   } finally {
@@ -527,6 +527,68 @@ test('discoverMcpTools downgrades connected endpoint when tool discovery fails',
   }
 });
 
+test('discoverMcpTools preserves last-known-good status and tools across a failed re-probe', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: false,
+    status: 502,
+    headers: { get: () => null },
+    text: async () => 'Bad gateway',
+  });
+
+  try {
+    const status = await discoverMcpTools(
+      {
+        production: {
+          status: 'configured',
+          url: 'http://127.0.0.1:3202/mcp/',
+          token: 'token',
+        },
+      },
+      {
+        production: {
+          status: 'connected',
+          tools: [{ name: 'production__agent_execute' }, { name: 'production__agent_status' }],
+        },
+      },
+    );
+
+    assert.equal(status.production.status, 'connected');
+    assert.deepEqual(status.production.tools.map((tool) => tool.name), [
+      'production__agent_execute',
+      'production__agent_status',
+    ]);
+    assert.match(status.production.toolError, /502/);
+    // Docker (`value.status`) no longer confirms this endpoint; only prior
+    // history keeps it "connected". `degraded` is what lets the caller
+    // (refreshMcpRuntimeStatus) tell this apart from a genuinely fresh probe
+    // success, so it can report the preservation instead of masking it.
+    assert.equal(status.production.degraded, true);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('discoverMcpTools does not mark a fresh probe failure on an already-connected endpoint as degraded', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: false,
+    status: 401,
+    headers: { get: () => null },
+    text: async () => '{"error":"invalid or missing bearer token"}',
+  });
+
+  try {
+    const status = await discoverMcpTools({
+      wiki: { status: 'connected', url: 'http://127.0.0.1:3201/mcp', token: 'token' },
+    });
+    assert.equal(status.wiki.status, 'connected');
+    assert.equal(status.wiki.degraded, false);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
 // A stateful server may reject any cold request, and every SDK words that
 // rejection differently ("No valid session" for the Node SDK, "Missing session
 // ID" for the Python one CME runs). The client must never read that prose: it