@monotykamary/pi-vcc 0.3.16

package/tests/normalize.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect } from "bun:test";
+import { normalize } from "../src/core/normalize";
+import {
+  userMsg,
+  assistantText,
+  assistantWithThinking,
+  assistantWithToolCall,
+  toolResult,
+} from "./fixtures";
+
+describe("normalize", () => {
+  it("returns empty for empty input", () => {
+    expect(normalize([])).toEqual([]);
+  });
+
+  it("normalizes user message (string content)", () => {
+    const blocks = normalize([userMsg("fix the bug")]);
+    expect(blocks).toEqual([{ kind: "user", text: "fix the bug", sourceIndex: 0 }]);
+  });
+
+  it("normalizes assistant text message", () => {
+    const blocks = normalize([assistantText("done")]);
+    expect(blocks).toEqual([{ kind: "assistant", text: "done", sourceIndex: 0 }]);
+  });
+
+  it("normalizes assistant string content", () => {
+    const msg = { ...assistantText("done"), content: "plain text" } as any;
+    expect(normalize([msg])).toEqual([{ kind: "assistant", text: "plain text", sourceIndex: 0 }]);
+  });
+
+  it("splits assistant thinking + text", () => {
+    const blocks = normalize([assistantWithThinking("result", "hmm")]);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({
+      kind: "thinking", text: "hmm", redacted: false, sourceIndex: 0,
+    });
+    expect(blocks[1]).toEqual({ kind: "assistant", text: "result", sourceIndex: 0 });
+  });
+
+  it("normalizes tool call", () => {
+    const blocks = normalize([assistantWithToolCall("Read", { path: "a.ts" })]);
+    expect(blocks).toEqual([{
+      kind: "tool_call", name: "Read", args: { path: "a.ts" }, sourceIndex: 0,
+    }]);
+  });
+
+  it("normalizes tool result", () => {
+    const blocks = normalize([toolResult("Read", "file contents")]);
+    expect(blocks).toEqual([{
+      kind: "tool_result", name: "Read",
+      text: "file contents", isError: false, sourceIndex: 0,
+    }]);
+  });
+
+  it("normalizes error tool result", () => {
+    const blocks = normalize([toolResult("Edit", "not found", true)]);
+    expect(blocks[0]).toMatchObject({
+      kind: "tool_result", isError: true,
+    });
+  });
+
+  it("handles mixed message sequence", () => {
+    const blocks = normalize([
+      userMsg("fix it"),
+      assistantWithToolCall("Read", { path: "x.ts" }),
+      toolResult("Read", "code"),
+      assistantText("done"),
+    ]);
+    expect(blocks).toHaveLength(4);
+    expect(blocks.map((b) => b.kind)).toEqual([
+      "user", "tool_call", "tool_result", "assistant",
+    ]);
+  });
+
+  it("produces image placeholder for user image content", () => {
+    const msg = {
+      role: "user" as const,
+      content: [
+        { type: "text" as const, text: "look at this" },
+        { type: "image" as const, data: "abc", mimeType: "image/png" },
+      ],
+      timestamp: Date.now(),
+    };
+    const blocks = normalize([msg]);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({ kind: "user", text: "look at this", sourceIndex: 0 });
+    expect(blocks[1]).toEqual({ kind: "user", text: "[image: image/png]", sourceIndex: 0 });
+  });
+
+  it("normalizes bashExecution messages", () => {
+    const msg = { role: "bashExecution", command: "ls -la", output: "files", exitCode: 0 } as any;
+    const blocks = normalize([msg]);
+    expect(blocks).toEqual([
+      { kind: "bash", command: "ls -la", output: "files", exitCode: 0, sourceIndex: 0 },
+    ]);
+  });
+
+  it("skips truly unknown message roles gracefully", () => {
+    const custom = { role: "custom", content: "hello" } as any;
+    expect(normalize([custom])).toEqual([]);
+  });
+});
+
+

package/tests/proactive-threshold.test.ts

