@cleocode/cleo 2026.10.4 → 2026.10.5

package/dist/cli/{init-IHEJDQWU.js → init-AN4DZ2XO.js}

@@ -20,14 +20,14 @@ import {
   initCommand,
   isCredentialPoolEmpty,
   maybeNudgeFirstRunLogin
-} from "./chunk-OPTEQKBB.js";
-import "./chunk-J3ZFM3UQ.js";
+} from "./chunk-EIUXVHNF.js";
+import "./chunk-UWCZY52R.js";
 import "./chunk-GZFVDR44.js";
-import "./chunk-ULN4OKQQ.js";
+import "./chunk-GRU74UE4.js";
 import "./chunk-47JYZAMS.js";
 import "./chunk-C3B7C43W.js";
 import "./chunk-PKKZPOOP.js";
-import "./chunk-3ZO3M37V.js";
+import "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
 export {
   FIRST_RUN_LOGIN_NEXT_STEP,
@@ -37,4 +37,4 @@ export {
   isCredentialPoolEmpty,
   maybeNudgeFirstRunLogin
 };
-//# sourceMappingURL=init-IHEJDQWU.js.map
+//# sourceMappingURL=init-AN4DZ2XO.js.map

package/dist/cli/{inject-LSRVWNCP.js → inject-HQWA5GWY.js}

@@ -13,18 +13,19 @@
     return _origEmitWarning.call(process, warning, type, code, ctor);
   };
 })();
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
 import {
   defineCommand
 } from "./chunk-PKKZPOOP.js";
