@dotdrelle/wiki-manager 0.15.91 → 0.15.94

package/docker-compose.yml

@@ -130,7 +130,7 @@ services:
       # error. Every compose-deployed ingest then ran without the Lot 4 barrier
       # and left the published map stale — the very defect that work fixed.
       # `copy` stays out on purpose: it is the legacy step, opt-in only.
-      - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,doctor_apply,ingest,ingest_plan,ingest_apply,build,export,polish,restore,pipeline}
+      - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,doctor_apply,copy,ingest,ingest_plan,ingest_apply,ingest_rebuild,build,export,polish,restore,pipeline,lint}
       - PRODUCTION_REQUIRE_CONFIRMATION=${PRODUCTION_REQUIRE_CONFIRMATION:-false}
       # Parallelism levers — effective concurrency ≈ recommendedConcurrency.
       # Intermediate defaults (4/8). Low profile 2/4, high profile 8/16.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.91",
+  "version": "0.15.94",
   "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/core/runtimeEventAdapter.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/wikiWorkspaceStart.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/orchestrator/providers/fakeRuntimeProvider.test.js src/orchestrator/providers/runtimeProviders.test.js src/orchestrator/providers/dispatcherExternalRuntime.test.js src/orchestrator/providers/deepAgentsProvider.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/core/runtimeEventAdapter.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/wikiWorkspaceStart.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/orchestrator/providers/fakeRuntimeProvider.test.js src/orchestrator/providers/runtimeProviders.test.js src/orchestrator/providers/dispatcherExternalRuntime.test.js src/orchestrator/providers/deepAgentsProvider.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 src/runtime/totp.test.js src/runtime/loginSession.test.js src/runtime/loginRoutes.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

@@ -555,6 +555,27 @@ function isUnresolvedTargetFailure(rawFailure) {
   return /file does not exist|does not exist|no files match/i.test(rawFailure);
 }
 
+// An agent that plans zero tasks is not a failure: it found nothing to act on
+// (no pending source, no template, no deliverable, no archived source to
+// re-file) and says so in its own synthesis sentence. Relaying that outcome is
+// the whole point — the old generic path called it "could not be started" and
+// sent the reader hunting a connectivity problem that did not exist.
+export function nothingToDoForDonna(rawReason) {
+  const reason = String(rawReason ?? '')
+    .replace(/\s*Available capabilities:\s*[\s\S]*$/i, '')
+    .replace(/\b(?:provider|endpoint)=[^\s,]+/g, '')
+    .replace(/\s{2,}/g, ' ')
+    .trim()
+    .slice(0, 400);
+  return JSON.stringify({
+    delegated: false,
+    nothingToDo: true,
+    reason,
+    instruction:
+      'The agent ran its planning and found nothing to act on. Answer the user naturally in their language, stating that plainly (use the reason above), and do not call it a failure, do not suggest restarting a service, and do not retry the same action. Do not expose exception names, capability identifiers, tool names, UUIDs, or internal routing details.',
+  });
+}
+
 function unresolvedTargetForDonna(rawFailure) {
   const cleaned = String(rawFailure ?? '')
     .replace(/\b(?:provider|endpoint)=[^\s,]+/g, '')
@@ -941,14 +962,19 @@ export async function handleRuntimeControlTool(session, tool, args = {}) {
         });
       }
       const result = await postRuntimeDelegate(objective, { url, workspace });
-      return result?.runId
-        ? JSON.stringify({
-            delegated: true,
-            runId: result.runId,
-            summary: result.delegation ?? null,
-            message: `Action started (${String(result.runId).slice(0, 8)}) after real-plan validation: ${result.delegation?.tasks ?? 0} task(s), ${result.delegation?.agent ?? 'resolved agent'}. Execution in progress.`,
-          })
-        : `Delegation refused: ${result?.error ?? JSON.stringify(result)}`;
+      if (result?.runId) {
+        return JSON.stringify({
+          delegated: true,
+          runId: result.runId,
+          summary: result.delegation ?? null,
+          message: `Action started (${String(result.runId).slice(0, 8)}) after real-plan validation: ${result.delegation?.tasks ?? 0} task(s), ${result.delegation?.agent ?? 'resolved agent'}. Execution in progress.`,
+        });
+      }
+      const refused = String(result?.error ?? JSON.stringify(result));
+      // Same EMPTY_PLAN outcome as the in-run path above: relay it, don't call
+      // it a failure.
+      if (/^EMPTY_PLAN:\s*/i.test(refused)) return nothingToDoForDonna(refused.replace(/^EMPTY_PLAN:\s*/i, ''));
+      return `Delegation refused: ${refused}`;
     }
     if (tool === 'run_skill') {
       const skillName = String(args.skillName ?? '').trim();
@@ -2009,6 +2035,14 @@ export function createAgentGraph(options = {}) {
                 missingRequiredFields: needsInput[1].split(',').map((item) => item.trim()).filter(Boolean),
                 instruction: 'Ask the user for the missing required information. Do not expose internal validation details.',
               });
