@context-use/openclaw-memory 0.1.0-beta.32 → 0.1.0-beta.523

package/dist/setup.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@context-use/openclaw-memory",
-  version: "0.1.0-beta.32",
+  version: "0.1.0-beta.523",
   description: "Context Use as OpenClaw's sole durable personal memory",
   type: "module",
   license: "MIT",
@@ -83,16 +83,21 @@ ${openclawConnectCommand(serverUrl)}
 
 Follow the plugin's instructions: give me the authorization URL and ask me to return the final localhost redirect URL. When I send it back, finish connecting. Let the plugin manage configuration and gateway refresh.
 
-After authorization, verify openclaw context-use status. If connected and authenticated, confirm that setup is complete and tell me to start a new session with /new so the memory tools become available.`;
+After authorization, tell me to start a new session with /new so the gateway can finish applying the memory settings. Verify openclaw context-use status in that new session before confirming that memory is active.`;
+}
+var OPENCLAW_REMOVAL_PROMPT = `Remove the Context Use memory plugin using ${OPENCLAW_INSTALL_COMMAND} remove in this OpenClaw profile. This also works if authorization was never completed or the plugin is disabled. Let the plugin restore its configuration changes, clear its credentials and refresh the gateway. Preserve my remote memories and conversation history. Removal runs separately: end this turn once it is queued, then check ${OPENCLAW_INSTALL_COMMAND} status in a new turn. Do not poll from the requesting turn, schedule retries, stop the gateway, or reinstall to finish removal. Verify that a fresh conversation uses the restored memory provider.`;
+function openclawReconnectPrompt(serverUrl) {
+  return `Reauthorize my Context Use memory plugin for ${serverUrl}. Run ${OPENCLAW_INSTALL_COMMAND} reconnect '${serverUrl.replaceAll("'", "'\\''")}' in the same OpenClaw profile. Give me the new authorization URL and ask me to return the final localhost redirect URL. Pass that URL to ${OPENCLAW_INSTALL_COMMAND} authorize through standard input. Let the plugin manage configuration and gateway refresh. After authorization, tell me to start a new session with /new, then verify status in that new session before confirming that memory is active.`;
 }
-var OPENCLAW_REMOVAL_PROMPT = `Remove the Context Use memory plugin using ${OPENCLAW_INSTALL_COMMAND} remove in this OpenClaw profile. This also works if authorization was never completed or the plugin is disabled. Let the plugin restore its configuration changes, clear its credentials and refresh the gateway. Preserve my remote memories and conversation history. Verify that a fresh conversation uses the restored memory provider.`;
 
 // src/setup.ts
 import { text } from "node:stream/consumers";
 
 // src/connection.ts
