@vellumai/assistant 0.10.12 → 0.11.0-staging.1

package/src/daemon/message-types/workspace.ts

@@ -1,137 +0,0 @@
-// Workspace file, identity, and tool permission types.
-
-import type { IdentityChangedEvent } from "../../api/events/identity-changed.js";
-
-// === Client → Server ===
-
-export interface WorkspaceFilesListRequest {
-  type: "workspace_files_list";
-}
-
-export interface WorkspaceFileReadRequest {
-  type: "workspace_file_read";
-  /** Relative path within the workspace directory (e.g. "IDENTITY.md"). */
-  path: string;
-}
-
-export interface IdentityGetRequest {
-  type: "identity_get";
-}
-
-export interface ToolPermissionSimulateRequest {
-  type: "tool_permission_simulate";
-  /** Tool name to simulate (e.g. 'bash', 'file_write'). */
-  toolName: string;
-  /** Tool input record to simulate. */
-  input: Record<string, unknown>;
-  /** Working directory context; defaults to daemon cwd when omitted. */
-  workingDir?: string;
-  /** Whether the simulated context is interactive (default true). */
-  isInteractive?: boolean;
-}
-
-export interface ToolNamesListRequest {
-  type: "tool_names_list";
-}
-
-// === Server → Client ===
-
-export interface WorkspaceFilesListResponse {
-  type: "workspace_files_list_response";
-  files: Array<{
-    /** Relative path within the workspace (e.g. "IDENTITY.md", "skills/my-skill"). */
-    path: string;
-    /** Display name (e.g. "IDENTITY.md"). */
-    name: string;
-    /** Whether the file/directory exists. */
-    exists: boolean;
-  }>;
-}
-
-export interface WorkspaceFileReadResponse {
-  type: "workspace_file_read_response";
-  path: string;
-  content: string | null;
-  error?: string;
-}
-
-export interface IdentityGetResponse {
-  type: "identity_get_response";
-  /** Whether an IDENTITY.md file was found. When false, all fields are empty defaults. */
-  found: boolean;
-  name: string;
-  role: string;
-  personality: string;
-  emoji: string;
-  home: string;
-  version?: string;
-  assistantId?: string;
-  createdAt?: string;
-  originSystem?: string;
-}
-
-export interface ToolPermissionSimulateResponse {
-  type: "tool_permission_simulate_response";
-  success: boolean;
-  /** The simulated permission decision. */
-  decision?: "allow" | "deny" | "prompt";
-  /** Risk level of the simulated tool invocation. */
-  riskLevel?: string;
-  /** Human-readable reason for the decision. */
-  reason?: string;
-  /** When decision is 'prompt', the data needed to render a ToolConfirmationBubble. */
-  promptPayload?: {
-    allowlistOptions: Array<{
-      label: string;
-      description: string;
-      pattern: string;
-    }>;
-    scopeOptions: Array<{ label: string; scope: string }>;
-    persistentDecisionsAllowed: boolean;
-  };
-  /** Resolved execution target for the tool. */
-  executionTarget?: "host" | "sandbox";
-  /** ID of the trust rule that matched (if any). */
-  matchedTrustRuleId?: string;
-  /** Error message when success is false. */
-  error?: string;
-}
-
-export interface ToolInputSchema {
-  type: "object";
-  properties?: Record<
-    string,
-    {
-      type?: string;
-      description?: string;
-      enum?: string[];
-      [key: string]: unknown;
-    }
-  >;
-  required?: string[];
-}
-
-export interface ToolNamesListResponse {
-  type: "tool_names_list_response";
-  /** Sorted list of all registered tool names. */
-  names: string[];
-  /** Input schemas keyed by tool name. */
-  schemas?: Record<string, ToolInputSchema>;
-}
-
-// --- Domain-level union aliases (consumed by the barrel file) ---
-
-export type _WorkspaceClientMessages =
-  | WorkspaceFilesListRequest
-  | WorkspaceFileReadRequest
-  | IdentityGetRequest
-  | ToolPermissionSimulateRequest
-  | ToolNamesListRequest;
-
-export type _WorkspaceServerMessages =
-  | WorkspaceFilesListResponse
-  | WorkspaceFileReadResponse
-  | IdentityGetResponse
-  | ToolPermissionSimulateResponse
-  | ToolNamesListResponse
-  | IdentityChangedEvent;

