chainlesschain 0.162.61 → 0.162.66

package/src/index.js

@@ -64,6 +64,8 @@ import { registerGoalCommand } from "./commands/goal.js";
 import { registerCommandCommand } from "./commands/command.js";
 import { registerCompactCommand } from "./commands/compact.js";
 import { registerLoopCommand } from "./commands/loop.js";
+import { registerReviewCommand } from "./commands/review.js";
+import { registerInsightsCommand } from "./commands/insights.js";
 import { registerPermissionsCommand } from "./commands/permissions.js";
 import { registerOutputStyleCommand } from "./commands/output-style.js";
 import { registerStatuslineCommand } from "./commands/statusline.js";
@@ -477,6 +479,8 @@ export function createProgram(opts = {}) {
   registerCommandCommand(program);
   registerCompactCommand(program);
   registerLoopCommand(program);
+  registerReviewCommand(program);
+  registerInsightsCommand(program);
   registerPermissionsCommand(program);
   registerOutputStyleCommand(program);
   registerStatuslineCommand(program);

package/src/lib/cost-budget.js

@@ -0,0 +1,109 @@
+/**
+ * cost-budget — a hard USD spend cap for unattended agent runs
+ * (Claude-Code `--max-budget-usd` parity).
+ *
+ * Where IterationBudget caps the number of agent-loop turns, CostBudget caps the
+ * estimated dollar cost: it accumulates the per-call cost (via llm-pricing) as
+ * token-usage events arrive and reports when the cap is reached, so the runner
+ * can stop BEFORE making another paid LLM call. Because a call's cost is only
+ * known after it returns, a run may overshoot by at most one call — it never
+ * starts a new turn once over budget.
+ *
+ * Local/free providers (ollama, …) and unpriced models cost $0 here, so a cap
+ * can never trigger for them; `shouldWarnInactive()` lets the caller surface a
+ * one-time "cap inactive" notice instead of silently doing nothing.
+ *
+ * Pure + dependency-light (only llm-pricing) so it is unit-testable without a
+ * real agent loop.
+ */
+
+import { estimateCost } from "./llm-pricing.js";
+
+const round = (n, dp = 6) => {
+  const f = Math.pow(10, dp);
+  return Math.round((Number(n) + Number.EPSILON) * f) / f;
+};
+
+/** Parse a `--max-budget-usd` value into a positive number, or null when unset. */
+export function parseBudgetUsd(value) {
+  if (value == null || value === "") return null;
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) {
+    throw new Error(
+      `Invalid --max-budget-usd "${value}". Expected a positive number of US dollars.`,
+    );
+  }
+  return n;
+}
+
+export class CostBudget {
+  /**
+   * @param {object} opts
+   * @param {number|null} [opts.limitUsd] cap in USD; null/≤0 → disabled
+   * @param {object} [opts.table]         merged price table (mergePricing output)
+   */
+  constructor({ limitUsd = null, table = undefined } = {}) {
+    const lim = Number(limitUsd);
+    this.limitUsd = Number.isFinite(lim) && lim > 0 ? lim : null;
+    this.table = table;
+    this.spentUsd = 0;
+    this.priced = false; // priced ≥1 non-free usage record
+    this.sawUnpriced = false; // saw tokens we couldn't price
+    this.sawFree = false; // saw a free/local provider
+    this._warned = false;
+  }
+
+  enabled() {
+    return this.limitUsd != null;
+  }
+
+  /**
+   * Fold one token-usage record into the running spend.
+   * @returns {object} the estimateCost() result for this record
+   */
+  add({ provider, model, usage } = {}) {
+    const est = estimateCost({
+      provider,
+      model,
+      inputTokens: usage?.input_tokens || 0,
+      outputTokens: usage?.output_tokens || 0,
+      table: this.table,
+    });
+    const tokens = (usage?.input_tokens || 0) + (usage?.output_tokens || 0);
+    if (est.free) {
+      this.sawFree = true;
+    } else if (est.matched) {
+      this.spentUsd = round(this.spentUsd + est.totalCost);
+      this.priced = true;
+    } else if (tokens > 0) {
+      this.sawUnpriced = true;
+    }
+    return est;
+  }
+
+  /** True once the running spend has reached/passed the cap. */
+  exceeded() {
+    return this.limitUsd != null && this.spentUsd >= this.limitUsd;
+  }
+
+  /** USD left under the cap (Infinity when disabled). */
+  remaining() {
+    return this.limitUsd == null
+      ? Infinity
+      : Math.max(0, round(this.limitUsd - this.spentUsd));
+  }
+
+  /**
+   * True the FIRST time we can tell the cap can't bite — a cap was set but every
+   * usage so far has been free/local or unpriced, so spend stays $0. Lets the
+   * caller print a one-time "cap inactive" warning instead of a silent no-op.
+   */
+  shouldWarnInactive() {
+    if (!this.enabled() || this._warned || this.priced) return false;
+    if (this.sawUnpriced || this.sawFree) {
+      this._warned = true;
+      return true;
+    }
+    return false;
+  }
+}