+            } else if (/^EMPTY_PLAN:\s*/i.test(delegationFailure)) {
+              // Valid planning, nothing to do (no pending source/template/
+              // deliverable). Not a failure and not retryable — Donna relays
+              // the agent's own sentence instead of a connectivity-sounding
+              // generic error. Checked before the target heuristic: a plan
+              // reason is authoritative and could mention a missing file
+              // without meaning "unresolved target".
+              resultText = nothingToDoForDonna(delegationFailure.replace(/^EMPTY_PLAN:\s*/i, ''));
             } else if (isUnresolvedTargetFailure(delegationFailure)) {
               // A named target that resolves to nothing is not an unsupported
               // action: Donna can look it up and retry (or ask), so the turn

package/src/agent/graph.test.js

@@ -3,7 +3,7 @@ import test from 'node:test';
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { bareToolCallJson, buildAgentSystemPrompt, connectorConfigurationTarget, createAgentGraph, invalidSuggestedSlashCommands, invalidUserFacingToolNames, isOrchestrationBypassTool, knownCapabilityIds, normalizeToolArgumentsFromSchema } from './graph.js';
+import { bareToolCallJson, buildAgentSystemPrompt, connectorConfigurationTarget, createAgentGraph, invalidSuggestedSlashCommands, invalidUserFacingToolNames, isOrchestrationBypassTool, knownCapabilityIds, normalizeToolArgumentsFromSchema, nothingToDoForDonna } from './graph.js';
 
 test('user-facing response guard hides MCP identifiers generically', () => {
   const session = sessionBase();
@@ -13,6 +13,29 @@ test('user-facing response guard hides MCP identifiers generically', () => {
   );
 });
 
+test('an empty agent plan is relayed as "nothing to do", not as a failure', () => {
+  // The agent planned zero tasks and said why: no pending source, no template,
+  // no deliverable. That is an outcome. The old generic path called it "could
+  // not be started" and sent the reader after a connectivity problem that did
+  // not exist.
+  const payload = JSON.parse(nothingToDoForDonna(
+    'No Markdown files were found in raw/untracked; no ingest operation was planned.',
+  ));
+  assert.equal(payload.delegated, false);
+  assert.equal(payload.nothingToDo, true);
+  assert.match(payload.reason, /No Markdown files were found in raw\/untracked/);
+  assert.match(payload.instruction, /do not call it a failure/i);
+  assert.doesNotMatch(payload.instruction, /EMPTY_PLAN/);
+});
+
+test('the nothing-to-do reason strips internal routing details', () => {
+  const payload = JSON.parse(nothingToDoForDonna(
+    'No templates were found. Available capabilities: document.build, knowledge.update provider=production endpoint=http://host:3202',
+  ));
+  assert.doesNotMatch(payload.reason, /Available capabilities/);
+  assert.doesNotMatch(payload.reason, /provider=|endpoint=/);
+});
+
 test('CME setup stays direct while CME export execution stays orchestrated', () => {
   assert.equal(isOrchestrationBypassTool('cme__cme_export_run'), true);
   assert.equal(isOrchestrationBypassTool('cme__cme_setup'), false);

package/src/cli/wiki-manager.js

@@ -11,6 +11,7 @@ import { randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
+import { createInterface } from 'node:readline/promises';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ensureManagerScaffold, loadManagerEnv } from '../core/env.js';
@@ -49,6 +50,17 @@ function valueAfter(argv, flag) {
   return argv[index + 1];
 }
 
+async function confirmOnTty(question, defaultValue) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return defaultValue;
+  const readline = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await readline.question(`${question} [y/N] `)).trim().toLowerCase();
+    return answer === 'y' || answer === 'yes';
+  } finally {
+    readline.close();
+  }
+}
+
 function errorDiagnostic(err) {
   const parts = [];
   let current = err;
@@ -949,6 +961,11 @@ async function runRuntime(argv, agent) {
   const host = valueAfter(argv, '--host') ?? process.env.WIKI_MANAGER_RUNTIME_HOST ?? '0.0.0.0';
   const port = Number(valueAfter(argv, '--port') ?? process.env.WIKI_MANAGER_RUNTIME_PORT ?? 7788);
   const stateDir = valueAfter(argv, '--state-dir') ?? defaultRuntimeStateDir();
+  // The TOTP login modules resolve their state directory from the ENV, not
+  // from the CLI option: without this, `runtime --state-dir X` would store
+  // totp.json/session.json in the DEFAULT manager state dir while the rest of
+  // the runtime uses X — sessions issued on one side invisible to the other.
+  process.env.WIKI_MANAGER_STATE_DIR = stateDir;
   const auth = resolveRuntimeAuthToken({ host, stateDir });
   if (auth.token) process.env.WIKI_MANAGER_RUNTIME_TOKEN = auth.token;
   if (!Number.isInteger(port) || port <= 0 || port > 65535) {
@@ -1351,7 +1368,15 @@ async function runRuntime(argv, agent) {
       );
     }
     if (!Array.isArray(fragment?.tasks) || fragment.tasks.length === 0) {
-      throw new Error(fragment?.summary?.initialSynthesis?.[0] ?? `No task was planned for ${selection.capability}/${selection.operation}.`);
+      // An agent may legitimately plan nothing: no pending source to ingest, no
+      // template, no deliverable, no archived source to re-file. That is an
+      // OUTCOME, not a failure — the agent carries its own human-readable
+      // sentence in summary.initialSynthesis. The stable EMPTY_PLAN sentinel
+      // tells graph.js to relay that outcome instead of the generic "could not
+      // be started" failure (which read as a connectivity problem).
+      const plannedReason = String(fragment?.summary?.initialSynthesis?.[0] ?? '').replace(/\s+/g, ' ').trim();
+      const reason = plannedReason || `${selection.capability} planned no task for ${selection.operation}.`;
+      throw new Error(`EMPTY_PLAN: ${reason}`);
     }
     const validation = validateFragment(fragment, {
       registry: capabilityRegistryForSession(session),
@@ -1898,6 +1923,65 @@ export async function runCli(argv) {
     return;
   }
 
+  if (argv[0] === 'login' || argv[0] === 'logout') {
+    const { ensureRuntime } = await import('../runtime/lifecycle.js');
+    const { fetchLoginStatus, requestTotpSession, revokeRuntimeSession } = await import('../runtime/totpLogin.js');
+    let runtime = null;
+    try {
+      runtime = await ensureRuntime();
+    } catch (err) {
+      runtime = { url: null, error: err instanceof Error ? err.message : String(err) };
+    }
+    if (!runtime.url) throw new Error(`Runtime unavailable: ${runtime.error}`);
+    if (argv[0] === 'logout') {
+      const { currentSessionToken } = await import('../runtime/loginSession.js');
+      const revoked = await revokeRuntimeSession(runtime, currentSessionToken());
+      console.log(revoked ? 'Session revoked.' : 'No active session to revoke (or the runtime is not answering).');
+      return;
+    }
+    if (argv.includes('--reset')) {
+      // Re-enrollment after a lost authenticator: wipes the secret and the
+      // active session (local files, not an HTTP route) then runs the normal
+      // login flow, which lands on a fresh enrollment QR code.
+      const confirmed = argv.includes('--yes') || (await confirmOnTty(
+        'Reset the TOTP enrollment? This revokes the active session.\nContinue?',
+        false,
+      ));
+      if (!confirmed) {
+        console.log('Aborted.');
+        return;
+      }
+      const { resetTotpEnrollment } = await import('../runtime/loginSession.js');
+      resetTotpEnrollment();
+      console.log('TOTP enrollment and the active session were reset — enrolling a new authenticator now.');
+    }
+    const status = await fetchLoginStatus(runtime);
+    if (status && !status.enabled) {
+      console.log('TOTP login is disabled (WIKI_MANAGER_TOTP=off).');
+      return;
+    }
+    if (!argv.includes('--reset') && status?.sessionActive) {
+      // A session already exists, but the *browser* only gets the shared
+      // wiki_session cookie the moment it verifies a code on the runtime's
+      // origin. Re-open the page when asked so a browser that has none can
+      // seed it (and then reuse it on serve, same host) without waiting for
+      // the session to expire first.
+      if (!argv.includes('--no-open')) {
+        const { loginPageUrl, openBrowser } = await import('../runtime/totpLogin.js');
+        try {
+          await openBrowser(loginPageUrl(runtime));
+        } catch {
+          console.log(`Open ${loginPageUrl(runtime)} to seed this browser's session.`);
+        }
+      }
+      console.log(`Session already active until ${new Date(status.sessionExpiresAt).toLocaleString()}.`);
+      return;
+    }
+    const result = await requestTotpSession(runtime, { open: !argv.includes('--no-open') });
+    if (!result.ok) throw new Error(result.error);
+    return;
+  }
+
   if (argv.includes('--setup-wizard')) {
     if (!process.versions.bun) {
       throw new Error('Setup wizard requires Bun. Run: bun ./bin/wiki-manager.js --setup-wizard');
@@ -2008,6 +2092,15 @@ export async function runCli(argv) {
       runtime = unavailableRuntime(err);
       console.error(`Runtime unavailable: ${runtime.error}`);
     }
+    if (runtime.url) {
+      const { requestTotpSession } = await import('../runtime/totpLogin.js');
+      const gate = await requestTotpSession(runtime);
+      if (!gate.ok) {
+        console.error(gate.error);
+        process.exitCode = 1;
+        return;
+      }
+    }
     preflight = withRuntimePreflight(preflight, runtime);
     // render() resolves at mount; the TUI owns renderer teardown. The shared
     // runtime deliberately survives shell exit because `serve` may use it.
@@ -2030,6 +2123,15 @@ export async function runCli(argv) {
       runtime = unavailableRuntime(err);
       console.error(`Runtime unavailable: ${runtime.error}`);
     }
+    if (runtime.url) {
+      const { requestTotpSession } = await import('../runtime/totpLogin.js');
+      const gate = await requestTotpSession(runtime);
+      if (!gate.ok) {
+        console.error(gate.error);
+        process.exitCode = 1;
+        return;
+      }
+    }
   }
   await runShell({ agent, packageJson, runtime });
 }

package/src/commands/slash.js

@@ -109,6 +109,26 @@ export function compactBaseUrl(value) {
   }
 }
 
+/*
+ The web UI URL `/openui` opens. The runtime sets the `wiki_session` cookie on
+ its own origin when the ShellUI logs in, and cookies ignore the port, so we
+ reuse the runtime's loopback hostname: serve on that same host then validates
+ the shared session instead of asking for a second TOTP code. A non-loopback
+ runtime (remote deployment) shares no cookie with the local browser, so we
+ keep the plain `localhost` URL there — behaving exactly as before.
+*/
+export function webUiUrl(port, runtimeUrl) {
+  let runtimeHost = null;
+  try {
+    if (runtimeUrl) runtimeHost = new URL(runtimeUrl).hostname || null;
+  } catch {
+    runtimeHost = null;
+  }
+  const loopback = runtimeHost === 'localhost' || runtimeHost === '::1' || /^127\./.test(runtimeHost ?? '');
+  const host = loopback ? runtimeHost : 'localhost';
+  return `http://${host}:${port}`;
+}
+
 function commandLabel(value) {
   return `${styles.bold}${styles.cyan}${value}${styles.reset}`;
 }
@@ -726,8 +746,8 @@ async function statusText(session) {
   const runtimesColumn = runtimeProvidersSection(session);
   const stats = workspaceStatsColumns(workspaceStats, session);
 
-  const wikiColumnAll = [workspaceColumn, stats.wiki, runtimeColumn].filter(Boolean).join('\n\n');
-  const configColumnAll = [configColumn, stats.tuning, mcpColumn, runtimesColumn].filter(Boolean).join('\n\n');
+  const wikiColumnAll = [workspaceColumn, stats.wiki, runtimeColumn, mcpColumn].filter(Boolean).join('\n\n');
+  const configColumnAll = [configColumn, stats.tuning, runtimesColumn].filter(Boolean).join('\n\n');
 
   // Leading/trailing blank row so the boxed pair doesn't butt directly against
   // the pane border when the view is scrolled to show the tail. It is padding,
@@ -1734,9 +1754,23 @@ export async function handleSlashCommand(line, context) {
     }
     case 'openui': {
       const port = context.session.workspaceEnv?.WIKI_SERVE_PORT ?? '3100';
-      const url = `http://localhost:${port}`;
+      const url = webUiUrl(port, context.runtime?.url ?? context.session?.runtime?.url ?? null);
+      // Hand the ShellUI session to the browser so serve opens without a second
+      // TOTP code: the token rides in the URL fragment (never sent to the
+      // server, so it stays out of logs), and serve's login page exchanges it
+      // for its cookie on load. Open `/login` directly rather than the root so
+      // the fragment never has to survive a redirect. The printed line never
+      // carries the token.
+      let openUrl = url;
+      try {
+        const { currentSessionToken } = await import('../runtime/loginSession.js');
+        const token = currentSessionToken();
+        if (token) openUrl = `${url}/login#t=${encodeURIComponent(token)}`;
+      } catch {
+        // No readable session (gate off, or a custom state dir): plain URL.
+      }
       const note = context.session.workspaceEnv ? '' : ' (no workspace loaded — using default port)';
-      if (openExternalUrl(url)) return { output: `Opening web UI: ${url}${note}` };
+      if (openExternalUrl(openUrl)) return { output: `Opening web UI: ${url}${note}` };
       return { output: `Web UI: ${url}${note}` };
     }
     case 'clear': {

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, refreshMcpRuntimeStatus } from './slash.js';
+import { agentConcurrencySections, compactBaseUrl, compactMcpStatus, handleSlashCommand, localizedOperationResult, refreshMcpRuntimeStatus, webUiUrl } from './slash.js';
 import { completionContext } from '../shell/repl.js';
 
 test('deterministic operation results ask Donna to localize compact facts without leaking commands', () => {
@@ -52,6 +52,16 @@ test('/status base URL displays only its domain while retaining the full link',
   assert.equal(compactBaseUrl(undefined), '-');
 });
 
+test('/openui reuses the loopback runtime host so serve shares the TOTP session', () => {
+  // The runtime sets wiki_session on its own origin and cookies ignore the
+  // port: opening serve on the same host avoids a second login. Non-loopback
+  // runtimes share no cookie, so the plain localhost URL stays.
+  assert.equal(webUiUrl('3200', 'http://127.0.0.1:7788'), 'http://127.0.0.1:3200');
+  assert.equal(webUiUrl('3200', 'http://localhost:7788'), 'http://localhost:3200');
+  assert.equal(webUiUrl('3200', null), 'http://localhost:3200');
+  assert.equal(webUiUrl('3200', 'https://manager.example.com'), 'http://localhost:3200');
+});
+
 test('/status replaces Internal and Hints with effective agent concurrency', () => {
   const sections = agentConcurrencySections({
     agentRegistrySnapshot: [

package/src/core/agentEvents.js

@@ -215,6 +215,8 @@ export function conversationEventSequences(events = []) {
 function createProjectionState() {
   return {
     conversation: [],
+    conversationSeedStart: 0,
+    conversationSummary: null,
     chain: [],
     plan: null,
     activities: {},
@@ -234,6 +236,8 @@ function createProjectionState() {
 function publicProjection(state) {
   const projection = {
     conversation: state.conversation.map((message) => ({ ...message })),
+    conversationSeedStart: state.conversationSeedStart ?? 0,
+    conversationSummary: state.conversationSummary ?? null,
     chain: state.chain.map((step) => ({ ...step })),
     plan: state.plan ? state.plan.map((step) => ({ ...step })) : null,
     activities: sortedActivities(state.activities).map((activity) => ({ ...activity })),
@@ -313,6 +317,25 @@ function applyEvent(state, event) {
     case 'user_message':
       state.conversation.push({ role: 'user', content: String(event.payload?.content ?? '') });
       return;
+    case 'conversation_reset':
+      // A deliberate user action (the served chat's memory gauge): everything
+      // said before this point stops feeding conversationSeed's LLM context,
+      // WITHOUT touching the displayed conversation — the thread stays visible
+      // everywhere (ShellUI and serve), only what Donna is told going forward
+      // is reset. Nothing is removed from the event log. Marking the boundary
+      // (length at reset time) instead of clearing state.conversation is what
+      // keeps the two concerns apart: the gauge/seed read conversationSeedStart,
+      // the display reads conversation.
+      state.conversationSeedStart = state.conversation.length;
+      // The summary is best-effort (an LLM call the compact route makes before
+      // dispatching this event): when it succeeds it REPLACES the previous one
+      // — it is a rolling summary of "everything before this point", not an
+      // accumulating log — and when it fails or is skipped (no LLM configured)
+      // the previous summary survives rather than being wiped by an empty one.
+      if (typeof event.payload?.summary === 'string' && event.payload.summary.trim()) {
+        state.conversationSummary = event.payload.summary.trim();
+      }
+      return;
     case 'assistant_message':
       finalizeAssistantMessage(state, String(event.payload?.content ?? ''));
       return;

package/src/core/agentEvents.test.js

@@ -39,6 +39,43 @@ test('a streamed reply keeps the sequence of the delta that created it', () => {
   assert.deepEqual(conversationEventSequences(events), [1, 2]);
 });
 
+test('conversation_reset marks a seed boundary and keeps the displayed thread', () => {
+  const events = sequenced([
+    createAgentEvent('user_message', { origin: 'user', payload: { content: 'avant' } }),
+    createAgentEvent('assistant_message', { origin: 'runtime', payload: { content: 'réponse avant' } }),
+    createAgentEvent('conversation_reset', { origin: 'user', payload: {} }),
+    createAgentEvent('user_message', { origin: 'user', payload: { content: 'après' } }),
+  ]);
+
+  const projection = reduceAgentEvents(events);
+  // The thread stays whole — compacting must not erase what the reader sees…
+  assert.deepEqual(projection.conversation.map((message) => message.content), ['avant', 'réponse avant', 'après']);
+  // …only the grounding boundary moves.
+  assert.equal(projection.conversationSeedStart, 2);
+});
+
+test('conversation_reset stores the summary it carries and keeps it through a later compact with none', () => {
+  const events = sequenced([
+    createAgentEvent('user_message', { origin: 'user', payload: { content: 'avant' } }),
+    createAgentEvent('conversation_reset', { origin: 'user', payload: { summary: 'Résumé 1' } }),
+    createAgentEvent('user_message', { origin: 'user', payload: { content: 'entre' } }),
+    // A summary is best-effort (an LLM call): a compact with no summary (LLM
+    // unavailable, or nothing worth summarizing) must not erase the last one.
+    createAgentEvent('conversation_reset', { origin: 'user', payload: {} }),
+  ]);
+  const projection = reduceAgentEvents(events);
+  assert.equal(projection.conversationSummary, 'Résumé 1');
+});
+
+test('a later compact with a new summary replaces the previous one', () => {
+  const events = sequenced([
+    createAgentEvent('conversation_reset', { origin: 'user', payload: { summary: 'Résumé 1' } }),
+    createAgentEvent('conversation_reset', { origin: 'user', payload: { summary: 'Résumé 2' } }),
+  ]);
+  const projection = reduceAgentEvents(events);
+  assert.equal(projection.conversationSummary, 'Résumé 2');
+});
+
 test('an independent queued skill invocation never inherits the active run identity', () => {
   const session = {
     workspace: 'docs',

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.91",
-  "commit": "fb6be4f"
+  "version": "0.15.94",
+  "commit": "00c41b1"
 }

package/src/core/dockerCompose.test.js

@@ -27,6 +27,20 @@ test('workspace production agent enables restore by default', async () => {
   assert.match(String(allowed), /(?:^|,)restore(?:,|})/);
 });
 
+test('the manager allowlist carries the new knowledge steps, not only the agent default', async () => {
+  // This env OVERRIDES agent-production's own default: a value missing
+  // ingest_rebuild/lint silently filters knowledge.rebuild/knowledge.check out
+  // of agent_describe (the capability is published only if one of its steps
+  // survives). That is exactly what made the wiki-row rebuild button run a
+  // plain ingest from raw/untracked instead of re-filing raw/ingested.
+  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
+  const compose = YAML.parse(raw);
+  const allowed = String(compose.services['production-mcp'].environment
+    .find((entry) => String(entry).startsWith('PRODUCTION_ALLOWED_STEPS=')));
+  assert.match(allowed, /(?:^|,)ingest_rebuild(?:,|})/);
+  assert.match(allowed, /(?:^|,)lint(?:,|})/);
+});
+
 test('the shipped default carries no step the engine retired in 0.15.66', async () => {
   /*
    0.15.66 a retiré du moteur llm-wiki les commandes `wiki concepts`,

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

package/src/core/skillCompiler.test.js

@@ -31,7 +31,7 @@ test('validation rejects technical routing details', () => {
 });
 
 test('every shipped scaffold skill compiles to a single intention, deterministically', async () => {
-  const expected = { pipeline: 1, 'wiki-sync': 1, 'wiki-ingest': 1, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1 };
+  const expected = { pipeline: 1, 'wiki-sync': 1, 'wiki-ingest': 1, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1, 'wiki-rebuild': 1 };
   // Passing no llmFallback used to make this test assert the one path
   // production never takes: an ambiguous body silently returns the safe
   // mono-intention fallback, so the count was 1 and the test was green while
@@ -47,6 +47,26 @@ test('every shipped scaffold skill compiles to a single intention, deterministic
   }
 });
 
+test('the shipped wiki-rebuild skill resolves through the deterministic alias path only', async () => {
+  // The objective resolver's fast path fires only when EXACTLY ONE capability
+  // alias phrase matches the objective. Bare words other agents alias ('build',
+  // 'rebuild', 'ingest', 'check', 'export'…) would make the LLM resolver decide
+  // instead. The shipped body is worded to stay on the deterministic path: it
+  // must carry the agent-production knowledge.rebuild alias phrase and none of
+  // the colliding words — verified against the alias lists actually shipped in
+  // agent-production (knowledge.rebuild / knowledge.check) and the other
+  // agents (cme: 'export sources'…, gateway: 'check'…).
+  const raw = readFileSync(resolve('../llm-wiki/scaffold/workspace/.wiki/skills', 'wiki-rebuild.md'), 'utf8');
+  const { body } = parseFrontmatter(raw);
+  const objectives = await compileSkillObjectives({ body }, {});
+  assert.equal(objectives.length, 1);
+  const text = objectives[0].text;
+  assert.match(text, /file the archived sources/i);
+  for (const word of ['ingest', 'build', 'rebuild', 'export', 'publish', 'okf', 'frontmatter', 'diagnose', 'restore', 'pipeline', 'check', 'audit', 'review', 'analyze', 'compare']) {
+    assert.doesNotMatch(text, new RegExp(`\\b${word}\\b`, 'i'), `word "${word}" must not appear in the objective`);
+  }
+});
+
 test('every orchestrated scaffold skill declares the capability it targets', () => {
   // Without a declaration the capability is inferred from the body's prose by
   // alias matching, which any runtime added to agent-runtimes.json can break by

package/src/orchestrator/objectiveResolver.test.js

@@ -108,6 +108,33 @@ test('resolveObjective resolves an ingest objective deterministically despite no
   assert.equal(result.operation, 'ingest');
 });
 
+test('"rebuild" resolves to knowledge.rebuild, not document.build', async () => {
+  // document.build used to alias "rebuild" too, so the wiki row's rebuild
+  // button ran a template build instead of re-filing the archive. The alias is
+  // unique to knowledge.rebuild now, and the bare /wiki-rebuild invocation must
+  // resolve deterministically (no LLM) to ingest_rebuild.
+  const knowledgeRebuild = makeCapability('knowledge.rebuild', {
+    operations: ['ingest_rebuild'],
+    aliases: ['file the archived sources', 'archived sources into the wiki', 'concept pages from the archive', 'rebuild', 'rebuild concepts'],
+    description: 'Re-file the archived sources into their concept folders.',
+  });
+  const documentBuild = makeCapability('document.build', {
+    operations: ['build'],
+    aliases: ['build', 'generate deliverable'],
+    description: 'Build llm-wiki deliverables from templates.',
+  });
+  const session = sessionWith([
+    provider('production-1', knowledgeRebuild),
+    provider('production-1', documentBuild),
+  ]);
+  session.llm.completeWithTools = async () => {
+    throw new Error('the rebuild alias must resolve without the LLM');
+  };
+  const result = await resolveObjective('/wiki-rebuild', session);
+  assert.equal(result.capability, 'knowledge.rebuild');
+  assert.equal(result.operation, 'ingest_rebuild');
+});
+
 test('resolveObjective resolves diagnose via alias despite the notification "send"', async () => {
   const session = sessionWith([
     provider('production-1', diagnose),