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

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__/published-app-updater.test.ts

@@ -0,0 +1,138 @@
+/**
+ * Tests that the auto-redeploy path deploys the app's *effective* HTML
+ * (dist/index.html for multifile apps) rather than the empty `htmlDefinition`.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { AppDefinition } from "../memory/app-store.js";
+
+// ── Mocks ───────────────────────────────────────────────────────────────
+
+let mockApp: AppDefinition | null = null;
+let mockIsMultifile = false;
+let mockEffectiveHtml = "";
+// A directory that does not exist on disk, so the multifile dist-existence
+// guard reads `false` from the real fs without mocking node:fs (which would
+// leak across test files).
+let mockAppDir = "/tmp/__vellum_test_nonexistent__/app-1";
+
+mock.module("../memory/app-store.js", () => ({
+  getApp: () => mockApp,
+  getAppDirPath: () => mockAppDir,
+  isMultifileApp: () => mockIsMultifile,
+  resolveEffectiveAppHtml: () => mockEffectiveHtml,
+}));
+
+let mockPublishedPage: {
+  id: string;
+  projectSlug?: string;
+  htmlHash: string;
+} | null = null;
+const updatePublishedPageSpy = mock(() => {});
+
+mock.module("../memory/published-pages-store.js", () => ({
+  getActivePublishedPageByAppId: () => mockPublishedPage,
+  updatePublishedPage: updatePublishedPageSpy,
+}));
+
+const deploySpy = mock(async (_args: { html: string; name: string }) => ({
+  deploymentId: "dep-1",
+  url: "https://example.vercel.app",
+}));
+
+mock.module("../services/vercel-deploy.js", () => ({
+  deployHtmlToVercel: deploySpy,
+}));
+
+// credentialBroker.serverUse invokes execute(token) and reports success.
+mock.module("../tools/credentials/broker.js", () => ({
+  credentialBroker: {
+    serverUse: async ({
+      execute,
+    }: {
+      execute: (token: string) => Promise<unknown>;
+    }) => {
+      await execute("test-token");
+      return { success: true };
+    },
+  },
+}));
+
+const { updatePublishedAppDeployment } =
+  await import("../services/published-app-updater.js");
+
+function makeApp(overrides: Partial<AppDefinition> = {}): AppDefinition {
+  return {
+    id: "app-1",
+    name: "App",
+    schemaJson: "{}",
+    htmlDefinition: "",
+    createdAt: 1,
+    updatedAt: 2,
+    ...overrides,
+  };
+}
+
+// ── Tests ───────────────────────────────────────────────────────────────
+
+describe("updatePublishedAppDeployment", () => {
+  beforeEach(() => {
+    mockApp = makeApp();
+    mockIsMultifile = false;
+    mockEffectiveHtml = "";
+    mockPublishedPage = { id: "pp-1", projectSlug: "slug", htmlHash: "old" };
+    mockAppDir = "/tmp/__vellum_test_nonexistent__/app-1";
+    deploySpy.mockClear();
+    updatePublishedPageSpy.mockClear();
+  });
+
+  test("deploys the resolved effective HTML, not the empty htmlDefinition", async () => {
+    // htmlDefinition is "" (as it is for every multifile app); the real
+    // content comes from resolveEffectiveAppHtml. isMultifile=false here keeps
+    // the dist guard out of the way so the assertion targets the html source.
+    mockApp = makeApp({ htmlDefinition: "" });
+    mockEffectiveHtml = "<html><body>real app</body></html>";
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).toHaveBeenCalledTimes(1);
+    expect(deploySpy.mock.calls[0][0].html).toBe(
+      "<html><body>real app</body></html>",
+    );
+  });
+
+  test("skips deploy when a multifile app has no compiled output", async () => {
+    mockIsMultifile = true;
+    mockApp = makeApp({ formatVersion: 2 });
+    mockEffectiveHtml = "<p>App compilation failed.</p>";
+    // mockAppDir does not exist → dist/index.html is absent.
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).not.toHaveBeenCalled();
+  });
+
+  test("skips deploy when content hash is unchanged", async () => {
+    const html = "<html>same</html>";
+    mockEffectiveHtml = html;
+    const { createHash } = await import("node:crypto");
+    mockPublishedPage = {
+      id: "pp-1",
+      htmlHash: createHash("sha256").update(html).digest("hex"),
+    };
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).not.toHaveBeenCalled();
+  });
+
+  test("skips deploy when the app has no active published page", async () => {
+    mockPublishedPage = null;
+    mockEffectiveHtml = "<html>x</html>";
+
+    await updatePublishedAppDeployment("app-1");
+
+    expect(deploySpy).not.toHaveBeenCalled();
+  });
+});

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 };
 }

package/src/agent/loop.ts

@@ -10,27 +10,22 @@ import {
   estimateToolsTokens,
   getCalibrationProviderKey,
 } from "../context/token-estimator.js";
-import type { ContextWindowResult } from "../context/window-manager.js";
 import type { InboundActorContext } from "../daemon/conversation-runtime-assembly.js";
 import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { stripHistoricalWebSearchResults } from "../daemon/web-search-history.js";
 import { HOOKS } from "../plugin-api/constants.js";
 import type {
-  AssistantMessageContext,
+  PostModelCallContext,
   PostToolUseContext,
   PreModelCallContext,
   StopContext,
 } from "../plugin-api/types.js";
-import {
-  DEFAULT_COMPACTION_PLUGIN_NAME,
-  defaultCompact,
-} from "../plugins/defaults/compaction/compact.js";
-import { getContextWindowManager } from "../plugins/defaults/compaction/manager-store.js";
+import { defaultCompact } from "../plugins/defaults/compaction/compact.js";
+import type { ContextWindowResult } from "../plugins/defaults/compaction/window-manager.js";
 import postCompact from "../plugins/defaults/memory-retrieval/hooks/post-compact.js";
 import { runHook } from "../plugins/pipeline.js";
 import type { CompactionCircuitEvent } from "../plugins/types.js";
-import { PluginExecutionError } from "../plugins/types.js";
 import { normalizeThinkingConfigForWire } from "../providers/thinking-config.js";
 import type {
   ContentBlock,
@@ -730,17 +725,8 @@ export class AgentLoop {
     // Record the history-stripped marker right after stripping, before the
     // pipeline runs.
     await onEvent({ type: "history_stripped" });
-    // The compaction module owns the per-conversation manager; resolve it from
-    // the store rather than holding a handle on the loop. Absent for callers
-    // without a compaction path (agent wakes, standalone unit tests), which
-    // never reach this gate.
-    const manager = getContextWindowManager(this.conversationId);
-    if (manager == null) {
-      throw new PluginExecutionError(
-        `default-compaction: no ContextWindowManager registered for conversation ${this.conversationId} — the compaction store must construct one before compaction runs`,
-        DEFAULT_COMPACTION_PLUGIN_NAME,
-      );
-    }
+    // The compaction module owns the per-conversation manager; pass the
+    // conversation id and let `defaultCompact` resolve it from the store.
     // The mid-loop budget gate is reached only when this turn decides to
     // compact in place, so `force` past the auto-threshold check.
     // `actorTrustClass` comes from the turn's trust snapshot (the actor whose
@@ -748,7 +734,7 @@ export class AgentLoop {
     // guardian-only attachments for untrusted actors. `overrideProfile` is the
     // turn's resolved inference-profile override for the summary call.
     const compactResult = await defaultCompact({
-      manager,
+      conversationId: this.conversationId,
       messages: rawHistory,
       signal,
       force: true,
@@ -1114,7 +1100,7 @@ export class AgentLoop {
 
         // A `pre-model-call` hook (below) can defer this turn's assistant
         // output; when set, the live text stream is held so an
-        // `assistant-message` hook can emit the finalized (transformed) text
+        // `post-model-call` hook can emit the finalized (transformed) text
         // instead. Reset per model call.
         let deferAssistantOutput = false;
 
@@ -1128,7 +1114,7 @@ export class AgentLoop {
           onEvent: (event) => {
             if (event.type === "text_delta") {
               // Held when the turn's output is deferred — the final text is
-              // emitted once, after the `assistant-message` hook runs.
+              // emitted once, after the `post-model-call` hook runs.
               if (deferAssistantOutput) return;
               // Apply sensitive-output placeholder substitution (chunk-safe)
               if (substitutionMap.size > 0) {
@@ -1298,7 +1284,7 @@ export class AgentLoop {
           streamingPending = "";
         }
 
-        // Run the `assistant-message` hook on a finalized message and, when
+        // Run the `post-model-call` hook on a finalized message and, when
         // output was deferred, emit the finalized text once (with sensitive-output
         // substitution applied, matching the live stream). Fail-open: the hook
         // receives a clone, so a throw — even mid in-place mutation — leaves the
@@ -1308,19 +1294,19 @@ export class AgentLoop {
         ): Promise<Message> => {
           let finalized = message;
           try {
-            const ctx: AssistantMessageContext = {
+            const ctx: PostModelCallContext = {
               conversationId: this.conversationId,
               callSite,
               content: structuredClone(message.content),
               stopReason: response.stopReason,
               logger: rlog,
             };
-            const result = await runHook(HOOKS.ASSISTANT_MESSAGE, ctx);
+            const result = await runHook(HOOKS.POST_MODEL_CALL, ctx);
             finalized = { role: "assistant", content: result.content };
           } catch (assistantMessageError) {
             rlog.error(
               { err: assistantMessageError },
-              "assistant-message hook failed — keeping the original content",
+              "post-model-call hook failed — keeping the original content",
             );
             finalized = message;
           }
@@ -1460,7 +1446,7 @@ export class AgentLoop {
           }
         }
 
-        // Run the `assistant-message` hook + emit any deferred final text.
+        // Run the `post-model-call` hook + emit any deferred final text.
         // On a no-tool turn this point is reached only after the `stop` hook
         // resolves to "stop" (a `continue` already re-queried above), so a
         // re-queried reply is never transformed-then-discarded.