@martian-engineering/lossless-claw 0.7.0 → 0.8.0

package/src/plugin/index.ts

@@ -143,6 +143,7 @@ type RuntimeModelAuth = {
 const MODEL_AUTH_PR_URL = "https://github.com/openclaw/openclaw/pull/41090";
 const MODEL_AUTH_MERGE_COMMIT = "4790e40";
 const MODEL_AUTH_REQUIRED_RELEASE = "the first OpenClaw release after 2026.3.8";
+const PROVIDER_API_RESOLUTION_ERROR_PREFIX = "[lcm] unable to resolve API family for provider ";
 const AUTH_ERROR_TEXT_PATTERN =
   /\b401\b|unauthorized|unauthorised|invalid[_ -]?token|invalid[_ -]?api[_ -]?key|authentication failed|authorization failed|missing scope|insufficient scope|model\.request\b/i;
 const AUTH_ERROR_STATUS_KEYS = ["status", "statusCode", "status_code"] as const;
@@ -174,6 +175,8 @@ const LOSSLESS_RECALL_POLICY_PROMPT = [
   "",
   "**`lcm_grep` routing guidance:**",
   '- Prefer `mode: "full_text"` for keyword or topical recall; keep `mode: "regex"` for literal patterns.',
+  '- Full-text queries use FTS5 semantics, and FTS5 defaults to AND matching, so extra terms make matching stricter rather than broader.',
+  '- Prefer 1-3 distinctive full-text terms or one quoted phrase. Do not pad queries with synonyms or extra keywords.',
   '- Wrap exact multi-word phrases in quotes, for example `"error handling"`.',
   '- Keep the default `sort: "recency"` for "what just happened?" lookups.',
   '- Use `sort: "relevance"` when hunting for the best older match on a topic.',
@@ -182,6 +185,17 @@ const LOSSLESS_RECALL_POLICY_PROMPT = [
   "**`lcm_expand_query` usage** — two patterns (always requires `prompt`):",
   "- With IDs: `lcm_expand_query(summaryIds: [\"sum_xxx\"], prompt: \"What config changes were discussed?\")`",
   "- With search: `lcm_expand_query(query: \"database migration\", prompt: \"What strategy was decided?\")`",
+  "- `query` uses the same FTS5 full-text search path as `lcm_grep`, so the same query-construction rules apply.",
+  "- `query` is for matching candidate summaries; `prompt` is the natural-language question or task to answer after expansion.",
+  "- FTS5 defaults to AND matching, so more query terms narrow results instead of broadening them.",
+  "- For `query`, use 1-3 distinctive terms or a quoted phrase. Do not stuff synonyms or extra keywords into it.",
+  "**Scope selection rule:**",
+  "- Start with the current conversation scope.",
+  "- If the in-context summaries already look relevant to the user's question, prefer `lcm_grep` or `lcm_expand_query` without `allConversations`.",
+  "- Use `allConversations: true` only when the current summaries do not appear sufficient, the question seems outside the current conversation, or the user is explicitly asking about work across sessions.",
+  "- For global discovery, prefer `lcm_grep(..., allConversations: true)` first.",
+  "- If global matches are found and the user needs one synthesized answer, use `lcm_expand_query(..., allConversations: true)`; this is bounded synthesis, not exhaustive expansion.",
+  "- If you already know the exact target conversation, prefer explicit `conversationId` instead of `allConversations`.",
   "- Optional: `maxTokens` (default 2000), `conversationId`, `allConversations: true`",
   "- Keep raw summary IDs out of normal user-facing prose unless the user explicitly asks for sources or IDs.",
   "",
@@ -204,6 +218,27 @@ function snapshotPluginEnv(env: NodeJS.ProcessEnv = process.env): PluginEnvSnaps
   };
 }
 
+/** Coerce a plugin-config-like value into a plain object when possible. */
+function toPluginConfig(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+/** Resolve plugin config from direct runtime injection or the root OpenClaw config fallback. */
+function resolvePluginConfig(api: OpenClawPluginApi): Record<string, unknown> | undefined {
+  const directPluginConfig = toPluginConfig(api.pluginConfig);
+  if (directPluginConfig && Object.keys(directPluginConfig).length > 0) {
+    return directPluginConfig;
+  }
+
+  const rootConfig = toPluginConfig(api.config);
+  const plugins = toPluginConfig(rootConfig?.plugins);
+  const entries = toPluginConfig(plugins?.entries);
+  const pluginEntry = toPluginConfig(entries?.["lossless-claw"]);
+  return toPluginConfig(pluginEntry?.config);
+}
+
 function truncateErrorMessage(message: string, maxChars = 240): string {
   return message.length <= maxChars ? message : `${message.slice(0, maxChars)}...`;
 }
@@ -501,7 +536,7 @@ function normalizeProviderId(provider: string): string {
 }
 
 /** Resolve known provider API defaults when model lookup misses. */
-function inferApiFromProvider(provider: string): string {
+function inferApiFromProvider(provider: string): string | undefined {
   const normalized = normalizeProviderId(provider);
   const map: Record<string, string> = {
     anthropic: "anthropic-messages",
@@ -514,7 +549,7 @@ function inferApiFromProvider(provider: string): string {
     "google-vertex": "google-vertex",
     "amazon-bedrock": "bedrock-converse-stream",
   };
-  return map[normalized] ?? "openai-responses";
+  return map[normalized];
 }
 
 /** Codex Responses rejects `temperature`; omit it for that API family. */
@@ -604,12 +639,18 @@ function buildModelAuthLookupModel(params: {
   provider: string;
   model: string;
   api?: string;
+  contextWindow?: number;
 }): RuntimeModelAuthModel {
+  const contextWindow =
+    typeof params.contextWindow === "number" && Number.isFinite(params.contextWindow) && params.contextWindow > 0
+      ? params.contextWindow
+      : 1_000_000;
+
   return {
     id: params.model,
     name: params.model,
     provider: params.provider,
-    api: params.api?.trim() || inferApiFromProvider(params.provider),
+    api: params.api?.trim() || inferApiFromProvider(params.provider) || "",
     reasoning: false,
     input: ["text"],
     cost: {
@@ -618,7 +659,7 @@ function buildModelAuthLookupModel(params: {
       cacheRead: 0,
       cacheWrite: 0,
     },
-    contextWindow: 200_000,
+    contextWindow,
     maxTokens: 8_000,
   };
 }
@@ -1211,10 +1252,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
   envSnapshot.openclawDefaultModel = readDefaultModelFromConfig(api.config);
   const modelAuth = getRuntimeModelAuth(api);
   const readEnv: ReadEnvFn = (key) => process.env[key];
-  const pluginConfig =
-    api.pluginConfig && typeof api.pluginConfig === "object" && !Array.isArray(api.pluginConfig)
-      ? api.pluginConfig
-      : undefined;
+  const pluginConfig = resolvePluginConfig(api);
   const config = resolveLcmConfig(process.env, pluginConfig);
   const log = createLcmLogger(api);
 
@@ -1260,7 +1298,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
       try {
         const modelAuthKey = resolveApiKeyFromAuthResult(
           await modelAuth.getApiKeyForModel({
-            model: buildModelAuthLookupModel({ provider, model }),
+            model: buildModelAuthLookupModel({ provider, model, contextWindow: 1_000_000 }),
             cfg: modelAuthConfig,
             ...(options?.profileId ? { profileId: options.profileId } : {}),
             ...(options?.preferredProfile ? { preferredProfile: options.preferredProfile } : {}),
@@ -1346,6 +1384,9 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
         const knownModel =
           typeof mod.getModel === "function" ? mod.getModel(providerId, modelId) : undefined;
         const fallbackApi =
+          (isRecord(knownModel) && typeof knownModel.api === "string" && knownModel.api.trim()
+            ? knownModel.api.trim()
+            : undefined) ||
           providerApi?.trim() ||
           resolveProviderApiFromRuntimeConfig(effectiveRuntimeConfig, providerId) ||
           (() => {
@@ -1360,6 +1401,11 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
             return first.api.trim();
           })() ||
           inferApiFromProvider(providerId);
+        if (!fallbackApi) {
+          throw new Error(
+            `[lcm] unable to resolve API family for provider ${providerId}; set models.providers.${providerId}.api explicitly instead of falling back implicitly.`,
+          );
+        }
         const modelAuthConfig = resolveModelAuthConfig(effectiveRuntimeConfig);
 
         // Resolve provider-level config (baseUrl, headers, etc.) from runtime config.
@@ -1386,18 +1432,29 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
                 ...knownModel,
                 id: knownModel.id,
                 provider: knownModel.provider,
-                api: knownModel.api,
-                // Merge baseUrl/headers from provider config if not already on the model.
+                api:
+                  typeof providerLevelConfig.api === "string" && providerLevelConfig.api.trim()
+                    ? providerLevelConfig.api.trim()
+                    : knownModel.api,
+                // Provider config must be able to override built-in transport defaults.
+                // Otherwise built-in providers like `openai` keep their catalog baseUrl
+                // (`https://api.openai.com/v1`) even when OpenClaw runtime config points
+                // that provider id at a custom proxy.
                 // Always set baseUrl to a string — pi-ai's detectCompat() crashes when
                 // baseUrl is undefined.
                 baseUrl:
-                  typeof knownModel.baseUrl === "string"
-                    ? knownModel.baseUrl
-                    : typeof providerLevelConfig.baseUrl === "string"
-                      ? providerLevelConfig.baseUrl
+                  typeof providerLevelConfig.baseUrl === "string"
+                    ? providerLevelConfig.baseUrl
+                    : typeof knownModel.baseUrl === "string"
+                      ? knownModel.baseUrl
                       : "",
-                ...(knownModel.headers == null && isRecord(providerLevelConfig.headers)
-                  ? { headers: providerLevelConfig.headers }
+                ...(isRecord(providerLevelConfig.headers)
+                  ? {
+                      headers: {
+                        ...(isRecord(knownModel.headers) ? knownModel.headers : {}),
+                        ...providerLevelConfig.headers,
+                      },
+                    }
                   : {}),
               }
             : {
@@ -1413,7 +1470,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
                   cacheRead: 0,
                   cacheWrite: 0,
                 },
-                contextWindow: 200_000,
+                contextWindow: 1_000_000,
                 maxTokens: 8_000,
                 // Always set baseUrl to a string — pi-ai's detectCompat() crashes when
                 // baseUrl is undefined.
@@ -1433,6 +1490,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
                 provider: providerId,
                 model: modelId,
                 api: resolvedModel.api,
+                contextWindow: resolvedModel.contextWindow,
               }),
               cfg: modelAuthConfig,
               ...(authProfileId ? { profileId: authProfileId } : {}),
@@ -1476,6 +1534,7 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
                   provider: providerId,
                   model: modelId,
                   api: resolvedModel.api,
+                  contextWindow: resolvedModel.contextWindow,
                 }),
                 cfg: modelAuthConfig,
                 ...(authProfileId ? { profileId: authProfileId } : {}),
@@ -1582,9 +1641,19 @@ function createLcmDependencies(api: OpenClawPluginApi): LcmDependencies {
       } catch (err) {
         log.error(`[lcm] completeSimple error: ${describeLogError(err)}`);
         const authError = detectProviderAuthError(err);
+        const configError =
+          !authError &&
+          err instanceof Error &&
+          err.message.startsWith(PROVIDER_API_RESOLUTION_ERROR_PREFIX)
+            ? {
+                kind: "provider_config",
+                message: err.message,
+              }
+            : undefined;
         return {
           content: [],
           ...(authError ? { error: authError } : {}),
+          ...(configError ? { error: configError } : {}),
         };
       }
     },
@@ -1777,6 +1846,7 @@ const lcmPlugin = {
     // when the same DB path is already initialized.
     const existingInit = getSharedInit(normalizedDbPath);
     if (existingInit && !existingInit.stopped) {
+      deps.log.info(`[lcm] Reusing shared engine init for db=${normalizedDbPath}`);
       wirePluginHandlers(api, deps, existingInit);
       return;
     }
@@ -1797,15 +1867,22 @@ const lcmPlugin = {
 
     /** Build a live DB+engine pair and roll back the DB handle if engine init fails. */
     function initializeEngine(): LcmContextEngine {
+      const startedAt = Date.now();
       const nextDatabase = createLcmDatabaseConnection(dbPath);
       try {
         const nextEngine = new LcmContextEngine(deps, nextDatabase);
         database = nextDatabase;
         lcm = nextEngine;
         initError = null;
+        deps.log.info(
+          `[lcm] Engine initialized for db=${normalizedDbPath} duration=${Date.now() - startedAt}ms`,
+        );
         return nextEngine;
       } catch (error) {
         closeLcmConnection(nextDatabase);
+        deps.log.info(
+          `[lcm] Engine init failed for db=${normalizedDbPath} duration=${Date.now() - startedAt}ms error=${toInitError(error).message}`,
+        );
         throw error;
       }
     }

package/src/plugin/lcm-command.ts

@@ -6,6 +6,13 @@ import type { LcmSummarizeFn } from "../summarize.js";
 import type { LcmDependencies } from "../types.js";
 import type { OpenClawPluginCommandDefinition, PluginCommandContext } from "openclaw/plugin-sdk";
 import { applyScopedDoctorRepair } from "./lcm-doctor-apply.js";
+import {
+  applyDoctorCleaners,
+  getDoctorCleanerApplyUnavailableReason,
+  getDoctorCleanerFilterIds,
+  scanDoctorCleaners,
+  type DoctorCleanerId,
+} from "./lcm-doctor-cleaners.js";
 import {
   detectDoctorMarker,
   getDoctorSummaryStats,
@@ -52,8 +59,11 @@ type CurrentConversationResolution =
 type ParsedLcmCommand =
   | { kind: "status" }
   | { kind: "doctor"; apply: boolean }
+  | { kind: "doctor_cleaners"; apply: boolean; filterId?: DoctorCleanerId; vacuum: boolean }
   | { kind: "help"; error?: string };
 
+const DOCTOR_CLEANER_IDS = new Set<DoctorCleanerId>(getDoctorCleanerFilterIds());
+
 function asRecord(value: unknown): Record<string, unknown> | undefined {
   return value && typeof value === "object" && !Array.isArray(value)
     ? (value as Record<string, unknown>)
@@ -138,6 +148,32 @@ function splitArgs(rawArgs: string | undefined): string[] {
     .filter(Boolean);
 }
 
+function parseDoctorCleanerApplyArgs(tokens: string[]):
+  | { ok: true; filterId?: DoctorCleanerId; vacuum: boolean }
+  | { ok: false; error: string } {
+  let filterId: DoctorCleanerId | undefined;
+  let vacuum = false;
+
+  for (const token of tokens) {
+    const normalized = token.toLowerCase();
+    if (normalized === "vacuum") {
+      vacuum = true;
+      continue;
+    }
+    if (DOCTOR_CLEANER_IDS.has(normalized as DoctorCleanerId) && !filterId) {
+      filterId = normalized as DoctorCleanerId;
+      continue;
+    }
+    return {
+      ok: false,
+      error:
+        `\`${VISIBLE_COMMAND} doctor clean apply\` accepts at most one filter id (\`${getDoctorCleanerFilterIds().join("`, `")}\`) plus optional \`vacuum\`.`,
+    };
+  }
+
+  return { ok: true, filterId, vacuum };
+}
+
 function parseLcmCommand(rawArgs: string | undefined): ParsedLcmCommand {
   const tokens = splitArgs(rawArgs);
   if (tokens.length === 0) {
@@ -154,19 +190,34 @@ function parseLcmCommand(rawArgs: string | undefined): ParsedLcmCommand {
       if (rest.length === 0) {
         return { kind: "doctor", apply: false };
       }
+      if (rest.length === 1 && rest[0]?.toLowerCase() === "clean") {
+        return { kind: "doctor_cleaners", apply: false, vacuum: false };
+      }
+      if (rest[0]?.toLowerCase() === "clean" && rest[1]?.toLowerCase() === "apply") {
+        const parsedApply = parseDoctorCleanerApplyArgs(rest.slice(2));
+        return parsedApply.ok
+          ? {
+              kind: "doctor_cleaners",
+              apply: true,
+              filterId: parsedApply.filterId,
+              vacuum: parsedApply.vacuum,
+            }
+          : { kind: "help", error: parsedApply.error };
+      }
       if (rest.length === 1 && rest[0]?.toLowerCase() === "apply") {
         return { kind: "doctor", apply: true };
       }
       return {
         kind: "help",
-        error: "`/lcm doctor` accepts no arguments, or `apply` for the scoped repair path.",
+        error:
+          `\`${VISIBLE_COMMAND} doctor\` accepts no arguments, \`clean\` for global high-confidence junk diagnostics, \`clean apply [filter-id] [vacuum]\` for cleanup, or \`apply\` for the scoped summary repair path.`,
       };
     case "help":
       return { kind: "help" };
     default:
       return {
         kind: "help",
-        error: `Unknown subcommand \`${head}\`. Supported: status, doctor, doctor apply.`,
+        error: `Unknown subcommand \`${head}\`. Supported: status, doctor, doctor clean, doctor apply, help.`,
       };
   }
 }
@@ -423,6 +474,14 @@ function buildHelpText(error?: string): string {
       buildStatLine(formatCommand(VISIBLE_COMMAND), "Show compact status output."),
       buildStatLine(formatCommand(`${VISIBLE_COMMAND} status`), "Show plugin, Global, and current-conversation status."),
       buildStatLine(formatCommand(`${VISIBLE_COMMAND} doctor`), "Scan for broken or truncated summaries."),
+      buildStatLine(
+        formatCommand(`${VISIBLE_COMMAND} doctor clean`),
+        "Report global high-confidence junk candidates without deleting anything.",
+      ),
+      buildStatLine(
+        formatCommand(`${VISIBLE_COMMAND} doctor clean apply`),
+        "Delete approved high-confidence cleaner matches after creating a DB backup.",
+      ),
       buildStatLine(formatCommand(`${VISIBLE_COMMAND} doctor apply`), "Repair broken summaries in the current conversation."),
     ]),
     "",
@@ -435,6 +494,17 @@ function buildHelpText(error?: string): string {
   return lines.join("\n");
 }
 
+function buildDoctorCleanerExampleLine(params: {
+  conversationId: number;
+  sessionKey: string | null;
+  messageCount: number;
+  firstMessagePreview: string | null;
+}): string {
+  const sessionKey = params.sessionKey ? formatCommand(truncateMiddle(params.sessionKey, 44)) : "missing";
+  const preview = params.firstMessagePreview ? ` · first: ${JSON.stringify(params.firstMessagePreview)}` : "";
+  return `conv ${formatNumber(params.conversationId)} · session key ${sessionKey} · messages ${formatNumber(params.messageCount)}${preview}`;
+}
+
 async function buildStatusText(params: {
   ctx: PluginCommandContext;
   db: DatabaseSync;
@@ -584,6 +654,198 @@ async function buildDoctorText(params: {
   return lines.join("\n");
 }
 
+async function buildDoctorCleanersText(params: {
+  db: DatabaseSync;
+}): Promise<string> {
+  const scan = scanDoctorCleaners(params.db);
+  const lines = [
+    ...buildHeaderLines(),
+    "",
+    "🩺 Lossless Claw Doctor Clean",
+    "",
+    buildSection("🌐 Global scan", [
+      buildStatLine("filters", formatNumber(scan.filters.length)),
+      buildStatLine("matched conversations", formatNumber(scan.totalDistinctConversations)),
+      buildStatLine("matched messages", formatNumber(scan.totalDistinctMessages)),
+      buildStatLine("mode", "read-only diagnostics"),
+    ]),
+  ];
+
+  if (scan.filters.every((filter) => filter.conversationCount === 0)) {
+    lines.push(
+      "",
+      buildSection("✅ Result", ["No high-confidence cleaner candidates detected."]),
+    );
+    return lines.join("\n");
+  }
+
+  for (const filter of scan.filters) {
+    lines.push(
+      "",
+      buildSection(`🧹 ${filter.label}`, [
+        buildStatLine("filter id", formatCommand(filter.id)),
+        buildStatLine("description", filter.description),
+        buildStatLine("matched conversations", formatNumber(filter.conversationCount)),
+        buildStatLine("matched messages", formatNumber(filter.messageCount)),
+      ]),
+    );
+
+    if (filter.examples.length > 0) {
+      lines.push(
+        "",
+        buildSection(
+          "🧷 Examples",
+          filter.examples.map((example) => buildDoctorCleanerExampleLine(example)),
+        ),
+      );
+    }
+  }
+
+  lines.push(
+    "",
+    buildSection("🛠️ Next step", [
+      `Review the examples, then run ${formatCommand(`${VISIBLE_COMMAND} doctor clean apply`)} to delete approved matches after Lossless Claw creates a backup.`,
+    ]),
+  );
+
+  return lines.join("\n");
+}
+
+function runQuickCheck(db: DatabaseSync): string {
+  const rows = db.prepare(`PRAGMA quick_check`).all() as Array<{ quick_check?: string }>;
+  const results = rows
+    .map((row) => row.quick_check)
+    .filter((value): value is string => typeof value === "string" && value.length > 0);
+
+  if (results.length === 0) {
+    return "unknown";
+  }
+
+  if (results.length === 1 && results[0] === "ok") {
+    return "ok";
+  }
+
+  return results.join("; ");
+}
+
+function isPassingQuickCheck(result: string): boolean {
+  return result === "ok";
+}
+
+async function buildDoctorCleanersApplyText(params: {
+  db: DatabaseSync;
+  config: LcmConfig;
+  filterId?: DoctorCleanerId;
+  vacuum: boolean;
+}): Promise<string> {
+  const filterIds = params.filterId ? [params.filterId] : undefined;
+  const unavailableReason = getDoctorCleanerApplyUnavailableReason(params.config.databasePath);
+  const lines = [
+    ...buildHeaderLines(),
+    "",
+    "🩺 Lossless Claw Doctor Clean Apply",
+    "",
+    buildSection("🌐 Cleaner scope", [
+      buildStatLine(
+        "filters",
+        filterIds && filterIds.length > 0
+          ? filterIds.map((filter) => formatCommand(filter)).join(", ")
+          : "all approved cleaner filters",
+      ),
+      buildStatLine("vacuum requested", formatBoolean(params.vacuum)),
+    ]),
+    "",
+  ];
+  if (unavailableReason) {
+    lines.push(
+      buildSection("🛠️ Apply", [
+        buildStatLine("status", "unavailable"),
+        buildStatLine("reason", unavailableReason),
+      ]),
+    );
+    return lines.join("\n");
+  }
+
+  const before = scanDoctorCleaners(params.db, filterIds);
+  lines.splice(
+    lines.length - 1,
+    0,
+    buildSection("📊 Current matches", [
+      buildStatLine("matched conversations before apply", formatNumber(before.totalDistinctConversations)),
+      buildStatLine("matched messages before apply", formatNumber(before.totalDistinctMessages)),
+    ]),
+    "",
+  );
+
+  if (before.totalDistinctConversations === 0) {
+    lines.push(
+      buildSection("🛠️ Apply", [
+        buildStatLine("status", "completed"),
+        buildStatLine("backup path", "skipped (no matches)"),
+        buildStatLine("deleted conversations", "0"),
+        buildStatLine("deleted messages", "0"),
+        buildStatLine("vacuumed", "no"),
+        buildStatLine("quick_check", "not run (no writes)"),
+        buildStatLine("result", "clean; no deletes ran"),
+      ]),
+    );
+    return lines.join("\n");
+  }
+
+  let result: ReturnType<typeof applyDoctorCleaners>;
+  try {
+    result = applyDoctorCleaners(params.db, {
+      databasePath: params.config.databasePath,
+      filterIds,
+      vacuum: params.vacuum,
+    });
+  } catch (error) {
+    lines.push(
+      buildSection("🛠️ Apply", [
+        buildStatLine("status", "failed"),
+        buildStatLine(
+          "reason",
+          error instanceof Error ? error.message : "unknown cleaner apply failure",
+        ),
+      ]),
+    );
+    return lines.join("\n");
+  }
+
+  if (result.kind === "unavailable") {
+    lines.push(
+      buildSection("🛠️ Apply", [
+        buildStatLine("status", "unavailable"),
+        buildStatLine("reason", result.reason),
+      ]),
+    );
+    return lines.join("\n");
+  }
+
+  const quickCheck = runQuickCheck(params.db);
+  const quickCheckPassed = isPassingQuickCheck(quickCheck);
+  lines.push(
+    buildSection("🛠️ Apply", [
+      buildStatLine("status", quickCheckPassed ? "completed" : "warning"),
+      buildStatLine("backup path", result.backupPath),
+      buildStatLine("deleted conversations", formatNumber(result.deletedConversations)),
+      buildStatLine("deleted messages", formatNumber(result.deletedMessages)),
+      buildStatLine("vacuumed", formatBoolean(result.vacuumed)),
+      buildStatLine("quick_check", quickCheck),
+      buildStatLine(
+        "result",
+        quickCheckPassed
+          ? result.deletedConversations > 0
+            ? `removed ${formatNumber(result.deletedConversations)} conversation(s)`
+            : "clean; no deletes ran"
+          : "writes committed, but SQLite integrity verification reported problems; inspect the database or restore from the backup before continuing",
+      ),
+    ]),
+  );
+
+  return lines.join("\n");
+}
+
 async function buildDoctorApplyText(params: {
   ctx: PluginCommandContext;
   db: DatabaseSync;
@@ -726,7 +988,8 @@ export function createLcmCommand(params: {
     nativeProgressMessages: {
       telegram: "Lossless Claw is working...",
     },
-    description: "Show Lossless Claw health, scan broken summaries, and repair scoped doctor issues.",
+    description:
+      "Show Lossless Claw health, scan broken summaries, inspect high-confidence junk candidates, and run scoped doctor actions.",
     acceptsArgs: true,
     handler: async (ctx) => {
       const parsed = parseLcmCommand(ctx.args);
@@ -745,6 +1008,17 @@ export function createLcmCommand(params: {
                 }),
               }
             : { text: await buildDoctorText({ ctx, db: await getDb() }) };
+        case "doctor_cleaners":
+          return parsed.apply
+            ? {
+                text: await buildDoctorCleanersApplyText({
+                  db: await getDb(),
+                  config: params.config,
+                  filterId: parsed.filterId,
+                  vacuum: parsed.vacuum,
+                }),
+              }
+            : { text: await buildDoctorCleanersText({ db: await getDb() }) };
         case "help":
           return { text: buildHelpText(parsed.error) };
       }
@@ -758,6 +1032,7 @@ export const __testing = {
   getDoctorSummaryStats,
   getLcmStatusStats,
   getConversationStatusStats,
+  scanDoctorCleaners,
   resolveCurrentConversation,
   resolveContextEngineSlot,
   resolvePluginEnabled,

package/src/plugin/lcm-doctor-apply.ts

@@ -6,6 +6,7 @@ import type { LcmSummarizeFn } from "../summarize.js";
 import { createLcmSummarizeFromLegacyParams } from "../summarize.js";
 import type { LcmDependencies } from "../types.js";
 import { detectDoctorMarker, loadDoctorTargets, type DoctorTargetRecord } from "./lcm-doctor-shared.js";
+import { estimateTokens } from "../estimate-tokens.js";
 
 type SummaryOverride = {
   content: string;
@@ -524,9 +525,6 @@ function parseSqliteTimestamp(value: string | null | undefined): Date | null {
   return null;
 }
 
-function estimateTokens(text: string): number {
-  return Math.max(1, Math.ceil(text.length / 4));
-}
 
 function updateSummaryFts(db: DatabaseSync, summaryId: string, content: string): void {
   try {