chainlesschain 0.162.182 → 0.162.183

package/src/commands/plugin.js

@@ -20,10 +20,8 @@ import {
   removePlugin,
   updatePlugin,
   getPluginSettings,
-  setPluginSetting,
   searchRegistry,
   listRegistry,
-  registerInMarketplace,
   getPluginSummary,
   installPluginSkills,
   removePluginSkills,
@@ -404,8 +402,28 @@ export function registerPluginCommand(program) {
     .command("enable")
     .description("Enable a plugin")
     .argument("<name>", "Plugin name")
-    .action(async (name) => {
+    .option(
+      "--scope <scope>",
+      "Enable the unified-runtime install at this scope (user|project|local)",
+    )
+    .option("--json", "Output unified-runtime result as JSON")
+    .action(async (name, options) => {
       try {
+        if (options.scope) {
+          const { setPluginEnabled } =
+            await import("../lib/plugin-runtime/install.js");
+          const result = setPluginEnabled(name, true, {
+            scope: options.scope,
+            cwd: process.cwd(),
+          });
+          if (options.json) console.log(JSON.stringify(result, null, 2));
+          else {
+            logger.success(
+              `Enabled ${name} (${options.scope} scope). Reload active plugin sessions to apply the change.`,
+            );
+          }
+          return;
+        }
         enforcePluginPolicy(
           { name, action: "enable" },
           loadPluginManagedPolicy(),
@@ -436,8 +454,28 @@ export function registerPluginCommand(program) {
     .command("disable")
     .description("Disable a plugin")
     .argument("<name>", "Plugin name")
-    .action(async (name) => {
+    .option(
+      "--scope <scope>",
+      "Disable the unified-runtime install at this scope (user|project|local)",
+    )
+    .option("--json", "Output unified-runtime result as JSON")
+    .action(async (name, options) => {
       try {
+        if (options.scope) {
+          const { setPluginEnabled } =
+            await import("../lib/plugin-runtime/install.js");
+          const result = setPluginEnabled(name, false, {
+            scope: options.scope,
+            cwd: process.cwd(),
+          });
+          if (options.json) console.log(JSON.stringify(result, null, 2));
+          else {
+            logger.success(
+              `Disabled ${name} (${options.scope} scope). Reload active plugin sessions to apply the change.`,
+            );
+          }
+          return;
+        }
         const ctx = await bootstrap({ verbose: program.opts().verbose });
         if (!ctx.db) {
           logger.error("Database not available");
@@ -860,6 +898,7 @@ export function registerPluginCommand(program) {
       // plugin name) resolves to a git source the installer already handles.
       let installSource = source;
       let integritySha = null;
+      let sourceMetadata = null;
       const { isRemoteSource, resolveRemoteSource } =
         await import("../lib/plugin-runtime/remote-source.js");
       if (options.registry || isRemoteSource(source)) {
@@ -883,6 +922,19 @@ export function registerPluginCommand(program) {
           });
           installSource = resolved.source;
           integritySha = resolved.sha256;
+          sourceMetadata = {
+            type: "registry",
+            source: url,
+            registry: url,
+            package: name || source,
+            resolvedSource: resolved.source,
+            ref:
+              (typeof resolved.source === "string" &&
+                resolved.source.includes("#") &&
+                resolved.source.slice(resolved.source.indexOf("#") + 1)) ||
+              null,
+            offline: resolved.fromCache === true,
+          };
           if (resolved.fromCache) {
             logger.warn(
               chalk.yellow(
@@ -897,13 +949,31 @@ export function registerPluginCommand(program) {
         }
       }
 
+      let managed = null;
+      try {
+        managed = loadPluginManagedPolicy();
+      } catch (err) {
+        logger.error(`Managed plugin policy is invalid: ${err.message}`);
+        process.exitCode = 1;
+        return;
+      }
+      const requiresManagedSignature =
+        managed?.requireSignedPlugins === true ||
+        managed?.requireSignedPlugins === "require";
       const signature =
-        options.sha256 || options.signature || options.publicKey || integritySha
+        options.sha256 ||
+        options.signature ||
+        options.publicKey ||
+        integritySha ||
+        requiresManagedSignature
           ? {
               sha256: options.sha256 || integritySha,
               signatureFile: options.signature,
               publicKeyFile: options.publicKey,
-              requireSignature: Boolean(options.signature),
+              requireSignature:
+                Boolean(options.signature) || requiresManagedSignature,
+              trustedKeySha256: managed?.trustedPluginKeySha256 || null,
+              requireTrustedKey: requiresManagedSignature,
             }
           : null;
       try {
@@ -912,6 +982,9 @@ export function registerPluginCommand(program) {
           cwd: process.cwd(),
           force: options.force === true,
           signature,
+          sourceMetadata,
+          managedPolicy: managed,
+          policySource: options.registry || source,
         });
         const capNotice = await resolvePluginCapabilityNotice(
           res.name,
@@ -1060,8 +1133,21 @@ export function registerPluginCommand(program) {
         const trust = isPluginTrusted(r)
           ? chalk.green("trusted")
           : chalk.yellow("untrusted");
+        const state =
+          r.enabled === false
+            ? chalk.yellow("disabled")
+            : chalk.green("enabled");
+        const signed = r.integrity?.signature?.verified
+          ? chalk.green("signed")
+          : chalk.gray("unsigned");
+        const policy =
+          r.policy?.allowed === false
+            ? chalk.red("policy-blocked")
+            : r.policy?.managed
+              ? chalk.cyan("managed")
+              : "";
         logger.log(
-          `  ${ok} ${chalk.cyan(r.name)} v${r.version} ${chalk.gray(`[${r.scope}]`)} ${trust}`,
+          `  ${ok} ${chalk.cyan(r.name)} v${r.version} ${chalk.gray(`[${r.scope}]`)} ${state} ${trust} ${signed}${policy ? ` ${policy}` : ""}`,
         );
       }
     });
@@ -1456,22 +1542,162 @@ export function registerPluginCommand(program) {
   plugin
     .command("upgrade <source>")
     .description(
-      "Update a runtime plugin from its source (local dir or git); repoints .active",
+      "Update a runtime plugin from its pinned local, git, or registry source; repoints .active",
     )
     .option("--scope <scope>", `Scope to update in (${SCOPES})`, "user")
     .option("--force", "Reinstall even if the version is unchanged")
+    .option("--sha256 <hex>", "Expected SHA-256 of the manifest file")
+    .option("--signature <path>", "Detached Ed25519 signature of the manifest")
+    .option("--public-key <path>", "Public key for signature verification")
+    .option(
+      "--registry <url>",
+      "Resolve <source> as a plugin NAME in this registry URL",
+    )
+    .option(
+      "--name <plugin>",
+      "Plugin name to select from a multi-plugin registry",
+    )
+    .option("--token <token>", "Bearer token for a private registry")
+    .option(
+      "--allow-insecure-registry",
+      "Allow a plain-HTTP registry URL (MITM risk — trusted networks only)",
+    )
     .option(
       "--grant-capabilities",
       "Grant any newly declared capabilities during the upgrade (no separate consent step)",
     )
+    .option("--json", "Output as JSON")
     .action(async (source, options) => {
       const { updatePlugin } = await import("../lib/plugin-runtime/install.js");
+      let installSource = source;
+      let integritySha = null;
+      let sourceMetadata = null;
+      const { isRemoteSource, resolveRemoteSource } =
+        await import("../lib/plugin-runtime/remote-source.js");
+      if (options.registry || isRemoteSource(source)) {
+        const url = options.registry || source;
+        const name = options.registry ? source : options.name;
+        let config = null;
+        try {
+          const cm = await import("../lib/config-manager.js");
+          config = cm.loadConfig();
+        } catch {
+          config = null;
+        }
+        try {
+          const resolved = await resolveRemoteSource(url, {
+            name,
+            token: options.token,
+            config,
+            allowInsecure: options.allowInsecureRegistry === true,
+          });
+          installSource = resolved.source;
+          integritySha = resolved.sha256;
+          sourceMetadata = {
+            type: "registry",
+            source: url,
+            registry: url,
+            package: name || source,
+            resolvedSource: resolved.source,
+            ref:
+              (typeof resolved.source === "string" &&
+                resolved.source.includes("#") &&
+                resolved.source.slice(resolved.source.indexOf("#") + 1)) ||
+              null,
+            offline: resolved.fromCache === true,
+          };
+          if (resolved.fromCache && !options.json) {
+            logger.warn(
+              chalk.yellow(
+                "  ⚠ registry unreachable — using cached copy (offline)",
+              ),
+            );
+          }
+        } catch (err) {
+          logger.error(`Registry resolution failed: ${err.message}`);
+          process.exitCode = 1;
+          return;
+        }
+      }
+
+      let managed = null;
       try {
-        const res = updatePlugin(source, {
+        managed = loadPluginManagedPolicy();
+      } catch (err) {
+        logger.error(`Managed plugin policy is invalid: ${err.message}`);
+        process.exitCode = 1;
+        return;
+      }
+      const requiresManagedSignature =
+        managed?.requireSignedPlugins === true ||
+        managed?.requireSignedPlugins === "require";
+      const signature =
+        options.sha256 ||
+        options.signature ||
+        options.publicKey ||
+        integritySha ||
+        requiresManagedSignature
+          ? {
+              sha256: options.sha256 || integritySha,
+              signatureFile: options.signature,
+              publicKeyFile: options.publicKey,
+              requireSignature:
+                Boolean(options.signature) || requiresManagedSignature,
+              trustedKeySha256: managed?.trustedPluginKeySha256 || null,
+              requireTrustedKey: requiresManagedSignature,
+            }
+          : null;
+      try {
+        const res = updatePlugin(installSource, {
           scope: options.scope,
           cwd: process.cwd(),
           force: options.force,
+          signature,
+          sourceMetadata,
+          managedPolicy: managed,
+          policySource: options.registry || source,
         });
+        const upgradeNotice = await resolvePluginCapabilityNotice(
+          res.name,
+          options.scope,
+          process.cwd(),
+        );
+        if (res.updated || res.reinstalled)
+          await auditPluginInstall(
+            "upgrade",
+            { ...res, scope: options.scope },
+            installSource,
+            upgradeNotice,
+          );
+
+        if (options.json) {
+          let capabilitiesGranted = false;
+          if (
+            options.grantCapabilities &&
+            upgradeNotice &&
+            !upgradeNotice.consented
+          ) {
+            capabilitiesGranted = await grantInstalledPluginCapabilities(
+              res.name,
+              options.scope,
+              process.cwd(),
+            );
+          }
+          console.log(
+            JSON.stringify(
+              {
+                ...res,
+                scope: options.scope,
+                capabilities: upgradeNotice,
+                capabilitiesGranted,
+              },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+
         if (res.updated) {
           logger.success(
             `Updated ${res.name}: ${res.previousVersion ? `v${res.previousVersion} → ` : ""}v${res.version} (${options.scope} scope)`,
@@ -1489,20 +1715,6 @@ export function registerPluginCommand(program) {
         // 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.
-        const upgradeNotice = await resolvePluginCapabilityNotice(
-          res.name,
-          options.scope,
-          process.cwd(),
-        );
-        // Only a version that actually landed on disk is an install; an
-        // already-up-to-date no-op fetched nothing new to run.
-        if (res.updated || res.reinstalled)
-          await auditPluginInstall(
-            "upgrade",
-            { ...res, scope: options.scope },
-            source,
-            upgradeNotice,
-          );
         await applyCapabilityConsentGate(
           res.name,
           options.scope,

package/src/commands/session.js

@@ -1333,6 +1333,7 @@ export function registerSessionCommand(program) {
     "subagent",
     "tool",
     "mcp",
+    "plugin",
     "model",
   ];
 
@@ -1403,6 +1404,18 @@ export function registerSessionCommand(program) {
         );
         return;
       }
+      case "plugin": {
+        const rows = a.tools?.byPlugin || [];
+        if (rows.length === 0) return empty("plugin-attributed tool calls");
+        for (const r of rows)
+          toolRow(`${r.plugin}${r.version ? `@${r.version}` : ""}`, r);
+        logger.log(
+          chalk.gray(
+            "  turnTokens = tokens of turns that used the plugin (approximation; do not sum across rows)",
+          ),
+        );
+        return;
+      }
       default:
         break;
     }

package/src/data/changelog.json

@@ -1,6 +1,19 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.162.183",
+      "cliVersions": ["0.4.74", "0.37.35", "0.162.182", "0.162.183"],
+      "date": "2026-07-27",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Added — cc CLI 0.162.183 + IDE quality, plugin, and worktree governance",
+          "body": "> `chainlesschain` **0.162.182 → 0.162.183**, VS Code\n> **0.37.34 → 0.37.35**, and JetBrains **0.4.73 → 0.4.74** (2026-07-27).\n> `@chainlesschain/personal-data-hub` remains **0.4.57** and\n> `@chainlesschain/agent-sdk` remains **0.1.7**.\n\n- **IDE-native quality context**: both IDE bridges negotiate bounded\n  `cc-ide-quality/v1` test-result, coverage, and debugger snapshots with\n  Context v2 freshness metadata; VS Code notebook execution now carries its\n  real notebook context.\n- **Installation Doctor depth**: VS Code and JetBrains report Node/Java\n  availability plus managed-CLI and plugin-registry offline recovery state,\n  without probing executables from an untrusted workspace directory.\n- **Plugin lifecycle and supply-chain UI**: scoped enable/disable, source-aware\n  upgrades, live-session reload, signature/SBOM summaries, managed-policy\n  provenance, and sanitized registry/Git/local source metadata stay governed\n  by the CLI runtime.\n- **Plugin usage attribution**: compact transcripts and usage reports now\n  attribute plugin-bin and plugin-provided MCP calls by plugin/version without\n  persisting tool arguments.\n- **Supervised worktree tasks**: IDE-created isolated tasks run as background\n  worktree agents and display canonical lifecycle, owner/session, permission\n  mode, resource budget, and bounded side-effect counts. Team and batch rows\n  remain explicitly unmanaged until they expose equivalent durable state.\n- **Release validation**: publication remains gated on the exact release\n  commit passing CLI CI, CLI Strict Sandbox, background reconnect E2E, packaged\n  VSIX Extension Host gates, JetBrains unit/build/Remote Robot gates, and\n  public marketplace readback."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.162.182",

package/src/harness/jsonl-session-store.js

@@ -164,20 +164,22 @@ export function appendToolCall(sessionId, toolName, args) {
 
 /**
  * Compact tool-call record for usage attribution (用量归因): tool name +
- * error flag (+ an optional skill hint for `run_skill`) — deliberately NOT
+ * error flag (+ optional skill and plugin/version hints) — deliberately NOT
  * the args, which can carry whole file bodies (write_file content) and would
  * bloat the transcript. Written at tool-result time by the agent drivers so
- * `cc session usage --by tool|mcp` and `cc insights` can aggregate tool use
- * for any persisted session.
+ * `cc session usage --by tool|mcp|plugin` and `cc insights` can aggregate tool
+ * use for any persisted session.
  */
 export function appendToolCallCompact(
   sessionId,
-  { tool, isError, skill } = {},
+  { tool, isError, skill, plugin, pluginVersion } = {},
 ) {
   appendEvent(sessionId, "tool_call", {
     tool: tool || "?",
     is_error: Boolean(isError),
     ...(skill ? { skill: String(skill) } : {}),
+    ...(plugin ? { plugin: String(plugin) } : {}),
+    ...(pluginVersion ? { plugin_version: String(pluginVersion) } : {}),
   });
 }
 

package/src/lib/agent-team/team-runner.js

@@ -51,6 +51,10 @@ export class TeamRunner {
     this._executions = 0;
     this._inFlight = 0;
     this._maxInFlight = 0;
+    // Keys executing in this runner process. An event-loop stall may let a
+    // short lease expire before its heartbeat callback runs; peer loops in the
+    // same process must not steal and double-run that still-active task.
+    this._activeKeys = new Set();
     this._members = new Map(); // holder → lifecycle record
     this._budgetStopped = false;
   }
@@ -208,6 +212,7 @@ export class TeamRunner {
     let best = null;
     let bestScore = Infinity;
     for (const key of claimable) {
+      if (this._activeKeys.has(key)) continue;
       const t = this.registry.getTask(key);
       const score = rank[t?.priority] ?? 1;
       if (score < bestScore) {
@@ -222,10 +227,22 @@ export class TeamRunner {
     const task = this.registry.getTask(key);
     this._executions++;
     this._inFlight++;
+    this._activeKeys.add(key);
     this._maxInFlight = Math.max(this._maxInFlight, this._inFlight);
     this._setState(holder, "running", { key });
     this._emit("task:claimed", { key, holder, attempts: task.attempts });
-    const renew = () => this.registry.renew(key, { holder, ttlMs: this.ttlMs });
+    const renew = () => {
+      const result = this.registry.renew(key, {
+        holder,
+        ttlMs: this.ttlMs,
+      });
+      // A delayed timer may wake just after expiry. Reacquire is safe and
+      // optimistic: it succeeds only if no external runner has taken the
+      // lease; a real takeover remains authoritative and stops the heartbeat.
+      return !result?.ok && result?.reason === "not_holder_or_expired"
+        ? this.registry.acquire(key, { holder, ttlMs: this.ttlMs })
+        : result;
+    };
     // Heartbeat: the built-in executors (shell / agent / worktree) never call
     // `renew` themselves, so before this ANY task outliving the lease TTL was
     // indistinguishable from a crash — a peer could steal it and the SAME task
@@ -338,6 +355,7 @@ export class TeamRunner {
       });
     } finally {
       clearInterval(heartbeat);
+      this._activeKeys.delete(key);
       this._inFlight--;
     }
   }

package/src/lib/background-agent-supervisor.js

@@ -762,6 +762,47 @@ export function normalizeBackgroundWorktree(worktree, cwd) {
   return normalized;
 }
 
+/**
+ * Persist only the bounded, secret-free governance envelope needed by IDE task
+ * rows. The supervisor owns `owner`; callers cannot forge it. Prompt text,
+ * argv, credentials and tool arguments are deliberately excluded.
+ */
+export function normalizeBackgroundGovernance(
+  governance,
+  { id, sessionId } = {},
+) {
+  const source = governance && typeof governance === "object" ? governance : {};
+  const budget =
+    source.resourceBudget && typeof source.resourceBudget === "object"
+      ? source.resourceBudget
+      : {};
+  const positive = (value) => {
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? n : null;
+  };
+  const permissionMode = new Set([
+    "manual",
+    "auto",
+    "dontAsk",
+    "default",
+    "plan",
+    "acceptEdits",
+    "bypassPermissions",
+  ]).has(source.permissionMode)
+    ? source.permissionMode
+    : "default";
+  return {
+    version: 1,
+    owner: `background:${String(id || "").slice(0, 160)}`,
+    sessionId: sessionId ? String(sessionId).slice(0, 256) : null,
+    permissionMode,
+    resourceBudget: {
+      maxTurns: positive(budget.maxTurns),
+      maxCostUsd: positive(budget.maxCostUsd),
+    },
+  };
+}
+
 function persistedWorktree(state) {
   if (!state?.worktreePath) return null;
   return {
@@ -817,6 +858,7 @@ export function resumeBackgroundAgent(id, prompt, options = {}) {
     cliEntry: options.cliEntry,
     followUpArgv: ["agent", "--session", state.sessionId],
     worktree,
+    governance: state.governance,
   });
 }
 
@@ -855,10 +897,15 @@ export function launchBackgroundAgent({
   cliEntry,
   followUpArgv,
   worktree,
+  governance,
 }) {
   assertUsableCwd(cwd);
   const worktreeState = normalizeBackgroundWorktree(worktree, cwd);
   const id = createBackgroundAgentId();
+  const governanceState = normalizeBackgroundGovernance(governance, {
+    id,
+    sessionId,
+  });
   const dir = backgroundAgentsDir();
   const jobFile = join(dir, `${id}.job.${process.pid}.json`);
   const worker = fileURLToPath(
@@ -873,6 +920,7 @@ export function launchBackgroundAgent({
     cliEntry: cliEntry || process.argv[1],
     logFile: logPath(id),
     ...(worktreeState || {}),
+    governance: governanceState,
     // Present = interactive attach can start follow-up turns; absent = the
     // transport rejects prompts (log-only session).
     ...(Array.isArray(followUpArgv) ? { followUpArgv } : {}),
@@ -897,6 +945,7 @@ export function launchBackgroundAgent({
     exitCode: null,
     logFile: job.logFile,
     ...(worktreeState || {}),
+    governance: governanceState,
   };
   writeBackgroundAgentState(state);
   let child;