token-goat 2.9.28 → 2.9.30

package/dist/token-goat-chunk-EFHMMIGP.mjs

@@ -0,0 +1,68 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  NATIVE_FALLBACK_ENV,
+  RELAY_QUEUE_WAIT_MS,
+  buildEvent,
+  nativeFallbackDetail,
+  relay,
+  relayInProcess
+} from "./token-goat-chunk-SQSSNQPE.mjs";
+import "./token-goat-chunk-ZEJVMUQH.mjs";
+import "./token-goat-chunk-GFBSN7BD.mjs";
+import "./token-goat-chunk-5RG5SBL6.mjs";
+import "./token-goat-chunk-KKUFXAPD.mjs";
+import "./token-goat-chunk-7F2UBPD3.mjs";
+import "./token-goat-chunk-54K3EUV3.mjs";
+import "./token-goat-chunk-7BXSNBY5.mjs";
+import "./token-goat-chunk-G5PJ7AGM.mjs";
+import "./token-goat-chunk-YARZFCZS.mjs";
+import "./token-goat-chunk-FBNQNSJK.mjs";
+import "./token-goat-chunk-PEPTHRFF.mjs";
+import "./token-goat-chunk-MNWKPRAL.mjs";
+import "./token-goat-chunk-JTQQGXZH.mjs";
+import "./token-goat-chunk-67TQJ76B.mjs";
+import "./token-goat-chunk-H2PHHGM5.mjs";
+import "./token-goat-chunk-P4QMM4WK.mjs";
+import "./token-goat-chunk-5KDMCMF2.mjs";
+import "./token-goat-chunk-APGZXSPS.mjs";
+import "./token-goat-chunk-COBQGL5S.mjs";
+import "./token-goat-chunk-ATCPY7EQ.mjs";
+import "./token-goat-chunk-VPBBTSJR.mjs";
+import "./token-goat-chunk-Q5VTGRH7.mjs";
+import "./token-goat-chunk-Y776AENC.mjs";
+import "./token-goat-chunk-SJHWVNDQ.mjs";
+import "./token-goat-chunk-AFLYLHDH.mjs";
+import "./token-goat-chunk-BPGCUMR7.mjs";
+import "./token-goat-chunk-C63JQV5K.mjs";
+import "./token-goat-chunk-JB6QN6VF.mjs";
+import "./token-goat-chunk-RHXKCZX3.mjs";
+import "./token-goat-chunk-EVMZJ27Z.mjs";
+import "./token-goat-chunk-HYBFA5X3.mjs";
+import "./token-goat-chunk-5Y6ZYL6U.mjs";
+import "./token-goat-chunk-ARDNEC2U.mjs";
+import "./token-goat-chunk-3Z5S4KGM.mjs";
+import "./token-goat-chunk-VL3YIFHZ.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-3BTK54F3.mjs";
+import "./token-goat-chunk-4FVIAHSI.mjs";
+import "./token-goat-chunk-7IN2MKDS.mjs";
+import "./token-goat-chunk-U4N3BN2W.mjs";
+import "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-GOLEOXZP.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-VES7EL7O.mjs";
+import "./token-goat-chunk-KWPNJBDH.mjs";
+import "./token-goat-chunk-HAVAOB3S.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  NATIVE_FALLBACK_ENV,
+  RELAY_QUEUE_WAIT_MS,
+  buildEvent,
+  nativeFallbackDetail,
+  relay,
+  relayInProcess
+};

package/dist/token-goat-chunk-ETBHVDB6.mjs

