@cleocode/cleo 2026.10.2 → 2026.10.4

package/dist/cli/chunk-QPUY2HQZ.js

@@ -0,0 +1,74 @@
+(() => {
+  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-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-heavy-command-hook.ts
+import { getProjectRoot } from "@cleocode/core/paths.js";
+import {
+  deliverHeavyCommandHooks,
+  heavyHookPresent,
+  inspectHeavyCommandHooks,
+  isHeavyHookProblem,
+  probeHeavyHookCliFor
+} from "@cleocode/core/resources/heavy-command-hook-delivery.js";
+var doctorHeavyCommandHookCommand = defineCommand({
+  meta: {
+    name: "heavy-command-hook",
+    description: "Report, per agent harness in use, whether the heavy-command hook (routes agent-run tests and builds through cleo run) is installed, outdated, missing or blocked. --fix installs it."
+  },
+  args: {
+    fix: {
+      type: "boolean",
+      description: "Install or refresh the hook in this project (project-level configs only, never user-global)"
+    },
+    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 projectRoot = getProjectRoot();
+    const outcomes = args.fix === true ? (await deliverHeavyCommandHooks(projectRoot)).outcomes : [];
+    const { mode, inspections } = await inspectHeavyCommandHooks(projectRoot);
+    const cli = mode !== "off" && heavyHookPresent(inspections) ? await probeHeavyHookCliFor(projectRoot) : null;
+    const problems = inspections.filter(isHeavyHookProblem);
+    const cliProblem = cli !== null && cli.state !== "current";
+    cliOutput(
+      {
+        projectRoot,
+        mode,
+        inspections,
+        cli,
+        fixApplied: args.fix === true,
+        outcomes,
+        healthy: problems.length === 0 && !cliProblem
+      },
+      { command: "doctor", operation: "doctor.heavy-command-hook.run" }
+    );
+    if ((problems.length > 0 || cliProblem) && (process.exitCode ?? 0) === 0) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorHeavyCommandHookCommand
+};
+//# sourceMappingURL=chunk-QPUY2HQZ.js.map

package/dist/cli/chunk-REUTEW3O.js

@@ -0,0 +1,258 @@
+(() => {
+  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,
+  humanInfo,
+  humanLine,
+  humanWarn
+} from "./chunk-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/migrate-agents-v2.ts
+import { createHash } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  ensureGlobalAgentRegistryDb,
+  getGlobalAgentRegistryNativeDb,
+  getProjectRoot,
+  installAgentFromCant
+} from "@cleocode/core/internal";
+var AUDIT_LOG_RELATIVE = ".cleo/audit/migration-agents-v2.jsonl";
+var MIGRATE_CONFLICT_DIAGNOSTIC_ID = "MIGRATE-AGENTS-V2-CONFLICT";
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function extractAgentName(source) {
+  let body = source;
+  if (body.startsWith("---")) {
+    const end = body.indexOf("\n---", 3);
+    if (end >= 0) {
+      const afterFence = body.indexOf("\n", end + 4);
+      body = afterFence >= 0 ? body.slice(afterFence + 1) : "";
+    }
+  }
+  const headerMatch = body.match(/^\s*agent\s+([a-zA-Z][\w-]*)\s*:\s*$/m);
+  if (!headerMatch) return null;
+  return headerMatch[1] ?? null;
+}
+function appendAuditLog(projectRoot, entry) {
+  const auditPath = join(projectRoot, AUDIT_LOG_RELATIVE);
+  const auditDir = join(auditPath, "..");
+  if (!existsSync(auditDir)) {
+    mkdirSync(auditDir, { recursive: true });
+  }
+  appendFileSync(auditPath, JSON.stringify(entry) + "\n", "utf8");
+}
+function walkAgentsDir(db, scanDir, projectRoot, summary, verbose) {
+  if (!existsSync(scanDir)) return;
+  let files;
+  try {
+    files = readdirSync(scanDir).filter((f) => f.endsWith(".cant"));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    humanWarn(`Error: failed to enumerate ${scanDir}: ${msg}`);
+    summary.errors++;
+    return;
+  }
+  for (const filename of files) {
+    const cantPath = join(scanDir, filename);
+    const relPath = cantPath.replace(`${projectRoot}/`, "");
+    let sourceBytes;
+    let sourceText;
+    try {
+      sourceBytes = readFileSync(cantPath);
+      sourceText = sourceBytes.toString("utf8");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      humanWarn(`Error: failed to read ${cantPath}: ${msg}`);
+      summary.errors++;
+      appendAuditLog(projectRoot, {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "conflict",
+        agentName: filename.replace(/\.cant$/, ""),
+        filePath: relPath,
+        action: `read-error: ${msg}`
+      });
+      continue;
+    }
+    const newSha256 = sha256Hex(sourceBytes);
+    const agentName = extractAgentName(sourceText);
+    if (!agentName) {
+      humanWarn(`Warning: no agent declaration found in ${cantPath} \u2014 skipping.`);
+      summary.errors++;
+      continue;
+    }
+    const existingRow = db.prepare("SELECT cant_sha256 FROM agent_registry_agents WHERE agent_id = ?").get(agentName);
+    if (existingRow) {
+      const existingSha256 = existingRow.cant_sha256 ?? "";
+      if (existingSha256 === newSha256) {
+        if (verbose) {
+          humanLine(`  skipped (already registered): ${agentName}`);
+        }
+        appendAuditLog(projectRoot, {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "skipped",
+          agentName,
+          filePath: relPath,
+          action: "already-registered-same-content"
+        });
+        summary.skipped++;
+      } else {
+        humanWarn(
+          `  WARN: conflict for ${agentName}: disk sha256=${newSha256.slice(0, 12)}... db sha256=${existingSha256.slice(0, 12)}... \u2014 NOT overwriting`
+        );
+        appendAuditLog(projectRoot, {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "conflict",
+          agentName,
+          filePath: relPath,
+          existingSha256,
+          newSha256,
+          action: "skipped-conflict-do-not-overwrite",
+          doctor_diagnostic_id: MIGRATE_CONFLICT_DIAGNOSTIC_ID
+        });
+        summary.conflicts++;
+      }
+    } else {
+      try {
+        installAgentFromCant(db, {
+          cantSource: cantPath,
+          targetTier: "project",
+          installedFrom: "manual",
+          projectRoot
+        });
+        if (verbose) {
+          humanLine(`  registered: ${agentName} from ${relPath}`);
+        }
+        appendAuditLog(projectRoot, {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "registered",
+          agentName,
+          filePath: relPath,
+          action: "registered-via-installAgentFromCant"
+        });
+        summary.registered++;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        humanWarn(`  ERROR: failed to register ${agentName}: ${msg}`);
+        summary.errors++;
+        appendAuditLog(projectRoot, {
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "conflict",
+          agentName,
+          filePath: relPath,
+          action: `install-error: ${msg}`
+        });
+      }
+    }
+  }
+}
+async function runMigrateAgentsV2(projectRoot, verbose = true) {
+  const summary = { registered: 0, skipped: 0, conflicts: 0, errors: 0 };
+  await ensureGlobalAgentRegistryDb();
+  const db = getGlobalAgentRegistryNativeDb();
+  try {
+    const canonicalDir = join(projectRoot, ".cleo", "cant", "agents");
+    walkAgentsDir(db, canonicalDir, projectRoot, summary, verbose);
+    const legacyDir = join(projectRoot, ".cleo", "agents");
+    walkAgentsDir(db, legacyDir, projectRoot, summary, verbose);
+  } finally {
+    db.close();
+  }
+  return summary;
+}
+function readMigrationConflicts(projectRoot) {
+  const auditPath = join(projectRoot, AUDIT_LOG_RELATIVE);
+  if (!existsSync(auditPath)) return [];
+  let raw;
+  try {
+    raw = readFileSync(auditPath, "utf8");
+  } catch {
+    return [];
+  }
+  const conflicts = [];
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const entry = JSON.parse(trimmed);
+      if (entry.type === "conflict" && entry.doctor_diagnostic_id === MIGRATE_CONFLICT_DIAGNOSTIC_ID) {
+        conflicts.push(entry);
+      }
+    } catch {
+    }
+  }
+  return conflicts;
+}
+var migrateAgentsV2Command = defineCommand({
+  meta: {
+    name: "agents-v2",
+    description: "Register existing .cant agent files into signaldock.db (idempotent, conflict-safe)"
+  },
+  args: {
+    quiet: {
+      type: "boolean",
+      description: "Suppress per-agent INFO lines; only print the summary"
+    }
+  },
+  async run({ args }) {
+    const projectRoot = getProjectRoot();
+    const verbose = args.quiet !== true;
+    if (verbose) {
+      humanInfo("Scanning .cleo/cant/agents/ and .cleo/agents/ for unregistered agents...");
+    }
+    try {
+      const summary = await runMigrateAgentsV2(projectRoot, verbose);
+      const summaryLine = `Migration complete: ${summary.registered} registered, ${summary.skipped} skipped, ${summary.conflicts} conflicts.`;
+      humanLine(summaryLine);
+      if (summary.conflicts > 0) {
+        humanLine(`  Conflicts logged to ${AUDIT_LOG_RELATIVE}. Run 'cleo doctor' for details.`);
+      }
+      cliOutput(
+        {
+          registered: summary.registered,
+          skipped: summary.skipped,
+          conflicts: summary.conflicts,
+          errors: summary.errors,
+          auditLog: summary.conflicts > 0 || summary.errors > 0 ? AUDIT_LOG_RELATIVE : null
+        },
+        { command: "migrate agents-v2", operation: "migrate.agents-v2" }
+      );
+      if (summary.errors > 0) {
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      cliError(message, "E_MIGRATION_FAILED", void 0, {
+        operation: "migrate.agents-v2"
+      });
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  extractAgentName,
+  walkAgentsDir,
+  runMigrateAgentsV2,
+  readMigrationConflicts,
+  migrateAgentsV2Command
+};
+//# sourceMappingURL=chunk-REUTEW3O.js.map

package/dist/cli/chunk-S24YI723.js

@@ -0,0 +1,88 @@
+(() => {
+  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-3ZO3M37V.js";
+
+// packages/cleo/src/cli/commands/doctor-superseded-store.ts
+import { getProjectRoot } from "@cleocode/core";
+import { scanSupersededStores } from "@cleocode/core/doctor/superseded-store.js";
+import { reconcileSupersededStores } from "@cleocode/core/store/exodus/index.js";
+var doctorSupersededStoreCommand = defineCommand({
+  meta: {
+    name: "superseded-store",
+    description: "Report pre-dual-scope store files (.cleo/tasks.db, .cleo/brain.db) still on disk under their old LIVE names after the cleo.db migration, proving which store holds the data. Read-only \u2014 deletes nothing."
+  },
+  args: {
+    reconcile: {
+      type: "boolean",
+      description: "Copy rows the superseded files hold that are missing from cleo.db (additive, verified, reverted on mismatch; legacy files are never touched). Writes a receipt."
+    },
+    additive: {
+      type: "boolean",
+      description: "With --reconcile, for a project already running on cleo.db: copy only history rows whose keys are absent from live, never write the live task graph, and list every row left uncopied as a conflict in the receipt"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "With --reconcile: report per-table counts and what would be copied; write nothing"
+    },
+    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 }) {
+    if (args.reconcile === true) {
+      const receipt = await reconcileSupersededStores(getProjectRoot(), {
+        dryRun: args["dry-run"] === true,
+        additive: args.additive === true
+      });
+      if (receipt.outcome === "refused") {
+        cliError(receipt.reason, "E_RECONCILE_REFUSED", {
+          details: receipt,
+          fix: `Inspect ${receipt.receiptPath ?? "the receipt"}; the legacy files are unchanged, so it is safe to retry after fixing the cause.`
+        });
+        process.exitCode = 1;
+        return;
+      }
+      cliOutput(
+        { kind: "generic", ...receipt },
+        {
+          command: "doctor",
+          operation: "doctor.superseded-store.reconcile",
+          message: receipt.reason
+        }
+      );
+      return;
+    }
+    const result = scanSupersededStores(getProjectRoot());
+    cliOutput(result, {
+      command: "doctor",
+      operation: "doctor.superseded-store.run"
+    });
+    if (result.entries.length > 0 && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorSupersededStoreCommand
+};
+//# sourceMappingURL=chunk-S24YI723.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