@remnic/core 9.3.624 → 9.3.625

package/dist/{chunk-7TPH6UZL.js → chunk-2RHI3FGV.js}

@@ -53,12 +53,12 @@ import {
 } from "./chunk-D6RIFG4O.js";
 import {
   rebuildMemoryLifecycleLedger
-} from "./chunk-O4UNM6OR.js";
+} from "./chunk-532VCWYW.js";
 import {
   rebuildMemoryProjection,
   repairMemoryProjection,
   verifyMemoryProjection
-} from "./chunk-GLWW3EJQ.js";
+} from "./chunk-KB4MFBF5.js";
 import {
   getBulkImportSource,
   listBulkImportSources,
@@ -70,15 +70,15 @@ import {
 } from "./chunk-YR6GIWWY.js";
 import {
   promoteSemanticRuleFromMemory
-} from "./chunk-ZZPIJPPD.js";
+} from "./chunk-N5RGXWLQ.js";
 import {
   buildResumeBundleFromState,
   getResumeBundleStatus,
   recordResumeBundle
-} from "./chunk-FH3PPO42.js";
+} from "./chunk-KVFYTRMV.js";
 import {
   parseXrayCliOptions
-} from "./chunk-3QSU4NFF.js";
+} from "./chunk-QHXW3LZV.js";
 import {
   resolveAgentAccessAuthToken
 } from "./chunk-TGQ2NTWH.js";
@@ -89,12 +89,12 @@ import {
   runOperatorInventory,
   runOperatorRepair,
   runOperatorSetup
-} from "./chunk-FMGWXIES.js";
+} from "./chunk-TZDSNIRO.js";
 import {
   listNamespaces,
   runNamespaceMigration,
   verifyNamespaces
-} from "./chunk-AYHXQR53.js";
+} from "./chunk-MVQN73GT.js";
 import {
   collectPatternMemories,
   explainPatternMemory,
@@ -124,13 +124,13 @@ import {
 } from "./chunk-TERNBNJB.js";
 import {
   searchVerifiedEpisodes
-} from "./chunk-R3OQGYOU.js";
+} from "./chunk-P2D2MM47.js";
 import {
   ThreadingManager
 } from "./chunk-W4RVMTHR.js";
 import {
   searchVerifiedSemanticRules
-} from "./chunk-2UFQYU5F.js";
+} from "./chunk-57QXN2CS.js";
 import {
   getWorkProductLedgerStatus,
   recordWorkProductLedgerEntry,
@@ -203,19 +203,22 @@ import {
 } from "./chunk-UQ7RN5HK.js";
 import {
   parseConfig
-} from "./chunk-5GOMXHLC.js";
+} from "./chunk-KKTXCFD7.js";
 import {
   getAbstractionNodeStoreStatus
 } from "./chunk-OADWQ5CR.js";
 import {
   EngramAccessHttpServer
-} from "./chunk-FG76RDVI.js";
+} from "./chunk-Y3TMFC6I.js";
+import {
+  WearablesInputError
+} from "./chunk-7WV3F5DQ.js";
 import {
   EngramMcpServer
-} from "./chunk-I6UCUHLK.js";
+} from "./chunk-SHV5Y2WU.js";
 import {
   EngramAccessService
-} from "./chunk-KQFQ3IS5.js";
+} from "./chunk-F3FY3D3S.js";
 import {
   WorkStorage
 } from "./chunk-GDB4J2H3.js";
@@ -223,13 +226,13 @@ import {
   parseRecallExplainFormat,
   renderRecallExplain,
   renderXray
-} from "./chunk-PSUB67YB.js";
+} from "./chunk-PW6GURU3.js";
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   restoreMemoryGovernanceRun,
   runMemoryGovernance
