@ai-sdlc/orchestrator 0.6.0 → 0.9.0

package/dist/sa-scoring/c1-sa2-computable.d.ts

@@ -0,0 +1,42 @@
+/**
+ * C1 — SA-2 computable component (RFC-0008 v4 §5.2).
+ *
+ * SA-2 ("soul alignment with design system") has two halves:
+ *   - Computable: deterministic formula over DSB status fields
+ *   - LLM: structured assessment of principle coverage (M5)
+ *
+ * This module implements the computable half only. LLM is returned as
+ * `null` until M5 (AISDLC-59/60) replaces it.
+ *
+ * Formula (§5.2):
+ *   computableComponent = 0.3 × tokenCompliance + 0.2 × catalogHealth
+ *
+ * Where `tokenCompliance` and `catalogHealth` are normalized to [0, 1]
+ * from the DSB's published status.
+ */
+import type { DesignIntentDocument, DesignSystemBinding } from '@ai-sdlc/reference';
+export interface Sa2ComputableResult {
+    /** Normalized token-compliance value in [0, 1]. */
+    tokenCompliance: number;
+    /** Normalized catalog-health coverage in [0, 1]. */
+    catalogHealth: number;
+    /** 0.3 × tokenCompliance + 0.2 × catalogHealth. */
+    computableComponent: number;
+    /** LLM component — filled by M5. Always `null` in Phase 1. */
+    llmComponent: null;
+}
+/**
+ * Compute the SA-2 computable half from a DID and its resolved DSB.
+ *
+ * Returns `undefined` (caller falls back to label-based `soulAlignment`)
+ * when:
+ *   - `dsb` is undefined, OR
+ *   - Neither `tokenCompliance.currentCoverage` nor `catalogHealth.coveragePercent`
+ *     is present on the DSB status (can't compute either term).
+ *
+ * The DID is accepted for API symmetry and future extension (e.g. when
+ * individual principles select which DSB metrics to include); §5.2
+ * itself only reads DSB status.
+ */
+export declare function computeSa2Computable(did: DesignIntentDocument, dsb: DesignSystemBinding | undefined): Sa2ComputableResult | undefined;
+//# sourceMappingURL=c1-sa2-computable.d.ts.map

package/dist/sa-scoring/c1-sa2-computable.js

@@ -0,0 +1,59 @@
+/**
+ * C1 — SA-2 computable component (RFC-0008 v4 §5.2).
+ *
+ * SA-2 ("soul alignment with design system") has two halves:
+ *   - Computable: deterministic formula over DSB status fields
+ *   - LLM: structured assessment of principle coverage (M5)
+ *
+ * This module implements the computable half only. LLM is returned as
+ * `null` until M5 (AISDLC-59/60) replaces it.
+ *
+ * Formula (§5.2):
+ *   computableComponent = 0.3 × tokenCompliance + 0.2 × catalogHealth
+ *
+ * Where `tokenCompliance` and `catalogHealth` are normalized to [0, 1]
+ * from the DSB's published status.
+ */
+/**
+ * Compute the SA-2 computable half from a DID and its resolved DSB.
+ *
+ * Returns `undefined` (caller falls back to label-based `soulAlignment`)
+ * when:
+ *   - `dsb` is undefined, OR
+ *   - Neither `tokenCompliance.currentCoverage` nor `catalogHealth.coveragePercent`
+ *     is present on the DSB status (can't compute either term).
+ *
+ * The DID is accepted for API symmetry and future extension (e.g. when
+ * individual principles select which DSB metrics to include); §5.2
+ * itself only reads DSB status.
+ */
+export function computeSa2Computable(did, dsb) {
+    void did;
+    if (!dsb?.status)
+        return undefined;
+    const rawTokenCoverage = dsb.status.tokenCompliance?.currentCoverage;
+    const rawCatalogCoverage = dsb.status.catalogHealth?.coveragePercent;
+    if (rawTokenCoverage === undefined && rawCatalogCoverage === undefined) {
+        return undefined;
+    }
+    const tokenCompliance = normalizeCoverage(rawTokenCoverage);
+    const catalogHealth = normalizeCoverage(rawCatalogCoverage);
+    const computableComponent = 0.3 * tokenCompliance + 0.2 * catalogHealth;
+    return {
+        tokenCompliance,
+        catalogHealth,
+        computableComponent,
+        llmComponent: null,
+    };
+}
+/**
+ * Normalize a coverage value to [0, 1]. Accepts percentages (0–100) or
+ * ratios (0–1). Missing values are treated as 0.
+ */
+function normalizeCoverage(value) {
+    if (value === undefined || Number.isNaN(value))
+        return 0;
+    const clamped = value > 1 ? value / 100 : value;
+    return Math.min(1, Math.max(0, clamped));
+}
+//# sourceMappingURL=c1-sa2-computable.js.map