package/src/live-voice/ack-phrases.ts

@@ -1,58 +0,0 @@
-import type { LiveVoiceSpokenAckKind } from "./live-voice-metrics.js";
-
-// Short, persona-neutral phrases spoken to hold the floor when the model is
-// slow to produce its first delta. Pure floor-holders:
-// they must never carry content or require domain knowledge, and they stay
-// short (≤ 6 words) so they finish before the real reply's audio arrives.
-const ACK_PHRASES: readonly string[] = [
-  "One sec — let me think.",
-  "Let me look into that.",
-  "Give me a moment.",
-  "Hmm, let me check.",
-  "Just a moment.",
-];
-
-// Tool-flavored variant spoken the moment a turn starts tool use (a
-// guaranteed-slow turn). Same rules as ACK_PHRASES: persona-neutral, no
-// domain content, ≤ 6 words.
-const TOOL_ACK_PHRASES: readonly string[] = [
-  "Let me check that.",
-  "Looking that up now.",
-  "Let me pull that up.",
-  "One moment, checking.",
-  "Give me a second here.",
-];
-
-const PHRASES_BY_KIND: Record<LiveVoiceSpokenAckKind, readonly string[]> = {
-  first_delta: ACK_PHRASES,
-  tool_use: TOOL_ACK_PHRASES,
-};
-
-// Static fallbacks for an idle-triggered progress narration whose LLM
-// phrasing failed — the one case where prolonged silence is actively harmful.
-// The idle trigger can fire on a slow turn with zero tool activity, so every
-// phrase stays strictly neutral: no claims about running tools or tasks.
-// Same rules as the ack lists: persona-neutral, no domain content, ≤ 8 words.
-// Exported so tests can assert the neutrality invariant against the list.
-export const PROGRESS_FALLBACK_PHRASES: readonly string[] = [
-  "Still on it — one moment.",
-  "Still thinking this through.",
-  "Almost there — thanks for waiting.",
-];
-
-// Deterministic rotation through a phrase list: callers hold a nonnegative
-// monotonic counter, so consecutive picks vary while tests stay reproducible.
-function pickPhrase(phrases: readonly string[], counter: number): string {
-  return phrases[counter % phrases.length];
-}
-
-export function pickAckPhrase(
-  kind: LiveVoiceSpokenAckKind,
-  counter: number,
-): string {
-  return pickPhrase(PHRASES_BY_KIND[kind], counter);
-}
-
-export function pickProgressPhrase(counter: number): string {
-  return pickPhrase(PROGRESS_FALLBACK_PHRASES, counter);
-}

package/src/plugins/defaults/memory/retrieval-budget.ts

@@ -1,29 +0,0 @@
-export interface RecallBudgetInput {
-  estimatedPromptTokens: number;
-  maxInputTokens: number;
-  targetHeadroomTokens: number;
-  minInjectTokens: number;
-  maxInjectTokens: number;
-}
-
-/**
- * Compute per-turn memory recall injection budget from context headroom.
- *
- * The result is always clamped into [minInjectTokens, maxInjectTokens].
- */
-export function computeRecallBudget(input: RecallBudgetInput): number {
-  const maxInput = Math.max(0, Math.floor(input.maxInputTokens));
-  const estimatedPrompt = Math.max(0, Math.floor(input.estimatedPromptTokens));
-  const headroomTarget = Math.max(0, Math.floor(input.targetHeadroomTokens));
-  const minInject = Math.max(1, Math.floor(input.minInjectTokens));
-  const maxInject = Math.max(minInject, Math.floor(input.maxInjectTokens));
-
-  const available = maxInput - estimatedPrompt - headroomTarget;
-  return clamp(Math.floor(available), minInject, maxInject);
-}
-
-function clamp(value: number, min: number, max: number): number {
-  if (value < min) return min;
-  if (value > max) return max;
-  return value;
-}

