om-memory-system 3.0.0

package/dist/adapters/pi/extension.js

@@ -0,0 +1,234 @@
+import { Type } from "typebox";
+import { CONFIG, initConfigWithLegacyMigration, isConfigured } from "../../config.js";
+import { executeMemoryOperation } from "../../core/memory-operations.js";
+import { getLanguageName } from "../../services/language-detector.js";
+import { log } from "../../services/logger.js";
+import { memoryClient } from "../../services/client.js";
+import { capturePiSettledWorkUnit, createPiCaptureState } from "./capture.js";
+import { createPiCaptureProvider } from "./provider.js";
+import { resolveModelFromContext } from "./provider.js";
+import { registerPiHistoryImportCommand } from "./import-command.js";
+import { performPiProfileLearning } from "./profile.js";
+import { buildRetrievalSection, wrapRetrievalSection } from "../../core/retrieval.js";
+const GLOBAL_PLUGIN_WARMUP_KEY = Symbol.for("omms.plugin.warmedup");
+const OMMS_STATUS_KEY = "omms";
+const MEMORY_TOOL_MODES = [
+    "add",
+    "search",
+    "profile",
+    "list",
+    "forget",
+    "help",
+    "migrate",
+    "list-shards",
+    "export",
+    "import",
+];
+function toSessionEntries(branch) {
+    return Array.isArray(branch) ? branch : [];
+}
+function lastSettledUserPrompt(entries) {
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.type !== "message" || entry.message?.role !== "user")
+            continue;
+        const content = entry.message.content;
+        if (typeof content === "string" && content.trim())
+            return content;
+        if (Array.isArray(content)) {
+            const text = content
+                .filter((block) => block.type === "text" && typeof block.text === "string")
+                .map((block) => block.text)
+                .join("\n")
+                .trim();
+            if (text)
+                return text;
+        }
+        return null;
+    }
+    return null;
+}
+/**
+ * Pi extension entry point for the shared omms engine.
+ *
+ * Lifecycle mapping:
+ * - `session_start`        -> load shared config for ctx.cwd, warm storage
+ * - `before_agent_start`   -> prompt-aware semantic retrieval, injected as a
+ *                             delimited system-prompt section (never a fake
+ *                             user message)
+ * - `agent_settled`        -> automatic capture of the settled work unit
+ * - `session_shutdown`     -> idempotent session-scoped cleanup
+ * - `memory` tool          -> shared add/search/profile/list/forget/help and
+ *                             portability operations
+ *
+ * Pi types are imported type-only: the compiled extension carries no Pi
+ * runtime dependency and uses the host Pi runtime provided at load time.
+ */
+export default function ommsPiExtension(pi) {
+    let captureState = createPiCaptureState();
+    let promptsSinceProfileAnalysis = [];
+    // Latest session context, refreshed on session_start and consumed by the
+    // import command (command contexts do not expose the model registry).
+    let latestCtx = null;
+    let statusVersion = 0;
+    const startStatus = (ctx, status) => {
+        const version = ++statusVersion;
+        if (ctx.hasUI)
+            ctx.ui.setStatus(OMMS_STATUS_KEY, `omms:${status}`);
+        return version;
+    };
+    const finishStatus = (ctx, version, status) => {
+        if (version !== statusVersion || !ctx.hasUI)
+            return;
+        ctx.ui.setStatus(OMMS_STATUS_KEY, `omms:${status}`);
+    };
+    const clearStatus = (ctx) => {
+        statusVersion++;
+        if (ctx.hasUI)
+            ctx.ui.setStatus(OMMS_STATUS_KEY, undefined);
+    };
+    const notify = (ctx) => (notification) => {
+        if (!ctx.hasUI)
+            return;
+        const level = notification.variant === "success" ? "info" : notification.variant;
+        ctx.ui.notify(`${notification.title}: ${notification.message}`, level);
+    };
+    const resolveModel = (ctx) => resolveModelFromContext(ctx);
+    pi.on("session_start", async (_event, ctx) => {
+        const status = startStatus(ctx, "warming");
+        try {
+            latestCtx = ctx;
+            initConfigWithLegacyMigration(ctx.cwd);
+            captureState = createPiCaptureState();
+            const globalScope = globalThis;
+            if (!globalScope[GLOBAL_PLUGIN_WARMUP_KEY] && isConfigured()) {
+                (async () => {
+                    try {
+                        await memoryClient.warmup();
+                        globalScope[GLOBAL_PLUGIN_WARMUP_KEY] = true;
+                        finishStatus(ctx, status, "connected");
+                    }
+                    catch (error) {
+                        log("Pi plugin memory warmup failed", { error: String(error) });
+                        finishStatus(ctx, status, "error");
+                    }
+                })();
+            }
+            else {
+                finishStatus(ctx, status, "connected");
+            }
+        }
+        catch (error) {
+            log("Pi session_start error", { error: String(error) });
+            finishStatus(ctx, status, "error");
+        }
+    });
+    pi.on("before_agent_start", async (event, ctx) => {
+        if (!isConfigured() || !CONFIG.chatMessage.enabled)
+            return;
+        const status = startStatus(ctx, "recalling");
+        try {
+            const section = await buildRetrievalSection(event.prompt, ctx.cwd, ctx.sessionManager.getSessionId());
+            finishStatus(ctx, status, "connected");
+            if (!section)
+                return;
+            return {
+                systemPrompt: event.systemPrompt + "\n\n" + wrapRetrievalSection(section),
+            };
+        }
+        catch (error) {
+            log("Pi before_agent_start retrieval error", { error: String(error) });
+            finishStatus(ctx, status, "error");
+            return undefined;
+        }
+    });
+    pi.on("agent_settled", async (_event, ctx) => {
+        if (!isConfigured())
+            return;
+        const status = startStatus(ctx, "capturing");
+        try {
+            const entries = toSessionEntries(ctx.sessionManager.getBranch());
+            const provider = createPiCaptureProvider(() => resolveModel(ctx));
+            const captureResult = await capturePiSettledWorkUnit({
+                sessionId: ctx.sessionManager.getSessionId(),
+                directory: ctx.cwd,
+                entries,
+                provider,
+                state: captureState,
+                prompt: {
+                    providerId: ctx.model?.provider ?? null,
+                    modelId: ctx.model?.id ?? null,
+                },
+                notify: notify(ctx),
+            });
+            const settledPrompt = lastSettledUserPrompt(entries);
+            if (settledPrompt &&
+                CONFIG.userProfileAnalysisInterval > 0 &&
+                !memoryClient.getEmbeddingInitError?.()) {
+                promptsSinceProfileAnalysis.push(settledPrompt);
+                if (promptsSinceProfileAnalysis.length >= CONFIG.userProfileAnalysisInterval) {
+                    const batch = promptsSinceProfileAnalysis;
+                    promptsSinceProfileAnalysis = [];
+                    await performPiProfileLearning({
+                        directory: ctx.cwd,
+                        prompts: batch,
+                        resolveModel: () => resolveModel(ctx),
+                        notify: notify(ctx),
+                    });
+                }
+            }
+            finishStatus(ctx, status, captureResult.status === "failed" ? "error" : "connected");
+        }
+        catch (error) {
+            log("Pi agent_settled error", { error: String(error) });
+            finishStatus(ctx, status, "error");
+        }
+    });
+    pi.on("session_shutdown", async (_event, ctx) => {
+        clearStatus(ctx);
+        latestCtx = null;
+        captureState = createPiCaptureState();
+        promptsSinceProfileAnalysis = [];
+        globalThis[GLOBAL_PLUGIN_WARMUP_KEY] = false;
+        try {
+            await memoryClient.close();
+        }
+        catch {
+            // Idempotent cleanup: closing an already-closed client must never fail
+            // the shutdown flow across quit, reload, new, resume, and fork.
+        }
+    });
+    pi.registerTool({
+        name: "memory",
+        label: "Memory",
+        description: `Manage and query project memory (MATCH USER LANGUAGE: ${getLanguageName(CONFIG.autoCaptureLanguage || "en")}). Use 'search' with technical keywords/tags, 'add' to store knowledge, 'profile' for preferences. Use migrate/list-shards/export/import when a project directory moves. Search/list scope: project or all-projects.`,
+        parameters: Type.Object({
+            mode: Type.Optional(Type.Union(MEMORY_TOOL_MODES.map((mode) => Type.Literal(mode)))),
+            content: Type.Optional(Type.String()),
+            query: Type.Optional(Type.String()),
+            tags: Type.Optional(Type.String()),
+            type: Type.Optional(Type.String()),
+            memoryId: Type.Optional(Type.String()),
+            limit: Type.Optional(Type.Number()),
+            scope: Type.Optional(Type.Union([Type.Literal("project"), Type.Literal("all-projects")])),
+            fromPath: Type.Optional(Type.String()),
+            fromHash: Type.Optional(Type.String()),
+            outputPath: Type.Optional(Type.String()),
+            inputPath: Type.Optional(Type.String()),
+            dryRun: Type.Optional(Type.Boolean()),
+            allowLinkedSource: Type.Optional(Type.Boolean()),
+        }),
+        async execute(_toolCallId, args, _signal, _onUpdate, ctx) {
+            const result = await executeMemoryOperation(args, {
+                directory: ctx.cwd,
+                host: "pi",
+                hostSessionId: ctx.sessionManager.getSessionId(),
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+                details: {},
+            };
+        },
+    });
+    registerPiHistoryImportCommand(pi, () => latestCtx);
+}

package/dist/adapters/pi/import-command.d.ts

@@ -0,0 +1,29 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type ImportPathMap } from "../../importer/importer.js";
+/**
+ * Pi command surface for the historical-session importer:
+ *
+ *   /memory-import-pi-history --dry-run
+ *   /memory-import-pi-history
+ *
+ * Runs over the shared importer service. Extraction inherits the active Pi
+ * model (or the piProvider/piModel override). Source session files are only
+ * ever read.
+ */
+export declare const PI_IMPORT_COMMAND = "memory-import-pi-history";
+export declare const PI_IMPORT_USAGE = "Usage: /memory-import-pi-history [options]\n\nOptions:\n  --dry-run                    Discover, map, and report; write nothing\n  --force                      Reprocess units with terminal ledger states\n  --scope=current-project      Import only sessions from this project (default)\n  --scope=all-projects         Import every discovered session\n  --session=<id-or-file>       Import one exact session\n  --since=<date>               Only work units at/after this time\n  --until=<date>               Only work units at/before this time\n  --max-sessions=<n>           Limit discovery to the oldest n sessions\n  --map=<oldPath>=<newPath>    Remap a recorded cwd that no longer exists\n  --root=<dir>                 Session root (default ~/.pi/agent/sessions)\n\nDates accept ISO 8601 (2026-01-01, 2026-01-01T10:00:00Z) or epoch\nmilliseconds. --since/--until filter on each work unit's user-entry\ntimestamp, inclusive. Unresolvable recorded cwds are skipped and listed\nin the report; use --map to import them into an existing directory.";
+export interface ParsedImportArgs {
+    dryRun: boolean;
+    force: boolean;
+    scope: "current-project" | "all-projects";
+    session?: string;
+    since?: number;
+    until?: number;
+    maxSessions?: number;
+    root?: string;
+    pathMaps: ImportPathMap[];
+    help: boolean;
+    errors: string[];
+}
+export declare function parseImportArgs(raw: string): ParsedImportArgs;
+export declare function registerPiHistoryImportCommand(pi: ExtensionAPI, getExtensionContext: () => ExtensionContext | null): void;