-} from "./chunk-GYTVOLNX.js";
+} from "./chunk-3MNBW7R7.js";
 import {
   getTrustZoneStoreStatus,
   promoteTrustZoneRecord,
@@ -244,7 +247,7 @@ import {
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-4R4KTDIE.js";
+} from "./chunk-FPNQF475.js";
 import {
   getCausalTrajectoryStoreStatus
 } from "./chunk-TQOU3VAT.js";
@@ -269,6 +272,421 @@ import path2 from "path";
 import { access, readFile, readdir as readdir2, unlink } from "fs/promises";
 import { createHash } from "crypto";
 
+// src/wearables/cli.ts
+var USAGE = `Usage: wearables <command> [options]
+
+Commands:
+  status                         Show configured sources, connectors, last sync
+  check <source>                 Verify credentials/connectivity for a source
+  sync [options]                 Pull + clean + store transcripts (and memories)
+    --source <id>                Only this source (default: all enabled)
+    --date <YYYY-MM-DD>          Exactly this day
+    --days <n>                   Lookback window ending today (default 2)
+    --force-memories             Re-extract memories for unchanged days
+  transcript --date <YYYY-MM-DD> [--source <id>]
+                                 Print the stored day transcript(s)
+  search <query> [options]       Search stored transcripts
+    --source <id>  --from <date>  --to <date>  --limit <n>
+  memories [options]             List memories created from transcripts
+    --source <id>  --date <date>  --limit <n>
+  speakers list                  Show the speaker registry
+  speakers self <name>           Set the wearer's display name
+  speakers set <source> <key> <name> [--self]
+                                 Map a provider speaker label to a name
+  speakers remove <source> <key> Remove a speaker mapping
+  corrections list               Show correction rules (config + state)
+  corrections add <match> <replace> [--regex] [--case-sensitive] [--source <id>]
+                                 Add a transcript correction rule
+  corrections remove <index>     Remove a state correction rule by index
+
+Add --json to status/sync/search/memories for machine-readable output.
+`;
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--source",
+  "--date",
+  "--days",
+  "--from",
+  "--to",
+  "--limit"
+]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "--json",
+  "--force-memories",
+  "--regex",
+  "--case-sensitive",
+  "--self"
+]);
+function parseFlags(args) {
+  const flags = /* @__PURE__ */ new Map();
+  const positional = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    if (BOOLEAN_FLAGS.has(arg)) {
+      flags.set(arg, true);
+      continue;
+    }
+    if (VALUE_FLAGS.has(arg)) {
+      const value = args[index + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        throw new WearablesInputError(`${arg} requires a value`);
+      }
+      flags.set(arg, value);
+      index++;
+      continue;
+    }
+    throw new WearablesInputError(
+      `unknown flag '${arg}' \u2014 valid flags: ${[...VALUE_FLAGS, ...BOOLEAN_FLAGS].join(", ")}`
+    );
+  }
+  return { flags, positional };
+}
+function flagString(parsed, name) {
+  const value = parsed.flags.get(name);
+  return typeof value === "string" ? value : void 0;
+}
+function flagInt(parsed, name) {
+  const value = flagString(parsed, name);
+  if (value === void 0) return void 0;
+  const parsedValue = Number(value);
+  if (!Number.isFinite(parsedValue) || !Number.isInteger(parsedValue) || parsedValue < 1) {
+    throw new WearablesInputError(`${name} expects a positive integer (got '${value}')`);
+  }
+  return parsedValue;
+}
+function renderSyncSummary(summary) {
+  const lines = [
+    `${summary.source}: ${summary.conversations} conversation${summary.conversations === 1 ? "" : "s"} across ${summary.days.length} day${summary.days.length === 1 ? "" : "s"} (${summary.days.join(", ")})`,
+    `  segments kept/dropped:  ${summary.segmentsKept}/${summary.segmentsDropped}`,
+    `  redactions applied:     ${summary.redactions}`,
+    `  corrections applied:    ${summary.correctionsApplied}`,
+    `  transcripts written:    ${summary.transcriptsWritten.length > 0 ? summary.transcriptsWritten.join(", ") : "(none \u2014 unchanged)"}`,
+    `  memories created:       ${summary.memoriesCreated} (skipped ${summary.memoriesSkipped})`
+  ];
+  if (summary.nativeMemoriesImported > 0) {
+    lines.push(`  native memories queued: ${summary.nativeMemoriesImported}`);
+  }
+  for (const warning of summary.warnings) {
+    lines.push(`  warning: ${warning}`);
+  }
+  return lines.join("\n");
+}
+async function runWearablesCliCommand(service, args, io) {
+  const [command, ...rest] = args;
+  try {
+    switch (command) {
+      case void 0:
+      case "help":
+      case "--help": {
+        io.stdout.write(USAGE);
+        return command === void 0 ? 1 : 0;
+      }
+      case "status": {
+        const parsed = parseFlags(rest);
+        const status = await service.status();
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify(status, null, 2)}
+`);
+          return 0;
+        }
+        io.stdout.write(
+          `Wearables: ${status.enabled ? "enabled" : "disabled"} (timezone ${status.timezone})
+`
+        );
+        if (status.sources.length === 0) {
+          io.stdout.write(
+            "No sources configured. Add wearables.sources.<id> to the plugin config.\n"
+          );
+          return 0;
+        }
+        for (const source of status.sources) {
+          io.stdout.write(
+            `  ${source.source} (${source.displayName}): ${source.enabled ? "enabled" : "disabled"}, connector ${source.connectorInstalled ? "installed" : `MISSING \u2014 npm install @remnic/connector-${source.source}`}, memoryMode ${source.memoryMode}, ${source.transcriptDays} transcript day${source.transcriptDays === 1 ? "" : "s"}, last sync ${source.lastSyncAt ?? "never"}
+`
+          );
+        }
+        return 0;
+      }
+      case "check": {
+        const [sourceId] = rest;
+        if (!sourceId) {
+          throw new WearablesInputError("check requires a source id (e.g. wearables check limitless)");
+        }
+        const result = await service.checkAuth(sourceId);
+        io.stdout.write(
+          result.ok ? `${sourceId}: OK${result.detail ? ` \u2014 ${result.detail}` : ""}
+` : `${sourceId}: FAILED${result.detail ? ` \u2014 ${result.detail}` : ""}
+`
+        );
+        return result.ok ? 0 : 1;
+      }
+      case "sync": {
+        const parsed = parseFlags(rest);
+        if (parsed.positional.length > 0) {
+          throw new WearablesInputError(
+            `unexpected argument '${parsed.positional[0]}' \u2014 sync takes flags only`
+          );
+        }
+        const summaries = await service.sync({
+          source: flagString(parsed, "--source"),
+          date: flagString(parsed, "--date"),
+          days: flagInt(parsed, "--days"),
+          forceMemories: parsed.flags.has("--force-memories")
+        });
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify({ summaries }, null, 2)}
+`);
+          return 0;
+        }
+        for (const summary of summaries) {
+          io.stdout.write(`${renderSyncSummary(summary)}
+`);
+        }
+        io.stdout.write("OK\n");
+        return 0;
+      }
+      case "transcript": {
+        const parsed = parseFlags(rest);
+        const date = flagString(parsed, "--date");
+        if (!date) {
+          throw new WearablesInputError("transcript requires --date <YYYY-MM-DD>");
+        }
+        const views = await service.dayTranscript(date, flagString(parsed, "--source"));
+        if (views.length === 0) {
+          io.stderr.write(`No stored transcripts for ${date}.
+`);
+          return 1;
+        }
+        for (const view of views) {
+          if (views.length > 1) {
+            io.stdout.write(`
+===== ${view.source} \u2014 ${view.date} =====
+
+`);
+          }
+          if (view.overlapsWith.length > 0) {
+            io.stdout.write(
+              `(also recorded by: ${view.overlapsWith.join(", ")})
+
+`
+            );
+          }
+          io.stdout.write(`${view.body}
+`);
+        }
+        return 0;
+      }
+      case "search": {
+        const parsed = parseFlags(rest);
+        const query = parsed.positional.join(" ").trim();
+        if (query.length === 0) {
+          throw new WearablesInputError("search requires a query");
+        }
+        const results = await service.searchTranscripts(query, {
+          source: flagString(parsed, "--source"),
+          from: flagString(parsed, "--from"),
+          to: flagString(parsed, "--to"),
+          limit: flagInt(parsed, "--limit")
+        });
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify({ results }, null, 2)}
+`);
+          return 0;
+        }
+        if (results.length === 0) {
+          io.stdout.write("No matches.\n");
+          return 0;
+        }
+        for (const result of results) {
+          io.stdout.write(
+            `${result.source} ${result.date}  ${result.snippet}
+`
+          );
+        }
+        if (results.some((result) => result.backend === "scan")) {
+          io.stdout.write(
+            "(search index unavailable \u2014 results from bounded text scan)\n"
+          );
+        }
+        return 0;
+      }
+      case "memories": {
+        const parsed = parseFlags(rest);
+        const memories = await service.transcriptMemories({
+          source: flagString(parsed, "--source"),
+          date: flagString(parsed, "--date"),
+          limit: flagInt(parsed, "--limit")
+        });
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify({ memories }, null, 2)}
+`);
+          return 0;
+        }
+        if (memories.length === 0) {
+          io.stdout.write("No wearable-derived memories found.\n");
+          return 0;
+        }
+        for (const memory of memories) {
+          const status = memory.status === "pending_review" ? " [pending review]" : "";
+          io.stdout.write(
+            `${memory.id} (${memory.source}${memory.date ? ` ${memory.date}` : ""})${status}
+  ${memory.content.split("\n")[0]}
+`
+          );
+        }
+        return 0;
+      }
+      case "speakers": {
+        const [action, ...speakerArgs] = rest;
+        if (action === "list" || action === void 0) {
+          const registry = await service.listSpeakers();
+          io.stdout.write(`Self: ${registry.selfName}
+`);
+          const entries = Object.entries(registry.speakers);
+          if (entries.length === 0) {
+            io.stdout.write("No speaker overrides stored.\n");
+            return 0;
+          }
+          for (const [key, override] of entries) {
+            io.stdout.write(
+              `  ${key} -> ${override.name}${override.isSelf ? " (you)" : ""}
+`
+            );
+          }
+          return 0;
+        }
+        if (action === "self") {
+          const name = speakerArgs.join(" ").trim();
+          if (name.length === 0) {
+            throw new WearablesInputError("speakers self requires a name");
+          }
+          await service.setSelfName(name);
+          io.stdout.write(`Self name set to '${name}'.
+`);
+          return 0;
+        }
+        if (action === "set") {
+          const parsed = parseFlags(speakerArgs);
+          const [sourceId, speakerKey, ...nameParts] = parsed.positional;
+          const name = nameParts.join(" ").trim();
+          if (!sourceId || !speakerKey || name.length === 0) {
+            throw new WearablesInputError(
+              "speakers set requires: <source> <speakerKey> <name>"
+            );
+          }
+          await service.setSpeaker(sourceId, speakerKey, name, {
+            isSelf: parsed.flags.has("--self")
+          });
+          io.stdout.write(`Mapped ${sourceId}:${speakerKey} -> ${name}.
+`);
+          io.stdout.write(
+            "(re-run `wearables sync --force-memories` to rebuild stored transcripts with the new label)\n"
+          );
+          return 0;
+        }
+        if (action === "remove") {
+          const [sourceId, speakerKey] = speakerArgs;
+          if (!sourceId || !speakerKey) {
+            throw new WearablesInputError("speakers remove requires: <source> <speakerKey>");
+          }
+          await service.removeSpeaker(sourceId, speakerKey);
+          io.stdout.write(`Removed mapping for ${sourceId}:${speakerKey}.
+`);
+          return 0;
+        }
+        throw new WearablesInputError(
+          `unknown speakers action '${action}' \u2014 expected list, self, set, or remove`
+        );
+      }
+      case "corrections": {
+        const [action, ...correctionArgs] = rest;
+        if (action === "list" || action === void 0) {
+          const { fromConfig, fromState, stateFilePath } = await service.listCorrections();
+          if (fromConfig.length === 0 && fromState.length === 0) {
+            io.stdout.write("No correction rules configured.\n");
+            return 0;
+          }
+          if (fromConfig.length > 0) {
+            io.stdout.write("From config (wearables.corrections):\n");
+            fromConfig.forEach((rule, index) => {
+              io.stdout.write(`  [config ${index}] ${formatRule(rule)}
+`);
+            });
+          }
+          if (fromState.length > 0) {
+            io.stdout.write(`From state (${stateFilePath}):
+`);
+            fromState.forEach((rule, index) => {
+              io.stdout.write(`  [${index}] ${formatRule(rule)}
+`);
+            });
+          }
+          return 0;
+        }
+        if (action === "add") {
+          const parsed = parseFlags(correctionArgs);
+          const [match, replace] = parsed.positional;
+          if (match === void 0 || replace === void 0) {
+            throw new WearablesInputError(
+              "corrections add requires: <match> <replace> (quote multi-word values)"
+            );
+          }
+          const sourceFlag = flagString(parsed, "--source");
+          await service.addCorrection({
+            match,
+            replace,
+            ...parsed.flags.has("--regex") ? { regex: true } : {},
+            ...parsed.flags.has("--case-sensitive") ? { caseInsensitive: false } : {},
+            ...sourceFlag !== void 0 ? { sources: [sourceFlag] } : {}
+          });
+          io.stdout.write(`Added correction: ${JSON.stringify(match)} -> ${JSON.stringify(replace)}.
+`);
+          return 0;
+        }
+        if (action === "remove") {
+          const [indexRaw] = correctionArgs;
+          const index = Number(indexRaw);
+          if (indexRaw === void 0 || !Number.isInteger(index) || index < 0) {
+            throw new WearablesInputError("corrections remove requires a non-negative index");
+          }
+          const removed = await service.removeCorrection(index);
+          io.stdout.write(`Removed correction ${formatRule(removed)}.
+`);
+          return 0;
+        }
+        throw new WearablesInputError(
+          `unknown corrections action '${action}' \u2014 expected list, add, or remove`
+        );
+      }
+      default:
+        throw new WearablesInputError(
+          `unknown wearables command '${command}'
+
+${USAGE}`
+        );
+    }
+  } catch (err) {
+    if (err instanceof WearablesInputError) {
+      io.stderr.write(`wearables: ${err.message}
+`);
+      return 1;
+    }
+    throw err;
+  }
+}
+function formatRule(rule) {
+  const parts = [`${JSON.stringify(rule.match)} -> ${JSON.stringify(rule.replace)}`];
+  if (rule.regex === true) parts.push("(regex)");
+  if (rule.caseInsensitive === false) parts.push("(case-sensitive)");
+  if (rule.sources && rule.sources.length > 0) {
+    parts.push(`(sources: ${rule.sources.join(", ")})`);
+  }
+  return parts.join(" ");
+}
+
 // src/training-export/converter.ts
 import { constants } from "fs";
 import { lstat, open, readdir, realpath } from "fs/promises";
