@dotdrelle/wiki-manager 0.15.78 → 0.15.84

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.78",
+  "version": "0.15.84",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "repository": {
     "type": "git",

package/src/agent/graph.js

@@ -23,10 +23,12 @@ import { RESERVED_SLASH_COMMANDS, explicitSkillReference, objectiveNamesSkill }
 import { handleSlashCommand } from '../commands/slash.js';
 import { extractActivity, formatActivitySummary, parseJsonText, sessionActivities } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { toolResultNote, toolStartNote } from '../core/progressNotes.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 { objectiveForResolution } from '../orchestrator/objectiveResolver.js';
 import { fetchRuntimeState, postRuntimeCancel, postRuntimeControl, postRuntimeDelegate, postRuntimeKill, postRuntimeSkill } from '../runtime/client.js';
 
 const MAX_TOOL_ITERATIONS = 80;
@@ -862,7 +864,20 @@ export async function handleRuntimeControlTool(session, tool, args = {}) {
     if (tool === 'delegate') {
       const objective = String(args.objective ?? '').trim();
       if (!objective) return 'Delegation rejected: missing objective.';
-      const connectorConfig = connectorConfigurationTarget(session, objective);
+      /*
+       La garde anti-configuration est un gouvernail INTERACTIF : elle corrige
+       Donna quand une demande de chat (« configure le connecteur ») part en
+       délégation vers une capacité d'export au lieu du tool de setup. Elle
+       n'a pas sa place à l'intérieur d'un run de compétence compilée : là,
+       l'objectif est déjà le workflow autorisé (le compilateur a produit une
+       intention MÉTIER), et le résolveur du runtime est l'autorité de routage.
+       Le corps expédié de /wiki-sync en est la preuve — « Export every
+       configured Confluence source exactly as the connector is currently
+       configured » a été refusé comme « configuration du connecteur » alors
+       que l'export était la seule action demandée.
+      */
+      const compiledSkillRun = Boolean(session?._currentRunIdentity) && normalizedSkillStack(session).length > 0;
+      const connectorConfig = compiledSkillRun ? null : connectorConfigurationTarget(session, objective);
       if (connectorConfig?.setupTool) {
         return `Delegation rejected: configuring or authenticating ${connectorConfig.serverName} is not an orchestrated export. Call the offered ${connectorConfig.serverName}__${connectorConfig.setupTool} tool directly and present its authorization instructions or URL to the user.`;
       }
@@ -1048,7 +1063,6 @@ export function connectorConfigurationTarget(session, objective) {
     .filter((message) => message?.role === 'user')
     .map((message) => String(message?.content ?? ''))
     .join(' ');
-  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
@@ -1058,7 +1072,33 @@ export function connectorConfigurationTarget(session, objective) {
   // "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;
+  //
+  // Guardrail and notification sentences are stripped first (the same
+  // objectiveForResolution pass the runtime resolver applies): "Never
+  // reconfigure the existing credentials" inside /wiki-sync is an execution
+  // constraint on the export, not the thing being asked.
+  const objectiveText = objectiveForResolution(objective).toLowerCase();
+  /*
+   Deux familles de mots de configuration, volontairement séparées :
+
+   - « configured », « configuration » (et leurs formes françaises) sont le
+     plus souvent du CONTEXTE passif — « export every configured source »,
+     « as the connector is currently configured ». Ils ne comptent comme une
+     intention de configuration que quand l'objectif ne porte aucun verbe
+     métier : sans ce filtre, le corps expédié de /wiki-sync était refusé
+     comme « configuration du connecteur » alors que son action est l'export.
+   - le reste (configure/ing/er/ez… actifs, credentials, password, token,
+     oauth, authenticate, connect, setup…) est une intention de configuration
+     et compte toujours, même à côté d'un verbe métier (« configure the
+     export » reste une demande de configuration).
+  */
+  const weakConfigMention = /\b(?:mis|re)?configur(?:ed|é(?:e)?s?|ations?)\b/i;
+  const businessMutationVerb = /\b(?:export|ingest|build|send|collect|fetch|import|retrieve|publish|polish|deliver|sync|notify|generate|convert|review|research)\b/i;
+  const strongConfigIntent = /(?:credential|identifiant|mot de passe|password|\bpat\b|api[ _-]?token|\boauth\b|authent|sign[ -]?in|\bsetup\b|\bconnect(?:ed|ing|ion|ions)?\b|(?:^|[^a-zà-ÿ])(?:mis|re)?configur(?!ed\b|é(?:e)?s?\b|ations?\b))/i;
+  if (!strongConfigIntent.test(objectiveText)) {
+    if (!weakConfigMention.test(objectiveText)) return null;
+    if (businessMutationVerb.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;
@@ -1847,6 +1887,13 @@ export function createAgentGraph(options = {}) {
         args: call.function.arguments ?? '{}',
         summary: argsSummary || 'calling...',
       });
+      // The turn's own account of itself, in the conversation rather than in a
+      // panel: an interactive turn publishes no plan and no activity, so this
+      // is the only thing that tells the user what is running while it runs.
+      emitAgentEvent(state.session, 'assistant_progress', 'tool', {
+        callId: call.id,
+        message: toolStartNote(toolName),
+      });
       // A plan represents work, never observation. Read-only inventory/status
       // calls stay out of Plan even when Donna uses them to answer a question.
       let minimalPlanActive = false;
@@ -2035,6 +2082,13 @@ export function createAgentGraph(options = {}) {
         result: boundedResult,
         summary: ok ? 'done' : 'failed',
       });
+      // A failure is the return the user most needs and the one that vanishes
+      // most easily: the loop keeps going, and without this the turn ends with
+      // an answer that never mentions the step that did not work.
+      emitAgentEvent(state.session, 'assistant_progress', 'tool', {
+        callId: call.id,
+        message: toolResultNote(toolName, ok, ok ? '' : boundedResult),
+      });
       toolResultMessages.push({
         role: 'tool',
         tool_call_id: call.id,

package/src/agent/graph.test.js

@@ -83,6 +83,103 @@ test('a stale configure-connector message does not poison a later business deleg
   assert.equal(target, null);
 });
 
+test('the shipped wiki-sync export objective is not connector setup', () => {
+  // "configured"/"configuration" here are passive context on an EXPORT
+  // objective — the exact wording that used to be rejected as connector
+  // configuration and steered the run into cme_setup.
+  const target = connectorConfigurationTarget({
+    agentProjection: { conversation: [] },
+    mcp: {
+      cme: {
+        status: 'connected',
+        tools: [
+          { name: 'cme_setup', description: 'Configure Confluence credentials.' },
+          { name: 'cme_export_run', description: 'Run export.' },
+        ],
+      },
+    },
+  }, 'Export every configured Confluence source exactly as the connector is currently configured, checking configuration and source availability first, waiting for the export to finish, and stopping without producing partial input if it fails or exports nothing. Do not build, export, polish or publish deliverables.');
+  assert.equal(target, null);
+});
+
+test('a passive configuration mention without a business verb still routes to connector setup', () => {
+  const target = connectorConfigurationTarget({
+    agentProjection: { conversation: [] },
+    mcp: {
+      cme: {
+        status: 'connected',
+        tools: [
+          { name: 'cme_setup', description: 'Configure Confluence credentials.' },
+          { name: 'cme_export_run', description: 'Run export.' },
+        ],
+      },
+    },
+  }, 'The cme connector is not configured yet.');
+  assert.deepEqual(target, { serverName: 'cme', setupTool: 'cme_setup' });
+});
+
+test('an active configuration request still wins over a business verb in the same objective', () => {
+  const target = connectorConfigurationTarget({
+    agentProjection: { conversation: [] },
+    mcp: {
+      cme: {
+        status: 'connected',
+        tools: [
+          { name: 'cme_setup', description: 'Configure Confluence credentials.' },
+          { name: 'cme_export_run', description: 'Run export.' },
+        ],
+      },
+    },
+  }, 'Configure the cme connector before the export.');
+  assert.deepEqual(target, { serverName: 'cme', setupTool: 'cme_setup' });
+});
+
+test('a compiled skill objective delegates without the connector-configuration steer', async () => {
+  const delegated = [];
+  let calls = 0;
+  const session = sessionBase({
+    runtime: { url: 'http://runtime.test' },
+    _skillStack: ['wiki-sync'],
+    _currentRunIdentity: { runId: 'run-sync', turnId: 'run-sync:turn-1', workspace: 'docs', skillChain: { skillName: 'wiki-sync', execution: 'orchestrated' } },
+    _delegateWithinRun: async (objective) => { delegated.push(objective); return { runId: 'run-sync', summary: { tasks: 1, agent: 'cme' } }; },
+    mcp: {
+      cme: {
+        status: 'connected',
+        url: 'http://cme.test/mcp',
+        tools: [
+          { name: 'cme_setup', description: 'Configure Confluence credentials.' },
+          { name: 'cme_export_run', description: 'Run export.' },
+        ],
+      },
+    },
+    llm: {
+      async completeWithTools() {
+        calls += 1;
+        if (calls === 1) {
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{
+              id: 'delegate-sync',
+              type: 'function',
+              function: {
+                name: 'runtime__delegate',
+                arguments: JSON.stringify({ objective: 'Export every configured Confluence source exactly as the connector is currently configured, checking configuration and source availability first.' }),
+              },
+            }],
+          };
+        }
+        return { content: 'Export delegated.', message: { role: 'assistant', content: 'Export delegated.' }, tool_calls: null };
+      },
+    },
+  });
+
+  const result = await createAgentGraph().invoke({ input: 'run sync', session });
+  assert.deepEqual(delegated, ['Export every configured Confluence source exactly as the connector is currently configured, checking configuration and source availability first.']);
+  assert.equal(result.response, 'Export delegated.');
+  assert.doesNotMatch(result.response, /Delegation rejected/);
+});
+
 test('Donna cannot answer an explicit action with manual instructions instead of delegating', async () => {
   const originalFetch = globalThis.fetch;
   let delegated = false;

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.78",
-  "commit": "6c0c150"
+  "version": "0.15.84",
+  "commit": "39cf1fa"
 }

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

package/src/core/progressNotes.js

@@ -0,0 +1,39 @@
+// Deterministic, English-only progress notes Donna publishes during a turn.
+//
+// Same reasoning as controlMessages.js, and the same trade-off: spending an LLM
+// turn to say "I am now calling template_write" would reintroduce exactly the
+// per-message cost the orchestration refactor removed, and would double the
+// latency of the very turn the note exists to explain. So these are written
+// here, deterministically, in English — the one language this lane can
+// guarantee — and never localized by a hardcoded fr/en catalog. Donna's own
+// localized prose stays what it has always been: the final answer.
+//
+// They are published as `assistant_progress`, which store.js keeps OUT of the
+// persisted event log. That is load-bearing: every persisted event feeds the
+// conversation projection, which seeds the next turn's LLM context — so a
+// progress note that persisted would be re-read by the model on every later
+// turn, growing the context with commentary about work already finished.
+//
+// Phrasing is generic on purpose. A per-tool verb catalog ("Reading a wiki
+// page…", "Writing the template…") reads better for the tools it knows and
+// drifts silently the day a tool is added, which is how the shipped help came
+// to advertise six skills against eleven. The tool name is data; the sentence
+// around it is prose.
+
+export function toolStartNote(name) {
+  return `Using ${name || 'a tool'}…`;
+}
+
+export function toolResultNote(name, ok, detail) {
+  const tool = name || 'the tool';
+  if (ok === false) {
+    const reason = String(detail ?? '').replace(/\s+/g, ' ').trim();
+    return reason ? `${tool} failed: ${reason}` : `${tool} failed.`;
+  }
+  return `${tool} finished.`;
+}
+
+export function turnDoneNote(steps) {
+  if (!steps) return 'Done.';
+  return `Done — ${steps} step${steps > 1 ? 's' : ''}.`;
+}

package/src/core/runtimeLog.js

@@ -181,8 +181,11 @@ export function isDispatchPlumbingLine(line) {
 // "Agent: classified input as …", "Agent: streaming final answer…" — describe
 // how the agent works, not what the business run does. They belong with the
 // dispatch plumbing in the Agent status tab; the Runtime tab keeps the
-// business flow (plan, task transitions, failures).
-const AGENT_TRACE_LINE = /^(?:runtime\s+)?(?:\d{1,2}:\d{2}(?::\d{2})?\s*(?:·\s*)?)?Agent:\s/;
+// business flow (plan, task transitions, failures). "Agents: …" (plural — the
+// slash-command lifecycle lines from `agents up`/`agents down`, e.g. "Agents:
+// reloading manager environment…") is the same category and must match too:
+// the singular-only pattern let those lines fall through to the Runtime tab.
+const AGENT_TRACE_LINE = /^(?:runtime\s+)?(?:\d{1,2}:\d{2}(?::\d{2})?\s*(?:·\s*)?)?Agents?:\s/;
 
 export function isAgentTraceLine(line) {
   return AGENT_TRACE_LINE.test(String(line ?? ''));

package/src/core/runtimeLog.test.js

@@ -170,6 +170,20 @@ test('isAgentTraceLine recognises the "Agent:" traces for the Agent status tab',
   }
 });
 
+test('isAgentTraceLine also recognises the plural "Agents:" lifecycle lines', () => {
+  // The `agents up`/`agents down` slash-command lines are written in the
+  // plural ("Agents: reloading manager environment…") and were falling
+  // through the singular-only pattern into the Runtime tab.
+  for (const line of [
+    '13:55:25 Agents: reloading manager environment and MCP endpoints…',
+    '13:55:26 Agents: stack started degraded — one optional agent failed; the base agents are up.',
+    '13:55:27 Agents: docker output — exit code 1',
+    'runtime 13:55:25 Agents: starting external agents…',
+  ]) {
+    assert.equal(isAgentTraceLine(line), true, `expected an agent trace: ${line}`);
+  }
+});
+
 test('isAgentTraceLine leaves every other line for the Runtime tab', () => {
   for (const line of [
     '14:42:18 ▸ Polish proposition — started  (knowledge.polish  → agent-production)',

package/src/runtime/store.js

@@ -20,7 +20,12 @@ import { markPersistedAgentsStale } from '../orchestrator/agentRegistry.js';
 
 export { defaultRuntimeStateDir };
 
-const NON_PERSISTED_EVENT_TYPES = new Set(['runtime_log']);
+// `assistant_progress` joins runtime_log here for a reason of its own: every
+// persisted event feeds the conversation projection, which seeds the next
+// turn's LLM context. A persisted progress note would be re-read by the model
+// on every later turn as if it were something the user said or Donna answered,
+// growing the context with commentary about work already finished.
+const NON_PERSISTED_EVENT_TYPES = new Set(['runtime_log', 'assistant_progress']);
 export const RUNTIME_STORE_SCHEMA_VERSION = 1;
 const RUNTIME_RETENTION_DAYS = 30;
 const TERMINAL_RUN_STATUSES = ['done', 'error', 'cancelled', 'interrupted'];

package/src/shell/RightPane.tsx

@@ -545,6 +545,36 @@ function TabHeader(props: { active: 'plan' | 'queue'; queueCount: number; onTabC
   );
 }
 
+/*
+  Reject = cancel the run waiting for the approval, same semantics as the
+  served UI's Reject button (which also confirms before cancelling). One
+  click arms the confirmation so an accidental hit cannot silently discard a
+  pending plan; the armed state expires on its own when the second click
+  never comes.
+*/
+function RejectRunButton(props: { onReject: () => void }) {
+  const [confirming, setConfirming] = createSignal(false);
+  let resetTimer: ReturnType<typeof setTimeout> | null = null;
+  function toggle() {
+    if (resetTimer) clearTimeout(resetTimer);
+    if (confirming()) {
+      setConfirming(false);
+      props.onReject();
+      return;
+    }
+    setConfirming(true);
+    resetTimer = setTimeout(() => setConfirming(false), 4000);
+  }
+  return (
+    <text
+      fg={confirming() ? '#0B1020' : '#F38BA8'}
+      bg={confirming() ? '#F38BA8' : undefined}
+      content={confirming() ? ' Confirm cancel ' : ' Reject '}
+      onMouseUp={toggle}
+    />
+  );
+}
+
 export function RightPane(props: {
   width: number;
   activities: any[];
@@ -557,6 +587,7 @@ export function RightPane(props: {
   logFilter?: string;
   pendingApprovals: any[];
   onApprove: () => void;
+  onReject: () => void;
   onTabClick: (tab: 'plan' | 'queue') => void;
   spinnerFrame?: string;
 }) {
@@ -578,7 +609,11 @@ export function RightPane(props: {
       <Show when={props.pendingApprovals.length > 0}>
         <box height={2} flexDirection="column" border={['left']} borderStyle="heavy" borderColor="#FBBF24" paddingX={1}>
           <text fg="#FBBF24" content={`${props.pendingApprovals.length} approval(s) required`} />
-          <text fg="#0B1020" bg="#FBBF24" content=" Approve run " onMouseUp={props.onApprove} />
+          <box flexDirection="row">
+            <text fg="#0B1020" bg="#FBBF24" content=" Approve run " onMouseUp={props.onApprove} />
+            <text fg="#4B5563" content=" " />
+            <RejectRunButton onReject={props.onReject} />
+          </box>
         </box>
       </Show>
       <Show when={props.activeTab === 'queue'} fallback={(

package/src/shell/repl.test.js

@@ -169,6 +169,18 @@ test('ShellUI shows the canonical run summary above the plan', async () => {
   assert.match(tui, /runSummary=\{state\.runSummary\(\)\}/);
 });
 
+test('ShellUI approval banner offers a reject next to approve, armed before it cancels', async () => {
+  const pane = await readFile(new URL('./RightPane.tsx', import.meta.url), 'utf8');
+  const tui = await readFile(new URL('./tui.tsx', import.meta.url), 'utf8');
+  // The banner no longer reduces a pending approval to "approve or nothing":
+  // reject cancels the waiting run, like the served UI's Reject button.
+  assert.match(pane, /content=" Approve run " onMouseUp=\{props\.onApprove\}/);
+  assert.match(pane, /content=\{confirming\(\) \? ' Confirm cancel ' : ' Reject '\}/);
+  assert.match(pane, /props\.onReject\(\)/);
+  assert.match(tui, /onReject=\{\(\) => \{ void state\.submitInput\('\/cancel'\); \}\}/);
+  assert.match(pane, /setTimeout\(\(\) => setConfirming\(false\), 4000\)/);
+});
+
 test('Flow/Trace does not repeat the runtime source prefix on every line', async () => {
   const source = await readFile(new URL('./RightPane.tsx', import.meta.url), 'utf8');
   const entryRenderer = source.slice(

package/src/shell/tui.tsx

@@ -434,6 +434,7 @@ function App(props: {
             logFilter={state.runtimeLogFilter()}
             pendingApprovals={state.pendingApprovals()}
             onApprove={() => { void state.submitInput('/approve'); }}
+            onReject={() => { void state.submitInput('/cancel'); }}
             onTabClick={state.selectRightTab}
             spinnerFrame={SPINNER_FRAMES[spinnerIndex()] ?? SPINNER_FRAMES[0]}
           />

package/src/shell/useSession.ts

@@ -87,6 +87,21 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     // split classifies lines structurally from that time prefix.
     setLogs((items) => [...items, `${new Date().toLocaleTimeString('en-GB', { hour12: false })} ${line}`].slice(-200));
   };
+  // An interactive turn runs on an ephemeral runtime session: its events are
+  // published over SSE but never enter the projection /state serves, so syncing
+  // state alone leaves every panel empty for the whole turn.
+  // The sentence is taken from the event, never composed here — progressNotes.js
+  // is the single source for this lane, exactly as controlMessages.js is for the
+  // control lane ("never hardcode a message in the shell or the server").
+  // The `Agent:` prefix is the one thing added, and it is load-bearing:
+  // isAgentTraceLine routes these to the Agent status tab rather than mixing
+  // them into the business flow.
+  const logRuntimeAgentEvent = (event: { type?: string; data?: any }) => {
+    if (event?.type !== 'agent_event') return;
+    if (event.data?.type !== 'assistant_progress') return;
+    const message = String(event.data?.payload?.message ?? '').trim();
+    if (message) addLog(`Agent: ${message}`);
+  };
   const runtimeUnavailableReason = createMemo(() => {
     if (props.runtime?.url) return null;
     const reason = props.runtime?.error ?? props.runtime?.unavailableReason ?? props.runtime?.reason ?? null;
@@ -537,12 +552,13 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     if (!props.runtime?.url || runtimeStreamStopped) return;
     runtimeStreamAbort = new AbortController();
     try {
-      for await (const _event of streamRuntimeEvents({
+      for await (const event of streamRuntimeEvents({
         url: props.runtime.url,
         signal: runtimeStreamAbort.signal,
         workspace: (session as any).workspace ?? null,
       })) {
         setRuntimeStatus('connected');
+        logRuntimeAgentEvent(event);
         debouncedSyncRuntimeState();
       }
     } catch {

package/wiki-workspace

@@ -140,7 +140,6 @@ wiki CLI commands reachable through `wiki <workspace> run`:
   lint                              Static checks: dead links, orphans, stale deliverables
   add-skill <source>                Install a workspace method (directory, .zip, HTTPS .zip)
   config                            Show the effective .wikirc.yaml
-  group-concepts                    Regroup wiki concepts
   doctor, ingest, build, export     Also available directly: wiki <workspace> <command>
 
   History is versioned for wiki/, templates/, build-context/, deliverables/,
@@ -1352,10 +1351,13 @@ reset_workspace() {
   # `.wikirc*`, templates/ and build-context/ come through untouched.
   run_wiki "$workspace" init
 
-  # The scaffold ships a demo brief in raw/untracked/. Reappearing here it would
-  # not read as a sample but as a pending source, and the next ingest would file
-  # it into the wiki as if the user had provided it.
-  rm -f -- "$ws_path/raw/untracked/demo-project-brief.md"
+  # The scaffold ships a handful of demo-*.md sources in raw/untracked/ (a
+  # project brief plus a few notes chosen to classify into different concepts
+  # with overlapping subjects/tags, so a first ingest already produces a
+  # non-trivial graph). Reappearing here they would not read as samples but as
+  # pending sources, and the next ingest would file them into the wiki as if
+  # the user had provided them.
+  rm -f -- "$ws_path"/raw/untracked/demo-*.md
 
   printf 'Reset done: %s\n' "$workspace"
   printf 'Kept: %s\n' "${kept[*]:-(nothing)}"