@vellumai/assistant 0.8.10 → 0.8.11-staging.1

package/src/__tests__/empty-response-hook.test.ts

@@ -1,23 +1,29 @@
 /**
- * Tests for the default `empty-response` plugin's `stop` hook.
+ * Tests for the default `empty-response` plugin's hooks.
  *
  * Covers:
- * - The default hook's binary decision for the canonical cases: empty turn
+ * - The `post-model-call` hook's decision for the canonical cases: empty turn
  *   after a prior tool-use turn → continue (with the canonical nudge text);
  *   visible text → stop; prior turn already delivered visible text → stop;
- *   first model call with no prior turn → stop; provider refusal → continue
- *   (with the refusal-specific nudge text); refusal-but-recovered → stop.
+ *   first model call with no prior turn → stop; provider refusal → stop with
+ *   the turn rewritten to the user-facing fallback; refusal-but-recovered →
+ *   stop; refusal after a visible reply this run → stop with no rewrite.
  * - The hook scopes its prior-turn signals to the current response cycle (the
  *   messages after the last genuine user prompt), so visible text from the
  *   inbound conversation does not suppress the nudge.
  * - When the hook continues, it appends the nudge as a `user` message to
  *   `messages`.
+ * - The retry bound is split across the two hooks: `post-model-call` marks the
+ *   bound (nudging at most once per run) and the `stop` hook clears it on the
+ *   definitive terminal so the next run nudges afresh.
+ * - The hook ignores outcomes it does not own: a provider rejection (it carries
+ *   an `error`) and a tool-bearing turn (the loop continues on its own).
  * - End-to-end through `runHook` + the registry: registering the default
  *   plugin makes the hook fire, and a later-registered user hook chains after
  *   it and can read/override the decision.
  *
- * The loop's actual side-effects (retry-budget cap, history splice, log
- * emission) live in `agent/loop.ts` and are covered by integration tests in
+ * The loop's actual side-effects (per-run backstop, history splice, streamed
+ * output) live in `agent/loop.ts` and are covered by integration tests in
  * `conversation-agent-loop.test.ts` / `agent-loop.test.ts`. This file isolates
  * the hook.
  */
@@ -25,12 +31,22 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
 import { HOOKS } from "../plugin-api/constants.js";
-import type { PluginLogger, StopContext } from "../plugin-api/types.js";
+import type {
+  PluginLogger,
+  PostModelCallContext,
+  StopContext,
+} from "../plugin-api/types.js";
 import {
   NUDGE_TEXT,
-  REFUSAL_NUDGE_TEXT,
-} from "../plugins/defaults/empty-response/hooks/stop.js";
+  REFUSAL_FALLBACK_TEXT,
+} from "../plugins/defaults/empty-response/hooks/post-model-call.js";
+import postModelCall from "../plugins/defaults/empty-response/hooks/post-model-call.js";
 import stop from "../plugins/defaults/empty-response/hooks/stop.js";
