@try-works/dsh-tool-mode 0.0.0-stage → 0.5.44

package/lib/decision-combine.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Code makes decisions (TypeSafe "Don't Call It a Decision Model", 2026-11-03).
+ *
+ * The model returns ATOMIC JUDGMENTS; this module combines facts and judgments
+ * with explicit rules and returns the exit plus the evaluated trace. It calls no
+ * model. A missing value is a failed check with `actual: null`, never a silent
+ * truthy default, and the trace names every rule and condition examined.
+ */
+export type DecisionSource = 'fact' | 'judgment';
+export type DecisionOperator = 'eq' | 'neq' | 'gte' | 'gt' | 'lte' | 'lt' | 'truthy' | 'falsy';
+export interface DecisionCondition {
+    readonly source: DecisionSource;
+    readonly key: string;
+    readonly op: DecisionOperator;
+    readonly value?: string | number | boolean;
+}
+export interface DecisionRule {
+    readonly id: string;
+    readonly when: readonly DecisionCondition[];
+    readonly exit: string;
+}
+export interface DecisionCheck {
+    readonly source: DecisionSource;
+    readonly key: string;
+    readonly op: DecisionOperator;
+    readonly expected: string | number | boolean | null;
+    readonly actual: unknown;
+    readonly passed: boolean;
+}
+export interface DecisionTraceEntry {
+    readonly rule: string;
+    readonly matched: boolean;
+    readonly checks: readonly DecisionCheck[];
+}
+export interface DecisionResult {
+    readonly exit: string;
+    readonly trace: readonly DecisionTraceEntry[];
+    readonly fallback: boolean;
+}
+/** Validate and normalize a policy before evaluation. */
+export declare function parseDecisionPolicy(facts: unknown, judgments: unknown, rules: unknown): {
+    readonly facts: Record<string, unknown>;
+    readonly judgments: Record<string, number>;
+    readonly rules: readonly DecisionRule[];
+};
+/**
+ * Evaluate the first matching rule; otherwise return the caller's explicit fallback.
+ * @param facts - code-computed facts (booleans, numbers or strings).
+ * @param judgments - model probabilities keyed by atomic judgment.
+ * @param rules - first-match policy rules.
+ * @param fallback - exit when no rule matches.
+ * @returns exit, full trace, and whether the fallback was used.
+ */
+export declare function combineDecision(facts: unknown, judgments: unknown, rules: unknown, fallback: string): DecisionResult;
+/** The MCP contract for the pure combiner. */
+export declare const DECISION_COMBINE_CONTRACT: {
+    readonly contract: "decision.combine";
+    readonly version: "1.0.0";
+    readonly toolName: "decision_combine";
+    readonly description: "Combine code-computed facts and atomic model judgment probabilities through explicit first-match rules; returns the exit and full trace.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["facts", "judgments", "rules", "fallback"];
+        readonly properties: {
+            readonly facts: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+            };
+            readonly judgments: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+            };
+            readonly rules: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                };
+            };
+            readonly fallback: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly outputSchema: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["exit", "fallback", "trace"];
+        readonly properties: {
+            readonly exit: {
+                readonly type: "string";
+            };
+            readonly fallback: {
+                readonly type: "boolean";
+            };
+            readonly trace: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                };
+            };
+        };
+    };
+    readonly semantics: {
+        readonly deterministic: true;
+        readonly readsInputs: true;
+    };
+    readonly limits: {};
+    readonly unsupported: readonly ["no model call", "no tool dispatch"];
+};
+//# sourceMappingURL=decision-combine.d.ts.map

package/lib/decision-combine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision-combine.d.ts","sourceRoot":"","sources":["../src/decision-combine.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,UAAU,CAAA;AAChD,MAAM,MAAM,gBAAgB,GAAG,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,QAAQ,GAAG,OAAO,CAAA;AAE9F,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,EAAE,gBAAgB,CAAA;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAA;CAC3C;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,IAAI,EAAE,SAAS,iBAAiB,EAAE,CAAA;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,EAAE,gBAAgB,CAAA;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAA;IACnD,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAA;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;IACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,aAAa,EAAE,CAAA;CAC1C;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,kBAAkB,EAAE,CAAA;IAC7C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAC3B;AA4BD,yDAAyD;AACzD,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,OAAO,EAClB,KAAK,EAAE,OAAO,GACb;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,CAAA;CAAE,CAwBlI;AAkBD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,OAAO,EAClB,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,GACf,cAAc,CAuBhB;AAED,8CAA8C;AAC9C,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6B5B,CAAA"}

