@dotdrelle/wiki-manager 0.15.27 → 0.15.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.27",
+  "version": "0.15.28",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/cli/wiki-manager.js

@@ -1435,13 +1435,20 @@ export async function runCli(argv) {
     const scaffolded = ensureManagerScaffold({ log: (message) => console.log(`[wiki-manager] ${message}`) });
     if (scaffolded.length > 0) loadManagerEnv();
     const reportCheck = ({ kind, ok, detail, context, skipped, pending }) => {
+      // "waiting" checks (containers not up yet, MCP not connected yet) are the
+      // normal state at launch — the shell starts them and reports the real
+      // status afterwards, so echoing them here is pure noise. Only what is
+      // ready or actually broken is printed.
+      if (!ok && (pending || skipped)) return;
       const labels = { docker: 'Docker', internet: 'Internet', agents: 'Agent containers', workspace: 'Workspaces', containers: 'Workspace containers', mcp: 'MCP' };
       const label = labels[kind] ?? kind;
       const instruction = !ok && context?.command ? ` — command: ${context.command}` : '';
-      const suffix = detail ? ` — ${detail}` : ` — ${context?.error ?? context?.dockerError ?? 'waiting'}`;
+      // On success the detail is diagnostic only (the probe URL for Internet);
+      // the label already says what passed.
+      const suffix = ok ? '' : ` — ${detail || context?.error || context?.dockerError || 'waiting'}`;
       const color = ok ? '\x1b[32m' : '\x1b[33m';
-      const state = ok ? 'ready' : pending || skipped ? 'waiting' : 'needs attention';
-      const icon = ok ? '✓' : pending || skipped ? '◐' : '✗';
+      const state = ok ? 'ready' : 'needs attention';
+      const icon = ok ? '✓' : '✗';
       console.log(`${color}${icon} configuration: ${label} ${state}${suffix}${instruction}\x1b[0m`);
     };
     let preflight = await runPreflightChecks({ onCheck: reportCheck });

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.27",
-  "commit": "35b5770"
+  "version": "0.15.28",
+  "commit": "11b99e6"
 }

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

package/src/shell/repl.test.js

@@ -54,13 +54,29 @@ test('redo is offered on user questions only, next to copy', async () => {
   const session = await readFile(new URL('./useSession.ts', import.meta.url), 'utf8');
   // The runtime must be truncated first: its conversation is derived from the
   // event log and would be merged straight back in otherwise.
-  const truncateIndex = session.indexOf('postRuntimeConversationTruncate(index');
+  const truncateIndex = session.indexOf('postRuntimeConversationTruncate(runtimeIndex');
   const spliceIndex = session.indexOf('full.splice(index)');
   const submitIndex = session.indexOf('return submitInput(content)');
   assert.ok(truncateIndex > 0 && spliceIndex > truncateIndex && submitIndex > spliceIndex);
   assert.match(session, /const windowOffset = Math\.max\(0, full\.length - messages\(\)\.length\);/);
 });
 
+test('redo translates the local thread index into a runtime conversation index', async () => {
+  const session = await readFile(new URL('./useSession.ts', import.meta.url), 'utf8');
+  const redo = session.slice(
+    session.indexOf('async function redoMessage('),
+    session.indexOf('function updateInput('),
+  );
+  // The local thread holds entries the runtime never recorded (slash-command
+  // output, help panels). Passing the raw local index to /conversation/truncate
+  // is what produced `index_out_of_range`; `backed` is the translation table.
+  assert.match(redo, /const backed = runtimeConversationRefsByWorkspace\.get\(workspaceKey\)/);
+  assert.match(redo, /let runtimeIndex = backed\.indexOf\(full\[index\]\)/);
+  assert.match(redo, /if \(full\.indexOf\(backed\[i\]\) < index\)/);
+  assert.match(redo, /props\.runtime\?\.url && runtimeIndex >= 0/);
+  assert.doesNotMatch(redo, /postRuntimeConversationTruncate\(index/);
+});
+
 test('ShellUI renders newest-first order in both Runtime and Agent status', async () => {
   const source = await readFile(new URL('./RightPane.tsx', import.meta.url), 'utf8');
   const filteredLogs = source.slice(

package/src/shell/useSession.ts

@@ -667,10 +667,28 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     const index = windowOffset + displayIndex;
     if (index < 0 || index >= full.length) return { exit: false };
 
-    if (props.runtime?.url) {
+    const workspaceKey = (session as any).workspace || '__global__';
+    // The local thread and the runtime conversation are NOT the same list:
+    // slash-command output, help panels and any other local-only entry live in
+    // `full` but were never recorded as events. Sending a `full` index straight
+    // to /conversation/truncate therefore points at the wrong entry — or past
+    // the end (`index_out_of_range`) — as soon as one local entry precedes the
+    // redone question. `backed` is index-aligned with the runtime conversation,
+    // so it is the only correct translation table.
+    const backed = runtimeConversationRefsByWorkspace.get(workspaceKey) ?? [];
+    let runtimeIndex = backed.indexOf(full[index]);
+    if (runtimeIndex === -1) {
+      // Local-only entry: truncate after the last runtime-backed entry that
+      // still precedes it, so nothing recorded before the question is lost.
+      for (let i = backed.length - 1; i >= 0; i -= 1) {
+        if (full.indexOf(backed[i]) < index) { runtimeIndex = i; break; }
+      }
+    }
+
+    if (props.runtime?.url && runtimeIndex >= 0) {
       // The runtime derives the conversation from its event log: deleting
       // locally alone would be undone by the next /state merge.
-      const result = await postRuntimeConversationTruncate(index, {
+      const result = await postRuntimeConversationTruncate(runtimeIndex, {
         url: props.runtime.url,
         workspace: (session as any).workspace ?? null,
       }) as { truncated?: boolean; reason?: string };
@@ -690,8 +708,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     // truncate above — clearing every workspace's refs here would desync
     // other workspaces' `backed` arrays from their untouched `target`
     // arrays and duplicate their history on the next merge.
-    const currentWorkspace = (session as any).workspace || '__global__';
-    runtimeConversationRefsByWorkspace.get(currentWorkspace)?.splice(0);
+    runtimeConversationRefsByWorkspace.get(workspaceKey)?.splice(0);
     refresh();
     return submitInput(content);
   }