@@ -3465,6 +3883,110 @@ function registerCli(api, orchestrator, registerOptions = {}) {
           process.exitCode = 1;
         }
       });
+      {
+        const wearablesCmd = cmd.command("wearables").description(
+          "Wearable transcript sources (Limitless / Bee / Omi): sync, transcripts, search, speakers, corrections"
+        );
+        const forwardWearables = async (argv) => {
+          const code = await runWearablesCliCommand(
+            orchestrator.getWearablesService(),
+            argv,
+            { stdout: process.stdout, stderr: process.stderr }
+          );
+          if (code !== 0) process.exitCode = code;
+        };
+        const stringOpt = (options, key, flag) => typeof options[key] === "string" && options[key].length > 0 ? [flag, options[key]] : [];
+        wearablesCmd.command("status").description("Show configured sources, connector availability, and last sync").option("--json", "JSON output").action(async (...args) => {
+          const options = args[0] ?? {};
+          await forwardWearables(["status", ...options.json === true ? ["--json"] : []]);
+        });
+        wearablesCmd.command("check <source>").description("Verify credentials/connectivity for a source").action(async (...args) => {
+          await forwardWearables(["check", String(args[0] ?? "")]);
+        });
+        wearablesCmd.command("sync").description("Pull, clean, and store wearable transcripts (and trust-gated memories)").option("--source <id>", "Only this source (default: all enabled)").option("--date <date>", "Sync exactly this day (YYYY-MM-DD)").option("--days <n>", "Lookback window in days ending today (default 2)").option("--force-memories", "Re-run memory extraction for unchanged days").option("--json", "JSON output").action(async (...args) => {
+          const options = args[0] ?? {};
+          await forwardWearables([
+            "sync",
+            ...stringOpt(options, "source", "--source"),
+            ...stringOpt(options, "date", "--date"),
+            ...stringOpt(options, "days", "--days"),
+            ...options.forceMemories === true ? ["--force-memories"] : [],
+            ...options.json === true ? ["--json"] : []
+          ]);
+        });
+        wearablesCmd.command("transcript").description("Print the stored transcript(s) for a day").requiredOption("--date <date>", "Day to read (YYYY-MM-DD)").option("--source <id>", "Scope to one source").action(async (...args) => {
+          const options = args[0] ?? {};
+          await forwardWearables([
+            "transcript",
+            ...stringOpt(options, "date", "--date"),
+            ...stringOpt(options, "source", "--source")
+          ]);
+        });
+        wearablesCmd.command("search <query>").description("Search stored wearable transcripts").option("--source <id>", "Source id filter").option("--from <date>", "Inclusive start date (YYYY-MM-DD)").option("--to <date>", "Inclusive end date (YYYY-MM-DD)").option("--limit <n>", "Maximum results (default 10)").option("--json", "JSON output").action(async (...args) => {
+          const query = typeof args[0] === "string" ? args[0] : "";
+          const options = args[1] ?? {};
+          await forwardWearables([
+            "search",
+            query,
+            ...stringOpt(options, "source", "--source"),
+            ...stringOpt(options, "from", "--from"),
+            ...stringOpt(options, "to", "--to"),
+            ...stringOpt(options, "limit", "--limit"),
+            ...options.json === true ? ["--json"] : []
+          ]);
+        });
+        wearablesCmd.command("memories").description("List memories created from wearable transcripts").option("--source <id>", "Source id filter").option("--date <date>", "Transcript day filter (YYYY-MM-DD)").option("--limit <n>", "Maximum results (default 50)").option("--json", "JSON output").action(async (...args) => {
+          const options = args[0] ?? {};
+          await forwardWearables([
+            "memories",
+            ...stringOpt(options, "source", "--source"),
+            ...stringOpt(options, "date", "--date"),
+            ...stringOpt(options, "limit", "--limit"),
+            ...options.json === true ? ["--json"] : []
+          ]);
+        });
+        const speakersCmd = wearablesCmd.command("speakers").description("Manage the speaker registry");
+        speakersCmd.command("list").description("Show stored speaker mappings").action(async () => forwardWearables(["speakers", "list"]));
+        speakersCmd.command("self <name>").description("Set the wearer's display name").action(
+          async (...args) => forwardWearables(["speakers", "self", String(args[0] ?? "")])
+        );
+        speakersCmd.command("set <source> <speakerKey> <name>").description("Map a provider speaker label to a display name").option("--self", "Mark this speaker as the wearer").action(async (...args) => {
+          const options = args[3] ?? {};
+          await forwardWearables([
+            "speakers",
+            "set",
+            String(args[0] ?? ""),
+            String(args[1] ?? ""),
+            String(args[2] ?? ""),
+            ...options.self === true ? ["--self"] : []
+          ]);
+        });
+        speakersCmd.command("remove <source> <speakerKey>").description("Remove a speaker mapping").action(
+          async (...args) => forwardWearables([
+            "speakers",
+            "remove",
+            String(args[0] ?? ""),
+            String(args[1] ?? "")
+          ])
+        );
+        const correctionsCmd = wearablesCmd.command("corrections").description("Manage user-specific transcript correction rules");
+        correctionsCmd.command("list").description("Show correction rules from config and state").action(async () => forwardWearables(["corrections", "list"]));
+        correctionsCmd.command("add <match> <replace>").description("Add a correction rule (quote multi-word values)").option("--regex", "Treat <match> as a regular expression").option("--case-sensitive", "Match case-sensitively").option("--source <id>", "Restrict the rule to one source").action(async (...args) => {
+          const options = args[2] ?? {};
+          await forwardWearables([
+            "corrections",
+            "add",
+            String(args[0] ?? ""),
+            String(args[1] ?? ""),
+            ...options.regex === true ? ["--regex"] : [],
+            ...options.caseSensitive === true ? ["--case-sensitive"] : [],
+            ...stringOpt(options, "source", "--source")
+          ]);
+        });
+        correctionsCmd.command("remove <index>").description("Remove a state correction rule by index").action(
+          async (...args) => forwardWearables(["corrections", "remove", String(args[0] ?? "")])
+        );
+      }
       cmd.command("benchmark-status").description("Show benchmark/evaluation harness status, benchmark packs, and latest run summary").action(async () => {
         const status = await runBenchmarkStatusCliCommand({
           memoryDir: orchestrator.config.memoryDir,
@@ -6527,6 +7049,7 @@ function parseDuration(duration) {
 }
 
 export {
+  runWearablesCliCommand,
   convertMemoriesToRecords,
   registerTrainingExportAdapter,
   getTrainingExportAdapter,
@@ -6623,4 +7146,4 @@ export {
   resolveMemoryDirForNamespace,
   registerCli
 };
-//# sourceMappingURL=chunk-7TPH6UZL.js.map
+//# sourceMappingURL=chunk-2RHI3FGV.js.map