-import {
-  dispatchFromCli
-} from "./chunk-3IOQVUO7.js";
-import "./chunk-AWCQH2W5.js";
-import "./chunk-OGV57L4J.js";
-import "./chunk-ZBISIPCK.js";
-import "./chunk-3ZO3M37V.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
-import "./chunk-QFFQSKRC.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
 
 // packages/cleo/src/cli/commands/inject.ts
 var injectCommand = defineCommand({
@@ -79,4 +80,4 @@ var injectCommand = defineCommand({
 export {
   injectCommand
 };
-//# sourceMappingURL=inject-LSRVWNCP.js.map
+//# sourceMappingURL=inject-HQWA5GWY.js.map

package/dist/cli/{install-global-4AZUCH6U.js → install-global-YQV4W5OG.js}

@@ -19,7 +19,7 @@ import {
 import {
   cliOutput,
   humanLine
-} from "./chunk-3ZO3M37V.js";
+} from "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
 
 // packages/cleo/src/cli/commands/install-global.ts
@@ -92,4 +92,4 @@ var installGlobalCommand = defineCommand({
 export {
   installGlobalCommand
 };
-//# sourceMappingURL=install-global-4AZUCH6U.js.map
+//# sourceMappingURL=install-global-YQV4W5OG.js.map

package/dist/cli/intelligence-OFFNQGHE.js

@@ -0,0 +1,238 @@
+(() => {
+  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,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/intelligence.ts
+import { getLogger, getProjectRoot, getTaskAccessor } from "@cleocode/core";
+import {
+  calculateTaskRisk,
+  extractPatternsFromHistory,
+  getBrainAccessor,
+  matchPatterns,
+  predictValidationOutcome,
+  scoreVerificationConfidence,
+  suggestGateFocus
+} from "@cleocode/core/internal";
+var IntelligenceHandler = class {
+  // -----------------------------------------------------------------------
+  // Query
+  // -----------------------------------------------------------------------
+  async query(operation, params) {
+    const projectRoot = getProjectRoot();
+    const startTime = Date.now();
+    try {
+      switch (operation) {
+        // ------------------------------------------------------------------
+        // predict — calculateTaskRisk or predictValidationOutcome
+        // ------------------------------------------------------------------
+        case "predict": {
+          const taskId = params?.taskId;
+          if (!taskId) {
+            return errorResult(
+              "query",
+              "intelligence",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          }
+          const [accessor, brain] = await Promise.all([
+            getTaskAccessor(projectRoot),
+            getBrainAccessor(projectRoot)
+          ]);
+          const stage = params?.stage;
+          if (stage) {
+            const result2 = await predictValidationOutcome(taskId, stage, accessor, brain);
+            return wrapResult(
+              { success: true, data: result2 },
+              "query",
+              "intelligence",
+              operation,
+              startTime
+            );
+          }
+          const result = await calculateTaskRisk(taskId, accessor, brain);
+          return wrapResult(
+            { success: true, data: result },
+            "query",
+            "intelligence",
+            operation,
+            startTime
+          );
+        }
+        // ------------------------------------------------------------------
+        // suggest — suggestGateFocus
+        // ------------------------------------------------------------------
+        case "suggest": {
+          const taskId = params?.taskId;
+          if (!taskId) {
+            return errorResult(
+              "query",
+              "intelligence",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          }
+          const [accessor, brain] = await Promise.all([
+            getTaskAccessor(projectRoot),
+            getBrainAccessor(projectRoot)
+          ]);
+          const result = await suggestGateFocus(taskId, accessor, brain);
+          return wrapResult(
+            { success: true, data: result },
+            "query",
+            "intelligence",
+            operation,
+            startTime
+          );
+        }
+        // ------------------------------------------------------------------
+        // learn-errors — extractPatternsFromHistory
+        // ------------------------------------------------------------------
+        case "learn-errors": {
+          const [accessor, brain] = await Promise.all([
+            getTaskAccessor(projectRoot),
+            getBrainAccessor(projectRoot)
+          ]);
+          const limit = typeof params?.limit === "number" ? params.limit : void 0;
+          const result = await extractPatternsFromHistory(accessor, brain, { limit });
+          return wrapResult(
+            { success: true, data: result },
+            "query",
+            "intelligence",
+            operation,
+            startTime
+          );
+        }
+        // ------------------------------------------------------------------
+        // confidence — scoreVerificationConfidence
+        // ------------------------------------------------------------------
+        case "confidence": {
+          const taskId = params?.taskId;
+          if (!taskId) {
+            return errorResult(
+              "query",
+              "intelligence",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          }
+          const [accessor, brain] = await Promise.all([
+            getTaskAccessor(projectRoot),
+            getBrainAccessor(projectRoot)
+          ]);
+          const task = await accessor.loadSingleTask(taskId);
+          if (!task) {
+            return errorResult(
+              "query",
+              "intelligence",
+              operation,
+              "E_NOT_FOUND",
+              `Task ${taskId} not found`,
+              startTime
+            );
+          }
+          const verification = task.verification ?? {
+            passed: false,
+            round: 1,
+            gates: {},
+            lastAgent: null,
+            lastUpdated: null,
+            failureLog: [],
+            checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          const result = await scoreVerificationConfidence(taskId, verification, accessor, brain, {
+            dryRun: true
+          });
+          return wrapResult(
+            { success: true, data: result },
+            "query",
+            "intelligence",
+            operation,
+            startTime
+          );
+        }
+        // ------------------------------------------------------------------
+        // match — matchPatterns
+        // ------------------------------------------------------------------
+        case "match": {
+          const taskId = params?.taskId;
+          if (!taskId) {
+            return errorResult(
+              "query",
+              "intelligence",
+              operation,
+              "E_INVALID_INPUT",
+              "taskId is required",
+              startTime
+            );
+          }
+          const [accessor, brain] = await Promise.all([
+            getTaskAccessor(projectRoot),
+            getBrainAccessor(projectRoot)
+          ]);
+          const result = await matchPatterns(taskId, accessor, brain);
+          return wrapResult(
+            { success: true, data: result },
+            "query",
+            "intelligence",
+            operation,
+            startTime
+          );
+        }
+        default:
+          return unsupportedOp("query", "intelligence", operation, startTime);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      getLogger("domain:intelligence").error(
+        { gateway: "query", domain: "intelligence", operation, err: error },
+        message
+      );
+      return handleErrorResult("query", "intelligence", operation, error, startTime);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Mutate — not supported; intelligence is read-only at the domain level
+  // -----------------------------------------------------------------------
+  async mutate(operation, _params) {
+    const startTime = Date.now();
+    return unsupportedOp("mutate", "intelligence", operation, startTime);
+  }
+  // -----------------------------------------------------------------------
+  // Supported operations
+  // -----------------------------------------------------------------------
+  getSupportedOperations() {
+    return {
+      query: ["predict", "suggest", "learn-errors", "confidence", "match"],
+      mutate: []
+    };
+  }
+};
+export {
+  IntelligenceHandler
+};
+//# sourceMappingURL=intelligence-OFFNQGHE.js.map

package/dist/cli/{intelligence-2OSFOGD2.js → intelligence-QIC4SN4X.js}

@@ -13,19 +13,20 @@
     return _origEmitWarning.call(process, warning, type, code, ctor);
   };
 })();
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
 import {
   defineCommand,
   showUsage
 } from "./chunk-PKKZPOOP.js";
-import {
-  dispatchFromCli
-} from "./chunk-3IOQVUO7.js";
-import "./chunk-AWCQH2W5.js";
-import "./chunk-OGV57L4J.js";
-import "./chunk-ZBISIPCK.js";
-import "./chunk-3ZO3M37V.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
-import "./chunk-QFFQSKRC.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
 
 // packages/cleo/src/cli/commands/intelligence.ts
 var predictCommand = defineCommand({
@@ -178,4 +179,4 @@ var intelligenceCommand = defineCommand({
 export {
   intelligenceCommand
 };
-//# sourceMappingURL=intelligence-2OSFOGD2.js.map
+//# sourceMappingURL=intelligence-QIC4SN4X.js.map

package/dist/cli/{issue-IIWEDNFC.js → issue-P5RNMRDG.js}

@@ -13,22 +13,23 @@
     return _origEmitWarning.call(process, warning, type, code, ctor);
   };
 })();
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
 import {
   defineCommand,
   showUsage
 } from "./chunk-PKKZPOOP.js";
-import {
-  dispatchFromCli
-} from "./chunk-3IOQVUO7.js";
-import "./chunk-AWCQH2W5.js";
-import "./chunk-OGV57L4J.js";
-import "./chunk-ZBISIPCK.js";
+import "./chunk-QKMBWYAS.js";
 import {
   cliError,
   cliOutput
-} from "./chunk-3ZO3M37V.js";
+} from "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
-import "./chunk-QFFQSKRC.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
 
 // packages/cleo/src/cli/commands/issue.ts
 import { execFileSync } from "node:child_process";
@@ -155,4 +156,4 @@ var issueCommand = defineCommand({
 export {
   issueCommand
 };
-//# sourceMappingURL=issue-IIWEDNFC.js.map
+//# sourceMappingURL=issue-P5RNMRDG.js.map

package/dist/cli/{janitor-GPMC7VOR.js → janitor-ZNCFQ7E3.js}

@@ -20,7 +20,7 @@ import {
 import {
   cliError,
   cliOutput
-} from "./chunk-3ZO3M37V.js";
+} from "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
 
 // packages/cleo/src/cli/commands/janitor.ts
@@ -108,4 +108,4 @@ var janitorCommand = defineCommand({
 export {
   janitorCommand
 };
-//# sourceMappingURL=janitor-GPMC7VOR.js.map
+//# sourceMappingURL=janitor-ZNCFQ7E3.js.map

package/dist/cli/{labels-5NPOIQXN.js → labels-ORBM3T57.js}

@@ -13,18 +13,19 @@
     return _origEmitWarning.call(process, warning, type, code, ctor);
   };
 })();
+import {
+  dispatchFromCli
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
 import {
   defineCommand
 } from "./chunk-PKKZPOOP.js";
-import {
-  dispatchFromCli
-} from "./chunk-3IOQVUO7.js";
-import "./chunk-AWCQH2W5.js";
-import "./chunk-OGV57L4J.js";
-import "./chunk-ZBISIPCK.js";
-import "./chunk-3ZO3M37V.js";
+import "./chunk-QKMBWYAS.js";
+import "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
-import "./chunk-QFFQSKRC.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
 
 // packages/cleo/src/cli/commands/labels.ts
 var listCommand = defineCommand({
@@ -84,4 +85,4 @@ var labelsCommand = defineCommand({
 export {
   labelsCommand
 };
-//# sourceMappingURL=labels-5NPOIQXN.js.map
+//# sourceMappingURL=labels-ORBM3T57.js.map

package/dist/cli/{lifecycle-4FFS2K2T.js → lifecycle-MHR22TVI.js}

@@ -13,21 +13,22 @@
     return _origEmitWarning.call(process, warning, type, code, ctor);
   };
 })();
-import {
-  defineCommand,
-  showUsage
-} from "./chunk-PKKZPOOP.js";
 import {
   dispatchFromCli,
   dispatchRaw,
   handleRawError
-} from "./chunk-3IOQVUO7.js";
-import "./chunk-AWCQH2W5.js";
-import "./chunk-OGV57L4J.js";
-import "./chunk-ZBISIPCK.js";
-import "./chunk-3ZO3M37V.js";
+} 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-QFFQSKRC.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
 
 // packages/cleo/src/cli/commands/lifecycle.ts
 var VALID_STAGES = "research|consensus|architecture_decision|specification|decomposition|implementation|validation|testing|release|contribution";
@@ -123,7 +124,7 @@ var gateCommand = defineCommand({
       targetStage: args.stage
     });
     if (result.success) {
-      const { cliOutput } = await import("./renderers-64OR3IWX.js");
+      const { cliOutput } = await import("./renderers-TGSW77J4.js");
       cliOutput(result.data, { command: "lifecycle" });
       const data = result.data;
       if (data && !data["canProgress"]) {
@@ -269,4 +270,4 @@ var lifecycleCommand = defineCommand({
 export {
   lifecycleCommand
 };
-//# sourceMappingURL=lifecycle-4FFS2K2T.js.map
+//# sourceMappingURL=lifecycle-MHR22TVI.js.map

package/dist/cli/{list-47KEUGPQ.js → list-LB6GCYYU.js}

@@ -17,27 +17,28 @@ import {
   getOperationParams,
   paramsToCittyArgs,
   registryParamsToDispatchPayload
-} from "./chunk-W33Q3FBH.js";
-import {
-  defineCommand
-} from "./chunk-PKKZPOOP.js";
+} from "./chunk-RRKP7HLU.js";
 import {
   dispatchRaw,
   handleRawError,
   maybeEmitDescribe
-} from "./chunk-3IOQVUO7.js";
-import "./chunk-AWCQH2W5.js";
-import "./chunk-OGV57L4J.js";
-import "./chunk-ZBISIPCK.js";
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  defineCommand
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
 import {
   cliOutput
-} from "./chunk-3ZO3M37V.js";
+} from "./chunk-4RGSNUUP.js";
 import "./chunk-6JSJNYH2.js";
-import "./chunk-QFFQSKRC.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
 
 // packages/cleo/src/cli/commands/list.ts
-import { ExitCode } from "@cleocode/contracts";
-import { createPage } from "@cleocode/core";
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+import { createPage } from "@cleocode/core/pagination";
 var listArgs = {
   ...paramsToCittyArgs(getOperationParams("query", "tasks", "list")),
   includeArchive: {
@@ -105,4 +106,4 @@ var listCommand = defineCommand({
 export {
   listCommand
 };
-//# sourceMappingURL=list-47KEUGPQ.js.map
+//# sourceMappingURL=list-LB6GCYYU.js.map

package/dist/cli/llm-H7LZWQKX.js

@@ -0,0 +1,130 @@
+(() => {
+  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/llm/index.ts
+import {
+  llmAdd,
+  llmAuxiliaryStatus,
+  llmList,
+  llmProfile,
+  llmRemove,
+  llmSystemsOfUse,
+  llmTest,
+  llmUse,
+  llmWhoami
+} from "@cleocode/core/internal";
+var coreOps = {
+  list: llmList,
+  test: llmTest,
+  whoami: llmWhoami,
+  "systems-of-use": llmSystemsOfUse,
+  "auxiliary-status": llmAuxiliaryStatus,
+  add: llmAdd,
+  remove: llmRemove,
+  use: llmUse,
+  profile: llmProfile
+};
+async function wrap(op, params, label) {
+  try {
+    const result = await op(params);
+    if (result.success) return lafsSuccess(result.data, label);
+    return lafsError(String(result.error.code), result.error.message, label);
+  } catch (err) {
+    return lafsError("E_INTERNAL", err instanceof Error ? err.message : String(err), label);
+  }
+}
+var _llmTypedHandler = defineTypedHandler("llm", {
+  // -------------------------------------------------------------------------
+  // Query ops
+  // -------------------------------------------------------------------------
+  list: async (params) => wrap(coreOps["list"], params, "list"),
+  test: async (params) => wrap(coreOps["test"], params, "test"),
+  whoami: async (params) => wrap(coreOps["whoami"], params, "whoami"),
+  "systems-of-use": async (params) => wrap(coreOps["systems-of-use"], params, "systems-of-use"),
+  "auxiliary-status": async (params) => wrap(coreOps["auxiliary-status"], params, "auxiliary-status"),
+  // -------------------------------------------------------------------------
+  // Mutate ops
+  // -------------------------------------------------------------------------
+  add: async (params) => wrap(coreOps["add"], params, "add"),
+  remove: async (params) => wrap(coreOps["remove"], params, "remove"),
+  use: async (params) => wrap(coreOps["use"], params, "use"),
+  profile: async (params) => wrap(coreOps["profile"], params, "profile")
+});
+var QUERY_OPS = /* @__PURE__ */ new Set(["list", "test", "whoami", "systems-of-use", "auxiliary-status"]);
+var MUTATE_OPS = /* @__PURE__ */ new Set(["add", "remove", "use", "profile"]);
+var LlmHandler = class {
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return {
+      query: ["list", "test", "whoami", "systems-of-use", "auxiliary-status"],
+      mutate: ["add", "remove", "use", "profile"]
+    };
+  }
+  /**
+   * Execute a read-only llm query operation.
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "llm", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _llmTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(envelopeToEngineResult(envelope), "query", "llm", operation, startTime);
+    } catch (error) {
+      return handleErrorResult("query", "llm", operation, error, startTime);
+    }
+  }
+  /**
+   * Execute a state-modifying llm mutate operation.
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (!MUTATE_OPS.has(operation)) {
+      return unsupportedOp("mutate", "llm", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _llmTypedHandler,
+        operation,
+        params ?? {}
+      );
+      return wrapResult(envelopeToEngineResult(envelope), "mutate", "llm", operation, startTime);
+    } catch (error) {
+      return handleErrorResult("mutate", "llm", operation, error, startTime);
+    }
+  }
+};
+export {
+  LlmHandler
+};
+//# sourceMappingURL=llm-H7LZWQKX.js.map