package/dist/sa-scoring/composite.d.ts

@@ -0,0 +1,107 @@
+/**
+ * SA-1 / SA-2 composite (RFC-0008 Addendum B §B.7).
+ *
+ * Combines Layer 1 deterministic results, Layer 2 BM25 structural
+ * scores, and Layer 3 LLM structured assessments into the two
+ * soul-alignment dimensions used by the admission composite.
+ *
+ * SA-1 per §B.7.1:
+ *   hard gate: scopeGate core → SA-1 = 0.0 (STOP)
+ *   coreConflictPenalty    = min(0.8, coreViolationCount × 0.4)
+ *   evolvingConflictPenalty = min(0.3, evolvingViolationCount × 0.1)
+ *   conflictPenalty        = 1.0 − coreConflictPenalty − evolvingConflictPenalty
+ *   subtleMult             = 0.5 if any high-severity conflict, else 1.0
+ *   blended                = w_s × domainRelevance + w_l × domainIntent × subtleMult
+ *   SA-1                   = blended × conflictPenalty
+ *
+ * SA-2 per corrected §B.7.2 (CR-1 — no self-multiplication):
+ *   computableScore       = 0.3 × tokenCompliance + 0.2 × catalogHealth
+ *   designConflictPenalty = 1.0 − min(0.6, coreAp × 0.3 + evolvingAp × 0.1)
+ *   llmTerm               = w_l × principleAlignment × subtleMult
+ *   blendedScore          = w_s × principleCoverage + llmTerm
+ *   llmComponent          = blendedScore × designConflictPenalty
+ *   SA-2                  = computableScore + 0.5 × llmComponent
+ *
+ * Phase weights (§B.7.3):
+ *   2a shadow      → (0, 0)      — computed but not used in ranking
+ *   2b blended     → (0.20, 0.80)
+ *   2c calibrating → (0.35, 0.65)
+ *   3 calibrated   → flywheel-driven; w_structural floored at 0.20 (CR-2)
+ */
+import type { SubtleConflict, SubtleDesignConflict } from './layer3-llm.js';
+export type SaPhase = '2a' | '2b' | '2c' | '3';
+export interface PhaseWeights {
+    wStructural: number;
+    wLlm: number;
+}
+/** CR-2: Phase 3 must never drop w_structural below this floor. */
+export declare const W_STRUCTURAL_FLOOR = 0.2;
+export declare function getPhaseWeights(phase: SaPhase, calibrated?: PhaseWeights): PhaseWeights;
+export interface Sa1Inputs {
+    /** True when Layer 1 scope gate flagged a core out-of-scope hit. */
+    hardGated: boolean;
+    coreViolationCount: number;
+    evolvingViolationCount: number;
+    /** Layer 2 SA-1 domainRelevance in [0, 1]. */
+    domainRelevance: number;
+    /** Layer 3 SA-1 domainIntent in [0, 1] (already confidence-filtered). */
+    domainIntent: number;
+    /** Layer 3 SA-1 subtle conflicts (already confidence-filtered). */
+    subtleConflicts: SubtleConflict[];
+}
+export interface Sa2Inputs {
+    /** From DSB status, normalized to [0, 1]. */
+    tokenCompliance: number;
+    /** From DSB status, normalized to [0, 1]. */
+    catalogHealth: number;
+    /** Layer 2 SA-2 principleCoverage (weighted mean) in [0, 1]. */
+    principleCoverage: number;
+    /** Layer 3 SA-2 principleAlignment in [0, 1] (confidence-filtered). */
+    principleAlignment: number;
+    /** Count of core-classified design anti-pattern hits. */
+    coreDesignAntiPatternCount: number;
+    /** Count of evolving-classified design anti-pattern hits. */
+    evolvingDesignAntiPatternCount: number;
+    /** Layer 3 SA-2 subtle design conflicts (confidence-filtered). */
+    subtleDesignConflicts: SubtleDesignConflict[];
+}
+export interface Sa1Result {
+    sa1: number;
+    hardGated: boolean;
+    /** Structural contribution: w_s × domainRelevance. */
+    structuralContribution: number;
+    /** LLM contribution: w_l × domainIntent × subtleMult. */
+    llmContribution: number;
+    blended: number;
+    conflictPenalty: number;
+    subtleMult: number;
+}
+export interface Sa2Result {
+    sa2: number;
+    computableScore: number;
+    structuralContribution: number;
+    llmContribution: number;
+    blendedScore: number;
+    designConflictPenalty: number;
+    subtleMult: number;
+    llmComponent: number;
+}
+export interface SoulAlignmentResult {
+    phase: SaPhase;
+    weights: PhaseWeights;
+    /** True for Phase 2a — consumers must NOT use sa1/sa2 in ranking. */
+    shadowMode: boolean;
+    sa1: Sa1Result;
+    sa2: Sa2Result;
+}
+export declare function computeSa1(inputs: Sa1Inputs, weights: PhaseWeights): Sa1Result;
+export declare function computeSa2(inputs: Sa2Inputs, weights: PhaseWeights): Sa2Result;
+export interface SoulAlignmentInput {
+    phase: SaPhase;
+    /** Required for Phase 3 if calibrated weights differ from the 2c default. */
+    calibratedWeights?: PhaseWeights;
+    sa1: Sa1Inputs;
+    sa2: Sa2Inputs;
+}
+export declare function computeSoulAlignment(input: SoulAlignmentInput): SoulAlignmentResult;
+//# sourceMappingURL=composite.d.ts.map

