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

package/dist/cli/selfimprove-4SMOCLUV.js

@@ -0,0 +1,89 @@
+(() => {
+  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 "./chunk-C3B7C43W.js";
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
+import "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/selfimprove.ts
+var runCommand = defineCommand({
+  meta: {
+    name: "run",
+    description: "Run ONE self-improvement loop iteration: boot a sandbox, replay a canned scenario, diff vs golden; on regression emit ONE leased DHQ row + ONE DRAFT PR. DEFAULT OFF \u2014 pass --execute to act (else DRY-RUN: replay + diff + report only)."
+  },
+  args: {
+    scenario: {
+      type: "string",
+      description: "Canned dogfood scenario name to replay (e.g. dhq-replay-find)",
+      required: true
+    },
+    execute: {
+      type: "boolean",
+      description: "Permit mutation (leased DHQ UPSERT) + egress (draft PR). DEFAULT off \u21D2 DRY-RUN (replay + diff + report only \u2014 no DB write, no PR)."
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Force DRY-RUN explicitly (no DB write, no PR). The loop is default-OFF."
+    },
+    backend: {
+      type: "string",
+      description: "Confinement backend preference: 'gondolin' (micro-VM; degrades to the in-process guarded env when VM infra is absent) | 'in-process'. Default: gondolin."
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "selfimprove",
+      "run",
+      {
+        scenario: args.scenario,
+        execute: args.execute === true,
+        dryRun: args["dry-run"] === true,
+        backend: args.backend
+      },
+      { command: "selfimprove" }
+    );
+  }
+});
+var selfimproveCommand = defineCommand({
+  meta: {
+    name: "selfimprove",
+    description: "Self-improvement loop \u2014 replay a canned dogfood scenario, diff vs golden, and surface regressions as leased DHQ rows + DRAFT PRs. Default OFF (requires --execute to act)."
+  },
+  subCommands: {
+    run: runCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  selfimproveCommand
+};
+//# sourceMappingURL=selfimprove-4SMOCLUV.js.map

package/dist/cli/selfimprove-EB4RQLP4.js

@@ -0,0 +1,139 @@
+(() => {
+  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 {
+  errorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/selfimprove.ts
+import { randomUUID } from "node:crypto";
+import {
+  buildProbePayload,
+  getLogger,
+  getProjectRoot,
+  runSelfImprove
+} from "@cleocode/core/internal";
+var log = getLogger("domain:selfimprove");
+var SelfimproveHandler = class {
+  /**
+   * Handle self-improvement query operations.
+   *
+   * Supported operations:
+   * - `probe` — return the probe payload from {@link buildProbePayload} (T11988).
+   *   Used by the `seeded-code-regression` scenario to expose a patchable code
+   *   bug (the probe version off-by-one) for end-to-end fix-gen proof.
+   */
+  async query(operation, _params) {
+    const startTime = Date.now();
+    switch (operation) {
+      case "probe":
+        return wrapResult(
+          { success: true, data: buildProbePayload() },
+          "query",
+          "selfimprove",
+          operation,
+          startTime
+        );
+      default:
+        return unsupportedOp("query", "selfimprove", operation, startTime);
+    }
+  }
+  /**
+   * Handle self-improvement mutations.
+   *
+   * Supported operations:
+   * - `run` — delegate to CORE `runSelfImprove`, supplying the in-process
+   *   `ReplayDispatch` port. DEFAULT OFF: mutation/egress require `execute`.
+   *
+   * Param validation runs FIRST: a missing `scenario` returns `E_INVALID_INPUT`
+   * before any engine call or dispatcher binding — so the registry-parity test
+   * (which invokes `run` with empty params) exercises the case without booting
+   * a sandbox.
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    switch (operation) {
+      case "run": {
+        const scenario = typeof params?.scenario === "string" ? params.scenario : void 0;
+        if (!scenario) {
+          return errorResult(
+            "mutate",
+            "selfimprove",
+            operation,
+            "E_INVALID_INPUT",
+            "scenario is required",
+            startTime
+          );
+        }
+        const execute = params?.execute === true;
+        const dryRun = params?.dryRun === true;
+        const backend = normalizeBackend(params?.backend);
+        const { getCliDispatcher } = await import("./cli-A23Q335V.js");
+        const dispatcher = getCliDispatcher();
+        const dispatch = (op) => dispatcher.dispatch({
+          gateway: op.gateway,
+          domain: op.domain,
+          operation: op.operation,
+          ...op.params !== void 0 ? { params: op.params } : {},
+          source: "rpc",
+          requestId: randomUUID()
+        });
+        try {
+          const opts = {
+            scenario,
+            dispatch,
+            // `--dry-run` forces DRY-RUN even if `--execute` was also passed;
+            // the loop is default-OFF so omitting `--execute` already means dry.
+            execute: execute && !dryRun,
+            cwd: getProjectRoot(),
+            ...backend !== void 0 ? { backend } : {}
+          };
+          const result = await runSelfImprove(opts);
+          return wrapResult(
+            { success: true, data: result },
+            "mutate",
+            "selfimprove",
+            operation,
+            startTime
+          );
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          log.error({ scenario, err: message }, "selfimprove.run failed");
+          return errorResult("mutate", "selfimprove", operation, "E_INTERNAL", message, startTime);
+        }
+      }
+      default:
+        return unsupportedOp("mutate", "selfimprove", operation, startTime);
+    }
+  }
+  /** Return declared operations for introspection and registry validation. */
+  getSupportedOperations() {
+    return {
+      query: ["probe"],
+      mutate: ["run"]
+    };
+  }
+};
+function normalizeBackend(value) {
+  if (value === "gondolin") return "gondolin";
+  if (value === "in-process" || value === "guarded") return "in-process";
+  return void 0;
+}
+export {
+  SelfimproveHandler
+};
+//# sourceMappingURL=selfimprove-EB4RQLP4.js.map

package/dist/cli/sentient-QPETVE53.js

@@ -0,0 +1,254 @@
+(() => {
+  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 {
+  defineTypedHandler,
+  lafsError,
+  lafsSuccess,
+  typedDispatch
+} from "./chunk-QWNKLLLG.js";
+import {
+  envelopeToEngineResult,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/sentient.ts
+import { getProjectRoot } from "@cleocode/core";
+import {
+  getSentientDaemonStatus,
+  sentientAllowlistAdd,
+  sentientAllowlistList,
+  sentientAllowlistRemove,
+  sentientProposeAccept,
+  sentientProposeDiff,
+  sentientProposeDisable,
+  sentientProposeEnable,
+  sentientProposeList,
+  sentientProposeReject,
+  sentientProposeRun
+} from "@cleocode/core/sentient";
+var coreOps = {
+  status: (_params) => getSentientDaemonStatus(getProjectRoot()),
+  "propose.list": (params) => sentientProposeList(getProjectRoot(), params),
+  "propose.diff": (params) => sentientProposeDiff(getProjectRoot(), params),
+  "allowlist.list": (params) => sentientAllowlistList(getProjectRoot(), params),
+  "propose.accept": (params) => sentientProposeAccept(getProjectRoot(), params),
+  "propose.reject": (params) => sentientProposeReject(getProjectRoot(), params),
+  "propose.run": (params) => sentientProposeRun(getProjectRoot(), params),
+  "propose.enable": (params) => sentientProposeEnable(getProjectRoot(), params),
+  "propose.disable": (params) => sentientProposeDisable(getProjectRoot(), params),
+  "allowlist.add": (params) => sentientAllowlistAdd(getProjectRoot(), params),
+  "allowlist.remove": (params) => sentientAllowlistRemove(getProjectRoot(), params)
+};
+var _sentientTypedHandler = defineTypedHandler("sentient", {
+  // -------------------------------------------------------------------------
+  // Query ops
+  // -------------------------------------------------------------------------
+  status: async (_params) => {
+    try {
+      const data = await coreOps.status(_params);
+      return lafsSuccess(data, "status");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError("E_SENTIENT_STATUS", message, "status");
+    }
+  },
+  "propose.list": async (params) => {
+    try {
+      const data = await coreOps["propose.list"](params);
+      return lafsSuccess(data, "propose.list");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError("E_INTERNAL", message, "propose.list");
+    }
+  },
+  "propose.diff": async (params) => {
+    try {
+      const data = await coreOps["propose.diff"](params);
+      return lafsSuccess(data, "propose.diff");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError("E_INTERNAL", message, "propose.diff");
+    }
+  },
+  "allowlist.list": async (_params) => {
+    try {
+      const data = await coreOps["allowlist.list"](_params);
+      return lafsSuccess(data, "allowlist.list");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError("E_INTERNAL", message, "allowlist.list");
+    }
+  },
+  // -------------------------------------------------------------------------
+  // Mutate ops
+  // -------------------------------------------------------------------------
+  "propose.accept": async (params) => {
+    try {
+      const data = await coreOps["propose.accept"](params);
+      return lafsSuccess(data, "propose.accept");
+    } catch (err) {
+      const code = err.code ?? "E_INTERNAL";
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError(code, message, "propose.accept");
+    }
+  },
+  "propose.reject": async (params) => {
+    try {
+      const data = await coreOps["propose.reject"](params);
+      return lafsSuccess(data, "propose.reject");
+    } catch (err) {
+      const code = err.code ?? "E_INTERNAL";
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError(code, message, "propose.reject");
+    }
+  },
+  "propose.run": async (_params) => {
+    try {
+      const data = await coreOps["propose.run"](_params);
+      return lafsSuccess(data, "propose.run");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError("E_INTERNAL", message, "propose.run");
+    }
+  },
+  "propose.enable": async (_params) => {
+    try {
+      const data = await coreOps["propose.enable"](_params);
+      return lafsSuccess(data, "propose.enable");
+    } catch (err) {
+      const code = err.code ?? "E_INTERNAL";
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError(code, message, "propose.enable");
+    }
+  },
+  "propose.disable": async (_params) => {
+    try {
+      const data = await coreOps["propose.disable"](_params);
+      return lafsSuccess(data, "propose.disable");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError("E_INTERNAL", message, "propose.disable");
+    }
+  },
+  "allowlist.add": async (params) => {
+    try {
+      const data = await coreOps["allowlist.add"](params);
+      return lafsSuccess(data, "allowlist.add");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError("E_ALLOWLIST_ADD", message, "allowlist.add");
+    }
+  },
+  "allowlist.remove": async (params) => {
+    try {
+      const data = await coreOps["allowlist.remove"](params);
+      return lafsSuccess(data, "allowlist.remove");
+    } catch (err) {
+      const code = err.code === "E_ALLOWLIST_KEY_NOT_FOUND" ? "E_ALLOWLIST_KEY_NOT_FOUND" : "E_ALLOWLIST_REMOVE";
+      const message = err instanceof Error ? err.message : String(err);
+      return lafsError(code, message, "allowlist.remove");
+    }
+  }
+});
+var QUERY_OPS = /* @__PURE__ */ new Set(["status", "propose.list", "propose.diff", "allowlist.list"]);
+var MUTATE_OPS = /* @__PURE__ */ new Set([
+  "propose.accept",
+  "propose.reject",
+  "propose.run",
+  "propose.enable",
+  "propose.disable",
+  "allowlist.add",
+  "allowlist.remove"
+]);
+var SentientHandler = class {
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return {
+      query: ["status", "propose.list", "propose.diff", "allowlist.list"],
+      mutate: [
+        "propose.accept",
+        "propose.reject",
+        "propose.run",
+        "propose.enable",
+        "propose.disable",
+        "allowlist.add",
+        "allowlist.remove"
+      ]
+    };
+  }
+  /**
+   * Execute a read-only sentient query operation.
+   *
+   * @param operation - The sentient query op name (e.g. 'propose.list').
+   * @param params - Raw params from the dispatcher (narrowed internally).
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "sentient", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _sentientTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(
+        envelopeToEngineResult(envelope),
+        "query",
+        "sentient",
+        operation,
+        startTime
+      );
+    } catch (error) {
+      return handleErrorResult("query", "sentient", operation, error, startTime);
+    }
+  }
+  /**
+   * Execute a state-modifying sentient mutation operation.
+   *
+   * @param operation - The sentient mutate op name (e.g. 'propose.accept').
+   * @param params - Raw params from the dispatcher (narrowed internally).
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (!MUTATE_OPS.has(operation)) {
+      return unsupportedOp("mutate", "sentient", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _sentientTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(
+        envelopeToEngineResult(envelope),
+        "mutate",
+        "sentient",
+        operation,
+        startTime
+      );
+    } catch (error) {
+      return handleErrorResult("mutate", "sentient", operation, error, startTime);
+    }
+  }
+};
+export {
+  SentientHandler
+};
+//# sourceMappingURL=sentient-QPETVE53.js.map