+import {
+  isEmptyResponseNudged,
+  markEmptyResponseNudged,
+  resetEmptyResponseNudgeStoreForTests,
+} from "../plugins/defaults/empty-response/nudge-state-store.js";
 import { defaultEmptyResponsePlugin } from "../plugins/defaults/index.js";
 import { runHook } from "../plugins/pipeline.js";
 import {
@@ -67,11 +83,14 @@ function userPrompt(text: string): Message {
   return { role: "user", content: [{ type: "text", text }] };
 }
 
-function makeCtx(overrides: Partial<StopContext> = {}): StopContext {
+function makeCtx(
+  overrides: Partial<PostModelCallContext> = {},
+): PostModelCallContext {
   return {
-    conversationId: "conv-stop",
+    conversationId: "conv-pmc",
+    callSite: "mainAgent",
+    content: [],
     messages: [],
-    responseContent: [],
     stopReason: null,
     decision: "stop",
     logger: noopLogger,
@@ -79,19 +98,23 @@ function makeCtx(overrides: Partial<StopContext> = {}): StopContext {
   };
 }
 
+beforeEach(() => {
+  resetEmptyResponseNudgeStoreForTests();
+});
+
 // ─── Default decisions ───────────────────────────────────────────────────────
 
-describe("empty-response stop hook — default decisions", () => {
+describe("empty-response post-model-call hook — default decisions", () => {
   test("empty turn after a prior tool-use turn → continue with canonical nudge", async () => {
     // GIVEN a run that already issued a tool call, then returned an empty
     // (whitespace-only) assistant turn with no visible text.
     const ctx = makeCtx({
       messages: [priorToolUseTurn],
-      responseContent: [emptyTextBlock],
+      content: [emptyTextBlock],
     });
 
-    // WHEN the default stop hook runs.
-    await stop(ctx);
+    // WHEN the default post-model-call hook runs.
+    await postModelCall(ctx);
 
     // THEN it asks the loop to continue and appends the canonical nudge.
     expect(ctx.decision).toBe("continue");
@@ -105,28 +128,44 @@ describe("empty-response stop hook — default decisions", () => {
     // GIVEN a turn that delivered visible text.
     const ctx = makeCtx({
       messages: [priorToolUseTurn],
-      responseContent: [{ type: "text", text: "here is a summary" }],
+      content: [{ type: "text", text: "here is a summary" }],
     });
 
     // WHEN the hook runs.
-    await stop(ctx);
+    await postModelCall(ctx);
 
     // THEN the decision stays at stop and nothing is appended.
     expect(ctx.decision).toBe("stop");
     expect(ctx.messages).toEqual([priorToolUseTurn]);
   });
 
+  test("tool-bearing turn is ignored — no nudge, no rewrite", async () => {
+    // GIVEN a turn that carries a tool call (the loop continues on its own to
+    // run the tool, so the retry decision is not the hook's to make).
+    const ctx = makeCtx({
+      messages: [priorToolUseTurn],
+      content: [{ type: "tool_use", id: "tu_2", name: "read_file", input: {} }],
+    });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN it leaves the decision and history untouched.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toEqual([priorToolUseTurn]);
+  });
+
   test("prior turn already delivered visible text → stop", async () => {
     // GIVEN the model said its piece in an earlier turn this run, then ended
     // with a side-effect tool and returned empty. Nudging would force a
     // verbatim re-send of text the user already saw.
     const ctx = makeCtx({
       messages: [userPrompt("do X"), priorVisibleTextTurn, priorToolUseTurn],
-      responseContent: [],
+      content: [],
     });
 
     // WHEN the hook runs.
-    await stop(ctx);
+    await postModelCall(ctx);
 
     // THEN the decision stays at stop.
     expect(ctx.decision).toBe("stop");
@@ -143,11 +182,11 @@ describe("empty-response stop hook — default decisions", () => {
         userPrompt("do the next thing"),
         priorToolUseTurn,
       ],
-      responseContent: [],
+      content: [],
     });
 
     // WHEN the hook runs.
-    await stop(ctx);
+    await postModelCall(ctx);
 
     // THEN it continues — the cycle scope sees only the tool-use turn, not the
     // inbound conversation's visible text.
@@ -161,10 +200,10 @@ describe("empty-response stop hook — default decisions", () => {
   test("first model call with no prior turn → stop", async () => {
     // GIVEN an empty first assistant response with no prior turn this run and
     // no refusal — not the pattern the organic-empty-turn nudge guards against.
-    const ctx = makeCtx({ messages: [], responseContent: [] });
+    const ctx = makeCtx({ messages: [], content: [] });
 
     // WHEN the hook runs.
-    await stop(ctx);
+    await postModelCall(ctx);
 
     // THEN the decision stays at stop.
     expect(ctx.decision).toBe("stop");
@@ -172,88 +211,225 @@ describe("empty-response stop hook — default decisions", () => {
 
   // ─── Refusal stop ──────────────────────────────────────────────────────────
 
-  test("refusal on the first call with no content → continue with refusal nudge", async () => {
+  test("refusal on the first call with no content → stop with rewritten fallback", async () => {
     // GIVEN the canonical failure mode: the provider's safety classifier zeros
     // the response on the very first model call, returning `stopReason:
     // "refusal"` and no visible text.
     const ctx = makeCtx({
       messages: [],
-      responseContent: [],
+      content: [],
       stopReason: "refusal",
     });
 
     // WHEN the hook runs.
-    await stop(ctx);
+    await postModelCall(ctx);
 
-    // THEN it continues with the refusal-specific nudge, even with no prior turn.
-    expect(ctx.decision).toBe("continue");
-    expect(ctx.messages.at(-1)).toEqual({
-      role: "user",
-      content: [{ type: "text", text: REFUSAL_NUDGE_TEXT }],
-    });
+    // THEN it lets the turn end and rewrites the turn content to the
+    // user-facing fallback, without nudging the model.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.content).toEqual([
+      { type: "text", text: REFUSAL_FALLBACK_TEXT },
+    ]);
+    expect(ctx.messages).toEqual([]);
   });
 
-  test("refusal with a thinking-only block still continues", async () => {
+  test("refusal with a thinking-only block is still rewritten", async () => {
     // GIVEN a refusal whose only content is a thinking block — the user sees
     // nothing.
     const ctx = makeCtx({
       messages: [],
-      responseContent: [
-        { type: "thinking", thinking: "...", signature: "sig" },
-      ],
+      content: [{ type: "thinking", thinking: "...", signature: "sig" }],
       stopReason: "refusal",
     });
 
     // WHEN the hook runs.
-    await stop(ctx);
+    await postModelCall(ctx);
 
-    // THEN it continues with the refusal-specific nudge.
-    expect(ctx.decision).toBe("continue");
-    expect(ctx.messages.at(-1)).toEqual({
-      role: "user",
-      content: [{ type: "text", text: REFUSAL_NUDGE_TEXT }],
-    });
+    // THEN it stops and rewrites the turn content to the fallback.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.content).toEqual([
+      { type: "text", text: REFUSAL_FALLBACK_TEXT },
+    ]);
   });
 
-  test("refusal but visible text present → stop (model recovered)", async () => {
+  test("refusal but visible text present → stop, no rewrite (model recovered)", async () => {
     // GIVEN a refusal that still delivered some visible text before refusing —
     // the user has something to see.
     const ctx = makeCtx({
-      responseContent: [{ type: "text", text: "partial answer" }],
+      content: [{ type: "text", text: "partial answer" }],
       stopReason: "refusal",
     });
 
     // WHEN the hook runs.
-    await stop(ctx);
+    await postModelCall(ctx);
 
-    // THEN the decision stays at stop.
+    // THEN the decision stays at stop and the turn content is left untouched.
     expect(ctx.decision).toBe("stop");
+    expect(ctx.content).toEqual([{ type: "text", text: "partial answer" }]);
   });
 
-  test("refusal beats the post-tool-empty nudge wording", async () => {
+  test("refusal after a visible reply this run → stop, no rewrite", async () => {
+    // GIVEN an earlier turn this run already delivered a real answer (text
+    // alongside a tool call), then the trailing turn refuses after the tool
+    // result. Rewriting here would stack an apology beneath the real answer.
+    const ctx = makeCtx({
+      messages: [userPrompt("do X"), priorVisibleTextTurn, priorToolUseTurn],
+      content: [],
+      stopReason: "refusal",
+    });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN the refusal is left as-is — no fallback is stacked beneath the
+    // earlier reply.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.content).toEqual([]);
+  });
+
+  test("refusal beats the post-tool-empty nudge", async () => {
     // GIVEN conditions that would trip both the refusal branch and the
-    // post-tool-empty branch.
+    // post-tool-empty branch (a prior tool-use turn with no visible text).
     const ctx = makeCtx({
       messages: [priorToolUseTurn],
-      responseContent: [],
+      content: [],
       stopReason: "refusal",
     });
 
     // WHEN the hook runs.
-    await stop(ctx);
+    await postModelCall(ctx);
 
-    // THEN refusal wins because its wording is more accurate.
-    expect(ctx.decision).toBe("continue");
-    expect(ctx.messages.at(-1)).toEqual({
-      role: "user",
-      content: [{ type: "text", text: REFUSAL_NUDGE_TEXT }],
+    // THEN refusal wins: the turn content is rewritten to the fallback and the
+    // model is not nudged.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.content).toEqual([
+      { type: "text", text: REFUSAL_FALLBACK_TEXT },
+    ]);
+    expect(ctx.messages).toEqual([priorToolUseTurn]);
+  });
+
+  test("provider rejection is ignored — no nudge, no rewrite", async () => {
+    // GIVEN a rejection outcome (the call threw before any reply existed). The
+    // shape otherwise matches the post-tool-empty nudge case, but no response
+    // was produced, so this plugin defers to the recovery hooks.
+    const ctx = makeCtx({
+      messages: [priorToolUseTurn],
+      content: [],
+      error: new Error("provider rejected the request"),
+    });
+
+    // WHEN the hook runs.
+    await postModelCall(ctx);
+
+    // THEN it leaves the decision and history untouched — empty-response only
+    // acts on a finalized (successful) reply.
+    expect(ctx.decision).toBe("stop");
+    expect(ctx.messages).toEqual([priorToolUseTurn]);
+  });
+});
+
+// ─── One-shot retry bound ────────────────────────────────────────────────────
+
+describe("empty-response post-model-call hook — one-shot bound", () => {
+  test("a second empty turn this run is not nudged again", async () => {
+    // GIVEN the hook already nudged once this run for the conversation.
+    const first = makeCtx({
+      conversationId: "conv-bound",
+      messages: [priorToolUseTurn],
+      content: [],
+    });
+    await postModelCall(first);
+    expect(first.decision).toBe("continue");
+
+    // WHEN a second empty-after-tools turn arrives for the same conversation.
+    const second = makeCtx({
+      conversationId: "conv-bound",
+      messages: [priorToolUseTurn],
+      content: [],
+    });
+    await postModelCall(second);
+
+    // THEN the hook lets the turn end rather than nudging again.
+    expect(second.decision).toBe("stop");
+    expect(second.messages).toEqual([priorToolUseTurn]);
+  });
+
+  test("the hook never clears its own bound — clearing is the stop hook's job", async () => {
+    // GIVEN the hook nudged once this run for the conversation.
+    const nudged = makeCtx({
+      conversationId: "conv-no-self-clear",
+      messages: [priorToolUseTurn],
+      content: [],
     });
+    await postModelCall(nudged);
+
+    // WHEN the re-queried call comes back as a provider rejection, then as a
+    // recovered visible-text reply — outcomes that end the turn.
+    await postModelCall(
+      makeCtx({
+        conversationId: "conv-no-self-clear",
+        messages: [priorToolUseTurn],
+        content: [],
+        error: new Error("provider rejected the request"),
+      }),
+    );
+    await postModelCall(
+      makeCtx({
+        conversationId: "conv-no-self-clear",
+        messages: [priorToolUseTurn],
+        content: [{ type: "text", text: "here is the summary" }],
+      }),
+    );
+
+    // THEN the bound stays marked — `post-model-call` only ever marks; the
+    // sibling `stop` hook is what clears it at the turn boundary.
+    expect(isEmptyResponseNudged("conv-no-self-clear")).toBe(true);
+  });
+});
+
+// ─── stop hook (terminal cleanup) ────────────────────────────────────────────
+
+function makeStopCtx(overrides: Partial<StopContext> = {}): StopContext {
+  return {
+    conversationId: "conv-stop",
+    messages: [],
+    exitReason: "no_tool_calls",
+    logger: noopLogger,
+    ...overrides,
+  };
+}
+
+describe("empty-response stop hook — terminal cleanup", () => {
+  test("a terminal stop clears the nudge bound", async () => {
+    // GIVEN a conversation that nudged this run.
+    const conversationId = "conv-stop-clear";
+    markEmptyResponseNudged(conversationId);
+
+    // WHEN the terminal stop hook runs.
+    await stop(makeStopCtx({ conversationId }));
+
+    // THEN the bound is cleared so the next run nudges afresh.
+    expect(isEmptyResponseNudged(conversationId)).toBe(false);
+  });
+
+  test("clears the bound regardless of how the turn ended", async () => {
+    // GIVEN a conversation that nudged this run, ending on an abort rather than
+    // a finalized reply.
+    const conversationId = "conv-stop-abort";
+    markEmptyResponseNudged(conversationId);
+
+    // WHEN the terminal stop hook runs for that exit.
+    await stop(makeStopCtx({ conversationId, exitReason: "aborted_pre_call" }));
+
+    // THEN the bound is still cleared — `stop` is the definitive terminal, so
+    // the next run always nudges afresh.
+    expect(isEmptyResponseNudged(conversationId)).toBe(false);
   });
 });
 
 // ─── Via runHook + registry ──────────────────────────────────────────────────
 
-describe("empty-response stop hook — via runHook", () => {
+describe("empty-response post-model-call hook — via runHook", () => {
   beforeEach(() => {
     resetPluginRegistryForTests();
   });
@@ -262,10 +438,10 @@ describe("empty-response stop hook — via runHook", () => {
     // GIVEN the default empty-response plugin is registered.
     registerPlugin(defaultEmptyResponsePlugin);
 
-    // WHEN the stop chain runs over an empty-after-tools context.
-    const result = await runHook<StopContext>(
-      HOOKS.STOP,
-      makeCtx({ messages: [priorToolUseTurn], responseContent: [] }),
+    // WHEN the post-model-call chain runs over an empty-after-tools context.
+    const result = await runHook<PostModelCallContext>(
+      HOOKS.POST_MODEL_CALL,
+      makeCtx({ messages: [priorToolUseTurn], content: [] }),
     );
 
     // THEN the chain settles on continue with the canonical nudge appended.
@@ -284,7 +460,7 @@ describe("empty-response stop hook — via runHook", () => {
     registerPlugin({
       manifest: { name: "force-stop", version: "0.0.1" },
       hooks: {
-        stop: async (ctx: StopContext) => {
+        "post-model-call": async (ctx: PostModelCallContext) => {
           observedDecision = ctx.decision;
           ctx.decision = "stop";
         },
@@ -292,9 +468,9 @@ describe("empty-response stop hook — via runHook", () => {
     });
 
     // WHEN the chain runs over an empty-after-tools context.
-    const result = await runHook<StopContext>(
-      HOOKS.STOP,
-      makeCtx({ messages: [priorToolUseTurn], responseContent: [] }),
+    const result = await runHook<PostModelCallContext>(
+      HOOKS.POST_MODEL_CALL,
+      makeCtx({ messages: [priorToolUseTurn], content: [] }),
     );
 
     // THEN the user hook saw the default's continue, and its override wins.

package/src/__tests__/external-plugin-loader.test.ts

@@ -521,34 +521,3 @@ export default async function init(_ctx: unknown): Promise<void> {}
     expect(registeredNames()).not.toContain("hanging-init");
   });
 });
-
-describe("loadExternalPlugin — end-to-end @vellumai/simple-memory", () => {
-  test("loads the in-tree simple-memory plugin", async () => {
-    // Resolve the real on-disk plugin from the worktree. This double-acts
-    // as the loader's contract test against the canonical Phase 0 plugin
-    // and exercises the relative `../src/state.js` imports inside the
-    // plugin's surface files.
-    const pluginDir = join(
-      import.meta.dir,
-      "..",
-      "..",
-      "..",
-      "experimental",
-      "plugins",
-      "simple-memory",
-    );
-
-    await loadExternalPlugin(pluginDir);
-
-    const registered = getRegisteredPlugins().find(
-      (p) => p.manifest.name === "simple-memory",
-    );
-    expect(registered).toBeDefined();
-    expect(typeof registered?.hooks?.init).toBe("function");
-    expect(typeof registered?.hooks?.shutdown).toBe("function");
-    const toolNames = (registered?.tools ?? [])
-      .map((t) => (t as { name: string }).name)
-      .sort();
-    expect(toolNames).toEqual(["recall", "remember"]);
-  });
-});

package/src/__tests__/get-skill-detail-audit.test.ts

@@ -11,8 +11,15 @@ const mockResolveSkillStates = mock(
       displayName: string;
       description: string;
       emoji?: string;
-      source: "bundled" | "managed" | "workspace" | "extra" | "catalog";
+      source:
+        | "bundled"
+        | "managed"
+        | "workspace"
+        | "extra"
+        | "catalog"
+        | "plugin";
       directoryPath: string;
+      owner?: { kind: "skill" | "mcp" | "plugin" | "workspace"; id: string };
     };
     state: "enabled" | "disabled";
   }> => [],
@@ -313,4 +320,39 @@ describe("getSkill — skillssh audit enrichment", () => {
     // fetchSkillAudits was still called (just failed)
     expect(mockFetchSkillAudits).toHaveBeenCalledTimes(1);
   });
+
+  test("attributes a plugin-resident skill to its owning plugin on the detail response", async () => {
+    // GIVEN a skill shipped inside an installed plugin, resolved with a
+    // `plugin` source and a plugin owner descriptor
+    mockResolveSkillStates.mockReturnValue([
+      {
+        summary: {
+          id: "caveman",
+          displayName: "Caveman",
+          description: "Ultra-compressed communication mode",
+          source: "plugin" as const,
+          directoryPath: "/tmp/test-skills/plugins/caveman/skills/caveman",
+          owner: { kind: "plugin", id: "caveman" },
+        },
+        state: "enabled" as const,
+      },
+    ]);
+
+    // WHEN we fetch its detail
+    const result = await getSkill("caveman");
+
+    // THEN it resolves to the vellum origin (plugin skills are mapped to
+    // bundled/vellum for older clients) while preserving plugin attribution
+    // on the owner descriptor
+    expect("skill" in result).toBe(true);
+    if (!("skill" in result)) throw new Error("Expected skill response");
+
+    const detail = result.skill;
+    expect(detail.origin).toBe("vellum");
+    expect(detail.id).toBe("caveman");
+    // AND the owner identifies the plugin so detail consumers can attribute it
+    if (detail.origin === "vellum") {
+      expect(detail.owner).toEqual({ kind: "plugin", id: "caveman" });
+    }
+  });
 });

package/src/__tests__/guardian-routing-invariants.test.ts

@@ -1332,6 +1332,97 @@ describe("routing invariant: callback buttons route through canonical primitive"
   });
 });
 
+// ===========================================================================
+// SECTION 8b: route-owned (directResolve) confirmations resolve via the
+// channel/guardian-action path too.
+//
+// The ACP spawn/steer approval gate (acp-routes.ts, ATL-822) registers
+// pending confirmations with a `directResolve` callback rather than a
+// Conversation.prompter. The tool_approval resolver must fire that callback
+// directly; otherwise a guardian approval submitted over a channel never
+// reaches the waiting route and the spawn/resume hangs until timeout.
+// ===========================================================================
+
+describe("routing invariant: directResolve interactions resolve via guardian decisions", () => {
+  beforeEach(() => resetTables());
+
+  function registerDirectResolveInteraction(
+    requestId: string,
+    conversationId: string,
+  ): string[] {
+    const decisions: string[] = [];
+    pendingInteractions.register(requestId, {
+      conversationId,
+      kind: "confirmation",
+      confirmationDetails: {
+        toolName: "acp_spawn",
+        input: { agent: "claude", task: "t", cwd: "/work" },
+        riskLevel: "high",
+        executionTarget: "host",
+        allowlistOptions: [],
+        scopeOptions: [],
+        persistentDecisionsAllowed: false,
+      },
+      directResolve: (d) => decisions.push(d),
+    });
+    return decisions;
+  }
+
+  test("channel approval fires directResolve('allow') with no live Conversation", async () => {
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-acp",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "acp_spawn",
+      expiresAt: Date.now() + 60_000,
+    });
+    // Deliberately no _conversationMocks entry: the prompter path would have
+    // failed with conversation_not_found, proving directResolve is what runs.
+    const decisions = registerDirectResolveInteraction(req.id, "conv-acp");
+
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "",
+        callbackData: `apr:${req.id}:approve_once`,
+        conversationId: "conv-acp",
+      }),
+    );
+
+    expect(result.decisionApplied).toBe(true);
+    expect(decisions).toEqual(["allow"]);
+    expect(pendingInteractions.get(req.id)).toBeUndefined();
+    expect(getCanonicalGuardianRequest(req.id)!.status).toBe("approved");
+  });
+
+  test("channel rejection fires directResolve('deny')", async () => {
+    const req = createCanonicalGuardianRequest({
+      kind: "tool_approval",
+      sourceType: "channel",
+      conversationId: "conv-acp",
+      guardianExternalUserId: "guardian-1",
+      guardianPrincipalId: TEST_PRINCIPAL_ID,
+      toolName: "acp_spawn",
+      expiresAt: Date.now() + 60_000,
+    });
+    const decisions = registerDirectResolveInteraction(req.id, "conv-acp");
+
+    const result = await routeGuardianReply(
+      replyCtx({
+        messageText: "",
+        callbackData: `apr:${req.id}:reject`,
+        conversationId: "conv-acp",
+      }),
+    );
+
+    expect(result.decisionApplied).toBe(true);
+    expect(decisions).toEqual(["deny"]);
+    expect(pendingInteractions.get(req.id)).toBeUndefined();
+    expect(getCanonicalGuardianRequest(req.id)!.status).toBe("denied");
+  });
+});
+
 // ===========================================================================
 // SECTION 9: Destination hints do not bypass principal binding for tool_approval
 // ===========================================================================