@ken-jo/agent-connector 0.4.67 → 0.4.75

package/dist/chunk-ECSRTK4M.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sdk/test-harness.ts"],"sourcesContent":["/**\n * sdk/test-harness — the SHIPPED, OFFLINE behavioral harness.\n *\n * Two read-only tools a connector author runs WITHOUT installing anything or\n * touching the host's filesystem:\n *\n *   • `explain(connector)` — the static per-host × per-DECLARED-surface matrix:\n *     for every registered host and every surface the connector actually ships,\n *     is it `native` (the host can honor it), `disabled` (the connector opted\n *     out for that host via `platforms[host].<surface> === false`), or\n *     `skip-warn` (the host cannot honor it → install would skip-warn)?\n *\n *   • `simulate(connector, opts)` — runs the REAL adapter parse → handler →\n *     format chain INLINE against a host-shaped raw payload and reports whether\n *     the host actually HONORS the connector's response (the trustworthy part:\n *     it surfaces the documented degradations, e.g. Codex silently dropping a\n *     UserPromptSubmit \"context\" injection that has no stdout path).\n *\n * It deliberately does NOT import the runtime entrypoints (runHook /\n * runStatusline) — those load the REGISTERED connector from disk and record\n * telemetry. The harness instead re-implements the tiny parse→handler→format\n * chain against the in-memory connector + the adapter, mirroring the runtime's\n * input tolerance (empty/malformed payload → `{}`) and its fail-safe envelope.\n */\n\nimport type {\n  HookEventName,\n  HookResponse,\n  PlatformCapabilities,\n  PlatformId,\n  PlatformOverride,\n  ResolvedConnector,\n} from \"../core/types.js\";\nimport { allAdapters, loadAdapter } from \"../adapters/registry.js\";\nimport type { NormalizedEvent } from \"../adapters/spi.js\";\nimport {\n  compileMatcher,\n  eventMatcherSubject,\n} from \"../runtime/hook-entrypoint.js\";\nimport type { SurfaceName } from \"./introspect.js\";\nimport { hostCanFireEvent, SURFACE_PREDICATES } from \"./introspect.js\";\n\n// ─────────────────────────────────────────────────────────────────────────\n// explain — the static per-host × per-declared-surface matrix\n// ─────────────────────────────────────────────────────────────────────────\n\n/** One cell of the {@link explain} matrix: a host × a declared surface. */\nexport interface ExplainRow {\n  host: PlatformId;\n  surface: SurfaceName;\n  /**\n   *  - \"native\"    — the host's capabilities pass the surface predicate.\n   *  - \"disabled\"  — the connector opted out for this host\n   *                  (`platforms[host].<surface> === false`).\n   *  - \"skip-warn\" — the host cannot honor it; install would skip-warn.\n   */\n  support: \"native\" | \"skip-warn\" | \"disabled\";\n  reason: string;\n}\n\n/**\n * The GLOBAL surfaces a connector declares (these apply to every host — only\n * declared surfaces get a matrix row). The two platform-scoped surfaces\n * (`configPatch` / `nativeHooks`) are deliberately EXCLUDED here: they are\n * declared under one specific `platforms[host]`, so each is added PER HOST in\n * {@link explain} (see {@link platformScopedSurfacesFor}) — adding them globally\n * would falsely promise a configPatch row on hosts that never declared it.\n */\nfunction declaredGlobalSurfaces(connector: ResolvedConnector): SurfaceName[] {\n  const out: SurfaceName[] = [];\n  if (connector.server) out.push(\"server\");\n  if (Object.keys(connector.hooks).length > 0) out.push(\"hooks\");\n  if (connector.commands.length > 0) out.push(\"commands\");\n  if (connector.skills.length > 0) out.push(\"skills\");\n  if (connector.subagents.length > 0) out.push(\"subagents\");\n  if (connector.memory.length > 0) out.push(\"memory\");\n  if (connector.statusline) out.push(\"statusline\");\n  if (connector.actions.length > 0) out.push(\"actions\");\n  return out;\n}\n\n/**\n * The platform-scoped surfaces (`configPatch` / `nativeHooks`) THIS host\n * actually declares — keyed off the host's own `platforms[host]` override, so a\n * configPatch declared under claude-code never shows up as a row for codex.\n */\nfunction platformScopedSurfacesFor(\n  override: PlatformOverride | undefined,\n): SurfaceName[] {\n  const out: SurfaceName[] = [];\n  if (!override) return out;\n  if ((override.configPatch?.length ?? 0) > 0) out.push(\"configPatch\");\n  if (override.nativeHooks != null && Object.keys(override.nativeHooks).length > 0) {\n    out.push(\"nativeHooks\");\n  }\n  return out;\n}\n\n/**\n * Is the surface explicitly DISABLED for this host? Mirrors the per-host opt-out\n * the installer honors: a boolean-or-object surface override is \"disabled\" only\n * when set to the literal `false` (the object form is a tuning, not an opt-out).\n * `configPatch` / `nativeHooks` have no boolean opt-out form — declaring them is\n * the opt-in, so they are never \"disabled\".\n */\nfunction isDisabledForHost(\n  connector: ResolvedConnector,\n  host: PlatformId,\n  surface: SurfaceName,\n): boolean {\n  const override = connector.platforms[host];\n  if (!override) return false;\n  switch (surface) {\n    case \"server\":\n      return override.server === false;\n    case \"hooks\":\n      return override.hooks === false;\n    case \"commands\":\n      return override.commands === false;\n    case \"skills\":\n      return override.skills === false;\n    case \"subagents\":\n      return override.subagents === false;\n    case \"memory\":\n      return override.memory === false;\n    case \"statusline\":\n      return override.statusline === false;\n    case \"actions\":\n    case \"configPatch\":\n    case \"nativeHooks\":\n      // No per-host boolean opt-out form (declaring them is the opt-in).\n      return false;\n  }\n}\n\n/**\n * The static support matrix: every registered host × every surface the\n * connector declares. Rows are sorted by host then surface for stable output.\n * Pure read of the adapter capabilities — installs nothing, writes nothing.\n */\nexport async function explain(connector: ResolvedConnector): Promise<ExplainRow[]> {\n  const globalSurfaces = declaredGlobalSurfaces(connector);\n  const adapters = await allAdapters();\n  const rows: ExplainRow[] = [];\n\n  for (const adapter of adapters) {\n    // Per-host surface set = the global surfaces every host gets a row for, plus\n    // the platform-scoped surfaces THIS host actually declares (configPatch /\n    // nativeHooks live under platforms[host], so they are host-local).\n    const override = connector.platforms[adapter.id];\n    const surfaces = [\n      ...globalSurfaces,\n      ...platformScopedSurfacesFor(override),\n    ];\n    for (const surface of surfaces) {\n      if (isDisabledForHost(connector, adapter.id, surface)) {\n        rows.push({\n          host: adapter.id,\n          surface,\n          support: \"disabled\",\n          reason: `connector opted out for ${adapter.id} (platforms.${adapter.id}.${surface} = false)`,\n        });\n        continue;\n      }\n      // The hooks surface is judged against the connector's SPECIFIC declared\n      // events, not the coarse \"host has a hook runtime\" predicate — otherwise a\n      // Stop-only connector falsely shows `native` on a PreToolUse-only host\n      // (the host CAN fire a hook, just not the one this connector declared).\n      if (surface === \"hooks\") {\n        rows.push(hooksRow(connector, adapter.id, adapter.capabilities));\n        continue;\n      }\n      const native = SURFACE_PREDICATES[surface](adapter.capabilities);\n      rows.push({\n        host: adapter.id,\n        surface,\n        support: native ? \"native\" : \"skip-warn\",\n        reason: explainReason(adapter.id, surface, native),\n      });\n    }\n  }\n\n  rows.sort((a, b) =>\n    a.host === b.host ? a.surface.localeCompare(b.surface) : a.host.localeCompare(b.host),\n  );\n  return rows;\n}\n\n/**\n * The per-DECLARED-event hooks verdict for one host. A connector's hooks surface\n * is `native` only when EVERY event it declares can fire on the host; if any\n * declared event has no native equivalent the row is `skip-warn` and the reason\n * names the specific dead events (the same events install skip-warns). This is\n * the fix for the OR-across-all-events false green: a Stop-only connector on a\n * host that cannot fire Stop now reports skip-warn, not native.\n *\n * Reuses {@link hostCanFireEvent} — the single per-event source of truth shared\n * with {@link SURFACE_PREDICATES} and simulate's runtime verdict — so explain\n * never re-derives the per-event rules.\n */\nfunction hooksRow(\n  connector: ResolvedConnector,\n  host: PlatformId,\n  capabilities: PlatformCapabilities,\n): ExplainRow {\n  const declared = connector.hookEvents;\n  const dead = declared.filter((e) => !hostCanFireEvent(capabilities, e));\n  if (dead.length === 0) {\n    return {\n      host,\n      surface: \"hooks\",\n      support: \"native\",\n      reason: `${host} can fire every declared hook event (${declared.join(\", \")})`,\n    };\n  }\n  const fireable = declared.filter((e) => hostCanFireEvent(capabilities, e));\n  const reason =\n    fireable.length === 0\n      ? `${host} cannot fire any declared hook event (${dead.join(\", \")}); install skip-warns each`\n      : `${host} cannot fire ${dead.join(\", \")} (install skip-warns these); honors ${fireable.join(\", \")}`;\n  return { host, surface: \"hooks\", support: \"skip-warn\", reason };\n}\n\n/**\n * The human-readable reason for a native/skip-warn cell. `server` is a special\n * case: the predicate is CAPABILITY-based (the host advertises ≥1 MCP\n * transport), but advertising a transport does NOT guarantee a writable\n * registration — e.g. jetbrains-copilot advertises stdio yet its installServer\n * skip-warns because MCP is managed in IDE settings. So the server reason states\n * the verdict is capability-based and registration may be host-managed, rather\n * than promising a write. (A precise per-adapter installServer dry-run is a\n * Phase-2 enhancement — until then this avoids over-promising.)\n */\nfunction explainReason(host: PlatformId, surface: SurfaceName, native: boolean): string {\n  if (surface === \"server\") {\n    return native\n      ? `${host} advertises an MCP transport (capability-based; registration may be host-managed)`\n      : `${host} advertises no MCP transport; install skip-warns`;\n  }\n  return native\n    ? `${host} natively supports ${surface}`\n    : `${host} cannot honor ${surface}; install skip-warns`;\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// simulate — the real adapter parse → handler → format chain, inline\n// ─────────────────────────────────────────────────────────────────────────\n\n/** What to drive through the harness: one host, one surface, one raw payload. */\nexport interface SimulateOptions {\n  surface: \"hooks\" | \"statusline\";\n  host: PlatformId | string;\n  /** REQUIRED when `surface === \"hooks\"`: which normalized lifecycle event. */\n  event?: HookEventName;\n  /** The host-shaped RAW payload (what the host would pipe in on stdin). */\n  input: unknown;\n}\n\n/** The harness verdict: did the host actually honor the connector's response? */\nexport interface SimulateResult {\n  /** True when the host's native reply carries the connector's intent. */\n  honored: boolean;\n  /** The host-native stdout the adapter would emit (when there is one). */\n  hostReply?: string;\n  /** Human-readable why — names the documented degradation when honored:false. */\n  reason: string;\n}\n\n/**\n * Tolerantly coerce the raw payload, mirroring the runtime's parseStdin: a\n * string is JSON-parsed (empty/malformed → `{}`); a nullish value → `{}`; any\n * other value (already-parsed object) is passed through untouched.\n */\nfunction coerceInput(input: unknown): unknown {\n  if (input == null) return {};\n  if (typeof input === \"string\") {\n    const trimmed = input.trim();\n    if (trimmed === \"\") return {};\n    try {\n      return JSON.parse(trimmed);\n    } catch {\n      return {};\n    }\n  }\n  return input;\n}\n\n/** Normalize a handler's return into a concrete response (void/non-object → `{}`). */\nfunction normalizeResponse(value: HookResponse | void): HookResponse {\n  if (value == null || typeof value !== \"object\") return {};\n  return value;\n}\n\n/**\n * The decoded shape of a host's native hook reply on stdout. Every json-stdio\n * adapter writes a SUBSET of these fields (claude-code / codex share the\n * `hookSpecificOutput` envelope; Stop-class continuation uses the TOP-LEVEL\n * `decision:\"block\"`). We read the DECODED fields — never substring-match the\n * serialized JSON, which a path/newline/quote in the payload would break.\n */\ninterface ParsedReply {\n  /** Top-level Stop-class continuation: {\"decision\":\"block\",\"reason\"}. */\n  decision?: unknown;\n  reason?: unknown;\n  /** Top-level Claude context channel (no adapter emits it yet; future-proofing). */\n  systemMessage?: unknown;\n  hookSpecificOutput?: {\n    hookEventName?: unknown;\n    additionalContext?: unknown;\n    permissionDecision?: unknown;\n    permissionDecisionReason?: unknown;\n    updatedInput?: unknown;\n    /** PermissionRequest nested envelope: decision:{behavior:\"allow\"|\"deny\", updatedInput?}. */\n    decision?: { behavior?: unknown; updatedInput?: unknown };\n  };\n}\n\n/**\n * Tolerantly decode a reply's stdout into {@link ParsedReply}. Empty / absent /\n * unparseable stdout is a legitimate \"no payload\" signal (the adapter wrote a\n * bare exit-0) → `undefined`, the honest \"this decision had no stdout path\"\n * verdict input.\n */\nfunction parseReplyStdout(stdout: string | undefined): ParsedReply | undefined {\n  if (stdout == null || stdout.trim() === \"\") return undefined;\n  try {\n    const value = JSON.parse(stdout);\n    return value != null && typeof value === \"object\"\n      ? (value as ParsedReply)\n      : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/** Structural deep-equal for plain JSON values (objects/arrays/primitives). */\nfunction deepEqual(a: unknown, b: unknown): boolean {\n  if (a === b) return true;\n  if (typeof a !== typeof b || a == null || b == null) return false;\n  if (typeof a !== \"object\") return false;\n  const aArr = Array.isArray(a);\n  if (aArr !== Array.isArray(b)) return false;\n  if (aArr) {\n    const x = a as unknown[];\n    const y = b as unknown[];\n    return x.length === y.length && x.every((v, i) => deepEqual(v, y[i]));\n  }\n  const x = a as Record<string, unknown>;\n  const y = b as Record<string, unknown>;\n  const xk = Object.keys(x);\n  const yk = Object.keys(y);\n  return xk.length === yk.length && xk.every((k) => deepEqual(x[k], y[k]));\n}\n\n/**\n * Decide whether the host HONORED a decision-bearing response, judging the\n * PARSED reply against each adapter's ACTUAL (event, decision) contract — never\n * by substring-matching the serialized JSON. `allow`/no-decision is always\n * pass-through honored; every other decision is honored only when the decoded\n * reply carries that exact intent, and the verdict names the documented\n * degradation when it does not.\n */\nfunction judgeHookHonor(\n  host: string,\n  event: HookEventName,\n  response: HookResponse,\n  stdout: string | undefined,\n): { honored: boolean; reason: string } {\n  const decision = response.decision;\n  if (decision === undefined || decision === \"allow\") {\n    return { honored: true, reason: \"pass-through allow\" };\n  }\n\n  const reply = parseReplyStdout(stdout);\n  const hso = reply?.hookSpecificOutput;\n\n  if (decision === \"context\") {\n    // Honored only when the DECODED additionalContext equals what the handler\n    // asked to inject (claude-code's hookSpecificOutput.additionalContext, or a\n    // future top-level systemMessage). codex only emits this on\n    // SessionStart/PostToolUse — every other event silently drops it.\n    const want = response.additionalContext;\n    const got = hso?.additionalContext ?? reply?.systemMessage;\n    if (reply && got === want) {\n      return { honored: true, reason: `${host} injects context on ${event}` };\n    }\n    return {\n      honored: false,\n      reason: `${host} drops context on ${event} (no stdout path)`,\n    };\n  }\n\n  if (decision === \"deny\") {\n    if (!reply) {\n      return {\n        honored: false,\n        reason: `${host} drops deny on ${event} (deny not honored; fails open to allow)`,\n      };\n    }\n    // A real block: PreToolUse's permissionDecision:\"deny\", or the\n    // PermissionRequest nested decision.behavior:\"deny\".\n    if (hso?.permissionDecision === \"deny\" || hso?.decision?.behavior === \"deny\") {\n      return { honored: true, reason: `${host} blocks ${event}` };\n    }\n    // Stop-class continuation: top-level decision:\"block\" KEEPS the session /\n    // subagent running (persistence) — the SEMANTIC OPPOSITE of a block. Honored\n    // (the reply carried the intent), but the reason must not say \"blocks\".\n    if (reply.decision === \"block\") {\n      return {\n        honored: true,\n        reason: `${host} continues the session/subagent on ${event} (persistence) — NOT a block`,\n      };\n    }\n    // SubagentStart / PostToolUseFailure DEGRADE a deny to a context note — the\n    // spawn/failure is not actually blocked.\n    if (hso?.additionalContext != null) {\n      return {\n        honored: false,\n        reason: `${host} degrades deny to a context note on ${event}; spawn/failure not blocked`,\n      };\n    }\n    return {\n      honored: false,\n      reason: `${host} drops deny on ${event} (deny not honored; fails open to allow)`,\n    };\n  }\n\n  if (decision === \"ask\") {\n    if (hso?.permissionDecision === \"ask\") {\n      return { honored: true, reason: `${host} asks on ${event}` };\n    }\n    // On PermissionRequest, ask/void falls through to the host's NATIVE dialog\n    // (the dialog IS the ask), which the adapter expresses as a bare exit-0.\n    if (event === \"PermissionRequest\" && !reply) {\n      return {\n        honored: true,\n        reason: `${host} shows the native confirmation dialog on ${event} (the ask)`,\n      };\n    }\n    return {\n      honored: false,\n      reason: `${host} drops ask on ${event} (no ask path)`,\n    };\n  }\n\n  // decision === \"modify\": honored only when the decoded updatedInput deep-equals\n  // what the handler asked to write (hookSpecificOutput.updatedInput, or the\n  // PermissionRequest nested decision.updatedInput).\n  const wrote = hso?.updatedInput ?? hso?.decision?.updatedInput;\n  if (reply && wrote !== undefined && deepEqual(wrote, response.updatedInput)) {\n    return { honored: true, reason: `${host} rewrites tool input on ${event}` };\n  }\n  return {\n    honored: false,\n    reason: `${host} drops modify on ${event} (modify not honored)`,\n  };\n}\n\n/**\n * Run the connector against ONE host-shaped payload through the REAL adapter\n * path and report whether the host honors the response. Self-contained (does not\n * touch the registered-connector loader or telemetry) and fail-safe: any throw\n * in the chain degrades to `honored:false` with the error message, never rejects.\n */\nexport async function simulate(\n  connector: ResolvedConnector,\n  opts: SimulateOptions,\n): Promise<SimulateResult> {\n  try {\n    const adapter = await loadAdapter(opts.host);\n    if (!adapter) {\n      return { honored: false, reason: `unknown host \"${opts.host}\"` };\n    }\n\n    if (opts.surface === \"statusline\") {\n      if (\n        !(adapter.capabilities.supportsStatusline ?? false) ||\n        !adapter.parseStatusInput ||\n        !adapter.formatStatusOutput\n      ) {\n        return { honored: false, reason: `${opts.host} has no statusline surface` };\n      }\n      // Guarding on the TOP-LEVEL render is sufficient: a `hosts`-only statusline\n      // (a hosts: map with no top-level render) is rejected at defineConnector, so\n      // a connector that targets `opts.host` only via hosts[] still has a top-level\n      // render here. (If that author-time invariant ever relaxes, revisit this.)\n      if (!connector.statusline || typeof connector.statusline.render !== \"function\") {\n        return { honored: false, reason: \"connector declares no statusline\" };\n      }\n      const ctx = adapter.parseStatusInput(coerceInput(opts.input));\n      ctx.connectorId = connector.id;\n      // Defensive: parseStatusInput now sets ctx.capabilities (it is required on\n      // StatuslineContext), but a future adapter could omit it — backfill from\n      // the adapter so render() can always read ctx.capabilities.\n      if (ctx.capabilities == null) ctx.capabilities = adapter.capabilities;\n      // Per-host render override, mirroring the runtime: hosts[host].render wins\n      // over the top-level render; an unlisted host falls back to top-level.\n      const perHost = connector.statusline.hosts?.[opts.host as PlatformId]?.render;\n      const render =\n        typeof perHost === \"function\" ? perHost : connector.statusline.render;\n      const rendered = await render(ctx);\n      const line = rendered == null ? \"\" : String(rendered);\n      const reply = adapter.formatStatusOutput(line);\n      return {\n        honored: true,\n        ...(reply.stdout !== undefined ? { hostReply: reply.stdout } : {}),\n        reason: \"rendered\",\n      };\n    }\n\n    // surface === \"hooks\"\n    const event = opts.event;\n    if (!event) {\n      return { honored: false, reason: \"event is required when surface === \\\"hooks\\\"\" };\n    }\n    if (!adapter.parseEvent || !adapter.formatReply) {\n      return { honored: false, reason: `${opts.host} has no hook runtime (mcp-only)` };\n    }\n\n    const evt = adapter.parseEvent(event, coerceInput(opts.input));\n    evt.connectorId = connector.id;\n    // Mirror the runtime: runHook backfills evt.capabilities from the adapter so\n    // a handler reading evt.capabilities behaves the same here. (scope/telemetry\n    // are runtime-only — recovered from the registered meta / store, which the\n    // offline harness deliberately never touches — so they stay undefined.)\n    evt.capabilities = adapter.capabilities;\n\n    // Guarding on the TOP-LEVEL handler is sufficient: a `hosts`-only hook (a\n    // hosts: map with no top-level handler) is rejected at defineConnector, so a\n    // host targeted only via hosts[] still has a top-level handler here. (If that\n    // author-time invariant ever relaxes, revisit this.)\n    const definition = connector.hooks[event];\n    if (!definition || typeof definition.handler !== \"function\") {\n      return { honored: false, reason: `connector declares no ${event} handler` };\n    }\n\n    // Matcher filtering, in lockstep with runHook: when the connector's matcher\n    // is set and the event's subject (tool name, or agent type for Subagent*\n    // events) does not match, the host never runs the handler — so the harness\n    // must NOT run it either, and reports the (honored) exclusion. Reuses the\n    // runtime helpers directly so the two stay byte-for-byte aligned.\n    const subject = eventMatcherSubject(evt as NormalizedEvent);\n    if (subject !== undefined) {\n      const re = compileMatcher(definition.matcher);\n      if (re && !re.test(subject)) {\n        return {\n          honored: true,\n          reason: `matcher excludes ${subject} (handler not run)`,\n        };\n      }\n    }\n\n    // Per-host handler override, mirroring runHook: hosts[host].handler wins\n    // over the top-level handler; an unlisted host falls back to top-level.\n    const perHost = definition.hosts?.[opts.host as PlatformId]?.handler;\n    const handler = typeof perHost === \"function\" ? perHost : definition.handler;\n    const response = normalizeResponse(\n      await handler(evt as never),\n    );\n    const reply = adapter.formatReply(event, response);\n    const verdict = judgeHookHonor(String(opts.host), event, response, reply.stdout);\n    return {\n      honored: verdict.honored,\n      ...(reply.stdout !== undefined ? { hostReply: reply.stdout } : {}),\n      reason: verdict.reason,\n    };\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err);\n    const verb = opts.surface === \"statusline\" ? \"render\" : \"handler\";\n    return { honored: false, reason: `${verb} threw: ${message}` };\n  }\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// explainHooks — the per-(host, event) honor verdict (powers doctor --explain)\n// ─────────────────────────────────────────────────────────────────────────\n\n/**\n * One per-(host, event) cell of {@link explainHooks}.\n *\n *  - \"honored\"  — the host fires the event AND carries the connector's response\n *                 intent (simulate's runtime verdict, e.g. a real deny/block).\n *  - \"degraded\" — the host fires the event but silently DROPS the response's\n *                 decision (e.g. codex fires UserPromptSubmit but has no stdout\n *                 path for a context injection, so the injection vanishes).\n *  - \"dropped\"  — the host cannot fire the event at all (no native equivalent /\n *                 mcp-only host); install skip-warns it and it never runs.\n */\nexport interface HookEventVerdict {\n  host: PlatformId;\n  event: HookEventName;\n  verdict: \"honored\" | \"degraded\" | \"dropped\";\n  /** The simulate()-grade reason string (names the documented degradation). */\n  reason: string;\n}\n\n/**\n * A subject (tool name / agent type) that SATISFIES the connector's matcher for\n * this event, so a matcher-gated hook actually runs and the verdict reflects the\n * real honor — not a spurious \"matcher excludes my arbitrary synthetic tool\".\n * A plain-literal matcher (no regex metacharacters — the common case, e.g.\n * `acme_query`) IS the subject. A missing/empty matcher matches everything, and\n * a complex regex falls back to the generic subject (then an honest \"matcher\n * excludes\" verdict surfaces — the dev's matcher genuinely would not fire here).\n */\nfunction matchingSubject(matcher: string | undefined, fallback: string): string {\n  if (!matcher || matcher === \"\") return fallback;\n  return /^[\\w.-]+$/.test(matcher) ? matcher : fallback;\n}\n\n/**\n * A minimal host-shaped synthetic payload so the real parse→handler→format\n * chain has something to run on. The harness coerces a `{}` to a valid event,\n * but tool/subagent events read a subject (tool name / agent type) the connector\n * matcher may filter on — so we plant a subject that SATISFIES the connector's\n * declared matcher ({@link matchingSubject}) to exercise the honor path.\n */\nfunction syntheticPayloadFor(\n  event: HookEventName,\n  matcher: string | undefined,\n): Record<string, unknown> {\n  switch (event) {\n    case \"PreToolUse\":\n    case \"PostToolUse\":\n    case \"PostToolUseFailure\":\n    case \"PermissionRequest\": {\n      const tool = matchingSubject(matcher, \"Bash\");\n      return { tool_name: tool, tool_input: { command: \"echo hi\" } };\n    }\n    case \"SubagentStart\":\n    case \"SubagentStop\": {\n      const agent = matchingSubject(matcher, \"general\");\n      return { agent_type: agent, subagent_type: agent };\n    }\n    case \"UserPromptSubmit\":\n      return { prompt: \"hello\" };\n    default:\n      return {};\n  }\n}\n\n/**\n * The per-(host, event) hook honor matrix for the connector's DECLARED events\n * across `hosts` — the trustworthy detail behind `doctor --explain`.\n *\n * For each (host, declared event): when the host cannot fire the event\n * ({@link hostCanFireEvent} is false, OR the host has no hook runtime at all)\n * the cell is `dropped`; otherwise it RUNS the real chain via {@link simulate}\n * and reports `honored` (simulate honored the response) or `degraded` (the host\n * fired but dropped the decision). Reuses the per-event signal + simulate's\n * verdict — no per-event honor logic is re-derived here.\n */\nexport async function explainHooks(\n  connector: ResolvedConnector,\n  hosts: (PlatformId | string)[],\n): Promise<HookEventVerdict[]> {\n  const events = connector.hookEvents;\n  const rows: HookEventVerdict[] = [];\n\n  for (const host of hosts) {\n    const adapter = await loadAdapter(host);\n    if (!adapter) {\n      for (const event of events) {\n        rows.push({\n          host: host as PlatformId,\n          event,\n          verdict: \"dropped\",\n          reason: `unknown host \"${host}\"`,\n        });\n      }\n      continue;\n    }\n\n    // An mcp-only host (no hook runtime) drops every declared event.\n    const hasHookRuntime = !!adapter.parseEvent && !!adapter.formatReply;\n\n    for (const event of events) {\n      if (!hasHookRuntime) {\n        rows.push({\n          host: adapter.id,\n          event,\n          verdict: \"dropped\",\n          reason: `${adapter.id} has no hook runtime (mcp-only) — ${event} never fires`,\n        });\n        continue;\n      }\n      if (!hostCanFireEvent(adapter.capabilities, event)) {\n        rows.push({\n          host: adapter.id,\n          event,\n          verdict: \"dropped\",\n          reason: `${adapter.id} has no ${event} equivalent — install skip-warns it; never fires`,\n        });\n        continue;\n      }\n      const sim = await simulate(connector, {\n        surface: \"hooks\",\n        host: adapter.id,\n        event,\n        input: syntheticPayloadFor(event, connector.hooks[event]?.matcher),\n      });\n      rows.push({\n        host: adapter.id,\n        event,\n        verdict: sim.honored ? \"honored\" : \"degraded\",\n        reason: sim.reason,\n      });\n    }\n  }\n\n  rows.sort((a, b) =>\n    a.host === b.host ? a.event.localeCompare(b.event) : a.host.localeCompare(b.host),\n  );\n  return rows;\n}\n"],"mappings":"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","names":["x","y","perHost","reply"]}

