@ken-jo/agent-connector 0.4.8 → 0.4.26

package/dist/{chunk-OZ5EXXQV.js → chunk-JLMD3IGK.js}

@@ -2,7 +2,7 @@
 import {
   allAdapters,
   loadAdapter
-} from "./chunk-XQUUNAGC.js";
+} from "./chunk-HU6DZZBG.js";
 
 // src/sdk/introspect.ts
 var SURFACE_PREDICATES = {
@@ -41,4 +41,4 @@ export {
   hostsSupporting,
   surfaceSupport
 };
-//# sourceMappingURL=chunk-OZ5EXXQV.js.map
+//# sourceMappingURL=chunk-JLMD3IGK.js.map

package/dist/{chunk-YS2NYJ6R.js → chunk-KD4BE5MW.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-DBQMX75U.js";
 import {
   BaseAdapter
-} from "./chunk-KG6T3YNJ.js";
+} from "./chunk-3I7UG52L.js";
 import {
   renderSkillMd
 } from "./chunk-IEGR4TP3.js";
@@ -676,4 +676,4 @@ export {
   adapter,
   antigravity_default
 };
-//# sourceMappingURL=chunk-YS2NYJ6R.js.map
+//# sourceMappingURL=chunk-KD4BE5MW.js.map

package/dist/{chunk-FAHIMJRU.js → chunk-L7ESV37V.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ensureDir
-} from "./chunk-TRQKHP7D.js";
+} from "./chunk-QY42WGBX.js";
 
 // src/core/config-patch-ledger.ts
 import { createHash, randomBytes } from "crypto";
@@ -174,4 +174,4 @@ export {
   removeLedgerOwner,
   dropLedgerEntry
 };
-//# sourceMappingURL=chunk-FAHIMJRU.js.map
+//# sourceMappingURL=chunk-L7ESV37V.js.map

package/dist/{chunk-JNM3TPLX.js → chunk-LETB5HCK.js}

@@ -4,7 +4,7 @@ import {
   inferModelFamily,
   openStore,
   worstConfidence
-} from "./chunk-BCHWFTV4.js";
+} from "./chunk-F4DSMVZ7.js";
 
 // src/telemetry/surface-footprint.ts
 function countParts(parts, family, tok) {
@@ -590,4 +590,4 @@ export {
   formatHostNativeTurns,
   formatSurfaceLeaderboard
 };
-//# sourceMappingURL=chunk-JNM3TPLX.js.map
+//# sourceMappingURL=chunk-LETB5HCK.js.map

package/dist/{chunk-7TVBFRVI.js → chunk-M3H7PQWT.js}

@@ -8,7 +8,7 @@ import {
   connectorsDir,
   dataRoot,
   ensureDir
-} from "./chunk-TRQKHP7D.js";
+} from "./chunk-QY42WGBX.js";
 
 // src/core/marketplace-state.ts
 import { createHash } from "crypto";
@@ -505,4 +505,4 @@ export {
   marketplaceEvidence,
   hashDirectory
 };
-//# sourceMappingURL=chunk-7TVBFRVI.js.map
+//# sourceMappingURL=chunk-M3H7PQWT.js.map

package/dist/{chunk-JWNT5KW7.js → chunk-O7SDRBVB.js}