@@ -0,0 +1,328 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  HOOK_EVENTS
+} from "./token-goat-chunk-KKUFXAPD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/bridges_status.ts
+init_define_import_meta_env();
+var NO_SERVER_HANDLER_REASON = "token-goat has no registered server-side handler for this event (zero registerHook('notification'|'stop', ...) call sites in src/) -- wiring it client-side would currently be a no-op";
+var NO_POST_COMPACT_EVENT_REASON = "post_compact is a Claude Code event (hook_event_name PostCompact, carrying compact_summary); no equivalent has been confirmed for this harness, so it is left unwired rather than guessed at";
+var NO_SEPARATE_FAILURE_EVENT_REASON = "post_tool_use_failure exists because Copilot CLI (postToolUseFailure) and Claude Code (PostToolUseFailure) route a failed tool result to a separate event instead of their post-tool one. No separate failure event is wired for this harness, so a failed tool call either arrives on post_tool_use like any other result or is not seen; which of the two has not been checked here";
+var COPILOT_NO_POST_COMPACT_REASON = "Copilot CLI has no post-compaction hook: its HookType enum (schemas/api.schema.json, 1.0.79 and 1.0.80) declares preCompact and no postCompact, and both preCompact call sites in app.js await the hook and never assign its result. Whether the summary is reachable another way is open. app.js does emit session.compaction_complete carrying summaryContent, and the session event writer subscribes to '*' -- but emit() vs emitEphemeral() does NOT gate that writer: dispatchEventHandlers runs outside the ephemeral branch in emitInternal, on('*') early-returns past every filter, and the writer's callback applies no filter of its own before handing the JSON to native recordEventJson. The durable-vs-ephemeral decision is in Rust (api_session_event_writer.rs) and was not readable. Nor is the event uniformly summary-bearing: two of the four emit sites are the branches taken when no summary exists, summaryContent is optional in the schema, and the relay session class emits the same event via emitEphemeral. A manual /compact on 1.0.88 (tg-captures C7 and C7d) fired preCompact, and a marker returned from it reached neither the wire requests nor the model. token-goat therefore queues the session manifest at preCompact and delivers it as the next userPromptSubmitted's additionalContext, which reached the model in 5 of 5 runs on 1.0.88 (tg-captures C3)";
+var NO_SUBAGENT_START_REASON = "subagent_start is wired only where the harness's subagent-start hook was shown to deliver additionalContext into the subagent itself (Copilot CLI 1.0.88, VS Code 1.137); here the spawn briefing still rides the spawn tool's prompt through pre_tool_use";
+var VERIFICATION_RANK = {
+  dogfooded: 0,
+  sourced: 1,
+  documented: 2
+};
+var VERIFICATION_BLURB = {
+  dogfooded: "driven against the real harness binary",
+  sourced: "wire format read from the harness's own source or declarations, never driven against it",
+  documented: "wired from the harness's documentation only, never driven against it"
+};
+var BRIDGE_CAPABILITY_MATRIX = [
+  {
+    harness: "claudecode",
+    label: "Claude Code",
+    sourceFile: "src/install.ts (HOOK_EVENT_MAP)",
+    verification: "dogfooded",
+    verificationNote: "The harness this repo is developed and released under; CLAUDE.md requires every CLI/hook change be run against the built binary here before it ships.",
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "post_tool_use_failure", "pre_compact", "post_compact", "user_prompt_submit", "subagent_stop", "session_start"]),
+    reasons: [
+      { events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON },
+      { events: ["subagent_start"], reason: NO_SUBAGENT_START_REASON }
+    ]
+  },
+  {
+    harness: "codex",
+    label: "Codex CLI",
+    sourceFile: "src/bridges/codex_install.ts (CODEX_HOOK_EVENTS, CODEX_GLOBAL_HOOK_EVENTS)",
+    verification: "dogfooded",
+    verificationNote: `codex-cli 0.155.0, 2026-09-22: observed running the installed config.toml hooks and delivering real payloads to the shim -- PreToolUse/PostToolUse with tool_name "Bash" and tool_input.command, and PreCompact with trigger "auto" from a forced auto-compaction. A pre-tool deny was honored (the model dropped Get-Content and ran token-goat outline instead) and post-tool additionalContext reached the model; the pre-compact response did not, which is why codex is in PRE_COMPACT_CONTEXT_DROPPED. Two conditions gate the tool events and both fail silently. config.toml must carry the matching [hooks.state] trusted_hash the installer writes, and the matcher must name the tool as it appears on the hook wire -- "Bash" for shell execution, since Codex normalizes its own exec tool into Claude Code's vocabulary before matching, while apply_patch stays native. A matcher naming the internal spelling produced a run with eight pre_compact rows and no pre_tool_use or post_tool_use row at all, and that also stranded every queued compaction manifest. Verified end to end after the fix: a forced auto-compaction run recorded eight compactions and twelve manifest deliveries in its own rollout transcript.`,
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact", "user_prompt_submit", "subagent_stop"]),
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON },
+      { events: ["subagent_start"], reason: NO_SUBAGENT_START_REASON },
+      {
+        events: ["post_compact", "session_start"],
+        reason: "Codex CLI 0.155.0 does declare PostCompact and SessionStart -- both appear in the hook-event enum next to PreToolUse and PreCompact, so the earlier claim that it had no session-start equivalent and no post-compact event was wrong. They stay unwired for the reason the rest of this table applies: neither channel has been measured. The post-compact input has no summary field anywhere in the binary's payload key list (session_id, turn_id, agent_id, agent_type, transcript_path, hook_event_name, model, permission_mode, trigger, tool_name, tool_input, tool_use_id), so postCompactHandler would have nothing to count, and whether SessionStart forwards additionalContext has not been run"
+      }
+    ]
+  },
+  {
+    harness: "grok",
+    label: "Grok CLI",
+    sourceFile: "src/bridges/grok_install.ts (GROK_HOOK_EVENTS)",
+    verification: "dogfooded",
+    verificationNote: "grok 0.2.93, 2026-07-09: observed executing the global settings.json hooks config unmodified and setting GROK_SESSION_ID on every hook subprocess (src/bridges/registry.ts, src/hooks_cli.ts).",
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact", "user_prompt_submit", "subagent_stop"]),
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
+      { events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON },
+      { events: ["subagent_start"], reason: NO_SUBAGENT_START_REASON },
+      {
+        events: ["session_start"],
+        reason: "GROK_HOOK_EVENTS (this row's explicit `install --grok` writer) mirrors install.ts's HOOK_EVENT_MAP as of the doc verification date -- Grok's real hooks doc has not been re-checked for SessionStart support since, so it is left unwired rather than guessed at (Grok's *default*, non---grok path still rides Claude Code's own settings.json directly and does receive session_start there, same as claudecode)"
+      }
+    ]
+  },
+  /** What Copilot CLI's wired events can actually carry, read from the shipping 1.0.80 bundle rather than from its hooks reference page. A row's `implemented` set says an event is wired; it deliberately says nothing about how much of that event's response the harness honors, and for Copilot the difference matters: - `pre_tool_use` deny is real, and the reason text reaches the model. The native string table (runtime.node offset 98057208) carries `permissionDecision`, `permissionDecisionReason`, the default "No reason provided." and the formatter "Denied by preToolUse hook: " as distinct literals, and app.js sets `{textResultForLlm: reason, resultType: "denied"}` per denial and filters that call out of execution. This was previously only an inference drawn from an incident comment; it is now confirmed. The fail-closed "(hook errored)" deny-all strings sit beside these, so that incident was behavior layered on top of a working deny handler, not a substitute for one. - `post_tool_use` honors `modifiedResult`, so compression, injection fencing and image shrink do reach the model: `postToolExecution` (app.js offset 2043150) assigns the returned `toolResultJson` onto the tool result in place. - `post_tool_use` also carries `additionalContext` to the model. The 1.0.80 bundle's JS path has no supplier for it, but on 1.0.88 the native side folds it in: a marker returned there reached the model once, appended to the tool output after `Tool "view" succeeded. Additional guidance from postToolUse hooks:` (tg-captures C1a), and returned beside `modifiedResult` both arrived once, the output replaced and the context appended (C1c). - Failed tool calls never reach `post_tool_use` at all. Copilot routes them to a separate `postToolUseFailure` event, which is handed only a stringified error and honors only `additionalContext`; `modifiedResult` is documented as not honored there. So on Copilot the output of a failed tool call reaches the model unfenced, uncompressed and unshrunk, and no response shape token-goat's shim can emit changes that. Known gap, deliberately recorded. What `additionalContext` does on that event is no longer doc-derived: app.js offset 2043380 reads the native processor's return and, when it carries `additionalContext`, either folds it into `textResultForLlm` (if `appendFailureContextToToolResult` is set) or formats it and pushes `{content, source: "system"}` onto `toolResult.newMessages`. So the channel is real and model-visible -- it just carries advice alongside the failure, never a replacement for it. It is wired now, as its own `post_tool_use_failure` event rather than a reuse of `post_tool_use`: routing failures through the success event would let success-path handlers mark a file as successfully read when the read failed. Because the channel spends tokens instead of saving them, its handler (`src/hooks_tool_failure.ts`) stays silent on a first failure and speaks only on an exact repeat. - `pre_compact` is wired and fires, but nothing it returns can reach the model. Both dispatch sites call it in statement position and drop the result: app.js offset 2467452 (the manual `/compact` path) and offset 2571216 (`case "execute_pre_compact_hook"`). The contrast is what makes this conclusive rather than an absence of evidence -- the same `event()` runner's return IS read for other events, e.g. `notification` at offset 2296123 assigns it and forwards `additionalContext` as a prepended system prompt. The compaction prompt is then built from session history and the user's own focus text, with no hook channel into it. So token-goat's `pre_compact` registration here is observe-only by construction: 1.0.88 confirmed it by run as well as by reading, since a marker returned there as `additionalContext` appeared nowhere in the wire requests, the OTel spans or the model's reply after a manual `/compact` (tg-captures C7 and C7d). The session manifest built there is queued and delivered on the next prompt instead, through `userPromptSubmitted` (see COPILOT_NO_POST_COMPACT_REASON above). */
+  {
+    harness: "copilot_cli",
+    label: "Copilot CLI",
+    sourceFile: "src/bridges/copilot_cli_install.ts (COPILOT_CLI_HOOK_EVENTS), src/bridges/copilot_cli.ts (COPILOT_TO_TG_EVENT)",
+    verification: "dogfooded",
+    verificationNote: "doctor's checkCopilotCli drives the installed shim end to end, and every hook payload field is cross-checked against Copilot's own declarations pinned at 1.0.80 (schemas/copilot_cli.hooks.json). On 1.0.88 the model-visible channels were captured on the wire (tg-captures): postToolUse additionalContext and modifiedResult (C1a, C1b, C1c), preToolUse additionalContext (C2a, C2b), userPromptSubmitted additionalContext in 5 of 5 runs (C3), subagentStart additionalContext at the start of the subagent's own prompt (C4a), and preCompact additionalContext reaching nothing (C7, C7d).",
+    implemented: /* @__PURE__ */ new Set([
+      "session_start",
+      "pre_tool_use",
+      "post_tool_use",
+      "pre_compact",
+      "stop",
+      "subagent_stop",
+      "subagent_start",
+      "user_prompt_submit",
+      "post_tool_use_failure"
+    ]),
+    reasons: [
+      { events: ["post_compact"], reason: COPILOT_NO_POST_COMPACT_REASON },
+      {
+        events: ["notification"],
+        reason: "Copilot CLI has a real 'notification' hook event, but copilot_cli.ts's COPILOT_TO_TG_EVENT deliberately leaves it (and sessionEnd/errorOccurred/permissionRequest) unimplemented rather than guessed at"
+      }
+    ]
+  },
+  {
+    harness: "gemini",
+    label: "Gemini CLI",
+    sourceFile: "src/bridges/gemini_install.ts (GEMINI_HOOK_EVENTS)",
+    verification: "sourced",
+    verificationNote: "Verified against Gemini CLI's published hooks reference (src/bridges/gemini_install.ts); no run against a Gemini binary is recorded here.",
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact"]),
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
+      {
+        events: ["notification", "stop", "user_prompt_submit", "subagent_stop", "subagent_start", "session_start"],
+        reason: `Gemini CLI's hooks integration only wires BeforeTool/AfterTool/PreCompress (README "Gemini CLI users")`
+      }
+    ]
+  },
+  {
+    harness: "qwen",
+    label: "Qwen Code",
+    sourceFile: "src/bridges/qwen_install.ts (QWEN_HOOK_EVENTS)",
+    verification: "documented",
+    verificationNote: "Wired from QwenLM/qwen-code's hooks.md, which src/bridges/qwen_install.ts states was not live-tested against a running install.",
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact", "user_prompt_submit", "subagent_stop"]),
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
+      {
+        events: ["notification"],
+        reason: "Only five Qwen Code events have a token-goat handler; every other real event (Notification, SessionEnd, PostToolUseFailure, StopFailure, SubagentStart, PermissionRequest, TodoCreated, TodoCompleted) is left unimplemented rather than guessed at (qwen_install.ts)"
+      },
+      { events: ["stop"], reason: NO_SERVER_HANDLER_REASON },
+      { events: ["subagent_start"], reason: NO_SUBAGENT_START_REASON },
+      {
+        events: ["session_start"],
+        reason: "QWEN_EVENT_ARG has no session-start mapping wired yet -- left unimplemented rather than guessed at"
+      }
+    ]
+  },
+  {
+    harness: "vscode",
+    label: "VS Code (Copilot agent)",
+    sourceFile: "src/bridges/vscode_install.ts (vscodeHooksDir), src/bridges/copilot_cli.ts (isVscodePayload), src/bridges/vscode_hooks.ts",
+    verification: "sourced",
+    verificationNote: "Hook-file parsing, payload keys, tool names and response fields read from the VS Code 1.136.0 bundle (workbench.desktop.main.js, extensions/copilot/dist/extension.js, extensions/copilot/package.json); the installed shim is driven with VS Code-shaped payloads, but no run inside a live VS Code is recorded here.",
+    implemented: /* @__PURE__ */ new Set(["session_start", "pre_tool_use", "post_tool_use", "user_prompt_submit", "subagent_stop", "subagent_start"]),
+    reasons: [
+      {
+        events: ["pre_compact", "post_tool_use_failure"],
+        reason: "VS Code reads the shared Copilot hooks file but maps only sessionStart, sessionEnd, userPromptSubmitted, preToolUse, postToolUse, agentStop, subagentStop and errorOccurred out of it, so the file's preCompact and postToolUseFailure entries never fire there. Re-read in the 1.138.0 bundle, where the github-copilot branch of that table still lists exactly those eight: the compaction manifest is unavailable on this harness rather than merely unwired, and unlike Copilot CLI and Codex there is no queueing fallback, because the trigger itself never arrives"
+      },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
+      { events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON }
+    ]
+  },
+  {
+    harness: "visualstudio",
+    label: "Visual Studio (Copilot agent)",
+    sourceFile: "src/bridges/visualstudio_install.ts",
+    verification: "documented",
+    verificationNote: "MCP file locations and the servers key from Microsoft's Visual Studio MCP docs (learn.microsoft.com/en-us/visualstudio/ide/mcp-servers), instructions paths from its Copilot chat context page; no run inside a live Visual Studio is recorded here.",
+    implemented: /* @__PURE__ */ new Set(),
+    reasons: [
+      {
+        events: [...HOOK_EVENTS],
+        reason: "Visual Studio documents no agent hooks (GitHub lists hooks only for Copilot cloud agent and Copilot CLI), so install --visualstudio writes no hooks file and token-goat works there through its MCP tools and instructions only"
+      }
+    ]
+  },
+  {
+    harness: "kimi",
+    label: "Kimi Code CLI",
+    sourceFile: "src/bridges/kimi_install.ts (KIMI_EVENT_ARG), src/bridges/kimi.ts (KIMI_HOOK_SCRIPT)",
+    verification: "sourced",
+    verificationNote: "Payload keys and response contract read from MoonshotAI/kimi-code's own source (externalHooksRunner/runner.ts, externalHooksService.ts); no run against a Kimi binary is recorded here.",
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact", "user_prompt_submit", "subagent_stop", "session_start"]),
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
+      { events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON },
+      { events: ["subagent_start"], reason: NO_SUBAGENT_START_REASON }
+    ]
+  },
+  {
+    harness: "antigravity",
+    label: "Antigravity CLI (agy)",
+    sourceFile: "src/bridges/antigravity_install.ts (ANTIGRAVITY_HOOK_EVENTS), src/bridges/antigravity_hooks.ts, src/hooks_cli.ts (antigravityToCanonicalWire)",
+    verification: "documented",
+    verificationNote: `PreToolUse/PostToolUse payload and response fields from atamel.dev's "Where agy hooks" (2026-07-16). The plugin layout and the Windows command form were driven against agy 1.2.11 (a plugin hook fired with the plugin directory as its working directory), but a tool event was not: agy's quota refused the model call, so no PreToolUse payload has been captured.`,
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use"]),
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
+      { events: ["notification", "stop"], reason: NO_SERVER_HANDLER_REASON },
+      { events: ["subagent_start"], reason: NO_SUBAGENT_START_REASON },
+      {
+        events: ["pre_compact", "session_start", "subagent_stop"],
+        reason: "agy documents PreToolUse, PostToolUse, PreInvocation, PostInvocation and Stop only: no compaction, session-start or subagent event exists to wire"
+      },
+      {
+        events: ["user_prompt_submit"],
+        reason: "agy's nearest event is PreInvocation, which fires before each model call rather than once per prompt, and its payload has not been captured; left unwired rather than guessed at"
+      }
+    ]
+  },
+  {
+    harness: "opencode",
+    label: "opencode",
+    sourceFile: "src/bridges/opencode.ts",
+    verification: "sourced",
+    verificationNote: "Tool ids, parameter keys and handler behavior read directly from opencode's own source (src/bridges/opencode.ts); no run against a running gateway is recorded here.",
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact"]),
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
+      {
+        events: ["notification", "stop", "user_prompt_submit", "subagent_stop", "subagent_start", "session_start"],
+        reason: "opencode's plugin API only exposes three relevant hooks -- tool.execute.before, tool.execute.after, experimental.session.compacting (opencode.ts module docstring, verified against opencode's real source)"
+      }
+    ]
+  },
+  {
+    harness: "openclaw",
+    label: "OpenClaw",
+    sourceFile: "src/bridges/openclaw.ts",
+    verification: "sourced",
+    verificationNote: "Verified against the live plugin docs and OpenClaw's aristotle-agent/types.ts; the bridge's own note lists what stays unverified without a live instance (built-in tool names, session id).",
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact"]),
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
+      {
+        events: ["notification", "stop", "user_prompt_submit", "subagent_stop", "subagent_start", "session_start"],
+        reason: "OpenClaw's in-process plugin API only exposes before_tool_call/after_tool_call/before_compaction as api.on() handlers relevant here"
+      }
+    ]
+  },
+  {
+    harness: "pi",
+    label: "pi (pi-coding-agent)",
+    sourceFile: "src/bridges/pi.ts",
+    verification: "sourced",
+    verificationNote: "Response shape verified against pi's own TextContent/ImageContent types (src/bridges/pi.ts); no run against a pi binary is recorded here.",
+    implemented: /* @__PURE__ */ new Set(["pre_tool_use", "post_tool_use", "pre_compact"]),
+    reasons: [
+      { events: ["post_tool_use_failure"], reason: NO_SEPARATE_FAILURE_EVENT_REASON },
+      { events: ["post_compact"], reason: NO_POST_COMPACT_EVENT_REASON },
+      {
+        events: ["notification", "stop", "user_prompt_submit", "subagent_stop", "subagent_start", "session_start"],
+        reason: "pi's extension API subscribes to session_start/tool_call/tool_result/session_before_compact/session_compact, of which only tool_call/tool_result/session_before_compact map onto real HOOK_EVENTS names (pre_tool_use/post_tool_use/pre_compact) -- pi's own session_start event is never forwarded to token-goat's callHook()"
+      }
+    ]
+  }
+];
+function bridgesStatusToJson(matrix = BRIDGE_CAPABILITY_MATRIX) {
+  return matrix.map((row) => {
+    const events = {};
+    for (const event of HOOK_EVENTS) {
+      events[event] = row.implemented.has(event);
+    }
+    const reasons = {};
+    for (const { events: missingEvents, reason } of row.reasons) {
+      for (const event of missingEvents) {
+        reasons[event] = reason;
+      }
+    }
+    return {
+      harness: row.harness,
+      label: row.label,
+      sourceFile: row.sourceFile,
+      verification: row.verification,
+      verificationNote: row.verificationNote,
+      events,
+      reasons
+    };
+  });
+}
+function formatBridgesStatus(matrix = BRIDGE_CAPABILITY_MATRIX) {
+  const lines = [];
+  lines.push("# Bridge hook-event parity matrix");
+  lines.push("");
+  lines.push("Columns: " + HOOK_EVENTS.join(", ") + " (source: HOOK_EVENTS in src/types.ts)");
+  lines.push("Read-only static analysis of src/bridges/*_install.ts and *.ts -- never invokes a real harness binary.");
+  lines.push("");
+  const harnessWidth = Math.max(...matrix.map((r) => r.harness.length), "harness".length);
+  const verifyWidth = Math.max(...matrix.map((r) => r.verification.length), "verified".length);
+  const header = ["harness".padEnd(harnessWidth), ...HOOK_EVENTS.map((e) => e), "score", "verified".padEnd(verifyWidth)].join("  ");
+  lines.push(header);
+  for (const row of matrix) {
+    const cells = HOOK_EVENTS.map((event) => {
+      const cell = row.implemented.has(event) ? "yes" : "no";
+      return cell.padEnd(event.length);
+    });
+    const score = `${row.implemented.size}/${HOOK_EVENTS.length}`;
+    lines.push([row.harness.padEnd(harnessWidth), ...cells, score, row.verification.padEnd(verifyWidth)].join("  "));
+  }
+  lines.push("");
+  lines.push("## How each row was established");
+  for (const level of Object.keys(VERIFICATION_RANK)) {
+    lines.push(`- ${level}: ${VERIFICATION_BLURB[level]}`);
+  }
+  lines.push("");
+  for (const row of [...matrix].sort((a, b) => VERIFICATION_RANK[a.verification] - VERIFICATION_RANK[b.verification])) {
+    lines.push(`- ${row.harness} (${row.verification}): ${row.verificationNote}`);
+  }
+  const gapRows = matrix.filter((r) => r.reasons.length > 0);
+  if (gapRows.length > 0) {
+    lines.push("");
+    lines.push("## Documented gaps");
+    for (const row of gapRows) {
+      for (const { events, reason } of row.reasons) {
+        lines.push(`- ${row.harness}: ${events.join(", ")} -- ${reason}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function installVerificationNotice(harness) {
+  const row = BRIDGE_CAPABILITY_MATRIX.find((r) => r.harness === harness);
+  if (row === void 0 || row.verification === "dogfooded") return null;
+  return `NOTE: the ${row.label} bridge is ${row.verification} -- ${VERIFICATION_BLURB[row.verification]}. If a token-goat feature seems to do nothing here, run \`token-goat doctor\` (its "Tool names" check reports what ${row.label} actually sent) and please open an issue. Details: token-goat bridges-status.`;
+}
+
+export {
+  BRIDGE_CAPABILITY_MATRIX,
+  bridgesStatusToJson,
+  formatBridgesStatus,
+  installVerificationNotice
+};

package/dist/token-goat-chunk-EVMZJ27Z.mjs

@@ -0,0 +1,147 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/line_matchers.ts
+init_define_import_meta_env();
+var ATX_OPEN_RE = /^ {0,3}(#{1,6})(\s+)/;
+var TABLE_OPEN_RE = /^\s*\[+/;
+var TOML_OPEN_RE = /^\s*\[/;
+var TABLE_TAIL_RE = /^\s*(?:[#;].*)?$/;
+var WS_RE = /\s/;
+var ATX_DOT_BREAK_RE = /[\n\r\u{2028}\u{2029}]/u;
+var ATX_CLASS_BREAK_RE = /[\r\n]/;
+function matchAtxHeading(line, lineBreak, absorbTrailingSpace) {
+  const open = ATX_OPEN_RE.exec(line);
+  if (open === null) return null;
+  const level = open[1].length;
+  const gap = open[2];
+  const rest = line.slice(open[0].length);
+  if (rest === "") {
+    if (gap.length < 2) return null;
+    const lowest = absorbTrailingSpace ? 1 : gap.length - 1;
+    for (let j = gap.length - 1; j >= lowest; j--) if (!lineBreak.test(gap.charAt(j))) return { level, name: "" };
+    return null;
+  }
+  const body = rest.trimEnd();
+  let hashStart = body.length;
+  while (hashStart > 0 && body.charAt(hashStart - 1) === "#") hashStart--;
+  let title = absorbTrailingSpace ? body : rest;
+  if (hashStart < body.length && hashStart > 0 && WS_RE.test(body.charAt(hashStart - 1))) {
+    let p = hashStart;
+    while (p > 0 && WS_RE.test(body.charAt(p - 1))) p--;
+    title = body.slice(0, p);
+  }
+  if (lineBreak.test(title)) return hashStart === 0 ? closingFromGap(gap, level, lineBreak) : null;
+  return { level, name: title.trim() };
+}
+function closingFromGap(gap, level, lineBreak) {
+  for (let i = gap.length - 2; i >= 1; i--) if (!lineBreak.test(gap.charAt(i))) return { level, name: "" };
+  return null;
+}
+function matchTomlSectionName(line) {
+  const open = TOML_OPEN_RE.exec(line);
+  if (open === null) return null;
+  const close = line.indexOf("]", open[0].length);
+  if (close < 0) return null;
+  const inner = line.slice(open[0].length, close);
+  const start = inner.startsWith("[") ? 1 : 0;
+  let first = start;
+  while (first < inner.length && WS_RE.test(inner.charAt(first))) first++;
+  if (first < inner.length) return inner.slice(first);
+  if (first > start) return inner.charAt(first - 1);
+  return start === 1 ? "[" : null;
+}
+function matchTableHeaderName(line) {
+  const open = TABLE_OPEN_RE.exec(line);
+  if (open === null) return null;
+  const close = line.indexOf("]", open[0].length);
+  if (close < 0) return null;
+  let after = close;
+  while (line.charAt(after) === "]") after++;
+  if (!TABLE_TAIL_RE.test(line.slice(after))) return null;
+  const inner = line.slice(open[0].length, close);
+  let first = 0;
+  while (first < inner.length && WS_RE.test(inner.charAt(first))) first++;
+  if (first < inner.length) {
+    let last = inner.length;
+    while (WS_RE.test(inner.charAt(last - 1))) last--;
+    return inner.slice(first, last);
+  }
+  if (first > 0) return inner.charAt(first - 1);
+  return open[0].trimStart().length >= 2 ? "[" : null;
+}
+function matchRuleBannerTitle(line) {
+  const n = line.length;
+  if (line.charAt(0) !== "#") return null;
+  let p = 1;
+  while (p < n && WS_RE.test(line.charAt(p))) p++;
+  let run = 0;
+  while (p + run < n && isRuleChar(line.charAt(p + run))) run++;
+  let tail = 0;
+  while (tail < n && isRuleChar(line.charAt(n - 1 - tail))) tail++;
+  if (run < 2 || tail < 2) return null;
+  let wsStart = n - tail;
+  while (WS_RE.test(line.charAt(wsStart - 1))) wsStart--;
+  const firstEnd = (from) => {
+    if (from <= wsStart) return wsStart;
+    const end = Math.max(from, n - tail + 1);
+    return end <= n - 2 ? end : -1;
+  };
+  const nextBreak = lineBreakIndex(line);
+  for (let k = run; k >= 2; k--) {
+    let start = p + k;
+    if (k === run) while (start < n && WS_RE.test(line.charAt(start))) start++;
+    if (start >= n) continue;
+    const end = firstEnd(start + 2);
+    if (end >= 0 && nextBreak(start) >= end) return line.slice(start, end);
+    if (firstEnd(start + 1) === start + 1) return line.charAt(start);
+  }
+  return null;
+}
+function matchRestOfLine(text, start, minGap) {
+  const n = text.length;
+  let k = start;
+  while (k < n && WS_RE.test(text.charAt(k))) k++;
+  if (k - start < minGap) return null;
+  if (k < n) {
+    let lineEnd = k;
+    while (lineEnd < n && !ATX_DOT_BREAK_RE.test(text.charAt(lineEnd))) lineEnd++;
+    return text.slice(k, lineEnd).trimEnd();
+  }
+  for (let m = n - 1; m >= start + minGap; m--) if (!ATX_DOT_BREAK_RE.test(text.charAt(m))) return text.charAt(m);
+  return null;
+}
+function isRuleChar(c) {
+  return c === "-" || c === "=";
+}
+function lineBreakIndex(line) {
+  if (!ATX_DOT_BREAK_RE.test(line)) return () => line.length;
+  const next = new Array(line.length + 1);
+  next[line.length] = line.length;
+  for (let i = line.length - 1; i >= 0; i--) next[i] = ATX_DOT_BREAK_RE.test(line.charAt(i)) ? i : next[i + 1];
+  return (from) => next[from];
+}
+function matchCssSelectorSpan(line) {
+  const brace = line.indexOf("{");
+  if (brace < 0) return null;
+  let indent = 0;
+  while (indent < line.length && (line.charAt(indent) === " " || line.charAt(indent) === "	")) indent++;
+  let start = Math.min(indent, brace - 1);
+  if (start >= 0 && (line.charAt(start) === "}" || line.charAt(start) === "@")) start--;
+  if (start < 0) return null;
+  return { start, end: brace };
+}
+
+export {
+  ATX_DOT_BREAK_RE,
+  ATX_CLASS_BREAK_RE,
+  matchAtxHeading,
+  matchTomlSectionName,
+  matchTableHeaderName,
+  matchRuleBannerTitle,
+  matchRestOfLine,
+  matchCssSelectorSpan
+};