chainlesschain 0.162.167 → 0.162.168

package/src/harness/worktree-isolator.js

@@ -163,9 +163,17 @@ export function pruneWorktrees(repoDir) {
   return before - after;
 }
 
-export async function isolateTask(repoDir, taskId, fn) {
+export async function isolateTask(repoDir, taskId, fn, options = {}) {
   const branchName = `agent/${taskId}`;
-  const { path: worktreePath } = createWorktree(repoDir, branchName);
+  // options (large-monorepo): { sparsePaths, symlinkDirectories } forwarded to
+  // createWorktree so an isolated task only materializes the packages it needs
+  // and reuses approved dep dirs. Empty/absent → full checkout (byte-identical).
+  const { path: worktreePath } = createWorktree(
+    repoDir,
+    branchName,
+    undefined,
+    options || {},
+  );
 
   try {
     const result = await fn(worktreePath);

package/src/lib/agent-core.js

@@ -46,4 +46,5 @@ export {
   _resetFileFreshness,
   _getSharedCodeIntel,
   disposeSharedCodeIntel,
+  _resetSubtreeInstructionLoaders,
 } from "../runtime/agent-core.js";

package/src/lib/background-phase-reporter.js

@@ -0,0 +1,116 @@
+/**
+ * background-phase-reporter — the missing PRODUCER for the background-agent
+ * `waiting_permission` phase (P0 state-machine slice,
+ * CLAUDE_CODE_CLI_INCREMENTAL_GAP_ANALYSIS_2026-07-12 §"后台 Agent 状态机").
+ *
+ * The consuming contract has existed for a while: `background-agent-phase.js`
+ * normalizes `waiting_permission` and `pendingApprovals > 0` into the
+ * dashboard's "Needs input" group, and `session-lifecycle.js` folds them into
+ * `waitingApproval`. But nothing ever WROTE those fields — the worker only
+ * emits `turn`/`idle`, so a background agent blocked on a human approval
+ * (`--permission-prompt-tool`, `--remote-control`) showed as "Working"
+ * indefinitely while a decision was actually pending.
+ *
+ * The production seam is the agent CHILD process, not the worker: the worker
+ * spawns each turn with `CC_BACKGROUND_AGENT_ID` in the environment, and the
+ * only places a plain headless run genuinely blocks on a human are the
+ * confirmer overrides installed on the ApprovalGate. This module wraps those
+ * confirmers: while one is awaiting a decision it patches the shared state
+ * file with `phase: "waiting_permission"` + a live `pendingApprovals` count,
+ * and restores `phase: "turn"` when every pending approval has settled.
+ *
+ * Safety properties:
+ *  - Disabled (no `CC_BACKGROUND_AGENT_ID`) → `wrapConfirmer` returns the
+ *    SAME function object; zero reads, zero writes, byte-identical behavior
+ *    for every non-background run.
+ *  - Never resurrects a terminal session: writes are skipped when the current
+ *    on-disk status is anything other than absent/"running" (mirrors the
+ *    worker's own writeHeartbeat guard).
+ *  - Best-effort throughout: a state-file hiccup must never break an approval.
+ *  - IO is injectable so tests never touch the real user data dir.
+ */
+
+import {
+  readBackgroundAgentState,
+  writeBackgroundAgentState,
+} from "./background-agent-supervisor.js";
+
+/**
+ * Create a phase reporter for the current process.
+ *
+ * @param {object} [opts]
+ * @param {string|null} [opts.agentId] background session id; defaults to
+ *   `process.env.CC_BACKGROUND_AGENT_ID`. Falsy → disabled no-op reporter.
+ * @param {(id:string)=>object|null} [opts.readState] injectable state reader
+ * @param {(state:object)=>void} [opts.writeState] injectable state writer
+ */
+export function createBackgroundPhaseReporter(opts = {}) {
+  const agentId =
+    opts.agentId !== undefined
+      ? opts.agentId
+      : process.env.CC_BACKGROUND_AGENT_ID;
+  const readState = opts.readState || readBackgroundAgentState;
+  const writeState = opts.writeState || writeBackgroundAgentState;
+  const enabled = typeof agentId === "string" && agentId.trim() !== "";
+  let pending = 0;
+
+  function patch(fields) {
+    if (!enabled) return false;
+    try {
+      const current = readState(agentId) || { id: agentId };
+      // Terminal states are owned by the worker/stopper — never write a
+      // "waiting" phase over a completed/failed/stopped record.
+      if (current.status && current.status !== "running") return false;
+      writeState({ ...current, id: agentId, ...fields });
+      return true;
+    } catch {
+      return false; // state persistence must never break the approval itself
+    }
+  }
+
+  return {
+    enabled,
+    /** Current in-process pending-approval count (for tests/introspection). */
+    pendingCount() {
+      return pending;
+    },
+    /** A human approval just started blocking progress. */
+    beginApproval() {
+      if (!enabled) return;
+      pending++;
+      patch({
+        phase: "waiting_permission",
+        pendingApprovals: pending,
+      });
+    },
+    /** A previously reported approval settled (approved, denied, or failed). */
+    endApproval() {
+      if (!enabled) return;
+      pending = Math.max(0, pending - 1);
+      if (pending === 0) {
+        // Back to a live turn — the worker owns the turn/idle transition, we
+        // only hand the phase back to its steady in-turn value.
+        patch({ phase: "turn", pendingApprovals: 0 });
+      } else {
+        patch({ pendingApprovals: pending });
+      }
+    },
+    /**
+     * Wrap a (potentially human-blocking) confirmer so the pending window is
+     * visible in the background state. Disabled → returns `confirmer`
+     * unchanged (same object identity, zero overhead).
+     */
+    wrapConfirmer(confirmer) {
+      if (!enabled || typeof confirmer !== "function") return confirmer;
+      const self = this;
+      return async function phaseReportingConfirmer(...args) {
+        self.beginApproval();
+        try {
+          return await confirmer(...args);
+        } finally {
+          self.endApproval();
+        }
+      };
+    },
+  };
+}

package/src/lib/hook-runner.cjs

@@ -26,8 +26,9 @@ const {
   buildPowershellArgv,
   loadShellConfig,
 } = require("./shell-selector.cjs");
+const { mergeHookDecisions } = require("./hook-event-bus.cjs");
 
-const _deps = { spawnSync: cpDefault.spawnSync };
+const _deps = { spawnSync: cpDefault.spawnSync, spawn: cpDefault.spawn };
 
 const HOOK_DECISIONS = Object.freeze({
   BLOCK: "block",
@@ -116,43 +117,65 @@ function tryParseDecision(stdout) {
  *            stdout?:string, stderr?:string, additionalContext?:string,
  *            nonBlockingError?:boolean, error?:string }}
  */
+// Circuit breaker (gap 2026-07-11 P2 "Hooks 硬化"): N consecutive non-blocking
+// failures (spawn error / timeout / non-zero non-2 exit) of the SAME command
+// trip an open state — further runs are skipped for a cooldown, then one
+// half-open trial runs; success (or a real block/ask decision) closes it.
+// CC_HOOK_BREAKER_THRESHOLD=0 disables. Extracted so the sync + async runners
+// share ONE breaker implementation.
+function _breakerShortCircuit(command, breaker) {
+  if (breaker.threshold <= 0) return null;
+  const st = _breaker.get(command);
+  if (st && st.fails >= breaker.threshold) {
+    const now = Date.now();
+    if (now - st.openedAt < breaker.cooldownMs) {
+      return {
+        decision: HOOK_DECISIONS.CONTINUE,
+        reason: `hook circuit breaker open (${st.fails} consecutive failures) — skipped for cooldown`,
+        exitCode: null,
+        skipped: true,
+        breakerOpen: true,
+      };
+    }
+    // half-open: let this one trial through; the outcome records below.
+  }
+  return null;
+}
+
+function _breakerRecord(command, breaker, result) {
+  if (breaker.threshold <= 0) return;
+  if (result.nonBlockingError) {
+    const st = _breaker.get(command) || { fails: 0, openedAt: 0 };
+    st.fails += 1;
+    if (st.fails >= breaker.threshold) st.openedAt = Date.now();
+    _breaker.set(command, st);
+  } else {
+    _breaker.delete(command); // success / block / ask closes the breaker
+  }
+}
+
 function runCommandHook(command, input = {}, opts = {}) {
   if (!command) {
     return { decision: HOOK_DECISIONS.CONTINUE, reason: null, exitCode: 0 };
   }
-  // Circuit breaker (gap 2026-07-11 P2 "Hooks 硬化"): N consecutive
-  // non-blocking failures (spawn error / timeout / non-zero non-2 exit) of
-  // the SAME command trip an open state — further runs are skipped for a
-  // cooldown, then one half-open trial runs; success (or a real block/ask
-  // decision) closes it. CC_HOOK_BREAKER_THRESHOLD=0 disables.
   const breaker = hookBreakerConfig();
-  if (breaker.threshold > 0) {
-    const st = _breaker.get(command);
-    if (st && st.fails >= breaker.threshold) {
-      const now = Date.now();
-      if (now - st.openedAt < breaker.cooldownMs) {
-        return {
-          decision: HOOK_DECISIONS.CONTINUE,
-          reason: `hook circuit breaker open (${st.fails} consecutive failures) — skipped for cooldown`,
-          exitCode: null,
-          skipped: true,
-          breakerOpen: true,
-        };
-      }
-      // half-open: let this one trial through; the outcome below decides.
-    }
-  }
+  const shortCircuit = _breakerShortCircuit(command, breaker);
+  if (shortCircuit) return shortCircuit;
   const result = _runCommandHookInner(command, input, opts);
-  if (breaker.threshold > 0) {
-    if (result.nonBlockingError) {
-      const st = _breaker.get(command) || { fails: 0, openedAt: 0 };
-      st.fails += 1;
-      if (st.fails >= breaker.threshold) st.openedAt = Date.now();
-      _breaker.set(command, st);
-    } else {
-      _breaker.delete(command); // success / block / ask closes the breaker
-    }
+  _breakerRecord(command, breaker, result);
+  return result;
+}
+
+/** Async counterpart of runCommandHook (same breaker + protocol). */
+async function runCommandHookAsync(command, input = {}, opts = {}) {
+  if (!command) {
+    return { decision: HOOK_DECISIONS.CONTINUE, reason: null, exitCode: 0 };
   }
+  const breaker = hookBreakerConfig();
+  const shortCircuit = _breakerShortCircuit(command, breaker);
+  if (shortCircuit) return shortCircuit;
+  const result = await _runCommandHookInnerAsync(command, input, opts);
+  _breakerRecord(command, breaker, result);
   return result;
 }
 
@@ -230,7 +253,19 @@ function _runCommandHookInner(command, input = {}, opts = {}) {
       nonBlockingError: true,
     };
   }
-  // spawnSync surfaces timeout/ENOENT on res.error (status null) — non-blocking.
+  return interpretHookOutcome(res);
+}
+
+/**
+ * Interpret a finished hook process — a spawnSync result OR the collected output
+ * of an async spawn — into a normalized decision. The exit-code / JSON-stdout
+ * protocol lives in ONE place so the sync and async runners can never drift.
+ *
+ * @param {{error?:Error|null, status:number|null, stdout?:string, stderr?:string}} res
+ */
+function interpretHookOutcome(res) {
+  // A surfaced spawn error (timeout / ENOENT, status null) is non-blocking — a
+  // broken hook must never wedge the agent; only an explicit block blocks.
   if (res.error) {
     return {
       decision: HOOK_DECISIONS.CONTINUE,
@@ -287,19 +322,157 @@ function _runCommandHookInner(command, input = {}, opts = {}) {
 }
 
 /**
- * Run a list of command hooks in order; first BLOCK (or ASK) short-circuits.
- * @returns {{ decision, reason, hook?, results }}
+ * Async single-hook runner — mirrors _runCommandHookInner but uses async spawn
+ * so a batch can run CONCURRENTLY (see runHooksParallel). stdin gets the JSON
+ * payload; stdout/stderr are collected (bounded); a hard timeout SIGKILLs a hung
+ * hook and reports it as a non-blocking error. Interpretation is shared via
+ * interpretHookOutcome so the exit-code protocol matches the sync path exactly.
+ */
+async function _runCommandHookInnerAsync(command, input = {}, opts = {}) {
+  const { cwd, event } = opts;
+  const _rawTimeout = Number(opts.timeout);
+  const timeout =
+    Number.isFinite(_rawTimeout) && _rawTimeout > 0
+      ? Math.min(_rawTimeout, 600000)
+      : 60000;
+  const shellKind = normalizeShellKind(opts.shell);
+  const usePowershell = shellKind === "powershell" || shellKind === "pwsh";
+  const wd = cwd || process.cwd();
+  const inputJson = JSON.stringify({
+    ...input,
+    schema_version: input.schema_version ?? HOOK_PAYLOAD_SCHEMA_VERSION,
+  });
+  const spawnEnv = {
+    ...process.env,
+    CLAUDE_HOOK_EVENT: event || input.hook_event_name || "",
+  };
+
+  let child;
+  try {
+    if (usePowershell) {
+      const { executionPolicy } = loadShellConfig({ cwd: wd });
+      const inv = buildPowershellArgv(command, shellKind, { executionPolicy });
+      child = _deps.spawn(inv.file, inv.argv, { cwd: wd, env: spawnEnv });
+    } else {
+      child = _deps.spawn(command, { cwd: wd, env: spawnEnv, shell: true });
+    }
+  } catch (err) {
+    return {
+      decision: HOOK_DECISIONS.CONTINUE,
+      reason: `hook spawn failed: ${err.message}`,
+      exitCode: null,
+      error: err.message,
+      nonBlockingError: true,
+    };
+  }
+
+  return await new Promise((resolve) => {
+    const MAXB = 8 * 1024 * 1024;
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    const done = (res) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(interpretHookOutcome(res));
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        /* already exited */
+      }
+      done({
+        error: new Error(`hook timed out after ${timeout}ms`),
+        status: null,
+        stdout,
+        stderr,
+      });
+    }, timeout);
+    if (typeof timer.unref === "function") timer.unref();
+
+    child.on("error", (err) =>
+      done({ error: err, status: null, stdout, stderr }),
+    );
+    if (child.stdout) {
+      child.stdout.on("data", (d) => {
+        if (stdout.length < MAXB) stdout += d.toString("utf8");
+      });
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (d) => {
+        if (stderr.length < MAXB) stderr += d.toString("utf8");
+      });
+    }
+    child.on("close", (code) =>
+      done({ error: null, status: code, stdout, stderr }),
+    );
+    // Feed the payload to the hook's stdin. A fast-exiting hook may close its
+    // end first (EPIPE) — that is harmless, the exit code still governs.
+    try {
+      if (child.stdin) {
+        child.stdin.on("error", () => {});
+        child.stdin.write(inputJson);
+        child.stdin.end();
+      }
+    } catch {
+      /* stdin already closed */
+    }
+  });
+}
+
+/**
+ * Run a list of command hooks and reduce to one decision.
+ *
+ * Default (`opts.mergeStrict` falsy): in-order, the first BLOCK **or** ASK
+ * short-circuits — byte-identical to the historical behavior.
+ *
+ * `opts.mergeStrict: true`: run EVERY matching hook (no short-circuit) then take
+ * the STRICTEST decision (block > ask > allow > continue) via mergeHookDecisions.
+ * This closes the safety gap where an earlier hook's `ask` masks a LATER hook's
+ * `block` (the short-circuit path returns `ask` and never runs the blocker).
+ * Claude-Code parity: all matching hooks contribute to the merged decision.
+ * spawnSync is synchronous so execution is sequential — but the MERGE is
+ * order-independent, so the outcome matches a parallel run.
+ *
+ * @returns {{ decision, reason, hook?, results, contributing? }}
  */
 function runHooks(commandHooks, input = {}, opts = {}) {
   const results = [];
-  for (const h of commandHooks || []) {
-    const r = runCommandHook(h.command, input, {
+  const hooks = commandHooks || [];
+  const runOne = (h) =>
+    runCommandHook(h.command, input, {
       ...opts,
       timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
       // per-hook shell selection (P1 #8): `{ "type":"command", "command":…,
       // "shell":"powershell" }` in the settings hook entry
       shell: h.shell != null ? h.shell : opts.shell,
     });
+
+  if (opts.mergeStrict) {
+    const decisions = [];
+    for (const h of hooks) {
+      const r = runOne(h);
+      results.push({ command: h.command, ...r });
+      decisions.push({
+        decision: r.decision,
+        reason: r.reason,
+        hook: h.command,
+      });
+    }
+    const merged = mergeHookDecisions(decisions);
+    return {
+      decision: merged.decision,
+      reason: merged.reason,
+      hook: merged.hook,
+      results,
+      contributing: merged.contributing,
+    };
+  }
+
+  for (const h of hooks) {
+    const r = runOne(h);
     results.push({ command: h.command, ...r });
     if (
       r.decision === HOOK_DECISIONS.BLOCK ||
@@ -316,9 +489,48 @@ function runHooks(commandHooks, input = {}, opts = {}) {
   return { decision: HOOK_DECISIONS.CONTINUE, reason: null, results };
 }
 
+/**
+ * Run every matching hook CONCURRENTLY (async spawn) and reduce to the strictest
+ * decision (block > ask > allow > continue) via mergeHookDecisions — the true-
+ * parallel form of runHooks({mergeStrict}). Wall-clock is the slowest single hook
+ * rather than their sum; the merge is order-independent so the outcome matches
+ * the sequential strict merge exactly. Same per-hook timeout/shell resolution as
+ * runHooks. Returns the same shape ({decision, reason, hook, results,
+ * contributing}) so the decision consumers are unchanged.
+ */
+async function runHooksParallel(commandHooks, input = {}, opts = {}) {
+  const hooks = commandHooks || [];
+  const settled = await Promise.all(
+    hooks.map((h) =>
+      runCommandHookAsync(h.command, input, {
+        ...opts,
+        timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
+        shell: h.shell != null ? h.shell : opts.shell,
+      }).then((r) => ({ h, r })),
+    ),
+  );
+  const results = settled.map(({ h, r }) => ({ command: h.command, ...r }));
+  const decisions = settled.map(({ h, r }) => ({
+    decision: r.decision,
+    reason: r.reason,
+    hook: h.command,
+  }));
+  const merged = mergeHookDecisions(decisions);
+  return {
+    decision: merged.decision,
+    reason: merged.reason,
+    hook: merged.hook,
+    results,
+    contributing: merged.contributing,
+  };
+}
+
 module.exports = {
   runCommandHook,
+  runCommandHookAsync,
   runHooks,
+  runHooksParallel,
+  interpretHookOutcome,
   tryParseDecision,
   HOOK_DECISIONS,
   HOOK_PAYLOAD_SCHEMA_VERSION,

package/src/lib/install-command-policy.js

@@ -128,8 +128,18 @@ function unwrapArgv(tokens) {
  * @returns {{manager:string, subcommand:string, packages:string[], global:boolean}|null}
  */
 export function classifyInstallSegment(segment) {
-  const argv = unwrapArgv(tokenizeShellCommand(segment));
+  let argv = unwrapArgv(tokenizeShellCommand(segment));
   if (argv.length === 0) return null;
+  // Module invocation: `python -m pip install …` (and `py -m pip …`) is the
+  // canonical way run_code's auto-install — and plenty of humans — invoke pip;
+  // treat the module as the binary so it classifies like a direct `pip`.
+  if (
+    /^(python[0-9.]*|py)$/.test(normalizeBin(argv[0])) &&
+    argv[1] === "-m" &&
+    argv.length > 2
+  ) {
+    argv = argv.slice(2);
+  }
   const bin = normalizeBin(argv[0]);
   const mgr = MANAGERS.find((m) => m.bin.test(bin));
   if (!mgr) return null;

package/src/lib/lsp/code-intelligence.js

@@ -64,7 +64,11 @@ export class CodeIntelligence {
       /* plugin LSP contributions are best-effort */
     }
     this.manager =
-      opts.manager || new LSPManager({ projectRoot: opts.projectRoot });
+      opts.manager ||
+      new LSPManager({
+        projectRoot: opts.projectRoot,
+        ...(opts.lspOptions || {}),
+      });
     this._ownsManager = !opts.manager;
     // One-shot callers (the `cc code-intel` CLI) spawn a cold server per run and
     // must wait for the project to load before querying; the long-lived agent

package/src/lib/lsp/workspace-roots.js

@@ -0,0 +1,115 @@
+/**
+ * workspace-roots — pure helpers for multi-root LSP workspaces (P2 LSP slice,
+ * CLAUDE_CODE_CLI_INCREMENTAL_GAP_ANALYSIS_2026-07-12 §"LSP 与 Code Review").
+ *
+ * A session started with `--add-dir` works across several project roots, but
+ * `code_intelligence` always keyed its shared language-server pool on the cwd
+ * alone — a query for a file living in an additional root spawned (or reused)
+ * the WRONG project's server, and `workspace_symbols` could only ever see the
+ * cwd project. These helpers make root selection explicit and testable:
+ *
+ *  - `workspaceRootsFor(cwd, additionalDirectories)` — the deduped, resolved
+ *    root list (cwd first, mirroring the roots the system prompt advertises).
+ *  - `pickRootForFile(file, roots)` — the root that CONTAINS the file
+ *    (deepest match wins so nested roots resolve to the more specific
+ *    project); falls back to the first root (cwd) for out-of-root files,
+ *    which is the pre-multi-root behavior.
+ *  - `mergeWorkspaceSymbolResults(results, roots)` — fold per-root
+ *    `workspaceSymbols` outcomes into one: available when ANY root answered,
+ *    symbols concatenated in root order and stamped with their `root` so
+ *    same-named symbols from different projects stay unambiguous.
+ *
+ * Pure + IO-free (path math only) so agent-core can consume them without any
+ * new export surface of its own.
+ */
+
+import path from "node:path";
+
+/** Case-fold for prefix comparison on case-insensitive filesystems. */
+function fold(p) {
+  return process.platform === "win32" ? p.toLowerCase() : p;
+}
+
+/**
+ * Resolved, deduped workspace roots — cwd first, then each additional
+ * directory. Non-string/empty entries are dropped; never returns empty (falls
+ * back to process.cwd()).
+ */
+export function workspaceRootsFor(cwd, additionalDirectories) {
+  const out = [];
+  const seen = new Set();
+  const push = (dir) => {
+    if (typeof dir !== "string" || dir.trim() === "") return;
+    const resolved = path.resolve(dir);
+    const key = fold(resolved);
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push(resolved);
+  };
+  push(cwd || process.cwd());
+  for (const d of Array.isArray(additionalDirectories)
+    ? additionalDirectories
+    : []) {
+    push(d);
+  }
+  if (out.length === 0) out.push(path.resolve(process.cwd()));
+  return out;
+}
+
+/**
+ * The workspace root that contains `file` — deepest containing root wins
+ * (nested roots resolve to the more specific project). Files outside every
+ * root fall back to the FIRST root (cwd), preserving the single-root
+ * behavior byte-for-byte.
+ */
+export function pickRootForFile(file, roots) {
+  const list = Array.isArray(roots) && roots.length > 0 ? roots : null;
+  if (!list) return path.resolve(process.cwd());
+  if (typeof file !== "string" || file.trim() === "") return list[0];
+  const f = fold(path.resolve(file));
+  let best = null;
+  for (const root of list) {
+    const r = fold(path.resolve(root));
+    if (f === r || f.startsWith(r + path.sep)) {
+      if (best === null || r.length > fold(best).length) {
+        best = path.resolve(root);
+      }
+    }
+  }
+  return best || list[0];
+}
+
+/**
+ * Merge per-root `workspaceSymbols` results (same order as `roots`).
+ * Any available root makes the merged result available; each symbol is
+ * stamped with its `root`. All-unavailable folds the reasons together so the
+ * caller still sees WHY (first reason wins the summary, all are listed).
+ */
+export function mergeWorkspaceSymbolResults(results, roots = []) {
+  const list = Array.isArray(results) ? results : [];
+  const symbols = [];
+  const reasons = [];
+  let anyAvailable = false;
+  for (let i = 0; i < list.length; i++) {
+    const r = list[i];
+    if (r && r.available) {
+      anyAvailable = true;
+      for (const s of Array.isArray(r.symbols) ? r.symbols : []) {
+        symbols.push(roots[i] ? { ...s, root: roots[i] } : s);
+      }
+    } else if (r) {
+      reasons.push(
+        roots[i]
+          ? `${roots[i]}: ${r.reason || "unavailable"}`
+          : r.reason || "unavailable",
+      );
+    }
+  }
+  if (!anyAvailable) {
+    return {
+      available: false,
+      reason: reasons.join("; ") || "language server unavailable",
+    };
+  }
+  return { available: true, symbols };
+}

package/src/lib/settings-hook-events.cjs

@@ -47,7 +47,15 @@ function withDeliveryId(event, payload, { sessionId, traceId, parentId } = {}) {
       /* best-effort — recording must not break the turn */
     }
   }
-  return { ...payload, event_id: env.event_id };
+  // trace_id/parent_id are stamped onto the DELIVERED payload only when the
+  // caller actually threaded them (agent-core context) — absent they are
+  // omitted entirely, keeping every legacy payload byte-identical.
+  return {
+    ...payload,
+    event_id: env.event_id,
+    ...(env.trace_id ? { trace_id: env.trace_id } : {}),
+    ...(env.parent_id ? { parent_id: env.parent_id } : {}),
+  };
 }
 
 /**
@@ -343,7 +351,7 @@ function runObserveHooks(
   settingsHooks,
   event,
   payload = {},
-  { cwd, matchTarget } = {},
+  { cwd, matchTarget, traceId, parentId } = {},
 ) {
   if (!settingsHooks) return { decision: "continue", results: [] };
   const matched = collectHooks(settingsHooks, event, matchTarget || "");
@@ -351,12 +359,17 @@ function runObserveHooks(
   if (sync.length === 0) return { decision: "continue", results: [] };
   return runHooks(
     sync,
-    withDeliveryId(event, { hook_event_name: event, cwd, ...payload }),
+    withDeliveryId(
+      event,
+      { hook_event_name: event, cwd, ...payload },
+      { traceId, parentId },
+    ),
     { cwd, event },
   );
 }
 
 module.exports = {
+  withDeliveryId,
   runUserPromptSubmitHooks,
   runSessionStartHooks,
   runCwdChangedHooks,