@@ -0,0 +1,490 @@
+import { describe, test, expect, beforeEach, afterEach, beforeAll, afterAll } from "bun:test";
+import { existsSync, unlinkSync, writeFileSync, mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { registerProactiveThresholdHook, resetProactiveState } from "../src/hooks/proactive-threshold";
+
+let tmpDir: string;
+let CONFIG_PATH: string;
+
+beforeAll(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "pi-vcc-test-"));
+  CONFIG_PATH = join(tmpDir, "pi-vcc-config.json");
+  process.env.PI_VCC_CONFIG_PATH = CONFIG_PATH;
+});
+
+afterAll(() => {
+  delete process.env.PI_VCC_CONFIG_PATH;
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+interface MockResult {
+  piApi: any; // the object passed to registerProactiveThresholdHook(pi)
+  ctx: any;
+  emit: (eventName: string, event?: any) => void;
+  captured: { method: string; args: any[] }[];
+  notifyCalls: { msg: string; level: string }[];
+}
+
+function createMockPi(
+  model?: { id: string; provider?: string; contextWindow?: number },
+  usage?: { tokens: number | null; contextWindow: number; percent: number | null },
+): MockResult {
+  const captured: { method: string; args: any[] }[] = [];
+  const notifyCalls: { msg: string; level: string }[] = [];
+  const handlers: Record<string, ((e: any, c: any) => any)[]> = {};
+
+  const ctx = {
+    hasUI: true,
+    model: model ?? undefined,
+    ui: {
+      notify: (msg: string, level: string) => {
+        notifyCalls.push({ msg, level });
+      },
+    },
+    getContextUsage: () => usage ?? { tokens: null, contextWindow: 0, percent: null },
+    compact: () => {
+      captured.push({ method: "compact", args: [] });
+    },
+  };
+
+  const piApi = {
+    on: (eventName: string, handler: (e: any, c: any) => any) => {
+      if (!handlers[eventName]) handlers[eventName] = [];
+      handlers[eventName].push(handler);
+    },
+  };
+
+  const emit = (eventName: string, event: any = {}) => {
+    const hs = handlers[eventName] ?? [];
+    for (const h of hs) h(event, ctx);
+  };
+
+  return { piApi, ctx, emit, captured, notifyCalls };
+}
+
+function setConfig(cfg: Record<string, unknown>) {
+  writeFileSync(CONFIG_PATH, JSON.stringify(cfg));
+}
+
+describe("proactiveThreshold: agent_end", () => {
+  afterEach(() => {
+    resetProactiveState();
+    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
+  });
+
+  test("triggers compact when context exceeds per-model threshold", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 110000, contextWindow: 128000, percent: 86 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(1);
+    expect(mock.captured[0].method).toBe("compact");
+    expect(mock.notifyCalls.length).toBeGreaterThanOrEqual(1);
+    expect(mock.notifyCalls[0].msg).toContain("auto");
+  });
+
+  test("does NOT trigger when context is below threshold", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 80000, contextWindow: 128000, percent: 63 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(0);
+  });
+
+  test("does NOT trigger when no modelThresholds configured", () => {
+    setConfig({ debug: false, overrideDefaultCompaction: true });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 110000, contextWindow: 128000, percent: 86 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(0);
+  });
+
+  test("does NOT trigger when context usage tokens is null", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: null, contextWindow: 128000, percent: null },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(0);
+  });
+
+  test("does NOT trigger when contextWindow is 0", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 0 },
+      { tokens: 50000, contextWindow: 0, percent: null },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(0);
+  });
+});
+
+describe("proactiveThreshold: model_select", () => {
+  afterEach(() => {
+    resetProactiveState();
+    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
+  });
+
+  test("triggers compact on model switch when context exceeds new model's threshold", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 110000, contextWindow: 128000, percent: 86 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("model_select", { type: "model_select" });
+    expect(mock.captured).toHaveLength(1);
+    expect(mock.notifyCalls[0].msg).toContain("model-switch");
+  });
+
+  test("does NOT trigger when context is below threshold after model switch", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 80000, contextWindow: 128000, percent: 63 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("model_select", { type: "model_select" });
+    expect(mock.captured).toHaveLength(0);
+  });
+
+  test("uses globalThreshold when model does not match modelThresholds", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      globalThreshold: { reserveTokens: 16384 },
+    });
+    const mock = createMockPi(
+      { id: "unknown-model", provider: "other", contextWindow: 128000 },
+      { tokens: 120000, contextWindow: 128000, percent: 94 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("model_select", { type: "model_select" });
+    expect(mock.captured).toHaveLength(1);
+  });
+
+  test("uses globalThreshold with compactPercent", () => {
+    // compactPercent: 65 → reserve = 128000 * 0.35 = 44800 → threshold = 83200
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      globalThreshold: { compactPercent: 65 },
+    });
+    const mock = createMockPi(
+      { id: "unknown-model", provider: "other", contextWindow: 128000 },
+      { tokens: 90000, contextWindow: 128000, percent: 70 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("model_select", { type: "model_select" });
+    expect(mock.captured).toHaveLength(1);
+  });
+
+  test("uses compactPercent in modelThresholds", () => {
+    // compactPercent: 65 → reserve = 128000 * 0.35 = 44800 → threshold = 83200
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { compactPercent: 65 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 90000, contextWindow: 128000, percent: 70 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(1);
+  });
+
+  test("does not trigger when context is below compactPercent threshold", () => {
+    // compactPercent: 65 → threshold = 83200
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { compactPercent: 65 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 70000, contextWindow: 128000, percent: 55 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(0);
+  });
+
+  test("falls back to defaultThreshold when globalThreshold is not set", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      defaultThreshold: { reserveTokens: 16384 },
+    });
+    const mock = createMockPi(
+      { id: "unknown-model", provider: "other", contextWindow: 128000 },
+      { tokens: 120000, contextWindow: 128000, percent: 94 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("model_select", { type: "model_select" });
+    expect(mock.captured).toHaveLength(1);
+  });
+});
+
+describe("proactiveThreshold: cooldown", () => {
+  afterEach(() => {
+    resetProactiveState();
+    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
+  });
+
+  test("does NOT double-trigger within cooldown after compaction", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 110000, contextWindow: 128000, percent: 86 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+
+    // First trigger: agent_end causes compact
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(1);
+
+    // session_compact fires (compaction completed) — sets cooldown
+    mock.emit("session_compact", { type: "session_compact", compactionEntry: {} });
+
+    // Second trigger: model_select within cooldown — blocked
+    mock.emit("model_select", { type: "model_select" });
+    expect(mock.captured).toHaveLength(1); // still 1, not 2
+  });
+
+  test("re-triggers after cooldown expires", async () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 110000, contextWindow: 128000, percent: 86 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+
+    // First trigger
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(1);
+
+    // session_compact sets cooldown
+    mock.emit("session_compact", { type: "session_compact", compactionEntry: {} });
+
+    // Wait for cooldown to expire (3s + buffer)
+    await new Promise(r => setTimeout(r, 3200));
+
+    // Second trigger should now work
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(2);
+  }, 10000);
+});
+
+describe("proactiveThreshold: modelId matching", () => {
+  afterEach(() => {
+    resetProactiveState();
+    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
+  });
+
+  test("matches on provider/modelId", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 110000, contextWindow: 128000, percent: 86 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(1);
+  });
+
+  test("matches on modelId only when provider/modelId doesn't match", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "other-provider", contextWindow: 128000 },
+      { tokens: 110000, contextWindow: 128000, percent: 86 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(1);
+  });
+
+  test("does NOT match when no key matches", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "Kimi-K2.6", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 110000, contextWindow: 128000, percent: 86 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(0);
+  });
+});
+
+describe("proactiveThreshold: exact boundary", () => {
+  afterEach(() => {
+    resetProactiveState();
+    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
+  });
+
+  test("does NOT trigger when tokens exactly equal threshold", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    // 128000 - 32768 = 95232 → exactly at threshold, NOT exceeded
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 95232, contextWindow: 128000, percent: 74 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(0);
+  });
+
+  test("triggers when tokens exceed threshold by 1", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    // 128000 - 32768 = 95232 → just over
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 95233, contextWindow: 128000, percent: 74 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(1);
+  });
+});
+
+describe("proactiveThreshold: without model", () => {
+  afterEach(() => {
+    resetProactiveState();
+    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
+  });
+
+  test("does NOT trigger when model is undefined", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: true,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(undefined, { tokens: 110000, contextWindow: 128000, percent: 86 });
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    expect(mock.captured).toHaveLength(0);
+  });
+});
+
+describe("proactiveThreshold: works for pi-core compaction too", () => {
+  afterEach(() => {
+    resetProactiveState();
+    if (existsSync(CONFIG_PATH)) unlinkSync(CONFIG_PATH);
+  });
+
+  test("proactive trigger works even when overrideDefaultCompaction is false", () => {
+    setConfig({
+      debug: false,
+      overrideDefaultCompaction: false,
+      modelThresholds: {
+        "neuralwatt/GLM-5.1": { reserveTokens: 32768 },
+      },
+    });
+    const mock = createMockPi(
+      { id: "GLM-5.1", provider: "neuralwatt", contextWindow: 128000 },
+      { tokens: 110000, contextWindow: 128000, percent: 86 },
+    );
+    registerProactiveThresholdHook(mock.piApi);
+    mock.emit("agent_end", { type: "agent_end", messages: [] });
+    // Should still trigger compact — ctx.compact() will invoke pi-core's compaction
+    expect(mock.captured).toHaveLength(1);
+  });
+});

