@yagni-app/code 1.0.6 → 1.0.8

package/dist/extension/settingsFiles.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared settings-file plumbing for the three YAGNI Code settings tiers:
+ *   user    ~/.yagni-code/config.json                 (always trusted)
+ *   project .yagni-code/config.json under the cwd    (shared, committed)
+ *   local   .yagni-code/config.local.json under cwd  (personal, gitignored)
+ *
+ * Owns the atomic config mutation (promoted from sandbox/session.ts, the
+ * single copy now) and the global-gitignore helper (Claude Code
+ * addFileGlobRuleToGitignore parity): on the first write to the local file,
+ * the LOCAL_GITIGNORE_ENTRY glob lands in the GLOBAL git ignore file so
+ * personal settings are never committed. Fail-soft by design — a gitignore
+ * failure never fails the settings write.
+ */
+export declare function mutateConfigJson(target: string, mutate: (config: Record<string, unknown>) => void): void;
+/** The project-local settings path for a session cwd. */
+export declare function localConfigPath(cwd: string): string;
+/**
+ * Mutate the project-local settings file. Every write fire-and-forgets
+ * ensureLocalGitignored (Claude parity: the local tier is added to the
+ * global git ignore on write, not on session start). The helper is
+ * fire-and-forget BY DESIGN — the write's success notice is not gated on
+ * two git spawns; when the gitignore step is skipped or fails, the sink
+ * warn (gitignore_skipped / gitignore_update_failed) is the designed
+ * signal, surfaced via the diagnostics trail.
+ *
+ * `sinkSource` attributes those sink events to the caller's surface
+ * ("permission-rules" for rule saves, "sandbox" for panel/toggle writes) —
+ * the diagnostics trail then says which surface's write failed to get
+ * ignore-protected, not a blanket permission-rules line for every write.
+ */
+export declare function mutateLocalConfig(cwd: string, mutate: (config: Record<string, unknown>) => void, sinkSource?: string): void;
+/**
+ * The global git ignore path git actually reads. Git consults
+ * $XDG_CONFIG_HOME/git/ignore (defaulting ~/.config/git/ignore) — honoring
+ * XDG is a deliberate divergence from Claude (which hardcodes ~/.config):
+ * writing a file git will not read when XDG is set would be a silent no-op.
+ */
+export declare function globalGitignorePath(env?: NodeJS.ProcessEnv): string;
+/**
+ * Ensure the LOCAL_GITIGNORE_ENTRY glob (covering config.local.json at any
+ * depth) is ignored by the user's GLOBAL git config so local settings are
+ * never committed. Skip when:
+ *  - cwd is not inside a git repo (nothing to protect);
+ *  - `git check-ignore` already matches (local or global patterns cover it);
+ *  - the global ignore file already carries the literal entry.
+ * Any failure logs one warn sink event and returns — the settings write it
+ * accompanies has already succeeded and must not be walked back.
+ */
+export declare function ensureLocalGitignored(cwd: string, env?: NodeJS.ProcessEnv, sinkSource?: string): Promise<void>;
+//# sourceMappingURL=settingsFiles.d.ts.map

package/dist/extension/settingsFiles.js

