@the-open-engine/zeroshot 6.28.0 → 6.29.1

package/scripts/build-cluster.js

@@ -6,8 +6,11 @@ const path = require('node:path');
 const root = path.resolve(__dirname, '..');
 const clusterBuildRoot = path.join(root, '.cluster-build');
 const hostedSessionBuildRoot = path.join(root, '.hosted-session-build');
+const hostedTargetBuildRoot = path.join(root, '.hosted-target-build');
 const clusterOutputRoot = path.join(root, 'lib/cluster');
 const hostedSessionOutputRoot = path.join(root, 'lib/hosted-session');
+const hostedTargetOutputRoot = path.join(root, 'lib/hosted-target');
+const targetOutputRoot = path.join(root, 'lib/target');
 
 function filesBelow(directory) {
   const entries = fs.readdirSync(directory, { withFileTypes: true });
@@ -17,6 +20,15 @@ function filesBelow(directory) {
   });
 }
 
+function declarationContent(source, localExtension) {
+  return fs
+    .readFileSync(source, 'utf8')
+    .replace(/(["'])(\.\.?\/[^"']+)\.ts\1/g, (_match, quote, specifier) => {
+      const extension = specifier.startsWith('../target/') ? '.js' : localExtension;
+      return `${quote}${specifier}${extension}${quote}`;
+    });
+}
+
 function copyBuild(sourceRoot, outputRoot, mode) {
   for (const source of filesBelow(sourceRoot)) {
     const relative = path.relative(sourceRoot, source);
@@ -32,15 +44,18 @@ function copyBuild(sourceRoot, outputRoot, mode) {
       fs.mkdirSync(path.dirname(target), { recursive: true });
       fs.writeFileSync(target, content);
     } else if (mode === 'cjs' && extension === '.ts' && relative.endsWith('.d.ts')) {
-      const target = path.join(outputRoot, relative);
-      fs.mkdirSync(path.dirname(target), { recursive: true });
-      fs.copyFileSync(source, target);
+      const base = path.join(outputRoot, relative.slice(0, -5));
+      fs.mkdirSync(path.dirname(base), { recursive: true });
+      fs.writeFileSync(`${base}.d.ts`, declarationContent(source, '.js'));
+      fs.writeFileSync(`${base}.d.cts`, declarationContent(source, '.cjs'));
+      fs.writeFileSync(`${base}.d.mts`, declarationContent(source, '.mjs'));
     }
   }
 }
 
 fs.rmSync(clusterOutputRoot, { recursive: true, force: true });
 fs.rmSync(hostedSessionOutputRoot, { recursive: true, force: true });
+fs.rmSync(hostedTargetOutputRoot, { recursive: true, force: true });
 copyBuild(path.join(clusterBuildRoot, 'cjs'), clusterOutputRoot, 'cjs');
 copyBuild(path.join(clusterBuildRoot, 'esm'), clusterOutputRoot, 'esm');
 copyBuild(
@@ -53,5 +68,10 @@ copyBuild(
   hostedSessionOutputRoot,
   'esm'
 );
+copyBuild(path.join(hostedTargetBuildRoot, 'cjs', 'hosted-target'), hostedTargetOutputRoot, 'cjs');
+copyBuild(path.join(hostedTargetBuildRoot, 'esm', 'hosted-target'), hostedTargetOutputRoot, 'esm');
+copyBuild(path.join(hostedTargetBuildRoot, 'cjs', 'target'), targetOutputRoot, 'cjs');
+copyBuild(path.join(hostedTargetBuildRoot, 'esm', 'target'), targetOutputRoot, 'esm');
 fs.rmSync(clusterBuildRoot, { recursive: true, force: true });
 fs.rmSync(hostedSessionBuildRoot, { recursive: true, force: true });
+fs.rmSync(hostedTargetBuildRoot, { recursive: true, force: true });

package/scripts/opcore-agent-gate.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { extractToolRequest, isRecord, overlaysForTool } = require('./opcore-agent-tool-overlays');
+
+const validationTimeoutMs = 120_000;
+const maxFeedbackChars = 4000;
+const preWriteChecks = [
+  'typescript.syntax',
+  'typescript.types',
+  'typescript.lint',
+  'typescript.function-metrics',
+  'typescript.file-length',
+  'rust.source-hygiene',
+  'rust.fmt',
+  'rust.file-length',
+  'rust.function-metrics',
+  'docs.staleness',
+  'docs.freshness',
+  'docs.length',
+  'docs.dry',
+  'docs.content-quality',
+  'docs.code-blocks',
+  'docs.rules-why',
+];
+
+function parseArgs(argv) {
+  const args = { harness: 'unknown' };
+  let index = 0;
+  while (index < argv.length) {
+    const arg = argv[index];
+    const next = argv[index + 1];
+    if (arg === '--harness') args.harness = next || 'unknown';
+    else if (arg.startsWith('--harness=')) args.harness = arg.slice('--harness='.length);
+    else if (arg === '--repo') args.repo = next;
+    else if (arg.startsWith('--repo=')) args.repo = arg.slice('--repo='.length);
+    index += arg === '--harness' || arg === '--repo' ? 2 : 1;
+  }
+  return args;
+}
+
+function resolveRepoRoot(explicitRepo, cwd) {
+  if (explicitRepo) return path.resolve(explicitRepo);
+  const start = path.resolve(cwd || process.cwd());
+  const result = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd: start,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+  });
+  return result.status === 0 && result.stdout.trim() ? path.resolve(result.stdout.trim()) : start;
+}
+
+function runValidation(request) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'zeroshot-opcore-prewrite-'));
+  const requestPath = path.join(tempDir, 'validation-request.json');
+  try {
+    fs.writeFileSync(requestPath, `${JSON.stringify(request)}\n`);
+    const opcoreEntrypoint = require.resolve('opcore');
+    const result = spawnSync(
+      process.execPath,
+      [
+        opcoreEntrypoint,
+        'validate',
+        'pre-write',
+        '--request-file',
+        requestPath,
+        '--timeout-ms',
+        String(validationTimeoutMs),
+        '--json',
+      ],
+      {
+        cwd: request.repo.repoRoot,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+      }
+    );
+    if (result.error) throw result.error;
+    const payload = JSON.parse((result.stdout || '').trim());
+    if (!payload.receipt) {
+      throw new Error(result.stderr || result.stdout || `Opcore exited ${result.status}`);
+    }
+    return payload.receipt;
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+function feedback(toolName, receipt) {
+  const summary = receipt.failureSummary?.message || 'Pre-write validation failed';
+  const checks = receipt.checks?.length ? ` checks=${receipt.checks.join(',')}` : '';
+  const paths = receipt.overlays?.paths?.length ? ` paths=${receipt.overlays.paths.join(',')}` : '';
+  const message = `Opcore write gate blocked ${toolName}: ${summary} status=${receipt.validationStatus}${checks}${paths}\n`;
+  return message.length <= maxFeedbackChars
+    ? message
+    : `${message.slice(0, maxFeedbackChars - 15).trimEnd()} [truncated]\n`;
+}
+
+async function readStdin() {
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk.toString();
+  return input;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  let mapped;
+  try {
+    const raw = await readStdin();
+    if (!raw.trim()) return 0;
+    const envelope = JSON.parse(raw);
+    if (!isRecord(envelope)) throw new Error('hook payload must be a JSON object');
+    const tool = extractToolRequest(envelope);
+    if (!tool) return 0;
+    const repoRoot = resolveRepoRoot(args.repo, tool.cwd);
+    const overlays = await overlaysForTool(repoRoot, tool);
+    if (overlays.length === 0) return 0;
+    mapped = {
+      toolName: tool.toolName,
+      request: {
+        requestId: `zeroshot-opcore-agent-gate-${Date.now()}`,
+        repo: { repoRoot },
+        scope: { kind: 'files', files: overlays.map((overlay) => overlay.path) },
+        graph: { mode: 'optional', provider: 'opcore-graph' },
+        overlays,
+        checks: preWriteChecks,
+        reportMode: 'introduced',
+      },
+    };
+  } catch (error) {
+    process.stderr.write(
+      `Opcore write gate skipped: ${error instanceof Error ? error.message : String(error)}\n`
+    );
+    return 0;
+  }
+
+  try {
+    const receipt = runValidation(mapped.request);
+    if (receipt.ok) return 0;
+    process.stderr.write(feedback(mapped.toolName, receipt));
+    return 2;
+  } catch (error) {
+    process.stderr.write(
+      `Opcore write gate blocked ${mapped.toolName}: validation command failed: ${error instanceof Error ? error.message : String(error)}\n`
+    );
+    return 2;
+  }
+}
+
+main()
+  .then((exitCode) => {
+    process.exitCode = exitCode;
+  })
+  .catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 2;
+  });

