kiokuko-dsh 0.2.16 → 0.2.18

package/dist/dsh/decisions/correction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"correction.d.ts","sourceRoot":"","sources":["../../../src/dsh/decisions/correction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,2CAA2C,CAAA;AAChF,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,qCAAqC,CAAA;AACvE,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,cAAc,CAAA;AAEjD,oFAAoF;AACpF,wBAAsB,oBAAoB,CAAC,OAAO,CAAC,EAAC,eAAe,GAAE,OAAO,CAAC;IAAC,IAAI,EAAC,cAAc,CAAC;IAAA,OAAO,CAAC,EAAC,iBAAiB,CAAA;CAAC,CAAC,CAU7H"}

package/dist/dsh/decisions/correction.js

@@ -0,0 +1,15 @@
+/** The configured Typed Decisions provider owns inference; no Jev-specific path. */
+export async function correctionClassifier(service) {
+    if (!service)
+        return { mode: 'shadow' };
+    await service.initialize();
+    const mode = service.correctionClassificationMode();
+    if (mode === 'off')
+        return { mode };
+    return { mode, backend: { configurationDigest: service.configurationDigest(), evaluate: async (id, batch, signal) => {
+                const config = await service.bind(id, signal);
+                const outcome = await service.evaluate(id, batch, signal);
+                return outcome.status === 'completed' ? { ...outcome, attested: config.provider !== 'laya-coreml' || config['laya-coreml']?.protocol !== 'v1' } : outcome;
+            } } };
+}
+//# sourceMappingURL=correction.js.map

package/dist/dsh/decisions/correction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"correction.js","sourceRoot":"","sources":["../../../src/dsh/decisions/correction.ts"],"names":[],"mappings":"AAIA,oFAAoF;AACpF,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,OAAwB;IACjE,IAAG,CAAC,OAAO;QAAC,OAAO,EAAC,IAAI,EAAC,QAAQ,EAAC,CAAA;IAClC,MAAM,OAAO,CAAC,UAAU,EAAE,CAAA;IAC1B,MAAM,IAAI,GAAC,OAAO,CAAC,4BAA4B,EAAE,CAAA;IACjD,IAAG,IAAI,KAAG,KAAK;QAAC,OAAO,EAAC,IAAI,EAAC,CAAA;IAC7B,OAAO,EAAC,IAAI,EAAC,OAAO,EAAC,EAAC,mBAAmB,EAAC,OAAO,CAAC,mBAAmB,EAAE,EAAC,QAAQ,EAAC,KAAK,EAAC,EAAE,EAAC,KAAK,EAAC,MAAM,EAAC,EAAE;gBACvG,MAAM,MAAM,GAAC,MAAM,OAAO,CAAC,IAAI,CAAC,EAAE,EAAC,MAAM,CAAC,CAAA;gBAC1C,MAAM,OAAO,GAAC,MAAM,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAC,KAAK,EAAC,MAAM,CAAC,CAAA;gBACrD,OAAO,OAAO,CAAC,MAAM,KAAG,WAAW,CAAA,CAAC,CAAA,EAAC,GAAG,OAAO,EAAC,QAAQ,EAAC,MAAM,CAAC,QAAQ,KAAG,aAAa,IAAE,MAAM,CAAC,aAAa,CAAC,EAAE,QAAQ,KAAG,IAAI,EAAC,CAAA,CAAC,CAAA,OAAO,CAAA;YAC3I,CAAC,EAAC,EAAC,CAAA;AACL,CAAC"}

package/dist/dsh/decisions/diagnostic-correlation.d.ts

@@ -0,0 +1,3 @@
+export declare function correlateRequestIntent(value: object, decisionId: string): void;
+export declare function requestIntentDiagnosticId(value: unknown): string | undefined;
+//# sourceMappingURL=diagnostic-correlation.d.ts.map

package/dist/dsh/decisions/diagnostic-correlation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic-correlation.d.ts","sourceRoot":"","sources":["../../../src/dsh/decisions/diagnostic-correlation.ts"],"names":[],"mappings":"AAEA,wBAAgB,sBAAsB,CAAC,KAAK,EAAC,MAAM,EAAC,UAAU,EAAC,MAAM,GAAE,IAAI,CAAqC;AAChH,wBAAgB,yBAAyB,CAAC,KAAK,EAAC,OAAO,GAAE,MAAM,GAAC,SAAS,CAExE"}

