remoteclaw
diff --git a/‎CHANGELOG.md‎
Lines changed: 1 addition & 0 deletions b/‎CHANGELOG.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎src/cli/daemon-cli/lifecycle-core.test.ts‎
Lines changed: 47 additions & 1 deletion b/‎src/cli/daemon-cli/lifecycle-core.test.ts‎
Lines changed: 47 additions & 1 deletion
diff --git a/‎src/cli/daemon-cli/lifecycle-core.ts‎
Lines changed: 70 additions & 17 deletions b/‎src/cli/daemon-cli/lifecycle-core.ts‎
Lines changed: 70 additions & 17 deletions
@@ -260,6 +260,7 @@ Docs: https://docs.openclaw.ai
 - Sessions/bootstrap cache rollover invalidation: clear cached workspace bootstrap snapshots whenever an existing `sessionKey` rolls to a new `sessionId` across auto-reply, command, and isolated cron session resolvers, so `AGENTS.md`/`MEMORY.md`/`USER.md` updates are reloaded after daily, idle, or forced session resets instead of staying stale until gateway restart. (#38494) Thanks @LivingInDrm.
 - Gateway/Telegram polling health monitor: skip stale-socket restarts for Telegram long-polling channels and thread channel identity through shared health evaluation so polling connections are not restarted on the WebSocket stale-socket heuristic. (#38395) Thanks @ql-wade and @Takhoffman.
 - Daemon/systemd fresh-install probe: check for OpenClaw's managed user unit before running `systemctl --user is-enabled`, so first-time Linux installs no longer fail on generic missing-unit probe errors. (#38819) Thanks @adaHubble.
+- Gateway/container lifecycle: allow `openclaw gateway stop` to SIGTERM unmanaged gateway listeners and `openclaw gateway restart` to SIGUSR1 a single unmanaged listener when no service manager is installed, so container and supervisor-based deployments are no longer blocked by `service disabled` no-op responses. Fixes #36137. Thanks @vincentkoc.
 - Gateway/Windows restart supervision: relaunch task-managed gateways through Scheduled Task with quoted helper-script command paths, distinguish restart-capable supervisors per platform, and stop orphaned Windows gateway children during self-restart. (#38825) Thanks @obviyus.
 - Telegram/native topic command routing: resolve forum-topic native commands through the same conversation route as inbound messages so topic `agentId` overrides and bound topic sessions target the active session instead of the default topic-parent session. (#38871) Thanks @obviyus.
 - Markdown/assistant image hardening: flatten remote markdown images to plain text across the Control UI, exported HTML, and shared Swift chat while keeping inline `data:image/...` markdown renderable, so model output no longer triggers automatic remote image fetches. (#38895) Thanks @obviyus.
 
@@ -40,10 +40,11 @@ vi.mock("../../runtime.js", () => ({
 }));
 
 let runServiceRestart: typeof import("./lifecycle-core.js").runServiceRestart;
+let runServiceStop: typeof import("./lifecycle-core.js").runServiceStop;
 
 describe("runServiceRestart token drift", () => {
   beforeAll(async () => {
-    ({ runServiceRestart } = await import("./lifecycle-core.js"));
+    ({ runServiceRestart, runServiceStop } = await import("./lifecycle-core.js"));
   });
 
   beforeEach(() => {
@@ -130,4 +131,49 @@ describe("runServiceRestart token drift", () => {
     const payload = JSON.parse(jsonLine ?? "{}") as { warnings?: string[] };
     expect(payload.warnings).toBeUndefined();
   });
+
+  it("emits stopped when an unmanaged process handles stop", async () => {
+    service.isLoaded.mockResolvedValue(false);
+
+    await runServiceStop({
+      serviceNoun: "Gateway",
+      service,
+      opts: { json: true },
+      onNotLoaded: async () => ({
+        result: "stopped",
+        message: "Gateway stop signal sent to unmanaged process on port 18789: 4200.",
+      }),
+    });
+
+    const jsonLine = runtimeLogs.find((line) => line.trim().startsWith("{"));
+    const payload = JSON.parse(jsonLine ?? "{}") as { result?: string; message?: string };
+    expect(payload.result).toBe("stopped");
+    expect(payload.message).toContain("unmanaged process");
+    expect(service.stop).not.toHaveBeenCalled();
+  });
+
+  it("runs restart health checks after an unmanaged restart signal", async () => {
+    const postRestartCheck = vi.fn(async () => {});
+    service.isLoaded.mockResolvedValue(false);
+
+    await runServiceRestart({
+      serviceNoun: "Gateway",
+      service,
+      renderStartHints: () => [],
+      opts: { json: true },
+      onNotLoaded: async () => ({
+        result: "restarted",
+        message: "Gateway restart signal sent to unmanaged process on port 18789: 4200.",
+      }),
+      postRestartCheck,
+    });
+
+    expect(postRestartCheck).toHaveBeenCalledTimes(1);
+    expect(service.restart).not.toHaveBeenCalled();
+    expect(service.readCommand).not.toHaveBeenCalled();
+    const jsonLine = runtimeLogs.find((line) => line.trim().startsWith("{"));
+    const payload = JSON.parse(jsonLine ?? "{}") as { result?: string; message?: string };
+    expect(payload.result).toBe("restarted");
+    expect(payload.message).toContain("unmanaged process");
+  });
 });
@@ -28,6 +28,18 @@ type RestartPostCheckContext = {
   fail: (message: string, hints?: string[]) => void;
 };
 
+type NotLoadedActionResult = {
+  result: "stopped" | "restarted";
+  message?: string;
+  warnings?: string[];
+};
+
+type NotLoadedActionContext = {
+  json: boolean;
+  stdout: Writable;
+  fail: (message: string, hints?: string[]) => void;
+};
+
 async function maybeAugmentSystemdHints(hints: string[]): Promise<string[]> {
   if (process.platform !== "linux") {
     return hints;
@@ -200,6 +212,7 @@ export async function runServiceStop(params: {
   serviceNoun: string;
   service: GatewayService;
   opts?: DaemonLifecycleOptions;
+  onNotLoaded?: (ctx: NotLoadedActionContext) => Promise<NotLoadedActionResult | null>;
 }) {
   const json = Boolean(params.opts?.json);
   const { stdout, emit, fail } = createActionIO({ action: "stop", json });
@@ -213,6 +226,25 @@ export async function runServiceStop(params: {
     return;
   }
   if (!loaded) {
+    try {
+      const handled = await params.onNotLoaded?.({ json, stdout, fail });
+      if (handled) {
+        emit({
+          ok: true,
+          result: handled.result,
+          message: handled.message,
+          warnings: handled.warnings,
+          service: buildDaemonServiceSnapshot(params.service, false),
+        });
+        if (!json && handled.message) {
+          defaultRuntime.log(handled.message);
+        }
+        return;
+      }
+    } catch (err) {
+      fail(`${params.serviceNoun} stop failed: ${String(err)}`);
+      return;
+    }
     emit({
       ok: true,
       result: "not-loaded",
@@ -251,9 +283,12 @@ export async function runServiceRestart(params: {
   opts?: DaemonLifecycleOptions;
   checkTokenDrift?: boolean;
   postRestartCheck?: (ctx: RestartPostCheckContext) => Promise<void>;
+  onNotLoaded?: (ctx: NotLoadedActionContext) => Promise<NotLoadedActionResult | null>;
 }): Promise<boolean> {
   const json = Boolean(params.opts?.json);
   const { stdout, emit, fail } = createActionIO({ action: "restart", json });
+  const warnings: string[] = [];
+  let handledNotLoaded: NotLoadedActionResult | null = null;
 
   const loaded = await resolveServiceLoadedOrFail({
     serviceNoun: params.serviceNoun,
@@ -264,19 +299,29 @@ export async function runServiceRestart(params: {
     return false;
   }
   if (!loaded) {
-    await handleServiceNotLoaded({
-      serviceNoun: params.serviceNoun,
-      service: params.service,
-      loaded,
-      renderStartHints: params.renderStartHints,
-      json,
-      emit,
-    });
-    return false;
+    try {
+      handledNotLoaded = (await params.onNotLoaded?.({ json, stdout, fail })) ?? null;
+    } catch (err) {
+      fail(`${params.serviceNoun} restart failed: ${String(err)}`);
+      return false;
+    }
+    if (!handledNotLoaded) {
+      await handleServiceNotLoaded({
+        serviceNoun: params.serviceNoun,
+        service: params.service,
+        loaded,
+        renderStartHints: params.renderStartHints,
+        json,
+        emit,
+      });
+      return false;
+    }
+    if (handledNotLoaded.warnings?.length) {
+      warnings.push(...handledNotLoaded.warnings);
+    }
   }
 
-  const warnings: string[] = [];
-  if (params.checkTokenDrift) {
+  if (loaded && params.checkTokenDrift) {
     // Check for token drift before restart (service token vs config token)
     try {
       const command = await params.service.readCommand(process.env);
@@ -309,22 +354,30 @@ export async function runServiceRestart(params: {
   }
 
   try {
-    await params.service.restart({ env: process.env, stdout });
+    if (loaded) {
+      await params.service.restart({ env: process.env, stdout });
+    }
     if (params.postRestartCheck) {
       await params.postRestartCheck({ json, stdout, warnings, fail });
     }
-    let restarted = true;
-    try {
-      restarted = await params.service.isLoaded({ env: process.env });
-    } catch {
-      restarted = true;
+    let restarted = loaded;
+    if (loaded) {
+      try {
+        restarted = await params.service.isLoaded({ env: process.env });
+      } catch {
+        restarted = true;
+      }
     }
     emit({
       ok: true,
       result: "restarted",
+      message: handledNotLoaded?.message,
       service: buildDaemonServiceSnapshot(params.service, restarted),
       warnings: warnings.length ? warnings : undefined,
     });
+    if (!json && handledNotLoaded?.message) {
+      defaultRuntime.log(handledNotLoaded.message);
+    }
     return true;
   } catch (err) {
     const hints = params.renderStartHints();