-import { rm as rm2 } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { existsSync } from "node:fs";
+import { rm as rm4 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 import { auth } from "@modelcontextprotocol/client";
 import {
   mutateConfigFile,
@@ -117,7 +122,10 @@ var OPENCLAW_VERSION_RANGE = package_default.peerDependencies.openclaw;
 var CALLBACK_URL = "http://127.0.0.1:49187/context-use/callback";
 var REQUEST_TIMEOUT_MS = 30000;
 var AUTHORIZATION_TIMEOUT_MS = 600000;
+var AUTHORIZATION_SCOPE = "mcp offline_access";
 var toolName = (name) => `context_use_${name}`;
+var FINISH_LEARNING_TOOL = toolName("finish_learning");
+var SAVE_ATTACHMENT_TOOL = toolName("save_learning_attachment");
 var PluginConfigSchema = z.strictObject({
   agentId: z.string().regex(/^[a-z0-9][a-z0-9_-]*$/),
   serverUrl: z.url()
@@ -164,13 +172,27 @@ import { randomBytes, timingSafeEqual } from "node:crypto";
 
 // src/state.ts
 import { readFileSync } from "node:fs";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 import { lock } from "proper-lockfile";
 import { z as z2 } from "zod";
+
+// src/private-files.ts
+import { rename, rm, writeFile } from "node:fs/promises";
 var PRIVATE_DIRECTORY_MODE = 448;
 var PRIVATE_FILE_MODE = 384;
+async function writePrivateFile(input) {
+  const temporary = `${input.path}.tmp`;
+  try {
+    await writeFile(temporary, input.data, { mode: PRIVATE_FILE_MODE });
+    await rename(temporary, input.path);
+  } finally {
+    await rm(temporary, { force: true });
+  }
+}
+
+// src/state.ts
 var LOCK_STALE_MS = 120000;
 var LOCK_RETRIES = 300;
 var LOCK_RETRY_MS = 100;
@@ -180,6 +202,7 @@ var ChangeSchema = z2.object({
   applied: z2.unknown()
 });
 var ConnectionStateSchema = z2.object({
+  learningId: z2.string().uuid().optional(),
   config: PluginConfigSchema,
   changes: z2.array(ChangeSchema),
   tools: z2.array(z2.object({
@@ -209,18 +232,16 @@ async function readState(directory) {
   }
 }
 async function writeState(input) {
-  const path = join(input.directory, "connection.json");
-  const temporary = `${path}.tmp`;
-  try {
-    await writeFile(temporary, JSON.stringify(input.state), { mode: PRIVATE_FILE_MODE });
-    await rename(temporary, path);
-  } finally {
-    await rm(temporary, { force: true });
-  }
+  await mkdir(input.directory, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  await writePrivateFile({
+    path: join(input.directory, "connection.json"),
+    data: JSON.stringify(input.state)
+  });
 }
 async function withConnection(input) {
-  await mkdir(input.directory, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+  await mkdir(dirname(input.directory), { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
   const release = await lock(input.directory, {
+    realpath: false,
     stale: LOCK_STALE_MS,
     retries: { retries: LOCK_RETRIES, minTimeout: LOCK_RETRY_MS, maxTimeout: LOCK_RETRY_MS }
   });
@@ -254,7 +275,7 @@ function oauthProvider(input) {
       grant_types: ["authorization_code", "refresh_token"],
       response_types: ["code"],
       token_endpoint_auth_method: "none",
-      scope: "mcp offline_access"
+      scope: AUTHORIZATION_SCOPE
     },
     state: () => randomBytes(STATE_BYTES).toString("hex"),
     clientInformation: () => oauth.client,
@@ -386,28 +407,29 @@ async function discoverTools(client) {
   }
   return tools.filter((tool) => MCP_TOOL_NAMES.some((name) => name === tool.name));
 }
-async function callMemoryTool(input) {
+async function withMemoryClient(input) {
   return await withConnection({
     directory: input.directory,
     run: async () => {
       input.signal?.throwIfAborted();
       const state = await readState(input.directory);
-      if (!state || state.config.serverUrl !== input.serverUrl || state.config.agentId !== input.agentId || !state.oauth.tokens) {
+      if (!state || state.learningId !== input.connectionId || state.config.serverUrl !== input.serverUrl || state.config.agentId !== input.agentId || !state.oauth.tokens) {
         throw new ConnectionError("Context Use is disconnected or requires authorization.");
       }
       return await withClient({
         directory: input.directory,
         state,
-        run: async (client) => {
-          return await client.callTool({ name: input.name, arguments: input.arguments }, {
-            timeout: REQUEST_TIMEOUT_MS,
-            signal: input.signal
-          });
-        }
+        run: input.run
       });
     }
   });
 }
+async function callMemoryTool(input) {
+  return await withMemoryClient({
+    ...input,
+    run: (client) => client.callTool({ name: input.name, arguments: input.arguments }, { timeout: REQUEST_TIMEOUT_MS, signal: input.signal })
+  });
+}
 
 // src/configuration.ts
 import { isDeepStrictEqual } from "node:util";
@@ -430,6 +452,12 @@ Do not save transient chatter, generic knowledge, unsupported inference, secrets
 authorization links, redirect URLs or authorization codes. Respect requests not to retain facts.
 If nothing merits preservation, make no write. If an operation fails or its outcome is uncertain,
 do not claim success or blindly replay a create. Keep the final reply focused on the user's task.`;
+var CONVERSATION_LEARNING_GUIDANCE = `When background learning is enabled, Context Use queues conversation evidence for background learning after turns and before resets
+and compactions. The Gateway curates this evidence without holding up your reply. Leave routine
+learning to that worker. If the user explicitly asks you to remember, correct or forget something,
+handle it now through Context Use tools: read the curation guide, search and read existing knowledge,
+then make the smallest supported change. Respect retention preferences. Do not claim information
+has been saved until the required writes succeed; queued background work is not a completed save.`;
 var MEMORY_GUIDANCE = `Context Use is your sole durable personal memory. Read and write
 through its context_use_ tools whenever useful, including background work. Use it across your
 connected conversations. If Context Use is unavailable, report the limitation when relevant;
@@ -510,29 +538,45 @@ function prepareConfiguration(input) {
   assertPersonalConfiguration(input);
   const grants = ["agents", "entries", input.state.config.agentId, "tools", "alsoAllow"];
   const allow = ["agents", "entries", input.state.config.agentId, "tools", "allow"];
-  const grantPath = readPath({ config, path: allow }) === undefined ? grants : allow;
-  const alsoAllow = readPath({ config, path: grantPath });
-  const pluginAllow = config.plugins?.allow;
+  const previousGrant = input.state.changes.find((change) => isDeepStrictEqual(change.path, grants) || isDeepStrictEqual(change.path, allow));
+  const grantPath = previousGrant?.path ?? (readPath({ config, path: allow }) === undefined ? grants : allow);
+  const alsoAllow = previousGrant?.applied ?? readPath({ config, path: grantPath });
+  const pluginAllow = input.state.changes.find((change) => isDeepStrictEqual(change.path, ["plugins", "allow"]))?.applied ?? config.plugins?.allow;
   const plan = configurationPlan(input.state);
   plan.push({
     path: grantPath,
     value: [...new Set([...Array.isArray(alsoAllow) ? alsoAllow : [], PLUGIN_ID])]
   });
-  if (pluginAllow) {
+  if (Array.isArray(pluginAllow)) {
     plan.push({
       path: ["plugins", "allow"],
       value: [...new Set([...pluginAllow, PLUGIN_ID, "active-memory"])]
     });
   }
-  applyPlan({ ...input, plan });
+  const previousConnection = input.state.changes.find((change) => isDeepStrictEqual(change.path, ["plugins", "entries", PLUGIN_ID, "config"]));
+  const reconfiguring = Boolean(previousConnection && isDeepStrictEqual(readPath({ config, path: previousConnection.path }), previousConnection.applied));
+  applyPlan({ ...input, plan, reconfiguring });
+}
+function mergeListChange(input) {
+  const removed = input.from.filter((value) => !input.to.includes(value));
+  const added = input.to.filter((value) => !input.from.includes(value));
+  return [...new Set([...input.current.filter((value) => !removed.includes(value)), ...added])];
 }
 function applyPlan(input) {
   const config = input.config;
   for (const { path, value } of input.plan) {
     const before = readPath({ config, path });
     const existing = input.state.changes.find((change) => isDeepStrictEqual(change.path, path));
+    if (existing && isDeepStrictEqual(value, existing.applied) && (input.reconfiguring || !isDeepStrictEqual(before, existing.before))) {
+      continue;
+    }
+    let updated = value;
     if (existing && !isDeepStrictEqual(before, existing.applied) && !isDeepStrictEqual(before, existing.before)) {
-      throw new ConnectionError(`Configuration changed since setup: ${path.join(".")}. Disconnect before reconfiguring.`);
+      if (Array.isArray(before) && Array.isArray(existing.applied) && Array.isArray(value)) {
+        updated = mergeListChange({ current: before, from: existing.applied, to: value });
+      } else {
+        throw new ConnectionError(`Configuration changed since setup: ${path.join(".")}. Disconnect before reconfiguring.`);
+      }
     }
     if (!existing) {
       input.state.changes.push({
@@ -543,7 +587,7 @@ function applyPlan(input) {
     } else {
       existing.applied = structuredClone(value);
     }
-    writePath({ config, path, value });
+    writePath({ config, path, value: updated });
   }
 }
 function restoreConfiguration(input) {
@@ -557,12 +601,15 @@ function restoreConfiguration(input) {
     const current = readPath({ config: input.config, path: change.path });
     if (isDeepStrictEqual(current, change.applied)) {
       writePath({ config: input.config, path: change.path, value: change.before });
-    } else if (Array.isArray(current) && Array.isArray(change.applied) && (change.before === undefined || Array.isArray(change.before)) && ["allow", "alsoAllow"].includes(change.path.at(-1) ?? "")) {
-      const added = change.applied.filter((value) => !change.before?.includes(value));
+    } else if (Array.isArray(current) && Array.isArray(change.applied) && (change.before === undefined || Array.isArray(change.before)) && ["allow", "alsoAllow", "toolsAllow"].includes(change.path.at(-1) ?? "")) {
       writePath({
         config: input.config,
         path: change.path,
-        value: current.filter((value) => !added.includes(value))
+        value: mergeListChange({
+          current,
+          from: change.applied,
+          to: change.before ?? []
+        })
       });
     } else if (!isDeepStrictEqual(current, change.before)) {
       preserved.push(change.path.join("."));
@@ -586,24 +633,449 @@ function assertPersonalConfiguration(input) {
   }
 }
 
+// src/learning-store.ts
+import { randomUUID } from "node:crypto";
+import { chmodSync, mkdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+var BATCH_CHARS = 48000;
+var LEARNING_SESSION_PREFIX = "subagent:context-use-learning:";
+var LEARNING_SESSION_PATTERN = new RegExp(`^agent:[^:]+:${LEARNING_SESSION_PREFIX}`);
+function isLearningSession(sessionKey) {
+  return LEARNING_SESSION_PATTERN.test(sessionKey ?? "");
+}
+var attachmentDirectory = (connectionId) => `learning-${encodeURIComponent(connectionId)}-attachments`;
+var DREAM_INTERVAL_MS = 21600000;
+var learningDatabase = (connectionId) => `learning-${encodeURIComponent(connectionId)}.sqlite`;
+
+class LearningStore {
+  db;
+  constructor(input) {
+    mkdirSync(input.directory, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+    const path = join2(input.directory, learningDatabase(input.connectionId));
+    this.db = new DatabaseSync(path);
+    chmodSync(path, PRIVATE_FILE_MODE);
+    this.db.exec(`
+      PRAGMA busy_timeout = 1000;
+      PRAGMA secure_delete = ON;
+      CREATE TABLE IF NOT EXISTS owner (config TEXT NOT NULL);
+      CREATE TABLE IF NOT EXISTS evidence (
+        id INTEGER PRIMARY KEY, source TEXT NOT NULL, fingerprint TEXT NOT NULL,
+        text TEXT, capturedAt INTEGER NOT NULL, UNIQUE(source, fingerprint)
+      );
+      CREATE TABLE IF NOT EXISTS job (
+        singleton INTEGER PRIMARY KEY CHECK(singleton = 1),
+        id TEXT NOT NULL, kind TEXT NOT NULL, sessionKey TEXT NOT NULL,
+        source TEXT NOT NULL, through INTEGER NOT NULL, evidence TEXT NOT NULL,
+        runId TEXT, acknowledged INTEGER NOT NULL DEFAULT 0, startedAt INTEGER NOT NULL DEFAULT 0
+      );
+      CREATE TABLE IF NOT EXISTS retries (source TEXT PRIMARY KEY, retryAt INTEGER NOT NULL);
+      CREATE TABLE IF NOT EXISTS attachments (
+        source TEXT NOT NULL, key TEXT NOT NULL, evidenceId INTEGER NOT NULL,
+        data TEXT, asset TEXT, uploadName TEXT, PRIMARY KEY (source, key)
+      );
+      CREATE TABLE IF NOT EXISTS dreaming (
+        singleton INTEGER PRIMARY KEY CHECK(singleton = 1), through INTEGER NOT NULL,
+        completedAt INTEGER NOT NULL
+      );
+    `);
+    const owner = JSON.stringify({ ...input.config, connectionId: input.connectionId });
+    this.db.prepare("INSERT INTO owner SELECT ? WHERE NOT EXISTS (SELECT 1 FROM owner)").run(owner);
+    if (this.db.prepare("SELECT config FROM owner").get().config !== owner) {
+      this.db.close();
+      throw new Error("Context Use learning queue belongs to a different connection.");
+    }
+  }
+  capture(input) {
+    this.transaction(() => {
+      const insert = this.db.prepare("INSERT OR IGNORE INTO evidence(source, fingerprint, text, capturedAt) VALUES (?, ?, ?, ?)");
+      for (const item of input.evidence) {
+        insert.run(input.source, item.key, item.text, input.now);
+        if (item.attachment) {
+          this.db.prepare(`INSERT OR IGNORE INTO attachments(source, key, evidenceId, data)
+            SELECT source, fingerprint, id, ? FROM evidence WHERE source = ? AND fingerprint = ?`).run(JSON.stringify(item.attachment), input.source, item.key);
+        }
+      }
+    });
+  }
+  current() {
+    return this.db.prepare("SELECT * FROM job").get();
+  }
+  next(input) {
+    return this.transaction(() => {
+      const existing = this.current();
+      if (existing) {
+        return existing;
+      }
+      const first = this.db.prepare("SELECT e.source FROM evidence e LEFT JOIN retries r ON r.source = e.source WHERE e.text IS NOT NULL AND (r.retryAt IS NULL OR r.retryAt <= ?) ORDER BY e.id LIMIT 1").get(input.now);
+      let { through, evidence } = this.batch(first?.source);
+      if (!first) {
+        through = this.dreamThrough(input.now);
+        if (!through) {
+          return;
+        }
+      }
+      const id = randomUUID();
+      this.db.prepare("INSERT INTO job(singleton, id, kind, sessionKey, source, through, evidence) VALUES (1, ?, ?, ?, ?, ?, ?)").run(id, first ? "learn" : "dream", `agent:${input.agentId}:${LEARNING_SESSION_PREFIX}${id}`, first?.source ?? "", through, evidence);
+      return this.current();
+    });
+  }
+  batch(source) {
+    const rows = source ? this.db.prepare("SELECT id, text, capturedAt FROM evidence WHERE source = ? AND text IS NOT NULL ORDER BY id LIMIT 100").all(source) : [];
+    let through = 0;
+    let evidence = "";
+    for (const row of rows) {
+      if (evidence.length + row.text.length > BATCH_CHARS) {
+        break;
+      }
+      evidence += `${JSON.stringify({ observedAt: new Date(row.capturedAt).toISOString(), message: JSON.parse(row.text) })}
+`;
+      through = row.id;
+    }
+    return { through, evidence };
+  }
+  dreamThrough(now) {
+    if (this.status().pending || this.db.prepare("SELECT 1 FROM retries WHERE source = '' AND retryAt > ?").get(now)) {
+      return 0;
+    }
+    const progress = this.db.prepare("SELECT MAX(id) AS through, MIN(capturedAt) AS since FROM evidence").get();
+    const dream = this.db.prepare("SELECT through, completedAt FROM dreaming").get();
+    if (!progress.through || progress.through <= (dream?.through ?? 0) || now - (dream?.completedAt ?? progress.since ?? now) < DREAM_INTERVAL_MS) {
+      return 0;
+    }
+    return progress.through;
+  }
+  started(input) {
+    this.db.prepare("UPDATE job SET runId = ?, startedAt = ? WHERE id = ?").run(input.runId, input.now, input.id);
+  }
+  attachments(job) {
+    const rows = this.db.prepare("SELECT key, data, asset FROM attachments WHERE source = ? AND evidenceId <= ? AND data IS NOT NULL ORDER BY evidenceId").all(job.source, job.through);
+    return rows.map((row) => ({
+      key: row.key,
+      attachment: JSON.parse(row.data),
+      asset: row.asset
+    }));
+  }
+  attachmentSource(input) {
+    const job = this.current();
+    if (!job || job.id !== input.jobId || !this.attachments(job).some((item) => item.key === input.key)) {
+      throw new Error("This attachment is not part of the active learning job.");
+    }
+    return job.source;
+  }
+  prepareAttachmentUpload(input) {
+    const source = this.attachmentSource(input);
+    this.db.prepare("UPDATE attachments SET uploadName = COALESCE(uploadName, ?) WHERE source = ? AND key = ?").run(input.name, source, input.key);
+    return this.db.prepare("SELECT uploadName FROM attachments WHERE source = ? AND key = ?").get(source, input.key).uploadName;
+  }
+  clearAttachmentUploadName(input) {
+    const source = this.attachmentSource(input);
+    this.db.prepare("UPDATE attachments SET uploadName = NULL WHERE source = ? AND key = ?").run(source, input.key);
+  }
+  savedAttachment(input) {
+    const source = this.attachmentSource(input);
+    this.db.prepare("UPDATE attachments SET asset = ? WHERE source = ? AND key = ?").run(input.asset, source, input.key);
+  }
+  acknowledge(input) {
+    const { sessionKey, omittedAttachments = [] } = input;
+    const job = this.current();
+    if (job?.sessionKey === sessionKey && this.attachments(job).some((item) => !item.asset && !omittedAttachments.includes(item.key))) {
+      throw new Error("Save every attachment or explicitly exclude it for a retention reason before finishing. Failed uploads must be retried.");
+    }
+    const result = this.db.prepare("UPDATE job SET acknowledged = 1 WHERE sessionKey = ?").run(sessionKey);
+    if (!result.changes) {
+      throw new Error("This learning run is no longer active.");
+    }
+  }
+  retry(input) {
+    this.transaction(() => {
+      const job = this.current();
+      if (!job || job.id !== input.id) {
+        return;
+      }
+      this.db.prepare("INSERT OR REPLACE INTO retries VALUES (?, ?)").run(job.source, input.at);
+      this.db.prepare("DELETE FROM job WHERE id = ?").run(input.id);
+    });
+  }
+  finish(input) {
+    this.transaction(() => {
+      const job = this.current();
+      if (!job || job.id !== input.id || !job.acknowledged) {
+        throw new Error("Learning must be acknowledged before removing its evidence.");
+      }
+      if (job.kind === "learn") {
+        this.db.prepare("UPDATE evidence SET text = NULL WHERE source = ? AND id <= ?").run(job.source, job.through);
+        this.db.prepare("UPDATE attachments SET data = NULL WHERE source = ? AND evidenceId <= ?").run(job.source, job.through);
+      } else {
+        this.db.prepare("INSERT OR REPLACE INTO dreaming VALUES (1, ?, ?)").run(job.through, input.now);
+      }
+      this.db.prepare("DELETE FROM retries WHERE source = ?").run(job.source);
+      this.db.prepare("DELETE FROM job WHERE id = ?").run(job.id);
+    });
+  }
+  status() {
+    return {
+      pending: this.db.prepare("SELECT COUNT(*) AS count FROM evidence WHERE text IS NOT NULL").get().count,
+      running: Boolean(this.current()?.runId),
+      retryAt: this.db.prepare("SELECT MIN(retryAt) AS at FROM retries").get().at ?? undefined
+    };
+  }
+  close() {
+    this.db.close();
+  }
+  transaction(run) {
+    this.db.exec("BEGIN IMMEDIATE");
+    try {
+      const result = run();
+      this.db.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+}
+
+// src/package-installation.ts
+import { execFile as execFile2 } from "node:child_process";
+import { mkdtemp, readFile as readFile2, rm as rm2 } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { dirname as dirname2, join as join3, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify as promisify2 } from "node:util";
+import { z as z3 } from "zod";
+
+// src/host-command.ts
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+var execute = promisify(execFile);
+var HOST_TIMEOUT_MS = 120000;
+async function runSetupCommand(input) {
+  const child = spawn(process.execPath, [...input.runtime ? ["--import", input.runtime] : [], input.script, ...input.args], { stdio: "inherit" });
+  return await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code) => resolve(code ?? 1));
+  });
+}
+async function openclaw(args) {
+  const result = await execute("openclaw", args, {
+    timeout: HOST_TIMEOUT_MS,
+    maxBuffer: 4000000
+  });
+  return result.stdout;
+}
+async function checkHost() {
+  const output = await openclaw(["--version"]);
+  const version = output.match(/\b\d{4}\.\d+\.\d+(?:-[\w.-]+)?\b/)?.[0];
+  if (!version) {
+    throw new ConnectionError("Could not determine the installed OpenClaw version.");
+  }
+  assertHostVersion(version);
+}
+
+// src/package-installation.ts
+var execute2 = promisify2(execFile2);
+var INSTALL_TIMEOUT_MS = 120000;
+async function pluginInventory() {
+  const inventory = z3.object({
+    plugins: z3.array(z3.object({
+      id: z3.string(),
+      rootDir: z3.string(),
+      origin: z3.string().optional()
+    }))
+  }).parse(JSON.parse(await openclaw(["--log-level", "silent", "plugins", "list", "--json"])));
+  return inventory.plugins;
+}
+async function installedPlugin() {
+  return (await pluginInventory()).find((plugin) => plugin.id === PLUGIN_ID);
+}
+async function hostSdkAnchor() {
+  const plugins = await pluginInventory();
+  for (const plugin of plugins.filter((entry) => entry.origin === "bundled")) {
+    try {
+      return createRequire(join3(plugin.rootDir, "package.json")).resolve("openclaw/plugin-sdk/config-mutation");
+    } catch {}
+  }
+  throw new ConnectionError("Could not locate the OpenClaw SDK. Run openclaw plugins doctor and retry.");
+}
+async function installPackage() {
+  const existing = await installedPlugin();
+  if (existing) {
+    const installed = z3.object({ name: z3.string() }).parse(JSON.parse(await readFile2(join3(existing.rootDir, "package.json"), "utf8")));
+    if (installed.name !== package_default.name) {
+      throw new ConnectionError(`The context-use plugin ID belongs to another package: ${installed.name}.`);
+    }
+    return;
+  }
+  const root = resolve(dirname2(fileURLToPath(import.meta.url)), "..");
+  const directory = await mkdtemp(join3(tmpdir(), "context-use-install-"));
+  try {
+    const packed = await execute2("npm", ["pack", root, "--ignore-scripts", "--json", "--pack-destination", directory], { timeout: INSTALL_TIMEOUT_MS });
+    const [{ filename }] = z3.tuple([z3.object({ filename: z3.string() })]).parse(JSON.parse(packed.stdout));
+    console.log(await openclaw([
+      "plugins",
+      "install",
+      join3(directory, filename),
+      "--force",
+      "--accept-capabilities"
+    ]));
+  } catch (error) {
+    if (error && typeof error === "object" && "stderr" in error && typeof error.stderr === "string") {
+      process.stderr.write(error.stderr);
+    }
+    throw new ConnectionError("OpenClaw could not install Context Use. Resolve the installer error above and retry connect.");
+  } finally {
+    await rm2(directory, { recursive: true, force: true });
+  }
+}
+
+// src/removal.ts
+import { fork } from "node:child_process";
+import { once } from "node:events";
+import { readFile as readFile3, rm as rm3 } from "node:fs/promises";
+import { dirname as dirname3, join as join4 } from "node:path";
+import { setTimeout } from "node:timers/promises";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { check, lock as lock2 } from "proper-lockfile";
+import { z as z4 } from "zod";
+var RemovalSchema = z4.object({ error: z4.string().optional() });
+var removalLease = { realpath: false, stale: 30000, update: 2000 };
+var removalFile = (directory) => `${directory}.removal.json`;
+async function removalStatus(directory) {
+  try {
+    const operation = RemovalSchema.parse(JSON.parse(await readFile3(removalFile(directory), "utf8")));
+    const running = await check(removalFile(directory), removalLease);
+    return {
+      running,
+      error: operation.error ?? (running ? undefined : "Removal was interrupted. Run remove again.")
+    };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw new ConnectionError("Context Use removal status is unreadable.");
+  }
+}
+async function runRemoval(input) {
+  const release = await lock2(removalFile(input.directory), removalLease);
+  let completed = false;
+  try {
+    process.send?.("ready");
+    await input.run();
+    completed = true;
+  } catch (error) {
+    await writePrivateFile({
+      path: removalFile(input.directory),
+      data: JSON.stringify({
+        error: error instanceof ConnectionError ? error.message : "Removal failed. Run remove again to resume cleanup."
+      })
+    });
+    throw error;
+  } finally {
+    await withConnection({
+      directory: input.directory,
+      run: async () => {
+        try {
+          if (completed) {
+            await rm3(removalFile(input.directory), { force: true });
+          }
+        } finally {
+          await release();
+        }
+      }
+    });
+  }
+}
+async function requestRemoval(directory) {
+  await withConnection({
+    directory,
+    run: async () => {
+      if ((await removalStatus(directory))?.running) {
+        return;
+      }
+      const state = await readState(directory);
+      if (state) {
+        state.oauth = {};
+        await writeState({ directory, state });
+      }
+      await writePrivateFile({ path: removalFile(directory), data: "{}" });
+      const scripts = dirname3(fileURLToPath2(import.meta.url));
+      const child = fork(join4(scripts, "remove-worker.js"), [], {
+        execArgv: ["--import", join4(scripts, "setup-runtime.js")],
+        detached: true,
+        stdio: "ignore"
+      });
+      await Promise.race([
+        once(child, "message"),
+        once(child, "exit").then(() => {
+          throw new ConnectionError("Removal could not start. Run remove again.");
+        })
+      ]);
+      child.disconnect();
+      child.unref();
+    }
+  });
+}
+var REMOVAL_WAIT_MS = 180000;
+var REMOVAL_POLL_MS = 500;
+async function waitForRemoval(directory) {
+  const deadline = Date.now() + REMOVAL_WAIT_MS;
+  while (Date.now() < deadline) {
+    const current = await removalStatus(directory);
+    if (!current) {
+      return;
+    }
+    if (current.error) {
+      throw new ConnectionError(current.error);
+    }
+    await setTimeout(REMOVAL_POLL_MS);
+  }
+  throw new ConnectionError("Removal is still running. Check status in a new turn.");
+}
+async function assertNotRemoving(directory) {
+  if (await removalStatus(directory)) {
+    throw new ConnectionError("Finish removing Context Use before connecting or authorizing again.");
+  }
+}
+
 // src/connection.ts
+var authorizationFetch = (url, init) => fetch(url, { ...init, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
 async function activate(input) {
-  input.state.tools = await withClient({ ...input, run: discoverTools });
+  try {
+    input.state.tools = await withClient({ ...input, run: discoverTools });
+  } catch {
+    throw new ConnectionError("Authorization was saved, but the MCP server did not verify memory access. Check the server URL and client access in Context Use Settings, then run reconnect to authorize a fresh connection. The previous memory settings have not been replaced.");
+  }
+  input.state.learningId ??= randomUUID2();
   await mutateConfigFile({
+    afterWrite: { mode: "none", reason: "Context Use setup requests gateway refresh after commit" },
     mutate: async (config) => {
       prepareConfiguration({ config, state: input.state });
       await writeState(input);
     }
   });
 }
+async function removeLearningData(input) {
+  await rm4(join5(input.directory, attachmentDirectory(input.connectionId)), {
+    recursive: true,
+    force: true
+  });
+  for (const suffix of ["", "-journal", "-wal", "-shm"]) {
+    await rm4(join5(input.directory, `${learningDatabase(input.connectionId)}${suffix}`), {
+      force: true
+    });
+  }
+}
 async function connect(input) {
   const config = { serverUrl: serverUrl(input.instance), agentId: input.agentId };
   return await withConnection({
     directory: input.directory,
     run: async () => {
+      await assertNotRemoving(input.directory);
       const existing = await readState(input.directory);
-      if (existing && (existing.config.serverUrl !== config.serverUrl || existing.config.agentId !== config.agentId)) {
-        throw new ConnectionError("Disconnect the existing account before changing instance or agent.");
+      if (existing && existing.config.agentId !== config.agentId) {
+        throw new ConnectionError("Disconnect the existing account before changing agent.");
       }
       const state = existing ?? { config, changes: [], tools: [], oauth: {} };
       const { snapshot } = await readConfigFileSnapshotForWrite();
@@ -611,11 +1083,26 @@ async function connect(input) {
         throw new ConnectionError("OpenClaw configuration is invalid. Run openclaw doctor first.");
       }
       assertPersonalConfiguration({ config: snapshot.config, state });
+      await installPackage();
+      if (input.reauthorize || state.config.serverUrl !== config.serverUrl) {
+        const previousLearningId = state.learningId;
+        state.config = config;
+        state.oauth = {};
+        state.tools = [];
+        delete state.learningId;
+        await writeState({ directory: input.directory, state });
+        if (previousLearningId) {
+          await removeLearningData({
+            directory: input.directory,
+            connectionId: previousLearningId
+          });
+        }
+      }
       await writeState({ directory: input.directory, state });
       const result = await auth(oauthProvider({ directory: input.directory, state, interactive: true }), {
         serverUrl: config.serverUrl,
-        scope: "mcp offline_access",
-        fetchFn: (url, init) => fetch(url, { ...init, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) })
+        scope: AUTHORIZATION_SCOPE,
+        fetchFn: authorizationFetch
       });
       if (result === "REDIRECT") {
         return { authorizationUrl: state.oauth.pending?.url };
@@ -629,6 +1116,7 @@ async function finishAuthorization(input) {
   await withConnection({
     directory: input.directory,
     run: async () => {
+      await assertNotRemoving(input.directory);
       const state = await readState(input.directory);
       if (!state) {
         throw new ConnectionError("Start connect before completing authorization.");
@@ -640,14 +1128,22 @@ async function finishAuthorization(input) {
       const result = await auth(oauthProvider({ directory: input.directory, state, interactive: true }), {
         serverUrl: state.config.serverUrl,
         ...response,
-        fetchFn: (url, init) => fetch(url, { ...init, signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) })
+        fetchFn: authorizationFetch
       });
       if (result !== "AUTHORIZED") {
         throw new ConnectionError("Authorization was not completed. Start connect again.");
       }
       delete state.oauth.pending;
       delete state.oauth.verifier;
+      const previousLearningId = state.learningId;
+      state.learningId = randomUUID2();
       await writeState({ directory: input.directory, state });
+      if (previousLearningId) {
+        await removeLearningData({
+          directory: input.directory,
+          connectionId: previousLearningId
+        });
+      }
       await activate({ directory: input.directory, state });
     }
   });
@@ -663,6 +1159,10 @@ async function disconnect(directory) {
       }
       let preserved = [];
       await mutateConfigFile({
+        afterWrite: {
+          mode: "none",
+          reason: "Context Use setup requests gateway refresh after cleanup"
+        },
         writeOptions: { allowConfigSizeDrop: true },
         mutate: (config) => {
           if (state) {
@@ -670,7 +1170,7 @@ async function disconnect(directory) {
           }
         }
       });
-      await rm2(join2(directory, "connection.json"), { force: true });
+      await rm4(directory, { recursive: true, force: true });
       return { preserved };
     }
   });
@@ -690,53 +1190,58 @@ async function status(directory) {
           ...state.config
         };
       }
-      const tools = await withClient({ directory, state, run: discoverTools });
+      let tools;
+      try {
+        tools = await withClient({ directory, state, run: discoverTools });
+      } catch {
+        return {
+          connected: false,
+          authenticated: false,
+          ...state.config,
+          error: "MCP access could not be verified. Check the server and run reconnect to authorize a fresh connection."
+        };
+      }
       const { snapshot } = await readConfigFileSnapshotForWrite();
       const selected = snapshot.config.plugins?.slots?.memory === PLUGIN_ID && snapshot.config.plugins?.entries?.[PLUGIN_ID]?.enabled === true;
-      return { connected: selected, authenticated: true, ...state.config, tools: tools.length };
+      const learning = state.learningId && existsSync(join5(directory, learningDatabase(state.learningId))) ? new LearningStore({
+        directory,
+        config: state.config,
+        connectionId: state.learningId
+      }) : undefined;
+      try {
+        return {
+          connected: selected,
+          authenticated: true,
+          ...state.config,
+          tools: tools.length,
+          learning: {
+            enabled: Boolean(state.learningId),
+            ...learning?.status() ?? { pending: 0, running: false }
+          }
+        };
+      } finally {
+        learning?.close();
+      }
     }
   });
 }
 
 // src/gateway.ts
-import { resolve } from "node:path";
-import { z as z3 } from "zod";
-
-// src/host-command.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execute = promisify(execFile);
-var HOST_TIMEOUT_MS = 120000;
-async function openclaw(args) {
-  const result = await execute("openclaw", args, {
-    timeout: HOST_TIMEOUT_MS,
-    maxBuffer: 4000000
-  });
-  return result.stdout;
-}
-async function checkHost() {
-  const output = await openclaw(["--version"]);
-  const version = output.match(/\b\d{4}\.\d+\.\d+(?:-[\w.-]+)?\b/)?.[0];
-  if (!version) {
-    throw new ConnectionError("Could not determine the installed OpenClaw version.");
-  }
-  assertHostVersion(version);
-}
-
-// src/gateway.ts
+import { resolve as resolve2 } from "node:path";
+import { z as z5 } from "zod";
 async function refreshGateway() {
-  const local = z3.object({ path: z3.string() }).parse(JSON.parse(await openclaw(["config", "file", "--json"])));
+  const local = z5.object({ path: z5.string() }).parse(JSON.parse(await openclaw(["config", "file", "--json"])));
   let remote;
   try {
-    remote = z3.object({ path: z3.string() }).parse(JSON.parse(await openclaw(["gateway", "call", "config.get", "--timeout", "3000", "--json"])));
+    remote = z5.object({ path: z5.string() }).parse(JSON.parse(await openclaw(["gateway", "call", "config.get", "--timeout", "3000", "--json"])));
   } catch {
     console.log(`Settings saved. No reachable gateway was verified; they apply on its next start. Run ${OPENCLAW_INSTALL_COMMAND} refresh to retry.`);
     return;
   }
-  if (resolve(remote.path) !== resolve(local.path)) {
+  if (resolve2(remote.path) !== resolve2(local.path)) {
     throw new ConnectionError(`Settings saved, but the running gateway uses another configuration. Start this profile’s gateway, then run ${OPENCLAW_INSTALL_COMMAND} refresh.`);
   }
-  const result = z3.object({ ok: z3.boolean() }).parse(JSON.parse(await openclaw([
+  const result = z5.object({ ok: z5.boolean() }).parse(JSON.parse(await openclaw([
     "gateway",
     "call",
     "gateway.restart.request",
@@ -751,124 +1256,103 @@ async function refreshGateway() {
 }
 
 // src/host.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 async function verifyRuntime() {
-  const { plugin } = z4.object({ plugin: z4.object({ status: z4.string(), toolNames: z4.array(z4.string()) }) }).parse(JSON.parse(await openclaw(["plugins", "inspect", PLUGIN_ID, "--runtime", "--json"])));
+  const { plugin } = z6.object({ plugin: z6.object({ status: z6.string(), toolNames: z6.array(z6.string()) }) }).parse(JSON.parse(await openclaw(["plugins", "inspect", PLUGIN_ID, "--runtime", "--json"])));
   if (plugin.status !== "loaded" || !MCP_TOOL_NAMES.every((name) => plugin.toolNames.includes(toolName(name)))) {
     throw new ConnectionError("Context Use native tools did not load. Run openclaw plugins doctor, or disconnect to restore the previous settings.");
   }
 }
 
-// src/install.ts
-import { mutateConfigFile as mutateConfigFile2 } from "openclaw/plugin-sdk/config-mutation";
-
-// src/package-installation.ts
-import { execFile as execFile2 } from "node:child_process";
-import { mkdtemp, readFile as readFile2, rm as rm3 } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join as join3, resolve as resolve2 } from "node:path";
-import { fileURLToPath } from "node:url";
-import { promisify as promisify2 } from "node:util";
-import { z as z5 } from "zod";
-var execute2 = promisify2(execFile2);
-var INSTALL_TIMEOUT_MS = 120000;
-async function installedPlugin() {
-  const inventory = z5.object({
-    plugins: z5.array(z5.object({
-      id: z5.string(),
-      rootDir: z5.string()
-    }))
-  }).parse(JSON.parse(await openclaw(["plugins", "list", "--json"])));
-  return inventory.plugins.find((plugin) => plugin.id === PLUGIN_ID);
-}
-async function installPackage() {
-  const existing = await installedPlugin();
-  if (existing) {
-    const installed = z5.object({ name: z5.string() }).parse(JSON.parse(await readFile2(join3(existing.rootDir, "package.json"), "utf8")));
-    if (installed.name !== package_default.name) {
-      throw new ConnectionError(`The context-use plugin ID belongs to another package: ${installed.name}.`);
-    }
-    return;
-  }
-  const root = resolve2(dirname(fileURLToPath(import.meta.url)), "..");
-  const directory = await mkdtemp(join3(tmpdir(), "context-use-install-"));
-  try {
-    const packed = await execute2("npm", ["pack", root, "--ignore-scripts", "--json", "--pack-destination", directory], { timeout: INSTALL_TIMEOUT_MS });
-    const [{ filename }] = z5.tuple([z5.object({ filename: z5.string() })]).parse(JSON.parse(packed.stdout));
-    console.log(await openclaw([
-      "plugins",
-      "install",
-      join3(directory, filename),
-      "--force",
-      "--accept-capabilities"
-    ]));
-  } catch (error) {
-    if (error && typeof error === "object" && "stderr" in error && typeof error.stderr === "string") {
-      process.stderr.write(error.stderr);
-    }
-    throw new ConnectionError("OpenClaw could not install Context Use. Resolve the installer error above and retry connect.");
-  } finally {
-    await rm3(directory, { recursive: true, force: true });
-  }
-}
-
-// src/install.ts
-async function uninstall() {
-  if (await installedPlugin()) {
-    console.log(await openclaw(["plugins", "uninstall", PLUGIN_ID, "--force"]));
-  }
-  await mutateConfigFile2({
-    writeOptions: { allowConfigSizeDrop: true },
-    mutate: (config) => {
-      if (config.plugins?.entries) {
-        delete config.plugins.entries[PLUGIN_ID];
-      }
-    }
-  });
-}
-
 // src/usage.ts
 var SETUP_USAGE = `context-use-openclaw connect <instance-url> [agent-id=main]
+context-use-openclaw reconnect [instance-url] [agent-id]
 context-use-openclaw authorize
 context-use-openclaw status
 context-use-openclaw disconnect
-context-use-openclaw remove
+context-use-openclaw remove [--wait]
 context-use-openclaw refresh
 
 Connect installs the plugin and starts browser authorization. Pass the returned URL to authorize
 through standard input. After installation, these commands also work through openclaw context-use.
-Use the same OpenClaw profile for every command. Remove restores your settings and uninstalls the
-plugin while preserving remote memories. Refresh also works after uninstall.`;
+Reconnect starts fresh authorization, using the saved URL when omitted. Connect with a different URL
+also starts fresh authorization. Use the same OpenClaw profile for every command. Remove restores your settings and uninstalls the
+plugin while preserving remote memories and conversation history. Remove runs in the background: end
+the requesting agent turn, then check status in a new turn. Use --wait only from a terminal outside
+an agent turn. Status, remove and refresh also work after uninstall through the npm helper.`;
 
 // src/setup.ts
+async function connectCommand({
+  directory,
+  command,
+  argument,
+  agentArgument
+}) {
+  const previous = await readState(directory);
+  const instance = argument ?? (command === "reconnect" ? previous?.config.serverUrl : undefined);
+  const agentId = agentArgument ?? previous?.config.agentId ?? "main";
+  if (!instance) {
+    throw new ConnectionError(SETUP_USAGE);
+  }
+  PluginConfigSchema.shape.agentId.parse(agentId);
+  const result = await connect({
+    directory,
+    instance,
+    agentId,
+    reauthorize: command === "reconnect"
+  });
+  if (result.authorizationUrl) {
+    console.log(`Open this URL to authorize Context Use:
+${result.authorizationUrl}
+
+Copy the final localhost URL and send it back, even if the page does not load. Finish with ${OPENCLAW_INSTALL_COMMAND} authorize, passing the returned URL through standard input.`);
+  } else {
+    console.log("Context Use authorized. Memory settings saved.");
+    await refreshGateway();
+  }
+  return;
+}
+async function statusCommand(directory) {
+  const removal = await removalStatus(directory);
+  if (removal) {
+    console.log(JSON.stringify({ connected: false, removal }, null, 2));
+    return;
+  }
+  const result = {
+    ...await status(directory),
+    installed: Boolean(await installedPlugin())
+  };
+  if (result.connected) {
+    try {
+      await verifyRuntime();
+    } catch {
+      result.connected = false;
+      result.activationPending = true;
+      result.error = "Memory settings are saved but native tools are not active. Finish active work, run refresh, then check status in a new turn.";
+    }
+  }
+  console.log(JSON.stringify(result, null, 2));
+  return;
+}
 async function main(args) {
-  const [command, argument, agentId = "main"] = args;
+  const [command, argument, agentArgument] = args;
   if (!command || command === "--help") {
     console.log(SETUP_USAGE);
     return;
   }
   await checkHost();
   const directory = connectionDirectory();
+  const removal = await removalStatus(directory);
+  if (removal && !["remove", "status", "refresh"].includes(command)) {
+    throw new ConnectionError(removal.error ?? "Removal is still running. Check status in a new turn before reconnecting.");
+  }
   switch (command) {
     case "refresh":
       await refreshGateway();
       return;
-    case "connect": {
-      if (!argument) {
-        throw new ConnectionError(SETUP_USAGE);
-      }
-      PluginConfigSchema.shape.agentId.parse(agentId);
-      const result = await connect({ directory, instance: argument, agentId });
-      if (result.authorizationUrl) {
-        console.log(`Open this URL to authorize Context Use:
-${result.authorizationUrl}
-
-Copy the final localhost URL and send it back, even if the page does not load. Finish with ${OPENCLAW_INSTALL_COMMAND} authorize, passing the returned URL through standard input.`);
-      } else {
-        await verifyRuntime();
-        console.log("Context Use connected.");
-        await refreshGateway();
-      }
+    case "connect":
+    case "reconnect": {
+      await connectCommand({ directory, command, argument, agentArgument });
       return;
     }
     case "authorize": {
@@ -877,29 +1361,33 @@ Copy the final localhost URL and send it back, even if the page does not load. F
       }
       const redirectUrl = (await text(process.stdin)).trim();
       await finishAuthorization({ directory, redirectUrl });
-      await verifyRuntime();
-      console.log("Context Use connected.");
+      console.log("Context Use authorized. Memory settings saved.");
       await refreshGateway();
       return;
     }
     case "status": {
-      const result = await status(directory);
-      if (result.connected) {
-        await verifyRuntime();
-      }
-      console.log(JSON.stringify(result, null, 2));
+      await statusCommand(directory);
       return;
     }
-    case "disconnect":
-    case "remove": {
+    case "disconnect": {
       const { preserved } = await disconnect(directory);
       console.log(`Disconnected. Remote memories are preserved.${preserved.length ? ` Kept user edits: ${preserved.join(", ")}.` : ""}`);
-      if (command === "remove") {
-        await uninstall();
-      }
       await refreshGateway();
       return;
     }
+    case "remove": {
+      if (![undefined, "--wait"].includes(argument)) {
+        throw new ConnectionError(SETUP_USAGE);
+      }
+      await requestRemoval(directory);
+      if (argument !== "--wait") {
+        console.log("Local authorization cleared. Removal is running separately so this agent turn can finish. End this turn; check status in a new turn. Do not poll from this turn or restart the gateway. Remote memories and conversation history are preserved.");
+        return;
+      }
+      await waitForRemoval(directory);
+      console.log("Context Use removed. Remote memories and conversation history are preserved.");
+      return;
+    }
     default:
       throw new ConnectionError(SETUP_USAGE);
   }