package/src/plugins/defaults/memory/v3/__tests__/gate-flag.test.ts

@@ -1,69 +0,0 @@
-/**
- * Tests for `gate-flag.ts` — the on/off predicate gating the memory-v3
- * per-turn injection gate. The assistant flag resolver is mocked so the test
- * asserts the composition: the predicate forwards `MEMORY_V3_INJECTION_GATE_FLAG`
- * and the config to `isAssistantFeatureFlagEnabled` and ANDs its boolean with
- * the `memory.v3.gate.enabled` config kill-switch.
- */
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { AssistantConfig } from "../../../../../config/schema.js";
-
-// The resolver is mocked BEFORE importing the module under test so the import
-// observes the spy at load time. The specifier is resolved relative to THIS
-// test file (one level deeper than gate-flag.ts's own import path).
-const isAssistantFeatureFlagEnabled = mock(
-  (_flag: string, _config: AssistantConfig): boolean => false,
-);
-
-mock.module("../../../../../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled,
-}));
-
-const { isMemoryV3InjectionGateEnabled, MEMORY_V3_INJECTION_GATE_FLAG } =
-  await import("../gate-flag.js");
-
-// The predicate reads only `memory.v3.gate.enabled` from the config.
-const cfgWithGateEnabled = (enabled: boolean): AssistantConfig =>
-  ({ memory: { v3: { gate: { enabled } } } }) as AssistantConfig;
-
-describe("gate-flag", () => {
-  beforeEach(() => {
-    isAssistantFeatureFlagEnabled.mockReset();
-  });
-
-  test("constant is the kebab-case flag id", () => {
-    expect(MEMORY_V3_INJECTION_GATE_FLAG).toBe("memory-v3-injection-gate");
-  });
-
-  test("flag on + config enabled → true, resolver called with the flag id + config", () => {
-    isAssistantFeatureFlagEnabled.mockReturnValue(true);
-
-    const cfg = cfgWithGateEnabled(true);
-    expect(isMemoryV3InjectionGateEnabled(cfg)).toBe(true);
-    expect(isAssistantFeatureFlagEnabled).toHaveBeenCalledTimes(1);
-    expect(isAssistantFeatureFlagEnabled).toHaveBeenCalledWith(
-      MEMORY_V3_INJECTION_GATE_FLAG,
-      cfg,
-    );
-  });
-
-  test("returns false when the resolver returns false", () => {
-    isAssistantFeatureFlagEnabled.mockReturnValue(false);
-
-    const cfg = cfgWithGateEnabled(true);
-    expect(isMemoryV3InjectionGateEnabled(cfg)).toBe(false);
-    expect(isAssistantFeatureFlagEnabled).toHaveBeenCalledWith(
-      MEMORY_V3_INJECTION_GATE_FLAG,
-      cfg,
-    );
-  });
-
-  test("config kill-switch: flag on + gate.enabled false → false", () => {
-    isAssistantFeatureFlagEnabled.mockReturnValue(true);
-
-    expect(isMemoryV3InjectionGateEnabled(cfgWithGateEnabled(false))).toBe(
-      false,
-    );
-  });
-});

package/src/plugins/defaults/memory/v3/gate-flag.ts

@@ -1,20 +0,0 @@
-import { isAssistantFeatureFlagEnabled } from "../../../../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../../../../config/schema.js";
-
-/** Feature-flag id (kebab-case) gating the memory-v3 per-turn injection gate. */
-export const MEMORY_V3_INJECTION_GATE_FLAG =
-  "memory-v3-injection-gate" as const;
-
-/** Whether the memory-v3 injection gate is enabled for this config: the
- *  feature flag (resolved via the standard assistant flag resolver — gateway
- *  override → registry default → false) AND the `memory.v3.gate.enabled`
- *  config kill-switch. `enabled: false` forces the full selection process
- *  every turn even with the flag on. Thresholds live in `memory.v3.gate`. */
-export function isMemoryV3InjectionGateEnabled(
-  config: AssistantConfig,
-): boolean {
-  return (
-    isAssistantFeatureFlagEnabled(MEMORY_V3_INJECTION_GATE_FLAG, config) &&
-    config.memory.v3.gate.enabled
-  );
-}