package/lib/decision-combine.js

@@ -0,0 +1,156 @@
+/**
+ * Code makes decisions (TypeSafe "Don't Call It a Decision Model", 2026-11-03).
+ *
+ * The model returns ATOMIC JUDGMENTS; this module combines facts and judgments
+ * with explicit rules and returns the exit plus the evaluated trace. It calls no
+ * model. A missing value is a failed check with `actual: null`, never a silent
+ * truthy default, and the trace names every rule and condition examined.
+ */
+const OPERATORS = new Set(['eq', 'neq', 'gte', 'gt', 'lte', 'lt', 'truthy', 'falsy']);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isScalar(value) {
+    return typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+}
+function readCondition(raw, label) {
+    if (!isRecord(raw))
+        throw new Error(`${label} must be an object`);
+    if (raw.source !== 'fact' && raw.source !== 'judgment')
+        throw new Error(`${label}.source must be fact or judgment`);
+    if (typeof raw.key !== 'string' || raw.key.length === 0 || raw.key.length > 128)
+        throw new Error(`${label}.key must be a non-empty string`);
+    const op = raw.op;
+    if (typeof op !== 'string' || !OPERATORS.has(op))
+        throw new Error(`${label}.op is not supported`);
+    if (raw.value !== undefined && !isScalar(raw.value))
+        throw new Error(`${label}.value must be a string, number or boolean`);
+    if ((op === 'truthy' || op === 'falsy') && raw.value !== undefined)
+        throw new Error(`${label}.value is not used by ${op}`);
+    return {
+        source: raw.source,
+        key: raw.key,
+        op: op,
+        ...raw.value === undefined ? {} : { value: raw.value },
+    };
+}
+/** Validate and normalize a policy before evaluation. */
+export function parseDecisionPolicy(facts, judgments, rules) {
+    if (!isRecord(facts))
+        throw new Error('facts must be an object');
+    if (!isRecord(judgments))
+        throw new Error('judgments must be an object of probabilities');
+    const normalizedJudgments = {};
+    for (const [key, value] of Object.entries(judgments)) {
+        if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 1) {
+            throw new Error(`judgment ${JSON.stringify(key)} must be a finite probability in [0,1]`);
+        }
+        normalizedJudgments[key] = value;
+    }
+    if (!Array.isArray(rules) || rules.length === 0 || rules.length > 64)
+        throw new Error('rules must be 1–64 entries');
+    const ids = new Set();
+    const parsed = rules.map((raw, index) => {
+        const label = `rules[${index}]`;
+        if (!isRecord(raw))
+            throw new Error(`${label} must be an object`);
+        if (typeof raw.id !== 'string' || raw.id.length === 0 || raw.id.length > 64)
+            throw new Error(`${label}.id must be a non-empty string`);
+        if (ids.has(raw.id))
+            throw new Error(`rule id ${JSON.stringify(raw.id)} is duplicated`);
+        ids.add(raw.id);
+        if (!Array.isArray(raw.when) || raw.when.length === 0 || raw.when.length > 16)
+            throw new Error(`${label}.when must be 1–16 conditions`);
+        const when = raw.when.map((condition, conditionIndex) => readCondition(condition, `${label}.when[${conditionIndex}]`));
+        if (typeof raw.exit !== 'string' || raw.exit.length === 0 || raw.exit.length > 256)
+            throw new Error(`${label}.exit must be a non-empty string`);
+        return { id: raw.id, when, exit: raw.exit };
+    });
+    return { facts, judgments: normalizedJudgments, rules: parsed };
+}
+function compare(actual, op, expected) {
+    if (actual === undefined || actual === null)
+        return false;
+    if (op === 'truthy')
+        return Boolean(actual);
+    if (op === 'falsy')
+        return !actual;
+    if (op === 'eq')
+        return actual === expected;
+    if (op === 'neq')
+        return actual !== expected;
+    if (typeof actual !== 'number' || typeof expected !== 'number' || !Number.isFinite(actual) || !Number.isFinite(expected))
+        return false;
+    switch (op) {
+        case 'gte': return actual >= expected;
+        case 'gt': return actual > expected;
+        case 'lte': return actual <= expected;
+        case 'lt': return actual < expected;
+        default: return false;
+    }
+}
+/**
+ * Evaluate the first matching rule; otherwise return the caller's explicit fallback.
+ * @param facts - code-computed facts (booleans, numbers or strings).
+ * @param judgments - model probabilities keyed by atomic judgment.
+ * @param rules - first-match policy rules.
+ * @param fallback - exit when no rule matches.
+ * @returns exit, full trace, and whether the fallback was used.
+ */
+export function combineDecision(facts, judgments, rules, fallback) {
+    const parsed = parseDecisionPolicy(facts, judgments, rules);
+    if (typeof fallback !== 'string' || fallback.length === 0 || fallback.length > 256) {
+        throw new Error('fallback must be a non-empty string');
+    }
+    const trace = [];
+    for (const rule of parsed.rules) {
+        const checks = rule.when.map((condition) => {
+            const actual = condition.source === 'fact' ? parsed.facts[condition.key] : parsed.judgments[condition.key];
+            return {
+                source: condition.source,
+                key: condition.key,
+                op: condition.op,
+                expected: condition.value ?? null,
+                actual: actual ?? null,
+                passed: compare(actual, condition.op, condition.value),
+            };
+        });
+        const matched = checks.every(check => check.passed);
+        trace.push({ rule: rule.id, matched, checks });
+        if (matched)
+            return { exit: rule.exit, trace, fallback: false };
+    }
+    return { exit: fallback, trace, fallback: true };
+}
+/** The MCP contract for the pure combiner. */
+export const DECISION_COMBINE_CONTRACT = {
+    contract: 'decision.combine',
+    version: '1.0.0',
+    toolName: 'decision_combine',
+    description: 'Combine code-computed facts and atomic model judgment probabilities through explicit first-match rules; returns the exit and full trace.',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['facts', 'judgments', 'rules', 'fallback'],
+        properties: {
+            facts: { type: 'object', additionalProperties: true },
+            judgments: { type: 'object', additionalProperties: true },
+            rules: { type: 'array', items: { type: 'object', additionalProperties: true } },
+            fallback: { type: 'string' },
+        },
+    },
+    outputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['exit', 'fallback', 'trace'],
+        properties: {
+            exit: { type: 'string' },
+            fallback: { type: 'boolean' },
+            trace: { type: 'array', items: { type: 'object', additionalProperties: true } },
+        },
+    },
+    semantics: { deterministic: true, readsInputs: true },
+    limits: {},
+    unsupported: ['no model call', 'no tool dispatch'],
+};
+//# sourceMappingURL=decision-combine.js.map

