@lore-co/cli 0.2.26 → 0.2.27

package/dist/runtime.js

@@ -2,10 +2,13 @@ import { redactSecrets } from "./runtime-redaction.js";
 export { redactSecrets } from "./runtime-redaction.js";
 import { createHash, randomUUID } from "node:crypto";
 import { CAPTURE_CONFLICT_MESSAGES } from "@lore-co/core/capture-conflict";
-import { approachGuidance } from "./approach-guidance.js";
+import { guardItemLine } from "@lore-co/core/learning-line";
+import { fitSkillContext } from "@lore-co/core/skill-context";
+import { systemCommand } from "@lore-co/core/system-command";
+import { approachGuidance, approachWorkflowRequested } from "./approach-guidance.js";
 import { skillGuidance } from "./skill-guidance.js";
 import { retainedContextTexts, retainedReceiptIds, rememberDeliveredContext } from "./retained-context.js";
-import { clearRetrievalTask, resolveRetrievalTask } from "./retrieval-task.js";
+import { clearRetrievalTask, forgetUncapturedPromptText, resolveRetrievalTask, unsavedRetrievalTask } from "./retrieval-task.js";
 import { access, chmod, mkdir, readFile, stat, } from "node:fs/promises";
 import { constants as fsConstants, realpathSync } from "node:fs";
 import { execFile as execFileCallback } from "node:child_process";
@@ -16,10 +19,10 @@ import { promisify } from "node:util";
 import { boundedUtf8Text, defaultGitPushBranches, repositoryRemoteScope, repositoryScopeFromGitRoot, } from "./repository.js";
 import { ReliabilityStore, ReliabilityStoreError, atomicWriteJson as durableAtomicWriteJson, classifyRetryFailure, createIntegrationInvocationAttempt, durableUnlink, recordLocalGuardMetric, recordLocalRetrievalMetric, } from "./reliability-store.js";
 import { writeInvocationAttemptBounded, writeInvocationCompletionBounded, } from "./invocation-health-writer.js";
-import { SignedSnapshotError, verifySignedSnapshot, } from "./signed-snapshot.js";
+import { SignedSnapshotError, referencesSourceConversations, verifySignedSnapshot, } from "./signed-snapshot.js";
 import { CONTEXT_CACHE_MAX_STALE_MS, isContextTransportFailure, selectCachedContext, } from "./context-fallback.js";
 import { RUNTIME_VERSION } from "./runtime-version.js";
-import { checkLoreAccess, checkDirectory, checkWorkspaceRepository, readLocalConfig, resolveLocalConnection, bindLocalSession } from "./directory-policy.js";
+import { checkLoreAccess, checkDirectory, checkWorkspaceRepository, readLocalConfig, resolveLocalConnection, bindLocalSession, loreDisabled, RECAP_REMINDER } from "./directory-policy.js";
 import { capturePendingImages, enqueueEventImages, flushImageAttachment, hostMessageImages, rememberImageCapture } from "./image-capture.js";
 import { guardRepositoryOverride, guardRuleConflict, guardToolTrigger, supportedGuardRule, guardEmergencyCommand, emergencyOverrideApplies } from "@lore-co/core/guard-evaluation";
 const IS_STANDALONE_RUNTIME = typeof __LORE_STANDALONE__ === "boolean" && __LORE_STANDALONE__;
