@nexalink/coding-contracts 0.3.0 → 0.4.0

package/dist/index.js

@@ -41,6 +41,7 @@ export const RCM_MODEL_POLICY_ID = "carecompass-rcm-review-v1";
 export const RCM_HUMAN_REVIEW_POLICY_ID = "qualified-coder-review-v1";
 export const RCM_OUTPUT_SCHEMA_NAME = "carecompass_rcm_grounded_review";
 export const RCM_HUMAN_REVIEW_INSTRUCTION = "Qualified human coder review is required before billing, coding, or claim submission.";
+export const PIN_TIME_WORKFLOW_ID = "monthly-pin-time-aggregation";
 // Schema wire versions (source: schemas/*.schema.json).
 export const CODING_CASE_CONTEXT_SCHEMA_VERSION = "coding-case-context-v1";
 export const CODING_CASE_PAYER_SCHEMA_VERSION = "coding-case-payer-v1";
@@ -59,6 +60,7 @@ export const RCM_INPUT_SCHEMA_VERSION = "rcm-coding-input-v1";
 export const RCM_OUTPUT_SCHEMA_VERSION = "rcm-grounded-human-review-v2";
 export const RCM_MODEL_PROMPT_SCHEMA_VERSION = "rcm-model-prompt-v1";
 export const RCM_RETRIEVAL_SCHEMA_VERSION = "rcm-retrieval-metadata-v1";
+export const RCM_REVIEWER_EVENT_SCHEMA_VERSION = "rcm-reviewer-event-v1";
 export const RCM_RUNTIME_EVENT_SCHEMA_VERSION = "rcm-runtime-event-v1";
 export const RCM_WORKFLOW_CATALOG_SCHEMA_VERSION = "rcm-workflow-catalog-v1";
 // --------------------------------------------------------------------
@@ -3166,7 +3168,7 @@ export const CodingRuleResultSchemaJson = {
     },
 };
 // --------------------------------------------------------------------
-// CodingReviewerAction (schema 1.0.0, wire coding-reviewer-action-v1)
+// CodingReviewerAction (schema 1.1.0, wire coding-reviewer-action-v1)
 // --------------------------------------------------------------------
 export const codingReviewerActionSchema = z
     .object({
@@ -3179,6 +3181,15 @@ export const codingReviewerActionSchema = z
         "escalated",
     ]),
     resolutionCode: z.string().min(1).max(80).optional(),
+    reviewOutcomeCategory: z
+        .enum([
+        "unsupported_or_excessive",
+        "missed_supported",
+        "unchanged_supported",
+        "missing_evidence",
+        "escalation",
+    ])
+        .optional(),
     notes: z
         .string()
         .min(1)
@@ -3202,6 +3213,7 @@ export function codingReviewerActionValidationError(value) {
         "reviewerRole",
         "action",
         "resolutionCode",
+        "reviewOutcomeCategory",
         "notes",
         "occurredAt",
     ].includes(key)))
@@ -3229,6 +3241,18 @@ export function codingReviewerActionValidationError(value) {
             value_resolutionCode.length > 80)
             return "reviewer_action_resolution_code";
     }
+    if (value["reviewOutcomeCategory"] !== undefined) {
+        const value_reviewOutcomeCategory = value["reviewOutcomeCategory"];
+        if (typeof value_reviewOutcomeCategory !== "string" ||
+            ![
+                "unsupported_or_excessive",
+                "missed_supported",
+                "unchanged_supported",
+                "missing_evidence",
+                "escalation",
+            ].includes(value_reviewOutcomeCategory))
+            return "reviewer_action_outcome_category";
+    }
     if (value["notes"] !== undefined) {
         const value_notes = value["notes"];
         if (typeof value_notes !== "string" ||
@@ -3250,8 +3274,8 @@ export const CodingReviewerActionSchemaJson = {
     $schema: "https://json-schema.org/draft/2020-12/schema",
     $id: "https://nexalink.care/contracts/coding-reviewer-action.schema.json",
     title: "CodingReviewerAction",
-    description: "Attributable human-review disposition appended to an otherwise immutable decision. A decision plus its reviewer actions remains replayable: original and reviewer versions are both preserved.",
-    version: "1.0.0",
+    description: "Attributable human-review disposition appended to an otherwise immutable decision. A decision plus its reviewer actions remains replayable: original and reviewer versions are both preserved. Review outcome categories are reviewer-adjudicated observations and never inferred from payment, code, or reimbursement changes.",
+    version: "1.1.0",
     type: "object",
     additionalProperties: false,
     required: ["reviewerId", "action", "occurredAt"],
@@ -3275,6 +3299,16 @@ export const CodingReviewerActionSchemaJson = {
             minLength: 1,
             maxLength: 80,
         },
+        reviewOutcomeCategory: {
+            type: "string",
+            enum: [
+                "unsupported_or_excessive",
+                "missed_supported",
+                "unchanged_supported",
+                "missing_evidence",
+                "escalation",
+            ],
+        },
         notes: {
             type: "string",
             minLength: 1,
@@ -3466,7 +3500,7 @@ export const codingDecisionSchema = z
         });
     }
 });
