@infinitedusky/indusk-mcp 1.18.1 → 1.19.0

package/dist/lib/eval/otel.d.ts

@@ -12,6 +12,7 @@
  * throws, same behavior. The evaluator never fails because of OTel.
  */
 import { type Attributes, type Span, type Tracer } from "@opentelemetry/api";
+import { type Logger } from "@opentelemetry/api-logs";
 export interface EvalOtelConfig {
     enabled: boolean;
     endpoint: string | null;
@@ -19,14 +20,21 @@ export interface EvalOtelConfig {
 }
 /**
  * Pure predicate — reads `.indusk/config.json` `eval.otel.{enabled,dataset}` and
- * the `INDUSK_EVAL_OTEL` / `INDUSK_EVAL_OTEL_DATASET` / `OTEL_EXPORTER_OTLP_ENDPOINT`
- * env vars. Does not init anything or touch the network.
+ * the `INDUSK_EVAL_OTEL` / `INDUSK_EVAL_OTEL_DATASET` / `EVAL_AGENT_DATASET` /
+ * `OTEL_EXPORTER_OTLP_ENDPOINT` env vars. Does not init anything or touch the network.
  *
  * Resolution:
  * - `enabled`: `INDUSK_EVAL_OTEL=1` (truthy) wins, else config `eval.otel.enabled`, else false.
  * - `endpoint`: `OTEL_EXPORTER_OTLP_ENDPOINT` (null if unset).
- * - `dataset`: `INDUSK_EVAL_OTEL_DATASET` env var wins, else config `eval.otel.dataset`,
- *   else `"agent"` default. Sent as the `Dash0-Dataset` header on every OTLP export.
+ * - `dataset` (priority, highest → lowest):
+ *   1. `INDUSK_EVAL_OTEL_DATASET` env var (explicit per-invocation override)
+ *   2. `EVAL_AGENT_DATASET` env var (composable.env convention — see env/components/dash0.env)
+ *   3. `.indusk/config.json` `eval.otel.dataset`
+ *   4. `"agent"` default
+ *
+ *   Sent as the `Dash0-Dataset` header on every OTLP export. Also rewritten into
+ *   `OTEL_EXPORTER_OTLP_HEADERS` if present there (env headers beat constructor
+ *   headers per OTel spec — so we fix the env header at the source).
  */
 export declare function isEvalOtelEnabled(projectRoot: string): EvalOtelConfig;
 /**
@@ -49,9 +57,30 @@ export declare function initEvalOtel(projectRoot: string): Tracer;
  */
 export declare function withSpan<T>(tracer: Tracer, name: string, attrs: Attributes | undefined, fn: (span: Span) => Promise<T> | T): Promise<T>;
 /**
- * Flush and shut down the active provider. Call this before `process.exit()`
- * in detached processes so batched spans are not lost. No-op if no provider
- * is active.
+ * Initialize the OTel logs pipeline alongside traces. Returns a Logger —
+ * real when enabled + endpoint set, no-op otherwise. Shares the same
+ * config gating + Dash0 dataset routing as `initEvalOtel`. Safe to call
+ * multiple times.
+ *
+ * Log records emitted via `getEvalLogger().emit(...)` automatically
+ * correlate with the active span via trace_id / span_id.
+ */
+export declare function initEvalOtelLogs(projectRoot: string): Logger;
+/**
+ * Accessor for the eval logger. Always safe to call — returns a no-op
+ * logger when logs aren't initialized.
+ */
+export declare function getEvalLogger(): Logger;
+/**
+ * Emit an info-severity log record with an arbitrary body. Shorthand for
+ * `getEvalLogger().emit(...)`. When called inside an active span, the
+ * SDK attaches trace_id + span_id automatically.
+ */
+export declare function logEvalContent(name: string, body: string | Record<string, unknown>, attributes?: Record<string, string | number | boolean>): void;
+/**
+ * Flush and shut down the active providers (traces + logs). Call this
+ * before `process.exit()` in detached processes so batched signals are
+ * not lost. No-op if neither provider is active.
  */
 export declare function shutdownEvalOtel(): Promise<void>;
 /**

package/dist/lib/eval/otel.js

@@ -14,8 +14,11 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
+import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchLogRecordProcessor, LoggerProvider } from "@opentelemetry/sdk-logs";
 import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
 import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
@@ -34,19 +37,27 @@ function syslog(projectRoot, msg) {
 const DEFAULT_DATASET = "agent";
 /**
  * Pure predicate — reads `.indusk/config.json` `eval.otel.{enabled,dataset}` and
- * the `INDUSK_EVAL_OTEL` / `INDUSK_EVAL_OTEL_DATASET` / `OTEL_EXPORTER_OTLP_ENDPOINT`
- * env vars. Does not init anything or touch the network.
+ * the `INDUSK_EVAL_OTEL` / `INDUSK_EVAL_OTEL_DATASET` / `EVAL_AGENT_DATASET` /
+ * `OTEL_EXPORTER_OTLP_ENDPOINT` env vars. Does not init anything or touch the network.
  *
  * Resolution:
  * - `enabled`: `INDUSK_EVAL_OTEL=1` (truthy) wins, else config `eval.otel.enabled`, else false.
  * - `endpoint`: `OTEL_EXPORTER_OTLP_ENDPOINT` (null if unset).
- * - `dataset`: `INDUSK_EVAL_OTEL_DATASET` env var wins, else config `eval.otel.dataset`,
- *   else `"agent"` default. Sent as the `Dash0-Dataset` header on every OTLP export.
+ * - `dataset` (priority, highest → lowest):
+ *   1. `INDUSK_EVAL_OTEL_DATASET` env var (explicit per-invocation override)
+ *   2. `EVAL_AGENT_DATASET` env var (composable.env convention — see env/components/dash0.env)
+ *   3. `.indusk/config.json` `eval.otel.dataset`
+ *   4. `"agent"` default
+ *
+ *   Sent as the `Dash0-Dataset` header on every OTLP export. Also rewritten into
+ *   `OTEL_EXPORTER_OTLP_HEADERS` if present there (env headers beat constructor
+ *   headers per OTel spec — so we fix the env header at the source).
  */
 export function isEvalOtelEnabled(projectRoot) {
     const envFlag = process.env.INDUSK_EVAL_OTEL;
     const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? null;
-    const envDataset = process.env.INDUSK_EVAL_OTEL_DATASET;
+    const explicitDataset = process.env.INDUSK_EVAL_OTEL_DATASET;
+    const composableDataset = process.env.EVAL_AGENT_DATASET;
     let configEnabled = false;
     let configDataset;
     const configPath = join(projectRoot, ".indusk", "config.json");
@@ -63,14 +74,34 @@ export function isEvalOtelEnabled(projectRoot) {
         }
     }
     const envForcesEnabled = envFlag !== undefined && envFlag !== "" && envFlag !== "0" && envFlag.toLowerCase() !== "false";
-    const dataset = envDataset && envDataset !== "" ? envDataset : (configDataset ?? DEFAULT_DATASET);
+    const dataset = (explicitDataset && explicitDataset !== "" && explicitDataset) ||
+        (composableDataset && composableDataset !== "" && composableDataset) ||
+        configDataset ||
+        DEFAULT_DATASET;
     return {
         enabled: envForcesEnabled || configEnabled,
         endpoint,
         dataset,
     };
 }
