@simulatte/doppler 0.1.3 → 0.1.5

package/src/tooling/conversion-config-materializer.js

@@ -0,0 +1,99 @@
+import path from 'node:path';
+
+import { createConverterConfig } from '../config/schema/index.js';
+import { resolveConversionPlan } from '../converter/conversion-plan.js';
+
+function toSafeString(value) {
+  if (typeof value !== 'string') return '';
+  const trimmed = value.trim();
+  return trimmed || '';
+}
+
+function normalizeQuantizationTag(value) {
+  const raw = toSafeString(value).toUpperCase();
+  if (!raw) return 'f16';
+  if (raw === 'Q4_K_M' || raw === 'Q4_K') return 'q4k';
+  return raw.toLowerCase();
+}
+
+function resolveArchitectureHint(architecture) {
+  if (!architecture) return '';
+  if (typeof architecture === 'string') return architecture;
+  return (
+    toSafeString(architecture.id)
+    || toSafeString(architecture.name)
+    || toSafeString(architecture.type)
+    || ''
+  );
+}
+
+function resolveHeadDim(architecture) {
+  const headDim = Number(architecture?.headDim ?? architecture?.head_dim);
+  return Number.isFinite(headDim) && headDim > 0 ? headDim : null;
+}
+
+function extractSourceQuantization(manifest) {
+  const explicitWeights = toSafeString(manifest?.quantizationInfo?.weights);
+  if (explicitWeights) return explicitWeights;
+  const explicitQuant = toSafeString(manifest?.quantization);
+  if (explicitQuant) return explicitQuant;
+  return 'f16';
+}
+
+function buildRefreshRawConfig(manifest) {
+  const baseConfig = (manifest?.config && typeof manifest.config === 'object')
+    ? { ...manifest.config }
+    : {};
+  const manifestLayerTypes = manifest?.inference?.layerPattern?.layerTypes;
+  if (Array.isArray(manifestLayerTypes) && manifestLayerTypes.length > 0) {
+    return {
+      ...baseConfig,
+      layer_types: [...manifestLayerTypes],
+    };
+  }
+  return baseConfig;
+}
+
+export function extractTensorEntriesFromManifest(manifest) {
+  if (!(manifest?.tensors && typeof manifest.tensors === 'object' && !Array.isArray(manifest.tensors))) {
+    return [];
+  }
+  return Object.entries(manifest.tensors).map(([name, tensor]) => ({
+    name,
+    dtype: tensor?.dtype ?? null,
+    shape: tensor?.shape ?? null,
+    role: tensor?.role ?? null,
+    layout: tensor?.layout ?? null,
+  }));
+}
+
+export function resolveMaterializedManifestFromConversionConfig(conversionConfigInput, manifest) {
+  const converterConfig = createConverterConfig(conversionConfigInput);
+  const tensorEntries = extractTensorEntriesFromManifest(manifest);
+  const architecture = manifest?.architecture && typeof manifest.architecture === 'object'
+    ? manifest.architecture
+    : null;
+  const plan = resolveConversionPlan({
+    rawConfig: buildRefreshRawConfig(manifest),
+    tensors: tensorEntries,
+    converterConfig,
+    sourceQuantization: normalizeQuantizationTag(extractSourceQuantization(manifest)),
+    modelKind: manifest?.modelType === 'diffusion' ? 'diffusion' : 'transformer',
+    architectureHint: resolveArchitectureHint(manifest?.architecture),
+    architectureConfig: architecture,
+    headDim: resolveHeadDim(architecture),
+    presetOverride: converterConfig?.presets?.model || manifest?.inference?.presetId || null,
+  });
+  return {
+    modelId: manifest?.modelId ?? converterConfig?.output?.modelBaseId ?? 'unknown',
+    modelType: manifest?.modelType ?? plan?.modelType ?? 'transformer',
+    architecture: manifest?.architecture ?? null,
+    inference: plan?.manifestInference ?? null,
+  };
+}
+
+export function inferConversionConfigModelId(configPath, conversionConfigInput) {
+  const configuredId = toSafeString(conversionConfigInput?.output?.modelBaseId);
+  if (configuredId) return configuredId;
+  return path.basename(String(configPath), path.extname(String(configPath)));
+}

