@lore-co/cli 0.2.22 → 0.2.24

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { parseDirectoryRules, checkDirectory, checkLoreAccess } from "./directory-policy.js";
+import { parseDirectoryRules, checkDirectory, checkLoreAccess, capturePauseMessage } from "./directory-policy.js";
 import { reportCommand, runTelemetryCommand, telemetryEnabled, trackedCommand, TELEMETRY_HELP } from "./telemetry.js";
 import { secureWindowsDirectory, windowsPermissionsArePrivate } from "./windows-permissions.js";
 import { COMMAND_GUIDES, ROOT_HELP, helpTopic } from "./command-help.js";
@@ -8,15 +8,16 @@ import { resolveConnectProject, validateConnectProjectOptions } from "./connect-
 import { captureDirectories } from "./capture-scope.js";
 import { prepareConnection, persistConnection, listConnections } from "./connections.js";
 import { connectionReferences, resolveLocalConnection } from "./directory-policy.js";
-import { withDirectoryLock } from "./reliability-store.js";
+import { atomicWriteJson, withDirectoryLock } from "./reliability-store.js";
 import { runConfigCommand } from "./config-command.js";
 import { codexApprovalDetail, inspectCodexHookApproval } from "./codex-hook-approval.js";
-import { claudeOnlyCommand, disableDevinCli, runDevinCliHook } from "./devin-cli.js";
+import { claudeOnlyCommand, disableDevinCli, refreshDevinHooks, runDevinCliHook } from "./devin-cli.js";
+import { LORE_MCP_SERVER_NAME, MCP_HOST_AGENTS, inspectCodexMcp, isLoreMcpServer, isLoreOpenCodeMcp, loreMcpServerEntry, loreVsCodeMcpServer, mergeLoreCodexMcp, mergeLoreMcpServers, mergeLoreOpenCodeMcp, mergeLoreVsCodeMcp, openCodeMcpEntry, removeLoreCodexMcp, removeLoreMcpServers, removeLoreOpenCodeMcp, removeLoreVsCodeMcp, } from "./mcp-config.js";
 import { access, chmod, copyFile, mkdir, open, readFile, readdir, rename, rm, stat, writeFile, } from "node:fs/promises";
 import { constants as fsConstants, realpathSync } from "node:fs";
 import { spawn, isWindows, windowsCommand, commandText, findExecutable, openBrowser } from "./platform.js";
 import { createHash, randomUUID } from "node:crypto";
