@event4u/agent-config 14.19.0 → 14.21.0

package/dist/cli/mcp/telemetry.js

@@ -0,0 +1,227 @@
+/**
+ * Call telemetry for the stdio-lite MCP server (roadmap step 4.1).
+ *
+ * WHY THIS EXISTS. Before it, `grep -rn 'telemetry|collector|record'
+ * src/cli/mcp/*.ts` was empty: the two lite tools were invisible, so every
+ * statement about whether the lite surface is used at all was an assumption.
+ * One row per `tools/call` turns that into a reading — including a zero, which
+ * is a result.
+ *
+ * THREE CONSTRAINTS THE ROADMAP SET, AND HOW EACH IS MET.
+ *
+ * - **No second sink.** Rows go to the sink that already collects MCP
+ *   `tools/call` records, `agents/runtime/mcp-telemetry/calls.jsonl`, through
+ *   the same `record_call` the kernel server uses. Nothing new is created.
+ * - **No new consent gate.** The switch is the EXISTING
+ *   `telemetry.artifact_engagement.enabled` key, default `false`. No key is
+ *   introduced, so a consumer who has not opted into telemetry does not
+ *   acquire a new thing to opt out of.
+ * - **One row per call, none when off.** `recordLiteCall` is the only writer
+ *   and returns `null` without touching the filesystem when the gate is off.
+ *
+ * PRIVACY BY CONSTRUCTION. Two fields are caller-influenced and both are
+ * clamped at the boundary. `host` is resolved against a CLOSED vocabulary; an
+ * unrecognised client name becomes `other`, never the string the client sent.
+ * `tool_name` is caller-supplied on the wire — a client may call
+ * `tools/call` with ANY name — so a name outside a conservative identifier
+ * shape is recorded as `other_tool` rather than stored verbatim. Without that
+ * clamp the sink would accept a path or a secret as a tool name and this
+ * report would print it. The record therefore has no field capable of carrying
+ * free-form text, and there is no scrubbing pass that could fail because there
+ * is nothing to scrub. The client-install hash comes from the kernel collector
+ * unchanged.
+ *
+ * NEVER THROWS. Telemetry must not break the wire surface; every path here
+ * either records or returns `null`.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { record_call } from '../../scripts/mcp_server/telemetry.js';
+/** Transport label for this surface — distinguishes it from the kernel server. */
+export const LITE_TRANSPORT = 'stdio-lite';
+/** The settings key that gates every row. Deliberately an EXISTING key. */
+export const LITE_TELEMETRY_SETTING = 'telemetry.artifact_engagement.enabled';
+/**
+ * The closed host vocabulary.
+ *
+ * Membership is what makes the field non-identifying: a value is either one of
+ * these literals, `other`, or `unknown`. It is matched against the MCP
+ * `clientInfo.name` a client sends at `initialize`, lower-cased, with `_` and
+ * spaces folded to `-`; a name that merely CONTAINS one of these is resolved to
+ * it, because clients ship names like `claude-code-cli` and `Cursor (0.42)`.
+ */
+export const KNOWN_HOSTS = [
+    'claude-code',
+    'claude-desktop',
+    'cursor',
+    'windsurf',
+    'cline',
+    'gemini-cli',
+    'copilot',
+    'augment',
+    'aider',
+    'codex',
+    'roocode',
+    'continue',
+    'kilocode',
+    'zed',
+    'jetbrains',
+    'kiro',
+    'opencode',
+    'trae',
+    'warp',
+];
+/** No `initialize` seen yet, or it carried no client name. */
+export const HOST_UNKNOWN = 'unknown';
+/** A client name that is not in the closed vocabulary. Never the raw string. */
+export const HOST_OTHER = 'other';
+/**
+ * Resolve a client-supplied name onto the closed vocabulary.
+ *
+ * Longest match first, so `claude-desktop` is not swallowed by a shorter
+ * sibling and `claude-code` wins over a bare `claude` substring.
+ */
+export function normalizeHost(clientName) {
+    if (typeof clientName !== 'string')
+        return HOST_UNKNOWN;
+    const folded = clientName.trim().toLowerCase().replace(/[_\s]+/g, '-');
+    if (folded === '')
+        return HOST_UNKNOWN;
+    const byLength = [...KNOWN_HOSTS].sort((a, b) => b.length - a.length);
+    for (const known of byLength) {
+        if (folded === known || folded.includes(known))
+            return known;
+    }
+    return HOST_OTHER;
+}
+/**
+ * The shape a tool name must have to be stored verbatim.
+ *
+ * Conservative on purpose: MCP tool names are identifiers, so anything with a
+ * separator, whitespace, or unusual length is not a tool name that this surface
+ * could ever serve — it is caller-supplied text, and text is what must not
+ * reach the store.
+ */
+const TOOL_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$/;
+/** A caller-supplied name that is not identifier-shaped. Never the raw string. */
+export const TOOL_OTHER = 'other_tool';
+/**
+ * Clamp a wire tool name onto a storable one.
+ *
+ * A name this surface actually serves always passes; an unknown but
+ * identifier-shaped name passes too, because that is the latent-demand signal
+ * the store exists to carry. Everything else becomes `other_tool`.
+ */
+export function normalizeToolName(name, isLiteTool) {
+    if (typeof name !== 'string' || name === '')
+        return '';
+    if (isLiteTool)
+        return name;
+    return TOOL_NAME_RE.test(name) ? name : TOOL_OTHER;
+}
+/** `str.strip()` on both ends, matching the sibling settings peeks in `src/cli`. */
+function _strip(s) {
+    return s.replace(/^[ \t\r\f\v]+/, '').replace(/[ \t\r\f\v]+$/, '');
+}
+/**
+ * Read `telemetry.artifact_engagement.enabled` from a project settings file.
+ *
+ * A deliberately small nested-key peek over the YAML subset this package's own
+ * settings files are written in — the same shape `workspace_crypto.isEnabled`
+ * and `workspace_analytics` already use in `src/cli`, and for the same reason:
+ * the lite server must stay pure-Node with no YAML dependency.
+ *
+ * Every failure resolves to `false`. Missing file, unreadable file, missing
+ * section, missing key and an unparseable value are all indistinguishable and
+ * all mean OFF — the default-off doctrine the engagement collector states for
+ * itself.
+ */
+export function liteTelemetryEnabled(settingsPath) {
+    const p = settingsPath ?? path.join(process.cwd(), '.agent-settings.yml');
+    let text;
+    try {
+        text = fs.readFileSync(p, 'utf-8');
+    }
+    catch {
+        return false;
+    }
+    // Track the two nesting levels the key needs: `telemetry:` at column 0,
+    // then `artifact_engagement:` beneath it, then `enabled:` beneath that.
+    let inTelemetry = false;
+    let inSection = false;
+    let sectionIndent = -1;
+    for (const raw of text.split(/\r\n|\r|\n/)) {
+        const line = raw.replace(/[ \t\r\f\v]+$/, '');
+        if (line === '' || _strip(line).startsWith('#'))
+            continue;
+        const indent = line.length - line.replace(/^ +/, '').length;
+        const body = _strip(line);
+        if (indent === 0) {
+            inTelemetry = body === 'telemetry:';
+            inSection = false;
+            sectionIndent = -1;
+            continue;
+        }
+        if (!inTelemetry)
+            continue;
+        if (!inSection) {
+            if (body === 'artifact_engagement:') {
+                inSection = true;
+                sectionIndent = indent;
+            }
+            continue;
+        }
+        // Left the section — a sibling key at or above its indent closes it.
+        if (indent <= sectionIndent) {
+            inSection = body === 'artifact_engagement:';
+            if (inSection)
+                sectionIndent = indent;
+            continue;
+        }
+        if (body.startsWith('enabled:')) {
+            const value = _strip(body.slice('enabled:'.length)).toLowerCase();
+            return value === 'true' || value === 'yes' || value === 'on';
+        }
+    }
+    return false;
+}
+/**
+ * Classify one lite `tools/call`.
+ *
+ * `implemented` — a lite tool ran. `stub` — the name is not on this surface, so
+ * the `not_implemented` envelope was returned, which is exactly the condition
+ * the kernel collector defines that outcome for. The lite server cannot
+ * distinguish "in the kernel catalogue but absent here" from "in no catalogue
+ * at all", so it never claims `latent_demand`: the kernel server owns that
+ * distinction, and guessing it here would put an unearned claim in the store.
+ */
+export function classifyLiteOutcome(isLiteTool) {
+    return isLiteTool ? 'implemented' : 'stub';
+}
+/**
+ * Append exactly one row for one `tools/call`, or nothing.
+ *
+ * Returns the record written, or `null` when the gate is off or the write
+ * failed. Never throws.
+ */
+export function recordLiteCall(options) {
+    const { toolName, isLiteTool, host, consumerRoot, settingsPath } = options;
+    const stored = normalizeToolName(toolName, isLiteTool);
+    if (stored === '')
+        return null;
+    try {
+        if (!liteTelemetryEnabled(settingsPath))
+            return null;
+        return record_call({
+            tool_name: stored,
+            outcome: classifyLiteOutcome(isLiteTool),
+            transport: LITE_TRANSPORT,
+            consumer_root: consumerRoot,
+            host,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=telemetry.js.map

package/dist/cli-delegate/{chunk-KPBWFOPZ.js → chunk-2FTMENJL.js}

@@ -81,7 +81,7 @@ __export(clients_exports, {
   record_cli_call: () => record_cli_call,
   reset_cli_call_counts: () => reset_cli_call_counts
 });
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 import * as fs3 from "node:fs";
 import * as os from "node:os";
 import * as path3 from "node:path";
@@ -205,6 +205,88 @@ function boundFor(member) {
   return AGENCY_BOUNDS.find((b) => b.member === member)?.bound ?? [];
 }
 
+// src/scripts/ai_council/api_transport.ts
+import { spawnSync } from "node:child_process";
+var GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+function curlJsonPost(url, extraHeaders, body) {
+  const args = ["-sS", "-X", "POST", url, "-H", "content-type: application/json"];
+  for (const h of extraHeaders) {
+    args.push("-H", h);
+  }
+  args.push("--connect-timeout", "30", "--max-time", "290");
+  args.push("-w", "\n%{http_code}", "--data-binary", "@-");
+  const r = spawnSync("curl", args, {
+    input: JSON.stringify(body),
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    timeout: 3e5
+  });
+  if (r.error) {
+    throw new Error(`curl spawn failed: ${r.error.message}`);
+  }
+  if (r.status !== 0) {
+    throw new Error(
+      `curl exited ${r.status ?? "null"}: ${(r.stderr ?? "").toString().slice(0, 500)}`
+    );
+  }
+  const out = (r.stdout ?? "").toString();
+  const nl = out.lastIndexOf("\n");
+  const httpCode = (nl >= 0 ? out.slice(nl + 1) : out).trim();
+  const bodyText = nl >= 0 ? out.slice(0, nl) : out;
+  if (!/^2\d\d$/.test(httpCode)) {
+    throw new Error(`HTTP ${httpCode}: ${bodyText.slice(0, 500)}`);
+  }
+  return JSON.parse(bodyText);
+}
+function openAiCompatibleClient(baseUrl, apiKey, post = curlJsonPost) {
+  const url = `${baseUrl.replace(/\/+$/, "")}/chat/completions`;
+  return {
+    chat: {
+      completions: {
+        create: (kwargs) => post(url, [`authorization: Bearer ${apiKey}`], kwargs)
+      }
+    }
+  };
+}
+function geminiRestClient(apiKey, post = curlJsonPost, baseUrl = GEMINI_BASE_URL) {
+  return {
+    models: {
+      generate_content: (kwargs) => {
+        const model = String(kwargs["model"] ?? "");
+        const cfg = kwargs["config"] ?? {};
+        const url = `${baseUrl.replace(/\/+$/, "")}/models/${model}:generateContent`;
+        const raw = post(
+          url,
+          [`x-goog-api-key: ${apiKey}`],
+          {
+            contents: [{ role: "user", parts: [{ text: String(kwargs["contents"] ?? "") }] }],
+            generationConfig: { maxOutputTokens: cfg["max_output_tokens"] ?? null }
+          }
+        );
+        return normaliseGeminiRest(raw);
+      }
+    }
+  };
+}
+function normaliseGeminiRest(raw) {
+  const env = raw ?? {};
+  const candidates = Array.isArray(env["candidates"]) ? env["candidates"] : [];
+  const first = candidates[0] ?? {};
+  const content = first["content"] ?? {};
+  const parts = Array.isArray(content["parts"]) ? content["parts"] : [];
+  const text = parts.map((p) => String((p ?? {})["text"] ?? "")).join("");
+  const usage = env["usageMetadata"] ?? {};
+  const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+  return {
+    text,
+    model_version: String(env["modelVersion"] ?? ""),
+    usage_metadata: {
+      prompt_token_count: num(usage["promptTokenCount"]),
+      candidates_token_count: num(usage["candidatesTokenCount"])
+    }
+  };
+}
+
 // src/scripts/_lib/session_role.ts
 var SESSION_ROLE_ENV = "AGENT_CONFIG_SESSION_ROLE";
 var KNOWN_ROLES = /* @__PURE__ */ new Set(["orchestrator", "worker", "reviewer"]);
@@ -899,34 +981,6 @@ var ExternalAIClient = class {
     return this.ask(system_prompt, user_prompt, max_tokens);
   }
 };
-function _curlJsonPost(url, extraHeaders, body) {
-  const args = ["-sS", "-X", "POST", url, "-H", "content-type: application/json"];
-  for (const h of extraHeaders) {
-    args.push("-H", h);
-  }
-  args.push("--connect-timeout", "30", "--max-time", "290");
-  args.push("-w", "\n%{http_code}", "--data-binary", "@-");
-  const r = spawnSync("curl", args, {
-    input: JSON.stringify(body),
-    encoding: "utf8",
-    maxBuffer: 64 * 1024 * 1024,
-    timeout: 3e5
-  });
-  if (r.error) {
-    throw new Error(`curl spawn failed: ${r.error.message}`);
-  }
-  if (r.status !== 0) {
-    throw new Error(`curl exited ${r.status ?? "null"}: ${(r.stderr ?? "").toString().slice(0, 500)}`);
-  }
-  const out = (r.stdout ?? "").toString();
-  const nl = out.lastIndexOf("\n");
-  const httpCode = (nl >= 0 ? out.slice(nl + 1) : out).trim();
-  const bodyText = nl >= 0 ? out.slice(0, nl) : out;
-  if (!/^2\d\d$/.test(httpCode)) {
-    throw new Error(`HTTP ${httpCode}: ${bodyText.slice(0, 500)}`);
-  }
-  return JSON.parse(bodyText);
-}
 var AnthropicClient = class extends ExternalAIClient {
   name = "anthropic";
   billable = true;
@@ -957,7 +1011,7 @@ var AnthropicClient = class extends ExternalAIClient {
     }
     this._client = {
       messages: {
-        create: (kwargs) => _curlJsonPost(
+        create: (kwargs) => curlJsonPost(
           "https://api.anthropic.com/v1/messages",
           [`x-api-key: ${api_key}`, "anthropic-version: 2023-06-01"],
           kwargs
@@ -1081,7 +1135,7 @@ var OpenAIClient = class extends ExternalAIClient {
     this._client = {
       chat: {
         completions: {
-          create: (kwargs) => _curlJsonPost(
+          create: (kwargs) => curlJsonPost(
             "https://api.openai.com/v1/chat/completions",
             [`authorization: Bearer ${api_key}`],
             kwargs
@@ -1164,7 +1218,7 @@ var GeminiClient = class extends ExternalAIClient {
         "GeminiClient requires explicit api_key or injected client. Use `api_key_ref: env:GEMINI_API_KEY` in ~/.event4u/agent-config/settings/.ai-council.yml."
       );
     }
-    throw new Error("google-genai package not installed. `pip install google-genai`.");
+    this._client = geminiRestClient(api_key, opts.transport ?? curlJsonPost);
   }
   ask(system_prompt, user_prompt, max_tokens = DEFAULT_MAX_TOKENS) {
     const t0 = _nowMs();
@@ -1226,7 +1280,11 @@ var _OpenAICompatibleClient = class extends ExternalAIClient {
         `${this.constructor.name} requires explicit api_key or injected client.`
       );
     }
-    throw new Error("openai package not installed. `pip install openai`.");
+    this._client = openAiCompatibleClient(
+      opts.base_url,
+      api_key,
+      opts.transport ?? curlJsonPost
+    );
   }
   ask(system_prompt, user_prompt, max_tokens = DEFAULT_MAX_TOKENS) {
     const t0 = _nowMs();
@@ -1279,7 +1337,13 @@ var XAIClient = class extends _OpenAICompatibleClient {
   name = "xai";
   base_url = XAI_BASE_URL;
   constructor(opts = {}) {
-    super({ model: opts.model ?? DEFAULT_XAI_MODEL, client: opts.client, api_key: opts.api_key });
+    super({
+      model: opts.model ?? DEFAULT_XAI_MODEL,
+      client: opts.client,
+      api_key: opts.api_key,
+      transport: opts.transport,
+      base_url: XAI_BASE_URL
+    });
   }
 };
 var PerplexityClient = class extends _OpenAICompatibleClient {
@@ -1289,7 +1353,9 @@ var PerplexityClient = class extends _OpenAICompatibleClient {
     super({
       model: opts.model ?? DEFAULT_PERPLEXITY_MODEL,
       client: opts.client,
-      api_key: opts.api_key
+      api_key: opts.api_key,
+      transport: opts.transport,
+      base_url: PERPLEXITY_BASE_URL
     });
   }
 };
@@ -1546,7 +1612,7 @@ var CliClient = class extends ExternalAIClient {
     if (stdinPayload !== null) {
       spawnOpts.input = stdinPayload;
     }
-    const r = spawnSync(argv0, cmd.slice(1), spawnOpts);
+    const r = spawnSync2(argv0, cmd.slice(1), spawnOpts);
     if (r.error) {
       const err = r.error;
       if (r.signal === "SIGTERM" || err.code === "ETIMEDOUT") {
@@ -2636,6 +2702,89 @@ import * as fs4 from "node:fs";
 import * as os2 from "node:os";
 import * as path4 from "node:path";
 
+// src/scripts/ai_council/content_ceiling.ts
+var CONTENT_CLASSES = ["public-artifact", "project-content"];
+var DEFAULT_CONTENT_CLASS = "project-content";
+var DEFAULT_SEAT_CEILING = "project-content";
+var _SET = new Set(CONTENT_CLASSES);
+function classifyContentClass(raw, fallback = DEFAULT_CONTENT_CLASS) {
+  if (typeof raw === "string" && _SET.has(raw)) {
+    return raw;
+  }
+  return fallback;
+}
+function admitsContent(seatCeiling, contentClass) {
+  if (seatCeiling === "public-artifact" && contentClass === "project-content") {
+    return {
+      admitted: false,
+      reason: "seat ceiling is 'public-artifact'; the payload is classified 'project-content' (consumer-supplied)"
+    };
+  }
+  return { admitted: true, reason: null };
+}
+
+// src/scripts/ai_council/seat_policy.ts
+var POLICY_EXCLUSIONS = [
+  /** The provider's terms forbid this use of the route. */
+  "policy_terms",
+  /** A privacy constraint forbids sending to this route. */
+  "policy_privacy",
+  /** The route's cost property is asserted rather than proven. */
+  "policy_unproven_cost",
+  /** The route serves a model other than the one requested. */
+  "policy_model_mismatch",
+  /** 2.2 — the payload's content class exceeds the seat's ceiling. */
+  "policy_content_ceiling",
+  /** The config named an exclusion this build does not understand. */
+  "policy_unknown"
+];
+var _SET2 = new Set(POLICY_EXCLUSIONS);
+function isPolicyExclusion(v) {
+  return typeof v === "string" && _SET2.has(v);
+}
+function classifyPolicyExclusion(raw) {
+  if (raw === void 0 || raw === null) {
+    return null;
+  }
+  return isPolicyExclusion(raw) ? raw : "policy_unknown";
+}
+function policyExclusionReason(p, provider) {
+  const who = provider === void 0 ? "this seat" : provider;
+  switch (p) {
+    case "policy_terms":
+      return `${who} is excluded by policy: the route's terms forbid this use`;
+    case "policy_privacy":
+      return `${who} is excluded by policy: a privacy constraint forbids this route`;
+    case "policy_unproven_cost":
+      return `${who} is excluded by policy: the route's cost property is asserted, not proven`;
+    case "policy_model_mismatch":
+      return `${who} is excluded by policy: the route serves a model other than the one requested`;
+    case "policy_content_ceiling":
+      return `${who} is excluded by policy: the payload exceeds the seat's content ceiling`;
+    case "policy_unknown":
+      return `${who} is excluded by policy: an exclusion this build does not understand (failing closed)`;
+  }
+}
+function parseSeatFields(name, raw) {
+  const dr = raw["disabled_reason"];
+  let disabled_reason = null;
+  if (dr !== void 0 && dr !== null) {
+    if (typeof dr !== "string" || dr.trim() === "") {
+      return {
+        error: `members.${name}.disabled_reason must be a non-empty string when set (got ${JSON.stringify(dr)}).`
+      };
+    }
+    disabled_reason = dr.trim();
+  }
+  return {
+    fields: {
+      disabled_reason,
+      policy_exclusion: classifyPolicyExclusion(raw["policy_exclusion"]),
+      content_ceiling: classifyContentClass(raw["content_ceiling"], DEFAULT_SEAT_CEILING)
+    }
+  };
+}
+
 // src/scripts/ai_council/fallback_config.ts
 var SECOND_MODEL_PROVIDERS = /* @__PURE__ */ new Set([
   "anthropic",
@@ -3830,6 +3979,10 @@ function _build_member(name, cfg, default_mode = "auto", ignored = []) {
     }
     verified_at = coerced;
   }
+  const seat = parseSeatFields(name, cfg);
+  if ("error" in seat) {
+    throw new CouncilConfigError(seat.error);
+  }
   const prompt_cache_raw = _get(cfg, "prompt_cache", null);
   let prompt_cache_ttl = "5m";
   if (prompt_cache_raw !== null && prompt_cache_raw !== void 0 && !_isBool(prompt_cache_raw)) {
@@ -3857,7 +4010,8 @@ function _build_member(name, cfg, default_mode = "auto", ignored = []) {
     participate_low_impact: participate_raw,
     tier,
     prompt_cache_ttl,
-    verified_at
+    verified_at,
+    ...seat.fields
   };
 }
 var DEFAULT_CLI_CALLS_PER_DAY2 = DEFAULT_CLI_CALLS_PER_DAY;
@@ -4210,6 +4364,9 @@ export {
   hardenedSpawnEnv,
   load_cli_call_counts,
   clients_exports,
+  DEFAULT_SEAT_CEILING,
+  admitsContent,
+  policyExclusionReason,
   _RAW_KEY_PREFIXES,
   config_exports
 };