@@ -73,6 +73,7 @@ function hostRoots(platformId) {
       out.push(join(homedir(), ".pi", "agent", "sessions"));
       break;
     case "kimi":
+      out.push(join(homedir(), ".kimi-code", "sessions"));
       out.push(join(homedir(), ".kimi", "sessions"));
       break;
     case "copilot-cli":
@@ -188,10 +189,11 @@ function listSubdirs(dir) {
 
 export {
   expandHome,
+  hostRoots,
   firstExistingRoot,
   isDir,
   isFile,
   walkFiles,
   listSubdirs
 };
-//# sourceMappingURL=chunk-JWNT5KW7.js.map
+//# sourceMappingURL=chunk-O7SDRBVB.js.map

package/dist/chunk-O7SDRBVB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/usage/paths.ts"],"sourcesContent":["/**\n * usage/paths — per-platform HOST storage-root resolution + small fs walkers.\n *\n * This is the read-only complement to core/paths.ts: where that module resolves\n * the FRAMEWORK data-root (~/.agent-connector), this one resolves each agent\n * CLI's OWN native storage roots (~/.qwen, ~/.claude, …) so the usage readers\n * can parse them. It NEVER writes; it only enumerates files.\n *\n * Ported from tokscale paths.rs (the tokscale cache dir) and from each reader's\n * storage-path spec (docs/research/usage-readers.json). Resolution order is\n * uniform across platforms:\n *   1. an explicit AGENT_CONNECTOR_<PLATFORM>_DIR env override (verbatim, when\n *      non-empty — an empty string is treated as unset so we never resolve to \"\");\n *   2. the platform-specific default for the current OS.\n *\n * The \"tokscale cache dir\" (~/.config/tokscale, or AGENT_CONNECTOR_TOKSCALE_DIR)\n * is where synced readers (cursor/antigravity/antigravity-cli/trae/warp) look for\n * a local cache that a separate tokscale run may have produced — we read it if\n * present, but we never create or sync it. (Antigravity's own native store is\n * protobuf .pb with no public schema, so it too is synced-cache-or-skip.)\n */\n\nimport {\n  existsSync,\n  readdirSync,\n  statSync,\n} from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { isAbsolute, join, resolve } from \"node:path\";\n\n// ─────────────────────────────────────────────────────────────────────────\n// Home / env helpers\n// ─────────────────────────────────────────────────────────────────────────\n\n/** Expand a leading \"~\" (and \"~/\") to the user's home directory. */\nexport function expandHome(p: string): string {\n  if (p === \"~\") return homedir();\n  if (p.startsWith(\"~/\") || p.startsWith(\"~\\\\\")) {\n    return join(homedir(), p.slice(2));\n  }\n  return p;\n}\n\n/**\n * Read an env override, treating empty/blank as unset (mirrors tokscale's\n * is_config_dir_overridden contract: an empty override must NOT resolve to \"\").\n * Relative paths are resolved against the process CWD; \"~\" is expanded.\n */\nfunction envOverride(name: string): string | undefined {\n  const raw = process.env[name];\n  if (raw == null || raw.trim() === \"\") return undefined;\n  const expanded = expandHome(raw.trim());\n  return isAbsolute(expanded) ? expanded : resolve(expanded);\n}\n\n/** $XDG_DATA_HOME (when set & non-empty) else ~/.local/share. */\nfunction xdgDataHome(): string {\n  const xdg = process.env.XDG_DATA_HOME;\n  if (xdg && xdg.trim() !== \"\") return resolve(expandHome(xdg.trim()));\n  return join(homedir(), \".local\", \"share\");\n}\n\n/** $XDG_CONFIG_HOME (when set & non-empty) else ~/.config. */\nfunction xdgConfigHome(): string {\n  const xdg = process.env.XDG_CONFIG_HOME;\n  if (xdg && xdg.trim() !== \"\") return resolve(expandHome(xdg.trim()));\n  return join(homedir(), \".config\");\n}\n\n/** Windows %LOCALAPPDATA% else ~/AppData/Local. */\nfunction localAppData(): string {\n  const v = process.env.LOCALAPPDATA;\n  if (v && v.trim() !== \"\") return resolve(v.trim());\n  return join(homedir(), \"AppData\", \"Local\");\n}\n\nconst isMac = process.platform === \"darwin\";\nconst isWin = process.platform === \"win32\";\n\n// ─────────────────────────────────────────────────────────────────────────\n// tokscale cache dir (for synced readers)\n// ─────────────────────────────────────────────────────────────────────────\n\n/**\n * Resolve the tokscale config dir (where synced caches live). Ported from\n * tokscale paths.rs get_config_dir():\n *   1. AGENT_CONNECTOR_TOKSCALE_DIR override (verbatim, non-empty);\n *   2. macOS: $HOME/.config/tokscale (NOT ~/Library/Application Support);\n *   3. Linux: $XDG_CONFIG_HOME/tokscale or ~/.config/tokscale;\n *   4. Windows: %APPDATA%/tokscale (config_dir equivalent) else ~/.config/tokscale.\n *\n * We use AGENT_CONNECTOR_TOKSCALE_DIR (not TOKSCALE_CONFIG_DIR) so the framework\n * never accidentally couples to a tokscale install's hermetic test env.\n */\nexport function tokscaleConfigDir(): string {\n  const override = envOverride(\"AGENT_CONNECTOR_TOKSCALE_DIR\");\n  if (override) return override;\n  if (isMac) return join(homedir(), \".config\", \"tokscale\");\n  if (isWin) {\n    const appData = process.env.APPDATA;\n    if (appData && appData.trim() !== \"\") return join(resolve(appData.trim()), \"tokscale\");\n    return join(homedir(), \".config\", \"tokscale\");\n  }\n  return join(xdgConfigHome(), \"tokscale\");\n}\n\n/** The directory a synced platform's local cache lives under, e.g. `<tokscale>/cursor-cache`. */\nexport function tokscaleCacheDir(name: string): string {\n  return join(tokscaleConfigDir(), name);\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// Antigravity native store roots (DETECTION ONLY — not parsed for usage)\n//\n// CONFIRMED-BY-INSTALL (2026-06-03, docs/research/antigravity-paths-confirmed.md):\n// the native Antigravity store is `~/.gemini/antigravity/conversations/<uuid>.pb`\n// — PROTOBUF with no public schema — and `brain/<uuid>/` holds only media +\n// `*.metadata.json`. There are NO `transcript*.jsonl` files. The `agy` CLI shares\n// this SAME `~/.gemini/antigravity/` dir (no separate config/storage dir). So the\n// native dir is used only for platform DETECTION (in the adapters); the usage\n// readers do NOT parse it (protobuf, unreadable) — they are SYNCED readers that\n// read the tokscale synced-cache instead (see hostRoots → antigravity-cache).\n//\n// These helpers are retained for any detection caller and honor the standard\n// AGENT_CONNECTOR_<PLATFORM>_DIR override (prepended, preferred when set).\n// ─────────────────────────────────────────────────────────────────────────\n\n/**\n * The native Antigravity store root for DETECTION: `~/.gemini/antigravity/`\n * (CONFIRMED). Its `conversations/<uuid>.pb` payloads are protobuf with no public\n * schema, so this dir is NOT parsed for usage — only its presence is a signal.\n *\n * Honors AGENT_CONNECTOR_ANTIGRAVITY_DIR (verbatim, when set) as the override.\n */\nexport function antigravityNativeRoots(): string[] {\n  const out: string[] = [];\n  const override = envOverride(\"AGENT_CONNECTOR_ANTIGRAVITY_DIR\");\n  if (override) out.push(override);\n  out.push(join(homedir(), \".gemini\", \"antigravity\"));\n  return out;\n}\n\n/**\n * The native store root for the Antigravity CLI (`agy`) for DETECTION. CONFIRMED:\n * `agy` has NO separate dir — it SHARES the IDE's `~/.gemini/antigravity/` (also\n * protobuf, not parsed for usage).\n *\n * Honors AGENT_CONNECTOR_ANTIGRAVITY_CLI_DIR (verbatim, when set) as the override.\n */\nexport function antigravityCliNativeRoots(): string[] {\n  const out: string[] = [];\n  const override = envOverride(\"AGENT_CONNECTOR_ANTIGRAVITY_CLI_DIR\");\n  if (override) out.push(override);\n  out.push(join(homedir(), \".gemini\", \"antigravity\"));\n  return out;\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// Per-platform host roots\n// ─────────────────────────────────────────────────────────────────────────\n\n/**\n * Candidate host storage roots for a platform, most-preferred first. Readers\n * iterate the returned list and use the first that exists (each variant is the\n * OS-correct default; the env override, when present, is prepended).\n *\n * Only the platforms this subsystem currently ships a reader for are listed in\n * detail; the table is structured so a new platform is one new case. Returning\n * `[]` (no candidate root) makes a reader fail-open to zero records.\n */\nexport function hostRoots(platformId: string): string[] {\n  const out: string[] = [];\n  const override = envOverride(`AGENT_CONNECTOR_${platformId.toUpperCase().replace(/-/g, \"_\")}_DIR`);\n  if (override) out.push(override);\n\n  switch (platformId) {\n    case \"qwen-code\":\n      // ~/.qwen/projects/*/chats/*.jsonl\n      out.push(join(homedir(), \".qwen\", \"projects\"));\n      break;\n    case \"claude-code\":\n      out.push(join(homedir(), \".claude\", \"projects\"));\n      break;\n    case \"codex\":\n      out.push(join(homedir(), \".codex\", \"sessions\"));\n      break;\n    case \"gemini-cli\":\n      out.push(join(homedir(), \".gemini\", \"tmp\"));\n      break;\n    case \"pi\":\n      out.push(join(homedir(), \".pi\", \"agent\", \"sessions\"));\n      break;\n    case \"kimi\":\n      // TWO Moonshot products share the \"kimi\" id with DIFFERENT session trees:\n      //   - Kimi Code (newer, @moonshot-ai/kimi-code): ~/.kimi-code/sessions/...\n      //     (deeper tree, see readers/kimi.ts) — the product our adapter targets.\n      //   - Kimi CLI (older): ~/.kimi/sessions/<GROUP>/<UUID>/wire.jsonl\n      // Both are scanned (Kimi Code preferred first). $KIMI_CODE_HOME relocates\n      // the Kimi Code home and is honored ahead of these in readers/kimi.ts.\n      out.push(join(homedir(), \".kimi-code\", \"sessions\"));\n      out.push(join(homedir(), \".kimi\", \"sessions\"));\n      break;\n    case \"copilot-cli\":\n      out.push(join(xdgDataHome(), \"Copilot\", \"telemetry\"));\n      out.push(join(xdgConfigHome(), \"copilot\", \"telemetry\"));\n      break;\n    case \"amp\":\n      out.push(join(xdgDataHome(), \"amp\", \"threads\"));\n      break;\n    case \"droid\":\n      out.push(join(homedir(), \".factory\", \"sessions\"));\n      break;\n    case \"mux\":\n      out.push(join(homedir(), \".mux\", \"sessions\"));\n      break;\n    case \"kiro\":\n      out.push(join(homedir(), \".kiro\", \"sessions\", \"cli\"));\n      break;\n    case \"opencode\":\n      out.push(join(xdgDataHome(), \"opencode\", \"opencode.db\"));\n      break;\n    case \"goose\":\n      if (isMac) out.push(join(homedir(), \"Library\", \"Application Support\", \"goose\", \"sessions\", \"sessions.db\"));\n      out.push(join(xdgDataHome(), \"goose\", \"sessions\", \"sessions.db\"));\n      out.push(join(xdgDataHome(), \"Block\", \"goose\", \"sessions\", \"sessions.db\"));\n      break;\n    case \"hermes\":\n      out.push(join(homedir(), \".hermes\", \"state.db\"));\n      break;\n    case \"kilo-cli\":\n      out.push(join(xdgDataHome(), \"kilo\", \"kilo.db\"));\n      break;\n    case \"crush\":\n      out.push(join(homedir(), \".cache\", \"crush\", \"crush.db\"));\n      break;\n    case \"zed\":\n      if (isMac) out.push(join(homedir(), \"Library\", \"Application Support\", \"Zed\", \"threads\", \"threads.db\"));\n      else if (isWin) out.push(join(localAppData(), \"Zed\", \"threads\", \"threads.db\"));\n      else out.push(join(xdgDataHome(), \"zed\", \"threads\", \"threads.db\"));\n      break;\n    // Synced platforms: local cache under the tokscale config dir.\n    case \"cursor\":\n      out.push(tokscaleCacheDir(\"cursor-cache\"));\n      break;\n    case \"antigravity\":\n      // SYNCED: the native store is protobuf (.pb, no public schema) and NOT\n      // parseable, so the reader reads only the tokscale synced-cache mirror if a\n      // separate tokscale run produced one (else [] → \"requires sync\"). The\n      // native `~/.gemini/antigravity/` dir is used only for detection.\n      out.push(tokscaleCacheDir(\"antigravity-cache\"));\n      break;\n    case \"antigravity-cli\":\n      // SYNCED: `agy` shares the IDE's protobuf (.pb) store (no schema), so the\n      // reader reads only the tokscale synced-cache mirror if present (else [] →\n      // \"requires sync\"). Shares the IDE's antigravity-cache name (same data).\n      out.push(tokscaleCacheDir(\"antigravity-cache\"));\n      break;\n    case \"trae\":\n      out.push(tokscaleCacheDir(\"trae-cache\"));\n      break;\n    case \"warp\":\n      out.push(tokscaleCacheDir(\"warp-cache\"));\n      break;\n    default:\n      break;\n  }\n  return out;\n}\n\n/** First existing host root for a platform, or undefined when none is present. */\nexport function firstExistingRoot(platformId: string): string | undefined {\n  for (const root of hostRoots(platformId)) {\n    if (existsSync(root)) return root;\n  }\n  return undefined;\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// Directory / glob walkers (tolerant — never throw)\n// ─────────────────────────────────────────────────────────────────────────\n\n/** Is the path an existing directory? Tolerant (false on any stat error). */\nexport function isDir(p: string): boolean {\n  try {\n    return statSync(p).isDirectory();\n  } catch {\n    return false;\n  }\n}\n\n/** Is the path an existing regular file? Tolerant (false on any stat error). */\nexport function isFile(p: string): boolean {\n  try {\n    return statSync(p).isFile();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Recursively list every file under `root` whose name matches `predicate`.\n * Tolerant: an unreadable directory is skipped, never thrown. Returns absolute\n * paths in directory-walk order. A non-existent root yields [].\n */\nexport function walkFiles(\n  root: string,\n  predicate: (name: string, absPath: string) => boolean,\n  maxDepth = 12,\n): string[] {\n  const out: string[] = [];\n  if (!isDir(root)) return out;\n\n  const stack: Array<{ dir: string; depth: number }> = [{ dir: root, depth: 0 }];\n  while (stack.length > 0) {\n    const { dir, depth } = stack.pop() as { dir: string; depth: number };\n    let entries: import(\"node:fs\").Dirent[];\n    try {\n      entries = readdirSync(dir, { withFileTypes: true });\n    } catch {\n      continue; // unreadable dir → skip\n    }\n    for (const entry of entries) {\n      const abs = join(dir, entry.name);\n      if (entry.isDirectory()) {\n        if (depth < maxDepth) stack.push({ dir: abs, depth: depth + 1 });\n      } else if (entry.isFile() && predicate(entry.name, abs)) {\n        out.push(abs);\n      }\n    }\n  }\n  return out;\n}\n\n/**\n * List immediate subdirectory names of `dir` (not recursive). Tolerant: returns\n * [] for a missing/unreadable directory.\n */\nexport function listSubdirs(dir: string): string[] {\n  if (!isDir(dir)) return [];\n  try {\n    return readdirSync(dir, { withFileTypes: true })\n      .filter((e) => e.isDirectory())\n      .map((e) => join(dir, e.name));\n  } catch {\n    return [];\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-MOW2RKHX.js → chunk-OLI5SD6I.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   defineConnector
-} from "./chunk-HOE2MN36.js";
+} from "./chunk-YEJCNOET.js";
 import {
   connectorDir,
   connectorsDir,
   ensureDir
-} from "./chunk-TRQKHP7D.js";
+} from "./chunk-QY42WGBX.js";
 
 // src/core/load-connector.ts
 import { existsSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "fs";
@@ -45,7 +45,11 @@ async function loadConnectorFromPath(path) {
     const connector2 = defineConnector(config);
     return { connector: connector2, modulePath };
   }
-  const mod = await import(pathToFileURL(modulePath).href);
+  const moduleUrl = pathToFileURL(modulePath).href;
+  const mod = await import(
+    /* @vite-ignore */
+    moduleUrl
+  );
   const exported = mod.default;
   if (exported == null) {
     throw new Error(
@@ -174,4 +178,4 @@ export {
   connectorFromMeta,
   listRegisteredConnectors
 };
-//# sourceMappingURL=chunk-MOW2RKHX.js.map
+//# sourceMappingURL=chunk-OLI5SD6I.js.map

package/dist/chunk-OLI5SD6I.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/load-connector.ts"],"sourcesContent":["/**\n * core/load-connector — discover, load, and register connector definitions.\n *\n * Responsibilities:\n *   1. Locate the developer's `agent-connector.config.{mjs,js,json}` by walking\n *      upward from a start directory (the project root convention).\n *   2. Load a config from a path into a LIVE ResolvedConnector (with handlers).\n *   3. Register a connector by persisting SERIALIZABLE metadata (no functions)\n *      to `connectorDir(id)/connector.json`, pointing at the source module so\n *      live handlers can be re-imported at runtime from a stable record.\n *\n * Why split live vs. serialized? Hook handlers are functions and cannot survive\n * JSON. The registry stores only what JSON can hold plus an absolute\n * `modulePath`; the runtime re-imports that module to recover the live handlers.\n */\n\nimport { existsSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from \"node:fs\";\nimport { dirname, isAbsolute, join, resolve } from \"node:path\";\nimport { pathToFileURL } from \"node:url\";\n\nimport type {\n  CommandDef,\n  HookEventName,\n  InstallScope,\n  MemoryDef,\n  PlatformId,\n  PlatformOverride,\n  ResolvedConnector,\n  ServerDef,\n  SkillDef,\n  SubagentDef,\n} from \"./types.js\";\nimport { defineConnector } from \"./define-connector.js\";\nimport { connectorDir, connectorsDir, ensureDir } from \"./paths.js\";\n\n/** Candidate config filenames, in resolution-precedence order. */\nconst CONFIG_FILENAMES = [\n  \"agent-connector.config.mjs\",\n  \"agent-connector.config.js\",\n  \"agent-connector.config.json\",\n] as const;\n\n/**\n * The serializable subset of a connector persisted to `connector.json`.\n * Hook handler functions are intentionally absent — only the absolute\n * `modulePath` is stored so the live ResolvedConnector can be re-imported.\n */\nexport interface RegisteredMeta {\n  id: string;\n  displayName: string;\n  version: string;\n  /** Absolute path to the source module that produced this connector. */\n  modulePath: string;\n  telemetry: ResolvedConnector[\"telemetry\"];\n  /** Canonical event names the connector handles (handlers themselves stripped). */\n  hookEvents: HookEventName[];\n  hasServer: boolean;\n  server: ServerDef | null;\n  /**\n   * Content surfaces (commands/skills/subagents). These are JSON-serializable\n   * (no functions) so they persist cleanly and let uninstall locate the files\n   * to remove even when the source module is gone.\n   */\n  commands: CommandDef[];\n  skills: SkillDef[];\n  subagents: SubagentDef[];\n  /**\n   * Memory entries (managed-block content surface). Plain content, persisted\n   * whole so uninstall normally has the full entry list even when the source\n   * module is gone (the marker prefix-scan is the fallback beyond that).\n   */\n  memory: MemoryDef[];\n  targets: ResolvedConnector[\"targets\"];\n  /** Per-platform overrides with any hook handler functions stripped. */\n  platforms: Partial<Record<PlatformId, PlatformOverride>>;\n  /**\n   * The install scope this connector was registered under, persisted so the\n   * runtime entrypoints (hook/statusline/action) can recover it cheaply (sync)\n   * and stamp it onto the HostCtx/event — scope is an install-time property the\n   * runtime otherwise has no access to. OPTIONAL: absent for an ad-hoc register\n   * that passed no scope, or a record written before this field existed.\n   * This is the install's RUN-WIDE DEFAULT scope; it can differ from the\n   * effective per-host scope when a `platforms[host].scope` override is set (the\n   * record is keyed by connector id only and holds no per-host scope map).\n   */\n  scope?: InstallScope;\n}\n\n/**\n * Search `startDir` and each ancestor for a connector config file. Returns the\n * absolute path to the first match (filesystem-root-stopping), or null.\n */\nexport function findConnectorConfig(startDir: string): string | null {\n  let dir = resolve(startDir);\n  // Walk upward until `dirname(dir) === dir` (filesystem root).\n  for (;;) {\n    for (const name of CONFIG_FILENAMES) {\n      const candidate = join(dir, name);\n      if (existsSync(candidate)) return candidate;\n    }\n    const parent = dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n  return null;\n}\n\n/** True if a value already looks like a ResolvedConnector (vs. a raw config). */\nfunction isResolvedConnector(value: unknown): value is ResolvedConnector {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    Array.isArray((value as { hookEvents?: unknown }).hookEvents)\n  );\n}\n\n/**\n * Load a connector from an absolute or relative path.\n *   - `.json`           → JSON.parse, then defineConnector().\n *   - `.mjs` / `.js`    → dynamic import (via pathToFileURL, Windows-safe),\n *                         take the default export. If it already looks like a\n *                         ResolvedConnector use it as-is; otherwise treat it as\n *                         a ConnectorConfig and run it through defineConnector().\n * Returns the live connector plus the absolute module path it came from.\n */\nexport async function loadConnectorFromPath(\n  path: string,\n): Promise<{ connector: ResolvedConnector; modulePath: string }> {\n  let modulePath = isAbsolute(path) ? path : resolve(path);\n  // Canonicalize before building the file:// URL for dynamic import. On Windows a\n  // short (8.3) temp path like C:\\Users\\RUNNER~1\\...\\x.mjs round-trips the \"~\" as\n  // %7E and fails to load; realpathSync.native expands it to the real long path.\n  // It also resolves symlinked temp roots (e.g. macOS /var -> /private/var).\n  // If the file does not exist yet, fall through with the resolve()'d path so the\n  // subsequent read/import throws the real not-found error.\n  try {\n    modulePath = realpathSync.native(modulePath);\n  } catch {\n    /* keep the resolve()'d path */\n  }\n\n  if (modulePath.endsWith(\".json\")) {\n    const text = readFileSync(modulePath, \"utf8\");\n    const config = JSON.parse(text) as unknown;\n    const connector = defineConnector(config as Parameters<typeof defineConnector>[0]);\n    return { connector, modulePath };\n  }\n\n  // .mjs / .js — dynamic ESM import. pathToFileURL keeps Windows paths valid.\n  const moduleUrl = pathToFileURL(modulePath).href;\n  const mod = (await import(/* @vite-ignore */ moduleUrl)) as {\n    default?: unknown;\n  };\n  const exported = mod.default;\n  if (exported == null) {\n    throw new Error(\n      `Connector module has no default export: ${modulePath}`,\n    );\n  }\n  const connector = isResolvedConnector(exported)\n    ? exported\n    : defineConnector(exported as Parameters<typeof defineConnector>[0]);\n  return { connector, modulePath };\n}\n\n/**\n * Strip any function-valued `hooks` from per-platform overrides so the result\n * is JSON-serializable. A boolean `hooks` override is preserved; an object\n * override is dropped (it can only carry handler functions, which are not\n * serializable). `nativeHooks` declarations are persisted HANDLER-LESS (event\n * name + matcher only) so meta-based inspection (doctor / health checks / the\n * hook CLI) can still see WHICH native events were declared — the live handlers\n * are re-imported from `modulePath` at runtime, exactly like normalized hooks.\n * Everything else on the override is kept verbatim — notably `configPatch`\n * declarations, which are pure JSON (key/value/reason/docsUrl, no functions)\n * and persist WHOLE so uninstall/doctor can reason about them even when the\n * source module is gone.\n */\nfunction serializablePlatforms(\n  platforms: Partial<Record<PlatformId, PlatformOverride>>,\n): Partial<Record<PlatformId, PlatformOverride>> {\n  const out: Partial<Record<PlatformId, PlatformOverride>> = {};\n  for (const [id, override] of Object.entries(platforms) as [\n    PlatformId,\n    PlatformOverride | undefined,\n  ][]) {\n    if (!override) continue;\n    const { hooks, nativeHooks, ...rest } = override;\n    const clean: PlatformOverride = { ...rest };\n    // Keep only a boolean hooks flag; object hooks carry handler functions.\n    if (typeof hooks === \"boolean\") clean.hooks = hooks;\n    if (nativeHooks && typeof nativeHooks === \"object\") {\n      const stripped: Record<string, { matcher?: string }> = {};\n      for (const [event, def] of Object.entries(nativeHooks)) {\n        stripped[event] =\n          typeof def?.matcher === \"string\" ? { matcher: def.matcher } : {};\n      }\n      // Cast: the persisted record deliberately omits the (non-serializable)\n      // handler; consumers of meta-derived connectors never dispatch handlers.\n      clean.nativeHooks = stripped as PlatformOverride[\"nativeHooks\"];\n    }\n    out[id] = clean;\n  }\n  return out;\n}\n\n/**\n * Persist a connector's serializable metadata to `connectorDir(id)/connector.json`.\n * Handlers are NOT serialized — they are re-imported from `modulePath` at runtime.\n * The optional `scope` (the install scope the caller deployed under) is persisted\n * so the runtime entrypoints can recover it and stamp it onto the HostCtx/event.\n * Returns the absolute path of the written record.\n */\nexport function registerConnector(\n  connector: ResolvedConnector,\n  modulePath: string,\n  scope?: InstallScope,\n): string {\n  const meta: RegisteredMeta = {\n    id: connector.id,\n    displayName: connector.displayName,\n    version: connector.version,\n    modulePath: resolve(modulePath),\n    telemetry: connector.telemetry,\n    hookEvents: connector.hookEvents,\n    hasServer: !!connector.server,\n    server: connector.server ?? null,\n    commands: connector.commands,\n    skills: connector.skills,\n    subagents: connector.subagents,\n    memory: connector.memory,\n    targets: connector.targets,\n    platforms: serializablePlatforms(connector.platforms),\n    // Persist the install scope when the caller supplied one (the installer\n    // passes its install scope). Omitted from the record when undefined so an\n    // ad-hoc register stays minimal and round-trips as \"no scope known\".\n    ...(scope !== undefined ? { scope } : {}),\n  };\n\n  const dir = connectorDir(connector.id);\n  ensureDir(dir);\n  const outPath = join(dir, \"connector.json\");\n  writeFileSync(outPath, `${JSON.stringify(meta, null, 2)}\\n`, \"utf8\");\n  return outPath;\n}\n\n/**\n * Deregister a connector by removing its DATA-dir record directory\n * (`connectorDir(id)`) recursively. This is the inverse of {@link registerConnector}:\n * registerConnector writes `connectorDir(id)/connector.json`, but per-target\n * uninstall only strips host-native registrations — it never removes this record,\n * leaving an orphan behind. Best-effort + guarded: returns the directory path and\n * whether it existed before removal.\n */\nexport function deregisterConnector(id: string): {\n  removed: boolean;\n  path: string;\n} {\n  const dir = connectorDir(id);\n  const existed = existsSync(dir);\n  if (existed) rmSync(dir, { recursive: true, force: true });\n  return { removed: existed, path: dir };\n}\n\n/**\n * Read the registered metadata record for `id`, or null if not registered or\n * the record is unreadable/corrupt.\n */\nexport function readRegisteredMeta(id: string): RegisteredMeta | null {\n  const recordPath = join(connectorDir(id), \"connector.json\");\n  if (!existsSync(recordPath)) return null;\n  try {\n    return JSON.parse(readFileSync(recordPath, \"utf8\")) as RegisteredMeta;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Load the LIVE ResolvedConnector (with hook handlers) for a registered id by\n * re-importing its source module. Throws a clear error when the connector is\n * not registered or its source module no longer resolves to it.\n */\nexport async function loadRegisteredConnector(\n  id: string,\n): Promise<ResolvedConnector> {\n  const meta = readRegisteredMeta(id);\n  if (!meta) {\n    throw new Error(\n      `Connector \"${id}\" is not registered (no record at ${join(connectorDir(id), \"connector.json\")}). ` +\n        `Run an install/register step first.`,\n    );\n  }\n  if (!meta.modulePath || !existsSync(meta.modulePath)) {\n    throw new Error(\n      `Connector \"${id}\" record points at a missing module: ${meta.modulePath}`,\n    );\n  }\n  const { connector } = await loadConnectorFromPath(meta.modulePath);\n  return connector;\n}\n\n/**\n * Build a handler-less ResolvedConnector from stored metadata. Suitable for\n * inspection/doctor where live hook handlers are not needed (and where the\n * source module may even be gone). `hooks` is empty; `hookEvents` is preserved.\n */\nexport function connectorFromMeta(meta: RegisteredMeta): ResolvedConnector {\n  return {\n    id: meta.id,\n    displayName: meta.displayName,\n    version: meta.version,\n    ...(meta.server ? { server: meta.server } : {}),\n    hooks: {},\n    hookEvents: meta.hookEvents ?? [],\n    telemetry: meta.telemetry,\n    commands: meta.commands ?? [],\n    skills: meta.skills ?? [],\n    subagents: meta.subagents ?? [],\n    memory: meta.memory ?? [],\n    // Actions carry live `run` handlers, so they are NOT serialized into the\n    // record (like the statusline render). A handler-less meta-derived connector\n    // gets [] — inspection/uninstall never dispatch action handlers, and the\n    // BaseAdapter action default already tolerates an empty list.\n    actions: [],\n    platforms: meta.platforms ?? {},\n    targets: meta.targets,\n  };\n}\n\n/**\n * List every registered connector as a handler-less ResolvedConnector (read\n * from `connectorsDir()`). Used by doctor to health-check what is actually\n * installed, rather than guessing from the local working directory.\n */\nexport function listRegisteredConnectors(): ResolvedConnector[] {\n  const dir = connectorsDir();\n  if (!existsSync(dir)) return [];\n  const out: ResolvedConnector[] = [];\n  for (const entry of readdirSync(dir)) {\n    const meta = readRegisteredMeta(entry);\n    if (meta) out.push(connectorFromMeta(meta));\n  }\n  return out;\n}\n"],"mappings":"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","names":["connector"]}

package/dist/{chunk-NYR55UT7.js → chunk-Q5HR4ADS.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ADAPTER_REGISTRY
-} from "./chunk-XQUUNAGC.js";
+} from "./chunk-HU6DZZBG.js";
 
 // src/adapters/detect.ts
 async function detectInstalledPlatforms(projectDir) {
@@ -80,4 +80,4 @@ export {
   detectInstalledPlatforms,
   detectRuntimeHost
 };
-//# sourceMappingURL=chunk-NYR55UT7.js.map
+//# sourceMappingURL=chunk-Q5HR4ADS.js.map

package/dist/{chunk-TRQKHP7D.js → chunk-QY42WGBX.js}

@@ -5,12 +5,13 @@ import { createHash } from "crypto";
 import {
   chmodSync,
   existsSync,
+  lstatSync,
   mkdirSync,
   readFileSync,
   writeFileSync
 } from "fs";
 import { homedir } from "os";
-import { basename, join, resolve } from "path";
+import { basename, join, parse, relative, resolve, sep } from "path";
 function dataRoot() {
   const override = process.env.AGENT_CONNECTOR_DATA_DIR;
   if (override && override.trim() !== "") return resolve(override);
@@ -35,6 +36,25 @@ function homeBinPath() {
 function ensureDir(dir) {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 }
+function firstSymlinkInPath(path) {
+  const abs = resolve(path);
+  const root = parse(abs).root;
+  const rest = relative(root, abs);
+  if (rest === "") return null;
+  let cur = root;
+  for (const part of rest.split(sep)) {
+    if (part === "") continue;
+    cur = join(cur, part);
+    try {
+      if (lstatSync(cur).isSymbolicLink()) return cur;
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT") return null;
+      throw err;
+    }
+  }
+  return null;
+}
 function ensureHomeBin(cliEntry, nodePath = process.execPath) {
   const binPath = homeBinPath();
   ensureDir(join(dataRoot(), "bin"));
@@ -87,7 +107,8 @@ export {
   telemetryPath,
   homeBinPath,
   ensureDir,
+  firstSymlinkInPath,
   ensureHomeBin,
   projectIdentity
 };
-//# sourceMappingURL=chunk-TRQKHP7D.js.map
+//# sourceMappingURL=chunk-QY42WGBX.js.map

package/dist/chunk-QY42WGBX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/paths.ts"],"sourcesContent":["/**\n * core/paths — home data-root, stable home binary, and project identity.\n *\n * Operating model (docs/ARCHITECTURE.md §3):\n *   • One home data-root holds the single binary + shared telemetry + state.\n *     Override with AGENT_CONNECTOR_DATA_DIR (the cross-agent shared-DB key).\n *     This relocates FRAMEWORK state only — never platform-native config files.\n *   • The home binary lives at a STABLE path so every host's pointer config\n *     keeps working across updates (no versioned cache dir → no cache-heal bug).\n *   • Per-project data is keyed by a stable project identity (git remote ||\n *     normalized absolute path), hashed — not by code location.\n */\n\nimport { createHash } from \"node:crypto\";\nimport {\n  chmodSync,\n  existsSync,\n  lstatSync,\n  mkdirSync,\n  readFileSync,\n  writeFileSync,\n} from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { basename, join, parse, relative, resolve, sep } from \"node:path\";\n\n/** Framework data-root: AGENT_CONNECTOR_DATA_DIR || ~/.agent-connector. */\nexport function dataRoot(): string {\n  const override = process.env.AGENT_CONNECTOR_DATA_DIR;\n  if (override && override.trim() !== \"\") return resolve(override);\n  return join(homedir(), \".agent-connector\");\n}\n\nexport function connectorsDir(): string {\n  return join(dataRoot(), \"connectors\");\n}\nexport function connectorDir(id: string): string {\n  return join(connectorsDir(), id);\n}\nexport function backupsDir(): string {\n  return join(dataRoot(), \"backups\");\n}\nexport function logsDir(): string {\n  return join(dataRoot(), \"logs\");\n}\n\n/** Telemetry store path for the selected backend. */\nexport function telemetryPath(store: \"ndjson\" | \"sqlite\" = \"ndjson\"): string {\n  return join(dataRoot(), store === \"sqlite\" ? \"telemetry.db\" : \"telemetry.ndjson\");\n}\n\n/** Stable, OS-correct path to the single home binary pointer. */\nexport function homeBinPath(): string {\n  const name = process.platform === \"win32\" ? \"agent-connector.cmd\" : \"agent-connector\";\n  return join(dataRoot(), \"bin\", name);\n}\n\nexport function ensureDir(dir: string): void {\n  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });\n}\n\n/**\n * Return the first existing symbolic-link component in `path`, or null when the\n * existing prefix is symlink-free. Stops at the first missing component so new\n * directories/files can still be created normally.\n */\nexport function firstSymlinkInPath(path: string): string | null {\n  const abs = resolve(path);\n  const root = parse(abs).root;\n  const rest = relative(root, abs);\n  if (rest === \"\") return null;\n\n  let cur = root;\n  for (const part of rest.split(sep)) {\n    if (part === \"\") continue;\n    cur = join(cur, part);\n    try {\n      if (lstatSync(cur).isSymbolicLink()) return cur;\n    } catch (err) {\n      const code = (err as NodeJS.ErrnoException).code;\n      if (code === \"ENOENT\") return null;\n      throw err;\n    }\n  }\n  return null;\n}\n\n/**\n * Write a stable launcher at homeBinPath() that execs the real CLI entry.\n * Avoids symlinks (Windows constraint) and versioned paths. Idempotent.\n *\n * @param cliEntry absolute path to the installed cli.js\n * @param nodePath node runtime to exec with (defaults to current process.execPath)\n * @returns the stable launcher path\n */\nexport function ensureHomeBin(cliEntry: string, nodePath: string = process.execPath): string {\n  const binPath = homeBinPath();\n  ensureDir(join(dataRoot(), \"bin\"));\n  const node = nodePath.replace(/\\\\/g, \"/\");\n  const cli = cliEntry.replace(/\\\\/g, \"/\");\n  if (process.platform === \"win32\") {\n    writeFileSync(binPath, `@echo off\\r\\n\"${node}\" \"${cli}\" %*\\r\\n`, \"utf8\");\n  } else {\n    writeFileSync(binPath, `#!/bin/sh\\nexec \"${node}\" \"${cli}\" \"$@\"\\n`, \"utf8\");\n    chmodSync(binPath, 0o755);\n  }\n  return binPath;\n}\n\n/** Read remote.origin.url from a project's .git/config without spawning git. */\nfunction gitRemoteUrl(projectDir: string): string | null {\n  const cfg = join(projectDir, \".git\", \"config\");\n  if (!existsSync(cfg)) return null;\n  try {\n    const text = readFileSync(cfg, \"utf8\");\n    // Find [remote \"origin\"] ... url = X\n    const lines = text.split(/\\r?\\n/);\n    let inOrigin = false;\n    for (const line of lines) {\n      const s = line.trim();\n      if (s.startsWith(\"[\")) inOrigin = /^\\[remote\\s+\"origin\"\\]$/.test(s);\n      else if (inOrigin) {\n        const m = s.match(/^url\\s*=\\s*(.+)$/);\n        if (m && m[1]) return m[1].trim();\n      }\n    }\n  } catch {\n    /* ignore */\n  }\n  return null;\n}\n\nexport interface ProjectIdentity {\n  /** Hashed stable key used to partition telemetry/state. */\n  key: string;\n  /** Human-readable label (git remote or directory name). */\n  label: string;\n  /** Absolute project directory. */\n  dir: string;\n}\n\n/**\n * Derive a stable project identity. Prefers the git origin URL (stable across\n * clones/locations); falls back to the normalized absolute path.\n */\nexport function projectIdentity(projectDir: string): ProjectIdentity {\n  const dir = resolve(projectDir);\n  const remote = gitRemoteUrl(dir);\n  const basis = remote ?? dir;\n  const key = createHash(\"sha256\").update(basis).digest(\"hex\").slice(0, 16);\n  return { key, label: remote ?? basename(dir), dir };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-HOE2MN36.js → chunk-YEJCNOET.js}

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import {
   REGISTERED_PLATFORM_IDS
-} from "./chunk-XQUUNAGC.js";
+} from "./chunk-HU6DZZBG.js";
 import {
   CONFIG_PATCH_SEGMENT_RE,
   configPatchNamespaceViolation,
   isJsonValue,
   isValidConfigPatchKey
-} from "./chunk-FAHIMJRU.js";
+} from "./chunk-L7ESV37V.js";
 import {
   MANAGED_BLOCK_BEGIN_TOKEN,
   MANAGED_BLOCK_END_TOKEN,
   MEMORY_CONTENT_HARD_CAP_BYTES
-} from "./chunk-N6HH7K6P.js";
+} from "./chunk-ZY25RG4Y.js";
 
 // src/core/define-connector.ts
 import { isAbsolute, normalize } from "path";
@@ -495,4 +495,4 @@ export {
   defineConfigPatch,
   defineNativeHook
 };
-//# sourceMappingURL=chunk-HOE2MN36.js.map
+//# sourceMappingURL=chunk-YEJCNOET.js.map

package/dist/{chunk-WI6YSXOC.js → chunk-YKVNI44Y.js}

@@ -5,21 +5,21 @@ import {
   newRecordId,
   openStore,
   worstConfidence
-} from "./chunk-BCHWFTV4.js";
+} from "./chunk-F4DSMVZ7.js";
 import {
   log
 } from "./chunk-KHO5WNTP.js";
 import {
   loadRegisteredConnector,
   readRegisteredMeta
-} from "./chunk-MOW2RKHX.js";
+} from "./chunk-OLI5SD6I.js";
 import {
   REGISTERED_PLATFORM_IDS,
   loadAdapter
-} from "./chunk-XQUUNAGC.js";
+} from "./chunk-HU6DZZBG.js";
 import {
   projectIdentity
-} from "./chunk-TRQKHP7D.js";
+} from "./chunk-QY42WGBX.js";
 
 // src/runtime/telemetry-accessor.ts
 var ZERO = {
@@ -28,34 +28,56 @@ var ZERO = {
   totalTokens: 0,
   calls: 0
 };
-function buildTelemetryAccessor(connectorId) {
-  return async () => {
-    if (process.env.AGENT_CONNECTOR_TELEMETRY === "0") return { ...ZERO };
+function readTelemetryUsageSummary(connectorId) {
+  if (process.env.AGENT_CONNECTOR_TELEMETRY === "0") return { ...ZERO };
+  try {
+    const store = openStore({});
     try {
-      const store = openStore({});
-      try {
-        let inputTokens = 0;
-        let outputTokens = 0;
-        let calls = 0;
-        for (const row of store.query({ connectorId })) {
-          inputTokens += Number.isFinite(row.inputTokens) ? row.inputTokens : 0;
-          outputTokens += Number.isFinite(row.outputTokens) ? row.outputTokens : 0;
-          calls += 1;
-        }
-        return {
-          inputTokens,
-          outputTokens,
-          totalTokens: inputTokens + outputTokens,
-          calls
-        };
-      } finally {
-        store.close();
+      let inputTokens = 0;
+      let outputTokens = 0;
+      let calls = 0;
+      for (const row of store.query({ connectorId })) {
+        inputTokens += Number.isFinite(row.inputTokens) ? row.inputTokens : 0;
+        outputTokens += Number.isFinite(row.outputTokens) ? row.outputTokens : 0;
+        calls += 1;
       }
-    } catch {
-      return { ...ZERO };
+      return {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+        calls
+      };
+    } finally {
+      store.close();
     }
+  } catch {
+    return { ...ZERO };
+  }
+}
+function buildTelemetryAccessor(connectorId) {
+  return async () => {
+    return readTelemetryUsageSummary(connectorId);
   };
 }
+function attachLazyTelemetryUsage(ctx, connectorId, read = readTelemetryUsageSummary) {
+  let cached;
+  let hasCached = false;
+  Object.defineProperty(ctx, "usage", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      if (!hasCached) {
+        cached = read(connectorId);
+        hasCached = true;
+      }
+      return cached;
+    },
+    set(value) {
+      cached = value;
+      hasCached = true;
+    }
+  });
+}
 
 // src/telemetry/measure.ts
 var MODALITY_ESTIMATE = {
@@ -340,6 +362,7 @@ async function runNativeHook(opts) {
 
 export {
   buildTelemetryAccessor,
+  attachLazyTelemetryUsage,
   measureToolCall,
   measureToolDefs,
   eventMatcherSubject,
@@ -348,4 +371,4 @@ export {
   isNativeHookDeclared,
   runNativeHook
 };
-//# sourceMappingURL=chunk-WI6YSXOC.js.map
+//# sourceMappingURL=chunk-YKVNI44Y.js.map

package/dist/chunk-YKVNI44Y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/runtime/telemetry-accessor.ts","../src/telemetry/measure.ts","../src/runtime/hook-entrypoint.ts"],"sourcesContent":["/**\n * runtime/telemetry-accessor — build the handler-facing {@link TelemetryAccessor}.\n *\n * Every runtime entrypoint (hook / statusline / action) stamps `ctx.telemetry`\n * (or `evt.telemetry`) with the accessor built here so a connector handler can\n * read ITS OWN recorded usage on demand (`await ctx.telemetry?.()`), without the\n * handler reaching into the telemetry store directly.\n *\n * The accessor is LAZY (it opens the store only when called) and DEFENSIVE:\n *   - AGENT_CONNECTOR_TELEMETRY=0 → resolves zeros without touching disk;\n *   - any read error → resolves zeros (NEVER throws into a handler — the hook\n *     runtime is fail-open, the statusline fail-safe, and even the action\n *     surface must not have a usage read crash an otherwise-fine run).\n *\n * COST: each accessor call, or the first read of a lazy `ctx.usage`, reads the\n * connector's telemetry file in full (the NDJSON store has no since/limit bound)\n * and linear-scans it. Cheap for normal stores, but a handler on a HOT path\n * should call it only when it needs usage.\n */\n\nimport type { TelemetryAccessor, TelemetryUsageSummary } from \"../core/types.js\";\nimport { openStore } from \"../telemetry/store.js\";\n\n/** The empty summary returned when telemetry is off or a read fails. */\nconst ZERO: TelemetryUsageSummary = {\n  inputTokens: 0,\n  outputTokens: 0,\n  totalTokens: 0,\n  calls: 0,\n};\n\n/**\n * Synchronously sum every stored row's inputTokens/outputTokens for the\n * connector and count rows (`calls`). Honors the AGENT_CONNECTOR_TELEMETRY=0\n * kill switch (zeros, no disk touch) and swallows any error (zeros).\n */\nexport function readTelemetryUsageSummary(connectorId: string): TelemetryUsageSummary {\n  if (process.env.AGENT_CONNECTOR_TELEMETRY === \"0\") return { ...ZERO };\n  try {\n    const store = openStore({});\n    try {\n      let inputTokens = 0;\n      let outputTokens = 0;\n      let calls = 0;\n      // COERCE each addend to a finite number: query() tolerates malformed\n      // LINES but does not validate field shapes, so a legacy/hand-edited row\n      // with a missing (→ NaN) or string (→ concat) token field must not\n      // poison the summary's numeric contract. A non-finite token reads as 0.\n      for (const row of store.query({ connectorId })) {\n        inputTokens += Number.isFinite(row.inputTokens) ? row.inputTokens : 0;\n        outputTokens += Number.isFinite(row.outputTokens) ? row.outputTokens : 0;\n        calls += 1;\n      }\n      return {\n        inputTokens,\n        outputTokens,\n        totalTokens: inputTokens + outputTokens,\n        calls,\n      };\n    } finally {\n      store.close();\n    }\n  } catch {\n    // Never throw into a handler — a usage read failure resolves to zeros.\n    return { ...ZERO };\n  }\n}\n\n/**\n * Build a {@link TelemetryAccessor} bound to `connectorId`. The returned async\n * function uses {@link readTelemetryUsageSummary}; it never throws.\n */\nexport function buildTelemetryAccessor(connectorId: string): TelemetryAccessor {\n  return async (): Promise<TelemetryUsageSummary> => {\n    return readTelemetryUsageSummary(connectorId);\n  };\n}\n\n/**\n * Install a cached lazy `usage` property on a statusline context. This preserves\n * synchronous `ctx.usage` reads for render functions without forcing every\n * status refresh to scan the telemetry store when the render never uses usage.\n */\nexport function attachLazyTelemetryUsage(\n  ctx: { usage?: TelemetryUsageSummary },\n  connectorId: string,\n  read: (connectorId: string) => TelemetryUsageSummary = readTelemetryUsageSummary,\n): void {\n  let cached: TelemetryUsageSummary | undefined;\n  let hasCached = false;\n\n  Object.defineProperty(ctx, \"usage\", {\n    configurable: true,\n    enumerable: true,\n    get() {\n      if (!hasCached) {\n        cached = read(connectorId);\n        hasCached = true;\n      }\n      return cached;\n    },\n    set(value: TelemetryUsageSummary | undefined) {\n      cached = value;\n      hasCached = true;\n    },\n  });\n}\n","/**\n * telemetry/measure — pure measurement helpers over a single MCP tool call.\n *\n * The framework tokenizes its OWN bytes: the tool-call arguments going in, the\n * tool result coming out, and the fixed tool-definition schemas. These helpers\n * turn those into {@link TokenCount}s using the default {@link Tokenizer}.\n *\n * Honesty rules:\n *   • Binary modalities (image/audio/resource blobs) are NOT tokenized — base64\n *     would massively over-count. Each gets a flat per-modality estimate, and\n *     because that estimate is itself an approximation the combined confidence\n *     is pulled down to at least \"tokenizer-approx\".\n *   • When combining several counts, the reported confidence is the WORST\n *     (least-confident) of the inputs — never report \"exact\" for a mixed bag.\n *\n * Everything here is pure: no IO, no mutation of inputs.\n */\n\nimport { getTokenizer } from \"./tokenizer.js\";\nimport { worstConfidence } from \"./types.js\";\nimport type {\n  ConfidenceSource,\n  ModelFamily,\n  TokenCount,\n  Tokenizer,\n} from \"./types.js\";\n\n/** Per-call measurement: tokens in, tokens out, and combined confidence. */\nexport interface ToolCallMeasurement {\n  inputTokens: number;\n  outputTokens: number;\n  source: ConfidenceSource;\n}\n\n/**\n * Flat token estimates for non-text content blocks. These mirror common host\n * accounting (an image tile is roughly ~85 tokens at low detail); they are\n * deliberately coarse — we never tokenize the underlying base64 payload.\n */\nconst MODALITY_ESTIMATE: Record<string, number> = {\n  image: 85,\n  audio: 85,\n  resource: 85,\n};\n/** Fallback estimate for an unknown non-text block type. */\nconst UNKNOWN_BLOCK_ESTIMATE = 85;\n\n// Confidence ordering + the worst-of comparison live in ./types (the single\n// source of truth, imported as `worstConfidence` above). Re-exported here so\n// callers that already import `worstConfidence` from this module keep working\n// as a new ConfidenceSource value (e.g. tokenizer-calibrated) slots into the\n// shared ordering.\nexport { worstConfidence };\n\n/** Reduce a list of sources to the single worst (least-confident) one. */\nfunction combineSources(sources: readonly ConfidenceSource[]): ConfidenceSource {\n  // Default to the most-confident floor so an empty list combines to the only\n  // other source it is paired with; in practice callers always pass ≥1 source.\n  let worst: ConfidenceSource = \"host-native\";\n  for (const s of sources) worst = worstConfidence(worst, s);\n  return worst;\n}\n\n// ── Structural shapes we read from a tool result (kept local + narrow) ───────\n\n/** A text content block: `{ type: \"text\", text: \"...\" }`. */\ninterface TextBlock {\n  type: \"text\";\n  text?: unknown;\n}\n/** Any content block; only text blocks expose a `text` field we tokenize. */\ninterface ContentBlock {\n  type?: unknown;\n  text?: unknown;\n}\n/** The portion of an MCP tool result we measure. */\ninterface ToolResultLike {\n  content?: unknown;\n  structuredContent?: unknown;\n}\n\nfunction isObject(v: unknown): v is Record<string, unknown> {\n  return typeof v === \"object\" && v !== null;\n}\n\nfunction isTextBlock(block: ContentBlock): block is TextBlock {\n  return block.type === \"text\";\n}\n\n/**\n * Measure one tool call.\n *\n * Input  = canonical JSON of `args`.\n * Output = tokens over the TEXTUAL parts of `result`:\n *   • If `result.content` is an array of blocks, text blocks are tokenized via\n *     their `text` field and non-text blocks add a flat per-modality estimate\n *     (no base64 tokenization).\n *   • `result.structuredContent`, when present, is tokenized as canonical JSON.\n *   • Anything else (string / arbitrary object) is tokenized as canonical JSON.\n *\n * The reported `source` is the worst of the input and output sources.\n */\nexport function measureToolCall(\n  args: unknown,\n  result: unknown,\n  family: ModelFamily,\n  tok: Tokenizer = getTokenizer(),\n): ToolCallMeasurement {\n  const input = tok.countValue(args, family);\n  const output = measureResult(result, family, tok);\n  return {\n    inputTokens: input.tokens,\n    outputTokens: output.tokens,\n    source: worstConfidence(input.source, output.source),\n  };\n}\n\n/** Tokenize the textual + structured parts of a tool result. */\nfunction measureResult(\n  result: unknown,\n  family: ModelFamily,\n  tok: Tokenizer,\n): TokenCount {\n  if (!isObject(result)) {\n    // Plain string or scalar result — count its canonical form directly.\n    return tok.countValue(result, family);\n  }\n\n  const res = result as ToolResultLike;\n  const sources: ConfidenceSource[] = [];\n  let tokens = 0;\n\n  if (Array.isArray(res.content)) {\n    for (const raw of res.content) {\n      if (!isObject(raw)) continue;\n      const block = raw as ContentBlock;\n      if (isTextBlock(block)) {\n        const text = typeof block.text === \"string\" ? block.text : \"\";\n        const c = tok.count(text, family);\n        tokens += c.tokens;\n        sources.push(c.source);\n      } else {\n        // image / audio / resource / unknown → flat estimate, no base64 BPE.\n        const key = typeof block.type === \"string\" ? block.type : \"\";\n        tokens += MODALITY_ESTIMATE[key] ?? UNKNOWN_BLOCK_ESTIMATE;\n        // A flat estimate is an approximation, never \"exact\".\n        sources.push(\"tokenizer-approx\");\n      }\n    }\n  } else if (res.content !== undefined) {\n    // content present but not an array (e.g. a bare string) → count it whole.\n    const c = tok.countValue(res.content, family);\n    tokens += c.tokens;\n    sources.push(c.source);\n  }\n\n  if (res.structuredContent !== undefined) {\n    const c = tok.countValue(res.structuredContent, family);\n    tokens += c.tokens;\n    sources.push(c.source);\n  }\n\n  // Nothing measurable found → count the whole object as a fallback so we never\n  // silently report zero for a non-empty result.\n  if (sources.length === 0) {\n    return tok.countValue(result, family);\n  }\n\n  return { tokens, source: combineSources(sources) };\n}\n\n/**\n * Measure the fixed tool-definition overhead: tokenize the JSON of the entire\n * `tools/list` array once. `tools` is the raw array of tool descriptors as the\n * server advertises them (shape is host/SDK-specific, so it is treated as\n * opaque JSON here).\n */\nexport function measureToolDefs(\n  tools: readonly unknown[],\n  family: ModelFamily,\n  tok: Tokenizer = getTokenizer(),\n): TokenCount {\n  return tok.countValue(tools, family);\n}\n\n/**\n * Measure one RUNTIME hook dispatch (the new `hook` developer-axis surface).\n *\n * Input  = canonical JSON of the inbound normalized event payload the handler\n *          reads (the host-provided fields: toolInput / prompt / raw / etc.).\n * Output = canonical JSON of what the handler RETURNS that becomes context or a\n *          decision the host consumes (additionalContext / updatedInput / reason\n *          and the rest of the normalized {@link HookResponse}).\n *\n * Uses the SAME tokenizer + worst-of confidence combination as the proxy. Pure:\n * no IO, no mutation. The two values are tokenized whole (a hook payload has no\n * binary content blocks to special-case, unlike a tool result).\n */\nexport function measureHook(\n  eventPayload: unknown,\n  handlerReturn: unknown,\n  family: ModelFamily,\n  tok: Tokenizer = getTokenizer(),\n): ToolCallMeasurement {\n  const input = tok.countValue(eventPayload, family);\n  const output = tok.countValue(handlerReturn, family);\n  return {\n    inputTokens: input.tokens,\n    outputTokens: output.tokens,\n    source: worstConfidence(input.source, output.source),\n  };\n}\n","/**\n * runtime/hook-entrypoint — the universal json-stdio hook dispatcher.\n *\n * Every json-stdio host points its hook config at the single stable home binary\n * (`<homeBin> hook <platformId> <event> --connector <id>`, built by\n * core/spawn.buildHomeBinHookCommand). The CLI reads stdin and calls\n * {@link runHook} with the parsed flags + the raw stdin string. This module:\n *\n *   1. Loads the registered connector (live handlers) and the host adapter.\n *   2. Parses the host's stdin payload into a normalized event via the adapter.\n *   3. Finds the connector's handler for the event, honoring the tool matcher.\n *   4. Runs the handler, normalizes its return, and formats the adapter's native\n *      reply.\n *\n * Fail-open is the safety contract: ANY error degrades to exit 0 (\"allow\") so a\n * framework or handler bug can never wedge a host's tool call — EXCEPT when the\n * event is PreToolUse or PermissionRequest and the handler explicitly denied,\n * in which case the deny (a deliberate security decision) is preserved rather\n * than swallowed.\n */\n\nimport type {\n  HookEventName,\n  HookResponse,\n  NativeHookDef,\n  NativeHookEvent,\n  PlatformId,\n  ResolvedConnector,\n} from \"../core/types.js\";\nimport { log } from \"../core/logger.js\";\nimport {\n  loadRegisteredConnector,\n  readRegisteredMeta,\n} from \"../core/load-connector.js\";\nimport { loadAdapter, REGISTERED_PLATFORM_IDS } from \"../adapters/registry.js\";\nimport { buildTelemetryAccessor } from \"./telemetry-accessor.js\";\nimport type { NormalizedEvent } from \"../adapters/spi.js\";\nimport { projectIdentity } from \"../core/paths.js\";\nimport { measureHook } from \"../telemetry/measure.js\";\nimport { openStore, newRecordId } from \"../telemetry/store.js\";\nimport { getTokenizer, inferModelFamily } from \"../telemetry/tokenizer.js\";\n\n/** Flags + stdin the CLI hands to {@link runHook}. */\nexport interface RunHookOptions {\n  /** Host platform id from the hook command (`hook <platformId> ...`). */\n  platformId: string;\n  /** Canonical lifecycle event name from the hook command. */\n  event: HookEventName;\n  /** Connector id from `--connector <id>`. */\n  connectorId: string;\n  /** Raw stdin payload (host-native JSON). Empty string is tolerated → `{}`. */\n  stdin: string;\n}\n\n/** Process-level result the CLI translates into exit code + stdout/stderr. */\nexport interface RunHookResult {\n  exitCode: number;\n  stdout?: string;\n  stderr?: string;\n}\n\n/** A pass-through \"allow\" reply with exit 0 and no payload. */\nconst ALLOW: RunHookResult = { exitCode: 0 };\n\n/**\n * The string a connector matcher filters on, when the event carries one:\n * tool events (PreToolUse / PostToolUse / PermissionRequest /\n * PostToolUseFailure) expose `toolName`; subagent events expose `agentType`.\n * Returns undefined when the event has neither (no filtering) — including a\n * SubagentStop arriving WITHOUT agent_type, which some hosts fail to populate;\n * filtering out such an event would silently drop a real stop, so we run the\n * handler instead (fail-open).\n */\nexport function eventMatcherSubject(evt: NormalizedEvent): string | undefined {\n  const name = (evt as { toolName?: unknown }).toolName;\n  if (typeof name === \"string\") return name;\n  const agentType = (evt as { agentType?: unknown }).agentType;\n  if (typeof agentType === \"string\") return agentType;\n  return undefined;\n}\n\n/**\n * Tolerantly parse the host's stdin payload. Empty / whitespace-only input is a\n * legitimate \"no payload\" signal from some hosts and resolves to `{}`. Malformed\n * JSON also degrades to `{}` rather than throwing — fail-open is the contract.\n */\nfunction parseStdin(stdin: string): unknown {\n  const trimmed = stdin.trim();\n  if (trimmed === \"\") return {};\n  try {\n    return JSON.parse(trimmed);\n  } catch {\n    return {};\n  }\n}\n\n/**\n * Compile the connector's matcher (a regex string) for a tool event. A missing\n * or empty matcher matches everything (returns null → no filtering). An invalid\n * regex degrades to \"match everything\" so a typo never blocks tool calls.\n */\nexport function compileMatcher(matcher: string | undefined): RegExp | null {\n  if (!matcher || matcher === \"\") return null;\n  try {\n    return new RegExp(matcher);\n  } catch {\n    return null;\n  }\n}\n\n/**\n * Normalize a handler return into a concrete HookResponse. A void/non-object\n * return becomes `{}` — NO decision — which every adapter formats as\n * pass-through allow (`response.decision ?? \"allow\"`). Deliberately NOT\n * `{decision:\"allow\"}`: on PermissionRequest an explicit \"allow\" is an ACTIVE\n * grant that suppresses the host's permission dialog, and a handler that\n * returns nothing must fall through to the dialog, never silently grant.\n */\nfunction normalizeResponse(value: HookResponse | void): HookResponse {\n  if (value == null || typeof value !== \"object\") return {};\n  return value;\n}\n\n/**\n * Resolve the host platform to stamp on a hook telemetry row. Mirrors the serve\n * `--host` plumbing: the install-target platform id is baked into the hook\n * command (`hook <platformId> <event> …`) so `opts.platformId` is authoritative,\n * but an explicit env override (AGENT_CONNECTOR_HOST) wins when it names a known\n * platform. Falls back to the event's adapter-stamped hostPlatform, then\n * \"unknown\" — never throws.\n */\nfunction resolveHookHostPlatform(\n  platformId: string,\n  evt: NormalizedEvent | NativeHookEvent,\n): PlatformId {\n  const override = process.env.AGENT_CONNECTOR_HOST;\n  if (\n    override !== undefined &&\n    REGISTERED_PLATFORM_IDS.has(override as PlatformId)\n  ) {\n    return override as PlatformId;\n  }\n  if (REGISTERED_PLATFORM_IDS.has(platformId as PlatformId)) {\n    return platformId as PlatformId;\n  }\n  const fromEvent = (evt as { hostPlatform?: unknown }).hostPlatform;\n  if (\n    typeof fromEvent === \"string\" &&\n    REGISTERED_PLATFORM_IDS.has(fromEvent as PlatformId)\n  ) {\n    return fromEvent as PlatformId;\n  }\n  return \"unknown\";\n}\n\n/**\n * Record one RUNTIME hook dispatch as a `hook` developer-axis telemetry row.\n *\n * input  = the inbound event payload the handler reads (normalized event, or\n *          the {@link NativeHookEvent} envelope for native passthrough hooks);\n * output = what the handler returned (a normalized {@link HookResponse}, or the\n *          verbatim native reply object). Tokenized with the SAME tokenizer the\n *          proxy uses. For a native hook `opts.event` is the host-native name.\n *\n * MUST be fail-open (the hook runtime is fail-open by contract): any error here\n * is swallowed so a measurement bug can NEVER break a host's hook. Honors the\n * AGENT_CONNECTOR_TELEMETRY=0 kill switch (skips entirely; the store's append is\n * already a no-op under it, but we also skip the tokenize work).\n */\nfunction recordHookTelemetry(\n  opts: { platformId: string; event: string; connectorId: string },\n  connector: ResolvedConnector,\n  evt: NormalizedEvent | NativeHookEvent,\n  response: unknown,\n): void {\n  if (process.env.AGENT_CONNECTOR_TELEMETRY === \"0\") return;\n  try {\n    const family = inferModelFamily(\"\", connector.telemetry.modelFamilyHint);\n    const measurement = measureHook(evt, response, family, getTokenizer());\n\n    const sessionId =\n      typeof (evt as { sessionId?: unknown }).sessionId === \"string\"\n        ? ((evt as { sessionId: string }).sessionId)\n        : \"\";\n    const evtProjectDir = (evt as { projectDir?: unknown }).projectDir;\n    const projectDir =\n      typeof evtProjectDir === \"string\" && evtProjectDir !== \"\"\n        ? evtProjectDir\n        : process.cwd();\n    const id = projectIdentity(projectDir);\n\n    const store = openStore({});\n    try {\n      store.append({\n        id: newRecordId(0),\n        ts: Date.now(),\n        connectorId: opts.connectorId,\n        toolName: opts.event, // for a hook row the per-item name IS the event\n        scope: \"hook\",\n        surfaceKind: \"hook\",\n        hostPlatform: resolveHookHostPlatform(opts.platformId, evt),\n        sessionId,\n        projectKey: id.key,\n        projectDir: id.dir,\n        inputTokens: measurement.inputTokens,\n        outputTokens: measurement.outputTokens,\n        confidenceSource: measurement.source,\n        isError: false,\n      });\n    } finally {\n      store.close();\n    }\n  } catch {\n    // Fail-open: a telemetry error must NEVER break the hook runtime.\n  }\n}\n\n/**\n * Dispatch one host hook invocation. Always resolves (never rejects): every\n * failure path returns a concrete {@link RunHookResult} so the CLI can exit\n * cleanly. See the module header for the fail-open contract.\n */\nexport async function runHook(opts: RunHookOptions): Promise<RunHookResult> {\n  const { platformId, event, connectorId, stdin } = opts;\n\n  try {\n    const connector = await loadRegisteredConnector(connectorId);\n    const adapter = await loadAdapter(platformId);\n\n    // mcp-only hosts (and any adapter without runtime dispatch) cannot parse a\n    // hook payload — nothing to do, allow.\n    if (!adapter || !adapter.parseEvent || !adapter.formatReply) {\n      return ALLOW;\n    }\n\n    const raw = parseStdin(stdin);\n    const evt = adapter.parseEvent(event, raw);\n    // The hook command carries the authoritative connector id; stamp it on the\n    // event so handlers see the connector they were dispatched for.\n    evt.connectorId = connectorId;\n    // Unify the hook event with HostCtx: the adapter's parseEvent has no\n    // capabilities/scope/telemetry at parse time (they are runtime-only), so the\n    // runtime ALWAYS backfills them before the handler runs. capabilities comes\n    // from the adapter; scope is recovered from the registered metadata (sync);\n    // telemetry is the lazy per-connector usage accessor. The SAME three\n    // assignments run on the error path (failOpenOrPreserveDeny) for symmetry.\n    evt.capabilities = adapter.capabilities;\n    evt.scope = readRegisteredMeta(connectorId)?.scope;\n    evt.telemetry = buildTelemetryAccessor(connectorId);\n\n    const definition = connector.hooks[event];\n    if (!definition || typeof definition.handler !== \"function\") {\n      // The connector declares no handler for this event — allow.\n      return ALLOW;\n    }\n\n    // Per-host handler override: when dispatching for host X, `hosts[X].handler`\n    // wins over the top-level handler; a host not listed (or a per-host entry\n    // that is somehow not a function) falls back to the top-level handler.\n    // Selection NEVER throws — fail-open is preserved.\n    // NOTE: keyed on the RAW install-baked platformId (the host this entrypoint\n    // was registered for), NOT resolveHookHostPlatform's AGENT_CONNECTOR_HOST\n    // override — that override only re-labels the telemetry row. The error path\n    // (failOpenOrPreserveDeny) resolves the IDENTICAL handler the same way, so a\n    // per-host deny is preserved consistently.\n    const perHost = definition.hosts?.[platformId as PlatformId]?.handler;\n    const handler = typeof perHost === \"function\" ? perHost : definition.handler;\n\n    // Matcher: if set and the event's subject (tool name, or agent type for\n    // Subagent* events) does not match, allow (the hook is simply not\n    // interested in this tool/agent). The matcher is the definition's — a\n    // per-host handler shares the top-level matcher.\n    const subject = eventMatcherSubject(evt);\n    if (subject !== undefined) {\n      const re = compileMatcher(definition.matcher);\n      if (re && !re.test(subject)) return ALLOW;\n    }\n\n    // Run the resolved handler. Its return is normalized (void → allow) and\n    // handed to the adapter to render the host-native reply.\n    const handlerResult = await handler(\n      // The adapter parsed `evt` as exactly this event's payload type; the\n      // HooksConfig handler for the same event expects that payload.\n      evt as never,\n    );\n    const response = normalizeResponse(handlerResult);\n\n    // Developer-axis telemetry for the RUNTIME `hook` surface. Fail-open: never\n    // lets a measurement error break the hook (handled inside the helper).\n    recordHookTelemetry(opts, connector, evt, response);\n\n    const reply = adapter.formatReply(event, response);\n    return {\n      exitCode: reply.exitCode,\n      ...(reply.stdout !== undefined ? { stdout: reply.stdout } : {}),\n      ...(reply.stderr !== undefined ? { stderr: reply.stderr } : {}),\n    };\n  } catch (err) {\n    // Fail-open: a framework/handler error must not wedge the host's tool call.\n    // The ONE exception is a PreToolUse / PermissionRequest deny — a deliberate\n    // block we honor even if a later step threw. We re-derive that decision\n    // defensively from the adapter so a throw AFTER the deny still surfaces it.\n    const message = err instanceof Error ? err.message : String(err);\n    log.error(`hook ${platformId}/${event} (${connectorId}) failed:`, message);\n    return failOpenOrPreserveDeny(opts, message);\n  }\n}\n\n/**\n * Events whose explicit deny survives the fail-open error path. Both are\n * permission gates — a deny there is a deliberate security decision that must\n * never be silently downgraded to allow. (Stop-class denies are persistence\n * conveniences, not security boundaries, so they stay fail-open.)\n */\nconst DENY_PRESERVE_EVENTS: ReadonlySet<HookEventName> = new Set([\n  \"PreToolUse\",\n  \"PermissionRequest\",\n]);\n\n/**\n * Error path. Returns fail-open allow, UNLESS this is a deny-preserving event\n * (PreToolUse / PermissionRequest) whose handler explicitly denied — in which\n * case the deny is reconstructed and preserved (a security decision is never\n * silently downgraded to allow).\n *\n * Best-effort: if anything in the deny reconstruction itself throws, we fall\n * back to allow (we never escalate an error into a spurious block).\n */\nasync function failOpenOrPreserveDeny(\n  opts: RunHookOptions,\n  errorMessage: string,\n): Promise<RunHookResult> {\n  if (!DENY_PRESERVE_EVENTS.has(opts.event)) return ALLOW;\n  try {\n    const connector = await loadRegisteredConnector(opts.connectorId);\n    const adapter = await loadAdapter(opts.platformId);\n    if (!adapter?.parseEvent || !adapter.formatReply) return ALLOW;\n\n    const definition = connector.hooks[opts.event];\n    if (!definition || typeof definition.handler !== \"function\") return ALLOW;\n\n    // Reconstruct the deny from the SAME handler the main path would have run —\n    // the per-host override if one is declared for this host, else the top-level\n    // handler. Otherwise a per-host deny could be silently downgraded on the\n    // error path.\n    const perHost = definition.hosts?.[opts.platformId as PlatformId]?.handler;\n    const handler = typeof perHost === \"function\" ? perHost : definition.handler;\n\n    const raw = parseStdin(opts.stdin);\n    const evt = adapter.parseEvent(opts.event, raw);\n    evt.connectorId = opts.connectorId;\n    // Backfill the HostCtx fields here too (symmetry with the main path), so a\n    // per-host deny reconstructed on the error path still carries capabilities/\n    // scope/telemetry — a handler that branches on them denies identically.\n    evt.capabilities = adapter.capabilities;\n    evt.scope = readRegisteredMeta(opts.connectorId)?.scope;\n    evt.telemetry = buildTelemetryAccessor(opts.connectorId);\n\n    const subject = eventMatcherSubject(evt);\n    if (subject !== undefined) {\n      const re = compileMatcher(definition.matcher);\n      if (re && !re.test(subject)) return ALLOW;\n    }\n\n    const response = normalizeResponse(await handler(evt as never));\n    if (response.decision !== \"deny\") return ALLOW;\n\n    const reply = adapter.formatReply(opts.event, response);\n    return {\n      exitCode: reply.exitCode,\n      ...(reply.stdout !== undefined ? { stdout: reply.stdout } : {}),\n      ...(reply.stderr !== undefined\n        ? { stderr: reply.stderr }\n        : { stderr: errorMessage }),\n    };\n  } catch {\n    // Reconstruction failed — never escalate an internal error into a block.\n    return ALLOW;\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// Native (passthrough) hooks — host events OUTSIDE the normalized union\n// ─────────────────────────────────────────────────────────────────────────\n\n/** Flags + stdin for {@link runNativeHook}. `event` is HOST-NATIVE (non-union). */\nexport interface RunNativeHookOptions {\n  /** Host platform id from the hook command (`hook <platformId> ...`). */\n  platformId: string;\n  /** Host-native event name, verbatim (e.g. \"TaskCreated\"). */\n  event: string;\n  /** Connector id from `--connector <id>`. */\n  connectorId: string;\n  /** Raw stdin payload (host-native JSON). Empty string is tolerated → `{}`. */\n  stdin: string;\n}\n\n/** The connector's native hook definition for `platformId`/`event`, if any. */\nfunction nativeHookDef(\n  connector: ResolvedConnector,\n  platformId: string,\n  event: string,\n): NativeHookDef | undefined {\n  return connector.platforms[platformId as PlatformId]?.nativeHooks?.[event];\n}\n\n/**\n * True when the registered connector declares `event` under\n * `platforms[platformId].nativeHooks` with a live handler. Used by the hook CLI\n * to decide whether a non-union event name is accepted (declared → dispatch via\n * {@link runNativeHook}) or rejected with the strict unknown-event error.\n * Fail-safe: any load error reads as \"not declared\".\n */\nexport async function isNativeHookDeclared(\n  platformId: string,\n  event: string,\n  connectorId: string,\n): Promise<boolean> {\n  try {\n    const connector = await loadRegisteredConnector(connectorId);\n    return typeof nativeHookDef(connector, platformId, event)?.handler === \"function\";\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Dispatch one NATIVE (passthrough) hook invocation. No normalized parse, no\n * HookResponse mapping, no runtime matcher evaluation (the host's own matcher\n * already filtered — the def's matcher string was written verbatim into the\n * host config at install):\n *\n *   stdin JSON → NativeHookEvent{raw} → handler → VERBATIM JSON stdout (exit 0).\n *\n * void/undefined return → exit 0 with no output. Fail-open: ANY throw degrades\n * to exit 0 with no output — exit-2 blocking semantics are not modeled in v1.\n * Telemetry: records the same scope:\"hook\" developer-axis row as normalized\n * hooks, with the NATIVE event name as the per-item name.\n */\nexport async function runNativeHook(\n  opts: RunNativeHookOptions,\n): Promise<RunHookResult> {\n  const { platformId, event, connectorId, stdin } = opts;\n  try {\n    const connector = await loadRegisteredConnector(connectorId);\n    const def = nativeHookDef(connector, platformId, event);\n    if (!def || typeof def.handler !== \"function\") {\n      // Not declared for this platform — nothing to do, allow.\n      return ALLOW;\n    }\n\n    const raw = parseStdin(stdin);\n    // Best-effort session/project extraction from the json-stdio common shape\n    // (Claude Code: session_id / cwd). Everything else stays in `raw` untouched.\n    const sessionId =\n      typeof (raw as { session_id?: unknown })?.session_id === \"string\"\n        ? (raw as { session_id: string }).session_id\n        : \"\";\n    const cwd = (raw as { cwd?: unknown })?.cwd;\n    const evt: NativeHookEvent = {\n      event,\n      hostPlatform: REGISTERED_PLATFORM_IDS.has(platformId as PlatformId)\n        ? (platformId as PlatformId)\n        : \"unknown\",\n      sessionId,\n      ...(typeof cwd === \"string\" && cwd !== \"\" ? { projectDir: cwd } : {}),\n      raw,\n    };\n\n    const result = await def.handler(evt);\n\n    // Same scope:\"hook\" telemetry row as normalized hooks (fail-open inside).\n    recordHookTelemetry(opts, connector, evt, result === undefined ? {} : result);\n\n    if (result === undefined) return ALLOW; // void → exit 0, no output\n    const json = JSON.stringify(result);\n    // Non-JSON-serializable returns (functions/symbols) degrade to silence.\n    if (json === undefined) return ALLOW;\n    return { exitCode: 0, stdout: json };\n  } catch (err) {\n    // Fail-open, unconditionally: native hooks have no deny-preserve carve-out\n    // (there is no normalized decision to reconstruct).\n    const message = err instanceof Error ? err.message : String(err);\n    log.error(\n      `native hook ${platformId}/${event} (${connectorId}) failed:`,\n      message,\n    );\n    return ALLOW;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-CENEXP7K.js → chunk-YRBFSZ2G.js}

@@ -5,7 +5,7 @@ import {
 import {
   BaseAdapter,
   parseJsonc
-} from "./chunk-KG6T3YNJ.js";
+} from "./chunk-3I7UG52L.js";
 import {
   renderSkillMd
 } from "./chunk-IEGR4TP3.js";
@@ -690,13 +690,20 @@ var OpenClawAdapter = class extends BaseAdapter {
    * Build the openclaw.plugin.json manifest the gateway reads inside a
    * plugins.load.paths directory. It names the plugin and points at the ESM
    * module entry (index.mjs) so the loader knows what to import.
+   *
+   * `configSchema` is REQUIRED: `openclaw config validate` (and `openclaw mcp
+   * list`) REJECT a manifest without it ("plugin manifest requires
+   * configSchema"). Our plugin takes no user config, so we emit the empty
+   * closed object schema from openclaw's own minimal manifest example
+   * ({ type: "object", additionalProperties: false }).
    */
   buildPluginManifest(ctx) {
     const manifest = {
       id: ctx.connector.id,
       name: ctx.connector.displayName || ctx.connector.id,
       main: this.pluginFileName(),
-      enabled: true
+      enabled: true,
+      configSchema: { type: "object", additionalProperties: false }
     };
     return `${JSON.stringify(manifest, null, 2)}
 `;
@@ -1031,4 +1038,4 @@ export {
   adapter,
   openclaw_default
 };
-//# sourceMappingURL=chunk-CENEXP7K.js.map
+//# sourceMappingURL=chunk-YRBFSZ2G.js.map