@@ -368,6 +371,7 @@ async function readRuntimeConfig(home, cwd) {
             agents,
             ...(timeoutMs === undefined ? {} : { timeoutMs }),
             capture: saved?.capture !== "off",
+            ...(saved?.recapReminder === "off" ? { recapReminder: false } : {}),
         };
     }
     catch {
@@ -479,7 +483,7 @@ async function repositoryScope(cwd, repository = repositoryRemoteScope) {
 }
 async function gitOutput(root, args) {
     try {
-        const result = await execFile("git", ["-C", root, ...args], {
+        const result = await execFile(systemCommand("git", { exclude: [root] }), ["-C", root, ...args], {
             encoding: "utf8",
             timeout: 500,
             maxBuffer: MAX_GIT_DIFF_BYTES * 2,
@@ -612,7 +616,11 @@ function createPromptObservationRequest(input, agent, sessionId, now, gitContext
         connector: "lore-cli",
         agent,
         sessionId,
-        eventId: deterministicUuid(`lore-prompt\0${agent}\0${sessionId}\0${promptId ?? idempotencyKey}`),
+        // Hosts keep one prompt or turn ID for messages queued while the agent is
+        // still working, so the ID alone does not identify a prompt. The key also
+        // covers the text: a repeated hook keeps its event and a queued message
+        // gets its own, instead of conflicting with the first one.
+        eventId: deterministicUuid(`lore-prompt\0${agent}\0${sessionId}\0${idempotencyKey}`),
         prompt: redactSecrets(prompt),
         ...(promptId === undefined ? {} : { promptId }),
         timestamp: now.toISOString(),
@@ -804,8 +812,10 @@ function deliveryFromResponse(value) {
         context: boundedContext(context),
         ...(typeof value.relatedContext === "string" ? { relatedContext: redactSecrets(value.relatedContext).slice(0, 2_500) }
             : isObject(value.context) && typeof value.context.relatedContext === "string" ? { relatedContext: redactSecrets(value.context.relatedContext).slice(0, 2_500) } : {}),
-        ...(typeof value.skillContext === "string" && value.skillContext.length <= 72_000 ? { skillContext: redactSecrets(value.skillContext) }
-            : isObject(value.context) && typeof value.context.skillContext === "string" && value.context.skillContext.length <= 72_000 ? { skillContext: redactSecrets(value.context.skillContext) } : {}),
+        ...(typeof value.skillContext === "string" ? { skillContext: fitSkillContext(redactSecrets(value.skillContext)) }
+            : isObject(value.context) && typeof value.context.skillContext === "string" ? { skillContext: fitSkillContext(redactSecrets(value.context.skillContext)) } : {}),
+        ...(typeof value.approachContext === "string" ? { approachContext: redactSecrets(value.approachContext).slice(0, 600) }
+            : isObject(value.context) && typeof value.context.approachContext === "string" ? { approachContext: redactSecrets(value.context.approachContext).slice(0, 600) } : {}),
         completeContext: context.length <= MAX_CONTEXT_CHARS,
         ...(receiptId === undefined ? {} : { receiptId }),
         learned,
@@ -918,6 +928,7 @@ function deliveryFromSignedContext(payload, expectedRequest) {
         context: payload.context,
         relatedContext: payload.relatedContext,
         skillContext: payload.skillContext,
+        approachContext: payload.approachContext,
         receipt: { id: payload.receiptId },
         memories: payload.memories,
         hits: payload.hits,
@@ -1180,6 +1191,7 @@ async function postTurn(config, request, fetchImplementation, store) {
         headers: {
             "x-lore-context": "related-work-v1",
             "x-lore-skills": "skills-v1",
+            "x-lore-approaches": "approaches-v1",
             accept: runtimeAccept(config),
             authorization: `Bearer ${config.token}`,
             "content-type": "application/json",
@@ -1249,11 +1261,13 @@ async function postTurn(config, request, fetchImplementation, store) {
             task: (request.task ?? request.currentUser.content).trim(),
         },
     });
-    await store
-        .writeContextSnapshot(request.eventId, {
-        compactJws: value.contextSnapshot,
-    })
-        .catch(() => undefined);
+    if (!referencesSourceConversations(payload)) {
+        await store
+            .writeContextSnapshot(request.eventId, {
+            compactJws: value.contextSnapshot,
+        })
+            .catch(() => undefined);
+    }
     return { ...delivery, reliability };
 }
 async function postPromptObservation(config, request, fetchImplementation, _store) {
@@ -1334,6 +1348,7 @@ async function getPromptContext(config, agent, sessionId, sourceEventId, prompt,
         headers: {
             "x-lore-context": "related-work-v1",
             "x-lore-skills": "skills-v1",
+            "x-lore-approaches": "approaches-v1",
             accept: runtimeAccept(config),
             authorization: `Bearer ${config.token}`,
             "content-type": "application/json",
@@ -1388,9 +1403,13 @@ async function getPromptContext(config, agent, sessionId, sourceEventId, prompt,
         };
     }
     const delivery = deliveryFromSignedContext(payload, deliveryRequest);
-    await store
-        .writeContextSnapshot(sourceEventId, { compactJws: value.snapshot })
-        .catch(() => undefined);
+    // The signed snapshot carries the request, prompt included, so capture off
+    // caches nothing. Offline fallback uses context cached while capture was on.
+    if (config.capture && !referencesSourceConversations(payload)) {
+        await store
+            .writeContextSnapshot(sourceEventId, { compactJws: value.snapshot })
+            .catch(() => undefined);
+    }
     return {
         ...delivery,
         reliability,
@@ -1437,8 +1456,9 @@ async function getCachedPromptContext(config, prompt, gitContext, store, now, re
                 now,
             }).payload;
             // Signed payloads cannot be redacted in place. Retire legacy snapshots
-            // containing raw request secrets and let a later live request replace them.
-            if (!hasRedactedContextRequest(payload)) {
+            // containing raw request secrets or source conversations and let a
+            // later live request replace them.
+            if (!hasRedactedContextRequest(payload) || referencesSourceConversations(payload)) {
                 await store.deleteContextSnapshot(record.cacheKey, value.compactJws);
                 continue;
             }
@@ -1740,7 +1760,7 @@ function receiptMessage(config, agent, delivery) {
         const path = delivery.receiptId === undefined
             ? learned === undefined
                 ? undefined
-                : `/memories/${encodeURIComponent(learned.id)}`
+                : `/learnings/${encodeURIComponent(learned.id)}`
             : `/receipts/${encodeURIComponent(delivery.receiptId)}`;
         if (path !== undefined) {
             parts.push(`${learned?.status === "proposed" ? "Review proposal" : "Review or forget"}: ${config.dashboardUrl}${path}`);
@@ -1817,23 +1837,13 @@ function guardResultFromResponse(value) {
             if (!isObject(item) || typeof item.content !== "string") {
                 return [];
             }
-            const scope = isObject(item.scope) ? item.scope : {};
-            const source = isObject(item.source) ? item.source : {};
-            const explanation = guardExplanationFromValue(item.explanation);
             return [
                 {
                     content: redactSecrets(item.content),
                     enforcement: typeof item.enforcement === "string"
                         ? item.enforcement
                         : "advisory",
-                    ...(typeof scope.repo === "string" ? { repo: scope.repo } : {}),
-                    ...(typeof scope.organization === "string"
-                        ? { organization: scope.organization }
-                        : {}),
-                    ...(typeof source.agent === "string"
-                        ? { sourceAgent: source.agent }
-                        : {}),
-                    ...(explanation === undefined ? {} : { explanation }),
+                    scope: guardItemScope(item),
                 },
             ];
         })
@@ -1856,48 +1866,23 @@ function guardResultFromResponse(value) {
         conflictSummaries,
     };
 }
-function guardExplanationFromValue(value) {
-    if (!isObject(value) ||
-        typeof value.summary !== "string" ||
-        !isObject(value.provenance) ||
-        typeof value.provenance.agent !== "string" ||
-        typeof value.status !== "string" ||
-        !isObject(value.freshness) ||
-        typeof value.freshness.updatedAt !== "string") {
-        return undefined;
-    }
-    const scope = isObject(value.scope) ? value.scope : {};
-    const scopeParts = [
-        typeof scope.organization === "string"
-            ? `org ${scope.organization}`
-            : undefined,
-        typeof scope.project === "string" ? `project ${scope.project}` : undefined,
-        typeof scope.repo === "string" ? `repo ${scope.repo}` : undefined,
-        typeof scope.path === "string" ? `path ${scope.path}` : undefined,
-        typeof scope.component === "string"
-            ? `component ${scope.component}`
-            : undefined,
-    ].filter((part) => part !== undefined);
-    const session = typeof value.provenance.sessionId === "string"
-        ? ` session ${value.provenance.sessionId}`
-        : "";
-    return `Why: ${redactSecrets(value.summary)} Source: ${value.provenance.agent}${session}. Scope: ${scopeParts.join(" · ") || "workspace-wide"}. Status: ${value.status}. Updated: ${value.freshness.updatedAt.slice(0, 10)}.`;
-}
-function guardItemSource(item) {
-    const scope = item.repo !== undefined
-        ? `${item.repo} repo`
-        : item.organization !== undefined
-            ? "organization rule"
-            : "workspace knowledge";
-    return item.sourceAgent === undefined
-        ? scope
-        : `${scope} · ${item.sourceAgent} session`;
-}
-function guardAssistContext(result) {
+/** Where the item applies, as the explanation (or the item) reports it. */
+function guardItemScope(item) {
+    const scope = isObject(item.explanation) && isObject(item.explanation.scope)
+        ? item.explanation.scope
+        : isObject(item.scope)
+            ? item.scope
+            : {};
+    return {
+        ...(typeof scope.repo === "string" ? { repo: scope.repo } : {}),
+        ...(typeof scope.path === "string" ? { path: scope.path } : {}),
+        ...(typeof scope.component === "string" ? { component: scope.component } : {}),
+    };
+}
+function guardAssistContext(result, repo) {
     const lines = ["Relevant Lore context:"];
     for (const item of result.items) {
-        lines.push(`- ${item.content}`);
-        lines.push(`  ${item.explanation ?? `Source: ${guardItemSource(item)}.`}`);
+        lines.push(`- ${guardItemLine(item, repo)}`);
     }
     if (result.conflictSummaries.length > 0) {
         lines.push("", "Lore policy notes:");
@@ -1907,7 +1892,7 @@ function guardAssistContext(result) {
     }
     return boundedContext(lines.join("\n"));
 }
-function guardConfirmationReason(result) {
+function guardConfirmationReason(result, repo) {
     if (result.policyUnavailable)
         return "Lore Guard cannot evaluate an existing required rule. An owner or admin must rewrite it using a supported prohibition or change it to advisory before retrying.";
     const required = result.items.filter((item) => item.enforcement === "required");
@@ -1915,10 +1900,7 @@ function guardConfirmationReason(result) {
     const lines = [
         result.items.length === 0 ? "Lore Guard cannot verify the enforcement policy." : "Lore Guard: this action conflicts with a required rule.",
         ...result.conflictSummaries,
-        ...shown.flatMap((item) => [
-            `- ${item.content}`,
-            `  ${item.explanation ?? `Source: ${guardItemSource(item)}.`}`,
-        ]),
+        ...shown.map((item) => `- ${guardItemLine(item, repo)}`),
     ];
     lines.push(result.offline && result.confirmCommand !== undefined
         ? `Restore Lore or run: ${result.confirmCommand}`
@@ -2009,7 +1991,7 @@ async function offlineGuard(config, store, request, now, previouslyEnforced, all
             }) !== null) : [];
         return {
             offline: true, mode: "enforce", requiresConfirmation: rules.length > 0,
-            items: rules.map((rule) => ({ content: String(rule.content), enforcement: "required" })),
+            items: rules.map((rule) => ({ content: String(rule.content), enforcement: "required", scope: guardItemScope(rule) })),
             conflictSummaries: ["Lore is offline; this action was checked against its verified, unexpired saved policy."],
             confirmCommand: guardEmergencyCommand(String(request.sessionId), String(request.repo ?? "")),
         };
@@ -2131,7 +2113,7 @@ async function handleGuardEvent(input, agent, config, sessionId, options, now, c
     // independently of `requiresConfirmation`: the producer reports it via
     // `policyIssue` rather than `confirm`, so it never sets `requiresConfirmation`.
     if (result.requiresConfirmation || result.policyUnavailable) {
-        const reason = guardConfirmationReason(result);
+        const reason = guardConfirmationReason(result, scope?.repo);
         if (agent === "polytoken")
             return { outcome: "deny", reason };
         if (agent === "copilot-cli") {
@@ -2166,8 +2148,11 @@ async function handleGuardEvent(input, agent, config, sessionId, options, now, c
         // context was already added by userPromptTransformed.
         return undefined;
     }
-    if (agent === "polytoken")
-        return { outcome: "allow" };
+    if (agent === "polytoken") {
+        // Like every other host, Polytoken gets no verdict on advisory results:
+        // Lore only ever blocks, it never approves an action.
+        return undefined;
+    }
     if (agent === "cursor") {
         // Cursor cannot inject agent context at the shell boundary on allow.
         return undefined;
@@ -2175,11 +2160,14 @@ async function handleGuardEvent(input, agent, config, sessionId, options, now, c
     return {
         hookSpecificOutput: {
             hookEventName: "PreToolUse",
-            additionalContext: guardAssistContext(result),
+            additionalContext: guardAssistContext(result, scope?.repo),
         },
     };
 }
 export async function handleHookEvent(value, agent, options = {}) {
+    // LORE_DISABLE: the same empty answer as an unconnected machine, for every host and event.
+    if (loreDisabled(options.environment ?? process.env))
+        return undefined;
     if (!isObject(value)) {
         throw new InvalidHookInputError();
     }
@@ -2255,6 +2243,8 @@ export async function handleHookEvent(value, agent, options = {}) {
                     : "Before answering each user request or using other tools, call lore_context with that sessionId and the full user message as prompt. This retrieves relevant shared knowledge; automatic capture is paused, so nothing is recorded.",
                 "Use the returned context when relevant. If retrieval fails, report that limitation; do not invent shared knowledge.",
                 ...(capture ? ["After completing each response, call lore_complete with the same sessionId and a concise response summary so the next user correction retains the prior attempt. These Lore calls are available through MCP and require no shell commands."] : ["These Lore calls are available through MCP and require no shell commands."]),
+                // Cursor's session start runs once per conversation, so no marker is needed.
+                ...(recapReminderApplies(agent, capture, config) ? [RECAP_REMINDER] : []),
             ].join("\n") };
     }
     if (eventName === "Stop" || eventName === "AssistantResponse") {
@@ -2323,27 +2313,69 @@ export async function handleHookEvent(value, agent, options = {}) {
             };
         }
     }
+    const promptConfig = { ...config, capture };
+    // Once per store: remove prompt text earlier versions kept with capture off.
+    await runtimeStore(config, options.home)
+        .then(store => forgetUncapturedPromptText(store, capture, now, CURSOR_SESSION_PREFIX))
+        .catch(() => undefined);
     if (agent === "cursor") {
         const store = await runtimeStore(config, options.home);
         const existing = await store.readState(cursorSessionKey(sessionId));
+        const { prompt: _prompt, ...kept } = isObject(existing) ? existing : {};
         const cwd = stringField(input.cwd);
+        // Capture off keeps no prompt: lore_context then searches with the
+        // message the agent passes it.
         if (cwd)
             await store.writeState(cursorSessionKey(sessionId), {
-                ...(isObject(existing) ? existing : {}), sessionId, cwd,
-                ...(stringField(input.prompt) ? { prompt: redactSecrets(String(input.prompt)) } : {}),
+                ...kept, sessionId, cwd,
+                ...(capture && stringField(input.prompt) ? { prompt: redactSecrets(String(input.prompt)) } : {}),
                 ...(stringField(input.prompt_id) ? { promptId: input.prompt_id } : {}), updatedAt: now.toISOString(),
             });
         // Cursor's prompt hook supports submission control only. The MCP call
         // delivers the context; capture here retains native editor event identity.
         // Retrieve is skipped so the notice cooldown is not primed by a discarded
         // result: the MCP `lore_context` call surfaces the reliability notice.
-        await handlePromptEvent(input, agent, sessionId, config, options, now, capture, false);
+        await handlePromptEvent(input, agent, sessionId, promptConfig, options, now, capture, false);
         return { continue: true };
     }
-    return handlePromptEvent(input, agent, sessionId, config, options, now, capture);
+    return handlePromptEvent(input, agent, sessionId, promptConfig, options, now, capture, true, recapReminderApplies(agent, capture, config));
+}
+export { RECAP_REMINDER };
+/** Hosts where `lore connect` installs the recap skill and this runtime delivers context. */
+const RECAP_HOSTS = new Set(["claude", "codex", "copilot-cli", "copilot-vscode", "cursor"]);
+function recapReminderApplies(agent, capture, config) {
+    return !capture && config.recapReminder !== false && RECAP_HOSTS.has(agent);
+}
+/** True for the first prompt of a session only. The marker is a hash of the session, never the prompt. */
+/** True once this session asked to save an approach. The marker is a hash of the session, never the prompt. */
+async function approachWorkflowStarted(store, agent, sessionId, now, requested) {
+    const key = `approach-workflow-${sha256(`${agent}\0${sessionId}`)}`;
+    try {
+        if (!requested)
+            return await store.readState(key) !== null;
+        await store.updateState(key, (current) => current ?? { at: now.toISOString() }, now, { recoverCorrupt: true });
+    }
+    catch {
+        // An unreadable marker only costs the reminder after compaction.
+    }
+    return requested;
+}
+async function claimRecapReminder(store, agent, sessionId, now) {
+    let first = false;
+    try {
+        await store.updateState(`recap-reminder-${sha256(`${agent}\0${sessionId}`)}`, (current) => {
+            first = current === null;
+            return current ?? { at: now.toISOString() };
+        }, now, { recoverCorrupt: true });
+    }
+    catch {
+        return false;
+    }
+    return first;
 }
+const CURSOR_SESSION_PREFIX = "cursor-session-";
 function cursorSessionKey(sessionId) {
-    return `cursor-session-${sha256(sessionId)}`;
+    return `${CURSOR_SESSION_PREFIX}${sha256(sessionId)}`;
 }
 /** MCP requests are bound to a session/workspace observed by the native hook. */
 async function cursorSession(sessionId, options) {
@@ -2371,7 +2403,7 @@ async function cursorSession(sessionId, options) {
     }
     // Same definition as the native hooks: local mode and the dashboard switches.
     const capture = config.capture && access.capturePausedBy === undefined;
-    return { config, store, state, cwd: stringField(state.cwd), capture };
+    return { config: { ...config, capture }, store, state, cwd: stringField(state.cwd), capture };
 }
 export async function getCursorContext(sessionId, prompt, options = {}) {
     const { config, state, cwd, capture } = await cursorSession(sessionId, options);
@@ -2390,7 +2422,7 @@ export async function completeCursorResponse(sessionId, response, options = {})
     const { prompt: _prompt, promptId: _promptId, ...rest } = state;
     await store.writeState(cursorSessionKey(sessionId), { ...rest, updatedAt: now.toISOString() });
 }
-async function handlePromptEvent(input, agent, sessionId, config, options, now, capture = true, retrieve = true) {
+async function handlePromptEvent(input, agent, sessionId, config, options, now, capture = true, retrieve = true, recapReminder = false) {
     const fetchImplementation = options.fetch ?? globalThis.fetch;
     const prompt = stringField(input.prompt);
     if (prompt === undefined) {
@@ -2466,11 +2498,14 @@ async function handlePromptEvent(input, agent, sessionId, config, options, now,
     };
     const lineage = await readLineageMetadata(options.home, options.environment ?? process.env);
     let delivery = emptyDelivery();
-    const retrievalTask = (repo) => resolveRetrievalTask(store, {
+    const retrievalSession = (repo) => ({
         agent, sessionId, connectionKey: credentialReliabilityWorkspaceKey(config),
         cwd: stringField(input.cwd), repo,
-    }, prompt, now, pending?.cwd === stringField(input.cwd) && pending
-        ? { content: pending.assistantMessage, capturedAt: pending.capturedAt } : undefined);
+    });
+    const retrievalTask = (repo) => !config.capture
+        ? unsavedRetrievalTask(store, retrievalSession(repo), prompt)
+        : resolveRetrievalTask(store, retrievalSession(repo), prompt, now, pending?.cwd === stringField(input.cwd) && pending
+            ? { content: pending.assistantMessage, capturedAt: pending.capturedAt } : undefined);
     if (pending !== null) {
         let receivedTurnContext = false;
         let request = await createTurnRequest(input, agent, pending, now, lineage);
@@ -2648,8 +2683,11 @@ async function handlePromptEvent(input, agent, sessionId, config, options, now,
         await rememberDeliveredContext(store, contextSession, delivery).catch(() => undefined);
     const relatedContext = delivery.relatedContext && !retainedContext.some(text => text.includes(delivery.relatedContext))
         ? delivery.relatedContext : undefined;
+    const approachContext = delivery.approachContext && !retainedContext.some(text => text.includes(delivery.approachContext))
+        ? delivery.approachContext : undefined;
     // Skills are fresh on every turn, even when learning context is retained.
-    const taskContext = [delivery.skillContext, delivery.context, relatedContext, delivery.reliability?.status === "failed" ? undefined : approachGuidance(prompt, agent, redactSecrets(sessionId), retainedContext), delivery.skillContext === undefined && delivery.reliability?.status !== "failed" ? skillGuidance(retainedContext) : undefined].filter(Boolean).join("\n\n");
+    const taskContext = [delivery.skillContext, delivery.context, relatedContext, approachContext, delivery.reliability?.status === "failed" ? undefined : approachGuidance(prompt, agent, redactSecrets(sessionId), retainedContext, await approachWorkflowStarted(store, agent, sessionId, now, approachWorkflowRequested(prompt))), delivery.skillContext === undefined && delivery.reliability?.status !== "failed" ? skillGuidance(retainedContext) : undefined,
+        recapReminder && await claimRecapReminder(store, agent, sessionId, now) ? RECAP_REMINDER : undefined].filter(Boolean).join("\n\n");
     const systemMessage = agent === "cursor" || agent === "polytoken"
         ? undefined
         : [receipt, reliabilityNotice].filter(Boolean).join(" · ") || undefined;
@@ -2738,6 +2776,15 @@ export async function runHook(args = process.argv.slice(2)) {
     if (agent === null) {
         return;
     }
+    if (loreDisabled(process.env)) {
+        // Nothing is read, sent, or written, not even invocation health. Drain the
+        // payload so the host never sees a broken pipe, then exit 0 with no output.
+        try {
+            for await (const _chunk of process.stdin) { /* discard */ }
+        }
+        catch { /* nothing to report */ }
+        return;
+    }
     let tracker = null;
     let input;
     try {