@vellumai/assistant 0.7.1 → 0.7.3

package/src/memory/v2/__tests__/consolidation-job.test.ts

@@ -372,26 +372,58 @@ describe("memoryV2ConsolidateJob — concurrent invocations", () => {
     writeFileSync(bufferPath(), "- [Apr 27, 9:00 AM] Alice prefers VS Code.\n");
   });
 
-  test("a stale lock file blocks a second concurrent invocation", async () => {
-    // Pre-seed a lock file as if a prior run was still in flight. The
-    // simple wx-based lock has no liveness probe, so this also covers
-    // stale-lock-on-disk behavior — operators clear stale locks manually.
+  test("a live lock holder blocks a second concurrent invocation", async () => {
+    // Pre-seed a lock file with the current process's PID so the liveness
+    // probe sees a running holder and the second invocation correctly
+    // reports `locked` rather than taking over.
     mkdirSync(join(memoryDir(), ".v2-state"), { recursive: true });
-    writeFileSync(lockPath(), "9999 1700000000000\n");
+    writeFileSync(lockPath(), `${process.pid} 1700000000000\n`);
 
     const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
 
     expect(result.kind).toBe("locked");
     if (result.kind === "locked") {
-      expect(result.holder).toContain("9999");
+      expect(result.holder).toContain(`${process.pid}`);
     }
     expect(bootstrapCalls).toBe(0);
     expect(wakeCalls).toBe(0);
     expect(enqueuedJobs).toHaveLength(0);
-    // The pre-seeded lock must NOT be removed by a contender — only the
-    // owner releases it.
+    // The live holder's lock must NOT be removed by a contender.
     expect(existsSync(lockPath())).toBe(true);
   });
+
+  test("a stale lock from a non-running PID is taken over and consolidation proceeds", async () => {
+    // PID 999999 is well outside the typical kernel max_pid range on macOS
+    // and Linux, so kill(pid, 0) reliably returns ESRCH. The takeover path
+    // must unlink the stale file, retry the wx create, and bootstrap the
+    // background conversation as if the lock had been free all along.
+    mkdirSync(join(memoryDir(), ".v2-state"), { recursive: true });
+    writeFileSync(lockPath(), "999999 1700000000000\n");
+
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    expect(bootstrapCalls).toBe(1);
+    expect(wakeCalls).toBe(1);
+    // Lock is released in the finally block after a successful run.
+    expect(existsSync(lockPath())).toBe(false);
+  });
+
+  test("an empty / corrupted lock file is treated as stale and taken over", async () => {
+    // A zero-byte file simulates a prior holder that crashed between the
+    // O_EXCL create and the PID write. With only one writer ever, an
+    // unparseable payload is unambiguously corruption, not a live
+    // mid-write — take it over.
+    mkdirSync(join(memoryDir(), ".v2-state"), { recursive: true });
+    writeFileSync(lockPath(), "");
+
+    const result = await memoryV2ConsolidateJob(makeJob(), CONFIG);
+
+    expect(result.kind).toBe("invoked");
+    expect(bootstrapCalls).toBe(1);
+    expect(wakeCalls).toBe(1);
+    expect(existsSync(lockPath())).toBe(false);
+  });
 });
 
 describe("CONSOLIDATION_PROMPT", () => {

package/src/memory/v2/__tests__/injection.test.ts

@@ -8,18 +8,18 @@
  *   - A new topic appearing on a later turn injects only the new slug.
  *   - `evictCompactedTurns` re-enables a previously-injected slug —
  *     after eviction the same slug appears again in `toInject`.
- *   - Skill pipeline: skill-only block, mixed concept-page+skill block,
- *     both-empty → null, no skill dedup across turns, `top_k_skills: 0`
- *     short-circuit.
+ *   - Unified-pool skills: a `skills/<id>` slug ranked into the top-K is
+ *     rendered under `### Skills You Can Use`, mixed concept-page+skill
+ *     blocks render concept sections first then the skills suffix, both
+ *     empty → null block, skills participate in `everInjected` so they
+ *     deduplicate across turns just like concepts.
  *
  * Hermetic by design: the embedding backend, qdrant client, and `getConfig`
  * are mocked at the module level so the suite never reaches a real backend.
- * The skill activation pipeline (`selectSkillCandidates`,
- * `computeSkillActivation`, `selectSkillInjections`) and the skill-store
- * lookup (`getSkillCapability`) are also mocked at the module level so each
- * test can stage its skill slate without touching the dedicated skills
- * Qdrant collection. The activation-store uses an in-memory SQLite database
- * so writes are real but contained.
+ * The skill-store cache (`getSkillCapability`, `isSkillSlug`) is mocked so
+ * each test can stage skill content without touching the real catalog.
+ * The activation-store uses an in-memory SQLite database so writes are
+ * real but contained.
  *
  * Tests use a temp workspace (mkdtemp) and never touch `~/.vellum/`. Sample
  * page content uses generic placeholders (Alice, Bob, etc.) per the cross-
@@ -124,43 +124,32 @@ mock.module("@qdrant/js-client-rest", () => ({
 }));
 
 // ---------------------------------------------------------------------------
-// Skill pipeline mocks
+// Skill-store mock
 // ---------------------------------------------------------------------------
 //
-// The skill side of the per-turn pipeline (`selectSkillCandidates`,
-// `computeSkillActivation`, `selectSkillInjections`) has its own dedicated
-// Qdrant collection and embedding round-trips. Rather than threading staged
-// hits through that whole pipeline for every test, we mock the three skill
-// helpers and the synchronous `getSkillCapability` lookup at the module level
-// and let each test stage a `topNow` ordering and the matching `SkillEntry`
-// content directly.
+// Skills now flow through the unified pipeline under the `skills/<id>` slug
+// prefix — they are scored by `simBatch` against the same Qdrant collection
+// as concept pages, ranked by `selectInjections`, and rendered alongside
+// concept sections. The render path branches on `isSkillSlug(slug)` to fetch
+// content from the in-process cache via `getSkillCapability` instead of
+// reading a page from disk. Tests stage that cache and rely on the regular
+// `stageTurn` plumbing to land skill slugs in the candidate set.
 
 const skillState = {
-  /** Ordered ids `selectSkillInjections.topNow` returns this turn. */
-  topSkillIds: [] as string[],
-  /** id → SkillEntry used by `getSkillCapability`. */
+  /** id → SkillEntry consulted by `getSkillCapability`. */
   entries: new Map<string, SkillEntry>(),
 };
 
-const realActivation = await import("../activation.js");
-mock.module("../activation.js", () => ({
-  ...realActivation,
-  // The injection wiring only consumes `topNow` — the candidate set and
-  // activation map are inputs to `selectSkillInjections`, not anything the
-  // injection logic introspects. Stub them to empty so the test stays focused
-  // on the wiring, not the pipeline internals (covered in activation.test.ts).
-  selectSkillCandidates: async () => new Set<string>(),
-  computeSkillActivation: async () => ({
-    activation: new Map<string, number>(),
-    breakdown: new Map(),
-  }),
-  selectSkillInjections: ({ topK }: { topK: number }) => ({
-    topNow: skillState.topSkillIds.slice(0, topK),
-  }),
-}));
-
 mock.module("../skill-store.js", () => ({
-  getSkillCapability: (id: string) => skillState.entries.get(id) ?? null,
+  getSkillCapability: (idOrSlug: string) => {
+    const id = idOrSlug.startsWith("skills/")
+      ? idOrSlug.slice("skills/".length)
+      : idOrSlug;
+    return skillState.entries.get(id) ?? null;
+  },
+  isSkillSlug: (slug: string) => slug.startsWith("skills/"),
+  SKILL_SLUG_PREFIX: "skills/",
+  skillSlugFor: (id: string) => `skills/${id}`,
 }));
 
 // ---------------------------------------------------------------------------
@@ -292,7 +281,6 @@ function makeConfig(
     k: number;
     hops: number;
     top_k: number;
-    top_k_skills: number;
     epsilon: number;
     dense_weight: number;
     sparse_weight: number;
@@ -307,8 +295,7 @@ function makeConfig(
         c_now: 0.2,
         k: 0.5,
         hops: 2,
-        top_k: 20,
-        top_k_skills: 5,
+        top_k: 25,
         epsilon: 0.01,
         dense_weight: 1.0,
         sparse_weight: 0.0,
@@ -331,6 +318,13 @@ function stageTurn(
   hits: Array<{ slug: string; denseScore?: number; sparseScore?: number }>,
   channels = 4,
 ): void {
+  // Clear any leftovers from a prior turn before staging this one so unused
+  // staged responses can't bleed into the next injection. The activation
+  // pipeline now skips the embedding round-trip for empty texts (turn 1's
+  // assistantMessage), so consumed-channel counts vary per turn — staging
+  // exclusively is the only way multi-turn tests stay aligned.
+  state.queryResponses.dense.length = 0;
+  state.queryResponses.sparse.length = 0;
   for (let i = 0; i < channels; i++) {
     state.queryResponses.dense.push({
       points: hits
@@ -350,7 +344,6 @@ function resetState(): void {
   state.sparseReturn = { indices: [1, 2, 3], values: [0.5, 0.5, 0.5] };
   state.queryResponses.dense.length = 0;
   state.queryResponses.sparse.length = 0;
-  skillState.topSkillIds.length = 0;
   skillState.entries.clear();
   telemetryState.recordCalls.length = 0;
   telemetryState.recordShouldThrow = false;
@@ -360,10 +353,8 @@ function resetState(): void {
   _resetMemoryV2QdrantForTests();
 }
 
-/** Stage the next turn's skill slate and the entries the renderer will look up. */
-function stageSkills(ids: string[], entries: SkillEntry[] = []): void {
-  skillState.topSkillIds.length = 0;
-  skillState.topSkillIds.push(...ids);
+/** Stage skill-store cache entries for the upcoming render. */
+function stageSkills(entries: SkillEntry[]): void {
   for (const entry of entries) {
     skillState.entries.set(entry.id, entry);
   }
@@ -399,11 +390,13 @@ describe("injectMemoryV2Block", () => {
 
     expect(result.toInject).toEqual(["alice-vscode"]);
     expect(result.block).not.toBeNull();
-    expect(result.block).toContain("<memory>");
+    // `block` is the unwrapped inner content; the caller adds the
+    // `<memory>...</memory>` wrapper exactly once at injection time.
+    expect(result.block).not.toContain("<memory>");
+    expect(result.block).not.toContain("</memory>");
     expect(result.block).not.toContain("## What I Remember Right Now");
     expect(result.block).toContain("### alice-vscode");
     expect(result.block).toContain("VS Code");
-    expect(result.block).toContain("</memory>");
 
     // State persisted: alice's activation is above epsilon and recorded;
     // everInjected captured the new slug + currentTurn.
@@ -652,27 +645,36 @@ describe("injectMemoryV2Block", () => {
     expect(persisted!.everInjected).toEqual([
       { slug: "phantom-slug", turn: 1 },
     ]);
+
+    // Activation log marks the slug `page_missing` (not `injected`) so a
+    // stale Qdrant / edge-index entry pointing at a vanished page is
+    // visible in telemetry instead of masquerading as a successful inject.
+    expect(telemetryState.recordCalls.length).toBe(1);
+    const row = telemetryState.recordCalls[0] as {
+      concepts: Array<{ slug: string; status: string }>;
+    };
+    const phantom = row.concepts.find((c) => c.slug === "phantom-slug");
+    expect(phantom).toBeDefined();
+    expect(phantom!.status).toBe("page_missing");
   });
 
   // ---------------------------------------------------------------------------
-  // Skill subsection rendering
+  // Unified pool — skills as `skills/<id>` slugs
   // ---------------------------------------------------------------------------
 
-  test("renders a skill-only block in the same `<memory>` wrapper as concept-page-only blocks", async () => {
-    // No concept-page candidates this turn — the candidate query and the three
-    // simBatch queries all return empty. The skill pipeline is mocked to
-    // surface a single skill.
-    stageTurn([]);
-    stageSkills(
-      ["example-skill-a"],
-      [
-        {
-          id: "example-skill-a",
-          content:
-            'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
-        },
-      ],
-    );
+  test("renders a skill-only block via the skills/ slug prefix", async () => {
+    // No concept-page candidates this turn — the only ANN hit is a skill
+    // slug. The render path branches on `skills/` prefix: it pulls the
+    // entry from the skill-store cache (mocked) and emits the bullet under
+    // the `### Skills You Can Use` subsection.
+    stageTurn([{ slug: "skills/example-skill-a", denseScore: 0.9 }]);
+    stageSkills([
+      {
+        id: "example-skill-a",
+        content:
+          'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
+      },
+    ]);
 
     const result = await injectMemoryV2Block({
       database: db,
@@ -685,14 +687,11 @@ describe("injectMemoryV2Block", () => {
       config: makeConfig(),
     });
 
-    expect(result.toInject).toEqual([]);
+    expect(result.toInject).toEqual(["skills/example-skill-a"]);
     expect(result.block).not.toBeNull();
-    // Same outer wrapping as concept-page-only blocks.
-    expect(result.block).toContain("<memory>");
+    expect(result.block).not.toContain("<memory>");
+    expect(result.block).not.toContain("</memory>");
     expect(result.block).not.toContain("## What I Remember Right Now");
-    expect(result.block).toContain("</memory>");
-    // No concept-page sections; skills subsection present with the right
-    // bullet shape and the unconditional `→ use skill_load to activate` suffix.
     expect(result.block).not.toContain("### alice-vscode");
     expect(result.block).toContain("### Skills You Can Use");
     expect(result.block).toContain(
@@ -701,19 +700,19 @@ describe("injectMemoryV2Block", () => {
   });
 
   test("renders concept-page sections before the skills subsection in mixed blocks", async () => {
-    // Concept page hits AND a skill — concept-page sections come first, then
+    // Concept page hit AND a skill — concept-page sections come first, then
     // the skills subsection.
-    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
-    stageSkills(
-      ["example-skill-a"],
-      [
-        {
-          id: "example-skill-a",
-          content:
-            'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
-        },
-      ],
-    );
+    stageTurn([
+      { slug: "alice-vscode", denseScore: 0.9 },
+      { slug: "skills/example-skill-a", denseScore: 0.7 },
+    ]);
+    stageSkills([
+      {
+        id: "example-skill-a",
+        content:
+          'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
+      },
+    ]);
 
     const result = await injectMemoryV2Block({
       database: db,
@@ -726,7 +725,10 @@ describe("injectMemoryV2Block", () => {
       config: makeConfig(),
     });
 
-    expect(result.toInject).toEqual(["alice-vscode"]);
+    // Both slugs ranked into top-K and got freshly attached.
+    expect(new Set(result.toInject)).toEqual(
+      new Set(["alice-vscode", "skills/example-skill-a"]),
+    );
     expect(result.block).not.toBeNull();
 
     const aliceIdx = result.block!.indexOf("### alice-vscode");
@@ -735,46 +737,20 @@ describe("injectMemoryV2Block", () => {
     expect(skillsIdx).toBeGreaterThan(-1);
     expect(aliceIdx).toBeLessThan(skillsIdx);
 
-    // The activation suffix is always appended for skills.
     expect(result.block).toContain(
       '- The "Example Skill A" skill (example-skill-a) is available. Helps with examples. → use skill_load to activate',
     );
   });
 
-  test("returns null when both concept pages and skills are empty", async () => {
-    // Empty concept-page candidate set (all simBatch + ANN responses empty)
-    // AND no skill ids.
-    stageTurn([]);
-    stageSkills([]);
-
-    const result = await injectMemoryV2Block({
-      database: db,
-      conversationId: "conv-1",
-      currentTurn: 1,
-      userMessage: "anything",
-      assistantMessage: "",
-      nowText: "",
-      messageId: "msg-1",
-      config: makeConfig(),
-    });
-
-    expect(result.toInject).toEqual([]);
-    expect(result.block).toBeNull();
-  });
-
-  test("re-renders the same top-ranked skill on consecutive turns (no dedup)", async () => {
-    // Skills are stateless: the same id can appear on back-to-back turns.
-    // Stage no concept-page candidates so the block content is purely the
-    // skills subsection.
+  test("skills participate in everInjected — an attached skill is not re-attached on the next turn", async () => {
+    // Turn 1: skill ranks high, gets attached.
     const skillEntry = {
       id: "example-skill-a",
       content:
         'The "Example Skill A" skill (example-skill-a) is available. Helps with examples.',
     };
-
-    // Turn 1 — only the skill.
-    stageTurn([]);
-    stageSkills(["example-skill-a"], [skillEntry]);
+    stageTurn([{ slug: "skills/example-skill-a", denseScore: 0.9 }]);
+    stageSkills([skillEntry]);
     const result1 = await injectMemoryV2Block({
       database: db,
       conversationId: "conv-1",
@@ -785,15 +761,14 @@ describe("injectMemoryV2Block", () => {
       messageId: "msg-1",
       config: makeConfig(),
     });
-    expect(result1.block).not.toBeNull();
+    expect(result1.toInject).toEqual(["skills/example-skill-a"]);
     expect(result1.block).toContain("### Skills You Can Use");
-    expect(result1.block).toContain("example-skill-a");
 
-    // Turn 2 — same skill ranks top again. Persisted state has advanced (the
-    // first call wrote a fresh activation_state row), and `everInjected` was
-    // not touched by the skill pipeline. The skill must still appear.
-    stageTurn([]);
-    stageSkills(["example-skill-a"], [skillEntry]);
+    // Turn 2: same skill ranks top again. It is already in `everInjected`, so
+    // `toInject` is empty and the block is null — the attachment from turn 1
+    // remains visible to the agent via the cached prior user message.
+    stageTurn([{ slug: "skills/example-skill-a", denseScore: 0.9 }]);
+    stageSkills([skillEntry]);
     const result2 = await injectMemoryV2Block({
       database: db,
       conversationId: "conv-1",
@@ -804,21 +779,57 @@ describe("injectMemoryV2Block", () => {
       messageId: "msg-2",
       config: makeConfig(),
     });
-    expect(result2.block).not.toBeNull();
-    expect(result2.block).toContain("### Skills You Can Use");
-    expect(result2.block).toContain("example-skill-a");
-
-    // The skill content line is identical across the two turns — the renderer
-    // is deterministic in `id → entry` lookup and the entry is unchanged.
-    const skillLine =
-      '- The "Example Skill A" skill (example-skill-a) is available. Helps with examples. → use skill_load to activate';
-    expect(result1.block).toContain(skillLine);
-    expect(result2.block).toContain(skillLine);
-
-    // `everInjected` is untouched by the skill pipeline — both turns left it
-    // empty (no concept pages were injected).
+    expect(result2.toInject).toEqual([]);
+    expect(result2.block).toBeNull();
+
     const persisted = await hydrate(db, "conv-1");
-    expect(persisted!.everInjected).toEqual([]);
+    expect(persisted!.everInjected).toEqual([
+      { slug: "skills/example-skill-a", turn: 1 },
+    ]);
+  });
+
+  test("skill slugs whose entry is missing from the cache are dropped silently", async () => {
+    // The skill ranks into top-K but the in-process cache no longer knows
+    // its content (skill uninstalled mid-run). The render path drops it
+    // without surfacing it as a `missingSlugs` page-missing event — that
+    // status is reserved for on-disk concept pages, not catalog-derived
+    // skill entries.
+    stageTurn([{ slug: "skills/missing-skill", denseScore: 0.9 }]);
+    // No `stageSkills` call — cache stays empty.
+
+    const result = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "anything",
+      assistantMessage: "",
+      nowText: "Now",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    // `toInject` still records the slug (it ranked into top-K) but the
+    // block collapses to null because the only entry was a cache miss.
+    expect(result.toInject).toEqual(["skills/missing-skill"]);
+    expect(result.block).toBeNull();
+  });
+
+  test("returns null when both concept pages and skills are empty", async () => {
+    stageTurn([]);
+
+    const result = await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "anything",
+      assistantMessage: "",
+      nowText: "",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    expect(result.toInject).toEqual([]);
+    expect(result.block).toBeNull();
   });
 
   test("context-load mode renders topNow even when every slug was previously injected", async () => {
@@ -910,39 +921,6 @@ describe("injectMemoryV2Block", () => {
     expect(persisted!.everInjected).toHaveLength(3);
   });
 
-  test("`top_k_skills: 0` short-circuits to no skills subsection", async () => {
-    // Even when the underlying mock would surface skills, the cap at 0 must
-    // drop them via `selectSkillInjections.topK = 0` → empty `topNow`.
-    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
-    stageSkills(
-      ["example-skill-a"],
-      [
-        {
-          id: "example-skill-a",
-          content:
-            'The "Example Skill A" skill (example-skill-a) is available.',
-        },
-      ],
-    );
-
-    const result = await injectMemoryV2Block({
-      database: db,
-      conversationId: "conv-1",
-      currentTurn: 1,
-      userMessage: "Alice's editor",
-      assistantMessage: "",
-      nowText: "Now",
-      messageId: "msg-1",
-      config: makeConfig({ top_k_skills: 0 }),
-    });
-
-    expect(result.toInject).toEqual(["alice-vscode"]);
-    expect(result.block).not.toBeNull();
-    expect(result.block).toContain("### alice-vscode");
-    expect(result.block).not.toContain("### Skills You Can Use");
-    expect(result.block).not.toContain("example-skill-a");
-  });
-
   // ---------------------------------------------------------------------------
   // Activation-log telemetry
   // ---------------------------------------------------------------------------
@@ -991,13 +969,12 @@ describe("injectMemoryV2Block", () => {
         status: string;
         source: string;
       }>;
-      skills: unknown[];
       config: { top_k: number };
     };
     expect(row.conversationId).toBe("conv-1");
     expect(row.turn).toBe(2);
     expect(row.mode).toBe("per-turn");
-    expect(row.config.top_k).toBe(20);
+    expect(row.config.top_k).toBe(25);
 
     // The candidate set is the union of fromPrior (alice) and fromAnn
     // (alice + carol) → two concept rows.
@@ -1019,6 +996,41 @@ describe("injectMemoryV2Block", () => {
     expect(byslug.get("carol-jazz")!.status).toBe("injected");
   });
 
+  test("activation-log concepts include skill rows under the skills/ prefix", async () => {
+    // Skills participate in the unified telemetry list — they live in the
+    // same `concepts` array, identifiable by the `skills/` slug prefix.
+    stageTurn([
+      { slug: "alice-vscode", denseScore: 0.9 },
+      { slug: "skills/example-skill-a", denseScore: 0.7 },
+    ]);
+    stageSkills([
+      {
+        id: "example-skill-a",
+        content: "skill content",
+      },
+    ]);
+
+    await injectMemoryV2Block({
+      database: db,
+      conversationId: "conv-1",
+      currentTurn: 1,
+      userMessage: "Alice's editor",
+      assistantMessage: "",
+      nowText: "Now",
+      messageId: "msg-1",
+      config: makeConfig(),
+    });
+
+    expect(telemetryState.recordCalls.length).toBe(1);
+    const row = telemetryState.recordCalls[0] as {
+      concepts: Array<{ slug: string; status: string }>;
+    };
+    const slugs = row.concepts.map((c) => c.slug);
+    expect(new Set(slugs)).toEqual(
+      new Set(["alice-vscode", "skills/example-skill-a"]),
+    );
+  });
+
   test("context-load mode marks every rendered slug as `injected`, never `in_context`", async () => {
     // Turn 1 (per-turn): seed alice as injected so the next turn's prior
     // `everInjected` includes her — the same setup the per-turn telemetry

package/src/memory/v2/__tests__/prompts-consolidation.test.ts

@@ -4,7 +4,14 @@
  * file-based override and falls back to the bundled prompt when the
  * override is missing/empty/unreadable.
  */
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import {
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -67,7 +74,14 @@ beforeEach(() => {
 });
 
 afterEach(() => {
-  for (const entry of ["custom-prompt.md", "empty.md", "no-placeholder.md"]) {
+  for (const entry of [
+    "custom-prompt.md",
+    "empty.md",
+    "no-placeholder.md",
+    "huge.md",
+    "link.md",
+    "fifo",
+  ]) {
     rmSync(join(tmpWorkspace, entry), { force: true });
   }
 });
@@ -178,4 +192,49 @@ describe("resolveConsolidationPrompt — failure modes", () => {
     const data = warnCalls[0].data as Record<string, unknown>;
     expect(data.reason).toBe("empty_override");
   });
+
+  test("falls back to bundled prompt when the override exceeds the size limit", () => {
+    const path = join(tmpWorkspace, "huge.md");
+    // 1 MiB + 1 byte — just over the cap so we don't waste test memory.
+    writeFileSync(path, Buffer.alloc(1 * 1024 * 1024 + 1, 0x61));
+
+    const result = resolveConsolidationPrompt(path, CUTOFF);
+
+    expect(result).toBe(bundledPrompt());
+    expect(warnCalls).toHaveLength(1);
+    const data = warnCalls[0].data as Record<string, unknown>;
+    expect(data.reason).toBe("oversized_override");
+    expect(data.size).toBe(1 * 1024 * 1024 + 1);
+  });
+
+  test("falls back to bundled prompt when the override is a symlink", () => {
+    const target = join(tmpWorkspace, "custom-prompt.md");
+    writeFileSync(target, "real prompt body\n");
+    const link = join(tmpWorkspace, "link.md");
+    symlinkSync(target, link);
+
+    const result = resolveConsolidationPrompt(link, CUTOFF);
+
+    expect(result).toBe(bundledPrompt());
+    expect(warnCalls).toHaveLength(1);
+    const data = warnCalls[0].data as Record<string, unknown>;
+    expect(data.reason).toBe("not_regular_file");
+  });
+
+  test("falls back to bundled prompt when the override is a FIFO", () => {
+    const fifoPath = join(tmpWorkspace, "fifo");
+    try {
+      execFileSync("mkfifo", [fifoPath]);
+    } catch {
+      // mkfifo unavailable on this platform — skip without failing.
+      return;
+    }
+
+    const result = resolveConsolidationPrompt(fifoPath, CUTOFF);
+
+    expect(result).toBe(bundledPrompt());
+    expect(warnCalls).toHaveLength(1);
+    const data = warnCalls[0].data as Record<string, unknown>;
+    expect(data.reason).toBe("not_regular_file");
+  });
 });