@infinitedusky/indusk-mcp 1.11.7 → 1.12.0

package/dist/bin/commands/eval.js

@@ -48,6 +48,12 @@ export async function evalSummary(projectRoot, opts) {
             console.info(`  ${id.padEnd(20)} ${bar} ${(rate * 100).toFixed(0)}%`);
         }
         console.info(`\nGraphiti writes: ${summary.totalGraphitiWrites}`);
+        if (summary.totalCostUsd > 0) {
+            console.info(`\nCost:`);
+            console.info(`  total:   $${summary.totalCostUsd.toFixed(2)}`);
+            console.info(`  per eval: $${(summary.totalCostUsd / scorecards.length).toFixed(2)}`);
+            console.info(`  tokens:  ${summary.totalInputTokens.toLocaleString()} in / ${summary.totalOutputTokens.toLocaleString()} out`);
+        }
         if (summary.evalCount >= 10) {
             console.info(`\nTrend (last 10 vs previous 10):`);
             for (const [id, delta] of Object.entries(summary.trend)) {
@@ -94,6 +100,9 @@ function computeSummary(scorecards) {
         baselineCount: baselineCards.length,
         passRates,
         totalGraphitiWrites: scorecards.reduce((sum, s) => sum + s.graphitiWrites, 0),
+        totalCostUsd: scorecards.reduce((sum, s) => sum + (s.usage?.costUsd ?? 0), 0),
+        totalInputTokens: scorecards.reduce((sum, s) => sum + (s.usage?.inputTokens ?? 0) + (s.usage?.cacheReadTokens ?? 0), 0),
+        totalOutputTokens: scorecards.reduce((sum, s) => sum + (s.usage?.outputTokens ?? 0), 0),
         trend,
     };
 }

package/dist/lib/eval/judge-runner.js

@@ -91,12 +91,24 @@ export function runJudgeBackground(opts) {
             if (code !== 0) {
                 throw new Error(`claude exited with code ${code}: ${stderr.slice(0, 500)}`);
             }
-            // --output-format json wraps the result; extract the text content
+            // --output-format json wraps the result; extract the text content and usage
             let scorecardText = stdout;
+            let usage;
             try {
                 const jsonOutput = JSON.parse(stdout);
-                // claude --print --output-format json returns { result: string } or similar
                 scorecardText = jsonOutput.result ?? jsonOutput.text ?? jsonOutput.content ?? stdout;
+                // Capture usage data from claude --print output
+                if (jsonOutput.total_cost_usd !== undefined || jsonOutput.usage) {
+                    const u = jsonOutput.usage ?? {};
+                    usage = {
+                        costUsd: jsonOutput.total_cost_usd ?? 0,
+                        inputTokens: u.input_tokens ?? 0,
+                        outputTokens: u.output_tokens ?? 0,
+                        cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+                        cacheReadTokens: u.cache_read_input_tokens ?? 0,
+                        durationMs: jsonOutput.duration_ms ?? 0,
+                    };
+                }
             }
             catch {
                 // stdout might be raw JSON scorecard already
@@ -107,6 +119,8 @@ export function runJudgeBackground(opts) {
                 scorecardText = jsonMatch[1];
             }
             const scorecard = JSON.parse(scorecardText.trim());
+            if (usage)
+                scorecard.usage = usage;
             scorecard.telemetryPosted = false;
             if (opts.evalEndpoint) {
                 await postTelemetry(opts.evalEndpoint, scorecard);
@@ -184,9 +198,21 @@ export async function runJudgeSync(opts) {
                     throw new Error(`claude exited with code ${code}: ${stderr.slice(0, 500)}`);
                 }
                 let scorecardText = stdout;
+                let syncUsage;
                 try {
                     const jsonOutput = JSON.parse(stdout);
                     scorecardText = jsonOutput.result ?? jsonOutput.text ?? jsonOutput.content ?? stdout;
+                    if (jsonOutput.total_cost_usd !== undefined || jsonOutput.usage) {
+                        const u = jsonOutput.usage ?? {};
+                        syncUsage = {
+                            costUsd: jsonOutput.total_cost_usd ?? 0,
+                            inputTokens: u.input_tokens ?? 0,
+                            outputTokens: u.output_tokens ?? 0,
+                            cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+                            cacheReadTokens: u.cache_read_input_tokens ?? 0,
+                            durationMs: jsonOutput.duration_ms ?? 0,
+                        };
+                    }
                 }
                 catch {
                     // raw JSON
@@ -196,6 +222,8 @@ export async function runJudgeSync(opts) {
                     scorecardText = jsonMatch[1];
                 }
                 const scorecard = JSON.parse(scorecardText.trim());
+                if (syncUsage)
+                    scorecard.usage = syncUsage;
                 scorecard.telemetryPosted = false;
                 if (opts.evalEndpoint) {
                     await postTelemetry(opts.evalEndpoint, scorecard);

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

@@ -17,6 +17,14 @@ export interface EvalQuestion {
     evidence: string;
     finding: string;
 }
+export interface EvalUsage {
+    costUsd: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    durationMs: number;
+}
 export interface EvalScorecard {
     version: 1;
     timestamp: string;
@@ -27,6 +35,7 @@ export interface EvalScorecard {
     summary: string;
     graphitiWrites: number;
     telemetryPosted: boolean;
+    usage?: EvalUsage;
 }
 export interface EvalErrorEntry {
     version: 1;

package/dist/server/index.js

@@ -1,3 +1,13 @@
+process.on("uncaughtException", (err) => {
+    console.error(`[indusk] uncaught exception: ${err.message}`);
+    if (err.stack)
+        console.error(err.stack);
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error(`[indusk] unhandled rejection: ${reason}`);
+    process.exit(1);
+});
 import { readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -32,19 +42,32 @@ function checkForUpdates(currentVersion) {
 export async function startServer() {
     const projectRoot = resolve(process.env.PROJECT_ROOT ?? ".");
     const version = getLocalVersion();
+    console.error(`[indusk] v${version} starting (project: ${projectRoot})`);
     // Non-blocking version check
     checkForUpdates(version);
-    const server = new McpServer({
-        name: "indusk",
-        version,
-    });
-    registerPlanTools(server, projectRoot);
-    registerContextTools(server, projectRoot);
-    registerQualityTools(server, projectRoot);
-    registerDocumentTools(server, projectRoot);
-    registerSystemTools(server, projectRoot);
-    registerGraphTools(server, projectRoot);
-    registerLessonTools(server, projectRoot);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+    try {
+        const server = new McpServer({
+            name: "indusk",
+            version,
+        });
+        console.error("[indusk] registering tools...");
+        registerPlanTools(server, projectRoot);
+        registerContextTools(server, projectRoot);
+        registerQualityTools(server, projectRoot);
+        registerDocumentTools(server, projectRoot);
+        registerSystemTools(server, projectRoot);
+        registerGraphTools(server, projectRoot);
+        registerLessonTools(server, projectRoot);
+        console.error("[indusk] tools registered");
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        console.error("[indusk] connected via stdio");
+    }
+    catch (err) {
+        console.error(`[indusk] FATAL: ${err instanceof Error ? err.message : String(err)}`);
+        if (err instanceof Error && err.stack) {
+            console.error(err.stack);
+        }
+        process.exit(1);
+    }
 }

package/hooks/eval-trigger.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+
 /**
  * PostToolUse hook: triggers the eval judge after `jj describe`.
  *
@@ -9,9 +10,9 @@
  * Exit 0 always — this is advisory, not blocking.
  */
 
-import { existsSync, readFileSync } from "node:fs";
 import { execSync, spawn } from "node:child_process";
-import { resolve, dirname } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // Read hook input from stdin
@@ -85,15 +86,64 @@ try {
 // Claude Code provides CLAUDE_TRANSCRIPT_PATH in the environment when hooks run,
 // or we can search for the most recent transcript.
 const transcriptPath =
-	process.env.CLAUDE_TRANSCRIPT_PATH ??
-	process.env.TRANSCRIPT_PATH ??
-	"(transcript unavailable)";
+	process.env.CLAUDE_TRANSCRIPT_PATH ?? process.env.TRANSCRIPT_PATH ?? "(transcript unavailable)";
+
+// Find the indusk-mcp package — resolve from the hook's own location.
+// The hook lives at .claude/hooks/eval-trigger.js but was copied from the package's hooks/ dir.
+// Try multiple resolution strategies:
+// 1. Relative to the hook's original package location (when run from the package source)
+// 2. Via npx cache / global install
+// 3. Via the project's node_modules
+const hookDir = dirname(fileURLToPath(import.meta.url));
+const candidates = [
+	// Source repo (apps/indusk-mcp/hooks/ → apps/indusk-mcp/dist/)
+	resolve(hookDir, "../dist/lib/eval/judge-runner.js"),
+	// Installed package (hooks/ → dist/)
+	resolve(hookDir, "../../node_modules/@infinitedusky/indusk-mcp/dist/lib/eval/judge-runner.js"),
+	// Global npx cache
+	...(() => {
+		try {
+			const which = execSync("which indusk", { encoding: "utf8" }).trim();
+			if (which)
+				return [
+					resolve(
+						dirname(which),
+						"../lib/node_modules/@infinitedusky/indusk-mcp/dist/lib/eval/judge-runner.js",
+					),
+				];
+		} catch {}
+		return [];
+	})(),
+];
+let judgeRunnerPath = null;
+for (const c of candidates) {
+	if (existsSync(c)) {
+		judgeRunnerPath = c;
+		break;
+	}
+}
+
+if (!judgeRunnerPath) {
+	// Can't find the package — log error and exit
+	const { mkdirSync, appendFileSync } = await import("node:fs");
+	const logPath = resolve(projectRoot, ".indusk", "eval", "results.log");
+	mkdirSync(dirname(logPath), { recursive: true });
+	const entry = JSON.stringify({
+		version: 1,
+		timestamp: new Date().toISOString(),
+		mode: "eval",
+		changeId,
+		error: true,
+		message:
+			"Could not find @infinitedusky/indusk-mcp package — eval judge not available. Run: npm i -g @infinitedusky/indusk-mcp",
+	});
+	appendFileSync(logPath, entry + "\n", "utf8");
+	process.exit(0);
+}
 
-// Spawn the judge runner as a detached background process.
 // Spawn a detached node process that calls runJudgeSync (which awaits completion).
-// runJudgeSync keeps the process alive until claude --print finishes and logs the result.
 const judgeScript = `
-import("${resolve(projectRoot, "apps/indusk-mcp/dist/lib/eval/judge-runner.js")}")
+import("${judgeRunnerPath}")
   .then(m => m.runJudgeSync({
     projectRoot: ${JSON.stringify(projectRoot)},
     changeId: ${JSON.stringify(changeId)},
@@ -137,6 +187,8 @@ const output = JSON.stringify({
 	},
 });
 process.stdout.write(output);
-process.stderr.write(`📊 Eval judge spawned in background for ${changeId.slice(0, 8)}. Results will appear in .indusk/eval/results.log\n`);
+process.stderr.write(
+	`📊 Eval judge spawned in background for ${changeId.slice(0, 8)}. Results will appear in .indusk/eval/results.log\n`,
+);
 
 process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@infinitedusky/indusk-mcp",
-	"version": "1.11.7",
+	"version": "1.12.0",
 	"description": "InDusk development system — skills, MCP tools, and CLI for structured AI-assisted development",
 	"type": "module",
 	"files": [