package/tests/real-sessions.test.ts

@@ -0,0 +1,38 @@
+import { beforeAll, describe, expect, it } from "bun:test";
+import { buildCompactReport } from "../src/core/report";
+import { prepareSessionSamples, readSourceStat, type SessionSample } from "./support/real-sessions";
+import { loadSessionMessages } from "./support/load-session";
+
+let samples: SessionSample[] = [];
+
+beforeAll(async () => {
+  samples = await prepareSessionSamples(2);
+});
+
+describe("real session integration", () => {
+  it("compiles copied large sessions without mutating originals", async () => {
+    for (const sample of samples) {
+      const before = await readSourceStat(sample);
+      const loaded = loadSessionMessages(sample.copy);
+      const report = buildCompactReport({ messages: loaded.messages });
+      const after = await readSourceStat(sample);
+
+      expect(loaded.messageCount).toBeGreaterThan(0);
+      expect(loaded.skippedCount).toBeGreaterThanOrEqual(0);
+      expect(report.summary.length).toBeGreaterThan(0);
+      expect(report.summary).toContain("[");
+      expect(report.before.preview.length).toBeGreaterThan(0);
+      expect(report.after.summaryPreview.length).toBeGreaterThan(0);
+      expect(report.compression.charsBefore).toBeGreaterThan(0);
+      expect(report.recall.probes.length).toBeGreaterThan(0);
+      expect(after).toEqual(before);
+    }
+  });
+
+  it("uses read-only copied fixtures", () => {
+    for (const sample of samples) {
+      expect(sample.copy).not.toBe(sample.source);
+      expect(sample.copy.includes("pi-vcc-sessions-")).toBe(true);
+    }
+  });
+});

