@neurcode-ai/contracts 0.1.2 → 0.2.0

package/dist/verification/pipeline.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Canonical Governance Pipeline Contracts
+ * ----------------------------------------
+ * Shared, immutable types describing the staged decomposition of the verify runtime.
+ *
+ * These contracts are ADDITIVE. They do not replace, mutate, or re-encode the canonical
+ * governance envelope (`GovernanceVerificationEnvelope`), the finding identity scheme,
+ * or the replay checksum. Stage metadata flows alongside the envelope as an
+ * out-of-band observability + replay-reconstruction surface.
+ *
+ * Design invariants:
+ *   - Stage IDs are a closed set. Adding a new stage requires bumping the schema version.
+ *   - Stage metadata never carries excerpts, file content, or PII.
+ *   - Stage fingerprints are computed from stable identifiers — never wall-clock timestamps.
+ *   - A stage's `replay.outputFingerprint` is independent of `replayChecksum`; the two
+ *     are consistent but serve different audiences (stage lineage vs. envelope identity).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GOVERNANCE_STAGE_ORDER = exports.GOVERNANCE_PIPELINE_SCHEMA_VERSION = void 0;
+exports.isGovernanceStageId = isGovernanceStageId;
+exports.GOVERNANCE_PIPELINE_SCHEMA_VERSION = '2026-05-14.1';
+/**
+ * Type guard: is the given string a known stage identifier?
+ */
+function isGovernanceStageId(value) {
+    return exports.GOVERNANCE_STAGE_ORDER.includes(value);
+}
+/**
+ * Canonical execution order. Mirror of the union above — exported as a runtime
+ * value for iteration, indexing, and stage-ordering invariants.
+ */
+exports.GOVERNANCE_STAGE_ORDER = [
+    'diff-normalization',
+    'plan-sync',
+    'policy-lock',
+    'compiled-policy',
+    'policy-exceptions',
+    'structural-analysis',
+    'runtime-guard',
+    'intent-evaluation',
+    'semantic-analysis',
+    'policy-evaluation',
+    'suppression-evaluation',
+    'advisory-signals',
+    'change-contract',
+    'ai-debt-budget',
+    'governance-synthesis',
+    'provenance-generation',
+    'replay-integrity',
+    'remediation-export-preparation',
+    'evidence-generation',
+    'telemetry-harvest',
+    'ci-shaping',
+    'output-rendering',
+];
+//# sourceMappingURL=pipeline.js.map

package/dist/verification/pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["../../src/verification/pipeline.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAuJH,kDAEC;AAPY,QAAA,kCAAkC,GAAG,cAAuB,CAAC;AAE1E;;GAEG;AACH,SAAgB,mBAAmB,CAAC,KAAa;IAC/C,OAAO,8BAAsB,CAAC,QAAQ,CAAC,KAA0B,CAAC,CAAC;AACrE,CAAC;AAED;;;GAGG;AACU,QAAA,sBAAsB,GAAiC;IAClE,oBAAoB;IACpB,WAAW;IACX,aAAa;IACb,iBAAiB;IACjB,mBAAmB;IACnB,qBAAqB;IACrB,eAAe;IACf,mBAAmB;IACnB,mBAAmB;IACnB,mBAAmB;IACnB,wBAAwB;IACxB,kBAAkB;IAClB,iBAAiB;IACjB,gBAAgB;IAChB,sBAAsB;IACtB,uBAAuB;IACvB,kBAAkB;IAClB,gCAAgC;IAChC,qBAAqB;IACrB,mBAAmB;IACnB,YAAY;IACZ,kBAAkB;CACV,CAAC"}

