Keep approval persistence failures from crashing the session

Author: TheGreatAxios

CHANGELOG.md

@@ -13,6 +13,12 @@ parallel copies under `docs/` or `scripts/notes/`. At cut time: rename
 
 ## [Unreleased]
 
+### Fixed
+
+- A failed write of a project, global, or provider-model approval no longer
+  crashes the session. The grant still applies in memory, the approved tool
+  call still completes, and a concise diagnostic is logged.
+
 ## [0.3.10] - 2026-08-30
 
 ### Fixed

src/session/runtime-assembly.test.ts

@@ -1,9 +1,14 @@
-import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { getLogger } from "@intx/log";
+import type { ToolCall } from "@intx/types/runtime";
 
+import { LOG_NAMESPACE_ROOT } from "../branding.js";
 import * as permissionStore from "../permission/store.js";
+import { createPermissionGate } from "../permission/gate.js";
+import type { GrantScope } from "../permission/types.js";
 import {
   buildSubAgentProvider,
   createApprovalPersist,
@@ -160,6 +165,12 @@ describe("loadSeededApprovals merge order", () => {
 });
 
 describe("createApprovalPersist", () => {
+  const persistLogger = getLogger([LOG_NAMESPACE_ROOT, "session", "approvals"]);
+
+  beforeEach(() => {
+    spyOn(persistLogger, "warn");
+  });
+
   afterEach(() => {
     mock.restore();
   });
@@ -187,6 +198,97 @@ describe("createApprovalPersist", () => {
     expect(global).toHaveBeenCalledTimes(1);
     expect(providerModel).toHaveBeenCalledTimes(1);
   });
+
+  const persistedScopes: {
+    scope: Exclude<GrantScope, "session">;
+    reject: (message: string) => void;
+  }[] = [
+    {
+      scope: "project",
+      reject: (message) => {
+        spyOn(permissionStore, "saveProjectApproval").mockRejectedValue(new Error(message));
+      },
+    },
+    {
+      scope: "global",
+      reject: (message) => {
+        spyOn(permissionStore, "saveGlobalApproval").mockRejectedValue(new Error(message));
+      },
+    },
+    {
+      scope: "provider-model",
+      reject: (message) => {
+        spyOn(permissionStore, "saveProviderModelApproval").mockRejectedValue(new Error(message));
+      },
+    },
+  ];
+
+  const shellCall = (command: string): ToolCall => ({
+    id: "c",
+    name: "run_shell",
+    arguments: { command },
+  });
+
+  async function flushUnhandledRejections(): Promise<unknown> {
+    let unhandled: unknown = null;
+    const onUnhandled = (reason: unknown): void => {
+      unhandled = reason;
+    };
+    process.on("unhandledRejection", onUnhandled);
+    try {
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    } finally {
+      process.off("unhandledRejection", onUnhandled);
+    }
+    return unhandled;
+  }
+
+  for (const { scope, reject } of persistedScopes) {
+    test(`a rejected ${scope} write is contained, logged, and never becomes an unhandled rejection`, async () => {
+      const message = `${scope} disk full`;
+      reject(message);
+
+      const persist = createApprovalPersist("/tmp/proj", "openai:gpt-5");
+      persist({ tool: "run_shell", pattern: "npm *" }, scope);
+
+      expect(await flushUnhandledRejections()).toBeNull();
+      expect(persistLogger.warn).toHaveBeenCalledTimes(1);
+      expect(persistLogger.warn).toHaveBeenCalledWith(
+        "Failed to persist {scope} approval: {error}",
+        {
+          scope,
+          error: message,
+        },
+      );
+    });
+
+    test(`an approved call still completes and the in-memory ${scope} grant still applies when persist rejects`, async () => {
+      reject(`${scope} EACCES`);
+      const persist = createApprovalPersist("/tmp/proj", "openai:gpt-5");
+      let asked = 0;
+      const gate = createPermissionGate({
+        approvals: [],
+        requestApproval: async () => {
+          asked++;
+          return {
+            allow: true,
+            persist: { id: scope, label: "", pattern: "npm *", grant: scope },
+          };
+        },
+        persist,
+        interactive: true,
+        skipPermissions: false,
+        providerName: "openai",
+        model: "gpt-5",
+      });
+
+      expect((await gate.evaluate(shellCall("npm test"))).allowed).toBe(true);
+      expect(asked).toBe(1);
+      expect(await flushUnhandledRejections()).toBeNull();
+      expect((await gate.evaluate(shellCall("npm run build"))).allowed).toBe(true);
+      expect(asked).toBe(1);
+    });
+  }
 });
 
 describe("skillDirsFromEnabledPlugins", () => {

src/session/runtime-assembly.ts

@@ -3,6 +3,7 @@
 // Only near-verbatim blocks live here. Gate / toolset / director construction
 // bind runner-specific state and stay in each runner.
 
+import { getLogger } from "@intx/log";
 import type { ConversationTurn, InferenceSource } from "@intx/types/runtime";
 import type { Compactor } from "@intx/types/runtime";
 
@@ -13,6 +14,7 @@ import {
   loadAgentContextExtensions,
   loadSystemPromptOverrides,
 } from "../agent/context-extensions.js";
+import { LOG_NAMESPACE_ROOT } from "../branding.js";
 import type { ProviderCatalogEntry } from "../config/index.js";
 import { buildMainSessionSources } from "../config/inference-sources.js";
 import type { SessionMode } from "../config/session-mode.js";
@@ -119,19 +121,34 @@ export async function loadSeededApprovals(
   return [...sessionApprovals, ...projectApprovals, ...globalApprovals, ...providerModelApprovals];
 }
 
+const persistLogger = getLogger([LOG_NAMESPACE_ROOT, "session", "approvals"]);
+
+// The persist callback is fire-and-forget from the gate. A rejected write must
+// not become an unhandledRejection (that path is fatal at process level); the
+// in-memory grant already applies, so the approved call still completes.
+function persistBestEffort(scope: GrantScope, write: Promise<void>): void {
+  void write.catch((err: unknown) => {
+    persistLogger.warn("Failed to persist {scope} approval: {error}", {
+      scope,
+      error: err instanceof Error ? err.message : String(err),
+    });
+  });
+}
+
 /**
  * Route a gate-persisted grant to the store its scope selects.
  * Session grants never reach here — the gate keeps those in memory only.
+ * Disk failures are logged and swallowed so they cannot crash the session.
  */
 export function createApprovalPersist(
   cwd: string,
   activeProviderModel: string,
 ): (approval: Approval, scope: GrantScope) => void {
   return (approval: Approval, scope: GrantScope) => {
-    if (scope === "project") void saveProjectApproval(cwd, approval);
-    else if (scope === "global") void saveGlobalApproval(approval);
+    if (scope === "project") persistBestEffort(scope, saveProjectApproval(cwd, approval));
+    else if (scope === "global") persistBestEffort(scope, saveGlobalApproval(approval));
     else if (scope === "provider-model") {
-      void saveProviderModelApproval(activeProviderModel, approval);
+      persistBestEffort(scope, saveProviderModelApproval(activeProviderModel, approval));
     }
   };
 }