@north-light/crouter 0.3.172 → 0.3.174

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/__tests__/{provider-rotation.test.ts → serial/provider-rotation.test.ts}

@@ -2,22 +2,22 @@ import { before, after, test } from "node:test";
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { LockedJsonFile } from "../../../../core/locked-file.ts";
-import { expandModelCandidates } from "../../../../core/model-routes.ts";
-import type { SubscriptionCredential } from "../../lib/subscription-state.ts";
+import { LockedJsonFile } from "../../../../../core/locked-file.ts";
+import { expandModelCandidates } from "../../../../../core/model-routes.ts";
+import type { SubscriptionCredential } from "../../../lib/subscription-state.ts";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 
 // Child processes reach crouter's locked-file primitive by absolute URL: they run under
 // tsx with `--input-type=module`, so a bare relative specifier has no base to resolve from.
-const lockedFileUrl = new URL("../../../../core/locked-file.ts", import.meta.url).href;
+const lockedFileUrl = new URL("../../../../../core/locked-file.ts", import.meta.url).href;
 
 let home: string;
 let nodeCwd: string;
-let helpers: typeof import("../../lib/subscription-state.ts");
-let providerManagement: typeof import("../../../../core/provider-management.ts");
-let rotationModule: typeof import("../provider-rotation.ts");
-let providerRotationExtension: typeof import("../provider-rotation.ts").default;
+let helpers: typeof import("../../../lib/subscription-state.ts");
+let providerManagement: typeof import("../../../../../core/provider-management.ts");
+let rotationModule: typeof import("../../provider-rotation.ts");
+let providerRotationExtension: typeof import("../../provider-rotation.ts").default;
 const previousHome = process.env.HOME;
 const previousAgentDir = process.env.PI_CODING_AGENT_DIR;
 const previousModelIntent = process.env.CRTR_MODEL_INTENT;
@@ -109,9 +109,9 @@ before(async () => {
   process.env.HOME = home;
   process.env.PI_CODING_AGENT_DIR = join(home, ".pi", "agent");
   process.env.CRTR_NODE_CWD = nodeCwd;
-  helpers = await import("../../lib/subscription-state.ts");
-  providerManagement = await import("../../../../core/provider-management.ts");
-  rotationModule = await import("../provider-rotation.ts");
+  helpers = await import("../../../lib/subscription-state.ts");
+  providerManagement = await import("../../../../../core/provider-management.ts");
+  rotationModule = await import("../../provider-rotation.ts");
   providerRotationExtension = rotationModule.default;
 });
 
@@ -128,33 +128,6 @@ after(() => {
   rmSync(nodeCwd, { recursive: true, force: true });
 });
 
-test("normalizes provider subscription pool files", async () => {
-  await resetRotationState();
-  await helpers.writeSubscriptionPool("anthropic", [
-    {
-      label: " personal ",
-      refresh: " refresh-token ",
-      access: " access-token ",
-      expires: 123,
-      rateLimitedUntil: Number.NaN,
-      lastAttemptAt: Number.NaN,
-      lastRateLimitedAt: Number.NaN,
-    },
-  ]);
-
-  assert.deepEqual(helpers.readSubscriptionPool("anthropic"), [
-    {
-      label: "personal",
-      refresh: "refresh-token",
-      access: "access-token",
-      expires: 123,
-      rateLimitedUntil: 0,
-      lastAttemptAt: 0,
-      lastRateLimitedAt: 0,
-    },
-  ]);
-});
-
 // Concurrent refreshes of the same expired pool credential serialize read, token exchange,
 // and write under one lock. The injected refresh runs once; the second caller observes the
 // winner's fresh token and does not make a second single-use refresh request.
@@ -364,144 +337,6 @@ test("a genuine invalid_grant through the pool account's lock with no UI reaches
   }
 });
 
