@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/chunk-QY76BRUZ.js

@@ -0,0 +1,35 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+
+// packages/cleo/src/dispatch/domains/_routing.ts
+function routeByParam(params, paramName, routes, defaultRoute) {
+  const value = params?.[paramName] ?? defaultRoute;
+  if (!value) {
+    const available = Object.keys(routes).join(", ");
+    throw new Error(`Missing required param '${paramName}'. Available: ${available}`);
+  }
+  const handler = routes[value];
+  if (!handler) {
+    const available = Object.keys(routes).join(", ");
+    throw new Error(`Unknown ${paramName} '${value}'. Available: ${available}`);
+  }
+  return handler();
+}
+
+export {
+  routeByParam
+};
+//# sourceMappingURL=chunk-QY76BRUZ.js.map

package/dist/cli/chunk-R45KVF5Y.js

@@ -0,0 +1,117 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-tool-locks.ts
+import {
+  admissionCapacityBytes,
+  entryLiveness,
+  readForeignEntries,
+  readLedger,
+  reapLedger,
+  removeLedgerEntry
+} from "@cleocode/core/resources/admission-ledger.js";
+import { CANONICAL_TOOLS } from "@cleocode/core/tasks/tool-resolver.js";
+var doctorToolLocksCommand = defineCommand({
+  meta: {
+    name: "tool-locks",
+    description: "Inspect the machine-wide admission ledger: which heavy runs hold the memory budget or wait for it, by which pid, and whether that pid is still alive. Read-only; --reap drops entries whose holder is provably gone; --remove <id> drops one entry."
+  },
+  args: {
+    reap: {
+      type: "boolean",
+      description: "Drop entries whose holder process and tool process groups are gone. Fails safe: an unreadable probe or a fresh heartbeat counts as ALIVE and is never reaped."
+    },
+    remove: {
+      type: "string",
+      description: "Drop the entry with this id whatever its liveness (an entry whose holder cannot be identified is otherwise kept until its heartbeat is 10 minutes old)."
+    },
+    tool: {
+      type: "string",
+      description: "Restrict to one canonical tool (test, build, lint, typecheck, \u2026)."
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const requested = typeof args.tool === "string" && args.tool.length > 0 ? args.tool : null;
+    if (requested && !CANONICAL_TOOLS.some((t) => t === requested)) {
+      cliOutput(
+        { error: `Unknown canonical tool "${requested}"`, known: [...CANONICAL_TOOLS] },
+        { command: "doctor", operation: "doctor.tool-locks.run" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const reaped = args.reap === true ? await reapLedger() : [];
+    const removeId = typeof args.remove === "string" && args.remove.length > 0 ? args.remove : null;
+    const removed = removeId === null ? null : await removeLedgerEntry(removeId);
+    const now = Date.now();
+    const entries = readLedger().filter((e) => requested === null || e.label === `tool:${requested}`).map((e) => {
+      const alive = entryLiveness(e, now) === "alive";
+      return {
+        id: e.id,
+        label: e.label,
+        state: e.state,
+        pid: e.pid,
+        host: e.host,
+        command: e.command,
+        cwd: e.cwd,
+        footprintBytes: e.footprintBytes,
+        // T13132: what the run covers (`full` = a whole-suite run) and its task.
+        scope: e.scope ?? null,
+        task: e.task ?? null,
+        enqueuedAt: new Date(e.enqueuedAtMs).toISOString(),
+        admittedAt: e.admittedAtMs === null ? null : new Date(e.admittedAtMs).toISOString(),
+        toolGroups: e.toolGroups,
+        alive,
+        orphaned: !alive
+      };
+    });
+    const orphaned = entries.filter((e) => e.orphaned);
+    const held = entries.filter((e) => e.state === "admitted");
+    const foreignEntries = requested === null ? readForeignEntries() : [];
+    cliOutput(
+      {
+        capacityBytes: admissionCapacityBytes(),
+        usedBytes: held.reduce((n, e) => n + e.footprintBytes, 0),
+        entries,
+        heldCount: held.length,
+        waitingCount: entries.length - held.length,
+        orphanedCount: orphaned.length,
+        foreignEntries,
+        reaped,
+        reapApplied: args.reap === true,
+        ...removeId === null ? {} : { removeId, removed }
+      },
+      { command: "doctor", operation: "doctor.tool-locks.run" }
+    );
+    if ((orphaned.length > 0 || removed === false) && (process.exitCode ?? 0) === 0) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorToolLocksCommand
+};
+//# sourceMappingURL=chunk-R45KVF5Y.js.map

package/dist/cli/chunk-RRKP7HLU.js

@@ -0,0 +1,66 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  OPERATIONS
+} from "./chunk-4VASFLUW.js";
+
+// packages/cleo/src/cli/lib/registry-args.ts
+import { paramsToCittyArgs } from "@cleocode/contracts/operations/params.js";
+var IDEMPOTENCY_KEY_PARAM = {
+  name: "idempotencyKey",
+  type: "string",
+  required: false,
+  description: "Optional retry token for safely replaying idempotent mutating commands.",
+  cli: { flag: "idempotency-key" }
+};
+function getOperationParams(gateway, domain, operation) {
+  const def = OPERATIONS.find(
+    (o) => o.gateway === gateway && o.domain === domain && o.operation === operation
+  );
+  const params = def?.params ?? [];
+  if (!def || def.gateway !== "mutate" || !def.idempotent) return params;
+  if (params.some((param) => param.name === IDEMPOTENCY_KEY_PARAM.name)) return params;
+  return [...params, IDEMPOTENCY_KEY_PARAM];
+}
+function registryParamsToDispatchPayload(params, args) {
+  const payload = {};
+  for (const param of params) {
+    const flag = param.cli?.flag ?? param.name;
+    const raw = args[flag];
+    if (raw === void 0 || raw === null) continue;
+    if (param.type === "number") {
+      payload[param.name] = typeof raw === "number" ? raw : Number(String(raw));
+      continue;
+    }
+    if (param.type === "boolean") {
+      payload[param.name] = typeof raw === "boolean" ? raw : String(raw) !== "false";
+      continue;
+    }
+    if (param.type === "array") {
+      payload[param.name] = Array.isArray(raw) ? raw : String(raw).split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+      continue;
+    }
+    payload[param.name] = raw;
+  }
+  return payload;
+}
+
+export {
+  getOperationParams,
+  registryParamsToDispatchPayload,
+  paramsToCittyArgs
+};
+//# sourceMappingURL=chunk-RRKP7HLU.js.map

package/dist/cli/chunk-SXXOC6KZ.js

@@ -0,0 +1,209 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+
+// packages/cleo/src/dispatch/domains/check/canon-docs.ts
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join, sep } from "node:path";
+import { resolveCanonDocPathPolicy } from "@cleocode/core/session/canon-lint";
+import { parse as parseYaml } from "yaml";
+var CanonDocsDiffError = class extends Error {
+  /** Stable diagnostic code for an unavailable Git candidate inventory. */
+  code = "E_CANON_DIFF_FAILED";
+  /**
+   * Preserve the requested scope and underlying command failure.
+   *
+   * @param projectRoot - Repository that could not be assessed.
+   * @param baseRef - Requested Git comparison base.
+   * @param cause - Original Git process failure.
+   */
+  constructor(projectRoot, baseRef, cause) {
+    super(
+      `E_CANON_DIFF_FAILED: Cannot assess docs in ${projectRoot} against ${baseRef}: ${cause.message}`,
+      { cause }
+    );
+    this.name = "CanonDocsDiffError";
+  }
+};
+function listAddedMarkdownFiles(projectRoot, baseRef) {
+  try {
+    const out = execFileSync(
+      "git",
+      [
+        "diff",
+        "--diff-filter=A",
+        "--name-only",
+        "-z",
+        "--end-of-options",
+        `${baseRef}...HEAD`,
+        "--"
+      ],
+      {
+        cwd: projectRoot,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 3e4
+      }
+    );
+    return out.split("\0").filter((line) => line.length > 0 && line.endsWith(".md"));
+  } catch (error) {
+    throw new CanonDocsDiffError(
+      projectRoot,
+      baseRef,
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+}
+function validateCanonRegistry(raw, source) {
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`${source}: top-level value must be an object`);
+  }
+  const obj = raw;
+  const version = obj["version"];
+  if (typeof version !== "number" || version !== 1) {
+    throw new Error(`${source}: 'version' must be the integer 1 (got ${String(version)})`);
+  }
+  const kindsRaw = obj["kinds"];
+  if (kindsRaw === null || typeof kindsRaw !== "object" || Array.isArray(kindsRaw)) {
+    throw new Error(`${source}: 'kinds' must be an object`);
+  }
+  const kinds = {};
+  for (const [kindId, entryRaw] of Object.entries(kindsRaw)) {
+    kinds[kindId] = validateKindEntry(kindId, entryRaw, source);
+  }
+  const similarity = validateSimilarity(obj["similarity"], source);
+  return similarity !== void 0 ? { version, kinds, similarity } : { version, kinds };
+}
+function validateSimilarity(raw, source) {
+  if (raw === void 0 || raw === null) {
+    return void 0;
+  }
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`${source}: 'similarity' must be an object`);
+  }
+  const obj = raw;
+  const warnThresholdRaw = obj["warnThreshold"];
+  let warnThreshold = 0.85;
+  if (warnThresholdRaw !== void 0) {
+    if (typeof warnThresholdRaw !== "number" || Number.isNaN(warnThresholdRaw) || warnThresholdRaw < 0 || warnThresholdRaw > 1) {
+      throw new Error(
+        `${source}: 'similarity.warnThreshold' must be a number in [0, 1] (got ${String(warnThresholdRaw)})`
+      );
+    }
+    warnThreshold = warnThresholdRaw;
+  }
+  const modeRaw = obj["mode"];
+  let mode = "warn";
+  if (modeRaw !== void 0) {
+    if (modeRaw !== "warn" && modeRaw !== "block") {
+      throw new Error(
+        `${source}: 'similarity.mode' must be 'warn' or 'block' (got ${String(modeRaw)})`
+      );
+    }
+    mode = modeRaw;
+  }
+  return { warnThreshold, mode };
+}
+function validateKindEntry(kindId, raw, source) {
+  const where = `${source} kinds.${kindId}`;
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`${where}: must be an object`);
+  }
+  const obj = raw;
+  const canonicalHome = obj["canonicalHome"];
+  if (canonicalHome !== "ssot" && canonicalHome !== "ssot-first") {
+    throw new Error(
+      `${where}: 'canonicalHome' must be 'ssot' or 'ssot-first' (got ${String(canonicalHome)})`
+    );
+  }
+  const publishMirror = obj["publishMirror"];
+  if (typeof publishMirror !== "string" || publishMirror.length === 0) {
+    throw new Error(`${where}: 'publishMirror' must be a non-empty string`);
+  }
+  const rawMdAllowed = obj["rawMdAllowed"];
+  if (typeof rawMdAllowed !== "boolean") {
+    throw new Error(`${where}: 'rawMdAllowed' must be a boolean`);
+  }
+  const rawMdPathsRaw = obj["rawMdPaths"];
+  let rawMdPaths;
+  if (rawMdPathsRaw !== void 0) {
+    if (!Array.isArray(rawMdPathsRaw)) {
+      throw new Error(`${where}: 'rawMdPaths' must be an array`);
+    }
+    for (const p of rawMdPathsRaw) {
+      if (typeof p !== "string" || p.length === 0) {
+        throw new Error(`${where}: 'rawMdPaths' entries must be non-empty strings`);
+      }
+    }
+    rawMdPaths = rawMdPathsRaw;
+  }
+  return {
+    canonicalHome,
+    publishMirror,
+    rawMdAllowed,
+    ...rawMdPaths !== void 0 ? { rawMdPaths } : {}
+  };
+}
+function loadCanonRegistry(projectRoot) {
+  const path = join(projectRoot, ".cleo", "canon.yml");
+  if (!existsSync(path)) {
+    return void 0;
+  }
+  const text = readFileSync(path, "utf8");
+  const parsed = parseYaml(text);
+  return validateCanonRegistry(parsed, path);
+}
+function runCanonDocsCheck(params) {
+  const { projectRoot, baseRef = "origin/main", candidateFiles } = params;
+  const registry = loadCanonRegistry(projectRoot);
+  if (!registry) {
+    return {
+      passed: true,
+      baseRef,
+      scanned: 0,
+      violations: [],
+      mode: "no-canon"
+    };
+  }
+  const candidates = candidateFiles ?? listAddedMarkdownFiles(projectRoot, baseRef);
+  const violations = [];
+  for (const file of candidates) {
+    const normalised = file.split(sep).join("/");
+    const policy = resolveCanonDocPathPolicy(registry, normalised);
+    if (policy && !policy.rawMdAllowed) {
+      violations.push({
+        file: normalised,
+        kind: policy.docKind,
+        matchedPath: policy.matchedPath,
+        fix: `cleo docs add <taskId> ${normalised} --type ${policy.docKind}`
+      });
+    }
+  }
+  return {
+    passed: violations.length === 0,
+    baseRef,
+    scanned: candidates.length,
+    violations,
+    mode: "enforced"
+  };
+}
+
+export {
+  CanonDocsDiffError,
+  loadCanonRegistry,
+  runCanonDocsCheck
+};
+//# sourceMappingURL=chunk-SXXOC6KZ.js.map

