@poncho-ai/harness 0.33.0 → 0.34.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @poncho-ai/harness@0.33.0 build /home/runner/work/poncho-ai/poncho-ai/packages/harness
+> @poncho-ai/harness@0.34.0 build /home/runner/work/poncho-ai/poncho-ai/packages/harness
 > node scripts/embed-docs.js && tsup src/index.ts --format esm --dts
 
 [embed-docs] Generated poncho-docs.ts with 4 topics
@@ -8,8 +8,8 @@
 CLI tsup v8.5.1
 CLI Target: es2022
 ESM Build start
-ESM dist/index.js 334.17 KB
-ESM ⚡️ Build success in 152ms
+ESM dist/index.js 336.31 KB
+ESM ⚡️ Build success in 164ms
 DTS Build start
-DTS ⚡️ Build success in 7104ms
-DTS dist/index.d.ts 33.55 KB
+DTS ⚡️ Build success in 7760ms
+DTS dist/index.d.ts 33.99 KB

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @poncho-ai/harness
 
+## 0.34.0
+
+### Minor Changes
+
+- [`3f096f2`](https://github.com/cesr/poncho-ai/commit/3f096f28b9ab797b52f1b725778976929156cce9) Thanks [@cesr](https://github.com/cesr)! - fix: scope MCP tools to skills via server-level claiming
+
+  MCP tools from configured servers are now globally available by default. When a skill claims any tool from a server via `allowed-tools`, the entire server becomes skill-managed — its tools are only available when the claiming skill is active (or declared in AGENT.md `allowed-tools`).
+
+## 0.33.1
+
+### Patch Changes
+
+- [`d8fe87c`](https://github.com/cesr/poncho-ai/commit/d8fe87c68d42878829422750f98e3c70a425e3e3) Thanks [@cesr](https://github.com/cesr)! - fix: OTLP trace exporter reliability and error visibility
+  - Use provider instance directly instead of global `trace.getTracer()` to avoid silent failure when another library registers a tracer provider first
+  - Append `/v1/traces` to base OTLP endpoints so users can pass either the base URL or the full signal-specific URL
+  - Surface HTTP status code and response body on export failures
+  - Enable OTel diagnostic logger at WARN level for internal SDK errors
+
 ## 0.33.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -759,6 +759,14 @@ declare class AgentHarness {
     private getAgentScriptIntent;
     private getAgentMcpApprovalPatterns;
     private getAgentScriptApprovalPatterns;
+    /**
+     * Return the set of MCP server names that have at least one tool claimed by
+     * any loaded skill's `allowedTools.mcp`.  When ANY skill claims tools from a
+     * server, the entire server is considered "skill-managed" — none of its tools
+     * are auto-exposed globally; only explicitly declared tools become available
+     * (via agent-level allowed-tools or active skill allowed-tools).
+     */
+    private getSkillManagedMcpServers;
     private getRequestedMcpPatterns;
     private getRequestedScriptPatterns;
     private getRequestedMcpApprovalPatterns;

package/dist/index.js

@@ -882,6 +882,7 @@ Connect your Poncho agent to messaging platforms so it responds to @mentions.
 1. Go to [api.slack.com/apps](https://api.slack.com/apps) and create a new app "From scratch"
 2. Under **OAuth & Permissions**, add these Bot Token Scopes:
    - \`app_mentions:read\`
+   - \`channels:history\` (needed to fetch thread context when mentioned in a reply)
    - \`chat:write\`
    - \`reactions:write\`
 3. Under **Event Subscriptions**, enable events:
@@ -5343,7 +5344,7 @@ var createSubagentTools = (manager) => [
 ];
 
 // src/harness.ts
-import { trace, context as otelContext, SpanStatusCode, SpanKind } from "@opentelemetry/api";
+import { trace, context as otelContext, SpanStatusCode, SpanKind, diag, DiagConsoleLogger, DiagLogLevel } from "@opentelemetry/api";
 import { NodeTracerProvider, BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 
@@ -5357,10 +5358,15 @@ function sanitizeEventForLog(event) {
     return value;
   });
 }
+var TRACES_PATH = "/v1/traces";
+function ensureTracesPath(url) {
+  if (url.endsWith(TRACES_PATH)) return url;
+  return url.replace(/\/+$/, "") + TRACES_PATH;
+}
 function normalizeOtlp(opt) {
   if (!opt) return void 0;
-  if (typeof opt === "string") return opt ? { url: opt } : void 0;
-  return opt.url ? opt : void 0;
+  if (typeof opt === "string") return opt ? { url: ensureTracesPath(opt) } : void 0;
+  return opt.url ? { ...opt, url: ensureTracesPath(opt.url) } : void 0;
 }
 var TelemetryEmitter = class {
   config;
@@ -5414,7 +5420,10 @@ var TelemetryEmitter = class {
           ]
         })
       });
-    } catch {
+    } catch (err) {
+      console.warn(
+        `[poncho][telemetry] OTLP log delivery failed: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
   }
 };
@@ -5507,6 +5516,16 @@ var ToolDispatcher = class {
 };
 
 // src/harness.ts
+function formatOtlpError(err) {
+  if (!(err instanceof Error)) return String(err);
+  const parts = [];
+  const code = err.code;
+  if (code != null) parts.push(`HTTP ${code}`);
+  if (err.message) parts.push(err.message);
+  const data = err.data;
+  if (data) parts.push(data);
+  return parts.join(" \u2014 ") || "unknown error";
+}
 var now = () => Date.now();
 var FIRST_CHUNK_TIMEOUT_MS = 9e4;
 var MAX_TRANSIENT_STEP_RETRIES = 1;
@@ -6283,6 +6302,25 @@ var AgentHarness = class _AgentHarness {
   getAgentScriptApprovalPatterns() {
     return this.parsedAgent?.frontmatter.approvalRequired?.scripts ?? [];
   }
+  /**
+   * Return the set of MCP server names that have at least one tool claimed by
+   * any loaded skill's `allowedTools.mcp`.  When ANY skill claims tools from a
+   * server, the entire server is considered "skill-managed" — none of its tools
+   * are auto-exposed globally; only explicitly declared tools become available
+   * (via agent-level allowed-tools or active skill allowed-tools).
+   */
+  getSkillManagedMcpServers() {
+    const servers = /* @__PURE__ */ new Set();
+    for (const skill of this.loadedSkills) {
+      for (const pattern of skill.allowedTools.mcp) {
+        const slash = pattern.indexOf("/");
+        if (slash > 0) {
+          servers.add(pattern.slice(0, slash));
+        }
+      }
+    }
+    return servers;
+  }
   getRequestedMcpPatterns() {
     const patterns = new Set(this.getAgentMcpIntent());
     for (const skillName of this.activeSkillNames) {
@@ -6294,6 +6332,17 @@ var AgentHarness = class _AgentHarness {
         patterns.add(pattern);
       }
     }
+    if (this.mcpBridge) {
+      const managedServers = this.getSkillManagedMcpServers();
+      const discoveredTools = this.mcpBridge.listDiscoveredTools();
+      for (const toolName of discoveredTools) {
+        const slash = toolName.indexOf("/");
+        const serverName = slash > 0 ? toolName.slice(0, slash) : toolName;
+        if (!managedServers.has(serverName)) {
+          patterns.add(toolName);
+        }
+      }
+    }
     return [...patterns];
   }
   getRequestedScriptPatterns() {
@@ -6603,6 +6652,7 @@ var AgentHarness = class _AgentHarness {
     const telemetryEnabled = config?.telemetry?.enabled !== false;
     const otlpConfig = telemetryEnabled ? normalizeOtlp(config?.telemetry?.otlp) : void 0;
     if (otlpConfig) {
+      diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.WARN);
       const exporter = new OTLPTraceExporter({
         url: otlpConfig.url,
         headers: otlpConfig.headers
@@ -6615,7 +6665,7 @@ var AgentHarness = class _AgentHarness {
       provider2.register();
       this.otlpTracerProvider = provider2;
       this.hasOtlpExporter = true;
-      console.info(`[poncho][telemetry] OTLP exporter active \u2192 ${otlpConfig.url}`);
+      console.info(`[poncho][telemetry] OTLP trace exporter active \u2192 ${otlpConfig.url}`);
     }
   }
   async buildBrowserStoragePersistence(config, sessionId) {
@@ -6761,17 +6811,13 @@ var AgentHarness = class _AgentHarness {
     await this.mcpBridge?.stopLocalServers();
     if (this.otlpSpanProcessor) {
       await this.otlpSpanProcessor.shutdown().catch((err) => {
-        console.warn(
-          `[poncho][telemetry] OTLP span processor shutdown error: ${err instanceof Error ? err.message : String(err)}`
-        );
+        console.warn(`[poncho][telemetry] OTLP span processor shutdown error: ${formatOtlpError(err)}`);
       });
       this.otlpSpanProcessor = void 0;
     }
     if (this.otlpTracerProvider) {
       await this.otlpTracerProvider.shutdown().catch((err) => {
-        console.warn(
-          `[poncho][telemetry] OTLP tracer provider shutdown error: ${err instanceof Error ? err.message : String(err)}`
-        );
+        console.warn(`[poncho][telemetry] OTLP tracer provider shutdown error: ${formatOtlpError(err)}`);
       });
       this.otlpTracerProvider = void 0;
     }
@@ -6785,8 +6831,8 @@ var AgentHarness = class _AgentHarness {
    * child spans (LLM calls via AI SDK, tool execution) group under one trace.
    */
   async *runWithTelemetry(input) {
-    if (this.hasOtlpExporter) {
-      const tracer = trace.getTracer("gen_ai");
+    if (this.hasOtlpExporter && this.otlpTracerProvider) {
+      const tracer = this.otlpTracerProvider.getTracer("gen_ai");
       const agentName = this.parsedAgent?.frontmatter.name ?? "agent";
       const rootSpan = tracer.startSpan(`invoke_agent ${agentName}`, {
         kind: SpanKind.INTERNAL,
@@ -6815,7 +6861,9 @@ var AgentHarness = class _AgentHarness {
         rootSpan.end();
         try {
           await this.otlpSpanProcessor?.forceFlush();
-        } catch {
+        } catch (err) {
+          const detail = formatOtlpError(err);
+          console.warn(`[poncho][telemetry] OTLP span flush failed: ${detail}`);
         }
       }
     } else {
@@ -7684,8 +7732,8 @@ ${textContent}` };
           return;
         }
         const toolSpans = /* @__PURE__ */ new Map();
-        if (this.hasOtlpExporter) {
-          const tracer = trace.getTracer("gen_ai");
+        if (this.hasOtlpExporter && this.otlpTracerProvider) {
+          const tracer = this.otlpTracerProvider.getTracer("gen_ai");
           for (const call of approvedCalls) {
             const toolDef = this.dispatcher.get(call.name);
             toolSpans.set(call.id, tracer.startSpan(`execute_tool ${call.name}`, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/harness",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "description": "Agent execution runtime - conversation loop, tool dispatch, streaming",
   "repository": {
     "type": "git",

package/src/harness.ts

@@ -37,10 +37,22 @@ import { createSkillTools, normalizeScriptPolicyPath } from "./skill-tools.js";
 import { createSearchTools } from "./search-tools.js";
 import { createSubagentTools } from "./subagent-tools.js";
 import type { SubagentManager } from "./subagent-manager.js";
-import { trace, context as otelContext, SpanStatusCode, SpanKind } from "@opentelemetry/api";
+import { trace, context as otelContext, SpanStatusCode, SpanKind, diag, DiagConsoleLogger, DiagLogLevel } from "@opentelemetry/api";
 import { NodeTracerProvider, BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { normalizeOtlp } from "./telemetry.js";
+
+/** Extract useful details from OTLPExporterError (has .code + .data) or plain Error. */
+function formatOtlpError(err: unknown): string {
+  if (!(err instanceof Error)) return String(err);
+  const parts: string[] = [];
+  const code = (err as { code?: number }).code;
+  if (code != null) parts.push(`HTTP ${code}`);
+  if (err.message) parts.push(err.message);
+  const data = (err as { data?: string }).data;
+  if (data) parts.push(data);
+  return parts.join(" — ") || "unknown error";
+}
 import {
   isSiblingScriptsPattern,
   matchesRelativeScriptPattern,
@@ -983,8 +995,30 @@ export class AgentHarness {
     return this.parsedAgent?.frontmatter.approvalRequired?.scripts ?? [];
   }
 
+  /**
+   * Return the set of MCP server names that have at least one tool claimed by
+   * any loaded skill's `allowedTools.mcp`.  When ANY skill claims tools from a
+   * server, the entire server is considered "skill-managed" — none of its tools
+   * are auto-exposed globally; only explicitly declared tools become available
+   * (via agent-level allowed-tools or active skill allowed-tools).
+   */
+  private getSkillManagedMcpServers(): Set<string> {
+    const servers = new Set<string>();
+    for (const skill of this.loadedSkills) {
+      for (const pattern of skill.allowedTools.mcp) {
+        const slash = pattern.indexOf("/");
+        if (slash > 0) {
+          servers.add(pattern.slice(0, slash));
+        }
+      }
+    }
+    return servers;
+  }
+
   private getRequestedMcpPatterns(): string[] {
     const patterns = new Set<string>(this.getAgentMcpIntent());
+
+    // Add patterns from active skills.
     for (const skillName of this.activeSkillNames) {
       const skill = this.loadedSkills.find((entry) => entry.name === skillName);
       if (!skill) {
@@ -994,6 +1028,26 @@ export class AgentHarness {
         patterns.add(pattern);
       }
     }
+
+    // MCP servers whose tools are NOT claimed by any skill are "unmanaged" —
+    // all their discovered tools are globally available so that configuring a
+    // server in poncho.config.js makes its tools accessible by default.
+    //
+    // Once ANY skill claims tools from a server (even a single tool), that
+    // server becomes "skill-managed" and ALL of its tools require explicit
+    // declaration (agent-level or active-skill) to be available.
+    if (this.mcpBridge) {
+      const managedServers = this.getSkillManagedMcpServers();
+      const discoveredTools = this.mcpBridge.listDiscoveredTools();
+      for (const toolName of discoveredTools) {
+        const slash = toolName.indexOf("/");
+        const serverName = slash > 0 ? toolName.slice(0, slash) : toolName;
+        if (!managedServers.has(serverName)) {
+          patterns.add(toolName);
+        }
+      }
+    }
+
     return [...patterns];
   }
 
@@ -1346,6 +1400,7 @@ export class AgentHarness {
     const telemetryEnabled = config?.telemetry?.enabled !== false;
     const otlpConfig = telemetryEnabled ? normalizeOtlp(config?.telemetry?.otlp) : undefined;
     if (otlpConfig) {
+      diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.WARN);
       const exporter = new OTLPTraceExporter({
         url: otlpConfig.url,
         headers: otlpConfig.headers,
@@ -1358,7 +1413,7 @@ export class AgentHarness {
       provider.register();
       this.otlpTracerProvider = provider;
       this.hasOtlpExporter = true;
-      console.info(`[poncho][telemetry] OTLP exporter active → ${otlpConfig.url}`);
+      console.info(`[poncho][telemetry] OTLP trace exporter active → ${otlpConfig.url}`);
     }
   }
 
@@ -1523,21 +1578,13 @@ export class AgentHarness {
     await this.mcpBridge?.stopLocalServers();
     if (this.otlpSpanProcessor) {
       await this.otlpSpanProcessor.shutdown().catch((err) => {
-        console.warn(
-          `[poncho][telemetry] OTLP span processor shutdown error: ${
-            err instanceof Error ? err.message : String(err)
-          }`,
-        );
+        console.warn(`[poncho][telemetry] OTLP span processor shutdown error: ${formatOtlpError(err)}`);
       });
       this.otlpSpanProcessor = undefined;
     }
     if (this.otlpTracerProvider) {
       await this.otlpTracerProvider.shutdown().catch((err) => {
-        console.warn(
-          `[poncho][telemetry] OTLP tracer provider shutdown error: ${
-            err instanceof Error ? err.message : String(err)
-          }`,
-        );
+        console.warn(`[poncho][telemetry] OTLP tracer provider shutdown error: ${formatOtlpError(err)}`);
       });
       this.otlpTracerProvider = undefined;
     }
@@ -1553,8 +1600,8 @@ export class AgentHarness {
    * child spans (LLM calls via AI SDK, tool execution) group under one trace.
    */
   async *runWithTelemetry(input: RunInput): AsyncGenerator<AgentEvent> {
-    if (this.hasOtlpExporter) {
-      const tracer = trace.getTracer("gen_ai");
+    if (this.hasOtlpExporter && this.otlpTracerProvider) {
+      const tracer = this.otlpTracerProvider.getTracer("gen_ai");
       const agentName = this.parsedAgent?.frontmatter.name ?? "agent";
 
       const rootSpan = tracer.startSpan(`invoke_agent ${agentName}`, {
@@ -1586,7 +1633,10 @@ export class AgentHarness {
         rootSpan.end();
         try {
           await this.otlpSpanProcessor?.forceFlush();
-        } catch { /* best-effort */ }
+        } catch (err: unknown) {
+          const detail = formatOtlpError(err);
+          console.warn(`[poncho][telemetry] OTLP span flush failed: ${detail}`);
+        }
       }
     } else {
       yield* this.run(input);
@@ -2642,8 +2692,8 @@ ${boundedMainMemory.trim()}`
       // OTel GenAI execute_tool spans for tool call visibility in traces
       type OtelSpan = ReturnType<ReturnType<typeof trace.getTracer>["startSpan"]>;
       const toolSpans = new Map<string, OtelSpan>();
-      if (this.hasOtlpExporter) {
-        const tracer = trace.getTracer("gen_ai");
+      if (this.hasOtlpExporter && this.otlpTracerProvider) {
+        const tracer = this.otlpTracerProvider.getTracer("gen_ai");
         for (const call of approvedCalls) {
           const toolDef = this.dispatcher.get(call.name);
           toolSpans.set(call.id, tracer.startSpan(`execute_tool ${call.name}`, {

package/src/telemetry.ts

@@ -18,10 +18,26 @@ export interface OtlpConfig {
 
 export type OtlpOption = string | OtlpConfig;
 
+const TRACES_PATH = "/v1/traces";
+
+/**
+ * Ensures the OTLP URL points to the trace-ingest endpoint.
+ *
+ * Users typically configure the *base* OTLP endpoint (e.g.
+ * `https://gateway.example.com/api/v1/otlp`) but `OTLPTraceExporter` uses
+ * the `url` constructor option as-is — it only appends `/v1/traces`
+ * automatically when reading from the `OTEL_EXPORTER_OTLP_ENDPOINT` env var.
+ * Without this fixup traces are POSTed to the wrong path and silently lost.
+ */
+function ensureTracesPath(url: string): string {
+  if (url.endsWith(TRACES_PATH)) return url;
+  return url.replace(/\/+$/, "") + TRACES_PATH;
+}
+
 export function normalizeOtlp(opt: OtlpOption | undefined): OtlpConfig | undefined {
   if (!opt) return undefined;
-  if (typeof opt === "string") return opt ? { url: opt } : undefined;
-  return opt.url ? opt : undefined;
+  if (typeof opt === "string") return opt ? { url: ensureTracesPath(opt) } : undefined;
+  return opt.url ? { ...opt, url: ensureTracesPath(opt.url) } : undefined;
 }
 
 export interface TelemetryConfig {
@@ -87,8 +103,12 @@ export class TelemetryEmitter {
           ],
         }),
       });
-    } catch {
-      // Ignore telemetry delivery failures.
+    } catch (err) {
+      console.warn(
+        `[poncho][telemetry] OTLP log delivery failed: ${
+          err instanceof Error ? err.message : String(err)
+        }`,
+      );
     }
   }
 

package/test/harness.test.ts

@@ -1037,6 +1037,360 @@ allowed-tools:
     await new Promise<void>((resolveClose) => mcpServer.close(() => resolveClose()));
   });
 
+  it("unclaimed MCP tools are globally available without allowed-tools declaration", async () => {
+    process.env.LINEAR_TOKEN = "token-123";
+    const mcpServer = createServer(async (req, res) => {
+      if (req.method === "DELETE") {
+        res.statusCode = 200;
+        res.end();
+        return;
+      }
+      const chunks: Buffer[] = [];
+      for await (const chunk of req) chunks.push(Buffer.from(chunk));
+      const body = Buffer.concat(chunks).toString("utf8");
+      const payload = body.trim().length > 0 ? (JSON.parse(body) as any) : {};
+      if (payload.method === "initialize") {
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Mcp-Session-Id", "sess");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: payload.id,
+            result: {
+              protocolVersion: "2025-03-26",
+              capabilities: { tools: { listChanged: true } },
+              serverInfo: { name: "remote", version: "1.0.0" },
+            },
+          }),
+        );
+        return;
+      }
+      if (payload.method === "notifications/initialized") {
+        res.statusCode = 202;
+        res.end();
+        return;
+      }
+      if (payload.method === "tools/list") {
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: payload.id,
+            result: {
+              tools: [
+                { name: "list_issues", inputSchema: { type: "object", properties: {} } },
+                { name: "save_issue", inputSchema: { type: "object", properties: {} } },
+              ],
+            },
+          }),
+        );
+        return;
+      }
+      res.statusCode = 404;
+      res.end();
+    });
+    await new Promise<void>((resolveOpen) => mcpServer.listen(0, () => resolveOpen()));
+    const address = mcpServer.address();
+    if (!address || typeof address === "string") throw new Error("Unexpected address");
+    const dir = await mkdtemp(join(tmpdir(), "poncho-harness-unclaimed-mcp-"));
+    // AGENT.md with no allowed-tools and no skills — MCP tools should be globally available
+    await writeFile(
+      join(dir, "AGENT.md"),
+      `---
+name: unclaimed-mcp-agent
+model:
+  provider: anthropic
+  name: claude-opus-4-5
+---
+
+# Agent with unclaimed MCP tools
+`,
+      "utf8",
+    );
+    await writeFile(
+      join(dir, "poncho.config.js"),
+      `export default {
+  mcp: [
+    {
+      name: "linear",
+      url: "http://127.0.0.1:${address.port}/mcp",
+      auth: { type: "bearer", tokenEnv: "LINEAR_TOKEN" }
+    }
+  ]
+};
+`,
+      "utf8",
+    );
+    const harness = new AgentHarness({ workingDir: dir });
+    await harness.initialize();
+    const toolNames = () => harness.listTools().map((t) => t.name);
+    // Unclaimed tools should be globally available
+    expect(toolNames()).toContain("linear/list_issues");
+    expect(toolNames()).toContain("linear/save_issue");
+    await harness.shutdown();
+    await new Promise<void>((resolveClose) => mcpServer.close(() => resolveClose()));
+  });
+
+  it("claiming any tool from a server scopes the entire server", async () => {
+    process.env.LINEAR_TOKEN = "token-123";
+    const mcpServer = createServer(async (req, res) => {
+      if (req.method === "DELETE") {
+        res.statusCode = 200;
+        res.end();
+        return;
+      }
+      const chunks: Buffer[] = [];
+      for await (const chunk of req) chunks.push(Buffer.from(chunk));
+      const body = Buffer.concat(chunks).toString("utf8");
+      const payload = body.trim().length > 0 ? (JSON.parse(body) as any) : {};
+      if (payload.method === "initialize") {
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Mcp-Session-Id", "sess");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: payload.id,
+            result: {
+              protocolVersion: "2025-03-26",
+              capabilities: { tools: { listChanged: true } },
+              serverInfo: { name: "remote", version: "1.0.0" },
+            },
+          }),
+        );
+        return;
+      }
+      if (payload.method === "notifications/initialized") {
+        res.statusCode = 202;
+        res.end();
+        return;
+      }
+      if (payload.method === "tools/list") {
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: payload.id,
+            result: {
+              tools: [
+                { name: "list_issues", inputSchema: { type: "object", properties: {} } },
+                { name: "save_issue", inputSchema: { type: "object", properties: {} } },
+                { name: "other_tool", inputSchema: { type: "object", properties: {} } },
+              ],
+            },
+          }),
+        );
+        return;
+      }
+      if (payload.method === "tools/call") {
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: payload.id,
+            result: { result: { ok: true } },
+          }),
+        );
+        return;
+      }
+      res.statusCode = 404;
+      res.end();
+    });
+    await new Promise<void>((resolveOpen) => mcpServer.listen(0, () => resolveOpen()));
+    const address = mcpServer.address();
+    if (!address || typeof address === "string") throw new Error("Unexpected address");
+    const dir = await mkdtemp(join(tmpdir(), "poncho-harness-server-scoped-"));
+    await writeFile(
+      join(dir, "AGENT.md"),
+      `---
+name: server-scoped-agent
+model:
+  provider: anthropic
+  name: claude-opus-4-5
+---
+
+# Server Scoped Agent
+`,
+      "utf8",
+    );
+    await writeFile(
+      join(dir, "poncho.config.js"),
+      `export default {
+  mcp: [
+    {
+      name: "remote",
+      url: "http://127.0.0.1:${address.port}/mcp",
+      auth: { type: "bearer", tokenEnv: "LINEAR_TOKEN" }
+    }
+  ]
+};
+`,
+      "utf8",
+    );
+    // Skill claims only 2 of the 3 tools from "remote" server
+    await mkdir(join(dir, "skills", "linear"), { recursive: true });
+    await writeFile(
+      join(dir, "skills", "linear", "SKILL.md"),
+      `---
+name: linear
+description: Linear issue tracking
+allowed-tools:
+  - mcp:remote/list_issues
+  - mcp:remote/save_issue
+---
+# Linear Skill
+`,
+      "utf8",
+    );
+    const harness = new AgentHarness({ workingDir: dir });
+    await harness.initialize();
+    const toolNames = () => harness.listTools().map((t) => t.name);
+
+    // Before activation: entire server is skill-managed, so ALL tools are hidden
+    // (even other_tool which the skill didn't explicitly claim)
+    expect(toolNames()).not.toContain("remote/list_issues");
+    expect(toolNames()).not.toContain("remote/save_issue");
+    expect(toolNames()).not.toContain("remote/other_tool");
+
+    // Activate the linear skill — only its declared tools appear
+    const activate = harness.listTools().find((t) => t.name === "activate_skill")!;
+    const deactivate = harness.listTools().find((t) => t.name === "deactivate_skill")!;
+    await activate.handler({ name: "linear" }, {} as any);
+
+    expect(toolNames()).toContain("remote/list_issues");
+    expect(toolNames()).toContain("remote/save_issue");
+    // other_tool is NOT claimed by any active skill, and the server is managed
+    expect(toolNames()).not.toContain("remote/other_tool");
+
+    // Deactivate — all tools from the managed server hidden again
+    await deactivate.handler({ name: "linear" }, {} as any);
+    expect(toolNames()).not.toContain("remote/list_issues");
+    expect(toolNames()).not.toContain("remote/save_issue");
+    expect(toolNames()).not.toContain("remote/other_tool");
+
+    await harness.shutdown();
+    await new Promise<void>((resolveClose) => mcpServer.close(() => resolveClose()));
+  });
+
+  it("wildcard skill claim scopes all tools from that server", async () => {
+    process.env.LINEAR_TOKEN = "token-123";
+    const mcpServer = createServer(async (req, res) => {
+      if (req.method === "DELETE") {
+        res.statusCode = 200;
+        res.end();
+        return;
+      }
+      const chunks: Buffer[] = [];
+      for await (const chunk of req) chunks.push(Buffer.from(chunk));
+      const body = Buffer.concat(chunks).toString("utf8");
+      const payload = body.trim().length > 0 ? (JSON.parse(body) as any) : {};
+      if (payload.method === "initialize") {
+        res.setHeader("Content-Type", "application/json");
+        res.setHeader("Mcp-Session-Id", "sess");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: payload.id,
+            result: {
+              protocolVersion: "2025-03-26",
+              capabilities: { tools: { listChanged: true } },
+              serverInfo: { name: "linear", version: "1.0.0" },
+            },
+          }),
+        );
+        return;
+      }
+      if (payload.method === "notifications/initialized") {
+        res.statusCode = 202;
+        res.end();
+        return;
+      }
+      if (payload.method === "tools/list") {
+        res.setHeader("Content-Type", "application/json");
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            id: payload.id,
+            result: {
+              tools: [
+                { name: "list_issues", inputSchema: { type: "object", properties: {} } },
+                { name: "save_issue", inputSchema: { type: "object", properties: {} } },
+                { name: "save_comment", inputSchema: { type: "object", properties: {} } },
+              ],
+            },
+          }),
+        );
+        return;
+      }
+      res.statusCode = 404;
+      res.end();
+    });
+    await new Promise<void>((resolveOpen) => mcpServer.listen(0, () => resolveOpen()));
+    const address = mcpServer.address();
+    if (!address || typeof address === "string") throw new Error("Unexpected address");
+    const dir = await mkdtemp(join(tmpdir(), "poncho-harness-wildcard-claim-"));
+    await writeFile(
+      join(dir, "AGENT.md"),
+      `---
+name: wildcard-agent
+model:
+  provider: anthropic
+  name: claude-opus-4-5
+---
+
+# Wildcard Agent
+`,
+      "utf8",
+    );
+    await writeFile(
+      join(dir, "poncho.config.js"),
+      `export default {
+  mcp: [
+    {
+      name: "linear",
+      url: "http://127.0.0.1:${address.port}/mcp",
+      auth: { type: "bearer", tokenEnv: "LINEAR_TOKEN" }
+    }
+  ]
+};
+`,
+      "utf8",
+    );
+    // Skill claims all linear tools with wildcard
+    await mkdir(join(dir, "skills", "linear"), { recursive: true });
+    await writeFile(
+      join(dir, "skills", "linear", "SKILL.md"),
+      `---
+name: linear
+description: Linear integration
+allowed-tools:
+  - mcp:linear/*
+---
+# Linear Skill
+`,
+      "utf8",
+    );
+    const harness = new AgentHarness({ workingDir: dir });
+    await harness.initialize();
+    const toolNames = () => harness.listTools().map((t) => t.name);
+
+    // None of the linear tools should be available (all claimed by wildcard)
+    expect(toolNames()).not.toContain("linear/list_issues");
+    expect(toolNames()).not.toContain("linear/save_issue");
+    expect(toolNames()).not.toContain("linear/save_comment");
+
+    // Activate the skill
+    const activate = harness.listTools().find((t) => t.name === "activate_skill")!;
+    await activate.handler({ name: "linear" }, {} as any);
+
+    // All linear tools now available
+    expect(toolNames()).toContain("linear/list_issues");
+    expect(toolNames()).toContain("linear/save_issue");
+    expect(toolNames()).toContain("linear/save_comment");
+
+    await harness.shutdown();
+    await new Promise<void>((resolveClose) => mcpServer.close(() => resolveClose()));
+  });
+
   it("supports flat tool access config format", async () => {
     const dir = await mkdtemp(join(tmpdir(), "poncho-harness-flat-tool-access-"));
     await writeFile(

package/test/telemetry.test.ts

@@ -1,5 +1,42 @@
 import { describe, expect, it, vi } from "vitest";
-import { TelemetryEmitter } from "../src/telemetry.js";
+import { TelemetryEmitter, normalizeOtlp } from "../src/telemetry.js";
+
+describe("normalizeOtlp", () => {
+  it("appends /v1/traces to a base URL string", () => {
+    expect(normalizeOtlp("https://gateway.example.com/api/v1/otlp")).toEqual({
+      url: "https://gateway.example.com/api/v1/otlp/v1/traces",
+    });
+  });
+
+  it("does not double-append when URL already ends with /v1/traces", () => {
+    expect(normalizeOtlp("https://api.honeycomb.io/v1/traces")).toEqual({
+      url: "https://api.honeycomb.io/v1/traces",
+    });
+  });
+
+  it("strips trailing slashes before appending", () => {
+    expect(normalizeOtlp("https://gateway.example.com/")).toEqual({
+      url: "https://gateway.example.com/v1/traces",
+    });
+  });
+
+  it("appends /v1/traces to object config", () => {
+    expect(
+      normalizeOtlp({
+        url: "https://gateway.example.com/otlp",
+        headers: { Authorization: "Bearer tok" },
+      }),
+    ).toEqual({
+      url: "https://gateway.example.com/otlp/v1/traces",
+      headers: { Authorization: "Bearer tok" },
+    });
+  });
+
+  it("returns undefined for falsy input", () => {
+    expect(normalizeOtlp(undefined)).toBeUndefined();
+    expect(normalizeOtlp("")).toBeUndefined();
+  });
+});
 
 describe("telemetry emitter", () => {
   it("delegates to custom handler when configured", async () => {
@@ -14,7 +51,7 @@ describe("telemetry emitter", () => {
     global.fetch = vi.fn().mockRejectedValue(new Error("network down"));
 
     const emitter = new TelemetryEmitter({
-      otlp: "https://otel.example.com/v1/logs",
+      otlp: "https://otel.example.com/v1/traces",
     });
 
     await expect(