@vellumai/assistant 0.10.2-dev.202606250318.5e7cfb0 → 0.10.2

package/src/cli/commands/memory/worker.ts

@@ -1,175 +0,0 @@
-/**
- * `assistant memory worker` CLI subgroup.
- *
- * Manages the memory jobs worker as its own OS process — separate from the
- * daemon's main event loop. This prevents long-running embedding jobs from
- * blocking user-facing HTTP traffic.
- *
- * Subcommands:
- *
- *   - `start`  — spawn the worker process (detached, background).
- *   - `stop`   — send SIGTERM to the running worker process.
- *   - `status` — report whether the worker process is running.
- *
- * All three run directly in the CLI process (transport: "local") — no IPC
- * round-trip to the daemon.
- */
-
-import type { Command } from "commander";
-
-import {
-  probeMemoryWorker,
-  spawnMemoryWorkerProcess,
-} from "../../../memory/worker-control.js";
-import { getMemoryWorkerPidPath } from "../../../util/platform.js";
-import { registerCommand } from "../../lib/register-command.js";
-import { log } from "../../logger.js";
-import { shouldOutputJson, writeOutput } from "../../output.js";
-
-// ---------------------------------------------------------------------------
-// `start`
-// ---------------------------------------------------------------------------
-
-async function startWorker(
-  opts: { json?: boolean },
-  cmd: Command,
-): Promise<void> {
-  let result: { pid: number; alreadyRunning: boolean };
-  try {
-    result = await spawnMemoryWorkerProcess();
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (shouldOutputJson(cmd)) {
-      writeOutput(cmd, { ok: false, error: msg });
-    } else {
-      log.error(msg);
-    }
-    process.exitCode = 1;
-    return;
-  }
-
-  if (result.alreadyRunning) {
-    const msg = `Memory worker is already running (PID ${result.pid})`;
-    if (shouldOutputJson(cmd)) {
-      writeOutput(cmd, { ok: false, error: msg, pid: result.pid });
-    } else {
-      log.error(msg);
-    }
-    process.exitCode = 1;
-    return;
-  }
-
-  if (shouldOutputJson(cmd)) {
-    writeOutput(cmd, {
-      ok: true,
-      pid: result.pid,
-      pidPath: getMemoryWorkerPidPath(),
-    });
-  } else {
-    log.info(`Memory worker started (PID ${result.pid})`);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// `stop`
-// ---------------------------------------------------------------------------
-
-function stopWorker(opts: { json?: boolean }, cmd: Command): void {
-  const current = probeMemoryWorker();
-  if (current.status !== "running" || current.pid == null) {
-    const msg = "Memory worker is not running";
-    if (shouldOutputJson(cmd)) {
-      writeOutput(cmd, { ok: false, error: msg });
-    } else {
-      log.error(msg);
-    }
-    process.exitCode = 1;
-    return;
-  }
-
-  const pid = current.pid;
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (shouldOutputJson(cmd)) {
-      writeOutput(cmd, { ok: false, error: msg, pid });
-    } else {
-      log.error(`Failed to stop memory worker (PID ${pid}): ${msg}`);
-    }
-    process.exitCode = 1;
-    return;
-  }
-
-  if (shouldOutputJson(cmd)) {
-    writeOutput(cmd, { ok: true, pid });
-  } else {
-    log.info(`Memory worker stop signal sent (PID ${pid})`);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// `status`
-// ---------------------------------------------------------------------------
-
-function statusWorker(opts: { json?: boolean }, cmd: Command): void {
-  const result = probeMemoryWorker();
-  if (shouldOutputJson(cmd)) {
-    writeOutput(cmd, result);
-  } else {
-    if (result.status === "running") {
-      log.info(`Memory worker is running (PID ${result.pid})`);
-    } else {
-      log.info("Memory worker is not running");
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Registration
-// ---------------------------------------------------------------------------
-
-export function registerMemoryWorkerCommand(memory: Command): void {
-  registerCommand(memory, {
-    name: "worker",
-    transport: "local",
-    description: "Manage the memory jobs worker process (start/stop/status)",
-    build: (worker) => {
-      worker.addHelpText(
-        "after",
-        `
-The memory worker processes embedding, consolidation, and cleanup jobs in a
-separate OS process so they do not block the daemon's main event loop.
-
-Examples:
-  $ assistant memory worker start
-  $ assistant memory worker status
-  $ assistant memory worker stop`,
-      );
-
-      worker
-        .command("start")
-        .description("Start the memory worker as a background process")
-        .option("--json", "Emit raw JSON instead of a formatted summary")
-        .action(async (opts: { json?: boolean }, cmd: Command) => {
-          await startWorker(opts, cmd);
-        });
-
-      worker
-        .command("stop")
-        .description("Stop the running memory worker process")
-        .option("--json", "Emit raw JSON instead of a formatted summary")
-        .action((opts: { json?: boolean }, cmd: Command) => {
-          stopWorker(opts, cmd);
-        });
-
-      worker
-        .command("status")
-        .description("Check whether the memory worker process is running")
-        .option("--json", "Emit raw JSON instead of a formatted summary")
-        .action((opts: { json?: boolean }, cmd: Command) => {
-          statusWorker(opts, cmd);
-        });
-    },
-  });
-}

package/src/config/__tests__/loader-callsite-strip-fallback.test.ts

@@ -1,143 +0,0 @@
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import {
-  afterAll,
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
-
-const WORKSPACE_DIR = process.env.VELLUM_WORKSPACE_DIR!;
-const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
-
-function ensureTestDir(): void {
-  const dirs = [
-    WORKSPACE_DIR,
-    join(WORKSPACE_DIR, "data"),
-    join(WORKSPACE_DIR, "data", "memory"),
-    join(WORKSPACE_DIR, "data", "logs"),
-  ];
-  for (const dir of dirs) {
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  }
-}
-
-function makeLoggerStub(): Record<string, unknown> {
-  const stub: Record<string, unknown> = {};
-  for (const m of [
-    "info",
-    "warn",
-    "error",
-    "debug",
-    "trace",
-    "fatal",
-    "silent",
-    "child",
-  ]) {
-    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
-  }
-  return stub;
-}
-
-mock.module("../../util/logger.js", () => ({
-  getLogger: () => makeLoggerStub(),
-}));
-
-afterAll(() => {
-  mock.restore();
-});
-
-import { resolveCallSiteConfig } from "../llm-resolver.js";
-import { invalidateConfigCache, loadConfig } from "../loader.js";
-
-function writeConfig(obj: unknown): void {
-  writeFileSync(CONFIG_PATH, JSON.stringify(obj, null, 2) + "\n");
-}
-
-/**
- * Base config where the active profile resolves to a DIFFERENT model than the
- * `balanced` profile that the shipped `memoryV3SelectL2` call-site default
- * points at. This lets each test distinguish the two failure modes:
- *   - call-site default applied (fixed)  -> model "balanced-model"
- *   - silently downgraded to active      -> model "active-model"
- */
-function baseLlm(callSites: Record<string, unknown>): unknown {
-  return {
-    llm: {
-      default: { provider: "anthropic", model: "default-model" },
-      profiles: {
-        balanced: { provider: "anthropic", model: "balanced-model" },
-        speedy: { provider: "anthropic", model: "active-model" },
-      },
-      activeProfile: "speedy",
-      callSites,
-    },
-  };
-}
-
-describe("config recovery prunes call-site overrides emptied by a strip", () => {
-  beforeEach(() => {
-    ensureTestDir();
-    if (existsSync(CONFIG_PATH)) rmSync(CONFIG_PATH, { force: true });
-    delete process.env.IS_PLATFORM;
-    invalidateConfigCache();
-  });
-
-  afterEach(() => {
-    delete process.env.IS_PLATFORM;
-    if (existsSync(CONFIG_PATH)) rmSync(CONFIG_PATH, { force: true });
-    invalidateConfigCache();
-  });
-
-  test("an undefined call-site profile ref falls back to the shipped default, not the active profile", () => {
-    // The `.profile` ref is invalid (no such profile), so schema recovery
-    // strips it. Before the fix this left `callSites.memoryV3SelectL2 = {}`,
-    // which the resolver treats as a present override and so skips the shipped
-    // `{profile:"balanced"}` default — silently resolving to the active profile.
-    writeConfig(baseLlm({ memoryV3SelectL2: { profile: "ghost-profile" } }));
-
-    const config = loadConfig();
-
-    // The emptied call-site entry must be pruned entirely, not left as `{}`.
-    expect(config.llm.callSites?.memoryV3SelectL2).toBeUndefined();
-
-    // Resolution now lands on the shipped call-site default (balanced), not the
-    // active profile ("active-model"), which is what the bug produced.
-    const resolved = resolveCallSiteConfig("memoryV3SelectL2", config.llm);
-    expect(resolved.model).toBe("balanced-model");
-  });
-
-  test("a valid sibling call-site override survives while the invalid one is pruned", () => {
-    // memoryRouter -> balanced is valid and must be preserved; only the invalid
-    // memoryV3SelectL2 entry is pruned. Guards against over-pruning the parent.
-    writeConfig(
-      baseLlm({
-        memoryV3SelectL2: { profile: "missing" },
-        memoryRouter: { profile: "balanced" },
-      }),
-    );
-
-    const config = loadConfig();
-
-    expect(config.llm.callSites?.memoryV3SelectL2).toBeUndefined();
-    expect(config.llm.callSites?.memoryRouter).toEqual({ profile: "balanced" });
-  });
-
-  test("a partial override keeping other fields is not pruned", () => {
-    // Stripping the invalid `.profile` leaves a non-empty `{temperature:0.5}`,
-    // a legitimate user override the resolver should keep (and which therefore
-    // still shadows the shipped default per existing either/or semantics).
-    writeConfig(
-      baseLlm({ memoryV3SelectL2: { profile: "missing", temperature: 0.5 } }),
-    );
-
-    const config = loadConfig();
-
-    expect(config.llm.callSites?.memoryV3SelectL2).toEqual({
-      temperature: 0.5,
-    });
-  });
-});

package/src/config/prune-seeded-callsite-defaults.ts

@@ -1,110 +0,0 @@
-// Exact system-owned default materializations. These are resolved through
-// shipped call-site defaults rather than persisted as user overrides.
-const SEEDED_CALL_SITES: Record<string, Record<string, unknown>> = {
-  guardianQuestionCopy: latencySeed(),
-  interactionClassifier: latencySeed(),
-  skillCategoryInference: latencySeed(),
-  inviteInstructionGenerator: latencySeed(),
-  notificationDecision: latencySeed(),
-  preferenceExtraction: latencySeed(),
-  commitMessage: {
-    model: "claude-haiku-4-5-20251001",
-    maxTokens: 120,
-    temperature: 0.2,
-    effort: "low",
-    thinking: { enabled: false },
-  },
-  conversationStarters: latencySeed(),
-  conversationSummarization: {
-    model: "claude-opus-4-7",
-    effort: "low",
-    thinking: { enabled: false },
-  },
-  recall: {
-    profile: "cost-optimized",
-    maxTokens: 4096,
-    effort: "low",
-    thinking: { enabled: false, streamThinking: false },
-    temperature: 0,
-    disableCache: true,
-  },
-  heartbeatAgent: {
-    profile: "cost-optimized",
-    maxTokens: 2048,
-    effort: "low",
-    temperature: 0,
-    thinking: { enabled: false, streamThinking: false },
-    contextWindow: { maxInputTokens: 16000 },
-  },
-  replySuggestion: {
-    model: "claude-haiku-4-5-20251001",
-    effort: "low",
-    thinking: { enabled: false },
-    disableCache: true,
-  },
-  memoryRouter: {
-    profile: "cost-optimized",
-    contextWindow: { maxInputTokens: 1_000_000 },
-  },
-};
-
-export function pruneSeededCallsiteDefaultsFromConfig(
-  config: Record<string, unknown>,
-): boolean {
-  const llm = readObject(config.llm);
-  if (llm === null) return false;
-
-  const callSites = readObject(llm.callSites);
-  if (callSites === null) return false;
-
-  let changed = false;
-  for (const [callSite, seed] of Object.entries(SEEDED_CALL_SITES)) {
-    if (deepEqual(callSites[callSite], seed)) {
-      delete callSites[callSite];
-      changed = true;
-    }
-  }
-  if (!changed) return false;
-
-  if (Object.keys(callSites).length === 0) {
-    delete llm.callSites;
-  } else {
-    llm.callSites = callSites;
-  }
-  config.llm = llm;
-  return true;
-}
-
-function latencySeed(): Record<string, unknown> {
-  return {
-    model: "claude-haiku-4-5-20251001",
-    effort: "low",
-    thinking: { enabled: false },
-  };
-}
-
-function readObject(value: unknown): Record<string, unknown> | null {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return null;
-  }
-  return value as Record<string, unknown>;
-}
-
-function deepEqual(a: unknown, b: unknown): boolean {
-  if (a === b) return true;
-  if (a === null || b === null) return false;
-  if (typeof a !== "object" || typeof b !== "object") return false;
-  if (Array.isArray(a) || Array.isArray(b)) return false;
-
-  const aRecord = a as Record<string, unknown>;
-  const bRecord = b as Record<string, unknown>;
-  const aKeys = Object.keys(aRecord);
-  const bKeys = Object.keys(bRecord);
-  if (aKeys.length !== bKeys.length) return false;
-
-  for (const key of aKeys) {
-    if (!Object.prototype.hasOwnProperty.call(bRecord, key)) return false;
-    if (!deepEqual(aRecord[key], bRecord[key])) return false;
-  }
-  return true;
-}

package/src/contacts/__tests__/contacts-write-revoke-relay.test.ts

@@ -1,129 +0,0 @@
-/**
- * Tests for the gateway-first member-revoke relay.
- *
- * revokeMemberChannel downgrades the channel's ACL status through the gateway
- * (source of truth) via `ipcCallPersistent("mark_channel_revoked", ...)` first,
- * then mirrors the downgrade to the assistant DB best-effort. A local mirror
- * failure is swallowed so the gateway-owned outcome stands.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { ContactWriteResult } from "../types.js";
-
-type IpcCall = { method: string; params?: Record<string, unknown> };
-
-let ipcCalls: IpcCall[] = [];
-let ipcOk = true;
-
-const ipcCallPersistentMock = mock(
-  async (method: string, params?: Record<string, unknown>) => {
-    ipcCalls.push({ method, params });
-    return {
-      ok: ipcOk,
-      didWrite: ipcOk,
-      channel: {
-        id: (params?.contactChannelId as string) ?? "ch1",
-        contactId: "c1",
-        type: "telegram",
-        address: "addr",
-        status: "revoked",
-        revokedReason: (params?.reason as string) ?? null,
-      },
-    };
-  },
-);
-const actualGatewayClient = await import("../../ipc/gateway-client.js");
-mock.module("../../ipc/gateway-client.js", () => ({
-  ...actualGatewayClient,
-  ipcCallPersistent: ipcCallPersistentMock,
-}));
-
-
-// Local-mirror primitive.
-const revokeMemberResult: ContactWriteResult = {
-  contact: { id: "c1" } as ContactWriteResult["contact"],
-  channel: { id: "ch1", status: "revoked" } as ContactWriteResult["channel"],
-};
-const revokeMemberMock = mock((_memberId: string, _reason?: string) =>
-  revokeMemberResult,
-);
-const actualContactsWrite = await import("../contacts-write.js");
-mock.module("../contacts-write.js", () => ({
-  ...actualContactsWrite,
-  revokeMember: revokeMemberMock,
-}));
-
-const { revokeMemberChannel } = await import("../member-write-relay.js");
-
-describe("revokeMemberChannel gateway-first relay", () => {
-  beforeEach(() => {
-    ipcCalls = [];
-    ipcOk = true;
-    ipcCallPersistentMock.mockClear();
-    revokeMemberMock.mockClear();
-    revokeMemberMock.mockImplementation(() => revokeMemberResult);
-  });
-
-  test("relays the revoke to the gateway before mirroring locally", async () => {
-    const result = await revokeMemberChannel("ch1", "removed");
-
-    expect(ipcCalls).toEqual([
-      {
-        method: "mark_channel_revoked",
-        params: { contactChannelId: "ch1", reason: "removed" },
-      },
-    ]);
-    expect(revokeMemberMock).toHaveBeenCalledTimes(1);
-    expect(revokeMemberMock).toHaveBeenCalledWith("ch1", "removed");
-    expect(result).toBe(revokeMemberResult);
-  });
-
-  test("strips the composite contactId:channelId prefix before the relay", async () => {
-    await revokeMemberChannel("c1:ch1");
-
-    expect(ipcCalls[0]?.params?.contactChannelId).toBe("ch1");
-    // The local mirror still receives the original composite id it accepts.
-    expect(revokeMemberMock).toHaveBeenCalledWith("c1:ch1", undefined);
-  });
-
-  test("always relays — never skips based on local mirror status", async () => {
-    // The gateway owns the ACL outcome; the relay must fire even if the local
-    // mirror lags (says revoked) while the gateway row is still active.
-    await revokeMemberChannel("ch1");
-
-    expect(ipcCalls).toEqual([
-      {
-        method: "mark_channel_revoked",
-        params: { contactChannelId: "ch1", reason: undefined },
-      },
-    ]);
-    expect(revokeMemberMock).toHaveBeenCalledTimes(1);
-  });
-
-  test("swallows a local-mirror failure without throwing; the gateway revoke stands", async () => {
-    revokeMemberMock.mockImplementation(() => {
-      throw new Error("local mirror exploded");
-    });
-
-    const result = await revokeMemberChannel("ch1", "removed");
-
-    expect(ipcCalls).toHaveLength(1);
-    expect(result).toBeNull();
-  });
-
-  test("throws when the gateway relay returns ok: false", async () => {
-    ipcOk = false;
-
-    let thrown: Error | undefined;
-    try {
-      await revokeMemberChannel("ch1");
-    } catch (err) {
-      thrown = err as Error;
-    }
-
-    expect(thrown).toBeDefined();
-    // Local mirror must not run when the gateway refuses the downgrade.
-    expect(revokeMemberMock).not.toHaveBeenCalled();
-  });
-});