package/dist/verification/taxonomy.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Canonical determinism taxonomy — every governance finding MUST map to exactly one.
+ * Do not blur or infer across these buckets in consumer UIs.
+ */
+export type DeterminismClassification = 'deterministic-structural' | 'deterministic-semantic' | 'heuristic-advisory' | 'llm-assisted-planning';
+export type GovernanceFindingCategory = 'structural' | 'semantic-advisory' | 'policy-engine' | 'governance-constraint' | 'intent-conditioned' | 'flow-connectivity' | 'regression' | 'scope' | 'replay' | 'ci' | 'pilot-metric' | 'workspace-federation';
+export type GovernanceSourceSystem = 'structural-rules' | 'policy-engine' | 'governance-runtime' | 'intent-engine' | 'semantic-index' | 'workspace-federation' | 'replay-runtime' | 'ci-adapter' | 'pilot-metrics';
+export declare const GOVERNANCE_FINDINGS_SCHEMA_VERSION: "2026-05-11.1";
+export declare function isDeterminismClassification(value: string): value is DeterminismClassification;
+//# sourceMappingURL=taxonomy.d.ts.map

package/dist/verification/taxonomy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taxonomy.d.ts","sourceRoot":"","sources":["../../src/verification/taxonomy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,yBAAyB,GACjC,0BAA0B,GAC1B,wBAAwB,GACxB,oBAAoB,GACpB,uBAAuB,CAAC;AAE5B,MAAM,MAAM,yBAAyB,GACjC,YAAY,GACZ,mBAAmB,GACnB,eAAe,GACf,uBAAuB,GACvB,oBAAoB,GACpB,mBAAmB,GACnB,YAAY,GACZ,OAAO,GACP,QAAQ,GACR,IAAI,GACJ,cAAc,GACd,sBAAsB,CAAC;AAE3B,MAAM,MAAM,sBAAsB,GAC9B,kBAAkB,GAClB,eAAe,GACf,oBAAoB,GACpB,eAAe,GACf,gBAAgB,GAChB,sBAAsB,GACtB,gBAAgB,GAChB,YAAY,GACZ,eAAe,CAAC;AAEpB,eAAO,MAAM,kCAAkC,EAAG,cAAuB,CAAC;AAE1E,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,yBAAyB,CAO7F"}

package/dist/verification/taxonomy.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Canonical determinism taxonomy — every governance finding MUST map to exactly one.
+ * Do not blur or infer across these buckets in consumer UIs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GOVERNANCE_FINDINGS_SCHEMA_VERSION = void 0;
+exports.isDeterminismClassification = isDeterminismClassification;
+exports.GOVERNANCE_FINDINGS_SCHEMA_VERSION = '2026-05-11.1';
+function isDeterminismClassification(value) {
+    return (value === 'deterministic-structural'
+        || value === 'deterministic-semantic'
+        || value === 'heuristic-advisory'
+        || value === 'llm-assisted-planning');
+}
+//# sourceMappingURL=taxonomy.js.map

package/dist/verification/taxonomy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"taxonomy.js","sourceRoot":"","sources":["../../src/verification/taxonomy.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAmCH,kEAOC;AATY,QAAA,kCAAkC,GAAG,cAAuB,CAAC;AAE1E,SAAgB,2BAA2B,CAAC,KAAa;IACvD,OAAO,CACL,KAAK,KAAK,0BAA0B;WACjC,KAAK,KAAK,wBAAwB;WAClC,KAAK,KAAK,oBAAoB;WAC9B,KAAK,KAAK,uBAAuB,CACrC,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@neurcode-ai/contracts",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Shared JSON contracts for Neurcode CLI, API, action, IDE, and MCP surfaces",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
@@ -12,6 +15,9 @@
   },
   "license": "MIT",
   "dependencies": {},