package/src/tooling/lean-execution-contract-runner.d.ts

@@ -0,0 +1,43 @@
+export interface LeanExecutionContractRunResult {
+  ok: boolean;
+  toolchainRef: string | null;
+  generatedPath: string;
+  moduleName: string;
+  facts: Record<string, unknown>;
+}
+
+export declare function resolveLeanBinary(): string;
+
+export declare function runLeanCheck(options: {
+  sourcePath: string;
+  rootDir: string;
+}): {
+  ok: boolean;
+  toolchainRef: string;
+};
+
+export declare function writeExecutionContractLeanModuleForManifest(
+  manifest: Record<string, unknown>,
+  options?: {
+    rootDir?: string;
+    moduleName?: string;
+    emitPath?: string | null;
+  }
+): {
+  rootDir: string;
+  facts: Record<string, unknown>;
+  moduleName: string;
+  source: string;
+  generatedPath: string;
+  tempDir: string | null;
+};
+
+export declare function runLeanExecutionContractForManifest(
+  manifest: Record<string, unknown>,
+  options?: {
+    rootDir?: string;
+    moduleName?: string;
+    emitPath?: string | null;
+    check?: boolean;
+  }
+): LeanExecutionContractRunResult;

package/src/tooling/lean-execution-contract-runner.js