package/dist/sa-scoring/composite.js

@@ -0,0 +1,139 @@
+/**
+ * SA-1 / SA-2 composite (RFC-0008 Addendum B §B.7).
+ *
+ * Combines Layer 1 deterministic results, Layer 2 BM25 structural
+ * scores, and Layer 3 LLM structured assessments into the two
+ * soul-alignment dimensions used by the admission composite.
+ *
+ * SA-1 per §B.7.1:
+ *   hard gate: scopeGate core → SA-1 = 0.0 (STOP)
+ *   coreConflictPenalty    = min(0.8, coreViolationCount × 0.4)
+ *   evolvingConflictPenalty = min(0.3, evolvingViolationCount × 0.1)
+ *   conflictPenalty        = 1.0 − coreConflictPenalty − evolvingConflictPenalty
+ *   subtleMult             = 0.5 if any high-severity conflict, else 1.0
+ *   blended                = w_s × domainRelevance + w_l × domainIntent × subtleMult
+ *   SA-1                   = blended × conflictPenalty
+ *
+ * SA-2 per corrected §B.7.2 (CR-1 — no self-multiplication):
+ *   computableScore       = 0.3 × tokenCompliance + 0.2 × catalogHealth
+ *   designConflictPenalty = 1.0 − min(0.6, coreAp × 0.3 + evolvingAp × 0.1)
+ *   llmTerm               = w_l × principleAlignment × subtleMult
+ *   blendedScore          = w_s × principleCoverage + llmTerm
+ *   llmComponent          = blendedScore × designConflictPenalty
+ *   SA-2                  = computableScore + 0.5 × llmComponent
+ *
+ * Phase weights (§B.7.3):
+ *   2a shadow      → (0, 0)      — computed but not used in ranking
+ *   2b blended     → (0.20, 0.80)
+ *   2c calibrating → (0.35, 0.65)
+ *   3 calibrated   → flywheel-driven; w_structural floored at 0.20 (CR-2)
+ */
+/** CR-2: Phase 3 must never drop w_structural below this floor. */
+export const W_STRUCTURAL_FLOOR = 0.2;
+export function getPhaseWeights(phase, calibrated) {
+    switch (phase) {
+        case '2a':
+            return { wStructural: 0, wLlm: 0 };
+        case '2b':
+            return { wStructural: 0.2, wLlm: 0.8 };
+        case '2c':
+            return { wStructural: 0.35, wLlm: 0.65 };
+        case '3': {
+            if (!calibrated)
+                return { wStructural: 0.35, wLlm: 0.65 };
+            const wStructural = Math.max(W_STRUCTURAL_FLOOR, calibrated.wStructural);
+            // wLlm is whatever is left after clamping — keeps the pair summing to 1.0.
+            const wLlm = Math.max(0, 1 - wStructural);
+            return { wStructural, wLlm };
+        }
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────
+function clamp01(value) {
+    if (Number.isNaN(value))
+        return 0;
+    return Math.min(1, Math.max(0, value));
+}
+function hasHighSeverity(conflicts) {
+    return conflicts.some((c) => c.severity === 'high');
+}
+function normalizeCoverage(value) {
+    if (value === undefined || Number.isNaN(value))
+        return 0;
+    const clamped = value > 1 ? value / 100 : value;
+    return clamp01(clamped);
+}
+// ── SA-1 ─────────────────────────────────────────────────────────────
+export function computeSa1(inputs, weights) {
+    // Hard gate: core out-of-scope match forces SA-1 = 0 irrespective of
+    // Layer 2/3 output (§B.7.1 STOP condition).
+    if (inputs.hardGated) {
+        return {
+            sa1: 0,
+            hardGated: true,
+            structuralContribution: 0,
+            llmContribution: 0,
+            blended: 0,
+            conflictPenalty: 0,
+            subtleMult: 1,
+        };
+    }
+    const coreConflictPenalty = Math.min(0.8, inputs.coreViolationCount * 0.4);
+    const evolvingConflictPenalty = Math.min(0.3, inputs.evolvingViolationCount * 0.1);
+    const conflictPenalty = Math.max(0, 1 - coreConflictPenalty - evolvingConflictPenalty);
+    const subtleMult = hasHighSeverity(inputs.subtleConflicts) ? 0.5 : 1.0;
+    const structuralContribution = weights.wStructural * clamp01(inputs.domainRelevance);
+    const llmContribution = weights.wLlm * clamp01(inputs.domainIntent) * subtleMult;
+    const blended = structuralContribution + llmContribution;
+    const sa1 = clamp01(blended * conflictPenalty);
+    return {
+        sa1,
+        hardGated: false,
+        structuralContribution,
+        llmContribution,
+        blended,
+        conflictPenalty,
+        subtleMult,
+    };
+}
+// ── SA-2 ─────────────────────────────────────────────────────────────
+export function computeSa2(inputs, weights) {
+    const tc = normalizeCoverage(inputs.tokenCompliance);
+    const ch = normalizeCoverage(inputs.catalogHealth);
+    // RFC §B.7.2: computableScore tops out at 0.5 by design — it's half
+    // the final SA-2 score. The other half comes from `0.5 × llmComponent`
+    // below, so perfect inputs on both layers yield SA-2 = 1.0. See the
+    // worked example in composite.test.ts: tc=0.88, ch=0.95 → 0.454.
+    const computableScore = 0.3 * tc + 0.2 * ch;
+    const rawPenalty = inputs.coreDesignAntiPatternCount * 0.3 + inputs.evolvingDesignAntiPatternCount * 0.1;
+    const designConflictPenalty = Math.max(0, 1 - Math.min(0.6, rawPenalty));
+    const subtleMult = hasHighSeverity(inputs.subtleDesignConflicts) ? 0.5 : 1.0;
+    const structuralContribution = weights.wStructural * clamp01(inputs.principleCoverage);
+    const llmContribution = weights.wLlm * clamp01(inputs.principleAlignment) * subtleMult;
+    const blendedScore = structuralContribution + llmContribution;
+    const llmComponent = blendedScore * designConflictPenalty;
+    const sa2 = clamp01(computableScore + 0.5 * llmComponent);
+    return {
+        sa2,
+        computableScore,
+        structuralContribution,
+        llmContribution,
+        blendedScore,
+        designConflictPenalty,
+        subtleMult,
+        llmComponent,
+    };
+}
+export function computeSoulAlignment(input) {
+    const weights = getPhaseWeights(input.phase, input.calibratedWeights);
+    const sa1 = computeSa1(input.sa1, weights);
+    const sa2 = computeSa2(input.sa2, weights);
+    return {
+        phase: input.phase,
+        weights,
+        shadowMode: input.phase === '2a',
+        sa1,
+        sa2,
+    };
+}
+//# sourceMappingURL=composite.js.map

package/dist/sa-scoring/depparse-client.d.ts

@@ -0,0 +1,79 @@
+/**
+ * TypeScript client for the `sidecar-depparse` HTTP service.
+ *
+ * Used by Layer 1 deterministic SA scoring (RFC-0008 §B.4.2) to detect
+ * requirement constructions (`requires X`, `must have X`, `X required`,
+ * passive + negation-aware) in issue text.
+ *
+ * The client is injectable — production code wires in `HttpDepparseClient`
+ * pointing at the sidecar URL, tests inject a `FakeDepparseClient` to
+ * avoid the Python dependency.
+ *
+ * Retry semantics: one retry on 5xx responses (network or transient),
+ * typed failure on anything else. Fail-soft by default — caller can
+ * treat a `DepparseUnavailable` failure as "no matches" when the
+ * sidecar is optional.
+ */
+export interface DepparseMatch {
+    pattern: string;
+    matchedText: string;
+    depPath: string[];
+    construction: string;
+}
+export interface DepparseMatchRequest {
+    text: string;
+    patterns: string[];
+}
+export interface DepparseMatchResponse {
+    matches: DepparseMatch[];
+}
+export interface DepparseHealth {
+    status: string;
+    model?: string;
+    modelLoaded: boolean;
+}
+export interface DepparseClient {
+    match(request: DepparseMatchRequest): Promise<DepparseMatchResponse>;
+    healthz(): Promise<DepparseHealth>;
+}
+export type DepparseErrorKind = 'network' | 'bad-request' | 'server-error' | 'model-unavailable' | 'timeout';
+export declare class DepparseError extends Error {
+    readonly kind: DepparseErrorKind;
+    readonly status?: number;
+    constructor(kind: DepparseErrorKind, message: string, status?: number);
+}
+export interface HttpDepparseClientOptions {
+    baseUrl: string;
+    /** Per-request timeout in ms. Default 5 000. */
+    timeoutMs?: number;
+    /** Number of retries on 5xx / network errors. Default 1. */
+    retries?: number;
+    /** Injectable fetch — lets tests stub without overriding globalThis. */
+    fetchImpl?: typeof fetch;
+}
+export declare class HttpDepparseClient implements DepparseClient {
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly retries;
+    private readonly fetchImpl;
+    constructor(opts: HttpDepparseClientOptions);
+    healthz(): Promise<DepparseHealth>;
+    match(request: DepparseMatchRequest): Promise<DepparseMatchResponse>;
+    private requestJson;
+    private doFetch;
+}
+/**
+ * In-memory test double that matches patterns by exact substring —
+ * sufficient for unit tests that don't care about dependency-parse
+ * semantics. Real scoring tests use recorded fixtures.
+ */
+export declare class FakeDepparseClient implements DepparseClient {
+    private responses;
+    private healthResponse;
+    callLog: DepparseMatchRequest[];
+    setResponse(response: DepparseMatchResponse): void;
+    setHealth(health: DepparseHealth): void;
+    match(request: DepparseMatchRequest): Promise<DepparseMatchResponse>;
+    healthz(): Promise<DepparseHealth>;
+}
+//# sourceMappingURL=depparse-client.d.ts.map

package/dist/sa-scoring/depparse-client.js

@@ -0,0 +1,187 @@
+/**
+ * TypeScript client for the `sidecar-depparse` HTTP service.
+ *
+ * Used by Layer 1 deterministic SA scoring (RFC-0008 §B.4.2) to detect
+ * requirement constructions (`requires X`, `must have X`, `X required`,
+ * passive + negation-aware) in issue text.
+ *
+ * The client is injectable — production code wires in `HttpDepparseClient`
+ * pointing at the sidecar URL, tests inject a `FakeDepparseClient` to
+ * avoid the Python dependency.
+ *
+ * Retry semantics: one retry on 5xx responses (network or transient),
+ * typed failure on anything else. Fail-soft by default — caller can
+ * treat a `DepparseUnavailable` failure as "no matches" when the
+ * sidecar is optional.
+ */
+export class DepparseError extends Error {
+    kind;
+    status;
+    constructor(kind, message, status) {
+        super(message);
+        this.name = 'DepparseError';
+        this.kind = kind;
+        this.status = status;
+    }
+}
+export class HttpDepparseClient {
+    baseUrl;
+    timeoutMs;
+    retries;
+    fetchImpl;
+    constructor(opts) {
+        this.baseUrl = assertHttpUrl(opts.baseUrl).replace(/\/$/, '');
+        this.timeoutMs = opts.timeoutMs ?? 5_000;
+        this.retries = opts.retries ?? 1;
+        this.fetchImpl = opts.fetchImpl ?? fetch;
+    }
+    async healthz() {
+        const res = await this.requestJson('GET', '/healthz');
+        return {
+            status: res.status,
+            model: res.model ?? undefined,
+            modelLoaded: Boolean(res.model_loaded),
+        };
+    }
+    async match(request) {
+        const body = JSON.stringify(request);
+        const res = await this.requestJson('POST', '/v1/match', body);
+        return {
+            matches: res.matches.map((m) => ({
+                pattern: m.pattern,
+                matchedText: m.matched_text,
+                depPath: m.dep_path,
+                construction: m.construction,
+            })),
+        };
+    }
+    // ── Internals ──────────────────────────────────────────────────
+    async requestJson(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        let lastError;
+        const attempts = this.retries + 1;
+        for (let attempt = 0; attempt < attempts; attempt++) {
+            try {
+                const res = await this.doFetch(url, method, body);
+                if (res.ok) {
+                    return (await res.json());
+                }
+                if (res.status === 503) {
+                    // Model not yet loaded — permanent for this request window.
+                    const text = await safeText(res);
+                    throw new DepparseError('model-unavailable', text || `503 at ${url}`, 503);
+                }
+                if (res.status >= 500) {
+                    lastError = new DepparseError('server-error', `${res.status} at ${url}`, res.status);
+                    continue; // retry
+                }
+                const text = await safeText(res);
+                throw new DepparseError('bad-request', text || `${res.status} at ${url}`, res.status);
+            }
+            catch (err) {
+                if (err instanceof DepparseError) {
+                    if (err.kind === 'server-error' && attempt + 1 < attempts) {
+                        lastError = err;
+                        continue;
+                    }
+                    throw err;
+                }
+                // Network / abort / unknown — retry once
+                lastError = new DepparseError(errIsAbort(err) ? 'timeout' : 'network', err instanceof Error ? err.message : String(err));
+                if (attempt + 1 >= attempts)
+                    throw lastError;
+            }
+        }
+        throw lastError ?? new DepparseError('network', `No response from ${url}`);
+    }
+    async doFetch(url, method, body) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            return await this.fetchImpl(url, {
+                method,
+                headers: body ? { 'content-type': 'application/json' } : undefined,
+                body,
+                signal: controller.signal,
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+async function safeText(res) {
+    try {
+        return await res.text();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Refuses non-HTTP schemes. Env-var or CLI-supplied `baseUrl` with
+ * `file://`, `data:`, `javascript:`, or similar could trigger local
+ * file reads or arbitrary protocol handlers when passed to `fetch()`.
+ */
+function assertHttpUrl(url) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new DepparseError('bad-request', `depparse baseUrl is not a valid URL: ${url}`);
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new DepparseError('bad-request', `depparse baseUrl must use http: or https: (got ${parsed.protocol})`);
+    }
+    return url;
+}
+function errIsAbort(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        'name' in err &&
+        err.name === 'AbortError');
+}
+// ── Fake client for tests ────────────────────────────────────────────
+/**
+ * In-memory test double that matches patterns by exact substring —
+ * sufficient for unit tests that don't care about dependency-parse
+ * semantics. Real scoring tests use recorded fixtures.
+ */
+export class FakeDepparseClient {
+    responses;
+    healthResponse = {
+        status: 'ok',
+        model: 'fake',
+        modelLoaded: true,
+    };
+    callLog = [];
+    setResponse(response) {
+        this.responses = response;
+    }
+    setHealth(health) {
+        this.healthResponse = health;
+    }
+    async match(request) {
+        this.callLog.push(request);
+        if (this.responses)
+            return this.responses;
+        // Fallback: return substring matches with no dep_path info.
+        const matches = [];
+        for (const pattern of request.patterns) {
+            if (request.text.toLowerCase().includes(pattern.toLowerCase())) {
+                matches.push({
+                    pattern,
+                    matchedText: pattern,
+                    depPath: [],
+                    construction: 'substring',
+                });
+            }
+        }
+        return { matches };
+    }
+    async healthz() {
+        return this.healthResponse;
+    }
+}
+//# sourceMappingURL=depparse-client.js.map