-test("/provider-sub add still adds an explicit additional subscription alongside the pool account", async () => {
-  await resetRotationState();
-  await helpers.writeSubscriptionPool("anthropic", [credential("anthropic", { refresh: "refresh-first", access: "access-first" })]);
-
-  await helpers.upsertSubscription("anthropic", credential("work", { refresh: "refresh-work", access: "access-work" }));
-
-  assert.deepEqual(helpers.readSubscriptionPool("anthropic").map((entry) => entry.label), ["anthropic", "work"]);
-});
-
-// /provider-sub <provider> add accepts the default label as the login-backed slot: the
-// registered command handler must store that login on the default pool entry rather than
-// discard it, because the pool is the only credential store a managed provider has.
-test("/provider-sub add with the default label persists the login credential to the default pool entry", async () => {
-  await resetRotationState();
-
-  const { ctx, commands, pi } = makeRotationCtx();
-  ctx.hasUI = true;
-  ctx.ui.notify = () => {};
-  ctx.ui.input = async () => "personal";
-  rotationModule.__setLoginForProviderForTest(async () => ({ refresh: "refresh-login", access: "access-login", expires: Date.now() + 60_000 }));
-
-  try {
-    await providerRotationExtension(pi);
-    await commands["provider-sub"].handler("anthropic add", ctx);
-
-    // The default pool entry carries the login's value with the cooldown cleared -- not a
-    // broken "authenticated but valueless" slot.
-    const [entry] = helpers.readSubscriptionPool("anthropic");
-    assert.equal(entry.label, "personal");
-    assert.equal(entry.refresh, "refresh-login");
-    assert.equal(entry.access, "access-login");
-    assert.equal(entry.rateLimitedUntil, 0);
-  } finally {
-    rotationModule.__setLoginForProviderForTest(undefined);
-  }
-});
-
-// The retained agent command must use the same coordinated removal as the Providers panel: the
-// pool account leaves the pool exactly like any explicit account.
-test("/provider-sub rm removes the pool account", async () => {
-  await resetRotationState();
-  await helpers.writeSubscriptionPool("anthropic", [credential("anthropic")]);
-  assert.equal(helpers.readSubscriptionPool("anthropic")[0]?.label, "anthropic");
-
-  const { ctx, commands, pi } = makeRotationCtx();
-  ctx.ui.notify = () => {};
-  await providerRotationExtension(pi);
-  await commands["provider-sub"].handler("anthropic rm anthropic", ctx);
-
-  assert.equal(helpers.readSubscriptionPool("anthropic").some((entry) => entry.label === "anthropic"), false);
-});
-
-// The manual-code-paste dialog races pi-ai's loopback callback server. These tests exercise
-// the wrapper directly with a run function that can leave manual input pending. Aborting the
-// dialog signal removes its broker entry and emits a request-scoped dismissal frame, so the
-// assertions verify the signal rather than an unrelated notification.
-
-test("loginWithManualInputCleanup aborts the still-open manual dialog's signal once the OAuth call settles without it (loopback-wins parity)", async () => {
-  let capturedSignal: AbortSignal | undefined;
-  const notifications: Array<{ message: string; type?: string }> = [];
-  const ctx = {
-    ui: {
-      notify: (message: string, type?: string) => notifications.push({ message, type }),
-      input: (_title: string, _placeholder: string, opts?: { signal?: AbortSignal }) => {
-        capturedSignal = opts?.signal;
-        // Never resolves on its own -- mirrors pi-ai abandoning the manual-input
-        // promise once the loopback callback server wins the race.
-        return new Promise<string | undefined>(() => {});
-      },
-    },
-  } as any;
-
-  const result = await rotationModule.loginWithManualInputCleanup(ctx, async (readCode: any) => {
-    // Start the manual-code prompt (as onManualCodeInput would) but -- like the real
-    // pi-ai race -- never await its outcome; the loopback callback "wins" instead.
-    void readCode("Open this URL...", "placeholder").catch(() => {});
-    return "loopback-code";
-  });
-
-  assert.equal(result, "loopback-code");
-  assert.equal(capturedSignal?.aborted, true, "the abandoned manual-input dialog's signal must be aborted once the OAuth call settles -- the broker turns that abort into a correlated extension_ui_dismiss");
-  assert.equal(notifications.length, 0, "no broad dismiss notify -- an unrelated notify must never be used as a dialog-dismissal signal");
-});
-
-test("loginWithManualInputCleanup dismisses the manual dialog at callback-win (onProgress), NOT after a delayed token exchange", async () => {
-  // Once the loopback callback supplies a code, progress starts token exchange. The manual
-  // dialog is aborted at that boundary, before the exchange resolves, so a slow exchange does
-  // not leave its overlay open.
-  let order = 0;
-  let abortedAt: number | undefined;
-  let runResolvedAt: number | undefined;
-  const ctx = {
-    ui: {
-      notify: () => {},
-      input: (_title: string, _placeholder: string, opts?: { signal?: AbortSignal }) =>
-        // Mirror the broker: resolve to undefined on abort (which readCode turns
-        // into a throw, inert on the abandoned promise like pi-ai's own .catch).
-        new Promise<string | undefined>((resolve) => {
-          opts?.signal?.addEventListener("abort", () => { abortedAt = order++; resolve(undefined); }, { once: true });
-        }),
-    },
-  } as any;
-
-  const result = await rotationModule.loginWithManualInputCleanup(ctx, async (readCode: any, dismissManual: () => void) => {
-    void readCode("Open this URL...", "placeholder").catch(() => {});
-    dismissManual(); // pi-ai's onProgress fires here -- it already has the code
-    await new Promise((r) => setTimeout(r, 25)); // the (possibly slow) token exchange
-    runResolvedAt = order++;
-    return "exchanged-token";
-  });
-
-  assert.equal(result, "exchanged-token");
-  assert.notEqual(abortedAt, undefined, "the manual dialog's signal must have been aborted");
-  assert.notEqual(runResolvedAt, undefined);
-  assert.ok(abortedAt! < runResolvedAt!, "the manual dialog must be dismissed at callback-win (onProgress), BEFORE the delayed token exchange completes");
-});
-
-test("loginWithManualInputCleanup's readCode rejects (rather than resolving to \"\") when the manual dialog is cancelled or times out", async () => {
-  const ctx = {
-    ui: {
-      notify: () => {},
-      // ctx.ui.input resolving to undefined is exactly what a Cancel button or the
-      // dialog's own timeout produces (dialogPromise's cancelled/timeout default).
-      input: async () => undefined,
-    },
-  } as any;
-
-  // pi-ai only calls its onPrompt paste-only fallback when onManualCodeInput
-  // RESOLVES (even to a falsy value) -- never when it rejects. Asserting
-  // loginWithManualInputCleanup itself rejects (instead of resolving to "", the
-  // pre-fix behavior) proves readCode ends the OAuth attempt directly and pi-ai
-  // never gets the chance to fall through to that second, URL-less dialog.
-  await assert.rejects(
-    () => rotationModule.loginWithManualInputCleanup(ctx, (readCode) => readCode("Open this URL...", "placeholder")),
-    /OAuth login cancelled/,
-  );
-});
-
 test("the synthesized ladder registry preserves family preference before configured strength fallback", async () => {
   await resetRotationState();
   writeLadderConfig();
@@ -877,7 +712,7 @@ test("addSubscription normalizes labels and enforces Codex account uniqueness in
 test("cross-process explicit adds admit exactly one duplicate Codex account", { timeout: 60_000 }, async () => {
   await resetRotationState();
   const poolPath = join(home, ".pi", "agent", "openai-codex-subscriptions.json");
-  const subscriptionStateUrl = new URL("../../lib/subscription-state.ts", import.meta.url).href;
+  const subscriptionStateUrl = new URL("../../../lib/subscription-state.ts", import.meta.url).href;
   const spawnContender = (label: string) => {
     const child = spawn(
       process.execPath,
@@ -1001,6 +836,100 @@ function makeRotationCtx(modelIntent?: string) {
   return { ctx, setModelCalls, thinkingLevelCalls, providers, events, commands, pi };
 }
 
+test("managed Anthropic requests opt into server-side fallback without changing other managed routes", async () => {
+  await resetRotationState();
+  writeLadderConfig();
+  await helpers.writeSubscriptionPool("anthropic", [credential("anthropic")]);
+
+  const anthropicModel = { provider: "anthropic", id: "claude-opus-5", api: "anthropic-messages" };
+  const { ctx, providers, events, pi } = makeRotationCtx("anthropic/ultra");
+  ctx.model = anthropicModel;
+  const streamOptions: any[] = [];
+  const fetchCalls: Array<[RequestInfo | URL, RequestInit | undefined]> = [];
+  const callerPayloads: unknown[] = [];
+  rotationModule.__setStreamForProviderForTest((_model, _context, options) => {
+    streamOptions.push(options);
+    return (async function* () {
+      yield { type: "text_delta", text: "served" };
+    })() as any;
+  });
+
+  try {
+    await providerRotationExtension(pi);
+    await events.session_start?.({}, ctx);
+    const stream = providers["anthropic"].streamSimple(anthropicModel, ctx, {
+      onPayload(payload: unknown) {
+        callerPayloads.push(payload);
+        if ((payload as { replaceWithNull?: boolean })?.replaceWithNull) return null;
+        return { ...(payload as object), callerPayload: true };
+      },
+      fetch: async (input: RequestInfo | URL, init?: RequestInit) => {
+        fetchCalls.push([input, init]);
+        return new Response();
+      },
+    });
+    for await (const _event of stream) {
+      // Drain the managed request so the injected stream options are captured.
+    }
+
+    const [anthropicOptions] = streamOptions;
+    assert.deepEqual(await anthropicOptions.onPayload({ request: true }, anthropicModel), {
+      request: true,
+      callerPayload: true,
+      fallbacks: "default",
+    });
+    assert.deepEqual(await anthropicOptions.onPayload({ replaceWithNull: true }, anthropicModel), { fallbacks: "default" });
+    assert.deepEqual(callerPayloads, [{ request: true }, { replaceWithNull: true }]);
+
+    for (const headers of [
+      new Headers({ "anthropic-beta": "claude-code-20250219,oauth-2025-04-20", "x-keep": "headers" }),
+      { "anthropic-beta": "claude-code-20250219,oauth-2025-04-20", "x-keep": "object" },
+      [["anthropic-beta", "claude-code-20250219,oauth-2025-04-20"], ["x-keep", "pairs"]],
+    ]) {
+      await anthropicOptions.fetch("https://example.test/messages", { headers });
+    }
+    for (const [_input, init] of fetchCalls) {
+      const headers = new Headers(init?.headers);
+      assert.equal(headers.get("anthropic-beta"), "claude-code-20250219,oauth-2025-04-20,server-side-fallback-2026-07-01");
+      assert.ok(headers.get("x-keep"));
+    }
+
+    const haikuModel = { provider: "anthropic", id: "claude-haiku-4-5", api: "anthropic-messages" };
+    const haikuOnPayload = (payload: unknown) => payload;
+    const haikuFetch = async () => new Response();
+    for await (const _event of providers["anthropic"].streamSimple(haikuModel, ctx, {
+      onPayload: haikuOnPayload,
+      fetch: haikuFetch,
+    })) {
+      // Drain the managed Haiku request.
+    }
+    assert.equal(streamOptions[1].onPayload, haikuOnPayload);
+    assert.equal(streamOptions[1].fetch, haikuFetch);
+    assert.deepEqual(await streamOptions[1].onPayload({ request: true }, haikuModel), { request: true });
+
+    await resetRotationState();
+    await helpers.writeSubscriptionPool("openai-codex", [credential("codex")]);
+    const codexModel = { provider: "openai-codex", id: "gpt-5.6-sol", api: "openai-codex-responses" };
+    const codex = makeRotationCtx("openai/strong");
+    const codexOptions: any[] = [];
+    rotationModule.__setStreamForProviderForTest((_model, _context, options) => {
+      codexOptions.push(options);
+      return (async function* () {
+        yield { type: "text_delta", text: "served" };
+      })() as any;
+    });
+    await providerRotationExtension(codex.pi);
+    await codex.events.session_start?.({}, codex.ctx);
+    for await (const _event of codex.providers["openai-codex"].streamSimple(codexModel, codex.ctx)) {
+      // Drain the managed Codex route.
+    }
+    assert.equal(codexOptions[0].onPayload, undefined);
+    assert.equal(codexOptions[0].fetch, undefined);
+  } finally {
+    rotationModule.__setStreamForProviderForTest(undefined);
+  }
+});
+
 // A live route carries the session's exact thinking level through every provider
 // request, including the requests that continue a turn after tool results.
 test("preserves a manually selected thinking level across provider requests", async () => {

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/claude-plugin-commands.ts

@@ -11,7 +11,7 @@ import {
   realpathSync,
 } from "node:fs";
 import { homedir } from "node:os";
-import { join, resolve, sep, dirname } from "node:path";
+import { join, resolve, dirname } from "node:path";
 import { loadProfileManifest } from "../../../core/profiles/manifest.js";
 import { stripMarkdownComments } from "../../../core/runtime/command-expansion.js";
 
@@ -53,7 +53,6 @@ const SHIM_DIR = join(HOME, ".pi", "agent", ".plugin-command-shims");
 const PI_PROMPTS = join(HOME, ".pi", "agent", "prompts");
 const PROJECT_PI_PROMPTS = ".pi/prompts";
 
-const INCLUDE_ALL_SCOPES = true;
 const EXCLUDE_NAMES = new Set(["claude.md", "agents.md", "readme.md", "index.md"]);
 
 type Kind = "command" | "skill";
@@ -63,7 +62,7 @@ type IndexRecord = { file: string; kind: Kind; baseDir: string };
 // hook to find the file to expand+execute (and how to frame it).
 const commandIndex = new Map<string, IndexRecord>();
 
-type InstallRecord = { scope?: string; installPath?: string; projectPath?: string };
+type InstallRecord = { installPath?: string };
 type InstalledPlugins = { plugins?: Record<string, InstallRecord[]> };
 type Shim = { name: string; target: string; kind: Kind; baseDir: string };
 
@@ -171,14 +170,8 @@ function selectedProfileProjects(): string[] {
   }
 }
 
-function cwdInProject(cwd: string, projectPath: string): boolean {
-  const a = resolve(cwd);
-  const b = resolve(projectPath);
-  return a === b || a.startsWith(b + sep);
-}
-
-// Installed plugins as { name, installPath } pairs (scope-filtered).
-function pluginDirs(cwd: string): { name: string; installPath: string }[] {
+// Installed plugins as { name, installPath } pairs.
+function pluginDirs(): { name: string; installPath: string }[] {
   if (!existsSync(INSTALLED)) return [];
   let data: InstalledPlugins;
   try {
@@ -191,9 +184,6 @@ function pluginDirs(cwd: string): { name: string; installPath: string }[] {
     const name = key.split("@")[0];
     for (const rec of records ?? []) {
       if (!rec.installPath) continue;
-      if (!INCLUDE_ALL_SCOPES && rec.scope === "project") {
-        if (!rec.projectPath || !cwdInProject(cwd, rec.projectPath)) continue;
-      }
       out.push({ name, installPath: rec.installPath });
     }
   }
@@ -254,7 +244,7 @@ function buildShims(cwd: string): string {
   const shims: Shim[] = [];
   const nativeStems = nativePiPromptStems();
   const projectDirs = projectClaudeDirs(cwd, selectedProfileProjects());
-  const plugins = pluginDirs(cwd);
+  const plugins = pluginDirs();
 
   // Commands: user, project ancestors, then plugins.
   collectCommands(USER_COMMANDS, [], [], shims);

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/frontmatter-rules/index.ts

@@ -70,6 +70,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { parse as parseYaml } from "yaml";
+import { mergeAutoLoadedContext } from "../../../../pi-extensions/envelope-merge.js";
 
 const MARKDOWN_EXTS = new Set([".md", ".mdx", ".markdown"]);
 
@@ -138,34 +139,6 @@ function attr(s: string): string {
 		.replace(/>/g, ">");
 }
 
-const AUTO_CONTEXT_RE = /<auto-loaded-context(?:\s[^>]*)?>\n([\s\S]*?)\n<\/auto-loaded-context>/;
-
-function isTextContent(block: ToolResultEvent["content"][number]): block is Extract<ToolResultEvent["content"][number], { type: "text" }> {
-	return block.type === "text";
-}
-
-function mergeAutoLoadedContext(items: string[], content: ToolResultEvent["content"]): ToolResultEvent["content"] {
-	const existingText = content.map((block) => isTextContent(block) ? block.text : "").join("\n");
-	const fresh = items.map((item) => item.trim()).filter((item) => item !== "" && !existingText.includes(item));
-	if (fresh.length === 0) return content;
-	const inner = fresh.join("\n");
-
-	const existingIdx = content.findIndex((block) => isTextContent(block) && AUTO_CONTEXT_RE.test(block.text));
-	if (existingIdx !== -1) {
-		return content.map((block, idx) => {
-			if (idx !== existingIdx || !isTextContent(block)) return block;
-			return {
-				...block,
-				text: block.text.replace(AUTO_CONTEXT_RE, (_whole: string, current: string) => {
-					const trimmed = String(current).trim();
-					return `<auto-loaded-context>\n${inner}${trimmed === "" ? "" : `\n${trimmed}`}\n</auto-loaded-context>`;
-				}),
-			};
-		});
-	}
-
-	return [{ type: "text" as const, text: `<auto-loaded-context>\n${inner}\n</auto-loaded-context>` }, ...content];
-}
 
 // Pull the leading `--- ... ---` YAML block out of a markdown file.
 function extractFrontmatter(raw: string): Frontmatter | null {

package/dist/builtin-pi-packages/pi-crtr-extensions/extensions/memory-slash-commands.ts

@@ -1,16 +1,11 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { readFileSync } from "node:fs";
-import { parse as parseYaml } from "yaml";
+import { listMemoryDocs } from "../../../commands/memory/list.js";
+import { createMemoryDocSnapshot, readMemoryDocContent } from "../../../commands/memory/read.js";
 import {
   expandDeterministicCommand,
   type DeterministicCommandExpansion,
 } from "../../../core/runtime/command-expansion.js";
 
-const exec = promisify(execFile);
-const CRTR = "crtr";
-
 // ---------------------------------------------------------------------------
 // memory-slash-commands: any memory doc frontmatter-flagged `slash: true`
 // becomes an invocable slash command (`/<name>`). This mirrors Hermes Agent's
@@ -18,24 +13,22 @@ const CRTR = "crtr";
 // the doc body (plus the user's free-text args) as a normal turn instead of
 // requiring a separate skill-invocation mechanism.
 //
-// Discovery shells out to `crtr memory list --json --paths`, which already
-// resolves the substrate's scope precedence (project stack > profile > user >
-// builtin) — this file does not walk memory/ directories or reimplement scope
-// resolution. `list`'s JSON items are already scope-precedence sorted (see
-// `scopeRank` in crouter's memory/shared.ts), so first-occurrence-wins per doc
-// name reproduces the resolver's identity precedence for free. `list` is
-// bounded/paginated, so discovery pages through the full corpus via
-// `next_cursor` until exhausted, and passes `--paths` because `path` is
-// load-bearing here (isSlashFlagged reads the file at each item's path).
+// Discovery uses the in-process `memory list` inventory and its source
+// snapshot, which already resolve the substrate's scope precedence (project
+// stack > profile > user > builtin). This file does not walk memory/
+// directories or reimplement scope resolution. `list`'s items are
+// scope-precedence sorted (see `scopeRank` in crouter's memory/shared.ts), so
+// first-occurrence-wins per doc name reproduces the resolver's identity
+// precedence for free. The inventory carries parsed `slash` flags and resolved
+// paths for command bodies.
 // ---------------------------------------------------------------------------
 
-const FRONTMATTER_RE = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?/;
-
 interface MemoryListItem {
   name: string;
   path: string;
   short_form: string;
   is_dir: boolean;
+  slash: boolean;
 }
 
 export interface SlashDoc {
@@ -49,65 +42,40 @@ export interface SlashDoc {
   description: string;
 }
 
-interface MemoryListPage {
-  items: MemoryListItem[];
-  next_cursor: string | null;
-}
+// `memory list` already chose the winning path for each identity. Keep that
+// path for registration-body reads so every slash document does not re-walk the
+// full corpus through `memory read`.
+const resolvedMemoryPaths = new Map<string, string>();
 
 async function defaultListMemoryDocs(): Promise<MemoryListItem[]> {
-  const items: MemoryListItem[] = [];
-  let cursor: string | undefined;
-  for (;;) {
-    const args = ["memory", "list", "--json", "--paths", "--limit", "200"];
-    if (cursor !== undefined) args.push("--cursor", cursor);
-    const { stdout } = await exec(CRTR, args, { maxBuffer: 8 * 1024 * 1024 });
-    const parsed = JSON.parse(stdout) as MemoryListPage;
-    items.push(...parsed.items);
-    if (parsed.next_cursor === null) break;
-    cursor = parsed.next_cursor;
-  }
+  const snapshot = createMemoryDocSnapshot();
+  const items = listMemoryDocs(undefined, undefined, true, snapshot.docs).map((doc) => ({
+    name: doc.name,
+    path: doc.path,
+    short_form: doc.shortForm,
+    is_dir: doc.isDir,
+    slash: doc.slash,
+  }));
+
+  // Slash eligibility follows the list identity, while the body follows the
+  // separate `memory read <name>` resolver contract (including direct-path
+  // precedence). Resolve all eligible names against one source snapshot.
+  const seen = new Set<string>();
+  const names = items.flatMap((item) => {
+    if (item.is_dir || seen.has(item.name)) return [];
+    seen.add(item.name);
+    return item.slash === true ? [item.name] : [];
+  });
+  const resolved = snapshot.resolve(names);
+  resolvedMemoryPaths.clear();
+  for (const [name, doc] of resolved) resolvedMemoryPaths.set(name, doc.path);
   return items;
 }
 
-async function defaultReadMemoryDoc(name: string): Promise<string> {
-  const { stdout } = await exec(CRTR, ["memory", "read", name, "--json"], { maxBuffer: 8 * 1024 * 1024 });
-  const parsed = JSON.parse(stdout) as { content: string };
-  return parsed.content;
-}
-
-let listMemoryDocsImpl = defaultListMemoryDocs;
-let readMemoryDocImpl = defaultReadMemoryDoc;
-
-/** Test seam: override doc discovery so tests never shell out to `crtr`. */
-export function __setListMemoryDocsForTest(fn?: typeof listMemoryDocsImpl): void {
-  listMemoryDocsImpl = fn ?? defaultListMemoryDocs;
-}
-
-/** Test seam: override doc-body reads so tests never shell out to `crtr`. */
-export function __setReadMemoryDocForTest(fn?: typeof readMemoryDocImpl): void {
-  readMemoryDocImpl = fn ?? defaultReadMemoryDoc;
-}
-
-/** Read a memory doc's raw frontmatter directly off its already-resolved
- *  `path` (from `crtr memory list`) and report whether `slash` is `true`.
- *  No directory walk, no scope reasoning — the path is already resolved. */
-function isSlashFlagged(path: string): boolean {
-  let raw: string;
-  try {
-    raw = readFileSync(path, "utf8");
-  } catch {
-    return false;
-  }
-  const match = raw.match(FRONTMATTER_RE);
-  if (!match) return false;
-  let data: unknown;
-  try {
-    data = parseYaml(match[1]);
-  } catch {
-    return false;
-  }
-  if (data === null || typeof data !== "object" || Array.isArray(data)) return false;
-  return (data as Record<string, unknown>).slash === true;
+function defaultReadMemoryDoc(name: string): string {
+  const path = resolvedMemoryPaths.get(name);
+  if (path === undefined) throw new Error(`memory slash document was not resolved: ${name}`);
+  return readMemoryDocContent(path);
 }
 
 /** `/`-joined path-derived doc name -> the registered slash-command name. */
@@ -121,7 +89,7 @@ export function slashCommandName(docName: string): string {
 export async function discoverSlashDocs(): Promise<SlashDoc[]> {
   let items: MemoryListItem[];
   try {
-    items = await listMemoryDocsImpl();
+    items = await defaultListMemoryDocs();
   } catch {
     return [];
   }
@@ -131,26 +99,13 @@ export async function discoverSlashDocs(): Promise<SlashDoc[]> {
     if (item.is_dir) continue;
     if (seen.has(item.name)) continue;
     seen.add(item.name);
-    if (isSlashFlagged(item.path)) {
+    if (item.slash) {
       out.push({ name: item.name, commandName: slashCommandName(item.name), description: item.short_form });
     }
   }
   return out;
 }
 
-/** Compose the invocation prompt from the freshly-read doc body plus the
- *  user's raw invocation args, following Claude Code's `$ARGUMENTS`
- *  convention. When the body contains `$ARGUMENTS`, every occurrence is
- *  replaced with the trimmed args (empty string when none were given) and the
- *  substituted body is injected AS-IS — the doc placed its own args, so no
- *  extra header is added. Otherwise: a short invocation header naming the
- *  command and the raw args (both the given-args and no-args cases are
- *  load-bearing, per the Hermes /learn prompt pattern this mirrors), followed
- *  by the full doc body as the instructions to follow. */
-export function composeSlashPrompt(commandName: string, rawArgs: string, body: string): string {
-  return expandDeterministicCommand({ kind: "memory-slash", commandName, body }, rawArgs);
-}
-
 export default async function (pi: ExtensionAPI) {
   const docs = await discoverSlashDocs();
   for (const doc of docs) {
@@ -160,7 +115,7 @@ export default async function (pi: ExtensionAPI) {
       expansion = {
         kind: "memory-slash",
         commandName: doc.commandName,
-        body: await readMemoryDocImpl(doc.name),
+        body: defaultReadMemoryDoc(doc.name),
       };
     } catch (err) {
       loadError = err;