package/scripts/opcore-agent-tool-overlays.js

@@ -0,0 +1,154 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { pathToFileURL } = require('node:url');
+
+const writeTools = new Set(['write']);
+const editTools = new Set(['edit']);
+const multiEditTools = new Set(['multiedit', 'multi_edit']);
+const applyPatchTools = new Set(['applypatch', 'apply_patch']);
+let editApiPromise;
+
+function firstString(...values) {
+  return values.find((value) => typeof value === 'string');
+}
+
+function isRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function firstRecord(...values) {
+  return values.find(isRecord);
+}
+
+function requiredString(value, name) {
+  if (value === undefined) throw new Error(`${name} must be a string`);
+  return value;
+}
+
+function resolveTargetPath(repoRoot, filePath) {
+  const absolute = path.isAbsolute(filePath)
+    ? path.resolve(filePath)
+    : path.resolve(repoRoot, filePath);
+  const relative = path.relative(repoRoot, absolute);
+  if (
+    !relative ||
+    relative.startsWith('..') ||
+    path.isAbsolute(relative) ||
+    relative.split(path.sep).includes('..')
+  ) {
+    throw new Error(`pre-write target must stay inside the repo: ${filePath}`);
+  }
+  return relative.replaceAll('\\', '/');
+}
+
+function extractToolRequest(envelope) {
+  const nested = firstRecord(envelope.tool, envelope.toolCall, envelope.tool_call);
+  const toolName = firstString(
+    envelope.tool_name,
+    envelope.toolName,
+    envelope.name,
+    nested?.name,
+    nested?.tool_name,
+    nested?.toolName
+  );
+  if (!toolName) return null;
+  return {
+    toolName,
+    normalizedToolName: toolName.toLowerCase().replaceAll('-', '_'),
+    input:
+      firstRecord(
+        envelope.tool_input,
+        envelope.toolInput,
+        envelope.input,
+        nested?.input,
+        nested?.tool_input,
+        nested?.toolInput
+      ) || envelope,
+    cwd: firstString(envelope.cwd),
+  };
+}
+
+function writeOverlay(repoRoot, input) {
+  return {
+    action: 'write',
+    path: resolveTargetPath(
+      repoRoot,
+      requiredString(firstString(input.file_path, input.filePath, input.path), 'file_path')
+    ),
+    content: requiredString(firstString(input.content, input.text), 'content'),
+  };
+}
+
+function editOverlay(repoRoot, input) {
+  const relative = resolveTargetPath(
+    repoRoot,
+    requiredString(firstString(input.file_path, input.filePath, input.path), 'file_path')
+  );
+  const oldString = requiredString(firstString(input.old_string, input.oldString), 'old_string');
+  const newString = requiredString(firstString(input.new_string, input.newString), 'new_string');
+  const existing = fs.readFileSync(path.resolve(repoRoot, relative), 'utf8');
+  if (!existing.includes(oldString)) throw new Error(`old_string was not found in ${relative}`);
+  return { action: 'write', path: relative, content: existing.replace(oldString, newString) };
+}
+
+function multiEditOverlay(repoRoot, input) {
+  const relative = resolveTargetPath(
+    repoRoot,
+    requiredString(firstString(input.file_path, input.filePath, input.path), 'file_path')
+  );
+  let content = fs.readFileSync(path.resolve(repoRoot, relative), 'utf8');
+  for (const edit of Array.isArray(input.edits) ? input.edits : []) {
+    if (!isRecord(edit)) throw new Error(`MultiEdit edit for ${relative} must be an object`);
+    const oldString = requiredString(firstString(edit.old_string, edit.oldString), 'old_string');
+    const newString = requiredString(firstString(edit.new_string, edit.newString), 'new_string');
+    if (!content.includes(oldString)) throw new Error(`old_string was not found in ${relative}`);
+    content = content.replace(oldString, newString);
+  }
+  return { action: 'write', path: relative, content };
+}
+
+function loadEditApi() {
+  if (!editApiPromise) {
+    const opcoreEntrypoint = require.resolve('opcore');
+    const editModule = path.resolve(
+      path.dirname(opcoreEntrypoint),
+      '../node_modules/@the-open-engine/opcore-edit/dist/index.js'
+    );
+    editApiPromise = import(pathToFileURL(editModule).href);
+  }
+  return editApiPromise;
+}
+
+async function patchOverlays(repoRoot, input) {
+  const patch = firstString(input.command, input.patch);
+  if (!patch) return [];
+  const { createNodeEditWorkspace, createPatchEditPlan, isCodexApplyPatch } = await loadEditApi();
+  if (!isCodexApplyPatch(patch)) return [];
+  const workspace = await createNodeEditWorkspace({ repoRoot });
+  const planned = await createPatchEditPlan(workspace, {
+    repo: { repoRoot },
+    validation: { required: false },
+    patch,
+  });
+  if (!planned.ok) throw new Error(planned.refusal.message);
+  return Object.entries(planned.afterState).flatMap(([filePath, content]) => {
+    if (content === undefined) return [];
+    return [
+      {
+        action: content === null ? 'delete' : 'write',
+        path: filePath,
+        ...(content === null ? {} : { content }),
+      },
+    ];
+  });
+}
+
+function overlaysForTool(repoRoot, tool) {
+  if (writeTools.has(tool.normalizedToolName)) return [writeOverlay(repoRoot, tool.input)];
+  if (editTools.has(tool.normalizedToolName)) return [editOverlay(repoRoot, tool.input)];
+  if (multiEditTools.has(tool.normalizedToolName)) return [multiEditOverlay(repoRoot, tool.input)];
+  if (applyPatchTools.has(tool.normalizedToolName)) return patchOverlays(repoRoot, tool.input);
+  return [];
+}
+
+module.exports = { extractToolRequest, isRecord, overlaysForTool };

