@vellumai/assistant 0.10.2 → 0.10.3-dev.202606251939.1e7d8ac

package/bun.lock

@@ -38,6 +38,7 @@
         "playwright": "1.58.2",
         "postgres": "3.4.8",
         "quickjs-emscripten": "0.32.0",
+        "re2js": "2.8.3",
         "rrule": "2.8.1",
         "semver": "7.8.0",
         "stemmer": "2.0.1",
@@ -54,6 +55,7 @@
         "@types/node": "25.5.0",
         "@types/semver": "7.5.8",
         "@types/uuid": "10.0.0",
+        "@typescript/native-preview": "7.0.0-dev.20260624.1",
         "ajv": "8.18.0",
         "drizzle-kit": "0.31.10",
         "eslint": "10.0.3",
@@ -454,6 +456,22 @@
 
     "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@8.57.0", "", { "dependencies": { "@typescript-eslint/types": "8.57.0", "eslint-visitor-keys": "^5.0.0" } }, "sha512-zm6xx8UT/Xy2oSr2ZXD0pZo7Jx2XsCoID2IUh9YSTFRu7z+WdwYTRk6LhUftm1crwqbuoF6I8zAFeCMw0YjwDg=="],
 
+    "@typescript/native-preview": ["@typescript/native-preview@7.0.0-dev.20260624.1", "", { "optionalDependencies": { "@typescript/native-preview-darwin-arm64": "7.0.0-dev.20260624.1", "@typescript/native-preview-darwin-x64": "7.0.0-dev.20260624.1", "@typescript/native-preview-linux-arm": "7.0.0-dev.20260624.1", "@typescript/native-preview-linux-arm64": "7.0.0-dev.20260624.1", "@typescript/native-preview-linux-x64": "7.0.0-dev.20260624.1", "@typescript/native-preview-win32-arm64": "7.0.0-dev.20260624.1", "@typescript/native-preview-win32-x64": "7.0.0-dev.20260624.1" }, "bin": { "tsgo": "bin/tsgo.js" } }, "sha512-ogwfNo1xuAutOF8RbTCo3Ut0q/65u2ucOeHizi6O14q+3vnelNS+u8qVC2QWXubMcwtuN5E9cbfPslvGC4kdwA=="],
+
+    "@typescript/native-preview-darwin-arm64": ["@typescript/native-preview-darwin-arm64@7.0.0-dev.20260624.1", "", { "os": "darwin", "cpu": "arm64" }, "sha512-g8CqDkYCHTCYdhBHXs5cMraBurOS+KrcMFxE0SsaKZoI6Tnp+le1aWvxUBbzNKJYyThHJqb/1mLopzEJxJCuKA=="],
+
+    "@typescript/native-preview-darwin-x64": ["@typescript/native-preview-darwin-x64@7.0.0-dev.20260624.1", "", { "os": "darwin", "cpu": "x64" }, "sha512-P00JVvSV90eioYDuINAKmOSA8yhFTWLq6RvS5lrCfUuDlcgr2kSOgZAfFHIksHBVz6ZXpAXpa0dHPmc5SJ3Ymw=="],
+
+    "@typescript/native-preview-linux-arm": ["@typescript/native-preview-linux-arm@7.0.0-dev.20260624.1", "", { "os": "linux", "cpu": "arm" }, "sha512-eWHELvfQMkVRjafMd+3ATgM9p9yAergJaM4AOY8AekCNWnHFwUrp/ohh+ryyMUIqque5jjb/kuTiOiGj728I2Q=="],
+
+    "@typescript/native-preview-linux-arm64": ["@typescript/native-preview-linux-arm64@7.0.0-dev.20260624.1", "", { "os": "linux", "cpu": "arm64" }, "sha512-cppM2yTZ/Gd1hOXy8NEJcUBxJ0O0zl9CU3OU1ZWZ/OHWWX/ukEzCCr94SUwJhjIWOylBCpIYkrvYoTwxNa94XQ=="],
+
+    "@typescript/native-preview-linux-x64": ["@typescript/native-preview-linux-x64@7.0.0-dev.20260624.1", "", { "os": "linux", "cpu": "x64" }, "sha512-FaB8rS+rKYz4nDrEsHsF3b4cn7eCKCYroMJReA375OuQ6PHcmCNQ6QlVetA0dfFBxTTgejmoKyfw9xgAA5P4Yw=="],
+
+    "@typescript/native-preview-win32-arm64": ["@typescript/native-preview-win32-arm64@7.0.0-dev.20260624.1", "", { "os": "win32", "cpu": "arm64" }, "sha512-BgkqbCmSHDb5UxqWaFlFFJ/DHNT3lEUO4W8627ap6+QthJZuXk2imiHAX3PgYXC6en9fLLyR6jjcseAa4CCshg=="],
+
+    "@typescript/native-preview-win32-x64": ["@typescript/native-preview-win32-x64@7.0.0-dev.20260624.1", "", { "os": "win32", "cpu": "x64" }, "sha512-WaZ+ue63NgB2j/lqjirfevh/TqcsCxSqnKhGGiRnlxHyYIBcoq+x7KngyEnyGIaywJE1PcFeXA+2EMSIPlSEiQ=="],
+
     "@vellumai/ces-client": ["@vellumai/ces-client@file:../packages/ces-client", { "dependencies": { "@vellumai/service-contracts": "file:../service-contracts" }, "devDependencies": { "@types/bun": "1.2.4", "typescript": "5.7.3" } }],
 
     "@vellumai/credential-storage": ["@vellumai/credential-storage@file:../packages/credential-storage", { "devDependencies": { "@types/bun": "1.3.10", "typescript": "5.9.3" } }],