@@ -0,0 +1,206 @@
+/**
+ * Shared settings-file plumbing for the three YAGNI Code settings tiers:
+ *   user    ~/.yagni-code/config.json                 (always trusted)
+ *   project .yagni-code/config.json under the cwd    (shared, committed)
+ *   local   .yagni-code/config.local.json under cwd  (personal, gitignored)
+ *
+ * Owns the atomic config mutation (promoted from sandbox/session.ts, the
+ * single copy now) and the global-gitignore helper (Claude Code
+ * addFileGlobRuleToGitignore parity): on the first write to the local file,
+ * the LOCAL_GITIGNORE_ENTRY glob lands in the GLOBAL git ignore file so
+ * personal settings are never committed. Fail-soft by design — a gitignore
+ * failure never fails the settings write.
+ */
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, appendFileSync, writeFileSync, renameSync, chmodSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { logEvent } from "./errorSink.js";
+const LOCAL_GITIGNORE_ENTRY = "**/.yagni-code/config.local.json";
+function isPlainRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+/**
+ * Safe config-file mutation shared by every settings writer:
+ *  - a PARSE FAILURE aborts (never treats a corrupt/half-written file as
+ *    empty — that would wipe activeProfile/permissions);
+ *  - the write is ATOMIC (tmp file + rename) so a crash never truncates;
+ *  - symlinked targets are rejected (a hostile repo's config symlink must
+ *    not redirect writes to arbitrary paths);
+ *  - the mutator runs only on a parsed object; a thrown mutator aborts.
+ * Throws on any failure — callers decide fail-soft messaging.
+ */
+/**
+ * Reject when the target's EXISTING parent directory is a symlink — a
+ * hostile repo can commit a symlinked `.yagni-code` DIRECTORY, and every
+ * local-settings write would then land outside the repo via the symlinked
+ * parent (the final-component lstat guard cannot see this). The parent is
+ * the repo-committable component (`.yagni-code` for project/local targets,
+ * the state home for user targets); ancestors above it are the user's own
+ * filesystem, not repo-controlled. Absent parent is fine — mkdirSync
+ * creates it fresh, and mkdir does not follow a symlinked path segment it
+ * creates itself. Fail closed.
+ */
+function assertRealParentDir(target) {
+    const dir = dirname(target);
+    try {
+        const st = lstatSync(dir);
+        if (!st.isDirectory() || st.isSymbolicLink()) {
+            throw new Error(`${dir} is not a real directory (symlinked parent?) — refusing to write through it`);
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return; // absent — created fresh below
+        throw err;
+    }
+}
+export function mutateConfigJson(target, mutate) {
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(target, "utf-8"));
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            parsed = {}; // genuinely fresh file — fine
+        }
+        else {
+            throw new Error(`config at ${target} is not valid JSON — refusing to rewrite it`);
+        }
+    }
+    if (!isPlainRecord(parsed))
+        throw new Error(`config at ${target} is not an object`);
+    const config = { ...parsed };
+    mutate(config);
+    mkdirSync(dirname(target), { recursive: true });
+    // Reject symlinked targets: lstat must show a regular file (or absent).
+    try {
+        const st = lstatSync(target);
+        if (!st.isFile())
+            throw new Error(`${target} is not a regular file (symlink?) — refusing`);
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    // And a symlinked PARENT directory: a committed symlinked .yagni-code
+    // dir would redirect the write outside the project — the final-component
+    // guard above cannot see it.
+    assertRealParentDir(target);
+    const tmp = `${target}.yagni-tmp-${process.pid}-${randomUUID().slice(0, 8)}`;
+    writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", { mode: 0o600 });
+    // chmod: writeFile honors mode only on create — guarantee 0600 even when a
+    // same-pid retry reuses an existing tmp file.
+    chmodSync(tmp, 0o600);
+    renameSync(tmp, target);
+}
+/** The project-local settings path for a session cwd. */
+export function localConfigPath(cwd) {
+    return join(cwd, ".yagni-code", "config.local.json");
+}
+/**
+ * Mutate the project-local settings file. Every write fire-and-forgets
+ * ensureLocalGitignored (Claude parity: the local tier is added to the
+ * global git ignore on write, not on session start). The helper is
+ * fire-and-forget BY DESIGN — the write's success notice is not gated on
+ * two git spawns; when the gitignore step is skipped or fails, the sink
+ * warn (gitignore_skipped / gitignore_update_failed) is the designed
+ * signal, surfaced via the diagnostics trail.
+ *
+ * `sinkSource` attributes those sink events to the caller's surface
+ * ("permission-rules" for rule saves, "sandbox" for panel/toggle writes) —
+ * the diagnostics trail then says which surface's write failed to get
+ * ignore-protected, not a blanket permission-rules line for every write.
+ */
+export function mutateLocalConfig(cwd, mutate, sinkSource = "permission-rules") {
+    mutateConfigJson(localConfigPath(cwd), mutate);
+    void ensureLocalGitignored(cwd, process.env, sinkSource);
+}
+// ---------------------------------------------------------------------------
+// Global-gitignore helper (Claude addFileGlobRuleToGitignore parity)
+// ---------------------------------------------------------------------------
+/** Run git <args> in cwd; resolves exit code (never throws). env threads
+ * through so the caller's PATH governs git resolution. */
+function git(cwd, args, env) {
+    return new Promise((resolve) => {
+        try {
+            const child = spawn("git", args, { cwd, env, stdio: "ignore" });
+            child.on("error", () => resolve(GIT_NOT_INSTALLED));
+            child.on("exit", (code) => resolve(code ?? GIT_NOT_INSTALLED));
+        }
+        catch {
+            resolve(GIT_NOT_INSTALLED);
+        }
+    });
+}
+const GIT_NOT_INSTALLED = -1;
+/**
+ * The global git ignore path git actually reads. Git consults
+ * $XDG_CONFIG_HOME/git/ignore (defaulting ~/.config/git/ignore) — honoring
+ * XDG is a deliberate divergence from Claude (which hardcodes ~/.config):
+ * writing a file git will not read when XDG is set would be a silent no-op.
+ */
+export function globalGitignorePath(env = process.env) {
+    const xdg = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.trim() !== "" ? env.XDG_CONFIG_HOME : null;
+    return join(xdg ?? join(homedir(), ".config"), "git", "ignore");
+}
+/**
+ * Ensure the LOCAL_GITIGNORE_ENTRY glob (covering config.local.json at any
+ * depth) is ignored by the user's GLOBAL git config so local settings are
+ * never committed. Skip when:
+ *  - cwd is not inside a git repo (nothing to protect);
+ *  - `git check-ignore` already matches (local or global patterns cover it);
+ *  - the global ignore file already carries the literal entry.
+ * Any failure logs one warn sink event and returns — the settings write it
+ * accompanies has already succeeded and must not be walked back.
+ */
+export async function ensureLocalGitignored(cwd, env = process.env, sinkSource = "permission-rules") {
+    try {
+        const inside = await git(cwd, ["rev-parse", "--is-inside-work-tree"], env);
+        // -1 = git missing or failed to spawn — protection silently skipped; a
+        // warn makes that visible (the file exists un-ignored). 128 = cleanly
+        // not a repo — the documented skip, nothing to surface.
+        if (inside === GIT_NOT_INSTALLED) {
+            logEvent({
+                source: sinkSource,
+                level: "warn",
+                event: "gitignore_skipped",
+                fields: { reason: "git-unavailable" },
+            });
+            return;
+        }
+        // Not inside a repo (128) or a failed rev-parse: skip, nothing to do.
+        if (inside !== 0)
+            return;
+        // 0 = already ignored by some pattern (project .gitignore or global).
+        if ((await git(cwd, ["check-ignore", ".yagni-code/config.local.json"], env)) === 0)
+            return;
+        const path = globalGitignorePath(env);
+        mkdirSync(dirname(path), { recursive: true });
+        if (existsSync(path)) {
+            const content = readFileSync(path, "utf-8");
+            if (content.includes(LOCAL_GITIGNORE_ENTRY))
+                return;
+            appendFileSync(path, `${content.endsWith("\n") ? "" : "\n"}${LOCAL_GITIGNORE_ENTRY}\n`);
+        }
+        else {
+            writeFileSync(path, `${LOCAL_GITIGNORE_ENTRY}\n`, { mode: 0o644 });
+        }
+    }
+    catch (err) {
+        logEvent({
+            source: sinkSource,
+            level: "warn",
+            event: "gitignore_update_failed",
+            fields: {
+                path: globalGitignorePath(env),
+                // The thrown message names the failing operation and the local
+                // filesystem path (mkdir/append of the ignore file) — no secret
+                // surface, and it makes EACCES-vs-ENOSPC diagnosable.
+                error: err instanceof Error ? err.message : String(err),
+            },
+        });
+    }
+}
+//# sourceMappingURL=settingsFiles.js.map

