@yagni-app/code 1.0.6 → 1.0.7

package/dist/goHeadless.d.ts

@@ -65,7 +65,7 @@ export declare function buildHeadlessChildEnv(opts: {
     workspaceId?: string;
     cliVersion?: string;
     sessionId?: string;
-    /** Resolved OTel export config; stage children load pi-otel when present. */
+    /** Resolved OTel export config; stage children export when present. */
     otel?: OtelLaunchConfig;
 }): NodeJS.ProcessEnv;
 /**

package/dist/goHeadless.js

@@ -55,8 +55,8 @@ export function buildHeadlessChildEnv(opts) {
         PI_CODING_AGENT_DIR: piAgentDir,
         PI_SKIP_VERSION_CHECK: "1",
         PI_TELEMETRY: "0",
-        // OTel export: pin metadata-only capture and forward pi-otel's path so
-        // every stage child spawns with it (see otel.ts for the policy).
+        // OTel export: the gate plus the OTLP env, inherited by every stage child
+        // (see otel.ts for the policy).
         ...(opts.otel ? otelChildEnv(opts.otel, opts.baseEnv) : {}),
     };
 }

package/dist/launch.d.ts

@@ -95,9 +95,10 @@ export interface BuildLaunchOptions {
     extraEnv?: Record<string, string>;
     /**
      * Resolved OTel export config (see `otel.ts`). When present, the session
-     * loads pi-otel alongside our extension and the env pins metadata-only
-     * capture; absent means no OTLP endpoint is configured and the launch is
-     * byte-for-byte what it was before OTel support existed.
+     * env carries the export gate and the OTLP variables and the bundled
+     * extension exports traces, metrics, and log events; absent means no OTLP
+     * endpoint is configured and the launch is byte-for-byte what it was
+     * before OTel support existed.
      */
     otel?: OtelLaunchConfig;
 }

package/dist/launch.js

@@ -9,6 +9,7 @@ import { randomUUID } from "node:crypto";
 import { agentDirEnvVar } from "./branding.js";
 import { otelChildEnv } from "./otel.js";
 import { PAD_X_ENV, resolvePadX } from "./padding.js";
+import { resolveCliPath } from "./paths.js";
 import { ENGINEERING_PRACTICE_SECTION, promptEnrichmentDisabled } from "./promptEnrichment.js";
 /**
  * How close to expiry the token can be before launch warns. A coding session
@@ -76,6 +77,9 @@ export function buildLaunch(creds, passthroughArgs, opts) {
         // the launcher read (0600). Absent when the caller can't resolve it.
         ...(opts.profilePath ? { YAGNI_PROFILE_PATH: opts.profilePath } : {}),
         ...(opts.stateDir ? { YAGNI_CODE_HOME: opts.stateDir } : {}),
+        // The launcher's own entry, so the in-session /plugin panel and
+        // /reload-plugins can run `yagni plugin …` with the same binary.
+        YAGNI_CLI_PATH: resolveCliPath(),
         // Forward the launcher's version so the extension's crash reports carry
         // the shipping version (the bundled extension has no package.json to read).
         ...(opts.cliVersion ? { YAGNI_CODE_VERSION: opts.cliVersion } : {}),
@@ -106,9 +110,9 @@ export function buildLaunch(creds, passthroughArgs, opts) {
         // the editor (which the launcher pads by seeding editorPaddingX). The
         // footer can't read pi's settings, so the value crosses over env.
         [PAD_X_ENV]: String(resolvePadX()),
-        // OTel export (gated in otel.ts): pin metadata-only capture and forward
-        // pi-otel's path so /go stage children and subagents load it too. Placed
-        // after baseEnv on purpose — the capture pin must beat a user env override.
+        // OTel export (gated in otel.ts): the YAGNI_OTEL_EXPORT gate plus the
+        // workspace's OTLP env; the bundled extension does the exporting, and
+        // /go stage children and subagents inherit this env so they export too.
         ...(opts.otel ? otelChildEnv(opts.otel, opts.baseEnv ?? {}) : {}),
     };
     // Always load our extension. Default the provider to `yagni` unless the user
@@ -130,7 +134,6 @@ export function buildLaunch(creds, passthroughArgs, opts) {
     const argv = [
         "-e",
         opts.extensionPath,
-        ...(opts.otel ? ["-e", opts.otel.extensionPath] : []),
         ...(userChoseProvider ? [] : ["--provider", "yagni"]),
         ...(userChoseModel ? [] : ["--model", "advanced"]),
         ...(enrichmentOff ? [] : ["--append-system-prompt", ENGINEERING_PRACTICE_SECTION]),

package/dist/mcpCommand.d.ts

@@ -22,6 +22,12 @@ export interface McpDeps {
     stderr?: (text: string) => void;
     /** Test seam: the extension module to import (defaults to the built copy). */
     loadMcpModule?: () => Promise<McpCliModule>;
