om-memory-system 4.26.2 → 4.28.0

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

@@ -8,6 +8,11 @@ import type { ImportPathMap } from "./importer.js";
  * imported set always use the same discovery and project rules.
  */
 export declare const MAX_SELECTED_KEYS = 1000;
+/** The outputs a run produces; a session is handled only when every ticked one is finished. */
+export interface ImportOutputs {
+    memories: boolean;
+    profile: boolean;
+}
 export interface ImportSessionRow {
     /**
      * Selection key: the OpenCode session ID, or the Pi or Claude Code file path
@@ -30,6 +35,10 @@ export interface ImportMatchOptions {
     /** Grouped imports can retain a valid source with no matching sessions as no-work. */
     allowEmpty?: boolean;
     signal?: AbortSignal;
+    /** Outputs the job writes; decides which sessions an "all" selection drops as handled. */
+    outputs?: ImportOutputs;
+    /** A forced run re-analyses handled history, so it keeps handled sessions. */
+    force?: boolean;
 }
 export declare class StaleSelectionError extends Error {
     readonly status = 409;
@@ -44,17 +53,27 @@ interface Matched {
     revision: string;
 }
 export declare function matchImportSessions(identity: ImportSourceIdentity, options: ImportMatchOptions, snapshotMode: "fresh" | "reuse" | "any"): Promise<Matched>;
+/**
+ * Sessions the ledger shows as finished for every ticked output. The check uses
+ * each row's `sessionId`, since Pi and Claude Code keys are file paths. A row
+ * without a session id is never handled. The ledger is read, never created.
+ */
+export declare function handledKeys(rows: ImportSessionRow[], outputs: ImportOutputs): Promise<Set<string>>;
 export interface ImportSessionPage {
     source: {
         kind: ImportSourceIdentity["kind"];
         displayPath: string;
         sourceToken: string;
     };
+    /** Rows shown: handled sessions are left out unless the request keeps them. */
     total: number;
     offset: number;
     rows: Array<ImportSessionRow & {
         selectable: boolean;
+        handled: boolean;
     }>;
+    /** Handled sessions left out of the list. */
+    hiddenHandled: number;
     /** Sessions whose recorded directory no longer exists. */
     unresolvedCount: number;
     revision: string;
@@ -65,6 +84,8 @@ export interface SessionListRequest {
     offset?: number;
     limit?: number;
     refresh?: boolean;
+    /** True when the page shows handled sessions; "Re-analyse handled history" implies it. */
+    includeHandled?: boolean;
     match: Omit<ImportMatchOptions, "cwd">;
 }
 /** Check a session-list request body from the page. */
@@ -75,6 +96,7 @@ export declare function listImportSessions(request: {
     offset?: number;
     limit?: number;
     refresh?: boolean;
+    includeHandled?: boolean;
 }, options: ImportMatchOptions): Promise<ImportSessionPage>;
 export type ImportSelection = {
     mode: "ids";
@@ -88,6 +110,8 @@ export type ImportSelection = {
     excludedKeys: string[];
     revision: string;
     listedAt: number;
+    /** False or absent: the server drops sessions already handled for the job's outputs. */
+    includeHandled?: boolean;
 };
 export declare function validateImportSelection(value: unknown): ImportSelection;
 export interface ResolvedImportSelection {

package/dist/importer/import-sessions.js

@@ -10,6 +10,7 @@ import { assertImportSourceUnchanged, importSourceKey, readImportSourceToken, va
  */
 export const MAX_SELECTED_KEYS = 1000;
 const MAX_PAGE = 200;
+const ALL_OUTPUTS = { memories: true, profile: true };
 export class StaleSelectionError extends Error {
     status = 409;
     constructor(message = "The session list is out of date. Refresh the list and try again.") {
@@ -97,6 +98,19 @@ export async function matchImportSessions(identity, options, snapshotMode) {
         revision: revisionOf(identity, merged, projectTag, matching.map((row) => row.key)),
     };
 }
+/**
+ * Sessions the ledger shows as finished for every ticked output. The check uses
+ * each row's `sessionId`, since Pi and Claude Code keys are file paths. A row
+ * without a session id is never handled. The ledger is read, never created.
+ */
+export async function handledKeys(rows, outputs) {
+    const ids = rows.flatMap((row) => (row.sessionId ? [row.sessionId] : []));
+    if (ids.length === 0)
+        return new Set();
+    const { ImportLedger } = await import("./ledger.js");
+    const handled = await new ImportLedger().handledSessionIds(ids, outputs);
+    return new Set(rows.filter((row) => row.sessionId && handled.has(row.sessionId)).map((r) => r.key));
+}
 /** Check a session-list request body from the page. */
 export function validateSessionListRequest(value) {
     const input = value;
@@ -124,16 +138,25 @@ export function validateSessionListRequest(value) {
             throw new Error(`Invalid ${key}`);
         }
     }
+    for (const key of ["skipMemories", "skipProfile", "force", "includeHandled"]) {
+        if (input[key] !== undefined && typeof input[key] !== "boolean") {
+            throw new Error(`Invalid ${key}`);
+        }
+    }
+    const force = input.force === true;
     return {
         ...(input.source !== undefined ? { sourceToken: input.source } : {}),
         ...(input.offset !== undefined ? { offset: input.offset } : {}),
         ...(input.limit !== undefined ? { limit: input.limit } : {}),
         refresh: input.refresh === true,
+        includeHandled: input.includeHandled === true || force,
         match: {
             host: input.host,
             scope,
             ...(project ? { project } : {}),
             pathMaps: maps,
+            outputs: { memories: input.skipMemories !== true, profile: input.skipProfile !== true },
+            ...(force ? { force } : {}),
         },
     };
 }
@@ -152,17 +175,21 @@ export async function listImportSessions(request, options) {
     // Feed the Directory maps list; a failure here must not break the listing.
     const { recordUnresolvedDirectories, summarizeUnresolvedDirectories } = await import("../services/backfill-state.js");
     await recordUnresolvedDirectories(options.host, summarizeUnresolvedDirectories(matched.unresolved.map((row) => ({ directory: row.recordedDirectory })))).catch(() => { });
-    const rows = [
-        ...matched.matching.map((row) => ({ ...row, selectable: true })),
+    const handled = await handledKeys(matched.matching, options.outputs ?? ALL_OUTPUTS);
+    const listed = [
+        ...matched.matching.map((row) => ({ ...row, selectable: true, handled: handled.has(row.key) })),
         ...(options.scope === "all-projects"
-            ? matched.unresolved.map((row) => ({ ...row, selectable: false }))
+            ? matched.unresolved.map((row) => ({ ...row, selectable: false, handled: false }))
             : []),
     ];
+    const keep = request.includeHandled === true || options.force === true;
+    const rows = keep ? listed : listed.filter((row) => !row.handled);
     return {
         source: { kind: identity.kind, displayPath: identity.realPath, sourceToken: token },
         total: rows.length,
         offset,
         rows: rows.slice(offset, offset + limit),
+        hiddenHandled: listed.length - rows.length,
         unresolvedCount: matched.unresolved.length,
         revision: matched.revision,
         listedAt,
@@ -201,7 +228,16 @@ export function validateImportSelection(value) {
         }
         if (typeof input.revision !== "string")
             throw new Error("Invalid session list revision");
-        return { mode: "all", excludedKeys: excluded, revision: input.revision, listedAt };
+        if (input.includeHandled !== undefined && typeof input.includeHandled !== "boolean") {
+            throw new Error("Invalid includeHandled");
+        }
+        return {
+            mode: "all",
+            excludedKeys: excluded,
+            revision: input.revision,
+            listedAt,
+            ...(input.includeHandled === true ? { includeHandled: true } : {}),
+        };
     }
     throw new Error("Choose sessions to import");
 }
@@ -223,7 +259,13 @@ export async function resolveImportSelection(sourceToken, selection, options) {
         if (matched.revision !== selection.revision)
             throw new StaleSelectionError();
         const excluded = new Set(selection.excludedKeys);
-        keys = matched.matching.map((row) => row.key).filter((key) => !excluded.has(key));
+        const keep = selection.includeHandled === true || options.force === true;
+        const handled = keep
+            ? new Set()
+            : await handledKeys(matched.matching, options.outputs ?? ALL_OUTPUTS);
+        keys = matched.matching
+            .map((row) => row.key)
+            .filter((key) => !excluded.has(key) && !handled.has(key));
     }
     else {
         const current = new Map(matched.matching.map((row) => [row.key, row.directory]));

package/dist/importer/ledger.d.ts

@@ -32,6 +32,17 @@ export declare class ImportLedger {
      * A ledger file without the table reads as empty.
      */
     peek(key: string): Promise<ImportLedgerRow | null>;
+    /**
+     * Sessions whose ledger rows are all finished for every ticked output.
+     * Memory rows and profile rows (`project_hash = 'profile'`) are judged apart.
+     * A ticked output passes when the session has at least one row of its kind
+     * and every such row is imported or skipped. Read-only like `peek`: a missing
+     * file or table gives an empty set and nothing is created.
+     */
+    handledSessionIds(sessionIds: readonly string[], outputs: {
+        memories: boolean;
+        profile: boolean;
+    }): Promise<Set<string>>;
     countByStatus(): Promise<Record<string, number>>;
     /** Upsert an in-progress marker before processing a unit. */
     begin(input: {

package/dist/importer/ledger.js

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { CONFIG } from "../config.js";
 import { tursoConnectionManager } from "../services/turso/connection-manager.js";
@@ -87,6 +88,59 @@ export class ImportLedger {
         const row = await db.get(`SELECT * FROM import_ledger WHERE key = ?`, [key]);
         return row ? rowToEntry(row) : null;
     }
+    /**
+     * Sessions whose ledger rows are all finished for every ticked output.
+     * Memory rows and profile rows (`project_hash = 'profile'`) are judged apart.
+     * A ticked output passes when the session has at least one row of its kind
+     * and every such row is imported or skipped. Read-only like `peek`: a missing
+     * file or table gives an empty set and nothing is created.
+     */
+    async handledSessionIds(sessionIds, outputs) {
+        const handled = new Set();
+        const ids = [...new Set(sessionIds.filter((id) => id !== ""))];
+        if ((!outputs.memories && !outputs.profile) || ids.length === 0)
+            return handled;
+        // Opening a connection creates the file, so a missing ledger is read as empty first.
+        if (!existsSync(importLedgerDbPath()))
+            return handled;
+        const db = await tursoConnectionManager.getConnection(importLedgerDbPath());
+        const table = await db.get(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'import_ledger'`);
+        if (!table)
+            return handled;
+        const kinds = new Map();
+        for (let start = 0; start < ids.length; start += 500) {
+            const chunk = ids.slice(start, start + 500);
+            const rows = await db.all(`
+          SELECT session_id,
+                 CASE WHEN project_hash = 'profile' THEN 'profile' ELSE 'memory' END AS kind,
+                 COUNT(*) AS total,
+                 SUM(CASE WHEN status IN ('imported', 'skipped') THEN 1 ELSE 0 END) AS done
+          FROM import_ledger
+          WHERE session_id IN (${chunk.map(() => "?").join(", ")})
+          GROUP BY session_id, kind
+        `, chunk);
+            for (const row of rows) {
+                const entry = kinds.get(String(row.session_id)) ?? {
+                    memory: [0, 0],
+                    profile: [0, 0],
+                };
+                entry[row.kind === "profile" ? "profile" : "memory"] = [
+                    Number(row.total),
+                    Number(row.done),
+                ];
+                kinds.set(String(row.session_id), entry);
+            }
+        }
+        const passes = ([total, done]) => total > 0 && total === done;
+        for (const [sessionId, entry] of kinds) {
+            if (outputs.memories && !passes(entry.memory))
+                continue;
+            if (outputs.profile && !passes(entry.profile))
+                continue;
+            handled.add(sessionId);
+        }
+        return handled;
+    }
     async countByStatus() {
         const db = await this.db();
         const rows = await db.all(`SELECT status, COUNT(*) AS count FROM import_ledger GROUP BY status`);

package/dist/importer/web-import-group.d.ts

@@ -52,6 +52,12 @@ type Deps = GroupImportDeps & {
     resolveSelection: typeof resolveImportSelection;
     readiness: () => Promise<ImportReadiness>;
 };
+/**
+ * Fixed sentences with no number, so the page can translate them by exact text.
+ * The failed count travels apart in the child's summary.
+ */
+export declare const MEMORY_FAILED_MESSAGE = "Some memory units failed. Completed work is saved. A new preview and import retries only the failed units.";
+export declare const PROFILE_FAILED_MESSAGE = "Profile learning failed. Completed memory work is saved. Refresh the preview and retry.";
 /** Preflight every child before launching a bounded sequential group in the existing slot. */
 export declare function startImportGroup(input: GroupImportRequest, directory: string, deps: Deps, publish: (job: GroupImportJob, controller: AbortController) => void): Promise<GroupImportJob>;
 export {};

package/dist/importer/web-import-group.js

@@ -38,6 +38,12 @@ async function discardSelection(identity) {
     const { opencodeSnapshots } = await import("./opencode-snapshot.js");
     opencodeSnapshots.discard(importSourceKey(identity));
 }
+/**
+ * Fixed sentences with no number, so the page can translate them by exact text.
+ * The failed count travels apart in the child's summary.
+ */
+export const MEMORY_FAILED_MESSAGE = "Some memory units failed. Completed work is saved. A new preview and import retries only the failed units.";
+export const PROFILE_FAILED_MESSAGE = "Profile learning failed. Completed memory work is saved. Refresh the preview and retry.";
 function matchOptions(child, directory, signal) {
     return {
         host: child.input.host,
@@ -47,6 +53,8 @@ function matchOptions(child, directory, signal) {
         cwd: directory,
         allowEmpty: true,
         signal,
+        outputs: { memories: !child.args.skipMemories, profile: !child.args.skipProfile },
+        ...(child.args.force ? { force: true } : {}),
     };
 }
 function hostError(host, error) {
@@ -326,7 +334,7 @@ async function executeGroup(children, job, signal, directory, deps, waiting) {
             else if (historyImportFailed(report)) {
                 child.row.state = "failed";
                 failed = true;
-                child.row.error = `${hostLabel(host)}: ${report.unitsFailed ? "Memory work failed" : "Profile learning failed"}. Refresh the preview and retry.`;
+                child.row.error = `${hostLabel(host)}: ${report.unitsFailed ? MEMORY_FAILED_MESSAGE : PROFILE_FAILED_MESSAGE}`;
                 job.error = child.row.error;
             }
             else {