package/dist/extension/telemetry/attrs.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Attribute, metric, and event names.
+ *
+ * Two vocabularies ride on every signal on purpose:
+ *
+ *   - Claude Code's telemetry shape (`session.id`, `input_tokens`,
+ *     `tool_name`, the `<prefix>.token.usage` counter, the `api_request`
+ *     event …) so a team's existing Claude Code dashboards swap to YAGNI Code
+ *     by changing the prefix from `claude_code` to `yagni_code`;
+ *   - the OpenTelemetry GenAI semantic conventions (`gen_ai.*`) on the LLM
+ *     and tool spans, which is what vendor LLM-observability products
+ *     (Datadog LLM Observability, Grafana's GenAI views) key on.
+ *
+ * Names are literal strings rather than semconv-package imports: the set is
+ * small, stable, and part of our documented customer contract.
+ */
+export declare const PREFIX = "yagni_code";
+export declare const ATTR_SESSION_ID = "session.id";
+export declare const ATTR_APP_VERSION = "app.version";
+export declare const ATTR_APP_ENTRYPOINT = "app.entrypoint";
+export declare const ATTR_ORGANIZATION_ID = "organization.id";
+export declare const ATTR_USER_EMAIL = "user.email";
+export declare const ATTR_TERMINAL_TYPE = "terminal.type";
+export declare const ATTR_GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+export declare const ATTR_GEN_AI_PROVIDER_NAME = "gen_ai.provider.name";
+export declare const ATTR_GEN_AI_SYSTEM = "gen_ai.system";
+export declare const ATTR_GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+export declare const ATTR_GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+export declare const ATTR_GEN_AI_RESPONSE_ID = "gen_ai.response.id";
+export declare const ATTR_GEN_AI_FINISH_REASONS = "gen_ai.response.finish_reasons";
+/**
+ * Token usage. The semconv registry says `gen_ai.usage.input_tokens` "SHOULD
+ * include all types of input tokens, including cached tokens", and defines the
+ * cache counters as subsets of it. pi reports the Anthropic way (non-cached
+ * input, cache read, cache write as three disjoint numbers), so the tracker
+ * adds them up for the `gen_ai.*` layer. Consumers such as Datadog LLM
+ * Observability divide cache_read by input_tokens; feeding them the disjoint
+ * number produced cache ratios in the tens of thousands of percent.
+ *
+ * The flat Claude Code attributes (`input_tokens`, `cache_read_tokens`, …) and
+ * the `<prefix>.token.usage` metric deliberately keep Claude Code's disjoint
+ * semantics so cross-harness comparisons stay apples to apples.
+ */
+export declare const ATTR_GEN_AI_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+export declare const ATTR_GEN_AI_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+export declare const ATTR_GEN_AI_TOTAL_TOKENS = "gen_ai.usage.total_tokens";
+export declare const ATTR_GEN_AI_CACHE_READ_TOKENS = "gen_ai.usage.cache_read.input_tokens";
+export declare const ATTR_GEN_AI_CACHE_WRITE_TOKENS = "gen_ai.usage.cache_write.input_tokens";
+/** Pre-semconv spellings emitted through 1.0.x; kept for one release so
+ * dashboards keyed on them keep working. */
+export declare const ATTR_GEN_AI_CACHE_READ_TOKENS_LEGACY = "gen_ai.usage.cache_read_input_tokens";
+export declare const ATTR_GEN_AI_CACHE_CREATION_TOKENS_LEGACY = "gen_ai.usage.cache_creation_input_tokens";
+/** The one cost attribute Datadog's OTLP ingestion documents. Carries the
+ * same sell-rate figure as the flat `cost_usd`, so the vendor Cost view
+ * populates for the opaque tier id, which no vendor price table knows.
+ * Unit is NANODOLLARS (integer), not dollars: Datadog copies the value
+ * unscaled into its nanodollar cost metric. */
+export declare const ATTR_GEN_AI_COST_ESTIMATED_TOTAL = "gen_ai.cost.estimated_total";
+export declare const ATTR_GEN_AI_CONVERSATION_ID = "gen_ai.conversation.id";
+export declare const ATTR_GEN_AI_AGENT_NAME = "gen_ai.agent.name";
+export declare const ATTR_GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+export declare const ATTR_GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
+export declare const ATTR_GEN_AI_TOOL_TYPE = "gen_ai.tool.type";
+export declare const ATTR_ERROR_TYPE = "error.type";
+export declare const ATTR_HTTP_STATUS_CODE = "http.response.status_code";
+/** The provider name every span carries. The backing model is never exposed:
+ * `gen_ai.request.model` is the opaque YAGNI tier id. */
+export declare const GEN_AI_PROVIDER = "yagni";
+export declare const SPAN_INTERACTION = "yagni_code.interaction";
+export declare const SPAN_TURN = "yagni_code.turn";
+export declare const SPAN_LLM_REQUEST = "yagni_code.llm_request";
+export declare const SPAN_TOOL = "yagni_code.tool";
+export declare const METRIC_SESSION_COUNT = "yagni_code.session.count";
+export declare const METRIC_LINES_OF_CODE = "yagni_code.lines_of_code.count";
+export declare const METRIC_PULL_REQUEST_COUNT = "yagni_code.pull_request.count";
+export declare const METRIC_COMMIT_COUNT = "yagni_code.commit.count";
+export declare const METRIC_COST_USAGE = "yagni_code.cost.usage";
+export declare const METRIC_TOKEN_USAGE = "yagni_code.token.usage";
+export declare const METRIC_CODE_EDIT_DECISION = "yagni_code.code_edit_tool.decision";
+export declare const METRIC_ACTIVE_TIME = "yagni_code.active_time.total";
+export declare const EVENT_USER_PROMPT = "user_prompt";
+export declare const EVENT_ASSISTANT_RESPONSE = "assistant_response";
+export declare const EVENT_TOOL_RESULT = "tool_result";
+export declare const EVENT_API_REQUEST = "api_request";
+export declare const EVENT_API_ERROR = "api_error";
+export declare const EVENT_TOOL_DECISION = "tool_decision";
+export declare const EVENT_PERMISSION_MODE_CHANGED = "permission_mode_changed";
+/** Claude Code token-type values on `<prefix>.token.usage`. */
+export type TokenType = "input" | "output" | "cacheRead" | "cacheCreation";
+/** Claude Code decision sources on tool_decision / code_edit_tool.decision. */
+export type DecisionSource = "config" | "hook" | "user_permanent" | "user_temporary" | "user_abort" | "user_reject";
+export type Decision = "accept" | "reject";
+export declare function clampString(s: string, max?: number): string;
+/** Language label from a file path's extension (Claude Code's `language` attr). */
+export declare function languageFromPath(path: string | undefined): string | undefined;
+//# sourceMappingURL=attrs.d.ts.map

package/dist/extension/telemetry/attrs.js

@@ -0,0 +1,149 @@
+/**
+ * Attribute, metric, and event names.
+ *
+ * Two vocabularies ride on every signal on purpose:
+ *
+ *   - Claude Code's telemetry shape (`session.id`, `input_tokens`,
+ *     `tool_name`, the `<prefix>.token.usage` counter, the `api_request`
+ *     event …) so a team's existing Claude Code dashboards swap to YAGNI Code
+ *     by changing the prefix from `claude_code` to `yagni_code`;
+ *   - the OpenTelemetry GenAI semantic conventions (`gen_ai.*`) on the LLM
+ *     and tool spans, which is what vendor LLM-observability products
+ *     (Datadog LLM Observability, Grafana's GenAI views) key on.
+ *
+ * Names are literal strings rather than semconv-package imports: the set is
+ * small, stable, and part of our documented customer contract.
+ */
+export const PREFIX = "yagni_code";
+// ── Resource / standard attributes ──────────────────────────────────────────
+export const ATTR_SESSION_ID = "session.id";
+export const ATTR_APP_VERSION = "app.version";
+export const ATTR_APP_ENTRYPOINT = "app.entrypoint";
+export const ATTR_ORGANIZATION_ID = "organization.id";
+export const ATTR_USER_EMAIL = "user.email";
+export const ATTR_TERMINAL_TYPE = "terminal.type";
+// ── GenAI semantic conventions ──────────────────────────────────────────────
+export const ATTR_GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+export const ATTR_GEN_AI_PROVIDER_NAME = "gen_ai.provider.name";
+export const ATTR_GEN_AI_SYSTEM = "gen_ai.system";
+export const ATTR_GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+export const ATTR_GEN_AI_RESPONSE_MODEL = "gen_ai.response.model";
+export const ATTR_GEN_AI_RESPONSE_ID = "gen_ai.response.id";
+export const ATTR_GEN_AI_FINISH_REASONS = "gen_ai.response.finish_reasons";
+/**
+ * Token usage. The semconv registry says `gen_ai.usage.input_tokens` "SHOULD
+ * include all types of input tokens, including cached tokens", and defines the
+ * cache counters as subsets of it. pi reports the Anthropic way (non-cached
+ * input, cache read, cache write as three disjoint numbers), so the tracker
+ * adds them up for the `gen_ai.*` layer. Consumers such as Datadog LLM
+ * Observability divide cache_read by input_tokens; feeding them the disjoint
+ * number produced cache ratios in the tens of thousands of percent.
+ *
+ * The flat Claude Code attributes (`input_tokens`, `cache_read_tokens`, …) and
+ * the `<prefix>.token.usage` metric deliberately keep Claude Code's disjoint
+ * semantics so cross-harness comparisons stay apples to apples.
+ */
+export const ATTR_GEN_AI_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+export const ATTR_GEN_AI_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+export const ATTR_GEN_AI_TOTAL_TOKENS = "gen_ai.usage.total_tokens";
+export const ATTR_GEN_AI_CACHE_READ_TOKENS = "gen_ai.usage.cache_read.input_tokens";
+export const ATTR_GEN_AI_CACHE_WRITE_TOKENS = "gen_ai.usage.cache_write.input_tokens";
+/** Pre-semconv spellings emitted through 1.0.x; kept for one release so
+ * dashboards keyed on them keep working. */
+export const ATTR_GEN_AI_CACHE_READ_TOKENS_LEGACY = "gen_ai.usage.cache_read_input_tokens";
+export const ATTR_GEN_AI_CACHE_CREATION_TOKENS_LEGACY = "gen_ai.usage.cache_creation_input_tokens";
+/** The one cost attribute Datadog's OTLP ingestion documents. Carries the
+ * same sell-rate figure as the flat `cost_usd`, so the vendor Cost view
+ * populates for the opaque tier id, which no vendor price table knows.
+ * Unit is NANODOLLARS (integer), not dollars: Datadog copies the value
+ * unscaled into its nanodollar cost metric. */
+export const ATTR_GEN_AI_COST_ESTIMATED_TOTAL = "gen_ai.cost.estimated_total";
+export const ATTR_GEN_AI_CONVERSATION_ID = "gen_ai.conversation.id";
+export const ATTR_GEN_AI_AGENT_NAME = "gen_ai.agent.name";
+export const ATTR_GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+export const ATTR_GEN_AI_TOOL_CALL_ID = "gen_ai.tool.call.id";
+export const ATTR_GEN_AI_TOOL_TYPE = "gen_ai.tool.type";
+export const ATTR_ERROR_TYPE = "error.type";
+export const ATTR_HTTP_STATUS_CODE = "http.response.status_code";
+/** The provider name every span carries. The backing model is never exposed:
+ * `gen_ai.request.model` is the opaque YAGNI tier id. */
+export const GEN_AI_PROVIDER = "yagni";
+// ── Span names (Claude Code's beta trace tree, prefixed) ────────────────────
+export const SPAN_INTERACTION = `${PREFIX}.interaction`;
+export const SPAN_TURN = `${PREFIX}.turn`;
+export const SPAN_LLM_REQUEST = `${PREFIX}.llm_request`;
+export const SPAN_TOOL = `${PREFIX}.tool`;
+// ── Metric names (Claude Code's eight counters, prefixed) ───────────────────
+export const METRIC_SESSION_COUNT = `${PREFIX}.session.count`;
+export const METRIC_LINES_OF_CODE = `${PREFIX}.lines_of_code.count`;
+export const METRIC_PULL_REQUEST_COUNT = `${PREFIX}.pull_request.count`;
+export const METRIC_COMMIT_COUNT = `${PREFIX}.commit.count`;
+export const METRIC_COST_USAGE = `${PREFIX}.cost.usage`;
+export const METRIC_TOKEN_USAGE = `${PREFIX}.token.usage`;
+export const METRIC_CODE_EDIT_DECISION = `${PREFIX}.code_edit_tool.decision`;
+export const METRIC_ACTIVE_TIME = `${PREFIX}.active_time.total`;
+// ── Event names (Claude Code's log events, prefixed in the body) ────────────
+export const EVENT_USER_PROMPT = "user_prompt";
+export const EVENT_ASSISTANT_RESPONSE = "assistant_response";
+export const EVENT_TOOL_RESULT = "tool_result";
+export const EVENT_API_REQUEST = "api_request";
+export const EVENT_API_ERROR = "api_error";
+export const EVENT_TOOL_DECISION = "tool_decision";
+export const EVENT_PERMISSION_MODE_CHANGED = "permission_mode_changed";
+/** Cap on any string attribute (Claude Code's 60 KB content limit). */
+const MAX_ATTR_BYTES = 60 * 1024;
+export function clampString(s, max = MAX_ATTR_BYTES) {
+    if (Buffer.byteLength(s, "utf8") <= max)
+        return s;
+    let end = max;
+    while (end > 0 && Buffer.byteLength(s.slice(0, end), "utf8") > max - 16)
+        end -= 64;
+    return `${s.slice(0, Math.max(0, end))}…[truncated]`;
+}
+/** Language label from a file path's extension (Claude Code's `language` attr). */
+export function languageFromPath(path) {
+    if (!path)
+        return undefined;
+    const m = /\.([A-Za-z0-9]+)$/.exec(path);
+    if (!m)
+        return undefined;
+    const ext = m[1].toLowerCase();
+    const map = {
+        ts: "typescript",
+        tsx: "typescript",
+        mts: "typescript",
+        cts: "typescript",
+        js: "javascript",
+        jsx: "javascript",
+        mjs: "javascript",
+        cjs: "javascript",
+        py: "python",
+        rb: "ruby",
+        go: "go",
+        rs: "rust",
+        java: "java",
+        kt: "kotlin",
+        swift: "swift",
+        c: "c",
+        h: "c",
+        cc: "cpp",
+        cpp: "cpp",
+        hpp: "cpp",
+        cs: "csharp",
+        php: "php",
+        sh: "shell",
+        bash: "shell",
+        zsh: "shell",
+        sql: "sql",
+        md: "markdown",
+        json: "json",
+        yaml: "yaml",
+        yml: "yaml",
+        toml: "toml",
+        html: "html",
+        css: "css",
+        scss: "scss",
+    };
+    return map[ext] ?? ext;
+}
+//# sourceMappingURL=attrs.js.map

package/dist/extension/telemetry/config.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Telemetry export configuration, resolved from the standard OpenTelemetry
+ * environment contract (the same variables Claude Code reads), so a machine
+ * or workspace already configured for Claude Code lights up YAGNI Code with
+ * no translation.
+ *
+ * Pure: reads an env record, never the network or disk. The launcher decides
+ * WHETHER a session exports (see the CLI's otel.ts: env, workspace settings,
+ * or a repo's committed config) and sets `YAGNI_OTEL_EXPORT=1` plus the OTLP
+ * variables in the child env; this module turns that env into per-signal
+ * exporter settings.
+ *
+ * Endpoint rules follow the OTLP exporter spec:
+ *   - a per-signal endpoint (`OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`, …) is used
+ *     verbatim;
+ *   - the generic `OTEL_EXPORTER_OTLP_ENDPOINT` is a BASE: http transports
+ *     append `/v1/<signal>`, gRPC uses it as-is;
+ *   - nothing configured falls back to the local-collector defaults.
+ *
+ * Content policy is enforced here, not configurable: prompt and response
+ * text never export. `OTEL_LOG_USER_PROMPTS` and `OTEL_LOG_TOOL_DETAILS` are
+ * deliberately NOT honored — session content leaving the machine is a
+ * contract change, not an env knob.
+ */
+export type OtlpProtocol = "grpc" | "http/protobuf" | "http/json";
+export type Signal = "traces" | "metrics" | "logs";
+export declare const SIGNALS: readonly Signal[];
+export interface SignalConfig {
+    enabled: boolean;
+    protocol: OtlpProtocol;
+    /** The fully resolved URL this signal exports to. */
+    url: string;
+    headers: Record<string, string>;
+    /** Batch / periodic export interval in ms. */
+    exportIntervalMs: number;
+}
+export interface TelemetryIdentity {
+    /** Bound workspace id (YAGNI_WORKSPACE_ID) → `organization.id`. */
+    organizationId?: string;
+    /**
+     * The signed-in user's email → `user.email`. From `YAGNI_USER_EMAIL` when
+     * the launcher forwards it; otherwise learned from the /context boot fetch
+     * (`TelemetryHandle.setUserEmail`). Gated by `includeAccountId`.
+     */
+    userEmail?: string;
+    /** Shipping CLI version (YAGNI_CODE_VERSION) → `app.version`. */
+    appVersion?: string;
+    /** Detected terminal (TERM_PROGRAM / TMUX) → `terminal.type`. */
+    terminalType?: string;
+    /** `cli` for an interactive launch, `sdk-cli` for a headless /go run. */
+    entrypoint: "cli" | "sdk-cli";
+}
+export interface TelemetryConfig {
+    enabled: boolean;
+    serviceName: string;
+    serviceVersion?: string;
+    /** OTEL_RESOURCE_ATTRIBUTES, decoded. Applied to the resource and (by
+     * default) to every metric and event. */
+    resourceAttributes: Record<string, string>;
+    traces: SignalConfig;
+    metrics: SignalConfig;
+    logs: SignalConfig;
+    metricsTemporality: "delta" | "cumulative";
+    /** Cardinality controls (Claude Code parity). */
+    includeSessionId: boolean;
+    includeVersion: boolean;
+    includeAccountId: boolean;
+    includeResourceAttributes: boolean;
+    includeEntrypoint: boolean;
+    identity: TelemetryIdentity;
+}
+export declare const DEFAULT_SERVICE_NAME = "yagni-code";
+type Env = Record<string, string | undefined>;
+export declare function normalizeProtocol(p: string | undefined): OtlpProtocol | undefined;
+/**
+ * Parse a `k=v,k2=v2` list (OTEL_EXPORTER_OTLP_HEADERS / OTEL_RESOURCE_ATTRIBUTES).
+ * Values may be percent-encoded per the W3C baggage rules the spec references;
+ * a malformed escape keeps the raw value. Splits on the FIRST `=` only so a
+ * base64 value's trailing `==` survives.
+ */
+export declare function parseKvList(s: string | undefined): Record<string, string>;
+/**
+ * Reduce an endpoint that carries a signal path to its base
+ * (`https://otlp.datadoghq.com/v1/traces` → `https://otlp.datadoghq.com`).
+ * Pre-parity workspace configs stored the full trace URL; treating it as a
+ * base keeps them exporting all three signals without an admin re-save.
+ */
+export declare function stripSignalPath(endpoint: string): string;
+/**
+ * Resolve one signal's URL from the env, per the OTLP exporter spec.
+ * Exported for the launcher's doctor so its report names the exact URL a
+ * session will post to.
+ */
+export declare function resolveSignalUrl(env: Env, signal: Signal, protocol: OtlpProtocol): string;
+/** Personal kill switch, beats every other source (both spellings accepted). */
+export declare function telemetryDisabled(env: Env): boolean;
+/** The launcher's "this session exports" gate. */
+export declare const OTEL_EXPORT_ENV = "YAGNI_OTEL_EXPORT";
+export declare function resolveTelemetryConfig(env?: Env): TelemetryConfig;
+/** Signals this config will actually export (for doctor / status lines). */
+export declare function enabledSignals(config: TelemetryConfig): Signal[];
+export {};
+//# sourceMappingURL=config.d.ts.map