@vellumai/assistant 0.11.2-dev.202608060701.ede4331 → 0.11.2-dev.202608062308.5442cf1

package/node_modules/@vellumai/ces-client/node_modules/@vellumai/service-contracts/src/remote-web-pairing.ts

@@ -21,6 +21,12 @@
  * `Date#toISOString()`.
  */
 
+/**
+ * Pairing-challenge TTL in milliseconds (10 minutes): the gateway's challenge
+ * store enforces it and the `vellum pair` CLI renders it in user-facing copy.
+ */
+export const REMOTE_WEB_PAIRING_CODE_TTL_MS = 10 * 60 * 1000;
+
 /** `POST /v1/remote-web/pairing-challenge` request body. */
 export interface RemoteWebPairingChallengeRequest {
   /** Public https base URL the scanning device can reach the assistant at. */

package/node_modules/@vellumai/environments/package.json

@@ -5,7 +5,8 @@
   "license": "MIT",
   "type": "module",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./seeds": "./src/seeds.ts"
   },
   "scripts": {
     "typecheck": "bunx tsc --noEmit",

package/node_modules/@vellumai/environments/src/__tests__/cloud-assistant-hub-url.test.ts

@@ -0,0 +1,38 @@
+/**
+ * Pins the environment-to-cloud-hub mapping in one place. Both consumers
+ * (the Capacitor shell's `server.url` and the CLI remote-web edge's
+ * `hubUrl`) read this helper, so this matrix is the single behavioral pin
+ * for the served URLs.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { cloudAssistantHubUrl, SEEDS } from "../index.js";
+
+describe("cloudAssistantHubUrl", () => {
+  test("cloud environments resolve to their own web origin", () => {
+    expect(cloudAssistantHubUrl("production")).toBe(
+      "https://www.vellum.ai/assistant",
+    );
+    expect(cloudAssistantHubUrl("staging")).toBe(
+      "https://staging-assistant.vellum.ai/assistant",
+    );
+  });
+
+  test("every other environment falls back to the dev SPA", () => {
+    for (const name of ["dev", "test", "local", "unknown-env", undefined]) {
+      expect(cloudAssistantHubUrl(name)).toBe(
+        "https://dev-assistant.vellum.ai/assistant",
+      );
+    }
+  });
+
+  test("cloud hub URLs derive from the seed web URLs", () => {
+    for (const name of ["production", "staging"]) {
+      expect(cloudAssistantHubUrl(name)).toBe(
+        `${SEEDS[name].webUrl}/assistant`,
+      );
+    }
+    expect(cloudAssistantHubUrl("local")).toBe(`${SEEDS.dev.webUrl}/assistant`);
+  });
+});

package/node_modules/@vellumai/environments/src/seeds.ts

@@ -24,6 +24,35 @@ function portBlock(base: number): PortMap {
   };
 }
 
+/**
+ * Base URL of the cloud-hosted assistant SPA (the "hub") for a deployment
+ * environment. The Capacitor mobile shell bakes this into native builds as
+ * `server.url`, and the CLI's remote-web edge stamps it into the served
+ * config as `hubUrl`, so the environment-to-hub mapping lives here exactly
+ * once.
+ *
+ * Only the cloud deployments (production, staging) serve the hosted SPA at
+ * their own web origin; every other environment (dev, test, local, unknown)
+ * falls back to the dev SPA, whose host serves remote clients that cannot
+ * reach a local or per-developer web URL.
+ *
+ * The `/assistant` suffix is deliberate: booting on the bare host lands on
+ * the marketing page, whose CTA redirects to `www.vellum.ai/assistant` and
+ * bounces non-prod shells off their own host.
+ *
+ * NOTE: this module is loaded by Capacitor's single-file TS config loader
+ * (via the `@vellumai/environments/seeds` subpath), which cannot follow the
+ * package index's `.js`-suffixed runtime re-exports. Keep this file's
+ * imports type-only so it stays loadable on its own.
+ */
+export function cloudAssistantHubUrl(envName: string | undefined): string {
+  const seed =
+    envName === "production" || envName === "staging"
+      ? SEEDS[envName]
+      : SEEDS.dev;
+  return `${seed.webUrl}/assistant`;
+}
+
 /**
  * Built-in environment definitions and the source of truth for the
  * set of known environment names.

package/node_modules/@vellumai/gateway-client/node_modules/@vellumai/service-contracts/src/remote-web-pairing.ts

@@ -21,6 +21,12 @@
  * `Date#toISOString()`.
  */
 
+/**
+ * Pairing-challenge TTL in milliseconds (10 minutes): the gateway's challenge
+ * store enforces it and the `vellum pair` CLI renders it in user-facing copy.
+ */
+export const REMOTE_WEB_PAIRING_CODE_TTL_MS = 10 * 60 * 1000;
+
 /** `POST /v1/remote-web/pairing-challenge` request body. */
 export interface RemoteWebPairingChallengeRequest {
   /** Public https base URL the scanning device can reach the assistant at. */

package/node_modules/@vellumai/ipc-server-utils/src/endpoint.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { removeIpcEndpointFile, resolveIpcEndpoint } from "./endpoint.js";
+const windowsEndpoint = (name: string, workspaceDir: string) => resolveIpcEndpoint(name, { workspaceDir, platform: "win32" });
+describe("resolveIpcEndpoint", () => {
+  test("keeps long POSIX fallbacks deterministic and bounded", () => {
+    const options = {
+      workspaceDir: `/tmp/${"a".repeat(120)}`,
+      platform: "darwin" as const,
+    };
+    const endpoint = resolveIpcEndpoint("assistant", options);
+    expect(resolveIpcEndpoint("assistant", options)).toEqual(endpoint);
+    expect(Buffer.byteLength(endpoint.path)).toBeLessThanOrEqual(103);
+  });
+  test("returns normalized, isolated, bounded Windows pipes", () => {
+    const first = windowsEndpoint("assistant", "C:\\one");
+    expect(resolveIpcEndpoint("assistant", { workspaceDir: "c:\\ONE\\", platform: "win32", env: { ASSISTANT_IPC_SOCKET_DIR: "C:\\ignored" } })).toEqual(first);
+    expect(first.path.length).toBeLessThanOrEqual(256);
+    expect(windowsEndpoint("assistant", "C:\\two").path).not.toBe(first.path);
+    expect(windowsEndpoint("gateway", "C:\\one").path).not.toBe(first.path);
+  });
+  test("cleans socket files but skips named pipes", () => {
+    const dir = mkdtempSync(join(tmpdir(), "vellum-ipc-cleanup-"));
+    const socketPath = join(dir, "assistant.sock");
+    try {
+      writeFileSync(socketPath, "stale");
+      removeIpcEndpointFile(socketPath);
+      expect(existsSync(socketPath)).toBe(false);
+      removeIpcEndpointFile("\\\\.\\pipe\\vellum-assistant-test");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/node_modules/@vellumai/ipc-server-utils/src/endpoint.ts

@@ -0,0 +1,142 @@
+import { createHash } from "node:crypto";
+import { unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { posix, win32 } from "node:path";
+
+const DARWIN_UNIX_SOCKET_MAX_PATH_BYTES = 103;
+const DEFAULT_UNIX_SOCKET_MAX_PATH_BYTES = 107;
+const IPC_TMP_DIR_NAME = "vellum-ipc";
+const join = posix.join;
+
+export type IpcSocketPathSource =
+  | "env-override"
+  | "workspace"
+  | "tmp-hash"
+  | "tmp-short-hash"
+  | "windows-named-pipe";
+
+export interface IpcSocketPathResolution {
+  path: string;
+  source: IpcSocketPathSource;
+}
+
+export interface IpcEndpointOptions {
+  workspaceDir: string;
+  env?: Record<string, string | undefined>;
+  platform?: NodeJS.Platform;
+}
+
+function getUnixSocketMaxPathBytes(platform: NodeJS.Platform): number {
+  return platform === "darwin"
+    ? DARWIN_UNIX_SOCKET_MAX_PATH_BYTES
+    : DEFAULT_UNIX_SOCKET_MAX_PATH_BYTES;
+}
+
+function isPathWithinSocketLimit(path: string, maxPathBytes: number): boolean {
+  return Buffer.byteLength(path, "utf8") <= maxPathBytes;
+}
+
+/**
+ * Derive the env var name and socket filename from a socket name.
+ *
+ * Examples (hyphens in the name become underscores in the env var):
+ */
+function deriveSocketNames(socketName: string): {
+  envVar: string;
+  fileName: string;
+} {
+  if (!/^[a-z][a-z0-9-]{0,63}$/.test(socketName)) {
+    throw new Error(`Invalid IPC endpoint name: ${socketName}`);
+  }
+  const envVar = `${socketName.toUpperCase().replace(/-/g, "_")}_IPC_SOCKET_DIR`;
+  const fileName = `${socketName}.sock`;
+  return { envVar, fileName };
+}
+
+function resolveWindowsNamedPipe(
+  socketName: string,
+  workspaceDir: string,
+): IpcSocketPathResolution {
+  const workspaceIdentity = win32
+    .normalize(workspaceDir)
+    .replace(/\\+$/, "")
+    .toLowerCase();
+  const hash = createHash("sha256")
+    .update(`${workspaceIdentity}\0${socketName}`)
+    .digest("hex")
+    .slice(0, 24);
+  return {
+    path: `\\\\.\\pipe\\vellum-${socketName}-${hash}`,
+    source: "windows-named-pipe",
+  };
+}
+
+export function isNamedPipePath(endpointPath: string): boolean {
+  return /^\\\\[.?]\\pipe\\/.test(endpointPath);
+}
+
+export function removeIpcEndpointFile(endpointPath: string): void {
+  if (isNamedPipePath(endpointPath)) {
+    return;
+  }
+  try {
+    unlinkSync(endpointPath);
+  } catch {
+    // Already absent.
+  }
+}
+
+/**
+ * Resolve the path to an IPC socket file.
+ *
+ * Resolution order:
+ * POSIX uses overrides, workspace paths, then bounded temporary paths.
+ * Windows uses deterministic named pipes.
+ */
+export function resolveIpcEndpoint(
+  socketName: string,
+  options: IpcEndpointOptions,
+): IpcSocketPathResolution {
+  const { envVar, fileName } = deriveSocketNames(socketName);
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") {
+    return resolveWindowsNamedPipe(socketName, options.workspaceDir);
+  }
+
+  // Explicit override via env var.
+  const envSocketDir = (options.env ?? process.env)[envVar]?.trim();
+  if (envSocketDir) {
+    return {
+      path: join(envSocketDir, fileName),
+      source: "env-override",
+    };
+  }
+
+  const maxPathBytes = getUnixSocketMaxPathBytes(platform);
+  const workspacePath = join(options.workspaceDir, fileName);
+
+  if (isPathWithinSocketLimit(workspacePath, maxPathBytes)) {
+    return {
+      path: workspacePath,
+      source: "workspace",
+    };
+  }
+
+  // Workspace path exceeds AF_UNIX limit - fall back to tmpdir.
+  const hash = createHash("sha256")
+    .update(workspacePath)
+    .digest("hex")
+    .slice(0, 12);
+  const hashedPath = join(tmpdir(), IPC_TMP_DIR_NAME, `${hash}-${fileName}`);
+  if (isPathWithinSocketLimit(hashedPath, maxPathBytes)) {
+    return {
+      path: hashedPath,
+      source: "tmp-hash",
+    };
+  }
+
+  return {
+    path: join(tmpdir(), `v-${hash}.sock`),
+    source: "tmp-short-hash",
+  };
+}

package/node_modules/@vellumai/ipc-server-utils/src/index.ts

@@ -4,6 +4,8 @@ export {
   type SocketWatchdogOptions,
   type SocketWatchdogLogger,
 } from "./socket-watchdog.js";
+export { isNamedPipePath, removeIpcEndpointFile, resolveIpcEndpoint } from "./endpoint.js";
+export { ipcListenOptions } from "./listen-options.js";
 export {
   IpcFrameReader,
   writeLegacyMessage,

package/node_modules/@vellumai/ipc-server-utils/src/listen-options.ts

@@ -0,0 +1,3 @@
+export function ipcListenOptions(path: string) {
+  return { path, readableAll: false, writableAll: false } as const;
+}

package/node_modules/@vellumai/ipc-server-utils/src/socket-watchdog.test.ts

@@ -46,6 +46,7 @@ interface TestHarness {
 
 interface BuildOptions {
   intervalMs?: number;
+  socketPathOverride?: string;
   createServerOverride?: () => Server;
   /** Override `getServer` to simulate races. */
   getServerOverride?: () => Server | null;
@@ -75,7 +76,7 @@ function buildHarness(opts: BuildOptions): TestHarness {
   };
 
   const watchdog = new SocketWatchdog({
-    socketPath,
+    socketPath: opts.socketPathOverride ?? socketPath,
     intervalMs: opts.intervalMs ?? 0,
     getServer: opts.getServerOverride ?? (() => serverRef.current),
     createServer: opts.createServerOverride ?? defaultFactory,
@@ -190,6 +191,19 @@ describe("SocketWatchdog", () => {
     expect(harness.rebinds).toHaveLength(0);
   });
 
+  test("named pipes skip filesystem watchdog behavior", async () => {
+    const server = createServer();
+    harness = buildHarness({
+      socketPathOverride: "\\\\.\\pipe\\vellum-assistant-test",
+      getServerOverride: () => server,
+      createServerOverride: () => {
+        throw new Error("must not rebind");
+      },
+    });
+    harness.spawnedServers.push(server);
+    expect(await harness.watchdog.rebindIfMissing()).toBe(false);
+  });
+
   test("rebindIfMissing recreates the listener when the path is gone", async () => {
     harness = buildHarness({});
     const initial = await startInitialServer(harness);

package/node_modules/@vellumai/ipc-server-utils/src/socket-watchdog.ts

@@ -16,6 +16,9 @@ import { existsSync, mkdirSync, unlinkSync } from "node:fs";
 import type { Server } from "node:net";
 import { dirname } from "node:path";
 
+import { isNamedPipePath } from "./endpoint.js";
+import { ipcListenOptions } from "./listen-options.js";
+
 /**
  * Minimal logger surface (pino-compatible). Each method receives a context
  * object plus an optional human-readable message.
@@ -66,6 +69,9 @@ const DEFAULT_INTERVAL_MS = 5000;
  * `mkdir` only applies the mode to directories it creates.
  */
 export function ensureSocketDir(socketPath: string): void {
+  if (isNamedPipePath(socketPath)) {
+    return;
+  }
   const socketDir = dirname(socketPath);
   if (!existsSync(socketDir)) {
     mkdirSync(socketDir, { recursive: true, mode: 0o700 });
@@ -109,7 +115,13 @@ export class SocketWatchdog {
    * watchdog is already running.
    */
   start(): void {
-    if (this.intervalMs <= 0 || this.handle !== null) return;
+    if (
+      this.intervalMs <= 0 ||
+      this.handle !== null ||
+      isNamedPipePath(this.socketPath)
+    ) {
+      return;
+    }
     this.handle = setInterval(() => {
       // The async entry path of rebindIfMissing performs filesystem work
       // (ensureSocketDir, createServer) before its inner try/catch, so a
@@ -143,6 +155,9 @@ export class SocketWatchdog {
    * is not running, or a shutdown/restart raced the rebind.
    */
   async rebindIfMissing(): Promise<boolean> {
+    if (isNamedPipePath(this.socketPath)) {
+      return false;
+    }
     const initialServer = this.getServer();
     if (initialServer === null) return false;
     if (existsSync(this.socketPath)) return false;
@@ -167,7 +182,7 @@ export class SocketWatchdog {
         };
         newServer.once("error", onError);
         newServer.once("listening", onListening);
-        newServer.listen(this.socketPath);
+        newServer.listen(ipcListenOptions(this.socketPath));
       });
     } catch (err) {
       this.log.error(

package/node_modules/@vellumai/service-contracts/src/remote-web-pairing.ts

@@ -21,6 +21,12 @@
  * `Date#toISOString()`.
  */
 
+/**
+ * Pairing-challenge TTL in milliseconds (10 minutes): the gateway's challenge
+ * store enforces it and the `vellum pair` CLI renders it in user-facing copy.
+ */
+export const REMOTE_WEB_PAIRING_CODE_TTL_MS = 10 * 60 * 1000;
+
 /** `POST /v1/remote-web/pairing-challenge` request body. */
 export interface RemoteWebPairingChallengeRequest {
   /** Public https base URL the scanning device can reach the assistant at. */

package/openapi.yaml

@@ -6772,6 +6772,9 @@ paths:
                             - messageId
                             - title
                           additionalProperties: false
+                        historyOrphaned:
+                          type: boolean
+                          const: true
                         archivedAt:
                           type: number
                         surfacedAt:
@@ -7132,6 +7135,9 @@ paths:
                           - messageId
                           - title
                         additionalProperties: false
+                      historyOrphaned:
+                        type: boolean
+                        const: true
                       archivedAt:
                         type: number
                       surfacedAt:
@@ -8342,6 +8348,9 @@ paths:
                           - messageId
                           - title
                         additionalProperties: false
+                      historyOrphaned:
+                        type: boolean
+                        const: true
                       archivedAt:
                         type: number
                       surfacedAt:
@@ -20067,8 +20076,8 @@ paths:
                   type: string
                 clientOs:
                   description:
-                    Client OS surface ("web" | "ios" | "macos" | "android"), reported separately from `interface`. Drives the
-                    per-turn `client_os` context only; does not affect transport/host-proxy capabilities.
+                    Client OS surface ("web" | "ios" | "macos" | "windows" | "android"), reported separately from `interface`.
+                    Drives the per-turn `client_os` context only; does not affect transport/host-proxy capabilities.
                   type: string
                 visibleAppId:
                   description:
@@ -25219,8 +25228,9 @@ paths:
         per conversation after activity (time/message thresholds, pre-compaction) — there is no global schedule, so
         `nextRunAt` is always null and no run-now endpoint exists. `intervalMs` is the per-conversation time threshold
         (`memory.retrospective.timeThresholdMs`), `lastRunAt` is the `createdAt` of the most recent retrospective
-        conversation across both legacy and fork sources, and `available` gates on `memory.enabled` (not
-        `memory.v2.enabled`).
+        conversation across both legacy and fork sources, `available` gates on `memory.enabled` (not
+        `memory.v2.enabled`), and `enabled` narrows that by `memory.retrospective.enabled`, the per-pass kill switch
+        that stops retrospectives without disabling the rest of memory.
       tags:
         - retrospective
       responses:
@@ -29405,6 +29415,73 @@ paths:
                   - isBinary
                   - content
                 additionalProperties: false
+  /v1/skills/{id}/history:
+    get:
+      operationId: skills_by_id_history_get
+      summary: Get skill revision history
+      description:
+        "Return a skill's recent updates, newest first, each with a combined diff across the skill directory.
+        Read-only: revisions come from the workspace git repository, which already retains prior content. Commits whose
+        only in-skill change is the `lastUsedAt` usage stamp are omitted, so entries are edits rather than loads."
+      tags:
+        - skills
+      parameters:
+        - name: id
+          in: path
+          required: true
+          schema:
+            type: string
+        - name: limit
+          in: query
+          required: false
+          schema:
+            type: integer
+          description: Maximum revisions to return, newest first. Defaults to 20 and is clamped to 100.
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  skillId:
+                    type: string
+                    description: The skill these revisions belong to
+                  revisions:
+                    type: array
+                    items:
+                      type: object
+                      properties:
+                        id:
+                          type: string
+                          description: Opaque revision identifier
+                        changedAt:
+                          type: string
+                          description: ISO-8601 time of the update
+                        files:
+                          type: array
+                          items:
+                            type: string
+                          description: Paths changed, relative to the skill directory
+                        diff:
+                          type: string
+                          description: Unified diff of this update, scoped to the skill
+                      required:
+                        - id
+                        - changedAt
+                        - files
+                        - diff
+                      additionalProperties: false
+                    description: Recent updates, newest first
+                  truncatedByCompaction:
+                    type: boolean
+                    description: Older history was squashed away, so the oldest entry is a floor rather than the skill's creation
+                required:
+                  - skillId
+                  - revisions
+                  - truncatedByCompaction
+                additionalProperties: false
   /v1/skills/{id}/inspect:
     get:
       operationId: skills_by_id_inspect_get

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.2-dev.202608060701.ede4331",
+  "version": "0.11.2-dev.202608062308.5442cf1",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-wake-disk-pressure-callsite.test.ts

@@ -88,6 +88,7 @@ function makeTarget(): Conversation {
     getTurnChannelContext: () => null,
     getTurnInterfaceContext: () => null,
     drainQueue: async () => {},
+    kickDrainQueue: async () => {},
     // Pre-run auto-compaction gate — no-op for these tests.
     maybeCompact: async () => null,
   };

package/src/__tests__/agent-wake-override-profile.test.ts

@@ -100,6 +100,7 @@ function makeTarget(): {
     getTurnChannelContext: () => null,
     getTurnInterfaceContext: () => null,
     drainQueue: async () => {},
+    kickDrainQueue: async () => {},
     // Pre-run auto-compaction gate — no-op for these tests.
     maybeCompact: async () => null,
     buildCurrentSystemPrompt: () => "mock-system-prompt",

package/src/__tests__/canned-reply-release.test.ts

@@ -0,0 +1,86 @@
+/**
+ * The canned-reply routes (canned first greeting, unknown slash command) hold
+ * the processing lock themselves and release it from a deferred callback that
+ * also publishes their client event burst. That release is the only one those
+ * turns get: no agent loop runs, so a throw escaping the burst would latch the
+ * conversation "processing" for the life of the daemon and queue every later
+ * send behind an idle conversation.
+ */
+import { describe, expect, test } from "bun:test";
+
+import type { QueueDrainReason } from "../daemon/conversation-queue-manager.js";
+import { scheduleCannedReplyRelease } from "../runtime/routes/canned-reply-release.js";
+
+function makeConversation() {
+  let processing = true;
+  const drainOrigins: string[] = [];
+  return {
+    isProcessing: () => processing,
+    drainOrigins,
+    target: {
+      setProcessing: (value: boolean) => {
+        processing = value;
+      },
+      kickDrainQueue: (_reason?: QueueDrainReason, origin?: string) => {
+        drainOrigins.push(origin ?? "");
+        return Promise.resolve();
+      },
+    },
+  };
+}
+
+/** Let the scheduled `setTimeout(..., 0)` callback run. */
+function nextTick(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+
+describe("scheduleCannedReplyRelease", () => {
+  test("releases and drains after the deferred event burst", async () => {
+    const conversation = makeConversation();
+    const order: string[] = [];
+
+    scheduleCannedReplyRelease({
+      conversation: {
+        setProcessing: (value: boolean) => {
+          order.push("release");
+          conversation.target.setProcessing(value);
+        },
+        kickDrainQueue: conversation.target.kickDrainQueue,
+      },
+      origin: "canned_greeting",
+      emit: () => {
+        order.push("emit");
+      },
+      afterRelease: () => {
+        order.push("after");
+      },
+    });
+
+    // Nothing runs synchronously: the HTTP response has to reach the client
+    // before its events do.
+    expect(order).toEqual([]);
+
+    await nextTick();
+
+    expect(order).toEqual(["emit", "release", "after"]);
+    expect(conversation.isProcessing()).toBe(false);
+    expect(conversation.drainOrigins).toEqual(["canned_greeting"]);
+  });
+
+  test("still releases and drains when a broadcast throws", async () => {
+    const conversation = makeConversation();
+
+    scheduleCannedReplyRelease({
+      conversation: conversation.target,
+      origin: "slash_command",
+      emit: () => {
+        throw new Error("broadcast exploded");
+      },
+    });
+
+    await nextTick();
+
+    expect(conversation.isProcessing()).toBe(false);
+    expect(conversation.drainOrigins).toEqual(["slash_command"]);
+  });
+});