om-memory-system 4.29.1 → 4.31.1

package/dist/importer/import-sessions.js

@@ -86,8 +86,13 @@ export async function matchImportSessions(identity, options, snapshotMode) {
     const { runPathMaps } = await import("./import-path-maps.js");
     const merged = { ...options, pathMaps: await runPathMaps(options.pathMaps, options.cwd) };
     const rows = await readRows(identity, merged, snapshotMode);
-    const unresolved = rows.filter((row) => row.directory === null);
-    const matching = rows
+    const missing = rows.filter((row) => row.directory === null);
+    // `via` stays "unresolved", so a kept row still shows its folder is gone.
+    const usable = options.skillTurnsOnly
+        ? rows.map((row) => (row.directory ? row : { ...row, directory: row.recordedDirectory }))
+        : rows;
+    const unresolved = usable.filter((row) => row.directory === null);
+    const matching = usable
         .filter((row) => row.directory !== null)
         .filter((row) => projectTag === null || projectFilterTag(row.directory) === projectTag)
         .sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0) || a.key.localeCompare(b.key));
@@ -95,6 +100,7 @@ export async function matchImportSessions(identity, options, snapshotMode) {
         identity,
         matching,
         unresolved,
+        missing,
         revision: revisionOf(identity, merged, projectTag, matching.map((row) => row.key)),
     };
 }
@@ -138,7 +144,13 @@ export function validateSessionListRequest(value) {
             throw new Error(`Invalid ${key}`);
         }
     }
-    for (const key of ["skipMemories", "skipProfile", "force", "includeHandled"]) {
+    for (const key of [
+        "skipMemories",
+        "skipProfile",
+        "force",
+        "includeHandled",
+        "skillTurnsOnly",
+    ]) {
         if (input[key] !== undefined && typeof input[key] !== "boolean") {
             throw new Error(`Invalid ${key}`);
         }
@@ -157,6 +169,7 @@ export function validateSessionListRequest(value) {
             pathMaps: maps,
             outputs: { memories: input.skipMemories !== true, profile: input.skipProfile !== true },
             ...(force ? { force } : {}),
+            ...(input.skillTurnsOnly === true ? { skillTurnsOnly: true } : {}),
         },
     };
 }