@@ -0,0 +1,158 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+import {
+  extractExecutionContractFacts,
+  renderExecutionContractLeanModule,
+  sanitizeLeanModuleName,
+} from './lean-execution-contract.js';
+
+export function resolveLeanBinary() {
+  const elanLean = path.join(os.homedir(), '.elan', 'bin', 'lean');
+  if (fs.existsSync(elanLean)) {
+    return elanLean;
+  }
+  const probe = spawnSync('bash', ['-lc', 'command -v lean'], { encoding: 'utf8' });
+  if (probe.status === 0) {
+    const resolved = probe.stdout.trim();
+    if (resolved) {
+      return resolved;
+    }
+  }
+  throw new Error('lean binary not found. Install Lean with elan first.');
+}
+
+function runLeanCommand({ leanBin, toolchainRef, buildDir, rootDir, sourcePath, outputPath }) {
+  const result = spawnSync(
+    leanBin,
+    [`+${toolchainRef}`, '-o', outputPath, sourcePath],
+    {
+      cwd: rootDir,
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        LEAN_PATH: `${buildDir}:${path.join(rootDir, 'lean')}`,
+      },
+    }
+  );
+  if (result.stdout) {
+    process.stdout.write(result.stdout);
+  }
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+  if (result.status !== 0) {
+    throw new Error(`lean exited with status ${result.status}`);
+  }
+}
+
+export function runLeanCheck({ sourcePath, rootDir }) {
+  const toolchainVersion = process.env.DOPPLER_LEAN_VERSION ?? '4.16.0';
+  const toolchainRef = toolchainVersion.startsWith('v')
+    ? `leanprover/lean4:${toolchainVersion}`
+    : `leanprover/lean4:v${toolchainVersion}`;
+  const leanBin = resolveLeanBinary();
+  const buildDir = fs.mkdtempSync(path.join(os.tmpdir(), 'doppler-lean-execution-contract-'));
+  try {
+    fs.mkdirSync(path.join(buildDir, 'Doppler'), { recursive: true });
+    runLeanCommand({
+      leanBin,
+      toolchainRef,
+      buildDir,
+      rootDir,
+      sourcePath: path.join(rootDir, 'lean', 'Doppler', 'Model.lean'),
+      outputPath: path.join(buildDir, 'Doppler', 'Model.olean'),
+    });
+    runLeanCommand({
+      leanBin,
+      toolchainRef,
+      buildDir,
+      rootDir,
+      sourcePath: path.join(rootDir, 'lean', 'Doppler', 'ExecutionContract.lean'),
+      outputPath: path.join(buildDir, 'Doppler', 'ExecutionContract.olean'),
+    });
+    const generatedOutput = path.join(buildDir, 'GeneratedExecutionContractCheck.olean');
+    const result = spawnSync(
+      leanBin,
+      [`+${toolchainRef}`, '-o', generatedOutput, sourcePath],
+      {
+        cwd: rootDir,
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          LEAN_PATH: `${buildDir}:${path.join(rootDir, 'lean')}`,
+        },
+      }
+    );
+    if (result.stdout) {
+      process.stdout.write(result.stdout);
+    }
+    if (result.stderr) {
+      process.stderr.write(result.stderr);
+    }
+    if (result.status !== 0) {
+      throw new Error(`lean exited with status ${result.status}`);
+    }
+    const overallMatch = result.stdout.match(/executionContractOverall:(pass|fail)/);
+    if (!overallMatch) {
+      throw new Error('unable to parse executionContractOverall from Lean output.');
+    }
+    return { ok: overallMatch[1] === 'pass', toolchainRef };
+  } finally {
+    fs.rmSync(buildDir, { recursive: true, force: true });
+  }
+}
+
+export function writeExecutionContractLeanModuleForManifest(manifest, options = {}) {
+  const rootDir = path.resolve(String(options.rootDir ?? process.cwd()));
+  const facts = extractExecutionContractFacts(manifest);
+  const moduleName = sanitizeLeanModuleName(options.moduleName ?? `${facts.modelId}_ExecutionContractCheck`);
+  const source = renderExecutionContractLeanModule(facts, { moduleName });
+  const tempDir = options.emitPath
+    ? null
+    : fs.mkdtempSync(path.join(rootDir, 'lean', '.generated-'));
+  const generatedPath = options.emitPath
+    ? path.resolve(rootDir, String(options.emitPath))
+    : path.join(tempDir, `${moduleName}.lean`);
+  fs.mkdirSync(path.dirname(generatedPath), { recursive: true });
+  fs.writeFileSync(generatedPath, source);
+  return {
+    rootDir,
+    facts,
+    moduleName,
+    source,
+    generatedPath,
+    tempDir,
+  };
+}
+
+export function runLeanExecutionContractForManifest(manifest, options = {}) {
+  const generated = writeExecutionContractLeanModuleForManifest(manifest, options);
+  try {
+    if (options.check === false) {
+      return {
+        ok: true,
+        toolchainRef: null,
+        generatedPath: generated.generatedPath,
+        moduleName: generated.moduleName,
+        facts: generated.facts,
+      };
+    }
+    const result = runLeanCheck({
+      sourcePath: generated.generatedPath,
+      rootDir: generated.rootDir,
+    });
+    return {
+      ...result,
+      generatedPath: generated.generatedPath,
+      moduleName: generated.moduleName,
+      facts: generated.facts,
+    };
+  } finally {
+    if (!options.emitPath && generated.tempDir) {
+      fs.rmSync(generated.tempDir, { recursive: true, force: true });
+    }
+  }
+}

package/src/tooling/lean-execution-contract.d.ts

@@ -0,0 +1,16 @@
+import type { ExecutionContractFacts } from '../config/execution-contract-check.js';
+
+export interface RenderLeanExecutionContractOptions {
+  moduleName?: string;
+}
+
+export declare function sanitizeLeanModuleName(value: unknown): string;
+
+export declare function extractExecutionContractFacts(
+  manifest: Record<string, unknown>
+): ExecutionContractFacts;
+
+export declare function renderExecutionContractLeanModule(
+  facts: LeanExecutionContractFacts,
+  options?: RenderLeanExecutionContractOptions
+): string;

package/src/tooling/lean-execution-contract.js

