@vellumai/assistant 0.7.0 → 0.7.2

package/src/__tests__/workspace-migration-064-unwind-main-agent-opus-seed.test.ts

@@ -0,0 +1,225 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { unwindMainAgentOpusSeedMigration } from "../workspace/migrations/064-unwind-main-agent-opus-seed.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-064-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+});
+
+describe("064-unwind-main-agent-opus-seed migration", () => {
+  test("has correct migration id", () => {
+    expect(unwindMainAgentOpusSeedMigration.id).toBe(
+      "064-unwind-main-agent-opus-seed",
+    );
+  });
+
+  test("removes exact seeded mainAgent override and sets balanced when activeProfile is missing", () => {
+    writeConfig({
+      llm: {
+        callSites: {
+          mainAgent: { model: "claude-opus-4-7", maxTokens: 32000 },
+        },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: {
+        activeProfile: string;
+        callSites: Record<string, unknown>;
+      };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toBeUndefined();
+  });
+
+  test("preserves balanced activeProfile (set by migration 052) while removing seed", () => {
+    // migration 052 sets activeProfile="balanced" before 064 runs; 064 must
+    // not override it — balanced is the intentional default, not a signal
+    // that the user wants the Opus quality tier.
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: {
+          mainAgent: { model: "claude-opus-4-7", maxTokens: 32000 },
+        },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toBeUndefined();
+  });
+
+  test("preserves custom activeProfile while removing the stale seed", () => {
+    writeConfig({
+      llm: {
+        activeProfile: "gpt-5-5",
+        callSites: {
+          mainAgent: { model: "claude-opus-4-7", maxTokens: 32000 },
+        },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("gpt-5-5");
+    expect(config.llm.callSites.mainAgent).toBeUndefined();
+  });
+
+  test("removes only seeded model and maxTokens when user fields are present, preserves balanced", () => {
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: {
+          mainAgent: {
+            model: "claude-opus-4-7",
+            maxTokens: 32000,
+            effort: "low",
+            thinking: { enabled: false },
+          },
+        },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: {
+        activeProfile: string;
+        callSites: Record<string, Record<string, unknown>>;
+      };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toEqual({
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("does not mutate mainAgent entries with explicit provider", () => {
+    const mainAgent = {
+      provider: "anthropic",
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    };
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: { mainAgent },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toEqual(mainAgent);
+  });
+
+  test("does not mutate mainAgent entries with explicit profile", () => {
+    const mainAgent = {
+      profile: "quality-optimized",
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    };
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: { mainAgent },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toEqual(mainAgent);
+  });
+
+  test("does not mutate explicit user pins with different maxTokens", () => {
+    const mainAgent = {
+      model: "claude-opus-4-7",
+      maxTokens: 64000,
+    };
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: { mainAgent },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toEqual(mainAgent);
+  });
+
+  test("does not mutate non-main-agent call sites", () => {
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: {
+          interactionClassifier: {
+            model: "claude-opus-4-7",
+            maxTokens: 32000,
+          },
+        },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.interactionClassifier).toEqual({
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    });
+  });
+});

package/src/__tests__/workspace-migration-backfill-installation-id.test.ts

@@ -84,7 +84,6 @@ describe("011-backfill-installation-id migration", () => {
     getExternalAssistantIdFn.mockReturnValue("my-assistant");
     getMemoryCheckpointFn.mockReturnValue(null);
     randomUUIDFn.mockReturnValue("generated-uuid-1234");
-    delete process.env.BASE_DATA_DIR;
   });
 
   test("no-op when no lockfile exists", () => {
@@ -284,12 +283,9 @@ describe("011-backfill-installation-id migration", () => {
     expect(parsed.assistants[0].installationId).toBe("sqlite-id");
   });
 
-  test("ignores BASE_DATA_DIR and always reads lockfile from homedir", () => {
-    process.env.BASE_DATA_DIR = "/custom-base";
+  test("always reads lockfile from homedir (per-user, not per-instance)", () => {
     getMemoryCheckpointFn.mockReturnValue("sqlite-id");
 
-    // Lockfile under BASE_DATA_DIR should be ignored — the migration
-    // always reads from homedir() (per-user, not per-instance).
     setupFs({
       [LOCK_PATH]: makeLockfile([{ assistantId: "my-assistant" }]),
     });

package/src/__tests__/workspace-migration-down-functions.test.ts

@@ -32,7 +32,7 @@ mock.module("../security/credential-key.js", () => ({
   credentialKey: (...args: string[]) => args.join(":"),
 }));
 
-// Mock getRootDir for 016-extract-feature-flags-to-protected
+// Mutable root dir used by 016-extract-feature-flags-to-protected tests
 let mockRootDir: string = "/tmp/mock-root";
 // ---------------------------------------------------------------------------
 // Imports — after mocking
@@ -763,21 +763,21 @@ describe("014-migrate-to-workspace-volume down()", () => {
 // ---------------------------------------------------------------------------
 
 describe("016-extract-feature-flags-to-protected down()", () => {
-  let savedBaseDataDir: string | undefined;
+  let savedWorkspaceDir: string | undefined;
 
   beforeEach(() => {
-    // The migration has an inlined platform helpers that reads BASE_DATA_DIR,
-    // so we set that env var so the inlined function resolves to mockRootDir.
+    // getVellumRoot() resolves via dirname(VELLUM_WORKSPACE_DIR), so we set
+    // VELLUM_WORKSPACE_DIR to <mockRootDir>/workspace so dirname gives mockRootDir.
     const baseDir = freshWorkspace();
     mockRootDir = join(baseDir, ".vellum");
     mkdirSync(mockRootDir, { recursive: true });
-    savedBaseDataDir = process.env.BASE_DATA_DIR;
-    process.env.BASE_DATA_DIR = baseDir;
+    savedWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+    process.env.VELLUM_WORKSPACE_DIR = join(mockRootDir, "workspace");
   });
 
   afterEach(() => {
-    if (savedBaseDataDir === undefined) delete process.env.BASE_DATA_DIR;
-    else process.env.BASE_DATA_DIR = savedBaseDataDir;
+    if (savedWorkspaceDir === undefined) delete process.env.VELLUM_WORKSPACE_DIR;
+    else process.env.VELLUM_WORKSPACE_DIR = savedWorkspaceDir;
   });
 
   test("moves feature flags from protected dir back to config.json", () => {

package/src/__tests__/workspace-migration-memory-v2-init.test.ts

@@ -3,9 +3,10 @@
  *
  * The migration seeds the `memory/` directory tree used by the v2 memory
  * subsystem: `memory/`, `memory/concepts/`, `memory/archive/`,
- * `memory/.v2-state/`, plus an empty `edges.json` and the four prose files
- * (`essentials.md`, `threads.md`, `recent.md`, `buffer.md`). It must be
- * idempotent and must not touch existing files.
+ * `memory/.v2-state/`, plus the four prose files (`essentials.md`,
+ * `threads.md`, `recent.md`, `buffer.md`). It must be idempotent and must
+ * not touch existing files. Outgoing edges live directly in concept-page
+ * frontmatter — there is no separate edges-index file to seed.
  */
 
 import {
@@ -90,11 +91,9 @@ describe("060-memory-v2-init migration", () => {
     expect(statSync(join(memoryDir, "archive")).isDirectory()).toBe(true);
     expect(statSync(join(memoryDir, ".v2-state")).isDirectory()).toBe(true);
 
-    // edges.json is seeded with the canonical empty index.
-    const edgesPath = join(memoryDir, "edges.json");
-    expect(existsSync(edgesPath)).toBe(true);
-    const edges = JSON.parse(readFileSync(edgesPath, "utf-8"));
-    expect(edges).toEqual({ version: 1, edges: [] });
+    // No edges-index file is seeded — outgoing edges live in concept-page
+    // frontmatter under the directed-edges model.
+    expect(existsSync(join(memoryDir, "edges.json"))).toBe(false);
 
     // Each prose file is created and empty.
     for (const filename of [
@@ -126,26 +125,6 @@ describe("060-memory-v2-init migration", () => {
     }
   });
 
-  test("preserves an existing edges.json with prior content", () => {
-    const memoryDir = join(workspaceDir, "memory");
-    mkdirSync(memoryDir, { recursive: true });
-
-    const customEdges = {
-      version: 1,
-      edges: [
-        ["alice-preferences", "bob-handoff"],
-        ["bob-handoff", "team-rituals"],
-      ],
-    };
-    const edgesPath = join(memoryDir, "edges.json");
-    writeFileSync(edgesPath, JSON.stringify(customEdges, null, 2), "utf-8");
-
-    memoryV2InitMigration.run(workspaceDir);
-
-    const reread = JSON.parse(readFileSync(edgesPath, "utf-8"));
-    expect(reread).toEqual(customEdges);
-  });
-
   test("preserves existing prose files with content", () => {
     const memoryDir = join(workspaceDir, "memory");
     mkdirSync(memoryDir, { recursive: true });
@@ -247,8 +226,7 @@ describe("060-memory-v2-init migration", () => {
       // .v2-state/ is gone.
       expect(existsSync(join(memoryDir, ".v2-state"))).toBe(false);
 
-      // Prose files and edges.json remain.
-      expect(existsSync(join(memoryDir, "edges.json"))).toBe(true);
+      // Prose files remain.
       expect(existsSync(join(memoryDir, "essentials.md"))).toBe(true);
       expect(existsSync(join(memoryDir, "threads.md"))).toBe(true);
       expect(existsSync(join(memoryDir, "recent.md"))).toBe(true);

package/src/__tests__/workspace-migration-unify-llm-callsite-configs.test.ts

@@ -119,15 +119,17 @@ describe("038-unify-llm-callsite-configs migration", () => {
   // ─── Schema-default-injection regression (the original bug) ────────────
 
   test("legacy services.inference.{provider,model} win over schema-default-injected llm.default", () => {
-    // Reproduces the production bug: between PR #26095 (added
-    // `LLMSchema.default(LLMSchema.parse({}))` to AssistantConfigSchema)
-    // and PR #26101 (this migration), any daemon boot caused the loader's
-    // `backfillConfigDefaults()` to write a schema-default `llm.default`
+    // Reproduces a production bug from a legacy-daemon era: between PR
+    // #26095 (added `LLMSchema.default(LLMSchema.parse({}))` to
+    // AssistantConfigSchema) and PR #26101 (this migration), any daemon
+    // boot caused the loader to write a schema-default `llm.default`
     // block to disk. Migration 038's old idempotency check (`return early
     // if llm.default exists`) then silently skipped, and migration 039
     // stripped `services.inference.{provider,model}` — losing the user's
     // actual configuration. The fix prefers legacy source keys over the
-    // injected schema defaults whenever both are present.
+    // injected schema defaults whenever both are present. (The loader
+    // no longer writes defaults to disk, but workspaces still on disk
+    // from that era can carry the bad state forward.)
     writeConfig({
       services: {
         inference: {
@@ -806,7 +808,9 @@ describe("038-unify-llm-callsite-configs migration", () => {
     // documented no-op — it leaves the config exactly as it found it,
     // whether the `llm` block is present or absent.
     const original = {
-      services: { inference: { mode: "your-own", provider: "openai", model: "gpt-5.4" } },
+      services: {
+        inference: { mode: "your-own", provider: "openai", model: "gpt-5.4" },
+      },
       maxTokens: 32000,
       llm: {
         default: {

package/src/acp/index.ts

@@ -1,8 +1,6 @@
-export { AcpSessionManager } from "./session-manager.js";
 export type { AcpAgentConfig, AcpSessionState } from "./types.js";
 
 import { getConfig } from "../config/loader.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import { AcpSessionManager } from "./session-manager.js";
 
 /** Singleton AcpSessionManager instance shared across the daemon. */
@@ -29,16 +27,3 @@ export function disposeAcpSessionManager(): void {
     manager = null;
   }
 }
-
-/**
- * Broadcast callback set by DaemonServer constructor so ACP session events
- * reach all connected SSE clients. Same pattern as
- * `getSubagentManager().broadcastToAllClients` in server.ts.
- */
-export let broadcastToAllClients: ((msg: ServerMessage) => void) | null = null;
-
-export function setBroadcastToAllClients(
-  fn: (msg: ServerMessage) => void,
-): void {
-  broadcastToAllClients = fn;
-}

package/src/acp/session-manager.ts

@@ -7,6 +7,7 @@ import { randomUUID } from "node:crypto";
 
 import { inArray } from "drizzle-orm";
 
+import { findConversation } from "../daemon/conversation-store.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { AcpSessionUpdate } from "../daemon/message-types/acp.js";
 import { getDb } from "../memory/db-connection.js";
@@ -55,19 +56,6 @@ export class AcpSessionManager {
    */
   private eventBuffers = new Map<string, BufferedAcpUpdate[]>();
 
-  /**
-   * Optional callback to inject a completion/failure message into the parent
-   * conversation so the LLM sees the agent's output.
-   * Wired by DaemonServer at startup.
-   */
-  onAcpSessionFinished:
-    | ((
-        parentConversationId: string,
-        message: string,
-        sendToClient: (msg: ServerMessage) => void,
-      ) => Promise<void>)
-    | null = null;
-
   constructor(private readonly maxConcurrent: number) {
     this.cleanupStaleRunningRows();
   }
@@ -446,28 +434,43 @@ export class AcpSessionManager {
           this.teardownSession(acpSessionId, current);
 
           // Notify parent session so the LLM sees the agent's output
-          if (this.onAcpSessionFinished) {
-            const agentLabel = current.state.agentId;
-            const responseText = current.clientHandler.responseText;
-            const sessionId = current.state.acpSessionId;
-            // `claude --resume <id>` is Claude Code-specific (the
-            // claude-agent-acp adapter binary). Other adapters resume
-            // differently or not at all, so the hint is gated.
-            const resumeHint =
-              current.command === "claude-agent-acp"
-                ? `\n\nTo resume: cd ${current.cwd} && claude --resume ${sessionId}`
-                : "";
-            const notifyMessage = `[ACP agent "${agentLabel}" completed]\n\n${responseText}${resumeHint}`;
-            this.onAcpSessionFinished(
-              current.parentConversationId,
+          const agentLabel = current.state.agentId;
+          const responseText = current.clientHandler.responseText;
+          const sessionId = current.state.acpSessionId;
+          const resumeHint =
+            current.command === "claude-agent-acp"
+              ? `\n\nTo resume: cd ${current.cwd} && claude --resume ${sessionId}`
+              : "";
+          const notifyMessage = `[ACP agent "${agentLabel}" completed]\n\n${responseText}${resumeHint}`;
+          const parentConversation = findConversation(
+            current.parentConversationId,
+          );
+          if (parentConversation) {
+            const enqueueResult = parentConversation.enqueueMessage(
               notifyMessage,
-              current.sendToVellum,
-            ).catch((notifyErr) => {
-              log.error(
-                { acpSessionId, notifyErr },
-                "Failed to notify parent of ACP completion",
-              );
-            });
+              [],
+            );
+            if (!enqueueResult.queued && !enqueueResult.rejected) {
+              parentConversation
+                .persistUserMessage(notifyMessage, [])
+                .then((messageId) =>
+                  parentConversation.runAgentLoop(notifyMessage, messageId),
+                )
+                .catch((err) => {
+                  log.error(
+                    {
+                      parentConversationId: current.parentConversationId,
+                      err,
+                    },
+                    "Failed to process ACP notification in parent",
+                  );
+                });
+            }
+          } else {
+            log.warn(
+              { parentConversationId: current.parentConversationId },
+              "ACP agent finished but parent conversation not found",
+            );
           }
         }
       })

package/src/agent/loop.ts

@@ -93,9 +93,13 @@ export type AgentEvent =
       contentBlocks?: ContentBlock[];
       riskLevel?: string;
       riskReason?: string;
+      matchedTrustRuleId?: string;
       isContainerized?: boolean;
       riskScopeOptions?: Array<{ pattern: string; label: string }>;
       riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
+      approvalMode?: string;
+      approvalReason?: string;
+      riskThreshold?: string;
     }
   | { type: "tool_use_preview_start"; toolUseId: string; toolName: string }
   | {
@@ -275,9 +279,13 @@ export type LoopToolExecutor = (
   yieldToUser?: boolean;
   riskLevel?: string;
   riskReason?: string;
+  matchedTrustRuleId?: string;
   isContainerized?: boolean;
   riskScopeOptions?: Array<{ pattern: string; label: string }>;
   riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
+  approvalMode?: string;
+  approvalReason?: string;
+  riskThreshold?: string;
 }>;
 
 export class AgentLoop {
@@ -364,6 +372,7 @@ export class AgentLoop {
      * default for the lifetime of an agent loop run.
      */
     overrideProfile?: string,
+    effectiveMaxInputTokens?: number,
   ): Promise<Message[]> {
     const history = [...messages];
     const initialHistoryLength = messages.length;
@@ -462,6 +471,7 @@ export class AgentLoop {
         // analyze, etc.) pass their own `callSite`.
         if (callSite) {
           providerConfig.callSite = callSite;
+          providerConfig.usageTracking = "manual";
         }
 
         // Per-call inference-profile override. The resolver layers
@@ -919,7 +929,8 @@ export class AgentLoop {
         // plugin pipeline so downstream plugins can swap in a smarter
         // truncation strategy (e.g. a summariser) while the default
         // middleware preserves the historical tail-drop behaviour.
-        const contextWindowTokens = this.config.maxInputTokens ?? 180_000;
+        const contextWindowTokens =
+          effectiveMaxInputTokens ?? this.config.maxInputTokens ?? 180_000;
         const maxChars = calculateMaxToolResultChars(contextWindowTokens);
         const truncateMiddlewares = getMiddlewaresFor("toolResultTruncate");
 
@@ -987,9 +998,13 @@ export class AgentLoop {
             contentBlocks: result.contentBlocks,
             riskLevel: result.riskLevel,
             riskReason: result.riskReason,
+            matchedTrustRuleId: result.matchedTrustRuleId,
             isContainerized: result.isContainerized,
             riskScopeOptions: result.riskScopeOptions,
             riskDirectoryScopeOptions: result.riskDirectoryScopeOptions,
+            approvalMode: result.approvalMode,
+            approvalReason: result.approvalReason,
+            riskThreshold: result.riskThreshold,
           });
         }
 

package/src/approvals/AGENTS.md

@@ -8,6 +8,10 @@
 - **Requester self-cancel:** A requester with a pending guardian approval must be able to cancel their own request (but not self-approve).
 - **Unified guardian decision primitive:** All guardian decision paths (callback buttons, conversational engine, requester self-cancel) must route through `applyGuardianDecision()` in `assistant/src/approvals/guardian-decision-primitive.ts`. Do not inline decision logic (approval record updates, grant minting) at individual callsites.
 
+## Single-Guardian Invariant
+
+Each assistant instance serves exactly one guardian. Multi-guardian is not supported and will never be. All connections, browser sessions, approval channels, and trust contexts within a single assistant process belong to the same guardian principal. Do not introduce guardian-keyed maps, per-guardian routing logic, or multi-guardian multiplexing — they add complexity without a real use case and create the false impression that cross-guardian isolation is required.
+
 ## Guardian Verification Invariant
 
 Guardian verification consumption must be identity-bound to the expected recipient identity. Every outbound verification session stores the expected identity (phone E.164, Telegram user/chat ID), and the consume path rejects attempts where the responding actor's identity does not match.

package/src/approvals/__tests__/guardian-feed-event.test.ts

@@ -88,6 +88,11 @@ mock.module("../../runtime/gateway-client.js", () => ({
   deliverChannelReply: async () => {},
 }));
 
+let _mockConversation: Record<string, unknown> | null = null;
+mock.module("../../daemon/conversation-store.js", () => ({
+  findConversation: () => _mockConversation,
+}));
+
 // Stub pending-interactions so tool_approval resolver can find/resolve.
 let mockInteraction: Record<string, unknown> | null = null;
 let mockResolved: Record<string, unknown> | null = null;
@@ -155,16 +160,18 @@ describe("guardian approval feed events", () => {
     mockInteraction = {
       confirmationDetails: { toolName: "web_fetch" },
     };
+    _mockConversation = {
+      handleConfirmationResponse: () => {},
+    };
     mockResolved = {
-      conversation: {
-        handleConfirmationResponse: () => {},
-      },
+      conversationId: "conv-test",
     };
   });
 
   afterEach(() => {
     mockInteraction = null;
     mockResolved = null;
+    _mockConversation = null;
   });
 
   // -----------------------------------------------------------------------

package/src/approvals/guardian-request-resolvers.ts

@@ -14,6 +14,7 @@
 import { answerCall } from "../calls/call-domain.js";
 import { findContactChannel } from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
+import { findConversation } from "../daemon/conversation-store.js";
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import {
   type CanonicalGuardianRequest,
@@ -203,7 +204,14 @@ const pendingInteractionResolver: GuardianRequestResolver = {
     // Map action to the permission system's UserDecision type and notify session.
     const userDecision: UserDecision =
       decision.action === "reject" ? "deny" : "allow";
-    resolved.conversation!.handleConfirmationResponse(
+    const conversation = findConversation(resolved.conversationId);
+    if (!conversation) {
+      return {
+        ok: false,
+        reason: `conversation_not_found: ${resolved.conversationId}`,
+      };
+    }
+    conversation.handleConfirmationResponse(
       request.id,
       userDecision,
       undefined,
@@ -982,7 +990,7 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
 const resolverRegistry = new Map<string, GuardianRequestResolver>();
 
 /** Register a resolver for a given request kind. */
-export function registerResolver(resolver: GuardianRequestResolver): void {
+function registerResolver(resolver: GuardianRequestResolver): void {
   resolverRegistry.set(resolver.kind, resolver);
 }