@monotykamary/pi-vcc 0.3.17 → 0.4.1

package/tests/proactive-threshold.test.ts

@@ -1,490 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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",
-    });
-  });
-});

package/tests/recall-tool-scope.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { mkdtempSync, writeFileSync, rmSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import { registerRecallTool } from "../src/tools/recall";
-
-const makeSession = () => {
-  const dir = mkdtempSync(join(tmpdir(), "pi-vcc-recall-scope-"));
-  const file = join(dir, "session.jsonl");
-  const lines = [
-    JSON.stringify({ type: "message", id: "m1", message: { role: "user", content: "active lineage token" } }),
-    JSON.stringify({ type: "message", id: "m2", message: { role: "user", content: "off lineage secret" } }),
-  ];
-  writeFileSync(file, lines.join("\n") + "\n", "utf8");
-  return { dir, file };
-};
-
-const register = () => {
-  let tool: any;
-  registerRecallTool({ registerTool: (t: any) => { tool = t; } } as any);
-  return tool;
-};
-
-const invoke = async (tool: any, file: string, params: Record<string, unknown>) => {
-  const result = await tool.execute("tool-call", params, undefined, undefined, {
-    sessionManager: {
-      getSessionFile: () => file,
-      getBranch: () => [{ id: "m1" }],
-      getEntries: () => [{ id: "m1" }, { id: "m2" }],
-    },
-  });
-  return result.content[0].text as string;
-};
-
-describe("vcc_recall scope", () => {
-  it("defaults to active lineage and opts into all-session search explicitly", async () => {
-    const { dir, file } = makeSession();
-    try {
-      const tool = register();
-
-      const lineage = await invoke(tool, file, { query: "secret" });
-      expect(lineage).toContain("No matches");
-
-      const all = await invoke(tool, file, { query: "secret", scope: "all" });
-      expect(all).toContain("scope: all");
-      expect(all).toContain("off lineage secret");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  it("keeps expand strict by default but allows off-lineage expand with scope all", async () => {
-    const { dir, file } = makeSession();
-    try {
-      const tool = register();
-
-      const lineage = await invoke(tool, file, { expand: [1] });
-      expect(lineage).toContain("Cannot expand indices outside active lineage: 1");
-
-      const all = await invoke(tool, file, { expand: [1], scope: "all" });
-      expect(all).toContain("Scope: all");
-      expect(all).toContain("#1 [user] off lineage secret");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-});