@kweaver-ai/kweaver-sdk 0.7.4 → 0.8.1

package/dist/trace-core/diagnose/builtin-rules/retrieval-empty-no-fallback.js

@@ -0,0 +1,29 @@
+function resultCount(s) {
+    const v = s.attributes["gen_ai.retrieval.result_count"];
+    return typeof v === "number" ? v : null;
+}
+export const predicate = (trace) => {
+    const ordered = trace.spans
+        .slice()
+        .sort((a, b) => Number(BigInt(a.startTimeUnixNano) - BigInt(b.startTimeUnixNano)));
+    const hits = [];
+    for (let i = 0; i < ordered.length; i++) {
+        const s = ordered[i];
+        if (s.kind !== "retrieval")
+            continue;
+        if (resultCount(s) !== 0)
+            continue;
+        const next = ordered[i + 1];
+        if (!next)
+            continue;
+        if (next.kind === "llm") {
+            hits.push({
+                evidenceSpans: [s.spanId, next.spanId],
+                excerpt: `retrieval returned 0 results; next step was LLM generation with no fallback path`,
+                bindings: {},
+            });
+        }
+        // retrieval (retry/rewrite) or tool (alt source) → no hit
+    }
+    return hits;
+};

package/dist/trace-core/diagnose/builtin-rules/retrieval-empty-no-fallback.yaml

@@ -0,0 +1,15 @@
+schema_version: diagnosis-rule/v1
+id: retrieval_empty_no_fallback
+severity: medium
+symptom: empty_retrieval_result_no_fallback_path
+taxonomy:
+  signals_axis: execution
+  ms_class: cascading_error
+suggested_fix:
+  target: decision_agent.prompt
+  change_template: "when retrieval returns 0 results, branch to query rewrite, alternate source, or explicit 'no answer' before generating"
+verify_with:
+  assertion_templates:
+    - "if(retrieval.result_count == 0): next_step in [retry, rewrite, alt_source, no_answer]"
+predicate: builtin:retrieval_empty_no_fallback
+params: {}

package/dist/trace-core/diagnose/builtin-rules/tool-error-swallowed.d.ts

@@ -0,0 +1,2 @@
+import type { Predicate } from "../types.js";
+export declare const predicate: Predicate;

package/dist/trace-core/diagnose/builtin-rules/tool-error-swallowed.js

@@ -0,0 +1,45 @@
+function getPrompt(s) {
+    const v = s.attributes["gen_ai.prompt"] ?? s.attributes["llm.prompt"];
+    return typeof v === "string" ? v : "";
+}
+function getErrorMessage(s) {
+    const v = s.attributes["error.message"];
+    return typeof v === "string" ? v : "";
+}
+function getToolName(s) {
+    const v = s.attributes["gen_ai.tool.name"];
+    return typeof v === "string" ? v : s.name;
+}
+export const predicate = (trace) => {
+    const allSpans = trace.spans
+        .slice()
+        .sort((a, b) => Number(BigInt(a.startTimeUnixNano) - BigInt(b.startTimeUnixNano)));
+    const hits = [];
+    for (let i = 0; i < allSpans.length; i++) {
+        const s = allSpans[i];
+        if (s.kind !== "tool" || s.status !== "error")
+            continue;
+        const errMsg = getErrorMessage(s);
+        const toolName = getToolName(s);
+        // find next LLM span
+        let next;
+        for (let j = i + 1; j < allSpans.length; j++) {
+            if (allSpans[j].kind === "llm") {
+                next = allSpans[j];
+                break;
+            }
+        }
+        if (!next)
+            continue;
+        const prompt = getPrompt(next).toLowerCase();
+        const errInPrompt = errMsg.length > 0 && prompt.includes(errMsg.toLowerCase());
+        if (!errInPrompt) {
+            hits.push({
+                evidenceSpans: [s.spanId, next.spanId],
+                excerpt: `tool '${toolName}' errored ('${errMsg}') but next LLM prompt did not propagate the error`,
+                bindings: { tool_name: toolName, error_message: errMsg },
+            });
+        }
+    }
+    return hits;
+};

package/dist/trace-core/diagnose/builtin-rules/tool-error-swallowed.yaml

