@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/__tests__/onboarding-template-contract.test.ts

@@ -16,69 +16,53 @@ describe("onboarding template contracts", () => {
       expect(bootstrap).toMatch(/^_ Lines starting with _/);
     });
 
-    test("contains identity section", () => {
+    test("anchors identity in the pre-chat personality and demands staying in character", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("identity");
-      expect(lower).toContain("colleague");
+      expect(lower).toContain("pre-chat");
+      expect(lower).toContain("in character");
     });
 
-    test("gathers user context", () => {
+    test("opens in character with a move drawn from workspace files", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("work role");
-      expect(lower).toContain("goals");
-      expect(lower).toContain("tools");
+      expect(lower).toContain("you start the conversation");
+      expect(lower).toContain("workspace files");
     });
 
-    test("contains cleanup instructions with deletion", () => {
+    test("is engaging, inquisitive, and brief", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("wrap up");
-      expect(lower).toContain("delete");
-      expect(lower).toContain("bootstrap.md");
+      expect(lower).toContain("follow-up question");
+      expect(lower).toContain("short");
     });
 
-    test("handles declined fields", () => {
+    test("does the task then keeps learning about the user", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("declined");
-    });
-
-    test("instructs saving to IDENTITY.md, SOUL.md, and user persona file via file_edit", () => {
-      expect(bootstrap).toContain("IDENTITY.md");
-      expect(bootstrap).toContain("SOUL.md");
-      expect(bootstrap).toContain("{{userSlug}}.md");
-      expect(bootstrap).toContain("file_edit");
-    });
-
-    test("contains core principle", () => {
-      expect(bootstrap).toContain("earns its keep");
+      expect(lower).toContain("just do it");
+      expect(lower).toContain("keep learning about them");
     });
 
-    test("contains opening move with onboarding context", () => {
+    test("contains cleanup instructions with deletion", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("onboarding");
-      expect(lower).toContain("json");
-      expect(lower).toContain("context");
+      expect(lower).toContain("delete");
+      expect(lower).toContain("bootstrap.md");
     });
 
-    test("contains tone matching guidance", () => {
+    test("offers assistant migration from an existing ChatGPT/Claude", () => {
       const lower = bootstrap.toLowerCase();
-      expect(lower).toContain("match");
-      expect(lower).toContain("energy");
+      expect(lower).toContain("chatgpt");
+      expect(lower).toContain("claude");
+      expect(bootstrap).toContain("assistant-migration");
     });
 
-    test("is one-shot", () => {
-      expect(bootstrap).toContain("One-shot");
+    test("does not instruct workspace identity-file writes", () => {
+      expect(bootstrap).not.toContain("file_edit");
+      expect(bootstrap).not.toContain("file_write");
+      expect(bootstrap).not.toMatch(/write .*to SOUL\.md/i);
+      expect(bootstrap).not.toMatch(/\{\{userSlug\}\}\.md/);
     });
 
-    test("offers assistant migration during low-signal first openings", () => {
-      expect(bootstrap).toContain("## Assistant migration");
-      expect(bootstrap).toContain("onboarding self-introduction");
-      expect(bootstrap).toContain("treat it as the real first user turn");
-      expect(bootstrap).toContain(
-        "If the first real user turn is only a greeting",
-      );
-      expect(bootstrap).toContain("that first response is the natural opening");
-      expect(bootstrap).toContain("assistant-migration");
-      expect(bootstrap).toContain("do not load or activate");
+    test("does not split users into conversation-first and task-first paths", () => {
+      expect(bootstrap).not.toMatch(/Path A/);
+      expect(bootstrap).not.toMatch(/Path B/);
     });
 
     test("does not contain personality quiz references", () => {

package/src/__tests__/openai-provider.test.ts

@@ -400,6 +400,39 @@ describe("OpenAIProvider", () => {
     expect(events[1]).toEqual({ type: "text_delta", text: ", world!" });
   });
 
+  test("fires tool preview and argument progress events while tool calls stream", async () => {
+    fakeChunks = [
+      ...toolCallChunks([
+        {
+          id: "call_write",
+          name: "app_create",
+          args: '{"source_files":[{"path":"src/App.tsx","content":"hello"}]}',
+        },
+      ]),
+      usageChunk(10, 15),
+    ];
+
+    const events: ProviderEvent[] = [];
+    await provider.sendMessage([userMsg("Create an app")], {
+      onEvent: (e) => events.push(e),
+    });
+
+    expect(events.slice(0, 2)).toEqual([
+      {
+        type: "tool_use_preview_start",
+        toolUseId: "call_write",
+        toolName: "app_create",
+      },
+      {
+        type: "input_json_delta",
+        toolUseId: "call_write",
+        toolName: "app_create",
+        accumulatedJson:
+          '{"source_files":[{"path":"src/App.tsx","content":"hello"}]}',
+      },
+    ]);
+  });
+
   // -----------------------------------------------------------------------
   // Reasoning content (MiniMax / DeepSeek extension)
   // -----------------------------------------------------------------------

package/src/__tests__/openai-responses-provider.test.ts

@@ -89,6 +89,10 @@ function textDeltaEvent(delta: string): FakeStreamEvent {
   return { type: "response.output_text.delta", delta };
 }
 
+function userMsg(text: string): Message {
+  return { role: "user", content: [{ type: "text", text }] };
+}
+
 function functionCallAddedEvent(
   callId: string,
   name: string,
@@ -395,6 +399,42 @@ describe("OpenAIResponsesProvider", () => {
     });
   });
 
+  test("fires tool preview and argument progress events while tool calls stream", async () => {
+    fakeStreamEvents = [
+      functionCallAddedEvent("call_write", "app_create"),
+      functionCallArgsDeltaEvent(
+        '{"source_files":[{"path":"src/App.tsx","content":"hello"}]}',
+        "call_write",
+      ),
+      functionCallArgsDoneEvent(
+        "call_write",
+        "app_create",
+        '{"source_files":[{"path":"src/App.tsx","content":"hello"}]}',
+      ),
+      completedEvent(10, 15),
+    ];
+
+    const events: ProviderEvent[] = [];
+    await provider.sendMessage([userMsg("Create an app")], {
+      onEvent: (e) => events.push(e),
+    });
+
+    expect(events.slice(0, 2)).toEqual([
+      {
+        type: "tool_use_preview_start",
+        toolUseId: "call_write",
+        toolName: "app_create",
+      },
+      {
+        type: "input_json_delta",
+        toolUseId: "call_write",
+        toolName: "app_create",
+        accumulatedJson:
+          '{"source_files":[{"path":"src/App.tsx","content":"hello"}]}',
+      },
+    ]);
+  });
+
   // -----------------------------------------------------------------------
   // Mixed text + tool calls
   // -----------------------------------------------------------------------

package/src/__tests__/persistence-layering-guard.test.ts

@@ -36,26 +36,31 @@ const MEMORY_DIR = join(ASSISTANT_SRC, "plugins", "defaults", "memory");
 /**
  * TECH DEBT — residual `persistence/` → `memory/` feature back-imports.
  *
- * These are genuine couplings to the memory *feature* (conversation
- * title/disk-view services, conversation/group migrations, retrospective +
- * v2 state, the graph bootstrap, the conversation-key store, raw-query helpers,
- * the job checkpoint/cleanup/worker controls) that the
- * persistence layer still depends on. They violate the
- * one-way memory → persistence direction and are scheduled for decoupling in a
- * follow-up (move the depended-on feature logic behind a persistence-owned
- * seam, or invert the dependency so memory injects it). Until then they are
- * pinned here so the guard fails the moment a NEW back-import is introduced.
+ * A genuine coupling to the memory *feature* that violates the one-way
+ * memory → persistence direction would be pinned here so the guard fails the
+ * moment a NEW back-import is introduced. It is currently EMPTY: persistence
+ * reaches the memory feature only through the `memory-lifecycle-hooks` seam
+ * (persistence calls registered handlers; memory never gets imported), never by
+ * importing memory internals. Do not add an entry without a decoupling plan.
  *
  * Keyed by the importing persistence file (relative to repo root); the value
  * is the set of allowed `memory/<specifier>` module paths it may import.
- * Do NOT add to this list without a decoupling plan — the whole point of the
- * guard is to ratchet this set down to empty, never up.
  */
-const PERSISTENCE_TO_MEMORY_ALLOWLIST: Record<string, ReadonlySet<string>> = {
-  "assistant/src/persistence/conversation-crud.ts": new Set([
-    "memory-retrospective-constants",
-  ]),
-  "assistant/src/persistence/jobs-worker.ts": new Set(["v2/consolidation-job"]),
+const PERSISTENCE_TO_MEMORY_ALLOWLIST: Record<string, ReadonlySet<string>> = {};
+
+/**
+ * PERMANENT exception — the migration registry, NOT tech debt.
+ *
+ * `steps.ts` is the ordered list of every migration step; it imports each
+ * migration's forward/down function from the domain that owns it (memory's
+ * `graph/bootstrap`, apps' `app-store`, …). Migrations are append-only and
+ * checkpointed by stable function name, so they live in their owning feature by
+ * design and are merely *referenced* here by the registry — this is the
+ * registry's job, not a layering violation to ratchet to zero. Validated by the
+ * no-stale-entries test like the allowlist, so a removed migration drops its
+ * entry here.
+ */
+const MIGRATION_REGISTRY_MEMORY_IMPORTS: Record<string, ReadonlySet<string>> = {
   "assistant/src/persistence/steps.ts": new Set(["graph/bootstrap"]),
 };
 
@@ -140,7 +145,10 @@ describe("persistence-layering boundary", () => {
       cwd: repoRoot,
     })) {
       const filePath = join(repoRoot, rel);
-      const allowed = PERSISTENCE_TO_MEMORY_ALLOWLIST[rel] ?? new Set<string>();
+      const allowed = new Set<string>([
+        ...(PERSISTENCE_TO_MEMORY_ALLOWLIST[rel] ?? []),
+        ...(MIGRATION_REGISTRY_MEMORY_IMPORTS[rel] ?? []),
+      ]);
       for (const { resolvedFromRoot } of relativeImports(filePath, repoRoot)) {
         const target = stripJs(resolvedFromRoot);
         if (
@@ -178,9 +186,10 @@ describe("persistence-layering boundary", () => {
     const memoryFromRoot = relative(repoRoot, join(repoRoot, MEMORY_DIR));
     const stale: string[] = [];
 
-    for (const [file, allowed] of Object.entries(
-      PERSISTENCE_TO_MEMORY_ALLOWLIST,
-    )) {
+    for (const [file, allowed] of [
+      ...Object.entries(PERSISTENCE_TO_MEMORY_ALLOWLIST),
+      ...Object.entries(MIGRATION_REGISTRY_MEMORY_IMPORTS),
+    ]) {
       const filePath = join(repoRoot, file);
       const actual = new Set<string>();
       for (const { resolvedFromRoot } of relativeImports(filePath, repoRoot)) {

package/src/__tests__/persona-resolver.test.ts

@@ -132,7 +132,6 @@ afterEach(() => {
 
 describe("resolveGuardianPersonaPath", () => {
   test("returns null when no guardian exists", () => {
-
     expect(resolveGuardianPersonaPath()).toBeNull();
   });
 
@@ -206,7 +205,6 @@ describe("ensureGuardianPersonaFile", () => {
 
 describe("resolveGuardianPersonaStrict", () => {
   test("returns null when no guardian contact exists", () => {
-
     expect(resolveGuardianPersonaStrict()).toBeNull();
   });
 
@@ -352,3 +350,59 @@ describe("resolveUserSlug (guardian trust, no requester identity)", () => {
     expect(resolveUserSlug(trustContext)).toBe("alice");
   });
 });
+
+// ── resolveUserSlug — guardian turns WITH a requester identity ─────
+//
+// A foreground guardian turn (e.g. the local desktop app after hatch) carries
+// both a `requesterExternalUserId` (the principal id) and a
+// `guardianExternalUserId`. The requester lookup can find the guardian's own
+// contact row whose `userFile` column is still null — the normal post-hatch
+// state, since onboarding writes users/guardian.md on disk but not the column.
+// That null must not strand the read on users/default.md: it has to fall
+// through to the guardian file the onboarding profile was written to.
+
+describe("resolveUserSlug (guardian trust WITH requester identity)", () => {
+  test("null-userFile guardian contact falls through to the guardian file, not default", () => {
+    // Guardian contact exists but has no explicit userFile (post-hatch state).
+    seedVellumGuardian(null);
+    // The requester principal id resolves to that same null-userFile contact.
+    mockContactsByAddress["vellum:principal-123"] = { userFile: null };
+
+    const trustContext = {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+      requesterExternalUserId: "principal-123",
+      guardianExternalUserId: "vellum:self",
+    } as TrustContext;
+
+    expect(resolveUserSlug(trustContext)).toBe("guardian");
+  });
+
+  test("an explicit requester userFile still wins over the guardian fallback", () => {
+    seedVellumGuardian(null);
+    mockContactsByAddress["vellum:principal-123"] = { userFile: "alice.md" };
+
+    const trustContext = {
+      sourceChannel: "vellum",
+      trustClass: "guardian",
+      requesterExternalUserId: "principal-123",
+      guardianExternalUserId: "vellum:self",
+    } as TrustContext;
+
+    expect(resolveUserSlug(trustContext)).toBe("alice");
+  });
+
+  test("non-guardian turn with a null-userFile contact does not borrow the guardian persona", () => {
+    seedVellumGuardian(null);
+    mockContactsByAddress["vellum:principal-123"] = { userFile: null };
+
+    const trustContext = {
+      sourceChannel: "vellum",
+      trustClass: "trusted_contact",
+      requesterExternalUserId: "principal-123",
+      guardianExternalUserId: "vellum:self",
+    } as TrustContext;
+
+    expect(resolveUserSlug(trustContext)).toBeNull();
+  });
+});

package/src/__tests__/personal-memory-auth-bypass.test.ts

@@ -0,0 +1,62 @@
+/**
+ * Security regression test for the personal-memory trust gate under
+ * DISABLE_HTTP_AUTH.
+ *
+ * `isPersonalMemoryAllowed` derives trust from `resolveTrustClass`, which only
+ * elevates an *unresolved* actor to guardian under DISABLE_HTTP_AUTH (the
+ * standing config in platform-managed deployments). A resolved non-guardian
+ * channel actor must therefore be denied personal memory even with auth
+ * disabled — otherwise the guardian's memory leaks to Slack/phone contacts in
+ * the cloud. See LUM-2669. These cases fail on the pre-fix behavior.
+ *
+ * Uses process.env directly (not a module mock) since isHttpAuthDisabled()
+ * reads DISABLE_HTTP_AUTH live.
+ */
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import {
+  isPersonalMemoryAllowed,
+  type TrustContext,
+} from "../daemon/trust-context.js";
+import type { TrustClass } from "../runtime/actor-trust-resolver.js";
+
+function slack(trustClass: TrustClass): TrustContext {
+  return { sourceChannel: "slack", trustClass };
+}
+
+let prior: string | undefined;
+
+beforeEach(() => {
+  // Platform-managed / dev-bypass posture: the flag is on process-wide.
+  prior = process.env.DISABLE_HTTP_AUTH;
+  process.env.DISABLE_HTTP_AUTH = "true";
+});
+
+afterEach(() => {
+  if (prior === undefined) {
+    delete process.env.DISABLE_HTTP_AUTH;
+  } else {
+    process.env.DISABLE_HTTP_AUTH = prior;
+  }
+});
+
+describe("isPersonalMemoryAllowed — no exposure to non-guardian channel actors under DISABLE_HTTP_AUTH", () => {
+  test("blocks personal memory for a non-guardian Slack actor even with auth disabled", () => {
+    expect(isPersonalMemoryAllowed(slack("trusted_contact"))).toBe(false);
+    expect(isPersonalMemoryAllowed(slack("unknown"))).toBe(false);
+    expect(isPersonalMemoryAllowed(slack("unverified_contact"))).toBe(false);
+  });
+
+  test("allows personal memory for the guardian and for local / internal turns", () => {
+    expect(isPersonalMemoryAllowed(slack("guardian"))).toBe(true);
+    // Local/native turn — no resolved actor.
+    expect(isPersonalMemoryAllowed(undefined)).toBe(true);
+    // Internal vellum-channel flow.
+    expect(
+      isPersonalMemoryAllowed({
+        sourceChannel: "vellum",
+        trustClass: "unknown",
+      }),
+    ).toBe(true);
+  });
+});

package/src/__tests__/phone.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import { isValidE164, normalizePhoneNumber } from "../util/phone.js";
+import { normalizePhoneNumber } from "../util/phone.js";
 
 describe("normalizePhoneNumber", () => {
   test("already E.164 — returned as-is", () => {
@@ -55,17 +55,3 @@ describe("normalizePhoneNumber", () => {
     expect(normalizePhoneNumber("")).toBeNull();
   });
 });
-
-describe("isValidE164", () => {
-  test("valid E.164 number", () => {
-    expect(isValidE164("+15551234567")).toBe(true);
-  });
-
-  test("missing + prefix", () => {
-    expect(isValidE164("5551234567")).toBe(false);
-  });
-
-  test("too short", () => {
-    expect(isValidE164("+123")).toBe(false);
-  });
-});