opencode-memory-pro 1.3.0

package/dist/llm.d.ts

@@ -0,0 +1,14 @@
+export interface LLMCapturedItem {
+    content: string;
+    type: "decision" | "fact" | "preference" | "other";
+    importance: number;
+}
+export interface LLMConfig {
+    provider?: string;
+    model?: string;
+}
+export declare function parseExtractionJSON(raw: string): LLMCapturedItem[] | null;
+export declare function isOwnSession(sessionID: unknown): boolean;
+export declare function extractAssistantText(response: unknown): string;
+export declare function requestLLMCapture(client: unknown, llmConfig: LLMConfig | undefined, sessionText: string, sessionID?: string): Promise<LLMCapturedItem[] | null>;
+export declare function requestLLMDigest(client: unknown, llmConfig: LLMConfig | undefined, texts: string[], targetChars: number, groupKey?: string): Promise<{ text: string; sourceCount: number } | null>;

package/dist/llm.js

@@ -0,0 +1,212 @@
+// LLM_CAPTURE (1.1): SDK-transport LLM extraction and digest generation for
+// opencode-memory-pro.
+import { log } from "./logger.js";
+//
+// Transport rules (per design):
+//   - The LLM is addressed by opencode provider ID + model ID. opencode owns
+//     routing, auth, and base URLs; this module never sees an API key.
+//   - Calls run through ephemeral SDK sessions (created, prompted, deleted),
+//     isolated from user-visible history.
+//   - Every entry point is failure-tolerant: returns null/[] on any error so
+//     callers can fall back to the offline heuristics pipeline.
+//   - Tools are disabled on the ephemeral prompt so extraction/summarization
+//     is a pure text-in/text-out call.
+const EXTRACTION_SYSTEM_PROMPT = `You are a memory extraction system for an AI coding assistant.
+
+Read the conversation transcript below and extract DURABLE, memory-worthy content: decisions made, preferences expressed, durable facts about the user's projects/systems, and context that will matter weeks from now.
+
+Ignore: greetings, small talk, ephemeral task details, raw tool output that contains no decision, and anything that will not matter later.
+
+Return ONLY valid JSON — an array of objects, with no markdown fences and no commentary:
+[{"content": "...", "type": "fact|decision|preference|other", "importance": 0.0-1.0}]
+
+Rules:
+- content: 1-3 self-contained sentences (no bare pronouns). One memory per item.
+- type: "decision" (a choice was made), "fact" (durable fact), "preference" (user's stated preference), "other".
+- importance: 0.0 (trivial) to 1.0 (critical). Be selective: most transcripts yield 1-4 memories.
+- Emit at most 8 memories per transcript.`;
+const DIGEST_SYSTEM_PROMPT = `You are a memory summarization system for an AI coding assistant.
+
+Below is a set of memories about the same topic. Write ONE concise abstractive summary (target length: TARGETCHARS characters; topic: GROUPKEY) that a future agent can read to regain the essentials.
+
+Preserve: decisions, root causes, concrete facts, user preferences, and any names/versions that matter. Omit repetition and low-value detail.
+
+Return ONLY the summary text. No markdown headers, no commentary.`;
+const VALID_CAPTURE_TYPES = ["decision", "fact", "preference", "other"];
+const MAX_EXTRACTIONS = 8;
+const MAX_CAPTURE_INPUT_CHARS = 60000;
+const MAX_DIGEST_INPUT_CHARS = 80000;
+/**
+ * Session IDs of ephemeral sessions this plugin created itself. Their own
+ * events (idle/deleted/text.complete) must never be fed back into the
+ * capture/consolidate pipeline, or the plugin would loop on itself,
+ * spawning unbounded LLM capture sessions and stacking consolidate passes.
+ */
+const OWN_SESSION_IDS = new Set();
+export function isOwnSession(sessionID) {
+    return typeof sessionID === "string" && OWN_SESSION_IDS.has(sessionID);
+}
+/**
+ * Tolerant JSON parse of the extraction model's reply. Accepts a bare array
+ * or an object wrapping an array under "memories"/"items"; strips markdown
+ * fences. Returns a normalized [{content,type,importance}] list, or null.
+ */
+export function parseExtractionJSON(raw) {
+    if (typeof raw !== "string")
+        return null;
+    let cleaned = raw.trim().replace(/^```(?:json)?\s*/i, "").replace(/```\s*$/, "").trim();
+    if (!cleaned)
+        return null;
+    let data;
+    try {
+        data = JSON.parse(cleaned);
+    }
+    catch {
+        return null;
+    }
+    let list = Array.isArray(data)
+        ? data
+        : (Array.isArray(data?.memories) ? data.memories
+            : (Array.isArray(data?.items) ? data.items : null));
+    if (list === null)
+        return null;
+    if (list.length === 0)
+        return [];
+    const out = [];
+    for (const item of list.slice(0, MAX_EXTRACTIONS)) {
+        const content = typeof item?.content === "string" ? item.content.trim() : "";
+        if (!content)
+            continue;
+        const type = VALID_CAPTURE_TYPES.includes(item?.type) ? item.type : "other";
+        let importance = Number(item?.importance);
+        if (!Number.isFinite(importance)) {
+            importance = type === "decision" ? 0.9 : type === "fact" ? 0.75 : 0.65;
+        }
+        importance = Math.max(0, Math.min(1, importance));
+        out.push({ content, type, importance });
+    }
+    return out.length > 0 ? out : null;
+}
+/**
+ * Pulls concatenated assistant text parts out of a session.prompt response
+ * (opencode SDK shape: { data: { info, parts } }).
+ */
+export function extractAssistantText(response) {
+    const payload = response && typeof response === "object" && "data" in response ? response.data : response;
+    const parts = payload?.parts;
+    if (!Array.isArray(parts))
+        return "";
+    return parts
+        .filter((p) => p?.type === "text" && typeof p?.text === "string")
+        .map((p) => p.text)
+        .join("\n")
+        .trim();
+}
+function hasUsableConfig(llmConfig, client) {
+    return Boolean(client?.session?.create && client?.session?.prompt && client?.session?.delete
+        && llmConfig?.provider && llmConfig?.model);
+}
+/**
+ * Runs one structured extraction pass over a session transcript via the
+ * opencode SDK. Returns [{content,type,importance}] on success — including [] 
+ * when the model finds nothing — or null on any failure (unreachable provider,
+ * timeout, unparseable reply, missing config).
+ */
+export async function requestLLMCapture(client, llmConfig, sessionText, sessionID) {
+    if (!hasUsableConfig(llmConfig, client))
+        return null;
+    const text = typeof sessionText === "string" ? sessionText.trim() : "";
+    if (!text)
+        return null;
+    const input = text.length > MAX_CAPTURE_INPUT_CHARS ? text.slice(0, MAX_CAPTURE_INPUT_CHARS) : text;
+    const userPart = `Conversation transcript (${sessionID ? `session ${sessionID}` : "session"}):\n\n${input}\n\nExtract memories now.`;
+    const reply = await runEphemeralPrompt(client, llmConfig, EXTRACTION_SYSTEM_PROMPT, userPart, "memory-capture");
+    if (reply === null) {
+        log("warn", "[capture] llm extraction returned nothing; falling back to heuristics");
+        return null;
+    }
+    const parsed = parseExtractionJSON(reply);
+    if (parsed === null) {
+        log("warn", `[capture] llm extraction reply was not parseable as structured JSON: ${reply.slice(0, 300)}`);
+        return null;
+    }
+    if (parsed.length === 0) {
+        log("info", "[capture] llm extraction succeeded but produced no memories; falling back to heuristics");
+        return parsed;
+    }
+    return parsed;
+}
+/**
+ * Generates one abstractive LLM digest for a group of memories. Returns
+ * { text, sourceCount } or null on any failure (caller falls back to the
+ * offline extractive digest).
+ */
+export async function requestLLMDigest(client, llmConfig, texts, targetChars, groupKey) {
+    if (!hasUsableConfig(llmConfig, client))
+        return null;
+    const safeTexts = Array.isArray(texts) ? texts.filter((t) => typeof t === "string" && t.trim().length > 0) : [];
+    if (safeTexts.length === 0)
+        return null;
+    let joined = safeTexts.map((t, i) => `[${i + 1}] ${t.trim()}`).join("\n\n");
+    if (joined.length > MAX_DIGEST_INPUT_CHARS) {
+        joined = joined.slice(0, MAX_DIGEST_INPUT_CHARS);
+    }
+    const userPart = `Topic: ${groupKey ?? "memories"}\nTarget length: ${Math.max(100, Number(targetChars) || 500)} characters\n\n${joined}\n\nWrite the summary now.`;
+    const system = DIGEST_SYSTEM_PROMPT
+        .replace("TARGETCHARS", String(Math.max(100, Number(targetChars) || 500)))
+        .replace("GROUPKEY", groupKey ?? "memories");
+    const reply = await runEphemeralPrompt(client, llmConfig, system, userPart, "memory-digest");
+    if (reply === null || reply.length === 0) {
+        log("warn", `[digest] llm digest failed for "${groupKey ?? "memories"}"; falling back to extractive digest`);
+        return null;
+    }
+    return { text: reply, sourceCount: safeTexts.length };
+}
+/**
+ * Shared ephemeral-session round trip: create → prompt (tools disabled) →
+ * delete (in finally). Returns the assistant's text, or null on failure.
+ */
+async function runEphemeralPrompt(client, llmConfig, system, userText, title) {
+    let sessionId = null;
+    try {
+        const created = await client.session.create({
+            body: { title: `opencode-memory-pro ${title}` },
+        });
+        const createdPayload = created && typeof created === "object" && "data" in created ? created.data : created;
+        sessionId = createdPayload?.id;
+        if (!sessionId) {
+            log("warn", `[llm] ${title}: session.create did not return an id (got ${JSON.stringify(createdPayload)?.slice(0, 200)})`);
+            return null;
+        }
+        OWN_SESSION_IDS.add(sessionId);
+        const response = await client.session.prompt({
+            path: { id: sessionId },
+            body: {
+                system,
+                parts: [{ type: "text", text: userText }],
+                model: { providerID: llmConfig.provider, modelID: llmConfig.model },
+                tools: {},
+            },
+        });
+        const text = extractAssistantText(response);
+        if (!text) {
+            log("warn", `[llm] ${title}: session.prompt succeeded but returned no text parts (provider=${llmConfig.provider}, model=${llmConfig.model})`);
+            return null;
+        }
+        return text;
+    }
+    catch (error) {
+        log("warn", `[llm] ${title}: ${error instanceof Error ? error.message : String(error)} (provider=${llmConfig.provider}, model=${llmConfig.model})`);
+        return null;
+    }
+    finally {
+        if (sessionId) {
+            try {
+                await client.session.delete({ path: { id: sessionId } });
+            }
+            catch (error) {
+                log("warn", `[llm] ${title}: ephemeral session cleanup failed for ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    }
+}

package/dist/logger.d.ts

@@ -0,0 +1,9 @@
+import type { OpencodeClient } from "@opencode-ai/sdk";
+type LogLevel = "debug" | "info" | "warn" | "error";
+export declare function initLogger(client: OpencodeClient): void;
+export declare function configureLogger(opts: {
+    logLevel?: string;
+    logFile?: string;
+}): void;
+export declare function log(level: LogLevel, message: string, extra?: Record<string, unknown>): void;
+export {};

package/dist/logger.js

@@ -0,0 +1,126 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import { homedir } from "node:os";
+
+const SERVICE_NAME = "opencode-memory-pro";
+const LOG_LEVELS = { debug: 10, info: 20, warn: 30, error: 40 };
+
+let _client = null;
+let _minLevel = LOG_LEVELS.info;
+let _logFile = null;
+
+function expandHomePath(path) {
+    if (typeof path !== "string" || path.length === 0)
+        return path;
+    if (path === "~")
+        return homedir();
+    if (path.startsWith("~/"))
+        return join(homedir(), path.slice(2));
+    if (!isAbsolute(path))
+        return join(process.cwd(), path);
+    return path;
+}
+
+function formatLine(level, message, extra) {
+    const timestamp = new Date().toISOString();
+    let line = `[${timestamp}] [${level.toUpperCase().padEnd(5)}] [${SERVICE_NAME}] ${message}`;
+    if (extra !== undefined) {
+        try {
+            line += ` ${JSON.stringify(extra)}`;
+        }
+        catch {
+            line += ` ${String(extra)}`;
+        }
+    }
+    return line;
+}
+
+function writeFileLog(level, message, extra) {
+    if (!_logFile)
+        return;
+    try {
+        appendFileSync(_logFile, formatLine(level, message, extra) + "\n", "utf8");
+    }
+    catch {
+        // File sink must never throw into the plugin flow — if the file is
+        // unwritable we degrade silently; the bus/console fallback still runs.
+    }
+}
+
+export function initLogger(client) {
+    _client = client;
+    if (process.env.OPENCODE_MEMORY_PRO_LOG_FILE) {
+        configureLogger({
+            logLevel: process.env.OPENCODE_MEMORY_PRO_LOG_LEVEL,
+            logFile: process.env.OPENCODE_MEMORY_PRO_LOG_FILE,
+        });
+    }
+}
+
+// Applies logger settings. Called from the plugin config hook once sidecar
+// config has been resolved (see resolveMemoryConfig -> logging section).
+// Idempotent: safe to call on every config re-resolution.
+export function configureLogger(opts = {}) {
+    if (opts && typeof opts === "object") {
+        // Accept both spellings: env path passes logLevel/logFile (initLogger),
+        // config path passes level/file (resolveMemoryConfig -> logging).
+        const file = opts.logFile ?? opts.file;
+        if (file) {
+            const expanded = expandHomePath(file);
+            try {
+                mkdirSync(dirname(expanded), { recursive: true });
+                _logFile = expanded;
+            }
+            catch (error) {
+                const err = error instanceof Error ? error.message : String(error);
+                console.warn(`[${SERVICE_NAME}] failed to open log file ${expanded}: ${err}`);
+                _logFile = null;
+            }
+        }
+        const level = opts.logLevel ?? opts.level;
+        if (level && LOG_LEVELS[level] !== undefined) {
+            _minLevel = LOG_LEVELS[level];
+        }
+    }
+}
+
+// Routes to client.app.log() when SDK client is bound, otherwise falls back to
+// console. Also appends to the configured log file when one is set.
+export function log(level, message, extra) {
+    const lvl = LOG_LEVELS[level] ?? LOG_LEVELS.info;
+    if (lvl < _minLevel)
+        return;
+    writeFileLog(level, message, extra);
+    if (_client?.app?.log) {
+        _client.app
+            .log({
+            body: {
+                service: SERVICE_NAME,
+                level,
+                message,
+                ...(extra !== undefined ? { extra } : {}),
+            },
+        })
+            .catch(() => consoleFallback(level, message));
+        return;
+    }
+    consoleFallback(level, message);
+}
+
+function consoleFallback(level, message) {
+    const formatted = `[${SERVICE_NAME}] ${message}`;
+    switch (level) {
+        case "error":
+            console.error(formatted);
+            break;
+        case "warn":
+            console.warn(formatted);
+            break;
+        case "info":
+            console.info(formatted);
+            break;
+        default:
+            console.log(formatted);
+            break;
+    }
+}

package/dist/ports.d.ts

@@ -0,0 +1,34 @@
+import type { MemoryRecord } from "./types.js";
+export interface PortServiceRequest {
+    name: string;
+    containerPort: number;
+    preferredHostPort?: number;
+}
+export interface PortReservation {
+    id: string;
+    project: string;
+    service: string;
+    hostPort: number;
+    containerPort: number;
+    protocol: "tcp";
+}
+export interface PortAssignment {
+    project: string;
+    service: string;
+    hostPort: number;
+    containerPort: number;
+    protocol: "tcp";
+}
+export interface PlanPortsInput {
+    project: string;
+    services: PortServiceRequest[];
+    rangeStart: number;
+    rangeEnd: number;
+    reservations: PortReservation[];
+}
+type PortChecker = (port: number) => Promise<boolean>;
+export declare function parsePortReservations(records: MemoryRecord[]): PortReservation[];
+export declare function planPorts(input: PlanPortsInput, checker?: PortChecker): Promise<PortAssignment[]>;
+export declare function reservationKey(project: string, service: string, protocol: "tcp"): string;
+export declare function isTcpPortAvailable(port: number): Promise<boolean>;
+export {};

package/dist/ports.js

@@ -0,0 +1,129 @@
+import { createServer } from "node:net";
+export function parsePortReservations(records) {
+    const parsed = [];
+    for (const record of records) {
+        let metadata;
+        try {
+            metadata = JSON.parse(record.metadataJson);
+        }
+        catch {
+            continue;
+        }
+        if (!isPortReservationMetadata(metadata))
+            continue;
+        parsed.push({
+            id: record.id,
+            project: metadata.project,
+            service: metadata.service,
+            hostPort: metadata.hostPort,
+            containerPort: metadata.containerPort,
+            protocol: "tcp",
+        });
+    }
+    return parsed;
+}
+export async function planPorts(input, checker = isTcpPortAvailable) {
+    const reservedByPort = new Map();
+    for (const reservation of input.reservations) {
+        const key = reservationKey(reservation.project, reservation.service, reservation.protocol);
+        if (!reservedByPort.has(reservation.hostPort)) {
+            reservedByPort.set(reservation.hostPort, new Set());
+        }
+        reservedByPort.get(reservation.hostPort)?.add(key);
+    }
+    const occupied = new Set();
+    const planUsed = new Set();
+    const checked = new Map();
+    const assignments = [];
+    for (const service of input.services) {
+        const serviceKey = reservationKey(input.project, service.name, "tcp");
+        const preferred = Number.isInteger(service.preferredHostPort) ? Number(service.preferredHostPort) : undefined;
+        const candidate = await pickCandidatePort({
+            preferredHostPort: preferred,
+            rangeStart: input.rangeStart,
+            rangeEnd: input.rangeEnd,
+            serviceKey,
+            reservedByPort,
+            occupied,
+            planUsed,
+            checked,
+            checker,
+        });
+        if (candidate === null) {
+            throw new Error(`No available host port for service '${service.name}' in range ${input.rangeStart}-${input.rangeEnd}.`);
+        }
+        planUsed.add(candidate);
+        occupied.add(candidate);
+        assignments.push({
+            project: input.project,
+            service: service.name,
+            hostPort: candidate,
+            containerPort: service.containerPort,
+            protocol: "tcp",
+        });
+    }
+    return assignments;
+}
+export function reservationKey(project, service, protocol) {
+    return `${project}\u0000${service}\u0000${protocol}`;
+}
+export async function isTcpPortAvailable(port) {
+    if (!isValidPort(port))
+        return false;
+    return new Promise((resolve) => {
+        const server = createServer();
+        const finish = (result) => {
+            server.removeAllListeners();
+            server.close(() => resolve(result));
+        };
+        server.once("error", () => finish(false));
+        server.once("listening", () => finish(true));
+        server.listen({ host: "0.0.0.0", port, exclusive: true });
+    });
+}
+function isPortReservationMetadata(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const data = value;
+    return data.type === "port-reservation"
+        && typeof data.project === "string"
+        && typeof data.service === "string"
+        && Number.isInteger(data.hostPort)
+        && Number.isInteger(data.containerPort)
+        && (data.protocol === undefined || data.protocol === "tcp");
+}
+async function pickCandidatePort(input) {
+    const candidates = [];
+    if (input.preferredHostPort !== undefined) {
+        candidates.push(input.preferredHostPort);
+    }
+    for (let port = input.rangeStart; port <= input.rangeEnd; port += 1) {
+        if (port === input.preferredHostPort)
+            continue;
+        candidates.push(port);
+    }
+    for (const port of candidates) {
+        if (!isValidPort(port))
+            continue;
+        if (input.planUsed.has(port) || input.occupied.has(port))
+            continue;
+        const owners = input.reservedByPort.get(port);
+        if (owners && (owners.size > 1 || !owners.has(input.serviceKey))) {
+            continue;
+        }
+        let free = input.checked.get(port);
+        if (free === undefined) {
+            free = await input.checker(port);
+            input.checked.set(port, free);
+        }
+        if (!free) {
+            input.occupied.add(port);
+            continue;
+        }
+        return port;
+    }
+    return null;
+}
+function isValidPort(port) {
+    return Number.isInteger(port) && port >= 1 && port <= 65535;
+}

package/dist/preference.d.ts

@@ -0,0 +1,10 @@
+import type { MemoryRecord, Preference, PreferenceScope, PreferenceSignal, PreferenceProfile } from "./types.js";
+export declare function extractPreferenceSignals(memory: MemoryRecord): PreferenceSignal[];
+export declare function aggregatePreferences(signals: PreferenceSignal[], scope: PreferenceScope): PreferenceProfile;
+export declare function resolveConflicts(projectPrefs: Preference[], globalPrefs: Preference[]): Preference[];
+export interface InjectionConfig {
+    mode: "budget" | "fixed";
+    maxMemories: number;
+    tokenBudget?: number;
+}
+export declare function buildPreferenceInjection(preferences: Preference[], config: InjectionConfig): string;

package/dist/preference.js

@@ -0,0 +1,125 @@
+const PREFERENCE_PATTERNS = [
+    { regex: /I prefer (?:using |)([\w#.+-]+)/i, category: "tool", source: "explicit" },
+    { regex: /I (?:always |)(?:use |use |using )([\w#.+-]+)/i, category: "tool", source: "explicit" },
+    { regex: /(?:prefer|preferred) (?:to |)([\w#.+-]+)/i, category: "tool", source: "explicit" },
+    { regex: /use ([\w#.+-]+) (?:for |)/i, category: "tool", source: "explicit" },
+    { regex: /I like (?:using |)([\w#.+-]+)/i, category: "tool", source: "explicit" },
+    { regex: /(typescript|javascript|python|rust|go|java)/i, category: "language", source: "explicit" },
+    { regex: /(jest|vitest|mocha|pytest|rubocop|prettier)/i, category: "tool", source: "explicit" },
+    { regex: /(react|vue|angular|svelte)/i, category: "tool", source: "explicit" },
+    { regex: /(eslint|prettier|black|ruff|gofmt)/i, category: "style", source: "explicit" },
+    { regex: /avoid (?:using |)([\w#.+-]+)/i, category: "tool", source: "explicit" },
+    { regex: /test(-|ing) (?:with |)([\w#.+-]+)/i, category: "tool", source: "explicit" },
+];
+const DEFAULT_DECAY_HALF_LIFE_DAYS = 30;
+export function extractPreferenceSignals(memory) {
+    const signals = [];
+    const text = memory.text;
+    for (const pattern of PREFERENCE_PATTERNS) {
+        const match = text.match(pattern.regex);
+        if (match) {
+            signals.push({
+                key: normalizePreferenceKey(match[1]),
+                value: match[1],
+                category: pattern.category,
+                source: pattern.source,
+                timestamp: memory.timestamp,
+                memoryId: memory.id,
+            });
+        }
+    }
+    return signals;
+}
+function normalizePreferenceKey(value) {
+    return value.toLowerCase().trim().replace(/\s+/g, "-");
+}
+export function aggregatePreferences(signals, scope) {
+    const preferenceMap = new Map();
+    for (const signal of signals) {
+        const existing = preferenceMap.get(signal.key);
+        if (existing) {
+            existing.count += 1;
+            if (signal.timestamp > existing.signal.timestamp) {
+                existing.signal = signal;
+            }
+        }
+        else {
+            preferenceMap.set(signal.key, { signal, count: 1 });
+        }
+    }
+    const preferences = [];
+    const now = Date.now();
+    for (const [key, data] of preferenceMap) {
+        const confidence = calculateConfidence(data.count, data.signal.timestamp, now);
+        preferences.push({
+            key,
+            value: data.signal.value,
+            category: data.signal.category,
+            confidence,
+            scope,
+            lastUpdated: data.signal.timestamp,
+            sourceCount: data.count,
+        });
+    }
+    preferences.sort((a, b) => b.confidence - a.confidence);
+    return {
+        scope,
+        preferences,
+        updatedAt: now,
+    };
+}
+function calculateConfidence(count, timestamp, now) {
+    const baseConfidence = Math.min(count / 5, 1);
+    const ageDays = (now - timestamp) / (1000 * 60 * 60 * 24);
+    const decayFactor = Math.pow(0.5, ageDays / DEFAULT_DECAY_HALF_LIFE_DAYS);
+    return baseConfidence * decayFactor;
+}
+export function resolveConflicts(projectPrefs, globalPrefs) {
+    const prefMap = new Map();
+    for (const pref of globalPrefs) {
+        prefMap.set(pref.key, { ...pref, scope: "global" });
+    }
+    for (const pref of projectPrefs) {
+        const existing = prefMap.get(pref.key);
+        if (!existing) {
+            prefMap.set(pref.key, { ...pref, scope: "project" });
+        }
+        else {
+            const winner = resolveSingleConflict(pref, existing);
+            prefMap.set(pref.key, winner);
+        }
+    }
+    return Array.from(prefMap.values()).sort((a, b) => b.confidence - a.confidence);
+}
+function resolveSingleConflict(a, b) {
+    if (a.lastUpdated > b.lastUpdated) {
+        return { ...a, scope: "project" };
+    }
+    return { ...b, scope: "global" };
+}
+export function buildPreferenceInjection(preferences, config) {
+    if (preferences.length === 0) {
+        return "";
+    }
+    const lines = [];
+    lines.push("## User Preferences");
+    if (config.mode === "fixed") {
+        const selected = preferences.slice(0, config.maxMemories);
+        for (const pref of selected) {
+            lines.push(`- [${pref.category}] ${pref.value} (confidence: ${Math.round(pref.confidence * 100)}%)`);
+        }
+    }
+    else {
+        let currentTokens = 0;
+        const budget = config.tokenBudget ?? 500;
+        for (const pref of preferences) {
+            const estimatedTokens = pref.value.length / 4;
+            if (currentTokens + estimatedTokens > budget) {
+                break;
+            }
+            lines.push(`- [${pref.category}] ${pref.value}`);
+            currentTokens += estimatedTokens;
+        }
+    }
+    return lines.join("\n");
+}

package/dist/scope.d.ts

@@ -0,0 +1,2 @@
+export declare function deriveProjectScope(worktree: string): string;
+export declare function buildScopeFilter(activeScope: string, includeGlobal: boolean): string[];