chainlesschain 0.162.174 → 0.162.176

package/src/lib/mcp-oauth.js

@@ -25,7 +25,7 @@ import pathDefault from "node:path";
 import { homedir as homedirDefault } from "node:os";
 import crypto from "node:crypto";
 import http from "node:http";
-import { spawn } from "node:child_process";
+import { executionBroker } from "./process-execution-broker/index.js";
 
 export const _deps = {
   fetch: (...a) => globalThis.fetch(...a),
@@ -35,7 +35,13 @@ export const _deps = {
   sha256: (s) => crypto.createHash("sha256").update(s).digest(),
   createServer: (h) => http.createServer(h),
   openBrowser: defaultOpenBrowser,
-  spawn: (...a) => spawn(...a),
+  spawn: (command, args, options) =>
+    executionBroker.spawn(command, args, {
+      ...options,
+      origin: "mcp:oauth-browser",
+      policy: "allow",
+      scope: "oauth",
+    }),
   now: () => Date.now(),
   // Backoff sleep seam (tests override with a no-op so the retry doesn't wait).
   sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),

package/src/lib/npm-invocation.js

@@ -0,0 +1,29 @@
+import path from "node:path";
+
+/**
+ * Resolve npm without asking a shell to interpret the platform shim.
+ *
+ * Windows npm installations expose `npm.cmd`, but Node cannot execute a CMD
+ * shim with `shell:false` (`spawnSync npm.cmd EINVAL`). The shim delegates to
+ * the npm CLI located beside node.exe, so invoke that JavaScript entrypoint
+ * through the current Node executable instead.
+ */
+export function resolveNpmInvocation({
+  platform = process.platform,
+  execPath = process.execPath,
+} = {}) {
+  if (platform !== "win32") {
+    return { command: "npm", prefixArgs: [] };
+  }
+
+  const npmCliPath = path.win32.join(
+    path.win32.dirname(execPath),
+    "node_modules",
+    "npm",
+    "bin",
+    "npm-cli.js",
+  );
+  return { command: execPath, prefixArgs: [npmCliPath] };
+}
+
+export default resolveNpmInvocation;

package/src/lib/packer/pkg-runner.js

@@ -14,8 +14,12 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
-import { spawnSync } from "node:child_process";
 import { PackError, EXIT } from "./errors.js";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+};
 
 /**
  * @param {object} ctx
@@ -47,12 +51,19 @@ export function runPkg(ctx) {
   ];
 
   log(`  [pkg] Running: ${pkgBin.runtime} ${args.join(" ")}`);
-  const res = spawnSync(pkgBin.runtime, args, {
+  const res = _deps.spawnSync(pkgBin.runtime, args, {
+    origin: "packer:pkg",
+    scope: "pack",
+    policy: "allow",
+    shell: false,
     cwd: path.dirname(pkgConfigFile),
     stdio: "inherit",
     windowsHide: true,
   });
 
+  if (res.error) {
+    throw new PackError(`Failed to start pkg: ${res.error.message}`, EXIT.PKG);
+  }
   if (res.status !== 0) {
     throw new PackError(
       `pkg exited with code ${res.status}. See output above for details.`,

package/src/lib/packer/precheck.js

@@ -5,9 +5,13 @@
 
 import fs from "node:fs";
 import path from "node:path";
-import { execSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { PackError, EXIT } from "./errors.js";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  execFileSync: (...args) => executionBroker.execFileSync(...args),
+};
 
 const WINDOWS_RESERVED = new Set([
   "CON",
@@ -139,22 +143,35 @@ export function precheck(ctx) {
   let gitCommit = null;
   let dirty = false;
   let repoRoot = null;
+  const gitOptions = (cwd) => ({
+    origin: "packer:precheck-git",
+    scope: "pack",
+    policy: "allow",
+    shell: false,
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "ignore"],
+  });
   try {
-    repoRoot = execSync("git rev-parse --show-toplevel", {
-      cwd: projectRoot,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    gitCommit = execSync("git rev-parse --short HEAD", {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-    const status = execSync("git status --porcelain", {
-      cwd: repoRoot,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    });
+    repoRoot = _deps
+      .execFileSync(
+        "git",
+        ["rev-parse", "--show-toplevel"],
+        gitOptions(projectRoot),
+      )
+      .trim();
+    gitCommit = _deps
+      .execFileSync(
+        "git",
+        ["rev-parse", "--short", "HEAD"],
+        gitOptions(repoRoot),
+      )
+      .trim();
+    const status = _deps.execFileSync(
+      "git",
+      ["status", "--porcelain"],
+      gitOptions(repoRoot),
+    );
     dirty = status.trim().length > 0;
   } catch (_e) {
     // Not a git repo — fine, leave the metadata null

package/src/lib/packer/web-panel-builder.js

@@ -10,8 +10,12 @@
 
 import fs from "node:fs";
 import path from "node:path";
-import { spawnSync } from "node:child_process";
 import { PackError, EXIT } from "./errors.js";
+import executionBroker from "../process-execution-broker/index.js";
+
+export const _deps = {
+  spawnSync: (...args) => executionBroker.spawnSync(...args),
+};
 
 /**
  * @param {object} ctx
@@ -50,11 +54,21 @@ export function ensureWebPanel(ctx) {
   if (needsBuild) {
     log("  [web-panel] Building Vue panel via 'npm run build:web-panel'...");
     const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
-    const res = spawnSync(npmCmd, ["run", "build:web-panel"], {
+    const res = _deps.spawnSync(npmCmd, ["run", "build:web-panel"], {
+      origin: "packer:web-panel-build",
+      scope: "pack",
+      policy: "allow",
+      shell: false,
       cwd: cliRoot,
       stdio: "inherit",
       windowsHide: true,
     });
+    if (res.error) {
+      throw new PackError(
+        `Failed to start 'npm run build:web-panel': ${res.error.message}`,
+        EXIT.WEB_PANEL,
+      );
+    }
     if (res.status !== 0) {
       throw new PackError(
         `'npm run build:web-panel' exited with code ${res.status}`,

package/src/lib/permission-rules.cjs

@@ -61,7 +61,7 @@ const TOOL_GROUPS = Object.freeze({
   grep: ["search_files"],
   glob: ["search_files"],
   write: ["write_file"],
-  edit: ["edit_file", "edit_file_hashed"],
+  edit: ["edit_file", "edit_file_hashed", "delete_file", "move_file"],
   webfetch: ["web_fetch"],
   websearch: ["web_search"],
   task: ["spawn_sub_agent"],
@@ -82,6 +82,8 @@ const PATH_TOOLS = new Set([
   "write_file",
   "edit_file",
   "edit_file_hashed",
+  "delete_file",
+  "move_file",
 ]);
 /** Tools whose match target is a URL. */
 const URL_TOOLS = new Set(["web_fetch"]);
