@vellumai/assistant 0.4.48 → 0.4.50

package/src/__tests__/computer-use-skill-lifecycle-cleanup.test.ts

@@ -1,249 +0,0 @@
-import { beforeAll, describe, expect, mock, test } from "bun:test";
-
-// Mock config before importing modules that depend on it.
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-
-    provider: "mock-provider",
-    permissions: { mode: "workspace" },
-    apiKeys: {},
-    sandbox: { enabled: false },
-    timeouts: { toolExecutionTimeoutSec: 30, permissionTimeoutSec: 5 },
-    skills: { load: { extraDirs: [] } },
-    secretDetection: { enabled: false },
-    contextWindow: {
-      enabled: true,
-      maxInputTokens: 180000,
-      targetBudgetRatio: 0.30,
-      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
-    },
-  }),
-  invalidateConfigCache: () => {},
-}));
-
-import { ComputerUseSession } from "../daemon/computer-use-session.js";
-import type { CuObservation } from "../daemon/message-protocol.js";
-import type { Provider, ProviderResponse } from "../providers/types.js";
-import {
-  __resetRegistryForTesting,
-  getAllTools,
-  getSkillRefCount,
-  initializeTools,
-} from "../tools/registry.js";
-
-function createProvider(responses: ProviderResponse[]): Provider {
-  let calls = 0;
-  return {
-    name: "mock",
-    async sendMessage() {
-      const response = responses[calls] ?? responses[responses.length - 1];
-      calls++;
-      return response;
-    },
-  };
-}
-
-const doneResponse: ProviderResponse = {
-  content: [
-    {
-      type: "tool_use",
-      id: "tu-cleanup",
-      name: "computer_use_done",
-      input: { summary: "Done" },
-    },
-  ],
-  model: "mock-model",
-  usage: { inputTokens: 10, outputTokens: 5 },
-  stopReason: "tool_use",
-};
-
-const observation: CuObservation = {
-  type: "cu_observation",
-  sessionId: "cleanup-test",
-  axTree: 'Window "Test" [1]',
-};
-
-describe("CU session skill tool lifecycle cleanup", () => {
-  beforeAll(async () => {
-    __resetRegistryForTesting();
-    await initializeTools();
-  });
-
-  test("computer-use skill refcount is 0 after session completes via computer_use_done", async () => {
-    const provider = createProvider([doneResponse]);
-    const session = new ComputerUseSession(
-      "cleanup-done",
-      "test cleanup",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-    );
-
-    expect(getSkillRefCount("computer-use")).toBe(0);
-
-    await session.handleObservation({
-      ...observation,
-      sessionId: "cleanup-done",
-    });
-
-    expect(session.getState()).toBe("complete");
-    expect(getSkillRefCount("computer-use")).toBe(0);
-  });
-
-  test("computer-use skill refcount is 0 after session is aborted", async () => {
-    // Use a provider that hangs until the abort signal fires, keeping the
-    // session active long enough to abort after skill projection has occurred.
-    const hangingProvider: Provider = {
-      name: "mock",
-      sendMessage: (_msgs, _tools, _sys, opts) =>
-        new Promise<ProviderResponse>((_, reject) => {
-          if (opts?.signal?.aborted) {
-            reject(new DOMException("Aborted", "AbortError"));
-            return;
-          }
-          opts?.signal?.addEventListener(
-            "abort",
-            () => reject(new DOMException("Aborted", "AbortError")),
-            { once: true },
-          );
-        }),
-    };
-
-    const session = new ComputerUseSession(
-      "cleanup-abort",
-      "test abort cleanup",
-      1440,
-      900,
-      hangingProvider,
-      () => {},
-      "computer_use",
-    );
-
-    expect(getSkillRefCount("computer-use")).toBe(0);
-
-    // Start the session (don't await — it will hang on the provider call).
-    // Skill projection happens synchronously at the start of runAgentLoop,
-    // so by the time sendMessage is called the refcount has been incremented.
-    const sessionPromise = session.handleObservation({
-      ...observation,
-      sessionId: "cleanup-abort",
-    });
-
-    // Yield to let runAgentLoop start and reach the provider call
-    await new Promise((r) => setTimeout(r, 50));
-
-    session.abort();
-
-    // Let the session finish its cleanup
-    await sessionPromise;
-
-    expect(session.getState()).toBe("error");
-    expect(getSkillRefCount("computer-use")).toBe(0);
-  });
-
-  test("computer-use skill refcount is 0 after session completes via computer_use_respond", async () => {
-    const provider = createProvider([
-      {
-        content: [
-          {
-            type: "tool_use",
-            id: "tu-respond-cleanup",
-            name: "computer_use_respond",
-            input: { answer: "Test answer", reasoning: "Test reasoning" },
-          },
-        ],
-        model: "mock-model",
-        usage: { inputTokens: 10, outputTokens: 5 },
-        stopReason: "tool_use",
-      },
-    ]);
-
-    const session = new ComputerUseSession(
-      "cleanup-respond",
-      "test respond cleanup",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-    );
-
-    await session.handleObservation({
-      ...observation,
-      sessionId: "cleanup-respond",
-    });
-
-    expect(session.getState()).toBe("complete");
-    expect(getSkillRefCount("computer-use")).toBe(0);
-  });
-
-  test("only escalation tool remains in registry after session cleanup", async () => {
-    const provider = createProvider([doneResponse]);
-    const session = new ComputerUseSession(
-      "cleanup-registry-check",
-      "test registry cleanup",
-      1440,
-      900,
-      provider,
-      () => {},
-      "computer_use",
-    );
-
-    await session.handleObservation({
-      ...observation,
-      sessionId: "cleanup-registry-check",
-    });
-
-    expect(session.getState()).toBe("complete");
-
-    const allTools = getAllTools();
-    const cuTools = allTools.filter((t) => t.name.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(1);
-    expect(cuTools[0].name).toBe("computer_use_request_control");
-  });
-
-  test("multiple sequential CU sessions do not leak refcounts", async () => {
-    for (let i = 0; i < 3; i++) {
-      const provider = createProvider([doneResponse]);
-      const session = new ComputerUseSession(
-        `cleanup-sequential-${i}`,
-        "test sequential cleanup",
-        1440,
-        900,
-        provider,
-        () => {},
-        "computer_use",
-      );
-
-      await session.handleObservation({
-        ...observation,
-        sessionId: `cleanup-sequential-${i}`,
-      });
-      expect(session.getState()).toBe("complete");
-    }
-
-    expect(getSkillRefCount("computer-use")).toBe(0);
-
-    const allTools = getAllTools();
-    const cuTools = allTools.filter((t) => t.name.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(1);
-    expect(cuTools[0].name).toBe("computer_use_request_control");
-  });
-
-  // Cross-suite regression: after CU sessions complete, core registry invariants hold
-  test("core registry has 1 computer_use_* tool after CU session lifecycle (escalation only)", () => {
-    const allTools = getAllTools();
-    const cuTools = allTools.filter((t) => t.name.startsWith("computer_use_"));
-    expect(cuTools).toHaveLength(1);
-    expect(cuTools[0].name).toBe("computer_use_request_control");
-  });
-
-  test("computer_use_request_control is in core registry after CU session lifecycle", async () => {
-    const { getTool } = await import("../tools/registry.js");
-    const tool = getTool("computer_use_request_control");
-    expect(tool).toBeDefined();
-  });
-});

package/src/__tests__/conflict-intent-tokenization.test.ts

@@ -1,160 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  areStatementsCoherent,
-  computeConflictRelevance,
-  overlapRatio as _overlapRatio,
-  tokenizeForConflictRelevance as _tokenizeForConflictRelevance,
-} from "../memory/conflict-intent.js";
-
-describe("tokenizeForConflictRelevance hardening", () => {
-  test("excludes numeric-only tokens from relevance", () => {
-    const relevance = computeConflictRelevance("Check PR 5526", {
-      existingStatement: "Track PR 5525 for review.",
-      candidateStatement: "Track PR 5526 for review.",
-    });
-    // Numeric tokens "5526" and "5525" should be excluded, so overlap is minimal
-    expect(relevance).toBeLessThan(0.5);
-  });
-
-  test("excludes URL boilerplate tokens from relevance", () => {
-    const relevance = computeConflictRelevance(
-      "Check https://github.com/org/repo/pull/123",
-      {
-        existingStatement: "Review https://github.com/org/repo/pull/456",
-        candidateStatement: "Review https://github.com/org/repo/pull/789",
-      },
-    );
-    // URL tokens like "https", "github", "pull" should be excluded;
-    // only real content tokens like "repo" remain, keeping relevance low
-    expect(relevance).toBeLessThanOrEqual(0.5);
-  });
-
-  test("URL-embedded tracking tokens are stripped, standalone usage preserved", () => {
-    // URLs containing "issue", "pull", etc. are stripped entirely before tokenizing
-    const urlRelevance = computeConflictRelevance(
-      "Check https://github.com/org/repo/issues/42",
-      {
-        existingStatement: "Review https://github.com/org/repo/issues/10",
-        candidateStatement: "Review https://github.com/org/repo/issues/11",
-      },
-    );
-    expect(urlRelevance).toBeLessThanOrEqual(0.5);
-
-    // Standalone "issue" is preserved as a meaningful token
-    const standaloneRelevance = computeConflictRelevance(
-      "should I file an issue?",
-      {
-        existingStatement: "File an issue when bugs are found.",
-        candidateStatement: "Skip filing an issue for minor bugs.",
-      },
-    );
-    expect(standaloneRelevance).toBeGreaterThan(0);
-  });
-
-  test("strips scheme-less bare domain URLs from relevance", () => {
-    const relevance = computeConflictRelevance(
-      "Check github.com/org/repo/pull/123",
-      {
-        existingStatement: "Review gitlab.com/org/repo/issues/456",
-        candidateStatement: "Review github.com/org/repo/pull/789",
-      },
-    );
-    // Bare URLs should be stripped entirely; tokens like "pull", "issues"
-    // embedded in paths must not contribute to overlap
-    expect(relevance).toBeLessThanOrEqual(0.5);
-  });
-
-  test("preserves dotted identifiers that look like file paths", () => {
-    const relevance = computeConflictRelevance("Use index.ts/runtime parser", {
-      existingStatement: "Keep index.ts/runtime approach.",
-      candidateStatement: "Switch to config.ts/runtime approach.",
-    });
-    // File-like identifiers should NOT be stripped as URLs
-    expect(relevance).toBeGreaterThan(0);
-  });
-
-  test("still computes meaningful relevance for real content tokens", () => {
-    const relevance = computeConflictRelevance(
-      "Should I use React for frontend?",
-      {
-        existingStatement: "Use React for frontend work.",
-        candidateStatement: "Use Vue for frontend work.",
-      },
-    );
-    // Real content tokens like "react", "frontend" should still match
-    expect(relevance).toBeGreaterThan(0);
-  });
-});
-
-describe("statement coherence (areStatementsCoherent)", () => {
-  test("unrelated statements are incoherent", () => {
-    expect(
-      areStatementsCoherent(
-        "The default model for the summarize CLI is google/gemini-3-flash-preview.",
-        "User's favorite color is blue.",
-      ),
-    ).toBe(false);
-  });
-
-  test("related statements are coherent", () => {
-    expect(
-      areStatementsCoherent(
-        "User's favorite color is blue.",
-        "User's favorite color is green.",
-      ),
-    ).toBe(true);
-  });
-
-  test("topically similar preferences are coherent", () => {
-    expect(
-      areStatementsCoherent(
-        "Use React for frontend work.",
-        "Use Vue for frontend work.",
-      ),
-    ).toBe(true);
-  });
-
-  test("completely disjoint technical topics are incoherent", () => {
-    expect(
-      areStatementsCoherent(
-        "Always use PostgreSQL for database storage.",
-        "The preferred terminal font is JetBrains Mono.",
-      ),
-    ).toBe(false);
-  });
-
-  test("short technical terms (3 chars) are preserved for coherence", () => {
-    // "vim" and "css" are 3 chars — should not be filtered
-    expect(
-      areStatementsCoherent(
-        "Use Vim for editing.",
-        "Use Emacs instead of Vim.",
-      ),
-    ).toBe(true);
-
-    expect(
-      areStatementsCoherent(
-        "Use CSS grid for layouts.",
-        "Use CSS flexbox for layouts.",
-      ),
-    ).toBe(true);
-
-    expect(
-      areStatementsCoherent(
-        "Use npm for installs.",
-        "Use npm with --legacy-peer-deps.",
-      ),
-    ).toBe(true);
-  });
-
-  test("short terms with no shared context are still incoherent", () => {
-    // No shared tokens at all — completely different topics
-    expect(
-      areStatementsCoherent(
-        "Vim is the preferred editor.",
-        "CSS grid handles page layouts.",
-      ),
-    ).toBe(false);
-  });
-});

package/src/__tests__/conflict-policy.test.ts

@@ -1,269 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  isConflictKindEligible,
-  isConflictKindPairEligible,
-  isConflictUserEvidenced,
-  isDurableInstructionStatement,
-  isStatementConflictEligible,
-  isTransientTrackingStatement,
-  isUserEvidencedVerificationState,
-} from "../memory/conflict-policy.js";
-
-describe("conflict-policy", () => {
-  const config = { conflictableKinds: ["preference", "profile", "constraint"] };
-
-  describe("isConflictKindEligible", () => {
-    test("returns true for eligible kind", () => {
-      expect(isConflictKindEligible("preference", config)).toBe(true);
-      expect(isConflictKindEligible("profile", config)).toBe(true);
-      expect(isConflictKindEligible("constraint", config)).toBe(true);
-    });
-
-    test("returns false for ineligible kind", () => {
-      expect(isConflictKindEligible("project", config)).toBe(false);
-      expect(isConflictKindEligible("todo", config)).toBe(false);
-      expect(isConflictKindEligible("fact", config)).toBe(false);
-    });
-  });
-
-  describe("isConflictKindPairEligible", () => {
-    test("returns true when both kinds are eligible", () => {
-      expect(isConflictKindPairEligible("preference", "profile", config)).toBe(
-        true,
-      );
-    });
-
-    test("returns false when existing kind is ineligible", () => {
-      expect(isConflictKindPairEligible("project", "preference", config)).toBe(
-        false,
-      );
-    });
-
-    test("returns false when candidate kind is ineligible", () => {
-      expect(isConflictKindPairEligible("preference", "todo", config)).toBe(
-        false,
-      );
-    });
-
-    test("returns false when both kinds are ineligible", () => {
-      expect(isConflictKindPairEligible("project", "todo", config)).toBe(false);
-    });
-  });
-
-  describe("isTransientTrackingStatement", () => {
-    test("detects PR URLs", () => {
-      expect(
-        isTransientTrackingStatement(
-          "Track https://github.com/org/repo/pull/5526",
-        ),
-      ).toBe(true);
-    });
-
-    test("detects issue/ticket references", () => {
-      expect(isTransientTrackingStatement("Track PR #5526 and #5525")).toBe(
-        true,
-      );
-      expect(isTransientTrackingStatement("See issue #42 for details")).toBe(
-        true,
-      );
-      expect(isTransientTrackingStatement("Filed ticket 1234")).toBe(true);
-    });
-
-    test("detects tracking language", () => {
-      expect(isTransientTrackingStatement("While we wait for CI to pass")).toBe(
-        true,
-      );
-      expect(isTransientTrackingStatement("This PR needs review")).toBe(true);
-    });
-
-    test("does not flag generic time words as transient", () => {
-      expect(isTransientTrackingStatement("The deadline is today")).toBe(false);
-      expect(isTransientTrackingStatement("I need this right now")).toBe(false);
-    });
-
-    test("does not flag durable statements", () => {
-      expect(
-        isTransientTrackingStatement(
-          "Always answer with concise bullet points",
-        ),
-      ).toBe(false);
-      expect(isTransientTrackingStatement("User prefers dark mode")).toBe(
-        false,
-      );
-    });
-
-    test("does not false-positive on non-PR URLs", () => {
-      expect(
-        isTransientTrackingStatement("Visit https://example.com for docs"),
-      ).toBe(false);
-    });
-  });
-
-  describe("isDurableInstructionStatement", () => {
-    test("detects durable instruction cues", () => {
-      expect(
-        isDurableInstructionStatement(
-          "Always answer with concise bullet points",
-        ),
-      ).toBe(true);
-      expect(
-        isDurableInstructionStatement("Never use semicolons in JavaScript"),
-      ).toBe(true);
-      expect(
-        isDurableInstructionStatement("Use concise format for status updates"),
-      ).toBe(true);
-      expect(
-        isDurableInstructionStatement("The default database is Postgres"),
-      ).toBe(true);
-    });
-
-    test("rejects statements without durable cues", () => {
-      expect(isDurableInstructionStatement("Check the build output")).toBe(
-        false,
-      );
-      expect(isDurableInstructionStatement("Run the migration script")).toBe(
-        false,
-      );
-    });
-  });
-
-  describe("isStatementConflictEligible", () => {
-    test("rejects transient statements for any kind", () => {
-      expect(isStatementConflictEligible("preference", "Track PR #5526")).toBe(
-        false,
-      );
-      expect(
-        isStatementConflictEligible("instruction", "This PR needs review"),
-      ).toBe(false);
-    });
-
-    test("accepts durable instruction statements", () => {
-      expect(
-        isStatementConflictEligible(
-          "instruction",
-          "Always use TypeScript strict mode",
-        ),
-      ).toBe(true);
-      expect(
-        isStatementConflictEligible("style", "Default to concise format"),
-      ).toBe(true);
-    });
-
-    test("rejects non-durable instruction statements", () => {
-      expect(
-        isStatementConflictEligible("instruction", "Run the build first"),
-      ).toBe(false);
-      expect(isStatementConflictEligible("style", "Check the output")).toBe(
-        false,
-      );
-    });
-
-    test("accepts non-transient statements for non-instruction kinds", () => {
-      expect(
-        isStatementConflictEligible("preference", "User prefers dark mode"),
-      ).toBe(true);
-      expect(
-        isStatementConflictEligible("fact", "User works at Acme Corp"),
-      ).toBe(true);
-    });
-
-    test("rejects kinds not in conflictableKinds when config is provided", () => {
-      const policyConfig = { conflictableKinds: ["preference", "profile"] };
-      expect(
-        isStatementConflictEligible(
-          "fact",
-          "User works at Acme Corp",
-          policyConfig,
-        ),
-      ).toBe(false);
-      expect(
-        isStatementConflictEligible(
-          "preference",
-          "User prefers dark mode",
-          policyConfig,
-        ),
-      ).toBe(true);
-    });
-
-    test("skips kind check when config is omitted", () => {
-      expect(
-        isStatementConflictEligible("fact", "User works at Acme Corp"),
-      ).toBe(true);
-    });
-  });
-
-  describe("isUserEvidencedVerificationState", () => {
-    test("accepts user_reported", () => {
-      expect(isUserEvidencedVerificationState("user_reported")).toBe(true);
-    });
-
-    test("accepts user_confirmed", () => {
-      expect(isUserEvidencedVerificationState("user_confirmed")).toBe(true);
-    });
-
-    test("accepts legacy_import", () => {
-      expect(isUserEvidencedVerificationState("legacy_import")).toBe(true);
-    });
-
-    test("rejects assistant_inferred", () => {
-      expect(isUserEvidencedVerificationState("assistant_inferred")).toBe(
-        false,
-      );
-    });
-
-    test("rejects unknown states", () => {
-      expect(isUserEvidencedVerificationState("")).toBe(false);
-      expect(isUserEvidencedVerificationState("auto_detected")).toBe(false);
-      expect(isUserEvidencedVerificationState("pending")).toBe(false);
-    });
-  });
-
-  describe("isConflictUserEvidenced", () => {
-    test("returns true when existing side is user-evidenced", () => {
-      expect(
-        isConflictUserEvidenced("user_reported", "assistant_inferred"),
-      ).toBe(true);
-      expect(
-        isConflictUserEvidenced("user_confirmed", "assistant_inferred"),
-      ).toBe(true);
-      expect(
-        isConflictUserEvidenced("legacy_import", "assistant_inferred"),
-      ).toBe(true);
-    });
-
-    test("returns true when candidate side is user-evidenced", () => {
-      expect(
-        isConflictUserEvidenced("assistant_inferred", "user_reported"),
-      ).toBe(true);
-      expect(
-        isConflictUserEvidenced("assistant_inferred", "user_confirmed"),
-      ).toBe(true);
-      expect(
-        isConflictUserEvidenced("assistant_inferred", "legacy_import"),
-      ).toBe(true);
-    });
-
-    test("returns true when both sides are user-evidenced", () => {
-      expect(isConflictUserEvidenced("user_reported", "user_confirmed")).toBe(
-        true,
-      );
-      expect(isConflictUserEvidenced("legacy_import", "user_reported")).toBe(
-        true,
-      );
-    });
-
-    test("returns false when neither side is user-evidenced", () => {
-      expect(
-        isConflictUserEvidenced("assistant_inferred", "assistant_inferred"),
-      ).toBe(false);
-    });
-
-    test("returns false for unknown states on both sides", () => {
-      expect(isConflictUserEvidenced("auto_detected", "pending")).toBe(false);
-      expect(
-        isConflictUserEvidenced("assistant_inferred", "auto_detected"),
-      ).toBe(false);
-    });
-  });
-});