package/dist/adapters/pi/import-command.js

@@ -0,0 +1,232 @@
+import { initConfigWithLegacyMigration, isConfigured } from "../../config.js";
+import { log } from "../../services/logger.js";
+import { memoryClient } from "../../services/client.js";
+import { importPiHistory, } from "../../importer/importer.js";
+import { loadPiSessionForImport } from "../../importer/session-loader.js";
+import { createPiCaptureProvider, resolveModelFromContext } from "./provider.js";
+/**
+ * Pi command surface for the historical-session importer:
+ *
+ *   /memory-import-pi-history --dry-run
+ *   /memory-import-pi-history
+ *
+ * Runs over the shared importer service. Extraction inherits the active Pi
+ * model (or the piProvider/piModel override). Source session files are only
+ * ever read.
+ */
+export const PI_IMPORT_COMMAND = "memory-import-pi-history";
+export const PI_IMPORT_USAGE = `Usage: /${PI_IMPORT_COMMAND} [options]
+
+Options:
+  --dry-run                    Discover, map, and report; write nothing
+  --force                      Reprocess units with terminal ledger states
+  --scope=current-project      Import only sessions from this project (default)
+  --scope=all-projects         Import every discovered session
+  --session=<id-or-file>       Import one exact session
+  --since=<date>               Only work units at/after this time
+  --until=<date>               Only work units at/before this time
+  --max-sessions=<n>           Limit discovery to the oldest n sessions
+  --map=<oldPath>=<newPath>    Remap a recorded cwd that no longer exists
+  --root=<dir>                 Session root (default ~/.pi/agent/sessions)
+
+Dates accept ISO 8601 (2026-01-01, 2026-01-01T10:00:00Z) or epoch
+milliseconds. --since/--until filter on each work unit's user-entry
+timestamp, inclusive. Unresolvable recorded cwds are skipped and listed
+in the report; use --map to import them into an existing directory.`;
+function parseTimestamp(raw) {
+    if (!raw)
+        return undefined;
+    if (/^\d+$/.test(raw))
+        return Number(raw);
+    const parsed = Date.parse(raw);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+export function parseImportArgs(raw) {
+    const result = {
+        dryRun: false,
+        force: false,
+        scope: "current-project",
+        pathMaps: [],
+        help: false,
+        errors: [],
+    };
+    for (const token of raw.trim().split(/\s+/).filter(Boolean)) {
+        if (token === "--help" || token === "-h") {
+            result.help = true;
+            continue;
+        }
+        if (token === "--dry-run") {
+            result.dryRun = true;
+            continue;
+        }
+        if (token === "--force") {
+            result.force = true;
+            continue;
+        }
+        const equals = token.indexOf("=");
+        const flag = equals === -1 ? token : token.slice(0, equals);
+        const value = equals === -1 ? "" : token.slice(equals + 1);
+        switch (flag) {
+            case "--scope":
+                if (value === "current-project" || value === "all-projects") {
+                    result.scope = value;
+                }
+                else {
+                    result.errors.push(`--scope must be current-project or all-projects, got "${value}"`);
+                }
+                break;
+            case "--session":
+                if (value)
+                    result.session = value;
+                else
+                    result.errors.push("--session requires a value");
+                break;
+            case "--since":
+                result.since = parseTimestamp(value);
+                if (result.since === undefined)
+                    result.errors.push(`--since is not a valid date: "${value}"`);
+                break;
+            case "--until":
+                result.until = parseTimestamp(value);
+                if (result.until === undefined)
+                    result.errors.push(`--until is not a valid date: "${value}"`);
+                break;
+            case "--max-sessions": {
+                const parsed = Number(value);
+                if (Number.isInteger(parsed) && parsed >= 0)
+                    result.maxSessions = parsed;
+                else
+                    result.errors.push(`--max-sessions must be a non-negative integer, got "${value}"`);
+                break;
+            }
+            case "--root":
+                if (value)
+                    result.root = value;
+                else
+                    result.errors.push("--root requires a value");
+                break;
+            case "--map": {
+                const separator = value.indexOf("=");
+                if (separator > 0 && separator < value.length - 1) {
+                    result.pathMaps.push({
+                        from: value.slice(0, separator),
+                        to: value.slice(separator + 1),
+                    });
+                }
+                else {
+                    result.errors.push(`--map must be <oldPath>=<newPath>, got "${value}"`);
+                }
+                break;
+            }
+            default:
+                result.errors.push(`Unknown option: "${token}"`);
+        }
+    }
+    return result;
+}
+function formatReport(report) {
+    const lines = [
+        `Pi history import ${report.dryRun ? "(dry-run)" : ""}`.trim(),
+        `  sessions: ${report.sessionsLoaded} loaded, ${report.sessionsFilteredOut} filtered, ` +
+            `${report.sessionsUnrecognized} unrecognized, ` +
+            `${report.unresolvableSessions.length} unresolvable cwd`,
+        `  work units: ${report.unitsTotal} total, ` +
+            (report.dryRun
+                ? `${report.unitsWouldImport} would import`
+                : `${report.unitsImported} imported, ${report.unitsSkipped} skipped, ` +
+                    `${report.unitsFailed} failed`) +
+            `, ${report.unitsAlreadyHandled} already handled`,
+    ];
+    for (const project of report.projects) {
+        lines.push(`  project ${project.tag} (${project.sessions} sessions, ${project.units} units) -> ${project.directory}`);
+    }
+    if (report.loadErrors.length > 0) {
+        lines.push(`  load errors: ${report.loadErrors.length}`);
+    }
+    return lines.join("\n");
+}
+let importCommandRunning = false;
+export function registerPiHistoryImportCommand(pi, getExtensionContext) {
+    pi.registerCommand(PI_IMPORT_COMMAND, {
+        description: "Import historical Pi sessions into the shared memory store (try --dry-run first)",
+        handler: async (args, commandCtx) => {
+            const notify = (message) => {
+                if (getExtensionContext()?.hasUI) {
+                    getExtensionContext()?.ui.notify(message, "info");
+                }
+            };
+            const parsed = parseImportArgs(args ?? "");
+            if (parsed.help) {
+                notify(PI_IMPORT_USAGE);
+                return;
+            }
+            if (parsed.errors.length > 0) {
+                notify(`memory-import-pi-history: ${parsed.errors.join("; ")}`);
+                return;
+            }
+            const ctx = getExtensionContext();
+            if (!ctx) {
+                notify("memory-import-pi-history: no active Pi session context; open a session first");
+                return;
+            }
+            if (!isConfigured()) {
+                notify("memory-import-pi-history: memory system not configured");
+                return;
+            }
+            if (importCommandRunning) {
+                notify("memory-import-pi-history: an import is already running");
+                return;
+            }
+            // Import against the current session's project and configuration.
+            initConfigWithLegacyMigration(ctx.cwd);
+            if (typeof commandCtx.waitForIdle === "function") {
+                await commandCtx.waitForIdle();
+            }
+            importCommandRunning = true;
+            try {
+                // Best-effort warmup so failures surface as per-unit errors instead of
+                // every unit failing on embedding initialisation.
+                try {
+                    await memoryClient.warmup();
+                }
+                catch (error) {
+                    log("Pi import: memory warmup failed", { error: String(error) });
+                }
+                const filters = {
+                    scope: parsed.scope,
+                    currentDirectory: ctx.cwd,
+                    ...(parsed.session !== undefined ? { session: parsed.session } : {}),
+                    ...(parsed.since !== undefined ? { since: parsed.since } : {}),
+                    ...(parsed.until !== undefined ? { until: parsed.until } : {}),
+                    ...(parsed.maxSessions !== undefined ? { maxSessions: parsed.maxSessions } : {}),
+                    ...(parsed.root !== undefined ? { root: parsed.root } : {}),
+                    ...(parsed.force ? { force: true } : {}),
+                    ...(parsed.dryRun ? { dryRun: true } : {}),
+                    pathMaps: parsed.pathMaps,
+                };
+                const provider = createPiCaptureProvider(() => resolveModelFromContext(ctx));
+                let lastProgressNotify = 0;
+                const report = await importPiHistory({
+                    loadSession: loadPiSessionForImport,
+                    provider,
+                    onProgress: (processed, total, promptPreview) => {
+                        if (processed - lastProgressNotify >= 25 || processed === total) {
+                            lastProgressNotify = processed;
+                            notify(`Pi import: ${processed}/${total} units (${promptPreview})`);
+                        }
+                    },
+                }, filters);
+                log("Pi history import report", { report });
+                notify(formatReport(report));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                log("Pi history import failed", { error: message });
+                notify(`memory-import-pi-history failed: ${message}`);
+            }
+            finally {
+                importCommandRunning = false;
+            }
+        },
+    });
+}

package/dist/adapters/pi/profile.d.ts

@@ -0,0 +1,39 @@
+import type { UserProfileData } from "../../services/user-profile/types.js";
+import type { PiModelHandle } from "./provider.js";
+export interface ExistingProfileInput {
+    id: string;
+    profileData: string;
+}
+export interface ProfileAnalysisResult {
+    raw: UserProfileData;
+    merged: UserProfileData | null;
+}
+export interface PiProfileAnalyzer {
+    analyzeProfile(context: string, existingProfile: ExistingProfileInput | null): Promise<ProfileAnalysisResult | null>;
+}
+/**
+ * Bridge the shared user-profile analysis onto Pi's model runtime. Uses the
+ * same schema and system prompt as the OpenCode structured-output path, so
+ * analysis results are validated with the shared schema before they reach the
+ * profile storage layer. Model failures throw (mirroring provider semantics);
+ * a missing model returns null so callers can skip without disabling anything.
+ */
+export declare function createPiProfileAnalyzer(resolveModel: () => PiModelHandle | null, timeoutMs?: number): PiProfileAnalyzer;
+export interface PiProfileLearningInput {
+    directory: string;
+    prompts: string[];
+    resolveModel: () => PiModelHandle | null;
+    notify?: (notification: {
+        title: string;
+        message: string;
+        variant: "success" | "warning" | "error" | "info";
+    }) => Promise<void> | void;
+}
+/**
+ * Pi-side profile learning lifecycle: analyse a batch of settled user prompts
+ * through the model bridge and persist via the shared profile manager. Failures
+ * log (and optionally toast) without ever disabling memory operations. The
+ * decay/validation-task machinery of the OpenCode idle path is not ported;
+ * this applies the analysed batch directly (documented limitation).
+ */
+export declare function performPiProfileLearning(input: PiProfileLearningInput): Promise<void>;

package/dist/adapters/pi/profile.js

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import { CONFIG } from "../../config.js";
+import { createUserProfileAnalysisSchema, extractJsonObject } from "../../core/extraction.js";
+import { log } from "../../services/logger.js";
+import { getTags } from "../../services/tags.js";
+/**
+ * System prompt mirrored from the OpenCode profile-learning path
+ * (src/services/user-memory-learning.ts, analyzeUserProfile). Kept local so
+ * the Pi adapter does not import an OpenCode-coupled module; update both when
+ * the analysis contract changes.
+ */
+function buildProfileAnalysisSystemPrompt(existingProfile) {
+    return `You are a user behavior analyst for a coding assistant.
+
+Your task is to analyze user prompts and ${existingProfile ? "update" : "create"} a comprehensive user profile.
+
+CRITICAL: Detect the language used by the user in their prompts. You MUST output all descriptions, categories, and text in the SAME language as the user's prompts.
+
+CRITICAL: All JSON string values MUST escape double quotes with backslash. Do NOT use unescaped quotation marks inside string values.
+
+Respond with a single JSON object matching the update_user_profile contract.`;
+}
+function replyText(reply) {
+    return reply.content
+        .filter((block) => block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("\n")
+        .trim();
+}
+/**
+ * Bridge the shared user-profile analysis onto Pi's model runtime. Uses the
+ * same schema and system prompt as the OpenCode structured-output path, so
+ * analysis results are validated with the shared schema before they reach the
+ * profile storage layer. Model failures throw (mirroring provider semantics);
+ * a missing model returns null so callers can skip without disabling anything.
+ */
+export function createPiProfileAnalyzer(resolveModel, timeoutMs = 120000) {
+    return {
+        async analyzeProfile(context, existingProfile) {
+            const model = resolveModel();
+            if (!model)
+                return null;
+            // Unref'd and cleared so the losing timeout timer never keeps the host
+            // process alive after the race settles.
+            let timeoutId;
+            try {
+                const reply = await Promise.race([
+                    model.complete({
+                        systemPrompt: buildProfileAnalysisSystemPrompt(Boolean(existingProfile)),
+                        messages: [{ role: "user", content: context, timestamp: Date.now() }],
+                    }),
+                    new Promise((_, reject) => {
+                        timeoutId = setTimeout(() => reject(new Error("pi profile analysis: timeout")), timeoutMs);
+                        timeoutId?.unref?.();
+                    }),
+                ]);
+                if (reply.stopReason === "error") {
+                    throw new Error(`pi profile analysis: model call failed: ${reply.errorMessage || "unknown error"}`);
+                }
+                const schema = createUserProfileAnalysisSchema(z);
+                const parsed = schema.safeParse(extractJsonObject(replyText(reply)));
+                if (!parsed.success) {
+                    log("pi profile analysis: model reply failed shared schema validation", {
+                        provider: model.provider,
+                        modelId: model.modelId,
+                    });
+                    throw new Error("pi profile analysis: invalid profile payload");
+                }
+                const rawData = parsed.data;
+                if (existingProfile) {
+                    const { userProfileManager } = await import("../../services/user-profile/user-profile-manager.js");
+                    const existingData = JSON.parse(existingProfile.profileData);
+                    const merged = await userProfileManager.mergeProfileData(existingData, rawData, undefined, existingProfile.id);
+                    return { raw: rawData, merged };
+                }
+                return { raw: rawData, merged: null };
+            }
+            finally {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+            }
+        },
+    };
+}
+/**
+ * Pi-side profile learning lifecycle: analyse a batch of settled user prompts
+ * through the model bridge and persist via the shared profile manager. Failures
+ * log (and optionally toast) without ever disabling memory operations. The
+ * decay/validation-task machinery of the OpenCode idle path is not ported;
+ * this applies the analysed batch directly (documented limitation).
+ */
+export async function performPiProfileLearning(input) {
+    if (input.prompts.length === 0)
+        return;
+    try {
+        const tags = getTags(input.directory);
+        if (!tags.user.userEmail) {
+            log("pi profile learning: skipped (no user email resolved)", {
+                directory: input.directory,
+            });
+            return;
+        }
+        const userId = tags.user.userEmail;
+        const { userProfileManager } = await import("../../services/user-profile/user-profile-manager.js");
+        const existing = await userProfileManager.getActiveProfile(userId);
+        const analyzer = createPiProfileAnalyzer(input.resolveModel);
+        const context = input.prompts.map((prompt, i) => `${i + 1}. ${prompt}`).join("\n");
+        const analysis = await analyzer.analyzeProfile(context, existing ? { id: existing.id, profileData: existing.profileData } : null);
+        if (!analysis) {
+            log("pi profile learning: skipped (no model available)", { userId });
+            return;
+        }
+        if (existing && analysis.merged) {
+            const updated = await userProfileManager.updateProfile(existing.id, analysis.merged, input.prompts.length, `Pi analysis of ${input.prompts.length} prompts`);
+            if (!updated) {
+                log("pi profile learning: update conflict", { profileId: existing.id });
+                return;
+            }
+        }
+        else {
+            await userProfileManager.createProfile(userId, tags.user.displayName || userId, tags.user.userName || userId, tags.user.userEmail || userId, analysis.raw, input.prompts.length);
+        }
+        log("pi profile learning: profile updated", {
+            userId,
+            prompts: input.prompts.length,
+            hadExisting: Boolean(existing),
+        });
+        if (CONFIG.showUserProfileToasts && input.notify) {
+            await Promise.resolve(input.notify({
+                title: "User Profile Updated",
+                message: `Analyzed ${input.prompts.length} prompts and updated your profile`,
+                variant: "success",
+            })).catch(() => { });
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log(`pi profile learning: aborted (${message})`);
+        if (CONFIG.showErrorToasts && input.notify) {
+            const shortReason = message.length > 100 ? message.substring(0, 100) + "..." : message;
+            await Promise.resolve(input.notify({
+                title: "Profile Learning Failed",
+                message: shortReason,
+                variant: "error",
+            })).catch(() => { });
+        }
+    }
+}