@vellumai/assistant 0.8.9-staging.2 → 0.8.9-staging.3

package/src/__tests__/persist-unsendable-image-downscale.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Regression test for the durable-downscale path of the image-too-large
+ * recovery (JARVIS-1041 review follow-up).
+ *
+ * When an oversized stored image *can* be shrunk on this host (the common macOS
+ * path where `sips` is available), `persistUnsendableImageDowngrades` must write
+ * the downscaled bytes back to the DB — not leave the original in place. The
+ * latest tool-result media is intentionally kept in context, so leaving the
+ * full-size block would rehydrate and re-reject on every later turn instead of
+ * durably self-healing the conversation.
+ *
+ * `optimizeImageForTransport` needs `sips` and a decodable image to actually
+ * downscale, which is not portable to CI, so it is mocked here to simulate a
+ * successful shrink. The mock is process-global, so this case lives in its own
+ * file (the test runner isolates each file in its own process) to avoid
+ * disturbing the no-op-resize cases in persist-unsendable-image.test.ts.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ── Module mock (must precede the import of the module under test) ────
+// Simulate a host where resizing succeeds: any oversized image is shrunk to a
+// small, distinct JPEG payload. durableImageReplacement checks the provider
+// caps before calling this, so in-limit images never reach the mock.
+const SHRUNK_DATA = "c2hydW5r"; // base64 for "shrunk"
+mock.module("../agent/image-optimize.js", () => ({
+  optimizeImageForTransport: () => ({
+    data: SHRUNK_DATA,
+    mediaType: "image/jpeg",
+  }),
+}));
+
+import { persistUnsendableImageDowngrades } from "../daemon/persist-unsendable-image.js";
+import {
+  addMessage,
+  createConversation,
+  getMessages,
+} from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import type { ContentBlock } from "../providers/types.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM memory_segments");
+  db.run("DELETE FROM memory_embeddings");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+/** Minimal PNG whose IHDR declares dimensions past the 8000px provider cap. */
+function oversizedPngBase64(): string {
+  const width = 12000;
+  const height = 9000;
+  return Buffer.from(
+    Uint8Array.from([
+      0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, // PNG signature
+      0x00, 0x00, 0x00, 0x0d, // IHDR length (13)
+      0x49, 0x48, 0x44, 0x52, // "IHDR"
+      (width >>> 24) & 0xff,
+      (width >>> 16) & 0xff,
+      (width >>> 8) & 0xff,
+      width & 0xff,
+      (height >>> 24) & 0xff,
+      (height >>> 16) & 0xff,
+      (height >>> 8) & 0xff,
+      height & 0xff,
+      0x08, 0x06, 0x00, 0x00, 0x00,
+    ]),
+  ).toString("base64");
+}
+
+function toolResultWithImage(data: string): ContentBlock {
+  return {
+    type: "tool_result",
+    tool_use_id: "toolu_123",
+    content: "Screenshot captured",
+    contentBlocks: [
+      { type: "image", source: { type: "base64", media_type: "image/png", data } },
+    ],
+  };
+}
+
+function storedContent(conversationId: string): ContentBlock[][] {
+  return getMessages(conversationId).map(
+    (row) => JSON.parse(row.content) as ContentBlock[],
+  );
+}
+
+describe("persistUnsendableImageDowngrades (downscalable host)", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  /** JARVIS-1041: an oversized screenshot that CAN be shrunk must persist the
+   *  downscaled bytes, not the note and not the original. */
+  test("persists the downscaled image for a shrinkable tool_result screenshot", async () => {
+    // GIVEN a tool_result holding an oversized but shrinkable screenshot
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([toolResultWithImage(oversizedPngBase64())]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN the nested block stays an image, rewritten to the downscaled payload
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    const toolResult = content.find((b) => b.type === "tool_result") as {
+      contentBlocks?: ContentBlock[];
+    };
+    const nested = toolResult.contentBlocks?.[0];
+    expect(nested?.type).toBe("image");
+    expect((nested as Extract<ContentBlock, { type: "image" }>).source.data).toBe(
+      SHRUNK_DATA,
+    );
+  });
+
+  /** Re-running is a no-op: the downscaled payload is within limits. */
+  test("is idempotent after a downscale rewrite", async () => {
+    // GIVEN a conversation whose oversized screenshot was already downscaled
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([toolResultWithImage(oversizedPngBase64())]),
+      { skipIndexing: true },
+    );
+    expect(persistUnsendableImageDowngrades(conv.id)).toBe(1);
+
+    // WHEN the downgrade runs again
+    const secondRun = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN nothing further is rewritten
+    expect(secondRun).toBe(0);
+  });
+});