package/src/plugins/defaults/memory/v3/substrate/__tests__/memory-v2-startup.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-
-import type { AssistantConfig } from "../../../../../../config/schema.js";
-
-function fakeConfig(): AssistantConfig {
-  return {
-    memory: { v2: { enabled: true } },
-  } as unknown as AssistantConfig;
-}
-
-/**
- * Reset and re-install the mocks for the collaborator modules
- * `maybeRebuildMemoryV2Concepts` pulls in, then re-import the module under test
- * so its dynamic imports resolve to the freshly-mocked collaborators. Returns
- * the spies plus the re-imported function.
- *
- * Drives the empty-after-create branch (collection not migrated, zero points,
- * pages on disk) so the reembed enqueue decision is reached, and lets the test
- * choose whether a `memory_v2_reembed` job is already in-flight.
- */
-async function withMocks(opts: { reembedInFlight: boolean }) {
-  const spies = {
-    enqueueMemoryJob: mock(() => "job-id"),
-    hasActiveJobOfType: mock(
-      (type: string) => opts.reembedInFlight && type === "memory_v2_reembed",
-    ),
-    ensureConceptPageCollection: mock(async () => ({ migrated: false })),
-    countConceptPagePoints: mock(async () => 0),
-    clearReembedSentinel: mock(async () => {}),
-    hasConceptPages: mock(async () => true),
-  };
-
-  mock.module("../../../../../../persistence/jobs-store.js", () => ({
-    enqueueMemoryJob: spies.enqueueMemoryJob,
-    hasActiveJobOfType: spies.hasActiveJobOfType,
-  }));
-  mock.module("../qdrant.js", () => ({
-    ensureConceptPageCollection: spies.ensureConceptPageCollection,
-    countConceptPagePoints: spies.countConceptPagePoints,
-    clearReembedSentinel: spies.clearReembedSentinel,
-  }));
-  mock.module("../page-store.js", () => ({
-    hasConceptPages: spies.hasConceptPages,
-  }));
-  const realPlatform = await import("../../../../../../util/platform.js");
-  mock.module("../../../../../../util/platform.js", () => ({
-    ...realPlatform,
-    getWorkspaceDir: () => "/tmp/workspace",
-  }));
-
-  const mod = await import("../memory-v2-startup.js");
-  return {
-    spies,
-    maybeRebuildMemoryV2Concepts: mod.maybeRebuildMemoryV2Concepts,
-  };
-}
-
-describe("maybeRebuildMemoryV2Concepts reembed dedup", () => {
-  test("does NOT enqueue a second reembed when one is already in-flight", async () => {
-    const { spies, maybeRebuildMemoryV2Concepts } = await withMocks({
-      reembedInFlight: true,
-    });
-
-    await maybeRebuildMemoryV2Concepts(fakeConfig());
-
-    expect(spies.hasActiveJobOfType).toHaveBeenCalledWith("memory_v2_reembed");
-    expect(spies.enqueueMemoryJob).toHaveBeenCalledTimes(0);
-    // The sentinel is still retired even when the enqueue is skipped.
-    expect(spies.clearReembedSentinel).toHaveBeenCalledTimes(1);
-  });
-
-  test("enqueues the reembed when none is in-flight", async () => {
-    const { spies, maybeRebuildMemoryV2Concepts } = await withMocks({
-      reembedInFlight: false,
-    });
-
-    await maybeRebuildMemoryV2Concepts(fakeConfig());
-
-    expect(spies.enqueueMemoryJob).toHaveBeenCalledTimes(1);
-    expect(spies.enqueueMemoryJob).toHaveBeenCalledWith(
-      "memory_v2_reembed",
-      {},
-    );
-    expect(spies.clearReembedSentinel).toHaveBeenCalledTimes(1);
-  });
-});

