@cleocode/cleo 2026.4.125 → 2026.4.127

package/dist/cli/index.js

@@ -744,13 +744,6 @@ var init_operations = __esm({
   }
 });
 
-// packages/contracts/src/orchestration-hierarchy.ts
-var init_orchestration_hierarchy = __esm({
-  "packages/contracts/src/orchestration-hierarchy.ts"() {
-    "use strict";
-  }
-});
-
 // packages/contracts/src/peer.ts
 var init_peer = __esm({
   "packages/contracts/src/peer.ts"() {
@@ -867,7 +860,6 @@ var init_src = __esm({
     init_lafs();
     init_operations();
     init_params();
-    init_orchestration_hierarchy();
     init_peer();
     init_session2();
     init_status_registry();
@@ -4644,6 +4636,25 @@ var init_registry = __esm({
         requiredParams: [],
         params: []
       },
+      // T1262 — memory-doctor read-only noise detector (E1-parallel per council verdict)
+      {
+        gateway: "query",
+        domain: "memory",
+        operation: "doctor",
+        description: "memory.doctor (query) \u2014 read-only brain noise scan: detects duplicate-content, missing-type, missing-provenance, orphan-edge, low-confidence, stale-unverified patterns. Used as M7 assert-clean gate for Sentient v1 activation.",
+        tier: 0,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: [],
+        params: [
+          {
+            name: "assert-clean",
+            type: "boolean",
+            required: false,
+            description: "If true, exit non-zero when any noise patterns are detected (M7 gate for Sentient v1)."
+          }
+        ]
+      },
       // T791 — LLM extraction backend status
       {
         gateway: "query",
@@ -4840,12 +4851,13 @@ var init_registry = __esm({
           { name: "agent", type: "string", required: false, description: "Agent provenance" }
         ]
       },
-      // T792 — promote entry to verified=true (owner/cleo-prime only)
+      // T792 — promote entry to verified=true (project-orchestrator or owner only)
+      // T1258 E1 migration shim: 'cleo-prime' accepted as legacy alias for 'project-orchestrator'
       {
         gateway: "mutate",
         domain: "memory",
         operation: "verify",
-        description: "memory.verify (mutate) \u2014 flip verified=1 on a brain entry; requires cleo-prime or owner identity",
+        description: "memory.verify (mutate) \u2014 flip verified=1 on a brain entry; requires project-orchestrator or owner identity",
         tier: 1,
         idempotent: true,
         sessionRequired: false,
@@ -4856,7 +4868,7 @@ var init_registry = __esm({
             name: "agent",
             type: "string",
             required: false,
-            description: "Caller identity ('cleo-prime' or 'owner'). Omit for terminal invocation."
+            description: "Caller identity ('project-orchestrator' or 'owner'). Legacy alias 'cleo-prime' accepted per T1258 E1 migration shim. Omit for terminal invocation."
           }
         ]
       },
@@ -18430,6 +18442,29 @@ var init_memory2 = __esm({
                 startTime
               );
             }
+            // T1262 — brain noise detector (read-only, E1-parallel per council verdict)
+            case "doctor": {
+              const { scanBrainNoise } = await import("@cleocode/core/memory/brain-doctor.js");
+              const result = await scanBrainNoise(projectRoot);
+              const assertClean = params?.["assert-clean"];
+              if (assertClean && !result.isClean) {
+                return errorResult(
+                  "query",
+                  "memory",
+                  operation,
+                  "E_BRAIN_NOISE_DETECTED",
+                  `Brain noise detected: ${result.findings.length} pattern(s) across ${result.totalScanned} entries. ` + result.findings.map((f) => `${f.pattern}(${f.count})`).join(", ") + ". Run `cleo memory doctor` for details. Fix noise before enabling Sentient v1 (M7 gate).",
+                  startTime
+                );
+              }
+              return wrapResult(
+                { success: true, data: result },
+                "query",
+                "memory",
+                operation,
+                startTime
+              );
+            }
             // T791 — LLM extraction backend status
             case "llm-status": {
               const resolvedSource = resolveAnthropicApiKeySource();
@@ -19264,14 +19299,20 @@ var init_memory2 = __esm({
                   startTime
                 );
               }
+              const VERIFY_PERMITTED_IDENTITIES = /* @__PURE__ */ new Set([
+                "owner",
+                "project-orchestrator",
+                "cleo-prime"
+                // legacy alias — see migration shim note above
+              ]);
               const callerAgent = params?.agent;
-              if (callerAgent && callerAgent !== "cleo-prime" && callerAgent !== "owner") {
+              if (callerAgent && !VERIFY_PERMITTED_IDENTITIES.has(callerAgent)) {
                 return errorResult(
                   "mutate",
                   "memory",
                   operation,
                   "E_FORBIDDEN",
-                  `verify requires agent identity 'cleo-prime' or 'owner'; got '${callerAgent}'`,
+                  `verify requires agent identity 'project-orchestrator' or 'owner'; got '${callerAgent}'`,
                   startTime
                 );
               }
@@ -19522,6 +19563,8 @@ var init_memory2 = __esm({
             "code.links",
             "code.memories-for-code",
             "code.for-memory",
+            // T1262 — brain noise detector (E1-parallel, read-only)
+            "doctor",
             // T791 — LLM extraction backend status
             "llm-status",
             // T792 — pending verification queue
@@ -33523,7 +33566,7 @@ agent ${agentId}:
   house: none
   allegiance: canon
   role: ${role}
-  parent: cleoos-opus-orchestrator
+  parent: project-orchestrator
   description: "${displayName}"
 
   tone:
@@ -35654,6 +35697,126 @@ var createCommand = defineCommand({
     }
   }
 });
+var mintCommand = defineCommand({
+  meta: {
+    name: "mint",
+    description: "Synthesize a project-specific agent from a .cant spec using agent-architect meta-agent"
+  },
+  args: {
+    spec: {
+      type: "positional",
+      description: "Path to the .cant spec file describing the agent to synthesize",
+      required: true
+    },
+    "output-dir": {
+      type: "string",
+      description: "Directory to write synthesized .cant files (defaults to .cleo/cant/agents/)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview invocation tokens without invoking agent-architect",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Emit result as LAFS JSON envelope",
+      default: false
+    }
+  },
+  async run({ args }) {
+    try {
+      const { existsSync: existsSync12, readFileSync: readFileSync15, mkdirSync: mkdirSync4 } = await import("node:fs");
+      const { resolve: resolve5, join: join22 } = await import("node:path");
+      const specPath = resolve5(args.spec);
+      if (!existsSync12(specPath)) {
+        const errEnv = {
+          success: false,
+          error: { code: "E_NOT_FOUND", message: `spec file not found: ${specPath}` },
+          meta: { operation: "agent.mint", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+        };
+        if (args.json) {
+          process.stdout.write(JSON.stringify(errEnv, null, 2) + "\n");
+        } else {
+          process.stderr.write(`error: spec file not found: ${specPath}
+`);
+        }
+        process.exitCode = 4;
+        return;
+      }
+      const specContent = readFileSync15(specPath, "utf-8");
+      const projectRoot = process.cwd();
+      const outputDir = args["output-dir"] ? resolve5(args["output-dir"]) : join22(projectRoot, ".cleo", "cant", "agents");
+      mkdirSync4(outputDir, { recursive: true });
+      if (args["dry-run"]) {
+        const preview = {
+          success: true,
+          data: {
+            dryRun: true,
+            agentName: "agent-architect",
+            specPath,
+            outputDir,
+            projectRoot,
+            message: "Dry-run: would invoke agent-architect with the above tokens"
+          },
+          meta: { operation: "agent.mint", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+        };
+        process.stdout.write(JSON.stringify(preview, null, 2) + "\n");
+        return;
+      }
+      const { invokeMetaAgent } = await import("@cleocode/core/agents/invoke-meta-agent");
+      const result = await invokeMetaAgent({
+        agentName: "agent-architect",
+        projectRoot,
+        tokens: {
+          CANT_AGENTS_DIR: outputDir,
+          // Pass spec content as PROJECT_CONTEXT to let agent-architect read it
+          PROJECT_CONTEXT: specContent
+        }
+      });
+      if (result.invoked) {
+        const envelope = {
+          success: true,
+          data: {
+            invoked: true,
+            outputs: result.outputs ?? [],
+            outputDir,
+            message: `agent-architect synthesized ${result.outputs?.length ?? 0} agent(s)`
+          },
+          meta: { operation: "agent.mint", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+        };
+        if (args.json) {
+          process.stdout.write(JSON.stringify(envelope, null, 2) + "\n");
+        } else {
+          process.stdout.write(`minted ${result.outputs?.length ?? 0} agent(s) to ${outputDir}
+`);
+          for (const out of result.outputs ?? []) {
+            process.stdout.write(`  + ${out}
+`);
+          }
+        }
+      } else {
+        const fallbackMsg = `agent-architect unavailable: ${result.reason ?? "unknown"}. Run 'cleo agent create' for static scaffolding.`;
+        const envelope = {
+          success: false,
+          error: { code: "E_META_AGENT_UNAVAILABLE", message: fallbackMsg },
+          meta: { operation: "agent.mint", timestamp: (/* @__PURE__ */ new Date()).toISOString() }
+        };
+        if (args.json) {
+          process.stdout.write(JSON.stringify(envelope, null, 2) + "\n");
+        } else {
+          process.stderr.write(`warn: ${fallbackMsg}
+`);
+        }
+        process.exitCode = 1;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`error: agent mint failed: ${message}
+`);
+      process.exitCode = 1;
+    }
+  }
+});
 var doctorCommand = defineCommand({
   meta: {
     name: "doctor",
@@ -35790,7 +35953,8 @@ var agentCommand = defineCommand({
     health: healthCommand3,
     install: installCommand,
     pack: packCommand,
-    create: createCommand
+    create: createCommand,
+    mint: mintCommand
   },
   async run({ cmd, rawArgs }) {
     const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
@@ -45267,6 +45431,31 @@ var importCommand3 = defineCommand({
     if (stats.errors > 0) process.exit(1);
   }
 });
+var doctorCommand3 = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Read-only brain noise scan: detects duplicate-content, missing-type, missing-provenance, orphan-edge, low-confidence, and stale-unverified patterns. Use --assert-clean as the M7 entry gate before enabling Sentient v1 (`cleo sentient propose enable`)."
+  },
+  args: {
+    "assert-clean": {
+      type: "boolean",
+      description: "Exit non-zero when any noise patterns are detected (M7 gate for Sentient v1)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "memory",
+      "doctor",
+      { "assert-clean": args["assert-clean"] },
+      { command: "memory-doctor", operation: "memory.doctor" }
+    );
+  }
+});
 var llmStatusCommand = defineCommand({
   meta: {
     name: "llm-status",
@@ -46125,6 +46314,7 @@ var memoryCommand = defineCommand({
     reflect: reflectCommand,
     "dedup-scan": dedupScanCommand,
     import: importCommand3,
+    doctor: doctorCommand3,
     "llm-status": llmStatusCommand,
     verify: verifyCommand,
     "pending-verify": pendingVerifyCommand,
@@ -52167,6 +52357,51 @@ var resumeCommand = defineCommand({
     );
   }
 });
+var createCommand2 = defineCommand({
+  meta: {
+    name: "create",
+    description: "Scaffold a new .cantbook playbook (invokes playbook-architect meta-agent)"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: 'Playbook name (kebab-case, e.g. "feature-ship")',
+      required: true
+    },
+    description: {
+      type: "string",
+      description: "Plain-text description of what the playbook should do"
+    },
+    stages: {
+      type: "string",
+      description: "Comma-separated list of stage names to scaffold (auto-inferred if omitted)"
+    },
+    "output-dir": {
+      type: "string",
+      description: "Output directory for the .cantbook file (defaults to .cleo/cant/playbooks/)"
+    },
+    "dry-run": {
+      type: "boolean",
+      description: "Preview what would be created without writing files",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "playbook",
+      "create",
+      {
+        name: args.name,
+        description: args.description,
+        stages: args.stages,
+        outputDir: args["output-dir"],
+        dryRun: args["dry-run"]
+      },
+      { command: "playbook" }
+    );
+  }
+});
 var listCommand13 = defineCommand({
   meta: {
     name: "list",
@@ -52208,13 +52443,14 @@ var listCommand13 = defineCommand({
 var playbookCommand = defineCommand({
   meta: {
     name: "playbook",
-    description: "Playbook runtime operations (run, status, resume, list)"
+    description: "Playbook runtime operations (run, status, resume, list, create)"
   },
   subCommands: {
     run: runCommand3,
     status: statusCommand10,
     resume: resumeCommand,
-    list: listCommand13
+    list: listCommand13,
+    create: createCommand2
   },
   async run({ cmd, rawArgs }) {
     const firstArg = rawArgs?.find((a) => !a.startsWith("-"));