@ggui-ai/negotiator 0.1.0-rc.1

package/dist/rerank-eval/run-probe.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Rerank quality probe.
+ *
+ * Runs the configured `LLMCaller` over the {@link EVAL_PAIRS} eval
+ * set and returns precision@1 + adversarial false-positive +
+ * latency p95. The caller compares these against the quality gates
+ * (precision, adversarial false-positive rate, latency, cost)
+ * reported by the probe CLI.
+ *
+ * Eval-only — not exported from the package index.
+ */
+import { type RerankDecision } from '../llm-rerank.js';
+import type { LLMCaller } from '../llm-caller.js';
+import { type EvalPair } from './pairs.js';
+export interface ProbeOutcome {
+    readonly pair: EvalPair;
+    readonly decision: RerankDecision;
+    /** Confidence threshold applied to compute correctness. */
+    readonly threshold: number;
+    /** Predicted matchId AFTER threshold gate (null if confidence below). */
+    readonly predictedMatchId: string | null;
+    /** Was the prediction correct vs gold? */
+    readonly correct: boolean;
+}
+export interface ProbeReport {
+    readonly outcomes: readonly ProbeOutcome[];
+    readonly totals: {
+        readonly all: number;
+        readonly correct: number;
+        readonly precision: number;
+    };
+    readonly byKind: Readonly<{
+        [K in EvalPair['kind']]: {
+            readonly all: number;
+            readonly correct: number;
+            readonly precision: number;
+        };
+    }>;
+    readonly adversarialFalsePositiveRate: number;
+    readonly latency: {
+        readonly p50Ms: number;
+        readonly p95Ms: number;
+    };
+    readonly threshold: number;
+}
+export interface RunProbeOptions {
+    /** Use a subset for smoke; default = all 25 pairs. */
+    readonly limit?: number;
+    /** Confidence threshold for considering a non-null match a hit. Default 0.6. */
+    readonly threshold?: number;
+    /**
+     * Optional progress callback. Fired AFTER each pair completes — the
+     * CLI uses this to print a per-pair line so the operator sees live
+     * progress instead of waiting for the full sweep to finish.
+     */
+    readonly onProgress?: (outcome: ProbeOutcome, index: number, total: number) => void;
+}
+/**
+ * Run the probe against `pairs` (defaults to {@link EVAL_PAIRS}).
+ * Sequential by design — small N (~25), and concurrent calls would
+ * complicate latency measurement without changing the gate decision.
+ */
+export declare function runProbe(deps: {
+    readonly llm: LLMCaller;
+}, options?: RunProbeOptions, pairs?: readonly EvalPair[]): Promise<ProbeReport>;
+/** Pretty-print a {@link ProbeReport} for terminal output. */
+export declare function formatReport(report: ProbeReport): string;
+//# sourceMappingURL=run-probe.d.ts.map

package/dist/rerank-eval/run-probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-probe.d.ts","sourceRoot":"","sources":["../../src/rerank-eval/run-probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAoB,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAc,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,2DAA2D;IAC3D,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,0CAA0C;IAC1C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,SAAS,YAAY,EAAE,CAAC;IAC3C,QAAQ,CAAC,MAAM,EAAE;QACf,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;QACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC5B,CAAC;IACF,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;SACvB,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,GAAG;YACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;YACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;YACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;SAC5B;KACF,CAAC,CAAC;IACH,QAAQ,CAAC,4BAA4B,EAAE,MAAM,CAAC;IAC9C,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACrE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B,sDAAsD;IACtD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,gFAAgF;IAChF,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACrF;AAED;;;;GAIG;AACH,wBAAsB,QAAQ,CAC5B,IAAI,EAAE;IAAE,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAA;CAAE,EACjC,OAAO,GAAE,eAAoB,EAC7B,KAAK,GAAE,SAAS,QAAQ,EAAe,GACtC,OAAO,CAAC,WAAW,CAAC,CAyDtB;AAsBD,8DAA8D;AAC9D,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAkDxD"}

