om-memory-system 4.29.1 → 4.31.1

package/README.md

@@ -131,6 +131,7 @@ Choose models and manage access. Diagnostics show capture outcomes and component
 | [Moving projects](docs/moving-projects.md)  | Folder moves, backup and restore                            |
 | [Updating and upgrading](docs/upgrading.md) | Updates, version pinning and older stores                   |
 | [CLI reference](docs/cli.md)                | Terminal commands                                           |
+| [Skill learning](docs/skill-learning.md)    | Opt-in turn recording, skill ranking and draft review       |
 | [For developers](docs/developers.md)        | Building, testing and architecture                          |
 | [Contributing](CONTRIBUTING.md)             | Development workflow and pull requests                      |
 

package/dist/adapters/opencode/conversation.js

@@ -1,4 +1,17 @@
-const MAX_TOOL_INPUT_LENGTH = 100;
+import { boundToolInput, readToolPath } from "../../core/tool-input.js";
+import { opencodeToolOutcome } from "../../core/tool-outcome.js";
+function formatToolInput(inputValue) {
+    if (!inputValue)
+        return "";
+    if (typeof inputValue === "string")
+        return inputValue;
+    if (typeof inputValue === "object") {
+        return Object.entries(inputValue)
+            .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+            .join(", ");
+    }
+    return "";
+}
 export function extractOpenCodeConversation(messages, promptMessageId) {
     const promptIndex = messages.findIndex((message) => message.info?.id === promptMessageId);
     if (promptIndex === -1)
@@ -28,22 +41,14 @@ export function extractOpenCodeConversation(messages, promptMessageId) {
         }
         for (const tool of message.parts.filter((part) => part.type === "tool")) {
             const name = tool.tool || "unknown";
-            let input = "";
-            if (tool.state?.input) {
-                const inputValue = tool.state.input;
-                if (typeof inputValue === "string") {
-                    input = inputValue;
-                }
-                else if (typeof inputValue === "object") {
-                    input = Object.entries(inputValue)
-                        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
-                        .join(", ");
-                }
-            }
-            if (input.length > MAX_TOOL_INPUT_LENGTH) {
-                input = input.substring(0, MAX_TOOL_INPUT_LENGTH) + "...";
-            }
-            toolCalls.push({ name, input });
+            const input = boundToolInput(formatToolInput(tool.state?.input));
+            const path = readToolPath(name, tool.state?.input);
+            toolCalls.push({
+                name,
+                input,
+                ...opencodeToolOutcome(tool.state),
+                ...(path === undefined ? {} : { path }),
+            });
         }
     }
     return { textResponses, toolCalls, sourceEntryIds };

package/dist/adapters/opencode/skills-tool.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+/** The OpenCode `skills` tool. V2 reaches it through the V1 plugin's `tool.skills`. */
+export declare function opencodeSkillsTool(directory: string): ToolDefinition;

package/dist/adapters/opencode/skills-tool.js

@@ -0,0 +1,31 @@
+import { tool } from "@opencode-ai/plugin";
+import { SKILLS_TOOL_DESCRIPTION, SKILLS_TOOL_MODES, runSkillsTool, } from "../../core/skills-tool.js";
+/** The OpenCode `skills` tool. V2 reaches it through the V1 plugin's `tool.skills`. */
+export function opencodeSkillsTool(directory) {
+    return tool({
+        description: SKILLS_TOOL_DESCRIPTION,
+        args: {
+            mode: tool.schema.enum(SKILLS_TOOL_MODES).optional(),
+            skill: tool.schema.string().optional(),
+            id: tool.schema.string().optional(),
+            state: tool.schema.string().optional(),
+            order: tool.schema.string().optional(),
+            folder: tool.schema.string().optional(),
+            idea: tool.schema
+                .object({
+                name: tool.schema.string().optional(),
+                description: tool.schema.string().optional(),
+                reason: tool.schema.string().optional(),
+                evidenceTurnIds: tool.schema.array(tool.schema.number()).optional(),
+            })
+                .optional(),
+            limit: tool.schema.number().optional(),
+            content: tool.schema.string().optional(),
+            summary: tool.schema.string().optional(),
+            evidence: tool.schema.array(tool.schema.number()).optional(),
+        },
+        async execute(args) {
+            return runSkillsTool(args, directory);
+        },
+    });
+}