package/dist/{chunk-F5COBB5F.js → chunk-FUXUEXDP.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   resolveEnvRefsDeep
-} from "./chunk-DBQMX75U.js";
+} from "./chunk-BEFVJ2OE.js";
 import {
   BaseAdapter,
   parseJsonc,
   renderSkillMd
-} from "./chunk-RHML2NOB.js";
+} from "./chunk-NUGMVVV2.js";
 import {
   buildWrappedStdio
 } from "./chunk-TO57WYBB.js";
@@ -1008,4 +1008,4 @@ export {
   adapter,
   openclaw_default
 };
-//# sourceMappingURL=chunk-F5COBB5F.js.map
+//# sourceMappingURL=chunk-FUXUEXDP.js.map

package/dist/{chunk-NXR4HM5N.js → chunk-HKM3HUOK.js}

@@ -73,36 +73,36 @@ function renderInstallResult(result, verb) {
   return lines.join("\n");
 }
 var COMMANDS = {
-  detect: () => import("./detect-IZOWP5AA.js"),
-  install: () => import("./install-EP6GPQ65.js"),
-  uninstall: () => import("./uninstall-MO3RGGVE.js"),
+  detect: () => import("./detect-CWEIQCRC.js"),
+  install: () => import("./install-S6BYIJ62.js"),
+  uninstall: () => import("./uninstall-WGEKTCDZ.js"),
   // `upgrade` is the single "bring everything current" verb (re-render host
   // config + refresh the home pointer + managed channel guidance). `sync` and
   // `update` are kept as back-compat aliases that route to the same module so
   // existing scripts/docs keep working without a second concept to learn.
-  upgrade: () => import("./upgrade-6XIGSPGY.js"),
-  sync: () => import("./upgrade-6XIGSPGY.js"),
-  update: () => import("./upgrade-6XIGSPGY.js"),
-  package: () => import("./package-BWLV24OO.js"),
-  doctor: () => import("./doctor-5IVUQ2YH.js"),
-  status: () => import("./status-BPB4VLQX.js"),
-  telemetry: () => import("./telemetry-SBVUJYNE.js"),
-  usage: () => import("./usage-IBN36ZVW.js"),
-  leaderboard: () => import("./leaderboard-6I2E5XZK.js"),
-  hook: () => import("./hook-7IUPIHCZ.js"),
+  upgrade: () => import("./upgrade-IH7CKPTO.js"),
+  sync: () => import("./upgrade-IH7CKPTO.js"),
+  update: () => import("./upgrade-IH7CKPTO.js"),
+  package: () => import("./package-KOAAVKHH.js"),
+  doctor: () => import("./doctor-AC437ZAW.js"),
+  status: () => import("./status-N5LCQQ3R.js"),
+  telemetry: () => import("./telemetry-V4YQL2NU.js"),
+  usage: () => import("./usage-DI7XRCKM.js"),
+  leaderboard: () => import("./leaderboard-SUSUDKHR.js"),
+  hook: () => import("./hook-VYD3OCLM.js"),
   // Internal (omitted from USAGE): the statusline (HUD) entrypoint a host's
   // status line config points at. Fail-safe: always exits 0 with at most a
   // rendered line. See cli/commands/statusline.ts.
-  statusline: () => import("./statusline-HIKR2I4Q.js"),
+  statusline: () => import("./statusline-442XOF7R.js"),
   // Internal (omitted from USAGE): the user-invokable action entrypoint a future
   // host affordance points at. USER-TRIGGERED: surfaces errors (exit 1 + stderr),
   // unlike the fail-open hook / fail-safe statusline. See cli/commands/action.ts.
-  action: () => import("./action-RUM6GP23.js"),
-  serve: () => import("./serve-CM4HZPMP.js"),
+  action: () => import("./action-TCKBTTZX.js"),
+  serve: () => import("./serve-BU23QUSJ.js"),
   // Hidden (omitted from USAGE): the opt-in host-native turn-usage entrypoint an
   // AfterModel / PostInvocation hook points at. Always exits 0; records a
   // distinct `model_turn` row. See cli/commands/usage-event.ts.
-  "usage-event": () => import("./usage-event-4RJP37K6.js")
+  "usage-event": () => import("./usage-event-2FCU55AN.js")
 };
 var DEFAULT_PROGRAM_NAME = "agent-connector";
 var COMMAND_USAGE = {
@@ -113,7 +113,7 @@ var COMMAND_USAGE = {
   sync: "sync \u2014 alias of upgrade (see `upgrade --help`)",
   update: "update \u2014 alias of upgrade (see `upgrade --help`)",
   package: "package [--connector <path>] [--format <fmt>|all] [--out <dir>] [--project <dir>] [--dry-run]",
-  doctor: "doctor [--targets a,b] [--connector <path>] [--scope user|project] [--project <dir>] [--probe] [--json] [--heal] [--dry-run]",
+  doctor: "doctor [--targets a,b] [--connector <path>] [--scope user|project] [--project <dir>] [--probe] [--explain] [--json] [--heal] [--dry-run]\n  --explain   per-(host,event) hook honor matrix (honored/degraded/dropped). Exit non-zero ONLY when an explicitly-targeted host DEGRADES a declared event (fires it but silently won't honor the reply); dropped/mcp-only hosts and fleet-wide (targets:auto) gaps are informational (exit 0).",
   status: "status [--connector <path>] [--scope user|project] [--project <dir>] [--json]",
   telemetry: "telemetry report|export|leaderboard [--by <dim>] [--since <dur>] [--connector <id>] [--scope <slice>] [--format csv|json] [--out <file>] [--json]",
   usage: "usage report|export|leaderboard [--by <dim>] [--since <dur>] [--platform <id>] [--format csv|json] [--out <file>] [--json]",
@@ -198,4 +198,4 @@ export {
   renderInstallResult,
   main
 };
-//# sourceMappingURL=chunk-NXR4HM5N.js.map
+//# sourceMappingURL=chunk-HKM3HUOK.js.map

package/dist/{chunk-NXR4HM5N.js.map → chunk-HKM3HUOK.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/cli/app.ts"],"sourcesContent":["/**\n * cli/app — shared CLI helpers + command dispatch (NO side effects).\n *\n * Command modules import the shared helpers (print, fail, parse-flags,\n * renderInstallResult) from here, and main() dispatches the first positional to a\n * command module.\n * This module never auto-runs — `cli/index.ts` is the thin bin entry that calls\n * `main()`. Keeping the auto-run out of here is what prevents a dispatch recursion\n * (a command module importing a helper must not re-trigger the program) and makes\n * it robust to bundler entry-splitting (the old import.meta.url entry-guard broke\n * once tsup hoisted this code into a shared chunk).\n */\n\nimport { createRequire } from \"node:module\";\n\nimport type {\n  ChangeRecord,\n  InstallResult,\n  InstallScope,\n  PlatformId,\n} from \"../core/types.js\";\n\n// ─────────────────────────────────────────────────────────────────────────\n// Shared helpers (imported by the command modules)\n// ─────────────────────────────────────────────────────────────────────────\n\n/** Print a line to stdout (machine-readable payloads must stay on stdout). */\nexport function print(line: string): void {\n  process.stdout.write(`${line}\\n`);\n}\n\n/**\n * The brand active for THIS invocation. main() sets it from\n * {@link MainOptions.programName} before dispatch, so error messages printed by\n * command modules via {@link fail} read as the embedding tool (e.g. `acme-db:`)\n * instead of always `agent-connector:`.\n */\nlet activeProgramName = \"agent-connector\";\n\n/** Print an error to stderr (branded) and return a non-zero exit code (default 2). */\nexport function fail(message: string, code = 2): number {\n  process.stderr.write(`${activeProgramName}: ${message}\\n`);\n  return code;\n}\n\n/**\n * Resolve agent-connector's own package version at runtime. Works from both the\n * bundled dist layout (dist/*.js → ../package.json) and the src layout under\n * tsx/vitest (src/cli/ → ../../package.json); the name check guards against\n * accidentally reading some other package.json on the walk.\n */\nexport function resolveOwnVersion(): string {\n  const req = createRequire(import.meta.url);\n  for (const rel of [\"../package.json\", \"../../package.json\", \"../../../package.json\"]) {\n    try {\n      const pkg = req(rel) as { name?: string; version?: string };\n      if (pkg.name === \"@ken-jo/agent-connector\" && typeof pkg.version === \"string\") {\n        return pkg.version;\n      }\n    } catch {\n      /* keep walking */\n    }\n  }\n  return \"0.0.0\";\n}\n\n/** Parse a --scope value the CLI accepts (user|project) into an InstallScope. */\nexport function parseScope(value: string | undefined): InstallScope | null {\n  if (value === \"user\" || value === \"project\") return value;\n  return null;\n}\n\n/**\n * Parse a comma-separated --targets value into PlatformId[]. Returns undefined\n * when the flag is absent/empty so callers can fall back to connector/detection.\n */\nexport function parseTargets(value: string | undefined): PlatformId[] | undefined {\n  if (value == null || value.trim() === \"\") return undefined;\n  const ids = value\n    .split(\",\")\n    .map((s) => s.trim())\n    .filter((s) => s !== \"\") as PlatformId[];\n  return ids.length > 0 ? ids : undefined;\n}\n\nconst ACTION_GLYPH: Record<ChangeRecord[\"action\"], string> = {\n  create: \"+\",\n  update: \"~\",\n  remove: \"-\",\n  skip: \"=\",\n  warn: \"!\",\n};\n\n/**\n * Render an InstallResult as a readable diff: one line per ChangeRecord (glyph,\n * platform, detail, path) followed by any warnings and a summary tally. Used by\n * install / upgrade / uninstall.\n */\nexport function renderInstallResult(\n  result: InstallResult,\n  verb: \"install\" | \"upgrade\" | \"uninstall\",\n): string {\n  const lines: string[] = [];\n  const mode = result.dryRun ? \" (dry-run — nothing written)\" : \"\";\n  lines.push(`${verb} \"${result.connectorId}\"${mode}`);\n\n  if (result.changes.length === 0) {\n    lines.push(\"  (no changes)\");\n  } else {\n    for (const c of result.changes) {\n      const glyph = ACTION_GLYPH[c.action];\n      const where = c.path ? `  ${c.path}` : \"\";\n      lines.push(`  ${glyph} [${c.platform}] ${c.action}: ${c.detail}${where}`);\n    }\n  }\n\n  if (result.warnings.length > 0) {\n    lines.push(\"\");\n    lines.push(\"warnings:\");\n    for (const w of result.warnings) lines.push(`  ! ${w}`);\n  }\n\n  const tally = result.changes.reduce<Record<ChangeRecord[\"action\"], number>>(\n    (acc, c) => {\n      acc[c.action] += 1;\n      return acc;\n    },\n    { create: 0, update: 0, remove: 0, skip: 0, warn: 0 },\n  );\n  lines.push(\"\");\n  lines.push(\n    `summary: ${tally.create} created, ${tally.update} updated, ` +\n      `${tally.remove} removed, ${tally.skip} skipped, ${tally.warn} warning(s)`,\n  );\n\n  return lines.join(\"\\n\");\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// Command dispatch\n// ─────────────────────────────────────────────────────────────────────────\n\n/** A command module: takes the post-command argv slice, returns an exit code. */\ntype CommandModule = { run: (argv: string[]) => Promise<number> | number };\n\n/** Lazy command loaders — keyed by the first positional. Imported on demand. */\nconst COMMANDS: Record<string, () => Promise<CommandModule>> = {\n  detect: () => import(\"./commands/detect.js\"),\n  install: () => import(\"./commands/install.js\"),\n  uninstall: () => import(\"./commands/uninstall.js\"),\n  // `upgrade` is the single \"bring everything current\" verb (re-render host\n  // config + refresh the home pointer + managed channel guidance). `sync` and\n  // `update` are kept as back-compat aliases that route to the same module so\n  // existing scripts/docs keep working without a second concept to learn.\n  upgrade: () => import(\"./commands/upgrade.js\"),\n  sync: () => import(\"./commands/upgrade.js\"),\n  update: () => import(\"./commands/upgrade.js\"),\n  package: () => import(\"./commands/package.js\"),\n  doctor: () => import(\"./commands/doctor.js\"),\n  status: () => import(\"./commands/status.js\"),\n  telemetry: () => import(\"./commands/telemetry.js\"),\n  usage: () => import(\"./commands/usage.js\"),\n  leaderboard: () => import(\"./commands/leaderboard.js\"),\n  hook: () => import(\"./commands/hook.js\"),\n  // Internal (omitted from USAGE): the statusline (HUD) entrypoint a host's\n  // status line config points at. Fail-safe: always exits 0 with at most a\n  // rendered line. See cli/commands/statusline.ts.\n  statusline: () => import(\"./commands/statusline.js\"),\n  // Internal (omitted from USAGE): the user-invokable action entrypoint a future\n  // host affordance points at. USER-TRIGGERED: surfaces errors (exit 1 + stderr),\n  // unlike the fail-open hook / fail-safe statusline. See cli/commands/action.ts.\n  action: () => import(\"./commands/action.js\"),\n  serve: () => import(\"./commands/serve.js\"),\n  // Hidden (omitted from USAGE): the opt-in host-native turn-usage entrypoint an\n  // AfterModel / PostInvocation hook points at. Always exits 0; records a\n  // distinct `model_turn` row. See cli/commands/usage-event.ts.\n  \"usage-event\": () => import(\"./commands/usage-event.js\"),\n};\n\n/** Default program name; an embedding SDK CLI overrides it via {@link MainOptions}. */\nexport const DEFAULT_PROGRAM_NAME = \"agent-connector\";\n\n/**\n * One-line usage signature per command — the single central copy behind\n * `<command> --help` and the friendly bad-flag error. Command modules use\n * node:util parseArgs (strict), which THROWS on an unknown flag; without the\n * dispatcher-level handling in {@link main}, `agent-connector install --help`\n * would die with a raw ERR_PARSE_ARGS stack trace — the very invocation the\n * root help tells users to run.\n */\nconst COMMAND_USAGE: Record<string, string> = {\n  detect: \"detect [--json] [--project <dir>]\",\n  install:\n    \"install [--method direct|marketplace] [--connector <path>] [--scope user|project] [--targets a,b] [--project <dir>] [--dry-run] [--force]\",\n  uninstall:\n    \"uninstall [--method auto|direct|marketplace] [--connector <path>] [--connector-id <id>] [--scope user|project] [--targets a,b] [--project <dir>] [--dry-run] [--purge]\",\n  upgrade:\n    \"upgrade [--method direct|marketplace] [--channel stable|latest] [--connector <path>] [--scope user|project] [--targets a,b] [--project <dir>] [--dry-run]\",\n  sync: \"sync — alias of upgrade (see `upgrade --help`)\",\n  update: \"update — alias of upgrade (see `upgrade --help`)\",\n  package:\n    \"package [--connector <path>] [--format <fmt>|all] [--out <dir>] [--project <dir>] [--dry-run]\",\n  doctor:\n    \"doctor [--targets a,b] [--connector <path>] [--scope user|project] [--project <dir>] [--probe] [--json] [--heal] [--dry-run]\",\n  status: \"status [--connector <path>] [--scope user|project] [--project <dir>] [--json]\",\n  telemetry:\n    \"telemetry report|export|leaderboard [--by <dim>] [--since <dur>] [--connector <id>] [--scope <slice>] [--format csv|json] [--out <file>] [--json]\",\n  usage:\n    \"usage report|export|leaderboard [--by <dim>] [--since <dur>] [--platform <id>] [--format csv|json] [--out <file>] [--json]\",\n  leaderboard: \"leaderboard [--since <dur>] [--connector <id>] [--scope <slice>] [--json]\",\n  hook: \"hook <platform> <event> --connector <id>   (internal — host hook configs point here)\",\n  statusline:\n    \"statusline <platform> --connector <id>   (internal — host status line configs point here)\",\n  action:\n    \"action <platform> <actionId> --connector <id>   (internal — host action affordances point here)\",\n  serve:\n    \"serve --connector <id> [--scope user|project] [--host <platformId>] -- <command> [args...]   (internal — host MCP entries point here)\",\n};\n\n/**\n * Build the top-level usage string for a given program name. The brand replaces\n * \"agent-connector\" in the title, the `usage:` line, and the per-command help\n * footer so an embedded CLI (e.g. `acme-db`) reads as its own tool.\n */\nfunction buildUsage(programName: string): string {\n  return `${programName} — write your MCP server + hooks once, install everywhere.\n\nusage: ${programName} <command> [flags]\n\ncommands:\n  detect       List the AI-agent platforms installed on this machine.\n  install      Deploy a connector across its target platforms (--method direct writes host config; --method marketplace drives the host's plugin install).\n  uninstall    Remove a connector's registrations (--method auto reverses whichever method is actually installed).\n  upgrade      Bring everything current: re-render host config + heal the home pointer + managed update guidance (alias: update, sync).\n  package      Emit a marketplace/extension bundle (9 host formats, or the standard artifacts mcp-server-json | mcpb).\n  doctor       Health-check every detected platform; non-zero exit on any failure.\n  status       Light install-state summary: which connectors are present on which hosts (always exits 0).\n  telemetry    Inspect local per-tool token telemetry (report | export | leaderboard).\n  usage        Inspect host-native token usage from agent CLI logs (report | export | leaderboard).\n  leaderboard  Three leaderboards: 🔌 MCP/plugin (mcp-self) + 🖥️ host/user (host-scan-logs) + 🛰️ host-native turns (host-native-live) — never summed.\n  hook         Universal json-stdio hook entrypoint (hosts call this).\n  serve        Telemetry-wrapping MCP stdio proxy (wraps a real server command).\n\nRun \\`${programName} <command> --help\\` for command-specific flags.`;\n}\n\n/** Options accepted by {@link main}. */\nexport interface MainOptions {\n  /**\n   * The brand shown in usage/help text. Defaults to {@link DEFAULT_PROGRAM_NAME}.\n   * An embedding SDK CLI (see cli/sdk.ts) passes its own bin name so every\n   * subcommand's help reads as the developer's tool.\n   */\n  programName?: string;\n}\n\nexport async function main(argv: string[], opts: MainOptions = {}): Promise<number> {\n  const programName = opts.programName ?? DEFAULT_PROGRAM_NAME;\n  activeProgramName = programName; // brand every fail() in this invocation\n  const usage = buildUsage(programName);\n  const command = argv[0];\n\n  if (command == null || command === \"--help\" || command === \"-h\" || command === \"help\") {\n    print(usage);\n    return command == null ? 1 : 0;\n  }\n  if (command === \"--version\" || command === \"-v\") {\n    print(`${programName} ${resolveOwnVersion()}`);\n    return 0;\n  }\n\n  const loader = COMMANDS[command];\n  if (!loader) {\n    process.stderr.write(`${programName}: unknown command \"${command}\"\\n\\n`);\n    process.stderr.write(`${usage}\\n`);\n    return 2;\n  }\n\n  // Per-command help: no command module defines a --help flag (strict parseArgs\n  // would throw on it), so answer it centrally from COMMAND_USAGE.\n  const rest = argv.slice(1);\n  if (rest.includes(\"--help\") || rest.includes(\"-h\")) {\n    const sig = COMMAND_USAGE[command];\n    if (sig) {\n      print(`usage: ${programName} ${sig}`);\n      return 0;\n    }\n  }\n\n  const mod = await loader();\n  try {\n    return await mod.run(rest);\n  } catch (err) {\n    // Friendly bad-flag errors: strict parseArgs throws ERR_PARSE_ARGS_* for an\n    // unknown/malformed option — print the message + the usage line instead of\n    // letting a raw stack trace reach the user. Everything else still rethrows\n    // (the bin entry reports those as fatal).\n    const code = (err as { code?: string }).code;\n    if (typeof code === \"string\" && code.startsWith(\"ERR_PARSE_ARGS\")) {\n      const message = err instanceof Error ? err.message : String(err);\n      const sig = COMMAND_USAGE[command];\n      if (sig) process.stderr.write(`usage: ${programName} ${sig}\\n`);\n      return fail(message);\n    }\n    throw err;\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/cli/app.ts"],"sourcesContent":["/**\n * cli/app — shared CLI helpers + command dispatch (NO side effects).\n *\n * Command modules import the shared helpers (print, fail, parse-flags,\n * renderInstallResult) from here, and main() dispatches the first positional to a\n * command module.\n * This module never auto-runs — `cli/index.ts` is the thin bin entry that calls\n * `main()`. Keeping the auto-run out of here is what prevents a dispatch recursion\n * (a command module importing a helper must not re-trigger the program) and makes\n * it robust to bundler entry-splitting (the old import.meta.url entry-guard broke\n * once tsup hoisted this code into a shared chunk).\n */\n\nimport { createRequire } from \"node:module\";\n\nimport type {\n  ChangeRecord,\n  InstallResult,\n  InstallScope,\n  PlatformId,\n} from \"../core/types.js\";\n\n// ─────────────────────────────────────────────────────────────────────────\n// Shared helpers (imported by the command modules)\n// ─────────────────────────────────────────────────────────────────────────\n\n/** Print a line to stdout (machine-readable payloads must stay on stdout). */\nexport function print(line: string): void {\n  process.stdout.write(`${line}\\n`);\n}\n\n/**\n * The brand active for THIS invocation. main() sets it from\n * {@link MainOptions.programName} before dispatch, so error messages printed by\n * command modules via {@link fail} read as the embedding tool (e.g. `acme-db:`)\n * instead of always `agent-connector:`.\n */\nlet activeProgramName = \"agent-connector\";\n\n/** Print an error to stderr (branded) and return a non-zero exit code (default 2). */\nexport function fail(message: string, code = 2): number {\n  process.stderr.write(`${activeProgramName}: ${message}\\n`);\n  return code;\n}\n\n/**\n * Resolve agent-connector's own package version at runtime. Works from both the\n * bundled dist layout (dist/*.js → ../package.json) and the src layout under\n * tsx/vitest (src/cli/ → ../../package.json); the name check guards against\n * accidentally reading some other package.json on the walk.\n */\nexport function resolveOwnVersion(): string {\n  const req = createRequire(import.meta.url);\n  for (const rel of [\"../package.json\", \"../../package.json\", \"../../../package.json\"]) {\n    try {\n      const pkg = req(rel) as { name?: string; version?: string };\n      if (pkg.name === \"@ken-jo/agent-connector\" && typeof pkg.version === \"string\") {\n        return pkg.version;\n      }\n    } catch {\n      /* keep walking */\n    }\n  }\n  return \"0.0.0\";\n}\n\n/** Parse a --scope value the CLI accepts (user|project) into an InstallScope. */\nexport function parseScope(value: string | undefined): InstallScope | null {\n  if (value === \"user\" || value === \"project\") return value;\n  return null;\n}\n\n/**\n * Parse a comma-separated --targets value into PlatformId[]. Returns undefined\n * when the flag is absent/empty so callers can fall back to connector/detection.\n */\nexport function parseTargets(value: string | undefined): PlatformId[] | undefined {\n  if (value == null || value.trim() === \"\") return undefined;\n  const ids = value\n    .split(\",\")\n    .map((s) => s.trim())\n    .filter((s) => s !== \"\") as PlatformId[];\n  return ids.length > 0 ? ids : undefined;\n}\n\nconst ACTION_GLYPH: Record<ChangeRecord[\"action\"], string> = {\n  create: \"+\",\n  update: \"~\",\n  remove: \"-\",\n  skip: \"=\",\n  warn: \"!\",\n};\n\n/**\n * Render an InstallResult as a readable diff: one line per ChangeRecord (glyph,\n * platform, detail, path) followed by any warnings and a summary tally. Used by\n * install / upgrade / uninstall.\n */\nexport function renderInstallResult(\n  result: InstallResult,\n  verb: \"install\" | \"upgrade\" | \"uninstall\",\n): string {\n  const lines: string[] = [];\n  const mode = result.dryRun ? \" (dry-run — nothing written)\" : \"\";\n  lines.push(`${verb} \"${result.connectorId}\"${mode}`);\n\n  if (result.changes.length === 0) {\n    lines.push(\"  (no changes)\");\n  } else {\n    for (const c of result.changes) {\n      const glyph = ACTION_GLYPH[c.action];\n      const where = c.path ? `  ${c.path}` : \"\";\n      lines.push(`  ${glyph} [${c.platform}] ${c.action}: ${c.detail}${where}`);\n    }\n  }\n\n  if (result.warnings.length > 0) {\n    lines.push(\"\");\n    lines.push(\"warnings:\");\n    for (const w of result.warnings) lines.push(`  ! ${w}`);\n  }\n\n  const tally = result.changes.reduce<Record<ChangeRecord[\"action\"], number>>(\n    (acc, c) => {\n      acc[c.action] += 1;\n      return acc;\n    },\n    { create: 0, update: 0, remove: 0, skip: 0, warn: 0 },\n  );\n  lines.push(\"\");\n  lines.push(\n    `summary: ${tally.create} created, ${tally.update} updated, ` +\n      `${tally.remove} removed, ${tally.skip} skipped, ${tally.warn} warning(s)`,\n  );\n\n  return lines.join(\"\\n\");\n}\n\n// ─────────────────────────────────────────────────────────────────────────\n// Command dispatch\n// ─────────────────────────────────────────────────────────────────────────\n\n/** A command module: takes the post-command argv slice, returns an exit code. */\ntype CommandModule = { run: (argv: string[]) => Promise<number> | number };\n\n/** Lazy command loaders — keyed by the first positional. Imported on demand. */\nconst COMMANDS: Record<string, () => Promise<CommandModule>> = {\n  detect: () => import(\"./commands/detect.js\"),\n  install: () => import(\"./commands/install.js\"),\n  uninstall: () => import(\"./commands/uninstall.js\"),\n  // `upgrade` is the single \"bring everything current\" verb (re-render host\n  // config + refresh the home pointer + managed channel guidance). `sync` and\n  // `update` are kept as back-compat aliases that route to the same module so\n  // existing scripts/docs keep working without a second concept to learn.\n  upgrade: () => import(\"./commands/upgrade.js\"),\n  sync: () => import(\"./commands/upgrade.js\"),\n  update: () => import(\"./commands/upgrade.js\"),\n  package: () => import(\"./commands/package.js\"),\n  doctor: () => import(\"./commands/doctor.js\"),\n  status: () => import(\"./commands/status.js\"),\n  telemetry: () => import(\"./commands/telemetry.js\"),\n  usage: () => import(\"./commands/usage.js\"),\n  leaderboard: () => import(\"./commands/leaderboard.js\"),\n  hook: () => import(\"./commands/hook.js\"),\n  // Internal (omitted from USAGE): the statusline (HUD) entrypoint a host's\n  // status line config points at. Fail-safe: always exits 0 with at most a\n  // rendered line. See cli/commands/statusline.ts.\n  statusline: () => import(\"./commands/statusline.js\"),\n  // Internal (omitted from USAGE): the user-invokable action entrypoint a future\n  // host affordance points at. USER-TRIGGERED: surfaces errors (exit 1 + stderr),\n  // unlike the fail-open hook / fail-safe statusline. See cli/commands/action.ts.\n  action: () => import(\"./commands/action.js\"),\n  serve: () => import(\"./commands/serve.js\"),\n  // Hidden (omitted from USAGE): the opt-in host-native turn-usage entrypoint an\n  // AfterModel / PostInvocation hook points at. Always exits 0; records a\n  // distinct `model_turn` row. See cli/commands/usage-event.ts.\n  \"usage-event\": () => import(\"./commands/usage-event.js\"),\n};\n\n/** Default program name; an embedding SDK CLI overrides it via {@link MainOptions}. */\nexport const DEFAULT_PROGRAM_NAME = \"agent-connector\";\n\n/**\n * One-line usage signature per command — the single central copy behind\n * `<command> --help` and the friendly bad-flag error. Command modules use\n * node:util parseArgs (strict), which THROWS on an unknown flag; without the\n * dispatcher-level handling in {@link main}, `agent-connector install --help`\n * would die with a raw ERR_PARSE_ARGS stack trace — the very invocation the\n * root help tells users to run.\n */\nconst COMMAND_USAGE: Record<string, string> = {\n  detect: \"detect [--json] [--project <dir>]\",\n  install:\n    \"install [--method direct|marketplace] [--connector <path>] [--scope user|project] [--targets a,b] [--project <dir>] [--dry-run] [--force]\",\n  uninstall:\n    \"uninstall [--method auto|direct|marketplace] [--connector <path>] [--connector-id <id>] [--scope user|project] [--targets a,b] [--project <dir>] [--dry-run] [--purge]\",\n  upgrade:\n    \"upgrade [--method direct|marketplace] [--channel stable|latest] [--connector <path>] [--scope user|project] [--targets a,b] [--project <dir>] [--dry-run]\",\n  sync: \"sync — alias of upgrade (see `upgrade --help`)\",\n  update: \"update — alias of upgrade (see `upgrade --help`)\",\n  package:\n    \"package [--connector <path>] [--format <fmt>|all] [--out <dir>] [--project <dir>] [--dry-run]\",\n  doctor:\n    \"doctor [--targets a,b] [--connector <path>] [--scope user|project] [--project <dir>] [--probe] [--explain] [--json] [--heal] [--dry-run]\\n\" +\n    \"  --explain   per-(host,event) hook honor matrix (honored/degraded/dropped). Exit non-zero ONLY when an explicitly-targeted host DEGRADES a declared event (fires it but silently won't honor the reply); dropped/mcp-only hosts and fleet-wide (targets:auto) gaps are informational (exit 0).\",\n  status: \"status [--connector <path>] [--scope user|project] [--project <dir>] [--json]\",\n  telemetry:\n    \"telemetry report|export|leaderboard [--by <dim>] [--since <dur>] [--connector <id>] [--scope <slice>] [--format csv|json] [--out <file>] [--json]\",\n  usage:\n    \"usage report|export|leaderboard [--by <dim>] [--since <dur>] [--platform <id>] [--format csv|json] [--out <file>] [--json]\",\n  leaderboard: \"leaderboard [--since <dur>] [--connector <id>] [--scope <slice>] [--json]\",\n  hook: \"hook <platform> <event> --connector <id>   (internal — host hook configs point here)\",\n  statusline:\n    \"statusline <platform> --connector <id>   (internal — host status line configs point here)\",\n  action:\n    \"action <platform> <actionId> --connector <id>   (internal — host action affordances point here)\",\n  serve:\n    \"serve --connector <id> [--scope user|project] [--host <platformId>] -- <command> [args...]   (internal — host MCP entries point here)\",\n};\n\n/**\n * Build the top-level usage string for a given program name. The brand replaces\n * \"agent-connector\" in the title, the `usage:` line, and the per-command help\n * footer so an embedded CLI (e.g. `acme-db`) reads as its own tool.\n */\nfunction buildUsage(programName: string): string {\n  return `${programName} — write your MCP server + hooks once, install everywhere.\n\nusage: ${programName} <command> [flags]\n\ncommands:\n  detect       List the AI-agent platforms installed on this machine.\n  install      Deploy a connector across its target platforms (--method direct writes host config; --method marketplace drives the host's plugin install).\n  uninstall    Remove a connector's registrations (--method auto reverses whichever method is actually installed).\n  upgrade      Bring everything current: re-render host config + heal the home pointer + managed update guidance (alias: update, sync).\n  package      Emit a marketplace/extension bundle (9 host formats, or the standard artifacts mcp-server-json | mcpb).\n  doctor       Health-check every detected platform; non-zero exit on any failure.\n  status       Light install-state summary: which connectors are present on which hosts (always exits 0).\n  telemetry    Inspect local per-tool token telemetry (report | export | leaderboard).\n  usage        Inspect host-native token usage from agent CLI logs (report | export | leaderboard).\n  leaderboard  Three leaderboards: 🔌 MCP/plugin (mcp-self) + 🖥️ host/user (host-scan-logs) + 🛰️ host-native turns (host-native-live) — never summed.\n  hook         Universal json-stdio hook entrypoint (hosts call this).\n  serve        Telemetry-wrapping MCP stdio proxy (wraps a real server command).\n\nRun \\`${programName} <command> --help\\` for command-specific flags.`;\n}\n\n/** Options accepted by {@link main}. */\nexport interface MainOptions {\n  /**\n   * The brand shown in usage/help text. Defaults to {@link DEFAULT_PROGRAM_NAME}.\n   * An embedding SDK CLI (see cli/sdk.ts) passes its own bin name so every\n   * subcommand's help reads as the developer's tool.\n   */\n  programName?: string;\n}\n\nexport async function main(argv: string[], opts: MainOptions = {}): Promise<number> {\n  const programName = opts.programName ?? DEFAULT_PROGRAM_NAME;\n  activeProgramName = programName; // brand every fail() in this invocation\n  const usage = buildUsage(programName);\n  const command = argv[0];\n\n  if (command == null || command === \"--help\" || command === \"-h\" || command === \"help\") {\n    print(usage);\n    return command == null ? 1 : 0;\n  }\n  if (command === \"--version\" || command === \"-v\") {\n    print(`${programName} ${resolveOwnVersion()}`);\n    return 0;\n  }\n\n  const loader = COMMANDS[command];\n  if (!loader) {\n    process.stderr.write(`${programName}: unknown command \"${command}\"\\n\\n`);\n    process.stderr.write(`${usage}\\n`);\n    return 2;\n  }\n\n  // Per-command help: no command module defines a --help flag (strict parseArgs\n  // would throw on it), so answer it centrally from COMMAND_USAGE.\n  const rest = argv.slice(1);\n  if (rest.includes(\"--help\") || rest.includes(\"-h\")) {\n    const sig = COMMAND_USAGE[command];\n    if (sig) {\n      print(`usage: ${programName} ${sig}`);\n      return 0;\n    }\n  }\n\n  const mod = await loader();\n  try {\n    return await mod.run(rest);\n  } catch (err) {\n    // Friendly bad-flag errors: strict parseArgs throws ERR_PARSE_ARGS_* for an\n    // unknown/malformed option — print the message + the usage line instead of\n    // letting a raw stack trace reach the user. Everything else still rethrows\n    // (the bin entry reports those as fatal).\n    const code = (err as { code?: string }).code;\n    if (typeof code === \"string\" && code.startsWith(\"ERR_PARSE_ARGS\")) {\n      const message = err instanceof Error ? err.message : String(err);\n      const sig = COMMAND_USAGE[command];\n      if (sig) process.stderr.write(`usage: ${programName} ${sig}\\n`);\n      return fail(message);\n    }\n    throw err;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-P5KA5NVR.js → chunk-MDZG5QHB.js}

@@ -2,12 +2,57 @@
 import {
   allAdapters,
   loadAdapter
-} from "./chunk-LS65GL2P.js";
+} from "./chunk-Q5LECKZL.js";
 
 // src/sdk/introspect.ts
+function hostCanFireEvent(c, event) {
+  switch (event) {
+    case "SessionStart":
+      return c.sessionStart;
+    case "SessionEnd":
+      return c.sessionEnd;
+    case "UserPromptSubmit":
+      return c.userPromptSubmit;
+    case "PreToolUse":
+      return c.preToolUse;
+    case "PostToolUse":
+      return c.postToolUse;
+    case "PreCompact":
+      return c.preCompact;
+    case "Stop":
+      return c.stop;
+    case "Notification":
+      return c.notification;
+    case "PermissionRequest":
+      return c.permissionRequest ?? false;
+    case "PostToolUseFailure":
+      return c.postToolUseFailure ?? false;
+    case "SubagentStart":
+      return c.subagentStart ?? false;
+    case "SubagentStop":
+      return c.subagentStop ?? false;
+    case "PostCompact":
+      return c.postCompact ?? false;
+  }
+}
+var ALL_HOOK_EVENTS = [
+  "SessionStart",
+  "SessionEnd",
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "PreCompact",
+  "Stop",
+  "Notification",
+  "PermissionRequest",
+  "PostToolUseFailure",
+  "SubagentStart",
+  "SubagentStop",
+  "PostCompact"
+];
 var SURFACE_PREDICATES = {
   server: (c) => c.transports.length > 0,
-  hooks: (c) => c.sessionStart || c.preToolUse || c.postToolUse || c.userPromptSubmit || c.stop || c.sessionEnd || c.preCompact || c.notification || (c.permissionRequest ?? false) || (c.postToolUseFailure ?? false) || (c.subagentStart ?? false) || (c.subagentStop ?? false),
+  hooks: (c) => ALL_HOOK_EVENTS.some((e) => hostCanFireEvent(c, e)),
   commands: (c) => c.supportsCommands ?? false,
   skills: (c) => c.supportsSkills ?? false,
   subagents: (c) => c.supportsSubagents ?? false,
@@ -36,9 +81,10 @@ async function surfaceSupport(host, surface) {
 }
 
 export {
+  hostCanFireEvent,
   SURFACE_PREDICATES,
   capabilitiesOf,
   hostsSupporting,
   surfaceSupport
 };
-//# sourceMappingURL=chunk-P5KA5NVR.js.map
+//# sourceMappingURL=chunk-MDZG5QHB.js.map

package/dist/chunk-MDZG5QHB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sdk/introspect.ts"],"sourcesContent":["/**\n * sdk/introspect — host-capability introspection over the adapter registry.\n *\n * A thin, READ-ONLY query layer above {@link loadAdapter} / {@link allAdapters}:\n * \"which hosts can honor surface X?\" and \"what can host Y do?\". It exists so a\n * connector author (or a docs/CLI surface) can answer those questions WITHOUT\n * reaching into adapter internals or re-deriving the per-surface capability\n * rules — the predicates below are the single source of truth for mapping the\n * raw {@link PlatformCapabilities} flags onto the developer-facing surface names.\n *\n * Everything is async because adapters load lazily (one entry per platform in\n * the registry, imported only when queried).\n */\n\nimport type {\n  HookEventName,\n  PlatformCapabilities,\n  PlatformId,\n} from \"../core/types.js\";\nimport { allAdapters, loadAdapter } from \"../adapters/registry.js\";\n\n/**\n * The single source of truth mapping each normalized {@link HookEventName} onto\n * the {@link PlatformCapabilities} flag that says \"this host can natively FIRE\n * this event\". The optional flags (the newer E1 events + PostCompact) are read\n * as `?? false`, mirroring the supportsCommands precedent — a host that leaves a\n * flag unset cannot fire that event, so a declared hook for it skip-warns at\n * install and `explain` reports it as not honored.\n *\n * This is the per-event signal {@link explain}'s hooks row evaluates against the\n * connector's DECLARED events (so a Stop-only connector on a PreToolUse-only\n * host no longer falsely shows `native`), and the same signal `simulate`'s real\n * parse→handler→format chain expresses at runtime.\n */\nexport function hostCanFireEvent(\n  c: PlatformCapabilities,\n  event: HookEventName,\n): boolean {\n  switch (event) {\n    case \"SessionStart\":\n      return c.sessionStart;\n    case \"SessionEnd\":\n      return c.sessionEnd;\n    case \"UserPromptSubmit\":\n      return c.userPromptSubmit;\n    case \"PreToolUse\":\n      return c.preToolUse;\n    case \"PostToolUse\":\n      return c.postToolUse;\n    case \"PreCompact\":\n      return c.preCompact;\n    case \"Stop\":\n      return c.stop;\n    case \"Notification\":\n      return c.notification;\n    case \"PermissionRequest\":\n      return c.permissionRequest ?? false;\n    case \"PostToolUseFailure\":\n      return c.postToolUseFailure ?? false;\n    case \"SubagentStart\":\n      return c.subagentStart ?? false;\n    case \"SubagentStop\":\n      return c.subagentStop ?? false;\n    case \"PostCompact\":\n      return c.postCompact ?? false;\n  }\n}\n\n/** The full normalized hook-event union, in canonical order. */\nconst ALL_HOOK_EVENTS: HookEventName[] = [\n  \"SessionStart\",\n  \"SessionEnd\",\n  \"UserPromptSubmit\",\n  \"PreToolUse\",\n  \"PostToolUse\",\n  \"PreCompact\",\n  \"Stop\",\n  \"Notification\",\n  \"PermissionRequest\",\n  \"PostToolUseFailure\",\n  \"SubagentStart\",\n  \"SubagentStop\",\n  \"PostCompact\",\n];\n\n/**\n * The developer-facing surface names a connector can declare. These mirror the\n * top-level {@link import(\"../core/types.js\").ConnectorConfig} keys (server,\n * hooks, commands, …) plus the platform-scoped `configPatch` / `nativeHooks`\n * escape hatches — the same vocabulary the install diff and `explain` use.\n */\nexport type SurfaceName =\n  | \"server\"\n  | \"hooks\"\n  | \"commands\"\n  | \"skills\"\n  | \"subagents\"\n  | \"memory\"\n  | \"statusline\"\n  | \"actions\"\n  | \"configPatch\"\n  | \"nativeHooks\";\n\n/**\n * Pure capability predicate per surface — `true` when the host can NATIVELY\n * honor that surface. The optional capability flags are read as `?? false`\n * (the supportsCommands precedent in core/types), so a host that simply leaves\n * a flag unset reports the surface as unsupported (the installer skip-warns it).\n *\n * `hooks` here is the COARSE host-capability predicate: `true` when the host can\n * fire AT LEAST ONE normalized event (it derives from {@link hostCanFireEvent},\n * the per-event source of truth, so the two never drift). It is the right answer\n * for the connector-less queries ({@link hostsSupporting} / {@link surfaceSupport}:\n * \"which hosts have a hook runtime at all?\"). It is deliberately NOT used by\n * {@link explain}, which must judge the hooks surface against the connector's\n * SPECIFIC declared events — a Stop-only connector on a PreToolUse-only host is\n * NOT honored even though the host has a hook runtime (see {@link explain}).\n */\nexport const SURFACE_PREDICATES: Record<\n  SurfaceName,\n  (c: PlatformCapabilities) => boolean\n> = {\n  server: (c) => c.transports.length > 0,\n  hooks: (c) => ALL_HOOK_EVENTS.some((e) => hostCanFireEvent(c, e)),\n  commands: (c) => c.supportsCommands ?? false,\n  skills: (c) => c.supportsSkills ?? false,\n  subagents: (c) => c.supportsSubagents ?? false,\n  memory: (c) => c.supportsMemory ?? false,\n  statusline: (c) => c.supportsStatusline ?? false,\n  // Emitters ship on droid + hermes + warp plus the ts-plugin slash-command\n  // hosts omp + openclaw (+ the nemoclaw fork) — the hosts with a verifiable\n  // target. Every other host leaves supportsActions unset, so explain() marks\n  // actions skip-warn there — the honest state for a host with no emission target.\n  actions: (c) => c.supportsActions ?? false,\n  configPatch: (c) => c.supportsConfigPatch ?? false,\n  nativeHooks: (c) => c.supportsNativeHooks ?? false,\n};\n\n/**\n * The {@link PlatformCapabilities} a host advertises, or `undefined` for an id\n * that is not in the registry (`\"unknown\"`, a usage-only id like `\"synthetic\"`,\n * or a typo) — callers branch on undefined rather than crash.\n */\nexport async function capabilitiesOf(\n  host: PlatformId | string,\n): Promise<PlatformCapabilities | undefined> {\n  const adapter = await loadAdapter(host);\n  return adapter?.capabilities;\n}\n\n/**\n * Every registered host that can NATIVELY honor `surface`, as a sorted id list\n * (stable output for snapshots/docs). Loads all adapters in parallel and keeps\n * only those whose capabilities pass {@link SURFACE_PREDICATES}.\n */\nexport async function hostsSupporting(surface: SurfaceName): Promise<PlatformId[]> {\n  const predicate = SURFACE_PREDICATES[surface];\n  const adapters = await allAdapters();\n  return adapters\n    .filter((adapter) => predicate(adapter.capabilities))\n    .map((adapter) => adapter.id)\n    .sort();\n}\n\n/**\n * Convenience: does `host` natively support `surface`? `false` for an unknown\n * id (no capabilities → cannot support anything).\n */\nexport async function surfaceSupport(\n  host: PlatformId | string,\n  surface: SurfaceName,\n): Promise<boolean> {\n  const capabilities = await capabilitiesOf(host);\n  return capabilities ? SURFACE_PREDICATES[surface](capabilities) : false;\n}\n"],"mappings":";;;;;;;AAkCO,SAAS,iBACd,GACA,OACS;AACT,UAAQ,OAAO;AAAA,IACb,KAAK;AACH,aAAO,EAAE;AAAA,IACX,KAAK;AACH,aAAO,EAAE;AAAA,IACX,KAAK;AACH,aAAO,EAAE;AAAA,IACX,KAAK;AACH,aAAO,EAAE;AAAA,IACX,KAAK;AACH,aAAO,EAAE;AAAA,IACX,KAAK;AACH,aAAO,EAAE;AAAA,IACX,KAAK;AACH,aAAO,EAAE;AAAA,IACX,KAAK;AACH,aAAO,EAAE;AAAA,IACX,KAAK;AACH,aAAO,EAAE,qBAAqB;AAAA,IAChC,KAAK;AACH,aAAO,EAAE,sBAAsB;AAAA,IACjC,KAAK;AACH,aAAO,EAAE,iBAAiB;AAAA,IAC5B,KAAK;AACH,aAAO,EAAE,gBAAgB;AAAA,IAC3B,KAAK;AACH,aAAO,EAAE,eAAe;AAAA,EAC5B;AACF;AAGA,IAAM,kBAAmC;AAAA,EACvC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAmCO,IAAM,qBAGT;AAAA,EACF,QAAQ,CAAC,MAAM,EAAE,WAAW,SAAS;AAAA,EACrC,OAAO,CAAC,MAAM,gBAAgB,KAAK,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAAA,EAChE,UAAU,CAAC,MAAM,EAAE,oBAAoB;AAAA,EACvC,QAAQ,CAAC,MAAM,EAAE,kBAAkB;AAAA,EACnC,WAAW,CAAC,MAAM,EAAE,qBAAqB;AAAA,EACzC,QAAQ,CAAC,MAAM,EAAE,kBAAkB;AAAA,EACnC,YAAY,CAAC,MAAM,EAAE,sBAAsB;AAAA;AAAA;AAAA;AAAA;AAAA,EAK3C,SAAS,CAAC,MAAM,EAAE,mBAAmB;AAAA,EACrC,aAAa,CAAC,MAAM,EAAE,uBAAuB;AAAA,EAC7C,aAAa,CAAC,MAAM,EAAE,uBAAuB;AAC/C;AAOA,eAAsB,eACpB,MAC2C;AAC3C,QAAM,UAAU,MAAM,YAAY,IAAI;AACtC,SAAO,SAAS;AAClB;AAOA,eAAsB,gBAAgB,SAA6C;AACjF,QAAM,YAAY,mBAAmB,OAAO;AAC5C,QAAM,WAAW,MAAM,YAAY;AACnC,SAAO,SACJ,OAAO,CAAC,YAAY,UAAU,QAAQ,YAAY,CAAC,EACnD,IAAI,CAAC,YAAY,QAAQ,EAAE,EAC3B,KAAK;AACV;AAMA,eAAsB,eACpB,MACA,SACkB;AAClB,QAAM,eAAe,MAAM,eAAe,IAAI;AAC9C,SAAO,eAAe,mBAAmB,OAAO,EAAE,YAAY,IAAI;AACpE;","names":[]}

package/dist/{chunk-CSRBMJLU.js → chunk-MHDQWZ4A.js}

@@ -9,13 +9,13 @@ import {
 } from "./chunk-7QRUZAUG.js";
 import {
   detectRuntimeHost
-} from "./chunk-GCRRX4MO.js";
+} from "./chunk-TW4DVR4V.js";
 import {
   attachLazyTelemetryUsage,
   buildTelemetryAccessor,
   measureToolCall,
   measureToolDefs
-} from "./chunk-E45SUUD7.js";
+} from "./chunk-24K6JOKV.js";
 import {
   getTokenizer,
   inferModelFamily,
@@ -28,11 +28,11 @@ import {
 import {
   loadRegisteredConnector,
   readRegisteredMeta
-} from "./chunk-RQCBBLTA.js";
+} from "./chunk-5LAFKXFM.js";
 import {
   REGISTERED_PLATFORM_IDS,
   loadAdapter
-} from "./chunk-LS65GL2P.js";
+} from "./chunk-Q5LECKZL.js";
 import {
   detectLaunchMethod
 } from "./chunk-TO57WYBB.js";
@@ -691,4 +691,4 @@ export {
   runStatusline,
   runAction
 };
-//# sourceMappingURL=chunk-CSRBMJLU.js.map
+//# sourceMappingURL=chunk-MHDQWZ4A.js.map

package/dist/{chunk-RHML2NOB.js → chunk-NUGMVVV2.js}

@@ -1046,7 +1046,7 @@ var BaseAdapter = class {
       if (hostEvent === void 0) {
         changes.push({
           platform: this.id,
-          action: "warn",
+          action: descriptor.unmappedAction ? descriptor.unmappedAction(event) : "warn",
           path: configPath,
           detail: descriptor.unmappedWarnDetail(event)
         });
@@ -1258,4 +1258,4 @@ export {
   renderOpenCodeSubagentMd,
   BaseAdapter
 };
-//# sourceMappingURL=chunk-RHML2NOB.js.map
+//# sourceMappingURL=chunk-NUGMVVV2.js.map