@@ -0,0 +1,15 @@
+schema_version: diagnosis-rule/v1
+id: tool_error_swallowed
+severity: high
+symptom: tool_error_not_propagated_to_next_prompt
+taxonomy:
+  signals_axis: execution
+  ms_class: cascading_error
+suggested_fix:
+  target: decision_agent.prompt
+  change_template: "after tool '{{tool_name}}' errors, include error.message in the next LLM prompt or take a recovery branch"
+verify_with:
+  assertion_templates:
+    - "next_llm_prompt_after({{tool_name}}_error).contains(error.message)"
+predicate: builtin:tool_error_swallowed
+params: {}

package/dist/trace-core/diagnose/builtin-rules/tool-loop-no-state-change.d.ts

@@ -0,0 +1,2 @@
+import type { Predicate } from "../types.js";
+export declare const predicate: Predicate;

package/dist/trace-core/diagnose/builtin-rules/tool-loop-no-state-change.js

@@ -0,0 +1,38 @@
+const STATE_KEY = "gen_ai.conversation.state";
+function toolName(s) {
+    const v = s.attributes["gen_ai.tool.name"];
+    return typeof v === "string" ? v : s.name;
+}
+function deepEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b); // PR-A: simple JSON compare; sufficient for tool args
+}
+export const predicate = (trace, params) => {
+    const minConsecutive = params.min_consecutive ?? 3;
+    const tools = (trace.byKind.get("tool") ?? []).slice().sort((a, b) => Number(BigInt(a.startTimeUnixNano) - BigInt(b.startTimeUnixNano)));
+    const hits = [];
+    let i = 0;
+    while (i < tools.length) {
+        const start = tools[i];
+        const startName = toolName(start);
+        const startArgs = start.attributes["gen_ai.tool.args"];
+        const startState = start.attributes[STATE_KEY];
+        let j = i + 1;
+        while (j < tools.length &&
+            toolName(tools[j]) === startName &&
+            deepEqual(tools[j].attributes["gen_ai.tool.args"], startArgs) &&
+            // state unchanged across the run (or both undefined)
+            (tools[j].attributes[STATE_KEY] === startState || (startState === undefined && tools[j].attributes[STATE_KEY] === undefined)))
+            j++;
+        const runLen = j - i;
+        if (runLen >= minConsecutive) {
+            const evidenceSpans = tools.slice(i, j).map((s) => s.spanId);
+            hits.push({
+                evidenceSpans,
+                excerpt: `tool '${startName}' called ${runLen} times consecutively with identical args; conversation state unchanged`,
+                bindings: { tool_name: startName, loop_count: runLen, max_count: minConsecutive - 1 },
+            });
+        }
+        i = j;
+    }
+    return hits;
+};

package/dist/trace-core/diagnose/builtin-rules/tool-loop-no-state-change.yaml

@@ -0,0 +1,16 @@
+schema_version: diagnosis-rule/v1
+id: tool_loop_no_state_change
+severity: high
+symptom: repeated_tool_call_without_state_change
+taxonomy:
+  signals_axis: execution
+  ms_class: retry_loop
+suggested_fix:
+  target: decision_agent.prompt
+  change_template: "add stop condition after {{loop_count}} equivalent failed retrievals of '{{tool_name}}'"
+verify_with:
+  assertion_templates:
+    - "tool_call_count({{tool_name}}) <= {{max_count}}"
+predicate: builtin:tool_loop_no_state_change
+params:
+  min_consecutive: 3

package/dist/trace-core/diagnose/index.d.ts

@@ -0,0 +1,9 @@
+import { RuleLoadError } from "./rule-loader.js";
+import { RuleProbeError } from "./signal-probe.js";
+import type { DiagnoseOpts, Report } from "./types.js";
+import "./builtin-rules/register.js";
+export declare class TraceNotFoundError extends Error {
+    constructor(conversationId: string);
+}
+export declare function diagnose(conversationId: string, opts: DiagnoseOpts): Promise<Report>;
+export { TraceNotFoundError as DiagnoseTraceNotFound, RuleLoadError, RuleProbeError };

package/dist/trace-core/diagnose/index.js

