om-memory-system 4.30.1 → 4.31.1

package/dist/importer/run-import.js

@@ -31,6 +31,11 @@ export async function runHistoryImport(host, args, run) {
     try {
         const { startImportRun } = await import("./import-runs.js");
         const { workProgress } = await import("./import-progress.js");
+        const { importSkillTurnsOn, skillTurnsOnly } = await import("./import-turn-outputs.js");
+        // Without memories, the source pass records skill turns only (no model call).
+        const skillTurnsPass = args.skipMemories && importSkillTurnsOn(args);
+        // A skills-only run reads sessions whose folder is gone, so its report misses them as unresolved.
+        const keepsMissingFolders = skillTurnsOnly(args, !args.skipProfile);
         const controller = new AbortController();
         const onAbort = () => controller.abort();
         run.signal?.addEventListener("abort", onAbort, { once: true });
@@ -38,12 +43,16 @@ export async function runHistoryImport(host, args, run) {
             controller.abort();
         const recorder = await startImportRun(host, run.track.surface, {
             onPause: () => controller.abort(),
+            ...(skillTurnsPass ? { phase: "skill-turns" } : {}),
         });
+        // Every unit the source pass reached is finished: the loop checks the signal before it.
+        let reached = 0;
         try {
             const report = await runUntracked(host, args, {
                 ...run,
                 signal: controller.signal,
                 onProgress: (processed, total, preview, alreadyHandled = 0) => {
+                    reached = processed;
                     // Units already in the ledger need no model call: leave them out of
                     // the progress so the bar and the time left describe real work.
                     const work = workProgress(processed, total, alreadyHandled, run.track.expectedTotal);
@@ -64,14 +73,14 @@ export async function runHistoryImport(host, args, run) {
                         ? "failed"
                         : "done", {
                 // The total stays the one progress last reported; a real run has no
-                // "would import" count of its own.
-                done: handled,
+                // "would import" count of its own. A skill-turns pass counts the turns it read.
+                done: skillTurnsPass ? reached : handled,
                 imported: report.unitsImported,
                 skipped: report.unitsSkipped,
                 failed: report.unitsFailed,
             }, report.profile?.error ? profileFailureCode(report.profile.error) : undefined);
             // Only a run over every project and every session sees the full list.
-            if (args.scope === "all-projects" && !run.selection)
+            if (args.scope === "all-projects" && !run.selection && !keepsMissingFolders)
                 await recordUnresolved(host, report, args.since !== undefined || args.until !== undefined);
             return report;
         }
@@ -129,6 +138,7 @@ async function runUntracked(host, args, run) {
             force: args.force,
             skipMemories: args.skipMemories,
             skipProfile: args.skipProfile,
+            skipSkills: args.skipSkills,
             ...(run.signal ? { signal: run.signal } : {}),
             ...(run.onProgress ? { onProgress: run.onProgress } : {}),
             ...(run.models.capture ? { provider: capture } : {}),
@@ -164,6 +174,7 @@ async function runUntracked(host, args, run) {
         force: args.force,
         dryRun: args.dryRun,
         skipMemories: args.skipMemories,
+        skipSkills: args.skipSkills,
         pathMaps,
     };
     if (host === "claude-code") {
@@ -195,6 +206,12 @@ export function formatHistoryImportReport(host, report, model) {
             : ""));
     lines.push(`  memory units: ${report.unitsWouldImport} pending, ${report.unitsAlreadyHandled} already done, ` +
         `${report.unitsImported} imported, ${report.unitsSkipped} skipped, ${report.unitsFailed} failed`);
+    if (report.skillTurnsWouldRecord !== undefined) {
+        lines.push(`  skill turns: ${report.skillTurnsWouldRecord} pending, ${report.skillTurnsAlreadyRecorded ?? 0} already recorded`);
+    }
+    if (report.skillTurnsRecorded !== undefined) {
+        lines.push(`  skill turns: ${report.skillTurnsRecorded} recorded, ${report.skillTurnsAlreadyPresent ?? 0} already present`);
+    }
     for (const project of report.projects) {
         lines.push(`  project ${project.directory}: ${project.sessions} sessions, ${project.units} units`);
     }
@@ -236,6 +253,10 @@ export function summarizeHistoryImportReport(report) {
         unitsAlreadyHandled: report.unitsAlreadyHandled,
         unitsHeldBack: report.unitsHeldBack ?? 0,
         unitsUntimed: report.unitsUntimed ?? 0,
+        skillTurnsRecorded: report.skillTurnsRecorded ?? 0,
+        skillTurnsAlreadyPresent: report.skillTurnsAlreadyPresent ?? 0,
+        skillTurnsWouldRecord: report.skillTurnsWouldRecord ?? 0,
+        skillTurnsAlreadyRecorded: report.skillTurnsAlreadyRecorded ?? 0,
         projects: report.projects.length,
         unresolved: (report.unresolvedProjects?.length ?? 0) + report.unresolvableSessions.length,
         loadErrors: report.loadErrors.length,

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

@@ -11,3 +11,17 @@ export { BackfillControls } from "./backfill-controls.js";
 export { directoryMapsView, readStoreProjects, type KnownProject } from "./map-suggestions.js";
 export { testExternalApi } from "./external-api-test.js";
 export { catchUpState, pauseCatchUp, previewCatchUp, startCatchUp } from "./profile-catch-up.js";
+import type { SettingsImportJobs } from "./web-import-jobs.js";
+/** Start Record past turns in the web app's import job slot. */
+export declare function startRecordPast(jobs: () => Promise<SettingsImportJobs>, cwd: string): Promise<{
+    id: string;
+    host: import("./import-args.js").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/web-import-api.js

@@ -11,3 +11,9 @@ export { BackfillControls } from "./backfill-controls.js";
 export { directoryMapsView, readStoreProjects } from "./map-suggestions.js";
 export { testExternalApi } from "./external-api-test.js";
 export { catchUpState, pauseCatchUp, previewCatchUp, startCatchUp } from "./profile-catch-up.js";
+import { importReadiness } from "./import-readiness.js";
+import { startRecordPastTurns } from "./record-past-turns.js";
+/** Start Record past turns in the web app's import job slot. */
+export async function startRecordPast(jobs, cwd) {
+    return startRecordPastTurns(await jobs(), cwd, await importReadiness());
+}

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

@@ -1,5 +1,6 @@
 import { type ImportHost } from "./import-args.js";
 import { type ImportReadiness } from "./import-readiness.js";
+import type { ImportSurface } from "./import-runs.js";
 import { resolveImportSelection } from "./import-sessions.js";
 import { type ImportSourceIdentity } from "./import-sources.js";
 import { runHistoryImport, summarizeHistoryImportReport, type HistoryImportRun } from "./run-import.js";
@@ -17,7 +18,7 @@ export interface GroupHostJob {
     host: ImportHost;
     state: GroupHostState;
     sessions: number;
-    phase: "preparing" | "memory" | "profile";
+    phase: "preparing" | "memory" | "skill-turns" | "profile";
     processed: number;
     total: number;
     profileProcessed: number;
@@ -46,6 +47,8 @@ export interface GroupImportDeps {
     prepareModels?: (choice: string, directory: string, signal: AbortSignal, host: ImportHost) => Promise<HistoryImportRun["models"]>;
     discardSelection?: (identity: ImportSourceIdentity) => Promise<void>;
     waitingPrompts?: () => Promise<Set<string>>;
+    /** Where the run record says the import started; `web` by default. */
+    surface?: ImportSurface;
 }
 type Deps = GroupImportDeps & {
     runner: typeof runHistoryImport;

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

@@ -3,6 +3,7 @@ import { CONFIG } from "../config.js";
 import { hostLabel } from "../types/host-label.js";
 import { parseHistoryImportArgs, webImportTokens, } from "./import-args.js";
 import { importBlockedReason } from "./import-readiness.js";
+import { importSkillTurnsOn, skillTurnsOnly } from "./import-turn-outputs.js";
 import { resolveImportSelection } from "./import-sessions.js";
 import { importSourceKey, readImportSourceToken, } from "./import-sources.js";
 import { historyImportFailed, ImportAlreadyRunningError, runHistoryImport, summarizeHistoryImportReport, } from "./run-import.js";
@@ -53,10 +54,19 @@ function matchOptions(child, directory, signal) {
         cwd: directory,
         allowEmpty: true,
         signal,
-        outputs: { memories: !child.args.skipMemories, profile: !child.args.skipProfile },
+        // Skill turns have no session ledger: while they are recorded, no session counts as handled.
+        outputs: importSkillTurnsOn(child.args)
+            ? { memories: false, profile: false }
+            : { memories: !child.args.skipMemories, profile: !child.args.skipProfile },
         ...(child.args.force ? { force: true } : {}),
+        // The list the selection came from passed the same flag.
+        ...(skillTurnsOnly(child.args, !child.args.skipProfile) ? { skillTurnsOnly: true } : {}),
     };
 }
+/** A skill-turns-only run reads history and calls no model. */
+function needsModel(args) {
+    return !args.skipMemories || !args.skipProfile;
+}
 function hostError(host, error) {
     return new ImportJobError(`${hostLabel(host)}: ${safeHealthError(error, [CONFIG.memoryApiKey, CONFIG.embeddingApiKey])}`, error.status ?? 400);
 }
@@ -74,6 +84,10 @@ function emptySummary(dryRun) {
         unitsAlreadyHandled: 0,
         unitsHeldBack: 0,
         unitsUntimed: 0,
+        skillTurnsRecorded: 0,
+        skillTurnsAlreadyPresent: 0,
+        skillTurnsWouldRecord: 0,
+        skillTurnsAlreadyRecorded: 0,
         projects: 0,
         unresolved: 0,
         loadErrors: 0,
@@ -171,7 +185,7 @@ export async function startImportGroup(input, directory, deps, publish) {
                 child.row.blocker =
                     importBlockedReason(readiness, {
                         host,
-                        needsModel: true,
+                        needsModel: needsModel(child.args),
                         modelChoice: child.input.modelChoice,
                     }) ?? undefined;
                 if (!job.dryRun && child.row.blocker)
@@ -269,12 +283,12 @@ async function executeGroup(children, job, signal, directory, deps, waiting) {
             // Reader/model readiness may change while earlier children finish their profile work.
             const blocked = importBlockedReason(await deps.readiness(), {
                 host,
-                needsModel: !job.dryRun,
+                needsModel: !job.dryRun && needsModel(child.args),
                 modelChoice: child.input.modelChoice,
             });
             if (blocked)
                 throw new Error(blocked);
-            const models = job.dryRun
+            const models = job.dryRun || !needsModel(child.args)
                 ? {}
                 : await (deps.prepareModels ?? prepareModels)(child.input.modelChoice, directory, signal, host);
             if (signal.aborted) {
@@ -282,12 +296,16 @@ async function executeGroup(children, job, signal, directory, deps, waiting) {
                 continue;
             }
             const eligible = new Set();
-            child.row.phase = child.args.skipMemories ? "profile" : "memory";
+            child.row.phase = !child.args.skipMemories
+                ? "memory"
+                : importSkillTurnsOn(child.args)
+                    ? "skill-turns"
+                    : "profile";
             const report = await deps.runner(host, child.args, {
                 cwd: directory,
                 models,
                 signal,
-                track: { surface: "web" },
+                track: { surface: deps.surface ?? "web" },
                 selection: {
                     keys: pinned.keys,
                     cutoff: pinned.cutoff,
@@ -340,6 +358,8 @@ async function executeGroup(children, job, signal, directory, deps, waiting) {
             else {
                 const pending = report.unitsImported +
                     report.unitsWouldImport +
+                    (report.skillTurnsRecorded ?? 0) +
+                    (report.skillTurnsWouldRecord ?? 0) +
                     (report.profile?.promptsRecorded ?? 0) +
                     (report.profile?.promptsWouldRecord ?? 0) +
                     (report.profile?.batchesBuilt ?? 0) +

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

@@ -23,6 +23,7 @@ const fields = new Set([
     "force",
     "skipMemories",
     "skipProfile",
+    "skipSkills",
     "scope",
     "project",
     "since",
@@ -65,7 +66,7 @@ export function validateWebImportRequest(value) {
     for (const [key, option] of Object.entries(options)) {
         if (!fields.has(key))
             throw new Error(`Unknown import option: ${key}`);
-        if (["dryRun", "force", "skipMemories", "skipProfile"].includes(key)) {
+        if (["dryRun", "force", "skipMemories", "skipProfile", "skipSkills"].includes(key)) {
             if (typeof option !== "boolean")
                 throw new Error(`Invalid ${key}`);
         }
@@ -92,7 +93,10 @@ export function validateWebImportRequest(value) {
             throw new Error("The project must be an absolute path");
         }
     }
-    if (options.skipMemories === true && options.skipProfile === true)
+    // Skill turns count as a target only while skillLearning is on.
+    if (options.skipMemories === true &&
+        options.skipProfile === true &&
+        (options.skipSkills === true || !CONFIG.skillLearning))
         throw new Error("Choose Project memories or User profile");
     if (input.modelChoice !== undefined &&
         (typeof input.modelChoice !== "string" ||

package/dist/index.js

@@ -21,6 +21,7 @@ import { getLanguageName } from "./services/language-detector.js";
 import { getHostClientConfig } from "./adapters/opencode/opencode-host-config.js";
 import { applySkillsPathConfig } from "./adapters/opencode/package-skills.js";
 import { loadOpencodeProvider } from "./adapters/opencode/opencode-provider-loader.js";
+import { opencodeSkillsTool } from "./adapters/opencode/skills-tool.js";
 import { STRUCTURED_OUTPUT_AGENT, STRUCTURED_OUTPUT_TOOLS, } from "./adapters/opencode/opencode-provider.js";
 import { INTERNAL_CAPTURE_SESSION_TITLE, isInternalCaptureSessionTitle, isTrackedInternalCaptureSession, } from "./adapters/opencode/internal-capture-sessions.js";
 import { registerOpencodeProfileModel } from "./adapters/opencode/profile-model.js";
@@ -544,6 +545,7 @@ export const OmmsPlugin = async (ctx) => {
                     return JSON.stringify(result);
                 },
             }),
+            skills: opencodeSkillsTool(directory),
         },
         event: async (input) => {
             const event = input.event;
@@ -559,7 +561,8 @@ export const OmmsPlugin = async (ctx) => {
                 return;
             }
             if (event.type === "session.idle") {
-                if (!isConfigured() || !CONFIG.autoCaptureEnabled)
+                // Skill learning records turns even when memory capture is off (ADR-036).
+                if (!isConfigured() || !(CONFIG.autoCaptureEnabled || CONFIG.skillLearning))
                     return;
                 const sessionID = event.properties?.sessionID;
                 if (!sessionID)
@@ -575,6 +578,8 @@ export const OmmsPlugin = async (ctx) => {
                 idleTimeout = setTimeout(async () => {
                     try {
                         await performAutoCapture(autoCaptureHost, sessionID, directory);
+                        if (!CONFIG.autoCaptureEnabled)
+                            return; // Skill turns only; the memory work stays off.
                         await performUserProfileLearning(ctx, directory);
                         const { cleanupService } = await import("./services/cleanup-service.js");
                         if (await cleanupService.shouldRunCleanup())

package/dist/services/ai/session/ai-session-manager.js

@@ -24,6 +24,19 @@ export class AISessionManager {
         this.initPromise = (async () => {
             try {
                 this.db = await tursoConnectionManager.getConnection(this.dbPath);
+                // Sessions hold prompts, including skill drafts built from recorded
+                // turns. Zero deleted rows so their text does not stay in free pages.
+                await this.db.execute("PRAGMA secure_delete = ON");
+                // A file written before secure_delete was on can still hold deleted
+                // text in free pages. Rebuild it at open when it has free pages.
+                try {
+                    const free = await this.db.get("PRAGMA freelist_count");
+                    if (Number(free?.freelist_count ?? 0) > 0)
+                        await this.db.execute("VACUUM");
+                }
+                catch {
+                    // Best effort: another process may hold the file; the next open tries again.
+                }
                 await this.initDatabase();
             }
             catch (error) {

package/dist/services/auto-capture.d.ts

@@ -1,4 +1,4 @@
-import { type CaptureResult, type CaptureWorkUnit } from "../core/capture.js";
+import type { CaptureResult, CaptureWorkUnit } from "../core/capture.js";
 import type { AutoCaptureHost } from "../core/host.js";
 import { type CaptureRetryDrainResult } from "./capture-retry-drain.js";
 export { buildBoundedSummaryPrompt, buildMarkdownContext, getAutoCaptureMarkdownBudget, } from "../core/capture-context.js";

package/dist/services/auto-capture.js

@@ -1,11 +1,19 @@
 import { CONFIG, refreshConfigIfChanged } 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 { drainCaptureRetries, queueFailedCapture, startCaptureRetryDrain, } from "./capture-retry-drain.js";
 import { log } from "./logger.js";
+import { skillTurnRecorder } from "./skill-learning/settings-for.js";
 import { userPromptManager } from "./user-prompt/user-prompt-manager.js";
 export { buildBoundedSummaryPrompt, buildMarkdownContext, getAutoCaptureMarkdownBudget, } from "../core/capture-context.js";
 let isCaptureRunning = false;
+/**
+ * With memory capture off, prompts stay uncaptured, so each idle event lists
+ * them again. This keeps, per session, the time of the last prompt recorded for
+ * skill learning, so no conversation is read twice. The prompts are not marked
+ * captured, so memory capture still sees them once it is turned on.
+ */
+const skillRecordedUpTo = new Map();
 async function notifySafely(host, notification) {
     try {
         await host.notify?.(notification);
@@ -20,18 +28,74 @@ export async function performAutoCapture(host, sessionID, directory) {
     isCaptureRunning = true;
     try {
         const prompts = await userPromptManager.getUncapturedPromptsForSession(sessionID);
-        if (prompts.length === 0 || !host.isCaptureReady())
+        if (prompts.length === 0)
             return;
+        const recorder = skillTurnRecorder(directory);
+        // Skill learning records turns even when memory capture is off (ADR-036).
+        if (CONFIG.autoCaptureEnabled === false || !host.isCaptureReady()) {
+            for (const prompt of prompts) {
+                if (prompt.createdAt <= (skillRecordedUpTo.get(sessionID) ?? -Infinity))
+                    continue;
+                if (await recordSkillTurnOnly(host, sessionID, directory, prompt, recorder))
+                    skillRecordedUpTo.set(sessionID, prompt.createdAt);
+            }
+            return;
+        }
         const maxRetries = CONFIG.autoCaptureMaxRetries ?? 3;
         for (const prompt of prompts) {
-            await capturePrompt(host, sessionID, directory, prompt, maxRetries);
+            await capturePrompt(host, sessionID, directory, prompt, maxRetries, recorder);
         }
     }
     finally {
         isCaptureRunning = false;
     }
 }
-async function capturePrompt(host, sessionID, directory, prompt, maxRetries) {
+function opencodeWorkUnit(host, sessionID, directory, prompt, conversation) {
+    return {
+        host: host.host,
+        hostSessionId: sessionID,
+        sourceType: "live-capture",
+        projectDirectory: directory,
+        userPrompt: prompt.content,
+        promptId: prompt.id,
+        prompt: {
+            id: prompt.id,
+            providerId: prompt.providerId,
+            modelId: prompt.modelId,
+        },
+        ...conversation,
+    };
+}
+/**
+ * The skill output keys a turn by OpenCode's message id, the id the history
+ * import reads, so a live turn imported later stays one row. The memory unit
+ * keeps the OMMS prompt id.
+ */
+function opencodeSkillRecorder(prompt, recorder) {
+    return recorder && ((unit) => recorder({ ...unit, promptId: prompt.messageId }));
+}
+/**
+ * Memory capture is off or not ready: record the turn for skill learning only.
+ * Returns true when the finished turn went to the skill output.
+ */
+async function recordSkillTurnOnly(host, sessionID, directory, prompt, recorder) {
+    if (!recorder)
+        return false;
+    try {
+        const conversation = await host.getConversation(sessionID, prompt.messageId);
+        if (!conversation)
+            return false;
+        if (conversation.textResponses.length === 0 && conversation.toolCalls.length === 0)
+            return false;
+        await handleFinishedTurn(opencodeWorkUnit(host, sessionID, directory, prompt, conversation), { memories: false, skills: true }, { recordSkillTurn: opencodeSkillRecorder(prompt, recorder) });
+        return true;
+    }
+    catch {
+        log("OpenCode skill turn read failed", { sessionID, code: "conversation-read-failed" }, "warn");
+        return false;
+    }
+}
+async function capturePrompt(host, sessionID, directory, prompt, maxRetries, recorder) {
     let claimedPromptId = null;
     let attempt = prompt.capture_attempts || 0;
     let workUnit = null;
@@ -47,21 +111,9 @@ async function capturePrompt(host, sessionID, directory, prompt, maxRetries) {
                     return;
                 if (conversation.textResponses.length === 0 && conversation.toolCalls.length === 0)
                     return;
-                workUnit = {
-                    host: host.host,
-                    hostSessionId: sessionID,
-                    sourceType: "live-capture",
-                    projectDirectory: directory,
-                    userPrompt: prompt.content,
-                    promptId: prompt.id,
-                    prompt: {
-                        id: prompt.id,
-                        providerId: prompt.providerId,
-                        modelId: prompt.modelId,
-                    },
-                    ...conversation,
-                };
-                const captureResult = await captureConversation(workUnit, host);
+                workUnit = opencodeWorkUnit(host, sessionID, directory, prompt, conversation);
+                const record = opencodeSkillRecorder(prompt, recorder);
+                const captureResult = await handleFinishedTurn(workUnit, { memories: true, skills: record !== undefined }, { provider: host, recordSkillTurn: record });
                 if (captureResult.status === "skipped") {
                     log("Auto-capture skipped", {
                         promptId: prompt.id,

package/dist/services/chat/chat-runtime.d.ts

@@ -15,6 +15,8 @@ export interface ChatRuntimeConfig {
 }
 /** The chat store for this storage path, opened and migrated once. */
 export declare function chatStore(config: Pick<ChatRuntimeConfig, "storagePath">): Promise<ChatStore>;
+/** One structured call to the external memory model. Skill drafting reuses it (design §6). */
+export declare function callTool(config: ChatRuntimeConfig, system: string, user: string, tool: object, timeoutMs?: number): Promise<import("../ai/providers/base-provider.js").ToolCallResult>;
 /** The memory ids from `ids` that still exist in any project or user shard. */
 export declare function existingMemoryIds(ids: string[]): Promise<Set<string>>;
 /** Real dependencies for `askQuestion`, built from the settings passed in. */

package/dist/services/chat/chat-runtime.js

@@ -16,11 +16,12 @@ export function chatStore(config) {
     }
     return store;
 }
-async function callTool(config, system, user, tool) {
+/** One structured call to the external memory model. Skill drafting reuses it (design §6). */
+export async function callTool(config, system, user, tool, timeoutMs = CHAT_MODEL_TIMEOUT_MS) {
     const { AIProviderFactory } = await import("../ai/ai-provider-factory.js");
     const { buildMemoryProviderConfig } = await import("../ai/provider-config.js");
     const { aiSessionManager } = await import("../ai/session/ai-session-manager.js");
-    const provider = AIProviderFactory.createProvider(config.memoryProvider, buildMemoryProviderConfig(config, { maxIterations: 1, iterationTimeout: CHAT_MODEL_TIMEOUT_MS }));
+    const provider = AIProviderFactory.createProvider(config.memoryProvider, buildMemoryProviderConfig(config, { maxIterations: 1, iterationTimeout: timeoutMs }));
     const sessionId = `chat_${crypto.randomUUID()}`;
     try {
         return await provider.executeToolCall(system, user, tool, sessionId);

package/dist/services/global-config-writer.js

@@ -5,6 +5,7 @@ import { applyEdits, modify, parse } from "jsonc-parser";
 import { getGlobalConfigSourcePath, getGlobalConfigWritePath, validateGlobalConfig, } from "../config.js";
 import { CONFIG_TEMPLATE } from "../config-template.js";
 import { isValidClaudeConfigDir } from "./claude-folder.js";
+import { missingSkillFolder } from "./skill-learning/skill-config.js";
 import { KEYWORD_MODES } from "../utils/keyword-boost.js";
 import { getMemoryLimitRule } from "../utils/memory-limits.js";
 import { RERANKER_TIMEOUT_MAX_MS, RERANKER_TIMEOUT_MIN_MS } from "./request-timeouts.js";
@@ -43,7 +44,18 @@ const keys = new Set([
     "rerankerModel",
     "rerankerApiKey",
     "rerankerTimeoutMs",
+    "skillLearning",
+    "skillLearningRedact",
+    "skillFolders",
 ]);
+function isFolder(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Written only by the embedding apply route, together, after a passing test.
  * The general settings save refuses them, so a change always re-embeds.
@@ -70,6 +82,8 @@ export function isSecretReference(value) {
 }
 /** Reranker keys that a null edit removes, the same wire form as a limit reset. */
 const OPTIONAL_RERANKER_KEYS = ["rerankerApiUrl", "rerankerModel", "rerankerApiKey"];
+/** Other keys whose `null` edit removes them, so they follow the default again. */
+const RESETTABLE_KEYS = ["keywordMode", "skillFolders"];
 function isValidEdit(key, value) {
     // `undefined` removes the key from the file. `null` is the wire form of
     // "reset to default", accepted for the six memory limits and the optional reranker keys.
@@ -78,6 +92,9 @@ function isValidEdit(key, value) {
         return true;
     if (OPTIONAL_RERANKER_KEYS.includes(key) && value === null)
         return true;
+    // skillFolders: null removes the key, so the default skill folders apply again.
+    if (key === "skillFolders" && value === null)
+        return true;
     // keywordMode: null removes the key, so the mode follows the default again.
     if (key === "keywordMode")
         return value === null || KEYWORD_MODES.includes(value);
@@ -114,9 +131,15 @@ function isValidEdit(key, value) {
     if (key === "captureTrace" ||
         key === "autoBackfill" ||
         key === "webServerAutoStart" ||
-        key === "userProfileAutoCleanupEnabled") {
+        key === "userProfileAutoCleanupEnabled" ||
+        key === "skillLearning" ||
+        key === "skillLearningRedact") {
         return typeof value === "boolean";
     }
+    // Path rules are checked by the startup validation below; existence just after this check.
+    if (key === "skillFolders") {
+        return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+    }
     // Each automatic cleanup is paid for, so the page refuses an interval that would run one
     // after almost every learning pass. A hand edit of the file has no floor.
     if (key === "userProfileAutoCleanupInterval") {
@@ -201,6 +224,11 @@ options = {}) {
                         ? `Invalid ${key} setting: accepted ${rerankerAccepted[key]}`
                         : `Invalid ${key} setting`);
         }
+        const missing = key === "skillFolders" && value !== null
+            ? missingSkillFolder(value, isFolder)
+            : null;
+        if (missing !== null)
+            throw new Error(`Skill folder not found: ${missing}`);
     }
     const wasQueued = pending > 0;
     pending++;
@@ -224,7 +252,9 @@ options = {}) {
             // null is the wire form of "reset to default": remove the key so the
             // value follows the default again (undefined removes in jsonc modify).
             const jsoncValue = value === null &&
-                (getMemoryLimitRule(key) || OPTIONAL_RERANKER_KEYS.includes(key) || key === "keywordMode")
+                (getMemoryLimitRule(key) ||
+                    OPTIONAL_RERANKER_KEYS.includes(key) ||
+                    RESETTABLE_KEYS.includes(key))
                 ? undefined
                 : value;
             content = applyEdits(content, modify(content, jsoncPath, jsoncValue, {

package/dist/services/profile-cleanup-routes.d.ts

@@ -1,6 +1,6 @@
 /**
- * The profile cleanup routes: AI Cleanup (start, status, stop, apply) and the undo of the
- * last automatic cleanup. Returns the JSON body, or undefined when the path and method are
+ * The profile cleanup routes: AI Cleanup (start, status, stop, apply), the undo of the
+ * last automatic cleanup, and category cleanup (start, status, apply, undo). Returns the JSON body, or undefined when the path and method are
  * not a cleanup route. The body is read only for the routes that need it.
  */
 export declare function routeProfileCleanup(path: string, method: string, url: URL, readBody: () => Promise<any>): Promise<unknown | undefined>;

package/dist/services/profile-cleanup-routes.js

@@ -1,8 +1,9 @@
 import * as aiCleanup from "./ai-cleanup-handlers.js";
 import * as autoCleanup from "./auto-cleanup-handlers.js";
+import * as categoryCleanup from "./api-handlers.js";
 /**
- * The profile cleanup routes: AI Cleanup (start, status, stop, apply) and the undo of the
- * last automatic cleanup. Returns the JSON body, or undefined when the path and method are
+ * The profile cleanup routes: AI Cleanup (start, status, stop, apply), the undo of the
+ * last automatic cleanup, and category cleanup (start, status, apply, undo). Returns the JSON body, or undefined when the path and method are
  * not a cleanup route. The body is read only for the routes that need it.
  */
 export async function routeProfileCleanup(path, method, url, readBody) {
@@ -28,5 +29,21 @@ export async function routeProfileCleanup(path, method, url, readBody) {
         const body = await readBody();
         return autoCleanup.handleAutoCleanupUndo(body.userId || undefined);
     }
+    if (path === "/api/user-profile/category-cleanup") {
+        if (method === "POST") {
+            const body = await readBody();
+            return categoryCleanup.handleCategoryCleanupStart(body.userId || undefined);
+        }
+        if (method === "GET")
+            return categoryCleanup.handleCategoryCleanupStatus(queryUser);
+    }
+    if (path === "/api/user-profile/category-cleanup/apply" && method === "POST") {
+        const body = await readBody();
+        return categoryCleanup.handleCategoryCleanupApply(body.userId || undefined, body);
+    }
+    if (path === "/api/user-profile/category-cleanup/undo" && method === "POST") {
+        const body = await readBody();
+        return categoryCleanup.handleCategoryCleanupUndo(body.userId || undefined);
+    }
     return undefined;
 }

package/dist/services/settings-snapshot.js

@@ -34,6 +34,9 @@ const editable = [
     "rerankerModel",
     "rerankerTimeoutMs",
     "keywordMode",
+    "skillLearning",
+    "skillLearningRedact",
+    "skillFolders",
     ...MEMORY_LIMIT_SETTINGS,
 ];
 /** Keys a project config cannot override, so the page always shows the global value. */
@@ -55,6 +58,8 @@ const globalOnly = [
     "rerankerModel",
     "rerankerApiKey",
     "rerankerTimeoutMs",
+    "skillLearningRedact",
+    "skillFolders",
 ];
 function readSettingsFile(path) {
     if (!path)
@@ -112,7 +117,8 @@ export function getSettingsSnapshot(directory) {
             return [key, nestedMemorySetting(limitRule, global, project)];
         }
         const projectOverrides = Object.hasOwn(project, key) &&
-            (key === "captureTrace"
+            // A project may turn these off, never on.
+            (key === "captureTrace" || key === "skillLearning"
                 ? project[key] === false
                 : !key.endsWith("RetentionDays") && !globalOnly.includes(key));
         const source = projectOverrides