chainlesschain 0.162.39 → 0.162.40

package/src/lib/repl-bang-memorize.js

@@ -0,0 +1,142 @@
+/**
+ * REPL `!` bash passthrough + `#` quick-memorize (Claude-Code parity).
+ *
+ * Pure logic for two agent-REPL input prefixes, extracted so it is unit
+ * testable without driving readline:
+ *
+ *  - `! <cmd>`  — run the shell command immediately (no LLM round-trip) and
+ *    return a `<bash-input>/<bash-output>` context message so the model sees
+ *    what happened on the next turn. Windows runs through `cmd.exe /d /s /c`
+ *    with a `chcp 65001` prefix (encoding.md rule); POSIX through `/bin/sh -c`.
+ *
+ *  - `# <note>` — append a one-line note to the project memory file (cc.md at
+ *    the git root — the file project-instructions.js auto-loads). Creates the
+ *    file/`## Notes` section when missing; next sessions pick it up
+ *    automatically and the caller can also inject it into the live context.
+ *
+ * All process/fs access goes through `_deps` for tests.
+ */
+
+import { spawnSync as spawnSyncDefault } from "child_process";
+import fsDefault from "fs";
+import pathDefault from "path";
+import { findProjectRoot } from "./project-instructions.js";
+
+export const BANG_TIMEOUT_MS = 120_000;
+export const BANG_MAX_BUFFER = 10 * 1024 * 1024;
+export const BANG_OUTPUT_CAP = 30_000;
+
+export const _deps = {
+  spawnSync: spawnSyncDefault,
+  fs: fsDefault,
+  path: pathDefault,
+};
+
+function cap(s) {
+  const str = s || "";
+  return str.length > BANG_OUTPUT_CAP
+    ? `${str.slice(0, BANG_OUTPUT_CAP)}\n… [truncated]`
+    : str;
+}
+
+/** True when the REPL line is a `!` bash passthrough. */
+export function isBangCommand(trimmed) {
+  return (
+    typeof trimmed === "string" &&
+    trimmed.startsWith("!") &&
+    trimmed.slice(1).trim().length > 0
+  );
+}
+
+/** True when the REPL line is a `#` quick-memorize. */
+export function isMemorizeLine(trimmed) {
+  return (
+    typeof trimmed === "string" &&
+    trimmed.startsWith("#") &&
+    trimmed.slice(1).trim().length > 0
+  );
+}
+
+/**
+ * Run a `!` command synchronously.
+ *
+ * @returns {{ cmd, stdout, stderr, exitCode, error, contextMessage }}
+ *          `contextMessage` is ready to push as a user-role message.
+ */
+export function runBangCommand(line, opts = {}) {
+  const spawnSync = opts.deps?.spawnSync || _deps.spawnSync;
+  const cwd = opts.cwd || process.cwd();
+  const isWin =
+    opts.platform != null ? opts.platform === "win32" : process.platform === "win32";
+  const cmd = String(line).replace(/^!/, "").trim();
+
+  const res = isWin
+    ? spawnSync("cmd.exe", ["/d", "/s", "/c", `chcp 65001 >nul && ${cmd}`], {
+        encoding: "utf-8",
+        timeout: BANG_TIMEOUT_MS,
+        maxBuffer: BANG_MAX_BUFFER,
+        cwd,
+      })
+    : spawnSync("/bin/sh", ["-c", cmd], {
+        encoding: "utf-8",
+        timeout: BANG_TIMEOUT_MS,
+        maxBuffer: BANG_MAX_BUFFER,
+        cwd,
+      });
+
+  const exitCode = res.status == null ? (res.error ? -1 : 0) : res.status;
+  const stdout = cap(res.stdout);
+  const stderr = cap(res.stderr);
+  const body = [stdout, stderr].filter(Boolean).join("\n");
+  return {
+    cmd,
+    stdout,
+    stderr,
+    exitCode,
+    error: res.error || null,
+    contextMessage: {
+      role: "user",
+      content: `<bash-input>${cmd}</bash-input>\n<bash-output exit-code="${exitCode}">\n${body}\n</bash-output>`,
+    },
+  };
+}
+
+/**
+ * Append a `#` note to the project cc.md (created at the git root — falls
+ * back to cwd outside a repo). Inserts under a `## Notes` heading, creating
+ * file/section as needed.
+ *
+ * @returns {{ target, line, created }}
+ */
+export function appendMemoryNote(rawLine, opts = {}) {
+  const fs = opts.deps?.fs || _deps.fs;
+  const path = opts.deps?.path || _deps.path;
+  const cwd = opts.cwd || process.cwd();
+  const note = String(rawLine).replace(/^#/, "").trim();
+  const stamp = opts.date || new Date().toISOString().slice(0, 10);
+
+  const root =
+    findProjectRoot(cwd, { deps: { fs, path } }) || path.resolve(cwd);
+  const target = opts.target || path.join(root, "cc.md");
+  const line = `- ${note} _(noted ${stamp})_`;
+
+  let text = null;
+  try {
+    text = fs.readFileSync(target, "utf-8");
+  } catch {
+    /* file does not exist yet */
+  }
+
+  let created = false;
+  if (text == null) {
+    text = `# Project Memory\n\n## Notes\n\n${line}\n`;
+    created = true;
+  } else if (/^## Notes\s*$/m.test(text)) {
+    // insert right after the heading (keeps newest notes on top)
+    text = text.replace(/^## Notes\s*$/m, (m) => `${m}\n\n${line}`);
+  } else {
+    text = `${text.trimEnd()}\n\n## Notes\n\n${line}\n`;
+  }
+  fs.writeFileSync(target, text, "utf-8");
+  return { target, line, note, created };
+}

package/src/lib/repl-completer.js

@@ -78,9 +78,12 @@ export function fileCandidates(prefix, { cwd = process.cwd(), deps } = {}) {
 
 /**
  * Build a readline completer. Returns `completer(line)` → `[hits, replaced]`
- * per the readline contract; non-@ lines complete to nothing.
+ * per the readline contract. Completes `@path` tokens anywhere in the line
+ * and `/command` names at line start (while the command token is still being
+ * typed); everything else completes to nothing.
  *
- * @param {object} opts { cwd?, getIdeOpenFiles?: () => Promise<string[]>, deps? }
+ * @param {object} opts { cwd?, getIdeOpenFiles?: () => Promise<string[]>,
+ *                        slashCommands?: string[], deps? }
  */
 export function makeAtCompleter(opts = {}) {
   const cwd = opts.cwd || process.cwd();
@@ -118,7 +121,19 @@ export function makeAtCompleter(opts = {}) {
       });
   };
 
+  const slashCommands = Array.isArray(opts.slashCommands)
+    ? [...opts.slashCommands].sort()
+    : [];
+
   const completer = (line) => {
+    // `/command` completion (Claude-Code parity): only while typing the
+    // command token itself — once a space follows, args are the user's.
+    const slash = /^\/([A-Za-z_-]*)$/.exec(line);
+    if (slash && slashCommands.length) {
+      const pref = `/${slash[1].toLowerCase()}`;
+      const hits = slashCommands.filter((c) => c.toLowerCase().startsWith(pref));
+      return [hits, line];
+    }
     const at = extractAtPrefix(line);
     if (!at) return [[], line];
     refreshIde(); // async top-up for the NEXT tab; this one uses the cache

package/src/lib/update-notice-refresh.mjs

@@ -0,0 +1,10 @@
+/**
+ * Detached cache refresher for the startup update notice.
+ * Spawned unref'd by update-notice.js; argv[2] = cache file path.
+ * Exits quietly on any failure — the notice is strictly best-effort.
+ */
+import { refreshCacheOnce } from "./update-notice.js";
+
+refreshCacheOnce({ cacheFile: process.argv[2] })
+  .catch(() => {})
+  .finally(() => process.exit(0));

package/src/lib/update-notice.js

@@ -0,0 +1,154 @@
+/**
+ * Startup update notice — Claude-Code-style "new version available" line.
+ *
+ * Zero startup cost by design:
+ *  - the CLI entry only does ONE sync cache read (~/.chainlesschain/
+ *    update-check.json) and prints a single gray stderr line when the cached
+ *    latest version is newer than the running one (TTY only, never pollutes
+ *    piped/JSON output);
+ *  - when the cache is stale (>24h) it spawns a DETACHED, unref'd child that
+ *    refreshes the cache from the npm registry for the NEXT run — the current
+ *    invocation never waits on the network. The cache's checkedAt is touched
+ *    optimistically before spawning so concurrent invocations don't stampede.
+ *
+ * Disable with CC_UPDATE_NOTICE=0. `cc update` remains the full interactive
+ * checker (GitHub releases + assets); this is just the passive nudge.
+ */
+
+import fsDefault from "fs";
+import pathDefault from "path";
+import osDefault from "os";
+import { spawn as spawnDefault } from "child_process";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+import semver from "semver";
+import { VERSION } from "../constants.js";
+
+export const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+export const NPM_LATEST_URL = "https://registry.npmjs.org/chainlesschain/latest";
+
+export const _deps = {
+  fs: fsDefault,
+  path: pathDefault,
+  os: osDefault,
+  spawn: spawnDefault,
+};
+
+export function cachePath(deps = _deps) {
+  return deps.path.join(
+    deps.os.homedir() || "",
+    ".chainlesschain",
+    "update-check.json",
+  );
+}
+
+function readCache(deps) {
+  try {
+    return JSON.parse(deps.fs.readFileSync(cachePath(deps), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(deps, cache) {
+  try {
+    const p = cachePath(deps);
+    deps.fs.mkdirSync(deps.path.dirname(p), { recursive: true });
+    deps.fs.writeFileSync(p, JSON.stringify(cache), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Entry-point hook. Cheap and fail-open — never throws, never blocks.
+ *
+ * @returns {{ printed: boolean, spawned: boolean }}
+ */
+export function maybeNotifyUpdate(opts = {}) {
+  const deps = { ..._deps, ...(opts.deps || {}) };
+  const env = opts.env || process.env;
+  const now = opts.now ?? Date.now();
+  const isTTY = opts.isTTY ?? Boolean(process.stderr.isTTY);
+  const current = opts.currentVersion || VERSION;
+  const print =
+    opts.print || ((line) => process.stderr.write(chalk.gray(line) + "\n"));
+
+  const out = { printed: false, spawned: false };
+  try {
+    if (env.CC_UPDATE_NOTICE === "0") return out;
+
+    const cache = readCache(deps);
+
+    if (
+      isTTY &&
+      cache?.latest &&
+      semver.valid(cache.latest) &&
+      semver.valid(current) &&
+      semver.gt(cache.latest, current)
+    ) {
+      print(
+        `Update available: chainlesschain ${current} → ${cache.latest} (npm i -g chainlesschain · CC_UPDATE_NOTICE=0 to hide)`,
+      );
+      out.printed = true;
+    }
+
+    const stale = !cache?.checkedAt || now - cache.checkedAt > CACHE_TTL_MS;
+    if (stale) {
+      // Optimistic touch first: parallel `cc` invocations inside the stale
+      // window won't each spawn a refresher.
+      writeCache(deps, { ...(cache || {}), checkedAt: now });
+      const refresher = deps.path.join(
+        deps.path.dirname(fileURLToPath(import.meta.url)),
+        "update-notice-refresh.mjs",
+      );
+      const child = deps.spawn(
+        process.execPath,
+        [refresher, cachePath(deps)],
+        { detached: true, stdio: "ignore", windowsHide: true },
+      );
+      if (child && typeof child.unref === "function") child.unref();
+      out.spawned = true;
+    }
+  } catch {
+    /* fail-open: a broken cache or spawn must never affect the CLI */
+  }
+  return out;
+}
+
+/**
+ * One cache refresh (used by the detached child; exported for tests).
+ * npm registry only — light, unauthenticated, no GitHub rate-limit risk.
+ */
+export async function refreshCacheOnce({
+  cacheFile,
+  fetchImpl = fetch,
+  deps = _deps,
+  now = Date.now(),
+  timeoutMs = 10_000,
+} = {}) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(NPM_LATEST_URL, {
+      headers: { Accept: "application/json" },
+      signal: ctrl.signal,
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const data = await res.json();
+    if (!data?.version) throw new Error("no version field");
+    const file = cacheFile || cachePath(deps);
+    deps.fs.mkdirSync(deps.path.dirname(file), { recursive: true });
+    deps.fs.writeFileSync(
+      file,
+      JSON.stringify({ checkedAt: now, latest: data.version }),
+      "utf-8",
+    );
+    return { ok: true, latest: data.version };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/repl/agent-repl.js

@@ -737,6 +737,30 @@ export async function startAgentRepl(options = {}) {
   const { makeAtCompleter } = await import("../lib/repl-completer.js");
   const atCompleter = makeAtCompleter({
     cwd: process.cwd(),
+    // Keep in sync with the rl.on("line") handlers + /help below.
+    slashCommands: [
+      "/auto",
+      "/clear",
+      "/compact",
+      "/context",
+      "/cowork",
+      "/exit",
+      "/help",
+      "/mcp",
+      "/model",
+      "/output-style",
+      "/plan",
+      "/profile",
+      "/provider",
+      "/quit",
+      "/reindex",
+      "/search",
+      "/session",
+      "/stats",
+      "/statusline",
+      "/sub-agents",
+      "/task",
+    ],
     getIdeOpenFiles: async () => {
       const exec = _adhocMcp?.externalToolExecutors?.mcp__ide__getOpenEditors;
       if (!exec || exec.kind !== "mcp" || !_adhocMcp?.mcpClient?.callTool) {
@@ -854,6 +878,45 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    // `!` bash passthrough (Claude-Code parity): run the command right here —
+    // no LLM round-trip — and fold the output into the conversation context.
+    if (trimmed.startsWith("!") && trimmed.slice(1).trim()) {
+      try {
+        const { runBangCommand } = await import("../lib/repl-bang-memorize.js");
+        const res = runBangCommand(trimmed, { cwd: process.cwd() });
+        logger.log(chalk.gray(`$ ${res.cmd}`));
+        if (res.stdout) process.stdout.write(res.stdout.endsWith("\n") ? res.stdout : `${res.stdout}\n`);
+        if (res.stderr) process.stderr.write(chalk.red(res.stderr.endsWith("\n") ? res.stderr : `${res.stderr}\n`));
+        if (res.error) logger.error(`shell error: ${res.error.message}`);
+        logger.log(chalk.gray(`(exit ${res.exitCode})`));
+        messages.push(res.contextMessage);
+      } catch (err) {
+        logger.error(`! command failed: ${err.message}`);
+      }
+      prompt();
+      return;
+    }
+
+    // `#` quick-memorize (Claude-Code parity): append a note to the project
+    // cc.md (auto-loaded next session) and keep it active in this one.
+    if (trimmed.startsWith("#") && trimmed.slice(1).trim()) {
+      try {
+        const { appendMemoryNote } = await import("../lib/repl-bang-memorize.js");
+        const res = appendMemoryNote(trimmed, { cwd: process.cwd() });
+        messages.push({
+          role: "system",
+          content: `<memory-note source="${res.target}">${res.note}</memory-note>`,
+        });
+        logger.log(
+          chalk.green(`✔ remembered in ${res.target}${res.created ? " (created)" : ""}`),
+        );
+      } catch (err) {
+        logger.error(`# memorize failed: ${err.message}`);
+      }
+      prompt();
+      return;
+    }
+
     // Slash commands
     if (trimmed === "/exit" || trimmed === "/quit") {
       logger.log(chalk.gray("\nGoodbye!"));
@@ -863,6 +926,12 @@ export async function startAgentRepl(options = {}) {
 
     if (trimmed === "/help") {
       logger.log(chalk.bold("\nCommands:"));
+      logger.log(
+        `  ${chalk.cyan("! <cmd>")}     Run a shell command directly (output joins context)`,
+      );
+      logger.log(
+        `  ${chalk.cyan("# <note>")}    Remember a note in the project cc.md`,
+      );
       logger.log(`  ${chalk.cyan("/exit")}       Exit the agent`);
       logger.log(
         `  ${chalk.cyan("/model")}      Show/change model (/model <name>)`,
@@ -872,6 +941,9 @@ export async function startAgentRepl(options = {}) {
       logger.log(
         `  ${chalk.cyan("/statusline")} Context-usage line on/off (/statusline [on|off])`,
       );
+      logger.log(
+        `  ${chalk.cyan("/context")}    Live context-window usage by role`,
+      );
       logger.log(
         `  ${chalk.cyan("/compact")}    Smart compact (importance-based)`,
       );
@@ -1110,6 +1182,52 @@ export async function startAgentRepl(options = {}) {
       return;
     }
 
+    if (trimmed === "/context") {
+      // Live-session twin of `cc context` (Claude-Code /context parity):
+      // bucket the CURRENT in-memory conversation by role against the model
+      // window. Reuses the same categorizer + estimator as the archived view.
+      try {
+        const { categorizeContext } = await import("../commands/context.js");
+        const { estimateTokens } = await import(
+          "../harness/prompt-compressor.js"
+        );
+        const { buckets, counts, total } = categorizeContext(
+          messages,
+          estimateTokens,
+        );
+        const window = getContextWindow(model, provider) || 0;
+        logger.log(chalk.bold("\nContext usage (live session):"));
+        const rows = [
+          ["system", buckets.system, counts.system],
+          ["user", buckets.user, counts.user],
+          ["assistant", buckets.assistant, counts.assistant],
+          ["tool", buckets.tool, counts.tool],
+          ["tool_calls", buckets.toolCalls, null],
+        ];
+        for (const [label, tok, n] of rows) {
+          if (!tok) continue;
+          const share = total ? Math.round((tok / total) * 100) : 0;
+          logger.log(
+            `  ${label.padEnd(11)}${String(tok).padStart(9)} tok ${String(share).padStart(3)}%${
+              n != null ? chalk.gray(`  (${n} msgs)`) : ""
+            }`,
+          );
+        }
+        const pct = window ? Math.round((total / window) * 100) : null;
+        logger.log(
+          `  ${"total".padEnd(11)}${String(total).padStart(9)} tok${
+            window
+              ? `  ${pct}% of ${window} (${Math.max(0, window - total)} left)`
+              : ""
+          }`,
+        );
+      } catch (err) {
+        logger.error(`/context failed: ${err.message}`);
+      }
+      prompt();
+      return;
+    }
+
     if (trimmed === "/compact") {
       if (_compressor && messages.length > 3) {
         const { messages: compacted, stats } = await _compressor.compress(

package/src/runtime/agent-core.js

@@ -230,6 +230,25 @@ async function runSettingsPreToolUseHooks(name, args, context, cwd) {
     return { blocked: true, reason: outcome.reason, hook: outcome.hook };
   }
   if (outcome.decision === "ask") {
+    // File edits in an interactive session with an IDE bridge: route the ask
+    // through the editor's openDiff review (same machinery as settings ask —
+    // accepted means the IDE wrote the file, so the caller must skip
+    // execution; see tryIdeDiffApprovalForEdit).
+    const ide = await tryIdeDiffApprovalForEdit(name, args, context, cwd, {
+      rule: `hook:${outcome.hook}`,
+      source: "PreToolUse hook",
+    });
+    if (ide?.outcome === "accepted") {
+      return { blocked: false, ideApplied: ide.result };
+    }
+    if (ide?.outcome === "rejected") {
+      return {
+        blocked: true,
+        reason: ide.result.error,
+        hook: outcome.hook,
+        ideResult: ide.result,
+      };
+    }
     const confirm = context.permissionConfirm || context.shellConfirm || null;
     const ok =
       typeof confirm === "function"
@@ -603,6 +622,133 @@ export function buildSystemPrompt(cwd, opts = {}) {
 
 // ─── Tool execution ──────────────────────────────────────────────────────
 
+/** The file-mutating tools whose `ask` can be reviewed as an IDE diff. */
+const IDE_DIFF_EDIT_TOOLS = new Set([
+  "write_file",
+  "edit_file",
+  "edit_file_hashed",
+]);
+
+/**
+ * Compute the content an edit tool WOULD write, without writing it — the
+ * left/right sides for an IDE diff review. Mirrors the corresponding
+ * executeToolInner cases exactly (write_file / edit_file / edit_file_hashed,
+ * the latter via the same pure replaceByHash). Returns
+ * `{ filePath, newContent, originalText|null }` or null when the edit cannot
+ * be computed (missing file, anchor/old_string miss, bad args) — the caller
+ * then falls back to the normal confirmation path so the tool can produce its
+ * own diagnostics.
+ */
+export function computeProposedEdit(name, args = {}, cwd = process.cwd()) {
+  try {
+    if (!args.path) return null;
+    const filePath = path.resolve(cwd, args.path);
+    if (name === "write_file") {
+      if (typeof args.content !== "string") return null;
+      const originalText = fs.existsSync(filePath)
+        ? fs.readFileSync(filePath, "utf8")
+        : "";
+      return { filePath, newContent: args.content, originalText };
+    }
+    if (name === "edit_file") {
+      if (!fs.existsSync(filePath)) return null;
+      const content = fs.readFileSync(filePath, "utf8");
+      if (
+        typeof args.old_string !== "string" ||
+        !content.includes(args.old_string)
+      ) {
+        return null;
+      }
+      return {
+        filePath,
+        newContent: content.replace(args.old_string, args.new_string),
+        originalText: content,
+      };
+    }
+    if (name === "edit_file_hashed") {
+      if (!fs.existsSync(filePath)) return null;
+      if (!args.anchor_hash || typeof args.new_line !== "string") return null;
+      const original = fs.readFileSync(filePath, "utf8");
+      const result = replaceByHash(original, {
+        anchorHash: args.anchor_hash,
+        expectedLine: args.expected_line,
+        newLine: args.new_line,
+      });
+      if (!result.success) return null;
+      return { filePath, newContent: result.content, originalText: original };
+    }
+  } catch {
+    // unreadable file etc. → no proposal, normal path handles it
+  }
+  return null;
+}
+
+/**
+ * Shared IDE-diff approval routing for an `ask` decision about a file edit
+ * (used by BOTH the settings-rules ask and the PreToolUse-hook ask). Returns
+ *   { outcome:"accepted", result }  — the IDE wrote the file; the caller MUST
+ *                                     return `result` and skip execution
+ *   { outcome:"rejected", result }  — deny with `result`, file untouched
+ *   null                            — not applicable (non-edit tool, headless,
+ *                                     no IDE, disabled, no proposal, IDE died)
+ *                                     → caller falls back to its own confirm.
+ */
+async function tryIdeDiffApprovalForEdit(
+  name,
+  args,
+  context,
+  cwd,
+  { rule, source } = {},
+) {
+  if (!IDE_DIFF_EDIT_TOOLS.has(name)) return null;
+  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 mcpLike = {
+      mcpClient: context.mcpClient,
+      externalToolExecutors: context.externalToolExecutors,
+    };
+    if (!ideDiffApprovalEnabled() || !hasIdeOpenDiff(mcpLike)) return null;
+    const proposal = computeProposedEdit(name, args, cwd);
+    if (!proposal) return null;
+    const verdict = await requestIdeDiffApproval(mcpLike, {
+      path: proposal.filePath,
+      modifiedText: proposal.newContent,
+      originalText: proposal.originalText,
+      title: `cc agent: ${name} ${path.basename(proposal.filePath)}`,
+    });
+    if (verdict?.outcome === "accepted") {
+      return {
+        outcome: "accepted",
+        result: {
+          success: true,
+          path: proposal.filePath,
+          appliedVia: "ide-diff",
+          ...(verdict.finalText != null &&
+          verdict.finalText !== proposal.newContent
+            ? { userEdited: true }
+            : {}),
+          policy: { decision: "allow", rule, via: "ide-diff" },
+        },
+      };
+    }
+    if (verdict?.outcome === "rejected") {
+      return {
+        outcome: "rejected",
+        result: {
+          error: `[Permission] "${name}" was rejected in the IDE diff review (${source}: ${rule}).`,
+          policy: { decision: "deny", rule, via: "ide-diff" },
+        },
+      };
+    }
+  } catch (_err) {
+    // diff-approval routing is best-effort — fall back to the normal confirm
+  }
+  return null;
+}
+
 /**
  * Execute a single tool call with plan-mode filtering and hook pipeline.
  *
@@ -719,6 +865,17 @@ export async function executeTool(name, args, context = {}) {
   // 3 + 4. settings ask / allow (only reached when neither layer denied)
   let ruleAllowed = false;
   if (settingsVerdict.decision === "ask") {
+    // IDE-native diff approval (Claude-Code parity): for file edits in an
+    // interactive session with an IDE bridge connected, review the edit in
+    // the editor instead of a terminal y/N. Accepted = the IDE wrote the
+    // file → return the synthetic result and SKIP execution; rejected =
+    // deny; null = fall through to the normal confirm below. Shared with the
+    // PreToolUse-hook ask path (tryIdeDiffApprovalForEdit).
+    const ide = await tryIdeDiffApprovalForEdit(name, args, context, cwd, {
+      rule: settingsVerdict.rule,
+      source: "settings rule",
+    });
+    if (ide) return ide.result;
     const confirm = context.permissionConfirm || context.shellConfirm || null;
     const ok =
       typeof confirm === "function"
@@ -792,7 +949,12 @@ export async function executeTool(name, args, context = {}) {
   }
   if (context.settingsHooks) {
     const pre = await runSettingsPreToolUseHooks(name, args, context, cwd);
+    // A hook `ask` resolved by the IDE diff review: accepted → the IDE
+    // already wrote the file, return the synthetic result and skip the tool;
+    // rejected → the ide-diff deny shape (via:"ide-diff", not via:"hook").
+    if (pre.ideApplied) return pre.ideApplied;
     if (pre.blocked) {
+      if (pre.ideResult) return pre.ideResult;
       return {
         error: `[Hook] PreToolUse blocked "${name}"${pre.reason ? ": " + pre.reason : ""}`,
         policy: { decision: "block", via: "hook", hook: pre.hook || null },