@wrongstack/cli 0.308.0 → 0.308.1

package/dist/{auth-TVOOHL4Q.js → auth-WOKC2RVG.js}

@@ -13,7 +13,7 @@ import {
   runOAuthLoginKind,
   runOAuthLoginMenu,
   validateFamily
-} from "./chunk-TOG7OMKJ.js";
+} from "./chunk-7JOMY3HO.js";
 import {
   restoreFlags
 } from "./chunk-CSAPOCBP.js";
@@ -596,4 +596,4 @@ async function runAuthRemove(deps, providerId) {
 export {
   authCmd
 };
-//# sourceMappingURL=auth-TVOOHL4Q.js.map
+//# sourceMappingURL=auth-WOKC2RVG.js.map

package/dist/{chunk-TOG7OMKJ.js → chunk-7JOMY3HO.js}

@@ -795,15 +795,15 @@ var COPILOT_PROVIDER_ID = "github-copilot";
 function sleep(ms, signal) {
   return new Promise((resolve, reject) => {
     if (signal.aborted) return reject(new DOMException("Aborted", "AbortError"));
-    const t = setTimeout(resolve, ms);
-    signal.addEventListener(
-      "abort",
-      () => {
-        clearTimeout(t);
-        reject(new DOMException("Aborted", "AbortError"));
-      },
-      { once: true }
-    );
+    const t = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    function onAbort() {
+      clearTimeout(t);
+      reject(new DOMException("Aborted", "AbortError"));
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
   });
 }
 async function startDeviceFlow(signal) {
@@ -1374,4 +1374,4 @@ export {
   addCustomProvider,
   addKeyForProvider
 };
-//# sourceMappingURL=chunk-TOG7OMKJ.js.map
+//# sourceMappingURL=chunk-7JOMY3HO.js.map

package/dist/{cli-main-RJSOWUGD.js → cli-main-5JPPEJ6N.js}

@@ -81,7 +81,7 @@ import {
   runClaudeOAuthLogin,
   runCopilotOAuthLogin,
   validateFamily
-} from "./chunk-TOG7OMKJ.js";
+} from "./chunk-7JOMY3HO.js";
 import {
   LOCAL_LLM_PRESETS,
   parseSpawnFlags
@@ -5563,7 +5563,7 @@ async function runCliExecution(params) {
     governanceHandle,
     setConfig
   } = params;
-  const { execute } = await import("./execution-4S6RSEQI.js");
+  const { execute } = await import("./execution-PHX3NFEK.js");
   return execute(
     toExecuteDeps({
       core: {
@@ -6517,7 +6517,7 @@ import { SageDomainTermExtractor } from "@wrongstack/sage";
 async function refreshDomainTermsMirror(options) {
   try {
     const extractor = new SageDomainTermExtractor();
-    return await extractor.writeDomainTermsFile(options.projectRoot, options.memoryStore);
+    return await extractor.writeDomainTermsFile(options.projectRoot, []);
   } catch (err) {
     writeErr2(
       `[wrongstack] domain-terms mirror refresh failed: ${err instanceof Error ? err.message : String(err)}
@@ -6570,7 +6570,7 @@ async function setupCliPromptAndTools(params) {
     pathJoiner: { join: (a, b) => path7.join(a, b) },
     systemPromptBuilderToken: TOKENS8.SystemPromptBuilder
   });
-  await refreshDomainTermsMirror({ projectRoot, memoryStore });
+  await refreshDomainTermsMirror({ projectRoot });
   const toolRegistry = new ToolRegistry2();
   registerBuiltinTools({
     toolRegistry,
@@ -18345,6 +18345,47 @@ function formatAudit(rows) {
 function formatLegacyImport(result) {
   return `Legacy import complete: ${result.imported} imported, ${result.skipped} skipped from ${result.files} file(s).`;
 }
+function formatMemoryDiagnostics(diag) {
+  const lines = ["\u{1FA7A} Memory diagnostics", ""];
+  const byStatus = Object.entries(diag.sageStats.byStatus).map(([k, v]) => `${k}=${v}`).join(" ");
+  const byKind = Object.entries(diag.sageStats.byKind).map(([k, v]) => `${k}=${v}`).join(" ");
+  lines.push("SAGE (lexical):");
+  lines.push(`  total entries:  ${diag.sageTotal}`);
+  lines.push(`  by status:      ${byStatus || "\u2205"}`);
+  lines.push(`  by kind:        ${byKind || "\u2205"}`);
+  if (diag.sageStats.injections !== void 0) {
+    lines.push(`  injections:     ${diag.sageStats.injections}`);
+  }
+  if (diag.sageStats.uses !== void 0) {
+    lines.push(`  uses:           ${diag.sageStats.uses}`);
+  }
+  lines.push("");
+  if (!diag.vector) {
+    lines.push("Vector memory: disabled \u2014 running on the SAGE-only surface.");
+  } else {
+    const v = diag.vector;
+    lines.push("Vector (semantic):");
+    lines.push(`  entries:        ${v.entries}`);
+    lines.push(`  with vectors:   ${v.vectors}`);
+    lines.push(`  providers:      ${v.providers.join(", ") || "\u2205"}`);
+    lines.push(`  model:          ${v.modelId} (${v.dimensions}-dim)`);
+    lines.push(`  cache:          ${v.cacheEntries} rows \xB7 ${v.cacheProviders} provider(s) \xB7 ${v.totalUseCount} hits`);
+    if (v.oldestLastUsedAt) {
+      lines.push(`  cache oldest:   ${v.oldestLastUsedAt}`);
+    }
+    lines.push(`  store path:     ${v.storePath}`);
+    lines.push("");
+    lines.push("Cross-system coverage:");
+    lines.push(`  vector \u2194 SAGE:  ${v.mirroredInSage} mirrored`);
+    if (v.standalone > 0) {
+      lines.push(`  standalone:     ${v.standalone} vector-only entries (no SAGE id \u2014 lexical recall misses these)`);
+    }
+    if (v.mirroredInSage === 0 && diag.sageTotal > 0) {
+      lines.push("  \u{1F4A1} Run `wrongstack --vector-sync` to backfill the vector mirror.");
+    }
+  }
+  return lines.join("\n");
+}
 function formatSageStats(stats, scopedCount, scopedRoles) {
   const lines = [
     "## SAGE Stats",
@@ -18407,6 +18448,60 @@ function formatSageShow(stats, memories) {
   lines.push(`*${memories.length} entr${memories.length === 1 ? "y" : "ies"}*`);
   return lines.join("\n");
 }
+function formatSearchRace(race) {
+  const lines = [];
+  const pct2 = (value) => `${Math.round(value * 100)}%`;
+  lines.push(`## \u{1F3C1} Search race \u2014 "${race.query}"`);
+  lines.push("");
+  lines.push(
+    `lexical: ${race.metrics.lexicalCount} \xB7 vector: ${race.metrics.vectorCount} \xB7 overlap: ${race.metrics.overlapCount} \xB7 agreement: ${pct2(race.metrics.agreementRatio)}`
+  );
+  if (race.metrics.lexicalOnlyRatio > 0) {
+    lines.push(
+      `  \u21B3 lexical-only: ${pct2(race.metrics.lexicalOnlyRatio)} of lexical recall is invisible to vector.`
+    );
+  }
+  if (race.metrics.vectorOnlyRatio > 0) {
+    lines.push(
+      `  \u21B3 vector-only: ${pct2(race.metrics.vectorOnlyRatio)} of vector recall is invisible to lexical.`
+    );
+  }
+  lines.push("");
+  if (race.overlap.length > 0) {
+    lines.push("### \u2705 Both channels");
+    for (const row of race.overlap) {
+      lines.push(
+        `- \`${row.id.slice(0, 12)}\u2026\` L=${pct2(row.lexicalScore)} V=${pct2(row.vectorScore)}  ${row.preview}`
+      );
+    }
+    lines.push("");
+  }
+  if (race.lexicalOnly.length > 0) {
+    lines.push("### \u{1F170}\uFE0F Lexical only (vector missed)");
+    for (const row of race.lexicalOnly) {
+      lines.push(
+        `- \`${row.id.slice(0, 12)}\u2026\` L=${pct2(row.lexicalScore ?? 0)}  ${row.preview}`
+      );
+    }
+    lines.push("");
+  }
+  if (race.vectorOnly.length > 0) {
+    lines.push("### \u{1F171}\uFE0F Vector only (lexical missed)");
+    for (const row of race.vectorOnly) {
+      lines.push(
+        `- \`${row.id.slice(0, 12)}\u2026\` V=${pct2(row.vectorScore ?? 0)}  ${row.preview}`
+      );
+    }
+    lines.push("");
+  }
+  if (race.overlap.length === 0 && race.lexicalOnly.length === 0 && race.vectorOnly.length === 0) {
+    lines.push("_No memories matched either channel for this query._");
+  }
+  return lines.join("\n");
+}
+
+// src/slash-commands/memory.ts
+import { runSearchRace } from "@wrongstack/vector-memory";
 
 // src/slash-commands/memory-gather.ts
 import { toErrorMessage as toErrorMessage15 } from "@wrongstack/core/utils";
@@ -18935,11 +19030,12 @@ async function fileProposals(Sage, proposals) {
 }
 
 // src/slash-commands/memory.ts
+var DOMAIN_TERM_TAG = "domain-term";
 function buildMemoryCommand(opts) {
   return {
     name: "memory",
     category: "Inspect",
-    description: "Inspect or edit persistent memory: /memory [show|search|file|path|for-file|graph|gather|remember|update|delete|forget|hygiene|verify|candidates|triage|audit|import-legacy|clear|compact|compact-log|stats|audience]",
+    description: "Inspect or edit persistent memory: /memory [show|search|race|file|path|for-file|graph|gather|remember|update|delete|forget|hygiene|verify|candidates|triage|audit|import-legacy|clear|compact|compact-log|stats|audience|diagnostics|purge-domain-terms]",
     async run(args) {
       const store = opts.memoryStore;
       if (!store) return { message: "No memory store configured." };
@@ -19139,6 +19235,32 @@ function buildMemoryCommand(opts) {
             )
           };
         }
+        case "race": {
+          if (!restJoined) return { message: "Usage: /memory race <query>" };
+          if (!Sage) {
+            return {
+              message: "`/memory race` requires the SAGE surface. Run the search with `/memory search <query>` instead."
+            };
+          }
+          const vectorStore = opts.vectorMemoryStore;
+          if (!vectorStore) {
+            const entries = await Sage.searchSage(restJoined, { limit: 20 });
+            return {
+              message: `Vector memory is not wired in this host \u2014 only the lexical channel is available.
+
+` + formatSageMemories(entries, `Search: ${restJoined}`)
+            };
+          }
+          try {
+            const lexical = await Sage.searchSage(restJoined, { limit: 20 });
+            const race = await runSearchRace(restJoined, lexical, vectorStore, { limit: 20 });
+            return { message: formatSearchRace(race) };
+          } catch (err) {
+            return {
+              message: `Race failed: ${err instanceof Error ? err.message : String(err)}`
+            };
+          }
+        }
         case "graph": {
           if (!Sage?.graphFor) return requiresSage("graph");
           if (!restJoined) return { message: "Usage: /memory graph <memory-id|path|query>" };
@@ -19218,6 +19340,94 @@ function buildMemoryCommand(opts) {
           await store.clear();
           return { message: "Cleared all non-permanent memory scopes by explicit force request." };
         }
+        case "purge-domain-terms": {
+          if (!Sage) return requiresSage("purge-domain-terms");
+          const force = rest.includes("--force");
+          if (!force) {
+            return {
+              message: `Refusing to run /memory purge-domain-terms without --force.
+
+This is a one-off migration that permanently removes every SAGE memory tagged \`${DOMAIN_TERM_TAG}\` (and the historical \`glossary\` / \`project-jargon\` companion tags). It cannot be undone. Run /memory purge-domain-terms --force when you are ready.`
+            };
+          }
+          try {
+            const targets = [];
+            const PAGE = 200;
+            let cursor;
+            const listPage = Sage.listSagePage;
+            if (typeof listPage === "function") {
+              while (true) {
+                const page = await listPage({
+                  statuses: ["active", "stale"],
+                  limit: PAGE,
+                  ...cursor !== void 0 ? { cursor } : {}
+                });
+                for (const mem of page.memories) {
+                  if (Array.isArray(mem.tags) && mem.tags.some(
+                    (t) => t === DOMAIN_TERM_TAG || t === "glossary" || t === "project-jargon"
+                  )) {
+                    targets.push({ id: mem.id, tags: mem.tags });
+                  }
+                }
+                if (!page.nextCursor || page.memories.length === 0) break;
+                cursor = page.nextCursor;
+              }
+            } else {
+              const memories = await Sage.listSage(["active", "stale"]);
+              for (const mem of memories) {
+                if (Array.isArray(mem.tags) && mem.tags.some(
+                  (t) => t === DOMAIN_TERM_TAG || t === "glossary" || t === "project-jargon"
+                )) {
+                  targets.push({ id: mem.id, tags: mem.tags });
+                }
+              }
+            }
+            if (targets.length === 0) {
+              return {
+                message: `No SAGE memories matched the legacy domain-term tag trio. Nothing to purge.`
+              };
+            }
+            let deleted = 0;
+            const failures = [];
+            for (const t of targets) {
+              try {
+                await Sage.deleteSage(
+                  t.id,
+                  "domain-term persistence removed; pre-migration cleanup",
+                  { force: true }
+                );
+                deleted++;
+              } catch (err) {
+                failures.push(`${t.id}: ${toErrorMessage17(err)}`);
+              }
+            }
+            const tagSummary = /* @__PURE__ */ new Map();
+            for (const t of targets) {
+              for (const tag of t.tags) {
+                if (tag === DOMAIN_TERM_TAG || tag === "glossary" || tag === "project-jargon") {
+                  tagSummary.set(tag, (tagSummary.get(tag) ?? 0) + 1);
+                }
+              }
+            }
+            const tagBreakdown = [...tagSummary.entries()].sort((a, b) => b[1] - a[1]).map(([tag, count]) => `  - ${tag}: ${count}`).join("\n");
+            const tail = failures.length > 0 ? `
+
+Failures (${failures.length}):
+${failures.slice(0, 10).map((f) => `  - ${f}`).join("\n")}` : "";
+            return {
+              message: `Purged ${deleted} of ${targets.length} legacy domain-term memories.
+
+Tag breakdown of matched memories:
+${tagBreakdown}
+
+The \`${DOMAIN_TERM_TAG}\` / \`glossary\` / \`project-jargon\` tags are now absent from the live corpus. Run \`/memory show\` to confirm.${tail}`
+            };
+          } catch (err) {
+            return {
+              message: `purge-domain-terms failed: ${toErrorMessage17(err)}`
+            };
+          }
+        }
         case "compact": {
           return runCompact(opts);
         }
@@ -19282,6 +19492,71 @@ File size reduced. Audit-logged as \`memory.log_compacted\`.`
           if (!Sage) return requiresSage("audience");
           return runAudienceMemory(Sage, rest);
         }
+        case "diagnostics": {
+          if (!Sage) {
+            return {
+              message: "Memory diagnostics require the SAGE surface (this memory store does not expose it)."
+            };
+          }
+          const vectorStore = opts.vectorMemoryStore;
+          let sageStats;
+          let sageTotal = 0;
+          try {
+            [sageStats, sageTotal] = await Promise.all([
+              Sage.stats(),
+              Sage.listSagePage({ limit: 1 }).then(
+                (page) => page.total ?? page.memories.length
+              )
+            ]);
+          } catch (err) {
+            return {
+              message: `Memory diagnostics failed: ${err instanceof Error ? err.message : String(err)}`
+            };
+          }
+          let vectorDiag;
+          if (vectorStore) {
+            try {
+              const stats = vectorStore.stats();
+              const cache = vectorStore.cacheStats();
+              const vectorRows = vectorStore.list({ limit: 5e3 });
+              let mirroredInSage = 0;
+              let standalone = 0;
+              for (const row of vectorRows) {
+                const sageId = row.metadata?.sageId;
+                if (typeof sageId === "string" && sageId.length > 0) {
+                  mirroredInSage++;
+                } else {
+                  standalone++;
+                }
+              }
+              vectorDiag = {
+                entries: stats.entries,
+                vectors: stats.vectors,
+                providers: stats.providers,
+                modelId: stats.modelId,
+                dimensions: stats.dimensions,
+                cacheEntries: cache.entries,
+                cacheProviders: cache.providers,
+                totalUseCount: cache.totalUseCount,
+                oldestLastUsedAt: cache.oldestLastUsedAt,
+                storePath: vectorStore.directory,
+                mirroredInSage,
+                standalone
+              };
+            } catch (err) {
+              return {
+                message: `Memory diagnostics (vector side) failed: ${err instanceof Error ? err.message : String(err)}`
+              };
+            }
+          }
+          return {
+            message: formatMemoryDiagnostics({
+              sageStats,
+              sageTotal,
+              vector: vectorDiag
+            })
+          };
+        }
         default:
           return {
             message: unknownSubcommand(
@@ -19289,6 +19564,7 @@ File size reduced. Audit-logged as \`memory.log_compacted\`.`
               [
                 "show",
                 "search",
+                "race",
                 "file",
                 "path",
                 "for-file",
@@ -19307,7 +19583,8 @@ File size reduced. Audit-logged as \`memory.log_compacted\`.`
                 "clear",
                 "compact",
                 "stats",
-                "audience"
+                "audience",
+                "purge-domain-terms"
               ],
               "memory"
             )
@@ -23527,7 +23804,8 @@ var THEME_META = {
     desc: "Anthony Fu's minimal palette \u2014 muted, print-like"
   },
   aura: { name: "Aura Dark", desc: "Vivid purple and spring green on near-black violet" },
-  "dark-plus": { name: "VS Code Dark+", desc: "VS Code's default \u2014 familiar blue/orange/teal" }
+  "dark-plus": { name: "VS Code Dark+", desc: "VS Code's default \u2014 familiar blue/orange/teal" },
+  monochrome: { name: "Monochrome", desc: "Pure grayscale \u2014 no hue, only luminance" }
 };
 var THEME_OPTIONS = THEME_PRESET_IDS.map((id) => ({ id, ...THEME_META[id] }));
 function presetHelpLines(perLine = 4) {
@@ -29419,6 +29697,7 @@ function setupCliSlashCommands(params) {
     renderer,
     events,
     memoryStore,
+    vectorMemoryStore,
     context,
     cwd,
     projectRoot,
@@ -29495,6 +29774,7 @@ function setupCliSlashCommands(params) {
     renderer,
     events,
     memoryStore,
+    vectorMemoryStore,
     context,
     cwd,
     projectRoot,
@@ -32065,7 +32345,12 @@ function warnUnlessMissing(logger, operation, error) {
 // src/cli-main.ts
 import {
   TransformersEmbeddingProvider,
-  VectorMemoryStore
+  VectorMemoryStore,
+  wrapMemoryPortWithVectorRecall
+} from "@wrongstack/vector-memory";
+import {
+  startFirstBootSageSync,
+  subscribeVectorMemoryToSage
 } from "@wrongstack/vector-memory";
 
 // src/wiring/replay-governance-setup.ts
@@ -32672,8 +32957,9 @@ async function runInteractive(cliCtx) {
   const modelCapabilitiesRef = {
     current: modelCapabilities
   };
-  const memoryStore = container.resolve(TOKENS12.MemoryStore);
+  let memoryStore = container.resolve(TOKENS12.MemoryStore);
   await memoryStore.initialize();
+  const teardownHandlers = [];
   let vectorMemoryStore;
   const vectorMemoryModelCacheDir = path32.join(
     projectRoot,
@@ -32695,6 +32981,34 @@ async function runInteractive(cliCtx) {
     );
     vectorMemoryStore = void 0;
   }
+  if (vectorMemoryStore) {
+    void startFirstBootSageSync({
+      store: vectorMemoryStore,
+      memoryStore,
+      logger
+    });
+    memoryStore = wrapMemoryPortWithVectorRecall(memoryStore, {
+      store: vectorMemoryStore,
+      weight: 0.3
+    });
+    const mirrorHandle = subscribeVectorMemoryToSage({
+      store: vectorMemoryStore,
+      memoryStore,
+      logger
+    });
+    teardownHandlers.push(() => mirrorHandle.dispose());
+    if (flags["vector-sync"] === true) {
+      const forced = await startFirstBootSageSync({
+        store: vectorMemoryStore,
+        memoryStore,
+        logger,
+        force: true
+      });
+      logger.info(
+        forced.synced ? `vector-memory forced re-sync complete (${forced.marker?.indexed ?? 0} new)` : `vector-memory forced re-sync skipped: ${forced.reason}`
+      );
+    }
+  }
   const skillLoader = container.resolve(TOKENS12.SkillLoader);
   const promptLoader = container.resolve(TOKENS12.PromptLoader);
   const sessionRef = {
@@ -32736,7 +33050,6 @@ async function runInteractive(cliCtx) {
     config: { provider: config.provider, model: config.model }
   });
   const tuiOwnsScreen = flags.tui === true && flags["no-tui"] !== true;
-  const teardownHandlers = [];
   const evOn = createTeardownEventRegistrar(events, teardownHandlers);
   if (vectorMemoryStore) {
     const store = vectorMemoryStore;
@@ -33166,6 +33479,7 @@ async function runInteractive(cliCtx) {
     renderer,
     events,
     memoryStore,
+    vectorMemoryStore,
     context,
     cwd,
     projectRoot,
@@ -33402,4 +33716,4 @@ export {
   CLI_VERSION,
   runInteractive
 };
-//# sourceMappingURL=cli-main-RJSOWUGD.js.map
+//# sourceMappingURL=cli-main-5JPPEJ6N.js.map

package/dist/{execution-4S6RSEQI.js → execution-PHX3NFEK.js}

@@ -207,7 +207,7 @@ async function runWebUIDispatch(ctx) {
   const isSimpleUi = !isSessionChild && flags["simpleui"] === true;
   agent.disableInteractiveConfirmation();
   renderer.setSilent(true);
-  const { runWebUI } = await import("./webui-server-A3H2SM6J.js");
+  const { runWebUI } = await import("./webui-server-CKIKAM2P.js");
   const flagValue = (names) => {
     for (const name of names) {
       if (!Object.hasOwn(flags, name)) continue;
@@ -1420,6 +1420,9 @@ async function resumeSession(ctx, sessionId) {
     }
     tokenCounter.reset();
     tokenCounter.account(resumed.data.usage, targetModel, targetProviderId);
+    if (typeof resumed.data.usage?.input === "number" && resumed.data.usage.input > 0) {
+      agent.ctx.lastRequestTokens = resumed.data.usage.input;
+    }
     const reqTokens = tokenCounter.currentRequestTokens?.();
     const tokens = (typeof reqTokens === "number" ? reqTokens : 0) + (typeof reqTokens?.input === "number" ? reqTokens.input : 0) + (typeof reqTokens?.cacheRead === "number" ? reqTokens.cacheRead : 0) + (typeof reqTokens?.cacheWrite === "number" ? reqTokens.cacheWrite : 0);
     const maxContext = agent.ctx.provider?.capabilities?.maxContext ?? 0;
@@ -6042,4 +6045,4 @@ export {
   execute,
   resolveReviewerFallbackModels
 };
-//# sourceMappingURL=execution-4S6RSEQI.js.map
+//# sourceMappingURL=execution-PHX3NFEK.js.map

package/dist/index.js

@@ -1836,7 +1836,7 @@ var subcommandsWithFocusedHelp = Object.keys(helpTable);
 var loaders = {
   acp: async () => (await import("./acp-5ZLGFHWP.js")).acpCmd,
   init: async () => (await import("./init-E2NDDOHI.js")).initCmd,
-  auth: async () => (await import("./auth-TVOOHL4Q.js")).authCmd,
+  auth: async () => (await import("./auth-WOKC2RVG.js")).authCmd,
   update: async () => (await import("./update-VZSOZGYC.js")).updateCmd,
   sessions: async () => (await import("./sessions-config-YX2ZPAFM.js")).sessionsCmd,
   config: async () => (await import("./sessions-config-YX2ZPAFM.js")).configCmd,
@@ -4447,7 +4447,7 @@ async function initializeCli(argv) {
 async function main(argv) {
   const cliCtx = await initializeCli(argv);
   if (typeof cliCtx === "number") return cliCtx;
-  const { runInteractive } = await import("./cli-main-RJSOWUGD.js");
+  const { runInteractive } = await import("./cli-main-5JPPEJ6N.js");
   return runInteractive(cliCtx);
 }
 

package/dist/slash-commands/command-context.d.ts

@@ -3,6 +3,7 @@ import type { EventBus } from '@wrongstack/core/kernel';
 import type { SlashCommandRegistry, ToolRegistry } from '@wrongstack/core/registry';
 import type { CompactReport, HealthRegistry, MemoryPort, MetricsRuntimeStatus, MetricsSink, ModeStore, Renderer, SessionStore, SkillLoader, TokenCounter } from '@wrongstack/core/types';
 import type { WstackPaths } from '@wrongstack/core/utils';
+import type { VectorMemoryStore } from '@wrongstack/vector-memory';
 /** Host capabilities supplied to command adapters. */
 export interface SlashCommandContext {
     registry: SlashCommandRegistry;
@@ -28,6 +29,13 @@ export interface SlashCommandContext {
     /** App-level EventBus — used by GoalRunner to emit phase/graph events to the TUI. */
     events: EventBus;
     memoryStore?: MemoryPort | undefined;
+    /**
+     * Optional vector memory store. Wired when the host has enabled the
+     * dual-channel system; slash commands like `/memory diagnostics`
+     * and `/memory race` use it to surface cross-system health and
+     * run lexical vs semantic channel comparisons.
+     */
+    vectorMemoryStore?: VectorMemoryStore | undefined;
     context?: Context | undefined;
     /** Working directory for the current session. */
     cwd: string;

package/dist/slash-commands/memory-formatters.d.ts

@@ -1,4 +1,5 @@
 import type { FindMemoriesForFileResponse, LegacyImportResult, MemoryCandidate, MemoryGraphEdge, MemoryVerificationResult, Sage, SageAuditRecord, SageHygieneReport, SageStats } from '@wrongstack/sage';
+import type { SearchRaceResult } from '@wrongstack/vector-memory';
 export declare function formatForFileResponse(filePath: string, response: FindMemoriesForFileResponse): string;
 export declare function requiresSage(command: string): {
     message: string;
@@ -11,6 +12,47 @@ export declare function formatHygiene(report: SageHygieneReport): string;
 export declare function formatCandidates(candidates: MemoryCandidate[]): string;
 export declare function formatAudit(rows: SageAuditRecord[]): string;
 export declare function formatLegacyImport(result: LegacyImportResult): string;
+/** Pre-collected diagnostic data for `formatMemoryDiagnostics`. */
+export interface MemoryDiagnostics {
+    sageStats: SageStats;
+    /** Total SAGE entries (active + non-active) in the corpus. */
+    sageTotal: number;
+    vector: {
+        entries: number;
+        vectors: number;
+        providers: string[];
+        modelId: string;
+        dimensions: number;
+        cacheEntries: number;
+        cacheProviders: number;
+        totalUseCount: number;
+        oldestLastUsedAt: string | null;
+        storePath: string;
+        /** Vector entries whose `metadata.sageId` resolves in SAGE. */
+        mirroredInSage: number;
+        /** Vector entries without a `metadata.sageId` (standalone). */
+        standalone: number;
+    } | undefined;
+}
+/**
+ * Two-system health snapshot — covers SAGE stats, vector memory
+ * stats, and the cross-system coverage (how many SAGE memories have a
+ * vector mirror). Surfaces the value of running both stores side by
+ * side: the operator sees drift (vector entries without a SAGE id),
+ * the embedding cache hit ratio, and the active provider / dimension.
+ */
+export declare function formatMemoryDiagnostics(diag: MemoryDiagnostics): string;
 export declare function formatSageStats(stats: SageStats, scopedCount?: number, scopedRoles?: string): string;
 export declare function formatSageShow(stats: SageStats, memories: Sage[]): string;
+/**
+ * Human-readable rendering of a `SearchRaceResult` — the channel
+ * comparison that makes the dual system's value visible. The output
+ * groups memories into three buckets: **both** (lexical + vector
+ * agreement), **lexical only** (rare-token matches the embedding
+ * model would under-rank), and **vector only** (semantic recall the
+ * FTS index would have missed). The summary metrics above the lists
+ * make the "what would I have missed?" question answerable in one
+ * glance.
+ */
+export declare function formatSearchRace(race: SearchRaceResult): string;
 //# sourceMappingURL=memory-formatters.d.ts.map

package/dist/webui-server/listen-helpers.d.ts

@@ -8,7 +8,9 @@ export declare function startDeferredHttpListen(args: {
     host: string;
     httpPort: number;
     logger: ListenLogger;
-}): Promise<void>;
+    /** Fail-fast bind (no auto-advance on EADDRINUSE). Mirrors WEBUI_STRICT_PORT. */
+    strictPort?: boolean;
+}): Promise<number>;
 export declare function startIpv6LoopbackProxy(args: {
     primary: http.Server;
     httpPort: number;

package/dist/{webui-server-A3H2SM6J.js → webui-server-CKIKAM2P.js}

@@ -32,6 +32,7 @@ import {
   createEmbeddedProviderOperations,
   envFlag,
   findFreePort,
+  isStrictPort,
   resolveAuthToken,
   sendSerialized
 } from "@wrongstack/webui-server";
@@ -649,18 +650,19 @@ import {
 
 // src/webui-server/listen-helpers.ts
 import * as http from "node:http";
+import { listenWithRetry } from "@wrongstack/webui-server";
 async function startDeferredHttpListen(args) {
-  const { server, host, httpPort, logger } = args;
-  await new Promise((resolveListen, rejectListen) => {
-    server.listen(httpPort, host, () => resolveListen());
-    server.once("error", rejectListen);
+  const { server, host, httpPort, logger, strictPort } = args;
+  const boundPort = await listenWithRetry(server, host, httpPort, {
+    maxTries: strictPort ? 1 : 10
   });
   server.on("error", (err) => {
     logger.error("http_server_error", {
       message: err.message,
-      port: httpPort
+      port: boundPort
     });
   });
+  return boundPort;
 }
 async function startIpv6LoopbackProxy(args) {
   const { primary, httpPort, logger } = args;
@@ -1207,12 +1209,12 @@ async function runWebUI(opts) {
   const surface = opts.surface ?? "webui";
   const surfaceDefaults = surface === "simpleui" ? { http: 3466 } : { http: 3456 };
   const requestedHttpPort = opts.httpPort ?? opts.port ?? surfaceDefaults.http;
-  const strictPort = opts.strictPort ?? (process.env["WEBUI_STRICT_PORT"] === "1" || process.env["WEBUI_STRICT_PORT"] === "true");
+  const strictPort = opts.strictPort ?? isStrictPort();
   let httpPort = requestedHttpPort;
   if (!strictPort) {
     httpPort = await findFreePort(host, requestedHttpPort);
   }
-  const wsPort = httpPort;
+  let wsPort = httpPort;
   const globalRoot = opts.globalConfigPath ? path7.dirname(opts.globalConfigPath) : wstackGlobalRoot();
   const profileConfigPath = opts.profileConfigPath ?? opts.globalConfigPath ?? path7.join(globalRoot, "config.json");
   const rateLimitMax = Number.parseInt(process.env["WEBUI_RATE_LIMIT"] ?? "600", 10);
@@ -1303,7 +1305,7 @@ async function runWebUI(opts) {
       return void 0;
     }
   }).filter((value) => Boolean(value));
-  const accessUrl = buildWebUIAccessUrl({
+  let accessUrl = buildWebUIAccessUrl({
     host,
     port: httpPort,
     token: wsToken,
@@ -1332,17 +1334,24 @@ async function runWebUI(opts) {
     apiToken: wsToken,
     requireToken,
     deferListen: surface === "simpleui",
+    strictPort,
     ...opts.getVectorMemoryStore ? { getVectorMemoryStore: opts.getVectorMemoryStore } : {},
     ...opts.vectorMemoryModelCacheDir ? { vectorMemoryModelCacheDir: opts.vectorMemoryModelCacheDir } : {}
   });
   const wss = httpServer ? new WebSocketServer({ server: httpServer.server, maxPayload: 20 * 1024 * 1024 }) : new WebSocketServer({ port: httpPort, host, maxPayload: 20 * 1024 * 1024 });
-  if (httpServer && surface === "simpleui") {
-    await startDeferredHttpListen({
+  if (httpServer) {
+    const boundPort = surface === "simpleui" ? await startDeferredHttpListen({
       server: httpServer.server,
       host,
       httpPort,
-      logger: consoleLogger
-    });
+      logger: consoleLogger,
+      strictPort
+    }) : httpServer.port;
+    if (boundPort !== httpPort) {
+      httpPort = boundPort;
+      wsPort = boundPort;
+      accessUrl = buildWebUIAccessUrl({ host, port: httpPort, token: wsToken, publicUrl });
+    }
   }
   let ipv6LoopbackServer = null;
   if (httpServer && host === "127.0.0.1") {
@@ -1671,4 +1680,4 @@ async function runWebUI(opts) {
 export {
   runWebUI
 };
-//# sourceMappingURL=webui-server-A3H2SM6J.js.map
+//# sourceMappingURL=webui-server-CKIKAM2P.js.map

package/dist/wiring/cli-slash-commands-setup.d.ts

@@ -12,6 +12,13 @@ export declare function setupCliSlashCommands(params: {
     renderer: any;
     events: any;
     memoryStore: any;
+    /**
+     * Vector memory store (semantic recall channel). When supplied, the
+     * `/memory diagnostics` and `/memory race` slash commands can
+     * surface cross-system health and the lexical vs semantic channel
+     * comparison.
+     */
+    vectorMemoryStore?: any;
     context: any;
     cwd: string;
     projectRoot: string;

package/dist/wiring/domain-terms-mirror.d.ts

@@ -1,49 +1,15 @@
-/**
- * Refresh the `.wrongstack/domain-terms.md` mirror file from the
- * resolved SAGE `MemoryPort` at CLI boot.
- *
- * Background
- * ----------
- * The Project Jargon Dictionary feature splits ownership between two
- * storage backends (per `packages/sage/docs/direct-icp-usage.md`):
- *   - SAGE's SQLite store is the authoritative source of truth.
- *   - `.wrongstack/domain-terms.md` is a *derived* view of the same
- *     data, kept on disk so humans (and ProjectRoot sandboxes) can
- *     read the glossary without going through the IPC client.
- *
- * `SageDomainTermExtractor.writeDomainTermsFile` already knows how to
- * regenerate the file from the canonical SAGE state. What it lacks
- * is a runtime host caller — the helper exists only in tests. This
- * module closes that gap for the CLI host.
- *
- * Behaviour
- * ---------
- * - **Fire and forget at boot.** The mirror is a derived artefact;
- *   a failure to refresh at startup must not abort the CLI. The
- *   helper logs via `writeErr` and returns `null` on failure.
- * - **Idempotent.** Calling this on every boot is safe: the file is
- *   regenerated atomically by `writeDomainTermsFile`, and the content
- *   is fully derived from SAGE state.
- * - **Honest about scope.** Only the CLI host invokes this. TUI and
- *   WebUI hosts share the same SAGE port and read the same file; the
- *   CLI boot path is the canonical place to refresh the mirror.
- */
-import type { MemoryPort } from '@wrongstack/core/types';
 export interface RefreshDomainTermsMirrorOptions {
     /** Absolute project root whose `.wrongstack/domain-terms.md` should be refreshed. */
     projectRoot: string;
-    /**
-     * Resolved SAGE `MemoryPort`. The extractor reads the `domain-term`
-     * tagged subset from this port.
-     */
-    memoryStore: MemoryPort;
 }
 /**
- * Regenerate the mirror file from the current SAGE state.
+ * Regenerate the mirror file with the empty placeholder so the path
+ * always exists. The next per-turn or session-end extraction pass
+ * overwrites the file with the freshly extracted terms.
  *
  * Returns the absolute path of the written file, or `null` when the
  * refresh failed (the CLI logs the underlying reason to stderr and
- * continues — the SAGE corpus remains authoritative).
+ * continues).
  *
  * Never throws — callers are guaranteed to receive a `string | null`
  * outcome.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/cli",
-  "version": "0.308.0",
+  "version": "0.308.1",
   "license": "MIT",
   "description": "WrongStack CLI — terminal AI coding agent with provider catalog from models.dev. Provides `wrongstack` and `wstack` binaries.",
   "keywords": [
@@ -42,32 +42,32 @@
   ],
   "dependencies": {
     "ws": "^8.21.3",
-    "@wrongstack/core": "0.308.0",
-    "@wrongstack/mcp": "0.308.0",
-    "@wrongstack/bench": "0.308.0",
-    "@wrongstack/kanban": "0.308.0",
-    "@wrongstack/acp": "0.308.0",
-    "@wrongstack/plugins": "0.308.0",
-    "@wrongstack/providers": "0.308.0",
-    "@wrongstack/persistence": "0.308.0",
-    "@wrongstack/sage": "0.308.0",
-    "@wrongstack/runtime": "0.308.0",
-    "@wrongstack/plug-lsp": "0.308.0",
-    "@wrongstack/techstack": "0.308.0",
-    "@wrongstack/sdd": "0.308.0",
-    "@wrongstack/tui": "0.308.0",
-    "@wrongstack/requirement-intake": "0.308.0",
-    "@wrongstack/telegram": "0.308.0",
-    "@wrongstack/simpleui": "0.308.0",
-    "@wrongstack/vector-memory": "0.308.0",
-    "@wrongstack/tools": "0.308.0",
-    "@wrongstack/webui": "0.308.0",
-    "@wrongstack/security-scanner": "0.308.0",
-    "@wrongstack/webui-server": "0.308.0",
-    "@wrongstack/webui-hq": "0.308.0"
+    "@wrongstack/bench": "0.308.1",
+    "@wrongstack/core": "0.308.1",
+    "@wrongstack/acp": "0.308.1",
+    "@wrongstack/kanban": "0.308.1",
+    "@wrongstack/mcp": "0.308.1",
+    "@wrongstack/plugins": "0.308.1",
+    "@wrongstack/plug-lsp": "0.308.1",
+    "@wrongstack/providers": "0.308.1",
+    "@wrongstack/requirement-intake": "0.308.1",
+    "@wrongstack/persistence": "0.308.1",
+    "@wrongstack/runtime": "0.308.1",
+    "@wrongstack/telegram": "0.308.1",
+    "@wrongstack/techstack": "0.308.1",
+    "@wrongstack/sage": "0.308.1",
+    "@wrongstack/security-scanner": "0.308.1",
+    "@wrongstack/tools": "0.308.1",
+    "@wrongstack/tui": "0.308.1",
+    "@wrongstack/simpleui": "0.308.1",
+    "@wrongstack/sdd": "0.308.1",
+    "@wrongstack/webui-hq": "0.308.1",
+    "@wrongstack/webui": "0.308.1",
+    "@wrongstack/vector-memory": "0.308.1",
+    "@wrongstack/webui-server": "0.308.1"
   },
   "optionalDependencies": {
-    "@wrongstack/desktop": "0.308.0"
+    "@wrongstack/desktop": "0.308.1"
   },
   "devDependencies": {
     "@types/node": "^26.2.0",
@@ -81,6 +81,7 @@
   "scripts": {
     "build": "node ../../scripts/build.mjs --target @wrongstack/webui-hq --skip-if-workspace-build && node ../../scripts/build-package.mjs",
     "typecheck": "pnpm --filter @wrongstack/tools run build && pnpm --filter @wrongstack/tui run build && tsc --noEmit",
+    "test": "vitest run",
     "test:hqdash": "vitest run --config vitest.hqdash.config.ts",
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   }