@vellumai/assistant 0.12.2-staging.7 → 0.12.2

package/src/tools/shared/shell-output.test.ts

@@ -7,7 +7,6 @@ import {
   formatShellOutput,
   MAX_OUTPUT_LENGTH,
   OUTPUT_TRUNCATED_TAG,
-  SHELL_DID_NOT_START_MESSAGE,
 } from "./shell-output.js";
 
 describe("BoundedStdioCollector", () => {
@@ -86,15 +85,6 @@ describe("attachBoundedStdio", () => {
   });
 });
 
-describe("formatShellOutput launch start", () => {
-  test("does not report command_completed when the process never started", () => {
-    const result = formatShellOutput("", "", 0, false, 120, { started: false });
-    expect(result.isError).toBe(true);
-    expect(result.content).toBe(SHELL_DID_NOT_START_MESSAGE);
-    expect(result.content).not.toContain("<command_completed />");
-  });
-});
-
 describe("formatShellOutput truncation", () => {
   test("truncates an already-materialized oversized string without a file path", () => {
     const longOutput = "x".repeat(30_000);

package/src/tools/shared/shell-output.ts

@@ -4,9 +4,6 @@ export const MAX_OUTPUT_LENGTH = 20_000;
 
 export const OUTPUT_TRUNCATED_TAG = `<output_truncated limit="20K" />`;
 
-export const SHELL_DID_NOT_START_MESSAGE =
-  "Error: the shell command did not start. No process was created, so the command did not run.";
-
 export interface ShellOutputResult {
   content: string;
   status: string | undefined;
@@ -34,16 +31,8 @@ export function formatShellOutput(
   code: number | null,
   timedOut: boolean,
   timeoutSec: number,
-  options?: { truncated?: boolean; started?: boolean },
+  options?: { truncated?: boolean },
 ): ShellOutputResult {
-  if (options?.started === false) {
-    return {
-      content: SHELL_DID_NOT_START_MESSAGE,
-      status: undefined,
-      isError: true,
-    };
-  }
-
   let output = stdout;
   if (stderr) {
     output += (output ? "\n" : "") + stderr;
@@ -148,7 +137,6 @@ export class BoundedStdioCollector {
     code: number | null,
     timedOut: boolean,
     timeoutSec: number,
-    options?: { started?: boolean },
   ): ShellOutputResult {
     return formatShellOutput(
       Buffer.concat(this.stdoutParts).toString(),
@@ -156,7 +144,7 @@ export class BoundedStdioCollector {
       code,
       timedOut,
       timeoutSec,
-      { truncated: this.truncated, started: options?.started },
+      { truncated: this.truncated },
     );
   }
 }

package/src/tools/skills/sandbox-runner.ts

@@ -7,12 +7,9 @@ import { conversationRevealNonce } from "../../runtime/reveal-nonce.js";
 import { computeSkillVersionHash } from "../../skills/version-hash.js";
 import {
   buildShellInvocation,
-  buildShellSpawnFlags,
   terminateProcessTree,
-  watchShellProcessStart,
 } from "../../util/host-process.js";
 import { safeStringSlice } from "../../util/unicode.js";
-import { SHELL_DID_NOT_START_MESSAGE } from "../shared/shell-output.js";
 import { buildSanitizedEnv } from "../terminal/safe-env.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
 
@@ -163,9 +160,9 @@ function spawnRunner(
       cwd: runDir,
       env,
       stdio: ["ignore", "pipe", "pipe"],
-      ...buildShellSpawnFlags(),
+      detached: true,
+      windowsHide: true,
     });
-    const launch = watchShellProcessStart(child);
 
     const timer = setTimeout(() => {
       timedOut = true;
@@ -191,14 +188,6 @@ function spawnRunner(
       clearTimeout(timer);
       context.signal?.removeEventListener("abort", onAbort);
 
-      if (!launch.didStart()) {
-        resolve({
-          content: `Failed to spawn skill tool script "${executorPath}": ${SHELL_DID_NOT_START_MESSAGE}`,
-          isError: true,
-        });
-        return;
-      }
-
       if (timedOut) {
         resolve({
           content: `Skill tool script "${executorPath}" timed out after ${timeoutMs}ms`,

package/src/tools/skills/scaffold-managed.ts

@@ -134,8 +134,7 @@ function notifyBackgroundSkillUpdate(args: {
     sourceEventName: "activity.complete",
     dedupeKey: `skill-updated:${args.skillId}:${day}`,
     contextPayload: {
-      // `summary` feeds the copy composer and `title` is the headline both
-      // it and the home feed keep; `title`/`body` are also the feed's
+      // `summary` feeds the copy composer; `title`/`body` are the home feed's
       // fallback when no channel copy was rendered. Without them a fully
       // suppressed delivery (the intended shape for this signal: low urgency,
       // background, no interruption) leaves the feed writer with no summary

package/src/tools/terminal/__tests__/safe-env.test.ts

@@ -111,35 +111,6 @@ describe("safe-env Windows forwarding", () => {
     }
   });
 
-  test("prepends the Windows assistant binary directory when it sits beside the runtime", () => {
-    const dir = mkdtempSync(join(tmpdir(), "win-assistant-"));
-    writeFileSync(join(dir, "assistant.exe"), "");
-    try {
-      const env = buildSanitizedEnv(
-        "win32",
-        { Path: "C:\\Windows\\System32" },
-        { execPath: join(dir, "vellum-daemon.exe") },
-      );
-      expect(env.PATH).toBe(`${dir};C:\\Windows\\System32`);
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  test("does not invent a Windows assistant path when the sibling binary is absent", () => {
-    const dir = mkdtempSync(join(tmpdir(), "win-no-assistant-"));
-    try {
-      const env = buildSanitizedEnv(
-        "win32",
-        { Path: "C:\\Windows\\System32" },
-        { execPath: join(dir, "vellum-daemon.exe") },
-      );
-      expect(env.PATH).toBe("C:\\Windows\\System32");
-    } finally {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
   test("matches Windows environment names case-insensitively", () => {
     const windowsEnv = buildSanitizedEnv("win32", {
       Path: "C:\\Windows\\System32;C:\\Program Files\\Vellum",

package/src/tools/terminal/safe-env.ts

@@ -7,12 +7,8 @@
  */
 import { readdirSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
 
-import {
-  pathListDelimiter,
-  prependUniquePathEntries,
-} from "@vellumai/environments/shell";
+import { pathListDelimiter } from "@vellumai/environments/shell";
 
 import { getGatewayInternalBaseUrl } from "../../config/env.js";
 import { getDataDir, getWorkspaceDir } from "../../util/platform.js";
@@ -288,7 +284,6 @@ function appendUniquePathEntries(
 export function buildSanitizedEnv(
   hostPlatform: NodeJS.Platform = process.platform,
   sourceEnv: NodeJS.ProcessEnv = process.env,
-  options?: { execPath?: string },
 ): Record<string, string> {
   const env: Record<string, string> = {};
   const isKataRuntime = isKataFamilyRuntime(sourceEnv.VELLUM_SANDBOX_RUNTIME);
@@ -365,29 +360,5 @@ export function buildSanitizedEnv(
   if (!env.LC_ALL) {
     env.LC_ALL = utf8Locale;
   }
-  prependWindowsAssistantDir(
-    env,
-    hostPlatform,
-    options?.execPath ?? process.execPath,
-  );
   return env;
 }
-
-function prependWindowsAssistantDir(
-  env: Record<string, string>,
-  hostPlatform: NodeJS.Platform,
-  execPath: string,
-): void {
-  if (hostPlatform !== "win32") {
-    return;
-  }
-  const execDir = dirname(execPath);
-  try {
-    if (!statSync(join(execDir, "assistant.exe")).isFile()) {
-      return;
-    }
-  } catch {
-    return;
-  }
-  env.PATH = prependUniquePathEntries(env.PATH, [execDir], hostPlatform);
-}

package/src/tools/terminal/sanitized-bash.ts

@@ -11,12 +11,9 @@ import { spawn } from "node:child_process";
 
 import {
   buildShellInvocation,
-  buildShellSpawnFlags,
   terminateProcessTree,
-  watchShellProcessStart,
 } from "../../util/host-process.js";
 import { getWorkspaceDir } from "../../util/platform.js";
-import { SHELL_DID_NOT_START_MESSAGE } from "../shared/shell-output.js";
 import { buildSanitizedEnv } from "./safe-env.js";
 
 export const DEFAULT_SANITIZED_BASH_TIMEOUT_MS = 30_000;
@@ -66,10 +63,10 @@ export function runSanitizedBash(
     const child = spawn(wrapped.command, wrapped.args, {
       cwd: getWorkspaceDir(),
       stdio: ["ignore", "pipe", "pipe"],
+      detached: true,
       env: buildSanitizedEnv(),
-      ...buildShellSpawnFlags(),
+      windowsHide: true,
     });
-    const launch = watchShellProcessStart(child);
 
     const timer = setTimeout(() => {
       timedOut = true;
@@ -86,16 +83,6 @@ export function runSanitizedBash(
 
     child.on("close", (code) => {
       clearTimeout(timer);
-      if (!launch.didStart()) {
-        finish({
-          stdout: "",
-          stderr: "",
-          exitCode: null,
-          timedOut: false,
-          error: SHELL_DID_NOT_START_MESSAGE,
-        });
-        return;
-      }
       finish({
         stdout: Buffer.concat(stdoutChunks).toString(),
         stderr: Buffer.concat(stderrChunks).toString(),

package/src/tools/terminal/shell.test.ts

@@ -7,7 +7,6 @@ import { setConfig } from "../../__tests__/helpers/set-config.js";
 import {
   MAX_OUTPUT_LENGTH,
   OUTPUT_TRUNCATED_TAG,
-  SHELL_DID_NOT_START_MESSAGE,
 } from "../shared/shell-output.js";
 import type { ToolContext } from "../types.js";
 
@@ -208,34 +207,6 @@ describe("foreground stdin handling", () => {
   });
 });
 
-describe("foreground command execution", () => {
-  let tmpDir = "";
-
-  beforeEach(async () => {
-    tmpDir = await mkdtemp(join(tmpdir(), "bash-exec-"));
-  });
-
-  afterEach(async () => {
-    if (tmpDir) {
-      await rm(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  test("a command that writes a file must actually create it", async () => {
-    const result = await shellTool.execute(
-      {
-        command: "printf ran > proof.txt",
-        activity: "test",
-      },
-      { ...makeContext(), workingDir: tmpDir },
-    );
-
-    expect(result.isError).toBeFalsy();
-    expect(result.content).not.toBe(SHELL_DID_NOT_START_MESSAGE);
-    expect(await readFile(join(tmpDir, "proof.txt"), "utf-8")).toBe("ran");
-  });
-});
-
 describe("streaming stdout cap", () => {
   let tmpDir = "";
 

package/src/tools/terminal/shell.ts

@@ -11,9 +11,7 @@ import { conversationRevealNonce } from "../../runtime/reveal-nonce.js";
 import { redactSecrets } from "../../security/secret-scanner.js";
 import {
   buildShellInvocation,
-  buildShellSpawnFlags,
   terminateProcessTree,
-  watchShellProcessStart,
 } from "../../util/host-process.js";
 import { getLogger } from "../../util/logger.js";
 import { getDataDir } from "../../util/platform.js";
@@ -326,9 +324,9 @@ export const shellTool = {
         cwd: context.workingDir,
         env,
         stdio: ["ignore", "pipe", "pipe"],
-        ...buildShellSpawnFlags(),
+        detached: true,
+        windowsHide: true,
       });
-      const launch = watchShellProcessStart(child);
       const collector = attachBoundedStdio(child);
 
       const killTree = buildKillTree(child, {
@@ -369,13 +367,11 @@ export const shellTool = {
           timedOut,
         });
 
-        const fmtResult = collector.format(code, timedOut, timeoutSec, {
-          started: launch.didStart(),
-        });
+        const fmtResult = collector.format(code, timedOut, timeoutSec);
 
         const status: BackgroundToolCompletedEvent["status"] = aborted
           ? "cancelled"
-          : timedOut || fmtResult.isError
+          : timedOut
             ? "failed"
             : code === 0
               ? "completed"
@@ -533,9 +529,9 @@ export const shellTool = {
         cwd: context.workingDir,
         env,
         stdio: ["ignore", "pipe", "pipe"],
-        ...buildShellSpawnFlags(),
+        detached: true,
+        windowsHide: true,
       });
-      const launch = watchShellProcessStart(child);
       const collector = attachBoundedStdio(child, {
         onOutput: context.onOutput,
       });
@@ -577,9 +573,7 @@ export const shellTool = {
           timedOut,
         });
 
-        const fmtResult = collector.format(code, timedOut, timeoutSec, {
-          started: launch.didStart(),
-        });
+        const fmtResult = collector.format(code, timedOut, timeoutSec);
 
         resolve({
           content: fmtResult.content,

package/src/util/host-process.test.ts

@@ -1,7 +1,6 @@
-import { EventEmitter } from "node:events";
 import { expect, mock, test } from "bun:test";
 
-import { terminateProcessTree, watchShellProcessStart } from "./host-process.js";
+import { terminateProcessTree } from "./host-process.js";
 
 test("Windows process trees use taskkill and fall back to the direct child", () => {
   const kill = mock(() => true);
@@ -16,18 +15,3 @@ test("Windows process trees use taskkill and fall back to the direct child", ()
   expect(kill).toHaveBeenCalledTimes(1);
   expect(kill).toHaveBeenCalledWith();
 });
-
-test("watchShellProcessStart is false until spawn or a pid appears", () => {
-  const child = new EventEmitter() as EventEmitter & { pid?: number };
-  const launch = watchShellProcessStart(child);
-  expect(launch.didStart()).toBe(false);
-
-  child.emit("spawn");
-  expect(launch.didStart()).toBe(true);
-});
-
-test("watchShellProcessStart treats a pid assigned at construction as started", () => {
-  const child = new EventEmitter() as EventEmitter & { pid?: number };
-  child.pid = 4242;
-  expect(watchShellProcessStart(child).didStart()).toBe(true);
-});

package/src/util/host-process.ts

@@ -2,34 +2,10 @@ import { spawn } from "node:child_process";
 
 export {
   buildShellInvocation,
-  buildShellSpawnFlags,
   pathListDelimiter,
   prependUniquePathEntries,
 } from "@vellumai/environments/shell";
 
-export interface ShellProcessStartWatch {
-  didStart(): boolean;
-}
-
-/**
- * Record whether a spawned child actually started. A `close` with exit 0 and
- * empty stdio is not proof of execution: Windows can emit that when the
- * process was never created. Callers must treat `didStart() === false` as a
- * launch failure.
- */
-export function watchShellProcessStart(child: {
-  pid?: number;
-  once(event: "spawn", listener: () => void): unknown;
-}): ShellProcessStartWatch {
-  let spawnSeen = child.pid != null;
-  child.once("spawn", () => {
-    spawnSeen = true;
-  });
-  return {
-    didStart: () => spawnSeen || child.pid != null,
-  };
-}
-
 export interface KillableProcess {
   pid?: number;
   kill: unknown;

package/src/util/unicode.ts

@@ -67,35 +67,6 @@ export function safeStringSlice(
   return str.slice(safeStart, safeEnd);
 }
 
-/**
- * A `[start, end)` character window of at most `maxChars` code units that
- * never splits a surrogate pair, for paging through text by offset. A split
- * leaves a lone half at each edge, and each encodes to U+FFFD, so the
- * character is lost from both this window and the next one paged in after
- * it. `charCodeAt` reads the underlying text so a caller need not hold it as
- * one string.
- */
-export function surrogateSafeWindow(
-  total: number,
-  charCodeAt: (index: number) => number,
-  requestedStart: number,
-  maxChars: number,
-): { start: number; end: number } {
-  let start = Math.max(0, Math.min(requestedStart, total));
-  if (start > 0 && start < total && isLowSurrogate(charCodeAt(start))) {
-    start -= 1;
-  }
-
-  let end = Math.min(total, start + maxChars);
-  if (end > start && end < total && isHighSurrogate(charCodeAt(end - 1))) {
-    // Backing off would empty a one-character window, which stalls paging on
-    // the same offset, so take the whole pair instead.
-    end = end - 1 > start ? end - 1 : Math.min(total, end + 1);
-  }
-
-  return { start, end };
-}
-
 /**
  * Replace every orphaned UTF-16 surrogate in `str` with U+FFFD
  * (REPLACEMENT CHARACTER).

package/src/__tests__/db-conversation-tool-surface.test.ts

@@ -1,144 +0,0 @@
-/**
- * Tests for the per-conversation wire tool-surface record
- * (`persistence/conversation-tool-surface.ts`): the resolver records the
- * tools array a live turn sends, fork wakes read it back verbatim, and an
- * unchanged surface is never rewritten.
- */
-
-import { Database } from "bun:sqlite";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { drizzle } from "drizzle-orm/bun-sqlite";
-
-import {
-  getConversationToolSurface,
-  hashConversationToolSurface,
-  recordConversationToolSurface,
-} from "../persistence/conversation-tool-surface.js";
-import { clearStoredDb, setStoredDb } from "../persistence/db-singleton.js";
-import { migrateCreateConversationToolSurfaces } from "../persistence/migrations/378-create-conversation-tool-surfaces.js";
-import * as schema from "../persistence/schema/index.js";
-import type { ToolDefinition } from "../providers/types.js";
-
-let sqlite: Database;
-
-beforeEach(() => {
-  sqlite = new Database(":memory:");
-  sqlite.run("PRAGMA foreign_keys = ON");
-  sqlite.run(/*sql*/ `CREATE TABLE conversations (id TEXT PRIMARY KEY)`);
-  sqlite.query(`INSERT INTO conversations (id) VALUES (?)`).run("conv-1");
-  const db = drizzle(sqlite, { schema });
-  migrateCreateConversationToolSurfaces(db);
-  setStoredDb("main", db, () => sqlite.close());
-});
-
-afterEach(() => {
-  clearStoredDb("main");
-});
-
-const TOOLS: ToolDefinition[] = [
-  {
-    name: "remember",
-    description: "Save a fact",
-    input_schema: { type: "object", properties: { content: {} } },
-  },
-  { name: "bell_jingle", description: "Ring", input_schema: {} },
-];
-
-function storedRow(): { tools_hash: string; updated_at: number } | null {
-  return sqlite
-    .query(
-      `SELECT tools_hash, updated_at FROM conversation_tool_surfaces WHERE conversation_id = ?`,
-    )
-    .get("conv-1") as { tools_hash: string; updated_at: number } | null;
-}
-
-describe("recordConversationToolSurface", () => {
-  test("stores the array and returns its content hash", () => {
-    const hash = recordConversationToolSurface("conv-1", TOOLS);
-
-    expect(hash).toBe(hashConversationToolSurface(TOOLS));
-    expect(storedRow()?.tools_hash).toBe(hash);
-    expect(getConversationToolSurface("conv-1")).toEqual(TOOLS);
-  });
-
-  test("replays the exact array, including key order and extra fields", () => {
-    const serverTool = {
-      type: "web_search_20250305",
-      name: "web_search",
-      max_uses: 5,
-    } as unknown as ToolDefinition;
-    const tools = [...TOOLS, serverTool];
-
-    recordConversationToolSurface("conv-1", tools);
-
-    expect(JSON.stringify(getConversationToolSurface("conv-1"))).toBe(
-      JSON.stringify(tools),
-    );
-  });
-
-  test("an unchanged surface with a known hash skips the write", () => {
-    const hash = recordConversationToolSurface("conv-1", TOOLS);
-    const before = storedRow()!.updated_at;
-    sqlite
-      .query(
-        `UPDATE conversation_tool_surfaces SET updated_at = ? WHERE conversation_id = ?`,
-      )
-      .run(before - 1000, "conv-1");
-
-    recordConversationToolSurface("conv-1", TOOLS, hash);
-
-    expect(storedRow()!.updated_at).toBe(before - 1000);
-  });
-
-  test("an unchanged surface with no known hash compares against the stored row before writing", () => {
-    recordConversationToolSurface("conv-1", TOOLS);
-    const marker = 42;
-    sqlite
-      .query(
-        `UPDATE conversation_tool_surfaces SET updated_at = ? WHERE conversation_id = ?`,
-      )
-      .run(marker, "conv-1");
-
-    // A freshly loaded conversation knows no hash yet; the stored row matches,
-    // so nothing is rewritten.
-    recordConversationToolSurface("conv-1", TOOLS, undefined);
-
-    expect(storedRow()!.updated_at).toBe(marker);
-  });
-
-  test("a changed surface overwrites the stored one", () => {
-    const first = recordConversationToolSurface("conv-1", TOOLS);
-    const changed = TOOLS.slice(0, 1);
-
-    const second = recordConversationToolSurface("conv-1", changed, first);
-
-    expect(second).not.toBe(first);
-    expect(storedRow()?.tools_hash).toBe(second);
-    expect(getConversationToolSurface("conv-1")).toEqual(changed);
-  });
-});
-
-describe("getConversationToolSurface", () => {
-  test("returns null when no turn has recorded a surface", () => {
-    expect(getConversationToolSurface("conv-1")).toBeNull();
-  });
-
-  test("returns null for an unreadable stored payload", () => {
-    sqlite
-      .query(
-        /*sql*/ `INSERT INTO conversation_tool_surfaces (conversation_id, tools_json, tools_hash, updated_at) VALUES (?, ?, ?, ?)`,
-      )
-      .run("conv-1", "not json", "h", 1);
-
-    expect(getConversationToolSurface("conv-1")).toBeNull();
-  });
-
-  test("the row cascades with its conversation", () => {
-    recordConversationToolSurface("conv-1", TOOLS);
-
-    sqlite.query(`DELETE FROM conversations WHERE id = ?`).run("conv-1");
-
-    expect(getConversationToolSurface("conv-1")).toBeNull();
-  });
-});

package/src/api/events/desktop-activity-changed.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-
-/** Transient browser activity changed; refetch desktop status. */
-export const DesktopActivityChangedEventSchema = z.object({
-  type: z.literal("desktop_activity_changed"),
-});
-
-export type DesktopActivityChangedEvent = z.infer<
-  typeof DesktopActivityChangedEventSchema
->;