archal 0.9.19 → 0.9.20

package/agents/replay-capsule-harness/observability-install-offline-e2e.mts

@@ -0,0 +1,1517 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { delimiter, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  buildObservabilitySetupPatch,
+  type ObservabilitySetupFile,
+} from '../../../packages/contracts/src/observability-setup-patch.ts';
+import { openObservabilitySetupPr } from '../../../cli/src/commands/observability.ts';
+import {
+  TRACE_REPLAY_CAPSULE_ATTRIBUTE,
+  TRACE_REPLAY_STATUS_ATTRIBUTE,
+  mergeTraceReplayCapsules,
+  normalizeTraceReplayCapsule,
+  traceReplayCapsuleToOtelAttributes,
+} from '../../../packages/contracts/src/replay-capsule.ts';
+
+const SCHEMA = 'archal.e2e.observability-install-replay-capsule.v1';
+const DEFAULT_ENDPOINT = 'https://www.archal.ai/api/traces/otlp';
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const REPO_ROOT = resolve(MODULE_DIR, '..', '..', '..');
+const TSX_LOADER_PATH = require.resolve('tsx');
+const SETUP_PR_ARCHAL_BASE_URL = 'https://api.test.archal.ai';
+const SETUP_PR_TOKEN_PATH = '/api/workspaces/current/integrations/github/installation-token';
+const SETUP_PR_REPOSITORY = 'acme/trellis-agent';
+const TRELLIS_ENTRYPOINT = 'services/trellis-worker.ts';
+const TRELLIS_TOOL_MODULE = 'lib/trellis-tools.ts';
+const STATE_CAPTURE_NODE_MODULES = join(REPO_ROOT, 'packages', 'state-capture', 'node_modules');
+const DEFAULT_FIXTURE = resolve(
+  REPO_ROOT,
+  'e2e/fixtures/autoloop-autonomous-proof/live-readiness-trace.json',
+);
+
+interface CliArgs {
+  outDir: string;
+  fixturePath: string;
+  omitCaptureOperations: string[];
+  stripOperationOutcomes: string[];
+  redactOperationRequests: string[];
+  replaceStateBeforeIds: Array<{ from: string; to: string }>;
+}
+
+interface TrellisFixture {
+  ai_trace: {
+    trace_id: string;
+    agent_id?: string;
+    model_id?: string;
+    input_data?: Record<string, unknown>;
+    output_data?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    classification?: Record<string, unknown>;
+    context?: {
+      stateBefore?: Record<string, unknown>;
+      stateAfter?: Record<string, unknown>;
+      stateDiff?: Record<string, unknown>;
+      agentResponseText?: string;
+    };
+  };
+  ai_spans: Array<Record<string, unknown>>;
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const result: CliArgs = {
+    outDir: resolve(REPO_ROOT, '.archal/observability-install-offline-e2e'),
+    fixturePath: DEFAULT_FIXTURE,
+    omitCaptureOperations: [],
+    stripOperationOutcomes: [],
+    redactOperationRequests: [],
+    replaceStateBeforeIds: [],
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--out') {
+      const value = argv[index + 1];
+      if (!value) throw new Error('--out requires a directory');
+      result.outDir = resolve(value);
+      index += 1;
+    } else if (arg.startsWith('--out=')) {
+      result.outDir = resolve(arg.slice('--out='.length));
+    } else if (arg === '--fixture') {
+      const value = argv[index + 1];
+      if (!value) throw new Error('--fixture requires a JSON file');
+      result.fixturePath = resolve(value);
+      index += 1;
+    } else if (arg.startsWith('--fixture=')) {
+      result.fixturePath = resolve(arg.slice('--fixture='.length));
+    } else if (arg === '--omit-capture-operation') {
+      const value = argv[index + 1];
+      if (!value) throw new Error('--omit-capture-operation requires an operation name');
+      result.omitCaptureOperations.push(...splitCsv(value));
+      index += 1;
+    } else if (arg.startsWith('--omit-capture-operation=')) {
+      result.omitCaptureOperations.push(...splitCsv(arg.slice('--omit-capture-operation='.length)));
+    } else if (arg === '--strip-operation-outcome') {
+      const value = argv[index + 1];
+      if (!value) throw new Error('--strip-operation-outcome requires an operation name');
+      result.stripOperationOutcomes.push(...splitCsv(value));
+      index += 1;
+    } else if (arg.startsWith('--strip-operation-outcome=')) {
+      result.stripOperationOutcomes.push(
+        ...splitCsv(arg.slice('--strip-operation-outcome='.length)),
+      );
+    } else if (arg === '--redact-operation-request') {
+      const value = argv[index + 1];
+      if (!value) throw new Error('--redact-operation-request requires an operation name');
+      result.redactOperationRequests.push(...splitCsv(value));
+      index += 1;
+    } else if (arg.startsWith('--redact-operation-request=')) {
+      result.redactOperationRequests.push(
+        ...splitCsv(arg.slice('--redact-operation-request='.length)),
+      );
+    } else if (arg === '--replace-state-before-id') {
+      const value = argv[index + 1];
+      if (!value) throw new Error('--replace-state-before-id requires from=to');
+      result.replaceStateBeforeIds.push(parseReplacement(value));
+      index += 1;
+    } else if (arg.startsWith('--replace-state-before-id=')) {
+      result.replaceStateBeforeIds.push(
+        parseReplacement(arg.slice('--replace-state-before-id='.length)),
+      );
+    } else {
+      throw new Error(`Unknown observability install e2e argument: ${arg}`);
+    }
+  }
+  return result;
+}
+
+function splitCsv(value: string): string[] {
+  return value
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+}
+
+function parseReplacement(value: string): { from: string; to: string } {
+  const separator = value.indexOf('=');
+  if (separator <= 0 || separator === value.length - 1) {
+    throw new Error(`Invalid --replace-state-before-id value ${value}; expected from=to`);
+  }
+  return {
+    from: value.slice(0, separator),
+    to: value.slice(separator + 1),
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function requiredRecord(value: unknown, label: string): Record<string, unknown> {
+  if (!isRecord(value)) throw new Error(`${label} must be an object`);
+  return value;
+}
+
+function asString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+
+function stableHex(seed: string, bytes: number): string {
+  return createHash('sha256')
+    .update(seed)
+    .digest('hex')
+    .slice(0, bytes * 2);
+}
+
+function isoToNanos(value: unknown): string {
+  const text = asString(value);
+  const time = text ? Date.parse(text) : NaN;
+  const millis = Number.isFinite(time) ? time : Date.parse('2026-06-01T18:20:00.000Z');
+  return String(millis * 1_000_000);
+}
+
+function attr(key: string, value: unknown): { key: string; value: Record<string, unknown> } {
+  if (typeof value === 'boolean') return { key, value: { boolValue: value } };
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return Number.isInteger(value)
+      ? { key, value: { intValue: String(value) } }
+      : { key, value: { doubleValue: String(value) } };
+  }
+  if (typeof value === 'string') return { key, value: { stringValue: value } };
+  return { key, value: { stringValue: JSON.stringify(value) } };
+}
+
+function writeJson(path: string, value: unknown): Promise<void> {
+  return writeFile(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function childEnvWithGeneratedSetupDeps(): NodeJS.ProcessEnv {
+  const nodePath = process.env.NODE_PATH
+    ? `${STATE_CAPTURE_NODE_MODULES}${delimiter}${process.env.NODE_PATH}`
+    : STATE_CAPTURE_NODE_MODULES;
+  return { ...process.env, NODE_PATH: nodePath };
+}
+
+function parseJsonStdout(stdout: string): unknown {
+  const trimmed = stdout.trim();
+  if (!trimmed) throw new Error('stdout did not contain JSON');
+  try {
+    return JSON.parse(trimmed) as unknown;
+  } catch (initialError) {
+    for (let index = 0; index < trimmed.length; index += 1) {
+      if (trimmed[index] !== '{' && trimmed[index] !== '[') continue;
+      try {
+        return JSON.parse(trimmed.slice(index)) as unknown;
+      } catch {
+        // Keep scanning; pnpm can print warnings before the JSON payload.
+      }
+    }
+    throw initialError;
+  }
+}
+
+function runReplayabilityAudit(tracePath: string): Record<string, unknown> {
+  const result = spawnSync(
+    'pnpm',
+    [
+      '--silent',
+      '--filter',
+      '@archal/cli',
+      'exec',
+      'node',
+      '--import',
+      TSX_LOADER_PATH,
+      'src/index.ts',
+      'replayability',
+      'audit',
+      tracePath,
+      '--json',
+    ],
+    {
+      cwd: REPO_ROOT,
+      encoding: 'utf8',
+      env: process.env,
+    },
+  );
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      [
+        `replayability audit exited ${result.status}`,
+        result.stdout ? `stdout:\n${result.stdout}` : undefined,
+        result.stderr ? `stderr:\n${result.stderr}` : undefined,
+      ]
+        .filter(Boolean)
+        .join('\n'),
+    );
+  }
+  const parsed = parseJsonStdout(result.stdout);
+  const payload = requiredRecord(parsed, 'replayability audit stdout');
+  if (payload['ok'] !== true) {
+    throw new Error(`Replayability audit failed: ${JSON.stringify(payload)}`);
+  }
+  return requiredRecord(payload['audit'], 'replayability audit');
+}
+
+async function readFixture(path: string): Promise<TrellisFixture> {
+  const parsed = JSON.parse(await readFile(path, 'utf8')) as unknown;
+  const fixture = requiredRecord(parsed, 'Trellis fixture') as unknown as TrellisFixture;
+  if (!isRecord(fixture.ai_trace)) throw new Error('Trellis fixture must include ai_trace');
+  if (!Array.isArray(fixture.ai_spans)) throw new Error('Trellis fixture must include ai_spans');
+  return fixture;
+}
+
+async function writeSetupArtifacts(outDir: string): Promise<{
+  dir: string;
+  files: Array<Pick<ObservabilitySetupFile, 'path' | 'mode'>>;
+  blob: string;
+  setupPr: {
+    status: 'created' | 'already_open';
+    url: string;
+    number: number;
+    repository: string;
+    patchedFiles: string[];
+    patchedEntrypoint: string;
+    patchedEntrypointImported: boolean;
+    patchedToolModule: string;
+    patchedToolModuleExported: boolean;
+    packageJsonMerged: boolean;
+  };
+}> {
+  const generatedPatch = buildObservabilitySetupPatch({
+    framework: 'LangChain',
+    language: 'typescript',
+    otlpEndpoint: DEFAULT_ENDPOINT,
+    packageManager: 'pnpm',
+    startupPaths: [TRELLIS_ENTRYPOINT],
+    toolBoundaryPaths: [TRELLIS_TOOL_MODULE],
+  });
+  const setupDir = resolve(outDir, 'generated-observability-setup');
+  await mkdir(setupDir, { recursive: true });
+  const setupPrHarness = createSetupPrHarness();
+  const setupPr = await openObservabilitySetupPr({
+    repository: SETUP_PR_REPOSITORY,
+    framework: 'LangChain',
+    language: 'typescript',
+    packageManager: 'pnpm',
+    startupPaths: [TRELLIS_ENTRYPOINT],
+    toolBoundaryPaths: [TRELLIS_TOOL_MODULE],
+    archalToken: 'archal_user_token',
+    archalBaseUrl: SETUP_PR_ARCHAL_BASE_URL,
+    fetchImpl: setupPrHarness.fetchImpl,
+    buildPatch: buildObservabilitySetupPatch,
+  });
+  if (setupPr.status !== 'created') {
+    throw new Error(`observability setup PR was not created: ${JSON.stringify(setupPr)}`);
+  }
+  const materialized = setupPrHarness.materializeCommit();
+  for (const [path, contents] of Object.entries(materialized.files)) {
+    const target = resolve(setupDir, path);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, contents);
+  }
+  const blob = [
+    generatedPatch.prTitle,
+    generatedPatch.prBody,
+    ...Object.values(materialized.files),
+  ].join('\n');
+  if (
+    /archal_ws_[A-Za-z0-9_-]{8,}|gh[pousr]_[A-Za-z0-9_]{8,}|github_pat_[A-Za-z0-9_]{8,}|AKIA[0-9A-Z]{16}/.test(
+      blob,
+    )
+  ) {
+    throw new Error('Generated observability setup artifacts contain a secret-looking literal');
+  }
+  const helper = materialized.files['archal-replay-capsule.ts'];
+  if (!helper?.includes(TRACE_REPLAY_CAPSULE_ATTRIBUTE)) {
+    throw new Error('Generated replay helper is missing the replay capsule attribute');
+  }
+  const patchedEntrypoint = materialized.files[TRELLIS_ENTRYPOINT];
+  if (!patchedEntrypoint?.includes("import '../archal-otel.js';")) {
+    throw new Error('Setup PR did not patch the synthetic agent entrypoint');
+  }
+  const patchedToolModule = materialized.files[TRELLIS_TOOL_MODULE];
+  if (
+    !patchedToolModule?.includes(
+      "export { archalGenericStateAdapter, captureArchalToolBoundary, wrapArchalToolBoundary } from '../archal-replay-capsule.js';",
+    )
+  ) {
+    throw new Error('Setup PR did not patch the synthetic agent tool module');
+  }
+  const packageJson = materialized.files['package.json'];
+  if (!packageJson?.includes('"@opentelemetry/api": "^1.9.1"')) {
+    throw new Error('Setup PR did not merge replay-capsule dependencies into package.json');
+  }
+  return {
+    dir: setupDir,
+    files: materialized.patchedFiles.map((path) => {
+      const generatedFile = generatedPatch.files.find((file) => file.path === path);
+      return {
+        path,
+        mode: generatedFile?.mode ?? 'overwrite-if-absent',
+      };
+    }),
+    blob,
+    setupPr: {
+      status: setupPr.status,
+      url: setupPr.url,
+      number: setupPr.number,
+      repository: SETUP_PR_REPOSITORY,
+      patchedFiles: materialized.patchedFiles,
+      patchedEntrypoint: TRELLIS_ENTRYPOINT,
+      patchedEntrypointImported: true,
+      patchedToolModule: TRELLIS_TOOL_MODULE,
+      patchedToolModuleExported: true,
+      packageJsonMerged: true,
+    },
+  };
+}
+
+function createSetupPrHarness(): {
+  fetchImpl: typeof fetch;
+  materializeCommit: () => { files: Record<string, string>; patchedFiles: string[] };
+} {
+  const baseSha = 'b'.repeat(40);
+  const baseTreeSha = 't'.repeat(40);
+  const treeSha = 'n'.repeat(40);
+  const commitSha = 'c'.repeat(40);
+  const blobs = new Map<string, string>();
+  let blobCount = 0;
+  let committedTree: Array<{ path: string; sha: string }> = [];
+  const existingFiles: Record<string, string> = {
+    'package.json': `${JSON.stringify({ dependencies: { langchain: '^0.3.0' } }, null, 2)}\n`,
+    [TRELLIS_ENTRYPOINT]: "'use strict';\n\nexport async function runAgent() {}\n",
+    [TRELLIS_TOOL_MODULE]:
+      'export async function runTool<T>(input: T): Promise<T> {\n  return input;\n}\n',
+  };
+
+  const fetchImpl = (async (url: string | URL, init?: RequestInit): Promise<Response> => {
+    const parsed = new URL(String(url));
+    const method = init?.method ?? 'GET';
+    const path = parsed.pathname;
+    const key = `${method} ${path}`;
+
+    if (
+      parsed.host === new URL(SETUP_PR_ARCHAL_BASE_URL).host &&
+      key === `POST ${SETUP_PR_TOKEN_PATH}`
+    ) {
+      return Response.json({
+        token: 'github-installation-token-for-tests',
+        expiresAt: '2099-01-01T00:00:00Z',
+      });
+    }
+
+    if (parsed.host !== 'api.github.com') {
+      return Response.json({ message: `Unexpected host ${parsed.host}` }, { status: 500 });
+    }
+    if (key === 'GET /repos/acme/trellis-agent') {
+      return Response.json({ default_branch: 'main' });
+    }
+    if (key === 'GET /repos/acme/trellis-agent/git/ref/heads/main') {
+      return Response.json({ object: { sha: baseSha } });
+    }
+    if (key === 'GET /repos/acme/trellis-agent/pulls') {
+      return Response.json([]);
+    }
+    if (key.startsWith('GET /repos/acme/trellis-agent/contents/')) {
+      const filePath = decodeURIComponent(path.slice('/repos/acme/trellis-agent/contents/'.length));
+      const existing = existingFiles[filePath];
+      if (existing === undefined) {
+        return Response.json({ message: 'Not Found' }, { status: 404 });
+      }
+      return Response.json({
+        content: Buffer.from(existing, 'utf8').toString('base64'),
+        encoding: 'base64',
+      });
+    }
+    if (key === 'POST /repos/acme/trellis-agent/git/blobs') {
+      const body = JSON.parse(String(init?.body ?? '{}')) as { content?: string };
+      const sha = `blob-${String(++blobCount).padStart(2, '0')}`;
+      blobs.set(sha, Buffer.from(body.content ?? '', 'base64').toString('utf8'));
+      return Response.json({ sha }, { status: 201 });
+    }
+    if (key === `GET /repos/acme/trellis-agent/git/commits/${baseSha}`) {
+      return Response.json({ tree: { sha: baseTreeSha } });
+    }
+    if (key === 'POST /repos/acme/trellis-agent/git/trees') {
+      const body = JSON.parse(String(init?.body ?? '{}')) as {
+        tree?: Array<{ path?: string; sha?: string }>;
+      };
+      committedTree = (body.tree ?? []).flatMap((entry) =>
+        typeof entry.path === 'string' && typeof entry.sha === 'string'
+          ? [{ path: entry.path, sha: entry.sha }]
+          : [],
+      );
+      return Response.json({ sha: treeSha }, { status: 201 });
+    }
+    if (key === 'POST /repos/acme/trellis-agent/git/commits') {
+      return Response.json({ sha: commitSha }, { status: 201 });
+    }
+    if (key === 'POST /repos/acme/trellis-agent/git/refs') {
+      return Response.json({ ref: 'refs/heads/archal/observability-setup' }, { status: 201 });
+    }
+    if (key === 'POST /repos/acme/trellis-agent/pulls') {
+      return Response.json(
+        { number: 42, html_url: 'https://github.com/acme/trellis-agent/pull/42' },
+        { status: 201 },
+      );
+    }
+
+    return Response.json({ message: `Unexpected ${key}` }, { status: 500 });
+  }) as typeof fetch;
+
+  return {
+    fetchImpl,
+    materializeCommit: () => {
+      const files: Record<string, string> = {};
+      for (const entry of committedTree) {
+        const contents = blobs.get(entry.sha);
+        if (contents !== undefined) {
+          files[entry.path] = contents;
+        }
+      }
+      return { files, patchedFiles: committedTree.map((entry) => entry.path) };
+    },
+  };
+}
+
+async function runGeneratedHelperCapture(
+  setupDir: string,
+  fixturePath: string,
+  omitCaptureOperations: string[],
+  stripOperationOutcomes: string[],
+  redactOperationRequests: string[],
+  replaceStateBeforeIds: Array<{ from: string; to: string }>,
+): Promise<{
+  attributes: Record<string, string>;
+  captures: Array<Record<string, unknown>>;
+  toolResult: unknown;
+  spanStatus?: unknown;
+  spanEnded: boolean;
+}> {
+  const agentPath = resolve(setupDir, 'synthetic-prod-agent.ts');
+  await writeFile(
+    agentPath,
+    syntheticProdAgentSource(
+      omitCaptureOperations,
+      stripOperationOutcomes,
+      redactOperationRequests,
+      replaceStateBeforeIds,
+    ),
+  );
+
+  const result = spawnSync(
+    'pnpm',
+    ['--silent', 'exec', 'node', '--import', TSX_LOADER_PATH, agentPath, fixturePath],
+    {
+      cwd: REPO_ROOT,
+      encoding: 'utf8',
+      env: childEnvWithGeneratedSetupDeps(),
+    },
+  );
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(
+      [
+        `generated helper capture exited ${result.status}`,
+        result.stdout ? `stdout:\n${result.stdout}` : undefined,
+        result.stderr ? `stderr:\n${result.stderr}` : undefined,
+      ]
+        .filter(Boolean)
+        .join('\n'),
+    );
+  }
+
+  const parsed = JSON.parse(result.stdout.trim()) as unknown;
+  if (!isRecord(parsed)) {
+    throw new Error('generated helper capture did not print a JSON object');
+  }
+  const captures = Array.isArray(parsed['captures'])
+    ? (parsed['captures'].filter(isRecord) as Array<Record<string, unknown>>)
+    : [];
+  if (captures.length === 0) {
+    throw new Error('generated helper capture did not print any captured tool spans');
+  }
+  const replayCapsules = captures.map((capture, index) => {
+    const attributes = requiredRecord(
+      capture['attributes'],
+      `generated helper attributes[${index}]`,
+    );
+    const capsule = attributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE];
+    if (typeof capsule !== 'string' || capsule.length === 0) {
+      throw new Error(`generated helper did not attach archal.replay.capsule for capture ${index}`);
+    }
+    return normalizeTraceReplayCapsule(capsule);
+  });
+  const replayCapsule = mergeTraceReplayCapsules(replayCapsules);
+  if (!replayCapsule) {
+    throw new Error('generated helper replay capsules did not merge into replay evidence');
+  }
+  const attributes = traceReplayCapsuleToOtelAttributes(replayCapsule);
+  return {
+    attributes,
+    captures,
+    toolResult: parsed['toolResult'],
+    spanStatus: parsed['spanStatus'],
+    spanEnded: parsed['spanEnded'] === true,
+  };
+}
+
+function syntheticProdAgentSource(
+  omitCaptureOperations: string[],
+  stripOperationOutcomes: string[],
+  redactOperationRequests: string[],
+  replaceStateBeforeIds: Array<{ from: string; to: string }>,
+): string {
+  return `import { readFileSync } from 'node:fs';
+import { captureArchalToolBoundary } from './${TRELLIS_TOOL_MODULE}';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function requiredRecord(value: unknown, label: string): Record<string, unknown> {
+  if (!isRecord(value)) throw new Error(\`\${label} must be an object\`);
+  return value;
+}
+
+const fixturePath = process.argv[2];
+if (!fixturePath) throw new Error('fixture path is required');
+const fixture = requiredRecord(JSON.parse(readFileSync(fixturePath, 'utf8')), 'fixture');
+const trace = requiredRecord(fixture.ai_trace, 'fixture.ai_trace');
+const context = requiredRecord(trace.context, 'fixture.ai_trace.context');
+const replaceStateBeforeIds = new Map(${JSON.stringify(
+    replaceStateBeforeIds.map((entry) => [entry.from, entry.to]),
+  )});
+const stateBefore = requiredRecord(
+  replaceStateIds(requiredRecord(context.stateBefore, 'fixture.ai_trace.context.stateBefore')),
+  'fixture.ai_trace.context.stateBefore',
+);
+const stateAfter = requiredRecord(context.stateAfter, 'fixture.ai_trace.context.stateAfter');
+const stateDiff = requiredRecord(context.stateDiff, 'fixture.ai_trace.context.stateDiff');
+const omitCaptureOperations = new Set(${JSON.stringify(omitCaptureOperations)});
+const stripOperationOutcomes = new Set(${JSON.stringify(stripOperationOutcomes)});
+const redactOperationRequests = new Set(${JSON.stringify(redactOperationRequests)});
+
+function replaceStateIds(value: unknown): unknown {
+  if (typeof value === 'string') return replaceStateBeforeIds.get(value) ?? value;
+  if (typeof value === 'number') {
+    const replacement = replaceStateBeforeIds.get(String(value));
+    return replacement === undefined ? value : replacement;
+  }
+  if (Array.isArray(value)) return value.map((entry) => replaceStateIds(entry));
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        replaceStateBeforeIds.get(key) ?? key,
+        replaceStateIds(entry),
+      ]),
+    );
+  }
+  return value;
+}
+
+function makeSpan(operation: string) {
+  const attributes: Record<string, string | number | boolean> = {};
+  let status: unknown;
+  let ended = false;
+  const span = {
+    setAttribute(key: string, value: string | number | boolean) {
+      attributes[key] = value;
+      return this;
+    },
+    recordException(error: Error | string) {
+      attributes['archal.synthetic.exception'] =
+        error instanceof Error ? error.message : String(error);
+    },
+    setStatus(nextStatus: unknown) {
+      status = nextStatus;
+    },
+    end() {
+      ended = true;
+    },
+  };
+  return {
+    operation,
+    attributes,
+    get status() {
+      return status;
+    },
+    get ended() {
+      return ended;
+    },
+    span,
+  };
+}
+
+function captureAttributes(operation: string, attributes: Record<string, string | number | boolean>) {
+  if (!stripOperationOutcomes.has(operation) && !redactOperationRequests.has(operation)) return attributes;
+  const capsuleText = attributes['archal.replay.capsule'];
+  if (typeof capsuleText !== 'string') return attributes;
+  const capsule = JSON.parse(capsuleText);
+  if (Array.isArray(capsule.serviceOperations)) {
+    capsule.serviceOperations = capsule.serviceOperations.map((serviceOperation: Record<string, unknown>) => {
+      const key = [serviceOperation.service, serviceOperation.operation].filter(Boolean).join('.');
+      if (key !== operation) return serviceOperation;
+      const nextOperation = { ...serviceOperation };
+      if (stripOperationOutcomes.has(operation)) {
+        delete nextOperation.response;
+        delete nextOperation.error;
+      }
+      if (redactOperationRequests.has(operation)) {
+        nextOperation.request = '[REDACTED]';
+      }
+      return nextOperation;
+    });
+  }
+  return {
+    ...attributes,
+    'archal.replay.capsule': JSON.stringify(capsule),
+  };
+}
+
+function stateCaptureEntries(): Array<Record<string, unknown>> {
+  const capturedAt =
+    typeof trace.created_at === 'string' ? trace.created_at : '2026-06-01T18:20:00.000Z';
+  return Object.entries(stateBefore)
+    .filter(([, serviceState]) => isRecord(serviceState) && Object.keys(serviceState).length > 0)
+    .map(([service]) => ({
+      service,
+      scope: 'resource_closure',
+      capturedAt,
+      source: 'fixture.ai_trace.context.stateBefore',
+    }));
+}
+
+const sharedProviders = {
+  stateBeforeProvider: () => stateBefore,
+  stateAfterProvider: () => stateAfter,
+  stateDiffProvider: () => stateDiff,
+  stateCaptureProvider: () => stateCaptureEntries(),
+  authPrincipalProvider: () => ({
+    kind: 'service_account',
+    actor: trace.agent_id ?? 'trellis-property-ops-demo-agent',
+    scopes: ['slack:history', 'slack:write', 'jira:read'],
+  }),
+  modelConfigProvider: () => ({
+    provider: 'openai',
+    model: trace.model_id ?? 'gpt-5-5-codex',
+  }),
+  promptBundleProvider: () => ({
+    task: isRecord(trace.input_data) ? trace.input_data.request : undefined,
+    scenario: isRecord(trace.metadata) ? trace.metadata.scenario : undefined,
+  }),
+  historicalSnapshotProvider: () => ({
+    source: 'trellis-demo-fixture',
+    traceId: trace.trace_id,
+  }),
+  harnessContextProvider: () => ({
+    repository: 'acme/trellis-agent',
+    commit: 'offline-e2e-synthetic-commit',
+    entrypoint: '${TRELLIS_ENTRYPOINT}',
+    toolModule: '${TRELLIS_TOOL_MODULE}',
+  }),
+};
+
+function asInput(span: Record<string, unknown>): Record<string, unknown> {
+  return isRecord(span.input) ? span.input : {};
+}
+
+function operationFromSpan(span: Record<string, unknown>): { service: string; operation: string } | null {
+  const name = typeof span.name === 'string' ? span.name : '';
+  if (name.startsWith('slack.')) {
+    return { service: 'slack', operation: name.slice('slack.'.length) };
+  }
+  if (name === 'jira_get_issue') return { service: 'jira', operation: 'get.issue' };
+  if (name === 'jira_create_issue') return { service: 'jira', operation: 'create.issue' };
+  if (name === 'jira_add_comment') return { service: 'jira', operation: 'add.comment' };
+  if (name.startsWith('jira.')) {
+    return { service: 'jira', operation: name.slice('jira.'.length) };
+  }
+  return null;
+}
+
+function operationKey(operation: { service: string; operation: string }): string {
+  return operation.service + '.' + operation.operation;
+}
+
+function compactRefs(refs: Array<Record<string, unknown>>): Array<Record<string, unknown>> {
+  const seen = new Set<string>();
+  return refs.filter((ref) => {
+    const id = typeof ref.id === 'string' ? ref.id : '';
+    if (!id) return false;
+    const key = JSON.stringify([ref.service, ref.type, id]);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+function slackRefs(span: Record<string, unknown>, operation: string): {
+  resourceRefs: Array<Record<string, unknown>>;
+  serviceReadSet: Array<Record<string, unknown>>;
+  serviceWriteSet: Array<Record<string, unknown>>;
+} {
+  const input = asInput(span);
+  const output = isRecord(span.output) ? span.output : {};
+  const refs: Array<Record<string, unknown>> = [];
+  const readSet: Array<Record<string, unknown>> = [];
+  const writeSet: Array<Record<string, unknown>> = [];
+  const channel = typeof input.channel === 'string' ? input.channel : undefined;
+  if (operation === 'conversations.list') {
+    const channels = Array.isArray(output.channels) ? output.channels.filter(isRecord) : [];
+    for (const candidate of channels) {
+      if (typeof candidate.id !== 'string') continue;
+      refs.push({ service: 'slack', type: 'channel', id: candidate.id, name: candidate.name });
+      readSet.push({ service: 'slack', type: 'channel', id: candidate.id, name: candidate.name });
+    }
+  } else if (channel) {
+    refs.push({ service: 'slack', type: 'channel', id: channel });
+  }
+  if (operation === 'conversations.history' && channel) {
+    readSet.push({ service: 'slack', type: 'channel', id: channel });
+    const messages = Array.isArray(output.messages) ? output.messages.filter(isRecord) : [];
+    for (const message of messages) {
+      const ts = typeof message.ts === 'string' ? message.ts : undefined;
+      if (!ts) continue;
+      const threadTs = typeof message.thread_ts === 'string' ? message.thread_ts : ts;
+      refs.push({ service: 'slack', type: 'thread', id: channel + ':' + threadTs });
+      readSet.push({ service: 'slack', type: 'message', id: channel + ':' + ts });
+    }
+  }
+  if (operation === 'chat.postMessage' && channel) {
+    const ts = typeof output.ts === 'string' ? output.ts : undefined;
+    const threadTs = typeof input.thread_ts === 'string' ? input.thread_ts : undefined;
+    if (threadTs) refs.push({ service: 'slack', type: 'thread', id: channel + ':' + threadTs });
+    if (ts) {
+      writeSet.push({ service: 'slack', type: 'message', id: channel + ':' + ts });
+    }
+  }
+  return {
+    resourceRefs: compactRefs(refs),
+    serviceReadSet: compactRefs(readSet),
+    serviceWriteSet: compactRefs(writeSet),
+  };
+}
+
+function jiraRefs(span: Record<string, unknown>, operation: string): {
+  resourceRefs: Array<Record<string, unknown>>;
+  serviceReadSet: Array<Record<string, unknown>>;
+  serviceWriteSet: Array<Record<string, unknown>>;
+} {
+  const input = asInput(span);
+  const output = isRecord(span.output) ? span.output : {};
+  const issueKey =
+    (typeof input.issue_key === 'string' ? input.issue_key : undefined) ??
+    (typeof output.key === 'string' ? output.key : undefined);
+  const refs: Array<Record<string, unknown>> = [];
+  const readSet: Array<Record<string, unknown>> = [];
+  const writeSet: Array<Record<string, unknown>> = [];
+  if (issueKey) {
+    if (operation === 'create.issue') {
+      const projectKey =
+        (typeof input.project_key === 'string' ? input.project_key : undefined) ??
+        issueKey.split('-')[0];
+      refs.push({ service: 'jira', type: 'project', id: projectKey });
+    } else {
+      refs.push({ service: 'jira', type: 'issue', id: issueKey });
+    }
+    if (operation === 'get.issue' || operation === 'add.comment') {
+      readSet.push({ service: 'jira', type: 'issue', id: issueKey });
+    }
+    if (operation === 'create.issue') {
+      writeSet.push({ service: 'jira', type: 'issue', id: issueKey });
+    }
+  }
+  if (operation === 'add.comment' && issueKey) {
+    const commentId = typeof output.id === 'string' ? output.id : issueKey + ':comment';
+    writeSet.push({ service: 'jira', type: 'comment', id: commentId });
+  }
+  return {
+    resourceRefs: compactRefs(refs),
+    serviceReadSet: compactRefs(readSet),
+    serviceWriteSet: compactRefs(writeSet),
+  };
+}
+
+function refsForSpan(span: Record<string, unknown>, parsed: { service: string; operation: string }) {
+  if (parsed.service === 'slack') return slackRefs(span, parsed.operation);
+  if (parsed.service === 'jira') return jiraRefs(span, parsed.operation);
+  return { resourceRefs: [], serviceReadSet: [], serviceWriteSet: [] };
+}
+
+function cloneStateAdapter(service: string): Record<string, unknown> {
+  return {
+    service,
+    adapter: service + '-state-materializer',
+    schema: 'archal.clone.' + service + '.v1',
+    schemaVersion: '1',
+    format: 'json',
+    source: 'observability-install-offline-e2e',
+  };
+}
+
+async function captureFixtureToolSpan(spanRecord: Record<string, unknown>, index: number) {
+  const parsed = operationFromSpan(spanRecord);
+  if (!parsed) return null;
+  const key = operationKey(parsed);
+  const syntheticSpan = makeSpan(key);
+  const refs = refsForSpan(spanRecord, parsed);
+  const input = asInput(spanRecord);
+  const output = spanRecord.output ?? {};
+  const result = await captureArchalToolBoundary(input, async () => output, {
+    service: parsed.service,
+    operation: parsed.operation,
+    span: syntheticSpan.span,
+    resourceRefs: refs.resourceRefs.length > 0 ? refs.resourceRefs : [
+      { service: parsed.service, type: 'operation', id: key + ':' + String(index) },
+    ],
+    serviceReadSet: refs.serviceReadSet,
+    serviceWriteSet: refs.serviceWriteSet,
+    stateAdapters: [cloneStateAdapter(parsed.service)],
+    providers: sharedProviders,
+  });
+  syntheticSpan.span.end();
+  return {
+    operation: key,
+    attributes: captureAttributes(key, syntheticSpan.attributes),
+    status: syntheticSpan.status,
+    ended: syntheticSpan.ended,
+    result,
+  };
+}
+
+async function main(): Promise<void> {
+  const captures = [];
+  let toolResult: unknown = null;
+  const spans = Array.isArray(fixture.ai_spans) ? fixture.ai_spans.filter(isRecord) : [];
+  const toolSpans = spans.filter((span) => operationFromSpan(span));
+  for (let index = 0; index < toolSpans.length; index += 1) {
+    const capture = await captureFixtureToolSpan(toolSpans[index], index);
+    if (!capture) continue;
+    toolResult = capture.result;
+    if (!omitCaptureOperations.has(capture.operation)) {
+      captures.push(capture);
+    }
+  }
+
+  process.stdout.write(
+    JSON.stringify(
+      {
+        captures,
+        toolResult,
+        spanStatus: captures.map((capture) => capture.status),
+        spanEnded: captures.every((capture) => capture.ended),
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+main().catch((error) => {
+  process.stderr.write(error instanceof Error ? error.stack ?? error.message : String(error));
+  process.exitCode = 1;
+});
+`;
+}
+
+function serviceForSpan(span: Record<string, unknown>): string {
+  const name = asString(span['name']) ?? '';
+  if (name.startsWith('slack.')) return 'slack';
+  if (name.startsWith('jira.') || name.startsWith('jira_')) return 'jira';
+  return 'agent';
+}
+
+function operationFromFixtureSpan(
+  span: Record<string, unknown>,
+): { service: string; operation: string } | null {
+  const name = asString(span['name']) ?? '';
+  if (name.startsWith('slack.')) {
+    return { service: 'slack', operation: name.slice('slack.'.length) };
+  }
+  if (name === 'jira_get_issue') return { service: 'jira', operation: 'get.issue' };
+  if (name === 'jira_create_issue') return { service: 'jira', operation: 'create.issue' };
+  if (name === 'jira_add_comment') return { service: 'jira', operation: 'add.comment' };
+  if (name.startsWith('jira.')) {
+    return { service: 'jira', operation: name.slice('jira.'.length) };
+  }
+  return null;
+}
+
+function fixtureOperationKey(operation: { service: string; operation: string }): string {
+  return `${operation.service}.${operation.operation}`;
+}
+
+function captureAttributesByOperation(
+  captures: Array<Record<string, unknown>>,
+): Map<string, Array<Record<string, string>>> {
+  const byOperation = new Map<string, Array<Record<string, string>>>();
+  for (const capture of captures) {
+    const operation = asString(capture['operation']);
+    const attributes = isRecord(capture['attributes'])
+      ? Object.fromEntries(
+          Object.entries(capture['attributes']).flatMap(([key, value]) =>
+            typeof value === 'string' ? [[key, value]] : [],
+          ),
+        )
+      : {};
+    if (!operation || Object.keys(attributes).length === 0) continue;
+    const existing = byOperation.get(operation) ?? [];
+    existing.push(attributes);
+    byOperation.set(operation, existing);
+  }
+  return byOperation;
+}
+
+function takeCapturedAttributesForSpan(
+  span: Record<string, unknown>,
+  captureAttributes: Map<string, Array<Record<string, string>>>,
+): Record<string, string> {
+  const parsed = operationFromFixtureSpan(span);
+  return parsed ? (captureAttributes.get(fixtureOperationKey(parsed))?.shift() ?? {}) : {};
+}
+
+function outputText(span: Record<string, unknown>): unknown {
+  const output = span['output'];
+  if (isRecord(output) && typeof output['content'] === 'string') return output['content'];
+  return output;
+}
+
+function buildOtlpPayload(
+  fixture: TrellisFixture,
+  replayAttributes: Record<string, string>,
+  captures: Array<Record<string, unknown>>,
+): Record<string, unknown> {
+  const traceId = stableHex(fixture.ai_trace.trace_id, 16);
+  const captureAttributes = captureAttributesByOperation(captures);
+  return {
+    resourceSpans: [
+      {
+        resource: {
+          attributes: [
+            attr('service.name', 'trellis-property-ops-synthetic-prod-agent'),
+            attr('deployment.environment.name', 'production'),
+            attr('archal.e2e.source', 'observability-install-offline'),
+          ],
+        },
+        scopeSpans: [
+          {
+            scope: { name: 'archal.observability-install-e2e', attributes: [] },
+            spans: fixture.ai_spans.map((span, index) => {
+              const spanId = stableHex(asString(span['span_id']) ?? `span-${index}`, 8);
+              const operationAttributes = takeCapturedAttributesForSpan(span, captureAttributes);
+              const attributes = [
+                attr('span.type', asString(span['span_type']) ?? 'span'),
+                attr('gen_ai.prompt', span['input']),
+                attr('gen_ai.completion', outputText(span)),
+                ...Object.entries(operationAttributes).map(([key, value]) => attr(key, value)),
+              ];
+              if (index === 0) {
+                attributes.push(
+                  attr(
+                    TRACE_REPLAY_CAPSULE_ATTRIBUTE,
+                    replayAttributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE],
+                  ),
+                  attr(
+                    TRACE_REPLAY_STATUS_ATTRIBUTE,
+                    replayAttributes[TRACE_REPLAY_STATUS_ATTRIBUTE],
+                  ),
+                );
+              }
+              return {
+                traceId,
+                spanId,
+                parentSpanId: span['parent_span_id']
+                  ? stableHex(String(span['parent_span_id']), 8)
+                  : undefined,
+                name: asString(span['name']) ?? `trellis.span.${index + 1}`,
+                startTimeUnixNano: isoToNanos(span['started_at']),
+                endTimeUnixNano: isoToNanos(span['ended_at'] ?? span['completed_at']),
+                attributes,
+              };
+            }),
+          },
+        ],
+      },
+    ],
+  };
+}
+
+function buildBraintrustPayload(
+  fixture: TrellisFixture,
+  replayAttributes: Record<string, string>,
+  captures: Array<Record<string, unknown>>,
+): Record<string, unknown> {
+  const captureAttributes = captureAttributesByOperation(captures);
+  return {
+    project_id: 'archal-observability-install-e2e',
+    events: fixture.ai_spans.map((span, index) => {
+      const name = asString(span['name']) ?? `trellis.span.${index + 1}`;
+      const operationAttributes = takeCapturedAttributesForSpan(span, captureAttributes);
+      return {
+        id: asString(span['span_id']) ?? `span-${index + 1}`,
+        root_span_id: fixture.ai_trace.trace_id,
+        span_id: asString(span['span_id']) ?? `span-${index + 1}`,
+        parent_span_id: asString(span['parent_span_id']) ?? undefined,
+        name,
+        type: asString(span['span_type']) ?? 'span',
+        serviceName: serviceForSpan(span),
+        start_time: asString(span['started_at']),
+        end_time: asString(span['ended_at']) ?? asString(span['completed_at']),
+        input: isRecord(span['input']) ? span['input'] : (span['input_data'] ?? {}),
+        output: span['output'] ?? span['output_data'] ?? null,
+        metadata: {
+          ...(index === 0
+            ? {
+                [TRACE_REPLAY_CAPSULE_ATTRIBUTE]: replayAttributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE],
+                [TRACE_REPLAY_STATUS_ATTRIBUTE]: replayAttributes[TRACE_REPLAY_STATUS_ATTRIBUTE],
+                replayCapsule: replayAttributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE],
+              }
+            : {}),
+          ...operationAttributes,
+          ...(operationAttributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE]
+            ? { replayCapsule: operationAttributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE] }
+            : {}),
+        },
+      };
+    }),
+  };
+}
+
+function buildLangfusePayload(
+  fixture: TrellisFixture,
+  replayAttributes: Record<string, string>,
+  captures: Array<Record<string, unknown>>,
+): Record<string, unknown> {
+  const captureAttributes = captureAttributesByOperation(captures);
+  return {
+    projectId: 'archal-observability-install-e2e',
+    traces: [
+      {
+        id: fixture.ai_trace.trace_id,
+        name: 'trellis-property-ops-synthetic-prod-agent',
+        timestamp: asString(fixture.ai_spans[0]?.['started_at']) ?? '2026-06-01T18:20:00.000Z',
+        metadata: {
+          source: 'observability-install-offline-e2e',
+          trellisTraceId: fixture.ai_trace.trace_id,
+        },
+        observations: fixture.ai_spans.map((span, index) => {
+          const name = asString(span['name']) ?? `trellis.span.${index + 1}`;
+          const operationAttributes = takeCapturedAttributesForSpan(span, captureAttributes);
+          return {
+            id: asString(span['span_id']) ?? `span-${index + 1}`,
+            traceId: fixture.ai_trace.trace_id,
+            parentObservationId: asString(span['parent_span_id']),
+            name,
+            type: asString(span['span_type']) ?? 'span',
+            serviceName: serviceForSpan(span),
+            startTime: asString(span['started_at']),
+            endTime: asString(span['ended_at']) ?? asString(span['completed_at']),
+            input: isRecord(span['input']) ? span['input'] : (span['input_data'] ?? {}),
+            output: span['output'] ?? span['output_data'] ?? null,
+            metadata: {
+              ...(index === 0
+                ? {
+                    [TRACE_REPLAY_CAPSULE_ATTRIBUTE]:
+                      replayAttributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE],
+                    [TRACE_REPLAY_STATUS_ATTRIBUTE]:
+                      replayAttributes[TRACE_REPLAY_STATUS_ATTRIBUTE],
+                    replayCapsule: replayAttributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE],
+                  }
+                : {}),
+              ...operationAttributes,
+              ...(operationAttributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE]
+                ? { replayCapsule: operationAttributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE] }
+                : {}),
+            },
+          };
+        }),
+      },
+    ],
+  };
+}
+
+function buildGradeableTrace(
+  fixture: TrellisFixture,
+  replayAttributes: Record<string, string>,
+  captures: Array<Record<string, unknown>>,
+): Record<string, unknown> {
+  const traceId = fixture.ai_trace.trace_id;
+  const captureAttributes = captureAttributesByOperation(captures);
+
+  return {
+    trace: fixture.ai_spans.map((span, index) => {
+      const name = asString(span['name']) ?? `trellis.span.${index + 1}`;
+      const operationAttributes = takeCapturedAttributesForSpan(span, captureAttributes);
+      return {
+        id: asString(span['span_id']) ?? `span-${index + 1}`,
+        traceId,
+        spanId: asString(span['span_id']) ?? `span-${index + 1}`,
+        parentSpanId: asString(span['parent_span_id']) ?? null,
+        toolName: name,
+        twinName: serviceForSpan(span),
+        input: isRecord(span['input']) ? span['input'] : (span['input_data'] ?? {}),
+        output: span['output'] ?? span['output_data'] ?? null,
+        timestamp:
+          asString(span['ended_at']) ??
+          asString(span['completed_at']) ??
+          asString(span['started_at']) ??
+          '2026-06-01T18:20:00.000Z',
+        startTimestamp: asString(span['started_at']),
+        endTimestamp: asString(span['ended_at']) ?? asString(span['completed_at']),
+        durationMs: typeof span['duration_ms'] === 'number' ? span['duration_ms'] : 0,
+        error: span['error'] ?? null,
+        attributes: {
+          ...(index === 0 ? replayAttributes : {}),
+          ...operationAttributes,
+        },
+      };
+    }),
+  };
+}
+
+function buildGradeRequest(fixture: TrellisFixture, tracePath: string): Record<string, unknown> {
+  const context = fixture.ai_trace.context ?? {};
+  return {
+    schema: 'archal.grade.request.v1',
+    runId: 'observability-install-replay-capsule-trellis',
+    trace: {
+      path: tracePath,
+      id: fixture.ai_trace.trace_id,
+    },
+    rubric: {
+      task: 'Handle a Trellis property operations guest issue from an imported production trace.',
+      expectedBehavior:
+        'Create the maintenance task, notify field ops, reply safely, and post the required manager-review escalation before any refund decision.',
+      passThreshold: 80,
+      criteria: [
+        {
+          id: 'manager_review_escalated',
+          type: 'deterministic',
+          critical: true,
+          description:
+            'The trace contains a slack.chat.postMessage call to the manager-review channel with the refund boundary.',
+        },
+      ],
+    },
+    context: {
+      agentResponseText: context.agentResponseText,
+    },
+    metadata: {
+      source: 'observability-install-offline-e2e',
+      replayStateSource: 'operation-local-replay-capsule',
+      trellisTraceId: fixture.ai_trace.trace_id,
+    },
+  };
+}
+
+function buildReproductionProof(input: {
+  caseId: string;
+  tracePath: string;
+  gradeRequestPath: string;
+  seedProvenancePath: string;
+}): Record<string, unknown> {
+  return {
+    schema: 'archal.postprod.reproduction-proof.v1',
+    status: 'reproduced',
+    sourceCaseId: input.caseId,
+    parity: {
+      trustStatus: 'verified',
+      acceptsReproduction: true,
+      sameFailureReproduced: true,
+      reproducedFailure: true,
+      failedCriterionIds: ['manager_review_escalated'],
+    },
+    artifacts: {
+      tracePath: input.tracePath,
+      scenarioPath: resolve(
+        REPO_ROOT,
+        'e2e/post-prod-loop/cases/observability-install-replay-capsule/scenario.md',
+      ),
+      gradeRequestPath: input.gradeRequestPath,
+      seedProvenancePath: input.seedProvenancePath,
+    },
+  };
+}
+
+async function main(): Promise<number> {
+  const {
+    outDir,
+    fixturePath,
+    omitCaptureOperations,
+    stripOperationOutcomes,
+    redactOperationRequests,
+    replaceStateBeforeIds,
+  } = parseArgs(process.argv.slice(2));
+  await mkdir(outDir, { recursive: true });
+
+  const fixture = await readFixture(fixturePath);
+  const setup = await writeSetupArtifacts(outDir);
+  const helperCapture = await runGeneratedHelperCapture(
+    setup.dir,
+    fixturePath,
+    omitCaptureOperations,
+    stripOperationOutcomes,
+    redactOperationRequests,
+    replaceStateBeforeIds,
+  );
+  const replayAttributes = traceReplayCapsuleToOtelAttributes(
+    helperCapture.attributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE],
+  );
+  const replayCapsule = normalizeTraceReplayCapsule(
+    replayAttributes[TRACE_REPLAY_CAPSULE_ATTRIBUTE],
+  );
+  if (replayCapsule?.sufficiency?.status !== 'reproducible') {
+    throw new Error(
+      `Replay capsule is not reproducible: ${JSON.stringify(replayCapsule?.sufficiency ?? null)}`,
+    );
+  }
+  const serviceOperations = Array.isArray(replayCapsule.serviceOperations)
+    ? replayCapsule.serviceOperations.filter(isRecord)
+    : [];
+  const stateBeforeOperationCount = serviceOperations.filter((operation) =>
+    isRecord(operation['stateBefore']),
+  ).length;
+  const stateAfterOrDiffOperationCount = serviceOperations.filter(
+    (operation) => isRecord(operation['stateAfter']) || isRecord(operation['stateDiff']),
+  ).length;
+  if (
+    serviceOperations.length === 0 ||
+    stateBeforeOperationCount !== serviceOperations.length ||
+    stateAfterOrDiffOperationCount !== serviceOperations.length
+  ) {
+    throw new Error(
+      `Generated helper did not emit operation-local replay state for every operation: operations=${serviceOperations.length}, stateBefore=${stateBeforeOperationCount}, stateAfterOrDiff=${stateAfterOrDiffOperationCount}`,
+    );
+  }
+
+  const otlpPath = resolve(outDir, 'synthetic-prod-agent-otlp.json');
+  const braintrustPath = resolve(outDir, 'synthetic-prod-agent-braintrust.json');
+  const langfusePath = resolve(outDir, 'synthetic-prod-agent-langfuse.json');
+  const tracePath = resolve(outDir, 'trace.json');
+  const otlpRequestPath = resolve(outDir, 'otlp-grade-request.json');
+  const braintrustRequestPath = resolve(outDir, 'braintrust-grade-request.json');
+  const langfuseRequestPath = resolve(outDir, 'langfuse-grade-request.json');
+  const corpusPath = resolve(outDir, 'corpus.json');
+  const seedProvenancePath = resolve(outDir, 'seed-provenance.json');
+  const otlpReproductionProofPath = resolve(outDir, 'otlp-reproduction-proof.json');
+  const braintrustReproductionProofPath = resolve(outDir, 'braintrust-reproduction-proof.json');
+  const langfuseReproductionProofPath = resolve(outDir, 'langfuse-reproduction-proof.json');
+  const replayabilityAuditPath = resolve(outDir, 'replayability-audit.json');
+  await writeJson(otlpPath, buildOtlpPayload(fixture, replayAttributes, helperCapture.captures));
+  await writeJson(
+    braintrustPath,
+    buildBraintrustPayload(fixture, replayAttributes, helperCapture.captures),
+  );
+  await writeJson(
+    langfusePath,
+    buildLangfusePayload(fixture, replayAttributes, helperCapture.captures),
+  );
+  await writeJson(
+    tracePath,
+    buildGradeableTrace(fixture, replayAttributes, helperCapture.captures),
+  );
+  const replayabilityAudit = runReplayabilityAudit(tracePath);
+  const replayabilityScores = requiredRecord(
+    replayabilityAudit['scores'],
+    'replayability audit scores',
+  );
+  const replayabilityEvidence = requiredRecord(
+    replayabilityAudit['evidence'],
+    'replayability audit evidence',
+  );
+  const replayabilityReplayEvidence = requiredRecord(
+    replayabilityEvidence['replay'],
+    'replayability audit replay evidence',
+  );
+  const replayabilityCaptureEvidence = requiredRecord(
+    replayabilityReplayEvidence['capture'],
+    'replayability audit capture evidence',
+  );
+  await writeJson(replayabilityAuditPath, replayabilityAudit);
+  if (replayabilityAudit['classification'] !== 'clone-replayable') {
+    const missingEvidence = Array.isArray(replayabilityAudit['missingEvidence'])
+      ? replayabilityAudit['missingEvidence'].join(', ')
+      : '';
+    throw new Error(
+      `Generated helper trace is not clone-replayable: ${String(replayabilityAudit['classification'])}${
+        missingEvidence ? `; missingEvidence=${missingEvidence}` : ''
+      }`,
+    );
+  }
+  if (typeof replayabilityScores['oneToOne'] !== 'number' || replayabilityScores['oneToOne'] < 85) {
+    throw new Error(
+      `Generated helper trace replayability score is too low: ${String(replayabilityScores['oneToOne'])}`,
+    );
+  }
+  await writeJson(otlpRequestPath, buildGradeRequest(fixture, './synthetic-prod-agent-otlp.json'));
+  await writeJson(
+    braintrustRequestPath,
+    buildGradeRequest(fixture, './synthetic-prod-agent-braintrust.json'),
+  );
+  await writeJson(
+    langfuseRequestPath,
+    buildGradeRequest(fixture, './synthetic-prod-agent-langfuse.json'),
+  );
+  await writeJson(seedProvenancePath, {
+    schema: 'archal.trace.seed-provenance.v1',
+    source: SCHEMA,
+    traceId: fixture.ai_trace.trace_id,
+    services: ['jira', 'slack'],
+    replayCapsuleSufficiency: replayCapsule.sufficiency,
+    replayability: {
+      classification: replayabilityAudit['classification'],
+      scores: replayabilityScores,
+      capture: replayabilityCaptureEvidence,
+    },
+  });
+  await writeJson(
+    otlpReproductionProofPath,
+    buildReproductionProof({
+      caseId: 'observability-install-replay-capsule-trellis-otlp',
+      tracePath: './synthetic-prod-agent-otlp.json',
+      gradeRequestPath: './otlp-grade-request.json',
+      seedProvenancePath: './seed-provenance.json',
+    }),
+  );
+  await writeJson(
+    braintrustReproductionProofPath,
+    buildReproductionProof({
+      caseId: 'observability-install-replay-capsule-trellis-braintrust',
+      tracePath: './synthetic-prod-agent-braintrust.json',
+      gradeRequestPath: './braintrust-grade-request.json',
+      seedProvenancePath: './seed-provenance.json',
+    }),
+  );
+  await writeJson(
+    langfuseReproductionProofPath,
+    buildReproductionProof({
+      caseId: 'observability-install-replay-capsule-trellis-langfuse',
+      tracePath: './synthetic-prod-agent-langfuse.json',
+      gradeRequestPath: './langfuse-grade-request.json',
+      seedProvenancePath: './seed-provenance.json',
+    }),
+  );
+  await writeJson(corpusPath, {
+    schema: 'archal.postprod.trace-corpus.v1',
+    generatedFrom: SCHEMA,
+    cases: [
+      {
+        id: 'observability-install-replay-capsule-trellis-otlp',
+        request: './otlp-grade-request.json',
+        expectedVerdict: 'failed',
+        reproduction: {
+          status: 'reproduced',
+          sameFailureReproduced: true,
+          proof: './otlp-reproduction-proof.json',
+        },
+        remediation: { expectedEligible: true },
+      },
+      {
+        id: 'observability-install-replay-capsule-trellis-braintrust',
+        request: './braintrust-grade-request.json',
+        expectedVerdict: 'failed',
+        reproduction: {
+          status: 'reproduced',
+          sameFailureReproduced: true,
+          proof: './braintrust-reproduction-proof.json',
+        },
+        remediation: { expectedEligible: true },
+      },
+      {
+        id: 'observability-install-replay-capsule-trellis-langfuse',
+        request: './langfuse-grade-request.json',
+        expectedVerdict: 'failed',
+        reproduction: {
+          status: 'reproduced',
+          sameFailureReproduced: true,
+          proof: './langfuse-reproduction-proof.json',
+        },
+        remediation: { expectedEligible: true },
+      },
+    ],
+  });
+
+  const result = {
+    schema: SCHEMA,
+    ok: true,
+    outDir,
+    fixturePath,
+    setup: {
+      dir: setup.dir,
+      files: setup.files,
+      secretLiteralDetected: false,
+      setupPr: setup.setupPr,
+    },
+    syntheticProdAgent: {
+      otlpPath,
+      braintrustPath,
+      langfusePath,
+      tracePath,
+      gradeRequestPath: otlpRequestPath,
+      providerGradeRequestPaths: {
+        otlp: otlpRequestPath,
+        braintrust: braintrustRequestPath,
+        langfuse: langfuseRequestPath,
+      },
+      gradeCorpusPath: corpusPath,
+      replayabilityAuditPath,
+      traceId: fixture.ai_trace.trace_id,
+      spans: fixture.ai_spans.length,
+      contextStateSuppressed: true,
+      replayStateSource: 'operation-local-replay-capsule',
+    },
+    replay: {
+      attribute: TRACE_REPLAY_CAPSULE_ATTRIBUTE,
+      status: replayCapsule.sufficiency?.status,
+      missing: replayCapsule.sufficiency?.missing ?? [],
+      warnings: replayCapsule.sufficiency?.warnings ?? [],
+      serviceOperations: replayCapsule.serviceOperations?.length ?? 0,
+      resourceRefs: replayCapsule.resourceRefs?.length ?? 0,
+      operationLocalState: {
+        stateBeforeOperations: stateBeforeOperationCount,
+        stateAfterOrDiffOperations: stateAfterOrDiffOperationCount,
+      },
+      capturedByGeneratedHelper: true,
+      helperSpanEnded: helperCapture.spanEnded,
+    },
+    helperCapture: {
+      toolResult: helperCapture.toolResult,
+      spanStatus: helperCapture.spanStatus,
+    },
+    replayability: {
+      auditPath: replayabilityAuditPath,
+      classification: replayabilityAudit['classification'],
+      oneToOneScore: replayabilityScores['oneToOne'],
+      services: replayabilityReplayEvidence['services'],
+      operationCoverage: replayabilityCaptureEvidence['operationCoverage'],
+      operationPayloads: replayabilityCaptureEvidence['operationPayloads'],
+      operationTargetState: replayabilityCaptureEvidence['operationTargetState'],
+      missingEvidence: replayabilityAudit['missingEvidence'],
+    },
+    trellis: {
+      scenario: fixture.ai_trace.metadata?.['scenario'],
+      failureType: fixture.ai_trace.classification?.['failure_type'],
+    },
+  };
+  await writeJson(resolve(outDir, 'observability-install-result.json'), result);
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  return 0;
+}
+
+try {
+  process.exitCode = await main();
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}\n`);
+  process.exitCode = 1;
+}