package/dist/dsh/decisions/diagnostic-correlation.js

@@ -0,0 +1,7 @@
+/** Process-local telemetry identity must never enter an authority fingerprint, wire value or cache key. */
+const identities = new WeakMap();
+export function correlateRequestIntent(value, decisionId) { identities.set(value, decisionId); }
+export function requestIntentDiagnosticId(value) {
+    return value && typeof value === 'object' ? identities.get(value) : undefined;
+}
+//# sourceMappingURL=diagnostic-correlation.js.map

package/dist/dsh/decisions/diagnostic-correlation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostic-correlation.js","sourceRoot":"","sources":["../../../src/dsh/decisions/diagnostic-correlation.ts"],"names":[],"mappings":"AAAA,2GAA2G;AAC3G,MAAM,UAAU,GAAC,IAAI,OAAO,EAAiB,CAAA;AAC7C,MAAM,UAAU,sBAAsB,CAAC,KAAY,EAAC,UAAiB,IAAS,UAAU,CAAC,GAAG,CAAC,KAAK,EAAC,UAAU,CAAC,CAAA,CAAC,CAAC;AAChH,MAAM,UAAU,yBAAyB,CAAC,KAAa;IACrD,OAAO,KAAK,IAAI,OAAO,KAAK,KAAG,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AAC7E,CAAC"}

package/dist/dsh/decisions/diagnostics.d.ts

