fix(messaging): harden Google Chat approval activation

Signed-off-by: Ho Lim <subhoya@gmail.com>

Author: HOYALIM

docs/manage-sandboxes/set-up-google-chat.mdx

@@ -172,6 +172,17 @@ The re-add flow prompts for the service-account JSON again when it is not alread
 ## Verify the Channel
 
 After the rebuild, send a direct message from an allowed or paired account and confirm that OpenClaw replies.
+If an unknown sender receives a pairing code, approve it through the registered OpenClaw sandbox:
+
+```bash
+nemoclaw my-assistant exec -- openclaw pairing approve googlechat <code>
+```
+
+After OpenClaw commits the sender to its owner allowlist, NemoClaw verifies the mutable config permissions and automatically restarts the managed gateway.
+An exit status of `0` means activation completed, so the sender's next message should receive a reply without another manual restart.
+If permission cleanup or gateway restart fails after the approval commits, `exec` exits with status `1`, reports that the approval was not rolled back, and prints the recovery command.
+Correct any reported permission problem, then run `nemoclaw my-assistant gateway restart` before testing the next message; do not submit the pairing code again unless OpenClaw reports that it was not accepted.
+
 If the webhook returns an error, verify that the public endpoint still ends in `/googlechat`, the dedicated tunnel and webhook proxy are running, and the Google Chat API configuration contains the exact same URL.
 
 Refer to [Manage Messaging Channels](manage-messaging-channels) to stop, start, or remove Google Chat after setup.

docs/reference/commands.mdx

@@ -1321,6 +1321,11 @@ When cleanup succeeds, `exec` returns the remote command's exit code.
 If cleanup cannot inspect, restore, or verify that contract, it fails closed and prints `OpenClaw permission cleanup failed (...)` to `stderr`.
 In that case, `exec` returns the cleanup failure instead of the remote command's status.
 
+For a registered OpenClaw sandbox, a successful direct `openclaw pairing approve googlechat <code>` command also restarts the managed gateway after cleanup so the new sender allowlist applies to the next message.
+If cleanup or restart fails after the approval commits, `exec` exits with status `1` and reports that the approval was not rolled back.
+Correct any reported cleanup problem, then run `$$nemoclaw <name> gateway restart` before testing the next message.
+NemoClaw does not apply this automatic restart to unregistered or non-OpenClaw sandboxes.
+
 </AgentOnly>
 <AgentOnly variant="hermes">
 
@@ -2148,6 +2153,10 @@ After the remote command exits, NemoClaw verifies and, when needed, restores the
 When cleanup succeeds, `exec` preserves the remote command's exit code.
 When cleanup fails closed, `exec` returns the cleanup failure and reports both statuses on `stderr`.
 
+A successful direct `openclaw pairing approve googlechat <code>` command in a registered OpenClaw sandbox restarts the managed gateway after cleanup, so the new sender allowlist applies to the next message.
+If the approval commits but cleanup or restart fails, `exec` exits with status `1`, reports that the approval was not rolled back, and directs you to run `$$nemoclaw <name> gateway restart` after correcting any cleanup problem.
+Unregistered and non-OpenClaw sandboxes do not receive this automatic restart.
+
 </AgentOnly>
 <AgentOnly variant="hermes">
 

src/lib/actions/sandbox/exec-googlechat-pairing-restart.test.ts

@@ -27,6 +27,7 @@ function depsFor(status: number, restartGateway = vi.fn(() => ({ ok: true }))):
     run: () => ({ status }),
     cleanupDeps: CLEANUP_SKIPPED,
     restartGateway,