-import { dirname, resolve } from "node:path";
+import { basename, dirname, resolve } from "node:path";
 import { homedir, hostname, platform } from "node:os";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -24,10 +25,14 @@ import { CLAUDE_RELIABILITY_INTEGRATION, CODEX_RELIABILITY_INTEGRATION, COPILOT_
 import { runHook, } from "./runtime.js";
 import { readInvocationHealthWriteInput, runInvocationHealthWrite, } from "./invocation-health-writer.js";
 import { runAskCommand } from "./ask.js";
+import { runChatCommand } from "./chat.js";
 import { runLearningsCommand } from "./learnings.js";
+import { runReviewCommand } from "./review.js";
 import { runEmbeddingsCommand } from "./embeddings.js";
 import { runRememberCommand } from "./remember.js";
 import { installLoreSkill, removeLoreSkill } from "./skills.js";
+import { GENERIC_AGENT, genericInstructions, genericMcpServers, parseGenericAgentId, readGenericAgents, recordGenericAgent, removeGenericAgents } from "./generic-mcp.js";
+import { installLoreAgent, removeLoreAgent } from "./lore-agent.js";
 import { runApproachCommand } from "./approach.js";
 import { runSkillCommand } from "./skill-command.js";
 import { runGuardCommand } from "./guard.js";
@@ -58,6 +63,20 @@ const HOOK_EVENTS = [
     "Stop",
     "SessionEnd",
 ];
+/**
+ * Hook events that exist only to record turns. Retrieval-only mode leaves them
+ * uninstalled, so the agent never hands a response to Lore at all.
+ */
+const CAPTURE_HOOK_EVENTS = new Set([
+    "Stop", "SessionEnd", "afterAgentResponse", "sessionEnd", "agentStop", "post_model_turn",
+]);
+function installedEvents(events, capture) {
+    return capture ? [...events] : events.filter((event) => !CAPTURE_HOOK_EVENTS.has(event));
+}
+/** Capture mode of a connection: absent means on. */
+export function captureEnabled(config) {
+    return config?.capture !== "off";
+}
 /** Tools the Context Guard PreToolUse hook cares about (regex matcher). */
 const GUARD_TOOL_MATCHER = "Edit|Write|MultiEdit|NotebookEdit|ApplyPatch|apply_patch|edit|write|patch|str_replace_editor|Bash|bash|Shell|shell|exec_command|shell_command|run_terminal_cmd";
 const CURSOR_HOOK_EVENTS = [
@@ -110,12 +129,16 @@ Options:
   --repository <repo>  Verify the selected folder matches this GitHub repository
   --folder <path>        Record only in this folder and subfolders (repeatable)
   --all-projects         Record in all projects allowed by your workspace
+  --no-capture           Retrieval-only mode: context, guard, and manual saves, no turn recording
+  --capture              Turn automatic turn recording back on
   --url <url>           Lore API base URL (default: https://api.uselore.co)
   --dashboard-url <url> Lore dashboard URL (default: https://uselore.co for hosted Lore)
   --login               Approve access securely in the Lore dashboard
   --no-open             Print the approval URL without opening a browser
   --token <token>       Workspace bearer token (or LORE_WORKSPACE_TOKEN/LORE_TOKEN)
-  --agent <name>        claude, codex, copilot, copilot-cli, copilot-vscode, cowork, cursor, devin, opencode, polytoken, or t3code
+  --agent <name>        claude, codex, copilot, copilot-cli, copilot-vscode, cowork, cursor, devin, generic, opencode, polytoken, or t3code
+  --agent-id <id>       With --agent generic: credit MCP saves to this agent (default: generic)
+  --write               With --agent generic: let the agent save through MCP (saves stay proposals)
   --timeout-ms <ms>     Hook request timeout, 250-10000 (default: 2500)
   --fallback <agent>   claude, codex, opencode, devin, cursor, copilot-cli, polytoken
   --no-recovery        Disable automatic handoff setup (otherwise enabled with two installed clients)
@@ -123,11 +146,14 @@ Options:
   --help                Show this command's help
 
 New connections stay paused until you choose a project, a folder, or --all-projects.
-Reconnecting without a capture option keeps your saved folder rules.
-Folder choices control capture; learning scope controls where knowledge applies.
+Reconnecting without a capture option keeps your saved folder rules and capture mode.
+Folder choices control where Lore runs; learning scope controls where knowledge applies.
+With --no-capture, Lore installs no Stop or SessionEnd hooks and sends no turns.
+Context injection, Guard, lore ask, and lore remember keep working. See lore capture.
 
 Examples:
   lore connect --login --agent claude --folder .
+  lore connect --login --agent claude --folder . --no-capture
   lore connect --login --agent cowork
   lore connect --login --agent devin --folder .
   lore connect --token "$LORE_WORKSPACE_TOKEN" --agent claude
@@ -154,6 +180,24 @@ Examples:
   lore doctor
   lore doctor --json
 `;
+const CAPTURE_HELP = `lore capture
+Choose whether this machine records agent turns automatically.
+
+Usage:
+  lore capture status [--json]
+  lore capture off [--json]
+  lore capture on [--json]
+
+With capture off, Lore installs no Stop or SessionEnd hooks and never sends a
+prompt or response as a turn. Context injection, Guard, lore ask, lore remember,
+and the lore skill's "remember this session" keep working. Folder rules still
+decide where Lore runs at all.
+
+Examples:
+  lore capture off
+  lore capture status
+  lore capture on
+`;
 const DISCONNECT_HELP = `lore disconnect
 Remove Lore-owned hooks/plugin, credentials, runtime, and transient state.
 Durable captures, dead letters, verified snapshots, unrelated agent settings,
@@ -222,6 +266,7 @@ function isConnectAgent(value) {
     return (isConfiguredAgent(value) ||
         value === "copilot" ||
         isCredentialOnlyAgent(value) ||
+        value === "generic" ||
         value === "t3code");
 }
 function isCredentialOnlyAgent(value) {
@@ -291,24 +336,29 @@ function eventHandler(agent, event, paths) {
             : {}),
     };
 }
-export function mergeLoreHooks(input, agent, paths) {
+export function mergeLoreHooks(input, agent, paths, capture = true) {
     const result = cloneObject(input);
     if (result.hooks !== undefined && !isObject(result.hooks)) {
         throw new Error("Agent configuration field \"hooks\" must be a JSON object");
     }
     const hooks = isObject(result.hooks) ? { ...result.hooks } : {};
+    const installed = installedEvents(HOOK_EVENTS, capture);
     for (const event of HOOK_EVENTS) {
         if (hooks[event] !== undefined && !Array.isArray(hooks[event])) {
             throw new Error(`Agent hook event "${event}" must be a JSON array`);
         }
-        hooks[event] = [
+        const groups = [
             ...stripLoreFromEvent(hooks[event]),
-            {
-                // Guard checks run only for mutation-shaped tools.
-                ...(event === "PreToolUse" ? { matcher: GUARD_TOOL_MATCHER } : {}),
-                hooks: [eventHandler(agent, event, paths)],
-            },
+            ...(installed.includes(event) ? [{
+                    // Guard checks run only for mutation-shaped tools.
+                    ...(event === "PreToolUse" ? { matcher: GUARD_TOOL_MATCHER } : {}),
+                    hooks: [eventHandler(agent, event, paths)],
+                }] : []),
         ];
+        if (groups.length === 0)
+            delete hooks[event];
+        else
+            hooks[event] = groups;
     }
     result.hooks = hooks;
     return result;
@@ -398,10 +448,53 @@ export function removeLoreCursorMcp(input) {
     const { [CURSOR_MCP_NAME]: _lore, ...rest } = config.mcpServers;
     return { ...config, mcpServers: rest };
 }
+function isMcpHostAgent(agent) {
+    return MCP_HOST_AGENTS.includes(agent);
+}
+/** The full Lore MCP server, run by this CLI so it shares the hooks' credentials and version. */
+export function loreMcpServer(paths, agent) {
+    return loreMcpServerEntry(loreMcpInvocation(), paths.home, agent);
+}
+/** This CLI's executable plus its script path (none for the standalone binary). */
+function loreMcpInvocation() {
+    return [process.execPath, ...(IS_STANDALONE_BINARY ? [] : [fileURLToPath(import.meta.url)])];
+}
+/** Where each agent lists MCP servers, located from the hooks file Lore already manages. */
+export function mcpConfigPath(agent, hooksPath) {
+    const directory = dirname(hooksPath);
+    switch (agent) {
+        case "claude":
+            // ~/.claude/settings.json pairs with ~/.claude.json; a CLAUDE_CONFIG_DIR keeps both inside it.
+            return basename(directory) === ".claude"
+                ? resolve(directory, "..", ".claude.json")
+                : resolve(directory, ".claude.json");
+        case "codex":
+            return resolve(directory, "config.toml");
+        case "cursor":
+            return resolve(directory, "mcp.json");
+        case "copilot-cli":
+            // $COPILOT_HOME/hooks/lore.json pairs with $COPILOT_HOME/mcp-config.json.
+            return resolve(directory, "..", "mcp-config.json");
+        case "copilot-vscode":
+            // <repo>/.github/hooks/lore-vscode.json pairs with <repo>/.vscode/mcp.json.
+            return resolve(directory, "..", "..", ".vscode", "mcp.json");
+    }
+}
+export function mergeLoreMcp(input, agent, paths) {
+    const config = objectConfiguration(input, agent);
+    // VS Code keeps its servers under `servers`; the other JSON hosts use `mcpServers`.
+    return agent === "copilot-vscode"
+        ? mergeLoreVsCodeMcp(config, loreMcpServer(paths, agent))
+        : mergeLoreMcpServers(config, loreMcpServer(paths, agent), agent);
+}
+export function removeLoreMcp(input, agent) {
+    const config = objectConfiguration(input, agent);
+    return agent === "copilot-vscode" ? removeLoreVsCodeMcp(config) : removeLoreMcpServers(config);
+}
 function stripLoreFromCursorEvent(value) {
     return Array.isArray(value) ? value.filter((hook) => !isLoreHook(hook)) : [];
 }
-export function mergeLoreCursorHooks(input, paths) {
+export function mergeLoreCursorHooks(input, paths, capture = true) {
     const result = cloneObject(input);
     if (result.version !== undefined && result.version !== 1) {
         throw new Error('Cursor configuration field "version" must be 1');
@@ -410,14 +503,19 @@ export function mergeLoreCursorHooks(input, paths) {
         throw new Error('Cursor configuration field "hooks" must be a JSON object');
     }
     const hooks = isObject(result.hooks) ? { ...result.hooks } : {};
+    const installed = installedEvents(CURSOR_HOOK_EVENTS, capture);
     for (const event of CURSOR_HOOK_EVENTS) {
         if (hooks[event] !== undefined && !Array.isArray(hooks[event])) {
             throw new Error(`Cursor hook event "${event}" must be a JSON array`);
         }
-        hooks[event] = [
+        const entries = [
             ...stripLoreFromCursorEvent(hooks[event]),
-            cursorEventHandler(event, paths),
+            ...(installed.includes(event) ? [cursorEventHandler(event, paths)] : []),
         ];
+        if (entries.length === 0)
+            delete hooks[event];
+        else
+            hooks[event] = entries;
     }
     result.version = 1;
     result.hooks = hooks;
@@ -492,7 +590,7 @@ function stripLoreFromCopilotEvent(value) {
         ? value.filter((hook) => !isLoreCopilotHook(hook))
         : [];
 }
-export function mergeLoreCopilotCliHooks(input, paths) {
+export function mergeLoreCopilotCliHooks(input, paths, capture = true) {
     const result = cloneObject(input);
     if (result.version !== undefined && result.version !== 1) {
         throw new Error('Copilot hook configuration field "version" must be 1');
@@ -501,14 +599,19 @@ export function mergeLoreCopilotCliHooks(input, paths) {
         throw new Error('Copilot hook configuration field "hooks" must be an object');
     }
     const hooks = isObject(result.hooks) ? { ...result.hooks } : {};
+    const installed = installedEvents(COPILOT_CLI_HOOK_EVENTS, capture);
     for (const event of COPILOT_CLI_HOOK_EVENTS) {
         if (hooks[event] !== undefined && !Array.isArray(hooks[event])) {
             throw new Error(`Copilot hook event "${event}" must be an array`);
         }
-        hooks[event] = [
+        const entries = [
             ...stripLoreFromCopilotEvent(hooks[event]),
-            copilotCliEventHandler(event, paths),
+            ...(installed.includes(event) ? [copilotCliEventHandler(event, paths)] : []),
         ];
+        if (entries.length === 0)
+            delete hooks[event];
+        else
+            hooks[event] = entries;
     }
     result.version = 1;
     result.hooks = hooks;
@@ -565,7 +668,7 @@ function copilotVscodeEventHandler(event, paths) {
                     : 25,
     };
 }
-export function mergeLoreCopilotVscodeHooks(input, paths) {
+export function mergeLoreCopilotVscodeHooks(input, paths, capture = true) {
     const result = cloneObject(input);
     if (result.version !== undefined && result.version !== 1) {
         throw new Error('VS Code Copilot hook field "version" must be 1');
@@ -574,14 +677,19 @@ export function mergeLoreCopilotVscodeHooks(input, paths) {
         throw new Error('VS Code Copilot hook field "hooks" must be an object');
     }
     const hooks = isObject(result.hooks) ? { ...result.hooks } : {};
+    const installed = installedEvents(HOOK_EVENTS, capture);
     for (const event of HOOK_EVENTS) {
         if (hooks[event] !== undefined && !Array.isArray(hooks[event])) {
             throw new Error(`VS Code Copilot hook event "${event}" must be an array`);
         }
-        hooks[event] = [
+        const entries = [
             ...stripLoreFromCursorEvent(hooks[event]),
-            copilotVscodeEventHandler(event, paths),
+            ...(installed.includes(event) ? [copilotVscodeEventHandler(event, paths)] : []),
         ];
+        if (entries.length === 0)
+            delete hooks[event];
+        else
+            hooks[event] = entries;
     }
     result.version = 1;
     result.hooks = hooks;
@@ -641,14 +749,14 @@ function isLorePolytokenHook(value) {
         (/(?:^|\s)--owner(?:=|\s+)lore(?:\s|$)/u.test(command) ||
             command.includes("/.lore/bin/lore-hook.mjs")));
 }
-export function mergeLorePolytokenHooks(input, paths) {
+export function mergeLorePolytokenHooks(input, paths, capture = true) {
     if (!Array.isArray(input)) {
         throw new Error("Polytoken hooks must contain a JSON array");
     }
     const retained = input.filter((hook) => !isLorePolytokenHook(hook));
     return [
         ...structuredClone(retained),
-        ...POLYTOKEN_HOOK_EVENTS.map((event) => polytokenEventHandler(event, paths)),
+        ...installedEvents(POLYTOKEN_HOOK_EVENTS, capture).map((event) => polytokenEventHandler(event, paths)),
     ];
 }
 export function removeLorePolytokenHooks(input) {
@@ -697,6 +805,9 @@ export function countLoreOpenCodePlugins(input) {
         ? input.plugin.filter(isLoreOpenCodePlugin).length
         : 0;
 }
+function countLoreOpenCodeMcp(input) {
+    return isObject(input.mcp) && isLoreOpenCodeMcp(input.mcp[LORE_MCP_SERVER_NAME]) ? 1 : 0;
+}
 function installationUnitId(event, index, total) {
     return total === 1 ? event : `installation-${index + 1}/${event}`;
 }
@@ -712,13 +823,13 @@ function installationUnitState(ownedCount, exactCount) {
 function exactConfiguration(left, right) {
     return canonicalJson(left) === canonicalJson(right);
 }
-function commandHookInstallationUnits(input, agent, paths, index, total) {
+function commandHookInstallationUnits(input, agent, paths, index, total, capture) {
     const configuration = objectConfiguration(input, agent);
     if (configuration.hooks !== undefined && !isObject(configuration.hooks)) {
         throw new Error(`${agent} configuration field "hooks" must be an object`);
     }
     const hooks = isObject(configuration.hooks) ? configuration.hooks : {};
-    return HOOK_EVENTS.map((event) => {
+    return installedEvents(HOOK_EVENTS, capture).map((event) => {
         const groups = hooks[event];
         if (groups !== undefined && !Array.isArray(groups)) {
             throw new Error(`${agent} hook event "${event}" must be an array`);
@@ -741,7 +852,7 @@ function commandHookInstallationUnits(input, agent, paths, index, total) {
         };
     });
 }
-function cursorInstallationUnits(input, paths, index, total) {
+function cursorInstallationUnits(input, paths, index, total, capture) {
     const configuration = objectConfiguration(input, "cursor");
     if (configuration.version !== undefined && configuration.version !== 1) {
         throw new Error('Cursor configuration field "version" must be 1');
@@ -750,7 +861,7 @@ function cursorInstallationUnits(input, paths, index, total) {
         throw new Error('Cursor configuration field "hooks" must be an object');
     }
     const hooks = isObject(configuration.hooks) ? configuration.hooks : {};
-    return CURSOR_HOOK_EVENTS.map((event) => {
+    return installedEvents(CURSOR_HOOK_EVENTS, capture).map((event) => {
         const values = hooks[event];
         if (values !== undefined && !Array.isArray(values)) {
             throw new Error(`Cursor hook event "${event}" must be an array`);
@@ -765,7 +876,7 @@ function cursorInstallationUnits(input, paths, index, total) {
         };
     });
 }
-function copilotCliInstallationUnits(input, paths, index, total) {
+function copilotCliInstallationUnits(input, paths, index, total, capture) {
     const configuration = objectConfiguration(input, "copilot-cli");
     if (configuration.version !== undefined && configuration.version !== 1) {
         throw new Error('Copilot hook configuration field "version" must be 1');
@@ -774,7 +885,7 @@ function copilotCliInstallationUnits(input, paths, index, total) {
         throw new Error('Copilot hook configuration field "hooks" must be an object');
     }
     const hooks = isObject(configuration.hooks) ? configuration.hooks : {};
-    return COPILOT_CLI_HOOK_EVENTS.map((event) => {
+    return installedEvents(COPILOT_CLI_HOOK_EVENTS, capture).map((event) => {
         const values = hooks[event];
         if (values !== undefined && !Array.isArray(values)) {
             throw new Error(`Copilot hook event "${event}" must be an array`);
@@ -789,7 +900,7 @@ function copilotCliInstallationUnits(input, paths, index, total) {
         };
     });
 }
-function copilotVscodeInstallationUnits(input, paths, index, total) {
+function copilotVscodeInstallationUnits(input, paths, index, total, capture) {
     const configuration = objectConfiguration(input, "copilot-vscode");
     if (configuration.version !== undefined && configuration.version !== 1) {
         throw new Error('VS Code Copilot hook field "version" must be 1');
@@ -798,7 +909,7 @@ function copilotVscodeInstallationUnits(input, paths, index, total) {
         throw new Error('VS Code Copilot hook field "hooks" must be an object');
     }
     const hooks = isObject(configuration.hooks) ? configuration.hooks : {};
-    return HOOK_EVENTS.map((event) => {
+    return installedEvents(HOOK_EVENTS, capture).map((event) => {
         const values = hooks[event];
         if (values !== undefined && !Array.isArray(values)) {
             throw new Error(`VS Code Copilot hook event "${event}" must be an array`);
@@ -813,11 +924,11 @@ function copilotVscodeInstallationUnits(input, paths, index, total) {
         };
     });
 }
-function polytokenInstallationUnits(input, paths, index, total) {
+function polytokenInstallationUnits(input, paths, index, total, capture) {
     if (!Array.isArray(input)) {
         throw new Error("Polytoken hooks must contain a JSON array");
     }
-    return POLYTOKEN_HOOK_EVENTS.map((event) => {
+    return installedEvents(POLYTOKEN_HOOK_EVENTS, capture).map((event) => {
         const expected = polytokenEventHandler(event, paths);
         const owned = input.filter((candidate) => isLorePolytokenHook(candidate) &&
             (!isObject(candidate) || candidate.event === event));
@@ -828,7 +939,7 @@ function polytokenInstallationUnits(input, paths, index, total) {
         };
     });
 }
-function openCodeInstallationUnits(input, index, total) {
+function openCodeInstallationUnits(input, paths, index, total) {
     const configuration = objectConfiguration(input, "opencode");
     if (configuration.plugin !== undefined &&
         !Array.isArray(configuration.plugin)) {
@@ -839,28 +950,37 @@ function openCodeInstallationUnits(input, index, total) {
         : [];
     const owned = plugins.filter(isLoreOpenCodePlugin);
     const exactCount = owned.filter((candidate) => candidate === LORE_OPENCODE_PLUGIN).length;
+    if (configuration.mcp !== undefined && !isObject(configuration.mcp)) {
+        throw new Error('OpenCode configuration field "mcp" must be a JSON object');
+    }
+    const server = isObject(configuration.mcp) ? configuration.mcp[LORE_MCP_SERVER_NAME] : undefined;
+    const ownedServer = Number(isLoreOpenCodeMcp(server));
     return [
         {
             id: installationUnitId("plugin", index, total),
             state: installationUnitState(owned.length, exactCount),
         },
+        {
+            id: installationUnitId("mcp-tools", index, total),
+            state: installationUnitState(ownedServer, Number(exactConfiguration(server, openCodeMcpEntry(loreMcpServer(paths, "opencode"))))),
+        },
     ];
 }
-function inspectInstallationUnits(input, agent, paths, index, total) {
+function inspectInstallationUnits(input, agent, paths, index, total, capture) {
     switch (agent) {
         case "claude":
         case "codex":
-            return commandHookInstallationUnits(input, agent, paths, index, total);
+            return commandHookInstallationUnits(input, agent, paths, index, total, capture);
         case "copilot-cli":
-            return copilotCliInstallationUnits(input, paths, index, total);
+            return copilotCliInstallationUnits(input, paths, index, total, capture);
         case "copilot-vscode":
-            return copilotVscodeInstallationUnits(input, paths, index, total);
+            return copilotVscodeInstallationUnits(input, paths, index, total, capture);
         case "cursor":
-            return cursorInstallationUnits(input, paths, index, total);
+            return cursorInstallationUnits(input, paths, index, total, capture);
         case "polytoken":
-            return polytokenInstallationUnits(input, paths, index, total);
+            return polytokenInstallationUnits(input, paths, index, total, capture);
         case "opencode":
-            return openCodeInstallationUnits(input, index, total);
+            return openCodeInstallationUnits(input, paths, index, total);
     }
 }
 async function readJsonDocument(path) {
@@ -920,6 +1040,39 @@ async function writeMergedJson(path, document, value, now) {
         ...(backup === undefined ? {} : { backup }),
     };
 }
+async function readTextDocument(path) {
+    try {
+        const [value, metadata] = await Promise.all([
+            readFile(path, "utf8"),
+            stat(path),
+        ]);
+        return { exists: true, value, mode: metadata.mode & 0o777 };
+    }
+    catch (error) {
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? error.code
+            : undefined;
+        if (code === "ENOENT") {
+            return { exists: false, value: "", mode: 0o600 };
+        }
+        throw error;
+    }
+}
+async function writeMergedText(path, document, value, now) {
+    if (document.exists && document.value === value) {
+        return { changed: false };
+    }
+    let backup;
+    if (document.exists) {
+        backup = `${path}.lore-backup-${backupTimestamp(now)}-${randomUUID().slice(0, 8)}`;
+        await copyFile(path, backup, fsConstants.COPYFILE_EXCL);
+    }
+    await atomicWrite(path, value, document.mode);
+    return {
+        changed: true,
+        ...(backup === undefined ? {} : { backup }),
+    };
+}
 function parseConnectorConfig(value) {
     if (!isObject(value) ||
         (value.version !== 1 && value.version !== 2) ||
@@ -979,6 +1132,7 @@ function parseConnectorConfig(value) {
             Object.keys(agentConfigPaths).length === 0
             ? {}
             : { agentConfigPaths }),
+        ...(value.capture === "off" ? { capture: "off" } : {}),
         connectedAt: value.connectedAt,
         timeoutMs,
     };
@@ -1145,79 +1299,84 @@ function objectConfiguration(input, agent) {
 const AGENT_TARGETS = {
     claude: {
         integration: "hooks",
-        expected: HOOK_EVENTS.length,
+        // Native hooks plus the Lore MCP server entry.
+        expected: (capture) => installedEvents(HOOK_EVENTS, capture).length + 1,
         runtimeRequired: true,
         emptyValue: () => ({}),
         configPath: (paths) => paths.claudeSettings,
         detect: async () => commandExists("claude"),
         executable: async () => commandExists("claude"),
-        merge: (input, paths) => mergeLoreHooks(objectConfiguration(input, "claude"), "claude", paths),
+        merge: (input, paths, capture) => mergeLoreHooks(objectConfiguration(input, "claude"), "claude", paths, capture),
         remove: (input) => removeLoreHooks(objectConfiguration(input, "claude")),
         count: (input) => countLoreHooks(objectConfiguration(input, "claude")),
     },
     codex: {
         integration: "hooks",
-        expected: HOOK_EVENTS.length,
+        expected: (capture) => installedEvents(HOOK_EVENTS, capture).length + 1,
         runtimeRequired: true,
         emptyValue: () => ({}),
         configPath: (paths) => paths.codexHooks,
         detect: async () => commandExists("codex"),
         executable: async () => commandExists("codex"),
-        merge: (input, paths) => mergeLoreHooks(objectConfiguration(input, "codex"), "codex", paths),
+        merge: (input, paths, capture) => mergeLoreHooks(objectConfiguration(input, "codex"), "codex", paths, capture),
         remove: (input) => removeLoreHooks(objectConfiguration(input, "codex")),
         count: (input) => countLoreHooks(objectConfiguration(input, "codex")),
     },
     "copilot-cli": {
         integration: "hooks",
-        expected: COPILOT_CLI_HOOK_EVENTS.length,
+        // Native hooks plus the Lore MCP server entry.
+        expected: (capture) => installedEvents(COPILOT_CLI_HOOK_EVENTS, capture).length + 1,
         runtimeRequired: true,
         emptyValue: () => ({}),
         configPath: (paths) => paths.copilotCliHooks,
         detect: async (paths) => (await commandExists("copilot")) || pathExists(paths.copilotCliHooks),
         executable: async () => commandExists("copilot"),
-        merge: (input, paths) => mergeLoreCopilotCliHooks(objectConfiguration(input, "copilot-cli"), paths),
+        merge: (input, paths, capture) => mergeLoreCopilotCliHooks(objectConfiguration(input, "copilot-cli"), paths, capture),
         remove: (input) => removeLoreCopilotCliHooks(objectConfiguration(input, "copilot-cli")),
         count: (input) => countLoreCopilotCliHooks(objectConfiguration(input, "copilot-cli")),
     },
     "copilot-vscode": {
         integration: "hooks",
-        expected: HOOK_EVENTS.length,
+        // Repository hooks plus the Lore MCP server entry in .vscode/mcp.json.
+        expected: (capture) => installedEvents(HOOK_EVENTS, capture).length + 1,
         runtimeRequired: true,
         emptyValue: () => ({}),
         configPath: (paths) => paths.copilotVscodeHooks,
         detect: async (paths) => pathExists(paths.copilotVscodeHooks),
         executable: async () => commandExists("code"),
-        merge: (input, paths) => mergeLoreCopilotVscodeHooks(objectConfiguration(input, "copilot-vscode"), paths),
+        merge: (input, paths, capture) => mergeLoreCopilotVscodeHooks(objectConfiguration(input, "copilot-vscode"), paths, capture),
         remove: (input) => removeLoreCopilotVscodeHooks(objectConfiguration(input, "copilot-vscode")),
         count: (input) => countLoreCopilotVscodeHooks(objectConfiguration(input, "copilot-vscode")),
     },
     cursor: {
         integration: "hooks",
-        expected: CURSOR_HOOK_EVENTS.length + 1,
+        // Hooks, the capture bridge, and the Lore MCP server entry.
+        expected: (capture) => installedEvents(CURSOR_HOOK_EVENTS, capture).length + 2,
         runtimeRequired: true,
         emptyValue: () => ({}),
         configPath: (paths) => paths.cursorHooks,
         detect: async (paths) => (await cursorAvailable(paths)) || pathExists(paths.cursorHooks),
         executable: cursorAvailable,
-        merge: (input, paths) => mergeLoreCursorHooks(objectConfiguration(input, "cursor"), paths),
+        merge: (input, paths, capture) => mergeLoreCursorHooks(objectConfiguration(input, "cursor"), paths, capture),
         remove: (input) => removeLoreCursorHooks(objectConfiguration(input, "cursor")),
         count: (input) => countLoreCursorHooks(objectConfiguration(input, "cursor")),
     },
     opencode: {
         integration: "plugin",
-        expected: 1,
+        // The plugin entry plus the Lore MCP server entry, both in opencode.json.
+        expected: () => 2,
         runtimeRequired: false,
         emptyValue: () => ({}),
         configPath: (paths) => paths.openCodeConfig,
         detect: async (paths) => (await commandExists("opencode")) || pathExists(paths.openCodeConfig),
         executable: async () => commandExists("opencode"),
-        merge: (input) => mergeLoreOpenCodePlugin(objectConfiguration(input, "opencode")),
-        remove: (input) => removeLoreOpenCodePlugin(objectConfiguration(input, "opencode")),
-        count: (input) => countLoreOpenCodePlugins(objectConfiguration(input, "opencode")),
+        merge: (input, paths) => mergeLoreOpenCodeMcp(mergeLoreOpenCodePlugin(objectConfiguration(input, "opencode")), loreMcpServer(paths, "opencode")),
+        remove: (input) => removeLoreOpenCodeMcp(removeLoreOpenCodePlugin(objectConfiguration(input, "opencode"))),
+        count: (input) => countLoreOpenCodePlugins(objectConfiguration(input, "opencode")) + countLoreOpenCodeMcp(objectConfiguration(input, "opencode")),
     },
     polytoken: {
         integration: "hooks",
-        expected: POLYTOKEN_HOOK_EVENTS.length,
+        expected: (capture) => installedEvents(POLYTOKEN_HOOK_EVENTS, capture).length,
         runtimeRequired: true,
         emptyValue: () => [],
         configPath: (paths) => paths.polytokenHooks,
@@ -1400,7 +1559,7 @@ async function readT3CodeProviderInstallations(paths) {
 }
 async function expandConnectInstallations(requested, paths) {
     const direct = requested.flatMap((agent) => {
-        if (isCredentialOnlyAgent(agent) || agent === "t3code") {
+        if (isCredentialOnlyAgent(agent) || agent === "t3code" || agent === GENERIC_AGENT) {
             return [];
         }
         return [
@@ -1433,6 +1592,7 @@ async function installRuntime(paths) {
             rm(paths.runtime, { force: true }),
             rm(paths.runtimeRepository, { force: true }),
             rm(resolve(dirname(paths.runtime), "repository-address.js"), { force: true }),
+            rm(resolve(dirname(paths.runtime), "capture-policy.js"), { force: true }),
             rm(resolve(dirname(paths.runtime), "directory-policy.js"), { force: true }),
             rm(paths.runtimeReliabilityStore, { force: true }),
             rm(resolve(dirname(paths.runtime), "windows-permissions.js"), { force: true }),
@@ -1491,6 +1651,8 @@ async function installRuntime(paths) {
         "skill-guidance.js": await readFile(resolve(sourceDirectory, "skill-guidance.js"), "utf8"),
         "repository.js": repository,
         "repository-address.js": await readFile(resolve(dirname(fileURLToPath(import.meta.resolve("@lore-co/core/repository-location"))), "repository-address.js"), "utf8"),
+        // directory-policy.js reads the live capture switches through this dependency-free module.
+        "capture-policy.js": await readFile(resolve(dirname(fileURLToPath(import.meta.resolve("@lore-co/core/local-scope"))), "capture-policy.js"), "utf8"),
         "directory-policy.js": (await readFile(fileURLToPath(import.meta.resolve("@lore-co/core/local-scope")), "utf8")).replaceAll("./repository-location.js", "./repository.js"),
         "reliability-store.js": reliabilityStore,
         "windows-permissions.js": await readFile(resolve(sourceDirectory, "windows-permissions.js"), "utf8"),
@@ -1524,6 +1686,7 @@ async function installRuntime(paths) {
         atomicWrite(resolve(dirname(paths.runtime), "skill-guidance.js"), runtimeFiles["skill-guidance.js"], 0o600),
         atomicWrite(paths.runtimeRepository, repository, 0o600),
         atomicWrite(resolve(dirname(paths.runtime), "repository-address.js"), runtimeFiles["repository-address.js"], 0o600),
+        atomicWrite(resolve(dirname(paths.runtime), "capture-policy.js"), runtimeFiles["capture-policy.js"], 0o600),
         atomicWrite(resolve(dirname(paths.runtime), "directory-policy.js"), runtimeFiles["directory-policy.js"], 0o600),
         atomicWrite(paths.runtimeReliabilityStore, reliabilityStore, 0o600),
         atomicWrite(resolve(dirname(paths.runtime), "windows-permissions.js"), runtimeFiles["windows-permissions.js"], 0o600),
@@ -1541,13 +1704,109 @@ async function installRuntime(paths) {
 function agentConfigPath(agent, paths) {
     return targetFor(agent).configPath(paths);
 }
-function mergeAgentConfig(input, agent, paths) {
+function mergeAgentConfig(input, agent, paths, capture) {
     const target = targetFor(agent);
-    return target.merge(input === undefined ? target.emptyValue() : input, paths);
+    return target.merge(input === undefined ? target.emptyValue() : input, paths, capture);
 }
 function removeAgentConfig(input, agent) {
     return targetFor(agent).remove(input);
 }
+/**
+ * Read each installation's hooks file and, for MCP hosts, its MCP config, and
+ * merge the Lore entries this CLI version writes. Nothing touches disk yet.
+ */
+async function prepareAgentEntries(installations, paths, capture) {
+    const documents = new Map();
+    const mergedDocuments = new Map();
+    const mcpDocuments = new Map();
+    for (const installation of installations) {
+        const key = installationKey(installation);
+        const document = await readJsonDocument(installation.configPath);
+        documents.set(key, document);
+        mergedDocuments.set(key, mergeAgentConfig(document.value, installation.agent, paths, capture));
+        if (isMcpHostAgent(installation.agent)) {
+            const mcpPath = mcpConfigPath(installation.agent, installation.configPath);
+            if (installation.agent === "codex") {
+                const text = await readTextDocument(mcpPath);
+                mcpDocuments.set(mcpPath, { kind: "text", document: text, merged: mergeLoreCodexMcp(text.value, loreMcpServer(paths, "codex")) });
+            }
+            else {
+                const mcp = await readJsonDocument(mcpPath);
+                const base = mcp.exists ? mcp.value : {};
+                // Cursor keeps its capture bridge next to the shared tool server.
+                const withBridge = installation.agent === "cursor" ? mergeLoreCursorMcp(base, paths) : base;
+                mcpDocuments.set(mcpPath, { kind: "json", document: mcp, merged: mergeLoreMcp(withBridge, installation.agent, paths) });
+            }
+        }
+    }
+    return { installations: [...installations], documents, mergedDocuments, mcpDocuments };
+}
+/**
+ * Install the hook runtime when an installation needs it, then write the
+ * merged files. Unchanged files are left alone; changed ones get a backup.
+ */
+async function writeAgentEntries(entries, paths, now) {
+    if (entries.installations.some((installation) => targetFor(installation.agent).runtimeRequired)) {
+        await installRuntime(paths);
+    }
+    const changedFiles = [];
+    const backups = [];
+    for (const [path, entry] of entries.mcpDocuments) {
+        const result = entry.kind === "json"
+            ? await writeMergedJson(path, entry.document, entry.merged, now)
+            : await writeMergedText(path, entry.document, entry.merged, now);
+        if (result.changed)
+            changedFiles.push(path);
+        if (result.backup)
+            backups.push(result.backup);
+    }
+    for (const installation of entries.installations) {
+        const key = installationKey(installation);
+        const document = entries.documents.get(key);
+        const merged = entries.mergedDocuments.get(key);
+        if (document === undefined || merged === undefined) {
+            continue;
+        }
+        const result = await writeMergedJson(installation.configPath, document, merged, now);
+        if (result.changed) {
+            changedFiles.push(installation.configPath);
+        }
+        if (result.backup !== undefined) {
+            backups.push(result.backup);
+        }
+    }
+    return { changedFiles, backups };
+}
+/**
+ * Re-apply the Lore-owned hook and MCP entries and the `lore` skill for the
+ * agents recorded in the stored connection, for example after `lore update`
+ * replaced the binary. Nothing is authorized again and folder rules are
+ * untouched. Resolves to null when no connection is stored.
+ */
+export async function refreshAgentEntries(paths = getLorePaths()) {
+    const config = await readConnectorConfig(paths);
+    if (config === null)
+        return null;
+    const installations = uniqueInstallations(configuredInstallations(config, paths));
+    return withDirectoryLock(resolve(paths.loreDirectory, "connections.lock"), async () => {
+        const entries = await prepareAgentEntries(installations, paths, captureEnabled(config));
+        const written = await writeAgentEntries(entries, paths, new Date());
+        const generic = (await readGenericAgents(paths.loreDirectory)).length > 0;
+        const skills = await installLoreSkill(paths, generic ? [...installations, { agent: GENERIC_AGENT, configPath: paths.config }] : installations);
+        const agent = await installLoreAgent(paths, installations);
+        return {
+            // Same order the files are written in, so the two update lines match.
+            configFiles: [
+                ...entries.mcpDocuments.keys(),
+                ...installations.map((installation) => installation.configPath),
+            ],
+            ...written,
+            skillFiles: skills.files,
+            agentFiles: agent.files,
+            warnings: [...skills.warnings, ...agent.warnings],
+        };
+    });
+}
 function countAgentIntegrations(input, agent) {
     const target = targetFor(agent);
     return target.count(input === undefined ? target.emptyValue() : input);
@@ -1595,6 +1854,14 @@ function parseConnectArguments(args) {
             parsed.recovery = false;
             continue;
         }
+        if (argument === "--no-capture") {
+            parsed.capture = false;
+            continue;
+        }
+        if (argument === "--capture") {
+            parsed.capture = true;
+            continue;
+        }
         if (argument === "--current-project") {
             parsed.currentProject = true;
             continue;
@@ -1607,6 +1874,10 @@ function parseConnectArguments(args) {
             parsed.allProjects = true;
             continue;
         }
+        if (argument === "--write") {
+            parsed.writeTools = true;
+            continue;
+        }
         if (argument !== "--repository" &&
             argument !== "--folder" &&
             argument !== "--name" &&
@@ -1614,6 +1885,7 @@ function parseConnectArguments(args) {
             argument !== "--dashboard-url" &&
             argument !== "--token" &&
             argument !== "--agent" &&
+            argument !== "--agent-id" &&
             argument !== "--fallback" &&
             argument !== "--timeout-ms") {
             throw new Error(`Unknown connect option: ${argument ?? ""}`);
@@ -1629,6 +1901,9 @@ function parseConnectArguments(args) {
         else if (argument === "--name") {
             parsed.connectionName = value;
         }
+        else if (argument === "--agent-id") {
+            parsed.agentId = parseGenericAgentId(value);
+        }
         else if (argument === "--fallback") {
             if (!isLaunchable(value))
                 throw new Error(`--fallback must be ${LAUNCHABLE_AGENTS.join(", ")}`);
@@ -1654,10 +1929,13 @@ function parseConnectArguments(args) {
             parsed.agents.push(value);
         }
         else {
-            throw new Error("--agent must be claude, codex, copilot, copilot-cli, copilot-vscode, cowork, cursor, devin, opencode, polytoken, or t3code");
+            throw new Error("--agent must be claude, codex, copilot, copilot-cli, copilot-vscode, cowork, cursor, devin, generic, opencode, polytoken, or t3code");
         }
     }
     validateConnectProjectOptions(parsed);
+    if ((parsed.agentId !== undefined || parsed.writeTools) && !parsed.agents.includes(GENERIC_AGENT)) {
+        throw new Error("--agent-id and --write apply to --agent generic.");
+    }
     if (parsed.login && parsed.token !== undefined) {
         throw new Error("--login and --token cannot be used together");
     }
@@ -1755,7 +2033,7 @@ async function connectWithCredentialLocked(options, identity) {
         ...new Set([
             ...requestedExpansion.installations.map((installation) => installation.agent),
             ...detectedAgents,
-            ...options.agents.filter((agent) => isCredentialOnlyAgent(agent) || agent === "t3code"),
+            ...options.agents.filter((agent) => isCredentialOnlyAgent(agent) || agent === "t3code" || agent === GENERIC_AGENT),
         ]),
     ].sort();
     const keptAgents = [
@@ -1769,24 +2047,17 @@ async function connectWithCredentialLocked(options, identity) {
     // Cowork and the Devin CLI read the saved credential from ~/.lore/config.json
     // and need no hooks, so they connect without a native agent installation.
     const credentialOnlyAgents = CREDENTIAL_ONLY_AGENTS.filter((agent) => options.agents.includes(agent));
-    if (agents.length === 0 && credentialOnlyAgents.length === 0) {
+    // An MCP-only agent has no hooks or settings Lore can edit; it gets the skills and a printed entry.
+    const genericAgent = options.agents.includes(GENERIC_AGENT) ? options.genericAgent ?? { id: GENERIC_AGENT, writeTools: false } : undefined;
+    if (agents.length === 0 && credentialOnlyAgents.length === 0 && genericAgent === undefined) {
         throw new Error("No Claude, Codex, Copilot CLI, Cursor, OpenCode, or Polytoken installation detected. Use --agent <name>; T3 Code users can use --agent t3code, and Devin CLI users --agent devin.");
     }
     const now = new Date();
-    const documents = new Map();
-    const mergedDocuments = new Map();
-    const cursorMcpDocuments = new Map();
-    for (const installation of installations) {
-        const key = installationKey(installation);
-        const document = await readJsonDocument(installation.configPath);
-        documents.set(key, document);
-        mergedDocuments.set(key, mergeAgentConfig(document.value, installation.agent, paths));
-        if (installation.agent === "cursor") {
-            const mcpPath = resolve(dirname(installation.configPath), "mcp.json");
-            const mcp = await readJsonDocument(mcpPath);
-            cursorMcpDocuments.set(mcpPath, { document: mcp, merged: mergeLoreCursorMcp(mcp.exists ? mcp.value : {}, paths) });
-        }
-    }
+    // Reconnecting without a capture option keeps the saved mode, like folder rules.
+    const capture = options.capture ?? captureEnabled(existing);
+    // Read and merge before anything is persisted so an unreadable agent file
+    // stops the run without a half-written connection.
+    const entries = await prepareAgentEntries(installations, paths, capture);
     const agentConfigPaths = {};
     for (const agent of agents) {
         agentConfigPaths[agent] = installations
@@ -1802,6 +2073,7 @@ async function connectWithCredentialLocked(options, identity) {
         token: token.trim(),
         agents,
         agentConfigPaths,
+        ...(capture ? {} : { capture: "off" }),
         connectedAt: connection.profiles.find(value => value.connectionId === connection.fields.connectionId)?.connectedAt ?? now.toISOString(),
         timeoutMs,
     };
@@ -1812,33 +2084,10 @@ async function connectWithCredentialLocked(options, identity) {
     await reliabilityStore.initialize();
     // Folder restrictions must be durable before any new hook can run.
     await persistConnection(paths, config, connection.profiles);
-    if (installations.some((installation) => targetFor(installation.agent).runtimeRequired)) {
-        await installRuntime(paths);
-    }
-    const changedHookFiles = [];
-    const backups = [];
-    for (const [path, { document, merged }] of cursorMcpDocuments) {
-        const result = await writeMergedJson(path, document, merged, now);
-        if (result.changed)
-            changedHookFiles.push(path);
-        if (result.backup)
-            backups.push(result.backup);
-    }
-    for (const installation of installations) {
-        const key = installationKey(installation);
-        const document = documents.get(key);
-        const merged = mergedDocuments.get(key);
-        if (document === undefined || merged === undefined) {
-            continue;
-        }
-        const result = await writeMergedJson(installation.configPath, document, merged, now);
-        if (result.changed) {
-            changedHookFiles.push(installation.configPath);
-        }
-        if (result.backup !== undefined) {
-            backups.push(result.backup);
-        }
-    }
+    const { changedFiles: changedHookFiles, backups } = await writeAgentEntries(entries, paths, now);
+    // The Devin wrapper and hook check the capture mode when they run, so stale
+    // Devin hooks record nothing; an unreadable Devin config must not fail connect.
+    changedHookFiles.push(...await refreshDevinHooks(paths.home, capture).catch(() => []));
     if (existing && !existing.connectionId && existing.apiUrl === apiUrl && existing.token === token) {
         await new ReliabilityStore(identity.workspaceId, { home: paths.home }).transferPendingTo(reliabilityStore);
         await reliabilityStore.migrateLegacyQueue(paths.queue);
@@ -1858,7 +2107,10 @@ async function connectWithCredentialLocked(options, identity) {
             .catch((error) => [`Host recovery setup: ${error.message}`]) : [];
     if (options.recovery === false)
         await disableRecovery(paths.home);
-    const skills = await installLoreSkill(paths, installations);
+    const skills = await installLoreSkill(paths, genericAgent ? [...installations, { agent: GENERIC_AGENT, configPath: paths.config }] : installations);
+    const loreAgent = await installLoreAgent(paths, installations);
+    if (genericAgent)
+        await recordGenericAgent(paths.loreDirectory, genericAgent, now);
     // An unchanged reconnect: same server, credential, and workspace, every
     // configured agent was already configured, and no agent file was rewritten.
     const alreadyConnected = existing !== null &&
@@ -1867,6 +2119,7 @@ async function connectWithCredentialLocked(options, identity) {
         existing.workspaceId === identity.workspaceId &&
         existing.connectionId === config.connectionId &&
         agents.every((agent) => existing.agents.includes(agent)) &&
+        captureEnabled(existing) === capture &&
         changedHookFiles.length === 0 &&
         JSON.stringify(existing.directories ?? null) === JSON.stringify(config.directories ?? null);
     // A Codex set up in this run gets the approval step in its next-step line;
@@ -1877,12 +2130,18 @@ async function connectWithCredentialLocked(options, identity) {
     const codexNeedsApproval = !installedAgents.includes("codex") &&
         changedHookFiles.some((path) => codexHookPaths.includes(path));
     return {
-        capture: { folders: config.directories?.include ?? null, excludedFolders: config.directories?.exclude ?? [] },
+        capture: { mode: capture ? "on" : "off", folders: config.directories?.include ?? null, excludedFolders: config.directories?.exclude ?? [] },
         skillFiles: skills.files,
+        agentFiles: loreAgent.files,
+        ...(genericAgent ? { genericAgent: {
+                ...genericAgent,
+                mcpServers: genericMcpServers(loreMcpInvocation(), paths.home, genericAgent).mcpServers,
+                instructions: genericInstructions(genericAgent.id, skills.files.filter((file) => file.startsWith(resolve(paths.home, ".agents", "skills")))),
+            } } : {}),
         connected: true,
         apiUrl: config.apiUrl,
         identity,
-        agents: [...agents, ...credentialOnlyAgents],
+        agents: [...agents, ...credentialOnlyAgents, ...(genericAgent ? [GENERIC_AGENT] : [])],
         installedAgents,
         keptAgents,
         alreadyConnected,
@@ -1891,7 +2150,7 @@ async function connectWithCredentialLocked(options, identity) {
         config: paths.config,
         changedHookFiles,
         backups,
-        warnings: [...skills.warnings, ...(connection.needsFolders ? [`Lore is off for ${config.connectionName} until you choose where to record. Reconnect with --folder <path> or --all-projects, or run lore config open --connection ${config.connectionName}.`] : []), ...requestedExpansion.warnings, ...hostRecoveryWarnings, ...(codexNeedsApproval
+        warnings: [...skills.warnings, ...loreAgent.warnings, ...(connection.needsFolders ? [`Lore is off for ${config.connectionName} until you choose where to record. Reconnect with --folder <path> or --all-projects, or run lore config open --connection ${config.connectionName}.`] : []), ...requestedExpansion.warnings, ...hostRecoveryWarnings, ...(codexNeedsApproval
                 ? ["Codex requires hook approval. Open /hooks in Codex and review any new or changed Lore hooks, then start a fresh session. Run lore doctor to verify approval and the first invocation."]
                 : [])],
         ...(recoveryNotice ? { recoveryNotice } : {}),
@@ -2024,11 +2283,11 @@ async function acknowledgeDeviceAuthorization(apiUrl, authorization) {
 export function connectNextStep(agent) {
     switch (agent) {
         case "claude":
-            return "Restart Claude Code.";
+            return "Restart Claude Code and allow the lore MCP server when it asks.";
         case "codex":
             return "Restart Codex, open /hooks, approve Lore's hooks, then start a fresh session.";
         case "cursor":
-            return "Restart Cursor and enable the lore-native MCP server (lore_context and lore_complete).";
+            return "Restart Cursor and enable the lore-native and lore MCP servers.";
         case "opencode":
             return "Restart OpenCode.";
         case "copilot":
@@ -2043,12 +2302,17 @@ export function connectNextStep(agent) {
         case "cowork":
         case "t3code":
             return "Restart your agent and complete a turn.";
+        case "generic":
+            return "Add the MCP entry below to your agent's MCP settings and the instructions to its AGENTS.md (or GEMINI.md or rules file), then restart it.";
     }
 }
 export function formatConnectResult(result) {
-    const captureSummary = result.capture.folders === null ? "all projects allowed by the workspace"
+    const folderSummary = result.capture.folders === null ? "all projects allowed by the workspace"
         : result.capture.folders.length ? result.capture.folders.join(", ") : "paused — choose folders with --folder <path>";
     const installed = result.installedAgents.join(", ");
+    const generic = result.genericAgent;
+    // With only an MCP agent connected, nothing on this machine records turns.
+    const nothingRecords = result.capture.mode === "off" || (generic !== undefined && result.agents.every((agent) => agent === GENERIC_AGENT));
     const lines = [
         result.alreadyConnected
             ? `Already connected to ${result.identity.workspaceName} for ${installed}; nothing changed.`
@@ -2056,14 +2320,32 @@ export function formatConnectResult(result) {
         ...(result.keptAgents.length ? [`kept: ${result.keptAgents.join(", ")}`] : []),
         `api_url: ${result.apiUrl}`,
         `config: ${result.config}`,
-        `capture: ${captureSummary}${result.capture.excludedFolders.length ? `; excluded: ${result.capture.excludedFolders.join(", ")}` : ""}`,
+        ...(result.capture.mode === "off" ? [`capture: ${captureSummary("off")}`] : []),
+        ...(generic ? [`capture for ${generic.id}: off; an MCP-only agent has no hooks, so Lore saves only what you ask it to`] : []),
+        `${nothingRecords ? "folders" : "capture"}: ${folderSummary}${result.capture.excludedFolders.length ? `; excluded: ${result.capture.excludedFolders.join(", ")}` : ""}`,
         ...result.installedAgents.map((agent) => `Next step for ${agent}: ${connectNextStep(agent)}`),
-        result.dashboardUrl === undefined
-            ? `Send one message in ${result.folder}, then run lore doctor to confirm recording.`
-            : `Send one message in ${result.folder}, then open ${result.dashboardUrl}/connect to confirm recording.`,
-        ...(result.skillFiles.length ? ["Choose lore in your agent’s skills to find knowledge or remember this session."] : []),
+        generic !== undefined && nothingRecords
+            ? `Ask your agent "Lore, has anything like this come up before?" in ${result.folder}, then run lore doctor.`
+            : result.capture.mode === "off"
+                ? `Send one message in ${result.folder}, then run lore doctor to confirm context delivery.`
+                : result.dashboardUrl === undefined
+                    ? `Send one message in ${result.folder}, then run lore doctor to confirm recording.`
+                    : `Send one message in ${result.folder}, then open ${result.dashboardUrl}/connect to confirm recording.`,
+        ...(result.skillFiles.length ? ["Choose lore in your agent’s skills to find knowledge or remember this session, or recap to write a session up by hand."] : []),
+        ...(result.agentFiles.length ? ["Delegate to the lore agent (\"use the lore agent to review my pending learnings\") for recall, proposal review, or a recap with a fresh context."] : []),
         ...(result.recoveryNotice ? [result.recoveryNotice] : []),
         ...result.warnings.map((warning) => `warning: ${warning}`),
+        ...(generic ? [
+            generic.writeTools
+                ? `Saves from ${generic.id} are proposals credited to ${generic.id}; review them in Learnings.`
+                : `${generic.id} can read Lore; it saves through the lore CLI. Reconnect with --write to let it save through MCP (saves stay proposals).`,
+            "",
+            `MCP entry for ${generic.id} (merge into its mcpServers settings):`,
+            JSON.stringify({ mcpServers: generic.mcpServers }, null, 2),
+            "",
+            "Instructions for AGENTS.md, GEMINI.md, or the agent's rules file:",
+            generic.instructions,
+        ] : []),
     ];
     return `${lines.join("\n")}\n`;
 }
@@ -2107,13 +2389,17 @@ async function connectCommand(args) {
     }
     const result = await connectWithCredential({
         ...capture,
+        ...(parsed.capture === undefined ? {} : { capture: parsed.capture }),
         ...(parsed.connectionName === undefined ? {} : { connectionName: parsed.connectionName }),
         ...(parsed.fallback === undefined ? {} : { fallback: parsed.fallback }),
-        recovery: parsed.recovery ?? true,
+        // Automatic recovery installs hooks for other agents on PATH; an MCP-only
+        // connection must not start recording them as a side effect.
+        recovery: parsed.recovery ?? !(parsed.agents.length > 0 && parsed.agents.every((agent) => agent === GENERIC_AGENT)),
         apiUrl,
         ...(dashboardUrl === undefined ? {} : { dashboardUrl }),
         token,
         agents: parsed.agents,
+        ...(parsed.agents.includes(GENERIC_AGENT) ? { genericAgent: { id: parsed.agentId ?? GENERIC_AGENT, writeTools: parsed.writeTools === true } } : {}),
         ...(parsed.timeoutMs === undefined ? {} : { timeoutMs: parsed.timeoutMs }),
     });
     if (authorization)
@@ -2235,6 +2521,7 @@ async function inspectRuntimeInstallation(required, paths) {
         "skill-guidance.js": resolve(dirname(paths.runtime), "skill-guidance.js"),
         "repository.js": paths.runtimeRepository,
         "repository-address.js": resolve(dirname(paths.runtime), "repository-address.js"),
+        "capture-policy.js": resolve(dirname(paths.runtime), "capture-policy.js"),
         "directory-policy.js": resolve(dirname(paths.runtime), "directory-policy.js"),
         "reliability-store.js": paths.runtimeReliabilityStore,
         "windows-permissions.js": resolve(dirname(paths.runtime), "windows-permissions.js"),
@@ -2349,14 +2636,31 @@ async function getAgentStatus(agent, config, paths, runtime) {
             existing += document.exists ? 1 : 0;
             units.push(...inspectInstallationUnits(document.value === undefined
                 ? target.emptyValue()
-                : document.value, agent, paths, index, configPaths.length));
-            if (agent === "cursor") {
-                const mcp = await readJsonDocument(resolve(dirname(path), "mcp.json"));
-                const value = isObject(mcp.value) && isObject(mcp.value.mcpServers) ? mcp.value.mcpServers[CURSOR_MCP_NAME] : undefined;
-                const owned = Number(isLoreCursorMcp(value));
-                installed += owned;
-                units.push({ id: installationUnitId("mcp", index, configPaths.length),
-                    state: installationUnitState(owned, Number(exactConfiguration(value, cursorMcpServer(paths)))) });
+                : document.value, agent, paths, index, configPaths.length, captureEnabled(config)));
+            if (isMcpHostAgent(agent)) {
+                const mcpPath = mcpConfigPath(agent, path);
+                if (agent === "codex") {
+                    const state = inspectCodexMcp((await readTextDocument(mcpPath)).value, loreMcpServer(paths, "codex"));
+                    installed += state.owned;
+                    units.push({ id: installationUnitId("mcp-tools", index, configPaths.length),
+                        state: installationUnitState(state.owned, Number(state.exact)) });
+                }
+                else {
+                    const mcp = await readJsonDocument(mcpPath);
+                    const servers = isObject(mcp.value) && isObject(mcp.value.mcpServers) ? mcp.value.mcpServers : {};
+                    if (agent === "cursor") {
+                        const bridge = servers[CURSOR_MCP_NAME];
+                        const owned = Number(isLoreCursorMcp(bridge));
+                        installed += owned;
+                        units.push({ id: installationUnitId("mcp", index, configPaths.length),
+                            state: installationUnitState(owned, Number(exactConfiguration(bridge, cursorMcpServer(paths)))) });
+                    }
+                    const value = agent === "copilot-vscode" ? loreVsCodeMcpServer(mcp.value) : servers[LORE_MCP_SERVER_NAME];
+                    const owned = Number(isLoreMcpServer(value));
+                    installed += owned;
+                    units.push({ id: installationUnitId("mcp-tools", index, configPaths.length),
+                        state: installationUnitState(owned, Number(exactConfiguration(value, loreMcpServer(paths, agent)))) });
+                }
             }
         }
         catch {
@@ -2377,7 +2681,7 @@ async function getAgentStatus(agent, config, paths, runtime) {
                 state: "not_required",
                 version: null,
             };
-    const expected = target.expected * configPaths.length;
+    const expected = target.expected(captureEnabled(config)) * configPaths.length;
     const exactUnits = units.filter((unit) => unit.state === "exact").length;
     const installationState = invalidConfiguration
         ? "invalid"
@@ -2440,13 +2744,17 @@ async function statusData(paths, cwd) {
     }
     const runtimeRequired = config?.agents.some((agent) => targetFor(agent).runtimeRequired) ?? false;
     const runtime = await inspectRuntimeInstallation(runtimeRequired, paths);
-    const [legacyQueuedTurns, reliability, agents] = await Promise.all([
+    const [legacyQueuedTurns, reliability, agents, switches] = await Promise.all([
         queueCount(paths),
         inspectReliabilityStore(config, paths),
         Promise.all(CONFIGURED_AGENT_NAMES.map(async (agent) => getAgentStatus(agent, config, paths, runtime))),
+        // Only a machine that records turns needs the dashboard switches.
+        captureEnabled(config) ? captureSwitches(config, paths.home, cwd) : CAPTURE_SWITCHES_UNCHECKED,
     ]);
     return {
         folderAccess: await checkDirectory(cwd, paths.home, config ?? undefined),
+        capture: captureEnabled(config) ? "on" : "off",
+        captureSwitches: switches,
         schemaVersion: "lore-cli-status-v1",
         integrationContractVersion: RELIABILITY_INTEGRATION_CONTRACT_VERSION,
         connected: config !== null,
@@ -2495,7 +2803,7 @@ async function statusCommand(args) {
         ? "-"
         : `${(value * 100).toFixed(1)}%`;
     const retrievalFailureLines = formatRetrievalFailureDiagnostics(data.reliability?.operational.retrieval);
-    writeResult(data, parsed.json, `connected: ${data.connected ? "yes" : "no"}\ncurrent_folder: ${data.folderAccess.allowed ? "allowed" : "off"} (${data.folderAccess.reason})\napi_url: ${data.apiUrl ?? "-"}\nconfig_mode: ${data.configMode ?? "-"}\nruntime: ${data.runtimeRequired ? (data.runtimeInstalled ? `installed (${data.runtimeVersion})` : data.runtimeVersion === null ? "missing" : `stale (${data.runtimeVersion})`) : "not required"}\ndurable_outbox: ${data.reliability?.outbox.total ?? 0} ready=${data.reliability?.outbox.ready ?? 0} auth_blocked=${data.reliability?.outbox.authBlocked ?? 0} dead=${data.reliability?.outbox.dead ?? 0}\noldest_capture: ${data.reliability?.outbox.oldestEnqueuedAt ?? "-"}\ncontext_snapshots: ${data.reliability?.cache.context ?? 0}\noldest_context_snapshot: ${data.reliability?.cache.oldestContextWrittenAt ?? "-"}\npolicy_snapshots: ${data.reliability?.cache.policy ?? 0}\nlocal_context_fallback_rate: ${metricRate(data.reliability?.operational.retrieval.fallbackRate)}\nlocal_guard_coverage: ${metricRate(data.reliability?.operational.guard.coverageRate)}\nlocal_guard_failures: ${data.reliability?.operational.guard.failures ?? 0}\nlocal_retrieval_failures: ${data.reliability?.operational.retrieval.failed ?? 0}\n${retrievalFailureLines}${data.reliabilityError === null ? "" : `reliability_error: ${data.reliabilityError}\n`}${agentLines}\n${externalSurfaceLines}\n`);
+    writeResult(data, parsed.json, `connected: ${data.connected ? "yes" : "no"}\ncurrent_folder: ${data.folderAccess.allowed ? "allowed" : "off"} (${data.folderAccess.reason})\ncapture: ${captureSummary(data.capture, data.captureSwitches)}\napi_url: ${data.apiUrl ?? "-"}\nconfig_mode: ${data.configMode ?? "-"}\nruntime: ${data.runtimeRequired ? (data.runtimeInstalled ? `installed (${data.runtimeVersion})` : data.runtimeVersion === null ? "missing" : `stale (${data.runtimeVersion})`) : "not required"}\ndurable_outbox: ${data.reliability?.outbox.total ?? 0} ready=${data.reliability?.outbox.ready ?? 0} auth_blocked=${data.reliability?.outbox.authBlocked ?? 0} dead=${data.reliability?.outbox.dead ?? 0}\noldest_capture: ${data.reliability?.outbox.oldestEnqueuedAt ?? "-"}\ncontext_snapshots: ${data.reliability?.cache.context ?? 0}\noldest_context_snapshot: ${data.reliability?.cache.oldestContextWrittenAt ?? "-"}\npolicy_snapshots: ${data.reliability?.cache.policy ?? 0}\nlocal_context_fallback_rate: ${metricRate(data.reliability?.operational.retrieval.fallbackRate)}\nlocal_guard_coverage: ${metricRate(data.reliability?.operational.guard.coverageRate)}\nlocal_guard_failures: ${data.reliability?.operational.guard.failures ?? 0}\nlocal_retrieval_failures: ${data.reliability?.operational.retrieval.failed ?? 0}\n${retrievalFailureLines}${data.reliabilityError === null ? "" : `reliability_error: ${data.reliabilityError}\n`}${agentLines}\n${externalSurfaceLines}\n`);
 }
 async function disconnectCommand(args) {
     const parsed = parseOutputArguments(args, DISCONNECT_HELP, "disconnect");
@@ -2518,15 +2826,29 @@ export async function disconnectInstallation(paths = getLorePaths(), preservePen
     ]);
     for (const installation of installations) {
         const path = installation.configPath;
-        if (installation.agent === "cursor") {
-            const mcpPath = resolve(dirname(path), "mcp.json");
-            const mcp = await readJsonDocument(mcpPath);
-            if (mcp.exists) {
-                const result = await writeMergedJson(mcpPath, mcp, removeLoreCursorMcp(mcp.value), now);
-                if (result.changed)
-                    changedHookFiles.push(mcpPath);
-                if (result.backup)
-                    backups.push(result.backup);
+        if (isMcpHostAgent(installation.agent)) {
+            const mcpPath = mcpConfigPath(installation.agent, path);
+            if (installation.agent === "codex") {
+                const text = await readTextDocument(mcpPath);
+                if (text.exists) {
+                    const result = await writeMergedText(mcpPath, text, removeLoreCodexMcp(text.value), now);
+                    if (result.changed)
+                        changedHookFiles.push(mcpPath);
+                    if (result.backup)
+                        backups.push(result.backup);
+                }
+            }
+            else {
+                const mcp = await readJsonDocument(mcpPath);
+                if (mcp.exists) {
+                    const withoutTools = removeLoreMcp(mcp.value, installation.agent);
+                    const cleaned = installation.agent === "cursor" ? removeLoreCursorMcp(withoutTools) : withoutTools;
+                    const result = await writeMergedJson(mcpPath, mcp, cleaned, now);
+                    if (result.changed)
+                        changedHookFiles.push(mcpPath);
+                    if (result.backup)
+                        backups.push(result.backup);
+                }
             }
         }
         const document = await readJsonDocument(path);
@@ -2541,13 +2863,16 @@ export async function disconnectInstallation(paths = getLorePaths(), preservePen
             backups.push(result.backup);
         }
     }
-    await removeLoreSkill(paths, installations);
+    await removeLoreSkill(paths, [...installations, { agent: GENERIC_AGENT, configPath: paths.config }]);
+    await removeLoreAgent(paths, installations);
+    await removeGenericAgents(paths.loreDirectory);
     await Promise.all([
         rm(paths.config, { force: true }),
         rm(resolve(paths.loreDirectory, "connections"), { recursive: true, force: true }),
         rm(paths.runtime, { force: true }),
         rm(paths.runtimeRepository, { force: true }),
         rm(resolve(dirname(paths.runtime), "repository-address.js"), { force: true }),
+        rm(resolve(dirname(paths.runtime), "capture-policy.js"), { force: true }),
         rm(resolve(dirname(paths.runtime), "directory-policy.js"), { force: true }),
         rm(paths.runtimeReliabilityStore, { force: true }),
         rm(paths.runtimeSignedSnapshot, { force: true }),
@@ -2573,6 +2898,47 @@ export async function disconnectInstallation(paths = getLorePaths(), preservePen
     ]);
     return { connected: false, changedHookFiles, backups };
 }
+const CAPTURE_SWITCHES_UNCHECKED = { pausedBy: null, checked: false, reason: "not connected" };
+async function captureSwitches(config, home, cwd) {
+    if (config === null)
+        return CAPTURE_SWITCHES_UNCHECKED;
+    const access = await checkLoreAccess(cwd, home, config);
+    // A folder outside the local rules never reaches the workspace policy.
+    if (access.failure !== undefined || !access.reason.startsWith("Repository"))
+        return { pausedBy: null, checked: false, reason: access.reason };
+    return { pausedBy: access.capturePausedBy ?? null, checked: true, reason: access.capturePausedBy ? capturePauseMessage(access.capturePausedBy) : "on" };
+}
+/** How the dashboard switches are resumed, for status and doctor wording. */
+function captureResumeHint(pausedBy) {
+    return pausedBy === "workspace"
+        ? "An owner or admin can resume it under Settings, Session capture."
+        : "Resume it under Settings, Session capture.";
+}
+/**
+ * The effective capture state for `lore capture status` and `lore status`:
+ * the machine's own choice, then the dashboard switch that pauses it, worded
+ * as `lore doctor` words it.
+ */
+export function captureSummary(capture, switches = CAPTURE_SWITCHES_UNCHECKED) {
+    if (capture === "off")
+        return "off by choice; context and guard active";
+    if (switches.pausedBy === null)
+        return "on; turns are recorded in allowed folders";
+    // "Capture paused by workspace setting" -> "on locally, paused by workspace setting"
+    return `on locally, ${capturePauseMessage(switches.pausedBy).replace(/^Capture p/u, "p")}; context and guard active`;
+}
+/** Retrieval-only mode and a paused switch are chosen configurations, never warnings. */
+export function captureModeCheck(capture, switches = CAPTURE_SWITCHES_UNCHECKED) {
+    return {
+        name: "capture-mode",
+        status: "ok",
+        detail: capture === "off"
+            ? "Capture off by choice; context and guard active. lore remember still saves what you choose. Run lore capture on to record turns again."
+            : switches.pausedBy !== null
+                ? `${capturePauseMessage(switches.pausedBy)}; context and guard active. Saved learnings and /recap still work. ${captureResumeHint(switches.pausedBy)}`
+                : "on: turns are recorded in allowed folders",
+    };
+}
 /**
  * Server-side queue health. Dead embedding jobs name the operator fix: once the
  * provider is repaired, `lore embeddings repair` retries them without waiting
@@ -2714,6 +3080,93 @@ async function verifyConnectedInstallation() {
     }
     return (await apiChecks(config)).every((check) => check.status !== "error");
 }
+function formatCaptureResult(result) {
+    const pausedBy = result.pausedBy ?? null;
+    const lines = [
+        `capture: ${captureSummary(result.capture, { ...CAPTURE_SWITCHES_UNCHECKED, pausedBy })}`,
+        ...(result.capture === "on" && pausedBy !== null ? [captureResumeHint(pausedBy)] : []),
+        ...(result.changed
+            ? [
+                `updated: ${result.configFiles.join(", ")}`,
+                result.capture === "on"
+                    ? "Restart your agents, then send one message and run lore doctor to confirm recording."
+                    : "Restart your agents. lore remember and the lore skill still save what you choose.",
+            ]
+            : []),
+    ];
+    return `${lines.join("\n")}\n`;
+}
+/** Switch retrieval-only mode and rewrite the agent hooks to match, without re-authorizing. */
+export async function setCaptureMode(capture, paths = getLorePaths()) {
+    const config = await readConnectorConfig(paths);
+    if (config === null)
+        throw new Error("Lore is not connected. Run lore connect.");
+    const current = captureEnabled(config) ? "on" : "off";
+    if (current === capture)
+        return { capture, changed: false, configFiles: [] };
+    await withDirectoryLock(resolve(paths.loreDirectory, "connections.lock"), async () => {
+        const { capture: _previous, ...rest } = config;
+        await atomicWriteJson(paths.config, { ...rest, ...(capture === "off" ? { capture } : {}) }, 65536);
+    });
+    const refreshed = await refreshAgentEntries(paths);
+    const devinFiles = await refreshDevinHooks(paths.home, capture === "on");
+    return { capture, changed: true, configFiles: [...refreshed?.configFiles ?? [], ...devinFiles] };
+}
+async function captureCommand(args) {
+    let mode;
+    let json = false;
+    for (const argument of args) {
+        if (argument === "--help" || argument === "-h") {
+            process.stdout.write(CAPTURE_HELP);
+            return;
+        }
+        if (argument === "--json") {
+            json = true;
+            continue;
+        }
+        if ((argument === "status" || argument === "on" || argument === "off") && mode === undefined) {
+            mode = argument;
+            continue;
+        }
+        throw new Error("Usage: lore capture [status|on|off] [--json]");
+    }
+    const paths = getLorePaths();
+    if (mode === undefined || mode === "status") {
+        const config = await readConnectorConfig(paths);
+        if (config === null)
+            throw new Error("Lore is not connected. Run lore connect.");
+        const capture = captureEnabled(config) ? "on" : "off";
+        // Same reading as lore status and lore doctor: the folder's connection and its dashboard switches.
+        const switches = capture === "on" ? await captureSwitches(await diagnosticConfig(paths, process.cwd()), paths.home, process.cwd()) : CAPTURE_SWITCHES_UNCHECKED;
+        const result = { capture, pausedBy: switches.pausedBy, changed: false, configFiles: [] };
+        writeResult(result, json, formatCaptureResult(result));
+        return;
+    }
+    const result = await setCaptureMode(mode, paths);
+    writeResult(result, json, formatCaptureResult(result));
+}
+/** MCP-only agents from `lore connect --agent generic`: their skills, and that nothing records them. */
+export async function genericAgentChecks(paths) {
+    const agents = await readGenericAgents(paths.loreDirectory);
+    if (agents.length === 0)
+        return [];
+    const skills = (await Promise.all(["lore", "recap"].map(async (name) => {
+        const file = resolve(paths.home, ".agents", "skills", name, "SKILL.md");
+        return await access(file).then(() => null, () => file);
+    }))).filter((file) => file !== null);
+    return agents.flatMap((agent) => [
+        {
+            name: `${agent.id}-mcp`,
+            status: "ok",
+            detail: `MCP only, ${agent.writeTools ? "read-write (saves are proposals credited to " + agent.id + ")" : "read-only (saves go through the lore CLI)"}. Capture off: no hooks, so this agent's turns are never recorded. Lore cannot inspect the agent's own MCP settings; ask it "Lore, has anything like this come up before?" to confirm.`,
+        },
+        {
+            name: `${agent.id}-skills`,
+            status: skills.length === 0 ? "ok" : "warning",
+            detail: skills.length === 0 ? resolve(paths.home, ".agents", "skills") : `missing ${skills.join(", ")}; run lore connect --agent generic --agent-id ${agent.id} again`,
+        },
+    ]);
+}
 async function doctorCommand(args) {
     const parsed = parseOutputArguments(args, DOCTOR_HELP, "doctor");
     if (parsed === null) {
@@ -2723,7 +3176,15 @@ async function doctorCommand(args) {
     const config = await diagnosticConfig(paths, process.cwd());
     const prunedDeadLetters = await pruneUnrecoverableDeadLetters(config, paths);
     const status = await statusData(paths, process.cwd());
-    const checks = [{ name: "capture-folder", status: status.folderAccess.allowed ? "ok" : "warning", detail: status.folderAccess.allowed ? status.folderAccess.reason : `Recording is off here: ${status.folderAccess.reason}. Run lore scope check <folder> to verify a selected folder.` }];
+    const checks = [
+        { name: "capture-folder", status: status.folderAccess.allowed ? "ok" : "warning", detail: status.folderAccess.allowed ? status.folderAccess.reason : `${status.capture === "off" ? "Lore" : "Recording"} is off here: ${status.folderAccess.reason}. Run lore scope check <folder> to verify a selected folder.` },
+        captureModeCheck(status.capture, status.captureSwitches),
+    ];
+    const genericChecks = await genericAgentChecks(paths);
+    // With only MCP agents connected there are no hooks, so nothing records turns.
+    if (genericChecks.length > 0 && !status.agents.some((agent) => agent.configured)) {
+        checks[1] = { name: "capture-mode", status: "ok", detail: "off: only MCP agents are connected, and they have no hooks; Lore saves only what you ask them to" };
+    }
     checks.push({
         name: "platform",
         status: platform() === "darwin" || platform() === "linux" || isWindows() ? "ok" : "error",
@@ -2805,6 +3266,7 @@ async function doctorCommand(args) {
             });
         }
     }
+    checks.push(...genericChecks);
     for (const surface of status.externalSurfaces) {
         checks.push({
             name: `${surface.surface}-capability`,
@@ -2892,6 +3354,9 @@ async function printCommandHelp(path) {
         case "doctor":
             process.stdout.write(DOCTOR_HELP);
             return;
+        case "capture":
+            process.stdout.write(CAPTURE_HELP);
+            return;
         case "embeddings":
             await runEmbeddingsCommand(args, null);
             return;
@@ -2907,9 +3372,15 @@ async function printCommandHelp(path) {
         case "ask":
             await runAskCommand(args, null);
             return;
+        case "chat":
+            await runChatCommand(args, null);
+            return;
         case "learnings":
             await runLearningsCommand(args, null);
             return;
+        case "review":
+            await runReviewCommand(args, null);
+            return;
         case "remember":
             await runRememberCommand(args, null);
             return;
@@ -2994,7 +3465,7 @@ async function executeCli(args = process.argv.slice(2)) {
     const helpIndex = args.findIndex((value, index) => index > 0 && (separator < 0 || index < separator) && (value === "--help" || value === "-h"));
     if (helpIndex > 0) {
         const subcommand = args[1];
-        const grouped = ["connect", "config", "embeddings", "guard", "recovery", "github", "devin", "host", "self-host", "scope"].includes(command ?? "");
+        const grouped = ["connect", "config", "capture", "embeddings", "guard", "recovery", "github", "devin", "host", "self-host", "scope", "review"].includes(command ?? "");
         await printCommandHelp([command, ...(grouped && subcommand && !subcommand.startsWith("-") ? [subcommand] : [])]);
         return;
     }
@@ -3007,7 +3478,7 @@ async function executeCli(args = process.argv.slice(2)) {
         return;
     }
     const commandArgs = args.slice(1);
-    if (["ask", "learnings", "remember", "share", "resume", "continue", "approach", "skill"].includes(command) && !(command === "skill" && commandArgs[0] === "discover")) {
+    if (["ask", "chat", "learnings", "review", "remember", "share", "resume", "continue", "approach", "skill"].includes(command) && !(command === "skill" && commandArgs[0] === "discover")) {
         const decision = await checkDirectory(process.cwd(), getLorePaths(["approach", "skill"].includes(command) ? process.env.LORE_HOME : undefined).home);
         if (!decision.allowed)
             throw new Error(`Lore is off in this folder. ${decision.reason}`);
@@ -3021,6 +3492,9 @@ async function executeCli(args = process.argv.slice(2)) {
         case "config":
             await runConfigCommand(commandArgs, getLorePaths().config);
             return;
+        case "capture":
+            await captureCommand(commandArgs);
+            return;
         case "scope": {
             if (commandArgs[0] !== "check" || commandArgs.length > 2)
                 throw new Error("Usage: lore scope check [folder]");
@@ -3047,9 +3521,15 @@ async function executeCli(args = process.argv.slice(2)) {
         case "ask":
             await runAskCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
             return;
+        case "chat":
+            await runChatCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
+            return;
         case "learnings":
             await runLearningsCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
             return;
+        case "review":
+            await runReviewCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
+            return;
         case "remember":
             await runRememberCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
             return;
@@ -3164,6 +3644,10 @@ async function executeCli(args = process.argv.slice(2)) {
         case "cursor-mcp":
             await (await import("./cursor-mcp.js")).runCursorMcpServer();
             return;
+        case "mcp":
+            // The full Lore MCP server, registered by connect for hook-based agents.
+            await (await import("@lore-co/mcp")).runStdioServer();
+            return;
         case "internal-health-write": {
             const encoded = commandArgs[0] ?? (await readInvocationHealthWriteInput());
             await runInvocationHealthWrite(encoded);