@lore-co/cli 0.2.26 → 0.2.28

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { parseDirectoryRules, checkDirectory, checkLoreAccess, capturePauseMessage } from "./directory-policy.js";
+import { parseDirectoryRules, checkDirectory, checkDirectoryRules, checkLoreAccess, checkWorkspaceRepository, capturePauseMessage, LORE_DISABLED_MESSAGE, loreDisabled } 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";
@@ -10,14 +10,15 @@ import { prepareConnection, persistConnection, listConnections } from "./connect
 import { connectionReferences, resolveLocalConnection } from "./directory-policy.js";
 import { atomicWriteJson, withDirectoryLock } from "./reliability-store.js";
 import { runConfigCommand } from "./config-command.js";
+import { contextHealthLine, serverBehindLine, staleFilesLine } from "./status-health.js";
 import { codexApprovalDetail, inspectCodexHookApproval } from "./codex-hook-approval.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 { CURSOR_LORE_DISABLE_ENV, 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, 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 { basename, dirname, resolve } from "node:path";
+import { basename, dirname, resolve, sep } from "node:path";
 import { homedir, hostname, platform } from "node:os";
 import { setTimeout as delay } from "node:timers/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -29,10 +30,13 @@ import { runChatCommand } from "./chat.js";
 import { runLearningsCommand } from "./learnings.js";
 import { runReviewCommand } from "./review.js";
 import { runEmbeddingsCommand } from "./embeddings.js";
+import { CAPTURE_REPAIR_HELP, runCaptureRepairCommand } from "./capture-repair.js";
 import { runRememberCommand } from "./remember.js";
-import { installLoreSkill, removeLoreSkill } from "./skills.js";
+import { runDraftsCommand } from "./drafts.js";
+import { installLoreSkill, loreSkillFiles, recapSkillFiles, 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 { installLoreAgent, loreAgentFiles, removeLoreAgent } from "./lore-agent.js";
+import { regularPath } from "./owned-files.js";
 import { runApproachCommand } from "./approach.js";
 import { runSkillCommand } from "./skill-command.js";
 import { runGuardCommand } from "./guard.js";
@@ -46,10 +50,12 @@ import { runDevinCommand } from "./devin.js";
 import { runHostCommand } from "./host.js";
 import { runDemoCommand } from "./demo.js";
 import { updateCommand } from "./update.js";
+import { Output, PLAIN_OUTPUT, detectOutputStyle, listText } from "./terminal-output.js";
 import { UNINSTALL_HELP, uninstallCommand } from "./uninstall.js";
 import { runSelfHostCommand } from "./self-host.js";
 import { ReliabilityStore, ReliabilityStoreError, integrationInvocationStateKey, } from "./reliability-store.js";
 import { IS_STANDALONE_BINARY, LORE_VERSION } from "./version.js";
+import { openNoFollow } from "@lore-co/core/no-follow";
 const LORE_OWNER_ARGUMENT = "--owner lore";
 export const LORE_OPENCODE_PLUGIN = "@lore-co/opencode";
 export const DEFAULT_HOSTED_API_URL = "https://api.uselore.co";
@@ -141,7 +147,8 @@ Options:
   --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)
+  --no-recovery        Disable automatic handoff setup (otherwise set up between the agents you connect)
+  --verbose             Also list the files written and the connection details
   --json                Print machine-readable output
   --help                Show this command's help
 
@@ -161,14 +168,18 @@ Examples:
   lore connect --token "$LORE_WORKSPACE_TOKEN" --agent cursor
 `;
 const STATUS_HELP = `lore status
-Show exact installation, declared capabilities, and last invocation health.
+Show whether Lore is connected, whether it records in this folder, and which agents have used it.
 
 Usage:
-  lore status [--json]
+  lore status [--verbose] [--json]
+
+Options:
+  --verbose  Also show installation, capture queue, cache, and Guard details
+  --json     Print every detail as JSON
 
 Examples:
   lore status
-  lore status --json
+  lore status --verbose
 `;
 const DOCTOR_HELP = `lore doctor
 Check local security, exact wiring, invocation health, binaries, and Lore health.
@@ -187,16 +198,26 @@ Usage:
   lore capture status [--json]
   lore capture off [--json]
   lore capture on [--json]
+  lore capture reminder off|on [--json]
+  lore capture repair [--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.
 
+While nothing is recorded, Lore asks your agent to suggest /recap once in a
+session where you confirm a decision. lore capture reminder off stops that.
+
+lore capture repair retries captures the server dead-lettered while its
+extraction provider was down. See lore help capture repair.
+
 Examples:
   lore capture off
   lore capture status
+  lore capture reminder off
   lore capture on
+  lore capture repair
 `;
 const DISCONNECT_HELP = `lore disconnect
 Remove Lore-owned hooks/plugin, credentials, runtime, and transient state.
@@ -317,17 +338,25 @@ function stripLoreFromEvent(value) {
     }
     return groups;
 }
