@sweny-ai/core 0.1.205 → 0.1.207

package/dist/cli/run-history.js

@@ -201,18 +201,80 @@ export function recordRun(record, cwd = process.cwd()) {
     pruneRuns(cwd);
     return true;
 }
-function isRecord(v) {
-    const r = v;
-    return (!!r &&
-        typeof r === "object" &&
-        r.schema_version === RUN_HISTORY_SCHEMA_VERSION &&
-        typeof r.run_id === "string" &&
-        typeof r.workflow_id === "string" &&
-        typeof r.started_at === "string" &&
-        Array.isArray(r.nodes) &&
-        Array.isArray(r.routes) &&
-        !!r.totals &&
-        typeof r.totals === "object");
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
+const numOrNull = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+const RUNGS = new Set(["expr", "decider", "agent"]);
+/**
+ * A typed, allow-listed copy of a stored record, or null when it is not a run record. History is
+ * agent-writable, so a record is never passed through: only the documented fields are copied, numbers
+ * are made finite, and malformed node, route, harness, degraded and spend entries are dropped. Strings
+ * are kept as read (terminal safety is the printer's job, see `printableRun`).
+ */
+function parseRecord(v) {
+    if (!isObj(v))
+        return null;
+    if (v.schema_version !== RUN_HISTORY_SCHEMA_VERSION ||
+        typeof v.run_id !== "string" ||
+        typeof v.workflow_id !== "string" ||
+        typeof v.started_at !== "string" ||
+        typeof v.status !== "string" ||
+        !Array.isArray(v.nodes) ||
+        !Array.isArray(v.routes) ||
+        !isObj(v.totals)) {
+        return null;
+    }
+    const t = v.totals;
+    const out = {
+        schema_version: RUN_HISTORY_SCHEMA_VERSION,
+        run_id: v.run_id,
+        workflow_id: v.workflow_id,
+        workflow_hash: typeof v.workflow_hash === "string" ? v.workflow_hash : "",
+        started_at: v.started_at,
+        duration_ms: num(v.duration_ms),
+        status: v.status,
+        nodes: v.nodes
+            .filter((n) => isObj(n) && typeof n.id === "string" && typeof n.status === "string")
+            .map((n) => ({
+            id: n.id,
+            status: n.status,
+            duration_ms: num(n.duration_ms),
+            tool_calls: num(n.tool_calls),
+            tokens: numOrNull(n.tokens),
+            cost_usd: numOrNull(n.cost_usd),
+            retries: num(n.retries),
+        })),
+        routes: v.routes
+            .filter((e) => isObj(e) && typeof e.from === "string" && typeof e.to === "string")
+            .map((e) => ({
+            from: e.from,
+            to: e.to,
+            ...(typeof e.rung === "string" && RUNGS.has(e.rung) ? { rung: e.rung } : {}),
+        })),
+        totals: {
+            nodes_total: num(t.nodes_total),
+            nodes_ok: num(t.nodes_ok),
+            nodes_skipped: num(t.nodes_skipped),
+            tool_calls: num(t.tool_calls),
+            tokens: numOrNull(t.tokens),
+            cost_usd: numOrNull(t.cost_usd),
+        },
+    };
+    if (isObj(v.harness) && typeof v.harness.id === "string" && typeof v.harness.version === "string") {
+        out.harness = { id: v.harness.id, version: v.harness.version };
+    }
+    if (Array.isArray(v.degraded))
+        out.degraded = v.degraded.filter((d) => typeof d === "string");
+    if (isObj(v.spend)) {
+        const spend = {};
+        for (const k of SPEND_KINDS) {
+            const e = Object.hasOwn(v.spend, k) ? v.spend[k] : undefined;
+            if (isObj(e))
+                spend[k] = { tokens: num(e.tokens), cost_usd: num(e.cost_usd), calls: num(e.calls) };
+        }
+        out.spend = spend;
+    }
+    return out;
 }
 /**
  * All readable records, newest first. Corrupt files and unknown schema versions
@@ -238,8 +300,9 @@ export function listRuns(cwd = process.cwd()) {
             if (!st.isFile() || st.size > RECORD_READ_MAX_BYTES)
                 continue;
             const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
-            if (isRecord(parsed) && RUN_ID_RE.test(parsed.run_id) && f === `${parsed.run_id}.json`)
-                out.push(parsed);
+            const rec = parseRecord(parsed);
+            if (rec && RUN_ID_RE.test(rec.run_id) && f === `${rec.run_id}.json`)
+                out.push(rec);
         }
         catch {
             // corrupt record: skip

package/dist/cli/runs.d.ts

@@ -10,12 +10,15 @@ import { type RunRecord } from "./run-history.js";
 import { type AnswersComparison } from "./run-answers.js";
 export declare function formatAge(startedAt: string, nowMs?: number): string;
 /**
- * A copy of a history record that is safe to print. `.sweny/runs/` is writable by an agent, so every
- * string read from a record goes through {@link sanitizeTerminal} (control sequences stripped, length
- * capped) and every number is coerced to a finite number. Only for display: matching and `--json`
- * use the record as read.
+ * A copy of a history record that is safe to print and to export. `.sweny/runs/` is writable by an
+ * agent, so the copy is built from an explicit allow-list of typed fields, never by spreading the
+ * record: unknown keys are dropped at every level, every string goes through {@link sanitizeTerminal}
+ * (control sequences stripped, length capped), every number is coerced finite, and malformed node and
+ * route entries are skipped. The table, the diff and every `--json` output use it.
  */
 export declare function printableRun(r: RunRecord): RunRecord;
+/** `sweny runs --json`: the validated records, never the raw ones. */
+export declare function formatRunsJson(records: RunRecord[]): string;
 export declare function formatRunsTable(records: RunRecord[], color: boolean, nowMs?: number, unicode?: boolean): string;
 export interface RunDiffOptions {
     /** Answer comparison for the pair; when set the diff leads with it and ends on its summary line. */

package/dist/cli/runs.js

@@ -51,23 +51,31 @@ function pad(s, w, right = false) {
 // ── History records are untrusted ───────────────────────────────
 const finite = (v) => (typeof v === "number" && Number.isFinite(v) ? v : 0);
 const finiteOrNull = (v) => (typeof v === "number" && Number.isFinite(v) ? v : null);
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const RUNG = new Set(["expr", "decider", "agent"]);
 /**
- * A copy of a history record that is safe to print. `.sweny/runs/` is writable by an agent, so every
- * string read from a record goes through {@link sanitizeTerminal} (control sequences stripped, length
- * capped) and every number is coerced to a finite number. Only for display: matching and `--json`
- * use the record as read.
+ * A copy of a history record that is safe to print and to export. `.sweny/runs/` is writable by an
+ * agent, so the copy is built from an explicit allow-list of typed fields, never by spreading the
+ * record: unknown keys are dropped at every level, every string goes through {@link sanitizeTerminal}
+ * (control sequences stripped, length capped), every number is coerced finite, and malformed node and
+ * route entries are skipped. The table, the diff and every `--json` output use it.
  */
 export function printableRun(r) {
     const t = (v, max = 64) => sanitizeTerminal(v, max);
-    return {
-        ...r,
-        run_id: t(r.run_id),
-        workflow_id: t(r.workflow_id),
-        workflow_hash: t(r.workflow_hash),
-        started_at: t(r.started_at),
-        status: t(r.status, 16),
-        duration_ms: finite(r.duration_ms),
-        nodes: r.nodes.map((n) => ({
+    const rec = r;
+    const list = (v) => (Array.isArray(v) ? v : []);
+    const totals = isObj(rec.totals) ? rec.totals : {};
+    const out = {
+        schema_version: finite(rec.schema_version),
+        run_id: t(rec.run_id),
+        workflow_id: t(rec.workflow_id),
+        workflow_hash: t(rec.workflow_hash),
+        started_at: t(rec.started_at),
+        duration_ms: finite(rec.duration_ms),
+        status: t(rec.status, 16),
+        nodes: list(rec.nodes)
+            .filter(isObj)
+            .map((n) => ({
             id: t(n.id),
             status: t(n.status, 16),
             duration_ms: finite(n.duration_ms),
@@ -76,17 +84,34 @@ export function printableRun(r) {
             cost_usd: finiteOrNull(n.cost_usd),
             retries: finite(n.retries),
         })),
-        routes: r.routes.map((e) => ({ from: t(e.from), to: t(e.to) })),
+        routes: list(rec.routes)
+            .filter((e) => isObj(e) && typeof e.from === "string" && typeof e.to === "string")
+            .map((e) => ({
+            from: t(e.from),
+            to: t(e.to),
+            ...(typeof e.rung === "string" && RUNG.has(e.rung) ? { rung: e.rung } : {}),
+        })),
         totals: {
-            nodes_total: finite(r.totals.nodes_total),
-            nodes_ok: finite(r.totals.nodes_ok),
-            nodes_skipped: finite(r.totals.nodes_skipped),
-            tool_calls: finite(r.totals.tool_calls),
-            tokens: finiteOrNull(r.totals.tokens),
-            cost_usd: finiteOrNull(r.totals.cost_usd),
+            nodes_total: finite(totals.nodes_total),
+            nodes_ok: finite(totals.nodes_ok),
+            nodes_skipped: finite(totals.nodes_skipped),
+            tool_calls: finite(totals.tool_calls),
+            tokens: finiteOrNull(totals.tokens),
+            cost_usd: finiteOrNull(totals.cost_usd),
         },
-        ...(r.spend && typeof r.spend === "object" ? { spend: printableSpend(r.spend) } : {}),
     };
+    if (isObj(rec.harness))
+        out.harness = { id: t(rec.harness.id), version: t(rec.harness.version) };
+    if (Array.isArray(rec.degraded)) {
+        out.degraded = rec.degraded.filter((d) => typeof d === "string").map((d) => t(d));
+    }
+    if (isObj(rec.spend))
+        out.spend = printableSpend(rec.spend);
+    return out;
+}
+/** `sweny runs --json`: the validated records, never the raw ones. */
+export function formatRunsJson(records) {
+    return JSON.stringify(records.map(printableRun), null, 2) + "\n";
 }
 /** The record's split, or its totals as all node spend when it has none. */
 function splitOf(r) {
@@ -432,7 +457,8 @@ export function runRunsDiff(refs, opts, io) {
     const { a, b } = picked;
     const answers = compareAnswers(readRunAnswers(a.run_id, io.cwd), readRunAnswers(b.run_id, io.cwd));
     if (opts.json) {
-        io.stdout.write(JSON.stringify({ schema_version: 1, a, b, answers }, null, 2) + "\n");
+        const body = { schema_version: 1, a: printableRun(a), b: printableRun(b), answers };
+        io.stdout.write(JSON.stringify(body, null, 2) + "\n");
         return 0;
     }
     io.stdout.write("\n" + formatRunDiff(a, b, colorEnabled(io.stdout, env), { answers, unicode: supportsUnicode(env) }) + "\n");
@@ -458,7 +484,7 @@ export function registerRunsCommand(program) {
             runs = runs.filter((r) => r.workflow_id === opts.workflow);
         runs = runs.slice(0, limit);
         if (opts.json) {
-            process.stdout.write(JSON.stringify(runs, null, 2) + "\n");
+            process.stdout.write(formatRunsJson(runs));
             return;
         }
         process.stdout.write("\n" + formatRunsTable(runs, colorEnabled(process.stdout), Date.now(), supportsUnicode()) + "\n");

package/dist/harness/claude-code.js

@@ -528,12 +528,19 @@ export class ClaudeCodeHarness {
         // `sweny tool-bridge` stdio shim instead, so no in-process server is built.
         const useBridge = this.toolBridge && tools.length > 0;
         const sdkTools = useBridge ? [] : tools.map((t) => coreToolToSdkTool(t, this.defaultContext));
-        // Create in-process MCP server
+        // Create in-process MCP server. `alwaysLoad`: Claude Code defers every MCP
+        // server's tools behind ToolSearch by default and starts MCP servers
+        // without waiting, so a node's skill tools were not on the model's first
+        // turn and it could answer without them (dogfood run 42884113267: the
+        // pr-risk-review scope node called only StructuredOutput). These are the
+        // few tools the node was given to do its job; they load up front, and the
+        // query waits for the server before the first turn.
         const mcpServer = useBridge
             ? undefined
             : createSdkMcpServer({
                 name: "sweny-core",
                 tools: sdkTools,
+                alwaysLoad: true,
             });
         let bridge;
         // Build prompt. Context (workflow input such as issues/alerts, plus prior
@@ -565,6 +572,14 @@ export class ClaudeCodeHarness {
             const allMcpServers = mcpWithheld(!!readOnly, agentAccess)
                 ? {}
                 : { ...this.defaultMcpServers, ...opts.mcpServers, ...this.mcpServers };
+            // A server the node's own skills declare (stdio or http) carries tools the
+            // node's checks require, so it loads up front like sweny-core below
+            // (Claude Code otherwise defers them behind ToolSearch). An explicit
+            // `alwaysLoad` in the server config wins.
+            for (const name of Object.keys(opts.mcpServers ?? {})) {
+                if (allMcpServers[name])
+                    allMcpServers[name] = { alwaysLoad: true, ...allMcpServers[name] };
+            }
             if (useBridge) {
                 // Only `tools` (already allow/deny and dry-run filtered by the
                 // executor) are exposed. Under readOnly it is still the only MCP
@@ -575,7 +590,8 @@ export class ClaudeCodeHarness {
                     logger: this.logger,
                     ...(this.toolBridgeShim ? { shimCommand: this.toolBridgeShim } : {}),
                 });
-                allMcpServers["sweny-core"] = bridge.mcpServer;
+                // Same reason as the in-process server: the node's tools load up front.
+                allMcpServers["sweny-core"] = { ...bridge.mcpServer, alwaysLoad: true };
             }
             else if (sdkTools.length > 0) {
                 allMcpServers["sweny-core"] = mcpServer;
@@ -618,6 +634,19 @@ export class ClaudeCodeHarness {
                 },
             });
             for await (const message of stream) {
+                if (message.type === "system" && message.subtype === "init") {
+                    // What the agent was actually given: the tool list (--verbose) and,
+                    // loudly, a node tool server that did not come up.
+                    const init = message;
+                    if (Array.isArray(init.tools))
+                        this.logger.debug(`  agent tools: ${init.tools.join(", ")}`);
+                    const core = Array.isArray(init.mcp_servers)
+                        ? init.mcp_servers.find((s) => s?.name === "sweny-core")
+                        : undefined;
+                    if (allMcpServers["sweny-core"] && core && core.status !== "connected") {
+                        this.logger.warn(`  sweny-core tool server is ${core.status} at start; the node's skill tools may be missing`);
+                    }
+                }
                 if (message.type === "tool_progress") {
                     const tp = message;
                     if (tp.tool_name && typeof tp.elapsed_time_seconds === "number") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.205",
+  "version": "0.1.207",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"