package/dist/cli/chunk-T6GZJYL3.js

@@ -0,0 +1,108 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliError,
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-skill-fixtures.ts
+import {
+  auditSkillFixtures,
+  repairSkillFixtures,
+  restoreSkillFixtures
+} from "@cleocode/core/system/skill-fixtures.js";
+var doctorSkillFixturesCommand = defineCommand({
+  meta: {
+    name: "skill-fixtures",
+    description: "Find caamp test fixtures left in the real skills root (UUID-named and known fixture dirs whose content matches the tests). Read-only; --repair quarantines them with a receipt (--dry-run to preview)."
+  },
+  args: {
+    repair: {
+      type: "boolean",
+      description: "Move every fixture into <cleoHome>/audit/skill-fixture-quarantine/<receiptId>/ and append a receipt. Unclassified entries are reported, never moved."
+    },
+    restore: {
+      type: "string",
+      description: "Move the entries quarantined by this repair receipt id back to their original paths (never over an occupied path). Appends a restored receipt."
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "With --repair or --restore: report the receipt without touching disk"
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const dryRun = args["dry-run"] === true;
+    if (typeof args.restore === "string" && args.restore.length > 0) {
+      try {
+        const receipt = restoreSkillFixtures(args.restore, { dryRun });
+        cliOutput(
+          { restore: receipt, audit: auditSkillFixtures() },
+          { command: "doctor", operation: "doctor.skill-fixtures.run" }
+        );
+        if (receipt.skipped.length > 0 && !dryRun) process.exitCode = 1;
+      } catch (err) {
+        cliError(
+          err instanceof Error ? err.message : String(err),
+          1,
+          {
+            name: "E_SKILL_FIXTURE_RESTORE_FAILED",
+            fix: "Pass a receipt id from <cleoHome>/audit/skill-fixtures.jsonl whose repair finished and has not been restored. Entries restored before a failure are listed in that file; the rest stay in quarantine."
+          },
+          { operation: "doctor.skill-fixtures.run" }
+        );
+        process.exitCode = 1;
+      }
+      return;
+    }
+    let result = null;
+    if (args.repair === true) {
+      try {
+        result = repairSkillFixtures({ dryRun });
+      } catch (err) {
+        cliError(
+          err instanceof Error ? err.message : String(err),
+          1,
+          {
+            name: "E_SKILL_FIXTURE_REPAIR_FAILED",
+            fix: "Entries moved before the failure are in the quarantine dir named by the intent receipt in <cleoHome>/audit/skill-fixtures.jsonl; the rest are untouched. Re-run `cleo doctor skill-fixtures --repair`."
+          },
+          { operation: "doctor.skill-fixtures.run" }
+        );
+        process.exitCode = 1;
+        return;
+      }
+    }
+    const audit = result?.audit ?? auditSkillFixtures();
+    cliOutput(
+      { ...audit, receipt: result?.receipt ?? null },
+      { command: "doctor", operation: "doctor.skill-fixtures.run" }
+    );
+    if (!audit.healthy && !dryRun && (process.exitCode ?? 0) === 0) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorSkillFixturesCommand
+};
+//# sourceMappingURL=chunk-T6GZJYL3.js.map

package/dist/cli/chunk-TLQ37HRE.js

@@ -0,0 +1,67 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-acceptance-drift.ts
+import {
+  scanAcceptanceDrift,
+  writeAcceptanceDriftBaseline
+} from "@cleocode/core/doctor/acceptance-drift.js";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+var doctorAcceptanceDriftCommand = defineCommand({
+  meta: {
+    name: "acceptance-drift",
+    description: "Report tasks whose acceptance criteria disagree between the JSON column and the typed rows table, separating legacy-convention rows from current-era regressions. Read-only \u2014 repairs nothing."
+  },
+  args: {
+    "update-baseline": {
+      type: "boolean",
+      description: "Accept every current drifting task, so only NEW drift fails afterwards"
+    },
+    all: {
+      type: "boolean",
+      description: "Exit non-zero for every drifting task, baselined or not"
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run(ctx) {
+    const result = scanAcceptanceDrift(getProjectRoot());
+    cliOutput(result, {
+      command: "doctor",
+      operation: "doctor.acceptance-drift.run"
+    });
+    if (ctx.args["update-baseline"]) {
+      writeAcceptanceDriftBaseline(result);
+      return;
+    }
+    const failing = ctx.args.all ? result.entries.length : result.unbaselined.length;
+    if (failing > 0 && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorAcceptanceDriftCommand
+};
+//# sourceMappingURL=chunk-TLQ37HRE.js.map

package/dist/cli/chunk-TPTNEJZJ.js

@@ -0,0 +1,52 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import {
+  cliOutput
+} from "./chunk-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-sync-journal.ts
+import { runSyncRepair } from "@cleocode/core/doctor/sync-repair.js";
+import { getProjectRoot } from "@cleocode/core/paths.js";
+var doctorSyncJournalCommand = defineCommand({
+  meta: {
+    name: "sync-journal",
+    description: "Plan the repair diff of the project store's suspect tables (rows written uncaptured). --repair emits the repair ops, seals them, verifies each table and clears its suspect mark."
+  },
+  args: {
+    repair: {
+      type: "boolean",
+      description: "Seal pending captures, emit I/U/D repair ops for every row of each suspect table in a repair frame, seal them, verify (clean rescan, ledger equals count) and clear the suspect mark. Opens the store like any cleo command, so pending migrations are applied"
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    human: { type: "boolean", description: "Force human-readable output" },
+    quiet: { type: "boolean", description: "Suppress non-essential output" }
+  },
+  async run({ args }) {
+    const result = await runSyncRepair(getProjectRoot(), { repair: args.repair === true });
+    cliOutput(result, { command: "doctor", operation: "doctor.sync-journal.run" });
+    if (args.repair === true && (result.report.refused !== null || result.suspect.length > 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorSyncJournalCommand
+};
+//# sourceMappingURL=chunk-TPTNEJZJ.js.map