fix(snapshot): preserve external policy authority

ci/source-architecture-budget.json

@@ -27,7 +27,7 @@
       "src/lib/runner.ts": 86,
       "src/lib/security/redact.ts": 54,
       "src/lib/state/onboard-session.ts": 36,
-      "src/lib/state/registry.ts": 103,
+      "src/lib/state/registry.ts": 104,
       "src/lib/state/state-root.ts": 21,
       "src/lib/subprocess-env.ts": 24,
       "src/lib/validation.ts": 24

src/lib/actions/sandbox/policy-authority/preflight.ts

@@ -69,6 +69,7 @@ export function inspectPolicyAuthorityRequirements(
 ) {
   const inspections: SandboxPolicyAuthorityInspection[] = [];
   const authorities: RecordedPolicyAuthority[] = [];
+  let liveInspection: SandboxPolicyAuthorityInspection | null = null;
   const preparedRequirement = {
     appliedPresets: [],
     policyPath: "",
@@ -82,6 +83,7 @@ export function inspectPolicyAuthorityRequirements(
       gatewayName: options.gatewayName,
     });
     if (observed.authority !== "owner-unknown") {
+      liveInspection = observed;
       authorities.push(observed.authority);
       if (observed.authority === "externally-managed") inspections.push(observed);
     } else {
@@ -99,6 +101,8 @@ export function inspectPolicyAuthorityRequirements(
         },
         deps,
       );
+      liveInspection =
+        qualified.authority === "externally-managed" ? qualified.inspection : observed;
       authorities.push(qualified.authority);
       if (qualified.authority === "externally-managed") inspections.push(qualified.inspection);
     }
@@ -127,7 +131,7 @@ export function inspectPolicyAuthorityRequirements(
   }
   return {
     authority,
-    liveInspection: options.inspectLiveSource ? (inspections[0] ?? null) : null,
+    liveInspection,
     verifyRequirements: () => assertPolicyAuthorityRequirements(options, inspections),
   };
 }

src/lib/actions/sandbox/policy-authority/snapshot.test.ts

@@ -0,0 +1,124 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { makeMessagingPlan } from "../../../../../test/helpers/messaging-plan-fixtures";
+import * as registry from "../../../state/registry";
+import type { SandboxEntry } from "../../../state/registry";
+import {
+  qualifySnapshotPolicyAuthority,
+  resolveSnapshotBuiltinPolicyRequirements,
+  resolveSnapshotPolicyRequirements,
+} from "./snapshot";
+
+describe("snapshot policy authority qualification", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("retains only agreed legacy authority when a requirement is missing (#9833)", () => {
+    const sourceEntry = { name: "alpha" };
+    const updateSandbox = vi.spyOn(registry, "updateSandbox").mockReturnValue(true);
+    const inspection = {
+      authority: "externally-managed" as const,
+      effectivePolicy: { network_policies: {} },
+      policyIdentity: { hash: "external-policy", activeVersion: 1 },
+    };
+
+    expect(() =>
+      qualifySnapshotPolicyAuthority(
+        {
+          gatewayName: "nemoclaw",
+          managedMcpPolicies: [],
+          operation: "clone snapshot 'alpha' into sandbox 'beta'",
+          requiredPolicies: [{ network_policies: { required_api: {} } }],
+          sourceEntry,
+          sourceLive: true,
+          verifyGlobalCreatePolicy: false,
+        },
+        {
+          inspectSandboxPolicyAuthority: vi.fn(() => inspection),
+        },
+      ),
+    ).toThrow(/missing entries "required_api"/);
+
+    expect(updateSandbox).toHaveBeenCalledWith("alpha", {
+      policyAuthority: "externally-managed",
+    });
+    expect(sourceEntry).toEqual({ name: "alpha", policyAuthority: "externally-managed" });
+  });
+
+  it.each([
+    ["absent", "version: 1\n"],
+    ["empty", "version: 1\nnetwork_policies: {}\n"],
+  ])("rejects a required policy whose network_policies mapping is %s (#9833)", (_case, content) => {
+    expect(() =>
+      resolveSnapshotPolicyRequirements({
+        basePolicyContent: content,
+        builtinPresetNames: [],
+        customPolicies: [],
+        operation: "restore snapshot 'alpha'",
+        sandboxName: "alpha",
+      }),
+    ).toThrow(
+      "Refusing to restore snapshot 'alpha': a required network policy document is invalid.",
+    );
+  });
+
+  it("derives requirements from durable features without NemoClaw attribution (#9833)", () => {
+    expect(
+      resolveSnapshotBuiltinPolicyRequirements({
+        customPolicies: [],
+        snapshotPolicyPresets: [],
+        sourceEntry: {
+          name: "alpha",
+          agent: "langchain-deepagents-code",
+          messaging: {
+            schemaVersion: 1,
+            plan: {
+              ...makeMessagingPlan({ channels: ["telegram"] }),
+              networkPolicy: {
+                presets: ["telegram"],
+                entries: [
+                  {
+                    channelId: "telegram",
+                    presetName: "telegram",
+                    policyKeys: ["telegram"],
+                    source: "manifest",
+                  },
+                ],
+              },
+            },
+          },
+          observabilityEnabled: true,
+          policyAuthority: "externally-managed",
+          provider: "ollama-local",
+          webSearchEnabled: true,
+          webSearchProvider: "brave",
+        },
+      }),
+    ).toEqual(
+      expect.arrayContaining(["telegram", "brave", "local-inference", "observability-otlp-local"]),
+    );
+  });
+
+  it("does not require local inference for a proven canonical injected route (#9833)", () => {
+    const routeOnlyEntry = {
+      name: "alpha",
+      endpointSource: "inference-set",
+      endpointUrl: "https://inference.local/v1",
+      hostLocalInferenceProvenance: {},
+      hostLocalInferenceReceipt: "receipt",
+      provider: "ollama-local",
+    } as SandboxEntry;
+
+    expect(
+      resolveSnapshotBuiltinPolicyRequirements({
+        customPolicies: [],
+        snapshotPolicyPresets: [],
+        sourceEntry: routeOnlyEntry,
+      }),
+    ).not.toContain("local-inference");
+  });
+});