@cleocode/cleo 2026.4.114 → 2026.4.116

package/dist/cli/index.js

@@ -705,6 +705,13 @@ var init_variable_substitution = __esm({
   }
 });
 
+// packages/contracts/src/operations/worktree.ts
+var init_worktree = __esm({
+  "packages/contracts/src/operations/worktree.ts"() {
+    "use strict";
+  }
+});
+
 // packages/contracts/src/operations/index.ts
 var init_operations = __esm({
   "packages/contracts/src/operations/index.ts"() {
@@ -725,6 +732,7 @@ var init_operations = __esm({
     init_tasks();
     init_validate();
     init_variable_substitution();
+    init_worktree();
   }
 });
 
@@ -735,6 +743,13 @@ var init_orchestration_hierarchy = __esm({
   }
 });
 
+// packages/contracts/src/peer.ts
+var init_peer = __esm({
+  "packages/contracts/src/peer.ts"() {
+    "use strict";
+  }
+});
+
 // packages/contracts/src/session.ts
 var init_session2 = __esm({
   "packages/contracts/src/session.ts"() {
@@ -845,6 +860,7 @@ var init_src = __esm({
     init_operations();
     init_params();
     init_orchestration_hierarchy();
+    init_peer();
     init_session2();
     init_status_registry();
     init_task_evidence();
@@ -9617,13 +9633,15 @@ async function composeSpawnForTask(taskId, root, options = {}) {
       sessionId: options.sessionId ?? null,
       role: inferredRole,
       protocol: options.protocol,
-      skipAtomicityCheck: options.skipAtomicityCheck ?? false
+      skipAtomicityCheck: options.skipAtomicityCheck ?? false,
+      worktreePath: options.worktreePath,
+      worktreeBranch: options.worktreeBranch
     });
   } finally {
     db.close();
   }
 }
-async function orchestrateSpawn(taskId, protocolType, projectRoot, tier) {
+async function orchestrateSpawn(taskId, protocolType, projectRoot, tier, noWorktree) {
   if (!taskId) {
     return engineError("E_INVALID_INPUT", "taskId is required");
   }
@@ -9650,10 +9668,43 @@ async function orchestrateSpawn(taskId, protocolType, projectRoot, tier) {
     } catch {
       activeSessionId = null;
     }
+    let sdkWorktreeResult = null;
+    let worktreePath;
+    let worktreeBranch;
+    if (noWorktree) {
+      getLogger2("engine:orchestrate").info(
+        { taskId },
+        "T1140 --no-worktree: worktree provisioning skipped (audit logged)"
+      );
+      try {
+        const accessor2 = await getAccessor2(root);
+        await accessor2.appendLog({
+          action: "orchestrate.spawn.no-worktree",
+          taskId,
+          actor: "orchestrate-engine",
+          details: { reason: "--no-worktree flag set by caller", taskId }
+        });
+      } catch {
+      }
+    } else {
+      try {
+        const { spawnWorktree } = await import("@cleocode/core/internal");
+        sdkWorktreeResult = await spawnWorktree(root, { taskId });
+        worktreePath = sdkWorktreeResult.path;
+        worktreeBranch = sdkWorktreeResult.branch;
+      } catch (wtErr) {
+        getLogger2("engine:orchestrate").warn(
+          { taskId, err: wtErr },
+          `T1140 worktree creation failed for ${taskId} \u2014 spawning without isolation: ${wtErr instanceof Error ? wtErr.message : String(wtErr)}`
+        );
+      }
+    }
     const payload = await composeSpawnForTask(taskId, root, {
       tier,
       sessionId: activeSessionId,
-      protocol: protocolType
+      protocol: protocolType,
+      worktreePath,
+      worktreeBranch
     });
     if (!payload.atomicity.allowed) {
       return engineError(
@@ -9669,20 +9720,21 @@ async function orchestrateSpawn(taskId, protocolType, projectRoot, tier) {
         }
       );
     }
-    let worktreeResult = null;
-    try {
-      const { buildWorktreeSpawnResult, createAgentWorktree, ensureGitShimDir } = await import("@cleocode/core/internal");
-      const worktree = createAgentWorktree(taskId, root);
-      const shimDir = ensureGitShimDir(root);
-      worktreeResult = buildWorktreeSpawnResult(worktree, shimDir);
-    } catch (wtErr) {
-      getLogger2("engine:orchestrate").warn(
-        { taskId, err: wtErr },
-        `T1118 worktree creation failed for ${taskId} \u2014 spawning without isolation: ${wtErr instanceof Error ? wtErr.message : String(wtErr)}`
-      );
-    }
-    const finalPrompt = worktreeResult ? `${worktreeResult.preamble}
-${payload.prompt}` : payload.prompt;
+    const finalPrompt = payload.prompt;
+    const worktreeAdapterResult = sdkWorktreeResult ? {
+      worktree: {
+        path: sdkWorktreeResult.path,
+        branch: sdkWorktreeResult.branch,
+        taskId: sdkWorktreeResult.taskId,
+        baseRef: sdkWorktreeResult.baseRef,
+        projectHash: sdkWorktreeResult.projectHash,
+        createdAt: sdkWorktreeResult.createdAt,
+        locked: sdkWorktreeResult.locked
+      },
+      envVars: sdkWorktreeResult.envVars,
+      cwd: sdkWorktreeResult.path,
+      preamble: sdkWorktreeResult.preamble
+    } : null;
     return {
       success: true,
       data: {
@@ -9694,10 +9746,10 @@ ${payload.prompt}` : payload.prompt;
         harnessHint: payload.harnessHint,
         atomicity: payload.atomicity,
         meta: payload.meta,
-        // T1118 L1+L2 — worktree binding for harness adapters.
-        worktree: worktreeResult?.worktree ?? null,
-        worktreeEnv: worktreeResult?.envVars ?? null,
-        worktreeCwd: worktreeResult?.cwd ?? null,
+        // T1118 L1+L2 / T1140 — worktree binding for harness adapters.
+        worktree: worktreeAdapterResult?.worktree ?? null,
+        worktreeEnv: worktreeAdapterResult?.envVars ?? null,
+        worktreeCwd: worktreeAdapterResult?.cwd ?? null,
         spawnContext: {
           taskId: payload.taskId,
           protocol: payload.meta.protocol,
@@ -16407,6 +16459,15 @@ var init_conduit2 = __esm({
               );
               return wrapResult(result, "query", "conduit", operation, startTime);
             }
+            case "listen": {
+              const result = await this.listenTopic(
+                params?.topicName,
+                params?.agentId,
+                params?.limit,
+                params?.since
+              );
+              return wrapResult(result, "query", "conduit", operation, startTime);
+            }
             default:
               return unsupportedOp("query", "conduit", operation, startTime);
           }
@@ -16446,6 +16507,24 @@ var init_conduit2 = __esm({
               );
               return wrapResult(result, "mutate", "conduit", operation, startTime);
             }
+            case "subscribe": {
+              const result = await this.subscribeTopic(
+                params?.topicName,
+                params?.agentId,
+                params?.filter
+              );
+              return wrapResult(result, "mutate", "conduit", operation, startTime);
+            }
+            case "publish": {
+              const result = await this.publishToTopic(
+                params?.topicName,
+                params?.content,
+                params?.kind,
+                params?.payload,
+                params?.agentId
+              );
+              return wrapResult(result, "mutate", "conduit", operation, startTime);
+            }
             default:
               return unsupportedOp("mutate", "conduit", operation, startTime);
           }
@@ -16462,8 +16541,8 @@ var init_conduit2 = __esm({
       }
       getSupportedOperations() {
         return {
-          query: ["status", "peek"],
-          mutate: ["start", "stop", "send"]
+          query: ["status", "peek", "listen"],
+          mutate: ["start", "stop", "send", "subscribe", "publish"]
         };
       }
       // ---------------------------------------------------------------------------
@@ -16670,6 +16749,165 @@ var init_conduit2 = __esm({
           }
         };
       }
+      // ── A2A Topic Operations (T1252) ────────────────────────────────────────
+      /**
+       * Subscribe agent to a named topic.
+       *
+       * Uses `LocalTransport` exclusively — topic operations require conduit.db.
+       *
+       * @param topicName - Topic name, e.g. `"epic-T1149.wave-2"`.
+       * @param agentId   - Agent id (defaults to active agent).
+       * @param _filter   - Reserved for future filter support.
+       * @task T1252
+       */
+      async subscribeTopic(topicName, agentId, _filter) {
+        if (!topicName) {
+          return {
+            success: false,
+            error: { code: "E_ARGS", message: 'Must specify "topicName"' }
+          };
+        }
+        const credential = await this.resolveCredential(agentId);
+        const { LocalTransport } = await import("@cleocode/core/conduit");
+        if (!LocalTransport.isAvailable(process.cwd())) {
+          return {
+            success: false,
+            error: { code: "E_CONDUIT", message: "conduit.db not found \u2014 run: cleo init" }
+          };
+        }
+        const transport = new LocalTransport();
+        await transport.connect({
+          agentId: credential.agentId,
+          apiKey: credential.apiKey,
+          apiBaseUrl: credential.apiBaseUrl
+        });
+        try {
+          await transport.subscribeTopic(topicName);
+          return {
+            success: true,
+            data: {
+              agentId: credential.agentId,
+              topicName,
+              message: `Subscribed to topic: ${topicName}`
+            }
+          };
+        } finally {
+          await transport.disconnect();
+        }
+      }
+      /**
+       * Publish a message to a named topic.
+       *
+       * Uses `LocalTransport` exclusively — topic operations require conduit.db.
+       *
+       * @param topicName - Target topic name.
+       * @param content   - Message content (required).
+       * @param kind      - Message kind (default `"message"`).
+       * @param payload   - Optional structured payload.
+       * @param agentId   - Publisher agent id (defaults to active agent).
+       * @task T1252
+       */
+      async publishToTopic(topicName, content, kind, payload, agentId) {
+        if (!topicName) {
+          return {
+            success: false,
+            error: { code: "E_ARGS", message: 'Must specify "topicName"' }
+          };
+        }
+        if (!content) {
+          return {
+            success: false,
+            error: { code: "E_ARGS", message: 'Must specify "content"' }
+          };
+        }
+        const credential = await this.resolveCredential(agentId);
+        const { LocalTransport } = await import("@cleocode/core/conduit");
+        if (!LocalTransport.isAvailable(process.cwd())) {
+          return {
+            success: false,
+            error: { code: "E_CONDUIT", message: "conduit.db not found \u2014 run: cleo init" }
+          };
+        }
+        const transport = new LocalTransport();
+        await transport.connect({
+          agentId: credential.agentId,
+          apiKey: credential.apiKey,
+          apiBaseUrl: credential.apiBaseUrl
+        });
+        try {
+          const result = await transport.publishToTopic(topicName, content, { kind, payload });
+          return {
+            success: true,
+            data: {
+              messageId: result.messageId,
+              from: credential.agentId,
+              topicName,
+              transport: "local",
+              publishedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          };
+        } finally {
+          await transport.disconnect();
+        }
+      }
+      /**
+       * One-shot poll for topic messages.
+       *
+       * Returns messages published to the topic (ordered oldest-first).
+       * Uses `LocalTransport` exclusively — topic operations require conduit.db.
+       *
+       * @param topicName - Topic name to poll.
+       * @param agentId   - Agent id (defaults to active agent).
+       * @param limit     - Maximum messages to return (default 50).
+       * @param since     - Return only messages after this ISO 8601 timestamp.
+       * @task T1252
+       */
+      async listenTopic(topicName, agentId, limit, since) {
+        if (!topicName) {
+          return {
+            success: false,
+            error: { code: "E_ARGS", message: 'Must specify "topicName"' }
+          };
+        }
+        const startMs = Date.now();
+        const credential = await this.resolveCredential(agentId);
+        const { LocalTransport } = await import("@cleocode/core/conduit");
+        if (!LocalTransport.isAvailable(process.cwd())) {
+          return {
+            success: false,
+            error: { code: "E_CONDUIT", message: "conduit.db not found \u2014 run: cleo init" }
+          };
+        }
+        const transport = new LocalTransport();
+        await transport.connect({
+          agentId: credential.agentId,
+          apiKey: credential.apiKey,
+          apiBaseUrl: credential.apiBaseUrl
+        });
+        try {
+          const sinceUnix = since ? Math.floor(new Date(since).getTime() / 1e3) : 0;
+          const messages = await transport.pollTopic(topicName, {
+            limit: limit ?? 50,
+            since: sinceUnix
+          });
+          return {
+            success: true,
+            data: {
+              topicName,
+              messages: messages.map((m) => ({
+                id: m.id,
+                from: m.from,
+                content: m.content,
+                conversationId: m.threadId,
+                timestamp: m.timestamp
+              })),
+              listenedForMs: Date.now() - startMs
+            }
+          };
+        } finally {
+          await transport.disconnect();
+        }
+      }
       /** Send a message to an agent or conversation. Uses LocalTransport when conduit.db is available. */
       async sendMessage(content, to, conversationId, agentId) {
         if (!to && !conversationId) {
@@ -26285,7 +26523,14 @@ var init_orchestrate2 = __esm({
               }
               const protocolType = params?.protocolType;
               const tier = params?.tier;
-              const result = await orchestrateSpawn(taskId, protocolType, projectRoot, tier);
+              const noWorktree = params?.noWorktree;
+              const result = await orchestrateSpawn(
+                taskId,
+                protocolType,
+                projectRoot,
+                tier,
+                noWorktree
+              );
               return wrapResult(result, "mutate", "orchestrate", operation, startTime);
             }
             case "handoff": {
@@ -50383,6 +50628,10 @@ var spawnCommand2 = defineCommand({
     tier: {
       type: "string",
       description: "Protocol tier: 0 (minimal), 1 (standard), 2 (full), or auto (default \u2014 inferred from role+size+labels via T892 heuristics)"
+    },
+    "no-worktree": {
+      type: "boolean",
+      description: "Skip worktree provisioning for this spawn. The opt-out is logged to the audit log (T1140)."
     }
   },
   async run({ args }) {
@@ -50400,7 +50649,8 @@ var spawnCommand2 = defineCommand({
       {
         taskId: args.taskId,
         protocolType: args.protocol,
-        tier
+        tier,
+        noWorktree: args["no-worktree"] === true
       },
       { command: "orchestrate" }
     );