@@ -0,0 +1,81 @@
+import {
+  extractExecutionContractFacts,
+  sanitizeLeanModuleName,
+} from '../config/execution-contract-check.js';
+
+export {
+  extractExecutionContractFacts,
+  sanitizeLeanModuleName,
+} from '../config/execution-contract-check.js';
+
+function asLeanString(value) {
+  return JSON.stringify(String(value));
+}
+
+function renderExecutionStep(step) {
+  return [
+    '  {',
+    `    id := ${asLeanString(step.id)},`,
+    `    phase := .${step.phase},`,
+    `    opClass := .${step.opClass},`,
+    '  }',
+  ].join('\n');
+}
+
+function renderCheckName(modelId, suffix) {
+  return `${modelId}.${suffix}`;
+}
+
+export function renderExecutionContractLeanModule(facts, options = {}) {
+  const moduleName = sanitizeLeanModuleName(options.moduleName ?? facts?.modelId ?? 'GeneratedExecutionContractCheck');
+  const modelId = String(facts?.modelId ?? 'model').trim() || 'model';
+  const session = facts?.session;
+  const steps = Array.isArray(facts?.steps) ? facts.steps : [];
+  if (!session || typeof session !== 'object') {
+    throw new Error('lean execution contract: facts.session is required.');
+  }
+
+  const renderedSteps = steps.length > 0
+    ? steps.map(renderExecutionStep).join(',\n')
+    : '';
+  const stepsLiteral = steps.length > 0
+    ? `[\n${renderedSteps}\n]`
+    : '[]';
+
+  return [
+    'import Doppler.ExecutionContract',
+    '',
+    `def extractedModelId : String := ${asLeanString(modelId)}`,
+    '',
+    'def extractedSession : SessionConfig := {',
+    `  layout := .${session.layout},`,
+    `  disableCommandBatching := ${session.disableCommandBatching ? 'true' : 'false'},`,
+    `  decodeBatchSize := ${session.decodeBatchSize},`,
+    `  headDim := ${session.headDim},`,
+    `  kvLen := ${session.kvLen},`,
+    `  coldQuantMode := .${session.coldQuantMode},`,
+    '}',
+    '',
+    `def extractedSteps : List ExecutionStep := ${stepsLiteral}`,
+    '',
+    'def executionContractChecks : List (String × Bool) := [',
+    `  (${asLeanString(renderCheckName(modelId, 'steps'))}, allStepsCompatible extractedSteps extractedSession),`,
+    `  (${asLeanString(renderCheckName(modelId, 'session'))}, sessionConsistent extractedSession)`,
+    ']',
+    '',
+    'def renderCheck (entry : String × Bool) : String :=',
+    '  let status := if entry.2 then "pass" else "fail"',
+    '  s!"{entry.1}: {status}"',
+    '',
+    'def renderedChecks : List String :=',
+    '  executionContractChecks.map renderCheck',
+    '',
+    'def executionContractOverall : Bool :=',
+    '  executionContractChecks.all (fun entry => entry.2)',
+    '',
+    '#eval s!"executionContractModule:' + moduleName + '"',
+    '#eval s!"executionContractOverall:{if executionContractOverall then "pass" else "fail"}"',
+    '#eval renderedChecks',
+    '',
+  ].join('\n');
+}

package/src/tooling/node-convert.d.ts

@@ -1,4 +1,8 @@
 import type { ConverterConfigSchema } from '../config/schema/converter.schema.js';
