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

package/dist/cli/chunk-HXRXT3XU.js

@@ -0,0 +1,78 @@
+(() => {
+  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-memory-guard.ts
+import { spawnSync } from "node:child_process";
+import {
+  auditMemoryGuard,
+  buildMemoryGuardFixCommands
+} from "@cleocode/core/resources/memory-guard.js";
+var doctorMemoryGuardCommand = defineCommand({
+  meta: {
+    name: "memory-guard",
+    description: "Audit the machine-wide memory guard that bounds test runs an agent starts OUTSIDE cleo (pnpm test / npx vitest). Read-only; --fix applies the recommended cgroup limits."
+  },
+  args: {
+    fix: {
+      type: "boolean",
+      description: "Apply the recommended MemoryHigh/MemoryMax to app.slice. Persists a systemd user drop-in and affects the whole desktop session."
+    },
+    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 audit = auditMemoryGuard();
+    const commands = buildMemoryGuardFixCommands(audit);
+    const applied = [];
+    if (args.fix === true) {
+      for (const argv of commands) {
+        const [cmd, ...rest] = argv;
+        const r = spawnSync(cmd, rest, { encoding: "utf8" });
+        applied.push({
+          command: argv.join(" "),
+          exitCode: r.status,
+          stderr: (r.stderr ?? "").trim()
+        });
+      }
+    }
+    const finalAudit = args.fix === true ? auditMemoryGuard() : audit;
+    cliOutput(
+      {
+        ...finalAudit,
+        fixApplied: args.fix === true,
+        recommendedCommands: commands.map((c) => c.join(" ")),
+        applied
+      },
+      { command: "doctor", operation: "doctor.memory-guard.run" }
+    );
+    const failed = applied.some((a) => a.exitCode !== 0);
+    if ((!finalAudit.guarded || failed) && (process.exitCode ?? 0) === 0) {
+      process.exitCode = 1;
+    }
+  }
+});
+
+export {
+  doctorMemoryGuardCommand
+};
+//# sourceMappingURL=chunk-HXRXT3XU.js.map

package/dist/cli/chunk-IIOGUY3B.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-4RGSNUUP.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 { getProjectRoot } from "@cleocode/core/project-scope";
+import { installAgentFromCant } from "@cleocode/core/store/agent-install";
+import {
+  ensureGlobalAgentRegistryDb,
+  getGlobalAgentRegistryNativeDb
+} from "@cleocode/core/store/agent-registry-store";
+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-IIOGUY3B.js.map

package/dist/cli/chunk-ILWWL462.js

@@ -0,0 +1,60 @@
+(() => {
+  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-triggers.ts
+import {
+  repairSyncTriggers,
+  syncTriggersDoctorCheck
+} from "@cleocode/core/doctor/sync-triggers.js";
+import { getProjectRoot } from "@cleocode/core/paths.js";
+var doctorSyncTriggersCommand = defineCommand({
+  meta: {
+    name: "sync-triggers",
+    description: "Check the project store's triggers: the suspension table, owned guard triggers, capture triggers and triggers that reference a missing table or column. --repair fixes what CLEO owns."
+  },
+  args: {
+    repair: {
+      type: "boolean",
+      description: "Recreate cleo_trigger_suspend, re-run the owned DDL of every differing trigger and make the capture triggers match sync.capture; reports the row before and after. 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 projectRoot = getProjectRoot();
+    if (args.repair === true) {
+      const result = await repairSyncTriggers(projectRoot);
+      cliOutput(result, { command: "doctor", operation: "doctor.sync-triggers.run" });
+      if (result.after.status === "error") process.exitCode = 1;
+      return;
+    }
+    const check = syncTriggersDoctorCheck(projectRoot);
+    cliOutput(check, { command: "doctor", operation: "doctor.sync-triggers.run" });
+    if (check.status === "error") process.exitCode = 1;
+  }
+});
+
+export {
+  doctorSyncTriggersCommand
+};
+//# sourceMappingURL=chunk-ILWWL462.js.map

package/dist/cli/chunk-J5USPJKZ.js

@@ -0,0 +1,48 @@
+(() => {
+  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-dep-cycles.ts
+import { scanDependencyCycles } from "@cleocode/core/doctor/dependency-cycles.js";
+import { getProjectRoot } from "@cleocode/core/paths.js";
+var doctorDepCyclesCommand = defineCommand({
+  meta: {
+    name: "dep-cycles",
+    description: "Report task dependency cycles already stored (edges written before the T12886 cycle guard) with a repair plan: the edges whose removal breaks every cycle, each with its `cleo update <id> --remove-depends <dep>` command. Read-only; never removes an edge."
+  },
+  args: {
+    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() {
+    const report = await scanDependencyCycles(getProjectRoot());
+    cliOutput(report, { command: "doctor", operation: "doctor.dep-cycles.run" });
+    if (report.cycleCount > 0 && (process.exitCode === void 0 || process.exitCode === 0)) {
+      process.exitCode = 2;
+    }
+  }
+});
+
+export {
+  doctorDepCyclesCommand
+};
+//# sourceMappingURL=chunk-J5USPJKZ.js.map

package/dist/cli/chunk-KEQS36GD.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-4RGSNUUP.js";
+
+// packages/cleo/src/cli/commands/doctor-superseded-store.ts
+import { scanSupersededStores } from "@cleocode/core/doctor/superseded-store.js";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+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). A legacy task whose id a newer task took is recovered under a new id, with its references re-pointed (task ids inside free text are not rewritten). 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-KEQS36GD.js.map