@cleocode/cleo 2026.4.113 → 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": {
@@ -31868,6 +31927,17 @@ function resolveFormat(opts, defaults) {
 
 // packages/cleo/src/cli/commands/adapter.ts
 init_cli();
+
+// packages/cleo/src/cli/lib/subcommand-guard.ts
+function isSubCommandDispatch(rawArgs, subCommands2) {
+  if (!rawArgs || !subCommands2) return false;
+  const firstArg = rawArgs.find((a) => !a.startsWith("-"));
+  if (!firstArg) return false;
+  if (typeof subCommands2 !== "object") return false;
+  return firstArg in subCommands2;
+}
+
+// packages/cleo/src/cli/commands/adapter.ts
 var listCommand = defineCommand({
   meta: { name: "list", description: "List all discovered provider adapters" },
   async run() {
@@ -31979,7 +32049,8 @@ var adapterCommand = defineCommand({
     activate: activateCommand,
     dispose: disposeCommand
   },
-  async run() {
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
     await dispatchFromCli(
       "query",
       "tools",
@@ -36381,7 +36452,8 @@ var backupCommand = defineCommand({
     import: importCommand,
     inspect: backupInspectSubCommand
   },
-  async run() {
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
     await dispatchFromCli("mutate", "admin", "backup", {}, { command: "backup" });
   }
 });
@@ -39056,7 +39128,8 @@ var daemonCommand = defineCommand({
     stop: stopCommand3,
     status: statusCommand4
   },
-  async run({ args }) {
+  async run({ args, cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
     const cleoDir = args["cleo-dir"] ?? join11(homedir2(), ".cleo");
     await showDaemonStatus(cleoDir, args.json ?? false);
   }
@@ -43025,7 +43098,8 @@ var manifestCommand = defineCommand({
     append: appendCommand,
     archive: archiveCommand2
   },
-  async run({ cmd }) {
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
     await showUsage(cmd);
   }
 });
@@ -50368,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 }) {
@@ -50385,7 +50463,8 @@ var spawnCommand2 = defineCommand({
       {
         taskId: args.taskId,
         protocolType: args.protocol,
-        tier
+        tier,
+        noWorktree: args["no-worktree"] === true
       },
       { command: "orchestrate" }
     );
@@ -51625,7 +51704,8 @@ var providerCommand = defineCommand({
     hooks: hooksCommand,
     inject: injectCommand2
   },
-  async run() {
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
     await dispatchFromCli(
       "query",
       "tools",
@@ -54512,7 +54592,8 @@ var baselineSub = defineCommand({
   subCommands: {
     capture: baselineCaptureSub
   },
-  async run({ args }) {
+  async run({ args, cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
     const jsonMode = args.json === true;
     emitSuccess(
       { message: "Use: cleo sentient baseline capture <sha>" },
@@ -54625,7 +54706,8 @@ var allowlistSub = defineCommand({
     add: allowlistAddSub,
     remove: allowlistRemoveSub
   },
-  async run({ args }) {
+  async run({ args, cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
     const jsonMode = args.json === true;
     emitSuccess(
       { message: "Use: cleo sentient allowlist list|add|remove" },
@@ -54650,7 +54732,8 @@ var sentientCommand = defineCommand({
     baseline: baselineSub,
     allowlist: allowlistSub
   },
-  async run({ args }) {
+  async run({ args, cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
     const projectRoot = resolveProjectRoot7(args.project);
     const jsonMode = args.json === true;
     try {
@@ -55617,7 +55700,8 @@ var skillsCommand2 = defineCommand({
     deps: depsCommand3,
     "spawn-providers": spawnProvidersCommand
   },
-  async run() {
+  async run({ cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
     await dispatchFromCli(
       "query",
       "tools",
@@ -55789,7 +55873,8 @@ var statsCommand6 = defineCommand({
   subCommands: {
     compliance: complianceCommand2
   },
-  async run({ args }) {
+  async run({ args, cmd, rawArgs }) {
+    if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
     await dispatchFromCli(
       "query",
       "admin",