-export function codingDecisionValidationError(value, options) {
+export function codingDecisionValidationError(value) {
     if (!isRecord(value))
         return "coding_decision";
     if (![
@@ -5203,6 +5237,341 @@ export const RcmRetrievalMetadataSchemaJson = {
     },
 };
 // --------------------------------------------------------------------
+// RcmReviewerEvent (schema 1.0.0, wire rcm-reviewer-event-v1)
+// --------------------------------------------------------------------
+export const rcmReviewerEventSchema = z
+    .object({
+    eventName: z.enum([
+        "review_opened",
+        "decision_shown",
+        "evidence_opened",
+        "evidence_copied",
+        "review_active_time",
+    ]),
+    occurredAt: z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$"))
+        .refine(isRfc3339DateTime)
+        .max(64),
+    tenantRef: z
+        .string()
+        .regex(new RegExp("^[A-Za-z0-9_.:-]+$"))
+        .min(1)
+        .max(128),
+    caseRef: z.string().regex(new RegExp("^[A-Za-z0-9_.:-]+$")).min(1).max(128),
+    reviewId: z
+        .string()
+        .regex(new RegExp("^[A-Za-z0-9_.:-]+$"))
+        .min(1)
+        .max(128)
+        .optional(),
+    workflowId: z.enum([
+        "rcm-coding-assistance",
+        "monthly-pin-time-aggregation",
+    ]),
+    packId: z
+        .string()
+        .regex(new RegExp("^[A-Za-z0-9_.:-]+$"))
+        .min(1)
+        .max(80)
+        .optional(),
+    packVersion: z
+        .string()
+        .regex(new RegExp("^[A-Za-z0-9_.:-]+$"))
+        .min(1)
+        .max(80)
+        .optional(),
+    environment: z.enum(["development", "staging", "production"]).optional(),
+    source: z.enum(["portal", "embed"]),
+    evidenceId: z
+        .string()
+        .regex(new RegExp("^[A-Za-z0-9_.:-]{1,64}$"))
+        .min(1)
+        .max(64)
+        .optional(),
+    activeSeconds: z.number().int().min(0).max(86400).optional(),
+    idlePaused: z.boolean().optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const isEvidenceEvent = value["eventName"] === "evidence_opened" ||
+        value["eventName"] === "evidence_copied";
+    const isActiveTimeEvent = value["eventName"] === "review_active_time";
+    if (isEvidenceEvent !== (value.evidenceId !== undefined) ||
+        isActiveTimeEvent !== (value.activeSeconds !== undefined) ||
+        (!isActiveTimeEvent && value.idlePaused !== undefined)) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["eventName"],
+            message: "reviewer_event_shape",
+        });
+    }
+});
+export function rcmReviewerEventValidationError(value) {
+    if (!isRecord(value))
+        return "reviewer_event";
+    if (![
+        "eventName",
+        "occurredAt",
+        "tenantRef",
+        "caseRef",
+        "workflowId",
+        "source",
+    ].every((key) => key in value))
+        return "reviewer_event_keys";
+    if (!Object.keys(value).every((key) => [
+        "eventName",
+        "occurredAt",
+        "tenantRef",
+        "caseRef",
+        "reviewId",
+        "workflowId",
+        "packId",
+        "packVersion",
+        "environment",
+        "source",
+        "evidenceId",
+        "activeSeconds",
+        "idlePaused",
+    ].includes(key)))
+        return "reviewer_event_keys";
+    const value_eventName = value["eventName"];
+    if (typeof value_eventName !== "string" ||
+        ![
+            "review_opened",
+            "decision_shown",
+            "evidence_opened",
+            "evidence_copied",
+            "review_active_time",
+        ].includes(value_eventName))
+        return "reviewer_event_name";
+    const value_occurredAt = value["occurredAt"];
+    if (typeof value_occurredAt !== "string" ||
+        value_occurredAt.length > 64 ||
+        !new RegExp("^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$").test(value_occurredAt) ||
+        !isRfc3339DateTime(value_occurredAt))
+        return "reviewer_event_occurred_at";
+    const value_tenantRef = value["tenantRef"];
+    if (typeof value_tenantRef !== "string" ||
+        value_tenantRef.length < 1 ||
+        value_tenantRef.length > 128 ||
+        !new RegExp("^[A-Za-z0-9_.:-]+$").test(value_tenantRef))
+        return "reviewer_event_tenant_ref";
+    const value_caseRef = value["caseRef"];
+    if (typeof value_caseRef !== "string" ||
+        value_caseRef.length < 1 ||
+        value_caseRef.length > 128 ||
+        !new RegExp("^[A-Za-z0-9_.:-]+$").test(value_caseRef))
+        return "reviewer_event_case_ref";
+    if (value["reviewId"] !== undefined) {
+        const value_reviewId = value["reviewId"];
+        if (typeof value_reviewId !== "string" ||
+            value_reviewId.length < 1 ||
+            value_reviewId.length > 128 ||
+            !new RegExp("^[A-Za-z0-9_.:-]+$").test(value_reviewId))
+            return "reviewer_event_review_id";
+    }
+    const value_workflowId = value["workflowId"];
+    if (typeof value_workflowId !== "string" ||
+        !["rcm-coding-assistance", "monthly-pin-time-aggregation"].includes(value_workflowId))
+        return "reviewer_event_workflow_id";
+    if (value["packId"] !== undefined) {
+        const value_packId = value["packId"];
+        if (typeof value_packId !== "string" ||
+            value_packId.length < 1 ||
+            value_packId.length > 80 ||
+            !new RegExp("^[A-Za-z0-9_.:-]+$").test(value_packId))
+            return "reviewer_event_pack_id";
+    }
+    if (value["packVersion"] !== undefined) {
+        const value_packVersion = value["packVersion"];
+        if (typeof value_packVersion !== "string" ||
+            value_packVersion.length < 1 ||
+            value_packVersion.length > 80 ||
+            !new RegExp("^[A-Za-z0-9_.:-]+$").test(value_packVersion))
+            return "reviewer_event_pack_version";
+    }
+    if (value["environment"] !== undefined) {
+        const value_environment = value["environment"];
+        if (typeof value_environment !== "string" ||
+            !["development", "staging", "production"].includes(value_environment))
+            return "reviewer_event_environment";
+    }
+    const value_source = value["source"];
+    if (typeof value_source !== "string" ||
+        !["portal", "embed"].includes(value_source))
+        return "reviewer_event_source";
+    if (value["evidenceId"] !== undefined) {
+        const value_evidenceId = value["evidenceId"];
+        if (typeof value_evidenceId !== "string" ||
+            value_evidenceId.length < 1 ||
+            value_evidenceId.length > 64 ||
+            !new RegExp("^[A-Za-z0-9_.:-]{1,64}$").test(value_evidenceId))
+            return "reviewer_event_evidence_id";
+    }
+    if (value["activeSeconds"] !== undefined) {
+        const value_activeSeconds = value["activeSeconds"];
+        if (typeof value_activeSeconds !== "number" ||
+            Number.isNaN(value_activeSeconds) ||
+            !Number.isInteger(value_activeSeconds) ||
+            value_activeSeconds < 0 ||
+            value_activeSeconds > 86400)
+            return "reviewer_event_active_seconds";
+    }
+    if (value["idlePaused"] !== undefined) {
+        const value_idlePaused = value["idlePaused"];
+        if (typeof value_idlePaused !== "boolean")
+            return "reviewer_event_idle_paused";
+    }
+    const eventName = value["eventName"];
+    const isEvidenceEvent = eventName === "evidence_opened" || eventName === "evidence_copied";
+    if (isEvidenceEvent !== (value["evidenceId"] !== undefined))
+        return "reviewer_event_shape";
+    const isActiveTimeEvent = eventName === "review_active_time";
+    if (isActiveTimeEvent !== (value["activeSeconds"] !== undefined))
+        return "reviewer_event_shape";
+    if (!isActiveTimeEvent && value["idlePaused"] !== undefined)
+        return "reviewer_event_shape";
+    return null;
+}
+export const validRcmReviewerEvent = (value) => rcmReviewerEventValidationError(value) === null;
+export const RcmReviewerEventSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/rcm-reviewer-event.schema.json",
+    title: "RcmReviewerEvent",
+    description: "Tenant-scoped, PHI-free reviewer engagement event for CareCompass RCM workflows. Events carry only an opaque case reference, categorical engagement facts, and aggregate durations. They never carry prompts, model responses, document contents, patient or member identifiers, claim identifiers, or free text.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "eventName",
+        "occurredAt",
+        "tenantRef",
+        "caseRef",
+        "workflowId",
+        "source",
+    ],
+    properties: {
+        eventName: {
+            type: "string",
+            enum: [
+                "review_opened",
+                "decision_shown",
+                "evidence_opened",
+                "evidence_copied",
+                "review_active_time",
+            ],
+        },
+        occurredAt: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}T(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d(?:\\.\\d+)?(?:Z|[+-](?:[01]\\d|2[0-3]):[0-5]\\d)$",
+            format: "date-time",
+            maxLength: 64,
+        },
+        tenantRef: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+            pattern: "^[A-Za-z0-9_.:-]+$",
+        },
+        caseRef: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+            pattern: "^[A-Za-z0-9_.:-]+$",
+        },
+        reviewId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+            pattern: "^[A-Za-z0-9_.:-]+$",
+        },
+        workflowId: {
+            type: "string",
+            enum: ["rcm-coding-assistance", "monthly-pin-time-aggregation"],
+        },
+        packId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 80,
+            pattern: "^[A-Za-z0-9_.:-]+$",
+        },
+        packVersion: {
+            type: "string",
+            minLength: 1,
+            maxLength: 80,
+            pattern: "^[A-Za-z0-9_.:-]+$",
+        },
+        environment: {
+            type: "string",
+            enum: ["development", "staging", "production"],
+        },
+        source: {
+            type: "string",
+            enum: ["portal", "embed"],
+        },
+        evidenceId: {
+            type: "string",
+            minLength: 1,
+            pattern: "^[A-Za-z0-9_.:-]{1,64}$",
+            maxLength: 64,
+        },
+        activeSeconds: {
+            type: "integer",
+            minimum: 0,
+            maximum: 86400,
+        },
+        idlePaused: {
+            type: "boolean",
+        },
+    },
+    allOf: [
+        {
+            if: {
+                properties: {
+                    eventName: {
+                        enum: ["evidence_opened", "evidence_copied"],
+                    },
+                },
+                required: ["eventName"],
+            },
+            then: {
+                required: ["evidenceId"],
+            },
+            else: {
+                not: {
+                    required: ["evidenceId"],
+                },
+            },
+        },
+        {
+            if: {
+                properties: {
+                    eventName: {
+                        const: "review_active_time",
+                    },
+                },
+                required: ["eventName"],
+            },
+            then: {
+                required: ["activeSeconds"],
+            },
+            else: {
+                not: {
+                    anyOf: [
+                        {
+                            required: ["activeSeconds"],
+                        },
+                        {
+                            required: ["idlePaused"],
+                        },
+                    ],
+                },
+            },
+        },
+    ],
+};
+// --------------------------------------------------------------------
 // RcmRuntimeEvent (schema 1.0.0, wire rcm-runtime-event-v1)
 // --------------------------------------------------------------------
 export const rcmRuntimeEventSchema = z
