@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/runtime/services/__tests__/conversation-serializer.test.ts

@@ -159,3 +159,31 @@ describe("serializeConversationSummary · enabledPlugins", () => {
     expect("enabledPlugins" in summary).toBe(false);
   });
 });
+
+describe("serializeConversationSummary · title keys", () => {
+  test("resolves a stored title key for the locale", () => {
+    const summary = serializeConversationSummary({
+      conversation: makeConversationRow({
+        title: "conversation.title.generating",
+      }),
+      displayMeta: { displayOrder: null, isPinned: false, groupId: null },
+      parentCache: new Map(),
+      isProcessing: false,
+      locale: "es",
+    });
+    expect(summary.title).toBe("Generando título...");
+    expect("titleState" in summary).toBe(false);
+  });
+
+  test("passes a stored display string through", () => {
+    const summary = serialize(
+      makeConversationRow({ title: "Untitled Conversation" }),
+    );
+    expect(summary.title).toBe("Untitled Conversation");
+  });
+
+  test("passes a custom title through", () => {
+    const summary = serialize(makeConversationRow({ title: "Weekly planning" }));
+    expect(summary.title).toBe("Weekly planning");
+  });
+});

package/src/runtime/services/conversation-serializer.ts

@@ -8,6 +8,10 @@
 
 import { parseChannelId } from "../../channels/types.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
