@vellumai/assistant 0.9.0 → 0.9.1-staging.1

package/src/__tests__/voice-invite-redemption.test.ts

@@ -180,7 +180,7 @@ describe("redeemVoiceInviteCode", () => {
 
     const channelResult = findContactChannel({
       channelType: "phone",
-      externalUserId: phone,
+      address: phone,
     });
 
     expect(channelResult).not.toBeNull();
@@ -399,7 +399,7 @@ describe("redeemVoiceInviteCode", () => {
     // Verify the redeemer's phone is now bound to Mom's contact
     const contactResult = findContactChannel({
       channelType: "phone",
-      externalUserId: phone,
+      address: phone,
     });
     expect(contactResult).not.toBeNull();
     expect(contactResult!.contact.id).toBe(momContact.id);

package/src/__tests__/web-search-catalog-parity.test.ts

@@ -8,20 +8,15 @@ import {
 } from "../providers/search-provider-catalog.js";
 
 /**
- * Parity guard: daemon TS catalog vs the two generated JSON copies.
+ * Parity guard: daemon TS catalog vs the generated JSON copy.
  *
  * The daemon maintains its canonical search-provider catalog in
  * `assistant/src/providers/search-provider-catalog.ts`.
- * `assistant/scripts/sync-web-search-catalog.ts` writes two byte-identical
- * artifacts:
- *   - `meta/web-search-provider-catalog.json` — primary cross-package artifact.
- *   - `clients/shared/Resources/web-search-provider-catalog.json` — SwiftPM
- *     resource bundled into `VellumAssistantShared` (Swift cannot reach
- *     files outside a target's source directory).
+ * `assistant/scripts/sync-web-search-catalog.ts` writes
+ * `meta/web-search-provider-catalog.json` — the primary cross-package artifact.
  *
  * These tests enforce structural equality between the TS catalog and the
- * meta/ copy, plus byte equality between the meta/ copy and the SwiftPM
- * mirror. CI fails when any of the three drift.
+ * meta/ copy. CI fails when they drift.
  */
 
 interface JsonCatalogEntry {
@@ -46,11 +41,6 @@ const META_JSON_PATH = join(
   "..",
   "meta/web-search-provider-catalog.json",
 );
-const SWIFTPM_MIRROR_PATH = join(
-  process.cwd(),
-  "..",
-  "clients/shared/Resources/web-search-provider-catalog.json",
-);
 
 function loadJsonCatalog(): JsonCatalog {
   return JSON.parse(readFileSync(META_JSON_PATH, "utf-8"));
@@ -73,7 +63,8 @@ function entryToPlain(
   if (entry.apiKeyPrefix !== undefined) out.apiKeyPrefix = entry.apiKeyPrefix;
   if (entry.envVar !== undefined) out.envVar = entry.envVar;
   if (entry.secretKey !== undefined) out.secretKey = entry.secretKey;
-  if (entry.fallbackOrder !== undefined) out.fallbackOrder = entry.fallbackOrder;
+  if (entry.fallbackOrder !== undefined)
+    out.fallbackOrder = entry.fallbackOrder;
   if (entry.privacyPolicyUrl !== undefined) {
     out.privacyPolicyUrl = entry.privacyPolicyUrl;
   }
@@ -95,14 +86,4 @@ describe("web-search catalog parity (TS canonical vs meta/ JSON)", () => {
       SEARCH_PROVIDER_CATALOG.map((p) => p.id),
     );
   });
-
-  test("SwiftPM mirror is byte-identical to meta/ copy", () => {
-    // The generator writes both files from the same serializer; this guard
-    // catches any case where one copy is regenerated without the other.
-    // Byte equality is required because SwiftPM bundles the resource verbatim
-    // and the meta/ JSON is consumed as a cross-package artifact.
-    const metaBytes = readFileSync(META_JSON_PATH);
-    const swiftPmBytes = readFileSync(SWIFTPM_MIRROR_PATH);
-    expect(swiftPmBytes.equals(metaBytes)).toBe(true);
-  });
 });

package/src/__tests__/workspace-greetings.test.ts

@@ -0,0 +1,152 @@
+/**
+ * Unit tests for workspace-authored greeting parsing.
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+const workspaceFiles: Record<string, string> = {};
+
+mock.module("node:fs", () => ({
+  existsSync: (path: string) => {
+    const name = path.split("/").pop() ?? "";
+    return name in workspaceFiles;
+  },
+  readFileSync: (path: string, _encoding: string) => {
+    const name = path.split("/").pop() ?? "";
+    if (name in workspaceFiles) return workspaceFiles[name];
+    throw new Error(`ENOENT: ${path}`);
+  },
+}));
+
+import {
+  parseGreetingsSection,
+  readWorkspaceGreetings,
+} from "../runtime/routes/workspace-greetings.js";
+
+afterEach(() => {
+  for (const key of Object.keys(workspaceFiles)) {
+    delete workspaceFiles[key];
+  }
+});
+
+describe("parseGreetingsSection", () => {
+  test("parses bullet list from ## Greetings section", () => {
+    const content = [
+      "# Soul",
+      "",
+      "## Greetings",
+      "- Hey there, friend!",
+      "- What's on your mind?",
+      "- Ready to roll!",
+      "",
+      "## Other Section",
+      "Some other content.",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "Hey there, friend!",
+      "What's on your mind?",
+      "Ready to roll!",
+    ]);
+  });
+
+  test("handles asterisk bullets", () => {
+    const content = ["## Greetings", "* Hello!", "* Hi there."].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual(["Hello!", "Hi there."]);
+  });
+
+  test("handles plus and numbered bullets", () => {
+    const content = [
+      "## Greetings",
+      "+ Welcome back.",
+      "1. Ready when you are.",
+      "2) What are we building today?",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "Welcome back.",
+      "Ready when you are.",
+      "What are we building today?",
+    ]);
+  });
+
+  test("only starts at a level-two Greetings heading", () => {
+    const content = [
+      "# Greetings",
+      "- Not the section contract.",
+      "",
+      "## Greetings",
+      "- The real greeting.",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual(["The real greeting."]);
+  });
+
+  test("returns null when section is missing", () => {
+    const content = ["# Soul", "## Personality", "Be friendly."].join("\n");
+
+    expect(parseGreetingsSection(content)).toBeNull();
+  });
+
+  test("returns null when section is empty", () => {
+    const content = ["## Greetings", "", "## Next Section"].join("\n");
+
+    expect(parseGreetingsSection(content)).toBeNull();
+  });
+
+  test("ignores non-bullet lines in section", () => {
+    const content = [
+      "## Greetings",
+      "Some intro text that's not a bullet",
+      "- Actual greeting",
+      "Another non-bullet line",
+      "- Second greeting",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "Actual greeting",
+      "Second greeting",
+    ]);
+  });
+
+  test("allows nested headings and stops at the next same-or-higher heading", () => {
+    const content = [
+      "## Greetings",
+      "- First",
+      "- Second",
+      "### Sub-heading",
+      "- Third",
+      "## Other Section",
+      "- Should not appear",
+    ].join("\n");
+
+    expect(parseGreetingsSection(content)).toEqual([
+      "First",
+      "Second",
+      "Third",
+    ]);
+  });
+});
+
+describe("readWorkspaceGreetings", () => {
+  test("reads greetings from SOUL.md", () => {
+    workspaceFiles["SOUL.md"] = [
+      "# Soul",
+      "## Greetings",
+      "- Hey!",
+      "- What's up?",
+    ].join("\n");
+
+    expect(readWorkspaceGreetings()).toEqual(["Hey!", "What's up?"]);
+  });
+
+  test("returns null when SOUL.md has no greetings section", () => {
+    workspaceFiles["SOUL.md"] = "# Soul\nBe friendly.";
+    expect(readWorkspaceGreetings()).toBeNull();
+  });
+
+  test("returns null when SOUL.md does not exist", () => {
+    expect(readWorkspaceGreetings()).toBeNull();
+  });
+});

package/src/agent/loop.ts

@@ -761,8 +761,10 @@ export class AgentLoop {
   /**
    * Compact the running history in place when the budget gate trips.
    *
-   * Calls the default compaction plugin on the stripped history, then
-   * re-applies injections via the supplied hooks. When `overflowSignal` is
+   * Calls the default compaction plugin, then re-applies injections via the
+   * supplied hooks. The budget path summarizes the injected `history` (so the
+   * summary call reuses the agent's warm prefix cache); overflow recovery runs
+   * on the injection-stripped history. When `overflowSignal` is
    * supplied the plugin routes through the manager's reduction ladder (which
    * advances one rung per call and reports `exhausted` / `autoCompressApplied`
    * / `injectionMode`); otherwise it runs ordinary forced compaction. Returns
@@ -795,8 +797,11 @@ export class AgentLoop {
       startedAt,
       messages: history,
     });
-    // Strip runtime injections so the compactor summarizes the raw persistent
-    // messages.
+    // Injection-stripped history for overflow recovery's reduction ladder and
+    // the post-compaction re-injection base below. The budget-path summarizer
+    // instead runs on the injected `history` so its prompt prefix matches the
+    // agent's warm prefix cache and the summary call is a cache read, not a
+    // fresh cache write.
     const rawHistory = stripInjectionsForCompaction(history);
     // Record the history-stripped marker right after stripping, before the
     // pipeline runs.
@@ -812,7 +817,7 @@ export class AgentLoop {
     // routes the request through the reduction ladder when present.
     const compactResult = await defaultCompact({
       conversationId: this.conversationId,
-      messages: rawHistory,
+      messages: overflowSignal != null ? rawHistory : history,
       signal,
       force: true,
       actorTrustClass: trust.trustClass,
@@ -1434,6 +1439,7 @@ export class AgentLoop {
             conversationId: this.conversationId,
             callSite: callSite ?? null,
             systemPrompt: providerOptions.systemPrompt ?? null,
+            modelProfile: effectiveOverrideProfile ?? null,
             deferAssistantOutput: false,
             logger: rlog,
           };
@@ -1443,6 +1449,20 @@ export class AgentLoop {
           );
           providerOptions.systemPrompt =
             finalPreModelCtx.systemPrompt ?? undefined;
+          // Route this call to the hook's chosen inference profile. The
+          // resolver layers `llm.profiles[overrideProfile]` at the top of
+          // precedence for the user-facing call, so a model router can pick
+          // the profile per message; clearing it drops any seeded override.
+          const hookModelProfile = finalPreModelCtx.modelProfile?.trim();
+          if (hookModelProfile) {
+            providerConfig.overrideProfile = hookModelProfile;
+            if (forceOverrideProfile) {
+              providerConfig.forceOverrideProfile = true;
+            }
+          } else {
+            delete providerConfig.overrideProfile;
+            delete providerConfig.forceOverrideProfile;
+          }
           // The hook owns the policy (it sees `callSite`/conversation and
           // self-gates); the loop honors whatever it decides.
           deferAssistantOutput = finalPreModelCtx.deferAssistantOutput;

package/src/api/README.md

@@ -7,7 +7,7 @@ the wire contracts the assistant exposes: schemas, types, and pure helpers.
 Internal assistant code imports the files in this directory via relative paths
 (e.g. `../../api/events/open-url.js`). External consumers import the
 materialized npm-style package `@vellumai/assistant-api`, regenerated into
-`apps/web/node_modules/` by `apps/web/scripts/postinstall.ts`.
+`clients/web/node_modules/` by `clients/web/scripts/postinstall.ts`.
 
 ## Architecture
 
@@ -72,7 +72,7 @@ a migrated event is the import and the union membership.
 
 ### 3. Cut over web consumers
 
-`apps/web/src/domains/chat/api/event-types.ts` no longer needs to list the
+`clients/web/src/domains/chat/api/event-types.ts` no longer needs to list the
 migrated event in its `AssistantEvent` union — `APIAssistantEvent` covers it.
 Drop the per-event member, leaving the union to peel off legacy entries one
 at a time as each event migrates.
@@ -85,7 +85,7 @@ import them straight from the canonical package.
 ### 4. Delete the legacy parser cases
 
 Remove the matching `case "my_event":` blocks from
-`apps/web/src/domains/chat/api/event-parser.ts`. Any per-event helper
+`clients/web/src/domains/chat/api/event-parser.ts`. Any per-event helper
 (`parseFooBase`, etc.) goes with them.
 
 ### 5. Tests
@@ -110,15 +110,15 @@ Handler-level tests in the consuming domain modules typically need no change
 Run before push, in order:
 
 ```bash
-# In apps/web — regenerate the @vellumai/assistant-api bundle
+# In clients/web — regenerate the @vellumai/assistant-api bundle
 bun run scripts/postinstall.ts
 
 # Type-check both packages
 ( cd assistant && bunx tsc --noEmit )
-( cd apps/web && bunx tsc --noEmit )
+( cd clients/web && bunx tsc --noEmit )
 
 # Targeted tests
-( cd apps/web && bun test src/domains/chat/api/event-parser.test.ts )
+( cd clients/web && bun test src/domains/chat/api/event-parser.test.ts )
 
 # Lint + format the touched files
 bunx eslint <files>

package/src/api/responses/conversation-message.ts

@@ -390,10 +390,8 @@ export const ConversationMessageSchema = z.object({
   /**
    * @deprecated Superseded by `contentBlocks`. Flat plain-text body (joined
    * text segments). Redundant with `textSegments`/`contentOrder` for clients
-   * that render from the positional arrays (web, CLI), but the legacy Swift
-   * macOS client reads `content` directly and drops any history row missing it
-   * (its `HistoryReconstructionService` skips rows with empty text). The
-   * serializer always emits it — do not remove without updating that client.
+   * that render from the positional arrays (web, CLI). The serializer always
+   * emits it — do not remove without auditing clients that read it directly.
    */
   content: z
     .string()

package/src/api/responses/home.ts

@@ -12,10 +12,6 @@
  * generator, and the web/CLI clients all derive from one source and cannot
  * drift.
  *
- * A structurally compatible Swift mirror lives at
- * `clients/shared/Network/FeedItem.swift`. Any change to the feed-item
- * shape must be mirrored there.
- *
  * Canonical wire-contract source. Assistant code imports the types
  * directly from this file via relative paths; external consumers
  * (web client, gateway, evals) import via `@vellumai/assistant-api`.

package/src/approvals/guardian-request-resolvers.ts

@@ -373,7 +373,7 @@ const accessRequestResolver: GuardianRequestResolver = {
     const requesterContactResult = requesterExternalUserId
       ? findContactChannel({
           channelType: channel,
-          externalUserId: requesterExternalUserId,
+          address: requesterExternalUserId,
         })
       : null;
     const requesterDisplayName =
@@ -382,7 +382,7 @@ const accessRequestResolver: GuardianRequestResolver = {
     const decidedByContactResult = decidedByExternalUserId
       ? findContactChannel({
           channelType: channel,
-          externalUserId: decidedByExternalUserId,
+          address: decidedByExternalUserId,
         })
       : null;
     const decidedByDisplayName =

package/src/calls/relay-access-wait.ts

@@ -249,7 +249,7 @@ export function emitAccessRequestCallbackHandoff(
     try {
       const contactResult = findContactChannel({
         channelType: "phone",
-        externalUserId: fromNumber,
+        address: fromNumber,
         externalChatId: fromNumber,
       });
       if (

package/src/calls/voice-session-bridge.ts

@@ -553,8 +553,8 @@ export async function startVoiceTurn(
     } else if (msg.type === "secret_request") {
       if (usesLocalInteractiveApprovals) {
         // Local live voice runs alongside the desktop client, which has a
-        // secret-entry UI (SecretPromptManager). Forward the broadcast and
-        // let the prompter's existing registration handle the response.
+        // secret-entry UI. Forward the broadcast and let the prompter's
+        // existing registration handle the response.
         broadcastMessage(msg);
         return;
       }

package/src/cli/commands/plugins.ts

@@ -10,6 +10,11 @@
 import type { Command } from "commander";
 
 import { confirmPrompt } from "../lib/confirm-prompt.js";
+import {
+  diffPlugin,
+  type PluginDiffResult,
+  PluginDiffUnavailableError,
+} from "../lib/diff-plugin.js";
 import {
   inspectPlugin,
   type PluginInspection,
@@ -35,8 +40,13 @@ import {
   uninstallPlugin,
 } from "../lib/uninstall-plugin.js";
 import {
+  DEFAULT_PLUGIN_UPGRADE_STRATEGY,
+  PLUGIN_UPGRADE_STRATEGIES,
+  PluginMergeBaselineError,
   PluginNotUpgradableError,
   type PluginUpgradeResult,
+  type PluginUpgradeStrategy,
+  PluginUpgradeStrategyUnsupportedError,
   upgradePlugin,
 } from "../lib/upgrade-plugin.js";
 import { getCliLogger } from "../logger.js";
@@ -60,8 +70,12 @@ Examples:
   $ assistant plugins list --json
   $ assistant plugins inspect example
   $ assistant plugins inspect example --json
+  $ assistant plugins diff example
+  $ assistant plugins diff example --json
   $ assistant plugins upgrade example
   $ assistant plugins upgrade example --dry-run
+  $ assistant plugins upgrade example --strategy ours
+  $ assistant plugins upgrade example --strategy theirs
   $ assistant plugins search example
   $ assistant plugins search "^example"
   $ assistant plugins search example --json
@@ -212,6 +226,73 @@ Examples:
           }
         });
 
+      plugins
+        .command("diff <name>")
+        .description(
+          "Show a unified diff of local edits to an installed plugin against the commit it was installed at",
+        )
+        .option(
+          "--json",
+          "Emit the machine-readable diff result as JSON (files: { path, status, diff, binary, reconstructed }[]) instead of a unified diff",
+        )
+        .addHelpText(
+          "after",
+          `
+Arguments:
+  name   Install name (kebab-case directory under the workspace plugins dir);
+         run 'assistant plugins list' to see installed names.
+
+The baseline is the exact commit the plugin was installed at (recorded in its
+install-meta.json), re-materialized through the install pipeline — so an
+install-time adapter transform never reads as a local change. To compare
+against the marketplace's current pin instead, use 'plugins upgrade --dry-run'.
+
+Examples:
+  $ assistant plugins diff example
+  $ assistant plugins diff example --json`,
+        )
+        .action(async (name: string, opts: { json?: boolean }) => {
+          try {
+            const result = await diffPlugin(
+              { name },
+              { fetch: globalThis.fetch.bind(globalThis) },
+            );
+
+            if (opts.json) {
+              process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+              return;
+            }
+
+            // Logged after the JSON early-return: the CLI logger writes
+            // info to stdout, which would otherwise corrupt --json output.
+            log.info(
+              {
+                name: result.name,
+                clean: result.clean,
+                files: result.files.length,
+              },
+              "plugin diff",
+            );
+
+            for (const line of formatDiff(result)) {
+              console.log(line);
+            }
+          } catch (err) {
+            if (
+              err instanceof PluginNotInstalledError ||
+              err instanceof PluginDiffUnavailableError ||
+              err instanceof InvalidPluginNameError
+            ) {
+              console.error(err.message);
+              process.exitCode = 1;
+              return;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`Plugin diff failed: ${message}`);
+            process.exitCode = 1;
+          }
+        });
+
       plugins
         .command("search <query>")
         .description(
@@ -327,12 +408,36 @@ Examples:
           "--dry-run",
           "Show what would change without modifying the install",
         )
+        .option(
+          "--strategy <strategy>",
+          `How to reconcile local edits with the pin: ${PLUGIN_UPGRADE_STRATEGIES.join(", ")} (default: ${DEFAULT_PLUGIN_UPGRADE_STRATEGY})`,
+        )
         .option("--json", "Emit machine-readable JSON instead of a summary")
         .action(
-          async (name: string, opts: { dryRun?: boolean; json?: boolean }) => {
+          async (
+            name: string,
+            opts: { dryRun?: boolean; strategy?: string; json?: boolean },
+          ) => {
+            const strategy = opts.strategy;
+            if (
+              strategy !== undefined &&
+              !(PLUGIN_UPGRADE_STRATEGIES as readonly string[]).includes(
+                strategy,
+              )
+            ) {
+              console.error(
+                `Invalid --strategy "${strategy}". Expected one of: ${PLUGIN_UPGRADE_STRATEGIES.join(", ")}.`,
+              );
+              process.exitCode = 1;
+              return;
+            }
             try {
               const result = await upgradePlugin(
-                { name, dryRun: opts.dryRun },
+                {
+                  name,
+                  dryRun: opts.dryRun,
+                  strategy: strategy as PluginUpgradeStrategy | undefined,
+                },
                 { fetch: globalThis.fetch.bind(globalThis) },
               );
 
@@ -360,6 +465,8 @@ Examples:
               if (
                 err instanceof PluginNotInstalledError ||
                 err instanceof PluginNotUpgradableError ||
+                err instanceof PluginUpgradeStrategyUnsupportedError ||
+                err instanceof PluginMergeBaselineError ||
                 err instanceof InvalidPluginNameError
               ) {
                 console.error(err.message);
@@ -521,14 +628,48 @@ function formatUpgrade(result: PluginUpgradeResult): string[] {
         result.fileCount === null
           ? ""
           : `(${result.fileCount} file${result.fileCount === 1 ? "" : "s"}) `;
+      const mergeNote =
+        result.strategy === "ours" || result.strategy === "theirs"
+          ? `Local edits were merged (--strategy ${result.strategy}).`
+          : null;
       const lines = [
         `Upgraded "${name}" ${move}`,
         "",
         `${count}→ ${result.target}`,
         "Restart the assistant to pick up the upgrade.",
       ];
+      if (mergeNote) lines.push(mergeNote);
       if (provenanceNote) lines.push(provenanceNote);
       return lines;
     }
   }
 }
+
+/**
+ * Render a diff result: a one-line "no local changes" when clean, otherwise a
+ * header naming the install-commit baseline followed by each file's unified
+ * diff (blank-line separated, mirroring how `git diff` stacks file patches).
+ */
+function formatDiff(result: PluginDiffResult): string[] {
+  const baseline = `${formatTimestamp(result.committedAt)} (${shortSha(result.commit)})`;
+  if (result.clean) {
+    return [
+      `"${result.name}" has no local changes (matches install commit ${baseline}).`,
+    ];
+  }
+  const count = result.files.length;
+  const lines = [
+    `"${result.name}" — ${count} file${count === 1 ? "" : "s"} changed vs install commit ${baseline}`,
+    "",
+  ];
+  for (const file of result.files) {
+    // A non-reconstructed baseline carries an explanatory marker, not a patch
+    // with `a/`–`b/` headers, so name the file it refers to.
+    if (!file.reconstructed) {
+      lines.push(`${file.path}: ${file.diff.trimEnd()}`, "");
+      continue;
+    }
+    lines.push(file.diff.trimEnd(), "");
+  }
+  return lines;
+}