@@ -0,0 +1,104 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import { fileURLToPath } from "node:url";
+import { getSpansByConversationId } from "../../api/trace.js";
+import { assembleTraceTree } from "./trace-shaper.js";
+import { loadRules, RuleLoadError } from "./rule-loader.js";
+import { runRules, RuleProbeError } from "./signal-probe.js";
+import { templateSynthesize } from "./synthesizer-template.js";
+import { assembleReport, reportToYamlObject } from "./report-assembler.js";
+import "./builtin-rules/register.js"; // side effect: registers all builtin predicates
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const BUILTIN_DIR = path.join(__dirname, "builtin-rules");
+export class TraceNotFoundError extends Error {
+    constructor(conversationId) {
+        super(`no spans found for conversation: ${conversationId}`);
+        this.name = "TraceNotFoundError";
+    }
+}
+export async function diagnose(conversationId, opts) {
+    // PR-A: opts.noLlm, opts.agentProvider, opts.timeoutMs are reserved for PR-B's
+    // agent / rubric path; they are accepted by the interface but not consumed here.
+    const cwdRulesDir = opts.rulesDir ?? path.join(process.cwd(), "diagnosis-rules");
+    const fetched = await getSpansByConversationId({
+        baseUrl: opts.baseUrl,
+        token: opts.token,
+        businessDomain: opts.businessDomain,
+        conversationId,
+    });
+    const rawSpans = fetched.spans;
+    if (rawSpans.length === 0)
+        throw new TraceNotFoundError(conversationId);
+    // A conversation may produce multiple OTel traces (one per turn). PR-A
+    // diagnose is single-trace: pick the first observed traceId; warn on extras.
+    const observedTraceIds = fetched.traceIds.length > 0
+        ? fetched.traceIds
+        : [...new Set(rawSpans.map((s) => s.traceId).filter((t) => Boolean(t)))];
+    const primaryTraceId = observedTraceIds[0] ?? conversationId;
+    if (observedTraceIds.length > 1) {
+        process.stderr.write(`warning: conversation ${conversationId} has ${observedTraceIds.length} traces; diagnosing the first (${primaryTraceId})\n`);
+    }
+    const spansForPrimary = observedTraceIds.length > 0
+        ? rawSpans.filter((s) => !s.traceId || s.traceId === primaryTraceId)
+        : rawSpans;
+    const tree = assembleTraceTree(primaryTraceId, spansForPrimary);
+    const rules = await loadRules({
+        builtinDir: BUILTIN_DIR,
+        cwdRulesDir,
+        extraRulesDir: null,
+        noBuiltin: opts.noBuiltin,
+    });
+    const hits = await runRules(rules, tree);
+    const version = await cliVersion();
+    // Build provisional findings list to feed the synthesizer.
+    const provisionalReport = assembleReport({
+        traceId: primaryTraceId,
+        agentId: extractAgentId(tree),
+        tenant: extractTenant(tree),
+        cliVersion: version,
+        rules,
+        hits,
+        summary: { headline: "", primaryRootCause: null, fixPriority: [], crossFindingLinks: [] },
+    });
+    const summary = templateSynthesize(provisionalReport.findings);
+    const report = { ...provisionalReport, summary };
+    if (opts.out !== null) {
+        await fs.mkdir(path.dirname(opts.out), { recursive: true });
+        await fs.writeFile(opts.out, yaml.dump(reportToYamlObject(report)), "utf8");
+    }
+    else {
+        process.stdout.write(yaml.dump(reportToYamlObject(report)));
+    }
+    if (report.findings.length === 0) {
+        process.stderr.write("no findings\n");
+    }
+    return report;
+}
+function extractAgentId(tree) {
+    for (const s of tree.spans) {
+        const v = s.attributes["gen_ai.agent.id"];
+        if (typeof v === "string")
+            return v;
+    }
+    return null;
+}
+function extractTenant(tree) {
+    for (const s of tree.spans) {
+        const v = s.attributes["tenant"];
+        if (typeof v === "string")
+            return v;
+    }
+    return null;
+}
+async function cliVersion() {
+    try {
+        const pkgPath = path.join(__dirname, "..", "..", "..", "package.json");
+        const txt = await fs.readFile(pkgPath, "utf8");
+        return JSON.parse(txt).version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+export { TraceNotFoundError as DiagnoseTraceNotFound, RuleLoadError, RuleProbeError };

package/dist/trace-core/diagnose/predicate-registry.d.ts

@@ -0,0 +1,7 @@
+import type { Predicate } from "./types.js";
+export declare class PredicateNotFoundError extends Error {
+    constructor(name: string);
+}
+export declare function registerPredicate(name: string, fn: Predicate): void;
+export declare function resolvePredicate(ref: string): Predicate;
+export declare function clearRegistry(): void;

package/dist/trace-core/diagnose/predicate-registry.js

@@ -0,0 +1,30 @@
+export class PredicateNotFoundError extends Error {
+    constructor(name) {
+        super(`predicate not registered: ${name}`);
+        this.name = "PredicateNotFoundError";
+    }
+}
+const REGISTRY = new Map();
+export function registerPredicate(name, fn) {
+    if (REGISTRY.has(name)) {
+        throw new Error(`predicate already registered: ${name}`);
+    }
+    REGISTRY.set(name, fn);
+}
+export function resolvePredicate(ref) {
+    const m = ref.match(/^([a-z-]+):(.+)$/);
+    if (!m)
+        throw new Error(`malformed predicate ref: ${ref}`);
+    const [, scheme, name] = m;
+    if (scheme !== "builtin") {
+        throw new Error(`unsupported predicate scheme: ${scheme} (only 'builtin:' is allowed in PR-A)`);
+    }
+    const fn = REGISTRY.get(name);
+    if (!fn)
+        throw new PredicateNotFoundError(name);
+    return fn;
+}
+// Test-only escape hatch.
+export function clearRegistry() {
+    REGISTRY.clear();
+}

package/dist/trace-core/diagnose/report-assembler.d.ts

@@ -0,0 +1,12 @@
+import type { Hit, Report, Rule, Summary } from "./types.js";
+export interface AssembleReportOpts {
+    traceId: string;
+    agentId: string | null;
+    tenant: string | null;
+    cliVersion: string;
+    rules: Rule[];
+    hits: Map<string, Hit[]>;
+    summary: Summary;
+}
+export declare function assembleReport(opts: AssembleReportOpts): Report;
+export declare function reportToYamlObject(r: Report): unknown;

package/dist/trace-core/diagnose/report-assembler.js

@@ -0,0 +1,90 @@
+function renderTemplate(tpl, bindings) {
+    return tpl.replace(/{{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*}}/g, (_, key) => {
+        const v = bindings[key];
+        return v === undefined ? `{{${key}}}` : String(v);
+    });
+}
+export function assembleReport(opts) {
+    const findings = [];
+    for (const rule of opts.rules) {
+        const ruleHits = opts.hits.get(rule.id) ?? [];
+        for (const hit of ruleHits) {
+            findings.push({
+                ruleId: rule.id,
+                judgmentKind: "symbolic",
+                severity: rule.severity,
+                symptom: rule.symptom,
+                likelyCause: rule.symptom, // PR-A: no LLM, so we mirror symptom; PR-B agent overrides this
+                evidence: { spans: hit.evidenceSpans, excerpt: hit.excerpt },
+                suggestedFix: {
+                    target: rule.suggestedFix.target,
+                    change: renderTemplate(rule.suggestedFix.changeTemplate, hit.bindings),
+                },
+                confidence: "low",
+                verifyWith: {
+                    suggestedEvalCase: {
+                        queryId: null, // PR-A: no query extraction yet (deferred per spec)
+                        query: null,
+                        assertions: rule.verifyWith.assertionTemplates.map((t) => renderTemplate(t, hit.bindings)),
+                    },
+                },
+            });
+        }
+    }
+    return {
+        schemaVersion: "trace-diagnose-report/v1",
+        trace: { traceId: opts.traceId, agentId: opts.agentId, tenant: opts.tenant },
+        run: {
+            diagnosedAt: new Date().toISOString(),
+            cliVersion: opts.cliVersion,
+            mode: "symbolic-only",
+            rulesApplied: opts.rules.map((r) => r.id),
+            rulesSkipped: [],
+            synthesizerMode: "template",
+        },
+        summary: opts.summary,
+        findings,
+    };
+}
+// Convert internal camelCase Report to the snake_case shape used by ReportSchema (and by yaml output).
+export function reportToYamlObject(r) {
+    return {
+        schema_version: r.schemaVersion,
+        trace: { trace_id: r.trace.traceId, agent_id: r.trace.agentId, tenant: r.trace.tenant },
+        run: {
+            diagnosed_at: r.run.diagnosedAt,
+            cli_version: r.run.cliVersion,
+            mode: r.run.mode,
+            rules_applied: r.run.rulesApplied,
+            rules_skipped: r.run.rulesSkipped.map((s) => ({ rule_id: s.ruleId, reason: s.reason })),
+            synthesizer_mode: r.run.synthesizerMode,
+        },
+        summary: {
+            headline: r.summary.headline,
+            primary_root_cause: r.summary.primaryRootCause === null ? null : {
+                finding_ids: r.summary.primaryRootCause.findingIds,
+                description: r.summary.primaryRootCause.description,
+                target_for_fix: r.summary.primaryRootCause.targetForFix,
+            },
+            fix_priority: r.summary.fixPriority.map((p) => ({ finding_id: p.findingId, reason: p.reason })),
+            cross_finding_links: r.summary.crossFindingLinks.map((l) => ({ finding_ids: l.findingIds, relation: l.relation })),
+        },
+        findings: r.findings.map((f) => ({
+            rule_id: f.ruleId,
+            judgment_kind: f.judgmentKind,
+            severity: f.severity,
+            symptom: f.symptom,
+            likely_cause: f.likelyCause,
+            evidence: { spans: f.evidence.spans, excerpt: f.evidence.excerpt },
+            suggested_fix: { target: f.suggestedFix.target, change: f.suggestedFix.change },
+            confidence: f.confidence,
+            verify_with: {
+                suggested_eval_case: {
+                    query_id: f.verifyWith.suggestedEvalCase.queryId,
+                    query: f.verifyWith.suggestedEvalCase.query,
+                    assertions: f.verifyWith.suggestedEvalCase.assertions,
+                },
+            },
+        })),
+    };
+}

package/dist/trace-core/diagnose/rule-loader.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from "./types.js";
+export declare class RuleLoadError extends Error {
+    constructor(message: string);
+}
+export interface LoadRulesOpts {
+    builtinDir: string | null;
+    cwdRulesDir: string | null;
+    extraRulesDir: string | null;
+    noBuiltin: boolean;
+}
+export declare function loadRules(opts: LoadRulesOpts): Promise<Rule[]>;

package/dist/trace-core/diagnose/rule-loader.js

@@ -0,0 +1,86 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import { RuleSchema } from "./schemas.js";
+import { resolvePredicate } from "./predicate-registry.js";
+export class RuleLoadError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RuleLoadError";
+    }
+}
+async function listYamls(dir) {
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isFile() && (e.name.endsWith(".yaml") || e.name.endsWith(".yml")))
+            .map((e) => path.join(dir, e.name));
+    }
+    catch (e) {
+        const err = e;
+        if (err.code === "ENOENT")
+            return [];
+        throw err;
+    }
+}
+async function parseOne(filePath) {
+    const raw = await fs.readFile(filePath, "utf8");
+    let parsed;
+    try {
+        parsed = yaml.load(raw);
+    }
+    catch (e) {
+        throw new RuleLoadError(`yaml parse error in ${filePath}: ${e.message}`);
+    }
+    const result = RuleSchema.safeParse(parsed);
+    if (!result.success) {
+        throw new RuleLoadError(`schema validation failed for ${filePath}: ${result.error.issues.map((i) => `${i.path.join('.')}: ${i.message}`).join('; ')}`);
+    }
+    const r = result.data;
+    if (!r.predicate) {
+        throw new RuleLoadError(`PR-A only supports symbolic rules; ${filePath} has no predicate`);
+    }
+    // resolvePredicate throws PredicateNotFoundError; rewrap for uniform caller experience.
+    try {
+        resolvePredicate(r.predicate);
+    }
+    catch (e) {
+        throw new RuleLoadError(`${filePath}: ${e.message}`);
+    }
+    return {
+        schemaVersion: r.schema_version,
+        id: r.id,
+        severity: r.severity,
+        symptom: r.symptom,
+        taxonomy: { signalsAxis: r.taxonomy.signals_axis, msClass: r.taxonomy.ms_class },
+        suggestedFix: { target: r.suggested_fix.target, changeTemplate: r.suggested_fix.change_template },
+        verifyWith: { assertionTemplates: r.verify_with.assertion_templates },
+        predicateRef: r.predicate,
+        params: r.params,
+        sourcePath: filePath,
+    };
+}
+export async function loadRules(opts) {
+    const dirs = [];
+    if (opts.builtinDir && !opts.noBuiltin)
+        dirs.push(opts.builtinDir);
+    if (opts.cwdRulesDir)
+        dirs.push(opts.cwdRulesDir);
+    if (opts.extraRulesDir)
+        dirs.push(opts.extraRulesDir);
+    const seenIds = new Map(); // id → first path
+    const rules = [];
+    for (const dir of dirs) {
+        const yamls = await listYamls(dir);
+        for (const f of yamls) {
+            const r = await parseOne(f);
+            const prev = seenIds.get(r.id);
+            if (prev) {
+                throw new RuleLoadError(`rule id conflict for '${r.id}': defined in both ${prev} and ${f}`);
+            }
+            seenIds.set(r.id, f);
+            rules.push(r);
+        }
+    }
+    return rules;
+}