+import {
+  resolveConversationTitle,
+  type SupportedLocale,
+} from "../../i18n/index.js";
 import { buildChannelBindingMetadata } from "../../messaging/channel-binding-metadata.js";
 import {
   type AttentionState,
@@ -78,6 +82,7 @@ interface ForkLineage {
 function buildForkLineage(
   conversation: ConversationRow,
   parentCache: Map<string, ConversationRow | null>,
+  locale?: SupportedLocale,
 ): ForkLineage {
   const parentConversationId = conversation.forkParentConversationId;
   const parentMessageId = conversation.forkParentMessageId;
@@ -101,7 +106,7 @@ function buildForkLineage(
     forkParent: {
       conversationId: parentConversationId,
       messageId: parentMessageId,
-      title: parentConversation.title ?? "Untitled",
+      title: resolveConversationTitle(parentConversation.title, locale),
     },
   };
 }
@@ -178,6 +183,11 @@ export function serializeConversationSummary(params: {
    * with no daemon-store coupling.
    */
   isProcessing: boolean;
+  /**
+   * Locale used to resolve stored title keys. Omitted locale is English
+   * inside {@link resolveConversationTitle}.
+   */
+  locale?: SupportedLocale;
 }) {
   const {
     conversation,
@@ -186,14 +196,15 @@ export function serializeConversationSummary(params: {
     displayMeta,
     parentCache,
     isProcessing,
+    locale,
   } = params;
   const originChannel = parseChannelId(conversation.originChannel);
   const assistantAttention = buildAssistantAttention(attentionState);
-  const forkLineage = buildForkLineage(conversation, parentCache);
+  const forkLineage = buildForkLineage(conversation, parentCache, locale);
 
   return {
     id: conversation.id,
-    title: conversation.title ?? "Untitled",
+    title: resolveConversationTitle(conversation.title, locale),
     createdAt: conversation.createdAt,
     updatedAt: conversation.updatedAt,
     lastMessageAt: conversation.lastMessageAt,
@@ -253,6 +264,7 @@ export function serializeConversationSummary(params: {
  */
 export function buildConversationDetailResponse(
   conversationId: string,
+  locale?: SupportedLocale,
 ): { conversation: ReturnType<typeof serializeConversationSummary> } | null {
   const conversation = getConversation(conversationId);
   if (!conversation || conversation.conversationType === "private") {
@@ -274,6 +286,7 @@ export function buildConversationDetailResponse(
       // Checks in-memory flag first (hot path), falls back to the
       // persisted `processing_started_at` column for cold conversations.
       isProcessing: isConversationProcessing(conversation.id),
+      locale,
     }),
   };
 }

package/src/runtime/sync/resource-sync-events.ts

@@ -4,6 +4,7 @@ import {
   conversationMetadataSyncTag,
   SYNC_TAGS,
 } from "../../daemon/message-types/sync.js";
+import { resolveConversationTitle } from "../../i18n/index.js";
 import { syncAvatarToPlatform } from "../../platform/sync-avatar.js";
 import { getAvatarImagePath } from "../../util/platform.js";
 import { broadcastMessage } from "../assistant-event-hub.js";
@@ -257,7 +258,7 @@ export function publishConversationTitleChanged(
     {
       type: "conversation_title_updated",
       conversationId,
-      title,
+      title: resolveConversationTitle(title),
     },
     conversationId,
   );

package/src/schedule/run-script.ts

@@ -5,6 +5,7 @@ import {
 } from "../util/host-process.js";
 import { getLogger } from "../util/logger.js";
 import { getWorkspaceDir } from "../util/platform.js";
+import { safeStringSlice } from "../util/unicode.js";
 
 const log = getLogger("run-script");
 
@@ -200,7 +201,7 @@ function truncate(text: string): string {
   if (text.length <= MAX_OUTPUT_BYTES) {
     return text;
   }
-  return text.slice(0, MAX_OUTPUT_BYTES) + "\n... (truncated)";
+  return safeStringSlice(text, 0, MAX_OUTPUT_BYTES) + "\n... (truncated)";
 }
 
 /**

package/src/schedule/schedule-store.ts

@@ -23,6 +23,7 @@ import { publishSchedulesChanged } from "../runtime/sync/resource-sync-events.js
 import { UserError } from "../util/errors.js";
 import { getLogger } from "../util/logger.js";
 import { withSqliteRetry } from "../util/sqlite-retry.js";
+import { safeStringSlice } from "../util/unicode.js";
 import {
   hasOwnerDeferProvenance,
   isDeferSchedule,
@@ -1511,8 +1512,14 @@ async function finishScheduleRunRow(
           status: result.status,
           finishedAt: now,
           durationMs,
-          output: result.output?.slice(0, 10_000) ?? null,
-          error: result.error?.slice(0, 2000) ?? null,
+          output:
+            result.output === undefined
+              ? null
+              : safeStringSlice(result.output, 0, 10_000),
+          error:
+            result.error === undefined
+              ? null
+              : safeStringSlice(result.error, 0, 2000),
         })
         .where(eq(scheduleRuns.id, runId))
         .run(),

package/src/schedule/worker.ts

@@ -195,7 +195,7 @@ async function main(): Promise<void> {
   //
   // Bounded by MCP_STARTUP_GRACE_MS: unreachable servers must not hold the
   // schedules that do not use them. The connect runs on past the deadline.
-  const mcpStartup = startConfiguredMcpServers(getConfig().mcp);
+  const mcpStartup = startConfiguredMcpServers();
   await Promise.race([
     mcpStartup,
     // Unref'd so a connect that beats the deadline leaves nothing pending.

package/src/security/__tests__/ces-http-record-backend.test.ts

@@ -0,0 +1,137 @@
+import { afterEach, describe, expect, spyOn, test } from "bun:test";
+
+import type { CredentialRecord } from "@vellumai/service-contracts/credential-rpc";
+
+import * as envRegistry from "../../config/env-registry.js";
+import {
+  CesHttpRecordBackend,
+  createCesHttpRecordBackendIfConfigured,
+} from "../ces-http-record-backend.js";
+
+const ORIGINAL_URL = process.env.CES_CREDENTIAL_URL;
+const ORIGINAL_TOKEN = process.env.CES_SERVICE_TOKEN;
+
+function restoreCesHttpEnv(): void {
+  if (ORIGINAL_URL === undefined) {
+    delete process.env.CES_CREDENTIAL_URL;
+  } else {
+    process.env.CES_CREDENTIAL_URL = ORIGINAL_URL;
+  }
+  if (ORIGINAL_TOKEN === undefined) {
+    delete process.env.CES_SERVICE_TOKEN;
+  } else {
+    process.env.CES_SERVICE_TOKEN = ORIGINAL_TOKEN;
+  }
+}
+
+function fakeHttpClient(options: {
+  listRecords: () => Promise<{
+    records: Array<{ account: string; record: CredentialRecord }>;
+    unreachable: boolean;
+  }>;
+}) {
+  return {
+    getRecord: async () => ({ record: undefined, unreachable: false }),
+    setRecord: async () => false,
+    deleteRecord: async () => "error" as const,
+    listRecords: options.listRecords,
+    bulkSetRecords: async (records: Array<{ account: string }>) =>
+      records.map((entry) => ({ account: entry.account, ok: false })),
+  };
+}
+
+describe("CES HTTP credential record backend", () => {
+  afterEach(() => {
+    restoreCesHttpEnv();
+  });
+
+  test("factory returns null when the assistant is not containerized", () => {
+    const spy = spyOn(envRegistry, "getIsContainerized").mockReturnValue(false);
+    process.env.CES_CREDENTIAL_URL = "http://ces-container:8090";
+    process.env.CES_SERVICE_TOKEN = "token-123";
+    try {
+      expect(createCesHttpRecordBackendIfConfigured()).toBeNull();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("factory returns null when CES_CREDENTIAL_URL is unset", () => {
+    const spy = spyOn(envRegistry, "getIsContainerized").mockReturnValue(true);
+    delete process.env.CES_CREDENTIAL_URL;
+    process.env.CES_SERVICE_TOKEN = "token-123";
+    try {
+      expect(createCesHttpRecordBackendIfConfigured()).toBeNull();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("factory returns null when CES_SERVICE_TOKEN is unset", () => {
+    const spy = spyOn(envRegistry, "getIsContainerized").mockReturnValue(true);
+    process.env.CES_CREDENTIAL_URL = "http://ces-container:8090";
+    delete process.env.CES_SERVICE_TOKEN;
+    try {
+      expect(createCesHttpRecordBackendIfConfigured()).toBeNull();
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("factory returns a backend when containerized with CES HTTP env", () => {
+    const spy = spyOn(envRegistry, "getIsContainerized").mockReturnValue(true);
+    process.env.CES_CREDENTIAL_URL = "http://ces-container:8090";
+    process.env.CES_SERVICE_TOKEN = "token-123";
+    try {
+      const backend = createCesHttpRecordBackendIfConfigured();
+      expect(backend?.name).toBe("ces-http");
+      expect(backend?.isAvailable()).toBe(true);
+    } finally {
+      spy.mockRestore();
+    }
+  });
+
+  test("list returns records when HTTP reports a reachable catalog", async () => {
+    const record: CredentialRecord = {
+      credentialId: "cred-http",
+      service: "github",
+      field: "token",
+      allowedTools: ["bash"],
+      allowedDomains: [],
+      createdAt: 1,
+      updatedAt: 2,
+    };
+    const backend = new CesHttpRecordBackend(
+      fakeHttpClient({
+        listRecords: async () => ({
+          records: [{ account: "github:token", record }],
+          unreachable: false,
+        }),
+      }),
+    );
+
+    const listed = await backend.list();
+    expect(listed).toEqual([{ account: "github:token", record }]);
+  });
+
+  test("list returns an empty catalog when HTTP is reachable and empty", async () => {
+    const backend = new CesHttpRecordBackend(
+      fakeHttpClient({
+        listRecords: async () => ({ records: [], unreachable: false }),
+      }),
+    );
+
+    const listed = await backend.list();
+    expect(listed).toEqual([]);
+  });
+
+  test("list returns null when HTTP reports the vault unreachable", async () => {
+    const backend = new CesHttpRecordBackend(
+      fakeHttpClient({
+        listRecords: async () => ({ records: [], unreachable: true }),
+      }),
+    );
+
+    expect(await backend.list()).toBeNull();
+  });
+});

package/src/security/ces-http-record-backend.ts

@@ -0,0 +1,120 @@
+/**
+ * CES HTTP backend for non-secret credential records (identity + policy).
+ *
+ * Used when the CES RPC socket is down but the CES HTTP sidecar is
+ * reachable (containerized deployments with CES_CREDENTIAL_URL).
+ */
+
+import {
+  type CesHttpCredentialClient,
+  createCesHttpCredentialClient,
+} from "@vellumai/ces-client/http-credentials";
+import type { CredentialRecord } from "@vellumai/service-contracts/credential-rpc";
+
+import { getIsContainerized } from "../config/env-registry.js";
+import { getLogger } from "../util/logger.js";
+import type { CredentialRecordBackend } from "./ces-rpc-record-backend.js";
+
+const log = getLogger("ces-http-record-backend");
+
+type RecordHttpClient = Pick<
+  CesHttpCredentialClient,
+  | "getRecord"
+  | "setRecord"
+  | "deleteRecord"
+  | "listRecords"
+  | "bulkSetRecords"
+>;
+
+function resolveEnvHttpClient(): RecordHttpClient | undefined {
+  const baseUrl = process.env.CES_CREDENTIAL_URL?.trim();
+  const serviceToken = process.env.CES_SERVICE_TOKEN?.trim();
+  if (!baseUrl || !serviceToken) {
+    return undefined;
+  }
+  return createCesHttpCredentialClient({ baseUrl, serviceToken }, log);
+}
+
+export class CesHttpRecordBackend implements CredentialRecordBackend {
+  readonly name = "ces-http";
+
+  constructor(private readonly client?: RecordHttpClient) {}
+
+  private resolveClient(): RecordHttpClient | undefined {
+    return this.client ?? resolveEnvHttpClient();
+  }
+
+  isAvailable(): boolean {
+    return this.resolveClient() !== undefined;
+  }
+
+  async get(account: string): Promise<CredentialRecord | undefined> {
+    const client = this.resolveClient();
+    if (!client) {
+      return undefined;
+    }
+    const result = await client.getRecord(account);
+    return result.record;
+  }
+
+  async set(account: string, record: CredentialRecord): Promise<boolean> {
+    const client = this.resolveClient();
+    if (!client) {
+      return false;
+    }
+    return client.setRecord(account, record);
+  }
+
+  async delete(
+    account: string,
+  ): Promise<"deleted" | "not-found" | "error"> {
+    const client = this.resolveClient();
+    if (!client) {
+      return "error";
+    }
+    return client.deleteRecord(account);
+  }
+
+  async list(): Promise<Array<{
+    account: string;
+    record: CredentialRecord;
+  }> | null> {
+    const client = this.resolveClient();
+    if (!client) {
+      return null;
+    }
+    const result = await client.listRecords();
+    if (result.unreachable) {
+      return null;
+    }
+    return result.records ?? [];
+  }
+
+  async bulkSet(
+    records: Array<{ account: string; record: CredentialRecord }>,
+  ): Promise<Array<{ account: string; ok: boolean }>> {
+    const client = this.resolveClient();
+    if (!client) {
+      return records.map((entry) => ({ account: entry.account, ok: false }));
+    }
+    return client.bulkSetRecords(records);
+  }
+}
+
+/**
+ * CES HTTP record backend when the assistant is containerized and the
+ * CES HTTP sidecar URL is configured. Returns null otherwise.
+ */
+export function createCesHttpRecordBackendIfConfigured(): CredentialRecordBackend | null {
+  if (!getIsContainerized()) {
+    return null;
+  }
+  if (!process.env.CES_CREDENTIAL_URL?.trim()) {
+    return null;
+  }
+  const backend = new CesHttpRecordBackend();
+  if (!backend.isAvailable()) {
+    return null;
+  }
+  return backend;
+}

package/src/security/ces-rpc-record-backend.ts

@@ -11,6 +11,11 @@ import { getLogger } from "../util/logger.js";
 const log = getLogger("ces-rpc-record-backend");
 
 export interface CredentialRecordBackend {
+  /**
+   * Transport id. `"ces-rpc"` is the attached CES socket backend; live
+   * catalog listing fails over to CES HTTP when that transport is down.
+   */
+  readonly name?: string;
   isAvailable(): boolean;
   get(account: string): Promise<CredentialRecord | undefined>;
   set(account: string, record: CredentialRecord): Promise<boolean>;
@@ -29,6 +34,8 @@ export interface CredentialRecordBackend {
 }
 
 export class CesRpcRecordBackend implements CredentialRecordBackend {
+  readonly name = "ces-rpc";
+
   constructor(private readonly client: CesClient) {}
 
   isAvailable(): boolean {

package/src/security/untrusted-content.ts

@@ -11,6 +11,8 @@
  * 3. Enforces per-source character budgets to prevent context flooding.
  */
 
+import { safeStringSlice } from "../util/unicode.js";
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -156,7 +158,7 @@ export function escapeContentBoundaries(content: string): string {
 
 /** Sanitize a value for use as an XML attribute (no quotes, angle brackets, newlines). */
 function sanitizeAttr(value: string): string {
-  return value.replace(/[<>"&\r\n]/g, "").slice(0, 200);
+  return safeStringSlice(value.replace(/[<>"&\r\n]/g, ""), 0, 200);
 }
 
 function parseExternalContentAttributes(

package/src/skills/__tests__/workspace-skill-md-signature.test.ts

@@ -0,0 +1,60 @@
+import { mkdirSync, mkdtempSync, rmSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+
+import { readWorkspaceSkillMdSignature } from "../workspace-skill-md-signature.js";
+
+const ROOT = mkdtempSync(join(tmpdir(), "skill-md-signature-"));
+
+afterEach(() => {
+  rmSync(ROOT, { recursive: true, force: true });
+  mkdirSync(ROOT, { recursive: true });
+});
+
+function writeSkill(id: string, body = "body"): string {
+  const dir = join(ROOT, id);
+  mkdirSync(dir, { recursive: true });
+  const skillMd = join(dir, "SKILL.md");
+  writeFileSync(skillMd, `---\nname: ${id}\ndescription: ${id}\n---\n${body}\n`);
+  return skillMd;
+}
+
+describe("readWorkspaceSkillMdSignature", () => {
+  test("empty or missing skills dir is the empty signature", () => {
+    expect(readWorkspaceSkillMdSignature(join(ROOT, "missing"))).toBe("");
+    mkdirSync(ROOT, { recursive: true });
+    expect(readWorkspaceSkillMdSignature(ROOT)).toBe("");
+  });
+
+  test("includes SKILL.md mtimes and ignores TOOLS.json", () => {
+    const skillMd = writeSkill("alpha");
+    const first = readWorkspaceSkillMdSignature(ROOT);
+    expect(first).toMatch(/^alpha:\d+$/);
+
+    writeFileSync(join(ROOT, "alpha", "TOOLS.json"), '{"version":1,"tools":[]}');
+    expect(readWorkspaceSkillMdSignature(ROOT)).toBe(first);
+
+    const later = new Date(Date.now() + 5_000);
+    utimesSync(skillMd, later, later);
+    expect(readWorkspaceSkillMdSignature(ROOT)).not.toBe(first);
+  });
+
+  test("add and remove skill directories change the signature", () => {
+    writeSkill("alpha");
+    const one = readWorkspaceSkillMdSignature(ROOT);
+    writeSkill("bravo");
+    const two = readWorkspaceSkillMdSignature(ROOT);
+    expect(two).not.toBe(one);
+    expect(two.split("\n")).toHaveLength(2);
+
+    rmSync(join(ROOT, "bravo"), { recursive: true, force: true });
+    expect(readWorkspaceSkillMdSignature(ROOT)).toBe(one);
+  });
+
+  test("directories without SKILL.md are omitted", () => {
+    mkdirSync(join(ROOT, "not-a-skill"), { recursive: true });
+    writeFileSync(join(ROOT, "README.md"), "nope");
+    expect(readWorkspaceSkillMdSignature(ROOT)).toBe("");
+  });
+});

package/src/skills/workspace-skill-md-signature.ts

@@ -0,0 +1,50 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+import { getWorkspaceSkillsDir } from "../util/platform.js";
+
+/**
+ * Cheap change detector for workspace skill capability cards: the sorted set
+ * of immediate skill directories that contain a top-level `SKILL.md`, each
+ * paired with that file's mtime. Capability cards are frontmatter fields from
+ * `SKILL.md`. Body files, `TOOLS.json`, scripts, and `references/` are not part
+ * of this signature.
+ *
+ * Listing the skills directory (not only statting known paths) is what makes
+ * install and delete visible: a new or removed skill directory changes the
+ * signature even when no previously known `SKILL.md` mtime moved.
+ */
+export function readWorkspaceSkillMdSignature(
+  skillsDir: string = getWorkspaceSkillsDir(),
+): string {
+  if (!existsSync(skillsDir)) {
+    return "";
+  }
+
+  let entries;
+  try {
+    entries = readdirSync(skillsDir, { withFileTypes: true });
+  } catch {
+    return "";
+  }
+
+  const parts: string[] = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) {
+      continue;
+    }
+    const skillMdPath = join(skillsDir, entry.name, "SKILL.md");
+    try {
+      const st = statSync(skillMdPath);
+      if (!st.isFile()) {
+        continue;
+      }
+      parts.push(`${entry.name}:${Math.trunc(st.mtimeMs)}`);
+    } catch {
+      // No readable SKILL.md: not a catalog skill.
+    }
+  }
+
+  parts.sort();
+  return parts.join("\n");
+}

package/src/subagent/consult-context.ts

@@ -33,7 +33,6 @@
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 
-import type { SkillSummary } from "../config/skills.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { truncate as truncateText } from "../util/truncate.js";
@@ -56,15 +55,6 @@ export interface AdvisorContextSources {
    * from the catalog section, mirroring the `skill_load` gate.
    */
   enabledPluginSet?: ReadonlySet<string> | null;
-  /**
-   * Pre-resolved skill catalog, typically the parent conversation's warm
-   * `skillProjectionCache.catalog`. Passing it keeps the synchronous on-disk
-   * catalog scan out of the consult path (and matches the catalog view the
-   * parent turn's tool projection used). When absent, the section falls back
-   * to a fresh `loadSkillCatalog()` scan, the same call every agent turn's
-   * projection already makes.
-   */
-  skillCatalog?: readonly SkillSummary[];
 }
 
 /** Cap a block so the assembled context never balloons the consult prompt. */
@@ -114,7 +104,6 @@ async function buildToolsSection(
  */
 async function buildSkillsSection(
   enabledPluginSet: ReadonlySet<string> | null | undefined,
-  preResolvedCatalog: readonly SkillSummary[] | undefined,
 ): Promise<string | null> {
   try {
     const [
@@ -130,19 +119,17 @@ async function buildSkillsSection(
     ]);
     const config = getConfig();
     const pluginScope = enabledPluginSet ?? null;
-    const catalog = (preResolvedCatalog ?? loadSkillCatalog()).filter(
-      (skill) => {
-        if (
-          pluginScope !== null &&
-          skill.owner?.kind === "plugin" &&
-          !pluginScope.has(skill.owner.id)
-        ) {
-          return false;
-        }
-        const flagKey = skillFlagKey(skill);
-        return !flagKey || isAssistantFeatureFlagEnabled(flagKey, config);
-      },
-    );
+    const catalog = loadSkillCatalog().filter((skill) => {
+      if (
+        pluginScope !== null &&
+        skill.owner?.kind === "plugin" &&
+        !pluginScope.has(skill.owner.id)
+      ) {
+        return false;
+      }
+      const flagKey = skillFlagKey(skill);
+      return !flagKey || isAssistantFeatureFlagEnabled(flagKey, config);
+    });
     if (catalog.length === 0) {
       return null;
     }
@@ -384,7 +371,7 @@ export async function buildAdvisorContext(
   const sections = await Promise.all(
     [
       buildToolsSection(sources.allowedToolNames),
-      buildSkillsSection(sources.enabledPluginSet, sources.skillCatalog),
+      buildSkillsSection(sources.enabledPluginSet),
       buildWorkspaceSection(sources),
     ].map((section) => withSectionTimeout(section, sectionTimeoutMs)),
   );

package/src/tools/__tests__/side-effect-abort-guard.test.ts

@@ -158,6 +158,7 @@ const SKILL_TOOLS: GuardedTool[] = [
   proxied("computer_use_drag"),
   proxied("computer_use_open_app"),
   proxied("computer_use_run_applescript"),
+  proxied("computer_use_sequence"),
   proxied("computer_use_respond"),
 
   { name: "contact_merge", input: { keep_id: "c-1", merge_id: "c-2" } },

package/src/tools/acp/list-agents.test.ts

@@ -90,7 +90,9 @@ describe("executeAcpListAgents", () => {
     const codex = parsed.agents.find((a: { id: string }) => a.id === "codex");
     expect(codex.available).toBe(false);
     expect(codex.unavailableReason).toBe("'codex-acp' is not on PATH");
-    expect(codex.setupHint).toBe("bun add -g @agentclientprotocol/codex-acp");
+    expect(codex.setupHint).toBe(
+      "bun add -g @agentclientprotocol/codex-acp@1.10.0",
+    );
 
     const claude = parsed.agents.find((a: { id: string }) => a.id === "claude");
     expect(claude.available).toBe(true);