+/**
+ * Seconds a host waits for a Lore hook before stopping it. On Windows each
+ * hook starts PowerShell and lore.exe, and a reply hook took 3.6 s on
+ * windows-latest, so the 2 and 3 second limits would drop the capture there.
+ */
+function hookTimeout(seconds) {
+    return isWindows() ? Math.max(seconds, 10) : seconds;
+}
 function eventHandler(agent, event, paths) {
     return {
         type: "command",
         command: hookCommand(agent, paths),
-        timeout: event === "SessionEnd"
+        timeout: hookTimeout(event === "SessionEnd"
             ? 2
             : event === "Stop"
                 ? 3
                 : event === "PreToolUse"
                     ? 10
-                    : 25,
+                    : 25),
         ...(event === "UserPromptSubmit"
             ? { statusMessage: "Loading Lore context" }
             : {}),
@@ -410,13 +439,13 @@ function cursorEventHandler(event, paths) {
     return {
         type: "command",
         command: hookCommand("cursor", paths),
-        timeout: event === "sessionEnd"
+        timeout: hookTimeout(event === "sessionEnd"
             ? 2
             : event === "afterAgentResponse"
                 ? 3
                 : event === "beforeShellExecution"
                     ? 10
-                    : 25,
+                    : 25),
     };
 }
 const CURSOR_MCP_NAME = "lore-native";
@@ -424,7 +453,7 @@ function cursorMcpServer(paths) {
     return {
         type: "stdio", command: process.execPath,
         args: [...(IS_STANDALONE_BINARY ? [] : [fileURLToPath(import.meta.url)]), "cursor-mcp", "--owner", "lore"],
-        env: { LORE_HOME: paths.home },
+        env: { LORE_HOME: paths.home, ...CURSOR_LORE_DISABLE_ENV },
     };
 }
 function isLoreCursorMcp(value) {
@@ -480,6 +509,36 @@ export function mcpConfigPath(agent, hooksPath) {
             return resolve(directory, "..", "..", ".vscode", "mcp.json");
     }
 }
+/**
+ * The hooks and MCP files of an agent that keeps them inside a project, where
+ * a repository can commit them; null for agents configured in their own folders.
+ */
+function projectConfigFiles(installation) {
+    if (installation.agent !== "copilot-vscode")
+        return null;
+    return {
+        project: resolve(dirname(installation.configPath), "..", ".."),
+        files: [installation.configPath, mcpConfigPath(installation.agent, installation.configPath)],
+    };
+}
+/** The first project config file that is, or sits in a folder that is, a symlink. */
+async function linkedProjectConfigFile(installation, paths) {
+    const project = projectConfigFiles(installation);
+    if (project === null)
+        return null;
+    for (const file of project.files) {
+        // A link could point at any file of the user's, such as Lore's own token.
+        if (!await regularPath(file, paths.home, project.project))
+            return file;
+    }
+    return null;
+}
+async function assertProjectConfigNotLinked(installation, paths) {
+    const file = await linkedProjectConfigFile(installation, paths);
+    if (file !== null) {
+        throw new Error(`Refusing to edit ${file}: it or a folder above it in the project is a symlink. Replace the link with a regular file, then run this again.`);
+    }
+}
 export function mergeLoreMcp(input, agent, paths) {
     const config = objectConfiguration(input, agent);
     // VS Code keeps its servers under `servers`; the other JSON hosts use `mcpServers`.
@@ -563,13 +622,13 @@ function copilotCliEventHandler(event, paths) {
     return {
         type: "command",
         [isWindows() ? "powershell" : "bash"]: hookCommand("copilot-cli", paths, event),
-        timeoutSec: event === "sessionEnd"
+        timeoutSec: hookTimeout(event === "sessionEnd"
             ? 2
             : event === "agentStop"
                 ? 3
                 : event === "preToolUse"
                     ? 10
-                    : 25,
+                    : 25),
     };
 }
 function isLoreCopilotHook(value) {
@@ -659,13 +718,13 @@ function copilotVscodeEventHandler(event, paths) {
     return {
         type: "command",
         command: hookCommand("copilot-vscode", paths, event),
-        timeout: event === "SessionEnd"
+        timeout: hookTimeout(event === "SessionEnd"
             ? 2
             : event === "Stop"
                 ? 3
                 : event === "PreToolUse"
                     ? 10
-                    : 25,
+                    : 25),
     };
 }
 export function mergeLoreCopilotVscodeHooks(input, paths, capture = true) {
@@ -993,6 +1052,7 @@ async function readJsonDocument(path) {
         return {
             exists: true,
             value: parsed,
+            raw,
             mode: metadata.mode & 0o777,
         };
     }
@@ -1032,7 +1092,7 @@ async function writeMergedJson(path, document, value, now) {
     let backup;
     if (document.exists) {
         backup = `${path}.lore-backup-${backupTimestamp(now)}-${randomUUID().slice(0, 8)}`;
-        await copyFile(path, backup, fsConstants.COPYFILE_EXCL);
+        await writeFile(backup, document.raw ?? "", { flag: "wx", mode: document.mode });
     }
     await atomicWrite(path, `${JSON.stringify(value, null, 2)}\n`, document.mode);
     return {
@@ -1065,7 +1125,7 @@ async function writeMergedText(path, document, value, now) {
     let backup;
     if (document.exists) {
         backup = `${path}.lore-backup-${backupTimestamp(now)}-${randomUUID().slice(0, 8)}`;
-        await copyFile(path, backup, fsConstants.COPYFILE_EXCL);
+        await writeFile(backup, document.value, { flag: "wx", mode: document.mode });
     }
     await atomicWrite(path, value, document.mode);
     return {
@@ -1133,6 +1193,7 @@ function parseConnectorConfig(value) {
             ? {}
             : { agentConfigPaths }),
         ...(value.capture === "off" ? { capture: "off" } : {}),
+        ...(value.recapReminder === "off" ? { recapReminder: "off" } : {}),
         connectedAt: value.connectedAt,
         timeoutMs,
     };
@@ -1600,9 +1661,13 @@ async function installRuntime(paths) {
             rm(paths.runtimeCanonicalJson, { force: true }),
             rm(resolve(dirname(paths.runtime), "guard-evaluation.js"), { force: true }),
             rm(resolve(dirname(paths.runtime), "capture-conflict.js"), { force: true }),
+            rm(resolve(dirname(paths.runtime), "skill-context.js"), { force: true }),
+            rm(resolve(dirname(paths.runtime), "learning-line.js"), { force: true }),
             rm(resolve(dirname(paths.runtime), "image-bytes.js"), { force: true }),
             rm(resolve(dirname(paths.runtime), "image-capture.js"), { force: true }),
             rm(resolve(dirname(paths.runtime), "retained-context.js"), { force: true }),
+            rm(resolve(dirname(paths.runtime), "no-follow.js"), { force: true }),
+            rm(resolve(dirname(paths.runtime), "system-command.js"), { force: true }),
             rm(resolve(dirname(paths.runtime), "retrieval-task.js"), { force: true }),
             rm(resolve(dirname(paths.runtime), "runtime-redaction.js"), { force: true }),
             rm(resolve(dirname(paths.runtime), "user-message.js"), { force: true }),
@@ -1620,7 +1685,10 @@ async function installRuntime(paths) {
     const canonicalJsonModule = fileURLToPath(import.meta.resolve("@lore-co/core/canonical-json"));
     const guardEvaluation = await readFile(fileURLToPath(import.meta.resolve("@lore-co/core/guard-evaluation")), "utf8");
     const imageBytes = await readFile(fileURLToPath(import.meta.resolve("@lore-co/core/image-bytes")), "utf8");
-    const imageCapture = (await readFile(resolve(sourceDirectory, "image-capture.js"), "utf8")).replaceAll("@lore-co/core/image-bytes", "./image-bytes.js");
+    // Hook modules refuse symbolic links through this dependency-free module.
+    const noFollow = await readFile(fileURLToPath(import.meta.resolve("@lore-co/core/no-follow")), "utf8");
+    const localNoFollow = (source) => source.replaceAll("@lore-co/core/no-follow", "./no-follow.js");
+    const imageCapture = localNoFollow((await readFile(resolve(sourceDirectory, "image-capture.js"), "utf8")).replaceAll("@lore-co/core/image-bytes", "./image-bytes.js"));
     const [runtime, repository, reliabilityStore, signedSnapshot, canonicalJson, contextFallback, invocationHealthWriter,] = await Promise.all([
         readFile(resolve(sourceDirectory, "runtime.js"), "utf8"),
         readFile(fileURLToPath(import.meta.resolve("@lore-co/core/repository-location")), "utf8"),
@@ -1636,12 +1704,19 @@ async function installRuntime(paths) {
     }
     const runtimeVersion = `export const RUNTIME_VERSION = ${JSON.stringify(LORE_VERSION)};\n`;
     const runtimeFiles = {
-        "lore-hook.mjs": runtime.replaceAll("@lore-co/core/guard-evaluation", "./guard-evaluation.js").replaceAll("@lore-co/core/capture-conflict", "./capture-conflict.js"),
+        "lore-hook.mjs": runtime.replaceAll("@lore-co/core/guard-evaluation", "./guard-evaluation.js").replaceAll("@lore-co/core/capture-conflict", "./capture-conflict.js").replaceAll("@lore-co/core/learning-line", "./learning-line.js").replaceAll("@lore-co/core/skill-context", "./skill-context.js").replaceAll("@lore-co/core/system-command", "./system-command.js"),
         "guard-evaluation.js": guardEvaluation,
         "capture-conflict.js": await readFile(fileURLToPath(import.meta.resolve("@lore-co/core/capture-conflict")), "utf8"),
+        // Fits a redacted skill pack back within its cap; it has no imports.
+        "skill-context.js": await readFile(fileURLToPath(import.meta.resolve("@lore-co/core/skill-context")), "utf8"),
+        // Formats Guard items the way every integration does; imports only repository-address.js.
+        "learning-line.js": await readFile(fileURLToPath(import.meta.resolve("@lore-co/core/learning-line")), "utf8"),
         "image-bytes.js": imageBytes,
         "image-capture.js": imageCapture,
-        "retained-context.js": await readFile(resolve(sourceDirectory, "retained-context.js"), "utf8"),
+        "retained-context.js": localNoFollow(await readFile(resolve(sourceDirectory, "retained-context.js"), "utf8")),
+        "no-follow.js": noFollow,
+        // repository.js, directory-policy.js and the hook start git through this dependency-free module.
+        "system-command.js": await readFile(fileURLToPath(import.meta.resolve("@lore-co/core/system-command")), "utf8"),
         "retrieval-task.js": (await readFile(resolve(sourceDirectory, "retrieval-task.js"), "utf8")).replaceAll("@lore-co/core/user-message", "./user-message.js"),
         "runtime-redaction.js": await readFile(resolve(sourceDirectory, "runtime-redaction.js"), "utf8"),
         "user-message.js": await readFile(fileURLToPath(import.meta.resolve("@lore-co/core/user-message")), "utf8"),
@@ -1675,9 +1750,13 @@ async function installRuntime(paths) {
     await Promise.all([
         atomicWrite(resolve(dirname(paths.runtime), "guard-evaluation.js"), guardEvaluation, 0o600),
         atomicWrite(resolve(dirname(paths.runtime), "capture-conflict.js"), runtimeFiles["capture-conflict.js"], 0o600),
+        atomicWrite(resolve(dirname(paths.runtime), "skill-context.js"), runtimeFiles["skill-context.js"], 0o600),
+        atomicWrite(resolve(dirname(paths.runtime), "learning-line.js"), runtimeFiles["learning-line.js"], 0o600),
         atomicWrite(resolve(dirname(paths.runtime), "image-bytes.js"), imageBytes, 0o600),
         atomicWrite(resolve(dirname(paths.runtime), "image-capture.js"), imageCapture, 0o600),
         atomicWrite(resolve(dirname(paths.runtime), "retained-context.js"), runtimeFiles["retained-context.js"], 0o600),
+        atomicWrite(resolve(dirname(paths.runtime), "no-follow.js"), noFollow, 0o600),
+        atomicWrite(resolve(dirname(paths.runtime), "system-command.js"), runtimeFiles["system-command.js"], 0o600),
         atomicWrite(resolve(dirname(paths.runtime), "retrieval-task.js"), runtimeFiles["retrieval-task.js"], 0o600),
         atomicWrite(resolve(dirname(paths.runtime), "runtime-redaction.js"), runtimeFiles["runtime-redaction.js"], 0o600),
         atomicWrite(resolve(dirname(paths.runtime), "user-message.js"), runtimeFiles["user-message.js"], 0o600),
@@ -1721,6 +1800,7 @@ async function prepareAgentEntries(installations, paths, capture) {
     const mcpDocuments = new Map();
     for (const installation of installations) {
         const key = installationKey(installation);
+        await assertProjectConfigNotLinked(installation, paths);
         const document = await readJsonDocument(installation.configPath);
         documents.set(key, document);
         mergedDocuments.set(key, mergeAgentConfig(document.value, installation.agent, paths, capture));
@@ -1794,7 +1874,24 @@ export async function refreshAgentEntries(paths = getLorePaths()) {
         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);
+        const changed = new Set([...written.changedFiles, ...skills.changed, ...agent.changed]);
+        const agents = new Map();
+        for (const installation of installations) {
+            // Every file this agent reads: hooks, MCP config, skills, and the Lore agent.
+            const files = [
+                installation.configPath,
+                ...(isMcpHostAgent(installation.agent) ? [mcpConfigPath(installation.agent, installation.configPath)] : []),
+                ...loreSkillFiles(paths, [installation]),
+                ...recapSkillFiles(paths, [installation]),
+                ...loreAgentFiles([installation]).map((entry) => entry.file),
+            ];
+            const entry = agents.get(installation.agent) ?? { agent: installation.agent, changed: false, hooksChanged: false };
+            entry.changed ||= files.some((file) => changed.has(file));
+            entry.hooksChanged ||= written.changedFiles.includes(installation.configPath);
+            agents.set(installation.agent, entry);
+        }
         return {
+            agents: [...agents.values()],
             // Same order the files are written in, so the two update lines match.
             configFiles: [
                 ...entries.mcpDocuments.keys(),
@@ -1809,6 +1906,35 @@ export async function refreshAgentEntries(paths = getLorePaths()) {
         };
     });
 }
+/**
+ * The refresh after `lore update`, by agent: which agents got new Lore files
+ * and what the customer must do, or that nothing changed. --verbose adds the
+ * per-file report.
+ */
+export function formatRefreshSummary(result, style = PLAIN_OUTPUT) {
+    const out = new Output(style);
+    const updated = result.agents.filter((entry) => entry.changed).map((entry) => agentDisplayName(entry.agent));
+    if (updated.length === 0)
+        out.note("Your agents are up to date.");
+    else
+        out.outcome("ok", `Updated Lore for ${listText([...new Set(updated)])}`);
+    if (result.warnings.length)
+        out.blank();
+    for (const warning of result.warnings)
+        out.outcome("warning", tildePaths(warning, style.home));
+    out.steps("Next", [
+        ...(updated.length ? ["Restart your agents."] : []),
+        ...(result.agents.some((entry) => entry.agent === "codex" && entry.hooksChanged) ? [`In Codex, approve Lore's updated hooks with ${out.code("/hooks")}.`] : []),
+    ]);
+    if (style.verbose) {
+        out.blank().verbatim(out.bold("Details"));
+        for (const line of formatRefreshReport(result).trimEnd().split("\n")) {
+            if (!line.startsWith("warning: "))
+                out.text(tildePaths(line, style.home));
+        }
+    }
+    return out.toString();
+}
 /** What a refresh rewrote and what was already at this version, one line each. */
 export function formatRefreshReport(result) {
     const lines = [
@@ -1837,9 +1963,11 @@ export function formatRefreshReport(result) {
 async function runInternalCommand(args) {
     if (args.length !== 1 || args[0] !== "refresh-integrations")
         throw new Error("Usage: lore internal refresh-integrations");
-    const refreshed = await refreshAgentEntries(getLorePaths());
+    const paths = getLorePaths();
+    const refreshed = await refreshAgentEntries(paths);
+    // `lore update` runs this with piped stdout and says how to draw through LORE_OUTPUT_*.
     if (refreshed !== null)
-        process.stdout.write(formatRefreshReport(refreshed));
+        process.stdout.write(formatRefreshSummary(refreshed, detectOutputStyle({ home: paths.home })));
 }
 function countAgentIntegrations(input, agent) {
     const target = targetFor(agent);
@@ -1876,6 +2004,10 @@ function parseConnectArguments(args) {
             parsed.json = true;
             continue;
         }
+        if (argument === "--verbose") {
+            parsed.verbose = true;
+            continue;
+        }
         if (argument === "--login") {
             parsed.login = true;
             continue;
@@ -2040,9 +2172,13 @@ async function connectWithCredentialLocked(options, identity) {
     const recoveryEnv = options.home === undefined ? process.env : { ...process.env, ZDOTDIR: paths.home };
     let recoveryWarning;
     const externalRecoveryHost = options.agents.some(agent => ["t3code", "cowork", "copilot-vscode"].includes(agent));
+    // Named agents limit recovery to themselves; auto-detection already installs every detected agent.
+    const namedRecoveryAgents = options.agents.length === 0 ? undefined
+        : options.agents.map(agent => agent === "copilot" ? "copilot-cli" : agent);
+    const namedSources = namedRecoveryAgents?.filter((agent) => isRecoverySource(agent) && agent !== options.fallback);
     const installRecovery = options.fallback === undefined ? options.recovery === true ?
-        await prepareAutomaticRecovery(paths, recoveryEnv).catch((error) => { recoveryWarning = `Automatic recovery setup: ${error.message}`; return undefined; }) : undefined :
-        await prepareRecoveryInstallation(paths, options.fallback, recoveryEnv).catch((error) => {
+        await prepareAutomaticRecovery(paths, recoveryEnv, namedRecoveryAgents).catch((error) => { recoveryWarning = `Automatic recovery setup: ${error.message}`; return undefined; }) : undefined :
+        await prepareRecoveryInstallation(paths, options.fallback, recoveryEnv, namedSources?.length ? namedSources : undefined).catch((error) => {
             // A desktop host can be the source even when only its destination is on PATH.
             if (externalRecoveryHost && error.message.startsWith("No supported source client is installed."))
                 return undefined;
@@ -2108,6 +2244,7 @@ async function connectWithCredentialLocked(options, identity) {
         agents,
         agentConfigPaths,
         ...(capture ? {} : { capture: "off" }),
+        ...(existing?.recapReminder === "off" ? { recapReminder: "off" } : {}),
         connectedAt: connection.profiles.find(value => value.connectionId === connection.fields.connectionId)?.connectedAt ?? now.toISOString(),
         timeoutMs,
     };
@@ -2180,16 +2317,36 @@ async function connectWithCredentialLocked(options, identity) {
         keptAgents,
         alreadyConnected,
         ...(knownDashboardUrl === undefined ? {} : { dashboardUrl: knownDashboardUrl }),
-        folder: options.cwd ?? process.cwd(),
+        folder: await firstMessageFolder(options.cwd ?? process.cwd(), config.directories, paths.home),
         config: paths.config,
         changedHookFiles,
         backups,
         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."]
+                ? [CODEX_APPROVAL_WARNING]
                 : [])],
         ...(recoveryNotice ? { recoveryNotice } : {}),
     };
 }
+/**
+ * The browser approval link, and whether Lore may open it: only a page on the
+ * dashboard (or, without one, the API server) the person chose. With a
+ * dashboard, only the server's path and query are kept; setting them rather
+ * than resolving a reference keeps a `//host` path on the dashboard.
+ */
+export function deviceApprovalUrl(verificationUriComplete, input) {
+    const server = new URL(verificationUriComplete);
+    const url = input.dashboardUrl === undefined ? server : new URL(`${input.dashboardUrl}/`);
+    if (input.dashboardUrl !== undefined) {
+        url.pathname = server.pathname;
+        url.search = server.search;
+    }
+    const expectedOrigin = new URL(input.dashboardUrl ?? input.apiUrl).origin;
+    return {
+        url: url.toString(),
+        trusted: ["http:", "https:"].includes(url.protocol) && url.origin === expectedOrigin,
+        expectedOrigin,
+    };
+}
 async function requestDeviceAuthorization(input) {
     let response;
     try {
@@ -2219,13 +2376,13 @@ async function requestDeviceAuthorization(input) {
     if (!authorization.success) {
         throw new Error("Lore returned an incompatible device authorization response.");
     }
-    const serverApprovalUrl = new URL(authorization.data.verificationUriComplete);
-    const approvalUrl = input.dashboardUrl === undefined
-        ? serverApprovalUrl.toString()
-        : new URL(`${serverApprovalUrl.pathname}${serverApprovalUrl.search}`, `${input.dashboardUrl}/`).toString();
-    process.stderr.write(`Approve Lore access with code ${authorization.data.userCode}:\n${approvalUrl}\n`);
-    if (input.openBrowser) {
-        openBrowser(approvalUrl);
+    const approval = deviceApprovalUrl(authorization.data.verificationUriComplete, input);
+    process.stderr.write(`Approve Lore access with code ${authorization.data.userCode}:\n${approval.url}\n`);
+    if (input.openBrowser && approval.trusted) {
+        openBrowser(approval.url);
+    }
+    else if (input.openBrowser) {
+        process.stderr.write(`Lore did not open your browser because this link is not on ${approval.expectedOrigin}. Open it yourself if you expected it, or pass --dashboard-url.\n`);
     }
     const expiresAt = Date.parse(authorization.data.expiresAt);
     const intervalMs = authorization.data.intervalSeconds * 1_000;
@@ -2340,48 +2497,182 @@ export function connectNextStep(agent) {
             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 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(", ");
+/** A folder Lore records in: the current one when it is inside the capture folders, else the first capture folder. */
+export async function firstMessageFolder(cwd, directories, home) {
+    const first = directories?.include[0];
+    if (first === undefined || (await checkDirectoryRules(directories, cwd, home)).allowed)
+        return cwd;
+    const expanded = first.startsWith("~/") || first.startsWith("~\\") ? resolve(home, first.slice(2)) : first;
+    const parts = resolve(expanded).split(sep);
+    const wildcard = parts.findIndex((part) => /[*?]/u.test(part));
+    return wildcard < 0 ? resolve(expanded) : parts.slice(0, wildcard).join(sep) || sep;
+}
+const CODEX_APPROVAL_WARNING = "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.";
+/** Product names for human output; --json keeps the agent ids. */
+export function agentDisplayName(agent) {
+    switch (agent) {
+        case "claude": return "Claude Code";
+        case "codex": return "Codex";
+        case "copilot":
+        case "copilot-cli": return "Copilot CLI";
+        case "copilot-vscode": return "Copilot in VS Code";
+        case "cursor": return "Cursor";
+        case "opencode": return "OpenCode";
+        case "polytoken": return "Polytoken";
+        case "devin": return "Devin CLI";
+        case "cowork": return "Claude Cowork";
+        case "t3code": return "T3 Code";
+        case "generic": return "MCP agent";
+    }
+}
+/** What one connected agent still needs, for its row in the connect summary. */
+function connectAgentNote(agent, out) {
+    switch (agent) {
+        case "claude": return "ready after restart, allow the lore server when asked";
+        case "codex": return `ready after restart, approve hooks with ${out.code("/hooks")}`;
+        case "cursor": return "ready after restart, enable lore-native and lore";
+        case "copilot-vscode": return "ready after you restart the VS Code session";
+        case "devin": return `run ${out.code("lore devin cli setup")}, then open a new terminal`;
+        case "generic": return "add the MCP entry and instructions below, then restart it";
+        default: return "ready after restart";
+    }
+}
+/**
+ * The human summary of a connect run: the outcome, where Lore records, one
+ * row per agent, and the numbered steps left for the customer. Paths and
+ * per-file detail appear with --verbose; --json prints the result itself.
+ */
+export function formatConnectResult(result, options = {}) {
+    const style = options.style ?? { ...PLAIN_OUTPUT, home: dirname(dirname(result.config)) };
+    const out = new Output(style);
     const generic = result.genericAgent;
+    const genericName = generic?.id ?? agentDisplayName("generic");
+    const name = (agent) => agent === GENERIC_AGENT ? genericName : agentDisplayName(agent);
     // 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.`
-            : `access authorized; installed: ${installed}`,
-        ...(result.keptAgents.length ? [`kept: ${result.keptAgents.join(", ")}`] : []),
-        `api_url: ${result.apiUrl}`,
-        `config: ${result.config}`,
-        ...(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)}`),
-        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.`
+    const pausedBy = result.capture.mode === "on" ? options.capturePausedBy ?? null : null;
+    const folders = result.capture.folders;
+    const shownFolders = folders === null ? "all projects the workspace allows"
+        : folders.length === 0 ? "no folders yet"
+            : listText(folders.length > 3 ? [...folders.slice(0, 2).map((folder) => out.path(folder)), `${folders.length - 2} more`] : folders.map((folder) => out.path(folder)));
+    const excluded = result.capture.excludedFolders.length ? `, except ${listText(result.capture.excludedFolders.map((folder) => out.path(folder)))}` : "";
+    const mode = generic !== undefined && nothingRecords && result.capture.mode === "on" ? "MCP only, saves what you ask"
+        : result.capture.mode === "off" ? "capture off"
+            : pausedBy === "workspace" ? "paused by workspace"
+                : pausedBy === "member" ? "paused by your setting"
+                    : "capture on";
+    const records = mode === "capture on";
+    out.outcome("ok", result.alreadyConnected
+        ? `Already connected to ${result.identity.workspaceName}, nothing changed`
+        : `Connected to ${result.identity.workspaceName}`);
+    out.note(`${records ? "Recording in" : "Lore runs in"} ${shownFolders}${excluded}${out.separator}${mode}`);
+    if (generic !== undefined && !nothingRecords)
+        out.note(`${generic.id} is MCP-only: Lore saves only what you ask it to.`);
+    // One row per agent: set up in this run first, then the ones kept as they were.
+    const rows = [];
+    const seen = new Set();
+    for (const [agent, mark, note] of [
+        ...result.installedAgents.map((agent) => [agent, out.mark("ok"), connectAgentNote(agent, out)]),
+        ...result.keptAgents.map((agent) => [agent, "", out.dim("already set up")]),
+    ]) {
+        if (seen.has(name(agent)))
+            continue;
+        seen.add(name(agent));
+        rows.push([name(agent), mark, note]);
+    }
+    if (rows.length) {
+        out.blank();
+        const width = Math.max(...rows.map(([label]) => label.length));
+        for (const [label, mark, note] of rows)
+            out.row(label, width, note, mark);
+    }
+    const steps = [];
+    const restart = result.installedAgents.filter((agent) => agent !== "devin" && agent !== GENERIC_AGENT);
+    if (restart.length) {
+        steps.push(restart.length === rows.length ? "Restart the agents above." : `Restart ${listText([...new Set(restart.map(name))])}.`);
+    }
+    if (result.installedAgents.includes("devin"))
+        steps.push(`Run ${out.code("lore devin cli setup")}, then open a new terminal.`);
+    if (generic !== undefined)
+        steps.push(`Add the MCP entry and instructions below to ${generic.id}, then restart it.`);
+    const warnings = result.warnings.filter((warning) => warning !== CODEX_APPROVAL_WARNING);
+    if (warnings.length !== result.warnings.length)
+        steps.push(`In Codex, approve Lore's updated hooks with ${out.code("/hooks")}.`);
+    const notes = [];
+    for (const line of result.recoveryNotice?.split("\n") ?? []) {
+        const shell = /^Open a new terminal or run: (.+)$/u.exec(line);
+        if (!result.recoveryNotice.startsWith("Recovery enabled:"))
+            warnings.push(line);
+        else if (shell)
+            steps.push(`Open a new terminal, or run ${out.code(shell[1])}.`);
+        else if (line.startsWith("Codex requires one-time approval")) {
+            if (!result.installedAgents.includes("codex"))
+                steps.push(`In Codex, approve Lore's hooks with ${out.code("/hooks")}.`);
+        }
+        else
+            notes.push(style.rich ? line : line.replaceAll("→", "->"));
+    }
+    const folder = out.path(result.folder);
+    const ask = "\"Lore, has anything like this come up before?\"";
+    if (folders === null || folders.length > 0) {
+        steps.push(generic !== undefined && nothingRecords
+            ? `In ${folder}, ask your agent ${ask}, then run ${out.code("lore doctor")}.`
+            : !records
+                ? `In ${folder}, ask your agent anything, then run ${out.code("lore doctor")} to check that context arrives.`
                 : 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`;
+                    ? `In ${folder}, ask your agent anything, then run ${out.code("lore doctor")} to confirm recording.`
+                    : `In ${folder}, ask your agent anything, then check ${out.code(`${result.dashboardUrl}/connect`)}.`);
+    }
+    if (notes.length)
+        out.blank();
+    for (const note of notes)
+        out.note(note);
+    if (warnings.length)
+        out.blank();
+    for (const warning of warnings)
+        out.outcome("warning", tildePaths(warning, style.home));
+    out.steps("Next", steps);
+    const recap = result.skillFiles.some((file) => basename(dirname(file)) === "recap");
+    if (result.skillFiles.length || result.agentFiles.length) {
+        out.blank().text(`Try: ${ask}${recap ? `${style.rich ? " · " : " or "}${out.code("/recap")} to save a session` : ""}`, 0);
+    }
+    if (style.verbose) {
+        const details = [
+            ["Workspace", `${result.identity.workspaceName} (${result.identity.workspaceId})`],
+            ["API", result.apiUrl],
+            ...(result.dashboardUrl === undefined ? [] : [["Dashboard", result.dashboardUrl]]),
+            ["Config", out.path(result.config)],
+            ["Capture", captureSummary(result.capture.mode, { ...CAPTURE_SWITCHES_UNCHECKED, pausedBy })],
+            ["Folders", folders === null ? "all projects allowed by the workspace" : folders.map((value) => out.path(value)).join(", ") || "none"],
+            ...(result.capture.excludedFolders.length ? [["Excluded", result.capture.excludedFolders.map((value) => out.path(value)).join(", ")]] : []),
+            ["Agents", result.agents.join(", ")],
+            ...(result.keptAgents.length ? [["Kept", result.keptAgents.join(", ")]] : []),
+            ["Changed", result.changedHookFiles.map((file) => out.path(file)).join(", ") || "nothing"],
+            ...(result.backups.length ? [["Backups", result.backups.map((file) => out.path(file)).join(", ")]] : []),
+            ...(result.skillFiles.length ? [["Skills", result.skillFiles.map((file) => out.path(file)).join(", ")]] : []),
+            ...(result.agentFiles.length ? [["Lore agent", result.agentFiles.map((file) => out.path(file)).join(", ")]] : []),
+        ];
+        out.blank().verbatim(out.bold("Details"));
+        const width = Math.max(...details.map(([label]) => label.length));
+        for (const [label, value] of details)
+            out.row(label, width, value);
+    }
+    if (generic !== undefined) {
+        out.blank().note(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).`, 0);
+        // Copied into the agent's own settings: printed exactly, never styled or wrapped.
+        out.blank().verbatim(`MCP entry for ${generic.id} (merge into its mcpServers settings):`)
+            .verbatim(JSON.stringify({ mcpServers: generic.mcpServers }, null, 2))
+            .blank().verbatim("Instructions for AGENTS.md, GEMINI.md, or the agent's rules file:")
+            .verbatim(generic.instructions);
+    }
+    return out.toString();
+}
+/** Show the home folder as ~ inside a message that names paths. */
+function tildePaths(text, home) {
+    const prefix = home.endsWith(sep) ? home : `${home}${sep}`;
+    return text.replaceAll(prefix, `~${sep}`);
 }
 async function connectCommand(args) {
     const parsed = parseConnectArguments(args);
@@ -2438,7 +2729,18 @@ async function connectCommand(args) {
     });
     if (authorization)
         await acknowledgeDeviceAuthorization(apiUrl, authorization);
-    writeResult(result, parsed.json, formatConnectResult(result));
+    if (parsed.json) {
+        writeResult(result, true, "");
+        return;
+    }
+    // The summary says when a dashboard switch pauses recording; the policy read is best-effort.
+    const capturePausedBy = result.capture.mode === "on"
+        ? (await checkWorkspaceRepository({ apiUrl: result.apiUrl, token, timeoutMs: parsed.timeoutMs ?? 2_500 }, undefined).catch(() => undefined))?.capturePausedBy ?? null
+        : null;
+    process.stdout.write(formatConnectResult(result, {
+        style: detectOutputStyle({ verbose: parsed.verbose === true, home: getLorePaths().home }),
+        capturePausedBy,
+    }));
 }
 async function queueCount(paths) {
     try {
@@ -2501,7 +2803,7 @@ async function inspectReliabilityStore(config, paths) {
 const MAX_RUNTIME_MODULE_BYTES = 2 * 1024 * 1024;
 const MAX_RUNTIME_MANIFEST_BYTES = 64 * 1024;
 async function readRuntimeFile(path, maxBytes, executable = false) {
-    const handle = await open(path, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+    const handle = await openNoFollow(path, fsConstants.O_RDONLY);
     try {
         const metadata = await handle.stat();
         if (!metadata.isFile() ||
@@ -2544,9 +2846,13 @@ async function inspectRuntimeInstallation(required, paths) {
         "lore-hook.mjs": paths.runtime,
         "guard-evaluation.js": resolve(dirname(paths.runtime), "guard-evaluation.js"),
         "capture-conflict.js": resolve(dirname(paths.runtime), "capture-conflict.js"),
+        "skill-context.js": resolve(dirname(paths.runtime), "skill-context.js"),
+        "learning-line.js": resolve(dirname(paths.runtime), "learning-line.js"),
         "image-bytes.js": resolve(dirname(paths.runtime), "image-bytes.js"),
         "image-capture.js": resolve(dirname(paths.runtime), "image-capture.js"),
         "retained-context.js": resolve(dirname(paths.runtime), "retained-context.js"),
+        "no-follow.js": resolve(dirname(paths.runtime), "no-follow.js"),
+        "system-command.js": resolve(dirname(paths.runtime), "system-command.js"),
         "retrieval-task.js": resolve(dirname(paths.runtime), "retrieval-task.js"),
         "runtime-redaction.js": resolve(dirname(paths.runtime), "runtime-redaction.js"),
         "user-message.js": resolve(dirname(paths.runtime), "user-message.js"),
@@ -2665,6 +2971,7 @@ async function getAgentStatus(agent, config, paths, runtime) {
     const units = [];
     for (const [index, path] of configPaths.entries()) {
         try {
+            await assertProjectConfigNotLinked({ agent, configPath: path }, paths);
             const document = await readJsonDocument(path);
             installed += countAgentIntegrations(document.value, agent);
             existing += document.exists ? 1 : 0;
@@ -2819,12 +3126,99 @@ function formatRetrievalFailureDiagnostics(retrieval) {
     return (`local_retrieval_failure_reasons: ${reasons.length === 0 ? "-" : reasons.join(" ")}\n` +
         `last_retrieval_failure: ${last === null ? "-" : `${last.reason} (${last.path} request, agent ${last.agent}, at ${last.at})`}\n`);
 }
+/**
+ * The plain lines at the top of `lore status`: live context over the last
+ * days on this machine, then a server behind this CLI and out-of-date Lore
+ * files, each only when true.
+ */
+function statusHealth(data, serverVersion) {
+    const context = data.reliability?.operational.retrieval.recent ?? null;
+    const staleFiles = [];
+    if (data.runtimeRequired && !data.runtimeInstalled && data.runtimeVersion !== null) {
+        staleFiles.push({ name: "Lore hooks", version: data.runtimeVersion === LORE_VERSION ? null : data.runtimeVersion });
+    }
+    for (const agent of data.agents) {
+        // Hook agents share the runtime above; a plugin carries its own copy.
+        if (agent.installation.runtime !== "stale" || targetFor(agent.agent).runtimeRequired)
+            continue;
+        staleFiles.push({ name: `${agentDisplayName(agent.agent)} plugin`, version: agent.installation.runtimeVersion });
+    }
+    const lines = [
+        contextHealthLine(context ?? undefined),
+        serverBehindLine(serverVersion, LORE_VERSION),
+        staleFilesLine(staleFiles),
+    ].filter((line) => line !== null);
+    return { context, serverVersion, staleFiles, lines };
+}
+/** The server's release, from the identity endpoint; null when unreachable. */
+async function connectedServerVersion(config) {
+    try {
+        const response = await fetch(`${config.apiUrl}/v1/workspace/identity`, {
+            headers: { accept: "application/json", authorization: `Bearer ${config.token}`, "x-lore-connection-identity": "1" },
+            signal: AbortSignal.timeout(Math.min(config.timeoutMs ?? 2_000, 2_000)),
+        });
+        if (!response.ok)
+            return null;
+        const parsed = WorkspaceIdentityResponseSchema.safeParse(await response.json());
+        return parsed.success ? parsed.data.server.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The default `lore status`: what someone needs to know, and the one next step. */
+export function statusSummary(data, healthLines, workspaceName) {
+    if (!data.connected)
+        return "Lore isn't connected on this machine.\nNext: lore connect --login\n";
+    const lines = [...healthLines, workspaceName ? `Connected to ${workspaceName}.` : "Connected."];
+    lines.push(!data.folderAccess.allowed
+        ? `This folder: Lore is off (${data.folderAccess.reason}).`
+        : data.capture === "off" ? "This folder: context and Guard on; recording off."
+            : data.captureSwitches.pausedBy !== null ? `This folder: context and Guard on; ${capturePauseMessage(data.captureSwitches.pausedBy).toLowerCase()}.`
+                : "This folder: recording on.");
+    const agents = data.agents.filter((agent) => agent.configured);
+    const day = (value) => value === null ? "" : new Date(value).toISOString().slice(0, 10);
+    let next = null;
+    if (agents.length > 0) {
+        const width = Math.max(...agents.map((agent) => agentDisplayName(agent.agent).length));
+        lines.push("Agents:");
+        for (const agent of agents) {
+            const broken = agent.installation.state !== "complete" || agent.invocationError !== null
+                || agent.invocation.state === "failed" || agent.invocation.state === "incomplete";
+            if (broken)
+                next ??= "lore doctor";
+            const state = agent.installation.state !== "complete" ? "setup incomplete"
+                : agent.invocationError !== null || agent.invocation.state === "failed" || agent.invocation.state === "incomplete" ? "last run failed"
+                    : agent.invocation.state === "successful" ? `last used ${day(agent.invocation.lastSuccessfulAt)}`
+                        : "not used yet";
+            lines.push(`  ${agentDisplayName(agent.agent).padEnd(width)}  ${state}`);
+        }
+    }
+    if (next !== null)
+        lines.push(`Next: ${next}`);
+    lines.push("Details: lore status --verbose");
+    return `${lines.join("\n")}\n`;
+}
 async function statusCommand(args) {
-    const parsed = parseOutputArguments(args, STATUS_HELP, "status");
+    const verbose = args.includes("--verbose");
+    const parsed = parseOutputArguments(args.filter((argument) => argument !== "--verbose"), STATUS_HELP, "status");
     if (parsed === null) {
         return;
     }
-    const data = await statusData(getLorePaths(), process.cwd());
+    const paths = getLorePaths();
+    const config = await diagnosticConfig(paths, process.cwd());
+    const [statusResult, serverVersion] = await Promise.all([
+        statusData(paths, process.cwd()),
+        config === null ? null : connectedServerVersion(config),
+    ]);
+    const health = statusHealth(statusResult, serverVersion);
+    const data = { ...statusResult, health };
+    if (!parsed.json && loreDisabled(process.env))
+        process.stdout.write(`${LORE_DISABLED_MESSAGE}\n`);
+    if (!parsed.json && !verbose) {
+        process.stdout.write(statusSummary(data, health.lines, config?.workspaceName));
+        return;
+    }
     if (!parsed.json && data.connection)
         process.stdout.write(`connection: ${data.connection}\n`);
     const agentLines = data.agents
@@ -2837,7 +3231,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})\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`);
+    writeResult(data, parsed.json, `${health.lines.map((line) => `${line}\n`).join("")}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");
@@ -2860,6 +3254,9 @@ export async function disconnectInstallation(paths = getLorePaths(), preservePen
     ]);
     for (const installation of installations) {
         const path = installation.configPath;
+        // Leave linked project files alone; disconnecting everything else still matters.
+        if (await linkedProjectConfigFile(installation, paths) !== null)
+            continue;
         if (isMcpHostAgent(installation.agent)) {
             const mcpPath = mcpConfigPath(installation.agent, path);
             if (installation.agent === "codex") {
@@ -2914,9 +3311,12 @@ export async function disconnectInstallation(paths = getLorePaths(), preservePen
         rm(paths.runtimeContextFallback, { force: true }),
         rm(resolve(dirname(paths.runtime), "guard-evaluation.js"), { force: true }),
         rm(resolve(dirname(paths.runtime), "capture-conflict.js"), { force: true }),
+        rm(resolve(dirname(paths.runtime), "skill-context.js"), { force: true }),
+        rm(resolve(dirname(paths.runtime), "learning-line.js"), { force: true }),
         rm(resolve(dirname(paths.runtime), "image-bytes.js"), { force: true }),
         rm(resolve(dirname(paths.runtime), "image-capture.js"), { force: true }),
         rm(resolve(dirname(paths.runtime), "retained-context.js"), { force: true }),
+        rm(resolve(dirname(paths.runtime), "no-follow.js"), { force: true }),
         rm(resolve(dirname(paths.runtime), "retrieval-task.js"), { force: true }),
         rm(resolve(dirname(paths.runtime), "runtime-redaction.js"), { force: true }),
         rm(resolve(dirname(paths.runtime), "user-message.js"), { force: true }),
@@ -2974,17 +3374,18 @@ export function captureModeCheck(capture, switches = CAPTURE_SWITCHES_UNCHECKED)
     };
 }
 /**
- * Server-side queue health. Dead embedding jobs name the operator fix: once the
- * provider is repaired, `lore embeddings repair` retries them without waiting
- * for the reconciler's backoff.
+ * Server-side queue health. Dead jobs name the operator fix: once the provider
+ * is repaired, `lore capture repair` and `lore embeddings repair` retry them
+ * without waiting for a new capture or the reconciler's backoff.
  */
 export function operationalMetricsCheck(metrics) {
     const captureBacklog = metrics.captureReplay.captureExtraction.pending +
         metrics.captureReplay.captureExtraction.running;
     const embeddingBacklog = metrics.captureReplay.memoryEmbedding.pending +
         metrics.captureReplay.memoryEmbedding.running;
+    const captureDeadLetters = metrics.captureReplay.captureExtraction.dead;
     const embeddingDeadLetters = metrics.captureReplay.memoryEmbedding.dead;
-    const deadLetters = metrics.captureReplay.captureExtraction.dead + embeddingDeadLetters;
+    const deadLetters = captureDeadLetters + embeddingDeadLetters;
     const detectedFailures = metrics.silentFailures.count +
         metrics.guard.failures +
         deadLetters;
@@ -2998,11 +3399,44 @@ export function operationalMetricsCheck(metrics) {
                 ? "warning"
                 : "ok",
         detail: `${detectedFailures} detected failure(s), ${captureBacklog} capture and ${embeddingBacklog} embedding job(s) in backlog; ${metrics.guard.latency.samples} Guard latency sample(s)` +
+            (captureDeadLetters > 0
+                ? `; ${captureDeadLetters} dead capture job(s): once the extraction provider is back, run lore capture repair`
+                : "") +
             (embeddingDeadLetters > 0
                 ? `; ${embeddingDeadLetters} dead embedding job(s): fix the embedding provider, then run lore embeddings repair`
                 : ""),
     };
 }
+export const SEMANTIC_SEARCH_WINDOW_DAYS = 7;
+const SEMANTIC_SEARCH_MINIMUM_ATTEMPTS = 10;
+/**
+ * Embedding failures over the last week. The server records `semantic_unavailable`
+ * only when embeddings are configured and the request failed, and `lexical_only`
+ * when none are configured, so a self-hosted server without an embedding key
+ * never warns. Context still arrives during an outage, so nothing else shows it.
+ */
+export function semanticSearchCheck(retrieval) {
+    const period = `in the last ${SEMANTIC_SEARCH_WINDOW_DAYS} days`;
+    const attempts = retrieval.hybrid + retrieval.semanticUnavailable;
+    const failed = retrieval.semanticUnavailable;
+    if (attempts >= SEMANTIC_SEARCH_MINIMUM_ATTEMPTS && failed * 2 > attempts) {
+        return {
+            name: "semantic-search",
+            status: "warning",
+            detail: `Most prompts ${period} got keyword-only context because embedding requests are failing (${failed} of ${attempts} failed). Check the server's embedding key and provider.`,
+        };
+    }
+    return {
+        name: "semantic-search",
+        status: "ok",
+        detail: attempts === 0
+            ? retrieval.lexicalOnly > 0
+                ? "keyword search only; embeddings are not configured on the server"
+                : `no prompts with context ${period}`
+            : `semantic search on ${retrieval.hybrid} of ${attempts} prompts ${period}` +
+                (failed > 0 ? `; ${failed} fell back to keywords` : ""),
+    };
+}
 /**
  * Local outbox health. Dead letters that can never be replayed (an old snapshot
  * format or a permanent rejection) are a note, not an error: replaying them
@@ -3079,28 +3513,41 @@ async function apiChecks(config) {
                 : detail,
         });
     }
-    try {
-        const response = await fetch(`${config.apiUrl}/v1/reliability/metrics`, {
-            headers: {
-                authorization: `Bearer ${config.token}`,
-                "user-agent": `lore-cli/${LORE_VERSION}`,
-            },
-            signal: AbortSignal.timeout(3_000),
-        });
-        if (!response.ok) {
-            throw new Error("Operational metrics request failed");
-        }
-        checks.push(operationalMetricsCheck(OperationalMetricsResponseSchema.parse(await response.json())));
-    }
-    catch {
-        checks.push({
+    const now = Date.now();
+    const [daily, weekly] = await Promise.allSettled([
+        // The server's default window is the last 24 hours.
+        operationalMetrics(config),
+        operationalMetrics(config, new Date(now - SEMANTIC_SEARCH_WINDOW_DAYS * 24 * 60 * 60_000)),
+    ]);
+    checks.push(daily.status === "fulfilled"
+        ? operationalMetricsCheck(daily.value)
+        : {
             name: "server-operational-metrics",
             status: "warning",
             detail: "authenticated operational metrics are unavailable",
         });
+    // Without the weekly metrics, the warning above already says they are unavailable.
+    if (weekly.status === "fulfilled") {
+        checks.push(semanticSearchCheck(weekly.value.retrieval));
     }
     return checks;
 }
+async function operationalMetrics(config, from) {
+    const url = new URL(`${config.apiUrl}/v1/reliability/metrics`);
+    if (from !== undefined)
+        url.searchParams.set("from", from.toISOString());
+    const response = await fetch(url, {
+        headers: {
+            authorization: `Bearer ${config.token}`,
+            "user-agent": `lore-cli/${LORE_VERSION}`,
+        },
+        signal: AbortSignal.timeout(3_000),
+    });
+    if (!response.ok) {
+        throw new Error("Operational metrics request failed");
+    }
+    return OperationalMetricsResponseSchema.parse(await response.json());
+}
 async function verifyConnectedInstallation() {
     const paths = getLorePaths();
     const config = await readConnectorConfig(paths);
@@ -3119,6 +3566,7 @@ function formatCaptureResult(result) {
     const lines = [
         `capture: ${captureSummary(result.capture, { ...CAPTURE_SWITCHES_UNCHECKED, pausedBy })}`,
         ...(result.capture === "on" && pausedBy !== null ? [captureResumeHint(pausedBy)] : []),
+        ...(result.recapReminder === undefined ? [] : [result.recapReminder === "on" ? "recap reminder: on; lore capture reminder off stops it" : "recap reminder: off"]),
         ...(result.changed
             ? [
                 `updated: ${result.configFiles.join(", ")}`,
@@ -3146,7 +3594,35 @@ export async function setCaptureMode(capture, paths = getLorePaths()) {
     const devinFiles = await refreshDevinHooks(paths.home, capture === "on");
     return { capture, changed: true, configFiles: [...refreshed?.configFiles ?? [], ...devinFiles] };
 }
+/** The once-per-session /recap reminder agents get while nothing is recorded. Hooks read it on each prompt. */
+export async function setRecapReminder(reminder, paths = getLorePaths()) {
+    const config = await readConnectorConfig(paths);
+    if (config === null)
+        throw new Error("Lore is not connected. Run lore connect.");
+    if ((config.recapReminder ?? "on") === reminder)
+        return { recapReminder: reminder, changed: false };
+    await withDirectoryLock(resolve(paths.loreDirectory, "connections.lock"), async () => {
+        const { recapReminder: _previous, ...rest } = config;
+        await atomicWriteJson(paths.config, { ...rest, ...(reminder === "off" ? { recapReminder: reminder } : {}) }, 65536);
+    });
+    return { recapReminder: reminder, changed: true };
+}
 async function captureCommand(args) {
+    if (args[0] === "repair") {
+        await runCaptureRepairCommand(args.slice(1), await readConnectorConfig(getLorePaths(), process.cwd()));
+        return;
+    }
+    if (args[0] === "reminder") {
+        const json = args.includes("--json");
+        const [reminder, ...extra] = args.slice(1).filter((argument) => argument !== "--json");
+        if ((reminder !== "on" && reminder !== "off") || extra.length > 0)
+            throw new Error("Usage: lore capture reminder off|on [--json]");
+        const result = await setRecapReminder(reminder);
+        writeResult(result, json, reminder === "on"
+            ? "recap reminder: on. While nothing is recorded, your agent suggests /recap once in a session where you confirm a decision.\n"
+            : "recap reminder: off. Your agent no longer suggests /recap; you can still run it any time.\n");
+        return;
+    }
     let mode;
     let json = false;
     for (const argument of args) {
@@ -3162,7 +3638,7 @@ async function captureCommand(args) {
             mode = argument;
             continue;
         }
-        throw new Error("Usage: lore capture [status|on|off] [--json]");
+        throw new Error("Usage: lore capture [status|on|off|reminder off|reminder on|repair] [--json]");
     }
     const paths = getLorePaths();
     if (mode === undefined || mode === "status") {
@@ -3172,7 +3648,8 @@ async function captureCommand(args) {
         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: [] };
+        const recorded = capture === "on" && switches.pausedBy === null;
+        const result = { capture, pausedBy: switches.pausedBy, ...(recorded ? {} : { recapReminder: config.recapReminder ?? "on" }), changed: false, configFiles: [] };
         writeResult(result, json, formatCaptureResult(result));
         return;
     }
@@ -3219,6 +3696,8 @@ async function doctorCommand(args) {
     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" };
     }
+    if (loreDisabled(process.env))
+        checks.unshift({ name: "lore-disable", status: "warning", detail: LORE_DISABLED_MESSAGE });
     checks.push({
         name: "platform",
         status: platform() === "darwin" || platform() === "linux" || isWindows() ? "ok" : "error",
@@ -3238,13 +3717,18 @@ async function doctorCommand(args) {
     checks.push({
         name: "config",
         status: config === null ? "error" : "ok",
-        detail: config === null ? `missing or invalid: ${paths.config}` : paths.config,
-    });
-    checks.push({
-        name: "config-permissions",
-        status: ["600", "private-acl"].includes(status.configMode ?? "") ? "ok" : "error",
-        detail: status.configMode ?? "missing",
+        detail: config === null ? `not connected (${paths.config} is missing or invalid). Run lore connect --login` : paths.config,
     });
+    // Without a config there is nothing to protect yet; the check above says what to do.
+    if (config !== null)
+        checks.push({
+            name: "config-permissions",
+            status: ["600", "private-acl"].includes(status.configMode ?? "") ? "ok" : "error",
+            detail: status.configMode ?? "missing",
+        });
+    // A fresh connection has not been used yet; that is expected for a day, not a problem.
+    const connectedAt = config === null ? Number.NaN : Date.parse(config.connectedAt);
+    const recentlyConnected = Number.isFinite(connectedAt) && Date.now() - connectedAt < 24 * 60 * 60 * 1000;
     if (status.runtimeRequired) {
         checks.push({
             name: "runtime",
@@ -3272,7 +3756,9 @@ async function doctorCommand(args) {
                     : agent.invocation.state === "failed" ||
                         agent.invocation.state === "incomplete"
                         ? "error"
-                        : "warning",
+                        : agent.invocation.state === "never_observed" && recentlyConnected
+                            ? "ok"
+                            : "warning",
             detail: agent.invocationError !== null
                 ? agent.invocationError === "runtime_version_mismatch"
                     ? `observed Lore ${agent.invocation.runtimeVersion}; expected ${LORE_VERSION}`
@@ -3284,7 +3770,9 @@ async function doctorCommand(args) {
                         : agent.invocation.state === "incomplete"
                             ? `last invocation did not complete (${agent.invocation.lastAttemptedAt})`
                             : agent.invocation.state === "never_observed"
-                                ? "installed, but no invocation has been observed yet"
+                                ? recentlyConnected
+                                    ? "installed, not used yet"
+                                    : `installed, but not used since connecting. Start a session in ${agentDisplayName(agent.agent)}, then run lore doctor again`
                                 : "invocation health is unavailable",
         });
         if (agent.agent === "codex" && agent.executable) {
@@ -3308,23 +3796,28 @@ async function doctorCommand(args) {
             detail: "surface-specific repository configuration; local installation is not claimed",
         });
     }
-    checks.push({
-        name: "reliability-store",
-        status: status.reliabilityError !== null
-            ? "error"
-            : status.reliability === null
-                ? "warning"
-                : "ok",
-        detail: status.reliabilityError ??
-            status.reliability?.directory ??
-            "not initialized",
-    });
+    if (config !== null)
+        checks.push({
+            name: "reliability-store",
+            status: status.reliabilityError !== null
+                ? "error"
+                : status.reliability === null
+                    ? "warning"
+                    : "ok",
+            detail: status.reliabilityError ??
+                status.reliability?.directory ??
+                "not initialized",
+        });
     if (status.reliability !== null) {
         checks.push(durableOutboxCheck(status.reliability.outbox, prunedDeadLetters));
+        // Keys are pinned on the first delivery, so an unused connection has none yet.
+        const unused = status.agents.every((agent) => !agent.configured || agent.invocation.state === "never_observed");
         checks.push({
             name: "verified-snapshot-cache",
-            status: status.reliability.trustKeys > 0 ? "ok" : "warning",
-            detail: `${status.reliability.cache.context} context, ${status.reliability.cache.policy} policy, ${status.reliability.trustKeys} pinned key(s)`,
+            status: status.reliability.trustKeys > 0 || unused ? "ok" : "warning",
+            detail: status.reliability.trustKeys === 0 && unused
+                ? "empty until the first prompt"
+                : `${status.reliability.cache.context} context, ${status.reliability.cache.policy} policy, ${status.reliability.trustKeys} pinned key(s)`,
         });
         const operational = status.reliability.operational;
         const detectedFailures = operational.guard.failures + operational.retrieval.failed;
@@ -3389,7 +3882,7 @@ async function printCommandHelp(path) {
             process.stdout.write(DOCTOR_HELP);
             return;
         case "capture":
-            process.stdout.write(CAPTURE_HELP);
+            process.stdout.write(topic.subcommand === "repair" ? CAPTURE_REPAIR_HELP : CAPTURE_HELP);
             return;
         case "embeddings":
             await runEmbeddingsCommand(args, null);
@@ -3418,6 +3911,9 @@ async function printCommandHelp(path) {
         case "remember":
             await runRememberCommand(args, null);
             return;
+        case "drafts":
+            await runDraftsCommand(args, null);
+            return;
         case "approach":
             await runApproachCommand(args, null);
             return;
@@ -3512,7 +4008,7 @@ async function executeCli(args = process.argv.slice(2)) {
         return;
     }
     const commandArgs = args.slice(1);
-    if (["ask", "chat", "learnings", "review", "remember", "share", "resume", "continue", "approach", "skill"].includes(command) && !(command === "skill" && commandArgs[0] === "discover")) {
+    if (["ask", "chat", "learnings", "review", "remember", "drafts", "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}`);
@@ -3567,15 +4063,20 @@ async function executeCli(args = process.argv.slice(2)) {
         case "remember":
             await runRememberCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
             return;
+        case "drafts":
+            await runDraftsCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
+            return;
         case "approach":
             await runApproachCommand(commandArgs, await readConnectorConfig(getLorePaths(process.env.LORE_HOME), process.cwd()));
             return;
         case "skill":
-            await runSkillCommand(commandArgs, commandArgs[0] === "discover" ? null : await readConnectorConfig(getLorePaths(process.env.LORE_HOME), process.cwd()));
+            await runSkillCommand(commandArgs, commandArgs[0] === "discover" ? null : await readConnectorConfig(getLorePaths(process.env.LORE_HOME), process.cwd()), getLorePaths(process.env.LORE_HOME).loreDirectory);
             return;
-        case "guard":
-            await runGuardCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()));
+        case "guard": {
+            const paths = getLorePaths();
+            await runGuardCommand(commandArgs, await readConnectorConfig(paths, process.cwd()), paths.home);
             return;
+        }
         case "resume":
             await runResumeCommand(commandArgs, await readConnectorConfig(getLorePaths(), process.cwd()), getLorePaths());
             return;