@@ -1,9 +1,9 @@
 import assert from 'node:assert/strict';
 import { existsSync } from 'node:fs';
-import { chmod, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, mkdtemp, realpath, rm, writeFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { tmpdir } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ownerBrowser } from '@repo/browser-testing/owner-browser';
 import metadata from '../package.json';
@@ -55,11 +55,17 @@ const gatewayPort = gatewayReservation.port!;
 // The setup/removal tests below require an offline gateway, not an HTTP 503 listener.
 await gatewayReservation.stop(true);
 
-async function command(input: string[] | { args: string[]; stdin: string }): Promise<string> {
-  const { args, stdin } = Array.isArray(input) ? { args: input, stdin: undefined } : input;
+async function command(
+  input: string[] | { args: string[]; stdin?: string; env?: NodeJS.ProcessEnv },
+): Promise<string> {
+  const {
+    args,
+    stdin,
+    env: overrides,
+  } = Array.isArray(input) ? { args: input, stdin: undefined, env: undefined } : input;
   const process = Bun.spawn(args, {
     cwd: directory,
-    env,
+    env: { ...env, ...overrides },
     stdin: stdin === undefined ? 'ignore' : new Blob([stdin]),
     stdout: 'pipe',
     stderr: 'pipe',
@@ -189,16 +195,24 @@ config.models={providers:{fixture:{baseUrl:${JSON.stringify(`${model.origin}/v1`
   );
   // A stale operation record must not mistake this live, unrelated process for its worker.
   await writeFile(`${dirname(connectionFile)}.removal.json`, JSON.stringify({ pid: process.pid }));
+  // npm exec can unpack a local tarball again on every invocation. Isolate its
+  // caches so this tests competing profile removals rather than npm extraction races.
   await Promise.all([
-    command(['npx', '--yes', packageSpec, 'remove', '--wait']),
-    command(['npx', '--yes', packageSpec, 'remove', '--wait']),
+    command({
+      args: ['npx', '--yes', packageSpec, 'remove', '--wait'],
+      env: { npm_config_cache: join(directory, 'removal-first-npm-cache') },
+    }),
+    command({
+      args: ['npx', '--yes', packageSpec, 'remove', '--wait'],
+      env: { npm_config_cache: join(directory, 'removal-second-npm-cache') },
+    }),
   ]);
   assert(!(await Bun.file(connectionFile).exists()), 'Cancelled setup retained credentials');
   assert(!existsSync(dirname(connectionFile)), 'Removal retained its private directory');
   await command(['npx', '--yes', packageSpec, 'remove', '--wait']);
   assert((await command(['npx', '--yes', packageSpec, 'status'])).includes('"installed": false'));
   assert(!existsSync(dirname(connectionFile)), 'Status recreated removed state');
-  assert(!(await configuration()).plugins.entries?.[PLUGIN_ID]);
+  assert.deepEqual((await configuration()).plugins.entries?.[PLUGIN_ID], { enabled: false });
   await command(['npx', '--yes', packageSpec, 'connect', app.origin]);
   const pending = await Bun.file(connectionFile).json();
   console.log('Removed an unfinished installation through the npm helper and connected again.');
@@ -427,7 +441,7 @@ config.models={providers:{fixture:{baseUrl:${JSON.stringify(`${model.origin}/v1`
   );
   await command(['npx', '--yes', packageSpec, 'remove', '--wait']);
   const afterRemoval = await configuration();
-  assert(!afterRemoval.plugins.entries?.[PLUGIN_ID], 'Native uninstall tombstone survived');
+  assert.deepEqual(afterRemoval.plugins.entries?.[PLUGIN_ID], { enabled: false });
   assert.deepEqual(afterRemoval.agents.entries.main.tools.alsoAllow, ['web_search', 'read']);
   assert.equal(await Bun.file(join(workspace, 'AGENTS.md')).text(), editedAgents);
   assert.equal(
@@ -759,6 +773,46 @@ config.models={providers:{fixture:{baseUrl:${JSON.stringify(`${model.origin}/v1`
     'Removal lease survived cleanup',
   );
   console.log('The npm helper refreshed the gateway after uninstall.');
+  // Recovery must also work for interrupted installs whose files were removed
+  // externally, even when this shell cannot authenticate to the running gateway.
+  await command(['npx', '--yes', packageSpec, 'connect', app.origin]);
+  const interruptedInventory = JSON.parse(await command(['openclaw', 'plugins', 'list', '--json']));
+  const interruptedPlugin = interruptedInventory.plugins.find(
+    (plugin: { id: string }) => plugin.id === PLUGIN_ID,
+  );
+  assert(interruptedPlugin, 'Unfinished reinstall did not install the package');
+  const packageRoot = await realpath(interruptedPlugin.rootDir);
+  const fixtureRoot = await realpath(directory);
+  const packagePath = relative(fixtureRoot, packageRoot);
+  assert(packagePath && !packagePath.startsWith('..') && !isAbsolute(packagePath));
+  await rm(packageRoot, { recursive: true, force: true });
+  const invalidGatewayAuth = {
+    OPENCLAW_GATEWAY_URL: `ws://127.0.0.1:${gatewayPort}`,
+    OPENCLAW_GATEWAY_TOKEN: 'invalid-removal-test-token',
+  };
+  await assert.rejects(
+    command({
+      args: ['openclaw', 'gateway', 'call', 'config.get', '--timeout', '3000', '--json'],
+      env: invalidGatewayAuth,
+    }),
+  );
+  await command({
+    args: ['npx', '--yes', packageSpec, 'remove', '--wait'],
+    env: invalidGatewayAuth,
+  });
+  const recovered = await configuration();
+  assert.deepEqual(recovered.plugins.entries?.[PLUGIN_ID], { enabled: false });
+  assert.notEqual(recovered.plugins.slots?.memory, PLUGIN_ID);
+  assert(!existsSync(dirname(connectionFile)), 'Orphaned private state survived cleanup');
+  assert(
+    !existsSync(`${dirname(connectionFile)}.removal.json`),
+    'Gateway authorization failure blocked removal',
+  );
+  await command(['npx', '--yes', packageSpec, 'remove', '--wait']);
+  assert((await command(['npx', '--yes', packageSpec, 'status'])).includes('"installed": false'));
+  console.log(
+    'Recovered a partially deleted reinstall without gateway authorization, and repeated removal without leftovers.',
+  );
 } finally {
   try {
     await owner?.close();
 
@@ -178,7 +178,9 @@ export async function disconnect(directory: string): Promise<{ preserved: string
           reason: 'Context Use setup requests gateway refresh after cleanup',
         },
         // Removing only journal-owned settings can legitimately shrink a fresh config by over half.
-        writeOptions: { allowConfigSizeDrop: true },
+        // Restoration must also work after package files and their plugin schema
+        // have disappeared. The SDK still validates the core configuration.
+        writeOptions: { allowConfigSizeDrop: true, skipPluginValidation: true },
         mutate: (config) => {
           if (state) {
             preserved = restoreConfiguration({ config, state });
 
@@ -1,4 +1,5 @@
 import { resolve } from 'node:path';
+import { setTimeout } from 'node:timers/promises';
 import { z } from 'zod';
 import { PREPARE_REMOVAL_METHOD } from './contract';
 import { ConnectionError } from './error';
@@ -13,6 +14,8 @@ const GatewayFailureSchema = z.object({
     reason: z.string().optional(),
   }),
 });
+const PROBE_ATTEMPTS = 3;
+const PROBE_RETRY_MS = 500;
 
 function gatewayFailure(error: unknown) {
   try {
@@ -23,30 +26,46 @@ function gatewayFailure(error: unknown) {
   }
 }
 
+async function gatewayConfiguration(): Promise<{ path: string } | undefined> {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return z
+        .object({ path: z.string() })
+        .parse(
+          JSON.parse(
+            await openclaw(['gateway', 'call', 'config.get', '--timeout', '3000', '--json']),
+          ),
+        );
+    } catch (error) {
+      const failure = gatewayFailure(error);
+      if (
+        failure?.type === 'gateway_transport_error' &&
+        failure.reason?.startsWith('connect ECONNREFUSED ')
+      ) {
+        return undefined;
+      }
+      // A deferred host refresh can briefly close the socket or reject the probe.
+      // Retry only reads; never replay a cleanup or restart request with an uncertain result.
+      const transient =
+        failure?.type === 'gateway_transport_error' ||
+        (failure?.type === 'gateway_request_error' && failure.code === 'UNAVAILABLE');
+      if (!transient || attempt >= PROBE_ATTEMPTS) {
+        throw new ConnectionError(
+          'Could not verify this profile’s gateway. Resolve its connection or authorization error and retry.',
+        );
+      }
+      await setTimeout(PROBE_RETRY_MS);
+    }
+  }
+}
+
 async function hasMatchingGateway(): Promise<boolean> {
   const local = z
     .object({ path: z.string() })
     .parse(JSON.parse(await openclaw(['config', 'file', '--json'])));
-  let remote: { path: string };
-  try {
-    remote = z
-      .object({ path: z.string() })
-      .parse(
-        JSON.parse(
-          await openclaw(['gateway', 'call', 'config.get', '--timeout', '3000', '--json']),
-        ),
-      );
-  } catch (error) {
-    const failure = gatewayFailure(error);
-    if (
-      failure?.type === 'gateway_transport_error' &&
-      failure.reason?.startsWith('connect ECONNREFUSED ')
-    ) {
-      return false;
-    }
-    throw new ConnectionError(
-      'Could not verify this profile’s gateway. Resolve its connection or authorization error and retry.',
-    );
+  const remote = await gatewayConfiguration();
+  if (!remote) {
+    return false;
   }
   // config.get comes from the running gateway itself. Service-status output can
   // describe the account's default daemon even when this CLI uses isolated state.
@@ -59,7 +78,16 @@ async function hasMatchingGateway(): Promise<boolean> {
 }
 
 export async function prepareGatewayRemoval(): Promise<void> {
-  if (!(await hasMatchingGateway())) {
+  let matching: boolean;
+  try {
+    matching = await hasMatchingGateway();
+  } catch {
+    // Local removal must remain possible when gateway credentials are broken or
+    // this CLI points at another profile. Never send cleanup to an unverified host.
+    console.warn('Gateway cleanup could not be reached. Continuing local removal.');
+    return;
+  }
+  if (!matching) {
     return;
   }
   try {
 
@@ -1,52 +1,61 @@
-import { setTimeout } from 'node:timers/promises';
 import { mutateConfigFile } from 'openclaw/plugin-sdk/config-mutation';
 import { PLUGIN_ID } from './contract';
 import { openclaw } from './host-command';
 import { installedPlugin } from './package-installation';
 
-const DRAIN_TIMEOUT_MS = 120_000;
-const DRAIN_RETRY_MS = 1_000;
-
-function retainedWorkRejection(error: unknown): boolean {
-  if (!error || typeof error !== 'object') {
+async function alreadyRemoved(error: unknown): Promise<boolean> {
+  if (!error || typeof error !== 'object' || !('stderr' in error)) {
     return false;
   }
-  const output = ['stdout', 'stderr']
-    .map((key) => (key in error ? String(error[key as keyof typeof error]) : ''))
-    .join('\n');
+  // Host configuration warnings can precede the actual uninstall result.
+  const messages = String(error.stderr).trim().split('\n');
+  if (messages.includes(`Plugin not found: ${PLUGIN_ID}`)) {
+    return true;
+  }
+  // Current hosts reject an untracked ID before producing a not-found result.
+  // An unmanaged package can produce the same rejection, so verify discovery too.
   return (
-    output.includes('still has active retained work') && output.includes('replacement not applied')
+    messages.some((message) =>
+      message.startsWith(`Plugin "${PLUGIN_ID}" is not associated with a tracked package install.`),
+    ) && !(await installedPlugin())
   );
 }
 
-export async function uninstall(): Promise<void> {
-  if (await installedPlugin()) {
-    // Older hosts reject retained foreground work before committing. Retry only that
-    // explicit non-commit result, from the detached remover, until the turn releases it.
-    const deadline = Date.now() + DRAIN_TIMEOUT_MS;
-    for (;;) {
-      try {
-        console.log(await openclaw(['plugins', 'uninstall', PLUGIN_ID, '--force']));
-        break;
-      } catch (error) {
-        if (Date.now() >= deadline || !retainedWorkRejection(error)) {
-          throw error;
-        }
-        await setTimeout(DRAIN_RETRY_MS);
-      }
-    }
-  }
-  // OpenClaw retains an enabled:false entry on uninstall. Remove our entry too.
+async function writeRemovalEntry(entry: { enabled: false } | undefined): Promise<void> {
   await mutateConfigFile({
     afterWrite: {
       mode: 'none',
       reason: 'Context Use setup requests gateway refresh after cleanup',
     },
-    writeOptions: { allowConfigSizeDrop: true },
+    // Repair only our entry when an orphan install points to a missing manifest.
+    // The SDK still validates the core configuration.
+    writeOptions: { allowConfigSizeDrop: true, skipPluginValidation: true },
     mutate: (config) => {
-      if (config.plugins?.entries) {
+      config.plugins ??= {};
+      config.plugins.entries ??= {};
+      if (entry) {
+        config.plugins.entries[PLUGIN_ID] = entry;
+      } else {
         delete config.plugins.entries[PLUGIN_ID];
       }
     },
   });
 }
+
+export async function uninstall(): Promise<void> {
+  // Even a disabled entry can fail validation while its tracked manifest is missing.
+  await writeRemovalEntry(undefined);
+  try {
+    // OpenClaw owns runtime draining, package files, install records and policy.
+    console.log(await openclaw(['plugins', 'uninstall', PLUGIN_ID, '--force']));
+  } catch (error) {
+    // Discovery excludes missing package files. Still ask the host to remove
+    // orphaned install records, and accept only its explicit absent result.
+    if (!(await alreadyRemoved(error))) {
+      throw error;
+    }
+  }
+  // Keep the host's explicit uninstall choice, including when already absent.
+  // Startup repair must not automatically reinstall a package the user removed.
+  await writeRemovalEntry({ enabled: false });
+}