om-memory-system 5.2.0 → 5.4.0

package/dist/importer/claude-hook-context.js

@@ -0,0 +1,264 @@
+import { open, readFile, stat } from "node:fs/promises";
+import { CONFIG } from "../config.js";
+import { buildFirstPromptSections, openingQueryFor } from "../core/opening-context.js";
+import { RETRIEVAL_SECTION_TAG, buildRetrievalSection, retrievalWrapperBytes, wrapRetrievalSection, } from "../core/retrieval.js";
+import { isFullyPrivate, stripPrivateContent } from "../services/privacy.js";
+import { utf8ByteLength } from "../utils/context-limit.js";
+import { parseClaudeTranscript } from "./claude-conversation.js";
+// What the Claude Code hooks add beyond a plain retrieval section (change
+// align-recall-host-parity): the rows-off marker, the opening section for the
+// first prompt of a session, and the task memories for a subagent. The hook
+// reaches the recall rows only through the injected text, so the markers are
+// HTML comments on the line after a section's opening tag. They hold no memory
+// text. Logs here carry sizes and codes, never text.
+/** Tells the recall rows to draw nothing for this section. 21 bytes, newline included. */
+export const ROWS_OFF_MARKER = "<!--omms:rows-off-->\n";
+/** Between the prompt's section and the opening section. */
+const SECTION_SEPARATOR = "\n";
+const OPENING_QUERY_MAX = 300;
+/** Sessions this process remembers, so the transcript check runs once per session. */
+const SEEN_SESSIONS_MAX = 500;
+/** A transcript this large already holds earlier prompts, or is too big to scan. */
+const FIRST_PROMPT_SCAN_MAX_BYTES = 1024 * 1024;
+const SUBAGENT_TAIL_BYTES = 1024 * 1024;
+/** Read `visibleRecall` once per request, after the config refresh. */
+export function sectionLimits(budgetBytes) {
+    return { budgetBytes, rowsOff: CONFIG.visibleRecall === false };
+}
+/** The budget for one packed section: the retrieval tag, and the rows-off marker when set, are reserved. */
+export function sectionBudget(limits) {
+    const marker = limits.rowsOff ? utf8ByteLength(ROWS_OFF_MARKER) : 0;
+    return { maxBytes: limits.budgetBytes, wrapperBytes: retrievalWrapperBytes() + marker };
+}
+/** Put a marker line right after the opening tag of a wrapped section. */
+export function insertMarker(wrapped, marker) {
+    const head = `<${RETRIEVAL_SECTION_TAG}>\n`;
+    return wrapped.startsWith(head) ? head + marker + wrapped.slice(head.length) : wrapped;
+}
+/** Wrap a packed section, with the rows-off marker when rows are off. */
+export function wrapSection(section, limits) {
+    const wrapped = wrapRetrievalSection(section);
+    return limits.rowsOff ? insertMarker(wrapped, ROWS_OFF_MARKER) : wrapped;
+}
+/**
+ * The opening marker. The query goes on one line, with `"`, `<` and `>`
+ * removed, `--` folded to `-` and 300 characters at most, so it cannot end the
+ * comment early.
+ */
+export function openingMarker(query) {
+    const line = query
+        .replace(/["<>]/g, "")
+        .replace(/-{2,}/g, "-")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, OPENING_QUERY_MAX)
+        // Do not leave half of a surrogate pair at the cut.
+        .replace(/[\uD800-\uDBFF]$/, "");
+    return `<!--omms:opening query="${line}"-->\n`;
+}
+// --- First prompt of a session ---
+const seenSessions = new Set();
+/** Remember a session, so a later prompt in this process is never first. Oldest ids drop out. */
+export function markSessionSeen(sessionId) {
+    seenSessions.delete(sessionId);
+    seenSessions.add(sessionId);
+    if (seenSessions.size > SEEN_SESSIONS_MAX) {
+        seenSessions.delete(seenSessions.values().next().value);
+    }
+}
+// User entries that Claude Code writes itself (command output, shell mode,
+// background task notices) are not prompts.
+const NOT_PROMPT_PREFIXES = [
+    "<local-command-",
+    "<command-name>",
+    "<command-message>",
+    "<bash-",
+    "<task-notification>",
+];
+function contentBlocks(entry) {
+    const content = entry.message?.content;
+    return Array.isArray(content)
+        ? content.filter((block) => block && typeof block === "object")
+        : [];
+}
+/** The text of a prompt the user typed, or null for any other transcript entry. */
+function userPromptText(entry) {
+    if (entry.type !== "user" || entry.isMeta === true || entry.isSidechain === true)
+        return null;
+    const content = entry.message?.content;
+    let text;
+    if (typeof content === "string")
+        text = content;
+    else {
+        const blocks = contentBlocks(entry);
+        if (blocks.some((block) => block.type === "tool_result"))
+            return null;
+        text = blocks.map((block) => (block.type === "text" ? (block.text ?? "") : "")).join("\n");
+    }
+    text = text.trim();
+    return text && !NOT_PROMPT_PREFIXES.some((prefix) => text.startsWith(prefix)) ? text : null;
+}
+/**
+ * True when the transcript holds no user prompt before `prompt`. The host may
+ * or may not have written the current prompt yet, so a last prompt with the same
+ * text is not counted. A missing file is a session with no history. Any other
+ * problem counts as not first, so the opening section is skipped.
+ */
+async function hasNoEarlierPrompt(transcriptPath, prompt) {
+    let text;
+    try {
+        if ((await stat(transcriptPath)).size > FIRST_PROMPT_SCAN_MAX_BYTES)
+            return false;
+        text = await readFile(transcriptPath, "utf8");
+    }
+    catch (error) {
+        return error?.code === "ENOENT";
+    }
+    const earlier = parseClaudeTranscript(text)
+        .entries.map(userPromptText)
+        .filter((entry) => entry !== null);
+    if (earlier.at(-1) === prompt.trim())
+        earlier.pop();
+    return earlier.length === 0;
+}
+/**
+ * The first prompt of a session, as far as this process can tell: the session
+ * is new to this process and its transcript holds no earlier prompt. Marks the
+ * session seen. A missing or invalid transcript path counts as not first.
+ */
+async function isFirstPrompt(sessionId, transcriptPath, prompt) {
+    if (seenSessions.has(sessionId))
+        return false;
+    const first = transcriptPath ? await hasNoEarlierPrompt(transcriptPath, prompt) : false;
+    markSessionSeen(sessionId);
+    return first;
+}
+/**
+ * The added context for a prompt: its retrieval section, and on the first
+ * prompt of a session, with `openingContext` on, the opening section after it.
+ * Empty string when there is nothing to add.
+ */
+export async function promptContext(input, limits) {
+    const prompt = stripPrivateContent(input.prompt).trim();
+    if (!CONFIG.chatMessage.enabled || !prompt || isFullyPrivate(input.prompt))
+        return "";
+    const budget = sectionBudget(limits);
+    const openingQuery = openingQueryFor(CONFIG);
+    const first = openingQuery !== null &&
+        (await isFirstPrompt(input.sessionId, input.transcriptPath, input.prompt));
+    if (!first) {
+        const section = await buildRetrievalSection(prompt, input.cwd, input.sessionId, budget);
+        return section ? wrapSection(section, limits) : "";
+    }
+    const marker = limits.rowsOff ? ROWS_OFF_MARKER : openingMarker(openingQuery);
+    const { promptSection, openingSection } = await buildFirstPromptSections({
+        prompt,
+        openingQuery,
+        directory: input.cwd,
+        sessionId: input.sessionId,
+        budget,
+        // The rows-off marker is already in `wrapperBytes`; the opening marker and the
+        // line between the two sections are extra.
+        openingReserveBytes: (limits.rowsOff ? 0 : utf8ByteLength(marker)) + SECTION_SEPARATOR.length,
+    });
+    return [
+        promptSection &&
+            (limits.rowsOff ? insertMarker(promptSection, ROWS_OFF_MARKER) : promptSection),
+        openingSection && insertMarker(openingSection, marker),
+    ]
+        .filter(Boolean)
+        .join(SECTION_SEPARATOR);
+}
+// --- Subagents ---
+/**
+ * A background subagent's call gets this receipt as its tool result at launch, before the agent
+ * runs. It is not an answer: the call is still the one whose agent is starting.
+ */
+const LAUNCH_RECEIPT_PREFIX = "Async agent launched";
+function isLaunchReceipt(content) {
+    const text = Array.isArray(content)
+        ? content.map((part) => part?.text ?? "").join("")
+        : content;
+    return typeof text === "string" && text.startsWith(LAUNCH_RECEIPT_PREFIX);
+}
+/** Calls that already fed a subagent, per parent session. Bounded, in memory only. */
+const claimedCalls = new Map();
+const CLAIMED_SESSIONS_MAX = 500;
+const CLAIMED_CALLS_MAX = 200;
+function claimCall(sessionId, callId) {
+    const used = claimedCalls.get(sessionId) ?? new Set();
+    claimedCalls.delete(sessionId);
+    used.add(callId);
+    if (used.size > CLAIMED_CALLS_MAX)
+        used.delete(used.values().next().value);
+    claimedCalls.set(sessionId, used);
+    if (claimedCalls.size > CLAIMED_SESSIONS_MAX) {
+        claimedCalls.delete(claimedCalls.keys().next().value);
+    }
+}
+/**
+ * The task prompt of the oldest `Agent` or `Task` call of `agentType` that has no result yet and
+ * has not fed a subagent already.
+ * A background launch receipt does not count as a result.
+ */
+async function subagentTaskPrompt(transcriptPath, agentType, sessionId) {
+    const handle = await open(transcriptPath, "r");
+    let text;
+    try {
+        const { size } = await handle.stat();
+        const length = Math.min(size, SUBAGENT_TAIL_BYTES);
+        const buffer = Buffer.alloc(length);
+        await handle.read(buffer, 0, length, size - length);
+        text = buffer.toString("utf8");
+    }
+    finally {
+        await handle.close();
+    }
+    const answered = new Set();
+    const calls = [];
+    for (const entry of parseClaudeTranscript(text).entries) {
+        if (entry.isSidechain === true)
+            continue;
+        for (const block of contentBlocks(entry)) {
+            if (block.type === "tool_result" && block.tool_use_id && !isLaunchReceipt(block.content)) {
+                answered.add(block.tool_use_id);
+            }
+            if (block.type !== "tool_use" || !block.id)
+                continue;
+            if (block.name !== "Agent" && block.name !== "Task")
+                continue;
+            const input = (block.input ?? {});
+            if (typeof input.prompt !== "string")
+                continue;
+            const type = typeof input.subagent_type === "string" && input.subagent_type;
+            calls.push({ id: block.id, type: type || "general-purpose", prompt: input.prompt });
+        }
+    }
+    // Oldest first: parallel subagents start in the order of their calls. A call that already
+    // fed a subagent is not used again, so a background call (open until its agent ends) or a
+    // second start with no new call gets nothing.
+    const used = claimedCalls.get(sessionId);
+    const call = calls.find((candidate) => candidate.type === agentType && !answered.has(candidate.id) && !used?.has(candidate.id));
+    if (!call)
+        return null;
+    claimCall(sessionId, call.id);
+    return call.prompt;
+}
+/**
+ * The added context for a starting subagent: the retrieval section for its
+ * task prompt, read from the parent transcript. Every subagent section carries
+ * the rows-off marker. Any problem gives an empty string.
+ */
+export async function subagentContext(input, budgetBytes) {
+    if (!CONFIG.subagentMemory || !CONFIG.chatMessage.enabled)
+        return "";
+    if (!input.transcriptPath || !input.agentType)
+        return "";
+    const task = await subagentTaskPrompt(input.transcriptPath, input.agentType, input.sessionId).catch(() => null);
+    const prompt = stripPrivateContent(task ?? "").trim();
+    if (!task || !prompt || isFullyPrivate(task))
+        return "";
+    const limits = { budgetBytes, rowsOff: true };
+    const section = await buildRetrievalSection(prompt, input.cwd, input.sessionId, sectionBudget(limits));
+    return section ? wrapSection(section, limits) : "";
+}

package/dist/index.js

@@ -161,7 +161,7 @@ export async function configureOpencodeHostTransport(ctx) {
     if (hostConfig.fetch) {
         setHostFetch(hostConfig.fetch);
     }
-    else {
+    else if (!hostConfig.inProcess) {
         log("OpenCode host fetch unavailable; falling back to global fetch", {
             clientKeys: hostConfig.clientKeys,
             sdkConfigCount: hostConfig.sdkConfigCount,

package/dist/services/ai/local-api-url.d.ts

@@ -0,0 +1,2 @@
+/** True when the URL names this machine, so a model server there may run without a key. */
+export declare function isLocalApiUrl(url: string | undefined): boolean;

package/dist/services/ai/local-api-url.js

@@ -0,0 +1,12 @@
+const LOCAL_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
+/** True when the URL names this machine, so a model server there may run without a key. */
+export function isLocalApiUrl(url) {
+    if (!url)
+        return false;
+    try {
+        return LOCAL_HOSTS.has(new URL(url).hostname.toLowerCase());
+    }
+    catch {
+        return false;
+    }
+}

package/dist/services/ai/provider-config.d.ts

@@ -12,6 +12,8 @@ interface MemoryProviderRuntimeConfig {
 interface ProviderConfigOverrides {
     maxIterations?: number;
     iterationTimeout?: number;
+    /** Chat only: a model server on this machine needs no key. Other callers still need one. */
+    keylessForLocalUrl?: boolean;
 }
 export declare function buildMemoryProviderConfig(config: MemoryProviderRuntimeConfig, overrides?: ProviderConfigOverrides): ProviderConfig;
 export {};

package/dist/services/ai/provider-config.js

@@ -1,4 +1,5 @@
 import { isPlaceholderApiKey } from "./api-key-placeholder.js";
+import { isLocalApiUrl } from "./local-api-url.js";
 export function buildMemoryProviderConfig(config, overrides = {}) {
     const memoryModel = config.memoryModel;
     const memoryApiUrl = config.memoryApiUrl;
@@ -11,7 +12,8 @@ export function buildMemoryProviderConfig(config, overrides = {}) {
         issues.push("missing memoryModel");
     if (!memoryApiUrl && !isOrcaRouter)
         issues.push("missing memoryApiUrl");
-    if (!memoryApiKey)
+    const keyOptional = overrides.keylessForLocalUrl === true && isLocalApiUrl(memoryApiUrl);
+    if (!memoryApiKey && !keyOptional)
         issues.push("missing memoryApiKey");
     if (isPlaceholderApiKey(memoryApiKey))
         issues.push("replace the placeholder memoryApiKey value");

package/dist/services/ai/providers/google-gemini.js

@@ -123,7 +123,8 @@ export class GoogleGeminiProvider extends BaseAIProvider {
             const timeout = setTimeout(() => controller.abort(), iterationTimeout);
             try {
                 const baseUrl = this.config.apiUrl || "https://generativelanguage.googleapis.com/v1beta";
-                const url = `${baseUrl}/models/${this.config.model}:generateContent?key=${this.config.apiKey}`;
+                const keyQuery = this.config.apiKey ? `?key=${this.config.apiKey}` : "";
+                const url = `${baseUrl}/models/${this.config.model}:generateContent${keyQuery}`;
                 const requestBody = {
                     contents,
                     systemInstruction: geminiSystemInstruction,

package/dist/services/ai/providers/openai-responses.js

@@ -54,7 +54,8 @@ export class OpenAIResponsesProvider extends BaseAIProvider {
                     method: "POST",
                     headers: {
                         "Content-Type": "application/json",
-                        Authorization: `Bearer ${this.config.apiKey}`,
+                        // A keyless server on this machine gets no Authorization header.
+                        ...(this.config.apiKey ? { Authorization: `Bearer ${this.config.apiKey}` } : {}),
                     },
                     body: JSON.stringify(requestBody),
                     signal: controller.signal,

package/dist/services/chat/chat-runtime.js

@@ -23,7 +23,11 @@ export async function callTool(config, system, user, tool, timeoutMs = CHAT_MODE
     const { AIProviderFactory } = await import("../ai/ai-provider-factory.js");
     const { buildMemoryProviderConfig } = await import("../ai/provider-config.js");
     const { aiSessionManager } = await import("../ai/session/ai-session-manager.js");
-    const provider = AIProviderFactory.createProvider(config.memoryProvider, buildMemoryProviderConfig(config, { maxIterations: 1, iterationTimeout: timeoutMs }));
+    const provider = AIProviderFactory.createProvider(config.memoryProvider, buildMemoryProviderConfig(config, {
+        maxIterations: 1,
+        iterationTimeout: timeoutMs,
+        keylessForLocalUrl: true,
+    }));
     const sessionId = `chat_${crypto.randomUUID()}`;
     try {
         return await provider.executeToolCall(system, user, tool, sessionId);

package/dist/services/chat/chat-status.js

@@ -1,4 +1,5 @@
 import { isPlaceholderApiKey } from "../ai/api-key-placeholder.js";
+import { isLocalApiUrl } from "../ai/local-api-url.js";
 /** Whether chat can call the external memory model. Mirrors `buildMemoryProviderConfig`. */
 export function chatStatus(config) {
     const provider = config.memoryProvider ?? "openai-chat";
@@ -8,7 +9,9 @@ export function chatStatus(config) {
         missing.push("memoryModel");
     if (!config.memoryApiUrl && !presetEndpoint)
         missing.push("memoryApiUrl");
-    if (!config.memoryApiKey || isPlaceholderApiKey(config.memoryApiKey)) {
+    // A model server on this machine needs no key. A placeholder that was left in the box is still flagged.
+    const keyOptional = !config.memoryApiKey && isLocalApiUrl(config.memoryApiUrl);
+    if (!keyOptional && (!config.memoryApiKey || isPlaceholderApiKey(config.memoryApiKey))) {
         missing.push("memoryApiKey");
     }
     return {

package/dist/services/global-config-writer.js

@@ -8,6 +8,7 @@ import { isValidClaudeConfigDir } from "./claude-folder.js";
 import { missingSkillFolder } from "./skill-learning/skill-config.js";
 import { KEYWORD_MODES } from "../utils/keyword-boost.js";
 import { getMemoryLimitRule } from "../utils/memory-limits.js";
+import { OPENING_CONTEXT_QUERY_MAX_LENGTH } from "./injection-options-config.js";
 import { RERANKER_TIMEOUT_MAX_MS, RERANKER_TIMEOUT_MIN_MS } from "./request-timeouts.js";
 const keys = new Set([
     "opencodeProvider",
@@ -47,6 +48,11 @@ const keys = new Set([
     "skillLearning",
     "skillLearningRedact",
     "skillFolders",
+    "openingContext",
+    "openingContextQuery",
+    "subagentMemory",
+    "compaction.enabled",
+    "compaction.memoryLimit",
 ]);
 function isFolder(path) {
     try {
@@ -83,10 +89,18 @@ export function isSecretReference(value) {
 /** Reranker keys that a null edit removes, the same wire form as a limit reset. */
 const OPTIONAL_RERANKER_KEYS = ["rerankerApiUrl", "rerankerModel", "rerankerApiKey"];
 /** Other keys whose `null` edit removes them, so they follow the default again. */
-const RESETTABLE_KEYS = ["keywordMode", "skillFolders"];
+const RESETTABLE_KEYS = [
+    "keywordMode",
+    "skillFolders",
+    "openingContextQuery",
+    "openingContext",
+    "subagentMemory",
+    "compaction.enabled",
+];
+const QUERY_RULE = `openingContextQuery must be text of ${OPENING_CONTEXT_QUERY_MAX_LENGTH} characters or fewer`;
 function isValidEdit(key, value) {
     // `undefined` removes the key from the file. `null` is the wire form of
-    // "reset to default", accepted for the six memory limits and the optional reranker keys.
+    // "reset to default", accepted for the memory limits and the optional reranker keys.
     const memoryLimit = getMemoryLimitRule(key);
     if (memoryLimit && value === null)
         return true;
@@ -98,6 +112,11 @@ function isValidEdit(key, value) {
     // keywordMode: null removes the key, so the mode follows the default again.
     if (key === "keywordMode")
         return value === null || KEYWORD_MODES.includes(value);
+    // The opening context query: null removes it; an empty query means no opening search.
+    if (key === "openingContextQuery") {
+        return (value === null ||
+            (typeof value === "string" && value.trim().length <= OPENING_CONTEXT_QUERY_MAX_LENGTH));
+    }
     // The five opt-in reranker keys (openspec retrieval-threshold-and-reranker).
     if (key === "rerankerEnabled")
         return typeof value === "boolean";
@@ -133,8 +152,12 @@ function isValidEdit(key, value) {
         key === "webServerAutoStart" ||
         key === "userProfileAutoCleanupEnabled" ||
         key === "skillLearning" ||
-        key === "skillLearningRedact") {
-        return typeof value === "boolean";
+        key === "skillLearningRedact" ||
+        key === "openingContext" ||
+        key === "subagentMemory" ||
+        key === "compaction.enabled") {
+        // The three memory injection switches take null too: it removes the key (reset to default).
+        return typeof value === "boolean" || (value === null && RESETTABLE_KEYS.includes(key));
     }
     // Path rules are checked by the startup validation below; existence just after this check.
     if (key === "skillFolders") {
@@ -160,8 +183,8 @@ function isValidEdit(key, value) {
     // Entries are checked by the startup validation below.
     if (key === "importPathMaps" || key === "importIgnoredDirectories")
         return Array.isArray(value);
-    // The five memory limits share one validation rule set (six with
-    // similarityThreshold; null means reset, handled above).
+    // The memory limits share one validation rule set (similarityThreshold and
+    // compaction.memoryLimit included; null means reset, handled above).
     if (memoryLimit)
         return memoryLimit.isValid(value);
     // An empty value clears the field.
@@ -218,11 +241,13 @@ options = {}) {
             };
             throw new Error(["memoryApiKey", "embeddingApiKey", "webServerAuthPassword", "rerankerApiKey"].includes(key)
                 ? `${key} must be an env:// or file:// reference`
-                : memoryRule
-                    ? `Invalid ${key} setting: accepted ${memoryRule.accepted}`
-                    : rerankerAccepted[key]
-                        ? `Invalid ${key} setting: accepted ${rerankerAccepted[key]}`
-                        : `Invalid ${key} setting`);
+                : key === "openingContextQuery"
+                    ? QUERY_RULE
+                    : memoryRule
+                        ? `Invalid ${key} setting: accepted ${memoryRule.accepted}`
+                        : rerankerAccepted[key]
+                            ? `Invalid ${key} setting: accepted ${rerankerAccepted[key]}`
+                            : `Invalid ${key} setting`);
         }
         const missing = key === "skillFolders" && value !== null
             ? missingSkillFolder(value, isFolder)
@@ -246,9 +271,9 @@ options = {}) {
         }
         let content = original.content;
         for (const [key, value] of Object.entries(edits)) {
-            // A nested limit identifier maps to its JSONC leaf path, so
-            // chatMessage.maxMemories writes the leaf, never a literal dotted key.
-            const jsoncPath = (getMemoryLimitRule(key)?.path ?? [key]);
+            // A nested identifier maps to its JSONC leaf path, so chatMessage.maxMemories
+            // and compaction.enabled write the leaf, never a literal dotted key.
+            const jsoncPath = (getMemoryLimitRule(key)?.path ?? key.split("."));
             // null is the wire form of "reset to default": remove the key so the
             // value follows the default again (undefined removes in jsonc modify).
             const jsoncValue = value === null &&

package/dist/services/injection-options-config.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The memory injection settings (change align-recall-host-parity): the opening
+ * context and subagent memory, on OpenCode V2, Pi and Claude Code. Kept out of
+ * `src/config.ts` to save its lines. Pure on purpose, like
+ * `visible-recall-config.ts`: callers pass the file config and a log function,
+ * and the loaded `CONFIG` is never imported here, because many tests stub
+ * `src/config.js`.
+ *
+ * Read the effective values from `CONFIG.openingContext`,
+ * `CONFIG.openingContextQuery` and `CONFIG.subagentMemory`.
+ */
+/** The opening context search query when the config file sets none. */
+export declare const DEFAULT_OPENING_CONTEXT_QUERY = "project architecture, setup, conventions and key decisions";
+/** Most characters of `openingContextQuery`, after trimming. */
+export declare const OPENING_CONTEXT_QUERY_MAX_LENGTH = 500;
+/**
+ * The keys as they appear in a config file. `OmmsConfig` in `src/config.ts` has
+ * no fields for them, to save lines, so the functions take `FileConfigWithKeys`,
+ * which any config object satisfies. A hand-edited file can hold any value,
+ * which is why each key is checked for its type.
+ */
+export interface InjectionOptionsFileKeys {
+    /** Search memory with `openingContextQuery` on the first message of a new session. Default false. A project can only turn it off. */
+    openingContext?: boolean;
+    /** The opening context search query. Global only. Trimmed, 500 characters at most. Empty means no search. */
+    openingContextQuery?: string;
+    /** Give subagent sessions the memories that match their task. Default true. A project can only turn it off. */
+    subagentMemory?: boolean;
+}
+type FileConfigWithKeys = InjectionOptionsFileKeys & object;
+/**
+ * Read the settings from a merged file config. A value of the wrong type reads
+ * as the default. A query over the limit is cut, and `log` gets its length,
+ * never its text.
+ */
+export declare function injectionOptionsFromFile(fileConfig: FileConfigWithKeys, log?: (message: string, data: {
+    length: number;
+}) => void): {
+    openingContext: boolean;
+    openingContextQuery: string;
+    subagentMemory: boolean;
+};
+/**
+ * Apply the project rules to `overrides`, the copy of the project config that
+ * is merged over the global one. A project may turn either switch off, so a
+ * value of `false` stays. Any other value is dropped, and a value of `true` is
+ * reported through `log`. The query is global only, so a project query is
+ * always dropped and reported.
+ */
+export declare function applyProjectInjectionOptions(project: FileConfigWithKeys, overrides: FileConfigWithKeys, directory: string, log: (message: string, data: {
+    directory: string;
+}) => void): void;
+export {};

package/dist/services/injection-options-config.js

@@ -0,0 +1,56 @@
+/**
+ * The memory injection settings (change align-recall-host-parity): the opening
+ * context and subagent memory, on OpenCode V2, Pi and Claude Code. Kept out of
+ * `src/config.ts` to save its lines. Pure on purpose, like
+ * `visible-recall-config.ts`: callers pass the file config and a log function,
+ * and the loaded `CONFIG` is never imported here, because many tests stub
+ * `src/config.js`.
+ *
+ * Read the effective values from `CONFIG.openingContext`,
+ * `CONFIG.openingContextQuery` and `CONFIG.subagentMemory`.
+ */
+/** The opening context search query when the config file sets none. */
+export const DEFAULT_OPENING_CONTEXT_QUERY = "project architecture, setup, conventions and key decisions";
+/** Most characters of `openingContextQuery`, after trimming. */
+export const OPENING_CONTEXT_QUERY_MAX_LENGTH = 500;
+/**
+ * Read the settings from a merged file config. A value of the wrong type reads
+ * as the default. A query over the limit is cut, and `log` gets its length,
+ * never its text.
+ */
+export function injectionOptionsFromFile(fileConfig, log) {
+    const raw = fileConfig.openingContextQuery;
+    let query = typeof raw === "string" ? raw.trim() : DEFAULT_OPENING_CONTEXT_QUERY;
+    if (query.length > OPENING_CONTEXT_QUERY_MAX_LENGTH) {
+        log?.("openingContextQuery is longer than 500 characters; only the first 500 are used", {
+            length: query.length,
+        });
+        query = query.slice(0, OPENING_CONTEXT_QUERY_MAX_LENGTH);
+    }
+    return {
+        openingContext: fileConfig.openingContext === true,
+        openingContextQuery: query,
+        subagentMemory: fileConfig.subagentMemory !== false,
+    };
+}
+/**
+ * Apply the project rules to `overrides`, the copy of the project config that
+ * is merged over the global one. A project may turn either switch off, so a
+ * value of `false` stays. Any other value is dropped, and a value of `true` is
+ * reported through `log`. The query is global only, so a project query is
+ * always dropped and reported.
+ */
+export function applyProjectInjectionOptions(project, overrides, directory, log) {
+    for (const key of ["openingContext", "subagentMemory"]) {
+        if (project[key] === false)
+            continue;
+        delete overrides[key];
+        if (project[key] === true) {
+            log(`Project config cannot turn on ${key}; the value was ignored`, { directory });
+        }
+    }
+    delete overrides.openingContextQuery;
+    if (Object.hasOwn(project, "openingContextQuery")) {
+        log("Project config cannot set openingContextQuery; the value was ignored", { directory });
+    }
+}