package/lib/decision-evaluate.d.ts

@@ -0,0 +1,185 @@
+/**
+ * Domain-neutral confidence routing and evaluation for judgment tools.
+ *
+ * Two general lessons are drawn from a published identity-resolution evaluation
+ * (Hightouch, 2026-11-04); that domain is provenance, not scope:
+ * - a fixed 50% cutoff is arbitrary; thresholds trade false positives for false negatives;
+ * - a well-calibrated cheap judge can escalate only its uncertain band to an expensive
+ *   evaluator and approach frontier accuracy at much lower cost.
+ *
+ * These functions are pure. They never call a model; the caller supplies the primary
+ * probability (and, when escalations happen, the secondary one).
+ */
+/** A routing policy over one probability. */
+export interface ConfidenceRoute {
+    /** `accept` true, `reject` false, or `escalate` to the secondary judge. */
+    readonly route: 'accept' | 'reject' | 'escalate';
+    /** The decision when `route` is not escalate; null when a second opinion is needed. */
+    readonly decision: boolean | null;
+    /** Which part of the band the probability fell in. */
+    readonly band: 'high' | 'middle' | 'low';
+    readonly reason: string;
+}
+/**
+ * Route a primary judgment by a two-sided confidence band.
+ *
+ * The defaults are the article's shape (middle band escalated), but NOT a claim
+ * that these thresholds are calibrated for our models: pass reviewed thresholds.
+ * @param probability - the primary judge's probability that the condition is true.
+ * @param acceptAt - at or above this, accept true (default 0.9).
+ * @param rejectAt - at or below this, accept false (default 0.1).
+ * @returns the route, decision and band.
+ */
+export declare function routeConfidence(probability: number, acceptAt?: number, rejectAt?: number): ConfidenceRoute;
+/** One labeled observation for evaluation. */
+export interface DecisionCase {
+    readonly id?: string;
+    readonly expected: boolean;
+    /** Primary judge's P(true). */
+    readonly probability: number;
+    /** Optional secondary judge's P(true), used only inside the escalation band. */
+    readonly escalatedProbability?: number;
+    /** Optional observed cost of the primary call, in USD. */
+    readonly costUsd?: number;
+    /** Optional observed latency of the primary call, in ms. */
+    readonly latencyMs?: number;
+}
+/** Metrics for one decision rule over the cases. */
+export interface DecisionMetrics {
+    readonly count: number;
+    readonly correct: number;
+    readonly accuracy: number;
+    readonly truePositives: number;
+    readonly trueNegatives: number;
+    readonly falsePositives: number;
+    readonly falseNegatives: number;
+    readonly falsePositiveRate: number;
+    readonly falseNegativeRate: number;
+    readonly brier: number;
+    readonly expectedCalibrationError: number;
+}
+/** The full evaluation, with an optional hybrid escalation arm. */
+export interface DecisionEvaluation {
+    readonly threshold: number;
+    readonly base: DecisionMetrics;
+    readonly bestThreshold: number;
+    readonly bestAccuracy: number;
+    readonly sweep: readonly {
+        readonly threshold: number;
+        readonly accuracy: number;
+    }[];
+    readonly calibration: readonly {
+        readonly low: number;
+        readonly high: number;
+        readonly count: number;
+        readonly meanPredicted: number | null;
+        readonly observedRate: number | null;
+    }[];
+    readonly hybrid?: {
+        readonly rejectAt: number;
+        readonly acceptAt: number;
+        readonly escalated: number;
+        readonly escalationRate: number;
+        readonly accuracy: number;
+        readonly truePositives: number;
+        readonly trueNegatives: number;
+        readonly falsePositives: number;
+        readonly falseNegatives: number;
+        readonly falsePositiveRate: number;
+        readonly falseNegativeRate: number;
+        readonly escalatedCostUsd: number;
+        readonly escalatedLatencyMs: number;
+    };
+}
+/**
+ * Evaluate a labeled set: fixed threshold, best observed threshold, calibration bins,
+ * and an optional hybrid arm that sends the middle band to the secondary probability.
+ * @param rawCases - labeled observations.
+ * @param threshold - the primary cutoff (default 0.5).
+ * @param escalation - optional `{rejectAt, acceptAt}` hybrid band.
+ * @returns metrics, sweep and optional hybrid metrics.
+ */
+export declare function evaluateDecisions(rawCases: unknown, threshold?: number, escalation?: {
+    readonly rejectAt: number;
+    readonly acceptAt: number;
+}): DecisionEvaluation;
+/** The MCP contract for confidence routing. */
+export declare const DECISION_ROUTE_CONTRACT: {
+    readonly contract: "decision.route";
+    readonly version: "1.0.0";
+    readonly toolName: "decision_route";
+    readonly description: "Route a primary judgment probability into accept, reject or the escalate band.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["probability"];
+        readonly properties: {
+            readonly probability: {
+                readonly type: "number";
+            };
+            readonly acceptAt: {
+                readonly type: "number";
+            };
+            readonly rejectAt: {
+                readonly type: "number";
+            };
+        };
+    };
+    readonly outputSchema: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["route", "decision", "band", "reason"];
+        readonly properties: {
+            readonly route: {
+                readonly type: "string";
+            };
+            readonly decision: {
+                readonly type: readonly ["boolean", "null"];
+            };
+            readonly band: {
+                readonly type: "string";
+            };
+            readonly reason: {
+                readonly type: "string";
+            };
+        };
+    };
+    readonly semantics: {
+        readonly deterministic: true;
+        readonly readsInputs: true;
+    };
+    readonly limits: {};
+};
+/** The MCP contract for decision evaluation. */
+export declare const DECISION_EVALUATE_CONTRACT: {
+    readonly contract: "decision.evaluate";
+    readonly version: "1.0.0";
+    readonly toolName: "decision_evaluate";
+    readonly description: "Evaluate labeled decision probabilities: accuracy, FPR/FNR, Brier, calibration and an optional escalation arm.";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly additionalProperties: false;
+        readonly required: readonly ["cases"];
+        readonly properties: {
+            readonly cases: {
+                readonly type: "array";
+            };
+            readonly threshold: {
+                readonly type: "number";
+            };
+            readonly escalation: {
+                readonly type: "object";
+            };
+        };
+    };
+    readonly outputSchema: {
+        readonly type: "object";
+        readonly additionalProperties: true;
+    };
+    readonly semantics: {
+        readonly deterministic: true;
+        readonly readsInputs: true;
+    };
+    readonly limits: {};
+};
+//# sourceMappingURL=decision-evaluate.d.ts.map

package/lib/decision-evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decision-evaluate.d.ts","sourceRoot":"","sources":["../src/decision-evaluate.ts"],"names":[],"mappings":"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"}