@@ -0,0 +1,513 @@
+import type { IntentAssessment } from './intent-assessment.js';
+import { z } from 'zod';
+import type { SqliteDatabase } from '../../db/adapter.js';
+import type { RequestIntentContext, RequestIntentDecision } from './request-intent.js';
+export declare const DiagnosticBinding: z.ZodObject<{
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    repositoryDigest: z.ZodString;
+    revision: z.ZodNumber;
+    generation: z.ZodNumber;
+    sourceEpoch: z.ZodNumber;
+    workflowRevision: z.ZodOptional<z.ZodNumber>;
+    goalRevision: z.ZodOptional<z.ZodNumber>;
+    scopeRevision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type DiagnosticBinding = z.infer<typeof DiagnosticBinding>;
+export declare const DiagnosticAttempt: z.ZodObject<{
+    origin: z.ZodEnum<{
+        intake: "intake";
+        provider: "provider";
+    }>;
+    requestRef: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    turn: z.ZodOptional<z.ZodNumber>;
+    inputDigest: z.ZodString;
+    contextDigest: z.ZodOptional<z.ZodString>;
+    binding: z.ZodOptional<z.ZodObject<{
+        runId: z.ZodString;
+        sessionId: z.ZodString;
+        repositoryDigest: z.ZodString;
+        revision: z.ZodNumber;
+        generation: z.ZodNumber;
+        sourceEpoch: z.ZodNumber;
+        workflowRevision: z.ZodOptional<z.ZodNumber>;
+        goalRevision: z.ZodOptional<z.ZodNumber>;
+        scopeRevision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    policyRef: z.ZodString;
+    referenceDigests: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    purpose: z.ZodEnum<{
+        skills: "skills";
+        akinator: "akinator";
+        "request-intent": "request-intent";
+        "enno-check": "enno-check";
+        lisp: "lisp";
+        "memory-reuse": "memory-reuse";
+        compaction: "compaction";
+        "model-handoff": "model-handoff";
+        "answer-review": "answer-review";
+        "model-routing": "model-routing";
+        "intent-semantic-match": "intent-semantic-match";
+        "correction-classification": "correction-classification";
+    }>;
+}, z.core.$strict>;
+export type DiagnosticAttempt = z.input<typeof DiagnosticAttempt>;
+export declare const DIAGNOSTIC_REASONS: readonly ["observed", "resolved", "unresolved", "native_unowned", "clarification_required", "target_unknown", "scope_unknown", "transition_required", "question_unavailable", "context_changed", "answer_queued", "resume_observed", "receipt_observed", "continuation_observed", "assessment_disabled", "assessment_consistent", "assessment_clarify", "assessment_unavailable", "provider_completed", "provider_fallback", "provider_cancelled", "evaluation_failed"];
+export declare const DiagnosticEvent: z.ZodObject<{
+    kind: z.ZodEnum<{
+        reference: "reference";
+        provider: "provider";
+        extraction: "extraction";
+        answer: "answer";
+        question: "question";
+        receipt: "receipt";
+        semantic_match: "semantic_match";
+        choice: "choice";
+        resume: "resume";
+        detector: "detector";
+        route: "route";
+        admission: "admission";
+        task_resume: "task_resume";
+        continuation: "continuation";
+    }>;
+    status: z.ZodEnum<{
+        observed: "observed";
+        blocked: "blocked";
+        not_run: "not_run";
+        waiting: "waiting";
+        queued: "queued";
+    }>;
+    reason: z.ZodEnum<{
+        unresolved: "unresolved";
+        resolved: "resolved";
+        observed: "observed";
+        native_unowned: "native_unowned";
+        clarification_required: "clarification_required";
+        target_unknown: "target_unknown";
+        scope_unknown: "scope_unknown";
+        transition_required: "transition_required";
+        question_unavailable: "question_unavailable";
+        context_changed: "context_changed";
+        answer_queued: "answer_queued";
+        resume_observed: "resume_observed";
+        receipt_observed: "receipt_observed";
+        continuation_observed: "continuation_observed";
+        assessment_disabled: "assessment_disabled";
+        assessment_consistent: "assessment_consistent";
+        assessment_clarify: "assessment_clarify";
+        assessment_unavailable: "assessment_unavailable";
+        provider_completed: "provider_completed";
+        provider_fallback: "provider_fallback";
+        provider_cancelled: "provider_cancelled";
+        evaluation_failed: "evaluation_failed";
+    }>;
+    parentEventId: z.ZodOptional<z.ZodString>;
+    referenceDigest: z.ZodOptional<z.ZodString>;
+    targetSessionId: z.ZodOptional<z.ZodString>;
+    binding: z.ZodOptional<z.ZodObject<{
+        runId: z.ZodString;
+        sessionId: z.ZodString;
+        repositoryDigest: z.ZodString;
+        revision: z.ZodNumber;
+        generation: z.ZodNumber;
+        sourceEpoch: z.ZodNumber;
+        workflowRevision: z.ZodOptional<z.ZodNumber>;
+        goalRevision: z.ZodOptional<z.ZodNumber>;
+        scopeRevision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    relation: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        new: "new";
+        same_scope_continuation: "same_scope_continuation";
+        scope_change: "scope_change";
+    }>>;
+    action: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        research: "research";
+        answer: "answer";
+        change: "change";
+        verify: "verify";
+        operate: "operate";
+    }>>;
+    changeScope: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        implementation: "implementation";
+        document: "document";
+    }>>;
+    source: z.ZodOptional<z.ZodEnum<{
+        unresolved: "unresolved";
+        "decision-provider": "decision-provider";
+        "main-model": "main-model";
+    }>>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        typesafe: "typesafe";
+        nimble: "nimble";
+        "laya-coreml": "laya-coreml";
+    }>>;
+    modelRef: z.ZodOptional<z.ZodString>;
+    policyRef: z.ZodOptional<z.ZodString>;
+    detectorVersionRef: z.ZodOptional<z.ZodString>;
+    providerRevisionRef: z.ZodOptional<z.ZodString>;
+    elapsedMs: z.ZodOptional<z.ZodNumber>;
+    cacheHit: z.ZodOptional<z.ZodBoolean>;
+    providerDispatched: z.ZodOptional<z.ZodBoolean>;
+    semanticVerdict: z.ZodOptional<z.ZodEnum<{
+        unavailable: "unavailable";
+        contradicted: "contradicted";
+        insufficient: "insufficient";
+        supported: "supported";
+    }>>;
+    assessmentInputDigest: z.ZodOptional<z.ZodString>;
+    assessmentOutputDigest: z.ZodOptional<z.ZodString>;
+    judge: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<{
+            unavailable: "unavailable";
+            available: "available";
+        }>;
+        inputDigest: z.ZodOptional<z.ZodString>;
+        outputDigest: z.ZodOptional<z.ZodString>;
+        binaryHash: z.ZodOptional<z.ZodString>;
+        version: z.ZodLiteral<"kiokuko-fd-v1">;
+        complete: z.ZodOptional<z.ZodBoolean>;
+        status: z.ZodOptional<z.ZodEnum<{
+            entailed: "entailed";
+            refuted: "refuted";
+            undetermined: "undetermined";
+            inconsistent: "inconsistent";
+            resource_limit: "resource_limit";
+        }>>;
+        unavailableReason: z.ZodOptional<z.ZodEnum<{
+            cancelled: "cancelled";
+            timeout: "timeout";
+            unsupported_platform: "unsupported_platform";
+            artifact_unavailable: "artifact_unavailable";
+            artifact_mismatch: "artifact_mismatch";
+            invalid_input: "invalid_input";
+            process_failed: "process_failed";
+            output_limit: "output_limit";
+            malformed_response: "malformed_response";
+        }>>;
+    }, z.core.$strict>>;
+    selected: z.ZodOptional<z.ZodNumber>;
+    abstained: z.ZodOptional<z.ZodNumber>;
+    measured: z.ZodOptional<z.ZodNumber>;
+    choice: z.ZodOptional<z.ZodObject<{
+        questionRef: z.ZodString;
+        choiceRef: z.ZodString;
+        topProbability: z.ZodNumber;
+        runnerUpProbability: z.ZodNumber;
+        margin: z.ZodNumber;
+        confidence: z.ZodNumber;
+        gate: z.ZodEnum<{
+            confidence: "confidence";
+            probability_margin: "probability_margin";
+        }>;
+        acceptance: z.ZodObject<{
+            minConfidence: z.ZodOptional<z.ZodNumber>;
+            minProbability: z.ZodOptional<z.ZodNumber>;
+            minMargin: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        status: z.ZodEnum<{
+            selected: "selected";
+            abstained: "abstained";
+        }>;
+        failedChecks: z.ZodArray<z.ZodEnum<{
+            confidence: "confidence";
+            probability: "probability";
+            margin: "margin";
+        }>>;
+    }, z.core.$strict>>;
+    fallback: z.ZodOptional<z.ZodEnum<{
+        DECISION_TIMEOUT: "DECISION_TIMEOUT";
+        DECISION_UNAVAILABLE: "DECISION_UNAVAILABLE";
+        DECISION_AUTH: "DECISION_AUTH";
+        DECISION_CANCELLED: "DECISION_CANCELLED";
+        DECISION_INVALID_INPUT: "DECISION_INVALID_INPUT";
+        DECISION_UNSUPPORTED: "DECISION_UNSUPPORTED";
+        DECISION_TOO_LARGE: "DECISION_TOO_LARGE";
+        DECISION_MALFORMED_RESPONSE: "DECISION_MALFORMED_RESPONSE";
+        other: "other";
+    }>>;
+    resultRef: z.ZodOptional<z.ZodObject<{
+        requestId: z.ZodString;
+        inputDigest: z.ZodString;
+    }, z.core.$strict>>;
+    nextDecisionId: z.ZodOptional<z.ZodString>;
+    receiptId: z.ZodOptional<z.ZodString>;
+    continuationId: z.ZodOptional<z.ZodString>;
+    evaluationDecisionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type DiagnosticEvent = z.input<typeof DiagnosticEvent>;
+export type DiagnosticRuntime = {
+    withDatabase<T>(operation: (db: SqliteDatabase) => T): Promise<T>;
+};
+export declare function diagnosticId(): string;
+export declare function diagnosticEventId(decisionId: string, key: unknown): string;
+/** Current source epoch follows the same rule as task-source-history/finalization. */
+export declare function captureDiagnosticBinding(db: SqliteDatabase, runId: string, sessionId: string): DiagnosticBinding;
+export declare function createDiagnosticAttempt(db: SqliteDatabase, decisionId: string, raw: DiagnosticAttempt): void;
+/** Serialize sequence allocation and validate causality inside the caller's managed transaction. */
+export declare function appendDiagnosticEvent(db: SqliteDatabase, decisionId: string, eventId: string, raw: DiagnosticEvent): number;
+/** No raw exception is retained. A failed savepoint cannot alter the authoritative operation. */
+export declare function bestEffortDiagnostic(db: SqliteDatabase, scopeRef: string, operation: () => void): boolean;
+export declare function observeDiagnostic(runtime: DiagnosticRuntime, scope: string, operation: (db: SqliteDatabase) => void): Promise<void>;
+export declare function diagnosticRuntimeLosses(runtime: DiagnosticRuntime): number;
+/** Called only after the real host has bound the admitted run. Source interpretation stays immutable. */
+export declare function recordDiagnosticAdmission(db: SqliteDatabase, input: {
+    sessionId: string;
+    turn: number;
+    runId: string;
+    task: string;
+    context?: RequestIntentContext;
+    decision?: RequestIntentDecision;
+}): void;
+/** Same managed transaction as the authoritative state transition. Never creates a correctness label. */
+export declare function recordDiagnosticTaskResume(db: SqliteDatabase, runId: string, sessionId: string, operationId: string): void;
+/** The receipt/outbox already exists. Savepoint failure is advisory; outer rollback also rolls back diagnostics. */
+export declare function recordDiagnosticTurn(db: SqliteDatabase, receiptId: string): void;
+/** Runs after the existing Enno receipt trigger, inside its authoritative transaction. */
+export declare function recordDiagnosticEnnoCommit(db: SqliteDatabase, runId: string, operation: string, key: string): void;
+/** Trusted, independent adjudication API; never exposed as a model tool or inferred from resume. */
+export declare function reviewDiagnosticStop(db: SqliteDatabase, decisionId: string, verdict: 'false_stop' | 'justified_stop', reviewRef: string): void;
+/** SELECT-only. Never backfill, migrate, probe a provider, dispatch or label an outcome. */
+export declare function readDecisionDiagnostics(db: SqliteDatabase, sessionId: string, decisionId?: string): {
+    attempts: {
+        events: {
+            kind: "reference" | "provider" | "extraction" | "answer" | "question" | "receipt" | "semantic_match" | "choice" | "resume" | "detector" | "route" | "admission" | "task_resume" | "continuation";
+            status: "observed" | "blocked" | "not_run" | "waiting" | "queued";
+            reason: "unresolved" | "resolved" | "observed" | "native_unowned" | "clarification_required" | "target_unknown" | "scope_unknown" | "transition_required" | "question_unavailable" | "context_changed" | "answer_queued" | "resume_observed" | "receipt_observed" | "continuation_observed" | "assessment_disabled" | "assessment_consistent" | "assessment_clarify" | "assessment_unavailable" | "provider_completed" | "provider_fallback" | "provider_cancelled" | "evaluation_failed";
+            parentEventId?: string | undefined;
+            referenceDigest?: string | undefined;
+            targetSessionId?: string | undefined;
+            binding?: {
+                runId: string;
+                sessionId: string;
+                repositoryDigest: string;
+                revision: number;
+                generation: number;
+                sourceEpoch: number;
+                workflowRevision?: number | undefined;
+                goalRevision?: number | undefined;
+                scopeRevision?: number | undefined;
+            } | undefined;
+            relation?: "unknown" | "new" | "same_scope_continuation" | "scope_change" | undefined;
+            action?: "unknown" | "research" | "answer" | "change" | "verify" | "operate" | undefined;
+            changeScope?: "unknown" | "implementation" | "document" | undefined;
+            source?: "unresolved" | "decision-provider" | "main-model" | undefined;
+            provider?: "typesafe" | "nimble" | "laya-coreml" | undefined;
+            modelRef?: string | undefined;
+            policyRef?: string | undefined;
+            detectorVersionRef?: string | undefined;
+            providerRevisionRef?: string | undefined;
+            elapsedMs?: number | undefined;
+            cacheHit?: boolean | undefined;
+            providerDispatched?: boolean | undefined;
+            semanticVerdict?: "unavailable" | "contradicted" | "insufficient" | "supported" | undefined;
+            assessmentInputDigest?: string | undefined;
+            assessmentOutputDigest?: string | undefined;
+            judge?: {
+                state: "unavailable" | "available";
+                version: "kiokuko-fd-v1";
+                inputDigest?: string | undefined;
+                outputDigest?: string | undefined;
+                binaryHash?: string | undefined;
+                complete?: boolean | undefined;
+                status?: "entailed" | "refuted" | "undetermined" | "inconsistent" | "resource_limit" | undefined;
+                unavailableReason?: "cancelled" | "timeout" | "unsupported_platform" | "artifact_unavailable" | "artifact_mismatch" | "invalid_input" | "process_failed" | "output_limit" | "malformed_response" | undefined;
+            } | undefined;
+            selected?: number | undefined;
+            abstained?: number | undefined;
+            measured?: number | undefined;
+            choice?: {
+                questionRef: string;
+                choiceRef: string;
+                topProbability: number;
+                runnerUpProbability: number;
+                margin: number;
+                confidence: number;
+                gate: "confidence" | "probability_margin";
+                acceptance: {
+                    minConfidence?: number | undefined;
+                    minProbability?: number | undefined;
+                    minMargin?: number | undefined;
+                };
+                status: "selected" | "abstained";
+                failedChecks: ("confidence" | "probability" | "margin")[];
+            } | undefined;
+            fallback?: "DECISION_TIMEOUT" | "DECISION_UNAVAILABLE" | "DECISION_AUTH" | "DECISION_CANCELLED" | "DECISION_INVALID_INPUT" | "DECISION_UNSUPPORTED" | "DECISION_TOO_LARGE" | "DECISION_MALFORMED_RESPONSE" | "other" | undefined;
+            resultRef?: {
+                requestId: string;
+                inputDigest: string;
+            } | undefined;
+            nextDecisionId?: string | undefined;
+            receiptId?: string | undefined;
+            continuationId?: string | undefined;
+            evaluationDecisionId?: string | undefined;
+            eventId: unknown;
+            sequence: unknown;
+        }[];
+        authoritativeLinks: {
+            receipts: import("../../db/adapter.js").SqliteRow[];
+            outbox: import("../../db/adapter.js").SqliteRow[];
+        };
+        missingReceiptLinks: number;
+        missingContinuationLinks: number;
+        stages: {
+            extraction: "observed" | "blocked" | "not_run" | "waiting" | "queued";
+            semanticMatch: "observed" | "blocked" | "not_run" | "waiting" | "queued";
+            detector: "observed" | "blocked" | "not_run" | "waiting" | "queued";
+        };
+        providerAttempts: {
+            events: {
+                kind: "reference" | "provider" | "extraction" | "answer" | "question" | "receipt" | "semantic_match" | "choice" | "resume" | "detector" | "route" | "admission" | "task_resume" | "continuation";
+                status: "observed" | "blocked" | "not_run" | "waiting" | "queued";
+                reason: "unresolved" | "resolved" | "observed" | "native_unowned" | "clarification_required" | "target_unknown" | "scope_unknown" | "transition_required" | "question_unavailable" | "context_changed" | "answer_queued" | "resume_observed" | "receipt_observed" | "continuation_observed" | "assessment_disabled" | "assessment_consistent" | "assessment_clarify" | "assessment_unavailable" | "provider_completed" | "provider_fallback" | "provider_cancelled" | "evaluation_failed";
+                parentEventId?: string | undefined;
+                referenceDigest?: string | undefined;
+                targetSessionId?: string | undefined;
+                binding?: {
+                    runId: string;
+                    sessionId: string;
+                    repositoryDigest: string;
+                    revision: number;
+                    generation: number;
+                    sourceEpoch: number;
+                    workflowRevision?: number | undefined;
+                    goalRevision?: number | undefined;
+                    scopeRevision?: number | undefined;
+                } | undefined;
+                relation?: "unknown" | "new" | "same_scope_continuation" | "scope_change" | undefined;
+                action?: "unknown" | "research" | "answer" | "change" | "verify" | "operate" | undefined;
+                changeScope?: "unknown" | "implementation" | "document" | undefined;
+                source?: "unresolved" | "decision-provider" | "main-model" | undefined;
+                provider?: "typesafe" | "nimble" | "laya-coreml" | undefined;
+                modelRef?: string | undefined;
+                policyRef?: string | undefined;
+                detectorVersionRef?: string | undefined;
+                providerRevisionRef?: string | undefined;
+                elapsedMs?: number | undefined;
+                cacheHit?: boolean | undefined;
+                providerDispatched?: boolean | undefined;
+                semanticVerdict?: "unavailable" | "contradicted" | "insufficient" | "supported" | undefined;
+                assessmentInputDigest?: string | undefined;
+                assessmentOutputDigest?: string | undefined;
+                judge?: {
+                    state: "unavailable" | "available";
+                    version: "kiokuko-fd-v1";
+                    inputDigest?: string | undefined;
+                    outputDigest?: string | undefined;
+                    binaryHash?: string | undefined;
+                    complete?: boolean | undefined;
+                    status?: "entailed" | "refuted" | "undetermined" | "inconsistent" | "resource_limit" | undefined;
+                    unavailableReason?: "cancelled" | "timeout" | "unsupported_platform" | "artifact_unavailable" | "artifact_mismatch" | "invalid_input" | "process_failed" | "output_limit" | "malformed_response" | undefined;
+                } | undefined;
+                selected?: number | undefined;
+                abstained?: number | undefined;
+                measured?: number | undefined;
+                choice?: {
+                    questionRef: string;
+                    choiceRef: string;
+                    topProbability: number;
+                    runnerUpProbability: number;
+                    margin: number;
+                    confidence: number;
+                    gate: "confidence" | "probability_margin";
+                    acceptance: {
+                        minConfidence?: number | undefined;
+                        minProbability?: number | undefined;
+                        minMargin?: number | undefined;
+                    };
+                    status: "selected" | "abstained";
+                    failedChecks: ("confidence" | "probability" | "margin")[];
+                } | undefined;
+                fallback?: "DECISION_TIMEOUT" | "DECISION_UNAVAILABLE" | "DECISION_AUTH" | "DECISION_CANCELLED" | "DECISION_INVALID_INPUT" | "DECISION_UNSUPPORTED" | "DECISION_TOO_LARGE" | "DECISION_MALFORMED_RESPONSE" | "other" | undefined;
+                resultRef?: {
+                    requestId: string;
+                    inputDigest: string;
+                } | undefined;
+                nextDecisionId?: string | undefined;
+                receiptId?: string | undefined;
+                continuationId?: string | undefined;
+                evaluationDecisionId?: string | undefined;
+            }[];
+            origin: "intake" | "provider";
+            requestRef: string;
+            inputDigest: string;
+            policyRef: string;
+            referenceDigests: string[];
+            purpose: "skills" | "akinator" | "request-intent" | "enno-check" | "lisp" | "memory-reuse" | "compaction" | "model-handoff" | "answer-review" | "model-routing" | "intent-semantic-match" | "correction-classification";
+            sessionId?: string | undefined;
+            turn?: number | undefined;
+            contextDigest?: string | undefined;
+            binding?: {
+                runId: string;
+                sessionId: string;
+                repositoryDigest: string;
+                revision: number;
+                generation: number;
+                sourceEpoch: number;
+                workflowRevision?: number | undefined;
+                goalRevision?: number | undefined;
+                scopeRevision?: number | undefined;
+            } | undefined;
+            decisionId: unknown;
+        }[];
+        origin: "intake" | "provider";
+        requestRef: string;
+        inputDigest: string;
+        policyRef: string;
+        referenceDigests: string[];
+        purpose: "skills" | "akinator" | "request-intent" | "enno-check" | "lisp" | "memory-reuse" | "compaction" | "model-handoff" | "answer-review" | "model-routing" | "intent-semantic-match" | "correction-classification";
+        sessionId?: string | undefined;
+        turn?: number | undefined;
+        contextDigest?: string | undefined;
+        binding?: {
+            runId: string;
+            sessionId: string;
+            repositoryDigest: string;
+            revision: number;
+            generation: number;
+            sourceEpoch: number;
+            workflowRevision?: number | undefined;
+            goalRevision?: number | undefined;
+            scopeRevision?: number | undefined;
+        } | undefined;
+        decisionId: unknown;
+    }[];
+    metrics: {
+        stopped: number;
+        evaluated: number;
+        falseStops: number;
+        falseStopRate: number | null;
+        evaluationRate: number | null;
+    };
+    completeness: {
+        persistedGaps: number;
+        volatileLosses: number;
+        missingReceiptLinks: number;
+        missingContinuationLinks: number;
+    };
+    truncated: boolean;
+};
+export interface IntakeDiagnosticInput {
+    agent: {
+        session?: {
+            id: string;
+        };
+    };
+    turn: number;
+    messages: readonly unknown[];
+}
+export interface IntakeDiagnosticObservation {
+    kind: 'interpretation' | 'native_unowned' | 'question' | 'answer' | 'resume' | 'assessment' | 'assessment_disabled';
+    assessment?: IntentAssessment;
+    context?: RequestIntentContext;
+    decision?: RequestIntentDecision;
+    questionRef?: string;
+    answerRef?: string;
+    reason?: 'target_unknown' | 'scope_unknown' | 'transition_required' | 'clarification_required' | 'context_changed';
+}
+/** References originate in captured native input / host-issued question and followup IDs, never model submissions. */
+export declare function createIntakeDiagnosticSink(runtime: DiagnosticRuntime): (input: IntakeDiagnosticInput, observation: IntakeDiagnosticObservation) => Promise<void>;
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/dsh/decisions/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../../../src/dsh/decisions/diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA;AAE9D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAGzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,qBAAqB,CAAA;AAStF,eAAO,MAAM,iBAAiB;;;;;;;;;;kBAE4F,CAAA;AAC1H,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG2L,CAAA;AACzN,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,eAAO,MAAM,kBAAkB,ycAE0J,CAAA;AACzL,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuBmH,CAAA;AAC/I,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAC7D,MAAM,MAAM,iBAAiB,GAAG;IAAE,YAAY,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,cAAc,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;CAAE,CAAA;AAGrG,wBAAgB,YAAY,IAAI,MAAM,CAAoD;AAC1F,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,MAAM,CAAkD;AAE7H,sFAAsF;AACtF,wBAAgB,wBAAwB,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,iBAAiB,CAWhH;AAKD,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,iBAAiB,GAAG,IAAI,CAU5G;AACD,oGAAoG;AACpG,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,eAAe,GAAG,MAAM,CAmD3H;AACD,iGAAiG;AACjG,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,IAAI,GAAG,OAAO,CAQzG;AACD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,cAAc,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAGzI;AACD,wBAAgB,uBAAuB,CAAC,OAAO,EAAC,iBAAiB,GAAE,MAAM,CAAoC;AAE7G,yGAAyG;AACzG,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE;IAAC,SAAS,EAAC,MAAM,CAAC;IAAA,IAAI,EAAC,MAAM,CAAC;IAAA,KAAK,EAAC,MAAM,CAAC;IAAA,IAAI,EAAC,MAAM,CAAC;IAAA,OAAO,CAAC,EAAC,oBAAoB,CAAC;IAAA,QAAQ,CAAC,EAAC,qBAAqB,CAAA;CAAC,GAAG,IAAI,CAmBhM;AACD,yGAAyG;AACzG,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,cAAc,EAAE,KAAK,EAAC,MAAM,EAAC,SAAS,EAAC,MAAM,EAAC,WAAW,EAAC,MAAM,GAAE,IAAI,CAYpH;AACD,oHAAoH;AACpH,wBAAgB,oBAAoB,CAAC,EAAE,EAAC,cAAc,EAAC,SAAS,EAAC,MAAM,GAAE,IAAI,CAc5E;AACD,0FAA0F;AAC1F,wBAAgB,0BAA0B,CAAC,EAAE,EAAC,cAAc,EAAC,KAAK,EAAC,MAAM,EAAC,SAAS,EAAC,MAAM,EAAC,GAAG,EAAC,MAAM,GAAE,IAAI,CAK1G;AAED,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAC,gBAAgB,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAQ5I;AACD,4FAA4F;AAC5F,wBAAgB,uBAAuB,CAAC,EAAE,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjG;AAoCD,MAAM,WAAW,qBAAqB;IAAG,KAAK,EAAE;QAAE,OAAO,CAAC,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAA;CAAE;AAC1H,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,gBAAgB,GAAC,gBAAgB,GAAC,UAAU,GAAC,QAAQ,GAAC,QAAQ,GAAC,YAAY,GAAC,qBAAqB,CAAC;IAAC,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAAC,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAAC,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACzM,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,gBAAgB,GAAC,eAAe,GAAC,qBAAqB,GAAC,wBAAwB,GAAC,iBAAiB,CAAA;CACrJ;AACD,sHAAsH;AACtH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iBAAiB,IAErD,OAAO,qBAAqB,EAAE,aAAa,2BAA2B,KAAG,OAAO,CAAC,IAAI,CAAC,CA6DrG"}