chainlesschain 0.162.162 → 0.162.163

package/src/commands/context.js

@@ -66,22 +66,21 @@ export function registerContextCommand(program) {
     .argument("[id]", "Session ID (omit for the most-recent headless session)")
     .option("--model <model>", "Size against this model's context window")
     .option("--provider <provider>", "Provider (for the window default)")
+    .option(
+      "--sources",
+      "Also break tokens down by source (project-memory instruction files + message classes)",
+    )
     .option("--json", "Output as JSON")
     .action(async (id, options) => {
-      const {
-        rebuildMessages,
-        getLastSessionId,
-        sessionExists,
-        readEvents,
-      } = await import("../harness/jsonl-session-store.js");
-      const { estimateTokens, getContextWindow } = await import(
-        "../harness/prompt-compressor.js"
-      );
+      const { rebuildMessages, getLastSessionId, sessionExists, readEvents } =
+        await import("../harness/jsonl-session-store.js");
+      const { estimateTokens, getContextWindow } =
+        await import("../harness/prompt-compressor.js");
 
       const sessionId = id || getLastSessionId();
       if (!sessionId) {
         logger.error(
-          'No session found. Run a headless agent with `--session <id>` first, or pass a session id.',
+          "No session found. Run a headless agent with `--session <id>` first, or pass a session id.",
         );
         process.exitCode = 1;
         return;
@@ -121,6 +120,55 @@ export function registerContextCommand(program) {
       const used = window > 0 ? total / window : 0;
       const remaining = Math.max(0, window - total);
 
+      // --sources (opt-in): attribute the project-memory instruction files that
+      // WOULD load for the current cwd (same instructionExcludes the agent
+      // honors), folded in with the session's message-role buckets. The base
+      // view is byte-for-byte unchanged when the flag is absent.
+      let sourceReport = null;
+      if (options.sources) {
+        try {
+          const { loadProjectInstructions } =
+            await import("../lib/project-instructions.js");
+          const { breakdownInstructionSources, rankContextSources } =
+            await import("../lib/context-breakdown.js");
+          const cwd = process.cwd();
+          let instructionExcludes;
+          try {
+            const { readStringArraySetting } =
+              await import("../lib/settings-loader.cjs");
+            instructionExcludes = readStringArraySetting(
+              "instructionExcludes",
+              {
+                cwd,
+              },
+            );
+          } catch {
+            instructionExcludes = undefined; // fail-open — load everything
+          }
+          const loaded = loadProjectInstructions({ cwd, instructionExcludes });
+          const instr = breakdownInstructionSources(
+            loaded.files,
+            estimateTokens,
+            cwd,
+          );
+          const ranked = rankContextSources({
+            instructionTotal: instr.total,
+            buckets,
+            counts,
+          });
+          sourceReport = {
+            cwd,
+            instructions: instr.sources,
+            instructionTokens: instr.total,
+            ranked: ranked.sources,
+            combinedTotal: ranked.total,
+          };
+        } catch {
+          // Best-effort — a source breakdown must never break the base view.
+          sourceReport = null;
+        }
+      }
+
       if (options.json) {
         console.log(
           JSON.stringify(
@@ -136,6 +184,15 @@ export function registerContextCommand(program) {
               breakdown: buckets,
               counts,
               overflows: total > window,
+              ...(sourceReport
+                ? {
+                    sources: sourceReport.ranked,
+                    instructions: sourceReport.instructions,
+                    instructionTokens: sourceReport.instructionTokens,
+                    combinedTotal: sourceReport.combinedTotal,
+                    cwd: sourceReport.cwd,
+                  }
+                : {}),
             },
             null,
             2,
@@ -144,7 +201,9 @@ export function registerContextCommand(program) {
         return;
       }
 
-      logger.log(chalk.bold(`Context — session ${chalk.gray(sessionId.slice(0, 28))}`));
+      logger.log(
+        chalk.bold(`Context — session ${chalk.gray(sessionId.slice(0, 28))}`),
+      );
       logger.log(
         chalk.gray(
           `  model ${model || "(default)"} · provider ${provider} · ` +
@@ -172,17 +231,69 @@ export function registerContextCommand(program) {
 
       logger.log("");
       const pct = (used * 100).toFixed(1);
-      const color = used > 0.9 ? chalk.red : used > 0.7 ? chalk.yellow : chalk.green;
+      const color =
+        used > 0.9 ? chalk.red : used > 0.7 ? chalk.yellow : chalk.green;
       logger.log(
         `  ${chalk.bold("total".padEnd(11))} ${String(total).padStart(7)}  ` +
           `${color(bar(used))} ${color(`${pct}% of window`)}`,
       );
       logger.log(
-        chalk.gray(`  headroom      ${String(remaining).padStart(7)} tokens remaining`),
+        chalk.gray(
+          `  headroom      ${String(remaining).padStart(7)} tokens remaining`,
+        ),
       );
       if (total > window) {
         logger.log(
-          chalk.red("  ⚠ exceeds the model context window — compaction required"),
+          chalk.red(
+            "  ⚠ exceeds the model context window — compaction required",
+          ),
+        );
+      }
+
+      if (sourceReport) {
+        logger.log("");
+        logger.log(
+          chalk.bold("By source") +
+            chalk.gray(`  (project memory for ${sourceReport.cwd})`),
+        );
+        if (sourceReport.instructions.length) {
+          for (const s of sourceReport.instructions) {
+            logger.log(
+              chalk.gray(`  · ${String(s.scope).padEnd(7)} `) +
+                `${String(s.tokens).padStart(7)}  ${s.source}` +
+                (s.truncated ? chalk.yellow("  (truncated)") : ""),
+            );
+          }
+          logger.log(
+            chalk.gray("    project-memory subtotal ") +
+              `${String(sourceReport.instructionTokens).padStart(7)} tokens`,
+          );
+        } else {
+          logger.log(
+            chalk.gray("  (no project-memory instruction files for this cwd)"),
+          );
+        }
+        logger.log("");
+        for (const s of sourceReport.ranked) {
+          logger.log(
+            `  ${String(s.source).padEnd(30)} ${String(s.tokens).padStart(7)}  ` +
+              `${chalk.cyan(bar(s.share))} ${String(Math.round(s.share * 100)).padStart(3)}%`,
+          );
+        }
+        logger.log(
+          chalk.gray(
+            "  note: instructions reflect the current cwd (what a new run here",
+          ),
+        );
+        logger.log(
+          chalk.gray(
+            "  would load); messages are this session's stored turns. Skill / MCP",
+          ),
+        );
+        logger.log(
+          chalk.gray(
+            "  tool schemas load at runtime and are not counted here.",
+          ),
         );
       }
     });

package/src/commands/hook.js

@@ -101,10 +101,7 @@ export function registerHookCommand(program) {
           }
           const events = Object.keys(settingsHooks);
           if (events.length > 0) {
-            const n = events.reduce(
-              (a, e) => a + settingsHooks[e].length,
-              0,
-            );
+            const n = events.reduce((a, e) => a + settingsHooks[e].length, 0);
             logger.log(chalk.bold(`\n.claude/settings.json hooks (${n}):`));
             for (const ev of events) {
               if (options.event && ev !== options.event) continue;
@@ -145,7 +142,8 @@ export function registerHookCommand(program) {
           settingsFile: options.settings,
         });
         const matched = collectHooks(hooks, event, tool);
-        const toolInput = args && args.length ? { command: args.join(" "), args } : {};
+        const toolInput =
+          args && args.length ? { command: args.join(" "), args } : {};
         const payload = {
           hook_event_name: event,
           tool_name: tool,
@@ -156,14 +154,18 @@ export function registerHookCommand(program) {
 
         if (!options.run) {
           if (options.json) {
-            console.log(JSON.stringify({ event, tool, matched, payload }, null, 2));
+            console.log(
+              JSON.stringify({ event, tool, matched, payload }, null, 2),
+            );
           } else if (matched.length === 0) {
             logger.log(
               chalk.gray(`no settings.json hooks match ${event} / ${tool}`),
             );
           } else {
             logger.log(
-              chalk.bold(`${matched.length} hook(s) would fire for ${event} / ${tool}:`),
+              chalk.bold(
+                `${matched.length} hook(s) would fire for ${event} / ${tool}:`,
+              ),
             );
             for (const h of matched) logger.log(`  ${chalk.gray(h.command)}`);
             logger.log(chalk.dim("  (use --run to execute and see decisions)"));
@@ -201,6 +203,178 @@ export function registerHookCommand(program) {
       }
     });
 
+  // hook replay — replay a recorded hook delivery by event id (P2 event bus).
+  // Dry-run by default; --run executes observe-only hooks. A DECISION hook can
+  // re-gate control flow, so its replay is refused without an explicit sandbox
+  // (and, since a real sandbox executor is not yet available, is never executed
+  // — only its dry-run plan is shown).
+  hook
+    .command("replay <event-id>")
+    .description(
+      "Replay a recorded hook delivery (needs CC_HOOK_EVENT_LOG); dry-run by default, --run executes observe-only hooks",
+    )
+    .option("--run", "Execute the replayed hooks (observe-only events only)")
+    .option(
+      "--sandbox",
+      "Assert an explicit sandbox for a decision-hook replay",
+    )
+    .option("--file <path>", "Read from a specific hook event log file")
+    .option("--json", "Output as JSON")
+    .action(async (eventId, options) => {
+      try {
+        const { findHookEvent } = await import("../lib/hook-event-log.cjs");
+        const { planHookReplay } = await import("../lib/hook-event-bus.cjs");
+        const envelope = findHookEvent(eventId, { filePath: options.file });
+        if (!envelope) {
+          logger.error(
+            `hook event "${eventId}" not found` +
+              (options.file
+                ? ""
+                : " (enable recording with CC_HOOK_EVENT_LOG=1)"),
+          );
+          process.exitCode = 1;
+          return;
+        }
+        const plan = planHookReplay(envelope, {
+          sandbox: Boolean(options.sandbox),
+        });
+        if (!plan.ok) {
+          if (options.json) {
+            console.log(JSON.stringify(plan, null, 2));
+          } else {
+            logger.error(`cannot replay: ${plan.reason}`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+        // Decision events re-gate flow; a real sandbox executor is still owed,
+        // so we never EXECUTE them — the dry-run plan is shown instead.
+        if (options.run && plan.requiresSandbox) {
+          const note =
+            "decision-hook execution needs a real sandbox executor (not yet available); showing dry-run plan";
+          if (options.json) {
+            console.log(
+              JSON.stringify({ ...plan, executed: false, note }, null, 2),
+            );
+          } else {
+            logger.warn(`${note}:`);
+            logger.log(JSON.stringify(plan.payload, null, 2));
+          }
+          return;
+        }
+        if (!options.run) {
+          if (options.json) {
+            console.log(JSON.stringify({ ...plan, executed: false }, null, 2));
+          } else {
+            logger.log(
+              chalk.bold(
+                `replay (dry-run) of ${plan.event_type} [${plan.event_id}]`,
+              ),
+            );
+            if (plan.requiresSandbox)
+              logger.log(chalk.dim("  (decision event — sandboxed)"));
+            logger.log(JSON.stringify(plan.payload, null, 2));
+            logger.log(
+              chalk.dim("  (use --run to execute observe-only hooks)"),
+            );
+          }
+          return;
+        }
+        // observe-only + --run: re-collect and execute the matching hooks.
+        const { loadHooks, collectHooks } =
+          await import("../lib/settings-hooks.cjs");
+        const { runHooks } = await import("../lib/hook-runner.cjs");
+        const { hooks } = loadHooks({ cwd: process.cwd() });
+        const matched = collectHooks(
+          hooks,
+          plan.event_type,
+          plan.payload.tool_name || "",
+        );
+        const outcome = runHooks(matched, plan.payload, {
+          cwd: process.cwd(),
+          event: plan.event_type,
+        });
+        if (options.json) {
+          console.log(
+            JSON.stringify({ ...plan, executed: true, outcome }, null, 2),
+          );
+        } else {
+          logger.log(
+            chalk.bold(
+              `replayed ${plan.event_type} [${plan.event_id}] → ${outcome.results.length} hook(s)`,
+            ),
+          );
+          for (const r of outcome.results) {
+            logger.log(
+              `  ${chalk.gray(r.command)} → ${r.decision}` +
+                (r.exitCode != null ? ` (exit ${r.exitCode})` : ""),
+            );
+          }
+        }
+      } catch (err) {
+        logger.error(`hook replay failed: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
+  // hook events-log — list / verify the recorded hook delivery log.
+  hook
+    .command("events-log")
+    .description(
+      "List or verify the recorded hook delivery log (CC_HOOK_EVENT_LOG)",
+    )
+    .option("--limit <n>", "Max entries to show", "20")
+    .option("--verify", "Verify the hash chain instead of listing")
+    .option("--file <path>", "Read from a specific hook event log file")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { listHookEvents, verifyHookEventChain, hookEventLogPath } =
+          await import("../lib/hook-event-log.cjs");
+        if (options.verify) {
+          const result = verifyHookEventChain({ filePath: options.file });
+          if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+          } else if (result.ok) {
+            logger.success(
+              `hook event log chain OK (${result.length} record(s))`,
+            );
+          } else {
+            logger.error(
+              `hook event log chain BROKEN at #${result.brokenAt}: ${result.reason}`,
+            );
+            process.exitCode = 1;
+          }
+          return;
+        }
+        const events = listHookEvents({
+          limit: parseInt(options.limit, 10) || 20,
+          filePath: options.file,
+        });
+        const logPath = options.file || hookEventLogPath();
+        if (options.json) {
+          console.log(JSON.stringify({ events, path: logPath }, null, 2));
+          return;
+        }
+        if (events.length === 0) {
+          logger.info(
+            `No recorded hook events (enable with CC_HOOK_EVENT_LOG=1). Log: ${logPath}`,
+          );
+          return;
+        }
+        logger.log(chalk.bold(`Recorded hook events (${events.length}):\n`));
+        for (const e of events) {
+          logger.log(
+            `  ${chalk.cyan(e.event_id)} ${chalk.yellow(e.event_type)}` +
+              (e.session_id ? ` session=${e.session_id}` : ""),
+          );
+        }
+      } catch (err) {
+        logger.error(`hook events-log failed: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
   // hook add
   hook
     .command("add")

package/src/commands/plugin.js

@@ -30,6 +30,59 @@ import {
   getPluginSkills,
 } from "../harness/plugin-manager.js";
 
+/**
+ * After an install/upgrade, resolve the just-installed plugin's DECLARED
+ * capabilities and its current consent status, so `cc plugin add`/`upgrade`
+ * surface a capability list + diff and tell the user when a WIDENING requires
+ * re-consent (mirroring `cc plugin consent`). Best-effort: capability rendering
+ * must never fail an otherwise-successful install. Returns a structured summary
+ * (for --json folding) or null when the plugin declares nothing / can't be
+ * resolved.
+ */
+async function resolvePluginCapabilityNotice(name, scope, cwd) {
+  try {
+    const { discoverPlugins } = await import("../lib/plugin-runtime/scopes.js");
+    const { describeCapabilities } =
+      await import("../lib/plugin-runtime/capabilities.js");
+    const consent = await import("../lib/plugin-runtime/capability-consent.js");
+    const installed = discoverPlugins({ cwd, skipPolicy: true }).find(
+      (p) => p.name === name && p.scope === scope,
+    );
+    if (!installed) return null;
+    const declared = installed.manifest?.capabilities;
+    if (!declared || consent.capabilitiesAreEmpty(declared)) return null;
+    const entry = consent.loadConsentStore()[`${scope}:${name}`] || null;
+    const status = consent.capabilityConsentStatus(declared, entry);
+    return {
+      declared: describeCapabilities(declared),
+      consented: status.consented,
+      reason: status.reason,
+      added: status.added,
+    };
+  } catch {
+    return null; // capability rendering is advisory — never break an install
+  }
+}
+
+/** Print the capability notice (text mode) after an install/upgrade. */
+function printPluginCapabilityNotice(name, notice) {
+  if (!notice) return;
+  logger.log(chalk.bold("\nCapabilities (declared):"));
+  for (const l of notice.declared) logger.log(`  ${chalk.magenta(l)}`);
+  if (notice.consented) {
+    logger.log(chalk.gray(`  capability consent: ${notice.reason}`));
+    return;
+  }
+  logger.log(
+    chalk.yellow(`  ⚠ capability consent required (${notice.reason})`),
+  );
+  if (notice.added.length)
+    logger.log(chalk.yellow(`    new: ${notice.added.join(", ")}`));
+  logger.log(
+    chalk.dim(`    run \`cc plugin consent ${name} --grant\` to allow them`),
+  );
+}
+
 export function registerPluginCommand(program) {
   const plugin = program
     .command("plugin")
@@ -632,6 +685,17 @@ export function registerPluginCommand(program) {
           logger.log(chalk.yellow(`  ⚠ ${issue}`));
         }
       }
+      // Declared capabilities (Phase 3 gap): show what the plugin says it needs
+      // so a user can compare against the components it ships (the audit findings
+      // for an under-declared manifest already surface in manifest.warnings).
+      if (manifest.capabilitiesDeclared) {
+        const { describeCapabilities } =
+          await import("../lib/plugin-runtime/capabilities.js");
+        const capLines = describeCapabilities(manifest.capabilities);
+        logger.log(chalk.bold("\nCapabilities (declared):"));
+        if (capLines.length === 0) logger.log(chalk.gray("  (none)"));
+        for (const l of capLines) logger.log(`  ${chalk.magenta(l)}`);
+      }
       for (const w of manifest.warnings) logger.log(chalk.yellow(`  ⚠ ${w}`));
       for (const e of manifest.errors) logger.log(chalk.red(`  ✖ ${e}`));
       if (manifest.ok) {
@@ -736,8 +800,15 @@ export function registerPluginCommand(program) {
           force: options.force === true,
           signature,
         });
+        const capNotice = await resolvePluginCapabilityNotice(
+          res.name,
+          res.scope,
+          process.cwd(),
+        );
         if (options.json) {
-          console.log(JSON.stringify(res, null, 2));
+          console.log(
+            JSON.stringify({ ...res, capabilities: capNotice }, null, 2),
+          );
         } else {
           logger.success(
             `Installed ${res.name} v${res.version} (${res.scope} scope)` +
@@ -746,6 +817,7 @@ export function registerPluginCommand(program) {
           logger.log(chalk.gray(`  → ${res.dir}`));
           for (const w of res.warnings || [])
             logger.log(chalk.yellow(`  ⚠ ${w}`));
+          printPluginCapabilityNotice(res.name, capNotice);
         }
       } catch (err) {
         logger.error(`Install failed: ${err.message}`);
@@ -905,6 +977,161 @@ export function registerPluginCommand(program) {
       }
     });
 
+  // plugin consent [name] — view / grant a plugin's CAPABILITY consent
+  // (process / network / filesystem / mcp / monitor / credential). Distinct from
+  // `trust`, which pins the code VERSION: consent pins the capability SET, and
+  // any widening re-prompts even for an already-trusted plugin.
+  plugin
+    .command("consent [name]")
+    .description(
+      "View or grant a plugin's capability consent (--grant / --revoke / --list)",
+    )
+    .option("--scope <scope>", "Scope of the plugin", "project")
+    .option(
+      "--grant",
+      "Grant consent for the plugin's currently-declared capabilities",
+    )
+    .option("--revoke", "Revoke capability consent")
+    .option("--list", "List all capability consent entries")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      const consent =
+        await import("../lib/plugin-runtime/capability-consent.js");
+      const { describeCapabilities } =
+        await import("../lib/plugin-runtime/capabilities.js");
+
+      if (!name || options.list) {
+        const rows = consent.listCapabilityConsent();
+        if (options.json) {
+          console.log(JSON.stringify(rows, null, 2));
+          return;
+        }
+        if (rows.length === 0) {
+          logger.info("No capability consent recorded.");
+          return;
+        }
+        logger.log(chalk.bold(`Capability consent (${rows.length}):`));
+        for (const r of rows) {
+          logger.log(`  ${chalk.cyan(r.name)} v${r.version} [${r.scope}]`);
+          for (const c of r.capabilities) logger.log(`    ${chalk.magenta(c)}`);
+        }
+        return;
+      }
+
+      if (options.revoke) {
+        const res = consent.revokeCapabilityConsent(name, {
+          scope: options.scope,
+        });
+        if (res.removed) {
+          logger.success(
+            `Revoked capability consent for ${name} (${options.scope} scope)`,
+          );
+        } else {
+          logger.info(
+            `${name} had no capability consent at ${options.scope} scope`,
+          );
+        }
+        return;
+      }
+
+      // Resolve the installed plugin + its declared capabilities.
+      const { discoverPlugins } =
+        await import("../lib/plugin-runtime/scopes.js");
+      let installed = null;
+      try {
+        installed = discoverPlugins({
+          cwd: process.cwd(),
+          skipPolicy: true,
+        }).find((p) => p.name === name && p.scope === options.scope);
+      } catch {
+        /* discovery best-effort */
+      }
+      if (!installed) {
+        logger.error(`${name} is not installed at ${options.scope} scope`);
+        process.exitCode = 1;
+        return;
+      }
+      const declared = installed.manifest?.capabilities;
+      const entry =
+        consent.loadConsentStore()[`${options.scope}:${name}`] || null;
+      const status = consent.capabilityConsentStatus(declared, entry);
+
+      if (options.grant) {
+        consent.consentPluginCapabilities(name, {
+          scope: options.scope,
+          version: installed.version,
+          capabilities: declared,
+        });
+        const capLines = describeCapabilities(declared);
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              {
+                granted: true,
+                name,
+                scope: options.scope,
+                version: installed.version,
+                capabilities: capLines,
+              },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+        logger.success(
+          `Granted capability consent for ${name} v${installed.version} (${options.scope} scope)`,
+        );
+        for (const l of capLines) logger.log(`    ${chalk.magenta(l)}`);
+        return;
+      }
+
+      // Show status.
+      const capLines = describeCapabilities(declared);
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              name,
+              scope: options.scope,
+              version: installed.version,
+              declared: capLines,
+              ...status,
+            },
+            null,
+            2,
+          ),
+        );
+        return;
+      }
+      logger.log(
+        chalk.bold("Capability consent: ") +
+          `${chalk.cyan(name)} v${installed.version} [${options.scope}]`,
+      );
+      logger.log(chalk.bold("Declared capabilities:"));
+      if (capLines.length === 0) logger.log(chalk.gray("  (none)"));
+      for (const l of capLines) logger.log(`  ${chalk.magenta(l)}`);
+      logger.log(
+        chalk.bold("Status: ") +
+          (status.consented
+            ? chalk.green("consented")
+            : chalk.yellow("NEEDS CONSENT")),
+      );
+      logger.log(chalk.gray(`  ${status.reason}`));
+      if (status.added.length) {
+        logger.log(
+          chalk.yellow(`  new since consent: ${status.added.join(", ")}`),
+        );
+      }
+      if (!status.consented) {
+        logger.log(
+          chalk.dim(
+            `  run \`cc plugin consent ${name} --grant\` to allow them`,
+          ),
+        );
+      }
+    });
+
   // plugin monitors — list (and optionally run) trusted plugins' background
   // monitors. `--run --seconds N` actually starts the supervisor for N seconds,
   // prints captured output, then reaps everything (verifies no leaked process).
@@ -1012,6 +1239,17 @@ 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.
+        printPluginCapabilityNotice(
+          res.name,
+          await resolvePluginCapabilityNotice(
+            res.name,
+            options.scope,
+            process.cwd(),
+          ),
+        );
       } catch (err) {
         logger.error(`Upgrade failed: ${err.message}`);
         process.exitCode = 1;