@vellumai/assistant 0.10.1 → 0.10.2-dev.202606241651.2d2b40d

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/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/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Vellum Assistant API
-  version: 0.10.1
+  version: 0.10.2
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821
@@ -3973,6 +3973,8 @@ paths:
                           anyOf:
                             - type: string
                             - type: "null"
+                        resolutionFailed:
+                          type: boolean
                         guardianExternalUserId:
                           type: string
                         guardianDeliveryChatId:
@@ -14709,6 +14711,12 @@ paths:
                   type: string
                 disabled:
                   type: boolean
+                headers:
+                  type: object
+                  propertyNames:
+                    type: string
+                  additionalProperties:
+                    type: string
               required:
                 - name
                 - transportType
@@ -14936,6 +14944,14 @@ paths:
                       items:
                         type: string
                     - type: "null"
+                headers:
+                  anyOf:
+                    - type: object
+                      propertyNames:
+                        type: string
+                      additionalProperties:
+                        type: string
+                    - type: "null"
               required:
                 - name
       responses:
@@ -19605,6 +19621,56 @@ paths:
       responses:
         "200":
           description: Successful response
+  /v1/onboarding/checkin:
+    post:
+      operationId: onboarding_checkin_post
+      summary: Schedule the onboarding Day 2 check-in
+      description:
+        "Find the first open 15-minute slot between 12pm and 5pm tomorrow (widening to 8am–8pm if booked) on the
+        user's Google Calendar and create the Day 2 Check-in event. Best-effort: returns scheduled=false when no
+        calendar is connected or the calendar scope wasn't granted."
+      tags:
+        - onboarding
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                userName:
+                  type: string
+                assistantName:
+                  type: string
+                timezone:
+                  type: string
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  scheduled:
+                    type: boolean
+                  reason:
+                    type: string
+                  eventId:
+                    type: string
+                  htmlLink:
+                    anyOf:
+                      - type: string
+                      - type: "null"
+                  start:
+                    type: string
+                  end:
+                    type: string
+                  timeZone:
+                    type: string
+                required:
+                  - scheduled
+                additionalProperties: false
   /v1/pages/{appId}:
     get:
       operationId: pages_by_appId_get
@@ -25978,6 +26044,13 @@ paths:
                           type: boolean
                         messageId:
                           type: string
+                        toolUseId:
+                          type: string
+                        input:
+                          type: object
+                          propertyNames:
+                            type: string
+                          additionalProperties: {}
                       required:
                         - type
                         - content

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.1",
+  "version": "0.10.2-dev.202606241651.2d2b40d",
   "license": "MIT",
   "type": "module",
   "exports": {

package/scripts/test.sh

@@ -169,6 +169,7 @@ printf '%s\n' "${test_files[@]}" | xargs -P "${WORKERS}" -I {} bash -c '
 
   safe_name="$(echo "${test_file}" | tr "/" "_")"
   out_file="${results_dir}/${safe_name}.out"
+  base="$(basename "${test_file}")"
 
   coverage_args=""
   if [[ "${coverage_enabled}" == "true" ]]; then
@@ -185,28 +186,48 @@ printf '%s\n' "${test_files[@]}" | xargs -P "${WORKERS}" -I {} bash -c '
     timeout_cmd="gtimeout"
   fi
 
-  start_ms=$(perl -MTime::HiRes=time -e "printf \"%d\", time*1000")
-
-  if [[ -n "${timeout_cmd}" ]]; then
-    if [[ "${exclude_exp}" == "true" ]]; then
-      "${timeout_cmd}" -k 10 "${per_test_timeout}" bun test ${coverage_args} --test-name-pattern "^(?!.*\\[experimental\\])" "${test_file}" > "${out_file}" 2>&1
-    else
-      "${timeout_cmd}" -k 10 "${per_test_timeout}" bun test ${coverage_args} "${test_file}" > "${out_file}" 2>&1
-    fi
-  else
-    if [[ "${exclude_exp}" == "true" ]]; then
-      bun test ${coverage_args} --test-name-pattern "^(?!.*\\[experimental\\])" "${test_file}" > "${out_file}" 2>&1
+  # Run the test file in its own bun process. Wrapped in a function so a
+  # transient infrastructure crash can be retried without duplicating the
+  # four-way (timeout × experimental-filter) invocation.
+  run_bun_test() {
+    if [[ -n "${timeout_cmd}" ]]; then
+      if [[ "${exclude_exp}" == "true" ]]; then
+        "${timeout_cmd}" -k 10 "${per_test_timeout}" bun test ${coverage_args} --test-name-pattern "^(?!.*\\[experimental\\])" "${test_file}" > "${out_file}" 2>&1
+      else
+        "${timeout_cmd}" -k 10 "${per_test_timeout}" bun test ${coverage_args} "${test_file}" > "${out_file}" 2>&1
+      fi
     else
-      bun test ${coverage_args} "${test_file}" > "${out_file}" 2>&1
+      if [[ "${exclude_exp}" == "true" ]]; then
+        bun test ${coverage_args} --test-name-pattern "^(?!.*\\[experimental\\])" "${test_file}" > "${out_file}" 2>&1
+      else
+        bun test ${coverage_args} "${test_file}" > "${out_file}" 2>&1
+      fi
     fi
-  fi
+  }
+
+  start_ms=$(perl -MTime::HiRes=time -e "printf \"%d\", time*1000")
+
+  run_bun_test
   exit_code=$?
 
+  # Retry once on a transient bun loader/runtime crash. Bun occasionally aborts
+  # a worker before its tests run — e.g. "# Unhandled error between tests" with
+  # "error: ENOENT reading <corrupted path>" — failing the whole job even though
+  # the file is green on a clean process. Such a crash truncates the run before
+  # any assertion executes, so it prints no "(fail)" line; genuine assertion
+  # failures do, and are reported immediately without a retry (fast feedback, no
+  # masking of intermittent real failures). Timeouts (124/137) are handled by the
+  # hang branch below, not here.
+  if [[ ${exit_code} -ne 0 && ${exit_code} -ne 124 && ${exit_code} -ne 137 ]] \
+     && ! grep -q "^(fail)" "${out_file}" 2>/dev/null; then
+    echo "  ↻ ${base} (transient crash, exit ${exit_code} — retrying once)"
+    run_bun_test
+    exit_code=$?
+  fi
+
   end_ms=$(perl -MTime::HiRes=time -e "printf \"%d\", time*1000")
   elapsed=$(( end_ms - start_ms ))
 
-  base="$(basename "${test_file}")"
-
   # Record duration for longest-first scheduling in future runs.
   # Write the repo-relative path (not the basename) so the lookup in future
   # runs disambiguates files that share a basename across directories.