@agentmemory/agentmemory 0.9.28 → 0.9.29

package/dist/{connect-JnsJXc68.mjs → connect-Qaeq15TQ.mjs}

@@ -17,6 +17,147 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
+//#region src/cli/connect/guidelines.ts
+const START = "<!-- agentmemory:start -->";
+const END = "<!-- agentmemory:end -->";
+const GUIDELINE_BODY = `## Agent memory (agentmemory)
+
+You have persistent long-term memory via the agentmemory MCP server. Tools: \`memory_recall\`, \`memory_smart_search\`, \`memory_save\`, \`memory_sessions\`.
+
+- At the START of a task, call \`memory_recall\` (or \`memory_smart_search\`) with the task context to load relevant past decisions, fixes, and preferences before asking the user to repeat anything.
+- When you learn something durable (a decision, a fix, a gotcha, a user preference, a project convention), call \`memory_save\` to persist it.
+- Prefer recalling over re-deriving, and save concise reusable facts rather than transcripts.`;
+function guidelineTargets(home = homedir()) {
+	return {
+		cursor: {
+			projectPath: join(".cursor", "rules", "agentmemory.mdc"),
+			format: "mdc",
+			scope: "project",
+			source: "https://cursor.com/docs/rules"
+		},
+		cline: {
+			projectPath: join(".clinerules", "agentmemory.md"),
+			format: "rule",
+			scope: "project",
+			source: "https://docs.cline.bot/customization/cline-rules"
+		},
+		continue: {
+			projectPath: join(".continue", "rules", "00-agentmemory.md"),
+			format: "rule",
+			scope: "project",
+			source: "https://docs.continue.dev/customize/deep-dives/rules"
+		},
+		zed: {
+			globalPath: join(home, ".config", "zed", "AGENTS.md"),
+			projectPath: "AGENTS.md",
+			format: "block",
+			scope: "global",
+			source: "https://zed.dev/docs/ai/instructions"
+		},
+		warp: {
+			projectPath: "AGENTS.md",
+			format: "block",
+			scope: "project",
+			source: "https://docs.warp.dev/agent-platform/capabilities/rules"
+		},
+		kiro: {
+			globalPath: join(home, ".kiro", "steering", "agentmemory.md"),
+			projectPath: join(".kiro", "steering", "agentmemory.md"),
+			format: "steering",
+			scope: "global",
+			source: "https://kiro.dev/docs/steering"
+		},
+		"gemini-cli": {
+			globalPath: join(home, ".gemini", "GEMINI.md"),
+			projectPath: "GEMINI.md",
+			format: "block",
+			scope: "global",
+			source: "https://github.com/google-gemini/gemini-cli/blob/main/docs/cli/gemini-md.md"
+		},
+		qwen: {
+			globalPath: join(home, ".qwen", "QWEN.md"),
+			projectPath: "QWEN.md",
+			format: "block",
+			scope: "global",
+			source: "https://github.com/QwenLM/qwen-code/blob/main/docs/users/features/memory.md"
+		},
+		opencode: {
+			globalPath: join(home, ".config", "opencode", "AGENTS.md"),
+			projectPath: "AGENTS.md",
+			format: "block",
+			scope: "global",
+			source: "https://opencode.ai/docs/rules"
+		},
+		droid: {
+			globalPath: join(home, ".factory", "AGENTS.md"),
+			projectPath: "AGENTS.md",
+			format: "block",
+			scope: "global",
+			source: "https://docs.factory.ai/cli/configuration/agents-md"
+		},
+		antigravity: {
+			globalPath: join(home, ".gemini", "GEMINI.md"),
+			projectPath: join(".agents", "rules", "agentmemory.md"),
+			format: "block",
+			scope: "global",
+			source: "https://antigravity.google/docs/rules-workflows"
+		},
+		"antigravity-cli": {
+			globalPath: join(home, ".gemini", "GEMINI.md"),
+			projectPath: join(".agents", "rules", "agentmemory.md"),
+			format: "block",
+			scope: "global",
+			source: "https://antigravity.google/docs/rules-workflows"
+		},
+		"copilot-cli": {
+			globalPath: join(home, ".copilot", "copilot-instructions.md"),
+			projectPath: join(".github", "copilot-instructions.md"),
+			format: "block",
+			scope: "global",
+			source: "https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-custom-instructions"
+		}
+	};
+}
+function renderDedicated(format) {
+	if (format === "mdc") return `---\ndescription: agentmemory long-term memory usage\nalwaysApply: true\n---\n\n${GUIDELINE_BODY}\n`;
+	if (format === "steering") return `---\ninclusion: always\n---\n\n${GUIDELINE_BODY}\n`;
+	return `${GUIDELINE_BODY}\n`;
+}
+function upsertBlock(existing) {
+	const block = `${START}\n${GUIDELINE_BODY}\n${END}`;
+	const startIdx = existing.indexOf(START);
+	const endIdx = existing.indexOf(END);
+	if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) return existing.slice(0, startIdx) + block + existing.slice(endIdx + 24);
+	if (startIdx !== -1 || endIdx !== -1) return existing;
+	return `${existing}${existing.length === 0 || existing.endsWith("\n") ? "" : "\n"}${existing.length === 0 ? "" : "\n"}${block}\n`;
+}
+function writeGuideline(agentName, opts = { cwd: process.cwd() }) {
+	const target = guidelineTargets(opts.home ?? homedir())[agentName];
+	if (!target) return { kind: "no-target" };
+	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);
+	if (existing === next) return {
+		kind: "unchanged",
+		path,
+		scope: target.scope
+	};
+	if (opts.dryRun) return {
+		kind: "would-write",
+		path,
+		scope: target.scope
+	};
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, next, "utf8");
+	return {
+		kind: "written",
+		path,
+		scope: target.scope,
+		source: target.source
+	};
+}
+//#endregion
 //#region src/cli/connect/util.ts
 const AGENTMEMORY_MCP_BLOCK = {
 	command: "npx",
@@ -77,9 +218,12 @@ function readJsonSafe(path) {
 	}
 }
 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, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+	writeFileSync(tmp, content, "utf-8");
 	renameSync(tmp, path);
 }
 function logInstalled(label, target) {
@@ -117,6 +261,10 @@ function createJsonMcpAdapter(config) {
 			const alreadyHas = entryMatches$3(servers["agentmemory"]);
 			if (alreadyHas && !opts.force) {
 				logAlreadyWired(config.displayName, config.configPath);
+				if (opts.withHooks && config.installHooks) {
+					const hookResult = config.installHooks(opts);
+					if (hookResult.kind === "skipped") p.log.warn(`${config.displayName} hooks skipped: ${hookResult.reason}.`);
+				}
 				return {
 					kind: "already-wired",
 					mutatedPath: config.configPath
@@ -124,6 +272,10 @@ function createJsonMcpAdapter(config) {
 			}
 			if (opts.dryRun) {
 				p.log.info(`[dry-run] Would ${alreadyHas ? "overwrite" : "add"} ${wrapperKey}.agentmemory in ${config.configPath}`);
+				if (opts.withHooks && config.installHooks) {
+					const hookResult = config.installHooks(opts);
+					if (hookResult.kind === "skipped") p.log.warn(`${config.displayName} hooks skipped: ${hookResult.reason}.`);
+				}
 				return {
 					kind: "installed",
 					mutatedPath: config.configPath
@@ -149,6 +301,10 @@ function createJsonMcpAdapter(config) {
 				};
 			}
 			logInstalled(config.displayName, config.configPath);
+			if (opts.withHooks && config.installHooks) {
+				const hookResult = config.installHooks(opts);
+				if (hookResult.kind === "skipped") p.log.warn(`${config.displayName} hooks skipped: ${hookResult.reason}. MCP wiring still applied.`);
+			}
 			return {
 				kind: "installed",
 				mutatedPath: config.configPath,
@@ -160,7 +316,7 @@ function createJsonMcpAdapter(config) {
 //#endregion
 //#region src/cli/connect/antigravity.ts
 const ANTIGRAVITY_DIR = platform() === "darwin" ? join(homedir(), "Library", "Application Support", "Antigravity", "User") : join(homedir(), ".config", "Antigravity", "User");
-const adapter$17 = createJsonMcpAdapter({
+const adapter$20 = createJsonMcpAdapter({
 	name: "antigravity",
 	displayName: "Antigravity",
 	detectDir: ANTIGRAVITY_DIR,
@@ -169,6 +325,84 @@ const adapter$17 = createJsonMcpAdapter({
 	protocolNote: "→ Using MCP via mcp_config.json. Antigravity replaces Gemini CLI (sunset 2026-06-18)."
 });
 //#endregion
+//#region src/cli/connect/antigravity-hooks.ts
+/** Tool events: `[ { matcher, hooks: [...] } ]`. */
+const TOOL_EVENT_KEYS = new Set(["PreToolUse", "PostToolUse"]);
+/** Lifecycle events: a flat `[ { type, command } ]` handler list. */
+const LIFECYCLE_EVENT_KEYS = new Set([
+	"PreInvocation",
+	"PostInvocation",
+	"Stop"
+]);
+/** Events Antigravity dispatches. Anything else in a bundle is metadata. */
+const EVENT_KEYS = new Set([...TOOL_EVENT_KEYS, ...LIFECYCLE_EVENT_KEYS]);
+function buildMergedAntigravityHooks(existing, pluginRoot, manifestFile = "hooks.antigravity.json") {
+	const ours = JSON.parse(readFileSync(join(pluginRoot, "hooks", manifestFile), "utf-8"));
+	const scriptsDir = join(pluginRoot, "scripts");
+	const out = {};
+	for (const [name, bundle] of Object.entries(existing ?? {})) {
+		if (isAgentmemoryBundle(bundle, scriptsDir)) continue;
+		out[name] = bundle;
+	}
+	for (const [name, bundle] of Object.entries(ours)) out[name] = resolveBundle(bundle, pluginRoot);
+	return out;
+}
+/** True when `pluginRoot` cannot be expressed in an Antigravity `command`. */
+function containsSpaces(pluginRoot) {
+	return /\s/.test(pluginRoot);
+}
+/**
+* Every handler in a bundle, across both event shapes: an entry that carries
+* no `hooks` array is itself the handler.
+*/
+function allHandlers(bundle) {
+	const out = [];
+	for (const [key, value] of Object.entries(bundle)) {
+		if (!EVENT_KEYS.has(key) || !Array.isArray(value)) continue;
+		for (const entry of value) {
+			if (!entry || typeof entry !== "object") continue;
+			const nested = entry.hooks;
+			if (Array.isArray(nested)) out.push(...nested);
+			else out.push(entry);
+		}
+	}
+	return out;
+}
+function isAgentmemoryBundle(bundle, scriptsDir) {
+	if (!bundle || typeof bundle !== "object" || Array.isArray(bundle)) return false;
+	const normalizedScriptsDir = normalizePathForCommandMatch$1(scriptsDir);
+	return allHandlers(bundle).some((handler) => normalizePathForCommandMatch$1(handler?.command ?? "").includes(normalizedScriptsDir));
+}
+function resolveBundle(bundle, pluginRoot) {
+	const out = {};
+	for (const [key, value] of Object.entries(bundle)) {
+		if (!EVENT_KEYS.has(key) || !Array.isArray(value)) {
+			out[key] = value;
+			continue;
+		}
+		if (LIFECYCLE_EVENT_KEYS.has(key)) {
+			out[key] = value.map((handler) => resolveHandler(handler, pluginRoot));
+			continue;
+		}
+		out[key] = value.map((entry) => {
+			const next = { hooks: entry.hooks.map((handler) => resolveHandler(handler, pluginRoot)) };
+			if (entry.matcher !== void 0) next.matcher = entry.matcher;
+			return next;
+		});
+	}
+	return out;
+}
+function resolveHandler(handler, pluginRoot) {
+	return {
+		type: handler.type,
+		command: handler.command.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, () => pluginRoot),
+		...handler.timeout !== void 0 && { timeout: handler.timeout }
+	};
+}
+function normalizePathForCommandMatch$1(value) {
+	return value.replace(/\\/g, "/");
+}
+//#endregion
 //#region src/cli/connect/codex-hooks.ts
 /**
 * Locate the bundled `plugin/` directory at runtime. Walks up from the
@@ -228,6 +462,62 @@ function normalizePathForCommandMatch(value) {
 	return value.replace(/\\/g, "/");
 }
 //#endregion
+//#region src/cli/connect/antigravity-cli.ts
+const GEMINI_DIR = join(homedir(), ".gemini");
+const ANTIGRAVITY_CLI_DIR = join(GEMINI_DIR, "antigravity-cli");
+const CUSTOMIZATION_DIR = join(GEMINI_DIR, "config");
+const ANTIGRAVITY_CLI_HOOKS = join(CUSTOMIZATION_DIR, "hooks.json");
+const adapter$19 = createJsonMcpAdapter({
+	name: "antigravity-cli",
+	displayName: "Antigravity CLI (agy)",
+	detectDir: ANTIGRAVITY_CLI_DIR,
+	configPath: join(CUSTOMIZATION_DIR, "mcp_config.json"),
+	docs: "https://github.com/rohitg00/agentmemory#other-agents",
+	protocolNote: "→ Using MCP via ~/.gemini/config/mcp_config.json (the agy CLI, not the Antigravity IDE — that one is `connect antigravity`). The `/mcp` slash command inside agy lists configured servers. Pass --with-hooks to also install the native ~/.gemini/config/hooks.json auto-capture hooks.",
+	installHooks: installAntigravityCliHooks
+});
+/**
+* Merge the bundled `plugin/hooks/hooks.antigravity.json` into
+* `~/.gemini/config/hooks.json`, replacing only the bundle agentmemory owns.
+*/
+function installAntigravityCliHooks(opts) {
+	let pluginRoot;
+	try {
+		pluginRoot = findPluginRoot();
+	} catch (err) {
+		return {
+			kind: "skipped",
+			reason: err instanceof Error ? err.message : String(err)
+		};
+	}
+	if (containsSpaces(pluginRoot)) return {
+		kind: "skipped",
+		reason: `Antigravity CLI cannot run hook commands whose path contains spaces, and agentmemory is installed at ${pluginRoot}. Reinstall it under a space-free path to use --with-hooks; MCP works either way.`
+	};
+	const existing = readJsonSafe(ANTIGRAVITY_CLI_HOOKS);
+	const merged = buildMergedAntigravityHooks(existing, pluginRoot);
+	if (opts.dryRun) {
+		p.log.info(`[dry-run] Would ${existing ? "merge" : "create"} ${ANTIGRAVITY_CLI_HOOKS} with ${Object.keys(merged).length} hook bundle(s)`);
+		return {
+			kind: "installed",
+			mutatedPath: ANTIGRAVITY_CLI_HOOKS
+		};
+	}
+	let backupPath;
+	if (existsSync(ANTIGRAVITY_CLI_HOOKS)) {
+		backupPath = backupFile(ANTIGRAVITY_CLI_HOOKS, "antigravity-cli-hooks", "json");
+		logBackup(backupPath);
+	} else mkdirSync(CUSTOMIZATION_DIR, { recursive: true });
+	writeJsonAtomic(ANTIGRAVITY_CLI_HOOKS, merged);
+	logInstalled("Antigravity CLI hooks", ANTIGRAVITY_CLI_HOOKS);
+	p.log.info("User-scope hooks reference absolute paths under the bundled plugin/ dir. Re-run `agentmemory connect antigravity-cli --with-hooks` after upgrading agentmemory to refresh them.");
+	return {
+		kind: "installed",
+		mutatedPath: ANTIGRAVITY_CLI_HOOKS,
+		...backupPath !== void 0 && { backupPath }
+	};
+}
+//#endregion
 //#region src/cli/connect/claude-code.ts
 const CLAUDE_DIR = join(homedir(), ".claude");
 const CLAUDE_JSON = join(homedir(), ".claude.json");
@@ -238,7 +528,7 @@ function entryMatches$2(entry) {
 	if (e["command"] !== "npx") return false;
 	return (Array.isArray(e["args"]) ? e["args"] : []).includes("@agentmemory/mcp");
 }
-const adapter$16 = {
+const adapter$18 = {
 	name: "claude-code",
 	displayName: "Claude Code",
 	category: "native",
@@ -350,7 +640,7 @@ function installClaudeHooks(opts) {
 }
 //#endregion
 //#region src/cli/connect/cline.ts
-const adapter$15 = createJsonMcpAdapter({
+const adapter$17 = createJsonMcpAdapter({
 	name: "cline",
 	displayName: "Cline",
 	detectDir: join(homedir(), ".cline"),
@@ -366,7 +656,7 @@ function entryMatches$1(entry) {
 	if (!entry || typeof entry !== "object") return false;
 	return JSON.stringify(entry) === JSON.stringify(AGENTMEMORY_COPILOT_MCP_BLOCK);
 }
-const adapter$14 = {
+const adapter$16 = {
 	name: "copilot-cli",
 	displayName: "GitHub Copilot CLI",
 	category: "native",
@@ -449,7 +739,7 @@ function stripExistingBlock(toml) {
 	}
 	return out.join("\n").replace(/\n{3,}$/, "\n\n").trimEnd() + "\n";
 }
-const adapter$13 = {
+const adapter$15 = {
 	name: "codex",
 	displayName: "Codex CLI",
 	category: "native",
@@ -536,7 +826,8 @@ function installCodexHooks(opts) {
 	}
 	writeJsonAtomic(CODEX_HOOKS, merged);
 	logInstalled("Codex hooks (workaround for openai/codex#16430)", CODEX_HOOKS);
-	p.log.info("User-scope hooks reference absolute paths under the bundled plugin/ dir. Re-run `agentmemory connect codex --with-hooks` after upgrading agentmemory to refresh them.");
+	p.log.warn("Codex runs only trusted hooks: launch `codex` (the TUI) once and choose \"Trust all and continue\" at the \"Hooks need review\" prompt. `codex exec` never shows the prompt, so hooks stay inert until then.");
+	p.log.info("User-scope hooks reference absolute paths under the bundled plugin/ dir. Re-run `agentmemory connect codex --with-hooks` after upgrading agentmemory to refresh them, then re-approve in the TUI.");
 	return {
 		kind: "installed",
 		mutatedPath: CODEX_HOOKS,
@@ -574,7 +865,7 @@ function renderFreshYaml() {
 		""
 	].join("\n");
 }
-const adapter$12 = {
+const adapter$14 = {
 	name: "continue",
 	displayName: "Continue",
 	category: "mcp",
@@ -654,7 +945,7 @@ const adapter$12 = {
 };
 //#endregion
 //#region src/cli/connect/cursor.ts
-const adapter$11 = createJsonMcpAdapter({
+const adapter$13 = createJsonMcpAdapter({
 	name: "cursor",
 	displayName: "Cursor",
 	detectDir: join(homedir(), ".cursor"),
@@ -663,16 +954,222 @@ const adapter$11 = createJsonMcpAdapter({
 	protocolNote: "→ Using MCP (the only protocol Cursor speaks). Memory bridge runs at :3111 underneath."
 });
 //#endregion
+//#region src/cli/connect/devin.ts
+function devinDir() {
+	if (platform() === "win32") {
+		const appData = process.env["APPDATA"];
+		if (appData) return join(appData, "devin");
+	}
+	const xdg = process.env["XDG_CONFIG_HOME"];
+	return xdg ? join(xdg, "devin") : join(homedir(), ".config", "devin");
+}
+const DEVIN_DIR = devinDir();
+const DEVIN_CONFIG = join(DEVIN_DIR, "config.json");
+const adapter$12 = createJsonMcpAdapter({
+	name: "devin",
+	displayName: "Devin CLI",
+	detectDir: DEVIN_DIR,
+	configPath: DEVIN_CONFIG,
+	docs: "https://github.com/rohitg00/agentmemory#other-agents",
+	protocolNote: "→ Using MCP via the user config. Devin CLI migrates mcpServers into mcp_config.json on newer builds. Pass --with-hooks for native auto-capture.",
+	installHooks: installDevinHooks
+});
+function installDevinHooks(opts) {
+	let pluginRoot;
+	try {
+		pluginRoot = findPluginRoot();
+	} catch (err) {
+		return {
+			kind: "skipped",
+			reason: err instanceof Error ? err.message : String(err)
+		};
+	}
+	const existing = readJsonSafe(DEVIN_CONFIG) ?? {};
+	const merged = buildMergedHooks(existing["hooks"] ? { hooks: existing["hooks"] } : null, pluginRoot, "hooks.devin.json");
+	const next = {
+		...existing,
+		hooks: merged.hooks
+	};
+	if (opts.dryRun) {
+		p.log.info(`[dry-run] Would write ${Object.keys(merged.hooks).length} hook event(s) into ${DEVIN_CONFIG}`);
+		return {
+			kind: "installed",
+			mutatedPath: DEVIN_CONFIG
+		};
+	}
+	let backupPath;
+	if (existsSync(DEVIN_CONFIG)) {
+		backupPath = backupFile(DEVIN_CONFIG, "devin-hooks", "json");
+		logBackup(backupPath);
+	} else mkdirSync(DEVIN_DIR, { recursive: true });
+	writeJsonAtomic(DEVIN_CONFIG, next);
+	logInstalled("Devin CLI hooks", DEVIN_CONFIG);
+	p.log.info("Verify with `/hooks` inside devin. Re-run `agentmemory connect devin --with-hooks` after upgrading agentmemory so the plugin paths stay current.");
+	return {
+		kind: "installed",
+		mutatedPath: DEVIN_CONFIG,
+		...backupPath !== void 0 && { backupPath }
+	};
+}
+//#endregion
 //#region src/cli/connect/droid.ts
-const adapter$10 = createJsonMcpAdapter({
+const DROID_DIR = join(homedir(), ".factory");
+const DROID_HOOKS = join(DROID_DIR, "hooks.json");
+const adapter$11 = createJsonMcpAdapter({
 	name: "droid",
 	displayName: "Droid (Factory.ai)",
-	detectDir: join(homedir(), ".factory"),
-	configPath: join(homedir(), ".factory", "mcp.json"),
+	detectDir: DROID_DIR,
+	configPath: join(DROID_DIR, "mcp.json"),
 	docs: "https://github.com/rohitg00/agentmemory#other-agents",
-	protocolNote: "→ Using MCP via ~/.factory/mcp.json. The `/mcp` slash command inside droid lists configured servers.",
-	extraEntryFields: { type: "stdio" }
+	protocolNote: "→ Using MCP via ~/.factory/mcp.json. The `/mcp` slash command inside droid lists configured servers. Pass --with-hooks to also install the native ~/.factory/hooks.json auto-capture hooks.",
+	extraEntryFields: { type: "stdio" },
+	installHooks: installDroidHooks
 });
+/**
+* Merge the bundled `plugin/hooks/hooks.droid.json` into
+* `~/.factory/hooks.json`. Same idempotent merge/strip-by-script-path
+* behavior as the Codex and Claude Code hook installers: re-running keeps
+* user-authored hook entries and only replaces the ones agentmemory owns.
+*/
+function installDroidHooks(opts) {
+	let pluginRoot;
+	try {
+		pluginRoot = findPluginRoot();
+	} catch (err) {
+		return {
+			kind: "skipped",
+			reason: err instanceof Error ? err.message : String(err)
+		};
+	}
+	const existing = readJsonSafe(DROID_HOOKS);
+	const merged = buildMergedHooks(existing, pluginRoot, "hooks.droid.json");
+	if (opts.dryRun) {
+		p.log.info(`[dry-run] Would ${existing ? "merge" : "create"} ${DROID_HOOKS} with ${Object.keys(merged.hooks).length} event(s)`);
+		return {
+			kind: "installed",
+			mutatedPath: DROID_HOOKS
+		};
+	}
+	let backupPath;
+	if (existsSync(DROID_HOOKS)) {
+		backupPath = backupFile(DROID_HOOKS, "droid-hooks", "json");
+		logBackup(backupPath);
+	} else mkdirSync(DROID_DIR, { recursive: true });
+	writeJsonAtomic(DROID_HOOKS, merged);
+	logInstalled("Droid hooks", DROID_HOOKS);
+	p.log.info("User-scope hooks reference absolute paths under the bundled plugin/ dir. Re-run `agentmemory connect droid --with-hooks` after upgrading agentmemory to refresh them.");
+	return {
+		kind: "installed",
+		mutatedPath: DROID_HOOKS,
+		...backupPath !== void 0 && { backupPath }
+	};
+}
+//#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'
+      config:
+        transport: stdio
+        serverName: agentmemory
+        command: npx
+        args: ['-y', '@agentmemory/mcp']
+        env:
+          AGENTMEMORY_URL: http://localhost:3111
+`;
+const MCP_MARKER = "serverName: agentmemory";
+const HOOKS_MARKER = "id: agentmemory-hooks";
+function hooksBlock(hooksConfigPath) {
+	return `- insert:
+    - id: agentmemory-hooks
+      name: '@deepseek-ai/dsh-hooks-claude-code'
+      config:
+        configPath: ${JSON.stringify(hooksConfigPath)}
+`;
+}
+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 = {
+	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.",
+	category: "native",
+	detect() {
+		return existsSync(dshHome());
+	},
+	async install(opts) {
+		const home = dshHome();
+		const configPath = join(home, "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) {
+			logAlreadyWired(this.displayName, configPath);
+			return {
+				kind: "already-wired",
+				mutatedPath: configPath
+			};
+		}
+		if (opts.dryRun) {
+			p.log.info(`[dry-run] Would append the agentmemory mcp-client row${wantHooks ? " and the hooks-claude-code row" : ""} to ${configPath}`);
+			return {
+				kind: "installed",
+				mutatedPath: configPath
+			};
+		}
+		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}`);
+		}
+		writeTextAtomic(configPath, next);
+		const written = readFileSync(configPath, "utf-8");
+		if (!written.includes(MCP_MARKER) || wantHooks && !written.includes(HOOKS_MARKER)) {
+			p.log.error(`Verification failed: ${configPath} did not contain the agentmemory rows after write.`);
+			return {
+				kind: "skipped",
+				reason: "verification-failed"
+			};
+		}
+		logInstalled(this.displayName, configPath);
+		return {
+			kind: "installed",
+			mutatedPath: configPath,
+			backupPath
+		};
+	}
+};
 //#endregion
 //#region src/cli/connect/gemini-cli.ts
 const adapter$9 = createJsonMcpAdapter({
@@ -844,32 +1341,75 @@ const adapter$4 = {
 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;
+}
 const adapter$3 = {
 	name: "pi",
 	displayName: "pi",
 	category: "native",
 	docs: DOCS,
-	protocolNote: "→ Using native hooks (REST API at :3111). MCP not required.",
+	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);
 	},
-	async install(_opts) {
-		p.log.warn("pi uses a TypeScript extension file. Automated copy + register isn't implemented yet — manual install required.");
-		p.note([
-			"Run these from the agentmemory repo root:",
-			"",
-			`  mkdir -p ${PI_EXT_DIR}`,
-			`  cp integrations/pi/index.ts ${PI_EXT_DIR}/index.ts`,
-			`  cp integrations/pi/security.ts ${PI_EXT_DIR}/security.ts`,
-			"",
-			"Then add to ~/.pi/agent/settings.json:",
-			"  { \"extensions\": [\"~/.pi/agent/extensions/agentmemory\"] }",
-			"",
-			`Full guide: ${DOCS}`
-		].join("\n"), "pi manual install");
+	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"
+			};
+		}
+		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);
+			return {
+				kind: "already-wired",
+				mutatedPath: PI_EXT_DIR
+			};
+		}
+		if (opts.dryRun) {
+			p.log.info(`[dry-run] Would install the pi extension (${EXT_FILES.join(", ")}) into ${PI_EXT_DIR}`);
+			return {
+				kind: "installed",
+				mutatedPath: PI_EXT_DIR
+			};
+		}
+		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.`);
+			return {
+				kind: "skipped",
+				reason: "verification-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: "stub",
-			reason: "ts-extension-copy-not-implemented"
+			kind: "installed",
+			mutatedPath: PI_EXT_DIR,
+			backupPath
 		};
 	}
 };
@@ -915,18 +1455,21 @@ var connect_exports = /* @__PURE__ */ __exportAll({
 	runConnect: () => runConnect
 });
 const ADAPTERS = [
+	adapter$18,
 	adapter$16,
-	adapter$14,
+	adapter$15,
 	adapter$13,
-	adapter$11,
+	adapter$12,
 	adapter$9,
 	adapter$2,
-	adapter$17,
+	adapter$20,
+	adapter$19,
 	adapter$7,
 	adapter$1,
-	adapter$15,
-	adapter$12,
+	adapter$17,
+	adapter$14,
 	adapter,
+	adapter$11,
 	adapter$10,
 	adapter$5,
 	adapter$6,
@@ -947,16 +1490,19 @@ function parseFlags(args) {
 	let force = false;
 	let all = false;
 	let withHooks = 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 === "--no-guidelines") guidelines = false;
 	else if (!a.startsWith("-")) positional.push(a);
 	return {
 		dryRun,
 		force,
 		all,
 		withHooks,
+		guidelines,
 		positional
 	};
 }
@@ -971,7 +1517,18 @@ async function runAdapter(adapter, opts) {
 	p.log.step(`Wiring ${adapter.displayName}…`);
 	if (adapter.protocolNote) p.log.message(adapter.protocolNote);
 	try {
-		return await adapter.install(opts);
+		const result = await adapter.install(opts);
+		if (opts.guidelines !== false && (result.kind === "installed" || result.kind === "already-wired")) try {
+			const g = writeGuideline(adapter.name, {
+				cwd: process.cwd(),
+				dryRun: opts.dryRun
+			});
+			if (g.kind === "written") p.log.message(`  ${pc.dim("guideline")} ${g.scope} → ${g.path} (memory auto-use)`);
+			else if (g.kind === "would-write") p.log.message(`  ${pc.dim("[dry-run] guideline")} → ${g.path}`);
+		} catch (gerr) {
+			p.log.warn(`${adapter.displayName}: guideline not written (${gerr instanceof Error ? gerr.message : String(gerr)})`);
+		}
+		return result;
 	} catch (err) {
 		p.log.error(`${adapter.displayName}: ${err instanceof Error ? err.message : String(err)}`);
 		return {
@@ -981,7 +1538,7 @@ async function runAdapter(adapter, opts) {
 	}
 }
 async function runConnect(args) {
-	const { dryRun, force, all, withHooks, positional } = parseFlags(args);
+	const { dryRun, force, all, withHooks, guidelines, positional } = parseFlags(args);
 	const allowWindowsAdapter = positional.length === 1 && positional[0]?.toLowerCase() === "copilot-cli";
 	if (platform() === "win32" && !allowWindowsAdapter) {
 		p.intro("agentmemory connect");
@@ -992,7 +1549,8 @@ async function runConnect(args) {
 	const opts = {
 		dryRun,
 		force,
-		withHooks
+		withHooks,
+		guidelines
 	};
 	p.intro("agentmemory connect");
 	if (positional.length === 0 && !all) {
@@ -1066,10 +1624,10 @@ 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 15 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) => 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");
 	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-JnsJXc68.mjs.map
+//# sourceMappingURL=connect-Qaeq15TQ.mjs.map