om-memory-system 3.0.0 → 3.1.0-next.4

package/dist/importer/opencode-reader.d.ts

@@ -0,0 +1,19 @@
+import type { ImportSourceSession } from "./importer.js";
+export interface OpencodeSourceSession extends ImportSourceSession {
+    recordedDirectory: string;
+    projectWorktree: string | null;
+    timeCreated: number;
+}
+export interface OpencodeReader {
+    childSessions: number;
+    topLevelSessions: number;
+    sessions: AsyncIterable<OpencodeSourceSession>;
+}
+export interface OpencodeReaderFilters {
+    session?: string;
+    maxSessions?: number;
+    since?: number;
+    until?: number;
+}
+/** Read V1 OpenCode history without changing its database or WAL sidecars. */
+export declare function readOpencodeHistory(dbPath: string, filters?: OpencodeReaderFilters): OpencodeReader;

package/dist/importer/opencode-reader.js

@@ -0,0 +1,214 @@
+import { constants, copyFileSync, existsSync, mkdtempSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { DatabaseSync } from "node:sqlite";
+import { INTERNAL_CAPTURE_SESSION_TITLES } from "../services/ai/internal-capture-sessions.js";
+function validateSchema(db) {
+    const required = {
+        session: ["id", "directory", "project_id", "parent_id", "time_created"],
+        project: ["id", "worktree"],
+        message: ["id", "session_id", "time_created", "data"],
+        part: ["id", "message_id", "session_id", "time_created", "data"],
+    };
+    for (const [table, columns] of Object.entries(required)) {
+        const found = db
+            .prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?")
+            .get(table);
+        if (!found)
+            throw new Error(`Unsupported OpenCode V1 database: missing ${table} table`);
+        const names = new Set(db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name));
+        for (const column of columns) {
+            if (!names.has(column))
+                throw new Error(`Unsupported OpenCode V1 database: missing ${table}.${column}`);
+        }
+    }
+}
+function parseData(json) {
+    try {
+        const parsed = JSON.parse(json);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function boundInput(value) {
+    const text = typeof value === "string" ? value : JSON.stringify(value ?? "");
+    return text.length > 100 ? `${text.slice(0, 100)}...` : text;
+}
+function buildWindows(db, sessionId, filters) {
+    const messages = db
+        .prepare("SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created, id")
+        .all(sessionId);
+    const parts = db
+        .prepare("SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created, id")
+        .all(sessionId);
+    const byMessage = new Map();
+    for (const part of parts) {
+        const entries = byMessage.get(part.message_id) ?? [];
+        entries.push(parseData(part.data));
+        byMessage.set(part.message_id, entries);
+    }
+    const units = [];
+    let current = null;
+    for (const message of messages) {
+        const role = parseData(message.data).role;
+        const content = byMessage.get(message.id) ?? [];
+        if (role === "user") {
+            if (current?.sourceEntryIds?.length)
+                units.push(current);
+            const prompt = content
+                .filter((part) => part.type === "text" &&
+                !part.synthetic &&
+                !part.ignored &&
+                typeof part.text === "string")
+                .map((part) => part.text)
+                .join("\n")
+                .trim();
+            const timestamp = Number(message.time_created);
+            current =
+                prompt &&
+                    (filters.since === undefined || timestamp >= filters.since) &&
+                    (filters.until === undefined || timestamp <= filters.until)
+                    ? {
+                        userEntryId: message.id,
+                        userPrompt: prompt,
+                        userTimestamp: timestamp,
+                        sourceTimestamp: timestamp,
+                        textResponses: [],
+                        toolCalls: [],
+                        sourceEntryIds: [],
+                    }
+                    : null;
+            continue;
+        }
+        if (role !== "assistant" || !current)
+            continue;
+        current.sourceEntryIds.push(message.id);
+        for (const part of content) {
+            if (part.type === "text" && typeof part.text === "string" && !part.synthetic) {
+                current.textResponses.push(part.text);
+            }
+            else if (part.type === "tool" || part.type === "agent" || part.type === "subtask") {
+                const state = part.state && typeof part.state === "object"
+                    ? part.state
+                    : {};
+                current.toolCalls.push({
+                    name: String(part.tool ?? part.name ?? part.type),
+                    input: boundInput(state.input ?? part.input ?? ""),
+                });
+            }
+        }
+    }
+    if (current?.sourceEntryIds?.length)
+        units.push(current);
+    return units;
+}
+function fileStamp(path) {
+    const info = statSync(path, { bigint: true });
+    return `${info.size}:${info.mtimeNs}`;
+}
+/**
+ * Copy the database and its WAL into a private folder. `immutable=1` ignores
+ * the WAL, and a normal open writes to OpenCode's `-shm`, so a copy is the only
+ * way to see uncheckpointed turns while leaving every source file untouched.
+ * A copy that raced a write or checkpoint is discarded and retried.
+ */
+function snapshotWalDatabase(dbPath) {
+    const dir = mkdtempSync(join(tmpdir(), "omms-opencode-"));
+    const cleanup = () => rmSync(dir, { recursive: true, force: true });
+    const copy = join(dir, "opencode.db");
+    try {
+        for (let attempt = 0; attempt < 5; attempt++) {
+            const before = [fileStamp(dbPath), fileStamp(`${dbPath}-wal`)];
+            // Clone where the file system supports it (APFS, Btrfs): large databases copy instantly.
+            copyFileSync(dbPath, copy, constants.COPYFILE_FICLONE);
+            copyFileSync(`${dbPath}-wal`, `${copy}-wal`, constants.COPYFILE_FICLONE);
+            const after = [fileStamp(dbPath), fileStamp(`${dbPath}-wal`)];
+            if (before[0] === after[0] && before[1] === after[1])
+                return { path: copy, cleanup };
+        }
+    }
+    catch (error) {
+        cleanup();
+        throw error;
+    }
+    cleanup();
+    throw new Error("OpenCode database kept changing while it was copied; retry the import");
+}
+function openSnapshot(dbPath) {
+    if (!existsSync(`${dbPath}-wal`)) {
+        // No WAL: every committed page is in the main file, so read it in place.
+        const uri = `${pathToFileURL(dbPath).href}?immutable=1`;
+        return { db: new DatabaseSync(uri, { readOnly: true }), cleanup: () => { } };
+    }
+    const snapshot = snapshotWalDatabase(dbPath);
+    try {
+        return { db: new DatabaseSync(snapshot.path), cleanup: snapshot.cleanup };
+    }
+    catch (error) {
+        snapshot.cleanup();
+        throw error;
+    }
+}
+/** Read V1 OpenCode history without changing its database or WAL sidecars. */
+export function readOpencodeHistory(dbPath, filters = {}) {
+    if (!existsSync(dbPath))
+        throw new Error(`OpenCode database not found: ${dbPath}`);
+    const { db, cleanup } = openSnapshot(dbPath);
+    const close = () => {
+        db.close();
+        cleanup();
+    };
+    try {
+        validateSchema(db);
+        // omms's own capture/profile calls run in OpenCode sessions; never import them as history.
+        const hasTitle = db.prepare("PRAGMA table_info(session)").all().some((column) => column.name === "title");
+        const notInternal = hasTitle
+            ? `AND (s.title IS NULL OR s.title NOT IN (${INTERNAL_CAPTURE_SESSION_TITLES.map(() => "?").join(", ")}))`
+            : "";
+        const internalArgs = hasTitle ? [...INTERNAL_CAPTURE_SESSION_TITLES] : [];
+        const count = (where) => Number(db
+            .prepare(`SELECT COUNT(*) AS count FROM session s WHERE ${where} ${notInternal}`)
+            .get(...internalArgs).count);
+        const childSessions = count("s.parent_id IS NOT NULL");
+        const topLevelSessions = count("s.parent_id IS NULL");
+        const sessions = {
+            async *[Symbol.asyncIterator]() {
+                try {
+                    const query = `SELECT s.id, s.directory, p.worktree AS project_worktree, s.time_created
+            FROM session s LEFT JOIN project p ON p.id = s.project_id
+            WHERE s.parent_id IS NULL ${notInternal} ${filters.session ? "AND s.id = ?" : ""}
+            ORDER BY s.time_created, s.id ${filters.maxSessions ? "LIMIT ?" : ""}`;
+                    const args = [...internalArgs];
+                    if (filters.session)
+                        args.push(filters.session);
+                    if (filters.maxSessions)
+                        args.push(filters.maxSessions);
+                    for (const row of db.prepare(query).all(...args)) {
+                        yield {
+                            sessionId: row.id,
+                            recordedDirectory: row.directory,
+                            directory: row.directory,
+                            sourceFile: dbPath,
+                            projectWorktree: row.project_worktree,
+                            timeCreated: row.time_created,
+                            units: buildWindows(db, row.id, filters),
+                        };
+                    }
+                }
+                finally {
+                    close();
+                }
+            },
+        };
+        return { childSessions, topLevelSessions, sessions };
+    }
+    catch (error) {
+        close();
+        throw error;
+    }
+}

package/dist/importer/profile-import.d.ts

@@ -0,0 +1,29 @@
+import { type ModelPort } from "../core/profile-analysis.js";
+import { userProfileManager } from "../services/user-profile/user-profile-manager.js";
+import { userPromptManager } from "../services/user-prompt/user-prompt-manager.js";
+import type { MemoryHost } from "../types/index.js";
+import { type ImportSourceSession } from "./importer.js";
+import { ImportLedger } from "./ledger.js";
+export interface ProfileImportReport {
+    promptsRecorded: number;
+    promptsWouldRecord: number;
+    promptsAlreadyHandled: number;
+    batchesBuilt: number;
+    remaining: number;
+    error?: string;
+}
+type PromptStore = Pick<typeof userPromptManager, "savePrompt" | "markAsCaptured" | "countUnanalyzedForUserLearning" | "getPromptsForUserLearning" | "markMultipleAsUserLearningCaptured">;
+type ProfileStore = Pick<typeof userProfileManager, "getActiveProfile" | "createProfile" | "updateProfile">;
+type Ledger = Pick<ImportLedger, "get" | "begin" | "complete"> & Partial<Pick<ImportLedger, "peek">>;
+export interface ProfileImportOptions {
+    host: MemoryHost;
+    dryRun?: boolean;
+    batchSize?: number;
+    model?: ModelPort;
+    ledger?: Ledger;
+    promptStore?: PromptStore;
+    profileStore?: ProfileStore;
+}
+/** Record historical prompts and build or update the user profile in batches. */
+export declare function importProfileFromHistory(source: AsyncIterable<ImportSourceSession> | Iterable<ImportSourceSession>, options: ProfileImportOptions): Promise<ProfileImportReport>;
+export {};

package/dist/importer/profile-import.js

@@ -0,0 +1,111 @@
+import { isInternalPrompt } from "../adapters/opencode/user-prompt.js";
+import { analyzeProfile } from "../core/profile-analysis.js";
+import { isFullyPrivate, stripPrivateContent } from "../services/privacy.js";
+import { getTags } from "../services/tags.js";
+import { userProfileManager } from "../services/user-profile/user-profile-manager.js";
+import { userPromptManager } from "../services/user-prompt/user-prompt-manager.js";
+import { buildImportKey } from "./importer.js";
+import { existsSync } from "node:fs";
+import { ImportLedger, importLedgerDbPath } from "./ledger.js";
+/** Record historical prompts and build or update the user profile in batches. */
+export async function importProfileFromHistory(source, options) {
+    if (!options.dryRun && !options.model)
+        throw new Error("Profile import needs a model");
+    const batchSize = options.batchSize ?? 50;
+    if (!Number.isSafeInteger(batchSize) || batchSize < 1) {
+        throw new Error("Profile batch size must be a positive integer");
+    }
+    const report = {
+        promptsRecorded: 0,
+        promptsWouldRecord: 0,
+        promptsAlreadyHandled: 0,
+        batchesBuilt: 0,
+        remaining: 0,
+    };
+    const ledger = options.ledger ?? new ImportLedger();
+    // A dry run reads the ledger only when it exists, so a preview never creates it.
+    const ledgerReadable = !options.dryRun || Boolean(options.ledger) || existsSync(importLedgerDbPath());
+    const prompts = options.promptStore ?? userPromptManager;
+    const profiles = options.profileStore ?? userProfileManager;
+    let directory;
+    for await (const session of source) {
+        for (const unit of session.units) {
+            const prompt = stripPrivateContent(unit.userPrompt).trim();
+            if (!prompt ||
+                isFullyPrivate(unit.userPrompt) ||
+                isInternalPrompt(session.sessionId, prompt)) {
+                continue;
+            }
+            const key = buildImportKey(session.sessionId, unit, options.host);
+            if (!key)
+                continue;
+            directory ??= session.directory;
+            const profileKey = `${key}#profile`;
+            const existing = !ledgerReadable
+                ? null
+                : options.dryRun && ledger.peek
+                    ? await ledger.peek(profileKey)
+                    : await ledger.get(profileKey);
+            if (existing?.status === "imported") {
+                report.promptsAlreadyHandled++;
+                continue;
+            }
+            if (options.dryRun) {
+                report.promptsWouldRecord++;
+                continue;
+            }
+            await ledger.begin({
+                key: profileKey,
+                sessionId: session.sessionId,
+                sourceFile: session.sourceFile,
+                projectHash: "profile",
+            });
+            // savePrompt also deduplicates a retry after a crash before ledger completion.
+            const promptId = await prompts.savePrompt(session.sessionId, unit.userEntryId, session.directory, prompt);
+            await prompts.markAsCaptured(promptId);
+            await ledger.complete(profileKey, promptId);
+            report.promptsRecorded++;
+        }
+    }
+    if (options.dryRun || !directory)
+        return report;
+    const user = getTags(directory).user;
+    if (!user.userEmail) {
+        report.remaining = await prompts.countUnanalyzedForUserLearning();
+        report.error = "Profile import needs a user email";
+        return report;
+    }
+    const model = options.model;
+    while ((report.remaining = await prompts.countUnanalyzedForUserLearning()) > 0) {
+        const batch = await prompts.getPromptsForUserLearning(batchSize);
+        if (batch.length === 0)
+            break;
+        let succeeded = false;
+        for (let attempt = 0; attempt < 2 && !succeeded; attempt++) {
+            try {
+                const existing = await profiles.getActiveProfile(user.userEmail);
+                const context = batch.map((item, index) => `${index + 1}. ${item.content}`).join("\n");
+                const analysis = await analyzeProfile(model, context, existing ? { id: existing.id, profileData: existing.profileData } : null);
+                if (existing) {
+                    if (!analysis.merged ||
+                        !(await profiles.updateProfile(existing.id, analysis.merged, batch.length, `History import of ${batch.length} prompts`)))
+                        throw new Error("Profile update conflict");
+                }
+                else {
+                    await profiles.createProfile(user.userEmail, user.displayName || user.userEmail, user.userName || user.userEmail, user.userEmail, analysis.raw, batch.length);
+                }
+                await prompts.markMultipleAsUserLearningCaptured(batch.map((item) => item.id));
+                report.batchesBuilt++;
+                succeeded = true;
+            }
+            catch (error) {
+                if (attempt === 1) {
+                    report.error = error instanceof Error ? error.message : String(error);
+                    report.remaining = await prompts.countUnanalyzedForUserLearning();
+                    return report;
+                }
+            }
+        }
+    }
+    return report;
+}

package/dist/importer/run-import.d.ts

@@ -0,0 +1,49 @@
+import type { CaptureSummaryProvider } from "../core/host.js";
+import type { ModelPort } from "../core/profile-analysis.js";
+import type { HistoryImportArgs, ImportHost } from "./import-args.js";
+import type { ImportReport } from "./importer.js";
+import type { UnresolvedProject } from "./opencode-project.js";
+/** The two model roles an import uses; absent in a dry run or when the step is skipped. */
+export interface HistoryImportModels {
+    capture?: CaptureSummaryProvider;
+    profile?: ModelPort;
+}
+export interface HistoryImportRun {
+    /** Directory that relative paths and the default project resolve against. */
+    cwd: string;
+    models: HistoryImportModels;
+    onProgress?: (processed: number, total: number, promptPreview: string) => void;
+}
+export type HistoryImportReport = ImportReport & {
+    childSessionsFolded?: number;
+    unresolvedProjects?: UnresolvedProject[];
+};
+/** Run one host's history import with already-parsed, validated arguments. */
+export declare function runHistoryImport(host: ImportHost, args: HistoryImportArgs, run: HistoryImportRun): Promise<HistoryImportReport>;
+/** The same plain-text report for every host and surface. */
+export declare function formatHistoryImportReport(host: ImportHost, report: HistoryImportReport, model?: string): string;
+/** Counts and identifiers for the log. Unit previews hold prompt text, so they stay out. */
+export declare function summarizeHistoryImportReport(report: HistoryImportReport): {
+    dryRun: boolean;
+    sessionsDiscovered: number;
+    sessionsLoaded: number;
+    sessionsFilteredOut: number;
+    unitsTotal: number;
+    unitsImported: number;
+    unitsWouldImport: number;
+    unitsSkipped: number;
+    unitsFailed: number;
+    unitsAlreadyHandled: number;
+    projects: number;
+    unresolved: number;
+    loadErrors: number;
+    profile: {
+        promptsRecorded: number;
+        promptsWouldRecord: number;
+        batchesBuilt: number;
+        remaining: number;
+        failed: boolean;
+    } | undefined;
+};
+/** A failed unit or profile step makes the whole run unsuccessful. */
+export declare function historyImportFailed(report: HistoryImportReport): boolean;

package/dist/importer/run-import.js

@@ -0,0 +1,123 @@
+import { resolve } from "node:path";
+const dryRunCapture = {
+    summarize: async () => {
+        throw new Error("A dry-run cannot call the capture model");
+    },
+};
+/** Run one host's history import with already-parsed, validated arguments. */
+export async function runHistoryImport(host, args, run) {
+    const at = (path) => resolve(run.cwd, path);
+    const project = args.scope === "current-project" ? at(args.project ?? ".") : undefined;
+    const pathMaps = args.pathMaps.map((map) => ({ from: map.from, to: at(map.to) }));
+    const capture = run.models.capture ?? dryRunCapture;
+    if (host === "opencode") {
+        const { importOpencodeHistory } = await import("./opencode-import.js");
+        return importOpencodeHistory({
+            ...(args.source ? { dbPath: at(args.source) } : {}),
+            dryRun: args.dryRun,
+            ...(args.since !== undefined ? { since: args.since } : {}),
+            ...(args.until !== undefined ? { until: args.until } : {}),
+            ...(args.session ? { session: args.session } : {}),
+            ...(project ? { project } : {}),
+            ...(args.maxSessions ? { maxSessions: args.maxSessions } : {}),
+            ...(args.profileBatch ? { profileBatch: args.profileBatch } : {}),
+            pathMaps,
+            force: args.force,
+            skipMemories: args.skipMemories,
+            skipProfile: args.skipProfile,
+            ...(run.models.capture ? { provider: capture } : {}),
+            ...(run.models.profile ? { profileModel: run.models.profile } : {}),
+        });
+    }
+    const { importPiHistory } = await import("./importer.js");
+    const { loadPiSessionForImport } = await import("./session-loader.js");
+    return importPiHistory({
+        loadSession: loadPiSessionForImport,
+        provider: capture,
+        ...(run.onProgress ? { onProgress: run.onProgress } : {}),
+        ...(!args.skipProfile
+            ? {
+                profile: {
+                    ...(run.models.profile ? { model: run.models.profile } : {}),
+                    ...(args.profileBatch ? { batchSize: args.profileBatch } : {}),
+                },
+            }
+            : {}),
+    }, {
+        scope: args.scope,
+        currentDirectory: project ?? run.cwd,
+        ...(args.session ? { session: args.session } : {}),
+        ...(args.since !== undefined ? { since: args.since } : {}),
+        ...(args.until !== undefined ? { until: args.until } : {}),
+        ...(args.maxSessions ? { maxSessions: args.maxSessions } : {}),
+        ...(args.source ? { root: at(args.source) } : {}),
+        force: args.force,
+        dryRun: args.dryRun,
+        skipMemories: args.skipMemories,
+        pathMaps,
+    });
+}
+/** The same plain-text report for every host and surface. */
+export function formatHistoryImportReport(host, report, model) {
+    const lines = [
+        `${host === "pi" ? "Pi" : "OpenCode"} history import${report.dryRun ? " (dry-run)" : ""}`,
+    ];
+    if (model)
+        lines.push(`  model: ${model}`);
+    lines.push(`  sessions: ${report.sessionsLoaded}/${report.sessionsDiscovered} loaded, ${report.sessionsFilteredOut} filtered out` +
+        (report.childSessionsFolded !== undefined
+            ? `, ${report.childSessionsFolded} child sessions folded`
+            : ""));
+    lines.push(`  memory units: ${report.unitsWouldImport} pending, ${report.unitsAlreadyHandled} already done, ` +
+        `${report.unitsImported} imported, ${report.unitsSkipped} skipped, ${report.unitsFailed} failed`);
+    for (const project of report.projects) {
+        lines.push(`  project ${project.directory}: ${project.sessions} sessions, ${project.units} units`);
+    }
+    for (const unresolved of report.unresolvedProjects ?? []) {
+        lines.push(`  unresolved ${unresolved.directory}: ${unresolved.sessions} sessions, ${unresolved.units} units (use --map)`);
+    }
+    for (const unresolvable of report.unresolvableSessions) {
+        lines.push(`  unresolved ${unresolvable.cwd ?? "(no cwd)"}: ${unresolvable.file} (use --map)`);
+    }
+    if (report.loadErrors.length > 0)
+        lines.push(`  load errors: ${report.loadErrors.length}`);
+    if (report.profile) {
+        lines.push(`  profile prompts: ${report.profile.promptsWouldRecord} pending, ${report.profile.promptsRecorded} recorded, ` +
+            `${report.profile.promptsAlreadyHandled} already done; ${report.profile.batchesBuilt} batches, ` +
+            `${report.profile.remaining} remaining`);
+        if (report.profile.error)
+            lines.push(`  profile error: ${report.profile.error}`);
+    }
+    return lines.join("\n");
+}
+/** Counts and identifiers for the log. Unit previews hold prompt text, so they stay out. */
+export function summarizeHistoryImportReport(report) {
+    return {
+        dryRun: report.dryRun,
+        sessionsDiscovered: report.sessionsDiscovered,
+        sessionsLoaded: report.sessionsLoaded,
+        sessionsFilteredOut: report.sessionsFilteredOut,
+        unitsTotal: report.unitsTotal,
+        unitsImported: report.unitsImported,
+        unitsWouldImport: report.unitsWouldImport,
+        unitsSkipped: report.unitsSkipped,
+        unitsFailed: report.unitsFailed,
+        unitsAlreadyHandled: report.unitsAlreadyHandled,
+        projects: report.projects.length,
+        unresolved: (report.unresolvedProjects?.length ?? 0) + report.unresolvableSessions.length,
+        loadErrors: report.loadErrors.length,
+        profile: report.profile
+            ? {
+                promptsRecorded: report.profile.promptsRecorded,
+                promptsWouldRecord: report.profile.promptsWouldRecord,
+                batchesBuilt: report.profile.batchesBuilt,
+                remaining: report.profile.remaining,
+                failed: Boolean(report.profile.error),
+            }
+            : undefined,
+    };
+}
+/** A failed unit or profile step makes the whole run unsuccessful. */
+export function historyImportFailed(report) {
+    return report.unitsFailed > 0 || Boolean(report.profile?.error);
+}

package/dist/index.d.ts

@@ -13,6 +13,10 @@ export { isStructuredSummaryPromptMessage };
  * 3. Latest non-compaction / non-summary assistant mode (v1) or agent (v2)
  */
 export declare function resolveSessionAgent(client: unknown, sessionID: string): Promise<string | undefined>;
+/** Register `/memory-import-opencode-history`; its work happens in command.execute.before. */
+export declare function applyHistoryImportCommandConfig(cfg: {
+    command?: Record<string, unknown>;
+}): void;
 /** Least-privilege agent used only by internal structured-output sessions (issue #189). */
 export declare function applyStructuredOutputAgentConfig(cfg: {
     agent?: Record<string, unknown>;

package/dist/index.js

@@ -6,6 +6,7 @@ import { performAutoCapture } from "./services/auto-capture.js";
 import { createOpenCodeAutoCaptureHost } from "./adapters/opencode/auto-capture-host.js";
 import { isInternalPrompt, isStructuredSummaryPromptMessage, recordUserPrompt, } from "./adapters/opencode/user-prompt.js";
 import { executeMemoryOperation } from "./core/memory-operations.js";
+import { OPENCODE_IMPORT_COMMAND, OPENCODE_IMPORT_DESCRIPTION, latestUserMessageModel, runOpencodeImportCommand, } from "./adapters/opencode/import-command.js";
 import { formatMemoriesForCompaction } from "./core/retrieval.js";
 import { performUserProfileLearning } from "./services/user-memory-learning.js";
 import { userPromptManager } from "./services/user-prompt/user-prompt-manager.js";
@@ -14,6 +15,7 @@ import { ensureTursoReady } from "./services/turso/ready.js";
 import { tursoConnectionManager } from "./services/turso/connection-manager.js";
 import { WebAuth } from "./services/web-auth.js";
 import { isConfigured, CONFIG, initConfigWithLegacyMigration } from "./config.js";
+import { resolveOpencodeHostModel } from "./services/ai/live-model-choice.js";
 import { log } from "./services/logger.js";
 import { getLanguageName } from "./services/language-detector.js";
 import { getHostClientConfig } from "./services/ai/opencode-host-config.js";
@@ -121,6 +123,16 @@ async function isInternalCaptureSession(client, sessionID) {
     }
     return false;
 }
+/** Register `/memory-import-opencode-history`; its work happens in command.execute.before. */
+export function applyHistoryImportCommandConfig(cfg) {
+    cfg.command = {
+        ...cfg.command,
+        [OPENCODE_IMPORT_COMMAND]: {
+            template: "Import OpenCode history into omms: $ARGUMENTS",
+            description: OPENCODE_IMPORT_DESCRIPTION,
+        },
+    };
+}
 /** Least-privilege agent used only by internal structured-output sessions (issue #189). */
 export function applyStructuredOutputAgentConfig(cfg) {
     cfg.agent = {
@@ -375,6 +387,29 @@ export const OmmsPlugin = async (ctx) => {
         dispose: disposePlugin,
         config: async (cfg) => {
             applyStructuredOutputAgentConfig(cfg);
+            applyHistoryImportCommandConfig(cfg);
+        },
+        // V1 runs slash commands as a model turn; do the import here and hand the
+        // turn only the finished report to relay.
+        "command.execute.before": async (input, output) => {
+            if (input.command !== OPENCODE_IMPORT_COMMAND)
+                return;
+            const report = await runOpencodeImportCommand({
+                argsText: input.arguments ?? "",
+                directory,
+                sessionModel: () => latestUserMessageModel(ctx.client, input.sessionID),
+                notify: (message) => {
+                    void ctx.client?.tui
+                        ?.showToast({
+                        body: { title: "omms import", message, variant: "info", duration: 3000 },
+                    })
+                        .catch(() => { });
+                },
+            });
+            output.parts.splice(0, output.parts.length, {
+                type: "text",
+                text: `Reply with this omms history import report exactly as written and nothing else:\n\n\`\`\`\n${report}\n\`\`\``,
+            });
         },
         "chat.message": async (input, output) => {
             if (!isConfigured() || !CONFIG.chatMessage.enabled)
@@ -454,7 +489,8 @@ export const OmmsPlugin = async (ctx) => {
             }
         },
         "chat.params": async (input) => {
-            if (!isConfigured() || CONFIG.opencodeModel !== "inherit")
+            // Record the session model whenever live calls follow it ("inherit" or nothing configured).
+            if (!isConfigured() || resolveOpencodeHostModel(CONFIG)?.modelID !== "inherit")
                 return;
             try {
                 await userPromptManager.setPromptModel(input.message.id, input.model.providerID, input.model.id);

package/dist/services/ai/internal-capture-sessions.d.ts

@@ -1,5 +1,7 @@
 /** Title used for transient structured-output sessions (capture / profile learning). */
 export declare const INTERNAL_CAPTURE_SESSION_TITLE = "omms capture";
+/** Every title omms has used for its own sessions (capture, profile learning, profile cleanup). */
+export declare const INTERNAL_CAPTURE_SESSION_TITLES: readonly ["omms capture", "opencode-mem capture", "omms profile cleanup", "opencode-mem profile cleanup"];
 export declare function isInternalCaptureSessionTitle(title: string | undefined | null): boolean;
 export declare function trackInternalCaptureSession(sessionID: string): void;
 export declare function untrackInternalCaptureSession(sessionID: string): void;

package/dist/services/ai/internal-capture-sessions.js

@@ -6,6 +6,13 @@ const LEGACY_INTERNAL_CAPTURE_SESSION_TITLE = "opencode-mem capture";
 const UNTRACK_GRACE_MS = 60_000;
 const trackedSessionIDs = new Set();
 const untrackTimers = new Map();
+/** Every title omms has used for its own sessions (capture, profile learning, profile cleanup). */
+export const INTERNAL_CAPTURE_SESSION_TITLES = [
+    INTERNAL_CAPTURE_SESSION_TITLE,
+    LEGACY_INTERNAL_CAPTURE_SESSION_TITLE,
+    "omms profile cleanup",
+    "opencode-mem profile cleanup",
+];
 export function isInternalCaptureSessionTitle(title) {
     return (title === INTERNAL_CAPTURE_SESSION_TITLE || title === LEGACY_INTERNAL_CAPTURE_SESSION_TITLE);
 }