chainlesschain 0.162.183 → 0.162.184

package/src/commands/batch.js

@@ -30,6 +30,14 @@ import {
 } from "../harness/worktree-isolator.js";
 import { findProjectRoot } from "../lib/project-detector.js";
 import executionBroker from "../lib/process-execution-broker/index.js";
+import {
+  createCollaborationRun,
+  createCollaborationRunId,
+  createCollaborationSessionId,
+  finalizeCollaborationRun,
+  updateCollaborationUnit,
+} from "../lib/collaboration-run-store.js";
+import { loadSideEffectLedger } from "../lib/side-effect-ledger-store.js";
 
 export const _processDeps = {
   spawn: executionBroker.spawn.bind(executionBroker),
@@ -86,6 +94,13 @@ export function registerBatchCommand(program) {
     .option("--test <cmd>", "Default test command run in each worktree")
     .option("--merge", "Merge clean, passing branches back to base")
     .option("--model <model>", "Model for agent runs")
+    .option(
+      "--permission-mode <mode>",
+      "Permission mode for each agent unit",
+      "acceptEdits",
+    )
+    .option("--max-turns <n>", "Per-unit agent turn cap")
+    .option("--max-budget-usd <amount>", "Per-unit agent cost cap")
     .option("--json", "Machine-readable JSON output")
     .action(async (options) => {
       process.exitCode = await runBatchCommand(options);
@@ -97,6 +112,18 @@ export async function runBatchCommand(options = {}, _deps = {}) {
   const errLog = _deps.err || ((m) => logger.error(m));
   const repoDir =
     _deps.repoDir || findProjectRoot(process.cwd()) || process.cwd();
+  const collaborationStore =
+    _deps.collaborationStore === false
+      ? null
+      : _deps.collaborationStore || {
+          createRun: createCollaborationRun,
+          createRunId: createCollaborationRunId,
+          createSessionId: createCollaborationSessionId,
+          updateUnit: updateCollaborationUnit,
+          finalizeRun: finalizeCollaborationRun,
+          loadSideEffects: (sessionId) =>
+            loadSideEffectLedger(sessionId, { failIfUnavailable: false }),
+        };
 
   // 1. Resolve the unit list — from a file, or by decomposing a goal.
   let units;
@@ -123,14 +150,53 @@ export async function runBatchCommand(options = {}, _deps = {}) {
     return 4;
   }
 
+  const permissionMode = normalizePermissionMode(options.permissionMode);
+  let governanceRun = null;
+  const governanceByKey = new Map();
+  if (collaborationStore) {
+    try {
+      const runId = collaborationStore.createRunId("batch");
+      governanceRun = collaborationStore.createRun({
+        id: runId,
+        kind: "batch",
+        repoRoot: repoDir,
+        permissionMode,
+        resourceBudget: {
+          maxTurns: options.maxTurns,
+          maxCostUsd: options.maxBudgetUsd,
+          maxTasks: Array.isArray(units) ? units.length : null,
+        },
+        units: (Array.isArray(units) ? units : []).map((unit, index) => {
+          const key = String(unit?.key || `unit-${index + 1}`);
+          const branch = `batch/${sanitize(key)}`;
+          const sessionId = collaborationStore.createSessionId(runId, key);
+          return { key, branch, sessionId };
+        }),
+      });
+      for (const unit of governanceRun.units) {
+        governanceByKey.set(unit.key, unit);
+      }
+    } catch (err) {
+      errLog(`Failed to persist batch governance: ${err.message}`);
+      return 1;
+    }
+  }
+
   // 2. Run the batch with real worktree + agent + git deps.
-  const deps = _deps.batchDeps || {
+  const baseDeps = _deps.batchDeps || {
     createWorktree: (key, branch) => createWorktree(repoDir, branch).path,
     removeWorktree: (worktreePath, opts) =>
       removeWorktree(repoDir, worktreePath, opts),
     runAgent:
       _deps.runAgent ||
-      ((prompt, cwd) => spawnAgent(prompt, cwd, { model: options.model })),
+      ((prompt, cwd, unit) =>
+        spawnAgent(prompt, cwd, {
+          model: options.model,
+          permissionMode,
+          maxTurns: options.maxTurns,
+          maxBudgetUsd: options.maxBudgetUsd,
+          sessionId: governanceByKey.get(unit?.key)?.sessionId,
+        })),
     runTest: _deps.runTest || runTestCommand,
     diffStat: _deps.diffStat || gitDiffStat,
     commit: _deps.commit || gitCommitAll,
@@ -139,6 +205,21 @@ export async function runBatchCommand(options = {}, _deps = {}) {
       mergeWorktree(repoDir, branch, { message }),
     branchFor: (key) => `batch/${sanitize(key)}`,
   };
+  const deps = {
+    ...baseDeps,
+    createWorktree: (key, branch) => {
+      const worktreePath = baseDeps.createWorktree(key, branch);
+      if (governanceRun) {
+        collaborationStore.updateUnit(governanceRun.id, key, {
+          status: "running",
+          branch,
+          worktreePath,
+          startedAt: Date.now(),
+        });
+      }
+      return worktreePath;
+    },
+  };
 
   const onEvent = options.json ? () => {} : (ev) => log(formatEvent(ev));
 
@@ -155,10 +236,61 @@ export async function runBatchCommand(options = {}, _deps = {}) {
       deps,
     );
   } catch (err) {
+    if (governanceRun) {
+      try {
+        collaborationStore.finalizeRun(governanceRun.id, "failed");
+      } catch {
+        /* retain the running record for diagnosis */
+      }
+    }
     errLog(`Batch failed: ${err.message}`);
     return 1;
   }
 
+  if (governanceRun) {
+    try {
+      for (const record of outcome.units) {
+        const unit = governanceByKey.get(record.key);
+        let sideEffects = null;
+        if (unit?.sessionId) {
+          try {
+            sideEffects = collaborationStore.loadSideEffects(unit.sessionId);
+          } catch {
+            /* side-effect summary is additive */
+          }
+        }
+        const completed = new Set(["done", "no-changes"]).has(record.status);
+        collaborationStore.updateUnit(governanceRun.id, record.key, {
+          status: completed ? "completed" : record.status,
+          endedAt: Date.now(),
+          ...(sideEffects ? { sideEffects } : {}),
+        });
+      }
+      const failed = outcome.summary.testFailed + outcome.summary.errored > 0;
+      const finalized = collaborationStore.finalizeRun(
+        governanceRun.id,
+        failed ? "failed" : "completed",
+      );
+      outcome.governance = {
+        runId: finalized.id,
+        owner: finalized.owner,
+        status: finalized.status,
+        permissionMode: finalized.permissionMode,
+        resourceBudget: finalized.resourceBudget,
+        units: finalized.units.map((unit) => ({
+          key: unit.key,
+          owner: unit.owner,
+          sessionId: unit.sessionId,
+          status: unit.status,
+          sideEffects: unit.sideEffects,
+        })),
+      };
+    } catch (err) {
+      errLog(`Failed to finalize batch governance: ${err.message}`);
+      return 1;
+    }
+  }
+
   if (options.json) {
     log(JSON.stringify(outcome, null, 2));
   } else {
@@ -187,6 +319,21 @@ function sanitize(key) {
   return String(key).replace(/[^a-zA-Z0-9._-]/g, "-");
 }
 
+function normalizePermissionMode(value) {
+  const mode = String(value || "acceptEdits");
+  return new Set([
+    "manual",
+    "auto",
+    "dontAsk",
+    "default",
+    "plan",
+    "acceptEdits",
+    "bypassPermissions",
+  ]).has(mode)
+    ? mode
+    : "acceptEdits";
+}
+
 function spawnBatchProcess(command, args, options, origin) {
   return _processDeps.spawn(command, args, {
     ...options,
@@ -212,14 +359,18 @@ function spawnAgent(prompt, cwd, opts = {}) {
     const args = [
       BIN,
       "agent",
-      "-p",
-      prompt,
       "--permission-mode",
-      "acceptEdits",
+      normalizePermissionMode(opts.permissionMode),
       "--output-format",
       "text",
     ];
     if (opts.model) args.push("--model", opts.model);
+    if (opts.sessionId) args.push("--session", opts.sessionId);
+    if (Number(opts.maxTurns) > 0)
+      args.push("--max-turns", String(opts.maxTurns));
+    if (Number(opts.maxBudgetUsd) > 0) {
+      args.push("--max-budget-usd", String(opts.maxBudgetUsd));
+    }
     const child = spawnBatchProcess(
       process.execPath,
       args,
@@ -233,6 +384,10 @@ function spawnAgent(prompt, cwd, opts = {}) {
     );
     let err = "";
     child.stderr?.on("data", (d) => (err += d.toString("utf8")));
+    if (child.stdin) {
+      child.stdin.on("error", () => {});
+      child.stdin.end(String(prompt || ""));
+    }
     child.on("error", (e) => reject(new Error(e.message)));
     child.on("close", (code) =>
       code === 0

package/src/commands/plugin.js

@@ -37,7 +37,12 @@ import {
  * (for --json folding) or null when the plugin declares nothing / can't be
  * resolved.
  */
-async function resolvePluginCapabilityNotice(name, scope, cwd) {
+async function resolvePluginCapabilityNotice(
+  name,
+  scope,
+  cwd,
+  { strict = false } = {},
+) {
   try {
     const { discoverPlugins } = await import("../lib/plugin-runtime/scopes.js");
     const { describeCapabilities } =
@@ -46,7 +51,12 @@ async function resolvePluginCapabilityNotice(name, scope, cwd) {
     const installed = discoverPlugins({ cwd, skipPolicy: true }).find(
       (p) => p.name === name && p.scope === scope,
     );
-    if (!installed) return null;
+    if (!installed) {
+      if (strict) {
+        throw new Error(`${name} is not discoverable at ${scope} scope`);
+      }
+      return null;
+    }
     const declared = installed.manifest?.capabilities;
     if (!declared || consent.capabilitiesAreEmpty(declared)) return null;
     const entry = consent.loadConsentStore()[`${scope}:${name}`] || null;
@@ -57,7 +67,12 @@ async function resolvePluginCapabilityNotice(name, scope, cwd) {
       reason: status.reason,
       added: status.added,
     };
-  } catch {
+  } catch (error) {
+    if (strict) {
+      throw new Error(
+        `installed plugin capability validation failed: ${error.message}`,
+      );
+    }
     return null; // capability rendering is advisory — never break an install
   }
 }
@@ -1568,7 +1583,8 @@ export function registerPluginCommand(program) {
     )
     .option("--json", "Output as JSON")
     .action(async (source, options) => {
-      const { updatePlugin } = await import("../lib/plugin-runtime/install.js");
+      const { updatePlugin, finalizePluginUpdate, rollbackPluginUpdate } =
+        await import("../lib/plugin-runtime/install.js");
       let installSource = source;
       let integritySha = null;
       let sourceMetadata = null;
@@ -1647,8 +1663,9 @@ export function registerPluginCommand(program) {
               requireTrustedKey: requiresManagedSignature,
             }
           : null;
+      let res = null;
       try {
-        const res = updatePlugin(installSource, {
+        res = updatePlugin(installSource, {
           scope: options.scope,
           cwd: process.cwd(),
           force: options.force,
@@ -1656,11 +1673,13 @@ export function registerPluginCommand(program) {
           sourceMetadata,
           managedPolicy: managed,
           policySource: options.registry || source,
+          transactional: true,
         });
         const upgradeNotice = await resolvePluginCapabilityNotice(
           res.name,
           options.scope,
           process.cwd(),
+          { strict: true },
         );
         if (res.updated || res.reinstalled)
           await auditPluginInstall(
@@ -1670,19 +1689,53 @@ export function registerPluginCommand(program) {
             upgradeNotice,
           );
 
+        let capabilitiesGranted = false;
         if (options.json) {
-          let capabilitiesGranted = false;
-          if (
-            options.grantCapabilities &&
-            upgradeNotice &&
-            !upgradeNotice.consented
-          ) {
+          if (options.grantCapabilities && upgradeNotice?.consented === false) {
             capabilitiesGranted = await grantInstalledPluginCapabilities(
               res.name,
               options.scope,
               process.cwd(),
             );
           }
+        } else {
+          capabilitiesGranted = await applyCapabilityConsentGate(
+            res.name,
+            options.scope,
+            upgradeNotice,
+            process.cwd(),
+            {
+              grant: options.grantCapabilities === true,
+              interactive: Boolean(process.stdin.isTTY),
+            },
+          );
+        }
+
+        const changed = res.updated || res.reinstalled;
+        const consentBlocked =
+          changed &&
+          upgradeNotice?.consented === false &&
+          capabilitiesGranted !== true;
+        const rollbackReason = consentBlocked
+          ? options.grantCapabilities
+            ? "capability_consent_failed"
+            : "capability_consent_required"
+          : null;
+        let activationStatus = changed ? "activated" : "unchanged";
+        let rollbackVersion = null;
+        let cleanupPending = false;
+        if (rollbackReason) {
+          const recovery = rollbackPluginUpdate(res);
+          if (!recovery.rolledBack) {
+            throw new Error("upgrade rollback transaction was unavailable");
+          }
+          activationStatus = "rolled_back";
+          rollbackVersion = recovery.version;
+        } else {
+          cleanupPending = finalizePluginUpdate(res).cleanupPending === true;
+        }
+
+        if (options.json) {
           console.log(
             JSON.stringify(
               {
@@ -1690,6 +1743,10 @@ export function registerPluginCommand(program) {
                 scope: options.scope,
                 capabilities: upgradeNotice,
                 capabilitiesGranted,
+                activationStatus,
+                rollbackVersion,
+                rollbackReason,
+                cleanupPending,
               },
               null,
               2,
@@ -1698,7 +1755,14 @@ export function registerPluginCommand(program) {
           return;
         }
 
-        if (res.updated) {
+        if (activationStatus === "rolled_back") {
+          logger.warn(
+            `Upgrade not activated: ${rollbackReason.replaceAll("_", " ")}; ` +
+              (rollbackVersion
+                ? `restored ${res.name} v${rollbackVersion}`
+                : `removed the rejected ${res.name} v${res.version} install`),
+          );
+        } else if (res.updated) {
           logger.success(
             `Updated ${res.name}: ${res.previousVersion ? `v${res.previousVersion} → ` : ""}v${res.version} (${options.scope} scope)`,
           );
@@ -1711,22 +1775,21 @@ export function registerPluginCommand(program) {
             `${res.name} is already up to date at v${res.version} (use --force to reinstall)`,
           );
         }
-        // Surface the (possibly widened) capability set + re-consent hint. An
-        // upgrade that adds a capability shows a `⚠ capability consent required`
-        // notice diffed against the prior consent, then either auto-grants
-        // (--grant-capabilities) or blocks interactively to re-consent now.
-        await applyCapabilityConsentGate(
-          res.name,
-          options.scope,
-          upgradeNotice,
-          process.cwd(),
-          {
-            grant: options.grantCapabilities === true,
-            interactive: Boolean(process.stdin.isTTY),
-          },
-        );
       } catch (err) {
-        logger.error(`Upgrade failed: ${err.message}`);
+        let recoveryNote = "";
+        if (res) {
+          try {
+            const recovery = rollbackPluginUpdate(res);
+            if (recovery.rolledBack) {
+              recoveryNote = recovery.version
+                ? `; restored v${recovery.version}`
+                : "; removed the rejected install";
+            }
+          } catch (recoveryError) {
+            recoveryNote = `; automatic recovery failed: ${recoveryError.message}`;
+          }
+        }
+        logger.error(`Upgrade failed: ${err.message}${recoveryNote}`);
         process.exitCode = 1;
       }
     });

package/src/commands/session.js

@@ -1334,6 +1334,7 @@ export function registerSessionCommand(program) {
     "tool",
     "mcp",
     "plugin",
+    "retry",
     "model",
   ];
 
@@ -1347,9 +1348,19 @@ export function registerSessionCommand(program) {
       logger.log(
         `  ${chalk.gray(String(label).padEnd(28))} in=${r.inputTokens}  out=${r.outputTokens}  total=${chalk.cyan(r.totalTokens.toLocaleString())}  calls=${r.calls}`,
       );
+    const elapsed = (ms) => {
+      const value = Math.max(0, Number(ms) || 0);
+      if (value < 1000) return `${Math.round(value)}ms`;
+      return `${(value / 1000).toFixed(2)}s`;
+    };
     const toolRow = (label, r) =>
       logger.log(
-        `  ${chalk.gray(String(label).padEnd(28))} calls=${r.calls}  errors=${r.errors}  turnTokens≈${chalk.cyan((r.turnTokens || 0).toLocaleString())}`,
+        `  ${chalk.gray(String(label).padEnd(28))} calls=${r.calls}  errors=${r.errors}` +
+          (r.retries != null ? `  retries=${r.retries}` : "") +
+          (r.timedCalls != null
+            ? `  observed=${elapsed(r.durationMs)} (${r.timedCalls} timed)`
+            : "") +
+          `  turnTokens≈${chalk.cyan((r.turnTokens || 0).toLocaleString())}`,
       );
     const empty = (what) => logger.log(chalk.gray(`  (no ${what} recorded)`));
 
@@ -1416,6 +1427,25 @@ export function registerSessionCommand(program) {
         );
         return;
       }
+      case "retry": {
+        const retry = a.retries || null;
+        if (!retry || !retry.totalRetries)
+          return empty("automatic LLM retries");
+        logger.log(
+          `  ${chalk.gray("all".padEnd(28))} retries=${retry.totalRetries}  failedAttemptTime=${chalk.cyan(elapsed(retry.durationMs))}`,
+        );
+        for (const r of retry.byReason || []) {
+          logger.log(
+            `  ${chalk.gray(String(r.reason || "unknown").padEnd(28))} retries=${r.retries}  failedAttemptTime=${chalk.cyan(elapsed(r.durationMs))}`,
+          );
+        }
+        for (const r of retry.byModel || []) {
+          logger.log(
+            `  ${chalk.gray(`${r.provider || "?"}/${r.model || "?"}`.padEnd(28))} retries=${r.retries}  failedAttemptTime=${chalk.cyan(elapsed(r.durationMs))}`,
+          );
+        }
+        return;
+      }
       default:
         break;
     }