@@ -354,6 +356,8 @@ const SUGGEST_UMBRELLA = Object.freeze({
   write_file: "Write",
   edit_file: "Edit",
   edit_file_hashed: "Edit",
+  delete_file: "Edit",
+  move_file: "Edit",
   web_fetch: "WebFetch",
   web_search: "WebSearch",
   spawn_sub_agent: "Task",

package/src/lib/personal-data-hub-aichat-wizard.js

@@ -141,7 +141,11 @@ export function createAccountsStore({ hubDir }) {
  * spec.validateCookie(). Kept duplicated so the cli build stays ESM-pure
  * without reaching into desktop-app-vue.
  */
-export function createVendorAdapterBridge({ specs, _httpClientFactory } = {}) {
+export function createVendorAdapterBridge({
+  specs,
+  runtimeAdapter,
+  _httpClientFactory,
+} = {}) {
   // DEFAULT_VENDOR_SPECS is shipped as a vendor-keyed object; tests pass an
   // array. Normalize to an array first so byVendor lookup works either way.
   const effectiveSpecs = specs ?? _loadAichatModule().DEFAULT_VENDOR_SPECS;
@@ -187,7 +191,15 @@ export function createVendorAdapterBridge({ specs, _httpClientFactory } = {}) {
     });
     try {
       const r = await spec.validateCookie({ httpClient: client, session });
-      return r || { ok: false, reason: "VALIDATE_RETURNED_NULL" };
+      const result = r || { ok: false, reason: "VALIDATE_RETURNED_NULL" };
+      if (
+        result.ok &&
+        runtimeAdapter &&
+        typeof runtimeAdapter.setSession === "function"
+      ) {
+        runtimeAdapter.setSession(vendor, session);
+      }
+      return result;
     } catch (err) {
       return { ok: false, reason: "VALIDATE_THREW", error: err.message };
     }
@@ -233,6 +245,8 @@ const _wizardsByHubDir = new Map();
  */
 export function getAIChatWizard({
   hubDir,
+  accountsStore,
+  vendorAdapter,
   _accountsStore,
   _vendorAdapter,
   _deps,
@@ -242,8 +256,10 @@ export function getAIChatWizard({
   if (!isTest && _wizardsByHubDir.has(hubDir))
     return _wizardsByHubDir.get(hubDir);
 
-  const accountsStore = _accountsStore || createAccountsStore({ hubDir });
-  const vendorAdapter = _vendorAdapter || createVendorAdapterBridge();
+  const effectiveAccountsStore =
+    accountsStore || _accountsStore || createAccountsStore({ hubDir });
+  const effectiveVendorAdapter =
+    vendorAdapter || _vendorAdapter || createVendorAdapterBridge();
   // Paste-mode is the default for cli. Tests can override via _deps.
   const deps = _deps || {
     sessionFactory: () => ({}),
@@ -273,8 +289,8 @@ export function getAIChatWizard({
     "@chainlesschain/personal-data-hub/adapters/ai-chat-history/wizard-controller",
   );
   const wiz = createAIChatWizardController({
-    accountsStore,
-    vendorAdapter,
+    accountsStore: effectiveAccountsStore,
+    vendorAdapter: effectiveVendorAdapter,
     _deps: deps,
   });
   if (!isTest) _wizardsByHubDir.set(hubDir, wiz);

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

@@ -136,6 +136,7 @@ let LocalVault,
   AmapAdapter,
   TelegramAdapter,
   WhatsAppAdapter,
+  AIChatHistoryAdapter,
   EntityResolver,
   EntityResolverEmbeddingStage,
   EntityResolverLLMStage,
@@ -259,6 +260,7 @@ function ensurePdhLoaded() {
         AmapAdapter,
         TelegramAdapter,
         WhatsAppAdapter,
+        AIChatHistoryAdapter,
         EntityResolver,
         EntityResolverEmbeddingStage,
         EntityResolverLLMStage,
@@ -587,6 +589,8 @@ async function initHub() {
       // KuaishouSignBridge.
       const { createKuaishouCookiesExtension } =
         await import("@chainlesschain/personal-data-hub/adapters/social-kuaishou-adb");
+      const { createWhatsAppBackupExtension } =
+        await import("@chainlesschain/personal-data-hub/adapters/messaging-whatsapp");
       hostAdbBridge = createHostAdbBridge({
         extensions: {
           "bilibili.cookies": createBilibiliCookiesExtension(),
@@ -597,6 +601,7 @@ async function initHub() {
           "toutiao.cookies": createToutiaoCookiesExtension(),
           "toutiao.account": createToutiaoAccountExtension(),
           "kuaishou.cookies": createKuaishouCookiesExtension(),
+          "whatsapp.backup": createWhatsAppBackupExtension(),
         },
       });
       sda._deps.bridgeProvider = () => hostAdbBridge;
@@ -796,7 +801,9 @@ async function initHub() {
     WhatsAppAdapter,
   ]) {
     try {
-      const adapter = new Cls();
+      const adapter = Cls === WhatsAppAdapter
+        ? new Cls({ bridgeProvider: () => hostAdbBridge })
+        : new Cls();
       if (!registry.has(adapter.name)) registry.register(adapter);
     } catch (_err) {
       // Continue boot even if one adapter ctor throws
@@ -838,7 +845,18 @@ async function initHub() {
   // periodic loop still validates persisted cookies so list-aichat-accounts
   // can surface lastHealth reliably.
   const aichatAccountsStore = createAIChatAccountsStore({ hubDir });
-  const aichatVendorAdapter = createAIChatVendorAdapterBridge();
+  const aiChatAdapter = new AIChatHistoryAdapter();
+  try {
+    const persistedAccounts = await aichatAccountsStore.list();
+    aiChatAdapter.restoreSessions(persistedAccounts);
+    if (!registry.has(aiChatAdapter.name)) registry.register(aiChatAdapter);
+  } catch (_err) {
+    // Corrupt rows are skipped by restoreSessions; a store/registry failure
+    // must not prevent the rest of the hub from booting.
+  }
+  const aichatVendorAdapter = createAIChatVendorAdapterBridge({
+    runtimeAdapter: aiChatAdapter,
+  });
   const createAIChatHealthChecker = await loadAIChatHealthChecker();
   const aichatHealthChecker = createAIChatHealthChecker({
     accountsStore: aichatAccountsStore,
@@ -849,7 +867,11 @@ async function initHub() {
   } catch (_err) {
     // Continue boot even if checker fails to schedule
   }
-  const aichatWizard = getAIChatWizard({ hubDir });
+  const aichatWizard = getAIChatWizard({
+    hubDir,
+    accountsStore: aichatAccountsStore,
+    vendorAdapter: aichatVendorAdapter,
+  });
 
   return {
     vault,
@@ -864,6 +886,7 @@ async function initHub() {
     alipayAccountsPath,
     entityResolver,
     aichatAccountsStore,
+    aiChatAdapter,
     aichatWizard,
     aichatHealthChecker,
     analysisSkillNames: ANALYSIS_SKILL_NAMES,
@@ -896,6 +919,7 @@ async function initHub() {
         return { ok: false, reason: "NOT_REGISTERED", vendor };
       }
       await aichatAccountsStore.delete(vendor);
+      aiChatAdapter.clearSession(vendor);
       try {
         await aichatWizard.rotateLoginPartition({ vendor });
       } catch (_err) {

package/src/lib/plan-mode.js

@@ -48,6 +48,8 @@ const READ_TOOLS = new Set([
 const WRITE_TOOLS = new Set([
   "write_file",
   "edit_file",
+  "delete_file",
+  "move_file",
   "run_shell",
   "git",
   "run_skill",
@@ -66,6 +68,8 @@ const TOOL_RISK_WEIGHTS = {
   list_skills: 1,
   write_file: 2,
   edit_file: 2,
+  delete_file: 2,
+  move_file: 2,
   run_skill: 2,
   run_shell: 3,
   git: 3,
@@ -91,6 +95,10 @@ export class PlanItem {
     this.status = data.status || PlanStatus.PENDING;
     this.result = null;
     this.error = null;
+    this.turn = Number.isInteger(data.turn) && data.turn > 0 ? data.turn : null;
+    this.toolUseId = data.toolUseId || null;
+    this.startedAt = data.startedAt || null;
+    this.completedAt = data.completedAt || null;
   }
 
   /**
@@ -109,12 +117,16 @@ export class PlanItem {
  */
 export class ExecutionPlan {
   constructor(data = {}) {
-    this.id = data.id || `plan-${Date.now()}`;
+    this.id =
+      data.id || `plan-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     this.title = data.title || "Untitled Plan";
     this.description = data.description || "";
     this.goal = data.goal || "";
     this.items = (data.items || []).map((i) => new PlanItem(i));
     this.status = data.status || PlanState.ANALYZING;
+    this.version =
+      Number.isInteger(data.version) && data.version > 0 ? data.version : 1;
+    this.revisionOf = data.revisionOf || null;
     this.createdAt = new Date().toISOString();
   }
 
@@ -258,6 +270,7 @@ export class PlanModeManager extends EventEmitter {
     this.currentPlan = null;
     this.history = [];
     this.blockedToolLog = [];
+    this.executionLock = null;
     this._hookDb = null;
   }
 
@@ -289,6 +302,7 @@ export class PlanModeManager extends EventEmitter {
     });
     this.state = PlanState.ANALYZING;
     this.blockedToolLog = [];
+    this.executionLock = null;
 
     this.emit("enter", { plan: this.currentPlan, state: this.state });
     this._fireHook("PlanModeEnter", { planId: this.currentPlan.id });
@@ -311,6 +325,7 @@ export class PlanModeManager extends EventEmitter {
     this.state = PlanState.INACTIVE;
     this.currentPlan = null;
     this.blockedToolLog = [];
+    this.executionLock = null;
 
     this.emit("exit", { plan, reason: options.reason || "manual" });
     return { plan };
@@ -323,6 +338,12 @@ export class PlanModeManager extends EventEmitter {
     if (!this.currentPlan) {
       return { error: "No active plan" };
     }
+    if (
+      this.state !== PlanState.ANALYZING &&
+      this.state !== PlanState.PLAN_READY
+    ) {
+      return { error: "Approved plan is locked" };
+    }
 
     const item = this.currentPlan.addItem(itemData);
     this.emit("item-added", { planId: this.currentPlan.id, item });
@@ -343,6 +364,49 @@ export class PlanModeManager extends EventEmitter {
     return { plan: this.currentPlan };
   }
 
+  /**
+   * Freeze the current draft and start a fresh plan version. This is the only
+   * supported way to replace an awaiting-review plan, so old/new IDE diffs can
+   * bind to stable plan IDs instead of guessing from mutable item arrays.
+   */
+  beginPlanRevision(options = {}) {
+    if (!this.currentPlan || !this.isActive()) {
+      return { error: "No active plan" };
+    }
+    if (
+      this.state !== PlanState.ANALYZING &&
+      this.state !== PlanState.PLAN_READY
+    ) {
+      return { error: "Approved plan is locked" };
+    }
+
+    const previousPlan = this.currentPlan;
+    this.history.push(previousPlan);
+    this.currentPlan = new ExecutionPlan({
+      title: options.title || previousPlan.title,
+      goal: options.goal ?? previousPlan.goal,
+      description: options.description ?? previousPlan.description,
+      version: previousPlan.version + 1,
+      revisionOf: previousPlan.id,
+    });
+    this.state = PlanState.ANALYZING;
+    this.blockedToolLog = [];
+    this.executionLock = null;
+    const payload = {
+      plan: this.currentPlan,
+      previousPlan,
+      reason: String(options.reason || "revision"),
+    };
+    this.emit("plan-revised", payload);
+    this._fireHook("PlanRevised", {
+      planId: this.currentPlan.id,
+      previousPlanId: previousPlan.id,
+      version: this.currentPlan.version,
+      reason: payload.reason,
+    });
+    return payload;
+  }
+
   /**
    * Approve the plan (or specific items)
    */
@@ -362,17 +426,140 @@ export class PlanModeManager extends EventEmitter {
       item.status = PlanStatus.APPROVED;
     }
 
+    this.executionLock = this._buildExecutionLock(
+      approvedItems,
+      options.permissionMode,
+    );
     this.state = PlanState.APPROVED;
     this.currentPlan.status = PlanState.APPROVED;
     this.emit("plan-approved", {
       plan: this.currentPlan,
       approvedCount: approvedItems.length,
+      executionLock: this.getExecutionLock(),
     });
     this._fireHook("PlanApproved", {
       planId: this.currentPlan.id,
       itemCount: approvedItems.length,
+      permissionMode: this.executionLock.permissionMode,
+      allowedTools: this.executionLock.allowedTools,
+    });
+    return {
+      plan: this.currentPlan,
+      approvedCount: approvedItems.length,
+      executionLock: this.getExecutionLock(),
+    };
+  }
+
+  /** Build the immutable authority envelope used after plan approval. */
+  _buildExecutionLock(approvedItems, permissionMode) {
+    const approvedItemIds = approvedItems.map((item) => item.id);
+    const allowedTools = [
+      ...new Set([
+        ...READ_TOOLS,
+        ...approvedItems.map((item) => item.tool).filter(Boolean),
+      ]),
+    ].sort();
+    return Object.freeze({
+      planId: this.currentPlan.id,
+      permissionMode: String(permissionMode || "default"),
+      approvedItemIds: Object.freeze(approvedItemIds),
+      allowedTools: Object.freeze(allowedTools),
+      createdAt: new Date().toISOString(),
     });
-    return { plan: this.currentPlan, approvedCount: approvedItems.length };
+  }
+
+  /** Return a serializable copy so callers cannot widen the live lock. */
+  getExecutionLock() {
+    if (!this.executionLock) return null;
+    return {
+      ...this.executionLock,
+      approvedItemIds: [...this.executionLock.approvedItemIds],
+      allowedTools: [...this.executionLock.allowedTools],
+    };
+  }
+
+  /**
+   * Attribute a live tool call to the next approved item for that tool.
+   * Read-only/helper calls that were not part of the approved plan remain
+   * unbound instead of advancing an unrelated item.
+   */
+  startPlanItemForTool(toolName, context = {}) {
+    if (
+      !this.currentPlan ||
+      (this.state !== PlanState.APPROVED && this.state !== PlanState.EXECUTING)
+    ) {
+      return null;
+    }
+    const tool = String(toolName || "");
+    const item = this.currentPlan.items.find(
+      (candidate) =>
+        candidate.status === PlanStatus.APPROVED && candidate.tool === tool,
+    );
+    if (!item) return null;
+
+    item.status = PlanStatus.EXECUTING;
+    item.toolUseId = context.toolUseId || null;
+    item.turn =
+      Number.isInteger(context.turn) && context.turn > 0 ? context.turn : null;
+    item.startedAt = String(context.startedAt || new Date().toISOString());
+    item.completedAt = null;
+    item.result = null;
+    item.error = null;
+    this.state = PlanState.EXECUTING;
+    this.currentPlan.status = PlanState.EXECUTING;
+    this.emit("item-executing", { planId: this.currentPlan.id, item });
+    this._fireHook("PlanItemExecute", {
+      planId: this.currentPlan.id,
+      itemId: item.id,
+      tool: item.tool,
+      toolUseId: item.toolUseId,
+      turn: item.turn,
+    });
+    return item;
+  }
+
+  /** Settle a tool-attributed item and derive the aggregate execution state. */
+  settlePlanItem(itemId, options = {}) {
+    if (!this.currentPlan || !itemId) return null;
+    const item = this.currentPlan.getItem(itemId);
+    if (!item || item.status !== PlanStatus.EXECUTING) return null;
+
+    const success = options.success !== false;
+    item.status = success ? PlanStatus.COMPLETED : PlanStatus.FAILED;
+    item.completedAt = String(options.completedAt || new Date().toISOString());
+    item.result = success ? (options.result ?? null) : null;
+    item.error = success ? null : String(options.error || "tool failed");
+
+    const tracked = this.currentPlan.items.filter((candidate) =>
+      [
+        PlanStatus.APPROVED,
+        PlanStatus.EXECUTING,
+        PlanStatus.COMPLETED,
+        PlanStatus.FAILED,
+      ].includes(candidate.status),
+    );
+    const allSettled =
+      tracked.length > 0 &&
+      tracked.every((candidate) =>
+        [PlanStatus.COMPLETED, PlanStatus.FAILED].includes(candidate.status),
+      );
+    if (allSettled) {
+      this.state = tracked.some(
+        (candidate) => candidate.status === PlanStatus.FAILED,
+      )
+        ? PlanState.FAILED
+        : PlanState.COMPLETED;
+    } else {
+      this.state = PlanState.EXECUTING;
+    }
+    this.currentPlan.status = this.state;
+    this.emit("item-settled", {
+      planId: this.currentPlan.id,
+      item,
+      success,
+      state: this.state,
+    });
+    return item;
   }
 
   /**
@@ -401,7 +588,10 @@ export class PlanModeManager extends EventEmitter {
       this.state === PlanState.APPROVED ||
       this.state === PlanState.EXECUTING
     ) {
-      return true;
+      const allowed =
+        this.executionLock?.allowedTools.includes(toolName) === true;
+      if (!allowed) this._recordBlockedTool(toolName, "execution-lock");
+      return allowed;
     }
 
     // In analyzing/plan_ready state, only read tools are allowed
@@ -409,11 +599,7 @@ export class PlanModeManager extends EventEmitter {
 
     // Block write tools and log
     if (WRITE_TOOLS.has(toolName)) {
-      this.blockedToolLog.push({
-        tool: toolName,
-        timestamp: new Date().toISOString(),
-      });
-      this.emit("tool-blocked", { toolName });
+      this._recordBlockedTool(toolName, "planning");
       return false;
     }
 
@@ -421,6 +607,15 @@ export class PlanModeManager extends EventEmitter {
     return false;
   }
 
+  _recordBlockedTool(toolName, reason) {
+    this.blockedToolLog.push({
+      tool: toolName,
+      reason,
+      timestamp: new Date().toISOString(),
+    });
+    this.emit("tool-blocked", { toolName, reason });
+  }
+
   /**
    * Generate a text summary of the current plan
    */
@@ -501,9 +696,7 @@ export class PlanModeManager extends EventEmitter {
 
     const allDone = results.every((r) => r.success);
     this.state = allDone ? PlanState.COMPLETED : PlanState.FAILED;
-    this.currentPlan.status = allDone
-      ? PlanState.COMPLETED
-      : PlanState.FAILED;
+    this.currentPlan.status = allDone ? PlanState.COMPLETED : PlanState.FAILED;
 
     return { results, success: allDone };
   }