package/dist/rerank-eval/run-probe.js

@@ -0,0 +1,113 @@
+/**
+ * Rerank quality probe.
+ *
+ * Runs the configured `LLMCaller` over the {@link EVAL_PAIRS} eval
+ * set and returns precision@1 + adversarial false-positive +
+ * latency p95. The caller compares these against the quality gates
+ * (precision, adversarial false-positive rate, latency, cost)
+ * reported by the probe CLI.
+ *
+ * Eval-only — not exported from the package index.
+ */
+import { rerankCandidates } from '../llm-rerank.js';
+import { EVAL_PAIRS } from './pairs.js';
+/**
+ * Run the probe against `pairs` (defaults to {@link EVAL_PAIRS}).
+ * Sequential by design — small N (~25), and concurrent calls would
+ * complicate latency measurement without changing the gate decision.
+ */
+export async function runProbe(deps, options = {}, pairs = EVAL_PAIRS) {
+    const threshold = options.threshold ?? 0.6;
+    const subset = options.limit ? pairs.slice(0, options.limit) : pairs;
+    const outcomes = [];
+    for (let i = 0; i < subset.length; i++) {
+        const pair = subset[i];
+        const decision = await rerankCandidates(deps, pair.query, pair.candidates);
+        const predictedMatchId = decision.confidence >= threshold ? decision.matchId : null;
+        const correct = predictedMatchId === pair.goldMatchId;
+        const outcome = {
+            pair,
+            decision,
+            threshold,
+            predictedMatchId,
+            correct,
+        };
+        outcomes.push(outcome);
+        options.onProgress?.(outcome, i, subset.length);
+    }
+    const totals = aggregate(outcomes);
+    const byKind = {
+        'should-match': aggregate(outcomes.filter((o) => o.pair.kind === 'should-match')),
+        'no-match': aggregate(outcomes.filter((o) => o.pair.kind === 'no-match')),
+        adversarial: aggregate(outcomes.filter((o) => o.pair.kind === 'adversarial')),
+    };
+    // Adversarial false-positive: judge accepted a candidate when gold
+    // says null. Compute as `(adversarial-pairs-with-prediction-when-
+    // gold-was-null) / (adversarial-pairs-with-gold-null)`.
+    const adversarial = outcomes.filter((o) => o.pair.kind === 'adversarial');
+    const adversarialNullGold = adversarial.filter((o) => o.pair.goldMatchId === null);
+    const adversarialFalsePositives = adversarialNullGold.filter((o) => o.predictedMatchId !== null);
+    const adversarialFalsePositiveRate = adversarialNullGold.length === 0
+        ? 0
+        : adversarialFalsePositives.length / adversarialNullGold.length;
+    const latencies = outcomes
+        .map((o) => o.decision.latencyMs)
+        .sort((a, b) => a - b);
+    const latency = {
+        p50Ms: percentile(latencies, 0.5),
+        p95Ms: percentile(latencies, 0.95),
+    };
+    return {
+        outcomes,
+        totals,
+        byKind,
+        adversarialFalsePositiveRate,
+        latency,
+        threshold,
+    };
+}
+function aggregate(outcomes) {
+    const all = outcomes.length;
+    const correct = outcomes.filter((o) => o.correct).length;
+    const precision = all === 0 ? 0 : correct / all;
+    return { all, correct, precision };
+}
+function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return 0;
+    const idx = Math.min(sorted.length - 1, Math.floor(p * sorted.length));
+    return sorted[idx] ?? 0;
+}
+/** Pretty-print a {@link ProbeReport} for terminal output. */
+export function formatReport(report) {
+    const lines = [];
+    lines.push('━━━ rerank quality probe ━━━');
+    lines.push('');
+    lines.push(`Threshold: confidence ≥ ${report.threshold}`);
+    lines.push('');
+    lines.push('Precision by kind:');
+    for (const [kind, stats] of Object.entries(report.byKind)) {
+        const pct = (stats.precision * 100).toFixed(1);
+        lines.push(`  ${kind.padEnd(14)} ${stats.correct}/${stats.all} (${pct}%)`);
+    }
+    lines.push('');
+    lines.push(`Overall:        ${report.totals.correct}/${report.totals.all} (${(report.totals.precision * 100).toFixed(1)}%)`);
+    lines.push(`Adversarial FP: ${(report.adversarialFalsePositiveRate * 100).toFixed(1)}%`);
+    lines.push(`Latency:        p50=${report.latency.p50Ms}ms · p95=${report.latency.p95Ms}ms`);
+    lines.push('');
+    lines.push('Gates:');
+    lines.push(`  G1 precision@1 ≥ 85%    →  ${report.totals.precision >= 0.85 ? 'PASS' : 'FAIL'} (${(report.totals.precision * 100).toFixed(1)}%)`);
+    lines.push(`  G2 adversarial FP ≤ 5%  →  ${report.adversarialFalsePositiveRate <= 0.05 ? 'PASS' : 'FAIL'} (${(report.adversarialFalsePositiveRate * 100).toFixed(1)}%)`);
+    lines.push(`  G3 latency p95 ≤ 600ms  →  ${report.latency.p95Ms <= 600 ? 'PASS' : 'FAIL'} (p95=${report.latency.p95Ms}ms)`);
+    // Per-pair detail for failed predictions
+    const failed = report.outcomes.filter((o) => !o.correct);
+    if (failed.length > 0) {
+        lines.push('');
+        lines.push('Failed predictions:');
+        for (const o of failed) {
+            lines.push(`  [${o.pair.kind}] ${o.pair.id}: predicted=${o.predictedMatchId ?? 'null'}, gold=${o.pair.goldMatchId ?? 'null'}, conf=${o.decision.confidence.toFixed(2)}`);
+            lines.push(`    reason: ${o.decision.reason}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/session.d.ts

@@ -0,0 +1,42 @@
+/**
+ * `SessionState` — what the decision engine sees about the live
+ * session at the moment of a negotiation call.
+ *
+ * Captures the UI stack (pages previously pushed into this
+ * session), recent conversation, and optional interface context
+ * (viewport, device class). Consumed by `NegotiatorDecisionInput`
+ * to drive `create / update / compose / replace` decisions — the
+ * stack tells the engine whether something already on screen can
+ * absorb this push as an `update`, and the conversation history
+ * feeds the decision LLM.
+ *
+ * Kept in `@ggui-ai/negotiator` (not `mcp-server-core`): this is
+ * the decision engine's input shape, not a storage seam. An MCP
+ * server implementer binding against the public `Negotiator`
+ * interface sees `NegotiatorInput` / `NegotiatorResult` — never
+ * this internal input shape. Community adapters that want to
+ * call `makeDecision` directly (bypassing the `Negotiator` wrapper)
+ * import this type.
+ */
+import type { DataContract, InterfaceContext } from '@ggui-ai/protocol';
+/**
+ * One entry on the session's UI stack — a page the agent previously
+ * pushed. Minimal shape: every field the decision engine actually
+ * reads to decide reuse vs. create.
+ */
+export interface SessionStackEntry {
+    id: string;
+    prompt?: string;
+    contract?: DataContract;
+    componentCode: string;
+}
+/** Current state of a session — stack + conversation history. */
+export interface SessionState {
+    stack: SessionStackEntry[];
+    conversationHistory: Array<{
+        role: 'user' | 'agent';
+        content: string;
+    }>;
+    interfaceContext?: InterfaceContext;
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAExE;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,YAAY,CAAC;IACxB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,mBAAmB,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxE,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC"}

package/dist/session.js

@@ -0,0 +1,21 @@
+/**
+ * `SessionState` — what the decision engine sees about the live
+ * session at the moment of a negotiation call.
+ *
+ * Captures the UI stack (pages previously pushed into this
+ * session), recent conversation, and optional interface context
+ * (viewport, device class). Consumed by `NegotiatorDecisionInput`
+ * to drive `create / update / compose / replace` decisions — the
+ * stack tells the engine whether something already on screen can
+ * absorb this push as an `update`, and the conversation history
+ * feeds the decision LLM.
+ *
+ * Kept in `@ggui-ai/negotiator` (not `mcp-server-core`): this is
+ * the decision engine's input shape, not a storage seam. An MCP
+ * server implementer binding against the public `Negotiator`
+ * interface sees `NegotiatorInput` / `NegotiatorResult` — never
+ * this internal input shape. Community adapters that want to
+ * call `makeDecision` directly (bypassing the `Negotiator` wrapper)
+ * import this type.
+ */
+export {};

package/dist/suggestion.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Suggestion engine — detects structured data patterns in free-form
+ * agent text and proposes a ggui_push call that would show them
+ * interactively.
+ *
+ * Pure regex heuristics — zero I/O, zero LLM. The agent can call this
+ * opportunistically on streamed output to decide whether to surface a
+ * UI suggestion. Callers must pass a deduplication set to avoid
+ * re-suggesting the same UI repeatedly in a live session.
+ */
+/** Suggestion event sent to the agent. */
+export interface NegotiatorSuggestion {
+    type: 'negotiator:suggest';
+    trigger: 'stream-data-detected' | 'session-context' | 'user-pattern';
+    message: string;
+    suggestedAction: {
+        tool: 'ggui_push';
+        input: {
+            data?: Record<string, unknown>;
+            prompt?: string;
+        };
+    };
+    confidence: number;
+    intentId: string;
+}
+/** Detect structured data patterns in streamed text. */
+export declare function detectDataPatterns(text: string): Array<{
+    pattern: string;
+    uiType: string;
+    confidence: number;
+}>;
+/** Build a suggestion event from detected patterns. */
+export declare function buildSuggestion(sessionId: string, detections: Array<{
+    pattern: string;
+    uiType: string;
+    confidence: number;
+}>, activeIntentIds: Set<string>): NegotiatorSuggestion | null;
+//# sourceMappingURL=suggestion.d.ts.map

package/dist/suggestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggestion.d.ts","sourceRoot":"","sources":["../src/suggestion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,0CAA0C;AAC1C,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,EAAE,sBAAsB,GAAG,iBAAiB,GAAG,cAAc,CAAC;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE;QACf,IAAI,EAAE,WAAW,CAAC;QAClB,KAAK,EAAE;YAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KAC5D,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAmBD,wDAAwD;AACxD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAQ/G;AAED,uDAAuD;AACvD,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EAC1E,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,GAC3B,oBAAoB,GAAG,IAAI,CAa7B"}

package/dist/suggestion.js

@@ -0,0 +1,47 @@
+/**
+ * Suggestion engine — detects structured data patterns in free-form
+ * agent text and proposes a ggui_push call that would show them
+ * interactively.
+ *
+ * Pure regex heuristics — zero I/O, zero LLM. The agent can call this
+ * opportunistically on streamed output to decide whether to surface a
+ * UI suggestion. Callers must pass a deduplication set to avoid
+ * re-suggesting the same UI repeatedly in a live session.
+ */
+import { computeIntentId } from './intent.js';
+const PATTERNS = [
+    { name: 'temperature', regex: /\b\d+\s*°[CF]\b/i, uiType: 'weather display', confidence: 0.8 },
+    { name: 'percentage', regex: /\b\d+(\.\d+)?\s*%/, uiType: 'metrics display', confidence: 0.6 },
+    { name: 'currency', regex: /\$\s*[\d,]+(\.\d{2})?|\b\d+(\.\d{2})?\s*(USD|EUR|GBP|JPY|KRW)\b/i, uiType: 'financial display', confidence: 0.7 },
+    { name: 'speed-or-distance', regex: /\b\d+(\.\d+)?\s*(km\/h|mph|km|mi|m\/s)\b/i, uiType: 'data display', confidence: 0.6 },
+    { name: 'numbered-list', regex: /(?:^|\n)\s*[1-9]\.\s+\S/m, uiType: 'step flow or list', confidence: 0.5 },
+    { name: 'comparison', regex: /\b(vs\.?|versus|compared to|on the other hand|alternatively)\b/i, uiType: 'comparison view', confidence: 0.6 },
+    { name: 'table-like', regex: /\|.*\|.*\|/, uiType: 'table or grid', confidence: 0.8 },
+];
+/** Detect structured data patterns in streamed text. */
+export function detectDataPatterns(text) {
+    const matches = [];
+    for (const p of PATTERNS) {
+        if (p.regex.test(text)) {
+            matches.push({ pattern: p.name, uiType: p.uiType, confidence: p.confidence });
+        }
+    }
+    return matches;
+}
+/** Build a suggestion event from detected patterns. */
+export function buildSuggestion(sessionId, detections, activeIntentIds) {
+    if (detections.length === 0)
+        return null;
+    const best = detections.reduce((a, b) => (a.confidence > b.confidence ? a : b));
+    const intentId = computeIntentId(sessionId, { detectedPattern: best.pattern }, 'create');
+    if (activeIntentIds.has(intentId))
+        return null;
+    return {
+        type: 'negotiator:suggest',
+        trigger: 'stream-data-detected',
+        message: `I noticed structured data in your response (${best.pattern}). Consider calling ggui_push for an interactive ${best.uiType} instead.`,
+        suggestedAction: { tool: 'ggui_push', input: { prompt: best.uiType } },
+        confidence: best.confidence,
+        intentId,
+    };
+}

package/dist/synth-bench/corpus.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Hand-curated synthesizer bench corpus.
+ *
+ * Each entry pairs a natural-language intent with the structural
+ * contract shape we expect the synthesizer to produce. The shape is
+ * intentionally coarse — we assert what specs MUST appear, what specs
+ * MUST be absent, and (when applicable) which action / slot names are
+ * acceptable. Exact action labels and schema details are out of scope
+ * because LLM phrasing varies.
+ *
+ * Entries carry no hand-labeled archetype — the protocol thinks in
+ * contract SHAPE, not interaction-pattern categories. The bench
+ * report groups entries by `contractShape(entry.expected)`, derived
+ * from which specs the expected contract declares: `props-only`,
+ * `context-only`, `context+action`, `stream`, `with-gadgets`.
+ *
+ * Used by:
+ *   - run-synth-bench.ts (live LLM probe — opt-in, costs ~$0.001/entry)
+ *   - structure-bench.test.ts (deterministic validator-only check)
+ */
+import type { GadgetDescriptor } from '@ggui-ai/protocol';
+export interface BenchEntry {
+    readonly id: string;
+    readonly intent: string;
+    readonly expected: BenchExpectation;
+    /**
+     * Per-entry registered gadget catalog. When set, the runner
+     * forwards this to `synthesizeContract`'s `appGadgets` option so
+     * the synth LLM sees the same "AVAILABLE GADGETS" prompt block a
+     * production server emits for an operator that registered these
+     * gadget packages in `App.gadgets`.
+     *
+     * Use for `capability-plugin` cases that test whether the synth
+     * reaches for an OPERATOR-REGISTERED 3rd-party gadget (Leaflet,
+     * Mapbox, …) — distinct from the STDLIB `capability` cases which
+     * rely on the hardcoded stdlib hint baked into the synth system
+     * prompt.
+     *
+     * Pre-plugin entries leave this absent — synth falls through to
+     * the static stdlib hint.
+     */
+    readonly appGadgets?: readonly GadgetDescriptor[];
+}
+export interface BenchExpectation {
+    readonly hasActionSpec: boolean;
+    readonly hasContextSpec: boolean;
+    readonly hasStreamSpec: boolean;
+    readonly hasProps: boolean;
+    /**
+     * EE+ wire-shape v2 surfaces (added 2026-05-11). Default to `false`
+     * on legacy entries so the bench stays strict on the new shape only
+     * where the corpus opts in.
+     */
+    readonly hasClientCapabilities?: boolean;
+    readonly hasAgentTools?: boolean;
+    /** Action names the synthesizer MAY emit. Match: at least one
+     *  synthesized action name contains, or is contained by, an allowed
+     *  name (case-insensitive — `nextStep` matches `next`). When
+     *  `hasActionSpec=false`, this MUST be empty / omitted. */
+    readonly actionNames?: readonly string[];
+    /** Context slot names the synthesizer MAY emit. Match: at least one
+     *  synthesized slot name contains, or is contained by, an allowed
+     *  name (case-insensitive). Extra intent-specific slots are
+     *  tolerated — the check verifies the synth landed a recognizable
+     *  slot, not that it produced ONLY enumerated ones. */
+    readonly contextSlots?: readonly string[];
+    /** Gadget export names (hook or component) the synthesizer MAY
+     *  declare on `clientCapabilities.gadgets` (the inner export key).
+     *  Match is case-insensitive set-membership over the union of
+     *  accepted names. Only checked when `hasClientCapabilities=true`. */
+    readonly capabilityHooks?: readonly string[];
+    /**
+     * Gadget export names the synthesizer MUST NOT declare on
+     * `clientCapabilities.gadgets`. Stricter dual of
+     * `capabilityHooks` — catches the failure mode "intent doesn't
+     * call for the gadget but the LLM over-eagerly attached it
+     * anyway." Case-insensitive set-membership; checked
+     * unconditionally (a contract with no clientCapabilities trivially
+     * passes). Used by distractor cases where a gadget is REGISTERED
+     * but the intent doesn't justify using it.
+     */
+    readonly forbiddenCapabilityHooks?: readonly string[];
+    /** AgentTool catalog keys the synthesizer MAY emit. Used for
+     *  source-fed-stream + action-nextStep cases. Match: at least one
+     *  synthesized tool name contains, or is contained by, an allowed
+     *  name (case-insensitive — `fetch_pending_jobs` matches `jobs`);
+     *  the synth guesses these names, so paraphrase is tolerated, as
+     *  with `actionNames`. Only checked when `hasAgentTools=true`. */
+    readonly agentToolNames?: readonly string[];
+    /** True when the corpus tolerates either shape (hard cases). When
+     *  set, the bench reports the entry as `tolerated` regardless of
+     *  hasActionSpec / hasContextSpec mismatches. */
+    readonly tolerateEitherShape?: boolean;
+    readonly notes?: string;
+}
+/**
+ * Contract-shape bucket of an expected contract — the grouping the
+ * bench report rolls precision up by, replacing the retired
+ * interaction-archetype categories. Priority-ordered so each entry
+ * lands in exactly one bucket: the most distinctive declared spec
+ * wins (a gadget-bearing contract is `with-gadgets` regardless of
+ * what else it declares; a stream-bearing one is `stream`; …).
+ */
+export declare function contractShape(expected: BenchExpectation): string;
+export declare const BENCH_CORPUS: readonly BenchEntry[];
+//# sourceMappingURL=corpus.d.ts.map

package/dist/synth-bench/corpus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corpus.d.ts","sourceRoot":"","sources":["../../src/synth-bench/corpus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACnD;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IACzC,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IACjC;;;+DAG2D;IAC3D,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC;;;;2DAIuD;IACvD,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C;;;0EAGsE;IACtE,QAAQ,CAAC,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C;;;;;;;;;OASG;IACH,QAAQ,CAAC,wBAAwB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtD;;;;;sEAKkE;IAClE,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C;;qDAEiD;IACjD,QAAQ,CAAC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IACvC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAOhE;AAoDD,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EA+7B7C,CAAC"}