+import type { ExecutionContractArtifact } from '../config/execution-contract-check.js';
+import type { ExecutionV0GraphContractArtifact } from '../config/execution-v0-graph-contract-check.js';
+import type { ManifestRequiredInferenceFieldsArtifact } from '../config/required-inference-fields-contract-check.js';
+import type { SavedReportInfo } from '../storage/reports.js';
 
 export interface NodeConvertProgress {
   stage: string | null;
@@ -34,6 +38,12 @@ export interface ConvertSafetensorsDirectoryResult {
   manifest: Record<string, unknown>;
   shardCount: number;
   tensorCount: number;
+  executionContractArtifact: ExecutionContractArtifact | null;
+  executionV0GraphContractArtifact: ExecutionV0GraphContractArtifact | null;
+  layerPatternContractArtifact: Record<string, unknown> | null;
+  requiredInferenceFieldsArtifact: ManifestRequiredInferenceFieldsArtifact | null;
+  report: Record<string, unknown>;
+  reportInfo: SavedReportInfo;
   presetId: string;
   modelType: string;
   outputDir: string;

package/src/tooling/node-converter.js

@@ -7,6 +7,11 @@ import { bootstrapNodeWebGPU } from './node-webgpu.js';
 import { isPlainObject } from '../utils/plain-object.js';
 import { selectRuleValue } from '../rules/rule-registry.js';
 import { log, trace } from '../debug/index.js';
+import { saveReport } from '../storage/reports.js';
+import {
+  CONVERSION_REPORT_SCHEMA_VERSION,
+  validateConversionReport,
+} from '../config/schema/conversion-report.schema.js';
 
 function asPositiveInteger(value, label) {
   if (!Number.isInteger(value) || value < 1) {
@@ -594,6 +599,44 @@ function normalizeTokenizerManifest(manifest) {
   return manifest;
 }
 
+function buildConvertReport(result, context) {
+  const manifest = result?.manifest ?? null;
+  const inference = manifest?.inference && typeof manifest.inference === 'object'
+    ? manifest.inference
+    : null;
+  return validateConversionReport({
+    schemaVersion: CONVERSION_REPORT_SCHEMA_VERSION,
+    suite: 'convert',
+    command: 'convert',
+    modelId: manifest?.modelId ?? context.modelId ?? 'unknown',
+    timestamp: manifest?.metadata?.convertedAt ?? new Date().toISOString(),
+    source: 'doppler',
+    result: {
+      presetId: context.presetId ?? null,
+      modelType: context.modelType ?? null,
+      outputDir: context.outputDir ?? null,
+      shardCount: result?.shardCount ?? null,
+      tensorCount: result?.tensorCount ?? null,
+      totalSize: result?.totalSize ?? null,
+    },
+    manifest: manifest
+      ? {
+          quantization: manifest.quantization ?? null,
+          quantizationInfo: manifest.quantizationInfo ?? null,
+          inference: {
+            presetId: inference?.presetId ?? null,
+            schema: inference?.schema ?? null,
+            defaultKernelPath: inference?.defaultKernelPath ?? null,
+          },
+        }
+      : null,
+    executionContractArtifact: result?.executionContractArtifact ?? null,
+    executionV0GraphContractArtifact: result?.executionV0GraphContractArtifact ?? null,
+    layerPatternContractArtifact: result?.layerPatternContractArtifact ?? null,
+    requiredInferenceFieldsArtifact: result?.requiredInferenceFieldsArtifact ?? null,
+  });
+}
+
 function createNodeTensorTransformer(options) {
   const pool = options?.pool;
   const execution = options?.execution;
@@ -1212,10 +1255,26 @@ export async function convertSafetensorsDirectory(options) {
   normalizeTokenizerManifest(result.manifest);
   await io.writeManifest(result.manifest);
 
+  const report = buildConvertReport(result, {
+    presetId,
+    modelType: resolvedModelType,
+    outputDir,
+    modelId: result.manifest?.modelId ?? modelId,
+  });
+  const reportInfo = await saveReport(report.modelId, report, {
+    timestamp: report.timestamp,
+  });
+
   return {
     manifest: result.manifest,
     shardCount: result.shardCount,
     tensorCount: result.tensorCount,
+    executionContractArtifact: result.executionContractArtifact ?? null,
+    executionV0GraphContractArtifact: result.executionV0GraphContractArtifact ?? null,
+    layerPatternContractArtifact: result.layerPatternContractArtifact ?? null,
+    requiredInferenceFieldsArtifact: result.requiredInferenceFieldsArtifact ?? null,
+    report,
+    reportInfo,
     presetId,
     modelType: resolvedModelType,
     outputDir,

package/src/tooling/node-webgpu.js

@@ -11,8 +11,9 @@ const DEFAULT_LOCAL_DOE_PROVIDER_PATH = resolve(
   '..',
   'fawn',
   'nursery',
-  'webgpu-core',
+  'webgpu-doe',
 );
+const DEFAULT_DOE_PROVIDER_CREATE_ARGS = 'enable-dawn-features=allow_unsafe_apis';
 
 function hasNavigatorGpu() {
   return typeof globalThis.navigator !== 'undefined' && !!globalThis.navigator?.gpu;
@@ -60,7 +61,7 @@ function resolveCandidateModuleSpecifier(candidate) {
 function resolveDefaultWebgpuModuleSpecifiers() {
   const specifiers = [];
   const localCandidates = [
-    resolve(process.cwd(), '..', 'fawn', 'nursery', 'webgpu-core'),
+    resolve(process.cwd(), '..', 'fawn', 'nursery', 'webgpu-doe'),
     DEFAULT_LOCAL_DOE_PROVIDER_PATH,
   ];
   for (const localCandidate of localCandidates) {
@@ -69,7 +70,7 @@ function resolveDefaultWebgpuModuleSpecifiers() {
       specifiers.push(pathToFileURL(resolvedPath).href);
     }
   }
-  specifiers.push('@doe/webgpu-core');
+  specifiers.push('@simulatte/webgpu-doe');
   specifiers.push('webgpu');
   return [...new Set(specifiers)];
 }
@@ -102,17 +103,17 @@ function resolveWorkspaceWebgpuProviderPath() {
   return null;
 }
 
-function isDoeWebgpuCoreSpecifier(specifier) {
-  if (specifier === '@doe/webgpu-core') {
+function isDoeWebgpuSpecifier(specifier) {
+  if (specifier === '@simulatte/webgpu-doe') {
     return true;
   }
   if (typeof specifier !== 'string') {
     return false;
   }
-  if (specifier.includes('/webgpu-core/')) {
+  if (specifier.includes('/webgpu-doe/')) {
     return true;
   }
-  return specifier.includes('webgpu-core') && specifier.startsWith('file://');
+  return specifier.includes('webgpu-doe') && specifier.startsWith('file://');
 }
 
 function resolveDoeProviderOverride(specifier) {
@@ -120,7 +121,7 @@ function resolveDoeProviderOverride(specifier) {
   if (typeof explicitProvider === 'string' && explicitProvider.trim().length > 0) {
     return null;
   }
-  if (!isDoeWebgpuCoreSpecifier(specifier)) {
+  if (!isDoeWebgpuSpecifier(specifier)) {
     return null;
   }
   return resolveWorkspaceWebgpuProviderPath();
@@ -128,12 +129,27 @@ function resolveDoeProviderOverride(specifier) {
 
 async function importWithProviderOverride(specifier) {
   const providerOverride = resolveDoeProviderOverride(specifier);
+  const shouldApplyCreateArgsDefault = isDoeWebgpuSpecifier(specifier)
+    && !(typeof process.env.FAWN_WEBGPU_CREATE_ARGS === 'string' && process.env.FAWN_WEBGPU_CREATE_ARGS.trim().length > 0);
   if (!providerOverride) {
-    return import(specifier);
+    if (!shouldApplyCreateArgsDefault) {
+      return import(specifier);
+    }
+    process.env.FAWN_WEBGPU_CREATE_ARGS = DEFAULT_DOE_PROVIDER_CREATE_ARGS;
+    try {
+      return await import(specifier);
+    } finally {
+      delete process.env.FAWN_WEBGPU_CREATE_ARGS;
+    }
   }
   const hadProvider = Object.prototype.hasOwnProperty.call(process.env, 'FAWN_WEBGPU_NODE_PROVIDER_MODULE');
   const previousProvider = process.env.FAWN_WEBGPU_NODE_PROVIDER_MODULE;
+  const hadCreateArgs = Object.prototype.hasOwnProperty.call(process.env, 'FAWN_WEBGPU_CREATE_ARGS');
+  const previousCreateArgs = process.env.FAWN_WEBGPU_CREATE_ARGS;
   process.env.FAWN_WEBGPU_NODE_PROVIDER_MODULE = providerOverride;
+  if (!hadCreateArgs) {
+    process.env.FAWN_WEBGPU_CREATE_ARGS = DEFAULT_DOE_PROVIDER_CREATE_ARGS;
+  }
   try {
     return await import(specifier);
   } finally {
@@ -142,6 +158,11 @@ async function importWithProviderOverride(specifier) {
     } else {
       delete process.env.FAWN_WEBGPU_NODE_PROVIDER_MODULE;
     }
+    if (hadCreateArgs) {
+      process.env.FAWN_WEBGPU_CREATE_ARGS = previousCreateArgs;
+    } else {
+      delete process.env.FAWN_WEBGPU_CREATE_ARGS;
+    }
   }
 }
 

package/src/version.d.ts

@@ -0,0 +1,2 @@
+export declare const DOPPLER_VERSION: string;
+export declare const DOPPLER_PROVIDER_VERSION: string;

package/src/version.js

@@ -0,0 +1,2 @@
+export const DOPPLER_VERSION = '0.1.5';
+export const DOPPLER_PROVIDER_VERSION = DOPPLER_VERSION;

package/tools/convert-safetensors-node.js

@@ -126,6 +126,51 @@ function normalizeExecutionConfig(rawExecution) {
   };
 }
 
+function printConvertContractSummary(result) {
+  const artifact = result?.executionContractArtifact;
+  if (!artifact || typeof artifact !== 'object') return;
+  const checks = Array.isArray(artifact.checks) ? artifact.checks : [];
+  const passedChecks = checks.filter((entry) => entry?.ok === true).length;
+  const layout = artifact.session?.layout ?? 'n/a';
+  console.log(
+    `[contract] status=${artifact.ok === true ? 'pass' : 'fail'} ` +
+    `checks=${checks.length > 0 ? `${passedChecks}/${checks.length}` : 'n/a'} layout=${layout}`
+  );
+  if (artifact.ok !== true && Array.isArray(artifact.errors)) {
+    for (const error of artifact.errors.slice(0, 3)) {
+      console.log(`[contract] error=${String(error)}`);
+    }
+  }
+  const graphArtifact = result?.executionV0GraphContractArtifact;
+  if (graphArtifact && typeof graphArtifact === 'object') {
+    const checks = Array.isArray(graphArtifact.checks) ? graphArtifact.checks : [];
+    const passedChecks = checks.filter((entry) => entry?.ok === true).length;
+    console.log(
+      `[graph] status=${graphArtifact.ok === true ? 'pass' : 'fail'} ` +
+      `checks=${checks.length > 0 ? `${passedChecks}/${checks.length}` : 'n/a'}`
+    );
+  }
+  for (const [label, extraArtifact] of [
+    ['layer-pattern', result?.layerPatternContractArtifact],
+    ['required-inference', result?.requiredInferenceFieldsArtifact],
+  ]) {
+    if (!extraArtifact || typeof extraArtifact !== 'object') continue;
+    const checks = Array.isArray(extraArtifact.checks) ? extraArtifact.checks : [];
+    const passedChecks = checks.filter((entry) => entry?.ok === true).length;
+    console.log(
+      `[${label}] status=${extraArtifact.ok === true ? 'pass' : 'fail'} ` +
+      `checks=${checks.length > 0 ? `${passedChecks}/${checks.length}` : 'n/a'}`
+    );
+  }
+}
+
+function printConvertReportSummary(result) {
+  const reportInfo = result?.reportInfo;
+  if (!reportInfo || typeof reportInfo !== 'object') return;
+  if (typeof reportInfo.path !== 'string' || reportInfo.path.length === 0) return;
+  console.log(`[report] ${reportInfo.path}`);
+}
+
 async function readJsonFile(filePath) {
   if (!filePath) return null;
   const raw = await fs.readFile(filePath, 'utf8');
@@ -172,6 +217,8 @@ async function main() {
   console.log(
     `[done] modelId=${result.manifest?.modelId ?? 'unknown'} preset=${result.presetId} modelType=${result.modelType} shards=${result.shardCount} tensors=${result.tensorCount}`
   );
+  printConvertContractSummary(result);
+  printConvertReportSummary(result);
 }
 
 main().catch((err) => {