+    /**
+     * Test seam: the plugin MCP payload the launcher would hand a session
+     * (defaults to running the real, non-interactive discovery). Lets `list`
+     * and `get` show plugin-bundled servers outside a session.
+     */
+    pluginMcpEnv?: () => Promise<string | undefined>;
     /** Test seam: health probe override (defaults to mod.probeServer). */
     probeServer?: (name: string, config: unknown, opts?: {
         env?: NodeJS.ProcessEnv;
@@ -73,12 +79,15 @@ export interface McpCliModule {
         missingVars: string[];
     };
 }
+export type McpListScope = "user" | "project" | "local" | "plugin";
 export interface McpLoadResult {
     servers: {
         name: string;
-        scope: "user" | "project" | "local";
+        scope: McpListScope;
         config: Record<string, unknown>;
         sourcePath: string;
+        plugin?: string;
+        gated?: boolean;
     }[];
     errors: {
         sourcePath: string;

package/dist/mcpCommand.js

@@ -18,7 +18,10 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { CLAUDE_PLUGIN_MCP_ENV, claudeCompatArgs } from "./claudeCompat.js";
+import { agentDir } from "./credentials.js";
 import { DISTRIBUTION } from "./distribution.js";
+import { getActiveProfileName } from "./profiles.js";
 export function resolveMcpConfigPath() {
     const bundled = fileURLToPath(new URL("./extension/mcp/cliConfig.js", import.meta.url));
     if (existsSync(bundled))
@@ -229,6 +232,25 @@ function describeScopePath(scope, cwd) {
         return join(cwd, ".mcp.json");
     return "~/.yagni-code/mcp.json";
 }
+/** The plugin MCP payload for `cwd`, computed the way a launch would (trust respected, never prompting). */
+async function defaultPluginMcpEnv(cwd) {
+    try {
+        const profile = await getActiveProfileName();
+        const compat = await claudeCompatArgs({ cwd, agentDir: agentDir(profile), interactive: false });
+        return compat.env[CLAUDE_PLUGIN_MCP_ENV];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** `list`/`get` see plugin servers even outside a session: merge the payload into the env they load with. */
+async function envWithPluginMcp(deps, cwd) {
+    const base = deps.env ?? process.env;
+    if (base[CLAUDE_PLUGIN_MCP_ENV])
+        return base;
+    const payload = await (deps.pluginMcpEnv ?? defaultPluginMcpEnv)(cwd);
+    return payload ? { ...base, [CLAUDE_PLUGIN_MCP_ENV]: payload } : base;
+}
 export async function mcpCommand(args, deps = {}) {
     const stdout = deps.stdout ?? ((t) => process.stdout.write(t));
     const stderr = deps.stderr ?? ((t) => process.stderr.write(t));
@@ -261,9 +283,9 @@ export async function mcpCommand(args, deps = {}) {
         case "remove":
             return mcpRemove(mod, parsed, { cwd, stdout, stderr });
         case "list":
-            return mcpList(mod, { cwd, stdout, stderr, env: deps.env ?? process.env, probeServer: deps.probeServer });
+            return mcpList(mod, { cwd, stdout, stderr, env: await envWithPluginMcp(deps, cwd), probeServer: deps.probeServer });
         case "get":
-            return mcpGet(mod, parsed, { cwd, stdout, stderr, env: deps.env ?? process.env, probeServer: deps.probeServer });
+            return mcpGet(mod, parsed, { cwd, stdout, stderr, env: await envWithPluginMcp(deps, cwd), probeServer: deps.probeServer });
         case "reset-project-choices":
             return mcpResetChoices(mod, { cwd, stdout, stderr });
         case "add-from-claude":
@@ -548,6 +570,8 @@ async function mcpGet(mod, parsed, io) {
     }
     io.stdout(`${name}:\n`);
     io.stdout(`  Scope: ${scopeLabel(server.scope)}\n`);
+    if (server.plugin)
+        io.stdout(`  Plugin: ${server.plugin}\n`);
     const config = server.config;
     if (config["type"] === "http" || config["type"] === "sse") {
         io.stdout(`  Type: ${config["type"]}\n`);
@@ -567,14 +591,19 @@ async function mcpGet(mod, parsed, io) {
             io.stdout(`  Env: ${key}=${value}\n`);
         }
     }
-    if (server.scope === "project") {
+    if (server.scope === "project" || server.gated) {
         const { state } = mod.readProjectApproval(mod.resolveProjectRoot(io.cwd));
         const decision = mod.decisionFor(state, name);
         io.stdout(`  Approved: ${decision === "enabled" ? "yes" : decision === "disabled" ? "no" : "not yet decided"}\n`);
     }
     io.stdout(`  Config file: ${server.sourcePath}\n`);
     io.stdout(await healthLine(mod, server, io));
-    io.stdout(`\nTo remove this server, run: ${DISTRIBUTION.commandName} mcp remove "${name}"\n`);
+    if (server.scope === "plugin") {
+        io.stdout(`\nThis server is bundled with plugin ${server.plugin}; remove it with: ${DISTRIBUTION.commandName} plugin uninstall "${server.plugin}"\n`);
+    }
+    else {
+        io.stdout(`\nTo remove this server, run: ${DISTRIBUTION.commandName} mcp remove "${name}"\n`);
+    }
     return 0;
 }
 function printOAuthDetail(mod, name, config, stdout) {
@@ -590,7 +619,7 @@ function printOAuthDetail(mod, name, config, stdout) {
 async function healthLine(mod, server, io) {
     // Approval gate: an undecided/disabled project server is reported WITHOUT
     // connecting (fail-closed — never spawn an unapproved process).
-    if (server.scope === "project") {
+    if (server.scope === "project" || server.gated) {
         const { state } = mod.readProjectApproval(mod.resolveProjectRoot(io.cwd));
         const decision = mod.decisionFor(state, server.name);
         if (decision === "disabled")
@@ -613,17 +642,18 @@ async function mcpList(mod, io) {
         return 0;
     }
     const lines = [];
-    const byScope = { user: [], project: [], local: [] };
+    const byScope = { user: [], project: [], local: [], plugin: [] };
     for (const s of servers)
         (byScope[s.scope] ??= []).push(s);
-    for (const scope of ["local", "project", "user"]) {
+    const labels = { local: "Local", project: "Project", user: "User", plugin: "Plugin" };
+    for (const scope of ["local", "project", "user", "plugin"]) {
         const group = byScope[scope];
         if (!group?.length)
             continue;
-        lines.push(`${scope === "local" ? "Local" : scope === "project" ? "Project" : "User"} servers:`);
+        lines.push(`${labels[scope]} servers:`);
         for (const s of group) {
             const status = await listHealthLine(mod, s, io);
-            lines.push(`  ${s.name} · ${status}`);
+            lines.push(`  ${s.name}${s.plugin ? ` (${s.plugin})` : ""} · ${status}`);
         }
     }
     for (const err of errors)
@@ -634,7 +664,7 @@ async function mcpList(mod, io) {
     return 0;
 }
 async function listHealthLine(mod, server, io) {
-    if (server.scope === "project") {
+    if (server.scope === "project" || server.gated) {
         const { state } = mod.readProjectApproval(mod.resolveProjectRoot(io.cwd));
         const decision = mod.decisionFor(state, server.name);
         if (decision === "disabled")
@@ -654,6 +684,8 @@ function scopeLabel(scope) {
         return "Local config (private to you in this project)";
     if (scope === "project")
         return "Project config (shared via .mcp.json)";
+    if (scope === "plugin")
+        return "Plugin (bundled with an installed plugin)";
     return "User config (available in all your projects)";
 }
 function mcpResetChoices(mod, io) {

package/dist/otel.d.ts

@@ -1,69 +1,55 @@
 /**
- * OTel export wiring (Updater pilot ask): bake the `pi-otel` extension into
- * every launch so a workspace can stream session traces — token usage, cost,
- * model tier, tool calls — to its own OTLP collector (e.g. Datadog) without
- * anyone hand-installing an extension.
+ * OTel export gate (Updater pilot ask, now Claude Code parity): decide
+ * whether a launch streams session telemetry — traces, metrics, and log
+ * events — to the workspace's own OTLP collector (Datadog, Grafana, an
+ * in-house collector), and hand the session the standard OpenTelemetry env
+ * it needs. The exporter itself lives in the bundled extension
+ * (`pi-extension-yagni/src/telemetry`), so there is nothing extra to load and
+ * nothing that can go missing on a customer's `npm install`.
  *
- * Three deliberate policies, all enforced here rather than left to defaults:
+ * Three deliberate policies, enforced here rather than left to defaults:
  *
- * 1. GATED, not always-on. pi-otel ships `enabled: true` pointed at
- *    `localhost:4317`, so loading it unconditionally would have every session
- *    probing a collector nobody runs. We only pass the extension to pi when an
- *    OTLP endpoint is actually configured: `OTEL_EXPORTER_OTLP_ENDPOINT` in the
- *    environment, or `otel.endpoint` in the repo's committed `.pi/settings.json`
- *    (the file pi-otel itself reads, so teams can configure once per repo).
+ * 1. GATED, not always-on. Nothing exports unless an OTLP destination is
+ *    configured: the user's own OTEL_* env, the workspace's admin-set config
+ *    (fetched fail-soft and cached), or the repo's committed
+ *    `.pi/settings.json`. The gate result travels to the session as
+ *    `YAGNI_OTEL_EXPORT=1` plus the OTLP variables; children (/go stages,
+ *    subagents) inherit the env and export too.
  *
- * 2. METADATA-ONLY, enforced. Cost, tokens, model, finish reasons and tool-call
- *    ids export; prompt and response text never do. `PI_OTEL_CAPTURE_CONTENT`
- *    is pinned in the child env, and env beats settings in pi-otel's own
- *    precedence — a repo settings file asking for "full" is overridden, not
- *    honored. Session content leaving the machine is a contract change, not a
- *    config knob.
+ * 2. METADATA-ONLY, in code. Token counts, cost, tier, durations, tool names,
+ *    and sizes export; prompt, response, and tool content never do. The
+ *    extension enforces this without a knob — no env var re-enables content.
  *
- * 3. Cost is the customer's SELL rate. pi-otel exports pi's `usage.cost.total`
- *    verbatim (as `pi.cost.usd`), and pi computes that from the catalog's
- *    tier rates (YAG-381) — so the collector sees contracted prices, and the
- *    exported model name is the opaque tier id, never the backing model.
+ * 3. Cost is the customer's SELL rate. Usage cost is pi's `usage.cost.total`,
+ *    computed from the catalog's tier rates (YAG-381), and the exported model
+ *    name is the opaque tier id, never the backing model.
  *
- * Everything here is fail-soft: telemetry must never block a launch, so a
- * missing package or unreadable settings file resolves to "disabled".
+ * Everything here is fail-soft: telemetry must never block a launch, so an
+ * unreadable settings file or an offline backend resolves to "disabled" or
+ * to last-known config.
  */
 import { readFileSync } from "node:fs";
-/**
- * Env var carrying the resolved pi-otel entry path to /go stage children and
- * subagents: they build their own pi argv inside pi-extension-yagni (which
- * cannot import this package), so the path crosses over env. The extension
- * reads the same literal in `pipeline/runner.ts`.
- */
-export declare const OTEL_EXTENSION_PATH_ENV = "YAGNI_OTEL_EXTENSION_PATH";
+/** The launcher's "this session exports" gate, read by the bundled extension. */
+export declare const OTEL_EXPORT_ENV = "YAGNI_OTEL_EXPORT";
 /** The service name a collector sees unless the user set their own. */
 export declare const DEFAULT_OTEL_SERVICE_NAME = "yagni-code";
+/** The standard per-signal endpoint variables, generic first (its precedence). */
+declare const ENDPOINT_ENV_VARS: readonly ["OTEL_EXPORTER_OTLP_ENDPOINT", "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", "OTEL_EXPORTER_OTLP_METRICS_ENDPOINT", "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT"];
+export type EndpointEnvVar = (typeof ENDPOINT_ENV_VARS)[number];
 export interface OtelLaunchConfig {
-    /** Absolute path to pi-otel's extension entry. */
-    extensionPath: string;
     /**
-     * Where the enablement signal came from. "workspace" additionally carries
-     * protocol/headers/serviceName, delivered as env to the session; "env" may
-     * carry a protocol when the endpoint arrived via the per-signal
-     * `OTEL_EXPORTER_OTLP_TRACES_(ENDPOINT|PROTOCOL)` bridge (pi-otel reads only
-     * the generic var, so the child env translates); "project-settings" leaves
-     * those to whatever the user/repo already configured.
+     * Where the enablement signal came from. "workspace" and "project-settings"
+     * carry endpoint/protocol/headers/serviceName that the launcher delivers as
+     * env; "env" is the user's own setup, passed through untouched.
      */
     source: "env" | "workspace" | "project-settings";
-    /**
-     * The env var the endpoint actually came from — the generic
-     * `OTEL_EXPORTER_OTLP_ENDPOINT` or the per-signal
-     * `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`. Doctor surfaces it so a user who set
-     * the per-signal var sees their own var named, not the generic one.
-     */
-    envVar?: "OTEL_EXPORTER_OTLP_ENDPOINT" | "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT";
-    /** The configured OTLP endpoint (for doctor display; env for workspace source). */
+    /** The env var the endpoint came from (env source only; doctor names it). */
+    envVar?: EndpointEnvVar;
+    /** The configured endpoint: a BASE URL for workspace/project sources. */
     endpoint: string;
-    /** OTLP protocol: workspace config, or a per-signal env bridge. */
     protocol?: string;
-    /** Workspace-configured collector headers (workspace source only; carries secrets). */
+    /** Collector headers (workspace / project sources; carries secrets). */
     headers?: Record<string, string>;
-    /** Workspace-configured service name (workspace source only). */
     serviceName?: string;
 }
 /**
@@ -79,51 +65,44 @@ export interface WorkspaceOtelConfig {
     headers?: Record<string, string>;
 }
 /**
- * Decide whether this launch exports OTel traces, and with which pi-otel entry.
- * Returns undefined when export stays off: no endpoint configured anywhere,
- * `PI_OTEL_DISABLED` set, or the pi-otel package unresolvable (never fatal).
+ * Reduce an endpoint that carries a signal path to its base
+ * (`https://otlp.datadoghq.com/v1/traces` → `https://otlp.datadoghq.com`).
+ * The extension appends `/v1/<signal>` per signal for http transports, so a
+ * workspace config saved before logs and metrics existed keeps exporting all
+ * three without an admin re-save. Mirrors the extension's own helper.
+ */
+export declare function stripSignalPath(endpoint: string): string;
+/** Personal kill switch: beats every source. Both spellings accepted. */
+export declare function envDisabled(env: NodeJS.ProcessEnv): boolean;
+/**
+ * Decide whether this launch exports, from the user's env and the repo's
+ * settings. Returns undefined when export stays off: no endpoint configured,
+ * or a kill switch set.
  *
- * Env sources, in precedence order: the generic `OTEL_EXPORTER_OTLP_ENDPOINT`,
- * then the per-signal `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`. pi-otel only reads
- * the generic var, so the per-signal one (the standard OTel env shape, and
- * what Claude Code setups configure — e.g. Updater's) is bridged: the traces
- * endpoint becomes the generic one, and a per-signal TRACES_PROTOCOL carries
- * over the same way. Logs/metrics per-signal vars are deliberately NOT read:
- * sessions export traces only, and pi-otel's metrics/logs signals are opt-in
- * elsewhere.
+ * Any of the standard endpoint variables enables export — the generic
+ * `OTEL_EXPORTER_OTLP_ENDPOINT` or a per-signal one — so a machine that
+ * carries a Claude Code telemetry env (typically all three per-signal
+ * endpoints) lights up with no translation. The extension reads the same
+ * variables, per signal, following the OTLP exporter spec.
  */
 export declare function resolveOtelLaunch(opts: {
     env: NodeJS.ProcessEnv;
     cwd: string;
-    /** Injectable seams for tests. */
-    resolveExtension?: () => string;
+    /** Injectable seam for tests. */
     readFile?: typeof readFileSync;
 }): OtelLaunchConfig | undefined;
-/** Absolute path to pi-otel's extension entry (its package main IS the pi
- * extension entry, `dist/index.js`). Resolved ESM-native like `paths.ts` does
- * for pi itself. Throws when the package is missing — callers treat that as
- * "export off", not an error.
- */
-export declare function resolveOtelExtensionPath(): string;
-/**
- * TCP reachability probe for an OTLP endpoint URL, with scheme-default ports:
- * WHATWG `URL` strips `:443`/`:80` as defaults, so an https endpoint with no
- * port probes 443 (the agentless SaaS shape). Returns false on any parse or
- * connect failure — reachability is advisory, never fatal. Mirrors the probe
- * inside (patched) pi-otel but lives here so `doctor` can use it without
- * importing the extension's SDK graph.
- */
-export declare function probeOtelEndpoint(endpoint: string, timeoutMs?: number): Promise<boolean>;
 /**
- * The env keys an OTel-exporting child must carry. `PI_OTEL_CAPTURE_CONTENT`
- * is pinned unconditionally (policy 2 above); the service name only fills in
- * when the user has not chosen their own.
+ * The env keys an exporting child must carry. `YAGNI_OTEL_EXPORT=1` is the
+ * gate the extension reads; the service name only fills in when the user has
+ * not chosen their own.
  *
- * A "workspace"-sourced config additionally delivers the admin-set endpoint,
- * protocol, and collector headers over the standard OTel env vars — but any
- * of those the USER already set in their own environment wins (local env >
- * workspace config), so an engineer can point one session at a scratch
- * collector without an admin change.
+ * A "workspace" or "project-settings" config delivers its endpoint (as the
+ * generic BASE endpoint — the extension derives the per-signal URLs),
+ * protocol, headers, and service name over the standard OTel env vars — but
+ * any of those the USER already set in their own environment wins (local
+ * env > workspace config), so an engineer can point one session at a
+ * scratch collector without an admin change. An "env" config is the user's
+ * own setup and passes through untouched.
  */
 export declare function otelChildEnv(config: OtelLaunchConfig, baseEnv: NodeJS.ProcessEnv): Record<string, string>;
 export interface WorkspaceOtelFetchDeps {
@@ -154,10 +133,8 @@ export declare function fetchWorkspaceOtel(creds: {
 /**
  * Full launch-time resolution, all four sources in precedence order:
  *
- *   1. `PI_OTEL_DISABLED`      — personal kill switch, beats everything.
- *   2. env `OTEL_EXPORTER_OTLP_ENDPOINT` / `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`
- *                              — the user's own setup, untouched (generic wins
- *                              over per-signal).
+ *   1. `PI_OTEL_DISABLED` / `YAGNI_OTEL_DISABLED` — personal kill switch.
+ *   2. env `OTEL_EXPORTER_OTLP_*_ENDPOINT` — the user's own setup, untouched.
  *   3. workspace config        — admin-set in the web app, fetched/cached.
  *   4. repo `.pi/settings.json` — committed per-repo config.
  *
@@ -171,9 +148,9 @@ export declare function resolveOtelLaunchWithWorkspace(opts: {
         token: string;
     } | null;
     profileName?: string;
-    resolveExtension?: () => string;
     readFile?: typeof readFileSync;
     fetchDeps?: WorkspaceOtelFetchDeps;
     fetchWorkspace?: typeof fetchWorkspaceOtel;
 }): Promise<OtelLaunchConfig | undefined>;
+export {};
 //# sourceMappingURL=otel.d.ts.map