package/dist/adapters/pi/capture.js

@@ -1,19 +1,21 @@
 import { CONFIG } from "../../config.js";
-import { captureConversation } from "../../core/capture.js";
 import { quickRetryDelayMs } from "../../core/capture-retry-policy.js";
+import { handleFinishedTurn } from "../../core/turn-outputs.js";
 import { log } from "../../services/logger.js";
 import { memoryClient } from "../../services/client.js";
 import { queueFailedCapture, startCaptureRetryDrain } from "../../services/capture-retry-drain.js";
-import { extractPiConversation } from "../../importer/pi-conversation.js";
+import { skillTurnRecorder, } from "../../services/skill-learning/settings-for.js";
+import { extractPiConversation, } from "../../importer/pi-conversation.js";
 export function createPiCaptureState() {
     return { handledUserEntries: new Set(), running: false };
 }
 /** Try the turn up to `autoCaptureMaxRetries` times, as OpenCode does, before it counts as failed. */
-async function captureWithQuickRetries(unit, provider) {
+async function captureWithQuickRetries(unit, provider, recorder) {
     const maxRetries = Math.max(1, CONFIG.autoCaptureMaxRetries ?? 3);
     for (let attempt = 1;; attempt++) {
         try {
-            return await captureConversation(unit, provider);
+            // A repeated attempt records the same turn key, which the store drops.
+            return await handleFinishedTurn(unit, { memories: true, skills: recorder !== undefined }, { provider, recordSkillTurn: recorder });
         }
         catch (error) {
             if (attempt >= maxRetries)
@@ -25,6 +27,32 @@ async function captureWithQuickRetries(unit, provider) {
         }
     }
 }
+function piWorkUnit(input, window) {
+    return {
+        host: "pi",
+        hostSessionId: input.sessionId,
+        sourceType: "live-capture",
+        projectDirectory: input.directory,
+        userPrompt: window.userPrompt,
+        promptId: window.userEntryId,
+        prompt: {
+            id: window.userEntryId,
+            providerId: input.prompt?.providerId ?? null,
+            modelId: input.prompt?.modelId ?? null,
+        },
+        textResponses: window.textResponses,
+        toolCalls: window.toolCalls,
+        sourceEntryIds: window.sourceEntryIds,
+        ...(window.sourceTimestamp !== undefined ? { sourceTimestamp: window.sourceTimestamp } : {}),
+    };
+}
+/** Memory capture is off or not ready: record the settled turn for skill learning only. */
+async function recordSkillTurnOnly(input, window = extractPiConversation(input.entries)) {
+    const recorder = skillTurnRecorder(input.directory);
+    if (!recorder || !window)
+        return;
+    await handleFinishedTurn(piWorkUnit(input, window), { memories: false, skills: true }, { recordSkillTurn: recorder });
+}
 /**
  * Capture the work unit completed by the most recent user prompt on the
  * settled branch. Safe to call for every `agent_settled` event: a work unit is
@@ -32,8 +60,11 @@ async function captureWithQuickRetries(unit, provider) {
  * compaction continuation, and repeated settled events never double-capture.
  */
 export async function capturePiSettledWorkUnit(input) {
-    if (!CONFIG.autoCaptureEnabled)
+    if (!CONFIG.autoCaptureEnabled) {
+        // Skill learning records turns even when memory capture is off (ADR-036).
+        await recordSkillTurnOnly(input);
         return { status: "skipped", reason: "disabled" };
+    }
     if (input.state.running)
         return { status: "skipped", reason: "busy" };
     input.state.running = true;
@@ -47,26 +78,11 @@ export async function capturePiSettledWorkUnit(input) {
         }
         const embeddingInitError = memoryClient.getEmbeddingInitError?.();
         if (embeddingInitError) {
+            await recordSkillTurnOnly(input, window);
             return { status: "skipped", reason: "not-ready" };
         }
-        workUnit = {
-            host: "pi",
-            hostSessionId: input.sessionId,
-            sourceType: "live-capture",
-            projectDirectory: input.directory,
-            userPrompt: window.userPrompt,
-            promptId: window.userEntryId,
-            prompt: {
-                id: window.userEntryId,
-                providerId: input.prompt?.providerId ?? null,
-                modelId: input.prompt?.modelId ?? null,
-            },
-            textResponses: window.textResponses,
-            toolCalls: window.toolCalls,
-            sourceEntryIds: window.sourceEntryIds,
-            ...(window.sourceTimestamp !== undefined ? { sourceTimestamp: window.sourceTimestamp } : {}),
-        };
-        const captureResult = await captureWithQuickRetries(workUnit, input.provider);
+        workUnit = piWorkUnit(input, window);
+        const captureResult = await captureWithQuickRetries(workUnit, input.provider, skillTurnRecorder(input.directory));
         input.state.handledUserEntries.add(window.userEntryId);
         if (captureResult.status === "skipped") {
             log("Pi auto-capture skipped by extractor", {

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

@@ -11,6 +11,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
  * - `session_shutdown`     -> idempotent session-scoped cleanup
  * - `memory` tool          -> shared add/search/profile/list/forget/help and
  *                             portability operations
+ * - `skills` tool          -> shared skill-learning operations (skills-tool.ts)
  *
  * Pi types are imported type-only: the compiled extension carries no Pi
  * runtime dependency and uses the host Pi runtime provided at load time.

package/dist/adapters/pi/extension.js

@@ -10,6 +10,7 @@ import { memoryClient } from "../../services/client.js";
 import { capturePiSettledWorkUnit, createPiCaptureState } from "./capture.js";
 import { createPiLiveModels } from "./live-model.js";
 import { registerPiHistoryImportCommand } from "./import-command.js";
+import { registerPiSkillsTool } from "./skills-tool.js";
 import { performPiProfileLearning } from "./profile.js";
 import { buildRetrievalSection, retrievalWrapperBytes, wrapRetrievalSection, } from "../../core/retrieval.js";
 import { DEFAULT_RETRIEVAL_MAX_TOKENS, tokensToByteCeiling } from "../../core/context-budget.js";
@@ -65,6 +66,7 @@ function lastSettledUserPrompt(entries) {
  * - `session_shutdown`     -> idempotent session-scoped cleanup
  * - `memory` tool          -> shared add/search/profile/list/forget/help and
  *                             portability operations
+ * - `skills` tool          -> shared skill-learning operations (skills-tool.ts)
  *
  * Pi types are imported type-only: the compiled extension carries no Pi
  * runtime dependency and uses the host Pi runtime provided at load time.
@@ -348,5 +350,6 @@ export default function ommsPiExtension(pi) {
             };
         },
     });
+    registerPiSkillsTool(pi);
     registerPiHistoryImportCommand(pi, () => latestCtx);
 }

package/dist/adapters/pi/skills-tool.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+/** The Pi `skills` tool, registered beside `memory`. */
+export declare function registerPiSkillsTool(pi: ExtensionAPI): void;

package/dist/adapters/pi/skills-tool.js

@@ -0,0 +1,34 @@
+import { Type } from "typebox";
+import { SKILLS_TOOL_DESCRIPTION, SKILLS_TOOL_MODES, runSkillsTool, } from "../../core/skills-tool.js";
+/** The Pi `skills` tool, registered beside `memory`. */
+export function registerPiSkillsTool(pi) {
+    pi.registerTool({
+        name: "skills",
+        label: "Skills",
+        description: SKILLS_TOOL_DESCRIPTION,
+        parameters: Type.Object({
+            mode: Type.Optional(Type.Union(SKILLS_TOOL_MODES.map((mode) => Type.Literal(mode)))),
+            skill: Type.Optional(Type.String()),
+            id: Type.Optional(Type.String()),
+            state: Type.Optional(Type.String()),
+            order: Type.Optional(Type.String()),
+            folder: Type.Optional(Type.String()),
+            idea: Type.Optional(Type.Object({
+                name: Type.Optional(Type.String()),
+                description: Type.Optional(Type.String()),
+                reason: Type.Optional(Type.String()),
+                evidenceTurnIds: Type.Optional(Type.Array(Type.Number())),
+            })),
+            limit: Type.Optional(Type.Number()),
+            content: Type.Optional(Type.String()),
+            summary: Type.Optional(Type.String()),
+            evidence: Type.Optional(Type.Array(Type.Number())),
+        }),
+        async execute(_toolCallId, args, _signal, _onUpdate, ctx) {
+            return {
+                content: [{ type: "text", text: await runSkillsTool(args, ctx.cwd) }],
+                details: {},
+            };
+        },
+    });
+}

package/dist/cli/index.js

@@ -17,6 +17,7 @@ Commands:
   web install|uninstall|status  Manage the web app login item
   web update                Update the global install and restart the web app
   memory <mode> [options]   Search, add, list, or forget memories (run with --help)
+  skills <mode> [options]   List skills, review proposals, record or delete turns (run with --help)
   profile-catch-up          Analyse every prompt waiting for profile learning (run with --help)
   profile-normalise-categories  Preview or confirm profile category renames (run with --help)
   profile-cleanup-categories    Group category names by meaning; preview, apply or undo (run with --help)
@@ -65,6 +66,10 @@ export async function runCli(argv) {
         const { runMemoryCommand } = await import("./memory-command.js");
         return await runMemoryCommand(argv.slice(1));
     }
+    if (argv[0] === "skills") {
+        const { runSkillsCommand } = await import("./skills-command.js");
+        return await runSkillsCommand(argv.slice(1));
+    }
     if (argv[0] === "profile-catch-up") {
         const { runProfileCatchUpCommand } = await import("./profile-catch-up-command.js");
         return await runProfileCatchUpCommand(argv.slice(1));

package/dist/cli/skills-command.d.ts

@@ -0,0 +1,12 @@
+import type { SkillOperationArgs } from "../core/skill-operations.js";
+type Print = (line: string) => void;
+type AppliedBy = "person" | "agent";
+/** Parse the shared modes' options. Throws on bad input or an unreadable content file. */
+export declare function parseOperationArgs(argv: string[]): {
+    args: SkillOperationArgs;
+    json: boolean;
+    appliedBy: AppliedBy;
+    directory?: string;
+};
+export declare function runSkillsCommand(argv: string[], print?: Print, printError?: Print): Promise<number>;
+export {};

package/dist/cli/skills-command.js

@@ -0,0 +1,242 @@
+import { readFileSync } from "node:fs";
+/**
+ * `om-memory-system skills <mode>`. Each mode lives in its own handler; this
+ * file only dispatches. Logs and progress go to stderr, results to stdout.
+ * The shared modes (list to help) run `runSkillOperation`, the same code as the
+ * hosts' `skills` tool, and record `person` on apply. The Claude Code tool
+ * passes the hidden `--applied-by agent`, so its applies record `agent`.
+ */
+const usage = `Usage: om-memory-system skills <mode> [options]
+
+Modes:
+  list                      Skills ranked by use in the last 30 days
+  ideas                     Up to three new skill ideas from recorded turns
+  draft                     Draft an improvement (--skill) or a new skill
+                            (--idea-name, --idea-description, --folder) as a pending proposal
+  evidence                  A skill's SKILL.md, numbers and recorded turns (--skill, --limit)
+  propose                   Save a fixed SKILL.md as a pending proposal, with no model call
+                            (--skill or the idea options, --content-file, --summary, --evidence)
+  proposals                 List proposals, newest first (--state)
+  show                      One proposal with its summary, evidence and diff (--id)
+  apply                     Write a pending proposal to its SKILL.md (--id)
+  reject                    Reject a pending proposal (--id)
+  undo                      Restore the file an applied proposal changed (--id)
+  help                      List the modes
+  record-past [--yes]       Record past turns from every set-up host's history; no model call
+  delete-turns [--yes]      Delete every recorded turn; proposals and saved skill versions stay
+
+Options for the modes from list to help:
+  --skill <name|path>       Skill name, or the full path of its SKILL.md (draft, evidence, propose)
+  --idea-name <name>        Name of a new skill idea (draft, propose)
+  --idea-description <text> Description of a new skill idea (draft, propose)
+  --idea-reason <text>      Why the idea is needed, from ideas (draft)
+  --idea-evidence <ids>     The idea's evidence turn ids, such as 12,14 (draft)
+  --folder <path>           Watched folder for a new skill (draft, propose)
+  --limit <n>               Recorded turns to show, 1 to 20; default 10 (evidence)
+  --content-file <path>     File with the full new SKILL.md; - reads standard input (propose)
+  --summary <text>          What changed and why (propose)
+  --evidence <ids>          Turn ids that show the need, such as 12,14 (propose)
+  --state <state>           pending, applied, stale, rejected or undone (proposals)
+  --order <order>           uses (default) or attention (list)
+  --id <id>                 Proposal id (show, apply, reject, undo)
+  --directory <path>        Project folder (default: the working folder)
+  --json                   Print the result as one JSON document
+
+Without --yes, record-past and delete-turns print counts and change nothing.
+Run record-past or delete-turns with --help to see its options.`;
+const OPERATION_MODES = new Set([
+    "list",
+    "ideas",
+    "draft",
+    "evidence",
+    "propose",
+    "proposals",
+    "show",
+    "apply",
+    "reject",
+    "undo",
+    "help",
+]);
+const VALUE_FLAGS = new Set([
+    "--skill",
+    "--id",
+    "--state",
+    "--order",
+    "--folder",
+    "--idea-name",
+    "--idea-description",
+    "--idea-reason",
+    "--idea-evidence",
+    "--directory",
+    "--limit",
+    "--content-file",
+    "--summary",
+    "--evidence",
+    // Hidden: the Claude Code tool passes `--applied-by agent`.
+    "--applied-by",
+]);
+/** Parse the shared modes' options. Throws on bad input or an unreadable content file. */
+export function parseOperationArgs(argv) {
+    const values = {};
+    let json = false;
+    for (let index = 0; index < argv.length; index++) {
+        const token = argv[index];
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        const equals = token.indexOf("=");
+        const flag = equals === -1 ? token : token.slice(0, equals);
+        if (!flag.startsWith("--"))
+            throw new Error(`Unexpected argument "${token}"`);
+        if (!VALUE_FLAGS.has(flag))
+            throw new Error(`Unknown option ${flag}`);
+        // A following flag is not a value; literal text that starts with "--" needs `--flag=value`.
+        const next = argv[index + 1];
+        const value = equals !== -1
+            ? token.slice(equals + 1)
+            : next !== undefined && !next.startsWith("--")
+                ? argv[++index]
+                : undefined;
+        if (value === undefined)
+            throw new Error(`${flag} needs a value`);
+        values[flag] = value;
+    }
+    const args = {
+        skill: values["--skill"],
+        id: values["--id"],
+        state: values["--state"],
+        order: values["--order"],
+        folder: values["--folder"],
+        limit: values["--limit"],
+        summary: values["--summary"],
+        evidence: values["--evidence"],
+    };
+    const contentFile = values["--content-file"];
+    if (contentFile !== undefined) {
+        try {
+            args.content = readFileSync(contentFile === "-" ? 0 : contentFile, "utf8");
+        }
+        catch {
+            throw new Error(`Cannot read --content-file ${contentFile}`);
+        }
+    }
+    const appliedBy = values["--applied-by"];
+    if (appliedBy !== undefined && appliedBy !== "agent") {
+        throw new Error("--applied-by accepts only agent");
+    }
+    if (values["--idea-name"] !== undefined || values["--idea-description"] !== undefined) {
+        args.idea = { name: values["--idea-name"], description: values["--idea-description"] };
+        if (values["--idea-reason"] !== undefined)
+            args.idea.reason = values["--idea-reason"];
+        const evidence = values["--idea-evidence"];
+        if (evidence !== undefined) {
+            args.idea.evidenceTurnIds = evidence
+                .split(",")
+                .map((item) => /^\s*T?(\d+)\s*$/i.exec(item)?.[1])
+                .filter((id) => id !== undefined)
+                .map(Number);
+        }
+    }
+    return {
+        args,
+        json,
+        appliedBy: appliedBy === "agent" ? "agent" : "person",
+        directory: values["--directory"],
+    };
+}
+/** Run one shared `skills` mode for the working directory (spec: Agents and terminal reach operations). */
+async function runOperation(mode, argv, print, printError) {
+    if (argv.includes("--help") || argv.includes("-h")) {
+        print(usage);
+        return 0;
+    }
+    let parsed;
+    try {
+        parsed = parseOperationArgs(argv);
+    }
+    catch (error) {
+        printError(`${error instanceof Error ? error.message : String(error)}\n\n${usage}`);
+        return 1;
+    }
+    const directory = parsed.directory ?? process.cwd();
+    const secrets = [];
+    let result;
+    try {
+        const { CONFIG, initConfig } = await import("../config.js");
+        initConfig(directory);
+        for (const secret of [CONFIG.memoryApiKey, CONFIG.embeddingApiKey]) {
+            if (secret)
+                secrets.push(secret);
+        }
+        const { runSkillOperation } = await import("../core/skill-operations.js");
+        const { skillOperationsDeps } = await import("../services/skill-learning/operations-deps.js");
+        result = await runSkillOperation(mode, parsed.args, skillOperationsDeps(directory, parsed.appliedBy));
+    }
+    catch (error) {
+        const text = error instanceof Error ? error.message : String(error);
+        result = { success: false, mode, code: "error", text };
+    }
+    let output = parsed.json ? JSON.stringify(result, null, 2) : result.text;
+    for (const secret of secrets)
+        output = output.replaceAll(secret, "[redacted]");
+    print(output);
+    return result.success ? 0 : 1;
+}
+/** Delete every recorded turn with its tool calls and skill uses (spec: The user can delete recorded turns). */
+async function runDeleteTurns(argv, print) {
+    let yes = false;
+    for (const flag of argv) {
+        if (flag === "--yes")
+            yes = true;
+        else if (flag === "--help" || flag === "-h") {
+            print("Usage: om-memory-system skills delete-turns [--yes]\n\nDelete every recorded turn. Proposals and saved skill versions stay.");
+            return 0;
+        }
+        else {
+            print(`Unknown option ${flag}; use --help`);
+            return 1;
+        }
+    }
+    try {
+        const { existsSync } = await import("node:fs");
+        const { CONFIG, initConfig } = await import("../config.js");
+        initConfig(process.cwd());
+        const { SkillStore, skillsDbPath } = await import("../services/skill-learning/store.js");
+        const { skillStoragePath } = await import("../services/skill-learning/skill-folders.js");
+        const path = skillsDbPath(skillStoragePath(CONFIG));
+        const store = new SkillStore(path);
+        if (!yes) {
+            print(`Recorded turns: ${await store.countTurns()}`);
+            print("Run again with --yes to delete them. Proposals and saved skill versions stay.");
+            return 0;
+        }
+        // init checks the schema version, so a file from a newer OMMS is never changed.
+        if (existsSync(path))
+            await store.init();
+        const deleted = await store.deleteAllTurns();
+        print(`Deleted ${deleted} recorded turns. Proposals and saved skill versions stay.`);
+        return 0;
+    }
+    catch (error) {
+        print(`Delete turns failed: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+}
+export async function runSkillsCommand(argv, print = console.log, printError = console.error) {
+    const [mode, ...rest] = argv;
+    if (!mode || mode === "--help" || mode === "-h") {
+        print(usage);
+        return 0;
+    }
+    if (OPERATION_MODES.has(mode))
+        return runOperation(mode, rest, print, printError);
+    if (mode === "record-past") {
+        const { runSkillsRecordPast } = await import("./skills-record-past.js");
+        return runSkillsRecordPast(rest, print);
+    }
+    if (mode === "delete-turns")
+        return runDeleteTurns(rest, print);
+    print(`Unknown skills mode: ${mode}\n\n${usage}`);
+    return 1;
+}

package/dist/cli/skills-record-past.d.ts

@@ -0,0 +1,5 @@
+export declare const RECORD_PAST_USAGE = "Usage: om-memory-system skills record-past [options]\n\nRecord past turns from every set-up host's history (Pi, OpenCode, Claude Code),\nall projects, with no date limit. It calls no model and is safe to run again.\nWithout --yes the command prints the counts and records nothing.\n\nOptions:\n  --yes                     Start the run\n  --dry-run                 Print the counts only\n  --help                    Show this help";
+type Print = (line: string) => void;
+/** `om-memory-system skills record-past`: the same grouped run as the web page. */
+export declare function runSkillsRecordPast(argv: string[], print?: Print, progress?: Print): Promise<number>;
+export {};

package/dist/cli/skills-record-past.js

@@ -0,0 +1,85 @@
+export const RECORD_PAST_USAGE = `Usage: om-memory-system skills record-past [options]
+
+Record past turns from every set-up host's history (Pi, OpenCode, Claude Code),
+all projects, with no date limit. It calls no model and is safe to run again.
+Without --yes the command prints the counts and records nothing.
+
+Options:
+  --yes                     Start the run
+  --dry-run                 Print the counts only
+  --help                    Show this help`;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function hostLines(job, dryRun, label) {
+    return job.hosts.map((child) => {
+        const s = child.summary;
+        const counts = !s
+            ? "not run"
+            : dryRun
+                ? `${s.skillTurnsWouldRecord} to record, ${s.skillTurnsAlreadyRecorded} already recorded`
+                : `${s.skillTurnsRecorded} recorded, ${s.skillTurnsAlreadyPresent} already present`;
+        return `${label(child.host)}: ${counts}${child.error ? ` (${child.error})` : ""}`;
+    });
+}
+/** `om-memory-system skills record-past`: the same grouped run as the web page. */
+export async function runSkillsRecordPast(argv, print = console.log, progress = console.error) {
+    let yes = false;
+    let dryRunFlag = false;
+    for (const flag of argv) {
+        if (flag === "--yes")
+            yes = true;
+        else if (flag === "--dry-run")
+            dryRunFlag = true;
+        else if (flag === "--help" || flag === "-h") {
+            print(RECORD_PAST_USAGE);
+            return 0;
+        }
+        else {
+            print(`Unknown option ${flag}; use --help`);
+            return 1;
+        }
+    }
+    const dryRun = dryRunFlag || !yes;
+    const { CONFIG, initConfig, initConfigWithLegacyMigration } = await import("../config.js");
+    try {
+        if (dryRun)
+            initConfig(process.cwd());
+        else
+            initConfigWithLegacyMigration(process.cwd());
+        if (!CONFIG.skillLearning) {
+            print("Skill learning is off. Set skillLearning to true in the global config first.");
+            return 1;
+        }
+        const [{ importReadiness }, { startRecordPastTurns }, { SettingsImportJobs }, { hostLabel }] = await Promise.all([
+            import("../importer/import-readiness.js"),
+            import("../importer/record-past-turns.js"),
+            import("../importer/web-import-jobs.js"),
+            import("../types/host-label.js"),
+        ]);
+        const readiness = await importReadiness();
+        const jobs = new SettingsImportJobs({ surface: "cli", readiness: async () => readiness });
+        await startRecordPastTurns(jobs, process.cwd(), readiness, { dryRun });
+        let job = jobs.current();
+        let shown = -1;
+        while (job.state === "running" || job.state === "cancelling") {
+            if (job.processed !== shown) {
+                shown = job.processed;
+                progress(`Reading past turns: ${job.processed}/${job.total}`);
+            }
+            await sleep(250);
+            job = jobs.current();
+        }
+        for (const line of hostLines(job, dryRun, hostLabel))
+            print(line);
+        if (job.state !== "done") {
+            print(`Record past turns ${job.state}${job.error ? `: ${job.error}` : ""}`);
+            return 1;
+        }
+        if (!dryRunFlag && !yes)
+            print("Run again with --yes to start.");
+        return 0;
+    }
+    catch (error) {
+        print(`Record past turns failed: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+}