+    resolveSandboxAgent: () => "openclaw",
     policyHint: {
       now: () => 1_000,
       probeLogs: () => "",
@@ -139,6 +140,7 @@ describe("Google Chat pairing approval gateway activation (#8553)", () => {
 
   it("does not restart when post-command config cleanup fails", async () => {
     const restartGateway = vi.fn(() => ({ ok: true }));
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
     const deps = depsFor(0, restartGateway);
     deps.cleanupDeps = {
       getSandbox: () => {
@@ -155,17 +157,51 @@ describe("Google Chat pairing approval gateway activation (#8553)", () => {
 
     expect(restartGateway).not.toHaveBeenCalled();
     expect(exitCode).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("pairing approval committed for 'alpha'"),
+    );
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("nemoclaw alpha gateway restart"),
+    );
   });
 
   it("fails the public command when activation restart fails", async () => {
     const restartGateway = vi.fn(() => ({ ok: false }));
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const exitCode = await runAndCaptureExit(
+      ["openclaw", "pairing", "approve", "googlechat", "ABCD1234"],
+      depsFor(0, restartGateway),
+    );
+
+    expect(restartGateway).toHaveBeenCalledOnce();
+    expect(exitCode).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("pairing approval committed for 'alpha'"),
+    );
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("nemoclaw alpha gateway restart"),
+    );
+  });
+
+  it("reports a controlled partial commit when the activation restart throws", async () => {
+    const restartGateway = vi.fn(() => {
+      throw new Error("supervisor transport unavailable");
+    });
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
     const exitCode = await runAndCaptureExit(
       ["openclaw", "pairing", "approve", "googlechat", "ABCD1234"],
       depsFor(0, restartGateway),
     );
 
     expect(restartGateway).toHaveBeenCalledOnce();
     expect(exitCode).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("approval was not rolled back"),
+    );
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("nemoclaw alpha gateway restart"),
+    );
   });
 
   it("does not restart after a failed approval", async () => {
@@ -189,4 +225,55 @@ describe("Google Chat pairing approval gateway activation (#8553)", () => {
     expect(restartGateway).not.toHaveBeenCalled();
     expect(exitCode).toBe(0);
   });
+
+  it.each(["hermes", "custom-agent"])(
+    "does not restart a recorded non-OpenClaw %s sandbox",
+    async (agent) => {
+      const restartGateway = vi.fn(() => ({ ok: true }));
+      const deps = depsFor(0, restartGateway);
+      deps.resolveSandboxAgent = () => agent;
+
+      const exitCode = await runAndCaptureExit(
+        ["openclaw", "pairing", "approve", "googlechat", "ABCD1234"],
+        deps,
+      );
+
+      expect(restartGateway).not.toHaveBeenCalled();
+      expect(exitCode).toBe(0);
+    },
+  );
+
+  it("does not restart an unregistered sandbox", async () => {
+    const restartGateway = vi.fn(() => ({ ok: true }));
+    const deps = depsFor(0, restartGateway);
+    deps.resolveSandboxAgent = () => null;
+
+    const exitCode = await runAndCaptureExit(
+      ["openclaw", "pairing", "approve", "googlechat", "ABCD1234"],
+      deps,
+    );
+
+    expect(restartGateway).not.toHaveBeenCalled();
+    expect(exitCode).toBe(0);
+  });
+
+  it("fails closed when the recorded sandbox identity cannot be read", async () => {
+    const restartGateway = vi.fn(() => ({ ok: true }));
+    const deps = depsFor(0, restartGateway);
+    deps.resolveSandboxAgent = () => {
+      throw new Error("registry unavailable");
+    };
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const exitCode = await runAndCaptureExit(
+      ["openclaw", "pairing", "approve", "googlechat", "ABCD1234"],
+      deps,
+    );
+
+    expect(restartGateway).not.toHaveBeenCalled();
+    expect(exitCode).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("pairing approval committed for 'alpha'"),
+    );
+  });
 });

src/lib/actions/sandbox/exec.ts

@@ -29,6 +29,8 @@ export type SandboxExecOptions = {
 
 export type SandboxExecGatewayRestart = (sandboxName: string) => { ok: boolean };
 
+export type SandboxExecAgentResolver = (sandboxName: string) => string | null;
+
 type SpawnLikeResult = {
   status: number | null;
   signal?: NodeJS.Signals | null;
@@ -368,6 +370,8 @@ export type ExecSandboxDeps = {
   cleanupDeps?: SandboxExecCleanupDeps;
   /** Activate config written by a successful direct Google Chat pairing approval. */
   restartGateway?: SandboxExecGatewayRestart;
+  /** Resolve the sandbox's recorded agent before applying agent-specific post-exec effects. */
+  resolveSandboxAgent?: SandboxExecAgentResolver;
   /** Select the sandbox's owning gateway before the exec talks to OpenShell. */
   selectGateway?: (sandboxName: string) => GatewaySelectResult;
 };
@@ -390,6 +394,24 @@ function defaultRestartGateway(sandboxName: string): { ok: boolean } {
   return defaultInferenceGatewayRestart(sandboxName);
 }
 
+function defaultResolveSandboxAgent(sandboxName: string): string | null {
+  const entry = (
+    require("../../state/registry") as typeof import("../../state/registry")
+  ).getSandbox(sandboxName);
+  if (!entry) return null;
+  return entry.agent ?? "openclaw";
+}
+
+function googleChatPairingActivationFailureMessage(
+  cliName: string,
+  sandboxName: string,
+): string {
+  return (
+    `  Google Chat pairing approval committed for '${sandboxName}', but managed gateway activation failed. ` +
+    `The approval was not rolled back. Run '${cliName} ${sandboxName} gateway restart' before testing the next message.`
+  );
+}
+
 export async function execSandbox(
   sandboxName: string,
   command: readonly string[],
@@ -460,9 +482,32 @@ export async function execSandbox(
   }
   await emitPolicyDenialHint(completion);
   let exitCode = completion.code;
-  if (exitCode === 0 && isGoogleChatPairingApproval(command)) {
-    const restart = (deps.restartGateway ?? defaultRestartGateway)(sandboxName);
-    if (!restart.ok) exitCode = 1;
+  const googleChatApprovalCommitted =
+    completion.commandCode === 0 && isGoogleChatPairingApproval(command);
+  if (googleChatApprovalCommitted && completion.cleanupError) {
+    console.error(googleChatPairingActivationFailureMessage(CLI_NAME, sandboxName));
+  }
+  if (exitCode === 0 && googleChatApprovalCommitted) {
+    let recordedAgent: string | null;
+    try {
+      recordedAgent = (deps.resolveSandboxAgent ?? defaultResolveSandboxAgent)(sandboxName);
+    } catch {
+      console.error(googleChatPairingActivationFailureMessage(CLI_NAME, sandboxName));
+      process.exit(1);
+    }
+    if (recordedAgent === "openclaw") {
+      let restartSucceeded = false;
+      try {
+        restartSucceeded = (deps.restartGateway ?? defaultRestartGateway)(sandboxName).ok;
+      } catch {
+        // The approval already committed inside OpenClaw. Convert restart
+        // exceptions into the same explicit partial-commit recovery contract.
+      }
+      if (!restartSucceeded) {
+        console.error(googleChatPairingActivationFailureMessage(CLI_NAME, sandboxName));
+        exitCode = 1;
+      }
+    }
   }
   process.exit(exitCode);
 }