chainlesschain 0.162.183 → 0.162.185

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;
     }

package/src/commands/team.js

@@ -24,14 +24,48 @@ import { TeamWorktreeCoordinator } from "../lib/agent-team/team-worktree.js";
 import { TeamBudget } from "../lib/agent-team/team-budget.js";
 import { TeamMailbox } from "../lib/agent-team/team-mailbox.js";
 import { executionBroker } from "../lib/process-execution-broker/index.js";
+import {
+  createCollaborationRun,
+  createCollaborationRunId,
+  createCollaborationSessionId,
+  finalizeCollaborationRun,
+  readCollaborationRun,
+  updateCollaborationUnit,
+} from "../lib/collaboration-run-store.js";
+import { loadSideEffectLedger } from "../lib/side-effect-ledger-store.js";
 
 export const _deps = {
   spawn: (...args) => executionBroker.spawn(...args),
+  collaborationStore: {
+    createRun: createCollaborationRun,
+    createRunId: createCollaborationRunId,
+    createSessionId: createCollaborationSessionId,
+    readRun: readCollaborationRun,
+    updateUnit: updateCollaborationUnit,
+    finalizeRun: finalizeCollaborationRun,
+    loadSideEffects: (sessionId) =>
+      loadSideEffectLedger(sessionId, { failIfUnavailable: false }),
+  },
 };
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const BIN = path.resolve(__dirname, "..", "..", "bin", "chainlesschain.js");
 