package/src/lib/ide-context.js

@@ -278,6 +278,13 @@ export function hasIdeOpenDiff(mcp) {
  * Run one blocking openDiff review in the connected IDE. Returns
  *   { outcome:"accepted", finalText|null }  — the IDE wrote the file itself
  *   { outcome:"rejected" }                  — nothing was written
+ *   { outcome:"changes-requested", comments, reviewedText }
+ *                                           — the user annotated the diff with
+ *                                             revision notes instead of
+ *                                             accepting/rejecting; nothing was
+ *                                             written and the caller should
+ *                                             feed `comments` back to the agent
+ *                                             so it revises and re-proposes.
  *   null                                    — IDE unavailable / transport
  *                                             error / malformed reply → the
  *                                             caller falls back to its normal
@@ -309,10 +316,53 @@ export async function requestIdeDiffApproval(mcp, req = {}) {
       finalText: typeof data.finalText === "string" ? data.finalText : null,
     };
   }
+  if (data?.outcome === "changes-requested") {
+    return {
+      outcome: "changes-requested",
+      comments: Array.isArray(data.comments) ? data.comments : [],
+      reviewedText:
+        typeof data.reviewedText === "string" ? data.reviewedText : null,
+    };
+  }
   if (data?.outcome === "rejected") return { outcome: "rejected" };
   return null; // anything else is not a verdict — fail safe to fallback
 }
 
+/**
+ * Render line-anchored review comments (from an openDiff "changes-requested"
+ * verdict) into a compact feedback block the agent can act on. Each comment is
+ * `{ line?, endLine?, lineText?, note }` with 0-based editor lines. Returns
+ * null when there is no actionable note. Pure — safe to unit-test.
+ */
+export function formatReviewComments(comments, { path: filePath } = {}) {
+  if (!Array.isArray(comments) || comments.length === 0) return null;
+  const lines = comments
+    .map((c) => {
+      if (!c || typeof c.note !== "string" || c.note.trim().length === 0) {
+        return null;
+      }
+      const start = Number.isInteger(c.line) ? c.line + 1 : null; // 0→1-based
+      const end = Number.isInteger(c.endLine) ? c.endLine + 1 : start;
+      const where =
+        start != null
+          ? end != null && end !== start
+            ? `lines ${start}-${end}`
+            : `line ${start}`
+          : "(general)";
+      const anchor =
+        typeof c.lineText === "string" && c.lineText.trim().length > 0
+          ? `  ⟪${c.lineText.trim().slice(0, 120)}⟫`
+          : "";
+      return `  • ${where}: ${c.note.trim()}${anchor}`;
+    })
+    .filter(Boolean);
+  if (lines.length === 0) return null;
+  const header = filePath
+    ? `Review comments on ${filePath}:`
+    : "Review comments:";
+  return `${header}\n${lines.join("\n")}`;
+}
+
 // ─── Explicit @selection / @diagnostics at-mentions (Claude-Code parity) ────
 //
 // The ambient `<ide-context>` block above shares the selection on every turn.

package/src/lib/personal-data-hub-wiring.js

