@cleocode/cleo 2026.4.126 → 2026.4.127

package/dist/cli/index.js

@@ -18457,7 +18457,13 @@ var init_memory2 = __esm({
                   startTime
                 );
               }
-              return wrapResult(result, "query", "memory", operation, startTime);
+              return wrapResult(
+                { success: true, data: result },
+                "query",
+                "memory",
+                operation,
+                startTime
+              );
             }
             // T791 — LLM extraction backend status
             case "llm-status": {
@@ -33560,7 +33566,7 @@ agent ${agentId}:
   house: none
   allegiance: canon
   role: ${role}
-  parent: cleoos-opus-orchestrator
+  parent: project-orchestrator
   description: "${displayName}"
 
   tone:
@@ -35691,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",
@@ -35827,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("-"));
@@ -52230,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",
@@ -52271,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("-"));