@@ -1040,6 +1058,8 @@
 
     "rc": ["rc@1.2.8", "", { "dependencies": { "deep-extend": "^0.6.0", "ini": "~1.3.0", "minimist": "^1.2.0", "strip-json-comments": "~2.0.1" }, "bin": { "rc": "./cli.js" } }, "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw=="],
 
+    "re2js": ["re2js@2.8.3", "", {}, "sha512-lUKeXVwMqU302DM/WaOm33XF2hhzjGUZ8CbLg4zSAMpW2PPkJ2+is25AROevNiw+DytFmKU5gsQ92cB1Kxy+fA=="],
+
     "readable-stream": ["readable-stream@2.3.8", "", { "dependencies": { "core-util-is": "~1.0.0", "inherits": "~2.0.3", "isarray": "~1.0.0", "process-nextick-args": "~2.0.0", "safe-buffer": "~5.1.1", "string_decoder": "~1.1.1", "util-deprecate": "~1.0.1" } }, "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA=="],
 
     "real-require": ["real-require@0.2.0", "", {}, "sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg=="],

package/docs/workspace-tools.md

@@ -5,9 +5,9 @@ add a brand-new one) by dropping a single file under their
 `<workspaceDir>/tools/` directory. The override survives assistant restarts,
 takes effect during the same startup phase as core tool initialization,
 and is recoverable: removing the file restores the original core behavior.
-When the `workspace-tools-watcher` feature flag is enabled, overrides are
-also hot-reloaded by a filesystem watcher (no restart required after the
-initial boot).
+Overrides are reconciled from disk on every conversation read, so edits
+under `tools/` take effect on the next conversation with no restart and no
+filesystem watcher.
 
 This page explains the file convention, lifecycle position, and the
 "single canonical source per name" invariant the design is built around.
@@ -100,8 +100,8 @@ Workspace tools are the highest-priority origin in the tool registry:
 
 - **Same name as a core tool** → the original core tool is moved into an
   internal stash (`getCoreToolOverride(name)`) and the workspace tool takes
-  its place. Removing the workspace file causes the watcher to restore
-  the original — workspace tools are not destructive to the core baseline.
+  its place. Removing the workspace file restores the original on the next
+  reconcile — workspace tools are not destructive to the core baseline.
 - **Brand-new name** → registers as a net-new entry. No stash.
 - **`<name>.removed` sentinel for a core tool** → the core tool is
   stripped (stashed in the same map as override-style stashing) and no