package/tests/recall-expand.test.ts

@@ -0,0 +1,15 @@
+import { describe, it, expect } from "bun:test";
+import { invalidExpandIndices } from "../src/tools/recall";
+
+describe("invalidExpandIndices", () => {
+  it("returns indices that are not in available lineage index set", () => {
+    const available = new Set([0, 2, 5]);
+    expect(invalidExpandIndices([0, 2], available)).toEqual([]);
+    expect(invalidExpandIndices([1, 2, 7], available)).toEqual([1, 7]);
+  });
+
+  it("rejects non-integer indices", () => {
+    const available = new Set([0, 1, 2]);
+    expect(invalidExpandIndices([1.5, 2], available)).toEqual([1.5]);
+  });
+});

package/tests/recall-scope.test.ts

@@ -0,0 +1,32 @@
+import { describe, it, expect } from "bun:test";
+import { normalizeRecallScope, parseRecallScope } from "../src/core/recall-scope";
+
+describe("normalizeRecallScope", () => {
+  it("defaults to active lineage", () => {
+    expect(normalizeRecallScope()).toBe("lineage");
+    expect(normalizeRecallScope("lineage")).toBe("lineage");
+    expect(normalizeRecallScope("unknown")).toBe("lineage");
+    expect(normalizeRecallScope(123)).toBe("lineage");
+  });
+
+  it("accepts all scope", () => {
+    expect(normalizeRecallScope("all")).toBe("all");
+    expect(normalizeRecallScope("ALL")).toBe("all");
+  });
+});
+
+describe("parseRecallScope", () => {
+  it("removes scope token from command text", () => {
+    expect(parseRecallScope("license scope:all page:2")).toEqual({
+      scope: "all",
+      text: "license page:2",
+    });
+  });
+
+  it("defaults to lineage when no scope token is present", () => {
+    expect(parseRecallScope("license page:2")).toEqual({
+      scope: "lineage",
+      text: "license page:2",
+    });
+  });
+});