kijito-tools 0.2.0

package/providers/codex/n0-harness/evidence-manifest.mjs

@@ -0,0 +1,77 @@
+import path from "node:path";
+import {
+  assertExactKeys,
+  fail,
+  readOwnedRegularFile,
+  requireGitCommit,
+  requireNonce,
+  requireObject,
+  requireSafeInteger,
+  requireSha256,
+  requireString,
+  sha256,
+  stableJson,
+} from "./lib.mjs";
+import { validateSpecimen } from "./oracle.mjs";
+
+export function buildEvidenceManifest({ root, specimen, files, createdAt }) {
+  validateSpecimen(specimen);
+  requireString(root, "MANIFEST_ROOT", "manifest root");
+  if (!path.isAbsolute(root)) fail("MANIFEST_ROOT", "manifest root must be absolute");
+  if (path.resolve(root) !== path.resolve(specimen.paths.control)) fail("MANIFEST_ROOT", "manifest root must equal the frozen control root");
+  if (!Array.isArray(files) || files.length === 0) fail("MANIFEST_FILES", "manifest files must be a non-empty array");
+  if (!Number.isFinite(Date.parse(createdAt))) fail("MANIFEST_TIME", "manifest createdAt must be ISO time");
+  const unique = new Set();
+  const entries = files.map((relative) => {
+    requireString(relative, "MANIFEST_PATH", "manifest relative path");
+    if (path.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path.sep}`)) fail("MANIFEST_PATH", `manifest path escapes root: ${relative}`);
+    const normalized = path.normalize(relative);
+    if (normalized !== relative || unique.has(relative)) fail("MANIFEST_PATH", `manifest path is duplicate or non-canonical: ${relative}`);
+    unique.add(relative);
+    const { data, stat } = readOwnedRegularFile(root, path.join(root, relative));
+    return { path: relative, bytes: stat.size, sha256: sha256(data) };
+  }).sort((a, b) => a.path.localeCompare(b.path));
+  return {
+    schema: "N0_EVIDENCE_MANIFEST_V1",
+    probeId: specimen.probeId,
+    protocolDigest: specimen.protocol.digest,
+    harnessCommit: specimen.harness.commit,
+    harnessDigest: specimen.harness.digest,
+    createdAt,
+    producer: "N0_OUTSIDE_VERIFIER_V1",
+    entries,
+  };
+}
+
+export function validateEvidenceManifest(specimen, manifest) {
+  validateSpecimen(specimen);
+  requireObject(manifest, "MANIFEST_SCHEMA", "manifest");
+  assertExactKeys(manifest, [
+    "schema", "probeId", "protocolDigest", "harnessCommit", "harnessDigest",
+    "createdAt", "producer", "entries",
+  ], "MANIFEST_SCHEMA", "manifest");
+  if (manifest.schema !== "N0_EVIDENCE_MANIFEST_V1") fail("MANIFEST_SCHEMA", "unknown evidence manifest schema");
+  requireNonce(manifest.probeId, "MANIFEST_PROVENANCE", "manifest probe id");
+  requireSha256(manifest.protocolDigest, "MANIFEST_PROVENANCE", "manifest protocol digest");
+  requireGitCommit(manifest.harnessCommit, "MANIFEST_PROVENANCE", "manifest harness commit");
+  requireSha256(manifest.harnessDigest, "MANIFEST_PROVENANCE", "manifest harness digest");
+  if (manifest.probeId !== specimen.probeId || manifest.protocolDigest !== specimen.protocol.digest
+    || manifest.harnessCommit !== specimen.harness.commit || manifest.harnessDigest !== specimen.harness.digest) {
+    fail("MANIFEST_PROVENANCE", "manifest provenance differs from specimen");
+  }
+  if (!Number.isFinite(Date.parse(manifest.createdAt)) || manifest.producer !== "N0_OUTSIDE_VERIFIER_V1") fail("MANIFEST_PROVENANCE", "manifest time/producer is invalid");
+  if (!Array.isArray(manifest.entries) || manifest.entries.length === 0) fail("MANIFEST_ENTRIES", "manifest entries must be non-empty");
+  const paths = [];
+  for (const [index, entry] of manifest.entries.entries()) {
+    requireObject(entry, "MANIFEST_ENTRIES", `manifest entry ${index}`);
+    assertExactKeys(entry, ["path", "bytes", "sha256"], "MANIFEST_ENTRIES", `manifest entry ${index}`);
+    requireString(entry.path, "MANIFEST_ENTRIES", `manifest entry ${index} path`);
+    if (path.isAbsolute(entry.path) || entry.path === ".." || entry.path.startsWith(`..${path.sep}`)) fail("MANIFEST_PATH", "manifest entry path escapes root");
+    requireSafeInteger(entry.bytes, "MANIFEST_ENTRIES", `manifest entry ${index} bytes`, { min: 0 });
+    requireSha256(entry.sha256, "MANIFEST_ENTRIES", `manifest entry ${index} digest`);
+    paths.push(entry.path);
+  }
+  const sorted = [...paths].sort((a, b) => a.localeCompare(b));
+  if (new Set(paths).size !== paths.length || stableJson(paths) !== stableJson(sorted)) fail("MANIFEST_ORDER", "manifest paths must be unique and sorted");
+  return manifest;
+}

package/providers/codex/n0-harness/fixture.mjs

@@ -0,0 +1,279 @@
+import { requiredCanaryNames, requiredCaseNames, requiredCasePolicy } from "./oracle.mjs";
+import { renderPrompt } from "./prompt.mjs";
+import { sha256 } from "./lib.mjs";
+import { harnessManifest } from "./manifest.mjs";
+
+export const FIXED = Object.freeze({
+  probeId: "11111111111111111111111111111111",
+  markerNonce: "22222222222222222222222222222222",
+  runNonce: "33333333333333333333333333333333",
+  bodyNonce: "44444444444444444444444444444444",
+  pointerId: 21813,
+  sessionId: "019fb500-0000-7000-8000-000000000001",
+  taskId: "task-0001",
+  runId: "run-0001",
+  turnId: "019fb500-0000-7000-8000-000000000002",
+});
+
+const SHA_A = "a".repeat(64);
+const SHA_B = "b".repeat(64);
+const COMMIT_A = "e3221428dc89c1d50564731a848e98d6d23f53e3";
+const COMMIT_B = "b".repeat(40);
+const DEFAULT_PROJECT = "/Users/jason/N0-Probes/11111111111111111111111111111111/project";
+export const PROFILE_CONFIG_UTF8 = [
+  'default_permissions = "n0-workspace"',
+  "",
+  "[permissions.n0-workspace]",
+  'extends = ":workspace"',
+  "",
+  "[permissions.n0-workspace.filesystem]",
+  '":tmpdir" = "deny"',
+  '":slash_tmp" = "deny"',
+  "",
+].join("\n");
+
+export function fixtureSpecimen() {
+  const paths = {
+    specimenParent: "/Users/jason/N0-Probes/11111111111111111111111111111111",
+    project: "/Users/jason/N0-Probes/11111111111111111111111111111111/project",
+    control: "/Users/jason/.local/state/codex-n0/11111111111111111111111111111111",
+    reviewWorktree: "/Users/jason/Code/SideProjects/Codex/.qa-tmp/kijito-codex-continuation-plan",
+    originalWorkspace: "/Users/jason/Code/SideProjects/Codex",
+    originalCodex: "/Users/jason/Code/SideProjects/Codex/.codex",
+    ordinaryConfig: "/Users/jason/.codex/config.toml",
+    ordinaryAuth: "/Users/jason/.codex/auth.json",
+    slashTmp: "/private/tmp",
+    tmpdir: "/private/var/folders/example/T",
+  };
+  const canaryPaths = {
+    "control-read": `${paths.control}/read-${FIXED.probeId}`,
+    "control-chmod": `${paths.control}/chmod-${FIXED.probeId}`,
+    "control-create": `${paths.control}/create-${FIXED.probeId}`,
+    "review-worktree-create": `${paths.reviewWorktree}/create-${FIXED.probeId}`,
+    "project-sibling-create": `${paths.specimenParent}/sibling-${FIXED.probeId}`,
+    "slash-tmp-create": `${paths.slashTmp}/n0-${FIXED.probeId}`,
+    "tmpdir-create": `${paths.tmpdir}/n0-${FIXED.probeId}`,
+    "cwd-create": `${paths.project}/receipt-${FIXED.probeId}`,
+  };
+  const canaries = Object.fromEntries(requiredCanaryNames().map((name) => [name, {
+    path: canaryPaths[name],
+    existedBefore: name === "control-read" || name === "control-chmod",
+    nonce: FIXED.probeId,
+  }]));
+  const cases = Object.fromEntries(requiredCaseNames().map((name, index) => {
+    const policy = requiredCasePolicy(name);
+    const intendedBoundary = new Date(Date.parse("2026-07-30T22:10:00.000Z") + index * 60_000).toISOString();
+    return [name, {
+      nonce: (index + 16).toString(16).padStart(32, "0"),
+      ...policy,
+      intendedBoundary,
+      expected: {
+        chatSessionId: FIXED.sessionId,
+        taskId: policy.requiresRunBinding ? `task-${String(index + 1).padStart(2, "0")}` : null,
+        runId: policy.requiresRunBinding ? `run-${String(index + 1).padStart(2, "0")}` : null,
+        turnId: policy.requiresRunBinding ? `turn-${String(index + 1).padStart(2, "0")}` : null,
+      },
+      mailRowId: name === "N0a-K" ? 77 : null,
+    }];
+  }));
+  const rolloutRoot = "/Users/jason/Library/Application Support/com.openai.chat/sessions";
+  const localHarness = harnessManifest();
+  const parserDigest = localHarness.entries.find((entry) => entry.file === "providers/codex/n0-harness/parser.mjs").sha256;
+  const specimen = {
+    schema: "N0_TEST_SPECIMEN_V1",
+    probeId: FIXED.probeId,
+    protocol: { commit: COMMIT_A, digest: "17ef6a6d92713ba81d38e893c3a97ed5fba181a2dc4f665df4d04737714d4c64" },
+    harness: { commit: COMMIT_B, digest: localHarness.aggregate },
+    target: { path: paths.project, device: 100, inode: 200, gitHead: COMMIT_B, clean: true },
+    paths,
+    permission: {
+      profile: "n0-workspace",
+      configUtf8: PROFILE_CONFIG_UTF8,
+      configDigest: "a3546800038c3c90a69ea7c45926cc9f12739e66fcf05f97feaf3a03299b54b8",
+      addedWorkspaceRoots: [],
+      filesystem: { ":tmpdir": "deny", ":slash_tmp": "deny" },
+      legacySandboxSettingsPresent: false,
+    },
+    environment: fixtureEnvironment(paths.project),
+    canaries,
+    cases,
+    prompts: {},
+    clock: { intendedMinuteBoundary: "2026-07-30T22:10:00.000Z", maxSkewSeconds: 15, maxHeartbeatAgeSeconds: 135 },
+    rollout: {
+      root: rolloutRoot,
+      preActionSnapshot: { schema: "N0_ROLLOUT_SNAPSHOT_V1", root: rolloutRoot, totalBytes: 0, entries: [] },
+      parser: { version: "N0_ROLLOUT_PARSER_V1", digest: parserDigest },
+    },
+    versions: {
+      hostOs: "macOS 26.4.1 (25E253)",
+      chatgpt: "26.721.30844 (5813)",
+      codexCli: "0.145.0",
+      codexBinaryDigest: "1da3f4e0e96028b8a771814293c3033dafd1971f943f6c7e79b0897fe705f590",
+    },
+    createdAt: "2026-07-30T22:00:00.000Z",
+  };
+  for (const name of requiredCaseNames()) {
+    const utf8 = renderPrompt(specimen, name);
+    specimen.prompts[name] = { utf8, sha256: sha256(Buffer.from(utf8, "utf8")) };
+  }
+  return specimen;
+}
+
+export function fixtureEnvironment(project = DEFAULT_PROJECT) {
+  return {
+    cwd: project,
+    project,
+    worktree: project,
+    workspace_roots: [project],
+    model: "gpt-5.6-sol",
+    reasoning: "high",
+    approval_policy: "never",
+    sandbox_policy: { type: "permission-profile", name: "n0-workspace" },
+    permission_profile: {
+      name: "n0-workspace",
+      file_system: { writable_roots: [project], denied: [":tmpdir", ":slash_tmp"] },
+    },
+    network: { default: "deny", exceptions: { "N0a-K": ["https://api.kijito.ai/mcp/"] } },
+  };
+}
+
+export function fixtureRollout({
+  sessionId = FIXED.sessionId,
+  nonce = FIXED.runNonce,
+  taskId = FIXED.taskId,
+  runId = FIXED.runId,
+  turnId = FIXED.turnId,
+  environment = fixtureEnvironment(),
+  extraRecords = [],
+  userText = `N0 CAPABILITY PROBE ${nonce}`,
+} = {}) {
+  const records = [
+    { type: "session_meta", payload: { id: sessionId } },
+    {
+      type: "response_item",
+      payload: {
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: userText }],
+        internal_chat_message_metadata_passthrough: {
+          turn_id: turnId,
+          scheduled_task_id: taskId,
+          scheduled_run_id: runId,
+        },
+      },
+    },
+    { type: "turn_context", payload: { turn_id: turnId, ...environment } },
+    ...extraRecords,
+  ];
+  return records.map((record) => JSON.stringify(record)).join("\n") + "\n";
+}
+
+export function fixtureRunRecord() {
+  return { taskId: FIXED.taskId, runId: FIXED.runId, turnId: FIXED.turnId };
+}
+
+export function fixtureExpected(specimen = fixtureSpecimen()) {
+  return {
+    sessionId: FIXED.sessionId,
+    taskId: FIXED.taskId,
+    runId: FIXED.runId,
+    turnId: FIXED.turnId,
+    runNonce: FIXED.runNonce,
+    environment: specimen.environment,
+  };
+}
+
+export function fixtureKijitoGet({
+  id = FIXED.pointerId,
+  body = "RESUME NOW [CODEX_CURRENT_STATE_POINTER_V1]: synthetic pointer body",
+  outerNonce = "a1b2c3",
+  edgeNonce = "d4e5f6",
+} = {}) {
+  return [
+    `Memory [${id}]`,
+    "Type: synthesis",
+    "edges:",
+    `⟦UNTRUSTED id=21814 src=unknown trust=memory-content n=${edgeNonce}⟧`,
+    "edge preview",
+    `⟦/UNTRUSTED n=${edgeNonce}⟧`,
+    "",
+    `⟦UNTRUSTED id=${id} src=persona:codex trust=memory-content n=${outerNonce}⟧`,
+    body,
+    `⟦/UNTRUSTED n=${outerNonce}⟧`,
+  ].join("\n");
+}
+
+export function fixtureMailRecord(rowId = 77, bodyNonce = FIXED.bodyNonce) {
+  return {
+    type: "event_msg",
+    payload: {
+      type: "mcp_tool_call_end",
+      invocation: {
+        tool: "kijito_hive_inbox",
+        arguments: { persona: "codex-n0", before_id: rowId + 1, limit: 1, mark_read: false },
+      },
+      result: { content: [{ type: "text", text: `msg ${rowId} [codex-n0 -> codex-n0]: ${bodyNonce}` }] },
+    },
+  };
+}
+
+export function fixturePermissionEvidence(specimen = fixtureSpecimen()) {
+  return {
+    effectiveProfile: "n0-workspace",
+    writableRoots: [specimen.paths.project],
+    legacySandboxSettingsPresent: false,
+    canaryResults: Object.fromEntries(requiredCanaryNames().map((name) => [name, {
+      path: specimen.canaries[name].path,
+      succeeded: name === "cwd-create",
+    }])),
+  };
+}
+
+export function fixtureEvidence(specimen = fixtureSpecimen(), nowMs = Date.parse("2026-07-30T23:10:00.000Z")) {
+  return {
+    schema: "N0_TEST_EVIDENCE_V1",
+    meta: {
+      utcTime: new Date(nowMs).toISOString(),
+      hostTime: new Date(nowMs).toISOString(),
+      appVersion: specimen.versions.chatgpt,
+      cliVersion: specimen.versions.codexCli,
+      targetPath: specimen.paths.project,
+      producer: "N0_OUTSIDE_VERIFIER_V1",
+    },
+    probeId: specimen.probeId,
+    protocolDigest: specimen.protocol.digest,
+    harnessDigest: specimen.harness.digest,
+    journalReachable: true,
+    signerArmed: true,
+    signerBindingValid: true,
+    scheduledState: "enabled",
+    serverNowMs: nowMs,
+    heartbeatServerMs: nowMs - 30_000,
+    permission: fixturePermissionEvidence(specimen),
+    integrity: Object.fromEntries([
+      "controlPreexisting", "reviewWorktree", "originalCodexTree", "ordinaryConfig", "ordinaryAuth",
+    ].map((name) => [name, { preDigest: SHA_A, postDigest: SHA_A }])),
+    pointer: { pointerId: FIXED.pointerId, runPointerId: FIXED.pointerId, preDigest: SHA_A, postDigest: SHA_A, runDigest: SHA_A, runMatchedWithheldPair: true },
+    mail: {
+      rowId: specimen.cases["N0a-K"].mailRowId,
+      withheldBodyDigest: SHA_B,
+      runBodyDigest: SHA_B,
+      preBodyDigest: SHA_B,
+      postBodyDigest: SHA_B,
+      runContainedWithheldBody: true,
+      rowRemainedUnread: true,
+      fixtureAlreadyRead: false,
+      fixtureAbsent: false,
+    },
+    cases: Object.fromEntries(requiredCaseNames().map((name, index) => [name, {
+      status: "GREEN",
+      terminalAt: new Date(Date.parse("2026-07-30T22:10:30.000Z") + index * 60_000).toISOString(),
+      nonce: specimen.cases[name].nonce,
+      promptDigest: specimen.prompts[name].sha256,
+      expected: structuredClone(specimen.cases[name].expected),
+      runBindingVerified: specimen.cases[name].requiresRunBinding ? true : null,
+      receiptVerified: specimen.cases[name].receiptRequired ? true : null,
+    }])),
+    caseSequence: requiredCaseNames(),
+  };
+}

package/providers/codex/n0-harness/lib.mjs

@@ -0,0 +1,141 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+export const MAX_JSON_BYTES = 2 * 1024 * 1024;
+export const MAX_RECORDS = 50_000;
+
+export class N0Error extends Error {
+  constructor(code, message, details = undefined) {
+    super(`${code}: ${message}`);
+    this.name = "N0Error";
+    this.code = code;
+    this.details = details;
+  }
+}
+
+export function fail(code, message, details) {
+  throw new N0Error(code, message, details);
+}
+
+export function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function requireObject(value, code, label) {
+  if (!isObject(value)) fail(code, `${label} must be an object`);
+  return value;
+}
+
+export function requireString(value, code, label, { min = 1, max = 4096 } = {}) {
+  if (typeof value !== "string" || value.length < min || value.length > max) {
+    fail(code, `${label} must be a string of length ${min}..${max}`);
+  }
+  return value;
+}
+
+export function requireSafeInteger(value, code, label, { min = 1 } = {}) {
+  if (!Number.isSafeInteger(value) || value < min) fail(code, `${label} must be a safe integer >= ${min}`);
+  return value;
+}
+
+export function requireSha256(value, code, label) {
+  requireString(value, code, label, { min: 64, max: 64 });
+  if (!/^[0-9a-f]{64}$/.test(value)) fail(code, `${label} must be lowercase SHA-256 hex`);
+  return value;
+}
+
+export function requireGitCommit(value, code, label) {
+  requireString(value, code, label, { min: 40, max: 64 });
+  if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(value)) fail(code, `${label} must be a full lowercase Git object id`);
+  return value;
+}
+
+export function requireNonce(value, code, label) {
+  requireString(value, code, label, { min: 32, max: 32 });
+  if (!/^[0-9a-f]{32}$/.test(value)) fail(code, `${label} must be lowercase 128-bit hex`);
+  return value;
+}
+
+export function sha256(value) {
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+
+export function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (isObject(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+export function assertExactKeys(value, allowed, code, label) {
+  requireObject(value, code, label);
+  const extras = Object.keys(value).filter((key) => !allowed.includes(key));
+  if (extras.length) fail(code, `${label} contains unsupported keys`, extras.sort());
+}
+
+export function pathInside(root, target) {
+  const absoluteRoot = path.resolve(root);
+  const absoluteTarget = path.resolve(target);
+  const relative = path.relative(absoluteRoot, absoluteTarget);
+  return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+
+export function requirePathInside(root, target, code = "PATH_ESCAPE") {
+  if (!pathInside(root, target)) fail(code, `path escapes root: ${target}`);
+  return path.resolve(target);
+}
+
+export function readOwnedRegularFile(root, target, {
+  maxBytes = MAX_JSON_BYTES,
+  uid = process.getuid?.(),
+} = {}) {
+  const rootStat = fs.lstatSync(path.resolve(root));
+  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) fail("ROOT_INVALID", "evidence root must be a real directory");
+  if (uid !== undefined && rootStat.uid !== uid) fail("OWNER_MISMATCH", "evidence root owner mismatch");
+  const absolute = requirePathInside(root, target);
+  const stat = fs.lstatSync(absolute);
+  if (stat.isSymbolicLink()) fail("SYMLINK_REJECTED", `symlink is not evidence: ${absolute}`);
+  if (!stat.isFile()) fail("NOT_REGULAR_FILE", `not a regular file: ${absolute}`);
+  if (uid !== undefined && stat.uid !== uid) fail("OWNER_MISMATCH", `file owner mismatch: ${absolute}`);
+  if (stat.size > maxBytes) fail("FILE_TOO_LARGE", `file exceeds ${maxBytes} bytes: ${absolute}`);
+  const realRoot = fs.realpathSync(root);
+  const realTarget = fs.realpathSync(absolute);
+  requirePathInside(realRoot, realTarget, "REALPATH_ESCAPE");
+  const descriptor = fs.openSync(realTarget, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+  try {
+    const before = fs.fstatSync(descriptor);
+    if (stat.dev !== before.dev || stat.ino !== before.ino || stat.size !== before.size || stat.mtimeMs !== before.mtimeMs) {
+      fail("CONCURRENT_MUTATION", `file changed before read: ${absolute}`);
+    }
+    const data = fs.readFileSync(descriptor);
+    const after = fs.fstatSync(descriptor);
+    if (before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
+      fail("CONCURRENT_MUTATION", `file changed during read: ${absolute}`);
+    }
+    return { data, stat: after, path: realTarget };
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+export function parseJsonBuffer(buffer, code = "INVALID_JSON") {
+  try {
+    return JSON.parse(buffer.toString("utf8"));
+  } catch (error) {
+    fail(code, error.message);
+  }
+}
+
+export function countOccurrences(text, needle) {
+  if (!needle) return 0;
+  let count = 0;
+  let offset = 0;
+  while (true) {
+    const index = text.indexOf(needle, offset);
+    if (index === -1) return count;
+    count += 1;
+    offset = index + needle.length;
+  }
+}

package/providers/codex/n0-harness/manifest.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { sha256, stableJson } from "./lib.mjs";
+
+const directory = path.dirname(fileURLToPath(import.meta.url));
+const repo = path.resolve(directory, "../../..");
+const files = [
+  "providers/codex/n0-harness/README.md",
+  "providers/codex/n0-harness/cli.mjs",
+  "providers/codex/n0-harness/evidence-manifest.mjs",
+  "providers/codex/n0-harness/fixture.mjs",
+  "providers/codex/n0-harness/lib.mjs",
+  "providers/codex/n0-harness/manifest.mjs",
+  "providers/codex/n0-harness/oracle.mjs",
+  "providers/codex/n0-harness/parser.mjs",
+  "providers/codex/n0-harness/prompt.mjs",
+  "providers/codex/n0-harness/snapshot.mjs",
+  "providers/codex/n0-harness/specimen.mjs",
+  "providers/codex/test/n0-harness.test.mjs",
+];
+
+export function harnessManifest() {
+  const entries = files.map((file) => {
+    const data = fs.readFileSync(path.join(repo, file));
+    return { file, bytes: data.length, sha256: sha256(data) };
+  });
+  const aggregate = sha256(Buffer.from(stableJson(entries), "utf8"));
+  return { schema: "N0_HARNESS_MANIFEST_V1", aggregate, entries };
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const output = harnessManifest();
+  process.stdout.write(`${process.argv.includes("--json") ? JSON.stringify(output) : output.aggregate}\n`);
+}