@@ -128,35 +128,44 @@ on the incoming tool.
 
 ```
 initializeTools()             # core tools register
-  → loadWorkspaceTools()      # initial workspace tool scan
+  → loadWorkspaceTools()      # initial workspace tool reconcile
     → MCP tool registration
     → loadUserPlugins()
     → bootstrapPlugins()
 
-# after providers-setup completes:
-DaemonServer.start()
-  → WorkspaceToolsWatcher.getInstance().start()   # hot register/unregister via fs.watch
+# on every conversation turn (createResolveToolsCallback):
+resolveTools(history)
+  → loadWorkspaceTools()                # reconcile registry against disk (fire-and-forget)
+  → getWorkspaceToolDefinitions()       # re-read workspace tools from the registry
+  → getMcpToolDefinitions()             # re-read MCP tools (same pattern)
 ```
 
 Workspace tools register _after_ core tools and _before_ every other
-extension surface during the initial scan so that every subsequent
-registration sees the workspace tool as already-owned. The initial scan
-(`loadWorkspaceTools()`) always runs, so workspace tools load from disk
-at every boot regardless of the flag.
-
-The filesystem watcher is gated on the `workspace-tools-watcher` feature
-flag (default off). When enabled, it runs for the lifetime of the
-assistant, picking up add/change/delete events on `<workspaceDir>/tools/`
-and reconciling the registry without requiring a restart. When disabled,
-no watch loop is mounted and live edits to `<workspaceDir>/tools/` take
-effect only on the next daemon restart. The flag is read at startup, so
-toggling it takes effect on restart rather than mid-process.
-
-The watcher debounces per filename stem and reconciles by re-deriving
-the world from disk ("given what's on disk right now for `<stem>.*`,
-what registry state should the assistant be in?") rather than routing
-on `fs.watch`'s unreliable add/change/rename event types. This is the
-same eventual-consistency pattern the plugin source watcher uses.
+extension surface during the initial reconcile so that every subsequent
+registration sees the workspace tool as already-owned. The initial
+reconcile always runs at boot, so workspace tools load from disk at every
+startup.
+
+There is no filesystem watcher. Instead, `loadWorkspaceTools()` is
+idempotent and is re-invoked by the per-turn tool resolver
+(`createResolveToolsCallback`), which then re-reads workspace tools from
+the registry the same way it re-reads MCP tools. Each reconcile re-derives
+the world from disk ("given what's on disk right now under `tools/`, what
+registry state should the assistant be in?") and applies the delta —
+registering added files, re-importing changed files, unregistering deleted
+files, and restoring core tools whose `.removed` sentinel was deleted. A
+conversation therefore picks up on-disk edits on its next turn, with no
+restart and without being recreated.
+
+The reconcile is fire-and-forget and eventually consistent: an edit lands
+in the registry during one turn's reconcile and is read on a subsequent
+turn. Unchanged files are skipped via an mtime cache, so a no-op reconcile
+costs one `readdir` plus a `stat` per file and never re-imports. Concurrent
+callers coalesce onto a single in-flight reconcile so their
+unregister/register sequences never interleave. This is the same
+eventual-consistency, re-derive-from-disk approach the plugin loader's
+mtime cache uses, with the per-turn tool read — rather than a watcher —
+kicking the reconcile.
 
 ## Per-tool isolation
 
@@ -182,15 +191,15 @@ the whole call without partially populating the registry.
 
 ## Unregistering
 
-Deleting `<workspaceDir>/tools/<name>.{ts,js,json}` triggers the file
-watcher's reconcile, which calls `unregisterWorkspaceTool(name)` and
-restores the stashed core tool when one exists, or simply deletes the
-entry when the workspace tool was net-new. No assistant restart is
-required.
+Deleting `<workspaceDir>/tools/<name>.{ts,js,json}` is picked up by the
+next reconcile, which calls `unregisterWorkspaceTool(name)` and restores
+the stashed core tool when one exists, or simply deletes the entry when
+the workspace tool was net-new. The change takes effect on the next
+conversation — no assistant restart is required.
 
 To strip a core tool without substituting a replacement, drop an empty
 `<workspaceDir>/tools/<name>.removed` file. Removing that sentinel
 restores the core tool on the next reconcile. The two states (override
 vs. strip) are mutually exclusive — placing both `<name>.ts` and
-`<name>.removed` for the same stem causes the watcher to tear down
+`<name>.removed` for the same stem causes the reconcile to tear down
 both states until the conflict is resolved on disk.

package/eslint-rules/cli-no-daemon-internals.js

@@ -51,11 +51,17 @@ const ALLOWED_PREFIXES = {
     "../../config/schema",
     "../../config/env",
     "../../util/platform",
+    "../../../util/platform",
     // Memory retrospective — the retrospective CLI runs the fork-based
     // retrospective in-process (no daemon, no IPC), so it imports the
     // job handler directly. Depth-2 for commands/memory/ nesting.
     "../../memory/memory-retrospective-job",
     "../../../memory/memory-retrospective-job",
+    // Memory worker control — the `memory worker` CLI spawns/probes/stops
+    // the worker OS process directly (no daemon, no IPC), so it imports the
+    // shared PID-file control helpers. Depth-2 for commands/memory/ nesting.
+    "../../memory/worker-control",
+    "../../../memory/worker-control",
     "../logger",
     "../output",
     "../../logger",

package/node_modules/@vellumai/gateway-client/src/__tests__/guardian-delivery-contract.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Tests for the guardian binding + delivery pull contract.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import {
+  GuardianDeliverySchema,
+  ResolveGuardianDeliveryRequestSchema,
+  type GuardianDelivery,
+} from "../guardian-delivery-contract.js";
+
+const fullGuardian: GuardianDelivery = {
+  channelType: "imessage",
+  contactId: "c1",
+  principalId: "p1",
+  displayName: "Guardian Name",
+  address: "+15555550100",
+  externalChatId: "ext-chat-1",
+  status: "active",
+  verifiedAt: 1699999999,
+};
+
+describe("ResolveGuardianDeliveryRequestSchema", () => {
+  test("parses with channelTypes", () => {
+    const req = { channelTypes: ["imessage", "sms"] };
+    expect(ResolveGuardianDeliveryRequestSchema.parse(req)).toEqual(req);
+  });
+
+  test("parses with channelTypes omitted", () => {
+    expect(ResolveGuardianDeliveryRequestSchema.parse({})).toEqual({});
+  });
+
+  test("defaults to {} when params are undefined (no-param IPC call)", () => {
+    expect(ResolveGuardianDeliveryRequestSchema.parse(undefined)).toEqual({});
+  });
+});
+
+describe("GuardianDeliverySchema", () => {
+  test("round-trips a fully-populated row", () => {
+    expect(GuardianDeliverySchema.parse(fullGuardian)).toEqual(fullGuardian);
+  });
+
+  test("requires channelType", () => {
+    const { channelType: _omit, ...rest } = fullGuardian;
+    expect(() => GuardianDeliverySchema.parse(rest)).toThrow();
+  });
+
+  test("requires contactId", () => {
+    const { contactId: _omit, ...rest } = fullGuardian;
+    expect(() => GuardianDeliverySchema.parse(rest)).toThrow();
+  });
+
+  test("requires address", () => {
+    const { address: _omit, ...rest } = fullGuardian;
+    expect(() => GuardianDeliverySchema.parse(rest)).toThrow();
+  });
+
+  test("requires status", () => {
+    const { status: _omit, ...rest } = fullGuardian;
+    expect(() => GuardianDeliverySchema.parse(rest)).toThrow();
+  });
+
+  test("optional fields accept null", () => {
+    const row = {
+      channelType: "imessage",
+      contactId: "c1",
+      address: "+15555550100",
+      status: "active",
+      principalId: null,
+      displayName: null,
+      externalChatId: null,
+      verifiedAt: null,
+    } satisfies GuardianDelivery;
+    expect(GuardianDeliverySchema.parse(row)).toEqual(row);
+  });
+
+  test("optional fields accept undefined (omitted)", () => {
+    const row = {
+      channelType: "imessage",
+      contactId: "c1",
+      address: "+15555550100",
+      status: "active",
+    } satisfies GuardianDelivery;
+    const parsed = GuardianDeliverySchema.parse(row);
+    expect(parsed.principalId).toBeUndefined();
+    expect(parsed.displayName).toBeUndefined();
+    expect(parsed.externalChatId).toBeUndefined();
+    expect(parsed.verifiedAt).toBeUndefined();
+  });
+});

package/node_modules/@vellumai/gateway-client/src/__tests__/trust-verdict-contract.test.ts

@@ -7,6 +7,7 @@ import { describe, expect, test } from "bun:test";
 
 import { SourceMetadataSchema } from "../inbound-contract.js";
 import {
+  makeResolutionFailedVerdict,
   TrustVerdictSchema,
   type TrustVerdict,
 } from "../trust-verdict-contract.js";
@@ -43,6 +44,36 @@ describe("TrustVerdictSchema", () => {
     expect(TrustVerdictSchema.parse(minimal)).toEqual(minimal);
   });
 
+  test("parses a verdict carrying resolutionFailed", () => {
+    const verdict = {
+      trustClass: "unknown",
+      canonicalSenderId: null,
+      resolutionFailed: true,
+    } satisfies TrustVerdict;
+    expect(TrustVerdictSchema.parse(verdict)).toEqual(verdict);
+  });
+
+  test("leaves resolutionFailed undefined when absent", () => {
+    const parsed = TrustVerdictSchema.parse({
+      trustClass: "unknown",
+      canonicalSenderId: null,
+    });
+    expect(parsed.resolutionFailed).toBeUndefined();
+  });
+
+  test("makeResolutionFailedVerdict builds an unknown sentinel", () => {
+    expect(makeResolutionFailedVerdict("+15555550100")).toEqual({
+      trustClass: "unknown",
+      canonicalSenderId: "+15555550100",
+      resolutionFailed: true,
+    });
+    expect(makeResolutionFailedVerdict(null)).toEqual({
+      trustClass: "unknown",
+      canonicalSenderId: null,
+      resolutionFailed: true,
+    });
+  });
+
   test("rejects an invalid trustClass", () => {
     expect(() =>
       TrustVerdictSchema.parse({

package/node_modules/@vellumai/gateway-client/src/gateway-ipc-contracts.ts

@@ -137,6 +137,50 @@ export type MarkChannelVerifiedIpcResponse = z.infer<
   typeof MarkChannelVerifiedIpcResponseSchema
 >;
 
+export const UpsertVerifiedChannelIpcParamsSchema = z.object({
+  type: z.string().min(1),
+  address: z.string().min(1),
+  externalChatId: z.string().min(1),
+  displayName: z.string().optional(),
+  username: z.string().optional(),
+  // Audit source for the verification. Free text (DB column is text) so the
+  // invite-activation path can pass "invite"; do not narrow to an enum.
+  verifiedVia: z.string().optional(),
+  // Target contact to bind the channel to (invite redemption). When set, an
+  // existing channel for the same (type,address) under a different contact is
+  // reassigned to this contact, mirroring the assistant's
+  // reassignConflictingChannels.
+  contactId: z.string().min(1).optional(),
+  // Relax the revoked refusal guard so a valid invite can reactivate a revoked
+  // member. Blocked actors are refused regardless.
+  allowRevokedReactivation: z.boolean().optional(),
+});
+
+export type UpsertVerifiedChannelIpcParams = z.infer<
+  typeof UpsertVerifiedChannelIpcParamsSchema
+>;
+
+export const UpsertVerifiedChannelIpcResponseSchema = z.object({
+  ok: z.boolean(),
+  verified: z.boolean(),
+  // Present only when verified — a blocked/revoked skip omits the channel.
+  channel: z
+    .object({
+      id: z.string(),
+      contactId: z.string(),
+      type: z.string(),
+      address: z.string(),
+      status: z.string(),
+      verifiedAt: z.number().nullable(),
+      verifiedVia: z.string().nullable(),
+    })
+    .optional(),
+});
+
+export type UpsertVerifiedChannelIpcResponse = z.infer<
+  typeof UpsertVerifiedChannelIpcResponseSchema
+>;
+
 export const MarkChannelRevokedIpcParamsSchema = z.object({
   contactChannelId: z.string().min(1),
   // Audit reason for the downgrade. The verification-revoke flow passes

package/node_modules/@vellumai/gateway-client/src/guardian-delivery-contract.ts

@@ -0,0 +1,48 @@
+/**
+ * Shared contract for the gateway-owned guardian binding + delivery pull.
+ *
+ * The gateway resolves the active guardian binding(s) and their per-channel
+ * delivery endpoints from its DB; the daemon pulls them via the
+ * `resolve_guardian_delivery` IPC route. INFO (notes / userFile) is NOT
+ * carried here — the daemon joins it locally by `contactId`.
+ */
+
+import { z } from "zod";
+
+/**
+ * IPC request for `resolve_guardian_delivery`. `channelTypes` is an optional
+ * filter; omitted ⇒ all active guardian channels.
+ */
+export const ResolveGuardianDeliveryRequestSchema = z
+  .object({
+    channelTypes: z.array(z.string()).optional(),
+  })
+  .default({});
+
+export type ResolveGuardianDeliveryRequest = z.infer<
+  typeof ResolveGuardianDeliveryRequestSchema
+>;
+
+/**
+ * One active guardian binding + delivery endpoint for a single channel.
+ */
+export const GuardianDeliverySchema = z.object({
+  channelType: z.string(),
+  contactId: z.string(),
+  principalId: z.string().nullable().optional(),
+  displayName: z.string().nullable().optional(),
+  address: z.string(),
+  externalChatId: z.string().nullable().optional(),
+  status: z.string(),
+  verifiedAt: z.number().nullable().optional(),
+});
+
+export type GuardianDelivery = z.infer<typeof GuardianDeliverySchema>;
+
+export const ResolveGuardianDeliveryResponseSchema = z.object({
+  guardians: z.array(GuardianDeliverySchema),
+});
+
+export type ResolveGuardianDeliveryResponse = z.infer<
+  typeof ResolveGuardianDeliveryResponseSchema
+>;

package/node_modules/@vellumai/gateway-client/src/index.ts

@@ -73,6 +73,7 @@ export type { AdmissionPolicy } from "./admission-policy-contract.js";
 
 // Trust verdict contract (gateway → daemon) — Zod schemas + derived types
 export {
+  makeResolutionFailedVerdict,
   ResolveInboundTrustRequestSchema,
   TRUST_CLASS_VALUES,
   TrustClassSchema,
@@ -84,3 +85,16 @@ export type {
   TrustClass,
   TrustVerdict,
 } from "./trust-verdict-contract.js";
+
+// Guardian delivery contract (daemon → gateway pull) — Zod schemas + derived types
+export {
+  GuardianDeliverySchema,
+  ResolveGuardianDeliveryRequestSchema,
+  ResolveGuardianDeliveryResponseSchema,
+} from "./guardian-delivery-contract.js";
+
+export type {
+  GuardianDelivery,
+  ResolveGuardianDeliveryRequest,
+  ResolveGuardianDeliveryResponse,
+} from "./guardian-delivery-contract.js";

package/node_modules/@vellumai/gateway-client/src/trust-verdict-contract.ts

@@ -42,6 +42,11 @@ export const TrustVerdictSchema = z.object({
   trustClass: TrustClassSchema,
   canonicalSenderId: z.string().nullable(),
 
+  // Present+true ⇒ gateway attempted resolution but failed (DB error);
+  // consumer treats it as "could not vouch", distinct from a real `unknown`
+  // stranger.
+  resolutionFailed: z.boolean().optional(),
+
   // Guardian binding — present only when a guardian binding matches.
   guardianExternalUserId: z.string().optional(),
   guardianDeliveryChatId: z.string().nullable().optional(),
@@ -63,6 +68,18 @@ export const TrustVerdictSchema = z.object({
 
 export type TrustVerdict = z.infer<typeof TrustVerdictSchema>;
 
+/**
+ * Sentinel for a gateway resolver failure; consumers treat it as
+ * could-not-vouch (distinct from a real `unknown` stranger). Takes the
+ * already-canonicalized sender id so this module stays free of the gateway's
+ * canonicalization util.
+ */
+export function makeResolutionFailedVerdict(
+  canonicalSenderId: string | null,
+): TrustVerdict {
+  return { trustClass: "unknown", canonicalSenderId, resolutionFailed: true };
+}
+
 /**
  * IPC request for `resolve_inbound_trust`. Per-actor identity keys the
  * gateway resolver needs to classify the inbound sender. The response reuses

package/node_modules/@vellumai/service-contracts/package.json

@@ -6,6 +6,7 @@
   "type": "module",
   "exports": {
     ".": "./src/index.ts",
+    "./channels": "./src/channels.ts",
     "./credential-rpc": "./src/credential-rpc.ts",
     "./ingress": "./src/ingress.ts",
     "./twilio-ingress": "./src/twilio-ingress.ts",

package/node_modules/@vellumai/service-contracts/src/__tests__/channels.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+
+import { CHANNEL_IDS, isChannelId } from "../channels.js";
+
+describe("isChannelId", () => {
+  test("accepts every canonical channel id", () => {
+    for (const id of CHANNEL_IDS) {
+      expect(isChannelId(id)).toBe(true);
+    }
+  });
+
+  test("includes the internal channels no external surface ingresses", () => {
+    // `platform` (control plane) and `vellum` (native app) are part of the
+    // canonical vocabulary even though the gateway never ingresses them. The
+    // gateway's narrower list is a compile-time-asserted subset of this set,
+    // so these must remain canonical for that assertion to mean anything.
+    expect(isChannelId("platform")).toBe(true);
+    expect(isChannelId("vellum")).toBe(true);
+  });
+
+  test("rejects unknown strings and non-string values", () => {
+    expect(isChannelId("discord")).toBe(false);
+    expect(isChannelId("")).toBe(false);
+    expect(isChannelId(undefined)).toBe(false);
+    expect(isChannelId(null)).toBe(false);
+    expect(isChannelId(42)).toBe(false);
+  });
+});

package/node_modules/@vellumai/service-contracts/src/channels.ts

@@ -0,0 +1,41 @@
+/**
+ * Canonical channel-id vocabulary shared between the assistant daemon and the
+ * gateway.
+ *
+ * A "channel" is an external messaging surface an actor can reach the
+ * assistant through (Slack, Telegram, WhatsApp, phone, …) plus a couple of
+ * internal ids (`vellum` for native app conversations, `platform` for the
+ * internal control plane). This is the single source of truth for that set:
+ * the assistant adopts it wholesale as its `ChannelId`, and the gateway
+ * asserts its own (narrower) inbound list is a subset of it so the two sides
+ * cannot silently drift.
+ *
+ * Both packages depend on `@vellumai/service-contracts`, so hoisting the set
+ * here (rather than maintaining a copy on each side) means adding or renaming
+ * a channel happens in exactly one place.
+ *
+ * Note that a consumer may legitimately handle only a *subset* of these — the
+ * gateway, for example, never ingresses `platform`. Use a local list guarded
+ * by `satisfies readonly ChannelId[]` for those cases rather than redefining
+ * the union.
+ */
+
+export const CHANNEL_IDS = [
+  "telegram",
+  "phone",
+  "vellum",
+  "whatsapp",
+  "slack",
+  "email",
+  "platform",
+  "a2a",
+] as const;
+
+export type ChannelId = (typeof CHANNEL_IDS)[number];
+
+export function isChannelId(value: unknown): value is ChannelId {
+  return (
+    typeof value === "string" &&
+    (CHANNEL_IDS as readonly string[]).includes(value)
+  );
+}

package/node_modules/@vellumai/service-contracts/src/index.ts

@@ -18,6 +18,7 @@
  * module so that both sides can depend on it without circular references.
  */
 
+export * from "./channels.js";
 export * from "./transport.js";
 export * from "./error.js";
 export * from "./handles.js";