+function normalizePermissionMode(value) {
+  const mode = String(value || "acceptEdits");
+  return new Set([
+    "manual",
+    "auto",
+    "dontAsk",
+    "default",
+    "plan",
+    "acceptEdits",
+    "bypassPermissions",
+  ]).has(mode)
+    ? mode
+    : "acceptEdits";
+}
+
 /** Load + validate a task-graph file into a registry (throws on bad input). */
 export function loadRegistry(file, { ttlMs } = {}) {
   const abs = path.resolve(process.cwd(), file);
@@ -136,6 +170,13 @@ export function spawnAgent(prompt, cwd, opts = {}) {
       "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 = _deps.spawn(process.execPath, args, {
       cwd,
       env: { ...process.env, CLAUDECODE: "1" },
@@ -162,12 +203,15 @@ export function spawnAgent(prompt, cwd, opts = {}) {
 
 /** Real executor: hand a task's `prompt` to a headless `cc agent -p` in cwd. */
 function makeAgentRunTask(opts = {}) {
-  return function runTask({ task }) {
+  return function runTask({ key, task }) {
     const prompt = task.metadata?.prompt || task?.prompt;
     if (!prompt) {
       throw new Error(`task "${task.key}" has no \`prompt\` to --agent`);
     }
-    return spawnAgent(prompt, process.cwd(), opts);
+    return spawnAgent(prompt, process.cwd(), {
+      ...opts,
+      sessionId: opts.sessionIdForTask?.(key) || null,
+    });
   };
 }
 
@@ -220,6 +264,13 @@ export function registerTeamCommand(program, { logger } = {}) {
       "Hand each task's `prompt` to a headless cc agent (real)",
     )
     .option("--model <model>", "Model for --agent runs")
+    .option(
+      "--permission-mode <mode>",
+      "Permission mode for each --agent task",
+      "acceptEdits",
+    )
+    .option("--agent-max-turns <n>", "Per-agent task turn cap")
+    .option("--agent-max-budget-usd <amount>", "Per-agent task cost cap")
     .option(
       "--worktree",
       "Run each task's `command` in its own git worktree (parallel isolation)",
@@ -272,6 +323,7 @@ export function registerTeamCommand(program, { logger } = {}) {
           : null,
       });
       let priorMembers = [];
+      let priorCollaborationRunId = null;
       try {
         // Resume from a prior (possibly crashed) run's state: completed tasks
         // stay COMPLETED, and any lease left dangling by a crash is reclaimed so
@@ -297,6 +349,7 @@ export function registerTeamCommand(program, { logger } = {}) {
                 },
               });
             priorMembers = Array.isArray(snap.members) ? snap.members : [];
+            priorCollaborationRunId = snap.collaborationRunId || null;
           }
           // A teammate whose lease is still dangling here crashed last run — its
           // task is about to be reclaimed, so report it LOST before the sweep.
@@ -331,6 +384,86 @@ export function registerTeamCommand(program, { logger } = {}) {
         return;
       }
 
+      const permissionMode = normalizePermissionMode(options.permissionMode);
+      let priorCollaborationRun = null;
+      if (priorCollaborationRunId) {
+        try {
+          priorCollaborationRun = _deps.collaborationStore.readRun(
+            priorCollaborationRunId,
+          );
+        } catch {
+          // A malformed/foreign v3 pointer must not block registry recovery.
+          priorCollaborationRun = null;
+        }
+      }
+      const priorUnits = new Map(
+        (priorCollaborationRun?.units || []).map((unit) => [unit.key, unit]),
+      );
+      let collaborationRun;
+      try {
+        const runId = _deps.collaborationStore.createRunId("team");
+        collaborationRun = _deps.collaborationStore.createRun({
+          id: runId,
+          kind: "team",
+          repoRoot: process.cwd(),
+          permissionMode: options.agent ? permissionMode : "default",
+          resourceBudget: {
+            maxTurns: options.agentMaxTurns,
+            maxCostUsd: options.agentMaxBudgetUsd,
+            maxTasks: options.maxTasks,
+            maxTokens: options.maxTokens,
+            maxWallMs: options.maxWall
+              ? Math.max(1, Number(options.maxWall)) * 1000
+              : null,
+          },
+          units: reg.list().map((task) => ({
+            key: task.key,
+            branch: options.worktree ? `team/${task.key}` : null,
+            sessionId: options.agent
+              ? priorUnits.get(task.key)?.sessionId ||
+                _deps.collaborationStore.createSessionId(runId, task.key)
+              : null,
+            status:
+              String(task.status || "").toLowerCase() === "completed"
+                ? "completed"
+                : "pending",
+          })),
+        });
+      } catch (err) {
+        (log.error || console.error)(
+          `Failed to persist team governance: ${err.message}`,
+        );
+        process.exitCode = 1;
+        return;
+      }
+      const collaborationUnits = new Map(
+        collaborationRun.units.map((unit) => [unit.key, unit]),
+      );
+      const settleGovernance = (key, status, extra = {}) => {
+        const unit = collaborationUnits.get(key);
+        let sideEffects = null;
+        if (unit?.sessionId) {
+          try {
+            sideEffects = _deps.collaborationStore.loadSideEffects(
+              unit.sessionId,
+            );
+          } catch {
+            /* side-effect summary is additive */
+          }
+        }
+        const updated = _deps.collaborationStore.updateUnit(
+          collaborationRun.id,
+          key,
+          {
+            status,
+            ...extra,
+            ...(sideEffects ? { sideEffects } : {}),
+          },
+        );
+        const next = updated.units.find((candidate) => candidate.key === key);
+        if (next) collaborationUnits.set(key, next);
+      };
+
       // Persist a snapshot after each task settles so a crash mid-run is
       // resumable (persist-after-run alone would lose everything on a crash).
       // v2 bundles registry + mailbox + budget + member lifecycle so a resume
@@ -347,11 +480,12 @@ export function registerTeamCommand(program, { logger } = {}) {
             tmp,
             JSON.stringify(
               {
-                version: 2,
+                version: 3,
                 registry: reg.snapshot(),
                 mailbox: mailbox.snapshot(),
                 budget: budget.snapshot(),
                 members: runnerRef ? runnerRef.members() : priorMembers,
+                collaborationRunId: collaborationRun.id,
               },
               null,
               2,
@@ -379,8 +513,20 @@ export function registerTeamCommand(program, { logger } = {}) {
         coord = new TeamWorktreeCoordinator(process.cwd(), {
           sparsePaths: splitList(options.sparsePaths),
           symlinkDirectories: splitList(options.symlinkDirs),
+          onWorktree: ({ key, branch, path: worktreePath }) => {
+            settleGovernance(key, "running", {
+              branch,
+              worktreePath,
+              startedAt: Date.now(),
+            });
+          },
         });
         if (!coord.isGitRepo()) {
+          try {
+            _deps.collaborationStore.finalizeRun(collaborationRun.id, "failed");
+          } catch {
+            /* the original validation error remains primary */
+          }
           (log.error || console.error)(
             "--worktree requires a git repository (run inside one)",
           );
@@ -397,7 +543,13 @@ export function registerTeamCommand(program, { logger } = {}) {
               if (!prompt) {
                 throw new Error(`task "${key}" has no \`prompt\` to --agent`);
               }
-              await spawnAgent(prompt, cwd, { model: options.model });
+              await spawnAgent(prompt, cwd, {
+                model: options.model,
+                permissionMode,
+                maxTurns: options.agentMaxTurns,
+                maxBudgetUsd: options.agentMaxBudgetUsd,
+                sessionId: collaborationUnits.get(key)?.sessionId,
+              });
             },
           });
         } else {
@@ -412,7 +564,13 @@ export function registerTeamCommand(program, { logger } = {}) {
         );
         runTask = makeShellRunTask(log);
       } else if (options.agent)
-        runTask = makeAgentRunTask({ model: options.model });
+        runTask = makeAgentRunTask({
+          model: options.model,
+          permissionMode,
+          maxTurns: options.agentMaxTurns,
+          maxBudgetUsd: options.agentMaxBudgetUsd,
+          sessionIdForTask: (key) => collaborationUnits.get(key)?.sessionId,
+        });
       else runTask = async () => ({ dryRun: true });
 
       // Optional workflow tracing (Claude-Code 2.1.202 parity): every task
@@ -439,6 +597,19 @@ export function registerTeamCommand(program, { logger } = {}) {
         mailbox,
         recorder,
         onEvent: (e) => {
+          if (e.type === "task:claimed") {
+            settleGovernance(e.key, "running", {
+              startedAt: Date.now(),
+            });
+          } else if (e.type === "task:completed") {
+            settleGovernance(e.key, "completed", {
+              endedAt: Date.now(),
+            });
+          } else if (e.type === "task:failed") {
+            settleGovernance(e.key, e.retry ? "pending" : "failed", {
+              endedAt: e.retry ? null : Date.now(),
+            });
+          }
           if (options.json) console.log(JSON.stringify(e));
           else if (e.type === "task:claimed")
             (log.info || console.log)(`  → ${e.key} [${e.holder}]`);
@@ -459,8 +630,43 @@ export function registerTeamCommand(program, { logger } = {}) {
       runner.seedMembers(priorMembers);
       runnerRef = runner;
 
-      const summary = await runner.run();
+      let summary;
+      try {
+        summary = await runner.run();
+      } catch (err) {
+        try {
+          _deps.collaborationStore.finalizeRun(collaborationRun.id, "failed");
+        } catch {
+          /* retain the original runner failure */
+        }
+        throw err;
+      }
       persist();
+      try {
+        // Reconcile from the authoritative registry after all event callbacks.
+        // This closes any best-effort onEvent write that failed mid-run.
+        for (const task of reg.list()) {
+          const state = String(task.status || "").toLowerCase();
+          const status =
+            state === "completed"
+              ? "completed"
+              : state === "cancelled" || state === "pending"
+                ? "cancelled"
+                : "failed";
+          settleGovernance(task.key, status, {
+            endedAt: Date.now(),
+          });
+        }
+        _deps.collaborationStore.finalizeRun(
+          collaborationRun.id,
+          summary.done ? "completed" : "failed",
+        );
+      } catch (err) {
+        (log.error || console.error)(
+          `Failed to finalize team governance: ${err.message}`,
+        );
+        process.exitCode = 1;
+      }
 
       if (recorder && options.otlp) {
         try {

package/src/data/changelog.json

@@ -1,6 +1,32 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.162.185",
+      "cliVersions": ["0.162.184", "0.162.185"],
+      "date": "2026-07-29",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed — cc CLI 0.162.185: sandbox authority and Hook runtime hardening",
+          "body": "> `chainlesschain` **0.162.184 → 0.162.185** (2026-07-29).\n> CLI-only release; `@chainlesschain/personal-data-hub` remains **0.4.57**\n> and `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Complete strong execution routes**: policy-bearing Plugin bins now retain\n  pinned identity through async/background launches, while generic background,\n  CLI PTY, and Desktop project PTY enter the same fail-closed Linux\n  filesystem/network boundary.\n- **Authority and teardown integrity**: every actual bind source requires\n  private mount propagation, parent-side pinned descriptors close after spawn,\n  raw PTY masters invalidate on close/error, and attached sessions terminate\n  their POSIX process group or Windows process tree.\n- **Trusted project and Hook roots**: Desktop V8 migrations quarantine\n  unattested project roots and prevent remote metadata from acquiring local PTY\n  authority. Hooks v2 binds canonical host roots to generation-aware opaque\n  durable identities across headless, stream, REPL, and WebSocket turns.\n- **Hook process reliability**: completed Hook subprocesses preserve their\n  status-0 output and status-2 block protocol when Node reports a late stdin\n  `EPIPE`; missing exit status and unrelated spawn errors still fail closed.\n- **Single Broker runtime graph**: Hooks v2 now registers its default runtime\n  as the Broker event sink without a reverse ESM load, preventing a duplicate\n  CredentialTransport Worker, Unix listener, and steady-state file descriptors.\n- **Release validation gate**: publication requires this exact release commit\n  to pass `CLI CI` and `CLI Strict Sandbox` on their configured Ubuntu,\n  Windows, and macOS runners; local tests remain supplementary."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.162.184",
+      "cliVersions": ["0.4.75", "0.37.36", "0.162.183", "0.162.184"],
+      "date": "2026-07-28",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added — cc CLI 0.162.184 + IDE retry, collaboration, and recovery governance",
+          "body": "> `chainlesschain` **0.162.183 → 0.162.184**, VS Code\n> **0.37.35 → 0.37.36**, and JetBrains **0.4.74 → 0.4.75** (2026-07-28).\n> `@chainlesschain/personal-data-hub` remains **0.4.57** and\n> `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **Measured retry and tool attribution**: compact transcripts now record\n  bounded tool durations, observed same-turn retries, and secret-free streaming\n  LLM retry reasons with actual provider/model identity. CLI and both IDE usage\n  reports consume the same authoritative aggregates.\n- **Durable team/batch governance**: collaboration runs persist bounded\n  owner/session, permission mode, resource budget, lifecycle, and side-effect\n  counts without prompts, argv, tool arguments, output, or credentials. IDE\n  worktree views project these records as managed tasks without exposing\n  background attach/stop controls.\n- **Transactional plugin upgrades**: staged installs revalidate manifests and\n  signed SBOMs before atomic activation. Failed copies, load checks,\n  post-install handling, or declined capability widening restore the prior\n  active version; forced same-version reinstalls restore the exact old bytes.\n- **IDE activation feedback**: VS Code and JetBrains parse controlled\n  `activated / rolled_back / unchanged` results, reload live sessions only\n  after activation, and require explicit user approval before retrying with a\n  widened capability grant.\n- **Process-boundary hardening**: plugin hooks, MCP/LSP servers, monitors, and\n  native bins retain sandbox policy through the centralized execution broker;\n  Linux bubblewrap setup fails closed with bounded diagnostics.\n- **Release validation**: publication requires this exact release commit to\n  pass CLI CI and CLI Strict Sandbox on Linux, Windows, and macOS plus the\n  packaged VSIX and JetBrains unit/build/Remote Robot gates."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.162.183",