+/**
+ * Rewrite the `Dash0-Dataset=<old>` entry in `OTEL_EXPORTER_OTLP_HEADERS` to
+ * `Dash0-Dataset=<target>`. OTel spec says env-set headers override constructor
+ * headers, so we have to fix the env directly for routing to work when the user's
+ * shell already sets `OTEL_EXPORTER_OTLP_HEADERS` via composable.env.
+ *
+ * No-op if the env var is unset or doesn't contain `Dash0-Dataset=`.
+ */
+function rewriteDatasetInEnvHeaders(target) {
+    const current = process.env.OTEL_EXPORTER_OTLP_HEADERS;
+    if (!current || !current.includes("Dash0-Dataset="))
+        return;
+    const rewritten = current.replace(/Dash0-Dataset=[^,]*/g, `Dash0-Dataset=${target}`);
+    process.env.OTEL_EXPORTER_OTLP_HEADERS = rewritten;
+}
+const LOGGER_NAME = "@infinitedusky/indusk-mcp/eval";
 let activeProvider = null;
+let activeLoggerProvider = null;
 /**
  * Initialize OTel tracing for the evaluator if enabled + endpoint set.
  * Returns a Tracer — real when enabled, no-op when not.
@@ -92,6 +123,12 @@ export function initEvalOtel(projectRoot) {
     if (activeProvider) {
         return trace.getTracer(TRACER_NAME);
     }
+    // Ensure env-set OTEL_EXPORTER_OTLP_HEADERS routes to the eval agent's
+    // dataset. Env headers beat constructor headers per OTel spec — so if the
+    // user's shell (composable.env) already set Dash0-Dataset for project
+    // telemetry, we rewrite it in-place to the eval agent dataset before the
+    // exporter reads it.
+    rewriteDatasetInEnvHeaders(dataset);
     // Build exporter headers. We pass Authorization and Dash0-Dataset in the
     // constructor rather than relying on OTEL_EXPORTER_OTLP_HEADERS env parsing,
     // because the OTel SDK's env parser has proven unreliable for tokens with
@@ -155,22 +192,105 @@ export async function withSpan(tracer, name, attrs, fn) {
     });
 }
 /**
- * Flush and shut down the active provider. Call this before `process.exit()`
- * in detached processes so batched spans are not lost. No-op if no provider
- * is active.
+ * Initialize the OTel logs pipeline alongside traces. Returns a Logger —
+ * real when enabled + endpoint set, no-op otherwise. Shares the same
+ * config gating + Dash0 dataset routing as `initEvalOtel`. Safe to call
+ * multiple times.
+ *
+ * Log records emitted via `getEvalLogger().emit(...)` automatically
+ * correlate with the active span via trace_id / span_id.
+ */
+export function initEvalOtelLogs(projectRoot) {
+    const { enabled, endpoint, dataset } = isEvalOtelEnabled(projectRoot);
+    if (!enabled)
+        return logs.getLogger(LOGGER_NAME);
+    if (!endpoint) {
+        syslog(projectRoot, "eval.otel.logs — endpoint unset; falling back to no-op logger");
+        return logs.getLogger(LOGGER_NAME);
+    }
+    if (activeLoggerProvider)
+        return logs.getLogger(LOGGER_NAME);
+    rewriteDatasetInEnvHeaders(dataset);
+    const headers = { "Dash0-Dataset": dataset };
+    if (process.env.DASH0_API_TOKEN) {
+        headers.Authorization = `Bearer ${process.env.DASH0_API_TOKEN}`;
+    }
+    try {
+        const exporter = new OTLPLogExporter({
+            url: endpoint.endsWith("/v1/logs") ? endpoint : `${endpoint.replace(/\/$/, "")}/v1/logs`,
+            headers,
+        });
+        const provider = new LoggerProvider({
+            resource: resourceFromAttributes({ [ATTR_SERVICE_NAME]: SERVICE_NAME }),
+            processors: [new BatchLogRecordProcessor(exporter)],
+        });
+        // setGlobalLoggerProvider returns false if one is already registered
+        // (e.g., a test's InMemoryLogRecordExporter provider). Respect that —
+        // only retain ownership (and tear down at shutdown) if we actually
+        // registered ours.
+        const accepted = logs.setGlobalLoggerProvider(provider);
+        if (accepted) {
+            activeLoggerProvider = provider;
+            syslog(projectRoot, `eval.otel.logs initialized — endpoint: ${endpoint}, dataset: ${dataset}`);
+        }
+        else {
+            syslog(projectRoot, "eval.otel.logs — global provider already set; using existing");
+            // Fire-and-forget shutdown of the unused provider
+            void provider.shutdown().catch(() => { });
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        syslog(projectRoot, `eval.otel.logs init failed — falling back to no-op: ${message}`);
+    }
+    return logs.getLogger(LOGGER_NAME);
+}
+/**
+ * Accessor for the eval logger. Always safe to call — returns a no-op
+ * logger when logs aren't initialized.
+ */
+export function getEvalLogger() {
+    return logs.getLogger(LOGGER_NAME);
+}
+/**
+ * Emit an info-severity log record with an arbitrary body. Shorthand for
+ * `getEvalLogger().emit(...)`. When called inside an active span, the
+ * SDK attaches trace_id + span_id automatically.
+ */
+export function logEvalContent(name, body, attributes) {
+    // AnyValue requires plain primitives/arrays/records — stringify objects so
+    // Dash0 ingests the content as a single searchable log body rather than a
+    // nested structure.
+    const bodyText = typeof body === "string" ? body : JSON.stringify(body);
+    getEvalLogger().emit({
+        severityNumber: SeverityNumber.INFO,
+        severityText: "INFO",
+        body: bodyText,
+        attributes: { "eval.event": name, ...(attributes ?? {}) },
+    });
+}
+/**
+ * Flush and shut down the active providers (traces + logs). Call this
+ * before `process.exit()` in detached processes so batched signals are
+ * not lost. No-op if neither provider is active.
  */
 export async function shutdownEvalOtel() {
-    if (!activeProvider)
-        return;
+    const tasks = [];
+    if (activeProvider) {
+        tasks.push(activeProvider.forceFlush().then(() => activeProvider?.shutdown()));
+    }
+    if (activeLoggerProvider) {
+        tasks.push(activeLoggerProvider.forceFlush().then(() => activeLoggerProvider?.shutdown()));
+    }
     try {
-        await activeProvider.forceFlush();
-        await activeProvider.shutdown();
+        await Promise.all(tasks);
     }
     catch {
         // shutdown is best-effort
     }
     finally {
         activeProvider = null;
+        activeLoggerProvider = null;
     }
 }
 /**
@@ -178,12 +298,17 @@ export async function shutdownEvalOtel() {
  * starts fresh. Not part of the public API.
  */
 export function __resetEvalOtelForTests() {
-    // Tear down any provider left over from a previous test. This un-registers
-    // from the global OTel API, so `trace.getTracer()` falls back to the no-op
-    // tracer until a new provider is registered.
+    // Tear down any providers left over from a previous test. This
+    // un-registers from the global OTel API so `trace.getTracer()` /
+    // `logs.getLogger()` fall back to no-op until re-registered.
     if (activeProvider) {
         void activeProvider.shutdown().catch(() => { });
     }
+    if (activeLoggerProvider) {
+        void activeLoggerProvider.shutdown().catch(() => { });
+    }
     activeProvider = null;
+    activeLoggerProvider = null;
     trace.disable();
+    logs.disable();
 }

package/dist/lib/eval/persistent-evaluator.js

@@ -13,7 +13,7 @@ import { getProjectGroupId } from "../config.js";
 import { readUnprocessedHighlights } from "../highlights/highlights.js";
 import { ingestScorecard } from "./findings.js";
 import { EvalLogWriter } from "./log-writer.js";
-import { initEvalOtel, shutdownEvalOtel, withSpan } from "./otel.js";
+import { initEvalOtel, initEvalOtelLogs, logEvalContent, shutdownEvalOtel, withSpan, } from "./otel.js";
 import { buildEvaluatorPrompt } from "./prompt-builder.js";
 import { V1_RUBRIC } from "./rubric.js";
 function getSessionPath(projectRoot) {
@@ -112,6 +112,7 @@ async function spawnClaude(args, prompt, cwd) {
  */
 export async function runPersistentEval(opts) {
     const tracer = initEvalOtel(opts.projectRoot);
+    initEvalOtelLogs(opts.projectRoot);
     const source = process.env.INDUSK_EVAL_SOURCE ?? "commit";
     const projectGroup = getProjectGroupId(opts.projectRoot);
     // Peek at the highlights queue before spawning — gives us observability
@@ -135,7 +136,17 @@ export async function runPersistentEval(opts) {
         const session = await withSpan(tracer, "eval.read_session", undefined, () => readSession(opts.projectRoot));
         rootSpan.setAttribute("resumed", session !== null);
         try {
-            const { args, prompt } = await withSpan(tracer, "eval.build_prompt", { resumed: session !== null }, () => {
+            const { args, prompt } = await withSpan(tracer, "eval.build_prompt", { resumed: session !== null }, (span) => {
+                const built = buildArgsAndPrompt();
+                span.setAttribute("prompt.length", built.prompt.length);
+                span.setAttribute("prompt.kind", session ? "resume" : "full");
+                logEvalContent("prompt", built.prompt, {
+                    "prompt.length": built.prompt.length,
+                    "prompt.kind": session ? "resume" : "full",
+                });
+                return built;
+            });
+            function buildArgsAndPrompt() {
                 if (session) {
                     const resumePrompt = `Evaluate a new commit. Change ID: ${opts.changeId}
 
@@ -175,16 +186,24 @@ Output ONLY the JSON scorecard as before — no commentary.`;
                         projectGroup,
                     }),
                 };
-            });
+            }
             const claudeResult = await withSpan(tracer, "eval.spawn_claude", {
                 "args.resumed": session !== null,
                 "args.model": session ? "(resumed)" : "opus",
             }, async (span) => {
                 const spawned = await spawnClaude(args, prompt, opts.projectRoot);
                 span.setAttribute("exit.code", spawned.code ?? -1);
+                span.setAttribute("stdout.length", spawned.stdout.length);
                 if (spawned.code !== 0) {
                     span.setAttribute("exit.stderr_tail", spawned.stderr.slice(-500));
+                    logEvalContent("claude.error", spawned.stderr, {
+                        "exit.code": spawned.code ?? -1,
+                    });
                 }
+                logEvalContent("claude.stdout", spawned.stdout, {
+                    "stdout.length": spawned.stdout.length,
+                    "exit.code": spawned.code ?? -1,
+                });
                 return spawned;
             });
             if (claudeResult.code !== 0) {
@@ -210,6 +229,26 @@ Output ONLY the JSON scorecard as before — no commentary.`;
             if (parsed.usage)
                 scorecard.usage = parsed.usage;
             scorecard.telemetryPosted = false;
+            // Carry scorecard-level content onto the root span for at-a-glance debugging in Dash0
+            rootSpan.setAttribute("scorecard.status", "ok");
+            rootSpan.setAttribute("scorecard.question_count", scorecard.questions?.length ?? 0);
+            if (scorecard.summary) {
+                rootSpan.setAttribute("scorecard.summary", scorecard.summary.slice(0, 500));
+            }
+            if (scorecard.usage) {
+                rootSpan.setAttribute("scorecard.cost_usd", scorecard.usage.costUsd);
+                rootSpan.setAttribute("scorecard.duration_ms", scorecard.usage.durationMs);
+                rootSpan.setAttribute("scorecard.input_tokens", scorecard.usage.inputTokens);
+                rootSpan.setAttribute("scorecard.output_tokens", scorecard.usage.outputTokens);
+            }
+            const answerCounts = { yes: 0, no: 0, partial: 0 };
+            for (const q of scorecard.questions ?? []) {
+                if (q.answer in answerCounts)
+                    answerCounts[q.answer]++;
+            }
+            rootSpan.setAttribute("scorecard.answers.yes", answerCounts.yes);
+            rootSpan.setAttribute("scorecard.answers.no", answerCounts.no);
+            rootSpan.setAttribute("scorecard.answers.partial", answerCounts.partial);
             await withSpan(tracer, "eval.update_session", undefined, () => {
                 const newSession = {
                     sessionId: parsed.sessionId ?? session?.sessionId ?? "unknown",
@@ -222,17 +261,28 @@ Output ONLY the JSON scorecard as before — no commentary.`;
             await withSpan(tracer, "eval.write_scorecard", undefined, async () => {
                 await logWriter.append(scorecard);
                 ingestScorecard(opts.projectRoot, scorecard);
+                logEvalContent("scorecard", JSON.stringify(scorecard), {
+                    "scorecard.question_count": scorecard.questions?.length ?? 0,
+                    "scorecard.summary_length": scorecard.summary?.length ?? 0,
+                });
             });
             return scorecard;
         }
         catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const stack = err instanceof Error ? (err.stack ?? "") : "";
+            rootSpan.setAttribute("scorecard.status", "error");
+            rootSpan.setAttribute("error.message", msg.slice(0, 500));
+            logEvalContent("error", stack || msg, {
+                "error.message": msg.slice(0, 500),
+            });
             const errorEntry = {
                 version: 1,
                 timestamp: new Date().toISOString(),
                 mode: opts.mode,
                 changeId: opts.changeId,
                 error: true,
-                message: err instanceof Error ? err.message : String(err),
+                message: msg,
             };
             await logWriter.append(errorEntry);
             return errorEntry;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@infinitedusky/indusk-mcp",
-	"version": "1.18.1",
+	"version": "1.19.0",
 	"description": "InDusk development system — skills, MCP tools, and CLI for structured AI-assisted development",
 	"type": "module",
 	"files": [
@@ -29,8 +29,11 @@
 	"dependencies": {
 		"@modelcontextprotocol/sdk": "^1.12.1",
 		"@opentelemetry/api": "^1.9.0",
+		"@opentelemetry/api-logs": "^0.214.0",
+		"@opentelemetry/exporter-logs-otlp-http": "^0.214.0",
 		"@opentelemetry/exporter-trace-otlp-http": "^0.214.0",
 		"@opentelemetry/resources": "^2.6.0",
+		"@opentelemetry/sdk-logs": "^0.214.0",
 		"@opentelemetry/sdk-trace-base": "^2.6.0",
 		"@opentelemetry/sdk-trace-node": "^2.6.0",
 		"@opentelemetry/semantic-conventions": "^1.40.0",