@@ -174,7 +187,7 @@ export async function listImportSessions(request, options) {
     const matched = await matchImportSessions(identity, options, request.refresh ? "fresh" : "any");
     // 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(() => { });
+    await recordUnresolvedDirectories(options.host, summarizeUnresolvedDirectories(matched.missing.map((row) => ({ directory: row.recordedDirectory })))).catch(() => { });
     const handled = await handledKeys(matched.matching, options.outputs ?? ALL_OUTPUTS);
     const listed = [
         ...matched.matching.map((row) => ({ ...row, selectable: true, handled: handled.has(row.key) })),

package/dist/importer/import-turn-outputs.d.ts

@@ -0,0 +1,49 @@
+import type { CaptureWorkUnit } from "../core/capture.js";
+import type { MemoryHost } from "../types/index.js";
+import type { ImportWindow } from "./importer.js";
+/**
+ * The outputs of one imported turn (design decision 11). Skill turns run
+ * first for every candidate, before the memory ledger is read, so turns the
+ * ledger or live capture already handled still reach `skills.db`.
+ */
+/** Skill-turn counts on an import report. Present only when the run records skill turns. */
+export interface ImportSkillTurnCounts {
+    /** Real run: turns written to `skills.db`. */
+    skillTurnsRecorded?: number;
+    /** Real run: turns `skills.db` already held. */
+    skillTurnsAlreadyPresent?: number;
+    /** Dry run: turns a real run would write. */
+    skillTurnsWouldRecord?: number;
+    /** Dry run: turns `skills.db` already holds. */
+    skillTurnsAlreadyRecorded?: number;
+}
+/** True when an import with these options records skill turns: `skillLearning` on and no `--skip-skills`. */
+export declare function importSkillTurnsOn(options: {
+    skipSkills?: boolean;
+}): boolean;
+/**
+ * True when a run writes skill turns and nothing else (`profile`: the run also
+ * learns the profile). Such a run also reads sessions whose project folder is
+ * gone; memory and profile runs still skip them.
+ */
+export declare function skillTurnsOnly(options: {
+    skipMemories?: boolean;
+    skipSkills?: boolean;
+}, profile: boolean): boolean;
+/** The capture work unit for one imported window, shared by the memory and skill outputs. */
+export declare function importWorkUnit(host: MemoryHost, turn: {
+    sessionId: string;
+    directory: string;
+    sourceFile: string;
+    window: ImportWindow;
+}, importId: string): CaptureWorkUnit;
+/**
+ * The skill output of one run, or undefined when the run records no skill
+ * turns. A real run records through `handleFinishedTurn`; a dry run only
+ * checks `turn_key` and never creates `skills.db`. Each project folder's
+ * settings are read once, with its project override applied.
+ */
+export declare function importSkillTurnOutput(options: {
+    skipSkills?: boolean;
+    dryRun?: boolean;
+}, report: ImportSkillTurnCounts): ((unit: CaptureWorkUnit) => Promise<void>) | undefined;

package/dist/importer/import-turn-outputs.js

@@ -0,0 +1,88 @@
+import { CONFIG } from "../config.js";
+import { handleFinishedTurn } from "../core/turn-outputs.js";
+import { skillTurnSettingsFor } from "../services/skill-learning/settings-for.js";
+import { peekSkillTurn, recordSkillTurn, } from "../services/skill-learning/turn-output.js";
+/** True when an import with these options records skill turns: `skillLearning` on and no `--skip-skills`. */
+export function importSkillTurnsOn(options) {
+    return options.skipSkills !== true && CONFIG.skillLearning === true;
+}
+/**
+ * True when a run writes skill turns and nothing else (`profile`: the run also
+ * learns the profile). Such a run also reads sessions whose project folder is
+ * gone; memory and profile runs still skip them.
+ */
+export function skillTurnsOnly(options, profile) {
+    return options.skipMemories === true && !profile && importSkillTurnsOn(options);
+}
+/** The capture work unit for one imported window, shared by the memory and skill outputs. */
+export function importWorkUnit(host, turn, importId) {
+    const { window } = turn;
+    return {
+        host,
+        hostSessionId: turn.sessionId,
+        sourceType: "history-import",
+        projectDirectory: turn.directory,
+        userPrompt: window.userPrompt,
+        promptId: window.userEntryId,
+        textResponses: window.textResponses,
+        toolCalls: window.toolCalls,
+        sourceEntryIds: window.sourceEntryIds,
+        ...(window.userTimestamp !== undefined
+            ? { sourceTimestamp: window.userTimestamp }
+            : window.sourceTimestamp !== undefined
+                ? { sourceTimestamp: window.sourceTimestamp }
+                : {}),
+        sourceFile: turn.sourceFile,
+        importId,
+    };
+}
+/**
+ * The skill output of one run, or undefined when the run records no skill
+ * turns. A real run records through `handleFinishedTurn`; a dry run only
+ * checks `turn_key` and never creates `skills.db`. Each project folder's
+ * settings are read once, with its project override applied.
+ */
+export function importSkillTurnOutput(options, report) {
+    if (!importSkillTurnsOn(options))
+        return undefined;
+    const dryRun = Boolean(options.dryRun);
+    if (dryRun) {
+        report.skillTurnsWouldRecord ??= 0;
+        report.skillTurnsAlreadyRecorded ??= 0;
+    }
+    else {
+        report.skillTurnsRecorded ??= 0;
+        report.skillTurnsAlreadyPresent ??= 0;
+    }
+    const count = (status) => {
+        if (status === "new") {
+            if (dryRun)
+                report.skillTurnsWouldRecord++;
+            else
+                report.skillTurnsRecorded++;
+        }
+        else if (status === "duplicate") {
+            if (dryRun)
+                report.skillTurnsAlreadyRecorded++;
+            else
+                report.skillTurnsAlreadyPresent++;
+        }
+    };
+    const settings = new Map();
+    const settingsFor = (directory) => {
+        let found = settings.get(directory);
+        if (!found) {
+            found = skillTurnSettingsFor(directory);
+            settings.set(directory, found);
+        }
+        return found;
+    };
+    const output = dryRun ? peekSkillTurn : recordSkillTurn;
+    return async (unit) => {
+        const current = settingsFor(unit.projectDirectory);
+        if (!current.enabled)
+            return;
+        // handleFinishedTurn logs a failure as skill-record-failed, so one bad turn never stops the run.
+        await handleFinishedTurn(unit, { memories: false, skills: true }, { recordSkillTurn: async (turn) => count(await output(turn, current)) });
+    };
+}

package/dist/importer/importer.d.ts

@@ -1,6 +1,7 @@
 import type { CaptureConversation, CaptureSummaryProvider } from "../core/host.js";
 import type { ModelPort } from "../core/profile-analysis.js";
 import type { ProfileImportReport } from "./profile-import.js";
+import { type ImportSkillTurnCounts } from "./import-turn-outputs.js";
 import { PiImportLedger } from "./ledger.js";
 import type { LoadedPiSession } from "./session-loader.js";
 import type { MemoryHost } from "../types/index.js";
@@ -27,6 +28,8 @@ export interface ImportFilters {
     dryRun?: boolean;
     /** Record profile prompts only; leave memory work units untouched. */
     skipMemories?: boolean;
+    /** Record no skill turns (design decision 11). */
+    skipSkills?: boolean;
     pathMaps?: ImportPathMap[];
     root?: string;
     /**
@@ -54,7 +57,7 @@ export interface ImportProjectReport {
     sessions: number;
     units: number;
 }
-export interface ImportReport {
+export interface ImportReport extends ImportSkillTurnCounts {
     dryRun: boolean;
     root: string;
     sessionsDiscovered: number;
@@ -140,5 +143,5 @@ export interface LazyImportSource {
     open: () => AsyncIterable<ImportSourceSession>;
 }
 /** Process host-labelled work units through the shared capture and ledger pipeline. */
-export declare function importHistorySource(source: AsyncIterable<ImportSourceSession> | Iterable<ImportSourceSession> | LazyImportSource, host: MemoryHost, deps: Pick<ImporterDeps, "provider" | "ledger" | "onProgress" | "signal">, filters: Pick<ImportFilters, "dryRun" | "force" | "since" | "until">, report: ImportReport): Promise<void>;
+export declare function importHistorySource(source: AsyncIterable<ImportSourceSession> | Iterable<ImportSourceSession> | LazyImportSource, host: MemoryHost, deps: Pick<ImporterDeps, "provider" | "ledger" | "onProgress" | "signal">, filters: Pick<ImportFilters, "dryRun" | "force" | "since" | "until" | "skipMemories" | "skipSkills">, report: ImportReport): Promise<void>;
 export declare function importPiHistory(deps: ImporterDeps, filters: ImportFilters): Promise<ImportReport>;

package/dist/importer/importer.js

@@ -1,5 +1,5 @@
 import { existsSync, realpathSync } from "node:fs";
-import { captureConversation } from "../core/capture.js";
+import { handleFinishedTurn } from "../core/turn-outputs.js";
 import { memoryClient } from "../services/client.js";
 import { findLiveCapturedEntryIds } from "../services/live-captured-entries.js";
 import { extractScopeFromContainerTag } from "../services/memory-scope.js";
@@ -8,7 +8,8 @@ import { tursoConnectionManager } from "../services/turso/connection-manager.js"
 import { tursoShardManager } from "../services/turso/shard-manager.js";
 import { extractPiConversationWindows, } from "./pi-conversation.js";
 import { discoverPiSessions } from "./discovery.js";
-import { resolveImportProject } from "./import-project.js";
+import { importDirectory } from "./import-project.js";
+import { importSkillTurnOutput, importSkillTurnsOn, importWorkUnit, skillTurnsOnly, } from "./import-turn-outputs.js";
 import { PiImportLedger, importLedgerDbPath } from "./ledger.js";
 export function buildImportKey(sessionId, window, host = "pi") {
     const terminalEntryId = window.sourceEntryIds?.[window.sourceEntryIds.length - 1];
@@ -106,13 +107,14 @@ async function lookupExistingMemory(projectHash, key, options) {
 /** Process host-labelled work units through the shared capture and ledger pipeline. */
 export async function importHistorySource(source, host, deps, filters, report) {
     const dryRun = Boolean(filters.dryRun);
+    const memories = !filters.skipMemories;
+    const recordSkills = importSkillTurnOutput(filters, report);
     const ledger = deps.ledger ?? new PiImportLedger();
     const ledgerFileExists = existsSync(importLedgerDbPath());
     const ledgerAccessible = !dryRun || ledgerFileExists;
-    // A dry run only reads the ledger (peek), so it never writes its schema.
-    if (!dryRun)
+    if (!dryRun && memories) {
+        // A dry run only reads the ledger (peek), so it never writes its schema.
         await ledger.get("__warmup__");
-    if (!dryRun) {
         const embeddingInitError = memoryClient.getEmbeddingInitError?.();
         if (embeddingInitError) {
             throw new Error(`Memory system is not ready for import: ${embeddingInitError}. Start the extension and retry.`);
@@ -146,7 +148,7 @@ export async function importHistorySource(source, host, deps, filters, report) {
     for await (const candidate of candidates) {
         if (deps.signal?.aborted)
             break;
-        const { sessionId, directory, sourceFile, hash, window } = candidate;
+        const { sessionId, sourceFile, hash, window } = candidate;
         const key = buildImportKey(sessionId, window, host);
         processed++;
         deps.onProgress?.(processed, report.unitsTotal, preview(window.userPrompt), report.unitsAlreadyHandled);
@@ -157,6 +159,11 @@ export async function importHistorySource(source, host, deps, filters, report) {
             promptPreview: preview(window.userPrompt),
             status: "would-import",
         };
+        const workUnit = importWorkUnit(host, candidate, key);
+        await recordSkills?.(workUnit);
+        // A skills-only unit leaves the memory ledger untouched.
+        if (!memories)
+            continue;
         const existing = !ledgerAccessible
             ? null
             : dryRun
@@ -203,31 +210,9 @@ export async function importHistorySource(source, host, deps, filters, report) {
             report.units.push(unit);
             continue;
         }
-        await ledger.begin({
-            key,
-            sessionId: sessionId,
-            sourceFile: sourceFile,
-            projectHash: hash,
-        });
+        await ledger.begin({ key, sessionId, sourceFile, projectHash: hash });
         try {
-            const result = await captureConversation({
-                host,
-                hostSessionId: sessionId,
-                sourceType: "history-import",
-                projectDirectory: directory,
-                userPrompt: window.userPrompt,
-                promptId: window.userEntryId,
-                textResponses: window.textResponses,
-                toolCalls: window.toolCalls,
-                sourceEntryIds: window.sourceEntryIds,
-                ...(window.userTimestamp !== undefined
-                    ? { sourceTimestamp: window.userTimestamp }
-                    : window.sourceTimestamp !== undefined
-                        ? { sourceTimestamp: window.sourceTimestamp }
-                        : {}),
-                sourceFile: sourceFile,
-                importId: key,
-            }, deps.provider);
+            const result = await handleFinishedTurn(workUnit, { memories: true, skills: false }, { provider: deps.provider });
             if (result.status === "skipped") {
                 await ledger.skip(key, `extractor-skip:${result.type ?? "unknown"}`);
                 unit.status = "skipped";
@@ -282,6 +267,7 @@ export async function importPiHistory(deps, filters) {
     const selected = filters.selectionKeys ? new Set(filters.selectionKeys) : null;
     const projectAggregates = new Map();
     const candidates = [];
+    const keepMissing = skillTurnsOnly(filters, Boolean(deps.profile));
     for (const discovered of discovery.sessions) {
         if (deps.signal?.aborted)
             break;
@@ -316,7 +302,7 @@ export async function importPiHistory(deps, filters) {
             });
             continue;
         }
-        const directory = resolveImportProject(session.cwd, pathMaps).directory;
+        const directory = importDirectory(session.cwd, pathMaps, keepMissing);
         if (!directory) {
             report.unresolvableSessions.push({ file: session.sourceFile, cwd: session.cwd });
             continue;
@@ -369,7 +355,7 @@ export async function importPiHistory(deps, filters) {
         }
     }
     const sourceSessions = [...grouped.values()];
-    if (filters.skipMemories) {
+    if (filters.skipMemories && !importSkillTurnsOn(filters)) {
         report.unitsTotal = candidates.length;
     }
     else {

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

@@ -23,6 +23,8 @@ export interface OpencodeImportOptions {
     force?: boolean;
     skipMemories?: boolean;
     skipProfile?: boolean;
+    /** Record no skill turns. */
+    skipSkills?: boolean;
     profileBatch?: number;
     provider?: CaptureSummaryProvider;
     profileModel?: ModelPort;

package/dist/importer/opencode-import.js

@@ -1,7 +1,8 @@
 import { getTags } from "../services/tags.js";
 import { extractScopeFromContainerTag } from "../services/memory-scope.js";
 import { countImportableUnits, importHistorySource, projectFilterTag, selectImportWindows, } from "./importer.js";
-import { resolveImportProject } from "./import-project.js";
+import { importDirectory } from "./import-project.js";
+import { importSkillTurnsOn, skillTurnsOnly } from "./import-turn-outputs.js";
 import { DEFAULT_OPENCODE_DB, openOpencodeHistory, } from "./opencode-reader.js";
 import { importProfileFromHistory } from "./profile-import.js";
 export { DEFAULT_OPENCODE_DB };
@@ -32,8 +33,9 @@ export async function importOpencodeHistory(options) {
         const projects = new Map();
         const selected = [];
         let filtered = 0;
+        const keepMissing = skillTurnsOnly(options, options.skipProfile !== true);
         for (const session of history.sessions) {
-            const { directory } = resolveImportProject(session.recordedDirectory, options.pathMaps ?? [], session.projectWorktree);
+            const directory = importDirectory(session.recordedDirectory, options.pathMaps ?? [], keepMissing, session.projectWorktree);
             if (!directory) {
                 const entry = unresolved.get(session.recordedDirectory) ?? {
                     directory: session.recordedDirectory,
@@ -120,7 +122,8 @@ export async function importOpencodeHistory(options) {
             childSessionsFolded: history.childSessions,
             unresolvedProjects: [...unresolved.values()],
         };
-        if (!options.skipMemories) {
+        // The memory path or skill turns read every turn; profile-only runs only count them.
+        if (!options.skipMemories || importSkillTurnsOn(options)) {
             await importHistorySource({ total, open }, "opencode", {
                 provider: options.provider ?? {
                     summarize: async () => {

package/dist/importer/opencode-reader.js

@@ -3,6 +3,8 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { DatabaseSync } from "node:sqlite";
+import { boundToolInput, readToolPath } from "../core/tool-input.js";
+import { opencodeToolOutcome } from "../core/tool-outcome.js";
 import { INTERNAL_CAPTURE_SESSION_TITLES } from "./opencode-internal-sessions.js";
 import { acquirePrivateSnapshot, opencodeSnapshots, OpencodeSnapshotError, } from "./opencode-snapshot.js";
 export const DEFAULT_OPENCODE_DB = join(homedir(), ".local/share/opencode/opencode.db");
@@ -37,9 +39,8 @@ function parseData(json) {
         return {};
     }
 }
-function boundInput(value) {
-    const text = typeof value === "string" ? value : JSON.stringify(value ?? "");
-    return text.length > 100 ? `${text.slice(0, 100)}...` : text;
+function formatInput(value) {
+    return typeof value === "string" ? value : JSON.stringify(value ?? "");
 }
 function buildWindows(db, sessionId, filters) {
     const messages = db
@@ -98,9 +99,14 @@ function buildWindows(db, sessionId, filters) {
                 const state = part.state && typeof part.state === "object"
                     ? part.state
                     : {};
+                const name = String(part.tool ?? part.name ?? part.type);
+                const args = state.input ?? part.input ?? "";
+                const path = readToolPath(name, args);
                 current.toolCalls.push({
-                    name: String(part.tool ?? part.name ?? part.type),
-                    input: boundInput(state.input ?? part.input ?? ""),
+                    name,
+                    input: boundToolInput(formatInput(args)),
+                    ...opencodeToolOutcome(state),
+                    ...(path === undefined ? {} : { path }),
                 });
             }
         }

package/dist/importer/pi-conversation.d.ts

@@ -11,10 +11,15 @@ export interface PiSessionEntry {
     message?: {
         role?: string;
         content?: string | PiContentBlock[];
+        /** Set on `toolResult` messages: the `id` of the matching `toolCall` block. */
+        toolCallId?: string;
+        /** Set on `toolResult` messages. */
+        isError?: boolean;
     };
 }
 export interface PiContentBlock {
     type: string;
+    id?: string;
     text?: string;
     thinking?: string;
     name?: string;

package/dist/importer/pi-conversation.js

@@ -1,4 +1,5 @@
-const MAX_TOOL_INPUT_LENGTH = 100;
+import { boundToolInput, readToolPath } from "../core/tool-input.js";
+import { errorOutcome } from "../core/tool-outcome.js";
 function entryText(content) {
     if (typeof content === "string")
         return content;
@@ -16,6 +17,24 @@ function isUserEntry(entry) {
 function isAssistantEntry(entry) {
     return entry.type === "message" && entry.message?.role === "assistant";
 }
+function isToolResultEntry(entry) {
+    return entry.type === "message" && entry.message?.role === "toolResult";
+}
+/**
+ * Set the outcome of the call a `toolResult` entry answers. Only the error
+ * text of a failed call is kept; a successful call's output is never stored.
+ */
+function applyToolResult(entry, callsById) {
+    const call = callsById.get(entry.message?.toolCallId ?? "");
+    if (!call)
+        return;
+    if (entry.message?.isError === true) {
+        Object.assign(call, errorOutcome(entryText(entry.message.content)));
+    }
+    else {
+        call.outcome = "ok";
+    }
+}
 function formatToolInput(args) {
     if (!args)
         return "";
@@ -23,12 +42,6 @@ function formatToolInput(args) {
         .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
         .join(", ");
 }
-function boundToolInput(input) {
-    if (input.length > MAX_TOOL_INPUT_LENGTH) {
-        return input.substring(0, MAX_TOOL_INPUT_LENGTH) + "...";
-    }
-    return input;
-}
 /**
  * Build the capture window for the user entry at `userIndex`: only that
  * prompt's assistant/tool work, stopping at the next user message. Hidden
@@ -46,10 +59,13 @@ function buildWindow(entries, userIndex) {
     const textResponses = [];
     const toolCalls = [];
     const sourceEntryIds = [];
+    const callsById = new Map();
     let sourceTimestamp;
     for (const entry of entries.slice(userIndex + 1)) {
         if (isUserEntry(entry))
             break;
+        if (isToolResultEntry(entry))
+            applyToolResult(entry, callsById);
         if (!isAssistantEntry(entry))
             continue;
         if (typeof entry.id === "string")
@@ -69,10 +85,18 @@ function buildWindow(entries, userIndex) {
         }
         for (const block of blocks.filter((item) => item.type === "toolCall")) {
             const name = typeof block.name === "string" ? block.name : "unknown";
-            toolCalls.push({
+            // A call stays `unknown` until a `toolResult` entry answers it.
+            const call = {
                 name,
                 input: boundToolInput(formatToolInput(block.arguments)),
-            });
+                outcome: "unknown",
+            };
+            const path = readToolPath(name, block.arguments);
+            if (path !== undefined)
+                call.path = path;
+            toolCalls.push(call);
+            if (typeof block.id === "string")
+                callsById.set(block.id, call);
         }
     }
     if (textResponses.length === 0 && toolCalls.length === 0)

package/dist/importer/profile-catch-up.d.ts

@@ -14,7 +14,7 @@ export interface CatchUpState {
  * newest run owns the record, and waits for the older run's current batch.
  */
 export declare function catchUpLeaseHooks(signal?: AbortSignal, lease?: CatchUpLease): Promise<{
-    beforeBatch: () => Promise<import("../services/user-prompt/profile-catch-up-lease.js").BatchStart>;
+    beforeBatch: () => Promise<import("../services/turso/table-lease.js").BatchStart>;
     afterBatch: () => Promise<void>;
     release: () => Promise<void>;
 }>;

package/dist/importer/record-past-turns.d.ts

@@ -0,0 +1,28 @@
+import type { ImportHost } from "./import-args.js";
+import type { ImportReadiness } from "./import-readiness.js";
+import { type GroupImportRequest, type SettingsImportJobs } from "./web-import-jobs.js";
+/** Hosts whose default history exists on this computer and whose reader loads. */
+export declare function setUpHosts(readiness: ImportReadiness): ImportHost[];
+/**
+ * The grouped request for every set-up host. Each host lists its default
+ * source now, so the selection is every session up to this moment, including
+ * sessions the memory ledger marks handled.
+ */
+export declare function recordPastTurnsRequest(cwd: string, readiness: ImportReadiness, options?: {
+    dryRun?: boolean;
+}): Promise<GroupImportRequest>;
+/** Start **Record past turns** in a job slot: the web app's own, or a new one in the terminal. */
+export declare function startRecordPastTurns(jobs: SettingsImportJobs, cwd: string, readiness: ImportReadiness, options?: {
+    dryRun?: boolean;
+}): Promise<{
+    id: string;
+    host: ImportHost;
+    dryRun: boolean;
+    state: "failed" | "done" | "running" | "cancelling" | "cancelled";
+    sessions: number;
+    processed: number;
+    total: number;
+    report?: string;
+    summary?: ReturnType<typeof import("./run-import.js").summarizeHistoryImportReport>;
+    error?: string;
+} | import("./web-import-group.js").GroupImportJob>;

package/dist/importer/record-past-turns.js

@@ -0,0 +1,63 @@
+import { ImportJobError, } from "./web-import-jobs.js";
+/**
+ * **Record past turns** (design decision 11): one skill-turns-only grouped
+ * import over every set-up host, all projects and every session, with no date
+ * limit. It runs through the grouped-import job, so the Memory page shows its
+ * progress, and it calls no model. Safe to run again: `turn_key` drops copies.
+ */
+const HOSTS = ["pi", "opencode", "claude-code"];
+/** Hosts whose default history exists on this computer and whose reader loads. */
+export function setUpHosts(readiness) {
+    return HOSTS.filter((host) => readiness.defaultSourceFound[host] && (host !== "pi" || readiness.piReader.available));
+}
+/**
+ * The grouped request for every set-up host. Each host lists its default
+ * source now, so the selection is every session up to this moment, including
+ * sessions the memory ledger marks handled.
+ */
+export async function recordPastTurnsRequest(cwd, readiness, options = {}) {
+    const { listImportSessions } = await import("./import-sessions.js");
+    const hosts = [];
+    for (const host of setUpHosts(readiness)) {
+        const page = await listImportSessions({ refresh: true, includeHandled: true, limit: 1 }, {
+            host,
+            scope: "all-projects",
+            pathMaps: [],
+            cwd,
+            outputs: { memories: false, profile: false },
+            // Matches the job's skills-only options, so sessions whose folder is gone are kept.
+            skillTurnsOnly: true,
+        });
+        const selection = {
+            mode: "all",
+            excludedKeys: [],
+            revision: page.revision,
+            listedAt: page.listedAt,
+            includeHandled: true,
+        };
+        hosts.push({
+            host,
+            source: page.source.sourceToken,
+            selection,
+            // Claude Code imports name the external API; this run never calls it.
+            ...(host === "claude-code" ? { modelChoice: "external" } : {}),
+        });
+    }
+    return {
+        hosts,
+        options: {
+            skipMemories: true,
+            skipProfile: true,
+            scope: "all-projects",
+            ...(options.dryRun ? { dryRun: true } : {}),
+        },
+    };
+}
+/** Start **Record past turns** in a job slot: the web app's own, or a new one in the terminal. */
+export async function startRecordPastTurns(jobs, cwd, readiness, options = {}) {
+    const request = await recordPastTurnsRequest(cwd, readiness, options);
+    if (request.hosts.length === 0) {
+        throw new ImportJobError("No Pi, OpenCode or Claude Code history was found on this computer");
+    }
+    return jobs.start(request, cwd);
+}

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

@@ -66,6 +66,10 @@ export declare function summarizeHistoryImportReport(report: HistoryImportReport
     unitsAlreadyHandled: number;
     unitsHeldBack: number;
     unitsUntimed: number;
+    skillTurnsRecorded: number;
+    skillTurnsAlreadyPresent: number;
+    skillTurnsWouldRecord: number;
+    skillTurnsAlreadyRecorded: number;
     projects: number;
     unresolved: number;
     loadErrors: number;