package/dist/trace-core/diagnose/schemas.d.ts

@@ -0,0 +1,109 @@
+import { z } from "zod";
+export declare const RuleSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"diagnosis-rule/v1">;
+    id: z.ZodString;
+    severity: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+    symptom: z.ZodString;
+    taxonomy: z.ZodObject<{
+        signals_axis: z.ZodEnum<{
+            interaction: "interaction";
+            execution: "execution";
+            environment: "environment";
+        }>;
+        ms_class: z.ZodEnum<{
+            retry_loop: "retry_loop";
+            tool_misuse: "tool_misuse";
+            context_loss: "context_loss";
+            goal_drift: "goal_drift";
+            cascading_error: "cascading_error";
+            silent_quality_degradation: "silent_quality_degradation";
+        }>;
+    }, z.core.$strip>;
+    suggested_fix: z.ZodObject<{
+        target: z.ZodString;
+        change_template: z.ZodString;
+    }, z.core.$strip>;
+    verify_with: z.ZodObject<{
+        assertion_templates: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    predicate: z.ZodOptional<z.ZodString>;
+    rubric: z.ZodOptional<z.ZodUnknown>;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type RuleYaml = z.infer<typeof RuleSchema>;
+export declare const ReportSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"trace-diagnose-report/v1">;
+    trace: z.ZodObject<{
+        trace_id: z.ZodString;
+        agent_id: z.ZodNullable<z.ZodString>;
+        tenant: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    run: z.ZodObject<{
+        diagnosed_at: z.ZodString;
+        cli_version: z.ZodString;
+        mode: z.ZodEnum<{
+            "symbolic-only": "symbolic-only";
+            "rubric-only": "rubric-only";
+            hybrid: "hybrid";
+        }>;
+        rules_applied: z.ZodArray<z.ZodString>;
+        rules_skipped: z.ZodArray<z.ZodObject<{
+            rule_id: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
+        synthesizer_mode: z.ZodEnum<{
+            agent: "agent";
+            template: "template";
+        }>;
+    }, z.core.$strip>;
+    summary: z.ZodObject<{
+        headline: z.ZodString;
+        primary_root_cause: z.ZodNullable<z.ZodObject<{
+            finding_ids: z.ZodArray<z.ZodNumber>;
+            description: z.ZodString;
+            target_for_fix: z.ZodString;
+        }, z.core.$strip>>;
+        fix_priority: z.ZodArray<z.ZodObject<{
+            finding_id: z.ZodNumber;
+            reason: z.ZodString;
+        }, z.core.$strip>>;
+        cross_finding_links: z.ZodArray<z.ZodObject<{
+            finding_ids: z.ZodArray<z.ZodNumber>;
+            relation: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    findings: z.ZodArray<z.ZodObject<{
+        rule_id: z.ZodString;
+        judgment_kind: z.ZodEnum<{
+            symbolic: "symbolic";
+        }>;
+        severity: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        symptom: z.ZodString;
+        likely_cause: z.ZodString;
+        evidence: z.ZodObject<{
+            spans: z.ZodArray<z.ZodString>;
+            excerpt: z.ZodString;
+        }, z.core.$strip>;
+        suggested_fix: z.ZodObject<{
+            target: z.ZodString;
+            change: z.ZodString;
+        }, z.core.$strip>;
+        confidence: z.ZodLiteral<"low">;
+        verify_with: z.ZodObject<{
+            suggested_eval_case: z.ZodObject<{
+                query_id: z.ZodNullable<z.ZodString>;
+                query: z.ZodNullable<z.ZodString>;
+                assertions: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ReportYaml = z.infer<typeof ReportSchema>;