fix(memory): gate reads on configured auth, lock mutations, use shared routing authority

Memory reads (status/core surfaces, routing snapshot, lane statuses) now
wait for configured authentication instead of a nonempty gateway URL,
show honest waiting copy, and invalidate in-flight requests when the auth
boundary changes. Runtime-default save, lane-policy save, and the two
source syncs are protected by synchronous same-tick locks. The duplicate
full-routing write path is removed: lane policy saves flow through the
shared PR #113 People & Routing controller (fresh load, clone upsert,
locked restore) and refuse while Front Desk holds unsaved routing edits.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: EmergentKnowledgeGroup

apps/mission-control/src/App.tsx

@@ -659,6 +659,8 @@ export default function App() {
     agents,
     enabled: memoryHubEnabled,
     preferredAgentId: assistantController.selectedAgentId,
+    tokenConfigured,
+    peopleRouting: peopleRoutingController,
     setNotice,
   });
   const connectorsController = useConnectorsController({

apps/mission-control/src/features/memory/MemoryPage.test.tsx

@@ -13,6 +13,10 @@ import type {
   RuntimeConfigResponse,
   RuntimeRoutingConfigResponse,
 } from "../../types";
+import {
+  usePeopleRoutingController,
+  type PeopleRoutingController,
+} from "../peopleRouting/usePeopleRoutingController";
 import { MemoryPage } from "./MemoryPage";
 import { useMemoryController } from "./useMemoryController";
 
@@ -483,6 +487,7 @@ function installDefaultMocks() {
 let root: Root | null = null;
 let container: HTMLDivElement;
 let latestController: ReturnType<typeof useMemoryController> | null = null;
+let latestPeopleRouting: PeopleRoutingController | null = null;
 const setNotice = vi.fn() as unknown as NotifyFn & ReturnType<typeof vi.fn>;
 const onOpenAssistant = vi.fn();
 
@@ -499,6 +504,7 @@ afterEach(async () => {
   await act(async () => root?.unmount());
   root = null;
   latestController = null;
+  latestPeopleRouting = null;
   container.remove();
 });
 
@@ -507,22 +513,34 @@ function Harness({
   agents,
   enabled = true,
   preferredAgentId = null,
+  tokenConfigured = true,
 }: {
   settings: RuntimeConnectionSettings;
   agents: Agent[];
   enabled?: boolean;
   preferredAgentId?: string | null;
+  tokenConfigured?: boolean;
 }) {
+  const peopleRouting = usePeopleRoutingController({
+    settings,
+    tokenConfigured,
+    agents,
+  });
   const controller = useMemoryController({
     settings,
     agents,
     enabled,
     preferredAgentId,
+    tokenConfigured,
+    peopleRouting,
     setNotice,
   });
   useEffect(() => {
     latestController = controller;
   }, [controller]);
+  useEffect(() => {
+    latestPeopleRouting = peopleRouting;
+  }, [peopleRouting]);
   return <MemoryPage controller={controller} onOpenAssistant={onOpenAssistant} />;
 }
 
@@ -538,7 +556,8 @@ async function render(
   settings: RuntimeConnectionSettings = SETTINGS,
   agents: Agent[] = AGENTS,
   enabled = true,
-  preferredAgentId: string | null = null
+  preferredAgentId: string | null = null,
+  tokenConfigured = true
 ) {
   await act(async () => {
     root ??= createRoot(container);
@@ -548,6 +567,7 @@ async function render(
         agents={agents}
         enabled={enabled}
         preferredAgentId={preferredAgentId}
+        tokenConfigured={tokenConfigured}
       />
     );
   });
@@ -1307,6 +1327,185 @@ describe("MemoryPage runtime defaults, lane policy, and sync mutations", () => {
   });
 });
 
+describe("MemoryPage configured-auth gating", () => {
+  it("waits for configured authentication before reading anything", async () => {
+    await render(SETTINGS, AGENTS, true, null, false);
+
+    expect(apiMocks.getAgentMemoryStatus).not.toHaveBeenCalled();
+    expect(apiMocks.getRuntimeConfig).not.toHaveBeenCalled();
+    expect(apiMocks.getAgentMemoryLaneStatuses).not.toHaveBeenCalled();
+    expect(container.textContent).toContain("Waiting for the gateway connection.");
+  });
+
+  it("starts reading only when authentication becomes configured", async () => {
+    await render(SETTINGS, AGENTS, true, null, false);
+    expect(apiMocks.getAgentMemoryStatus).not.toHaveBeenCalled();
+
+    await render(SETTINGS, AGENTS, true, null, true);
+
+    expect(apiMocks.getAgentMemoryStatus).toHaveBeenCalledWith(SETTINGS, "lyra");
+    await clickButton("Library");
+    expect(container.textContent).toContain("Lyra fact one");
+  });
+
+  it("discards an in-flight read when authentication is torn down", async () => {
+    const slowStatus = deferred<AgentMemoryStatusResponse>();
+    apiMocks.getAgentMemoryStatus.mockImplementation(async () => slowStatus.promise);
+    await render(SETTINGS, AGENTS, true, null, true);
+
+    await render(SETTINGS, AGENTS, true, null, false);
+    slowStatus.resolve(makeStatus("lyra"));
+    await flush();
+
+    expect(container.textContent).toContain("Waiting for the gateway connection.");
+    expect(apiMocks.listAgentMemoryCards).not.toHaveBeenCalled();
+  });
+
+  it("refuses every mutation without configured authentication", async () => {
+    await render(SETTINGS, AGENTS, true, null, false);
+
+    expect(latestController).toBeTruthy();
+    let saved = true;
+    await act(async () => {
+      saved = await latestController!.saveRuntimeMemoryDefaults("mno_primary", []);
+    });
+    expect(saved).toBe(false);
+    let laneSaved = true;
+    await act(async () => {
+      laneSaved = await latestController!.saveLaneMemoryPolicy(
+        "local-operator",
+        "lyra",
+        "local_only"
+      );
+    });
+    expect(laneSaved).toBe(false);
+    let synced = true;
+    await act(async () => {
+      synced = await latestController!.syncRuntimeMemoryDefaults();
+    });
+    expect(synced).toBe(false);
+    let laneSynced = true;
+    await act(async () => {
+      laneSynced = await latestController!.syncLaneMemorySources(
+        "local-operator",
+        "lyra"
+      );
+    });
+    expect(laneSynced).toBe(false);
+
+    expect(apiMocks.updateRuntimeConfig).not.toHaveBeenCalled();
+    expect(apiMocks.syncMemorySources).not.toHaveBeenCalled();
+  });
+});
+
+describe("MemoryPage same-tick mutation locks", () => {
+  it("lets one synchronous lock own a same-tick double runtime-defaults save", async () => {
+    await render();
+
+    let results: boolean[] = [];
+    await act(async () => {
+      results = await Promise.all([
+        latestController!.saveRuntimeMemoryDefaults("mno_primary", ["a.md"]),
+        latestController!.saveRuntimeMemoryDefaults("mno_primary", ["a.md"]),
+      ]);
+    });
+    await flush();
+
+    expect(apiMocks.updateRuntimeConfig).toHaveBeenCalledTimes(1);
+    expect(results.filter(Boolean)).toHaveLength(1);
+  });
+
+  it("lets one synchronous lock own a same-tick double lane-policy save", async () => {
+    await render();
+    apiMocks.updateRuntimeConfig.mockClear();
+
+    let results: boolean[] = [];
+    await act(async () => {
+      results = await Promise.all([
+        latestController!.saveLaneMemoryPolicy("local-operator", "lyra", "local_only"),
+        latestController!.saveLaneMemoryPolicy("local-operator", "lyra", "local_only"),
+      ]);
+    });
+    await flush();
+
+    expect(apiMocks.updateRuntimeConfig).toHaveBeenCalledTimes(1);
+    expect(results.filter(Boolean)).toHaveLength(1);
+  });
+
+  it("lets one synchronous lock own a same-tick double runtime sync", async () => {
+    await render();
+
+    await act(async () => {
+      await Promise.all([
+        latestController!.syncRuntimeMemoryDefaults(),
+        latestController!.syncRuntimeMemoryDefaults(),
+      ]);
+    });
+    await flush();
+
+    expect(apiMocks.syncMemorySources).toHaveBeenCalledTimes(1);
+  });
+
+  it("lets one synchronous lock own a same-tick double lane sync", async () => {
+    await render();
+
+    await act(async () => {
+      await Promise.all([
+        latestController!.syncLaneMemorySources("local-operator", "lyra"),
+        latestController!.syncLaneMemorySources("local-operator", "lyra"),
+      ]);
+    });
+    await flush();
+
+    expect(apiMocks.syncMemorySources).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("MemoryPage shared People & Routing authority", () => {
+  it("lands the lane policy save inside the shared routing authority state", async () => {
+    await render();
+
+    await setLabeledSelect("Memory mode", "local_only");
+    await clickButton("Save lane settings");
+
+    // The one shared People & Routing controller now holds the saved policy,
+    // proving the write flowed through it instead of a second writer.
+    const sharedPolicy = latestPeopleRouting?.routingConfig?.lane_memory_policies.find(
+      (policy) =>
+        policy.human_identity_id === "local-operator" &&
+        policy.assistant_agent_id === "lyra"
+    );
+    expect(sharedPolicy?.memory_mode).toBe("local_only");
+  });
+
+  it("refuses a lane policy save while Front Desk holds unsaved routing edits", async () => {
+    await render();
+    apiMocks.updateRuntimeConfig.mockClear();
+
+    await act(async () => {
+      latestPeopleRouting!.patchRoutingDraft((draft) => {
+        draft.human_identities[0]!.display_name = "Edited At The Front Desk";
+      });
+    });
+    await flush();
+
+    let saved = true;
+    await act(async () => {
+      saved = await latestController!.saveLaneMemoryPolicy(
+        "local-operator",
+        "lyra",
+        "local_only"
+      );
+    });
+    expect(saved).toBe(false);
+    expect(apiMocks.updateRuntimeConfig).not.toHaveBeenCalled();
+    expect(setNotice).toHaveBeenCalledWith({
+      tone: "error",
+      message: expect.stringContaining("unsaved"),
+    });
+  });
+});
+
 describe("MemoryPage refresh", () => {
   it("reloads memory, routing, and lane statuses on refresh", async () => {
     await render();

apps/mission-control/src/features/memory/MemoryPage.tsx

@@ -420,7 +420,7 @@ export function MemoryPage({ controller, onOpenAssistant }: MemoryPageProps) {
     return (
       <MemoryStatePanel
         title="Loading Memory"
-        detail="Checking agent memory status..."
+        detail={controller.availabilityMessage ?? "Checking agent memory status..."}
       />
     );
   }