+  "publishConfig": {
+    "access": "public"
+  },
   "devDependencies": {
     "@types/node": "^20.10.0",
     "tsx": "^4.20.6",

package/src/index.ts

@@ -1,566 +0,0 @@
-export const CLI_JSON_CONTRACT_VERSION = '2026-04-04';
-export const RUNTIME_COMPATIBILITY_CONTRACT_ID = 'neurcode-runtime-compatibility';
-export const RUNTIME_COMPATIBILITY_CONTRACT_VERSION = '2026-04-04';
-export const RUNTIME_COMPATIBILITY_MANIFEST_VERSION = '2026-04-04.1';
-export const RUNTIME_COMPATIBILITY_MANIFEST_SCHEMA_VERSION = 1;
-
-export type RuntimeComponent = 'cli' | 'action' | 'api';
-
-export type RuntimeMinimumPeerVersions = Partial<Record<RuntimeComponent, string>>;
-
-export interface RuntimeCompatibilityTriplet {
-  id: string;
-  channel: 'current' | 'support-floor' | 'compat-canary';
-  versions: Record<RuntimeComponent, string>;
-  notes?: string;
-}
-
-export interface RuntimeCompatibilityManifest {
-  schemaVersion: number;
-  manifestVersion: string;
-  contractId: string;
-  runtimeContractVersion: string;
-  cliJsonContractVersion: string;
-  minimumPeerVersions: Record<RuntimeComponent, RuntimeMinimumPeerVersions>;
-  validatedTriplets: RuntimeCompatibilityTriplet[];
-}
-
-const RUNTIME_COMPATIBILITY_MANIFEST: RuntimeCompatibilityManifest = {
-  schemaVersion: RUNTIME_COMPATIBILITY_MANIFEST_SCHEMA_VERSION,
-  manifestVersion: RUNTIME_COMPATIBILITY_MANIFEST_VERSION,
-  contractId: RUNTIME_COMPATIBILITY_CONTRACT_ID,
-  runtimeContractVersion: RUNTIME_COMPATIBILITY_CONTRACT_VERSION,
-  cliJsonContractVersion: CLI_JSON_CONTRACT_VERSION,
-  minimumPeerVersions: {
-    cli: {
-      action: '0.2.1',
-      api: '0.2.0',
-    },
-    action: {
-      cli: '0.9.35',
-      api: '0.2.0',
-    },
-    api: {
-      cli: '0.9.35',
-      action: '0.2.1',
-    },
-  },
-  validatedTriplets: [
-    {
-      id: 'current',
-      channel: 'current',
-      versions: {
-        cli: '0.9.42',
-        action: '0.2.2',
-        api: '0.2.0',
-      },
-      notes: 'Current release train validated in monorepo CI.',
-    },
-    {
-      id: 'support-floor',
-      channel: 'support-floor',
-      versions: {
-        cli: '0.9.35',
-        action: '0.2.1',
-        api: '0.2.0',
-      },
-      notes: 'Minimum supported compatibility floor for enterprise rollout.',
-    },
-  ],
-};
-
-const RUNTIME_MINIMUM_PEER_VERSIONS: Record<RuntimeComponent, RuntimeMinimumPeerVersions> =
-  RUNTIME_COMPATIBILITY_MANIFEST.minimumPeerVersions;
-
-export function getRuntimeCompatibilityManifest(): RuntimeCompatibilityManifest {
-  return {
-    ...RUNTIME_COMPATIBILITY_MANIFEST,
-    minimumPeerVersions: {
-      cli: { ...RUNTIME_COMPATIBILITY_MANIFEST.minimumPeerVersions.cli },
-      action: { ...RUNTIME_COMPATIBILITY_MANIFEST.minimumPeerVersions.action },
-      api: { ...RUNTIME_COMPATIBILITY_MANIFEST.minimumPeerVersions.api },
-    },
-    validatedTriplets: RUNTIME_COMPATIBILITY_MANIFEST.validatedTriplets.map((triplet) => ({
-      ...triplet,
-      versions: { ...triplet.versions },
-    })),
-  };
-}
-
-export interface RuntimeCompatibilityDescriptor {
-  contractId: string;
-  runtimeContractVersion: string;
-  cliJsonContractVersion: string;
-  manifestVersion?: string;
-  component: RuntimeComponent;
-  componentVersion: string;
-  minimumPeerVersions: RuntimeMinimumPeerVersions;
-}
-
-export interface CliContractBase {
-  contractVersion?: string;
-  [key: string]: unknown;
-}
-
-export interface CliPlanJsonPayload extends CliContractBase {
-  success: boolean;
-  cached: boolean;
-  mode: string;
-  planId: string | null;
-  sessionId: string | null;
-  timestamp: string;
-  message: string;
-}
-
-export interface CliApplyJsonPayload extends CliContractBase {
-  success: boolean;
-  planId: string;
-  filesGenerated: number;
-  files: unknown[];
-  writtenFiles: unknown[];
-  message: string;
-}
-
-export interface CliVerifyJsonPayload extends CliContractBase {
-  grade: string;
-  score: number;
-  verdict: string;
-  violations: unknown[];
-  message: string;
-  scopeGuardPassed: boolean;
-  verificationSource?: 'api' | 'local_fallback' | 'policy_only' | string;
-  policyCompilation?: Record<string, unknown>;
-  changeContract?: Record<string, unknown>;
-}
-
-export interface CliPromptJsonPayload extends CliContractBase {
-  success: boolean;
-  planId: string | null;
-  intent: string | null;
-  prompt: string | null;
-  copied: boolean;
-  outputPath: string | null;
-  message: string;
-}
-
-export interface CliContractImportJsonPayload extends CliContractBase {
-  success: boolean;
-  provider: string | null;
-  planId: string | null;
-  sessionId: string | null;
-  projectId: string | null;
-  parseMode: 'json' | 'text' | null;
-  importedFiles: number;
-  warnings: unknown[];
-  changeContract?: Record<string, unknown> | null;
-  message: string;
-  timestamp: string;
-}
-
-export interface CliShipJsonPayload extends CliContractBase {
-  success: boolean;
-  status: string;
-  finalPlanId: string | null;
-  audit?: Record<string, unknown>;
-  error?: Record<string, unknown>;
-}
-
-export interface CliShipRunsJsonPayload extends CliContractBase {
-  runs: unknown[];
-}
-
-export interface CliShipResumeJsonPayload extends CliContractBase {
-  success: boolean;
-  status: string;
-  error?: Record<string, unknown>;
-}
-
-export interface CliShipAttestationVerifyJsonPayload extends CliContractBase {
-  pass: boolean;
-  message?: string;
-  digest?: Record<string, unknown>;
-}
-
-export interface CliCompatJsonPayload extends CliContractBase {
-  success: boolean;
-  timestamp: string;
-  component: 'cli';
-  componentVersion: string;
-  compatibility: RuntimeCompatibilityDescriptor;
-}
-
-function asRecord(value: unknown, label: string): Record<string, unknown> {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    throw new Error(`${label}: expected object`);
-  }
-  return value as Record<string, unknown>;
-}
-
-function asBoolean(record: Record<string, unknown>, key: string, label: string): boolean {
-  if (typeof record[key] !== 'boolean') {
-    throw new Error(`${label}: expected ${key}:boolean`);
-  }
-  return record[key] as boolean;
-}
-
-function asNumber(record: Record<string, unknown>, key: string, label: string): number {
-  if (typeof record[key] !== 'number' || Number.isNaN(record[key])) {
-    throw new Error(`${label}: expected ${key}:number`);
-  }
-  return record[key] as number;
-}
-
-function asString(record: Record<string, unknown>, key: string, label: string): string {
-  if (typeof record[key] !== 'string') {
-    throw new Error(`${label}: expected ${key}:string`);
-  }
-  return record[key] as string;
-}
-
-function asNullableString(record: Record<string, unknown>, key: string, label: string): string | null {
-  const value = record[key];
-  if (value === null || typeof value === 'string') {
-    return value as string | null;
-  }
-  throw new Error(`${label}: expected ${key}:string|null`);
-}
-
-function asArray(record: Record<string, unknown>, key: string, label: string): unknown[] {
-  if (!Array.isArray(record[key])) {
-    throw new Error(`${label}: expected ${key}:array`);
-  }
-  return record[key] as unknown[];
-}
-
-function asOptionalRecord(record: Record<string, unknown>, key: string, label: string): Record<string, unknown> | undefined {
-  const value = record[key];
-  if (value === undefined) return undefined;
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    throw new Error(`${label}: expected ${key}:object`);
-  }
-  return value as Record<string, unknown>;
-}
-
-function asOptionalString(record: Record<string, unknown>, key: string, label: string): string | undefined {
-  const value = record[key];
-  if (value === undefined) return undefined;
-  if (typeof value !== 'string') {
-    throw new Error(`${label}: expected ${key}:string`);
-  }
-  return value;
-}
-
-function asContractVersion(record: Record<string, unknown>): string | undefined {
-  const value = record.contractVersion;
-  if (value === undefined) return undefined;
-  if (typeof value !== 'string') {
-    throw new Error('contractVersion: expected string when present');
-  }
-  return value;
-}
-
-function asRuntimeComponent(record: Record<string, unknown>, key: string, label: string): RuntimeComponent {
-  const value = asString(record, key, label);
-  if (value === 'cli' || value === 'action' || value === 'api') {
-    return value;
-  }
-  throw new Error(`${label}: expected ${key}:("cli"|"action"|"api")`);
-}
-
-function parseRuntimeMinimumPeerVersions(
-  value: unknown,
-  label: string
-): RuntimeMinimumPeerVersions {
-  if (value === undefined || value === null) return {};
-  const record = asRecord(value, `${label}.minimumPeerVersions`);
-  const next: RuntimeMinimumPeerVersions = {};
-  for (const component of ['cli', 'action', 'api'] as const) {
-    const componentValue = record[component];
-    if (componentValue === undefined) continue;
-    if (typeof componentValue !== 'string' || !componentValue.trim()) {
-      throw new Error(`${label}.minimumPeerVersions: expected ${component}:string`);
-    }
-    next[component] = componentValue.trim();
-  }
-  return next;
-}
-
-function parseRuntimeCompatibilityDescriptor(
-  value: unknown,
-  label: string
-): RuntimeCompatibilityDescriptor {
-  const record = asRecord(value, `${label}.compatibility`);
-  return {
-    contractId: asString(record, 'contractId', `${label}.compatibility`),
-    runtimeContractVersion: asString(record, 'runtimeContractVersion', `${label}.compatibility`),
-    cliJsonContractVersion: asString(record, 'cliJsonContractVersion', `${label}.compatibility`),
-    manifestVersion: asOptionalString(record, 'manifestVersion', `${label}.compatibility`),
-    component: asRuntimeComponent(record, 'component', `${label}.compatibility`),
-    componentVersion: asString(record, 'componentVersion', `${label}.compatibility`),
-    minimumPeerVersions: parseRuntimeMinimumPeerVersions(record.minimumPeerVersions, `${label}.compatibility`),
-  };
-}
-
-function parseSemver(value: string): [number, number, number] | null {
-  const normalized = value.trim().replace(/^v/i, '').split('+')[0].split('-')[0];
-  const match = normalized.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match) return null;
-  const major = Number(match[1]);
-  const minor = Number(match[2]);
-  const patch = Number(match[3]);
-  if (!Number.isFinite(major) || !Number.isFinite(minor) || !Number.isFinite(patch)) {
-    return null;
-  }
-  return [major, minor, patch];
-}
-
-export function compareSemver(left: string, right: string): number | null {
-  const l = parseSemver(left);
-  const r = parseSemver(right);
-  if (!l || !r) return null;
-  for (let idx = 0; idx < 3; idx += 1) {
-    if (l[idx] > r[idx]) return 1;
-    if (l[idx] < r[idx]) return -1;
-  }
-  return 0;
-}
-
-export function isSemverAtLeast(actual: string, minimum: string): boolean | null {
-  const compare = compareSemver(actual, minimum);
-  if (compare === null) return null;
-  return compare >= 0;
-}
-
-export function getMinimumCompatiblePeerVersion(
-  component: RuntimeComponent,
-  peer: RuntimeComponent
-): string | undefined {
-  return RUNTIME_MINIMUM_PEER_VERSIONS[component][peer];
-}
-
-export function getRuntimeMinimumPeerVersionMatrix(): Record<RuntimeComponent, RuntimeMinimumPeerVersions> {
-  return {
-    cli: { ...RUNTIME_MINIMUM_PEER_VERSIONS.cli },
-    action: { ...RUNTIME_MINIMUM_PEER_VERSIONS.action },
-    api: { ...RUNTIME_MINIMUM_PEER_VERSIONS.api },
-  };
-}
-
-export function buildRuntimeCompatibilityDescriptor(
-  component: RuntimeComponent,
-  componentVersion: string
-): RuntimeCompatibilityDescriptor {
-  return {
-    contractId: RUNTIME_COMPATIBILITY_CONTRACT_ID,
-    runtimeContractVersion: RUNTIME_COMPATIBILITY_CONTRACT_VERSION,
-    cliJsonContractVersion: CLI_JSON_CONTRACT_VERSION,
-    manifestVersion: RUNTIME_COMPATIBILITY_MANIFEST_VERSION,
-    component,
-    componentVersion,
-    minimumPeerVersions: { ...RUNTIME_MINIMUM_PEER_VERSIONS[component] },
-  };
-}
-
-export interface RuntimePeerCompatibilityIssue {
-  component: RuntimeComponent;
-  peer: RuntimeComponent;
-  required: string;
-  actual: string;
-  code: 'UNPARSABLE_VERSION' | 'VERSION_BELOW_MINIMUM';
-}
-
-export function evaluateRuntimePeerCompatibility(versions: Record<RuntimeComponent, string>): RuntimePeerCompatibilityIssue[] {
-  const issues: RuntimePeerCompatibilityIssue[] = [];
-  for (const component of ['cli', 'action', 'api'] as const) {
-    for (const peer of ['cli', 'action', 'api'] as const) {
-      if (peer === component) continue;
-      const required = getMinimumCompatiblePeerVersion(component, peer);
-      if (!required) continue;
-      const actual = versions[peer];
-      const compatible = isSemverAtLeast(actual, required);
-      if (compatible === null) {
-        issues.push({
-          component,
-          peer,
-          required,
-          actual,
-          code: 'UNPARSABLE_VERSION',
-        });
-      } else if (!compatible) {
-        issues.push({
-          component,
-          peer,
-          required,
-          actual,
-          code: 'VERSION_BELOW_MINIMUM',
-        });
-      }
-    }
-  }
-  return issues;
-}
-
-export function parseCliPlanJsonPayload(value: unknown, label = 'plan'): CliPlanJsonPayload {
-  const record = asRecord(value, label);
-  return {
-    ...record,
-    contractVersion: asContractVersion(record),
-    success: asBoolean(record, 'success', label),
-    cached: asBoolean(record, 'cached', label),
-    mode: asString(record, 'mode', label),
-    planId: asNullableString(record, 'planId', label),
-    sessionId: asNullableString(record, 'sessionId', label),
-    timestamp: asString(record, 'timestamp', label),
-    message: asString(record, 'message', label),
-  };
-}
-
-export function parseCliApplyJsonPayload(value: unknown, label = 'apply'): CliApplyJsonPayload {
-  const record = asRecord(value, label);
-  return {
-    ...record,
-    contractVersion: asContractVersion(record),
-    success: asBoolean(record, 'success', label),
-    planId: asString(record, 'planId', label),
-    filesGenerated: asNumber(record, 'filesGenerated', label),
-    files: asArray(record, 'files', label),
-    writtenFiles: asArray(record, 'writtenFiles', label),
-    message: asString(record, 'message', label),
-  };
-}
-
-export function parseCliVerifyJsonPayload(value: unknown, label = 'verify'): CliVerifyJsonPayload {
-  const record = asRecord(value, label);
-  const verificationSourceRaw = record.verificationSource;
-  const verificationSource = verificationSourceRaw === undefined
-    ? undefined
-    : asString(record, 'verificationSource', label);
-  return {
-    ...record,
-    contractVersion: asContractVersion(record),
-    grade: asString(record, 'grade', label),
-    score: asNumber(record, 'score', label),
-    verdict: asString(record, 'verdict', label),
-    violations: asArray(record, 'violations', label),
-    message: asString(record, 'message', label),
-    scopeGuardPassed: asBoolean(record, 'scopeGuardPassed', label),
-    verificationSource,
-  };
-}
-
-export function parseCliPromptJsonPayload(value: unknown, label = 'prompt'): CliPromptJsonPayload {
-  const record = asRecord(value, label);
-  return {
-    ...record,
-    contractVersion: asContractVersion(record),
-    success: asBoolean(record, 'success', label),
-    planId: asNullableString(record, 'planId', label),
-    intent: asNullableString(record, 'intent', label),
-    prompt: asNullableString(record, 'prompt', label),
-    copied: asBoolean(record, 'copied', label),
-    outputPath: asNullableString(record, 'outputPath', label),
-    message: asString(record, 'message', label),
-  };
-}
-
-export function parseCliContractImportJsonPayload(
-  value: unknown,
-  label = 'contract-import'
-): CliContractImportJsonPayload {
-  const record = asRecord(value, label);
-  const parseModeRaw = record.parseMode;
-  let parseMode: 'json' | 'text' | null = null;
-  if (parseModeRaw !== undefined && parseModeRaw !== null) {
-    const parseModeValue = asString(record, 'parseMode', label);
-    if (parseModeValue !== 'json' && parseModeValue !== 'text') {
-      throw new Error(`${label}: expected parseMode:"json"|"text"|null`);
-    }
-    parseMode = parseModeValue;
-  }
-  const changeContractValue = record.changeContract;
-  let changeContract: Record<string, unknown> | null | undefined;
-  if (changeContractValue === null) {
-    changeContract = null;
-  } else if (changeContractValue !== undefined) {
-    changeContract = asOptionalRecord(record, 'changeContract', label);
-  }
-  return {
-    ...record,
-    contractVersion: asContractVersion(record),
-    success: asBoolean(record, 'success', label),
-    provider: asNullableString(record, 'provider', label),
-    planId: asNullableString(record, 'planId', label),
-    sessionId: asNullableString(record, 'sessionId', label),
-    projectId: asNullableString(record, 'projectId', label),
-    parseMode,
-    importedFiles: asNumber(record, 'importedFiles', label),
-    warnings: asArray(record, 'warnings', label),
-    changeContract,
-    message: asString(record, 'message', label),
-    timestamp: asString(record, 'timestamp', label),
-  };
-}
-
-export function parseCliShipJsonPayload(value: unknown, label = 'ship'): CliShipJsonPayload {
-  const record = asRecord(value, label);
-  return {
-    ...record,
-    contractVersion: asContractVersion(record),
-    success: asBoolean(record, 'success', label),
-    status: asString(record, 'status', label),
-    finalPlanId: asNullableString(record, 'finalPlanId', label),
-    audit: asOptionalRecord(record, 'audit', label),
-    error: asOptionalRecord(record, 'error', label),
-  };
-}
-
-export function parseCliShipRunsJsonPayload(value: unknown, label = 'ship-runs'): CliShipRunsJsonPayload {
-  const record = asRecord(value, label);
-  return {
-    ...record,
-    contractVersion: asContractVersion(record),
-    runs: asArray(record, 'runs', label),
-  };
-}
-
-export function parseCliShipResumeJsonPayload(value: unknown, label = 'ship-resume'): CliShipResumeJsonPayload {
-  const record = asRecord(value, label);
-  return {
-    ...record,
-    contractVersion: asContractVersion(record),
-    success: asBoolean(record, 'success', label),
-    status: asString(record, 'status', label),
-    error: asOptionalRecord(record, 'error', label),
-  };
-}
-
-export function parseCliShipAttestationVerifyJsonPayload(
-  value: unknown,
-  label = 'ship-attestation-verify'
-): CliShipAttestationVerifyJsonPayload {
-  const record = asRecord(value, label);
-  return {
-    ...record,
-    contractVersion: asContractVersion(record),
-    pass: asBoolean(record, 'pass', label),
-    message: record.message === undefined ? undefined : asString(record, 'message', label),
-    digest: asOptionalRecord(record, 'digest', label),
-  };
-}
-
-export function parseCliCompatJsonPayload(value: unknown, label = 'compat'): CliCompatJsonPayload {
-  const record = asRecord(value, label);
-  const component = asString(record, 'component', label);
-  if (component !== 'cli') {
-    throw new Error(`${label}: expected component:"cli"`);
-  }
-  return {
-    ...record,
-    contractVersion: asContractVersion(record),
-    success: asBoolean(record, 'success', label),
-    timestamp: asString(record, 'timestamp', label),
-    component: 'cli',
-    componentVersion: asString(record, 'componentVersion', label),
-    compatibility: parseRuntimeCompatibilityDescriptor(record.compatibility, label),
-  };
-}