om-memory-system 4.30.1 → 4.31.1

package/dist/importer/auto-backfill.js

@@ -68,6 +68,8 @@ export async function scheduleAutoBackfill(options) {
             force: false,
             skipMemories: false,
             skipProfile: false,
+            // Skill turns follow the same cutoff and sessions as memories.
+            skipSkills: !CONFIG.skillLearning,
             scope: "all-projects",
             pathMaps: [],
             until: cutoff,
@@ -89,8 +91,18 @@ export async function scheduleAutoBackfill(options) {
             return;
         }
         if (!current.pending) {
+            // No memory work, but turns to record: a skill-turns pass needs no model.
+            const skillTurnsOnly = Boolean(dry.skillTurnsWouldRecord);
+            if (skillTurnsOnly) {
+                await run(options.host, { ...args, dryRun: false, skipMemories: true, skipProfile: true }, {
+                    cwd: options.cwd,
+                    models: {},
+                    signal: controller.signal,
+                    track: { surface: options.surface ?? "auto", lockHeld: true },
+                });
+            }
             // A pressed Run now needs an answer on the page: record a finished run.
-            if (options.userStarted) {
+            if (options.userStarted && !skillTurnsOnly) {
                 await startImportRun(options.host, options.surface ?? "web")
                     .then((recorder) => recorder.finish("done", {}))
                     .catch((error) => log("Backfill run record write failed", {

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

@@ -17,6 +17,7 @@ export interface ClaudeContentBlock {
     input?: unknown;
     tool_use_id?: string;
     content?: unknown;
+    is_error?: boolean;
 }
 export interface ClaudeTranscriptEntry {
     type: string;

package/dist/importer/claude-conversation.js

@@ -1,3 +1,5 @@
+import { boundToolInput, readToolPath } from "../core/tool-input.js";
+import { errorOutcome } from "../core/tool-outcome.js";
 /**
  * Entry types seen in real transcripts. A line with any other type is skipped
  * and counted, so a new Claude Code version shows up in the import report.
@@ -35,7 +37,6 @@ const NOISE_PREFIXES = [
     "<bash-stderr>",
     "<task-notification>",
 ];
-const MAX_TOOL_INPUT_LENGTH = 100;
 /** Parse one transcript line. A JSON value without a string `type` is unreadable. */
 export function parseClaudeTranscriptLine(line) {
     if (!line.trim())
@@ -121,12 +122,6 @@ function formatToolInput(input) {
         .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;
-}
 function closeWindow(open) {
     if (open.textResponses.length === 0 && open.toolCalls.length === 0)
         return null;
@@ -153,10 +148,45 @@ function addAssistantWork(open, entry) {
     if (text)
         open.textResponses.push(text);
     for (const block of blocks.filter((item) => item.type === "tool_use")) {
-        open.toolCalls.push({
-            name: typeof block.name === "string" ? block.name : "unknown",
+        // A call stays `unknown` until a `tool_result` block answers it.
+        const name = typeof block.name === "string" ? block.name : "unknown";
+        const call = {
+            name,
             input: boundToolInput(formatToolInput(block.input)),
-        });
+            outcome: "unknown",
+        };
+        const path = readToolPath(name, block.input);
+        if (path !== undefined)
+            call.path = path;
+        open.toolCalls.push(call);
+        if (typeof block.id === "string")
+            open.callsById.set(block.id, call);
+    }
+}
+/** Text of a `tool_result` block: a string, or an array of text blocks. */
+function toolResultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((block) => block && block.type === "text" && typeof block.text === "string")
+        .map((block) => block.text)
+        .join("\n");
+}
+/**
+ * Set the outcome of each call a user entry's `tool_result` blocks answer.
+ * Only the error text of a failed call is kept; tool output is never stored.
+ */
+function addToolResults(open, entry) {
+    for (const block of blocksOf(entry).filter((item) => item.type === "tool_result")) {
+        const call = open.callsById.get(block.tool_use_id ?? "");
+        if (!call)
+            continue;
+        if (block.is_error === true)
+            Object.assign(call, errorOutcome(toolResultText(block.content)));
+        else
+            call.outcome = "ok";
     }
 }
 function windowsWithIndex(entries) {
@@ -180,6 +210,7 @@ function windowsWithIndex(entries) {
                     textResponses: [],
                     toolCalls: [],
                     sourceEntryIds: [entry.uuid],
+                    callsById: new Map(),
                 };
             }
             return;
@@ -187,6 +218,9 @@ function windowsWithIndex(entries) {
         if (open && entry.type === "assistant" && entry.isSidechain !== true) {
             addAssistantWork(open, entry);
         }
+        if (open && entry.type === "user" && entry.isSidechain !== true) {
+            addToolResults(open, entry);
+        }
     });
     flush();
     return result;

package/dist/importer/claude-hook-api.d.ts

@@ -1,6 +1,5 @@
 import type { CaptureSummaryProvider } from "../core/host.js";
 import type { ModelPort } from "../core/profile-analysis.js";
-import { type ClaudeConversationWindow, type ClaudeTranscriptEntry } from "./claude-conversation.js";
 export interface ClaudeHookDeps {
     /** The capture model. Defaults to the external API. */
     captureProvider?: () => CaptureSummaryProvider;
@@ -34,13 +33,6 @@ export declare function handleClaudeCapture(body: unknown, deps?: ClaudeHookDeps
 };
 /** Resolves when every queued capture has finished. */
 export declare function whenClaudeCaptureIdle(): Promise<void>;
-/**
- * The windows after the cursor. The transcript file can lag the hook, so the
- * hook's final text is added as a last assistant reply when the transcript
- * does not already end with it. It carries no entry id, so `sourceEntryIds`
- * stay the reader's ids.
- */
-export declare function claudeWindowsToCapture(entries: ClaudeTranscriptEntry[], cursor: string | null, finalText: string | undefined): ClaudeConversationWindow[];
 /**
  * Register the Claude Code retry drain in this web app and start one retry
  * pass. The drain uses the external API. When capture is off, the first

package/dist/importer/claude-hook-api.js

@@ -2,9 +2,9 @@ import { realpathSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { CONFIG, refreshConfigIfChanged } from "../config.js";
-import { captureConversation } from "../core/capture.js";
 import { classifyCaptureFailure, quickRetryDelayMs } from "../core/capture-retry-policy.js";
-import { buildRecentMemoriesSection, buildRetrievalSection, formatMemoriesForCompaction, retrievalWrapperBytes, stripRetrievalSections, wrapRetrievalSection, } from "../core/retrieval.js";
+import { buildRecentMemoriesSection, buildRetrievalSection, formatMemoriesForCompaction, retrievalWrapperBytes, wrapRetrievalSection, } from "../core/retrieval.js";
+import { handleFinishedTurn } from "../core/turn-outputs.js";
 import { DEFAULT_RETRIEVAL_MAX_TOKENS, tokensToByteCeiling } from "../core/context-budget.js";
 import { resolveClaudeCodeLiveModel } from "../services/ai/live-model-choice.js";
 import { captureFailureOf, drainCaptureRetries, queueFailedCapture, registerCaptureRetryDrain, startCaptureRetryDrain, } from "../services/capture-retry-drain.js";
@@ -12,9 +12,11 @@ import { readClaudeCaptureCursor, writeClaudeCaptureCursor, } from "../services/
 import { memoryClient } from "../services/client.js";
 import { log } from "../services/logger.js";
 import { isFullyPrivate, stripPrivateContent } from "../services/privacy.js";
+import { skillTurnRecorder } from "../services/skill-learning/settings-for.js";
 import { getTags } from "../services/tags.js";
-import { extractClaudeWindowsAfter, parseClaudeTranscript, } from "./claude-conversation.js";
+import { parseClaudeTranscript } from "./claude-conversation.js";
 import { learnClaudeProfile } from "./claude-profile-learning.js";
+import { claudeWindowsToCapture, recordClaudeSkillTurns, sessionDirectory, skillUnitOf, workUnitOf, } from "./claude-turn-units.js";
 import { defaultClaudeProjectsRoot } from "./claude-reader.js";
 // The web app's side of the Claude Code hooks (design decisions 4, 6, 7):
 // retrieval for SessionStart and UserPromptSubmit, a one-worker capture queue
@@ -251,63 +253,13 @@ async function readTranscript(request) {
     }
     return parsed.entries;
 }
-/**
- * The windows after the cursor. The transcript file can lag the hook, so the
- * hook's final text is added as a last assistant reply when the transcript
- * does not already end with it. It carries no entry id, so `sourceEntryIds`
- * stay the reader's ids.
- */
-export function claudeWindowsToCapture(entries, cursor, finalText) {
-    const tail = finalText?.trim();
-    if (!tail)
-        return extractClaudeWindowsAfter(entries, cursor);
-    const hookReply = {
-        type: "assistant",
-        message: { role: "assistant", content: [{ type: "text", text: tail }] },
-    };
-    const windows = extractClaudeWindowsAfter([...entries, hookReply], cursor);
-    const last = windows.at(-1);
-    const replies = last?.textResponses ?? [];
-    if (replies.length > 1 && replies[replies.length - 2].trim().endsWith(tail))
-        replies.pop();
-    return windows;
-}
-/**
- * The project a session belongs to: the first prompt's directory, the same rule
- * the history import uses. Live capture must file a turn under the project the
- * import would choose, or the import cannot see that the turn is already saved.
- */
-function sessionDirectory(entries, fallback) {
-    const first = entries.find((entry) => entry.type === "user" && entry.isSidechain !== true);
-    return typeof first?.cwd === "string" && first.cwd ? first.cwd : fallback;
-}
-/** A cleaned work unit, or null for a prompt with nothing left to capture. */
-function workUnitOf(request, window, directory) {
-    const prompt = stripRetrievalSections(window.userPrompt);
-    if (!prompt || isFullyPrivate(prompt))
-        return null;
-    return {
-        host: HOST,
-        hostSessionId: request.sessionId,
-        sourceType: "live-capture",
-        projectDirectory: directory,
-        userPrompt: stripPrivateContent(prompt),
-        promptId: window.userEntryId,
-        textResponses: window.textResponses.map(stripPrivateContent),
-        toolCalls: window.toolCalls.map((call) => ({
-            name: call.name,
-            input: stripPrivateContent(call.input),
-        })),
-        sourceEntryIds: window.sourceEntryIds,
-        ...(window.sourceTimestamp !== undefined ? { sourceTimestamp: window.sourceTimestamp } : {}),
-    };
-}
 /** Try the turn up to `autoCaptureMaxRetries` times, as the other hosts do. */
-async function captureWithQuickRetries(unit, provider, sleep) {
+async function captureWithQuickRetries(unit, provider, sleep, recordSkillTurn) {
     const maxRetries = Math.max(1, CONFIG.autoCaptureMaxRetries ?? 3);
     for (let attempt = 1;; attempt++) {
         try {
-            return await captureConversation(unit, provider);
+            const skills = recordSkillTurn !== undefined;
+            return await handleFinishedTurn(unit, { memories: true, skills }, { provider, recordSkillTurn });
         }
         catch (error) {
             if (attempt >= maxRetries)
@@ -320,16 +272,26 @@ async function externalModels() {
     const { selectImportModel } = await import("./model-selection.js");
     return selectImportModel({});
 }
+/** Memory capture is on and ready. Logs why when it is not, as before. */
+function memoryCaptureOn(request) {
+    if (!CONFIG.autoCaptureEnabled)
+        return false;
+    const live = resolveClaudeCodeLiveModel(CONFIG);
+    if (!live.ready)
+        reportCaptureOff(live.issues);
+    else if (memoryClient.getEmbeddingInitError?.())
+        skipped(request, "not-ready");
+    else
+        return true;
+    return false;
+}
 async function captureTurn(request, deps) {
     const started = Date.now();
     refreshConfigIfChanged(request.cwd);
-    if (!CONFIG.autoCaptureEnabled)
+    const memories = memoryCaptureOn(request);
+    // Skill learning records turns even when memory capture is off (ADR-036).
+    if (!memories && !CONFIG.skillLearning)
         return;
-    const live = resolveClaudeCodeLiveModel(CONFIG);
-    if (!live.ready)
-        return reportCaptureOff(live.issues);
-    if (memoryClient.getEmbeddingInitError?.())
-        return skipped(request, "not-ready");
     const entries = await readTranscript(request);
     if (!entries)
         return;
@@ -342,29 +304,38 @@ async function captureTurn(request, deps) {
         return;
     }
     const directory = sessionDirectory(entries, request.cwd);
+    const recorder = skillTurnRecorder(directory);
+    const recordOnly = (only) => recordClaudeSkillTurns(only, request.sessionId, directory, recorder);
+    if (!memories)
+        return recordOnly(windows);
     let provider;
     try {
         provider = deps.captureProvider?.() ?? (await externalModels()).capture;
     }
     catch (error) {
-        return skipped(request, "model-unavailable", { error: errorCode(error) });
+        skipped(request, "model-unavailable", { error: errorCode(error) });
+        return recordOnly(windows);
     }
     const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     const counts = { captured: 0, skipped: 0, failed: 0, private: 0, queued: 0 };
     let blocked = null;
     for (const window of windows) {
-        const unit = workUnitOf(request, window, directory);
+        const unit = workUnitOf(request.sessionId, window, directory);
         if (!unit) {
             counts.private++;
+            await recordOnly([window]);
         }
         else if (blocked) {
             // The model is out of reach: queue the rest of the turns without calling it.
+            await recordOnly([window]);
             if (await queueFailedCapture(unit, blocked, CONFIG))
                 counts.queued++;
         }
         else {
             try {
-                const result = await captureWithQuickRetries(unit, provider, sleep);
+                // Memory capture reads the cleaned unit; skill learning records the raw one.
+                const record = recorder && (() => recorder(skillUnitOf(request.sessionId, window, directory)));
+                const result = await captureWithQuickRetries(unit, provider, sleep, record);
                 counts[result.status]++;
                 await recordPrompt(request, unit, result.status === "captured" ? result.memoryId : null);
             }

package/dist/importer/claude-import.js

@@ -1,5 +1,6 @@
 import { importHistorySource, } from "./importer.js";
 import { openClaudeHistorySource } from "./claude-reader.js";
+import { importSkillTurnsOn, skillTurnsOnly } from "./import-turn-outputs.js";
 /**
  * Import Claude Code history through the shared capture, ledger, and profile
  * steps, with host `claude-code`. Mirrors `importPiHistory`: the same filters,
@@ -16,6 +17,7 @@ export async function importClaudeHistory(deps, filters) {
         ...(filters.maxSessions !== undefined ? { maxSessions: filters.maxSessions } : {}),
         ...(filters.pathMaps ? { pathMaps: filters.pathMaps } : {}),
         ...(filters.scope === "current-project" ? { project: filters.currentDirectory } : {}),
+        keepMissingFolders: skillTurnsOnly(filters, Boolean(deps.profile)),
         ...(deps.signal ? { signal: deps.signal } : {}),
     }, deps.loadSession ? { loadSession: deps.loadSession } : {});
     const report = {
@@ -42,7 +44,7 @@ export async function importClaudeHistory(deps, filters) {
         unreadableLines: source.unreadableLines,
         unknownTypes: source.unknownTypes,
     };
-    if (filters.skipMemories) {
+    if (filters.skipMemories && !importSkillTurnsOn(filters)) {
         report.unitsTotal = source.unitsKept;
     }
     else {

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

@@ -64,6 +64,8 @@ export interface ClaudeHistoryOptions {
     pathMaps?: ImportPathMap[];
     /** Keep only sessions of this project directory (current-project scope). */
     project?: string;
+    /** A skills-only run keeps a session whose folder is gone, under its recorded path. */
+    keepMissingFolders?: boolean;
     signal?: AbortSignal;
 }
 export interface ClaudeHistoryDeps {

package/dist/importer/claude-reader.js

@@ -6,7 +6,7 @@ import { claudeProjectsRoot } from "../services/claude-folder.js";
 import { extractScopeFromContainerTag } from "../services/memory-scope.js";
 import { getTags } from "../services/tags.js";
 import { extractClaudeConversationWindows, parseClaudeTranscript, parseClaudeTranscriptLine, } from "./claude-conversation.js";
-import { resolveImportProject } from "./import-project.js";
+import { importDirectory } from "./import-project.js";
 import { countImportableUnits, projectFilterTag, selectImportWindows, } from "./importer.js";
 /**
  * Discovery and loading of Claude Code transcripts for the history import.
@@ -213,7 +213,7 @@ export async function openClaudeHistorySource(options = {}, deps = {}) {
             source.sessionsFilteredOut++;
             continue;
         }
-        const { directory } = resolveImportProject(discovered.cwd, options.pathMaps ?? []);
+        const directory = importDirectory(discovered.cwd, options.pathMaps ?? [], options.keepMissingFolders === true);
         if (!directory) {
             source.unresolvableSessions.push({ file: discovered.file, cwd: discovered.cwd });
             continue;

package/dist/importer/claude-turn-units.d.ts

@@ -0,0 +1,26 @@
+import type { CaptureWorkUnit } from "../core/capture.js";
+import type { SkillTurnRecorder } from "../services/skill-learning/settings-for.js";
+import { type ClaudeConversationWindow, type ClaudeTranscriptEntry } from "./claude-conversation.js";
+/**
+ * The windows after the cursor. The transcript file can lag the hook, so the
+ * hook's final text is added as a last assistant reply when the transcript
+ * does not already end with it. It carries no entry id, so `sourceEntryIds`
+ * stay the reader's ids.
+ */
+export declare function claudeWindowsToCapture(entries: ClaudeTranscriptEntry[], cursor: string | null, finalText: string | undefined): ClaudeConversationWindow[];
+/**
+ * The project a session belongs to: the first prompt's directory, the same rule
+ * the history import uses. Live capture must file a turn under the project the
+ * import would choose, or the import cannot see that the turn is already saved.
+ */
+export declare function sessionDirectory(entries: ClaudeTranscriptEntry[], fallback: string): string;
+/** A cleaned work unit, or null for a prompt with nothing left to capture. */
+export declare function workUnitOf(sessionId: string, window: ClaudeConversationWindow, directory: string): CaptureWorkUnit | null;
+/**
+ * The unit skill learning records: OMMS's injected memories removed, nothing
+ * else. Private text and secrets are the skill output's job, by its setting,
+ * and the tool calls keep their outcome, error and path.
+ */
+export declare function skillUnitOf(sessionId: string, window: ClaudeConversationWindow, directory: string): CaptureWorkUnit;
+/** Records windows that memory capture does not run for. Never moves the capture cursor. */
+export declare function recordClaudeSkillTurns(windows: ClaudeConversationWindow[], sessionId: string, directory: string, recorder: SkillTurnRecorder | undefined): Promise<void>;

package/dist/importer/claude-turn-units.js

@@ -0,0 +1,85 @@
+import { stripRetrievalSections } from "../core/retrieval.js";
+import { handleFinishedTurn } from "../core/turn-outputs.js";
+import { isFullyPrivate, stripPrivateContent } from "../services/privacy.js";
+import { extractClaudeWindowsAfter, } from "./claude-conversation.js";
+// Work units for the Claude Code Stop hook (`claude-hook-api.ts`): the cleaned
+// unit memory capture reads, and the raw unit skill learning records.
+const HOST = "claude-code";
+/**
+ * The windows after the cursor. The transcript file can lag the hook, so the
+ * hook's final text is added as a last assistant reply when the transcript
+ * does not already end with it. It carries no entry id, so `sourceEntryIds`
+ * stay the reader's ids.
+ */
+export function claudeWindowsToCapture(entries, cursor, finalText) {
+    const tail = finalText?.trim();
+    if (!tail)
+        return extractClaudeWindowsAfter(entries, cursor);
+    const hookReply = {
+        type: "assistant",
+        message: { role: "assistant", content: [{ type: "text", text: tail }] },
+    };
+    const windows = extractClaudeWindowsAfter([...entries, hookReply], cursor);
+    const last = windows.at(-1);
+    const replies = last?.textResponses ?? [];
+    if (replies.length > 1 && replies[replies.length - 2].trim().endsWith(tail))
+        replies.pop();
+    return windows;
+}
+/**
+ * The project a session belongs to: the first prompt's directory, the same rule
+ * the history import uses. Live capture must file a turn under the project the
+ * import would choose, or the import cannot see that the turn is already saved.
+ */
+export function sessionDirectory(entries, fallback) {
+    const first = entries.find((entry) => entry.type === "user" && entry.isSidechain !== true);
+    return typeof first?.cwd === "string" && first.cwd ? first.cwd : fallback;
+}
+/** A cleaned work unit, or null for a prompt with nothing left to capture. */
+export function workUnitOf(sessionId, window, directory) {
+    const prompt = stripRetrievalSections(window.userPrompt);
+    if (!prompt || isFullyPrivate(prompt))
+        return null;
+    return {
+        host: HOST,
+        hostSessionId: sessionId,
+        sourceType: "live-capture",
+        projectDirectory: directory,
+        userPrompt: stripPrivateContent(prompt),
+        promptId: window.userEntryId,
+        textResponses: window.textResponses.map(stripPrivateContent),
+        toolCalls: window.toolCalls.map((call) => ({
+            name: call.name,
+            input: stripPrivateContent(call.input),
+        })),
+        sourceEntryIds: window.sourceEntryIds,
+        ...(window.sourceTimestamp !== undefined ? { sourceTimestamp: window.sourceTimestamp } : {}),
+    };
+}
+/**
+ * The unit skill learning records: OMMS's injected memories removed, nothing
+ * else. Private text and secrets are the skill output's job, by its setting,
+ * and the tool calls keep their outcome, error and path.
+ */
+export function skillUnitOf(sessionId, window, directory) {
+    return {
+        host: HOST,
+        hostSessionId: sessionId,
+        sourceType: "live-capture",
+        projectDirectory: directory,
+        userPrompt: stripRetrievalSections(window.userPrompt),
+        promptId: window.userEntryId,
+        textResponses: window.textResponses,
+        toolCalls: window.toolCalls,
+        sourceEntryIds: window.sourceEntryIds,
+        ...(window.sourceTimestamp !== undefined ? { sourceTimestamp: window.sourceTimestamp } : {}),
+    };
+}
+/** Records windows that memory capture does not run for. Never moves the capture cursor. */
+export async function recordClaudeSkillTurns(windows, sessionId, directory, recorder) {
+    if (!recorder)
+        return;
+    for (const window of windows) {
+        await handleFinishedTurn(skillUnitOf(sessionId, window, directory), { memories: false, skills: true }, { recordSkillTurn: recorder });
+    }
+}

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

@@ -14,6 +14,8 @@ export interface HistoryImportArgs {
     force: boolean;
     skipMemories: boolean;
     skipProfile: boolean;
+    /** Record no skill turns. Skill turns are recorded only while `skillLearning` is on. */
+    skipSkills: boolean;
     profileBatch?: number;
     /** Session: `provider/id` from the host's signed-in models. CLI: a model id for `--provider`. */
     model?: string;
@@ -49,6 +51,7 @@ export interface WebImportOptions {
     force?: boolean;
     skipMemories?: boolean;
     skipProfile?: boolean;
+    skipSkills?: boolean;
     model?: string;
     scope?: HistoryImportArgs["scope"];
     project?: string;

package/dist/importer/import-args.js

@@ -11,6 +11,7 @@ const BOOLEAN_FLAGS = new Set([
     "--force",
     "--skip-memories",
     "--skip-profile",
+    "--skip-skills",
 ]);
 const VALUE_FLAGS = new Set([
     "--profile-batch",
@@ -55,6 +56,7 @@ export function parseHistoryImportArgs(tokens, options) {
         force: false,
         skipMemories: false,
         skipProfile: false,
+        skipSkills: false,
         scope: "current-project",
         pathMaps: [],
         errors: [],
@@ -77,6 +79,8 @@ export function parseHistoryImportArgs(tokens, options) {
                 result.force = true;
             else if (flag === "--skip-memories")
                 result.skipMemories = true;
+            else if (flag === "--skip-skills")
+                result.skipSkills = true;
             else
                 result.skipProfile = true;
             continue;
@@ -188,6 +192,7 @@ export function webImportTokens(options, _host) {
         ["force", "--force"],
         ["skipMemories", "--skip-memories"],
         ["skipProfile", "--skip-profile"],
+        ["skipSkills", "--skip-skills"],
     ]) {
         if (options[field])
             tokens.push(flag);
@@ -244,8 +249,9 @@ ${model}
   --max-sessions <n>        Read at most n sessions, oldest first
   --map <old>=<new>         Map a recorded directory that no longer exists (repeatable)
 ${source}
-  --skip-memories           Record profile prompts only
-  --skip-profile            Import memories only
+  --skip-memories           Save no memories
+  --skip-profile            Record no profile prompts
+  --skip-skills             Record no skill turns (recorded only while skillLearning is on)
   --profile-batch <n>       Prompts per profile analysis batch (default: 50)
   --force                   Reprocess already-handled memory units and profile prompts
   --help                    Show this help

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

@@ -14,3 +14,9 @@ export interface ResolvedImportProject {
  * of the same project.
  */
 export declare function resolveImportProject(recordedDirectory: string | null, maps?: ImportPathMap[], projectWorktree?: string | null): ResolvedImportProject;
+/**
+ * The folder an importer uses for one session. Skill turns need no project
+ * folder, so a skills-only run (`keepMissing`) keeps a session whose folder is
+ * gone under its recorded path. Every other run leaves it unresolved.
+ */
+export declare function importDirectory(recordedDirectory: string | null, maps: ImportPathMap[], keepMissing: boolean, projectWorktree?: string | null): string | null;

package/dist/importer/import-project.js

@@ -33,3 +33,12 @@ export function resolveImportProject(recordedDirectory, maps = [], projectWorktr
     }
     return { directory: null, via: "unresolved" };
 }
+/**
+ * The folder an importer uses for one session. Skill turns need no project
+ * folder, so a skills-only run (`keepMissing`) keeps a session whose folder is
+ * gone under its recorded path. Every other run leaves it unresolved.
+ */
+export function importDirectory(recordedDirectory, maps, keepMissing, projectWorktree = null) {
+    const { directory } = resolveImportProject(recordedDirectory, maps, projectWorktree);
+    return directory ?? (keepMissing ? recordedDirectory : null);
+}

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

@@ -2,8 +2,12 @@ import type { BackfillHost } from "./backfill-model.js";
 import { type ProgressEstimate } from "./import-progress.js";
 export type ImportSurface = "auto" | "web" | "cli" | "slash";
 export type ImportRunState = "running" | "paused" | "stopped" | "done" | "failed";
-/** A run imports exchanges first, then learns the profile from the imported prompts. */
-export type ImportRunPhase = "exchanges" | "profile";
+/**
+ * A run imports exchanges first, then learns the profile from the imported
+ * prompts. A run without memories that records skill turns starts in
+ * `skill-turns` instead of `exchanges`.
+ */
+export type ImportRunPhase = "exchanges" | "skill-turns" | "profile";
 export interface ImportRunCounts {
     total: number;
     done: number;
@@ -48,4 +52,6 @@ export declare function startImportRun(host: BackfillHost, surface: ImportSurfac
     intervalMs?: number;
     sampleIntervalMs?: number;
     onPause?: () => void;
+    /** The first phase; `exchanges` unless the run records skill turns only. */
+    phase?: Exclude<ImportRunPhase, "profile">;
 }): Promise<ImportRunRecorder>;

package/dist/importer/import-runs.js

@@ -67,7 +67,7 @@ export async function readImportRun(host) {
         failed: Number(row.failed),
         error: row.error === null ? null : String(row.error),
         paused: Number(row.paused) === 1,
-        phase: row.phase === "profile" ? "profile" : "exchanges",
+        phase: row.phase === "profile" || row.phase === "skill-turns" ? row.phase : "exchanges",
         profileDone: Number(row.profile_done ?? 0),
         profileTotal: Number(row.profile_total ?? 0),
         ...(state === "running"
@@ -102,8 +102,8 @@ export async function startImportRun(host, surface, options = {}) {
     const startedAt = clock();
     await db.run(`UPDATE import_runs SET surface = ?, state = 'running', pid = ?, started_at = ?, total = 0,
        done = 0, imported = 0, skipped = 0, failed = 0, error = NULL, updated_at = ?, samples = '[]',
-       phase = 'exchanges', profile_done = 0, profile_total = 0
-     WHERE host = ?`, [surface, process.pid, startedAt, startedAt, host]);
+       phase = ?, profile_done = 0, profile_total = 0
+     WHERE host = ?`, [surface, process.pid, startedAt, startedAt, options.phase ?? "exchanges", host]);
     let samples = [];
     let lastWrite = Number.NEGATIVE_INFINITY;
     let lastSample = Number.NEGATIVE_INFINITY;

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

@@ -39,6 +39,11 @@ export interface ImportMatchOptions {
     outputs?: ImportOutputs;
     /** A forced run re-analyses handled history, so it keeps handled sessions. */
     force?: boolean;
+    /**
+     * The run writes skill turns only. Skill turns need no project folder, so a
+     * session whose folder is gone matches under its recorded path.
+     */
+    skillTurnsOnly?: boolean;
 }
 export declare class StaleSelectionError extends Error {
     readonly status = 409;
@@ -48,8 +53,10 @@ interface Matched {
     identity: ImportSourceIdentity;
     /** Resolvable sessions in scope, newest first. */
     matching: ImportSessionRow[];
-    /** Sessions whose directory cannot be resolved, in any scope. */
+    /** Sessions this run cannot use because their directory cannot be resolved, in any scope. */
     unresolved: ImportSessionRow[];
+    /** Every session whose directory cannot be resolved; feeds the Directory maps list. */
+    missing: ImportSessionRow[];
     revision: string;
 }
 export declare function matchImportSessions(identity: ImportSourceIdentity, options: ImportMatchOptions, snapshotMode: "fresh" | "reuse" | "any"): Promise<Matched>;