@@ -57,6 +57,8 @@ const {
   ZhihuAdapter,
   BossZhipinAdapter,
   CsdnAdapter,
+  DongchediAdapter,
+  TianyanchaAdapter,
   DouyinAdapter,
   XiaohongshuAdapter,
   ToutiaoAdapter,
@@ -72,14 +74,30 @@ const {
   AppleHealthAdapter,
   NeteaseMusicAdapter,
   KugouMusicAdapter,
+  QQMusicAdapter,
+  FanqieReadingAdapter,
+  QimaoReadingAdapter,
+  JoyrunAdapter,
   IqiyiVideoAdapter,
   TencentVideoAdapter,
+  XiguaVideoAdapter,
   WeReadAdapter,
   WpsDocAdapter,
   TencentDocsAdapter,
   BaiduNetdiskAdapter,
+  CamScannerDocAdapter,
+  IXiamenAdapter,
+  MeiyouAdapter,
+  TaxAdapter,
+  CmbcBankAdapter,
+  BocBankAdapter,
+  BankcommBankAdapter,
+  IcbcBankAdapter,
+  DcepAdapter,
+  Tmri12123Adapter,
   DingTalkPcAdapter,
   FeishuPcAdapter,
+  WeWorkPcAdapter,
   BaiduMapAdapter,
   TencentMapAdapter,
   JdAdapter,
@@ -529,6 +547,8 @@ async function initHub() {
     ZhihuAdapter,
     BossZhipinAdapter,
     CsdnAdapter,
+    DongchediAdapter,
+    TianyanchaAdapter,
     DouyinAdapter,
     XiaohongshuAdapter,
     ToutiaoAdapter,
@@ -544,14 +564,30 @@ async function initHub() {
     AppleHealthAdapter,
     NeteaseMusicAdapter,
     KugouMusicAdapter,
+    QQMusicAdapter,
+    FanqieReadingAdapter,
+    QimaoReadingAdapter,
+    JoyrunAdapter,
     IqiyiVideoAdapter,
     TencentVideoAdapter,
+    XiguaVideoAdapter,
     WeReadAdapter,
     WpsDocAdapter,
     TencentDocsAdapter,
     BaiduNetdiskAdapter,
+    CamScannerDocAdapter,
+    IXiamenAdapter,
+    MeiyouAdapter,
+    TaxAdapter,
+    CmbcBankAdapter,
+    BocBankAdapter,
+    BankcommBankAdapter,
+    IcbcBankAdapter,
+    DcepAdapter,
+    Tmri12123Adapter,
     DingTalkPcAdapter,
     FeishuPcAdapter,
+    WeWorkPcAdapter,
     BaiduMapAdapter,
     TencentMapAdapter,
     JdAdapter,

package/src/lib/session-insights.js

@@ -0,0 +1,145 @@
+/**
+ * session-insights — turn a JSONL session's events into an analysis report
+ * (Claude-Code `/insights` parity). Pure: takes the already-read event array
+ * and returns a structured summary. No new data is collected — this reads the
+ * same `token_usage` / `tool_call` / message events the session already wrote,
+ * and layers on top of `aggregateUsage` (session-usage.js) for tokens.
+ *
+ * Note: headless runs persist user/assistant/token_usage but not necessarily
+ * tool_call/tool_result, so the tools section degrades gracefully to zero when
+ * those events aren't present (the REPL records them).
+ */
+
+import { aggregateUsage } from "./session-usage.js";
+
+/** Human-readable duration from milliseconds. */
+export function formatDuration(ms) {
+  const n = Number(ms);
+  if (!Number.isFinite(n) || n <= 0) return "0s";
+  const s = Math.round(n / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rs = s % 60;
+  if (m < 60) return rs ? `${m}m ${rs}s` : `${m}m`;
+  const h = Math.floor(m / 60);
+  const rm = m % 60;
+  return rm ? `${h}h ${rm}m` : `${h}h`;
+}
+
+/** Detect whether a tool_result event represents an error (lenient). */
+function isToolError(event) {
+  const r = event?.data?.result;
+  return Boolean(
+    event?.data?.error ||
+      (r && typeof r === "object" && (r.error || r.is_error || r.isError)),
+  );
+}
+
+/**
+ * Analyze a session's events into a structured insights object. Pure.
+ *
+ * @param {object[]} events  JSONL events ({type, timestamp, data})
+ * @param {string} [sessionId]
+ * @returns {object}
+ */
+export function analyzeSession(events, sessionId) {
+  const evs = Array.isArray(events) ? events : [];
+  const start = evs.find((e) => e && e.type === "session_start");
+
+  const stamps = evs
+    .map((e) => Number(e?.timestamp))
+    .filter((t) => Number.isFinite(t) && t > 0);
+  const startedAt = stamps.length ? Math.min(...stamps) : null;
+  const endedAt = stamps.length ? Math.max(...stamps) : null;
+  const durationMs =
+    startedAt != null && endedAt != null ? endedAt - startedAt : 0;
+
+  let userMsgs = 0;
+  let assistantMsgs = 0;
+  let compactions = 0;
+  let toolCalls = 0;
+  let toolErrors = 0;
+  const toolByName = new Map();
+
+  const bump = (name) => {
+    const t = toolByName.get(name) || { tool: name, count: 0, errors: 0 };
+    toolByName.set(name, t);
+    return t;
+  };
+
+  for (const e of evs) {
+    if (!e || typeof e !== "object") continue;
+    switch (e.type) {
+      case "user_message":
+        userMsgs++;
+        break;
+      case "assistant_message":
+        assistantMsgs++;
+        break;
+      case "compact":
+        compactions++;
+        break;
+      case "tool_call": {
+        toolCalls++;
+        bump(e.data?.tool || "?").count++;
+        break;
+      }
+      case "tool_result": {
+        if (isToolError(e)) {
+          toolErrors++;
+          bump(e.data?.tool || "?").errors++;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+
+  // Headless persistence writes token_usage with only {input_tokens,
+  // output_tokens} — no model/provider — so the raw aggregate can't be priced.
+  // Backfill the session's recorded model/provider (from session_start) onto
+  // those events so cost estimation works (cc cost lacks this, so insights cost
+  // is strictly better for headless sessions).
+  const sessModel = start?.data?.model || null;
+  const sessProvider = start?.data?.provider || null;
+  const usageEvents =
+    sessModel || sessProvider
+      ? evs.map((e) => {
+          if (e?.type !== "token_usage") return e;
+          const d = e.data || {};
+          if (d.provider || d.model) return e;
+          return {
+            ...e,
+            data: { ...d, provider: sessProvider, model: sessModel },
+          };
+        })
+      : evs;
+  const usage = aggregateUsage(usageEvents);
+  const iso = (t) => (t != null ? new Date(t).toISOString() : null);
+
+  return {
+    sessionId: sessionId || null,
+    meta: {
+      title: start?.data?.title || null,
+      model: start?.data?.model || usage.byModel[0]?.model || null,
+      provider: start?.data?.provider || usage.byModel[0]?.provider || null,
+      startedAt: iso(startedAt),
+      endedAt: iso(endedAt),
+      durationMs,
+    },
+    events: evs.length,
+    messages: {
+      user: userMsgs,
+      assistant: assistantMsgs,
+      total: userMsgs + assistantMsgs,
+    },
+    tools: {
+      calls: toolCalls,
+      errors: toolErrors,
+      byTool: Array.from(toolByName.values()).sort((a, b) => b.count - a.count),
+    },
+    compactions,
+    usage,
+  };
+}

package/src/lib/skill-loader.js

@@ -1,8 +1,9 @@
 /**
  * Multi-layer skill loader for CLI
  *
- * 6-layer priority system (highest wins on name collision):
- *   0 (lowest)  bundled        — desktop-app-vue/.../skills/builtin/
+ * 7-layer priority system (highest wins on name collision):
+ *   0 (lowest)  bundled        — desktop-app-vue/.../skills/builtin/ (monorepo only)
+ *   0b          cli-bundled    — packages/cli/src/skills-bundled/ (ships with cc)
  *   1           marketplace    — <userData>/marketplace/skills/
  *   2           managed        — <userData>/skills/
  *   3           claude-user    — ~/.claude/skills/            (Claude-Code 可移植)
@@ -69,6 +70,7 @@ export function bundledSkillsDisabled(opts = {}) {
 /** Layer names in priority order (lowest → highest) */
 export const LAYER_NAMES = [
   "bundled",
+  "cli-bundled",
   "marketplace",
   "managed",
   "claude-user",
@@ -269,6 +271,18 @@ export class CLISkillLoader {
       exists: bundledPath !== null,
     });
 
+    // Layer 0b: cli-bundled — skills shipped INSIDE the cc package
+    // (packages/cli/src/skills-bundled). Unlike the desktop `bundled` layer
+    // above (absent in a published cc install), this is always present, so
+    // CLI-owned global skills (run / verify) work everywhere cc runs without
+    // touching the desktop app's version-counted skill set.
+    const cliBundledPath = path.resolve(__dirname, "../skills-bundled");
+    layers.push({
+      layer: "cli-bundled",
+      path: cliBundledPath,
+      exists: fs.existsSync(cliBundledPath),
+    });
+
     // Layer 1: marketplace — <userData>/marketplace/skills/
     const userData = getElectronUserDataDir();
     const marketplacePath = path.join(userData, "marketplace", "skills");
@@ -399,7 +413,8 @@ export class CLISkillLoader {
     // Process in priority order (lowest first, so higher layers overwrite)
     for (const { layer, path: layerPath, exists } of layers) {
       if (!exists) continue;
-      if (dropBundled && layer === "bundled") continue;
+      if (dropBundled && (layer === "bundled" || layer === "cli-bundled"))
+        continue;
       const skills = this._loadFromDir(layerPath, layer);
       for (const skill of skills) {
         skillMap.set(skill.id, skill);

package/src/repl/agent-repl.js

@@ -75,7 +75,10 @@ import {
   agentLoop as coreAgentLoop,
   formatToolArgs,
   killAllBackgroundShellTasks,
+  killBackgroundShellTask,
+  listBackgroundShellTasks,
 } from "../runtime/agent-core.js";
+import { formatBackgroundTasks } from "./tasks-status.js";
 import { expandFileRefs } from "../runtime/file-ref-expander.js";
 import { composeSystemPrompt } from "../runtime/system-prompt.js";
 import {
@@ -833,6 +836,7 @@ export async function startAgentRepl(options = {}) {
       "/statusline",
       "/sub-agents",
       "/task",
+      "/tasks",
       "/terminal-setup",
       "/vim",
     ],
@@ -1253,6 +1257,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/sub-agents")}  Show active/completed sub-agents`,
       );
+      logger.log(
+        `  ${chalk.cyan("/tasks")}      Show background shell tasks (kill <id> · kill-all)`,
+      );
       logger.log(
         `  ${chalk.cyan("/ide")}        IDE bridge status (connected editor, tools, or why not)`,
       );
@@ -1292,6 +1299,33 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `/tasks` — user-facing view of the agent's background shell tasks
+    // (run_shell run_in_background). Must precede the `/task` handler below,
+    // which matches with startsWith("/task") and would otherwise swallow it.
+    if (trimmed === "/tasks" || trimmed.startsWith("/tasks ")) {
+      const rest = trimmed.slice("/tasks".length).trim();
+      if (rest === "kill-all") {
+        const n = killAllBackgroundShellTasks();
+        logger.log(chalk.dim(`Killed ${n} background shell task(s).`));
+      } else if (rest.startsWith("kill ")) {
+        const id = rest.slice("kill ".length).trim();
+        const ok = id ? killBackgroundShellTask(id) : false;
+        logger.log(
+          ok
+            ? chalk.dim(`Killed background shell task ${id}.`)
+            : chalk.dim(`No running background shell task with id "${id}".`),
+        );
+      } else if (rest === "kill") {
+        logger.log(chalk.dim("Usage: /tasks kill <id> · /tasks kill-all"));
+      } else {
+        logger.log(
+          "\n" + formatBackgroundTasks(listBackgroundShellTasks()) + "\n",
+        );
+      }
+      prompt();
+      return;
+    }
+
     if (trimmed === "/sub-agents" || trimmed === "/subagents") {
       try {
         const { SubAgentRegistry } =

package/src/repl/tasks-status.js

@@ -0,0 +1,82 @@
+/**
+ * Pure renderer for the `/tasks` REPL command — a user-facing view of the
+ * agent's background shell tasks (the ones it starts with
+ * run_shell { run_in_background: true }). The data comes from agent-core's
+ * listBackgroundShellTasks(); this module only formats it, so it stays
+ * deterministic and unit-testable (inject `now` for stable elapsed time).
+ *
+ * Background shells are otherwise only visible to the agent (via its
+ * check_shell tool) — this surfaces them to the human, the way Claude Code's
+ * background-tasks view does. Sub-agents live under a separate registry and
+ * are shown by `/sub-agents`.
+ */
+
+/** Coerce an ISO-string or epoch-ms timestamp to epoch ms, or null. */
+function toMs(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string") {
+    const t = Date.parse(v);
+    return Number.isFinite(t) ? t : null;
+  }
+  return null;
+}
+
+/** Human-friendly elapsed duration. */
+function fmtElapsed(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "?";
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m${s % 60}s`;
+  const h = Math.floor(m / 60);
+  return `${h}h${m % 60}m`;
+}
+
+/** A short status badge for one task. */
+export function taskStatusLabel(t) {
+  switch (t?.status) {
+    case "running":
+      return "● running";
+    case "exited":
+      return `✓ exited${t.exitCode != null ? ` (${t.exitCode})` : ""}`;
+    case "failed":
+      return `✗ failed${t.exitCode != null ? ` (${t.exitCode})` : ""}`;
+    case "error":
+      return "✗ error";
+    default:
+      return t?.status || "?";
+  }
+}
+
+/**
+ * Render the background-shell task list as a plain-text block.
+ * @param {Array} tasks  from listBackgroundShellTasks()
+ * @param {object} opts  { now?: epoch-ms } — defaults to Date.now()
+ */
+export function formatBackgroundTasks(tasks, { now = Date.now() } = {}) {
+  const list = Array.isArray(tasks) ? tasks : [];
+  if (list.length === 0) {
+    return (
+      "No background shell tasks.\n" +
+      "  (The agent starts these with run_shell run_in_background:true; " +
+      "sub-agents are under /sub-agents.)"
+    );
+  }
+  const running = list.filter((t) => t?.status === "running").length;
+  const lines = [
+    `Background shell tasks (${list.length}, ${running} running):`,
+  ];
+  for (const t of list) {
+    const started = toMs(t.startedAt);
+    const ended = toMs(t.endedAt);
+    const elapsed =
+      started != null ? fmtElapsed((ended ?? now) - started) : "?";
+    const cmd = String(t.command || "")
+      .replace(/\s+/g, " ")
+      .trim();
+    const cmdShort = cmd.length > 70 ? cmd.slice(0, 70) + "…" : cmd;
+    lines.push(`  ${taskStatusLabel(t)}  ${t.id}  ${elapsed}  ${cmdShort}`);
+  }
+  lines.push("Manage: /tasks kill <id> · /tasks kill-all");
+  return lines.join("\n");
+}

package/src/runtime/agent-core.js

@@ -175,6 +175,16 @@ function _killTask(task) {
   }
 }
 
+/**
+ * Kill one background shell task by id (for the user-facing `/tasks kill <id>`).
+ * @returns {boolean} true if a running task with that id was signalled
+ */
+export function killBackgroundShellTask(id) {
+  const task = _backgroundShellTasks.get(id);
+  if (!task) return false;
+  return _killTask(task);
+}
+
 /**
  * Kill every still-running background shell task. Callers (REPL exit, headless
  * shutdown) invoke this so a backgrounded `npm run dev` doesn't outlive the
@@ -241,7 +251,9 @@ async function runSettingsPreToolUseHooks(name, args, context, cwd) {
     if (ide?.outcome === "accepted") {
       return { blocked: false, ideApplied: ide.result };
     }
-    if (ide?.outcome === "rejected") {
+    // Both rejected and changes-requested mean "not applied + feed the
+    // verdict's message back" — same control flow, different message body.
+    if (ide?.outcome === "rejected" || ide?.outcome === "changes-requested") {
       return {
         blocked: true,
         reason: ide.result.error,
@@ -714,8 +726,12 @@ async function tryIdeDiffApprovalForEdit(
   if (typeof context.permissionConfirm !== "function") return null; // interactive only
   if (!context.mcpClient || !context.externalToolExecutors) return null;
   try {
-    const { ideDiffApprovalEnabled, hasIdeOpenDiff, requestIdeDiffApproval } =
-      await import("../lib/ide-context.js");
+    const {
+      ideDiffApprovalEnabled,
+      hasIdeOpenDiff,
+      requestIdeDiffApproval,
+      formatReviewComments,
+    } = await import("../lib/ide-context.js");
     const mcpLike = {
       mcpClient: context.mcpClient,
       externalToolExecutors: context.externalToolExecutors,
@@ -753,6 +769,25 @@ async function tryIdeDiffApprovalForEdit(
         },
       };
     }
+    if (verdict?.outcome === "changes-requested") {
+      // The reviewer annotated the diff instead of accepting/rejecting: the
+      // file is untouched and the notes flow back as the tool result, so the
+      // agent revises and re-proposes (Claude-Code inline-review parity).
+      const feedback =
+        formatReviewComments(verdict.comments, { path: proposal.filePath }) ||
+        "The user requested changes in the IDE diff review (no specific notes).";
+      return {
+        outcome: "changes-requested",
+        result: {
+          error:
+            `[IDE review] "${name}" was NOT applied — the user requested changes:\n` +
+            `${feedback}\n` +
+            "Revise the edit to address this feedback, then propose it again.",
+          policy: { decision: "deny", rule, via: "ide-diff-review" },
+          reviewComments: verdict.comments,
+        },
+      };
+    }
   } catch (_err) {
     // diff-approval routing is best-effort — fall back to the normal confirm
   }