package/scripts/opcore-introduced-check.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+
+const { isUtf8 } = require('node:buffer');
+const { spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const TYPESCRIPT_AUTHORITIES = [
+  'tsconfig.agent-cli-provider.json',
+  'tsconfig.cluster.json',
+  'tsconfig.hosted-session.json',
+  'tsconfig.hosted-target.json',
+  'tsconfig.target.json',
+];
+
+const DEFAULT_CHECKS = [
+  'typescript.syntax',
+  'typescript.types',
+  'typescript.import-graph',
+  'typescript.dead-code',
+  'typescript.function-metrics',
+  'typescript.relevant-tests',
+  'typescript.file-length',
+  'rust.source-hygiene',
+  'rust.fmt',
+  'rust.cargo-check',
+  'rust.clippy',
+  'rust.rustdoc',
+  'rust.import-graph',
+  'rust.dead-code',
+  'rust.graph-signals',
+  'rust.file-length',
+  'rust.function-metrics',
+  'clone.duplication',
+].join(',');
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    encoding: options.encoding ?? 'buffer',
+    env: options.env ?? process.env,
+    maxBuffer: 64 * 1024 * 1024,
+    timeout: options.timeout ?? 300_000,
+  });
+  if (result.error) throw result.error;
+  return result;
+}
+
+function git(repo, args, options = {}) {
+  const result = run('git', args, {
+    cwd: repo,
+    encoding: options.encoding ?? 'buffer',
+    env: options.env,
+  });
+  if (result.status !== 0) {
+    const stderr = Buffer.isBuffer(result.stderr) ? result.stderr.toString('utf8') : result.stderr;
+    throw new Error(`git ${args[0]} failed: ${stderr.trim() || `exit ${result.status}`}`);
+  }
+  return result.stdout;
+}
+
+function withoutGitLocalEnv(repo) {
+  const names = git(repo, ['rev-parse', '--local-env-vars'], { encoding: 'utf8' })
+    .split('\n')
+    .filter(Boolean);
+  const env = { ...process.env };
+  for (const name of names) delete env[name];
+  return env;
+}
+
+function valueOption(argv, index) {
+  const arg = argv[index];
+  for (const key of ['base', 'checks']) {
+    const flag = `--${key}`;
+    if (arg === flag) return { key, value: argv[index + 1], consumed: 1 };
+    if (arg.startsWith(`${flag}=`)) return { key, value: arg.slice(flag.length + 1), consumed: 0 };
+  }
+  return null;
+}
+
+function parseArgs(argv) {
+  const options = { base: 'HEAD', checks: DEFAULT_CHECKS, staged: false };
+  let index = 0;
+  while (index < argv.length) {
+    const arg = argv[index];
+    if (arg === '--staged') {
+      options.staged = true;
+      index += 1;
+      continue;
+    }
+    if (arg === '--json') {
+      index += 1;
+      continue;
+    }
+    const option = valueOption(argv, index);
+    if (!option) throw new Error(`Unsupported Opcore introduced-check argument: ${arg}`);
+    options[option.key] = option.value;
+    index += option.consumed + 1;
+  }
+  if (!options.base) throw new Error('--base requires a Git revision');
+  if (options.staged && options.base !== 'HEAD') {
+    throw new Error('--staged cannot be combined with a non-HEAD --base');
+  }
+  return options;
+}
+
+function nulTokens(buffer) {
+  return buffer
+    .toString('utf8')
+    .split('\0')
+    .filter((token) => token.length > 0);
+}
+
+function parseChanges(repo, options) {
+  const args = options.staged
+    ? ['diff', '--cached', '--name-status', '-z', '--find-renames', 'HEAD', '--']
+    : ['diff', '--name-status', '-z', '--find-renames', options.base, '--'];
+  const tokens = nulTokens(git(repo, args));
+  const changes = [];
+
+  for (let index = 0; index < tokens.length; ) {
+    const status = tokens[index++];
+    const kind = status[0];
+    if (kind === 'R' || kind === 'C') {
+      changes.push({ kind, oldPath: tokens[index++], path: tokens[index++] });
+    } else if ('AMDT'.includes(kind)) {
+      changes.push({ kind, path: tokens[index++] });
+    } else {
+      throw new Error(`Unsupported Git change status: ${status}`);
+    }
+  }
+
+  if (!options.staged) {
+    for (const untrackedPath of nulTokens(
+      git(repo, ['ls-files', '--others', '--exclude-standard', '-z', '--'])
+    )) {
+      changes.push({ kind: 'A', path: untrackedPath });
+    }
+  }
+
+  const byPath = new Map();
+  for (const change of changes) byPath.set(change.path, change);
+  return [...byPath.values()];
+}
+
+function safePath(root, relativePath) {
+  const absolute = path.resolve(root, relativePath);
+  const relative = path.relative(root, absolute);
+  if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+    throw new Error(`Changed path escapes repository root: ${relativePath}`);
+  }
+  return absolute;
+}
+
+function readAfter(repo, change, staged) {
+  let content;
+  if (staged) {
+    content = git(repo, ['show', `:${change.path}`]);
+  } else {
+    const absolute = safePath(repo, change.path);
+    const stat = fs.lstatSync(absolute);
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+      throw new Error(`Opcore introduced gate supports regular changed files only: ${change.path}`);
+    }
+    content = fs.readFileSync(absolute);
+  }
+  return isUtf8(content) && !content.includes(0) ? content.toString('utf8') : null;
+}
+
+function copyPolicy(repo, baseline) {
+  const source = path.join(repo, '.opcore', 'config');
+  if (!fs.existsSync(source)) return;
+  const target = path.join(baseline, '.opcore', 'config');
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.copyFileSync(source, target);
+}
+
+function linkDependencies(repo, baseline) {
+  const source = path.join(repo, 'node_modules');
+  const target = path.join(baseline, 'node_modules');
+  if (fs.existsSync(source) && !fs.existsSync(target)) fs.symlinkSync(source, target, 'dir');
+}
+
+function normalizeBaselineRename(baseline, change) {
+  if (change.kind !== 'R') return;
+  const source = safePath(baseline, change.oldPath);
+  const target = safePath(baseline, change.path);
+  if (!fs.existsSync(source)) return;
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  fs.renameSync(source, target);
+}
+
+function createRequest(repo, baseline, changes, options) {
+  const overlays = [];
+  const files = [];
+  for (const change of changes) {
+    normalizeBaselineRename(baseline, change);
+    if (change.kind === 'D') {
+      continue;
+    }
+    const content = readAfter(repo, change, options.staged);
+    if (content === null) continue;
+    overlays.push({ action: 'write', path: change.path, content });
+    files.push(change.path);
+  }
+  for (const authority of TYPESCRIPT_AUTHORITIES) {
+    if (fs.existsSync(safePath(baseline, authority))) files.push(authority);
+  }
+
+  return {
+    requestId: `zeroshot-opcore-introduced-${process.pid}`,
+    repo: { repoRoot: baseline },
+    scope: { kind: 'files', files: [...new Set(files)] },
+    graph: { mode: 'optional', provider: 'opcore-graph' },
+    overlays,
+    ...(options.checks ? { checks: options.checks.split(',').filter(Boolean) } : {}),
+    reportMode: 'introduced',
+  };
+}
+
+function runOpcoreDirect(repo, args, env = process.env) {
+  const entrypoint = require.resolve('opcore');
+  return run(process.execPath, [entrypoint, ...args], {
+    cwd: repo,
+    encoding: 'utf8',
+    env: {
+      ...env,
+      PATH: `${path.join(repo, 'node_modules', '.bin')}${path.delimiter}${env.PATH || ''}`,
+    },
+  });
+}
+
+function emit(result) {
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  process.exitCode = result.status ?? 1;
+}
+
+function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const repo = git(process.cwd(), ['rev-parse', '--show-toplevel'], {
+    encoding: 'utf8',
+  }).trim();
+  git(repo, ['rev-parse', '--verify', `${options.base}^{commit}`]);
+  const changes = parseChanges(repo, options);
+  if (changes.length === 0) {
+    emit(runOpcoreDirect(repo, ['check', '--changed', '--json']));
+    return;
+  }
+
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'zeroshot-opcore-baseline-'));
+  const baseline = path.join(tempRoot, 'repo');
+  try {
+    const baselineEnv = withoutGitLocalEnv(repo);
+    git(repo, ['clone', '--quiet', '--shared', '--no-checkout', repo, baseline], {
+      env: baselineEnv,
+    });
+    git(baseline, ['checkout', '--quiet', '--detach', options.base], {
+      env: baselineEnv,
+    });
+    linkDependencies(repo, baseline);
+    copyPolicy(repo, baseline);
+    const request = createRequest(repo, baseline, changes, options);
+    if (request.overlays.length === 0) {
+      emit(runOpcoreDirect(repo, ['check', '--changed', '--json']));
+      return;
+    }
+    const requestPath = path.join(tempRoot, 'validation-request.json');
+    fs.writeFileSync(requestPath, `${JSON.stringify(request)}\n`);
+    emit(
+      runOpcoreDirect(
+        baseline,
+        ['validate', 'hypothetical', '--request-file', requestPath, '--json'],
+        baselineEnv
+      )
+    );
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}