harnery 0.31.6 → 0.33.0

package/src/core/hooks/cli.ts

@@ -1,6 +1,5 @@
 /**
- * `agent-hook` CLI entry point. Phase 2: real canonical-event emission
- * alongside the legacy stream.
+ * `agent-hook` CLI entry point for canonical event emission.
  *
  * Flow:
  *   1. Parse argv → event-name + adapter.
@@ -22,13 +21,22 @@ import { spawnSync } from "node:child_process";
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { coordEnv } from "../../lib/env.ts";
+import { buildInstructionBundle } from "../../lib/instructions/bundle.ts";
 import { replayCodexJsonl } from "../agents/codex-replay.ts";
 import { coordBinPath } from "../agents/coord-bin.ts";
 import { consumeSince, writeCursor } from "../agents/events/consume.ts";
+import {
+  type ClaimFinalizationDecision,
+  type ClaimFinalizationDescriptor,
+  classifyWriteClaimFinalization,
+  formatWriteClaimFinalizationDenial,
+} from "../agents/finalization.ts";
 import { evaluateStopHook } from "../agents/rules/stop-hook.ts";
 import { projectHeartbeats } from "../agents/state/heartbeat-projector.ts";
+import { stampSessionStateEvent } from "../agents/state/heartbeat-writer.ts";
 import { writePidmapRow } from "../agents/state/pidmap.ts";
 import { shellMutationPaths } from "../agents/state/shell-mutation.ts";
+import { agentsRequireGitFinalization, resolveBinName } from "../config.ts";
 import {
   checkpointContext,
   completeContextRecovery,
@@ -49,6 +57,12 @@ import {
   type ParsedPayload,
   parsePayload,
 } from "./adapter/parse.ts";
+import {
+  codexWslFileLinkTelemetry,
+  inspectCodexWslBridge,
+  isWslUncPath,
+  renderCodexWslFileLinkContext,
+} from "./codex-wsl-bridge.ts";
 import {
   captureImages,
   detectPresence,
@@ -69,7 +83,14 @@ import { adapterPidFromEnv, parsePsChainLine, selectAnchorPid } from "./resolve/
 import { findCoordRoot } from "./resolve/coord-root.ts";
 import { extractIntentComment, resolveIntent } from "./resolve/intent.ts";
 import { resolveOwner } from "./resolve/owner.ts";
-import { scanStatusBoxPresent, scanTranscriptModel } from "./resolve/transcript.ts";
+import {
+  detectForkParent,
+  scanAssistantTextIncludes,
+  scanStatusBoxPresent,
+  scanTranscriptModel,
+} from "./resolve/transcript.ts";
+import { sessionNamePresence } from "./session-name-presence.ts";
+import { unsafeCrossShellReason } from "./unsafe-cross-shell.ts";
 
 interface Argv {
   eventName: string | null;
@@ -80,11 +101,11 @@ function parseArgv(argv: string[]): Argv {
   const out: Argv = { eventName: null, extra: [] };
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i]!;
-    if (arg === "--adapter" || arg === "--harness") {
+    if (arg === "--adapter") {
       i++; // detectAdapter will re-parse; just consume the value here.
       continue;
     }
-    if (arg.startsWith("--adapter=") || arg.startsWith("--harness=")) continue;
+    if (arg.startsWith("--adapter=")) continue;
     if (!out.eventName && !arg.startsWith("--")) {
       out.eventName = arg;
     } else {
@@ -160,11 +181,14 @@ function assignNameViaAgentCoord(
   coordRoot: string,
   instanceId: string,
   kind: "session" | "subagent" | "transient",
+  forkedFrom?: string,
 ): { name: string; kind: string } | null {
   const binary = coordBinPath("agent-coord", coordRoot) ?? "";
   if (!existsSync(binary)) return null;
   try {
-    const result = spawnSync(binary, ["assign-name", instanceId, kind], {
+    const args = ["assign-name", instanceId, kind];
+    if (forkedFrom) args.push("--forked-from", forkedFrom);
+    const result = spawnSync(binary, args, {
       encoding: "utf8",
       timeout: 2000,
       env: childEnv(coordRoot),
@@ -238,13 +262,26 @@ function buildEventData(
     case "session.start": {
       const adapterPlatform =
         ctx.adapter === "claude-code"
-          ? "claude_code"
+          ? "claude-code"
           : ctx.adapter === "cursor"
             ? "cursor"
             : "codex";
+      // Recorded fork lineage is NOT detected here. On claude-code a fork
+      // never fires its own session.start — SessionStart fires under the
+      // PARENT's session id (source=resume) before the fork id is minted
+      // (verified 2026-08-05) — so detection at this point can only mislabel
+      // the resumed parent. The fork's new instance is caught by the
+      // tool.pre_use heal path instead. The forkedFrom plumbing below stays
+      // for adapters that DO report a parent at session start.
+      const forkedFrom: string | undefined = undefined;
       // Assign (or recover) name + kind via agent-coord. Idempotent: resume
       // returns the original name; new owner consumes a counter slot.
-      const assigned = assignNameViaAgentCoord(ctx.coordRoot, ctx.instanceId, "session");
+      const assigned = assignNameViaAgentCoord(
+        ctx.coordRoot,
+        ctx.instanceId,
+        "session",
+        forkedFrom,
+      );
       // Write the adapter pid-map row so `harn agents whoami` ppid-walks find
       // this owner. Prefer the payload pid (the actual claude binary), then the
       // anchor walk (the `node` ancestor for Cursor, which has no payload pid),
@@ -255,6 +292,7 @@ function buildEventData(
       if (adapterPid) {
         writePidmapViaAgentCoord(ctx.coordRoot, adapterPid, ctx.instanceId, adapterPlatform);
       }
+      const bundle = safeInstructionBundle(ctx.coordRoot, p?.cwd ?? process.cwd(), ctx.adapter);
       return {
         started_at: new Date().toISOString(),
         cwd: p?.cwd ?? process.cwd(),
@@ -268,6 +306,18 @@ function buildEventData(
         name: assigned?.name,
         kind: "session",
         agent_id: ctx.instanceId,
+        ...(bundle
+          ? {
+              instruction_bundle_id: bundle.instruction_bundle_id,
+              instruction_source_id: bundle.canonical_source_id,
+              instruction_profile_root: bundle.profile_root,
+              instruction_component_count: bundle.components.length,
+            }
+          : {}),
+        // Recorded fork lineage rides the canonical event too, so full replay
+        // and derived readers converge on the same parent linkage that
+        // .name-history carries (the ADR 0017 dual-write pattern).
+        ...(forkedFrom ? { forked_from: forkedFrom } : {}),
         // Workflow-child linkage: `workflow run` children carry the run id in
         // env (spawn adapters set it via buildChildEnv), so their sessions and
         // heartbeats join back to the run transcript + /workflows web view.
@@ -298,6 +348,11 @@ function buildEventData(
     }
 
     case "turn.stop": {
+      const lastAssistantMessage = (p?.raw.last_assistant_message as string | undefined) ?? "";
+      const fileLinkTelemetry =
+        ctx.adapter === "codex"
+          ? codexWslFileLinkTelemetry(ctx.coordRoot, p?.cwd, lastAssistantMessage)
+          : null;
       return {
         // Backfill the model for adapters that omit it at session.start
         // (Claude Code). The transcript is populated with assistant turns by
@@ -316,8 +371,27 @@ function buildEventData(
         // the verdict now sees because agent-hook emits this turn.stop itself
         // (the previous path passed those via the no-history fail-open).
         status_box_present:
-          scanStatusBoxPresent(p?.transcript_path) ||
-          ((p?.raw.last_assistant_message as string | undefined) ?? "").includes("┌─ agent-"),
+          scanStatusBoxPresent(p?.transcript_path) || lastAssistantMessage.includes("┌─ agent-"),
+        // Shadow measurement for the rule-2/3 detector: the loose scan above
+        // matches the box prefix ANYWHERE in the transcript tail, including
+        // the tool_result row the status command itself writes, so it can
+        // report a paste that never happened. The strict variant counts
+        // assistant text only (same window, same scanner as the session-name
+        // detection). Telemetry-only: the Stop verdict still reads
+        // status_box_present. Once the divergence rate between the two fields
+        // is known, the gate either flips to strict or the rule gets
+        // reconsidered; either way this field decides it with data.
+        status_box_present_strict:
+          scanAssistantTextIncludes(p?.transcript_path, "┌─ agent-") ||
+          lastAssistantMessage.includes("┌─ agent-"),
+        // Whether the session's suggested name is satisfied as of this turn,
+        // and which name that refers to. Reported on every stop while a name
+        // exists (the stop-hook.session_name verdict reads it per turn); the
+        // transcript scan itself stops once the name has been sighted.
+        ...sessionNamePresence(ctx.coordRoot, ctx.instanceId, lastAssistantMessage, (name) =>
+          scanAssistantTextIncludes(p?.transcript_path, name),
+        ),
+        ...(fileLinkTelemetry ?? {}),
         stop_hook_active: p?.stop_hook_active,
       };
     }
@@ -372,6 +446,16 @@ function buildEventData(
       };
     }
 
+    case "interaction.input_requested": {
+      const description = extractToolDescription(p?.tool_input);
+      const reason = description ? clampString(description, 500).value : undefined;
+      return {
+        request_kind: "permission",
+        tool_name: p?.tool_name,
+        ...(reason ? { reason } : {}),
+      };
+    }
+
     case "tool.post_use": {
       const toolName = p?.tool_name ?? "unknown";
       const summary = summarizeOutput(p?.tool_response);
@@ -425,6 +509,15 @@ function buildEventData(
   }
 }
 
+function safeInstructionBundle(coordRoot: string, cwd: string, adapter: Adapter) {
+  try {
+    return buildInstructionBundle({ coordRoot, cwd, adapter });
+  } catch (err) {
+    logError(coordRoot, err, { phase: "instruction-bundle-identity" });
+    return null;
+  }
+}
+
 function objectRecord(value: unknown): Record<string, unknown> | undefined {
   return typeof value === "object" && value !== null && !Array.isArray(value)
     ? (value as Record<string, unknown>)
@@ -539,6 +632,21 @@ async function main(): Promise<number> {
     event_id: envelope.event_id,
   });
 
+  // Activity is only useful while it is current. Stamp prompt and permission
+  // evidence directly from this envelope rather than draining the global
+  // projector: a drain here could apply a tool event before its authorization
+  // verdict. Tool progress is stamped later, after the guard allows it.
+  if (
+    norm.event_type === "user_prompt.submit" ||
+    norm.event_type === "interaction.input_requested"
+  ) {
+    try {
+      stampSessionStateEvent(coordRoot, owner.instance_id, envelope);
+    } catch (err) {
+      logError(coordRoot, err, { phase: "activity-projection" });
+    }
+  }
+
   // Context telemetry is opportunistic and truthful: only persist a sample
   // when the adapter payload actually exposes usage/window data. Identical
   // measurements are de-duplicated before they reach the canonical stream.
@@ -805,6 +913,7 @@ async function main(): Promise<number> {
         owner.instance_id,
         sessionId,
         adapter,
+        payload?.cwd,
         recovery?.briefing ?? "",
       );
       if (injected && recovery) {
@@ -891,13 +1000,30 @@ async function main(): Promise<number> {
       bypass: coordEnv("AGENT_COORD_BYPASS_STOP") === "1",
       workflow_child: coordEnv("WORKFLOW_CHILD") === "1",
     });
+    const enforcementMode = stopEnforcementMode(verdict.rule);
+    emit(coordRoot, {
+      event_type: "stop.verdict",
+      instance_id: owner.instance_id,
+      session_id: sessionId,
+      turn_id: payload?.turn_id,
+      parent_turn_id: payload?.parent_turn_id,
+      adapter,
+      data: {
+        allow: verdict.allow,
+        rule: verdict.rule,
+        ...(verdict.reason ? { reason: verdict.reason } : {}),
+        enforcement_mode: enforcementMode,
+        eligible: enforcementMode === "enforced",
+        nag_delivered: enforcementMode === "enforced" && !verdict.allow,
+      },
+    });
     if (!verdict.allow) {
       // Adapter-aware enforcement channel: Claude Code / Codex honor exit-2 +
       // stderr as a turn block; Cursor ignores exit codes (fail-open) and
       // re-prompts only via a `followup_message` it auto-submits. emitStopBlock
       // writes the right shape and returns the exit code to use.
       const { emitStopBlock } = await import("./adapter/output.ts");
-      return emitStopBlock(adapter, verdict);
+      return emitStopBlock(adapter, verdict, coordRoot);
     }
   }
 
@@ -912,7 +1038,21 @@ async function main(): Promise<number> {
   // call was restored here afterward.
   if (norm.event_type === "tool.pre_use") {
     try {
-      healHeartbeatViaCli(coordRoot, owner.instance_id, sessionId, adapter);
+      // Recorded fork lineage, heal-path flavor. A forked CC conversation
+      // never fires its own session.start (SessionStart fires under the
+      // PARENT's session id with source=resume, before the fork id is
+      // minted; verified 2026-08-05), so the fork's new instance first
+      // materializes right here. Gate detection on "no heartbeat yet" so the
+      // transcript scan runs once per instance lifetime, not per tool call.
+      let forkedFrom: string | undefined;
+      if (
+        adapter === "claude-code" &&
+        payload?.transcript_path &&
+        !existsSync(join(coordRoot, ".harnery", "active", `${owner.instance_id}.json`))
+      ) {
+        forkedFrom = detectForkParent(payload.transcript_path, owner.instance_id);
+      }
+      healHeartbeatViaCli(coordRoot, owner.instance_id, sessionId, adapter, forkedFrom);
       refreshPidmap(coordRoot, owner.instance_id, adapter, payload?.pid);
     } catch (err) {
       logError(coordRoot, err, { phase: "pre-tool-use-heal" });
@@ -933,6 +1073,29 @@ async function main(): Promise<number> {
       logError(coordRoot, err, { phase: "pre-tool-use-image-capture" });
     }
 
+    // Windows-native Codex + WSL UNC only: block the one cross-shell shape
+    // proven to corrupt argument boundaries. Normal WSL argv calls, literal
+    // bash -s scripts, native Linux/macOS sessions, and every other adapter
+    // pass through. The host instructions name its concrete safe bridge.
+    const unsafeShellReason = unsafeCrossShellReason({
+      adapter,
+      cwd: payload?.cwd,
+      toolName: payload?.tool_name,
+      toolInput: payload?.tool_input,
+    });
+    if (unsafeShellReason) {
+      emit(coordRoot, {
+        event_type: "decision.block",
+        instance_id: owner.instance_id,
+        session_id: sessionId,
+        adapter,
+        data: { rule: "unsafe_cross_shell", reason: unsafeShellReason },
+      });
+      const { emitDeny } = await import("./adapter/output.ts");
+      emitDeny(adapter, unsafeShellReason);
+      return 0;
+    }
+
     // G-guard for ALL adapters. Claude Code previously ran this via a
     // pre-tool-use bash adapter (which called `agent-coord verdict --rule=claim`);
     // that adapter is now deleted, so agent-hook owns the deny for every adapter.
@@ -941,12 +1104,27 @@ async function main(): Promise<number> {
     // apply_patch (codex) parses paths from the patch body and runs verdict
     // per-path; Edit/Write/NotebookEdit resolve a single target. Non-write tools
     // (incl. Agent) yield no targets and pass through with no deny.
+    let guardAllowed = true;
     try {
-      await runPreToolUseGuard(coordRoot, owner.instance_id, sessionId, data, adapter);
+      guardAllowed = await runPreToolUseGuard(
+        coordRoot,
+        owner.instance_id,
+        sessionId,
+        data,
+        adapter,
+      );
     } catch (err) {
       logError(coordRoot, err, { phase: "pre-tool-use-guard" });
     }
 
+    if (guardAllowed) {
+      try {
+        stampSessionStateEvent(coordRoot, owner.instance_id, envelope);
+      } catch (err) {
+        logError(coordRoot, err, { phase: "activity-projection" });
+      }
+    }
+
     // Shell-mutation warn (warn-only, never blocks). Was the cursor
     // beforeShellExecution + codex preToolUse-Bash shell-mutation-claim-log in
     // the per-adapter shell adapters. Cursor sends the command at payload.command;
@@ -1025,21 +1203,60 @@ async function main(): Promise<number> {
   return 0;
 }
 
+function stopEnforcementMode(rule: string): "enforced" | "observe_only" | "exempt" | "fail_open" {
+  if (rule === "stop-hook.codex_observe_only") return "observe_only";
+  if (rule === "stop-hook.fail_open" || rule === "stop-hook.no_history") return "fail_open";
+  if (rule === "stop-hook.bypass" || rule === "stop-hook.workflow_child") return "exempt";
+  return "enforced";
+}
+
 async function runPreToolUseGuard(
   coordRoot: string,
   instanceId: string,
   sessionId: string,
   data: Record<string, unknown>,
   adapter: Adapter,
-): Promise<void> {
+): Promise<boolean> {
   const toolName = (data.tool_name as string | undefined) ?? "";
-  const targets = collectGuardTargets(toolName, data)
-    .map((p) => canonicalize(coordRoot, p))
-    .filter((p): p is string => p !== null);
-  if (targets.length === 0) return;
+  const rawTargets = collectGuardTargets(toolName, data);
+  if (rawTargets.length === 0) return true;
+
+  let targets: Array<{ path: string; finalization?: ClaimFinalizationDescriptor }>;
+  if (agentsRequireGitFinalization(coordRoot)) {
+    const decisions = rawTargets.map((path) => classifyWriteClaimFinalization(coordRoot, path));
+    const denied = decisions.find((decision) => !decision.allow);
+    if (denied && !denied.allow) {
+      const { emitDeny } = await import("./adapter/output.ts");
+      emitDeny(adapter, formatWriteClaimFinalizationDenial(denied, resolveBinName(coordRoot)));
+      return false;
+    }
+    const allowed = decisions.filter(
+      (decision): decision is Extract<ClaimFinalizationDecision, { allow: true }> => decision.allow,
+    );
+    targets = allowed.map((decision) => ({
+      path: decision.path,
+      finalization: decision.descriptor,
+    }));
+  } else {
+    targets = rawTargets
+      .map((path) => canonicalize(coordRoot, path))
+      .filter((path): path is string => path !== null)
+      .map((path) => ({ path }));
+  }
+  if (targets.length === 0) return true;
 
   const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
-  if (!existsSync(agentCoordBin)) return;
+  if (!existsSync(agentCoordBin)) {
+    if (agentsRequireGitFinalization(coordRoot)) {
+      const { emitDeny } = await import("./adapter/output.ts");
+      emitDeny(
+        adapter,
+        "Harnery denied the write before mutation because the claim coordinator is unavailable; repair the project's Harnery installation and retry.",
+      );
+      return false;
+    }
+    return true;
+  }
 
   // For apply_patch (multi-file), collect siblings so the deny reason names
   // them. For single-file tools the array has one entry.
@@ -1048,7 +1265,7 @@ async function runPreToolUseGuard(
       rule: "claim",
       instance_id: instanceId,
       session_id: sessionId,
-      path: target,
+      path: target.path,
     });
     const result = spawnSync(agentCoordBin, ["verdict"], {
       input: verdictReq,
@@ -1064,10 +1281,12 @@ async function runPreToolUseGuard(
       continue;
     }
     if (parsed.allow === false) {
-      let reason = parsed.reason ?? `Path ${target} is currently being edited by another agent.`;
+      let reason =
+        parsed.reason ?? `Path ${target.path} is currently being edited by another agent.`;
       if (targets.length > 1) {
         const siblings = targets
-          .filter((p) => p !== target)
+          .filter((candidate) => candidate !== target)
+          .map((candidate) => candidate.path)
           .slice(0, 3)
           .join(", ");
         if (siblings) {
@@ -1076,9 +1295,28 @@ async function runPreToolUseGuard(
       }
       const { emitDeny } = await import("./adapter/output.ts");
       emitDeny(adapter, reason);
-      return;
+      return false;
     }
+
+    // The verdict mutates the live heartbeat immediately, but that file is a
+    // projection and can be rebuilt at any later hook. Persist the acquisition
+    // in the canonical stream too. This matters most for Codex apply_patch:
+    // one tool call can claim several files, and tool.pre_use's clamped payload
+    // is not a durable ownership representation for those targets.
+    emit(coordRoot, {
+      event_type: "claim.acquire",
+      instance_id: instanceId,
+      session_id: sessionId,
+      adapter,
+      source: "agent-hooks",
+      data: {
+        path: target.path,
+        mode: "write",
+        ...(target.finalization ? { finalization: target.finalization } : {}),
+      },
+    });
   }
+  return true;
 }
 
 /** Canonicalize a path to monorepo-relative form. Absolute paths under
@@ -1142,14 +1380,18 @@ function healHeartbeatViaCli(
   instanceId: string,
   sessionId: string,
   adapter: string,
+  forkedFrom?: string,
 ): void {
   const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
   if (!existsSync(agentCoordBin)) return;
   // Pass the detected adapter so a pruned Cursor/Codex heartbeat is recreated
   // with the correct platform; without it, healHeartbeat defaults to
-  // claude_code and the dashboard mislabels the agent. See
-  // heartbeat-writer.healHeartbeat.
-  spawnSync(agentCoordBin, ["heal-heartbeat", instanceId, sessionId, `--adapter=${adapter}`], {
+  // claude-code and the dashboard mislabels the agent. See
+  // heartbeat-writer.healHeartbeat. --forked-from carries detected fork
+  // lineage for an instance that never session.started (the CC fork flow).
+  const args = ["heal-heartbeat", instanceId, sessionId, `--adapter=${adapter}`];
+  if (forkedFrom) args.push(`--forked-from=${forkedFrom}`);
+  spawnSync(agentCoordBin, args, {
     encoding: "utf8",
     timeout: 2000,
     env: childEnv(coordRoot),
@@ -1384,6 +1626,7 @@ async function emitUserPromptSubmitSystemMessage(
   instanceId: string,
   sessionId: string,
   adapter: Adapter,
+  workspaceCwd?: string,
   recoveryBriefing = "",
 ): Promise<boolean> {
   const agentCoordBin = coordBinPath("agent-coord", coordRoot) ?? "";
@@ -1410,12 +1653,23 @@ async function emitUserPromptSubmitSystemMessage(
     // staleness nudges; Claude Code enforces those via its Stop transcript.
     // Codex gets a fresh status-footer reminder on every prompt. Its Stop hook
     // stays observe-only, so missing the footer never replaces the answer.
+    // Claude Code + Cursor (the Stop-ENFORCING adapters) get a fresh per-turn
+    // ritual reminder: satisfying the contract up front is far cheaper than
+    // the bounce-and-retry the Stop hook otherwise forces.
     args.push("--session-name-nudge");
     if (adapter === "cursor" || adapter === "codex") args.push("--task-nudge");
     if (adapter === "codex") args.push("--status-footer-nudge");
+    if (adapter === "claude-code" || adapter === "cursor")
+      args.push("--turn-ritual-nudge", adapter);
     const result = spawnSync(agentCoordBin, args, { encoding: "utf8", timeout: 3000 });
     if (result.status === 0 && result.stdout) additionalContext = result.stdout.trim();
   }
+  if (adapter === "codex") {
+    const fileLinkContext = renderCodexWslFileLinkContext(coordRoot, workspaceCwd);
+    if (fileLinkContext) {
+      additionalContext = [additionalContext, fileLinkContext].filter(Boolean).join("\n\n");
+    }
+  }
   if (recoveryBriefing) {
     additionalContext = [additionalContext, recoveryBriefing].filter(Boolean).join("\n\n");
   }
@@ -1466,7 +1720,7 @@ function emitSubagentStartContext(
 }
 
 function adapterPlatform(adapter: Adapter): string {
-  if (adapter === "claude-code") return "claude_code";
+  if (adapter === "claude-code") return "claude-code";
   return adapter;
 }
 
@@ -1527,6 +1781,21 @@ async function emitSessionStartSystemMessage(
   if (recoveryBriefing) {
     additionalContext = [additionalContext, recoveryBriefing].filter(Boolean).join("\n\n");
   }
+  if (adapter === "codex" && isWslUncPath(emittedData.cwd)) {
+    const fileLinkContext = renderCodexWslFileLinkContext(coordRoot, emittedData.cwd);
+    if (fileLinkContext) {
+      additionalContext = [additionalContext, fileLinkContext].filter(Boolean).join("\n\n");
+    }
+    const bridge = inspectCodexWslBridge(process.env, { expected: true });
+    if (bridge && !bridge.ok) {
+      additionalContext = [
+        additionalContext,
+        `Harnery hybrid warning: ${bridge.detail}. Run \`${resolveBinName(coordRoot)} doctor\` for the repair hint.`,
+      ]
+        .filter(Boolean)
+        .join("\n\n");
+    }
+  }
   if (!additionalContext) return false;
 
   const { emitContext } = await import("./adapter/output.ts");