package/src/__tests__/persist-unsendable-image.test.ts

@@ -14,7 +14,10 @@
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import { persistUnsendableImageDowngrades } from "../daemon/persist-unsendable-image.js";
+import {
+  oversizedImageReplacement,
+  persistUnsendableImageDowngrades,
+} from "../daemon/persist-unsendable-image.js";
 import {
   addMessage,
   createConversation,
@@ -87,6 +90,20 @@ function imageBlock(data: string): ContentBlock {
   };
 }
 
+/**
+ * A tool_result carrying a nested image in its contentBlocks, mirroring what a
+ * browser screenshot produces. This is the JARVIS-1041 shape: the oversized
+ * image lives at tool_result.contentBlocks, never as a top-level block.
+ */
+function toolResultWithImage(data: string): ContentBlock {
+  return {
+    type: "tool_result",
+    tool_use_id: "toolu_123",
+    content: "Screenshot captured",
+    contentBlocks: [imageBlock(data)],
+  };
+}
+
 function storedContent(conversationId: string): ContentBlock[][] {
   return getMessages(conversationId).map(
     (row) => JSON.parse(row.content) as ContentBlock[],
@@ -194,6 +211,61 @@ describe("persistUnsendableImageDowngrades", () => {
     expect(content.some((b) => b.type === "image")).toBe(false);
   });
 
+  /** JARVIS-1041: the oversized image is nested inside a tool_result (e.g. a
+   *  browser screenshot), not a top-level block. The downgrade must descend
+   *  into tool_result.contentBlocks and swap the nested image for a note, while
+   *  keeping the tool_result itself intact so tool_use/tool_result pairing
+   *  survives. */
+  test("downgrades an oversized image nested in tool_result.contentBlocks", async () => {
+    // GIVEN an assistant turn whose tool_result holds an oversized screenshot
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([toolResultWithImage(makePngBase64(12000, 9000))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN the message is rewritten with the nested image swapped for a note
+    expect(rewritten).toBe(1);
+    const [content] = storedContent(conv.id);
+    const toolResult = content.find((b) => b.type === "tool_result");
+    expect(toolResult).toBeDefined();
+    // AND the tool_result is preserved (pairing intact) with no image left
+    const nested = (toolResult as { contentBlocks?: ContentBlock[] })
+      .contentBlocks;
+    expect(nested?.some((b) => b.type === "image")).toBe(false);
+    expect(nested?.some((b) => b.type === "text")).toBe(true);
+  });
+
+  /** A sendable nested screenshot is never disturbed. */
+  test("leaves a normally-sized tool_result image untouched", async () => {
+    // GIVEN a tool_result with an image well within provider limits
+    const conv = createConversation();
+    await addMessage(
+      conv.id,
+      "user",
+      JSON.stringify([toolResultWithImage(makePngBase64(1024, 768))]),
+      { skipIndexing: true },
+    );
+
+    // WHEN the downgrade is persisted
+    const rewritten = persistUnsendableImageDowngrades(conv.id);
+
+    // THEN nothing is rewritten and the nested image remains
+    expect(rewritten).toBe(0);
+    const [content] = storedContent(conv.id);
+    const toolResult = content.find((b) => b.type === "tool_result") as {
+      contentBlocks?: ContentBlock[];
+    };
+    expect(toolResult.contentBlocks?.some((b) => b.type === "image")).toBe(
+      true,
+    );
+  });
+
   /** Re-running after a rewrite is a safe no-op (no image blocks remain). */
   test("is idempotent — a second run rewrites nothing", async () => {
     // GIVEN a conversation whose oversized image has already been downgraded
@@ -213,3 +285,27 @@ describe("persistUnsendableImageDowngrades", () => {
     expect(secondRun).toBe(0);
   });
 });
+
+describe("oversizedImageReplacement", () => {
+  /** A still-sendable image must be left alone — never replaced with a note.
+   *  This is the gate that keeps the in-memory recovery from discarding valid
+   *  screenshots when only one image in the turn was actually oversized. */
+  test("returns null for an image within the provider caps", () => {
+    const sendable = imageBlock(makePngBase64(1024, 768)) as Extract<
+      ContentBlock,
+      { type: "image" }
+    >;
+    expect(oversizedImageReplacement(sendable)).toBeNull();
+  });
+
+  /** An image past the provider caps that cannot be shrunk on this host (fake
+   *  PNG that sips cannot decode) collapses to the unsendable note. */
+  test("returns the unsendable note when an oversized image cannot be shrunk", () => {
+    const oversized = imageBlock(makePngBase64(12000, 9000)) as Extract<
+      ContentBlock,
+      { type: "image" }
+    >;
+    const replacement = oversizedImageReplacement(oversized);
+    expect(replacement?.type).toBe("text");
+  });
+});

package/src/__tests__/post-turn-tool-result-truncation.test.ts

@@ -12,6 +12,7 @@ import {
   TARGET_CHARS,
   THRESHOLD_CHARS,
   TOOL_RESULT_DIR,
+  TRUNCATION_EXEMPT_TOOLS,
   TRUNCATION_MARKER,
 } from "../context/post-turn-tool-result-truncation.js";
 import type { ContentBlock, Message } from "../providers/types.js";
@@ -151,6 +152,74 @@ describe("postTurnTruncateToolResults", () => {
     expect(stub).toContain(filePath);
   });
 
+  test("skill_load result above threshold is NOT truncated (durable instructions exempt)", () => {
+    // Regression for JARVIS-1000: a hosted assistant lost its app-builder skill
+    // workflow when the large skill_load result was middle-truncated between the
+    // turn that loaded the skill and the turn that used it, then fell back to a
+    // local-dev (vite/localhost) build path.
+    const toolUseId = "tool_skill_load";
+    const skillBody = "S".repeat(THRESHOLD_CHARS + 5_000);
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use" as const,
+            id: toolUseId,
+            name: "skill_load",
+            input: { skill: "app-builder" },
+          },
+        ],
+      },
+      { role: "user", content: [makeToolResult(skillBody, toolUseId)] },
+    ];
+
+    const { messages: result, truncatedCount } =
+      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+
+    expect(truncatedCount).toBe(0);
+    expect(result).toBe(messages); // same reference — no copy
+    expect(existsSync(join(convDir, TOOL_RESULT_DIR))).toBe(false);
+
+    const block = result[1].content[0] as {
+      type: "tool_result";
+      content: string;
+    };
+    expect(block.content).toBe(skillBody);
+    expect(TRUNCATION_EXEMPT_TOOLS.has("skill_load")).toBe(true);
+  });
+
+  test("non-exempt tool result above threshold is still truncated when paired with a tool_use", () => {
+    // Control for the exemption: same shape as the skill_load case, but a tool
+    // that is NOT exempt must still be truncated.
+    const toolUseId = "tool_bash_1";
+    const longContent = "B".repeat(THRESHOLD_CHARS + 5_000);
+    const messages: Message[] = [
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use" as const,
+            id: toolUseId,
+            name: "bash",
+            input: { command: "cat big.log" },
+          },
+        ],
+      },
+      { role: "user", content: [makeToolResult(longContent, toolUseId)] },
+    ];
+
+    const { messages: result, truncatedCount } =
+      postTurnTruncateToolResults(messages, { conversationDir: convDir });
+
+    expect(truncatedCount).toBe(1);
+    const block = result[1].content[0] as {
+      type: "tool_result";
+      content: string;
+    };
+    expect(block.content).toContain(TRUNCATION_MARKER);
+  });
+
   test("file path is deterministic for the same toolUseId", () => {
     const id = "tool_use_deterministic";
     const path1 = getToolResultFilePath("/some/dir", id);

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -233,10 +233,9 @@ describe("frontmatter feature-flag integration", () => {
 // ---------------------------------------------------------------------------
 
 describe("bundled acp skill discoverability", () => {
-  test("acp skill resolves with the flag off and config.acp disabled (no frontmatter flag gate)", () => {
-    // The ACP skill carries its own first-time-setup instructions, so it must
-    // stay visible even when the acp flag and config.acp.enabled are both off.
-    // Runtime enforcement happens in the ACP tools via isAcpEnabled instead.
+  test("acp skill resolves with no frontmatter flag gate", () => {
+    // The ACP skill carries its own first-time-setup instructions and is
+    // always discoverable: it has no frontmatter feature-flag gate.
     const skillMdPath = fileURLToPath(
       new URL("../config/bundled-skills/acp/SKILL.md", import.meta.url),
     );
@@ -247,10 +246,9 @@ describe("bundled acp skill discoverability", () => {
     expect(skill!.featureFlag).toBeUndefined();
     expect(skillFlagKey(skill!)).toBeUndefined();
 
-    // acp flag at its registry default (off) and config.acp disabled.
     const config = makeConfig({
-      acp: { enabled: false, maxConcurrentSessions: 4, agents: {} },
-    } as Partial<AssistantConfig>);
+      acp: { maxConcurrentSessions: 4, agents: {} },
+    });
 
     const resolved = resolveSkillStates([skill!], config);
     expect(resolved.length).toBe(1);

package/src/__tests__/title-generate-hook.test.ts

@@ -76,6 +76,8 @@ function makeCtx(
   ];
   return {
     conversationId: "conv-1",
+    userMessageId: "msg-1",
+    requestId: "req-1",
     prompt: "first message",
     originalMessages: messages,
     latestMessages: messages,

package/src/__tests__/web-fetch.test.ts

@@ -5,6 +5,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import {
   buildFetchResponseFromNodeResponse,
   executeWebFetch,
+  getUpstreamStatus,
 } from "../tools/network/web-fetch.js";
 
 describe("web_fetch tool", () => {
@@ -62,6 +63,50 @@ describe("web_fetch tool", () => {
     expect(await response.text()).toBe("");
   });
 
+  test("buildFetchResponseFromNodeResponse does not throw on non-standard status codes", async () => {
+    const stream = new PassThrough() as PassThrough & {
+      statusCode?: number;
+      statusMessage?: string;
+      headers: IncomingHttpHeaders;
+    };
+    stream.statusCode = 999;
+    stream.statusMessage = "Request Denied";
+    stream.headers = { "content-type": "text/html; charset=utf-8" };
+    stream.end("blocked by anti-bot gateway");
+
+    const response = buildFetchResponseFromNodeResponse(stream);
+    // The Response object clamps to a constructable code, but the real upstream
+    // status is preserved for reporting.
+    expect(response.status).toBe(502);
+    expect(getUpstreamStatus(response)).toBe(999);
+    expect(response.ok).toBe(false);
+    expect(await response.text()).toBe("blocked by anti-bot gateway");
+  });
+
+  test("surfaces a non-standard status as a tool error instead of crashing", async () => {
+    const result = await executeWithMockFetch(
+      { url: "https://www.linkedin.com/jobs/view/123" },
+      {
+        requestExecutor: async () => {
+          const stream = new PassThrough() as PassThrough & {
+            statusCode?: number;
+            statusMessage?: string;
+            headers: IncomingHttpHeaders;
+          };
+          stream.statusCode = 999;
+          stream.statusMessage = "Request Denied";
+          stream.headers = { "content-type": "text/html; charset=utf-8" };
+          stream.end("<html><body>blocked</body></html>");
+          return buildFetchResponseFromNodeResponse(stream);
+        },
+      },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("HTTP 999");
+    expect(result.activityMetadata?.webFetch?.status).toBe(999);
+  });
+
   test("rejects missing url", async () => {
     const result = await executeWithMockFetch({});
     expect(result.isError).toBe(true);

package/src/acp/__tests__/helpers/acp-config-stub.ts

@@ -20,13 +20,11 @@ import { mock } from "bun:test";
 import type { AcpAgentConfig } from "../../../config/acp-schema.js";
 
 export interface MockAcpConfig {
-  enabled: boolean;
   maxConcurrentSessions: number;
   agents: Record<string, AcpAgentConfig>;
 }
 
 const DEFAULT_CONFIG: MockAcpConfig = {
-  enabled: true,
   maxConcurrentSessions: 4,
   agents: {},
 };

package/src/acp/resolve-agent.test.ts

@@ -1,25 +1,19 @@
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
-import { setOverridesForTesting } from "../__tests__/feature-flag-test-helpers.js";
 import { installAcpConfigStub } from "./__tests__/helpers/acp-config-stub.js";
 import { installWhichStub } from "./__tests__/helpers/which-stub.js";
-import { ACP_FLAG_KEY } from "./feature-gate.js";
 
 const config = await installAcpConfigStub();
 const which = installWhichStub();
 
 afterAll(() => {
   which.restore();
-  setOverridesForTesting({});
 });
 
 const { resolveAcpAgent, listAcpAgents } = await import("./resolve-agent.js");
 
 beforeEach(() => {
   config.setConfig({});
-  // Default: no flag overrides, so the `acp` flag falls back to its registry
-  // default (false) and enablement comes from the config stub alone.
-  setOverridesForTesting({});
   // Default: every command on PATH so binary preflight passes unless a test
   // explicitly says otherwise.
   which.setWhich((cmd) => `/usr/local/bin/${cmd}`);
@@ -30,32 +24,6 @@ beforeEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("resolveAcpAgent", () => {
-  test("returns acp_disabled when both the feature flag and config.acp.enabled are off", () => {
-    config.setConfig({ enabled: false });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(false);
-    if (result.ok) return;
-    expect(result.reason).toBe("acp_disabled");
-    if (result.reason !== "acp_disabled") return;
-    expect(result.hint).toContain("ACP Coding Agents");
-    expect(result.hint).toContain("feature flag");
-    expect(result.hint).toContain("acp.enabled");
-    expect(result.hint).toContain("config.json");
-  });
-
-  test("resolution proceeds when the acp feature flag is on and config.acp.enabled is false", () => {
-    config.setConfig({ enabled: false });
-    setOverridesForTesting({ [ACP_FLAG_KEY]: true });
-
-    const result = resolveAcpAgent("claude");
-
-    expect(result.ok).toBe(true);
-    if (!result.ok) return;
-    expect(result.agent.command).toBe("claude-agent-acp");
-  });
-
   test("user config wins over default profile", () => {
     config.setConfig({
       agents: {
@@ -359,35 +327,11 @@ describe("resolveAcpAgent - missing binary", () => {
 // ---------------------------------------------------------------------------
 
 describe("listAcpAgents", () => {
-  test("returns enabled: false with empty agents when both the flag and config are off", () => {
-    config.setConfig({ enabled: false });
-
-    const result = listAcpAgents();
-
-    expect(result.enabled).toBe(false);
-    expect(result.agents).toEqual([]);
-  });
-
-  test("returns the catalog when the acp feature flag is on and config.acp.enabled is false", () => {
-    config.setConfig({ enabled: false });
-    setOverridesForTesting({ [ACP_FLAG_KEY]: true });
-
-    const result = listAcpAgents();
-
-    expect(result.enabled).toBe(true);
-    expect(result.agents.map((a) => a.id)).toEqual([
-      "claude",
-      "codex",
-      "gemini",
-    ]);
-  });
-
   test("includes all bundled defaults when user config is empty", () => {
     config.setConfig({ agents: {} });
 
     const result = listAcpAgents();
 
-    expect(result.enabled).toBe(true);
     const ids = result.agents.map((a) => a.id);
     expect(ids).toEqual(["claude", "codex", "gemini"]);
     for (const entry of result.agents) {

package/src/acp/resolve-agent.ts

@@ -3,15 +3,13 @@
  *
  * `resolveAcpAgent(id)` merges user-provided `config.acp.agents[id]` (wins on
  * overlap) with the bundled `DEFAULT_ACP_AGENT_PROFILES` so common agents like
- * `claude` and `codex` Just Work whenever ACP is enabled (the `acp` feature
- * flag or `acp.enabled: true`; see `feature-gate.ts`), with no per-user
- * config required. Natural names ("claude code", "Gemini CLI") resolve via
- * `AGENT_ID_ALIASES` when the raw id misses both maps. The result is a
- * discriminated union covering every reason
- * a spawn might fail before we even start the agent process: ACP disabled,
- * unknown agent id, or binary missing from PATH. Callers (acp_spawn,
- * acp_list_agents, and the `/v1/acp/spawn` HTTP route) get a single source
- * of truth and matching actionable hints.
+ * `claude` and `codex` Just Work with no per-user config required. Natural
+ * names ("claude code", "Gemini CLI") resolve via `AGENT_ID_ALIASES` when the
+ * raw id misses both maps. The result is a discriminated union covering every
+ * reason a spawn might fail before we even start the agent process: unknown
+ * agent id, or binary missing from PATH. Callers (acp_spawn, acp_list_agents,
+ * and the `/v1/acp/spawn` HTTP route) get a single source of truth and
+ * matching actionable hints.
  *
  * The resolver NEVER fetches or runs packages in the (untrusted) task cwd.
  * When the adapter binary is missing, resolution simply fails with
@@ -33,7 +31,6 @@ import {
 } from "../config/acp-defaults.js";
 import type { AcpAgentConfig } from "../config/acp-schema.js";
 import { getConfig } from "../config/loader.js";
-import { isAcpEnabled } from "./feature-gate.js";
 
 /**
  * Whether this agent's entry came from user config (wins over default) or
@@ -47,7 +44,6 @@ export type ResolveAcpAgentResult =
   | ResolveAcpAgentFailure;
 
 export type ResolveAcpAgentFailure =
-  | { ok: false; reason: "acp_disabled"; hint: string }
   | { ok: false; reason: "unknown_agent"; available: string[] }
   | {
       ok: false;
@@ -68,8 +64,6 @@ export function formatResolveFailure(
   failure: ResolveAcpAgentFailure,
 ): string {
   switch (failure.reason) {
-    case "acp_disabled":
-      return failure.hint;
     case "unknown_agent":
       return `Unknown agent "${agentId}". Available: ${failure.available.join(", ")}.`;
     case "binary_not_found":
@@ -93,14 +87,6 @@ interface AcpAgentEntry {
   setupHint?: string;
 }
 
-/**
- * Single-source-of-truth hint for "ACP is disabled". Exported so any caller
- * that surfaces a disabled-state message (resolver, list-agents tool) reads
- * the same string instead of duplicating near-identical copy.
- */
-export const ACP_DISABLED_HINT =
-  "Enable the \"ACP Coding Agents\" feature flag in the client's feature flags UI (or set 'acp.enabled': true in ~/.vellum/workspace/config.json).";
-
 function installHintFor(command: string): string {
   const pkg = DEFAULT_AGENT_NPM_PACKAGES[command];
   return pkg
@@ -209,9 +195,8 @@ function mergedAgentIds(userAgents: Record<string, AcpAgentConfig>): string[] {
  * Resolve an ACP agent id to its config + binary preflight result.
  *
  * Order of checks:
- * 1. ACP must be enabled (feature flag or config; see `isAcpEnabled`).
- * 2. The id must resolve to an agent (user config wins; falls back to defaults).
- * 3. The agent must be runnable: its `command` on PATH (see
+ * 1. The id must resolve to an agent (user config wins; falls back to defaults).
+ * 2. The agent must be runnable: its `command` on PATH (see
  *    `resolveRunnableAgent`).
  *
  * Each failure mode carries an actionable hint so callers can surface a
@@ -219,10 +204,6 @@ function mergedAgentIds(userAgents: Record<string, AcpAgentConfig>): string[] {
  */
 export function resolveAcpAgent(id: string): ResolveAcpAgentResult {
   const config = getConfig();
-  if (!isAcpEnabled(config)) {
-    return { ok: false, reason: "acp_disabled", hint: ACP_DISABLED_HINT };
-  }
-
   const userAgents = config.acp.agents;
   const found = lookupAgent(userAgents, id);
   if (!found) {
@@ -252,20 +233,11 @@ export function resolveAcpAgent(id: string): ResolveAcpAgentResult {
  * plus any user-only entries — with per-entry availability info. Used by the
  * `acp_list_agents` tool to render setup steps when an agent's binary isn't
  * installed yet.
- *
- * `enabled: false` short-circuits and returns an empty catalog so the tool
- * can render a single "ACP is disabled" hint instead of advertising agents
- * the user can't actually run.
  */
 export function listAcpAgents(): {
-  enabled: boolean;
   agents: AcpAgentEntry[];
 } {
   const config = getConfig();
-  if (!isAcpEnabled(config)) {
-    return { enabled: false, agents: [] };
-  }
-
   const userAgents = config.acp.agents;
   const agents: AcpAgentEntry[] = mergedAgentIds(userAgents).map((id) => {
     // Non-null: ids come from `mergedAgentIds` so the lookup always resolves.
@@ -288,5 +260,5 @@ export function listAcpAgents(): {
     return entry;
   });
 
-  return { enabled: true, agents };
+  return { agents };
 }