@agentmemory/agentmemory 0.9.30 → 0.9.32

package/dist/{connect-B4_ca6BD.mjs → connect-BX3njQ3Y.mjs}

@@ -1,10 +1,13 @@
 import "node:module";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir, platform } from "node:os";
 import * as p from "@clack/prompts";
 import pc from "picocolors";
+import { createHash, randomUUID } from "node:crypto";
+import { Document, isMap, isSeq, parseDocument } from "yaml";
+import JSON5 from "json5";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -17,6 +20,91 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
+//#region src/cli/connect/util.ts
+const AGENTMEMORY_MCP_BLOCK = {
+	command: "npx",
+	args: ["-y", "@agentmemory/mcp"],
+	env: {
+		AGENTMEMORY_URL: "${AGENTMEMORY_URL:-http://localhost:3111}",
+		AGENTMEMORY_SECRET: "${AGENTMEMORY_SECRET:-}",
+		AGENTMEMORY_TOOLS: "${AGENTMEMORY_TOOLS:-all}"
+	}
+};
+const AGENTMEMORY_COPILOT_MCP_BLOCK = {
+	type: "local",
+	...process.platform === "win32" ? {
+		command: process.env["ComSpec"] || process.env["COMSPEC"] || "cmd.exe",
+		args: [
+			"/d",
+			"/s",
+			"/c",
+			"npx",
+			"-y",
+			"@agentmemory/mcp"
+		]
+	} : {
+		command: "npx",
+		args: ["-y", "@agentmemory/mcp"]
+	},
+	env: {
+		AGENTMEMORY_URL: "${AGENTMEMORY_URL:-http://localhost:3111}",
+		AGENTMEMORY_SECRET: "${AGENTMEMORY_SECRET:-}",
+		AGENTMEMORY_TOOLS: "${AGENTMEMORY_TOOLS:-all}"
+	},
+	tools: ["*"]
+};
+function resolveDshHome(home = homedir()) {
+	const override = process.env["DSH_HOME"];
+	const value = override?.trim() ? override : join(home, ".dsh");
+	if (value === "~") return resolve(home);
+	if (value.startsWith("~/") || value.startsWith("~\\")) return resolve(join(home, value.slice(2)));
+	return resolve(value);
+}
+function backupsDir() {
+	return join(homedir(), ".agentmemory", "backups");
+}
+function ensureBackupsDir() {
+	const dir = backupsDir();
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
+function timestampSlug() {
+	return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+}
+function backupFile(sourcePath, agent, ext = "json") {
+	ensureBackupsDir();
+	const stamp = timestampSlug();
+	const target = join(backupsDir(), `${agent}-${stamp}.${ext}`);
+	copyFileSync(sourcePath, target);
+	return target;
+}
+function readJsonSafe(path) {
+	if (!existsSync(path)) return null;
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function writeJsonAtomic(path, value) {
+	writeTextAtomic(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+function writeTextAtomic(path, content) {
+	mkdirSync(dirname(path), { recursive: true });
+	const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+	writeFileSync(tmp, content, "utf-8");
+	renameSync(tmp, path);
+}
+function logInstalled(label, target) {
+	p.log.success(`${label} → wired into ${target}`);
+}
+function logAlreadyWired(label, target) {
+	p.log.info(`${label} already wired in ${target} (use --force to re-install)`);
+}
+function logBackup(target) {
+	p.log.info(`Backup: ${target}`);
+}
+//#endregion
 //#region src/cli/connect/guidelines.ts
 const START = "<!-- agentmemory:start -->";
 const END = "<!-- agentmemory:end -->";
@@ -95,6 +183,13 @@ function guidelineTargets(home = homedir()) {
 			scope: "global",
 			source: "https://docs.factory.ai/cli/configuration/agents-md"
 		},
+		dsh: {
+			globalPath: join(resolveDshHome(home), "AGENTS.md"),
+			projectPath: "AGENTS.md",
+			format: "block",
+			scope: "global",
+			source: "https://github.com/deepseek-ai/deepseek-harness"
+		},
 		antigravity: {
 			globalPath: join(home, ".gemini", "GEMINI.md"),
 			projectPath: join(".agents", "rules", "agentmemory.md"),
@@ -123,7 +218,7 @@ function renderDedicated(format) {
 	if (format === "steering") return `---\ninclusion: always\n---\n\n${GUIDELINE_BODY}\n`;
 	return `${GUIDELINE_BODY}\n`;
 }
-function upsertBlock(existing) {
+function upsertBlock$1(existing) {
 	const block = `${START}\n${GUIDELINE_BODY}\n${END}`;
 	const startIdx = existing.indexOf(START);
 	const endIdx = existing.indexOf(END);
@@ -137,7 +232,7 @@ function writeGuideline(agentName, opts = { cwd: process.cwd() }) {
 	const path = target.globalPath ?? join(opts.cwd, target.projectPath);
 	const dedicated = target.format !== "block";
 	const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
-	const next = dedicated ? renderDedicated(target.format) : upsertBlock(existing);
+	const next = dedicated ? renderDedicated(target.format) : upsertBlock$1(existing);
 	if (existing === next) return {
 		kind: "unchanged",
 		path,
@@ -158,84 +253,6 @@ function writeGuideline(agentName, opts = { cwd: process.cwd() }) {
 	};
 }
 //#endregion
-//#region src/cli/connect/util.ts
-const AGENTMEMORY_MCP_BLOCK = {
-	command: "npx",
-	args: ["-y", "@agentmemory/mcp"],
-	env: {
-		AGENTMEMORY_URL: "${AGENTMEMORY_URL:-http://localhost:3111}",
-		AGENTMEMORY_SECRET: "${AGENTMEMORY_SECRET:-}",
-		AGENTMEMORY_TOOLS: "${AGENTMEMORY_TOOLS:-all}"
-	}
-};
-const AGENTMEMORY_COPILOT_MCP_BLOCK = {
-	type: "local",
-	...process.platform === "win32" ? {
-		command: process.env["ComSpec"] || process.env["COMSPEC"] || "cmd.exe",
-		args: [
-			"/d",
-			"/s",
-			"/c",
-			"npx",
-			"-y",
-			"@agentmemory/mcp"
-		]
-	} : {
-		command: "npx",
-		args: ["-y", "@agentmemory/mcp"]
-	},
-	env: {
-		AGENTMEMORY_URL: "${AGENTMEMORY_URL:-http://localhost:3111}",
-		AGENTMEMORY_SECRET: "${AGENTMEMORY_SECRET:-}",
-		AGENTMEMORY_TOOLS: "${AGENTMEMORY_TOOLS:-all}"
-	},
-	tools: ["*"]
-};
-function backupsDir() {
-	return join(homedir(), ".agentmemory", "backups");
-}
-function ensureBackupsDir() {
-	const dir = backupsDir();
-	mkdirSync(dir, { recursive: true });
-	return dir;
-}
-function timestampSlug() {
-	return (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-}
-function backupFile(sourcePath, agent, ext = "json") {
-	ensureBackupsDir();
-	const stamp = timestampSlug();
-	const target = join(backupsDir(), `${agent}-${stamp}.${ext}`);
-	copyFileSync(sourcePath, target);
-	return target;
-}
-function readJsonSafe(path) {
-	if (!existsSync(path)) return null;
-	try {
-		return JSON.parse(readFileSync(path, "utf-8"));
-	} catch {
-		return null;
-	}
-}
-function writeJsonAtomic(path, value) {
-	writeTextAtomic(path, `${JSON.stringify(value, null, 2)}\n`);
-}
-function writeTextAtomic(path, content) {
-	mkdirSync(dirname(path), { recursive: true });
-	const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
-	writeFileSync(tmp, content, "utf-8");
-	renameSync(tmp, path);
-}
-function logInstalled(label, target) {
-	p.log.success(`${label} → wired into ${target}`);
-}
-function logAlreadyWired(label, target) {
-	p.log.info(`${label} already wired in ${target} (use --force to re-install)`);
-}
-function logBackup(target) {
-	p.log.info(`Backup: ${target}`);
-}
-//#endregion
 //#region src/cli/connect/json-mcp-adapter.ts
 function entryMatches$3(entry) {
 	if (!entry || typeof entry !== "object") return false;
@@ -413,13 +430,14 @@ function findPluginRoot(startUrl = import.meta.url) {
 /**
 * Build the merged hooks.json content.
 *
-*   1. Strip any entry from `existing` whose first hook command points
-*      under `<pluginRoot>/scripts/`. This lets us re-install idempotently
-*      without leaving stale references.
+*   1. Strip every handler in `existing` whose command points under
+*      `<pluginRoot>/scripts/`, and an entry only once nothing else is left
+*      in it. This lets us re-install idempotently without leaving stale
+*      references or dropping the user's own handlers.
 *   2. Append fresh entries from the bundled Codex manifest with
 *      `${CLAUDE_PLUGIN_ROOT}` rewritten to the absolute plugin path.
-*      Matcher values from the bundled manifest are preserved so PreToolUse
-*      event routing keeps working.
+*      Matchers and the other handler fields from the bundled manifest are
+*      preserved so PreToolUse event routing keeps working.
 */
 function buildMergedHooks(existing, pluginRoot, manifestFile = "hooks.codex.json") {
 	const bundledManifestPath = join(pluginRoot, "hooks", manifestFile);
@@ -427,15 +445,26 @@ function buildMergedHooks(existing, pluginRoot, manifestFile = "hooks.codex.json
 	const scriptsDir = join(pluginRoot, "scripts");
 	const out = { hooks: {} };
 	if (existing?.hooks) for (const [event, entries] of Object.entries(existing.hooks)) {
-		const kept = entries.filter((entry) => !isAgentmemoryEntry(entry, scriptsDir));
+		const kept = entries.flatMap((entry) => {
+			const hooks = entry.hooks.filter((handler) => !isAgentmemoryHandler(handler, scriptsDir));
+			if (hooks.length === entry.hooks.length) return [entry];
+			return hooks.length > 0 ? [{
+				...entry,
+				hooks
+			}] : [];
+		});
 		if (kept.length > 0) out.hooks[event] = kept;
 	}
 	for (const [event, entries] of Object.entries(ours.hooks)) {
 		const resolvedEntries = entries.map((entry) => {
-			const next = { hooks: entry.hooks.map((handler) => ({
-				type: handler.type,
-				command: handler.command.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginRoot)
-			})) };
+			const next = { hooks: entry.hooks.map((handler) => {
+				const resolved = {
+					...handler,
+					command: withPluginRoot(handler.command, pluginRoot)
+				};
+				if (handler.args) resolved.args = handler.args.map((arg) => withPluginRoot(arg, pluginRoot));
+				return resolved;
+			}) };
 			if (entry.matcher !== void 0) next.matcher = entry.matcher;
 			return next;
 		});
@@ -443,9 +472,11 @@ function buildMergedHooks(existing, pluginRoot, manifestFile = "hooks.codex.json
 	}
 	return out;
 }
-function isAgentmemoryEntry(entry, scriptsDir) {
-	const normalizedScriptsDir = normalizePathForCommandMatch(scriptsDir);
-	return entry.hooks.some((handler) => normalizePathForCommandMatch(handler.command).includes(normalizedScriptsDir));
+function withPluginRoot(value, pluginRoot) {
+	return value?.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, () => pluginRoot);
+}
+function isAgentmemoryHandler(handler, scriptsDir) {
+	return [handler.command, ...Array.isArray(handler.args) ? handler.args : []].some((part) => typeof part === "string" && normalizePathForCommandMatch(part).includes(normalizePathForCommandMatch(scriptsDir)));
 }
 function normalizePathForCommandMatch(value) {
 	return value.replace(/\\/g, "/");
@@ -456,7 +487,7 @@ const GEMINI_DIR = join(homedir(), ".gemini");
 const ANTIGRAVITY_CLI_DIR = join(GEMINI_DIR, "antigravity-cli");
 const CUSTOMIZATION_DIR$1 = join(GEMINI_DIR, "config");
 const ANTIGRAVITY_CLI_HOOKS = join(CUSTOMIZATION_DIR$1, "hooks.json");
-const adapter$20 = createJsonMcpAdapter({
+const adapter$21 = createJsonMcpAdapter({
 	name: "antigravity-cli",
 	displayName: "Antigravity CLI (agy)",
 	detectDir: ANTIGRAVITY_CLI_DIR,
@@ -521,7 +552,7 @@ const mcpAdapter = createJsonMcpAdapter({
 	protocolNote: "→ Using MCP via ~/.gemini/config/mcp_config.json, shared by current Antigravity surfaces. Pass --with-hooks for capture through ~/.gemini/config/hooks.json.",
 	installHooks: installAntigravityCliHooks
 });
-const adapter$19 = {
+const adapter$20 = {
 	...mcpAdapter,
 	detect: () => mcpAdapter.detect() || existsSync(join(homedir(), ".gemini", "antigravity")) || existsSync(LEGACY_USER_DIR)
 };
@@ -536,7 +567,7 @@ function entryMatches$2(entry) {
 	if (e["command"] !== "npx") return false;
 	return (Array.isArray(e["args"]) ? e["args"] : []).includes("@agentmemory/mcp");
 }
-const adapter$18 = {
+const adapter$19 = {
 	name: "claude-code",
 	displayName: "Claude Code",
 	category: "native",
@@ -637,14 +668,21 @@ function installClaudeHooks(opts) {
 }
 //#endregion
 //#region src/cli/connect/cline.ts
-const adapter$17 = createJsonMcpAdapter({
-	name: "cline",
-	displayName: "Cline",
-	detectDir: join(homedir(), ".cline"),
-	configPath: join(homedir(), ".cline", "mcp.json"),
-	docs: "https://github.com/rohitg00/agentmemory#other-agents",
-	protocolNote: "→ Using MCP via ~/.cline/mcp.json (CLI). VS Code users: add the same block via Cline Settings → MCP Servers → Edit JSON."
-});
+const CLINE_DIR = join(homedir(), ".cline");
+const SETTINGS_OVERRIDE = process.env["CLINE_MCP_SETTINGS_PATH"];
+const adapter$18 = {
+	...createJsonMcpAdapter({
+		name: "cline",
+		displayName: "Cline",
+		detectDir: CLINE_DIR,
+		configPath: SETTINGS_OVERRIDE || join(CLINE_DIR, "data", "settings", "cline_mcp_settings.json"),
+		docs: "https://github.com/rohitg00/agentmemory#other-agents",
+		protocolNote: "→ Using MCP via ~/.cline/data/settings/cline_mcp_settings.json (CLI), or CLINE_MCP_SETTINGS_PATH when set. VS Code users: add the same block via Cline Settings → MCP Servers → Edit JSON."
+	}),
+	detect() {
+		return Boolean(SETTINGS_OVERRIDE) || existsSync(CLINE_DIR);
+	}
+};
 //#endregion
 //#region src/cli/connect/copilot-cli.ts
 const COPILOT_DIR = process.env["COPILOT_HOME"] || join(homedir(), ".copilot");
@@ -653,7 +691,7 @@ function entryMatches$1(entry) {
 	if (!entry || typeof entry !== "object") return false;
 	return JSON.stringify(entry) === JSON.stringify(AGENTMEMORY_COPILOT_MCP_BLOCK);
 }
-const adapter$16 = {
+const adapter$17 = {
 	name: "copilot-cli",
 	displayName: "GitHub Copilot CLI",
 	category: "native",
@@ -736,7 +774,7 @@ function stripExistingBlock(toml) {
 	}
 	return out.join("\n").replace(/\n{3,}$/, "\n\n").trimEnd() + "\n";
 }
-const adapter$15 = {
+const adapter$16 = {
 	name: "codex",
 	displayName: "Codex CLI",
 	category: "native",
@@ -856,7 +894,7 @@ function renderFreshYaml() {
 		""
 	].join("\n");
 }
-const adapter$14 = {
+const adapter$15 = {
 	name: "continue",
 	displayName: "Continue",
 	category: "mcp",
@@ -936,13 +974,14 @@ const adapter$14 = {
 };
 //#endregion
 //#region src/cli/connect/cursor.ts
-const adapter$13 = createJsonMcpAdapter({
+const adapter$14 = createJsonMcpAdapter({
 	name: "cursor",
 	displayName: "Cursor",
+	category: "native",
 	detectDir: join(homedir(), ".cursor"),
 	configPath: join(homedir(), ".cursor", "mcp.json"),
-	docs: "https://github.com/rohitg00/agentmemory#other-agents",
-	protocolNote: "→ Using MCP (the only protocol Cursor speaks). Memory bridge runs at :3111 underneath."
+	docs: "https://github.com/rohitg00/agentmemory#cursor",
+	protocolNote: "→ Using MCP. Lifecycle hooks ship in the Cursor plugin: Settings → Plugins → Add marketplace → this repo, then enable agentmemory."
 });
 //#endregion
 //#region src/cli/connect/devin.ts
@@ -956,7 +995,7 @@ function devinDir() {
 }
 const DEVIN_DIR = devinDir();
 const DEVIN_CONFIG = join(DEVIN_DIR, "config.json");
-const adapter$12 = createJsonMcpAdapter({
+const adapter$13 = createJsonMcpAdapter({
 	name: "devin",
 	displayName: "Devin CLI",
 	detectDir: DEVIN_DIR,
@@ -1006,7 +1045,7 @@ function installDevinHooks(opts) {
 //#region src/cli/connect/droid.ts
 const DROID_DIR = join(homedir(), ".factory");
 const DROID_HOOKS = join(DROID_DIR, "hooks.json");
-const adapter$11 = createJsonMcpAdapter({
+const adapter$12 = createJsonMcpAdapter({
 	name: "droid",
 	displayName: "Droid (Factory.ai)",
 	detectDir: DROID_DIR,
@@ -1057,9 +1096,6 @@ function installDroidHooks(opts) {
 }
 //#endregion
 //#region src/cli/connect/dsh.ts
-function dshHome() {
-	return process.env["DSH_HOME"] || join(homedir(), ".dsh");
-}
 const MCP_BLOCK = `- insert:
     - id: agentmemory
       name: '@deepseek-ai/dsh-mcp-client'
@@ -1069,55 +1105,89 @@ const MCP_BLOCK = `- insert:
         command: npx
         args: ['-y', '@agentmemory/mcp']
         env:
-          AGENTMEMORY_URL: http://localhost:3111
+          AGENTMEMORY_URL: !!js process.env.AGENTMEMORY_URL || 'http://localhost:3111'
+          AGENTMEMORY_SECRET: !!js process.env.AGENTMEMORY_SECRET || ''
 `;
 const MCP_MARKER = "serverName: agentmemory";
 const HOOKS_MARKER = "id: agentmemory-hooks";
-function hooksBlock(hooksConfigPath) {
+function hooksBlock(pluginPath) {
 	return `- insert:
     - id: agentmemory-hooks
-      name: '@deepseek-ai/dsh-hooks-claude-code'
-      config:
-        configPath: ${JSON.stringify(hooksConfigPath)}
+      name: ${JSON.stringify(pluginPath)}
 `;
 }
-function stripBlock(content, marker) {
-	if (!content.includes(marker)) return content;
-	const lines = content.split("\n");
-	const markerIdx = lines.findIndex((l) => l.includes(marker));
-	let start = markerIdx;
-	while (start > 0 && !lines[start].startsWith("- ")) start--;
-	let end = markerIdx + 1;
-	while (end < lines.length && !lines[end].startsWith("- ")) end++;
-	return lines.slice(0, start).concat(lines.slice(end)).join("\n").replace(/\n+$/, "\n");
-}
-function appendBlock(content, block) {
-	const base = content.replace(/\n+$/, "\n");
-	return base.trim() ? `${base}\n${block}` : block;
-}
-function installHooksFile(home) {
-	const hooksPath = join(home, "agentmemory.hooks.json");
-	const pluginRoot = findPluginRoot();
-	writeJsonAtomic(hooksPath, buildMergedHooks(readJsonSafe(hooksPath), pluginRoot, "hooks.codex.json"));
-	return hooksPath;
-}
-const adapter$10 = {
+function parsePatch(content) {
+	const doc = parseDocument(content);
+	if (doc.contents === null) doc.contents = doc.createNode([]);
+	if (doc.errors.length || !isSeq(doc.contents)) throw new Error("Cannot update dsh cordis.patch.yml: expected a valid YAML sequence.");
+	return {
+		doc,
+		operations: doc.contents
+	};
+}
+function isManaged(entry, marker) {
+	if (!isMap(entry)) return false;
+	return marker === MCP_MARKER ? entry.get("name") === "@deepseek-ai/dsh-mcp-client" && entry.getIn(["config", "serverName"]) === "agentmemory" : entry.get("id") === "agentmemory-hooks" && typeof entry.get("name") === "string" && (entry.get("name") === "@deepseek-ai/dsh-hooks-claude-code" || /[\\/]dist[\\/]integrations[\\/]dsh\.mjs$/.test(String(entry.get("name"))));
+}
+function managedEntries(content, marker) {
+	return parsePatch(content).operations.items.flatMap((operation) => {
+		const entries = isMap(operation) ? operation.get("insert", true) : null;
+		return isSeq(entries) ? entries.items.filter((entry) => isManaged(entry, marker)) : [];
+	});
+}
+function hasBlock(content, marker) {
+	return managedEntries(content, marker).length > 0;
+}
+function upsertBlock(content, marker, block) {
+	const { doc, operations } = parsePatch(content);
+	const addition = parsePatch(block).operations;
+	const replacement = addition.getIn([
+		0,
+		"insert",
+		0
+	], true);
+	let replaced = false;
+	for (let i = 0; i < operations.items.length; i++) {
+		const operation = operations.items[i];
+		if (!isMap(operation)) continue;
+		const entries = operation.get("insert", true);
+		if (!isSeq(entries)) continue;
+		let removed = false;
+		for (let j = 0; j < entries.items.length; j++) {
+			if (!isManaged(entries.items[j], marker)) continue;
+			if (!replaced) {
+				entries.set(j, replacement);
+				replaced = true;
+			} else {
+				entries.delete(j--);
+				removed = true;
+			}
+		}
+		if (removed && entries.items.length === 0) operations.delete(i--);
+	}
+	if (!replaced) operations.items.push(...addition.items);
+	operations.flow = false;
+	return doc.toString();
+}
+const adapter$11 = {
 	name: "dsh",
 	displayName: "DeepSeek Harness",
-	docs: "https://github.com/rohitg00/agentmemory#other-agents",
-	protocolNote: "→ Using MCP via $DSH_HOME/cordis.patch.yml (the home-level patch layer every profile loads). Tools appear as mcp__agentmemory__*. Pass --with-hooks to also wire auto-capture through Harness's Claude Code hook bridge.",
+	docs: "https://github.com/rohitg00/agentmemory/blob/main/docs/dsh.md",
+	protocolNote: "→ Using MCP via $DSH_HOME/cordis.patch.yml (the home-level patch layer every profile loads). Tools appear as mcp__agentmemory__*. Pass --with-hooks to also wire auto-capture with the bundled native DSH plugin.",
 	category: "native",
 	detect() {
-		return existsSync(dshHome());
+		return existsSync(resolveDshHome());
 	},
 	async install(opts) {
-		const home = dshHome();
-		const configPath = join(home, "cordis.patch.yml");
+		const configPath = join(resolveDshHome(), "cordis.patch.yml");
 		const existing = existsSync(configPath) ? readFileSync(configPath, "utf-8") : "";
 		const wantHooks = opts.withHooks === true;
-		const hasMcp = existing.includes(MCP_MARKER);
-		const hasHooks = existing.includes(HOOKS_MARKER);
-		if (hasMcp && (!wantHooks || hasHooks) && !opts.force) {
+		const hasMcp = hasBlock(existing, MCP_MARKER);
+		const hooks = managedEntries(existing, HOOKS_MARKER);
+		const pluginPath = wantHooks ? join(dirname(findPluginRoot()), "dist", "integrations", "dsh.mjs") : "";
+		const hooksReady = hooks.length === 1 && hooks[0].get("name") === pluginPath && existsSync(pluginPath);
+		if (wantHooks && !opts.force && hooks.some((entry) => entry.get("name") === "@deepseek-ai/dsh-hooks-claude-code")) throw new Error("Legacy DSH hooks bridge found. Run agentmemory connect dsh --with-hooks --force to replace it with the bundled native plugin. Existing manifest files will be preserved.");
+		if (hasMcp && (!wantHooks || hooksReady) && !opts.force) {
 			logAlreadyWired(this.displayName, configPath);
 			return {
 				kind: "already-wired",
@@ -1125,28 +1195,23 @@ const adapter$10 = {
 			};
 		}
 		if (opts.dryRun) {
-			p.log.info(`[dry-run] Would append the agentmemory mcp-client row${wantHooks ? " and the hooks-claude-code row" : ""} to ${configPath}`);
+			p.log.info(`[dry-run] Would update the agentmemory mcp-client row${wantHooks ? " and the bundled capture plugin" : ""} in ${configPath}`);
 			return {
 				kind: "installed",
 				mutatedPath: configPath
 			};
 		}
+		if (wantHooks && !existsSync(pluginPath)) throw new Error("Bundled DSH plugin is missing. Reinstall AgentMemory, or run npm run build in a source checkout.");
 		let backupPath;
 		if (existsSync(configPath)) {
 			backupPath = backupFile(configPath, this.name, "yml");
 			logBackup(backupPath);
 		} else mkdirSync(dirname(configPath), { recursive: true });
-		let next = stripBlock(existing, MCP_MARKER);
-		next = appendBlock(next, MCP_BLOCK);
-		if (wantHooks) {
-			const hooksPath = installHooksFile(home);
-			next = stripBlock(next, HOOKS_MARKER);
-			next = appendBlock(next, hooksBlock(hooksPath));
-			p.log.info(`Hook manifest: ${hooksPath}`);
-		}
+		let next = hasMcp && !opts.force ? existing : upsertBlock(existing, MCP_MARKER, MCP_BLOCK);
+		if (wantHooks && (!hooksReady || opts.force)) next = upsertBlock(next, HOOKS_MARKER, hooksBlock(pluginPath));
 		writeTextAtomic(configPath, next);
 		const written = readFileSync(configPath, "utf-8");
-		if (!written.includes(MCP_MARKER) || wantHooks && !written.includes(HOOKS_MARKER)) {
+		if (!hasBlock(written, MCP_MARKER) || wantHooks && !hasBlock(written, HOOKS_MARKER)) {
 			p.log.error(`Verification failed: ${configPath} did not contain the agentmemory rows after write.`);
 			return {
 				kind: "skipped",
@@ -1163,7 +1228,7 @@ const adapter$10 = {
 };
 //#endregion
 //#region src/cli/connect/gemini-cli.ts
-const adapter$9 = createJsonMcpAdapter({
+const adapter$10 = createJsonMcpAdapter({
 	name: "gemini-cli",
 	displayName: "Gemini CLI",
 	detectDir: join(homedir(), ".gemini"),
@@ -1172,43 +1237,275 @@ const adapter$9 = createJsonMcpAdapter({
 	protocolNote: "→ Using MCP (the only protocol Gemini CLI speaks). Memory bridge runs at :3111 underneath."
 });
 //#endregion
+//#region src/cli/connect/native-install.ts
+const MANIFEST = ".agentmemory-install.json";
+const digest = (content) => createHash("sha256").update(content).digest("hex");
+const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function nativePackageRoot() {
+	return dirname(findPluginRoot());
+}
+function nativeUserPath(value, home) {
+	return resolve(value.replace(/^~(?=$|[/\\])/, () => home));
+}
+function nativeMcpEntry(packageRoot) {
+	const entry = join(packageRoot, "dist", "standalone.mjs");
+	if (!existsSync(entry)) throw new Error("Bundled MCP runtime is missing; reinstall AgentMemory before connecting.");
+	return {
+		command: process.execPath,
+		args: [entry],
+		env: {
+			AGENTMEMORY_TOOLS: "all",
+			AGENTMEMORY_FORCE_PROXY: "1"
+		}
+	};
+}
+function filesUnder(dir, prefix = "") {
+	const files = /* @__PURE__ */ new Map();
+	for (const item of readdirSync(dir, { withFileTypes: true })) {
+		if ([
+			"__pycache__",
+			".git",
+			"node_modules",
+			MANIFEST
+		].includes(item.name) || item.name.endsWith(".pyc")) continue;
+		const path = join(dir, item.name);
+		if (item.isSymbolicLink()) throw new Error(`Native installation does not follow symbolic links: ${path}`);
+		const name = join(prefix, item.name);
+		if (item.isDirectory()) for (const [key, value] of filesUnder(path, name)) files.set(key, value);
+		else if (item.isFile()) files.set(name, readFileSync(path));
+	}
+	return files;
+}
+function rejectSymlink(path) {
+	if (existsSync(path) && lstatSync(path).isSymbolicLink()) throw new Error(`Native installation does not replace symbolic links: ${path}`);
+}
+function prepareNativeBundle(source, target, label, required, force, skillsSource, extraFiles = {}) {
+	if (!required.every((name) => existsSync(join(source, name)))) throw new Error(`Bundled ${label} files are missing; reinstall AgentMemory before connecting.`);
+	rejectSymlink(target);
+	const files = filesUnder(source);
+	if (skillsSource) {
+		if (!["remember/SKILL.md", "recall/SKILL.md"].every((name) => existsSync(join(skillsSource, name)))) throw new Error("Bundled skills are missing; reinstall AgentMemory before connecting.");
+		for (const [name, content] of filesUnder(skillsSource)) files.set(join("skills", name), content);
+	}
+	for (const [name, content] of Object.entries(extraFiles)) files.set(name, Buffer.from(content));
+	let previous = {};
+	if (existsSync(join(target, MANIFEST))) {
+		let stored;
+		try {
+			stored = JSON.parse(readFileSync(join(target, MANIFEST), "utf8"));
+		} catch {
+			stored = null;
+		}
+		if (!record(stored) || !record(stored.files) || !Object.values(stored.files).every((hash) => typeof hash === "string")) throw new Error(`Invalid native install manifest in ${target}; restore its backup before reconnecting.`);
+		previous = stored.files;
+		for (const name of Object.keys(previous)) {
+			const location = relative(target, resolve(target, name));
+			if (!location || location === ".." || location.startsWith(`..${sep}`) || resolve(target, name) === resolve(target, MANIFEST)) throw new Error(`Invalid native install path in ${target}.`);
+		}
+	}
+	const installed = existsSync(target) ? filesUnder(target) : /* @__PURE__ */ new Map();
+	if (!force) for (const [name, content] of installed) {
+		if (!files.has(name) && !(name in previous)) continue;
+		if (previous[name] ? digest(content) !== previous[name] : !files.get(name)?.equals(content)) throw new Error(`Customized ${label} file ${name} was preserved; use --force to replace it with a backup.`);
+	}
+	const changed = !existsSync(join(target, MANIFEST)) || [...files].some(([name, content]) => !installed.get(name)?.equals(content)) || Object.keys(previous).some((name) => !files.has(name) && installed.has(name));
+	return {
+		target,
+		label,
+		files,
+		previous,
+		changed
+	};
+}
+function installNativeBundles(bundles, configPath, configText) {
+	rejectSymlink(configPath);
+	const transaction = randomUUID();
+	const configStage = `${configPath}.stage-${transaction}`;
+	const staged = [];
+	let backupPath;
+	try {
+		for (const bundle of bundles.filter((item) => item.changed)) {
+			mkdirSync(dirname(bundle.target), { recursive: true });
+			const stage = `${bundle.target}.stage-${transaction}`;
+			const item = {
+				bundle,
+				stage,
+				rollback: `${bundle.target}.previous-${transaction}`,
+				replaced: false,
+				installed: false
+			};
+			staged.push(item);
+			if (existsSync(bundle.target)) cpSync(bundle.target, stage, { recursive: true });
+			else mkdirSync(stage);
+			for (const name of Object.keys(bundle.previous)) if (!bundle.files.has(name)) rmSync(join(stage, name), { force: true });
+			for (const [name, content] of bundle.files) {
+				mkdirSync(dirname(join(stage, name)), { recursive: true });
+				writeFileSync(join(stage, name), content);
+			}
+			writeFileSync(join(stage, MANIFEST), JSON.stringify({ files: Object.fromEntries([...bundle.files].map(([name, content]) => [name, digest(content)])) }) + "\n");
+			if (existsSync(bundle.target)) {
+				const backup = join(ensureBackupsDir(), `${bundle.label}-${transaction}`);
+				cpSync(bundle.target, backup, { recursive: true });
+				backupPath ??= backup;
+			}
+		}
+		const configChanged = !existsSync(configPath) || readFileSync(configPath, "utf8") !== configText;
+		if (configChanged && existsSync(configPath)) backupPath = backupFile(configPath, `native-config-${transaction}`, "config");
+		if (configChanged) {
+			mkdirSync(dirname(configPath), { recursive: true });
+			writeFileSync(configStage, configText, { mode: existsSync(configPath) ? lstatSync(configPath).mode & 511 : 384 });
+		}
+		for (const item of staged) {
+			if (existsSync(item.bundle.target)) {
+				renameSync(item.bundle.target, item.rollback);
+				item.replaced = true;
+			}
+			renameSync(item.stage, item.bundle.target);
+			item.installed = true;
+		}
+		if (configChanged) renameSync(configStage, configPath);
+	} catch (error) {
+		for (const item of [...staged].reverse()) {
+			if (item.installed) rmSync(item.bundle.target, {
+				recursive: true,
+				force: true
+			});
+			if (item.replaced) renameSync(item.rollback, item.bundle.target);
+		}
+		throw error;
+	} finally {
+		for (const item of staged) rmSync(item.stage, {
+			recursive: true,
+			force: true
+		});
+		rmSync(configStage, { force: true });
+	}
+	for (const item of staged) rmSync(item.rollback, {
+		recursive: true,
+		force: true
+	});
+	return backupPath;
+}
+//#endregion
 //#region src/cli/connect/hermes.ts
-const HERMES_DIR = join(homedir(), ".hermes");
-const HERMES_CONFIG = join(HERMES_DIR, "config.yaml");
-const DOCS$2 = "https://github.com/rohitg00/agentmemory/tree/main/integrations/hermes";
-const adapter$8 = {
+const hermesHome = () => {
+	return nativeUserPath((process.env.HERMES_HOME?.trim() || join(homedir(), `.hermes${process.env.HERMES_DATA_DIR_SUFFIX ?? ""}`)).replace(/\$(?:\{([^}]+)\}|([A-Za-z_][A-Za-z_0-9]*))/g, (match, braced, plain) => process.env[braced ?? plain] ?? match), homedir());
+};
+const DOCS$1 = "https://github.com/rohitg00/agentmemory/tree/main/integrations/hermes";
+const stringList$1 = (value) => value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
+const adapter$9 = {
 	name: "hermes",
 	displayName: "Hermes Agent",
 	category: "native",
-	docs: DOCS$2,
-	protocolNote: "→ Using MCP. Hooks are also available — see https://github.com/rohitg00/agentmemory/tree/main/integrations/hermes.",
-	detect() {
-		return existsSync(HERMES_DIR);
-	},
-	async install(_opts) {
-		p.log.warn("Hermes uses YAML config. Automated merge isn't implemented yet — manual install required.");
-		p.note([
-			`Add to ${HERMES_CONFIG}:`,
-			"",
-			"  mcp_servers:",
-			"    agentmemory:",
-			"      command: npx",
-			"      args: [\"-y\", \"@agentmemory/mcp\"]",
-			"",
-			"  memory:",
-			"    provider: agentmemory",
-			"",
-			`Full guide: ${DOCS$2}`
-		].join("\n"), "Hermes manual install");
-		return {
-			kind: "stub",
-			reason: "yaml-merge-not-implemented"
-		};
+	docs: DOCS$1,
+	protocolNote: "→ Installs the native memory provider and bundled skills into the active Hermes profile. Credentials stay managed by Hermes.",
+	detect: () => existsSync(hermesHome()),
+	async install(opts) {
+		const home = hermesHome();
+		const path = join(home, "config.yaml");
+		const raw = existsSync(path) ? readFileSync(path, "utf8") : "";
+		const doc = parseDocument(raw);
+		let existing;
+		try {
+			existing = doc.contents === null ? {} : doc.toJS({ maxAliasCount: 100 });
+		} catch {
+			existing = null;
+		}
+		if (doc.errors.length || !record(existing) || existing.memory !== void 0 && !record(existing.memory) || existing.plugins !== void 0 && !record(existing.plugins) || existing.mcp_servers !== void 0 && !record(existing.mcp_servers)) {
+			p.log.warn(`Hermes config is not a valid YAML mapping. Left ${path} unchanged.`);
+			return {
+				kind: "skipped",
+				reason: "invalid-config"
+			};
+		}
+		const memory = existing.memory ?? {};
+		const plugins = existing.plugins ?? {};
+		const servers = existing.mcp_servers ?? {};
+		if (!stringList$1(plugins.enabled) || !stringList$1(plugins.disabled) || memory.provider !== void 0 && typeof memory.provider !== "string") {
+			p.log.warn(`Hermes provider or plugin settings are invalid. Left ${path} unchanged.`);
+			return {
+				kind: "skipped",
+				reason: "invalid-config"
+			};
+		}
+		if (servers.agentmemory !== void 0 && !record(servers.agentmemory) && !(opts.force && opts.withMcp)) {
+			p.log.warn("Hermes's AgentMemory MCP entry is invalid. Repair it or use --force --with-mcp.");
+			return {
+				kind: "skipped",
+				reason: "invalid-entry"
+			};
+		}
+		if (memory.provider && memory.provider !== "agentmemory" && !opts.force) {
+			p.log.warn("Hermes already selects another memory provider. Use --force to select AgentMemory and keep a backup.");
+			return {
+				kind: "skipped",
+				reason: "memory-provider-conflict"
+			};
+		}
+		if (plugins.disabled?.includes("agentmemory") && !opts.force) {
+			p.log.warn("AgentMemory is disabled in this Hermes profile. Use --force to enable it.");
+			return {
+				kind: "skipped",
+				reason: "plugin-disabled"
+			};
+		}
+		try {
+			const root = nativePackageRoot();
+			const bundles = [prepareNativeBundle(join(root, "integrations", "hermes"), join(home, "plugins", "agentmemory"), "hermes-provider", ["__init__.py", "plugin.yaml"], opts.force), prepareNativeBundle(join(root, "plugin", "skills"), join(home, "skills", "agentmemory"), "hermes-skills", ["remember/SKILL.md", "recall/SKILL.md"], opts.force)];
+			if (memory.provider !== "agentmemory") doc.setIn(["memory", "provider"], "agentmemory");
+			const enabled = plugins.enabled ?? [];
+			if (!enabled.includes("agentmemory")) doc.setIn(["plugins", "enabled"], [...enabled, "agentmemory"]);
+			if (plugins.disabled?.includes("agentmemory")) doc.setIn(["plugins", "disabled"], plugins.disabled.filter((name) => name !== "agentmemory"));
+			if (opts.withMcp) {
+				p.log.warn("MCP exposes all AgentMemory tools against the configured backend. It does not enforce the native provider's profile scope; enable it only for a trusted, deliberately shared backend.");
+				if (servers.agentmemory === void 0 || opts.force) {
+					const entry = nativeMcpEntry(root);
+					entry.env = {
+						...entry.env,
+						AGENTMEMORY_URL: "${AGENTMEMORY_URL}",
+						AGENTMEMORY_SECRET: "${AGENTMEMORY_SECRET}",
+						AGENTMEMORY_CREDENTIAL_MODE: "explicit"
+					};
+					doc.setIn(["mcp_servers", "agentmemory"], entry);
+				} else p.log.info("Preserved the existing AgentMemory MCP entry. After moving the installed package, review its settings and reconnect with --with-mcp --force to refresh its runtime path.");
+			}
+			const configText = doc.toString();
+			if (opts.dryRun) {
+				p.log.info(`[dry-run] Would install the native provider and skills, then activate AgentMemory in ${path}`);
+				return {
+					kind: "installed",
+					mutatedPath: path
+				};
+			}
+			let backupPath;
+			const unchanged = !bundles.some((bundle) => bundle.changed) && configText === raw;
+			if (unchanged) logAlreadyWired(this.displayName, path);
+			else {
+				backupPath = installNativeBundles(bundles, path, configText);
+				if (backupPath) logBackup(backupPath);
+				logInstalled(this.displayName, path);
+			}
+			p.log.info("Authentication is not verified. Start AgentMemory, then run `hermes memory setup` in this same HERMES_HOME to set its URL and scoped secret. Verify a save and recall in a new session. Skills needing tools beyond native save, recall and search require the optional --with-mcp connection.");
+			return unchanged ? {
+				kind: "already-wired",
+				mutatedPath: path
+			} : {
+				kind: "installed",
+				mutatedPath: path,
+				...backupPath ? { backupPath } : {}
+			};
+		} catch (error) {
+			p.log.warn(error instanceof Error ? error.message : "Hermes installation failed; configuration was not activated.");
+			return {
+				kind: "skipped",
+				reason: "native-install-failed"
+			};
+		}
 	}
 };
 //#endregion
 //#region src/cli/connect/kiro.ts
-const adapter$7 = createJsonMcpAdapter({
+const adapter$8 = createJsonMcpAdapter({
 	name: "kiro",
 	displayName: "Kiro",
 	detectDir: join(homedir(), ".kiro"),
@@ -1218,15 +1515,182 @@ const adapter$7 = createJsonMcpAdapter({
 });
 //#endregion
 //#region src/cli/connect/openclaw.ts
-const adapter$6 = createJsonMcpAdapter({
+const paths = () => {
+	const home = nativeUserPath(process.env.OPENCLAW_HOME?.trim() || homedir(), homedir());
+	const preferred = join(home, ".openclaw");
+	const legacy = join(home, ".clawdbot");
+	const state = process.env.OPENCLAW_STATE_DIR?.trim() ? nativeUserPath(process.env.OPENCLAW_STATE_DIR.trim(), home) : !existsSync(preferred) && existsSync(legacy) ? legacy : preferred;
+	return {
+		state,
+		config: process.env.OPENCLAW_CONFIG_PATH?.trim() ? nativeUserPath(process.env.OPENCLAW_CONFIG_PATH.trim(), home) : !existsSync(join(state, "openclaw.json")) && existsSync(join(state, "clawdbot.json")) ? join(state, "clawdbot.json") : join(state, "openclaw.json")
+	};
+};
+const stringList = (value) => value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
+const adapter$7 = {
 	name: "openclaw",
 	displayName: "OpenClaw",
 	category: "native",
-	detectDir: join(homedir(), ".openclaw"),
-	configPath: join(homedir(), ".openclaw", "openclaw.json"),
 	docs: "https://github.com/rohitg00/agentmemory/tree/main/integrations/openclaw",
-	protocolNote: "→ Using MCP. Hooks are also available — see https://github.com/rohitg00/agentmemory/tree/main/integrations/openclaw."
-});
+	protocolNote: "→ Installs native recall/capture and bundled skills into the active OpenClaw state directory. MCP tools are opt-in with --with-mcp.",
+	detect: () => existsSync(paths().config) || existsSync(paths().state),
+	async install(opts) {
+		const { state, config: configPath } = paths();
+		const raw = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+		let existing;
+		try {
+			existing = raw ? JSON5.parse(raw) : {};
+		} catch {
+			existing = null;
+		}
+		if (!record(existing) || [
+			"mcp",
+			"plugins",
+			"skills"
+		].some((key) => existing[key] !== void 0 && !record(existing[key]))) {
+			p.log.warn(`OpenClaw config is not a valid JSON/JSON5 object. Left ${configPath} unchanged.`);
+			return {
+				kind: "skipped",
+				reason: "invalid-config"
+			};
+		}
+		const next = { ...existing };
+		const mcp = { ...next.mcp ?? {} };
+		if (mcp.servers !== void 0 && !record(mcp.servers)) return {
+			kind: "skipped",
+			reason: "invalid-config"
+		};
+		const servers = { ...mcp.servers ?? {} };
+		const legacyServers = record(next.mcpServers) ? { ...next.mcpServers } : {};
+		const legacy = legacyServers.agentmemory;
+		const migrateLegacy = record(legacy) && legacy.command === "npx" && Array.isArray(legacy.args) && legacy.args.includes("@agentmemory/mcp");
+		if (next.mcpServers !== void 0 && (!migrateLegacy || Object.keys(legacyServers).some((key) => key !== "agentmemory"))) {
+			p.log.warn("OpenClaw rejects the legacy mcpServers key. Left the file unchanged; migrate custom servers with OpenClaw's native configuration tools first.");
+			return {
+				kind: "skipped",
+				reason: "legacy-config-needs-migration"
+			};
+		}
+		if (servers.agentmemory !== void 0 && !record(servers.agentmemory) && !(opts.force && opts.withMcp)) {
+			p.log.warn("OpenClaw's AgentMemory MCP entry is invalid. Repair it or use --force --with-mcp.");
+			return {
+				kind: "skipped",
+				reason: "invalid-entry"
+			};
+		}
+		const plugins = { ...next.plugins ?? {} };
+		const skills = { ...next.skills ?? {} };
+		if (["entries", "slots"].some((key) => plugins[key] !== void 0 && !record(plugins[key])) || skills.load !== void 0 && !record(skills.load) || !stringList(plugins.allow) || !stringList(plugins.deny)) return {
+			kind: "skipped",
+			reason: "invalid-config"
+		};
+		const entries = { ...plugins.entries ?? {} };
+		const slots = { ...plugins.slots ?? {} };
+		if (!stringList({ ...skills.load ?? {} }.extraDirs) || entries.agentmemory !== void 0 && !record(entries.agentmemory) || slots.memory !== void 0 && typeof slots.memory !== "string") return {
+			kind: "skipped",
+			reason: "invalid-config"
+		};
+		if (slots.memory !== void 0 && slots.memory !== "agentmemory" && !opts.force) {
+			p.log.warn("OpenClaw already selects another memory plugin. Use --force to select AgentMemory and keep a backup.");
+			return {
+				kind: "skipped",
+				reason: "memory-provider-conflict"
+			};
+		}
+		const entry = { ...entries.agentmemory ?? {} };
+		if (entry.hooks !== void 0 && !record(entry.hooks)) return {
+			kind: "skipped",
+			reason: "invalid-config"
+		};
+		const hooks = { ...entry.hooks ?? {} };
+		if (plugins.enabled === false || !opts.force && (entry.enabled === false || hooks.allowConversationAccess === false || plugins.deny?.includes("agentmemory"))) {
+			p.log.warn("OpenClaw plugin execution or AgentMemory conversation access is disabled. Enable it explicitly before connecting, or use --force for AgentMemory's own settings.");
+			return {
+				kind: "skipped",
+				reason: "plugin-disabled"
+			};
+		}
+		try {
+			const root = nativePackageRoot();
+			const bundles = [prepareNativeBundle(join(root, "integrations", "openclaw"), join(state, "extensions", "agentmemory"), "openclaw-plugin", [
+				"plugin.mjs",
+				"openclaw.plugin.json",
+				"package.json"
+			], opts.force, join(root, "plugin", "skills"))];
+			if (opts.withMcp || migrateLegacy) {
+				p.log.warn("MCP exposes all AgentMemory tools against the configured backend. It does not enforce native profile scope; use it only for a trusted, deliberately shared backend.");
+				if (servers.agentmemory === void 0 || opts.force) {
+					const migrated = migrateLegacy && !opts.force ? { ...legacy } : {};
+					const runtime = nativeMcpEntry(root);
+					const env = {
+						...runtime.env,
+						...record(migrated.env) ? migrated.env : {}
+					};
+					for (const [key, value] of Object.entries(env)) {
+						if (key === "AGENTMEMORY_URL" && value === "${AGENTMEMORY_URL:-http://localhost:3111}" || key === "AGENTMEMORY_SECRET" && value === "${AGENTMEMORY_SECRET:-}") delete env[key];
+						if (key === "AGENTMEMORY_TOOLS" && value === "${AGENTMEMORY_TOOLS:-all}") env[key] = "all";
+					}
+					servers.agentmemory = {
+						...migrated,
+						...runtime,
+						transport: "stdio",
+						env
+					};
+				} else p.log.info("Preserved the existing AgentMemory MCP entry. After moving the installed package, review its settings and reconnect with --with-mcp --force to refresh its runtime path.");
+				if (migrateLegacy) delete next.mcpServers;
+				next.mcp = {
+					...mcp,
+					servers
+				};
+			}
+			entries.agentmemory = {
+				...entry,
+				enabled: true,
+				hooks: {
+					...hooks,
+					allowConversationAccess: true
+				}
+			};
+			plugins.entries = entries;
+			plugins.slots = {
+				...slots,
+				memory: "agentmemory"
+			};
+			if (plugins.allow !== void 0) plugins.allow = [...new Set([...plugins.allow, "agentmemory"])];
+			if (plugins.deny?.includes("agentmemory")) plugins.deny = plugins.deny.filter((name) => name !== "agentmemory");
+			next.plugins = plugins;
+			const configText = JSON.stringify(next) === JSON.stringify(existing) ? raw : JSON.stringify(next, null, 2) + "\n";
+			if (opts.dryRun) {
+				p.log.info(`[dry-run] Would install native plugin and skills, then activate AgentMemory in ${configPath}`);
+				return {
+					kind: "installed",
+					mutatedPath: configPath
+				};
+			}
+			if (!bundles.some((bundle) => bundle.changed) && configText === raw) {
+				logAlreadyWired(this.displayName, configPath);
+				return {
+					kind: "already-wired",
+					mutatedPath: configPath
+				};
+			}
+			const backupPath = installNativeBundles(bundles, configPath, configText);
+			if (backupPath) logBackup(backupPath);
+			logInstalled(this.displayName, configPath);
+			p.log.info("Start AgentMemory and verify capture and recall in a new OpenClaw session. Skills that call memory tools require --with-mcp; authentication and connectivity are not yet verified.");
+			return {
+				kind: "installed",
+				mutatedPath: configPath,
+				...backupPath ? { backupPath } : {}
+			};
+		} catch (error) {
+			p.log.warn(error instanceof Error ? error.message : "OpenClaw installation failed; configuration was not activated.");
+			return {
+				kind: "skipped",
+				reason: "native-install-failed"
+			};
+		}
+	}
+};
 //#endregion
 //#region src/cli/connect/opencode.ts
 const CONFIG_PATH = join(homedir(), ".config", "opencode", "opencode.json");
@@ -1245,7 +1709,7 @@ function entryMatches(entry) {
 	const command = entry["command"];
 	return Array.isArray(command) && command.includes("@agentmemory/mcp");
 }
-const adapter$5 = {
+const adapter$6 = {
 	name: "opencode",
 	displayName: "OpenCode",
 	category: "mcp",
@@ -1301,12 +1765,12 @@ const adapter$5 = {
 //#endregion
 //#region src/cli/connect/openhuman.ts
 const OPENHUMAN_DIR = join(homedir(), ".openhuman");
-const DOCS$1 = "https://github.com/tinyhumansai/openhuman";
-const adapter$4 = {
+const DOCS = "https://github.com/tinyhumansai/openhuman";
+const adapter$5 = {
 	name: "openhuman",
 	displayName: "OpenHuman",
 	category: "native",
-	docs: DOCS$1,
+	docs: DOCS,
 	protocolNote: "→ Using native hooks (REST API at :3111). MCP not required.",
 	detect() {
 		return existsSync(OPENHUMAN_DIR);
@@ -1319,7 +1783,7 @@ const adapter$4 = {
 			"impl. Once integrations/openhuman/ lands in agentmemory we'll wire",
 			"this up automatically.",
 			"",
-			`Tracking: ${DOCS$1}`
+			`Tracking: ${DOCS}`
 		].join("\n"), "OpenHuman manual install");
 		return {
 			kind: "stub",
@@ -1328,80 +1792,225 @@ const adapter$4 = {
 	}
 };
 //#endregion
-//#region src/cli/connect/pi.ts
-const PI_DIR = join(homedir(), ".pi");
-const PI_EXT_DIR = join(PI_DIR, "agent", "extensions", "agentmemory");
-const DOCS = "https://github.com/rohitg00/agentmemory/tree/main/integrations/pi";
-const EXT_FILES = ["index.ts", "security.ts"];
-function findPiSourceDir() {
-	let packageRoot;
-	try {
-		packageRoot = dirname(findPluginRoot());
-	} catch {
-		return null;
-	}
-	const dir = join(packageRoot, "integrations", "pi");
-	return EXT_FILES.every((f) => existsSync(join(dir, f))) ? dir : null;
+//#region src/cli/connect/omp.ts
+function ompPaths() {
+	const root = join(homedir(), process.env.PI_CONFIG_DIR || ".omp");
+	const profile = (process.env.OMP_PROFILE ?? process.env.PI_PROFILE ?? "").trim();
+	if (profile && profile !== "default" && (!/^[a-z0-9][a-z0-9._-]{0,63}$/.test(profile) || profile.endsWith(".") || /^(?:con|prn|aux|nul|com[0-9]|lpt[0-9])(?:\..*)?$/i.test(profile))) throw new Error("Invalid OMP profile; use the same valid OMP_PROFILE as Oh My Pi.");
+	const configRoot = profile && profile !== "default" ? join(root, "profiles", profile) : root;
+	return {
+		root: configRoot,
+		agent: configRoot !== root ? join(configRoot, "agent") : process.env.PI_CODING_AGENT_DIR ? resolve(process.env.PI_CODING_AGENT_DIR) : join(root, "agent"),
+		profile: profile && profile !== "default" ? profile : void 0
+	};
 }
-const adapter$3 = {
-	name: "pi",
-	displayName: "pi",
+const adapter$4 = {
+	name: "omp",
+	displayName: "Oh My Pi",
 	category: "native",
-	docs: DOCS,
-	protocolNote: "→ Using native lifecycle hooks against the REST API at :3111 (recall on agent start, capture on agent end, memory tools). MCP not required.",
-	detect() {
-		return existsSync(PI_DIR);
+	docs: "https://github.com/rohitg00/agentmemory/tree/main/integrations/omp",
+	protocolNote: "Installs native recall, capture and skills. Add --with-mcp for the full memory toolset.",
+	detect: () => {
+		try {
+			const paths = ompPaths();
+			return existsSync(paths.agent) || existsSync(paths.root);
+		} catch {
+			return false;
+		}
 	},
 	async install(opts) {
-		const sourceDir = findPiSourceDir();
-		if (!sourceDir) {
-			p.log.error("Bundled pi extension not found (integrations/pi missing from the install) — reinstall agentmemory.");
-			return {
-				kind: "skipped",
-				reason: "bundled-extension-missing"
+		try {
+			const paths = ompPaths();
+			const target = join(paths.agent, "agentmemory");
+			const config = join(paths.agent, existsSync(join(paths.agent, "config.yml")) || !existsSync(join(paths.agent, "config.yaml")) ? "config.yml" : "config.yaml");
+			const raw = existsSync(config) ? readFileSync(config, "utf8") : "";
+			const legacy = join(paths.agent, "settings.json");
+			const doc = !existsSync(config) && existsSync(legacy) ? new Document(JSON.parse(readFileSync(legacy, "utf8"))) : parseDocument(raw);
+			const existing = doc.contents === null ? {} : doc.toJS({ maxAliasCount: 100 });
+			if (doc.errors.length || !record(existing) || existing.extensions !== void 0 && (!Array.isArray(existing.extensions) || !existing.extensions.every((item) => typeof item === "string"))) throw new Error(`Invalid OMP configuration; left ${config} unchanged.`);
+			const extensions = existing.extensions ?? [];
+			const oldRoots = [
+				...extensions.map((value) => nativeUserPath(value, homedir())).filter((value) => value !== target),
+				join(paths.root, "plugins/node_modules/agentmemory-omp-extension"),
+				join(paths.agent, "plugins/node_modules/agentmemory-omp-extension"),
+				join(process.cwd(), ".omp/plugins/node_modules/agentmemory-omp-extension"),
+				join(paths.agent, "extensions/agentmemory")
+			];
+			if (process.platform === "linux") {
+				const dataRoot = join(process.env.XDG_DATA_HOME || join(homedir(), ".local/share"), "omp");
+				oldRoots.push(join(dataRoot, ...paths.profile ? ["profiles", paths.profile] : [], "plugins/node_modules/agentmemory-omp-extension"));
+			}
+			for (const old of oldRoots) {
+				const manifest = join(old, "package.json");
+				if (existsSync(manifest) && JSON.parse(readFileSync(manifest, "utf8")).name === "agentmemory-omp-extension") throw new Error(`Another OMP AgentMemory extension exists at ${old}. Uninstall it with 'omp plugin uninstall agentmemory-omp-extension' or remove its extensions entry before reconnecting, to prevent duplicate capture.`);
+			}
+			const root = nativePackageRoot();
+			const mcpPath = join(target, ".mcp.json");
+			const extra = {};
+			if (existsSync(mcpPath)) extra[".mcp.json"] = readFileSync(mcpPath, "utf8");
+			let userOwnsMcp = false;
+			if (opts.withMcp || existsSync(mcpPath)) {
+				const nativeMcpPath = join(paths.agent, "mcp.json");
+				userOwnsMcp = (existsSync(nativeMcpPath) ? JSON.parse(readFileSync(nativeMcpPath, "utf8")) : {}).mcpServers?.agentmemory !== void 0;
+				if (userOwnsMcp) {
+					delete extra[".mcp.json"];
+					p.log.info("Preserved the existing AgentMemory MCP server in OMP's mcp.json.");
+				} else if (opts.withMcp) extra[".mcp.json"] = JSON.stringify({ mcpServers: { agentmemory: nativeMcpEntry(root) } }, null, 2) + "\n";
+			}
+			const bundle = prepareNativeBundle(join(root, "integrations/omp"), target, "omp-extension", ["package.json", "dist/index.mjs"], opts.force, join(root, "plugin/skills"), extra);
+			if (userOwnsMcp && existsSync(mcpPath) && !bundle.previous[".mcp.json"] && JSON.parse(readFileSync(mcpPath, "utf8")).mcpServers?.agentmemory !== void 0) throw new Error(`Unmanaged ${mcpPath} conflicts with OMP's mcp.json. Remove the duplicate AgentMemory configuration before reconnecting.`);
+			if (!extensions.includes(target)) doc.set("extensions", [...extensions, target]);
+			const text = doc.toString();
+			if (opts.dryRun) {
+				p.log.info(`[dry-run] Would install OMP's extension and skills into ${target}, then register it in ${config}.`);
+				return {
+					kind: "installed",
+					mutatedPath: config
+				};
+			}
+			const unchanged = !bundle.changed && text === raw;
+			const backupPath = unchanged ? void 0 : installNativeBundles([bundle], config, text);
+			if (backupPath) logBackup(backupPath);
+			if (unchanged) logAlreadyWired(this.displayName, config);
+			else logInstalled(this.displayName, config);
+			p.log.info("Restart OMP and run /agentmemory-status. Native save/search work without MCP; the other bundled skills require --with-mcp. Project extensions arrays override this user setting: include the installed directory there when overriding extensions.");
+			return unchanged ? {
+				kind: "already-wired",
+				mutatedPath: config
+			} : {
+				kind: "installed",
+				mutatedPath: config,
+				...backupPath ? { backupPath } : {}
 			};
-		}
-		const sources = EXT_FILES.map((f) => ({
-			name: f,
-			content: readFileSync(join(sourceDir, f), "utf-8"),
-			target: join(PI_EXT_DIR, f)
-		}));
-		if (sources.every((s) => existsSync(s.target) && readFileSync(s.target, "utf-8") === s.content) && !opts.force) {
-			logAlreadyWired(this.displayName, PI_EXT_DIR);
+		} catch (error) {
+			p.log.warn(error instanceof Error ? error.message : "OMP installation failed.");
 			return {
-				kind: "already-wired",
-				mutatedPath: PI_EXT_DIR
+				kind: "skipped",
+				reason: "native-install-failed"
 			};
 		}
-		if (opts.dryRun) {
-			p.log.info(`[dry-run] Would install the pi extension (${EXT_FILES.join(", ")}) into ${PI_EXT_DIR}`);
+	}
+};
+//#endregion
+//#region src/cli/connect/pi.ts
+const agentDir = () => process.env.PI_CODING_AGENT_DIR ? nativeUserPath(process.env.PI_CODING_AGENT_DIR, homedir()) : join(homedir(), ".pi/agent");
+const entryHash = (entry) => createHash("sha256").update(JSON.stringify(entry)).digest("hex");
+function readConfig(path) {
+	if (!existsSync(path)) return {};
+	if (lstatSync(path).isSymbolicLink()) throw new Error(`Pi configuration is a symbolic link; left ${path} unchanged.`);
+	const value = JSON.parse(readFileSync(path, "utf8"));
+	if (!record(value)) throw new Error(`Invalid Pi configuration; left ${path} unchanged.`);
+	return value;
+}
+function hasPackage(config, configDir, target) {
+	if (config.packages === void 0) return false;
+	if (!Array.isArray(config.packages)) throw new Error("Pi settings.packages must be an array.");
+	return config.packages.some((item) => {
+		const source = typeof item === "string" ? item : record(item) ? item.source : void 0;
+		if (typeof source !== "string") throw new Error("Invalid Pi package entry; configuration was preserved.");
+		if (/^npm:@agentmemory\/pi(?:@|$)/.test(source)) return true;
+		const path = source.startsWith("~") ? nativeUserPath(source, homedir()) : resolve(configDir, source);
+		if (path === target) return false;
+		const manifest = join(path, "package.json");
+		return existsSync(manifest) && JSON.parse(readFileSync(manifest, "utf8")).name === "@agentmemory/pi";
+	});
+}
+const adapter$3 = {
+	name: "pi",
+	displayName: "Pi",
+	category: "native",
+	docs: "https://github.com/rohitg00/agentmemory/tree/main/integrations/pi",
+	protocolNote: "Installs native recall, capture and skills. Add --with-mcp for the full memory toolset.",
+	detect: () => existsSync(agentDir()) || existsSync(join(homedir(), ".pi")),
+	async install(opts) {
+		try {
+			const dir = agentDir();
+			const target = join(dir, "agentmemory");
+			const configPath = join(dir, "settings.json");
+			const config = readConfig(configPath);
+			const projectPath = join(process.cwd(), ".pi/settings.json");
+			const packaged = hasPackage(config, dir, target);
+			const projectConfig = readConfig(projectPath);
+			if (!packaged && hasPackage(projectConfig, dirname(projectPath), target)) throw new Error("AgentMemory is configured as a project Pi package. Remove that package entry before installing globally, or keep using the project installation.");
+			for (const [settings, base] of [[config, dir], [projectConfig, dirname(projectPath)]]) {
+				if (!Array.isArray(settings.extensions)) continue;
+				for (const entry of settings.extensions) {
+					if (typeof entry !== "string") continue;
+					const path = entry.startsWith("~") ? nativeUserPath(entry, homedir()) : resolve(base, entry);
+					const manifest = join(/\.[cm]?[jt]s$/.test(path) ? dirname(path) : path, "package.json");
+					if (existsSync(manifest) && JSON.parse(readFileSync(manifest, "utf8")).name === "@agentmemory/pi") throw new Error("Remove the explicit AgentMemory extensions entry before connecting; the package already declares its extension.");
+				}
+			}
+			const legacy = join(dir, "extensions/agentmemory");
+			if (existsSync(legacy)) throw new Error(`Move the old copied extension at ${legacy} outside Pi's extensions directory before reconnecting, to prevent duplicate capture. Keep it as a backup.`);
+			const root = nativePackageRoot();
+			const bundle = packaged ? void 0 : prepareNativeBundle(join(root, "integrations/pi"), target, "pi-extension", ["package.json", "dist/index.mjs"], opts.force, join(root, "plugin/skills"));
+			if (packaged) p.log.info("Using the existing AgentMemory Pi package; no second extension was installed.");
+			else {
+				const packages = config.packages ?? [];
+				if (!packages.some((item) => (typeof item === "string" ? item : record(item) ? item.source : void 0) === target)) config.packages = [...packages, target];
+			}
+			const text = JSON.stringify(config, null, 2) + "\n";
+			const raw = existsSync(configPath) ? readFileSync(configPath, "utf8") : void 0;
+			const mcpPath = join(dir, "mcp.json");
+			const mcpRaw = existsSync(mcpPath) ? readFileSync(mcpPath, "utf8") : void 0;
+			let mcpText = mcpRaw;
+			if (opts.withMcp) {
+				const mcp = readConfig(mcpPath);
+				if (mcp.mcpServers !== void 0 && !record(mcp.mcpServers)) throw new Error("Invalid Pi mcpServers configuration; nothing was changed.");
+				const servers = mcp.mcpServers ?? {};
+				const managed = servers.agentmemory !== void 0 && record(mcp._agentmemoryConnector) && mcp._agentmemoryConnector.entryHash === entryHash(servers.agentmemory);
+				if (servers.agentmemory !== void 0 && !managed) p.log.info("Preserved the existing AgentMemory MCP server. Project MCP settings apply only to trusted projects.");
+				else {
+					const entry = {
+						...nativeMcpEntry(root),
+						exposure: "direct"
+					};
+					mcpText = JSON.stringify({
+						...mcp,
+						mcpServers: {
+							...servers,
+							agentmemory: entry
+						},
+						_agentmemoryConnector: { entryHash: entryHash(entry) }
+					}, null, 2) + "\n";
+				}
+			}
+			if (opts.dryRun) {
+				p.log.info(`[dry-run] Would configure Pi in ${dir}.`);
+				return {
+					kind: "installed",
+					mutatedPath: configPath
+				};
+			}
+			const configChanged = !packaged && (bundle.changed || text !== raw);
+			const mcpChanged = mcpText !== mcpRaw;
+			let backupPath;
+			if (mcpChanged) backupPath = installNativeBundles([], mcpPath, mcpText);
+			try {
+				if (configChanged) backupPath = installNativeBundles([bundle], configPath, text) ?? backupPath;
+			} catch (error) {
+				if (mcpChanged) if (mcpRaw === void 0) rmSync(mcpPath, { force: true });
+				else installNativeBundles([], mcpPath, mcpRaw);
+				throw error;
+			}
+			if (backupPath) logBackup(backupPath);
+			const changed = configChanged || mcpChanged;
+			if (changed) logInstalled(this.displayName, dir);
+			else logAlreadyWired(this.displayName, dir);
+			p.log.info("Restart Pi or /reload, then /agentmemory-status. Skills appear as /skill:<name>; the wider workflows require MCP. Reconnect after upgrading AgentMemory to refresh bundled runtime paths.");
 			return {
-				kind: "installed",
-				mutatedPath: PI_EXT_DIR
+				kind: changed ? "installed" : "already-wired",
+				mutatedPath: configPath,
+				...backupPath ? { backupPath } : {}
 			};
-		}
-		let backupPath;
-		for (const s of sources) if (existsSync(s.target) && readFileSync(s.target, "utf-8") !== s.content) {
-			const backup = backupFile(s.target, `${this.name}-${s.name.replace(/\.ts$/, "")}`, "ts");
-			logBackup(backup);
-			backupPath ??= backup;
-		}
-		mkdirSync(PI_EXT_DIR, { recursive: true });
-		for (const s of sources) writeTextAtomic(s.target, s.content);
-		if (!sources.every((s) => existsSync(s.target) && readFileSync(s.target, "utf-8") === s.content)) {
-			p.log.error(`Verification failed: ${PI_EXT_DIR} does not match the bundled extension.`);
+		} catch (error) {
+			p.log.warn(error instanceof Error ? error.message : "Pi installation failed.");
 			return {
 				kind: "skipped",
-				reason: "verification-failed"
+				reason: "native-install-failed"
 			};
 		}
-		logInstalled(this.displayName, PI_EXT_DIR);
-		p.log.info("pi auto-discovers the extension on next launch; a running pi picks it up with /reload. Verify with /agentmemory-status.");
-		return {
-			kind: "installed",
-			mutatedPath: PI_EXT_DIR,
-			backupPath
-		};
 	}
 };
 //#endregion
@@ -1446,27 +2055,28 @@ var connect_exports = /* @__PURE__ */ __exportAll({
 	runConnect: () => runConnect
 });
 const ADAPTERS = [
-	adapter$18,
+	adapter$19,
+	adapter$17,
 	adapter$16,
-	adapter$15,
+	adapter$14,
 	adapter$13,
-	adapter$12,
-	adapter$9,
+	adapter$10,
 	adapter$2,
-	adapter$19,
 	adapter$20,
-	adapter$7,
+	adapter$21,
+	adapter$8,
 	adapter$1,
-	adapter$17,
-	adapter$14,
+	adapter$18,
+	adapter$15,
 	adapter,
+	adapter$12,
 	adapter$11,
-	adapter$10,
-	adapter$5,
 	adapter$6,
-	adapter$8,
+	adapter$7,
+	adapter$9,
 	adapter$3,
-	adapter$4
+	adapter$4,
+	adapter$5
 ];
 function resolveAdapter(name) {
 	const lower = name.toLowerCase();
@@ -1481,11 +2091,13 @@ function parseFlags(args) {
 	let force = false;
 	let all = false;
 	let withHooks = false;
+	let withMcp = false;
 	let guidelines = true;
 	for (const a of args) if (a === "--dry-run") dryRun = true;
 	else if (a === "--force") force = true;
 	else if (a === "--all") all = true;
 	else if (a === "--with-hooks") withHooks = true;
+	else if (a === "--with-mcp") withMcp = true;
 	else if (a === "--no-guidelines") guidelines = false;
 	else if (!a.startsWith("-")) positional.push(a);
 	return {
@@ -1493,6 +2105,7 @@ function parseFlags(args) {
 		force,
 		all,
 		withHooks,
+		withMcp,
 		guidelines,
 		positional
 	};
@@ -1529,7 +2142,7 @@ async function runAdapter(adapter, opts) {
 	}
 }
 async function runConnect(args) {
-	const { dryRun, force, all, withHooks, guidelines, positional } = parseFlags(args);
+	const { dryRun, force, all, withHooks, withMcp, guidelines, positional } = parseFlags(args);
 	const allowWindowsAdapter = positional.length === 1 && positional[0]?.toLowerCase() === "copilot-cli";
 	if (platform() === "win32" && !allowWindowsAdapter) {
 		p.intro("agentmemory connect");
@@ -1541,6 +2154,7 @@ async function runConnect(args) {
 		dryRun,
 		force,
 		withHooks,
+		withMcp,
 		guidelines
 	};
 	p.intro("agentmemory connect");
@@ -1615,10 +2229,17 @@ function summarize(results) {
 	p.note(lines.join("\n"), "summary");
 	const stubs = results.filter((r) => r.result.kind === "stub");
 	if (stubs.length > 0) p.log.info(`${stubs.length} agent(s) require manual install — see docs links above.`);
-	if (results.some((r) => r.result.kind === "installed" || r.result.kind === "already-wired")) p.log.info("Next: install agentmemory's 17 skills into the same agent(s) so they know when to call the tools:\n  npx skills add rohitg00/agentmemory -y");
+	if (results.some((r) => ![
+		"hermes",
+		"hermes-agent",
+		"openclaw",
+		"claw",
+		"omp",
+		"pi"
+	].includes(r.name) && (r.result.kind === "installed" || r.result.kind === "already-wired"))) p.log.info("Next: install agentmemory's 17 skills into the same agent(s) so they know when to call the tools:\n  npx skills@1.7.1 add rohitg00/agentmemory -y");
 	p.outro("Restart any wired agent (or open a new session) to pick up agentmemory.");
 }
 //#endregion
 export { runAdapter as a, resolveAdapter as i, connect_exports as n, knownAgents as r, ADAPTERS as t };
 
-//# sourceMappingURL=connect-B4_ca6BD.mjs.map
+//# sourceMappingURL=connect-BX3njQ3Y.mjs.map