package/src/plugins/defaults/memory/v3/substrate/memory-v2-startup.test.ts

@@ -1,205 +0,0 @@
-/**
- * Tests for `maybeReseedCapabilitiesAfterManagedCredential` in
- * `memory-v2-startup.ts`.
- *
- * The secrets route calls this when a managed-proxy credential lands, to close
- * the first-boot race where the daemon's startup capability seed (skills + CLI
- * commands) runs before the platform provisions the managed embedding
- * credential — the seed's embed throws and the synthetic capability pages never
- * reach the page index. The reseed must fire only when v2 memory is enabled AND
- * the managed-proxy prerequisites are now satisfied, so self-hosted / BYOK
- * assistants (no managed proxy) are never made to run a doomed embed. When v3 is
- * live it then enqueues a `memory_v3_maintain` job so v3 picks up the capability
- * pages immediately instead of waiting out the 6h maintain backstop.
- *
- * Dynamic-imported collaborators are mocked at module scope; `bun:test`
- * isolates `mock.module` per test file.
- */
-import { afterEach, describe, expect, mock, test } from "bun:test";
-
-import type { AssistantConfig } from "../../../../../config/schema.js";
-
-const proxyState = { prereqs: true };
-const v3State = { live: true };
-const seedSkill = mock(async () => {});
-const seedCli = mock(async () => {});
-const enqueueJob = mock(
-  (_type: string, _payload: Record<string, unknown>) => 1,
-);
-
-mock.module("../../../../../providers/platform-proxy/context.js", () => ({
-  hasManagedProxyPrereqs: async () => proxyState.prereqs,
-}));
-
-mock.module("../../../../../config/memory-v3-gate.js", () => ({
-  isMemoryV3Live: () => v3State.live,
-  usesConceptPageMemory: (memory?: {
-    enabled?: boolean;
-    v2?: { enabled?: boolean };
-    v3?: { live?: boolean };
-  }) =>
-    memory?.enabled !== false &&
-    (memory?.v3?.live === true || memory?.v2?.enabled === true),
-}));
-
-mock.module("../../../../../persistence/jobs-store.js", () => ({
-  enqueueMemoryJob: enqueueJob,
-}));
-
-mock.module("./skill-store.js", () => ({
-  seedV2SkillEntries: seedSkill,
-}));
-
-mock.module("./cli-command-store.js", () => ({
-  seedV2CliCommandEntries: seedCli,
-}));
-
-const { maybeReseedCapabilitiesAfterManagedCredential } =
-  await import("./memory-v2-startup.js");
-
-function configWithV2(enabled: boolean): AssistantConfig {
-  return { memory: { v2: { enabled } } } as unknown as AssistantConfig;
-}
-
-/** Poll until `m` has been called at least `n` times, or `timeoutMs` elapses. */
-async function waitForCalls(
-  m: { mock: { calls: unknown[] } },
-  n: number,
-  timeoutMs = 1000,
-): Promise<void> {
-  const start = Date.now();
-  while (m.mock.calls.length < n && Date.now() - start < timeoutMs) {
-    await new Promise((resolve) => setTimeout(resolve, 5));
-  }
-}
-
-afterEach(() => {
-  seedSkill.mockClear();
-  seedCli.mockClear();
-  enqueueJob.mockClear();
-  proxyState.prereqs = true;
-  v3State.live = true;
-});
-
-describe("maybeReseedCapabilitiesAfterManagedCredential", () => {
-  test("reseeds both skill and CLI entries when v2 is enabled and managed-proxy prereqs are satisfied", async () => {
-    proxyState.prereqs = true;
-
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
-
-    expect(seedSkill).toHaveBeenCalledTimes(1);
-    expect(seedCli).toHaveBeenCalledTimes(1);
-  });
-
-  test("enqueues a v3 maintain pass after reseeding when v3 is live", async () => {
-    proxyState.prereqs = true;
-    v3State.live = true;
-
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
-
-    expect(enqueueJob).toHaveBeenCalledTimes(1);
-    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
-  });
-
-  test("reseeds but does not enqueue a v3 maintain pass when v3 is not live", async () => {
-    proxyState.prereqs = true;
-    v3State.live = false;
-
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
-
-    expect(seedSkill).toHaveBeenCalledTimes(1);
-    expect(seedCli).toHaveBeenCalledTimes(1);
-    expect(enqueueJob).not.toHaveBeenCalled();
-  });
-
-  test("no-op when v2 memory is disabled", async () => {
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(false));
-
-    expect(seedSkill).not.toHaveBeenCalled();
-    expect(seedCli).not.toHaveBeenCalled();
-    expect(enqueueJob).not.toHaveBeenCalled();
-  });
-
-  test("no-op for non-managed assistants (managed-proxy prereqs not satisfied)", async () => {
-    proxyState.prereqs = false;
-
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
-
-    expect(seedSkill).not.toHaveBeenCalled();
-    expect(seedCli).not.toHaveBeenCalled();
-    expect(enqueueJob).not.toHaveBeenCalled();
-  });
-
-  test("swallows a seed failure and still reseeds the other catalog", async () => {
-    proxyState.prereqs = true;
-    seedSkill.mockImplementationOnce(async () => {
-      throw new Error('Embedding backend "gemini" is not configured');
-    });
-
-    // Must not reject — the helper contains each seed's failure so a doomed
-    // embed never propagates back to the credential-store caller.
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
-
-    expect(seedCli).toHaveBeenCalledTimes(1);
-  });
-
-  test("enqueues the v3 maintain pass even when one catalog reseed rejects", async () => {
-    proxyState.prereqs = true;
-    v3State.live = true;
-    seedSkill.mockImplementationOnce(async () => {
-      throw new Error('Embedding backend "gemini" is not configured');
-    });
-
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true));
-
-    // The CLI catalog seeded, so v3 must still rebuild its lanes — a single
-    // catalog failure cannot suppress the maintain pass.
-    expect(seedCli).toHaveBeenCalledTimes(1);
-    expect(enqueueJob).toHaveBeenCalledTimes(1);
-    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
-  });
-
-  test("enqueues the v3 maintain pass without blocking when a catalog reseed exceeds the timeout", async () => {
-    proxyState.prereqs = true;
-    v3State.live = true;
-    // Skill reseed never settles — mirrors the wedged getCatalog()/embed seen in
-    // the field. The CLI reseed completes normally.
-    seedSkill.mockImplementationOnce(() => new Promise<void>(() => {}));
-
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true), {
-      reseedTimeoutMs: 20,
-    });
-
-    // An unbounded `Promise.all` barrier would hang here forever; the bounded
-    // barrier lets the CLI catalog's maintain pass enqueue regardless.
-    expect(seedCli).toHaveBeenCalledTimes(1);
-    expect(enqueueJob).toHaveBeenCalledTimes(1);
-    expect(enqueueJob).toHaveBeenCalledWith("memory_v3_maintain", {});
-  });
-
-  test("re-enqueues the v3 maintain pass when a straggler catalog finishes after the timeout", async () => {
-    proxyState.prereqs = true;
-    v3State.live = true;
-    let resolveSkill!: () => void;
-    seedSkill.mockImplementationOnce(
-      () =>
-        new Promise<void>((resolve) => {
-          resolveSkill = resolve;
-        }),
-    );
-
-    await maybeReseedCapabilitiesAfterManagedCredential(configWithV2(true), {
-      reseedTimeoutMs: 10,
-    });
-
-    // Post-barrier enqueue fires once even though the skill catalog is still
-    // embedding.
-    expect(enqueueJob).toHaveBeenCalledTimes(1);
-
-    // The straggler lands; maintain re-enqueues so its late capability rows are
-    // reconciled without waiting out the 6h backstop.
-    resolveSkill();
-    await waitForCalls(enqueueJob, 2);
-    expect(enqueueJob).toHaveBeenCalledTimes(2);
-  });
-});