@@ -5560,17 +5929,20 @@ export const RcmRuntimeEventSchemaJson = {
     },
 };
 // --------------------------------------------------------------------
-// RcmWorkflowCatalog (schema 1.0.0, wire rcm-workflow-catalog-v1)
+// RcmWorkflowCatalog (schema 1.1.0, wire rcm-workflow-catalog-v1)
 // --------------------------------------------------------------------
 export const rcmWorkflowCatalogSchema = z
     .object({
-    id: z.enum(["rcm-coding-assistance"]),
+    id: z.enum(["rcm-coding-assistance", "monthly-pin-time-aggregation"]),
     name: z.string().min(1).max(120),
     description: z.string().min(1).max(400),
     environments: z.array(z.enum(["development", "production"])).min(1),
     modelPolicy: z
         .object({
-        policyId: z.literal("carecompass-rcm-review-v1"),
+        policyId: z.enum([
+            "carecompass-rcm-review-v1",
+            "carecompass-pin-time-policy-v1",
+        ]),
         inferencePath: z.string().max(64),
         maxNewTokens: z.number().int().min(1).max(2048),
         temperature: z.number().min(0).max(2),
@@ -5586,7 +5958,21 @@ export const rcmWorkflowCatalogSchema = z
         .strict(),
     outputSchemaVersion: z.literal("rcm-grounded-human-review-v2"),
 })
-    .strict();
+    .strict()
+    .superRefine((value, ctx) => {
+    const expectedPolicy = value.id === "rcm-coding-assistance"
+        ? "carecompass-rcm-review-v1"
+        : "carecompass-pin-time-policy-v1";
+    if (value.modelPolicy.policyId !== expectedPolicy ||
+        (value.id === "monthly-pin-time-aggregation" &&
+            value.environments.some((environment) => environment !== "development"))) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["modelPolicy"],
+            message: "workflow_policy_binding",
+        });
+    }
+});
 export function rcmWorkflowCatalogValidationError(value) {
     if (!isRecord(value))
         return "workflow_catalog";
@@ -5612,7 +5998,7 @@ export function rcmWorkflowCatalogValidationError(value) {
         return "workflow_catalog_keys";
     const value_id = value["id"];
     if (typeof value_id !== "string" ||
-        !["rcm-coding-assistance"].includes(value_id))
+        !["rcm-coding-assistance", "monthly-pin-time-aggregation"].includes(value_id))
         return "workflow_id";
     const value_name = value["name"];
     if (typeof value_name !== "string" ||
@@ -5655,7 +6041,7 @@ export function rcmWorkflowCatalogValidationError(value) {
         return "model_policy_keys";
     const value_modelPolicy_policyId = value_modelPolicy["policyId"];
     if (typeof value_modelPolicy_policyId !== "string" ||
-        value_modelPolicy_policyId !== "carecompass-rcm-review-v1")
+        !["carecompass-rcm-review-v1", "carecompass-pin-time-policy-v1"].includes(value_modelPolicy_policyId))
         return "model_policy_id";
     const value_modelPolicy_inferencePath = value_modelPolicy["inferencePath"];
     if (typeof value_modelPolicy_inferencePath !== "string" ||
@@ -5701,6 +6087,15 @@ export function rcmWorkflowCatalogValidationError(value) {
     if (typeof value_outputSchemaVersion !== "string" ||
         value_outputSchemaVersion !== "rcm-grounded-human-review-v2")
         return "workflow_output_schema_version";
+    const policy = isRecord(value["modelPolicy"]) ? value["modelPolicy"] : {};
+    const expectedPolicy = value["id"] === "rcm-coding-assistance"
+        ? "carecompass-rcm-review-v1"
+        : "carecompass-pin-time-policy-v1";
+    if (policy["policyId"] !== expectedPolicy ||
+        (value["id"] === "monthly-pin-time-aggregation" &&
+            Array.isArray(value["environments"]) &&
+            value["environments"].some((environment) => environment !== "development")))
+        return "workflow_policy_binding";
     return null;
 }
 export const validRcmWorkflowCatalog = (value) => rcmWorkflowCatalogValidationError(value) === null;
@@ -5708,8 +6103,8 @@ export const RcmWorkflowCatalogSchemaJson = {
     $schema: "https://json-schema.org/draft/2020-12/schema",
     $id: "https://nexalink.care/contracts/rcm-workflow-catalog.schema.json",
     title: "RcmWorkflowCatalog",
-    description: "A single authorized workflow entry. The catalog pins the workflow identifier, model policy, human-review policy, and output schema version that the runtime and portal may offer for the RCM coding-assistance workflow. Customer configuration can never redefine these immutable server-side values.",
-    version: "1.0.0",
+    description: "A single authorized workflow entry. The catalog pins the workflow identifier, model policy, human-review policy, and output schema version that the runtime and portal may offer for registered coding workflows (currently rcm-coding-assistance and monthly-pin-time-aggregation). Customer configuration can never redefine these immutable server-side values.",
+    version: "1.1.0",
     type: "object",
     additionalProperties: false,
     required: [
@@ -5724,7 +6119,7 @@ export const RcmWorkflowCatalogSchemaJson = {
     properties: {
         id: {
             type: "string",
-            enum: ["rcm-coding-assistance"],
+            enum: ["rcm-coding-assistance", "monthly-pin-time-aggregation"],
         },
         name: {
             type: "string",
@@ -5758,7 +6153,7 @@ export const RcmWorkflowCatalogSchemaJson = {
             properties: {
                 policyId: {
                     type: "string",
-                    const: "carecompass-rcm-review-v1",
+                    enum: ["carecompass-rcm-review-v1", "carecompass-pin-time-policy-v1"],
                 },
                 inferencePath: {
                     type: "string",
@@ -5804,4 +6199,51 @@ export const RcmWorkflowCatalogSchemaJson = {
             const: "rcm-grounded-human-review-v2",
         },
     },
+    allOf: [
+        {
+            if: {
+                properties: {
+                    id: {
+                        const: "rcm-coding-assistance",
+                    },
+                },
+            },
+            then: {
+                properties: {
+                    modelPolicy: {
+                        properties: {
+                            policyId: {
+                                const: "carecompass-rcm-review-v1",
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        {
+            if: {
+                properties: {
+                    id: {
+                        const: "monthly-pin-time-aggregation",
+                    },
+                },
+            },
+            then: {
+                properties: {
+                    modelPolicy: {
+                        properties: {
+                            policyId: {
+                                const: "carecompass-pin-time-policy-v1",
+                            },
+                        },
+                    },
+                    environments: {
+                        items: {
+                            const: "development",
+                        },
+                    },
+                },
+            },
+        },
+    ],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexalink/coding-contracts",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Versioned TypeScript types, validators, constants, and JSON Schemas for CareCompass coding workflows.",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,8 +32,10 @@
     "contracts:check": "bun scripts/codegen.ts --check",
     "format": "bunx prettier --write --ignore-unknown .",
     "format:check": "bunx prettier --check --ignore-unknown .",
+    "lint": "bunx eslint .",
     "test": "bun test",
     "test:python": "PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=python .venv/bin/python -m pytest -p no:cacheprovider python/tests",
+    "tidy": "bun run format && bun run lint",
     "audit": "bun audit",
     "verify:package": "bun scripts/verify-package.mjs",
     "pack:dry-run": "bun run build && bun run verify:package && bun pm pack --dry-run --ignore-scripts",
@@ -43,8 +45,12 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.12.0",
+    "globals": "^17.13.0",
     "prettier": "3.8.1",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.2",
+    "typescript-eslint": "^8.71.0"
   },
   "publishConfig": {
     "access": "public",

package/schemas/coding-reviewer-action.schema.json

@@ -2,8 +2,8 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://nexalink.care/contracts/coding-reviewer-action.schema.json",
   "title": "CodingReviewerAction",
-  "description": "Attributable human-review disposition appended to an otherwise immutable decision. A decision plus its reviewer actions remains replayable: original and reviewer versions are both preserved.",
-  "version": "1.0.0",
+  "description": "Attributable human-review disposition appended to an otherwise immutable decision. A decision plus its reviewer actions remains replayable: original and reviewer versions are both preserved. Review outcome categories are reviewer-adjudicated observations and never inferred from payment, code, or reimbursement changes.",
+  "version": "1.1.0",
   "x-wire-version": "coding-reviewer-action-v1",
   "x-wire-constant": "CODING_REVIEWER_ACTION_SCHEMA_VERSION",
   "x-code": "reviewer_action",
@@ -35,6 +35,17 @@
       "maxLength": 80,
       "x-code": "reviewer_action_resolution_code"
     },
+    "reviewOutcomeCategory": {
+      "type": "string",
+      "enum": [
+        "unsupported_or_excessive",
+        "missed_supported",
+        "unchanged_supported",
+        "missing_evidence",
+        "escalation"
+      ],
+      "x-code": "reviewer_action_outcome_category"
+    },
     "notes": {
       "type": "string",
       "minLength": 1,