@cleocode/cleo 2026.4.114 → 2026.4.115

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,
@@ -26285,7 +26337,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 +50442,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 +50463,8 @@ var spawnCommand2 = defineCommand({
       {
         taskId: args.taskId,
         protocolType: args.protocol,
-        tier
+        tier,
+        noWorktree: args["no-worktree"] === true
       },
       { command: "orchestrate" }
     );