anti-yapping 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,3361 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync7, readdirSync as readdirSync4 } from "node:fs";
+import { join as join8, resolve as resolve6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { parseArgs } from "node:util";
+
+// src/build.ts
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, extname, join as join2, relative, resolve as resolve2, sep } from "node:path";
+import { parse, stringify } from "yaml";
+
+// src/adapters/fake.ts
+var FakeAdapter = class {
+  id = "fake";
+  capabilities = {
+    alwaysOnInstructions: true,
+    onDemandSkills: true,
+    progressiveDisclosure: true,
+    managedBlock: false,
+    toolPermissions: false,
+    hooks: false
+  };
+  render(input) {
+    const metadata = JSON.stringify(
+      {
+        name: `hahahah-${input.persona.id}`,
+        description: `${input.persona.display_name} persona for ${input.persona.locale} coding work`
+      },
+      null,
+      2
+    );
+    return [
+      {
+        path: "always-on.md",
+        content: `${input.core.trim()}
+
+${input.card.trim()}
+`,
+        kind: "always_on"
+      },
+      {
+        path: "skill-metadata.json",
+        content: `${metadata}
+`,
+        kind: "skill_metadata"
+      },
+      {
+        path: "references/voice.md",
+        content: `${input.voice.trim()}
+`,
+        kind: "skill_body"
+      },
+      {
+        path: "references/lexicon.md",
+        content: `${input.lexiconMarkdown.trim()}
+`,
+        kind: "reference"
+      },
+      ...input.coreRefs.map((reference) => ({
+        path: `references/core/${reference.path}`,
+        content: `${reference.content.trim()}
+`,
+        kind: "reference"
+      })),
+      ...input.cultureRefs.map((reference) => ({
+        path: `references/culture/${reference.path}`,
+        content: `${reference.content.trim()}
+`,
+        kind: "reference"
+      }))
+    ];
+  }
+};
+
+// src/adapters/generic.ts
+function marker(input) {
+  return `<!-- hahahah:begin profile=${input.profile.id} version=${input.persona.version} -->`;
+}
+function block(parts) {
+  return `${parts.join("\n")}
+`;
+}
+function alwaysOnBlock(input, extra = []) {
+  return block([
+    marker(input),
+    input.core.trim(),
+    "",
+    input.card.trim(),
+    ...extra,
+    "<!-- hahahah:end -->"
+  ]);
+}
+var GenericHarnessAdapter = class {
+  id;
+  scope;
+  spec;
+  constructor(spec, scope = "workspace") {
+    this.spec = spec;
+    this.id = spec.id;
+    this.scope = scope;
+  }
+  render(input) {
+    const skillName = `hahahah-${input.persona.id}`;
+    const description = `HAHahah ${input.persona.display_name} persona for ${input.persona.locale} coding work. Use when this voice is active; includes humor boundaries, serious-mode rules, and culture references.`;
+    const root = this.scope === "global" ? this.spec.globalOnDemandRoot : this.spec.onDemandRoot;
+    if (this.spec.layout === "fold") {
+      return [
+        {
+          path: this.spec.blockPath,
+          content: alwaysOnBlock(input, [
+            "",
+            "<!-- folded: this target has no on-demand layer, so the voice ships inline -->",
+            "",
+            input.voice.trim()
+          ]),
+          kind: "always_on"
+        }
+      ];
+    }
+    if (this.spec.layout === "rules-dir") {
+      const rules = [
+        {
+          path: `${root}/${skillName}-voice.md`,
+          content: block(["---", "trigger: always_on", "---", "", input.voice.trim()]),
+          kind: "skill_body"
+        },
+        {
+          path: `${root}/${skillName}-lexicon.md`,
+          content: block([
+            "---",
+            "trigger: model_decision",
+            `description: "HAHahah ${input.persona.display_name} lexicon: Indonesian slang, register, and internet-culture terms."`,
+            "---",
+            "",
+            input.lexiconMarkdown.trim()
+          ]),
+          kind: "reference"
+        },
+        ...input.coreRefs.map((reference) => ({
+          path: `${root}/${skillName}-core-${reference.path}`,
+          content: block([
+            "---",
+            "trigger: model_decision",
+            `description: "HAHahah core policy ${reference.path}: identity, safety, decision, efficiency rules that outrank persona tone."`,
+            "---",
+            "",
+            reference.content.trim()
+          ]),
+          kind: "reference"
+        })),
+        ...input.cultureRefs.map((reference) => ({
+          path: `${root}/${skillName}-culture-${reference.path}`,
+          content: block([
+            "---",
+            "trigger: model_decision",
+            `description: "HAHahah culture reference ${reference.path}: Indonesian humor boundaries, memes, registers, religious-expression etiquette."`,
+            "---",
+            "",
+            reference.content.trim()
+          ]),
+          kind: "reference"
+        }))
+      ];
+      return [
+        {
+          path: this.spec.blockPath,
+          content: alwaysOnBlock(input, [
+            "",
+            `Voice detail, lexicon, kebijakan penuh, dan referensi budaya ada di \`${root}/\` sebagai rules; yang selalu termuat cuma voice.`
+          ]),
+          kind: "always_on"
+        },
+        ...rules
+      ];
+    }
+    const references = [
+      {
+        path: `${root}/${skillName}/references/lexicon.md`,
+        content: `${input.lexiconMarkdown.trim()}
+`,
+        kind: "reference"
+      },
+      ...input.coreRefs.map((reference) => ({
+        path: `${root}/${skillName}/references/core/${reference.path}`,
+        content: `${reference.content.trim()}
+`,
+        kind: "reference"
+      })),
+      ...input.cultureRefs.map((reference) => ({
+        path: `${root}/${skillName}/references/culture/${reference.path}`,
+        content: `${reference.content.trim()}
+`,
+        kind: "reference"
+      }))
+    ];
+    return [
+      { path: this.spec.blockPath, content: alwaysOnBlock(input), kind: "always_on" },
+      {
+        path: `${root}/${skillName}/SKILL.md`,
+        content: block([
+          "---",
+          `name: ${skillName}`,
+          `description: ${JSON.stringify(description)}`,
+          "---",
+          "",
+          input.voice.trim(),
+          "",
+          "Load `references/lexicon.md` for terms, `references/core/*.md` for the full identity, safety, decision, and efficiency policies, and `references/culture/*` for humor boundaries and regional guidance. Read a reference only when the task needs it."
+        ]),
+        kind: "skill_body"
+      },
+      ...references
+    ];
+  }
+};
+
+// src/harnesses.ts
+var HARNESS_SPECS = [
+  {
+    id: "claude-code",
+    layout: "skill-tree",
+    blockPath: "CLAUDE.md",
+    onDemandRoot: ".claude/skills",
+    globalOnDemandRoot: null,
+    alwaysOnTarget: null,
+    alwaysOnHardCap: null,
+    status: "verified on this machine",
+    source: "https://code.claude.com/docs/en/skills",
+    notes: [
+      "Reference target: install, doctor, uninstall, headless run and permission posture all measured here.",
+      "Docs list AGENTS.md only as a fallback when no CLAUDE.md exists, so the block belongs in CLAUDE.md."
+    ]
+  },
+  {
+    id: "opencode",
+    layout: "skill-tree",
+    blockPath: "AGENTS.md",
+    onDemandRoot: ".claude/skills",
+    globalOnDemandRoot: null,
+    alwaysOnTarget: null,
+    alwaysOnHardCap: null,
+    status: "verified on this machine",
+    source: "opencode 1.18.31: `debug skill` listed the installed skill; a live run echoed the AGENTS.md marker",
+    notes: [
+      "opencode discovers the Claude-compatible skill tree, so reusing .claude/skills avoids a second copy under .opencode/.",
+      'Permissions are NOT written here: opencode defaults the build agent to "*": allow, and dropping an opencode.json into a user repo would silently widen what an install does. The study posture lives in the runner instead (OPENCODE_CONFIG).'
+    ]
+  },
+  {
+    id: "agents-md",
+    layout: "skill-tree",
+    blockPath: "AGENTS.md",
+    onDemandRoot: ".agents/skills",
+    globalOnDemandRoot: null,
+    alwaysOnTarget: null,
+    alwaysOnHardCap: null,
+    status: "documented, not verified",
+    source: "https://agentskills.io/specification",
+    notes: [
+      "Vendor-neutral target for Codex and Cursor, both of which document .agents/skills.",
+      "No Cursor or Codex run on this machine has read the output; the paths follow the published standard."
+    ]
+  },
+  {
+    id: "antigravity",
+    layout: "rules-dir",
+    blockPath: "AGENTS.md",
+    onDemandRoot: ".agents/rules",
+    globalOnDemandRoot: "config/rules",
+    alwaysOnTarget: null,
+    alwaysOnHardCap: null,
+    status: "documented, not verified",
+    source: "https://antigravity.google/docs/rules/",
+    notes: [
+      "Rules files need a `trigger` in frontmatter: always_on injects the whole file every turn, model_decision injects only its description until the model opens it.",
+      "Documented ceilings are 24KB per file and a 20k-token rule budget; nothing here approaches them.",
+      "`opencode debug agent` style introspection does not reflect this layout, so loading has never been observed."
+    ]
+  },
+  {
+    id: "qoder",
+    layout: "skill-tree",
+    blockPath: "AGENTS.md",
+    onDemandRoot: ".qoder/skills",
+    globalOnDemandRoot: null,
+    alwaysOnTarget: null,
+    alwaysOnHardCap: null,
+    status: "documented, not verified",
+    source: "https://docs.qoder.com/cli/Skills",
+    notes: [
+      "Docs give memory as <project>/AGENTS.md plus .qoder/rules/, and skills as .qoder/skills/<name>/SKILL.md.",
+      "The skills page does not claim adherence to the open Agent Skills standard, and auto-trigger is unverified; user-level skills also override project-level ones on a name clash.",
+      "Qoder Desktop was not on PATH for any run in this repository, so no Qoder integration has been executed."
+    ]
+  },
+  {
+    id: "copilot",
+    layout: "fold",
+    blockPath: ".github/copilot-instructions.md",
+    onDemandRoot: null,
+    globalOnDemandRoot: null,
+    // core + card + voice measured at 2342 tokens on rusuh-id; the global 600 ceiling describes a
+    // card-only block and would be a lie here.
+    alwaysOnTarget: 2650,
+    alwaysOnHardCap: 3e3,
+    status: "documented, not verified",
+    source: "https://docs.github.com/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot",
+    notes: [
+      "AGENTS.md is supported for the coding agent (github.blog changelog 2025-08-28), but skill support is not documented, so the voice has nowhere to live except the instructions file itself.",
+      "Precedence is the reason this is not the reference target: personal instructions outrank repository instructions, so a safety-sensitive layer cannot rely on being the last word.",
+      "Folding costs the full voice on every turn \u2014 the build warns about it rather than hiding it."
+    ]
+  }
+];
+function harnessSpec(id) {
+  return HARNESS_SPECS.find((spec) => spec.id === id);
+}
+
+// src/budget.ts
+function evaluateBudget(spec, tokens) {
+  let status = "ok";
+  if (tokens > spec.hardCap) {
+    status = "error";
+  } else if (tokens > spec.target) {
+    status = "warning";
+  }
+  return { ...spec, tokens, status };
+}
+
+// src/schema.ts
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import Ajv from "ajv";
+var defaultPackageRoot = resolve(fileURLToPath(import.meta.url), "..", "..");
+var schemaFiles = {
+  profile: "profile.schema.json",
+  persona: "persona.schema.json",
+  culture: "culture.schema.json",
+  memes: "memes.schema.json",
+  registers: "register-map.schema.json",
+  lexicon: "lexicon.schema.json",
+  config: "config.schema.json",
+  manifest: "manifest.schema.json",
+  install: "install-manifest.schema.json",
+  evalSuite: "eval-suite.schema.json",
+  codingFixture: "coding-fixture.schema.json"
+};
+var validators = /* @__PURE__ */ new Map();
+var SchemaValidationError = class extends Error {
+  issues;
+  source;
+  constructor(source, issues) {
+    super(`Schema validation failed for ${source}:
+${issues.join("\n")}`);
+    this.name = "SchemaValidationError";
+    this.source = source;
+    this.issues = issues;
+  }
+};
+function validate(name, data, source = "inline", root = defaultPackageRoot) {
+  const key = `${root}:${name}`;
+  let compiled = validators.get(key);
+  if (!compiled) {
+    const schemaPath = join(root, "schemas", schemaFiles[name]);
+    const schema = JSON.parse(readFileSync(schemaPath, "utf8"));
+    const AjvCtor = Ajv;
+    const ajv = new AjvCtor({ allErrors: true, strict: false });
+    compiled = ajv.compile(schema);
+    validators.set(key, compiled);
+  }
+  if (!compiled(data)) {
+    const issues = (compiled.errors ?? []).map((error) => {
+      const location = error.instancePath || "/";
+      const property = error.params && typeof error.params === "object" && "missingProperty" in error.params ? ` (${String(error.params.missingProperty)})` : "";
+      return `${location}${property} ${error.message ?? "invalid value"}`.trim();
+    });
+    throw new SchemaValidationError(source, issues);
+  }
+}
+
+// src/tokenizer.ts
+import { countTokens as countWithO200k } from "gpt-tokenizer";
+var TOKENIZER_PROFILE = "o200k_base";
+function countTokens(text) {
+  return countWithO200k(text);
+}
+
+// src/build.ts
+var ADAPTERS = {
+  fake: () => new FakeAdapter(),
+  ...Object.fromEntries(
+    HARNESS_SPECS.map((spec) => [
+      spec.id,
+      (scope) => new GenericHarnessAdapter(spec, scope)
+    ])
+  )
+};
+var CORE_POLICY_FILES = ["00-identity.md", "10-safety.md", "20-decision.md", "30-efficiency.md"];
+var HARD_CAPS = {
+  always_on: 600,
+  skill_metadata: 120,
+  skill_body: 2e3,
+  references: 5e3
+};
+var BuildError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BuildError";
+  }
+};
+function sha256(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function readText(path) {
+  return readFileSync2(path, "utf8").replace(/\r\n/g, "\n");
+}
+function readYaml(path) {
+  return parse(readText(path));
+}
+function resolveInside(base, child) {
+  const basePath = resolve2(base);
+  const target = resolve2(basePath, child);
+  const prefix = basePath.endsWith(sep) ? basePath : `${basePath}${sep}`;
+  if (target !== basePath && !target.startsWith(prefix)) {
+    throw new BuildError(`Refusing path outside ${relative(process.cwd(), basePath)}: ${child}`);
+  }
+  return target;
+}
+function readNonEmpty(path, label) {
+  const value = readText(path).trim();
+  if (!value) {
+    throw new BuildError(`${label} is empty: ${path}`);
+  }
+  return value;
+}
+function loadProfile(root, id) {
+  const path = join2(root, "profiles", `${id}.yaml`);
+  const data = readYaml(path);
+  validate("profile", data, `profiles/${id}.yaml`, root);
+  return data;
+}
+function loadPersona(root, id) {
+  const path = join2(root, "personas", id, "persona.yaml");
+  const data = readYaml(path);
+  validate("persona", data, `personas/${id}/persona.yaml`, root);
+  return data;
+}
+function loadPersonaLexicon(root, persona) {
+  const path = resolveInside(join2(root, "personas", persona.id), persona.lexicon);
+  const data = readYaml(path);
+  validate("lexicon", data, `personas/${persona.id}/${persona.lexicon}`, root);
+  const lexicon = data;
+  if (lexicon.persona !== persona.id) {
+    throw new BuildError(`Lexicon persona ${lexicon.persona} does not match ${persona.id}`);
+  }
+  return lexicon;
+}
+function loadCultureRef(root, ref) {
+  const path = resolveInside(join2(root, "culture"), ref);
+  const content = readNonEmpty(path, `Culture reference ${ref}`);
+  const extension = extname(path).toLowerCase();
+  if (extension === ".yaml" || extension === ".yml") {
+    const data = readYaml(path);
+    const schema = data?.schema;
+    if (schema === "hahahah.culture.lexicon/v1") {
+      validate("culture", data, `culture/${ref}`, root);
+      return { path: ref, content, parsed: data };
+    }
+    if (schema === "hahahah.culture.memes/v1") {
+      validate("memes", data, `culture/${ref}`, root);
+      return { path: ref, content, parsed: data };
+    }
+    if (schema === "hahahah.culture.registers/v1") {
+      validate("registers", data, `culture/${ref}`, root);
+      return { path: ref, content, parsed: data };
+    }
+    throw new BuildError(`Unknown culture schema in culture/${ref}`);
+  }
+  return { path: ref, content };
+}
+function reviewIssues(persona, cultureFiles, memeFiles, registerFiles) {
+  const issues = [];
+  for (const [name, state] of Object.entries(persona.reviews)) {
+    if (name !== "reviewed_at" && state !== "approved") {
+      issues.push(`persona ${persona.id}: ${name} review is ${String(state)}`);
+    }
+  }
+  for (const culture of cultureFiles) {
+    if (culture.reviewed_by !== "approved") {
+      issues.push(`culture ${culture.locale}: reviewed_by is ${culture.reviewed_by}`);
+    }
+  }
+  for (const memes of memeFiles) {
+    if (memes.reviewed_by !== "approved") {
+      issues.push(`meme notes: reviewed_by is ${memes.reviewed_by}`);
+    }
+  }
+  for (const registers of registerFiles) {
+    if (registers.reviewed_by !== "approved") {
+      issues.push(`register map ${registers.locale}: reviewed_by is ${registers.reviewed_by}`);
+    }
+  }
+  return issues;
+}
+function expiryIssues(persona, reviewables, today) {
+  const issues = [];
+  if (persona.expires < today) {
+    issues.push(`persona ${persona.id} expired on ${persona.expires}`);
+  }
+  for (const culture of reviewables) {
+    if (culture.next_review < today) {
+      issues.push(`culture review expired on ${culture.next_review}`);
+    }
+    for (const entry of culture.entries ?? []) {
+      if (entry.expires < today) {
+        issues.push(`culture entry ${entry.id} expired on ${entry.expires}`);
+      }
+    }
+  }
+  return issues;
+}
+function renderLexicon(persona, lexicon) {
+  const lines = [
+    `# ${persona.display_name} lexicon references`,
+    "",
+    "Use only in the listed context; respect the cap and the global no-repetition rule.",
+    "",
+    ...lexicon.entries.map((entry) => {
+      const cap = entry.max_per_response ?? 1;
+      return `- ${entry.culture_ref}: ${entry.usage} (max ${cap} per response)`;
+    })
+  ];
+  return lines.join("\n");
+}
+var LEXICON_ENTRY_KEYS = [
+  "id",
+  "term",
+  "gloss",
+  "register",
+  "regions",
+  "decay_class",
+  "offensiveness",
+  "contexts",
+  "avoid_when",
+  "max_per_response",
+  "purpose"
+];
+var MEME_ENTRY_KEYS = ["id", "pattern", "context", "avoid_when", "note"];
+var REGISTER_KEYS = ["locale", "levels", "honorifics", "defaults", "common_errors", "banyumasan"];
+function pick(source, keys) {
+  const record = source;
+  return Object.fromEntries(keys.filter((key) => key in record).map((key) => [key, record[key]]));
+}
+function runtimeCulture(ref) {
+  const parsed = ref.parsed;
+  if (parsed === void 0) {
+    return ref.content;
+  }
+  if (parsed.schema === "hahahah.culture.lexicon/v1") {
+    return stringify({
+      schema: parsed.schema,
+      locale: parsed.locale,
+      entries: parsed.entries.map((entry) => pick(entry, LEXICON_ENTRY_KEYS))
+    });
+  }
+  if (parsed.schema === "hahahah.culture.memes/v1") {
+    return stringify({
+      schema: parsed.schema,
+      entries: parsed.entries.map((entry) => pick(entry, MEME_ENTRY_KEYS))
+    });
+  }
+  return stringify({ schema: parsed.schema, ...pick(parsed, REGISTER_KEYS) });
+}
+function measure(artifacts) {
+  return artifacts.map((artifact) => {
+    const content = artifact.content.replace(/\r\n/g, "\n");
+    return {
+      ...artifact,
+      content,
+      tokens: countTokens(content),
+      sha256: sha256(content)
+    };
+  });
+}
+function sumTokens(artifacts, kind) {
+  return artifacts.filter((artifact) => artifact.kind === kind).reduce((total, artifact) => total + artifact.tokens, 0);
+}
+function skillFrontmatterTokens(artifacts) {
+  const skill = artifacts.find((artifact) => artifact.path.endsWith("/SKILL.md"));
+  if (!skill) {
+    return 0;
+  }
+  const frontmatter = skill.content.match(/^---\n[\s\S]*?\n---\n/);
+  return frontmatter ? countTokens(frontmatter[0]) : 0;
+}
+function skillMetadataTokens(artifacts) {
+  return sumTokens(artifacts, "skill_metadata") + skillFrontmatterTokens(artifacts);
+}
+function contentHash(artifacts) {
+  const hash = createHash("sha256");
+  for (const artifact of [...artifacts].sort((a, b) => a.path.localeCompare(b.path))) {
+    hash.update(artifact.path);
+    hash.update("\0");
+    hash.update(artifact.content);
+    hash.update("\0");
+  }
+  return hash.digest("hex");
+}
+function cleanupManagedFiles(outDir, nextPaths) {
+  const manifestPath = join2(outDir, "manifest.json");
+  if (!existsSync(manifestPath)) {
+    return;
+  }
+  let old;
+  try {
+    old = JSON.parse(readFileSync2(manifestPath, "utf8"));
+  } catch {
+    throw new BuildError(`Refusing to clean unreadable manifest: ${manifestPath}`);
+  }
+  if (old.schema !== "hahahah.manifest/v1" || !Array.isArray(old.files)) {
+    throw new BuildError(`Refusing to clean unmanaged manifest: ${manifestPath}`);
+  }
+  for (const file of old.files) {
+    if (typeof file.path !== "string" || nextPaths.has(file.path)) {
+      continue;
+    }
+    const path = resolveInside(outDir, file.path);
+    if (existsSync(path)) {
+      unlinkSync(path);
+    }
+  }
+}
+function writeArtifacts(outDir, artifacts, manifest) {
+  for (const artifact of artifacts) {
+    const path = resolveInside(outDir, artifact.path);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, artifact.content, "utf8");
+  }
+  mkdirSync(outDir, { recursive: true });
+  writeFileSync(join2(outDir, "manifest.json"), `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function makeWarnings(persona, cultureFiles, review, expiry) {
+  return [
+    ...review.map((issue) => `pending review: ${issue}`),
+    ...expiry.map((issue) => `expired: ${issue}`),
+    ...cultureFiles.flatMap((culture) => culture.entries).filter((entry) => entry.purpose === "awareness").map((entry) => `awareness-only entry: ${entry.id}`)
+  ];
+}
+function build(options) {
+  const root = resolve2(options.root);
+  const profile = loadProfile(root, options.profileId);
+  if (!profile.adapters.includes(options.adapterId)) {
+    throw new BuildError(`Profile ${profile.id} does not declare adapter ${options.adapterId}`);
+  }
+  const makeAdapter = ADAPTERS[options.adapterId];
+  if (!makeAdapter) {
+    throw new BuildError(`Adapter ${options.adapterId} is not implemented`);
+  }
+  const scope = options.scope ?? "workspace";
+  const spec = harnessSpec(options.adapterId);
+  if (scope === "global") {
+    if (!spec?.globalOnDemandRoot) {
+      throw new BuildError(
+        `--scope global needs a documented user-level path: ${options.adapterId} has none (${spec ? spec.source : "not a harness row"})`
+      );
+    }
+  }
+  const adapter = makeAdapter(scope);
+  const persona = loadPersona(root, profile.persona);
+  const personaDir = join2(root, "personas", persona.id);
+  const core = readNonEmpty(join2(root, "core", "always-on.md"), "Core always-on");
+  const coreRefs = CORE_POLICY_FILES.map((name) => ({
+    path: name,
+    content: readNonEmpty(join2(root, "core", name), `Core policy ${name}`)
+  }));
+  const card = readNonEmpty(
+    resolveInside(personaDir, persona.card),
+    `Persona card ${persona.card}`
+  );
+  const voice = readNonEmpty(
+    resolveInside(personaDir, persona.voice),
+    `Persona voice ${persona.voice}`
+  );
+  const lexicon = loadPersonaLexicon(root, persona);
+  const culture = persona.culture_refs.map((ref) => loadCultureRef(root, ref));
+  const cultureFiles = culture.flatMap(
+    (ref) => ref.parsed?.schema === "hahahah.culture.lexicon/v1" ? [ref.parsed] : []
+  );
+  const memeFiles = culture.flatMap(
+    (ref) => ref.parsed?.schema === "hahahah.culture.memes/v1" ? [ref.parsed] : []
+  );
+  const registerFiles = culture.flatMap(
+    (ref) => ref.parsed?.schema === "hahahah.culture.registers/v1" ? [ref.parsed] : []
+  );
+  const artifacts = adapter.render({
+    profile,
+    persona,
+    core,
+    card,
+    voice,
+    lexiconMarkdown: renderLexicon(persona, lexicon),
+    coreRefs,
+    cultureRefs: culture.map((ref) => ({ path: ref.path, content: runtimeCulture(ref) }))
+  });
+  const measured = measure(artifacts);
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const review = reviewIssues(persona, cultureFiles, memeFiles, registerFiles);
+  const expiry = expiryIssues(persona, [...cultureFiles, ...memeFiles, ...registerFiles], today);
+  const warnings = makeWarnings(persona, cultureFiles, review, expiry);
+  if (options.release && (review.length > 0 || expiry.length > 0)) {
+    throw new BuildError(`Release build blocked:
+${[...review, ...expiry].join("\n")}`);
+  }
+  const budgetSpecs = {
+    // A folded block carries the whole voice, so the card-sized global numbers no longer
+    // describe it and the harness row states its own target and ceiling instead.
+    always_on: {
+      target: spec?.alwaysOnTarget ?? profile.budgets.always_on_tokens,
+      hardCap: spec?.alwaysOnHardCap ?? HARD_CAPS.always_on
+    },
+    skill_metadata: {
+      target: profile.budgets.skill_metadata_tokens,
+      hardCap: HARD_CAPS.skill_metadata
+    },
+    skill_body: { target: profile.budgets.skill_body_tokens, hardCap: HARD_CAPS.skill_body },
+    references: { target: profile.budgets.reference_tokens_max, hardCap: HARD_CAPS.references }
+  };
+  if (spec?.layout === "fold") {
+    warnings.push(
+      `folded layout: ${spec.id} has no on-demand layer, so the full voice is injected on every turn (always_on ceiling ${spec.alwaysOnHardCap})`
+    );
+  }
+  const budgets = {
+    always_on: evaluateBudget(budgetSpecs.always_on, sumTokens(measured, "always_on")),
+    skill_metadata: evaluateBudget(budgetSpecs.skill_metadata, skillMetadataTokens(measured)),
+    skill_body: evaluateBudget(
+      budgetSpecs.skill_body,
+      Math.max(0, sumTokens(measured, "skill_body") - skillFrontmatterTokens(measured))
+    ),
+    references: evaluateBudget(budgetSpecs.references, sumTokens(measured, "reference"))
+  };
+  const failedBudgets = Object.entries(budgets).filter(([, report]) => report.status === "error").map(([name, report]) => `${name}: ${report.tokens} > hard cap ${report.hardCap}`);
+  if (failedBudgets.length > 0) {
+    throw new BuildError(`Token budget exceeded:
+${failedBudgets.join("\n")}`);
+  }
+  for (const [name, report] of Object.entries(budgets)) {
+    if (report.status === "warning") {
+      warnings.push(
+        `token target exceeded: ${name} ${report.tokens}/${report.target} (hard cap ${report.hardCap})`
+      );
+    }
+  }
+  const version = (() => {
+    try {
+      return JSON.parse(readFileSync2(join2(root, "package.json"), "utf8")).version ?? "0.0.0";
+    } catch {
+      return "0.0.0";
+    }
+  })();
+  const manifest = {
+    schema: "hahahah.manifest/v1",
+    generated_by: `hahahah@${version}`,
+    profile: profile.id,
+    persona: persona.id,
+    adapter: adapter.id,
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    content_hash: contentHash(measured),
+    tokenizer: TOKENIZER_PROFILE,
+    release: options.release === true,
+    files: [...measured].sort((a, b) => a.path.localeCompare(b.path)).map((artifact) => ({
+      path: artifact.path,
+      sha256: artifact.sha256,
+      tokens: artifact.tokens
+    })),
+    budgets,
+    warnings
+  };
+  validate("manifest", manifest, "generated manifest", root);
+  const outDir = options.outDir ?? join2(root, ".hahahah", "build", adapter.id);
+  if (options.write !== false) {
+    if (existsSync(outDir) && !existsSync(join2(outDir, "manifest.json"))) {
+      let entries = [];
+      try {
+        entries = readdirSync(outDir);
+      } catch {
+        entries = [];
+      }
+      if (entries.length > 0) {
+        throw new BuildError(`Refusing to write into non-empty unmanaged directory: ${outDir}`);
+      }
+    }
+    cleanupManagedFiles(outDir, new Set(measured.map((artifact) => artifact.path)));
+    writeArtifacts(outDir, measured, manifest);
+  }
+  return { outDir, manifest, artifacts: measured, warnings };
+}
+
+// src/coding.ts
+import { spawnSync as spawnSync3 } from "node:child_process";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync5,
+  mkdtempSync as mkdtempSync2,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync3,
+  statSync,
+  writeFileSync as writeFileSync5
+} from "node:fs";
+import { dirname as dirname3, join as join6, relative as relative2, resolve as resolve5 } from "node:path";
+import { parse as parse3 } from "yaml";
+
+// src/install.ts
+import { createHash as createHash2 } from "node:crypto";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync3,
+  readdirSync as readdirSync2,
+  renameSync,
+  rmdirSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { dirname as dirname2, join as join3, resolve as resolve3, sep as sep2 } from "node:path";
+var MANIFEST_PATH = ".hahahah/manifest.json";
+var BLOCK_BEGIN = /<!-- hahahah:begin [^\n]*-->/;
+var BLOCK_END = /<!-- hahahah:end -->/;
+var InstallError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InstallError";
+  }
+};
+function sha2562(text) {
+  return createHash2("sha256").update(text).digest("hex");
+}
+function resolveInside2(base, child) {
+  const basePath = resolve3(base);
+  const target = resolve3(basePath, child);
+  const prefix = basePath.endsWith(sep2) ? basePath : `${basePath}${sep2}`;
+  if (target !== basePath && !target.startsWith(prefix)) {
+    throw new InstallError(`Refusing path outside ${basePath}: ${child}`);
+  }
+  return target;
+}
+function readManifest(targetRoot) {
+  const path = join3(targetRoot, MANIFEST_PATH);
+  if (!existsSync2(path)) {
+    return null;
+  }
+  let data;
+  try {
+    data = JSON.parse(readFileSync3(path, "utf8"));
+  } catch {
+    throw new InstallError(`Unreadable install manifest: ${path}`);
+  }
+  validate("install", data, MANIFEST_PATH);
+  return data;
+}
+function writeAtomic(path, content) {
+  mkdirSync2(dirname2(path), { recursive: true });
+  const temp = `${path}.tmp-${process.pid}`;
+  writeFileSync2(temp, content, "utf8");
+  renameSync(temp, path);
+}
+function parseBlock(text) {
+  const begins = [...text.matchAll(new RegExp(BLOCK_BEGIN.source, "g"))];
+  const ends = [...text.matchAll(new RegExp(BLOCK_END.source, "g"))];
+  if (begins.length === 0 && ends.length === 0) {
+    return null;
+  }
+  if (begins.length !== 1 || ends.length !== 1) {
+    throw new InstallError("Malformed or duplicate HAHahah managed block markers");
+  }
+  const begin = begins[0];
+  const end = ends[0];
+  if (!begin || !end) {
+    throw new InstallError("Malformed HAHahah managed block markers");
+  }
+  if (begin.index === void 0 || end.index === void 0 || end.index < begin.index) {
+    throw new InstallError("Malformed HAHahah managed block order");
+  }
+  const endIndex = end.index + end[0].length;
+  const content = text.slice(begin.index, endIndex);
+  return { start: begin.index, end: endIndex, content, hash: sha2562(content.trimEnd()) };
+}
+function blockContent(artifact) {
+  const text = artifact.content.replace(/\r\n/g, "\n").trimEnd();
+  if (!BLOCK_BEGIN.test(text) || !BLOCK_END.test(text)) {
+    throw new InstallError("Adapter did not render a valid managed block");
+  }
+  return `${text}
+`;
+}
+function installBlock(existing, block2, old, force) {
+  const parsed = parseBlock(existing);
+  const createdFile = existing.trim() === "";
+  if (parsed) {
+    if (!old && !force) {
+      throw new InstallError(
+        "An existing HAHahah managed block has no install manifest; use --force to replace it"
+      );
+    }
+    if (old && old.block.sha256 !== parsed.hash && !force) {
+      throw new InstallError("Managed block was modified; use --force to replace it");
+    }
+    const before = existing.slice(0, parsed.start);
+    const after = existing.slice(parsed.end).replace(/^\n+/, "");
+    const separator = before && !before.endsWith("\n") ? "\n" : "";
+    const tail = after ? `
+${after}` : "";
+    return { text: `${before}${separator}${block2}${tail}`, createdFile };
+  }
+  return {
+    text: `${existing.trimEnd()}${existing.trim() ? "\n\n" : ""}${block2}`,
+    createdFile
+  };
+}
+function install(options) {
+  const targetRoot = resolve3(options.targetRoot);
+  const adapterId = options.adapterId ?? "claude-code";
+  const scope = options.scope ?? "workspace";
+  const built = build({
+    root: options.sourceRoot,
+    profileId: options.profileId,
+    adapterId,
+    scope,
+    write: false
+  });
+  const blockArtifact = built.artifacts.find((artifact) => artifact.kind === "always_on");
+  if (!blockArtifact) {
+    throw new InstallError(`Adapter ${adapterId} rendered no always-on managed block`);
+  }
+  const blockPath = blockArtifact.path;
+  const artifactFiles = built.artifacts.filter((artifact) => artifact.kind !== "always_on");
+  const block2 = blockContent(blockArtifact);
+  const blockHash = sha2562(block2.trimEnd());
+  const old = readManifest(targetRoot);
+  const oldFiles = new Map((old?.files ?? []).map((file) => [file.path, file]));
+  for (const artifact of artifactFiles) {
+    const target = resolveInside2(targetRoot, artifact.path);
+    if (!existsSync2(target)) {
+      continue;
+    }
+    const oldFile = oldFiles.get(artifact.path);
+    if (!oldFile) {
+      if (!options.force) {
+        throw new InstallError(`Unmanaged file already exists: ${artifact.path}; use --force`);
+      }
+      continue;
+    }
+    if (oldFile.sha256 !== artifact.sha256 && !options.force) {
+      throw new InstallError(`Managed file was modified: ${artifact.path}; use --force`);
+    }
+  }
+  const claudePath = join3(targetRoot, blockPath);
+  const existingClaude = existsSync2(claudePath) ? readFileSync3(claudePath, "utf8") : "";
+  const merged = installBlock(existingClaude, block2, old, options.force === true);
+  const createdClaudeMd = old ? old.created_claude_md : merged.createdFile;
+  const manifest = {
+    schema: "hahahah.install/v1",
+    generated_by: built.manifest.generated_by,
+    profile: built.manifest.profile,
+    persona: built.manifest.persona,
+    adapter: built.manifest.adapter,
+    installed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    files: artifactFiles.map((artifact) => ({
+      path: artifact.path,
+      sha256: artifact.sha256,
+      tokens: artifact.tokens
+    })).sort((a, b) => a.path.localeCompare(b.path)),
+    block: { path: blockPath, sha256: blockHash },
+    created_claude_md: createdClaudeMd
+  };
+  validate("install", manifest, "install manifest", options.sourceRoot);
+  if (!options.dryRun) {
+    for (const artifact of artifactFiles) {
+      writeAtomic(resolveInside2(targetRoot, artifact.path), artifact.content);
+    }
+    writeAtomic(claudePath, merged.text);
+    writeAtomic(join3(targetRoot, MANIFEST_PATH), `${JSON.stringify(manifest, null, 2)}
+`);
+  }
+  return {
+    manifest,
+    targetRoot,
+    warnings: built.warnings,
+    dryRun: options.dryRun === true
+  };
+}
+function pruneEmptyDirs(start, stop) {
+  let current = start;
+  while (current !== stop && current.startsWith(stop)) {
+    try {
+      if (readdirSync2(current).length > 0) {
+        return;
+      }
+      rmdirSync(current);
+    } catch {
+      return;
+    }
+    current = dirname2(current);
+  }
+}
+function uninstall(options) {
+  const targetRoot = resolve3(options.targetRoot);
+  const old = readManifest(targetRoot);
+  if (!old) {
+    throw new InstallError(`No HAHahah install manifest at ${targetRoot}`);
+  }
+  const claudePath = join3(targetRoot, old.block.path);
+  const existingClaude = existsSync2(claudePath) ? readFileSync3(claudePath, "utf8") : "";
+  const parsed = parseBlock(existingClaude);
+  if (parsed && parsed.hash !== old.block.sha256 && !options.force) {
+    throw new InstallError("Managed block was modified; use --force to uninstall");
+  }
+  for (const file of old.files) {
+    const target = resolveInside2(targetRoot, file.path);
+    if (!existsSync2(target)) {
+      continue;
+    }
+    if (sha2562(readFileSync3(target, "utf8")) !== file.sha256 && !options.force) {
+      throw new InstallError(`Managed file was modified: ${file.path}; use --force`);
+    }
+    if (!options.dryRun) {
+      unlinkSync2(target);
+      pruneEmptyDirs(dirname2(target), targetRoot);
+    }
+  }
+  if (!options.dryRun) {
+    if (parsed) {
+      const remaining = `${existingClaude.slice(0, parsed.start)}${existingClaude.slice(parsed.end)}`;
+      const cleaned = `${remaining.trimEnd()}${remaining.trim() ? "\n" : ""}`;
+      if (old.created_claude_md && cleaned.trim() === "") {
+        unlinkSync2(claudePath);
+      } else {
+        writeAtomic(claudePath, cleaned);
+      }
+    }
+    unlinkSync2(join3(targetRoot, MANIFEST_PATH));
+    pruneEmptyDirs(dirname2(join3(targetRoot, MANIFEST_PATH)), targetRoot);
+  }
+  return old;
+}
+function doctor(options) {
+  const targetRoot = resolve3(options.targetRoot);
+  const errors = [];
+  const warnings = [];
+  const old = readManifest(targetRoot);
+  if (!old) {
+    return { ok: false, errors: [`No install manifest at ${targetRoot}`], warnings };
+  }
+  for (const file of old.files) {
+    const target = resolveInside2(targetRoot, file.path);
+    if (!existsSync2(target)) {
+      errors.push(`Missing managed file: ${file.path}`);
+      continue;
+    }
+    if (sha2562(readFileSync3(target, "utf8")) !== file.sha256) {
+      errors.push(`Hash mismatch: ${file.path}`);
+    }
+  }
+  const claudePath = join3(targetRoot, old.block.path);
+  if (!existsSync2(claudePath)) {
+    errors.push(`Missing ${old.block.path}`);
+  } else {
+    try {
+      const parsed = parseBlock(readFileSync3(claudePath, "utf8"));
+      if (!parsed) {
+        errors.push("CLAUDE.md has no managed block");
+      } else if (parsed.hash !== old.block.sha256) {
+        errors.push("CLAUDE.md managed block hash mismatch");
+      }
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  const skill = old.files.find((file) => file.path.endsWith("/SKILL.md"));
+  if (skill) {
+    const skillPath = resolveInside2(targetRoot, skill.path);
+    if (existsSync2(skillPath)) {
+      const text = readFileSync3(skillPath, "utf8");
+      const name = text.match(/^name:\s*(.+)$/m)?.[1]?.trim();
+      const description = text.match(/^description:\s*(.+)$/m)?.[1]?.trim();
+      if (name !== `hahahah-${old.persona}`) {
+        errors.push(`SKILL.md name mismatch: ${String(name)}`);
+      }
+      if (!description) {
+        errors.push("SKILL.md has no description");
+      }
+    }
+  }
+  return { ok: errors.length === 0, errors, warnings };
+}
+function update(options) {
+  const targetRoot = resolve3(options.targetRoot);
+  const old = readManifest(targetRoot);
+  if (!old) {
+    throw new InstallError(`No HAHahah install manifest at ${targetRoot}; run install first`);
+  }
+  return install({
+    sourceRoot: options.sourceRoot,
+    targetRoot,
+    profileId: old.profile,
+    adapterId: old.adapter,
+    dryRun: options.dryRun,
+    force: true
+  });
+}
+
+// src/diagnose.ts
+import { spawnSync } from "node:child_process";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+var DENIAL = /permission|denied|not allowed|rejected|blocked/i;
+var MAX_TEXT = 240;
+function clip(text) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > MAX_TEXT ? `${flat.slice(0, MAX_TEXT)}\u2026` : flat;
+}
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.map(textOf).filter(Boolean).join(" ");
+  if (typeof content === "object" && content !== null) {
+    const block2 = content;
+    if (typeof block2.text === "string") return block2.text;
+    if (block2.content !== void 0) return textOf(block2.content);
+  }
+  return "";
+}
+function summarizeStream(ndjson) {
+  const physical = ndjson.split("\n");
+  const tools = {};
+  const toolErrors = [];
+  const denials = [];
+  let finalText = "";
+  let subtype = null;
+  let numTurns = null;
+  let totalCostUsd = null;
+  for (const line of physical) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (event.type === "result") {
+      subtype = typeof event.subtype === "string" ? event.subtype : null;
+      numTurns = typeof event.num_turns === "number" ? event.num_turns : null;
+      totalCostUsd = typeof event.total_cost_usd === "number" ? event.total_cost_usd : null;
+      const result = typeof event.result === "string" ? event.result : "";
+      if (result !== "") finalText = clip(result);
+      continue;
+    }
+    const message = event.message;
+    const blocks = Array.isArray(message?.content) ? message.content : [];
+    for (const raw of blocks) {
+      if (typeof raw !== "object" || raw === null) continue;
+      const block2 = raw;
+      if (block2.type === "tool_use" && typeof block2.name === "string") {
+        tools[block2.name] = (tools[block2.name] ?? 0) + 1;
+      } else if (block2.type === "text" && typeof block2.text === "string" && block2.text.trim() !== "") {
+        finalText = clip(block2.text);
+      } else if (block2.type === "tool_result") {
+        const text = clip(textOf(block2.content));
+        if (text === "") continue;
+        if (block2.is_error === true || DENIAL.test(text)) {
+          toolErrors.push(text);
+          if (DENIAL.test(text)) denials.push(text);
+        }
+      }
+    }
+  }
+  return {
+    lines: physical.length,
+    tools,
+    toolErrors,
+    denials,
+    finalText,
+    subtype,
+    numTurns,
+    totalCostUsd
+  };
+}
+function writeRawStream(dir, arm, ndjson) {
+  mkdirSync3(dir, { recursive: true });
+  const path = join4(dir, `${arm}-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.ndjson`);
+  writeFileSync3(path, `${ndjson}
+`, "utf8");
+  return path;
+}
+function runClaudeStream(cwd, prompt, budgetUsd, options = {}) {
+  const command = process.env.HAHAHAH_CLAUDE_BIN ?? "claude";
+  const args = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    // Without this the harness emits only the final result, which is the format that hid the
+    // refusal this run exists to find.
+    "--verbose",
+    "--max-budget-usd",
+    budgetUsd.toFixed(2),
+    "--no-session-persistence",
+    "--permission-mode",
+    "acceptEdits",
+    "--permission-prompts",
+    "none"
+  ];
+  if (options.model) args.push("--model", options.model);
+  if (options.settingSources) args.push("--setting-sources", options.settingSources);
+  const result = process.platform === "win32" ? spawnSync(
+    process.env.ComSpec ?? "cmd.exe",
+    ["/d", "/s", "/c", [command, ...args].join(" ")],
+    {
+      cwd,
+      input: prompt,
+      encoding: "utf8",
+      timeout: 18e4
+    }
+  ) : spawnSync(command, args, {
+    cwd,
+    input: prompt,
+    encoding: "utf8",
+    timeout: 18e4
+  });
+  const ndjson = (result.stdout ?? "").trim();
+  if (result.error) return { run: { output: "", costUsd: 0, error: result.error.message }, ndjson };
+  const summary = summarizeStream(ndjson);
+  if (ndjson === "") {
+    return {
+      run: {
+        output: "",
+        costUsd: 0,
+        error: (result.stderr ?? "").trim() || `harness exited ${String(result.status)} with no output`
+      },
+      ndjson
+    };
+  }
+  return {
+    run: {
+      output: summary.finalText,
+      costUsd: summary.totalCostUsd ?? 0,
+      numTurns: summary.numTurns ?? void 0,
+      error: summary.subtype && summary.subtype !== "success" ? `harness reported an error (${[summary.subtype, summary.numTurns === null ? void 0 : `num_turns=${summary.numTurns}`, summary.denials.length > 0 ? `${summary.denials.length} permission denial(s)` : void 0].filter(Boolean).join(", ")})` : void 0
+    },
+    ndjson
+  };
+}
+
+// src/eval.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { createHash as createHash3 } from "node:crypto";
+import { mkdirSync as mkdirSync4, mkdtempSync, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { homedir } from "node:os";
+import { join as join5, resolve as resolve4 } from "node:path";
+import { parse as parse2 } from "yaml";
+
+// src/workspace.ts
+import { existsSync as existsSync3, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+function scratchRoot() {
+  const base = tmpdir();
+  try {
+    return realpathSync.native(base);
+  } catch {
+    return base;
+  }
+}
+function removeWorkspace(dir) {
+  try {
+    rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  } catch {
+  }
+  return !existsSync3(dir);
+}
+
+// src/checks.ts
+var ID_MARKERS = [
+  "ada",
+  "adalah",
+  "agar",
+  "aku",
+  "aktif",
+  "anda",
+  "apa",
+  "apakah",
+  "asli",
+  "atau",
+  "bantu",
+  "banyak",
+  "bahwa",
+  "banget",
+  "belum",
+  "berhati",
+  "berikut",
+  "bener",
+  "beres",
+  "betul",
+  "bikin",
+  "boleh",
+  "buat",
+  "coba",
+  "cuma",
+  "cuman",
+  "dan",
+  "dari",
+  "dapat",
+  "dengan",
+  "deh",
+  "dia",
+  "dll",
+  "doang",
+  "dong",
+  "dua",
+  "dulu",
+  "emang",
+  "gak",
+  "ga",
+  "gimana",
+  "gini",
+  "gitu",
+  "gue",
+  "gw",
+  "hapus",
+  "harus",
+  "jadi",
+  "jangan",
+  "justru",
+  "kalau",
+  "kali",
+  "kami",
+  "kamu",
+  "kan",
+  "kapasitas",
+  "kemarin",
+  "ke",
+  "kerja",
+  "kepake",
+  "kok",
+  "kurang",
+  "lagi",
+  "lah",
+  "lama",
+  "lihat",
+  "lu",
+  "maka",
+  "malah",
+  "mana",
+  "masih",
+  "mending",
+  "mereka",
+  "minta",
+  "mirip",
+  "nanti",
+  "nah",
+  "nggak",
+  "nih",
+  "nyari",
+  "pakai",
+  "pake",
+  "paling",
+  "pada",
+  "perlu",
+  "punya",
+  "sama",
+  "sana",
+  "sang",
+  "satu",
+  "secara",
+  "sedang",
+  "sehingga",
+  "saja",
+  "sambil",
+  "sebentar",
+  "sih",
+  "sini",
+  "sistem",
+  "supaya",
+  "tadi",
+  "tahap",
+  "tak",
+  "telah",
+  "temen",
+  "terus",
+  "tidak",
+  "tinggal",
+  "tuh",
+  "udah",
+  "untuk",
+  "wae",
+  "waktu",
+  "ya",
+  "yang"
+];
+var EN_MARKERS = [
+  "a",
+  "about",
+  "after",
+  "again",
+  "all",
+  "also",
+  "an",
+  "and",
+  "any",
+  "are",
+  "as",
+  "at",
+  "because",
+  "been",
+  "before",
+  "being",
+  "below",
+  "between",
+  "both",
+  "but",
+  "by",
+  "can",
+  "could",
+  "did",
+  "do",
+  "does",
+  "each",
+  "even",
+  "every",
+  "for",
+  "from",
+  "get",
+  "had",
+  "has",
+  "have",
+  "he",
+  "her",
+  "him",
+  "his",
+  "how",
+  "i",
+  "if",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "just",
+  "like",
+  "me",
+  "more",
+  "most",
+  "my",
+  "no",
+  "not",
+  "of",
+  "on",
+  "or",
+  "other",
+  "our",
+  "out",
+  "over",
+  "own",
+  "say",
+  "she",
+  "should",
+  "so",
+  "some",
+  "still",
+  "such",
+  "than",
+  "that",
+  "the",
+  "their",
+  "them",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "those",
+  "through",
+  "to",
+  "too",
+  "us",
+  "very",
+  "was",
+  "we",
+  "were",
+  "what",
+  "when",
+  "where",
+  "which",
+  "who",
+  "why",
+  "will",
+  "with",
+  "would",
+  "you",
+  "your"
+];
+function countMarkers(text, markers) {
+  let count = 0;
+  for (const word of text.toLowerCase().split(/[^a-z]+/)) {
+    if (markers.has(word)) count += 1;
+  }
+  return count;
+}
+var ID_SET = new Set(ID_MARKERS);
+var EN_SET = new Set(EN_MARKERS);
+function detectLanguage(text) {
+  const prose = text.replace(/`[^`]*`/g, " ").replace(/"[^"]*"/g, " ").replace(/\*\*[^*]*\*\*/g, " ");
+  const idScore = countMarkers(prose, ID_SET);
+  const enScore = countMarkers(prose, EN_SET);
+  let detected = "unknown";
+  if (idScore === 0 && enScore === 0) detected = "unknown";
+  else if (enScore === 0) detected = "id";
+  else if (idScore === 0) detected = "en";
+  else if (idScore >= enScore * 2) detected = "id";
+  else if (enScore >= idScore * 2) detected = "en";
+  else detected = "mixed";
+  return { detected, idScore, enScore };
+}
+function compile(source, label) {
+  try {
+    return new RegExp(source, "iu");
+  } catch {
+    return { error: `${label}: invalid pattern /${source}/` };
+  }
+}
+function visibleAnswer(text) {
+  return text.replace(/<thinking>[\s\S]*?<\/thinking>/gi, " ").replace(/<thinking>[\s\S]*$/i, " ");
+}
+function runChecks(text, checks) {
+  if (!checks) return [];
+  const results = [];
+  const answer = visibleAnswer(text);
+  if (checks.language) {
+    const { detected, idScore, enScore } = detectLanguage(answer);
+    const detail = `expected ${checks.language}, got ${detected} (id=${idScore} en=${enScore})`;
+    results.push({
+      name: "language",
+      status: detected === checks.language ? "pass" : detected === "unknown" || detected === "mixed" ? "unknown" : "fail",
+      detail
+    });
+  }
+  for (const source of checks.require ?? []) {
+    const pattern = compile(source, "require");
+    if ("error" in pattern) {
+      results.push({ name: "require", status: "unknown", detail: pattern.error });
+      continue;
+    }
+    const found = pattern.test(answer);
+    results.push({
+      name: "require",
+      status: found ? "pass" : "fail",
+      detail: `/${source}/ ${found ? "present" : "absent"}`
+    });
+  }
+  for (const source of checks.forbid ?? []) {
+    const pattern = compile(source, "forbid");
+    if ("error" in pattern) {
+      results.push({ name: "forbid", status: "unknown", detail: pattern.error });
+      continue;
+    }
+    const found = pattern.test(text);
+    results.push({
+      name: "forbid",
+      status: found ? "fail" : "pass",
+      detail: found ? `/${source}/ matched` : `/${source}/ absent`
+    });
+  }
+  return results;
+}
+var INJECTED_STYLE_LAYERS = [
+  { label: "caveman", pattern: /\bcaveman\b/i },
+  { label: "lazy senior developer", pattern: /\blazy senior dev(?:eloper)?\b/i },
+  { label: "auto-clarity", pattern: /\bAuto-Clarity\b/ },
+  { label: "ponytail", pattern: /\bponytail\b/i }
+];
+function detectInjectedStyleLayers(text) {
+  const found = INJECTED_STYLE_LAYERS.filter((layer) => layer.pattern.test(text)).map(
+    (layer) => layer.label
+  );
+  return found.sort();
+}
+function summarize(results) {
+  const summary = { pass: 0, fail: 0, unknown: 0, findings: [] };
+  for (const result of results) {
+    summary[result.status] += 1;
+    if (result.status !== "pass") {
+      summary.findings.push(`${result.name}: ${result.detail}`);
+    }
+  }
+  return summary;
+}
+var REPEAT_GRAM = 6;
+function words(text) {
+  return visibleAnswer(text).replace(/```[\s\S]*?```/g, " ").replace(/`[^`]*`/g, " ").toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((word) => word.length > 0);
+}
+function repeatAcrossTurns(answers) {
+  const grams = answers.map((answer) => {
+    const parts = words(answer);
+    const set = /* @__PURE__ */ new Set();
+    for (let index = 0; index + REPEAT_GRAM <= parts.length; index += 1) {
+      set.add(parts.slice(index, index + REPEAT_GRAM).join(" "));
+    }
+    return set;
+  });
+  for (let turn = 1; turn < grams.length; turn += 1) {
+    const previous = grams[turn - 1];
+    const shared = [...grams[turn]].find((gram) => previous.has(gram));
+    if (shared !== void 0) {
+      return {
+        name: "repeat",
+        status: "fail",
+        detail: `turn ${turn + 1} reuses "${shared}" from turn ${turn}`
+      };
+    }
+  }
+  return {
+    name: "repeat",
+    status: "pass",
+    detail: `${answers.length} turns, no shared ${REPEAT_GRAM}-word run`
+  };
+}
+function checkSuiteErrors(tasks) {
+  const errors = [];
+  for (const task of tasks) {
+    const blocks = [
+      [task.id, task.checks],
+      ...(task.turns ?? []).map((turn, index) => [
+        `${task.id} turn ${index + 1}`,
+        turn.checks
+      ])
+    ];
+    for (const [label, checks] of blocks) {
+      for (const key of ["require", "forbid"]) {
+        for (const source of checks?.[key] ?? []) {
+          try {
+            new RegExp(source, "iu");
+          } catch {
+            errors.push(`${label}: invalid ${key} pattern /${source}/`);
+          }
+        }
+      }
+    }
+  }
+  return errors;
+}
+
+// src/eval.ts
+function tasksFingerprint(tasks) {
+  const canonical = tasks.map((task) => ({
+    id: task.id,
+    prompt: task.prompt ?? null,
+    // A turn's own screens are part of the ruler too: editing one changes what a pass rate means.
+    turns: task.turns?.map((turn) => ({ prompt: turn.prompt, checks: turn.checks ?? null })) ?? null,
+    checks: task.checks ?? null
+  }));
+  return createHash3("sha256").update(JSON.stringify(canonical)).digest("hex").slice(0, 16);
+}
+function loadSuite(root, name) {
+  const path = join5(root, "evals", `${name}.yaml`);
+  const data = parse2(readFileSync4(path, "utf8"));
+  validate("evalSuite", data, `evals/${name}.yaml`, root);
+  const suite = data;
+  const errors = checkSuiteErrors(suite.tasks);
+  if (errors.length > 0) {
+    throw new Error(`Invalid eval suite ${name}:
+${errors.map((line) => `- ${line}`).join("\n")}`);
+  }
+  return suite;
+}
+function safeRun(runner, cwd, prompt, budgetUsd, history) {
+  try {
+    return runner(cwd, prompt, budgetUsd, history);
+  } catch (error) {
+    return {
+      output: "",
+      costUsd: 0,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function mergeUsage(runs) {
+  const merged = {};
+  for (const run of runs) {
+    if (typeof run.usage !== "object" || run.usage === null) return void 0;
+    for (const [key, value] of Object.entries(run.usage)) {
+      if (typeof value === "number") merged[key] = (merged[key] ?? 0) + value;
+    }
+  }
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function runTask(runner, cwd, task, budgetUsd) {
+  const turns = task.turns;
+  if (turns === void 0 || turns.length === 0) {
+    return safeRun(runner, cwd, task.prompt ?? "", budgetUsd);
+  }
+  const history = [];
+  const outputs = [];
+  const runs = [];
+  const checks = [];
+  for (const [index, turn] of turns.entries()) {
+    const run = safeRun(runner, cwd, turn.prompt, budgetUsd, [...history]);
+    runs.push(run);
+    if (run.error) {
+      return {
+        ...run,
+        durationMs: runs.reduce((total, item) => total + (item.durationMs ?? 0), 0),
+        checks,
+        turnOutputs: outputs
+      };
+    }
+    outputs.push(run.output);
+    history.push({ role: "user", text: turn.prompt }, { role: "assistant", text: run.output });
+    for (const result of runChecks(run.output, turn.checks ?? task.checks)) {
+      checks.push({ ...result, detail: `turn ${index + 1}: ${result.detail}` });
+    }
+  }
+  checks.push(repeatAcrossTurns(outputs));
+  return {
+    output: outputs[outputs.length - 1] ?? "",
+    costUsd: runs.reduce((total, run) => total + run.costUsd, 0),
+    usage: mergeUsage(runs),
+    numTurns: runs.reduce((total, run) => total + (run.numTurns ?? 0), 0),
+    durationMs: runs.reduce((total, run) => total + (run.durationMs ?? 0), 0),
+    checks,
+    turnOutputs: outputs
+  };
+}
+function median(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+}
+function usageNumber(usage, key) {
+  if (typeof usage !== "object" || usage === null) return void 0;
+  const value = usage[key];
+  return typeof value === "number" ? value : void 0;
+}
+function promptTokens(usage) {
+  const input = usageNumber(usage, "input_tokens");
+  if (input === void 0) return void 0;
+  return input + (usageNumber(usage, "cache_read_input_tokens") ?? 0) + (usageNumber(usage, "cache_creation_input_tokens") ?? 0);
+}
+function statusOf(run) {
+  if (run.error) return "error";
+  if (!run.checks || run.checks.length === 0) return "no-checks";
+  if (run.checks.some((check) => check.status === "fail")) return "fail";
+  if (run.checks.some((check) => check.status === "unknown")) return "unknown";
+  return "pass";
+}
+function consensusOf(statuses) {
+  const meaningful = statuses.filter((status) => status !== "no-checks");
+  if (meaningful.length === 0) return "no-checks";
+  if (meaningful.every((status) => status === "error")) return "error";
+  if (meaningful.every((status) => status === "pass")) return "pass";
+  if (meaningful.every((status) => status === "fail")) return "fail";
+  if (!meaningful.includes("fail") && meaningful.includes("unknown")) return "unknown";
+  return "mixed";
+}
+function buildArm(runs, checks) {
+  for (const run of runs) {
+    if (!run.error && checks && run.checks === void 0)
+      run.checks = runChecks(run.output, checks);
+    run.injectedLayers = detectInjectedStyleLayers(run.turnOutputs?.join("\n\n") ?? run.output);
+  }
+  const statuses = runs.map(statusOf);
+  const answered = runs.filter((run) => !run.error);
+  return {
+    runs,
+    consensus: consensusOf(statuses),
+    runStatuses: statuses,
+    errored: runs.length - answered.length,
+    median: {
+      costUsd: median(answered.map((run) => run.costUsd)),
+      inputTokens: median(
+        answered.map((run) => promptTokens(run.usage)).filter((value) => value !== void 0)
+      ),
+      outputTokens: median(
+        answered.map((run) => usageNumber(run.usage, "output_tokens")).filter((value) => value !== void 0)
+      ),
+      numTurns: median(
+        answered.map((run) => run.numTurns).filter((value) => value !== void 0)
+      )
+    },
+    screens: summarize(runs.flatMap((run) => run.checks ?? []))
+  };
+}
+var ROUTE_RATIO_LO = 0.6;
+var ROUTE_RATIO_HI = 1.6;
+function routeSplitOf(baseline, treatment) {
+  const answered = (runs) => runs.filter((run) => !run.error && promptTokens(run.usage) !== void 0);
+  const both = [...answered(baseline), ...answered(treatment)];
+  const sizes = both.map((run) => promptTokens(run.usage) ?? 0);
+  const center = median(sizes);
+  const deviating = (runs) => answered(runs).filter((run) => {
+    const size = promptTokens(run.usage) ?? 0;
+    return center > 0 && (size / center < ROUTE_RATIO_LO || size / center > ROUTE_RATIO_HI);
+  }).length;
+  return {
+    runs: both.length,
+    deviating: deviating(baseline) + deviating(treatment),
+    byArm: { baseline: deviating(baseline), treatment: deviating(treatment) },
+    medianInputTokens: center,
+    extremeInputTokens: sizes.length > 0 ? Math.max(...sizes) : 0
+  };
+}
+function withTranscript(history, prompt) {
+  if (history === void 0 || history.length === 0) return prompt;
+  const lines = ["Earlier turns in this conversation:", ""];
+  for (const record of history) {
+    lines.push(`${record.role === "user" ? "User" : "Assistant"}: ${record.text}`, "");
+  }
+  lines.push("Current message:", prompt);
+  return lines.join("\n");
+}
+function parseClaudeResult(stdout) {
+  const lines = stdout.split("\n").filter((line) => line.trim().startsWith("{"));
+  for (const line of lines.reverse()) {
+    try {
+      const parsed = JSON.parse(line.trim());
+      if (typeof parsed === "object" && parsed !== null) return parsed;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function runClaude(cwd, prompt, budgetUsd, options = {}, history) {
+  const command = process.env.HAHAHAH_CLAUDE_BIN ?? "claude";
+  const input = withTranscript(history, prompt);
+  const args = [
+    "-p",
+    "--output-format",
+    "json",
+    "--max-budget-usd",
+    budgetUsd.toFixed(2),
+    "--no-session-persistence"
+  ];
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.settingSources) {
+    args.push("--setting-sources", options.settingSources);
+  }
+  if (options.agentArgs) {
+    args.push(...options.agentArgs);
+  }
+  const result = process.platform === "win32" ? spawnSync2(
+    process.env.ComSpec ?? "cmd.exe",
+    ["/d", "/s", "/c", [command, ...args].join(" ")],
+    {
+      cwd,
+      input,
+      encoding: "utf8",
+      timeout: 18e4
+    }
+  ) : spawnSync2(command, args, {
+    cwd,
+    input,
+    encoding: "utf8",
+    timeout: 18e4
+  });
+  if (result.error) {
+    return { output: "", costUsd: 0, error: result.error.message };
+  }
+  const stdout = (result.stdout ?? "").trim();
+  if (!stdout) {
+    return {
+      output: "",
+      costUsd: 0,
+      error: (result.stderr ?? "").trim() || `Harness exited ${String(result.status)} with no output`
+    };
+  }
+  const parsed = parseClaudeResult(stdout);
+  if (parsed === null) {
+    return {
+      output: stdout,
+      costUsd: 0,
+      error: `Harness output was not JSON (exit ${String(result.status)})`
+    };
+  }
+  const output = typeof parsed.result === "string" ? parsed.result : "";
+  const costUsd = typeof parsed.total_cost_usd === "number" ? parsed.total_cost_usd : 0;
+  const numTurns = typeof parsed.num_turns === "number" ? parsed.num_turns : void 0;
+  const durationMs = typeof parsed.duration_ms === "number" ? parsed.duration_ms : void 0;
+  const isError = parsed.is_error === true;
+  if (!isError) {
+    return { output, costUsd, usage: parsed.usage, numTurns, durationMs };
+  }
+  const subtype = typeof parsed.subtype === "string" ? parsed.subtype : "unknown subtype";
+  const detail = [subtype, numTurns === void 0 ? void 0 : `num_turns=${numTurns}`].filter(Boolean).join(", ");
+  return {
+    output,
+    costUsd,
+    usage: parsed.usage,
+    numTurns,
+    durationMs,
+    error: `${output ? `${output} \u2014 ` : ""}harness reported an error (${detail})`
+  };
+}
+function formatArm(arm) {
+  const passing = arm.runs.filter((run) => !run.error);
+  if (passing.length === 0) return `ERROR: ${arm.runs[0]?.error ?? "no runs"}`;
+  const output = passing[0].output.replace(/\|/g, "\\|").replace(/\n+/g, " ").trim();
+  const passCount = arm.runStatuses.filter((status) => status === "pass").length;
+  const detail = `${arm.consensus} ${passCount}/${arm.runs.length}`;
+  const flagged = passing.flatMap((run) => run.checks ?? []).filter((check) => check.status !== "pass").map((check) => `${check.name} ${check.status}`);
+  const unique = [...new Set(flagged)];
+  return unique.length === 0 ? `${output} [${detail}]` : `${output} [${detail}: ${unique.join(", ")}]`;
+}
+function medianCell(arm) {
+  const turns = arm.median.numTurns || "?";
+  return `$${arm.median.costUsd.toFixed(4)} (in ${Math.round(arm.median.inputTokens)}, out ${Math.round(arm.median.outputTokens)}, turns ${turns})`;
+}
+function contaminationLines(report) {
+  const lines = [];
+  for (const arm of ["baseline", "treatment"]) {
+    const armData = report.contamination[arm];
+    if (armData.affected === 0) continue;
+    lines.push(
+      `**${arm} is not a neutral reference**: ${armData.affected} of ${armData.runs} ${arm} run(s) name style layers the provider injected itself (${armData.phrases.join(", ")}).`
+    );
+  }
+  if (lines.length === 0) {
+    lines.push("No provider-injected style layers were detected in either arm.");
+  }
+  return lines;
+}
+function routingLine(report) {
+  const { routing } = report;
+  if (routing.deviating === 0 || routing.runs === 0) return [];
+  return [
+    `**these runs were not all served by one route**: ${routing.deviating} of ${routing.runs} answered runs (${routing.byArm.baseline} baseline, ${routing.byArm.treatment} treatment) sit more than ${ROUTE_RATIO_HI}x or under ${ROUTE_RATIO_LO}x away from the campaign's median prompt size (median ${Math.round(routing.medianInputTokens)} input tokens, largest ${Math.round(routing.extremeInputTokens)}). The harness reports no model per run, so this is a size signal, not a model name: a gateway that picks an upstream per request changes the model underneath an A/B, and these arm medians mix upstreams.`
+  ];
+}
+function erroredLine(report) {
+  const baseline = report.results.reduce((total, result) => total + result.baseline.errored, 0);
+  const treatment = report.results.reduce((total, result) => total + result.treatment.errored, 0);
+  if (baseline + treatment === 0) return [];
+  return [
+    `${baseline} baseline and ${treatment} treatment run(s) never answered and are excluded from every median and screen; those cells describe fewer than ${report.repeats} repeats per task.`
+  ];
+}
+function abortedLine(report) {
+  const abort = report.aborted;
+  if (!abort) return [];
+  const missing = abort.remainingTasks.length > 0 ? `Not measured at all: ${abort.remainingTasks.join(", ")}.` : "Every task was started, but the last one is incomplete.";
+  const cause = abort.kind === "quota" ? `the provider refused further requests (${abort.reason})` : `${UNANSWERED_STREAK} consecutive run(s) were answered with nothing at all (${abort.reason}) - the harness or the route behind it is not answering. That is what reached this process, not necessarily why: opencode logged its free-tier refusal 0.4 s after sending the request, then hung until the spawn limit, so two campaigns were labelled unresponsive while the provider was refusing. Read the harness's own log before naming the cause.`;
+  return [
+    `**the campaign was aborted after ${abort.afterRuns} run(s)** by ${cause}. ${missing} ${abort.partialTask} is reported with only the repeats it actually got, so these numbers cover fewer tasks than the suite defines.`
+  ];
+}
+function reportMarkdown(report) {
+  const lines = [
+    `# HAHahah eval report`,
+    "",
+    `- Profile: ${report.profile}`,
+    `- Suite: ${report.suite}`,
+    `- Suite fingerprint: ${report.tasksSha256} (prompts and screens; a different value means two reports are not comparable)`,
+    `- Model: ${report.model ?? "harness default"}`,
+    `- Generated: ${report.generated_at}`,
+    `- Budget per run: $${report.budget_per_run_usd.toFixed(2)}`,
+    `- Repeats per task per arm: ${report.repeats} (order alternates on every second repeat)`,
+    `- Total cost reported: $${report.total_cost_usd.toFixed(4)}`,
+    `- Tasks with checks: ${report.summary.tasks_with_checks}`,
+    `- Baseline checks: ${report.summary.baseline.pass} pass, ${report.summary.baseline.fail} fail, ${report.summary.baseline.unknown} unknown`,
+    `- Treatment checks: ${report.summary.treatment.pass} pass, ${report.summary.treatment.fail} fail, ${report.summary.treatment.unknown} unknown`,
+    `- Harness: ${report.environment.harness} ${report.environment.harnessVersion ?? "(version not readable)"}`,
+    `- Provider base URL host: ${report.environment.baseUrlHost ?? "(not set)"}`,
+    "",
+    ...contaminationLines(report),
+    ...routingLine(report),
+    ...erroredLine(report),
+    ...abortedLine(report),
+    "",
+    "Cost and token figures are medians across the repeats: this provider bills heavy-tailed spikes, so a single run is not a measurement.",
+    "",
+    "| Task | Baseline | Treatment | Baseline median | Treatment median |",
+    "|---|---|---|---:|---:|",
+    ...report.results.map(
+      (result) => `| ${result.task.id} | ${formatArm(result.baseline)} | ${formatArm(result.treatment)} | ${medianCell(result.baseline)} | ${medianCell(result.treatment)} |`
+    ),
+    "",
+    "Turns are reported by the harness; more than one turn means the agent used tools or iterated, which multiplies billed input tokens.",
+    "Checks are deterministic surface screens (language markers, required and forbidden patterns).",
+    "A check is not a semantic judgment: it flags text for human review, it does not prove intent or correctness.",
+    "Consensus is pass only when every repeat passes; one failing repeat makes the task mixed or fail.",
+    "No claim is made beyond these observed runs. Failed or blocked runs remain errors, not fabricated answers.",
+    ""
+  ];
+  return lines.join("\n");
+}
+function contaminationOf(runs) {
+  const phrases = /* @__PURE__ */ new Set();
+  let affected = 0;
+  for (const run of runs) {
+    const found = run.injectedLayers ?? [];
+    if (found.length > 0) affected += 1;
+    for (const phrase of found) phrases.add(phrase);
+  }
+  return { runs: runs.length, affected, phrases: [...phrases].sort() };
+}
+function probeHarnessVersion(harness) {
+  const command = harness === "opencode" ? process.env.HAHAHAH_OPENCODE_BIN ?? "opencode" : process.env.HAHAHAH_CLAUDE_BIN ?? "claude";
+  const args = harness === "opencode" ? ["-v"] : ["--version"];
+  const spawn = (file, argv) => process.platform === "win32" ? spawnSync2(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", [file, ...argv].join(" ")], {
+    encoding: "utf8",
+    timeout: 2e4
+  }) : spawnSync2(file, argv, { encoding: "utf8", timeout: 2e4 });
+  try {
+    const result = spawn(command, args);
+    const text = `${result.stdout ?? ""}`.trim() || `${result.stderr ?? ""}`.trim();
+    return text ? text.split("\n")[0].slice(0, 120) : null;
+  } catch {
+    return null;
+  }
+}
+function hostOfBaseUrl(raw) {
+  try {
+    return new URL(raw).host;
+  } catch {
+    return null;
+  }
+}
+function baseUrlFromSettings(text) {
+  try {
+    const env = JSON.parse(text).env;
+    const value = env?.ANTHROPIC_BASE_URL;
+    return typeof value === "string" ? value : null;
+  } catch {
+    return null;
+  }
+}
+function settingsBaseUrl() {
+  try {
+    return baseUrlFromSettings(readFileSync4(join5(homedir(), ".claude", "settings.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function baseUrlHost(harness) {
+  if (harness === "opencode") return null;
+  const raw = process.env.ANTHROPIC_BASE_URL ?? settingsBaseUrl();
+  return raw ? hostOfBaseUrl(raw) : null;
+}
+function probeRoute(runner, budgetUsd) {
+  const dir = mkdtempSync(join5(scratchRoot(), "hahahah-eval-probe-"));
+  try {
+    const run = safeRun(runner, dir, "Reply with exactly the word OK and nothing else.", budgetUsd);
+    if (run.error) {
+      throw new Error(
+        `Route probe failed before the campaign: ${run.error}
+Nothing was measured: check the harness and the provider route, then re-run.`
+      );
+    }
+  } finally {
+    removeWorkspace(dir);
+  }
+}
+var EXHAUSTION_PATTERNS = [
+  /\[402\]|status 402|error code 402/i,
+  /\b429\b|too many requests|rate[ -]limit/i,
+  /MONTHLY_REQUEST_COUNT|insufficient_quota|exceeded your current quota|reached the limit|quota[ -]?exhausted/i,
+  // opencode's free tier says "limit reached", not "reached the limit", and names no status code.
+  /usage limit reached/i
+];
+function providerExhausted(error) {
+  return EXHAUSTION_PATTERNS.some((pattern) => pattern.test(error));
+}
+var UNANSWERED_STREAK = 3;
+function runEval(options) {
+  const tasks = options.tasks.slice(0, options.limit ?? options.tasks.length);
+  const repeats = options.repeats ?? 1;
+  const runner = options.runner ?? ((cwd, prompt, budgetUsd, history) => runClaude(
+    cwd,
+    prompt,
+    budgetUsd,
+    {
+      model: options.model,
+      settingSources: options.settingSources
+    },
+    history
+  ));
+  if (options.probe ?? options.runner === void 0) probeRoute(runner, options.budgetUsd);
+  const results = [];
+  let stopReason = null;
+  let stopKind = null;
+  let unansweredStreak = 0;
+  let stoppedAt = -1;
+  let runCount = 0;
+  for (const [taskIndex, task] of tasks.entries()) {
+    if (stopReason) break;
+    const baselineDir = mkdtempSync(join5(scratchRoot(), "hahahah-eval-baseline-"));
+    const treatmentDir = mkdtempSync(join5(scratchRoot(), "hahahah-eval-treatment-"));
+    try {
+      install({
+        sourceRoot: options.sourceRoot,
+        targetRoot: treatmentDir,
+        profileId: options.profileId,
+        adapterId: options.adapterId
+      });
+      const baselineRuns = [];
+      const treatmentRuns = [];
+      for (let index = 0; index < repeats && !stopReason; index += 1) {
+        const order = index % 2 === 0 ? ["baseline", "treatment"] : ["treatment", "baseline"];
+        for (const arm of order) {
+          if (stopReason) break;
+          const run = runTask(
+            runner,
+            arm === "baseline" ? baselineDir : treatmentDir,
+            task,
+            options.budgetUsd
+          );
+          runCount += 1;
+          if (run.error) {
+            unansweredStreak += 1;
+            if (providerExhausted(run.error)) {
+              stopKind = "quota";
+            } else if (unansweredStreak >= UNANSWERED_STREAK) {
+              stopKind = "unresponsive";
+            }
+            if (stopKind) {
+              stopReason = run.error;
+              stoppedAt = taskIndex;
+            }
+          } else {
+            unansweredStreak = 0;
+          }
+          (arm === "baseline" ? baselineRuns : treatmentRuns).push(run);
+        }
+      }
+      results.push({
+        task,
+        baseline: buildArm(baselineRuns, task.checks),
+        treatment: buildArm(treatmentRuns, task.checks)
+      });
+    } finally {
+      removeWorkspace(baselineDir);
+      removeWorkspace(treatmentDir);
+    }
+  }
+  const baselineSummary = summarize(
+    results.flatMap((result) => result.baseline.runs.flatMap((run) => run.checks ?? []))
+  );
+  const treatmentSummary = summarize(
+    results.flatMap((result) => result.treatment.runs.flatMap((run) => run.checks ?? []))
+  );
+  const allRuns = results.flatMap((result) => [...result.baseline.runs, ...result.treatment.runs]);
+  const routing = routeSplitOf(
+    results.flatMap((result) => result.baseline.runs),
+    results.flatMap((result) => result.treatment.runs)
+  );
+  const harness = options.harness ?? "claude";
+  const report = {
+    schema: "hahahah.eval/v7",
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    profile: options.profileId,
+    suite: options.suite ?? "custom",
+    tasksSha256: tasksFingerprint(options.tasks),
+    aborted: stopReason ? {
+      kind: stopKind ?? "unresponsive",
+      reason: stopReason.replace(/\s+/g, " ").slice(0, 300),
+      afterRuns: runCount,
+      partialTask: tasks[stoppedAt]?.id ?? "",
+      remainingTasks: tasks.slice(stoppedAt + 1).map((task) => task.id)
+    } : null,
+    budget_per_run_usd: options.budgetUsd,
+    repeats,
+    model: options.model ?? null,
+    total_cost_usd: allRuns.reduce((total, run) => total + run.costUsd, 0),
+    environment: {
+      harness,
+      harnessVersion: probeHarnessVersion(harness),
+      baseUrlHost: baseUrlHost(harness)
+    },
+    routing,
+    contamination: {
+      baseline: contaminationOf(results.flatMap((result) => result.baseline.runs)),
+      treatment: contaminationOf(results.flatMap((result) => result.treatment.runs))
+    },
+    results,
+    summary: {
+      baseline: baselineSummary,
+      treatment: treatmentSummary,
+      tasks_with_checks: results.filter((result) => result.task.checks).length
+    }
+  };
+  const outDir = resolve4(options.outDir);
+  mkdirSync4(outDir, { recursive: true });
+  writeFileSync4(join5(outDir, "report.json"), `${JSON.stringify(report, null, 2)}
+`, "utf8");
+  writeFileSync4(join5(outDir, "report.md"), reportMarkdown(report), "utf8");
+  return report;
+}
+
+// src/coding.ts
+var DEFAULT_COMMAND = ["node", "--test"];
+function commandError(command) {
+  if (command[0] !== "node") return `${String(command[0])}: only the node test runner is allowed`;
+  if (command[1] !== "--test") return `node ${String(command[1])}: only --test is allowed`;
+  if (command.length > 3) return "too many arguments for the test runner";
+  const target = command[2];
+  if (target !== void 0 && (target.startsWith("-") || target.includes("..") || !/^[A-Za-z0-9._/-]+$/.test(target))) {
+    return `test target ${target} must be a plain relative path, not an option`;
+  }
+  return void 0;
+}
+function inside(root, path) {
+  const base = resolve5(root);
+  const target = resolve5(base, path);
+  if (target !== base && !target.startsWith(base + "/") && !target.startsWith(base + "\\")) {
+    throw new Error(`fixture path escapes the workspace: ${path}`);
+  }
+  return target;
+}
+function writeFiles(root, files) {
+  for (const file of files) {
+    const target = inside(root, file.path);
+    mkdirSync5(dirname3(target), { recursive: true });
+    writeFileSync5(target, file.content, "utf8");
+  }
+}
+function structureErrors(fixture) {
+  const problems = [];
+  const taskPaths = new Set(fixture.files.map((file) => file.path));
+  for (const file of fixture.solution) {
+    if (!taskPaths.has(file.path)) {
+      problems.push(`solution changes ${file.path}, which the task does not provide`);
+    }
+  }
+  if (!fixture.files.some((file) => /\.test\.(js|mjs|cjs)$/.test(file.path))) {
+    problems.push("no *.test.js file is provided, so the fixture cannot be graded");
+  }
+  return problems;
+}
+var GRADE_ENV = {
+  PATH: process.env.PATH ?? "",
+  HOME: scratchRoot(),
+  SYSTEMROOT: process.env.SYSTEMROOT ?? "",
+  TEMP: scratchRoot(),
+  TMP: scratchRoot(),
+  TMPDIR: scratchRoot(),
+  TZ: "UTC"
+};
+function ensureModuleMarker(dir) {
+  const marker2 = join6(dir, "package.json");
+  if (existsSync4(marker2) && !statSync(marker2).isFile()) {
+    return;
+  }
+  let parsed = null;
+  try {
+    parsed = JSON.parse(readFileSync5(marker2, "utf8"));
+  } catch {
+    parsed = null;
+  }
+  if (parsed === null) {
+    writeFileSync5(marker2, '{\n  "type": "module"\n}\n', "utf8");
+    return;
+  }
+  if (parsed.type === "module") {
+    return;
+  }
+  writeFileSync5(marker2, `${JSON.stringify({ ...parsed, type: "module" }, null, 2)}
+`, "utf8");
+}
+function testTargets(fixture, command) {
+  if (command.length > 2) {
+    return command.slice(2);
+  }
+  return fixture.files.filter((file) => TEST_FILE.test(file.path)).map((file) => file.path);
+}
+function runTests(cwd, command, targets = []) {
+  const args = ["--test", "--test-reporter=tap", ...targets];
+  ensureModuleMarker(cwd);
+  const result = spawnSync3(process.execPath, args, {
+    cwd,
+    encoding: "utf8",
+    timeout: 6e4,
+    shell: false,
+    env: GRADE_ENV
+  });
+  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+  const pass = Number(output.match(/^# pass (\d+)$/m)?.[1] ?? "0");
+  const fail = Number(output.match(/^# fail (\d+)$/m)?.[1] ?? "0");
+  if (result.error) return { passed: false, pass, fail, error: result.error.message };
+  return { passed: result.status === 0 && fail === 0 && pass > 0, pass, fail };
+}
+function loadFixtures(root, dir = "fixtures") {
+  const folder = join6(root, dir);
+  const names = readdirSync3(folder).filter((name) => name.endsWith(".yaml") || name.endsWith(".yml")).sort();
+  const fixtures = [];
+  const problems = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    let data;
+    try {
+      data = parse3(readFileSync5(join6(folder, name), "utf8"));
+      validate("codingFixture", data, `${dir}/${name}`, root);
+    } catch (error) {
+      problems.push(`${name}: ${error instanceof Error ? error.message : String(error)}`);
+      continue;
+    }
+    const fixture = data;
+    if (seen.has(fixture.id)) problems.push(`${name}: duplicate fixture id ${fixture.id}`);
+    seen.add(fixture.id);
+    const command = commandError(fixture.runner?.command ?? DEFAULT_COMMAND);
+    if (command) problems.push(`${name}: ${command}`);
+    for (const problem of structureErrors(fixture)) problems.push(`${name}: ${problem}`);
+    fixtures.push(fixture);
+  }
+  if (problems.length > 0) {
+    throw new Error(`Invalid coding fixtures:
+${problems.map((line) => `- ${line}`).join("\n")}`);
+  }
+  return fixtures;
+}
+function checkFixture(fixture) {
+  const workspace = mkdtempSync2(join6(scratchRoot(), "hahahah-fixture-"));
+  try {
+    const command = fixture.runner?.command ?? DEFAULT_COMMAND;
+    const targets = testTargets(fixture, command);
+    writeFiles(workspace, fixture.files);
+    const broken = runTests(workspace, command, targets);
+    writeFiles(workspace, fixture.solution);
+    const fixed = runTests(workspace, command, targets);
+    const problems = [];
+    if (broken.passed) problems.push("the task state already passes, so nothing is being asked");
+    if (!fixed.passed)
+      problems.push(`the reference solution does not pass: ${fixed.error ?? `fail=${fixed.fail}`}`);
+    if (fixed.pass !== fixture.tests) {
+      problems.push(`declared ${fixture.tests} tests, the runner counted ${fixed.pass}`);
+    }
+    if (broken.pass + broken.fail !== fixture.tests) {
+      problems.push(
+        `task state ran ${broken.pass + broken.fail} of ${fixture.tests} tests, so the suite is crashing rather than asserting`
+      );
+    }
+    return {
+      id: fixture.id,
+      ok: problems.length === 0,
+      detail: problems.length === 0 ? `${fixed.pass} tests pass with the solution; ${broken.fail} fail in the task state` : problems.join("; "),
+      hidden: fixture.hidden === true,
+      testsFailingWhenBroken: broken.fail,
+      testsPassingWithSolution: fixed.pass
+    };
+  } finally {
+    removeWorkspace(workspace);
+  }
+}
+function checkAll(root, dir = "fixtures") {
+  return loadFixtures(root, dir).map(checkFixture);
+}
+var TEST_FILE = /\.test\.(cjs|js|mjs)$/;
+var RUNNER_OWNED = /* @__PURE__ */ new Set(["CLAUDE.md", "package.json"]);
+var TASK_NOTES = {
+  id: [
+    "Kerjakan di direktori kerja ini.",
+    "Test ada di file test/*.test.js. Buat semuanya lulus.",
+    "Jangan mengubah file test dan jangan menambah file test baru."
+  ],
+  en: [
+    "Work in this working directory.",
+    "The tests live in test/*.test.js. Make all of them pass.",
+    "Do not modify a test file and do not add a new test file."
+  ]
+};
+function fixturePrompt(fixture) {
+  const notes = TASK_NOTES[fixture.language ?? "id"];
+  return [fixture.brief.trim(), "", ...notes].join("\n");
+}
+function listWorkspaceFiles(root, relativeDir = ".") {
+  const found = [];
+  for (const entry of readdirSync3(join6(root, relativeDir), { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      found.push(...listWorkspaceFiles(root, join6(relativeDir, entry.name)));
+    } else {
+      const absolute = join6(root, relativeDir, entry.name);
+      const path = relative2(root, absolute).replace(/\\/g, "/");
+      if (!RUNNER_OWNED.has(path)) found.push(path);
+    }
+  }
+  return found;
+}
+function diffWorkspace(fixture, workspace) {
+  const declared = new Map(fixture.files.map((file) => [file.path, file.content]));
+  const changedFiles = [];
+  const missingFiles = [];
+  for (const [path, content] of declared) {
+    let text;
+    try {
+      text = readFileSync5(inside(workspace, path), "utf8");
+    } catch {
+      text = void 0;
+    }
+    if (text === void 0) missingFiles.push(path);
+    else if (text.replace(/\r\n/g, "\n") !== content.replace(/\r\n/g, "\n"))
+      changedFiles.push(path);
+  }
+  const extraTestFiles = [];
+  const otherNewFiles = [];
+  for (const path of listWorkspaceFiles(workspace)) {
+    if (declared.has(path)) continue;
+    if (TEST_FILE.test(path)) extraTestFiles.push(path);
+    else otherNewFiles.push(path);
+  }
+  return { changedFiles, missingFiles, extraTestFiles, otherNewFiles };
+}
+function gradeRun(fixture, workspace, run) {
+  const diff = diffWorkspace(fixture, workspace);
+  const command = fixture.runner?.command ?? DEFAULT_COMMAND;
+  const result = runTests(workspace, command, testTargets(fixture, command));
+  const tampered = diff.extraTestFiles.length > 0 || diff.changedFiles.some((path) => TEST_FILE.test(path)) || diff.missingFiles.some((path) => TEST_FILE.test(path));
+  const untouched = diff.changedFiles.length === 0 && diff.missingFiles.length === 0 && diff.otherNewFiles.length === 0;
+  let grade;
+  if (run.error) grade = "error";
+  else if (tampered) grade = "tampered";
+  else if (untouched) grade = "untouched";
+  else if (result.error) grade = "error";
+  else grade = result.passed && result.pass >= fixture.tests ? "solved" : "failed";
+  return { grade, run, pass: result.pass, fail: result.fail, ...diff };
+}
+function summarizeArm(runs) {
+  const numbers = (pick2) => median(
+    runs.map((arm) => arm.run).map(pick2).filter((v) => v !== void 0)
+  );
+  return {
+    runs,
+    grades: runs.map((arm) => arm.grade),
+    solved: runs.filter((arm) => arm.grade === "solved").length,
+    median: {
+      costUsd: numbers((run) => run.costUsd),
+      inputTokens: numbers((run) => promptTokens(run.usage)),
+      outputTokens: numbers((run) => usageNumber(run.usage, "output_tokens")),
+      numTurns: numbers((run) => run.numTurns)
+    }
+  };
+}
+function tally(results, arm) {
+  const grades = results.flatMap((result) => result[arm].grades);
+  const count = (grade) => grades.filter((value) => value === grade).length;
+  return {
+    solved: count("solved"),
+    failed: count("failed"),
+    tampered: count("tampered"),
+    untouched: count("untouched"),
+    error: count("error")
+  };
+}
+function projectedCostUsd(count, repeats, budgetUsd, arms = 2) {
+  return count * repeats * arms * budgetUsd;
+}
+function safeAgent(runner, cwd, prompt, budget) {
+  try {
+    return runner(cwd, prompt, budget);
+  } catch (error) {
+    return {
+      output: "",
+      costUsd: 0,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function studyMarkdown(report) {
+  const line = (arm) => {
+    const oneLine = (text) => text.replace(/\s+/g, " ").trim();
+    if (arm.runs.length > 0 && arm.runs.every((run) => run.grade === "error"))
+      return `error (${oneLine(arm.runs[0]?.run.error ?? "no runs")})`;
+    return `${arm.grades.join(", ")} \u2014 solved ${arm.solved}/${arm.runs.length}`;
+  };
+  const cell = (arm) => `$${arm.median.costUsd.toFixed(4)} (in ${Math.round(arm.median.inputTokens)}, out ${Math.round(arm.median.outputTokens)}, turns ${arm.median.numTurns || "?"})`;
+  const residue = report.residue.length === 0 ? "none" : `${report.residue.length} workspace dir(s) were still held open by the harness and are left behind: ${report.residue.join(", ")}`;
+  const lines = [
+    "# HAHahah coding fixture study",
+    "",
+    `- Profile: ${report.profile}`,
+    `- Model: ${report.model ?? "harness default"}`,
+    `- Generated: ${report.generated_at}`,
+    `- Fixtures run: ${report.fixtures_run} (${report.hidden_run} hidden holdout)`,
+    `- Repeats per fixture per arm: ${report.repeats}`,
+    `- Arms run: ${report.arms.join(" + ")}${report.arms.length === 1 ? " (single arm \u2014 no baseline/treatment comparison is available from this run)" : ""}`,
+    `- Budget per run: $${report.budget_per_run_usd.toFixed(2)}`,
+    `- Total cost reported: $${report.total_cost_usd.toFixed(4)}`,
+    `- Harness: headless, --permission-mode ${report.harness.permission_mode}, --permission-prompts ${report.harness.permission_prompts}`,
+    `- Workspace residue after the run: ${residue}`,
+    "",
+    `Baseline: solved ${report.summary.baseline.solved}, failed ${report.summary.baseline.failed}, tampered ${report.summary.baseline.tampered}, untouched ${report.summary.baseline.untouched}, error ${report.summary.baseline.error}`,
+    `Treatment: solved ${report.summary.treatment.solved}, failed ${report.summary.treatment.failed}, tampered ${report.summary.treatment.tampered}, untouched ${report.summary.treatment.untouched}, error ${report.summary.treatment.error}`,
+    `Hidden holdout (${report.hidden_run} of ${report.fixtures_run} fixtures) \u2014 baseline solved ${report.summary.holdout.baseline.solved}, treatment solved ${report.summary.holdout.treatment.solved}. Read these apart: the visible set is what the fixtures were designed against, so a holdout that scores worse is the honest signal.`,
+    "",
+    "| Fixture | Baseline | Treatment | Baseline median | Treatment median |",
+    "|---|---|---|---:|---:|",
+    ...report.results.map(
+      (result) => `| ${result.fixture.id}${result.fixture.hidden ? " (hidden)" : ""} | ${line(result.baseline)} | ${line(result.treatment)} | ${cell(result.baseline)} | ${cell(result.treatment)} |`
+    ),
+    "",
+    "## What this grades",
+    "",
+    "Each run is graded by executing the fixture's own tests in the workspace after the agent finished, so this is a correctness signal rather than a text screen.",
+    "`solved` means the untouched tests all passed. `tampered` means a test file was edited, deleted, or added; those runs are never counted as solved even when the tests then pass.",
+    "`untouched` means the workspace was byte-identical to the task state: the agent replied without changing the code.",
+    "`error` is a run that did not complete. It is reported as an error and never scored as a failure of the persona.",
+    "",
+    "## Limits of this report",
+    "",
+    "The agent ran headless with file edits auto-accepted and every other permission denied, so it could not execute the test suite itself. Pass rates are conditioned on that and are not a claim about interactive use.",
+    "A `tampered` or `untouched` spike may be a harness permission problem rather than a model choice; check a raw transcript before attributing either grade to the persona.",
+    "Costs are medians over the repeats because this provider bills heavy-tailed spikes; one run is not a measurement.",
+    "With this many fixtures the solved counts are descriptive. No non-inferiority or accuracy rate is claimed.",
+    ""
+  ];
+  return lines.join("\n");
+}
+function runFixtureStudy(options) {
+  const repeats = options.repeats ?? 1;
+  const fixtures = options.fixtures.slice(0, options.limit ?? options.fixtures.length);
+  const runner = options.runner ?? ((cwd, prompt, budgetUsd) => runClaude(cwd, prompt, budgetUsd, {
+    model: options.model,
+    settingSources: options.settingSources,
+    // The fixture task is to change source files, so edits are the one thing the
+    // agent must be able to do. Shell and network stay denied: this host is
+    // unsandboxed (TECHNICAL_RISKS R-10/R-14), and the grade comes from the tests
+    // this tool runs afterwards, not from anything the agent ran.
+    agentArgs: ["--permission-mode", "acceptEdits", "--permission-prompts", "none"]
+  }));
+  const results = [];
+  const residue = [];
+  const remove = options.remove ?? removeWorkspace;
+  const arms = options.arm && options.arm !== "both" ? [options.arm] : ["baseline", "treatment"];
+  for (const fixture of fixtures) {
+    const prompt = fixturePrompt(fixture);
+    const baseline = [];
+    const treatment = [];
+    for (let index = 0; index < repeats; index += 1) {
+      let order = ["baseline", "treatment"];
+      if (arms.length === 1) {
+        order = arms;
+      } else if (index % 2 === 1) {
+        order = ["treatment", "baseline"];
+      }
+      for (const arm of order) {
+        const dir = mkdtempSync2(join6(scratchRoot(), `hahahah-study-${arm}-`));
+        try {
+          writeFiles(dir, fixture.files);
+          ensureModuleMarker(dir);
+          if (arm === "treatment") {
+            install({
+              sourceRoot: options.sourceRoot,
+              targetRoot: dir,
+              profileId: options.profileId,
+              adapterId: options.adapterId
+            });
+          }
+          const run = safeAgent(runner, dir, prompt, options.budgetUsd);
+          (arm === "baseline" ? baseline : treatment).push(gradeRun(fixture, dir, run));
+        } finally {
+          if (!remove(dir)) residue.push(dir);
+        }
+      }
+    }
+    results.push({
+      fixture,
+      baseline: summarizeArm(baseline),
+      treatment: summarizeArm(treatment)
+    });
+  }
+  const allRuns = results.flatMap((result) => [...result.baseline.runs, ...result.treatment.runs]);
+  const holdout = results.filter((result) => result.fixture.hidden);
+  const report = {
+    schema: "hahahah.coding.study/v1",
+    generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    profile: options.profileId,
+    model: options.model ?? null,
+    suite: "coding-fixtures",
+    budget_per_run_usd: options.budgetUsd,
+    repeats,
+    arms,
+    fixtures_run: results.length,
+    hidden_run: holdout.length,
+    total_cost_usd: allRuns.reduce((total, arm) => total + arm.run.costUsd, 0),
+    harness: { permission_mode: "acceptEdits", permission_prompts: "none" },
+    residue,
+    summary: {
+      baseline: tally(results, "baseline"),
+      treatment: tally(results, "treatment"),
+      holdout: {
+        baseline: tally(holdout, "baseline"),
+        treatment: tally(holdout, "treatment")
+      }
+    },
+    results
+  };
+  const outDir = resolve5(options.outDir);
+  mkdirSync5(outDir, { recursive: true });
+  writeFileSync5(join6(outDir, "report.json"), `${JSON.stringify(report, null, 2)}
+`, "utf8");
+  writeFileSync5(join6(outDir, "report.md"), studyMarkdown(report), "utf8");
+  return report;
+}
+function diagnoseFixture(options) {
+  const dir = mkdtempSync2(join6(scratchRoot(), `hahahah-diagnose-${options.arm}-`));
+  writeFiles(dir, options.fixture.files);
+  ensureModuleMarker(dir);
+  if (options.arm === "treatment") {
+    install({
+      sourceRoot: options.sourceRoot,
+      targetRoot: dir,
+      profileId: options.profileId
+    });
+  }
+  const stream = options.runner ?? runClaudeStream;
+  const { run, ndjson } = stream(dir, fixturePrompt(options.fixture), options.budgetUsd, {
+    model: options.model,
+    settingSources: options.settingSources
+  });
+  return {
+    summary: summarizeStream(ndjson),
+    graded: gradeRun(options.fixture, dir, run),
+    rawPath: writeRawStream(options.outDir, options.arm, ndjson),
+    workspace: dir
+  };
+}
+
+// src/notifier.ts
+function isNewerVersion(remote, current) {
+  const parse4 = (v) => v.replace(/^v/, "").split(/[-+.]/).map((p) => Number.parseInt(p, 10)).filter((n) => !Number.isNaN(n));
+  const rParts = parse4(remote);
+  const cParts = parse4(current);
+  const maxLen = Math.max(rParts.length, cParts.length, 3);
+  for (let i = 0; i < maxLen; i++) {
+    const r = rParts[i] ?? 0;
+    const c = cParts[i] ?? 0;
+    if (r !== c) {
+      return r > c;
+    }
+  }
+  return false;
+}
+function formatUpdateNotice(current, latest) {
+  return [
+    "",
+    "\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510",
+    `\u2502  Pembaruan Anti-Yapping tersedia: v${current} \u2192 v${latest}`.padEnd(57) + "\u2502",
+    "\u2502  Jalankan perintah berikut untuk memperbarui:          \u2502",
+    "\u2502  $ npx anti-yapping update                             \u2502",
+    "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518",
+    ""
+  ].join("\n");
+}
+async function checkRemoteUpdate(currentVersion) {
+  if (process.env.HAHAHAH_NO_UPDATE_CHECK || process.env.CI) {
+    return null;
+  }
+  try {
+    const res = await fetch(
+      "https://raw.githubusercontent.com/humanoiseLABS/anti-yapping/main/package.json",
+      {
+        signal: AbortSignal.timeout(1500)
+      }
+    );
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (data.version && isNewerVersion(data.version, currentVersion)) {
+      return data.version;
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/opencode.ts
+import { spawnSync as spawnSync4 } from "node:child_process";
+import {
+  closeSync,
+  mkdtempSync as mkdtempSync3,
+  openSync,
+  readFileSync as readFileSync6,
+  readSync,
+  statSync as statSync2,
+  writeFileSync as writeFileSync6
+} from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join7 } from "node:path";
+function opencodeArgs(cwd, options = {}) {
+  const args = ["run", "--format", "json", "--dir", cwd];
+  if (options.model) args.push("--model", options.model);
+  if (options.agentArgs) args.push(...options.agentArgs);
+  return args;
+}
+function opencodeStudyConfig() {
+  return JSON.stringify(
+    {
+      permission: {
+        edit: "allow",
+        bash: "deny",
+        webfetch: "deny",
+        external_directory: "deny",
+        doom_loop: "deny"
+      }
+    },
+    null,
+    2
+  );
+}
+function tokensOf(part) {
+  const tokens = part.tokens;
+  if (typeof tokens !== "object" || tokens === null) return null;
+  const record = tokens;
+  if (typeof record.input !== "number" || typeof record.output !== "number") return null;
+  const cache = typeof record.cache === "object" && record.cache !== null ? record.cache : {};
+  return {
+    input_tokens: record.input,
+    output_tokens: record.output,
+    cache_read_input_tokens: typeof cache.read === "number" ? cache.read : 0,
+    cache_creation_input_tokens: typeof cache.write === "number" ? cache.write : 0
+  };
+}
+function scanStream(stdout) {
+  const scan = { texts: [], costUsd: 0, turns: 0 };
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const part = event.part ?? {};
+    if (event.type === "text" && typeof part.text === "string") {
+      scan.texts.push(part.text);
+    } else if (event.type === "step_finish") {
+      scan.turns += 1;
+      if (typeof part.cost === "number") scan.costUsd = part.cost;
+      const tokens = tokensOf(part);
+      if (tokens) scan.usage = tokens;
+    } else if (event.type === "error") {
+      const detail = event.error;
+      const data = detail?.data;
+      const name = typeof detail?.name === "string" ? detail.name : "opencode error";
+      const message = typeof data?.message === "string" ? data.message : JSON.stringify(detail);
+      scan.error = `${name}: ${message}`;
+    }
+  }
+  return scan;
+}
+function parseOpencodeStream(stdout) {
+  const scan = scanStream(stdout);
+  const output = scan.texts.join("");
+  if (scan.error) return { output: "", costUsd: scan.costUsd, error: scan.error };
+  if (!output) return { output: "", costUsd: scan.costUsd, error: "opencode returned no text" };
+  return { output, costUsd: scan.costUsd, usage: scan.usage, numTurns: scan.turns };
+}
+var LOG_TAIL_BYTES = 512 * 1024;
+function opencodeLogPath() {
+  return join7(homedir2(), ".local", "share", "opencode", "log", "opencode.log");
+}
+function loggedErrorForRun(logText, directory) {
+  const quotedDirectory = `directory="${directory.replace(/\\/g, "\\\\")}"`;
+  const lines = logText.split("\n");
+  const created = lines.find(
+    (line) => line.includes("message=created") && line.includes(quotedDirectory)
+  );
+  const runId = created === void 0 ? void 0 : / run=(\S+)/.exec(created)?.[1];
+  if (runId === void 0) return null;
+  const errors = lines.filter(
+    (line) => line.includes(` run=${runId} `) && line.includes('message="stream error"')
+  );
+  const answer = errors.find((line) => line.includes("small=false")) ?? errors[0];
+  if (answer === void 0) return null;
+  return /error\.error="(.*)"\s*$/.exec(answer)?.[1] ?? null;
+}
+function readLogTail() {
+  try {
+    const path = opencodeLogPath();
+    const size = statSync2(path).size;
+    if (size <= LOG_TAIL_BYTES) return readFileSync6(path, "utf8");
+    const fd = openSync(path, "r");
+    try {
+      const buffer = Buffer.alloc(LOG_TAIL_BYTES);
+      readSync(fd, buffer, 0, LOG_TAIL_BYTES, size - LOG_TAIL_BYTES);
+      const text = buffer.toString("utf8");
+      return text.slice(text.indexOf("\n") + 1);
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    return "";
+  }
+}
+function runOpencode(cwd, prompt, budgetUsd, options = {}, history) {
+  const command = process.env.HAHAHAH_OPENCODE_BIN ?? "opencode";
+  const input = withTranscript(history, prompt);
+  const startedAt = Date.now();
+  const configDir = mkdtempSync3(join7(scratchRoot(), "hahahah-opencode-cfg-"));
+  const configPath = join7(configDir, "opencode.json");
+  writeFileSync6(configPath, opencodeStudyConfig(), "utf8");
+  const args = opencodeArgs(cwd, options);
+  const invocation = process.platform === "win32" ? (
+    // opencode on this machine is a .cmd shim, which spawnSync cannot exec directly
+    // (measured: `spawnSync opencode ENOENT`). Same wrapper runClaude uses.
+    spawnSync4(
+      process.env.ComSpec ?? "cmd.exe",
+      ["/d", "/s", "/c", [command, ...args].join(" ")],
+      {
+        cwd,
+        input,
+        encoding: "utf8",
+        timeout: options.timeoutMs ?? 18e4,
+        env: { ...process.env, OPENCODE_CONFIG: configPath }
+      }
+    )
+  ) : spawnSync4(command, args, {
+    cwd,
+    input,
+    encoding: "utf8",
+    timeout: options.timeoutMs ?? 18e4,
+    env: { ...process.env, OPENCODE_CONFIG: configPath }
+  });
+  const elapsed = () => Date.now() - startedAt;
+  if (invocation.error) {
+    const reported = scanStream(invocation.stdout ?? "").error;
+    const logged = loggedErrorForRun(readLogTail(), cwd);
+    const said = reported ?? logged;
+    return {
+      output: "",
+      costUsd: 0,
+      durationMs: elapsed(),
+      error: said === null || said === void 0 ? invocation.error.message : said
+    };
+  }
+  const stdout = (invocation.stdout ?? "").trim();
+  if (invocation.status !== 0 && !stdout) {
+    return {
+      output: "",
+      costUsd: 0,
+      durationMs: elapsed(),
+      error: (invocation.stderr ?? "").trim() || `opencode exited ${String(invocation.status)}`
+    };
+  }
+  const run = parseOpencodeStream(stdout);
+  run.durationMs = elapsed();
+  if (!run.error && run.costUsd > budgetUsd) {
+    return {
+      ...run,
+      error: `run cost $${run.costUsd.toFixed(4)} exceeded the $${budgetUsd} ceiling`
+    };
+  }
+  return run;
+}
+
+// src/cli.ts
+var HARNESS_ADAPTERS = {
+  claude: "claude-code",
+  opencode: "opencode"
+};
+function harnessOf(value) {
+  const kind = value ?? "claude";
+  if (!Object.keys(HARNESS_ADAPTERS).includes(kind)) {
+    throw new Error(`unknown --harness ${String(value)}: use claude or opencode`);
+  }
+  return kind;
+}
+function runnerFor(harness, options) {
+  const kind = harnessOf(harness);
+  if (kind === "opencode") {
+    return (cwd, prompt, budgetUsd, history) => runOpencode(cwd, prompt, budgetUsd, { model: options.model }, history);
+  }
+  return (cwd, prompt, budgetUsd, history) => runClaude(cwd, prompt, budgetUsd, options, history);
+}
+function printUsage() {
+  console.log(`Anti-Yapping (+62 Terse & Ponytail Surgical Diffs)
+
+Usage:
+  npx anti-yapping install [--target <repo>] [--adapter <name>] [--scope workspace|global] [--dry-run] [--force]
+  npx anti-yapping update [--target <repo>] [--dry-run] [--force]
+  npx anti-yapping uninstall [--target <repo>] [--dry-run] [--force]
+  npx anti-yapping doctor [--target <repo>]
+  npx anti-yapping measure [--profile <id>] [--adapter fake|claude-code|opencode|agents-md|antigravity]
+  npx anti-yapping build [--profile <id>] [--adapter fake|claude-code|opencode|agents-md|antigravity] [--out <dir>] [--release]
+
+Which --adapter to pass, by the agent you run (install into the project you want it active in):
+  Claude Code          --adapter claude-code    writes CLAUDE.md + .claude/skills/
+  opencode             --adapter opencode       writes AGENTS.md + .claude/skills/ (opencode reads that tree)
+  Antigravity          --adapter antigravity    writes AGENTS.md + .agents/rules/*.md; add --scope global with --target ~/.gemini for every project
+  Cursor / Codex / Qoder CLI / anything reading AGENTS.md
+                       --adapter agents-md      writes AGENTS.md + .agents/skills/
+Omitting --adapter installs for Claude Code. Uninstall needs only --target; the manifest remembers the rest.
+`);
+}
+function positiveInt(value, flag, fallback) {
+  if (value === void 0) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`${flag} must be a positive integer`);
+  }
+  return parsed;
+}
+function positiveNumber(value, flag) {
+  const parsed = Number.parseFloat(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${flag} must be a positive number`);
+  }
+  return parsed;
+}
+function printStudy(report) {
+  const oneLine = (text) => text.replace(/\s+/g, " ").trim();
+  console.log(
+    `coding study: ${report.fixtures_run} fixture(s) x ${report.repeats} repeat(s) x ${report.arms.length} arm(s) [${report.arms.join("+")}], cost $${report.total_cost_usd.toFixed(4)}`
+  );
+  for (const result of report.results) {
+    const state = (arm) => {
+      if (arm.grades.length === 0) return "not run";
+      if (arm.grades.every((grade) => grade === "error")) {
+        return `error (${oneLine(arm.runs[0]?.run.error ?? "no runs")})`;
+      }
+      return `${arm.grades.join(",")} solved ${arm.solved}/${arm.runs.length}`;
+    };
+    console.log(
+      `- ${result.fixture.id}${result.fixture.hidden ? " (hidden)" : ""}: baseline=${state(result.baseline)}, treatment=${state(result.treatment)}`
+    );
+  }
+  const tallyLine = (name) => {
+    const tally2 = report.summary[name];
+    return `grades: ${name} solved ${tally2.solved} failed ${tally2.failed} tampered ${tally2.tampered} untouched ${tally2.untouched} error ${tally2.error}`;
+  };
+  for (const arm of report.arms) {
+    console.log(tallyLine(arm));
+  }
+  if (report.hidden_run > 0) {
+    console.log(
+      `hidden holdout (${report.hidden_run} fixture(s)): baseline solved ${report.summary.holdout.baseline.solved}, treatment solved ${report.summary.holdout.treatment.solved}`
+    );
+  }
+  const errored = report.results.flatMap((result) => [...result.baseline.runs, ...result.treatment.runs]).some((run) => run.grade === "error");
+  if (errored) process.exitCode = 1;
+}
+function formatReport(result) {
+  const lines = [
+    `profile: ${result.manifest.profile}`,
+    `persona: ${result.manifest.persona}`,
+    `adapter: ${result.manifest.adapter}`,
+    `tokenizer: ${result.manifest.tokenizer}`,
+    `content_hash: ${result.manifest.content_hash}`
+  ];
+  for (const [name, report] of Object.entries(result.manifest.budgets)) {
+    lines.push(
+      `${name}: ${report.tokens}/${report.target} (${report.status}; hard cap ${report.hardCap})`
+    );
+  }
+  if (result.warnings.length > 0) {
+    lines.push("warnings:");
+    for (const warning of result.warnings) {
+      lines.push(`- ${warning}`);
+    }
+  }
+  return lines.join("\n");
+}
+function isMainEntry() {
+  const invoked = process.argv[1];
+  if (!invoked) return false;
+  return fileURLToPath2(import.meta.url) === resolve6(invoked);
+}
+var packageRoot = resolve6(fileURLToPath2(import.meta.url), "..", "..");
+function getCliVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync7(join8(packageRoot, "package.json"), "utf8"));
+    return pkg.version ?? "0.1.0";
+  } catch {
+    return "0.1.0";
+  }
+}
+if (isMainEntry()) {
+  const version = getCliVersion();
+  const updateCheck = checkRemoteUpdate(version);
+  try {
+    const parsed = parseArgs({
+      allowPositionals: true,
+      strict: true,
+      options: {
+        profile: { type: "string", default: "anti-yapping" },
+        adapter: { type: "string" },
+        target: { type: "string", default: process.cwd() },
+        out: { type: "string" },
+        suite: { type: "string", default: "smoke" },
+        task: { type: "string", multiple: true, default: [] },
+        id: { type: "string", multiple: true, default: [] },
+        limit: { type: "string" },
+        repeats: { type: "string" },
+        "budget-usd": { type: "string", default: "0.10" },
+        "max-total-usd": { type: "string" },
+        model: { type: "string" },
+        harness: { type: "string" },
+        scope: { type: "string" },
+        arm: { type: "string" },
+        "setting-sources": { type: "string" },
+        release: { type: "boolean", default: false },
+        "dry-run": { type: "boolean", default: false },
+        force: { type: "boolean", default: false },
+        strict: { type: "boolean", default: false },
+        live: { type: "boolean", default: false },
+        dir: { type: "string" },
+        help: { type: "boolean", short: "h", default: false }
+      }
+    });
+    const command = parsed.positionals[0];
+    if (!command || parsed.values.help) {
+      printUsage();
+      process.exitCode = command ? 0 : 1;
+    } else if (command === "build" || command === "measure") {
+      const result = build({
+        root: packageRoot,
+        profileId: parsed.values.profile,
+        adapterId: parsed.values.adapter ?? "fake",
+        outDir: parsed.values.out,
+        release: parsed.values.release,
+        write: command === "build"
+      });
+      console.log(formatReport(result));
+      if (command === "build") {
+        console.log(`out: ${result.outDir}`);
+      }
+    } else if (command === "install") {
+      const scope = parsed.values.scope ?? "workspace";
+      const result = install({
+        sourceRoot: packageRoot,
+        targetRoot: parsed.values.target,
+        profileId: parsed.values.profile,
+        adapterId: parsed.values.adapter ?? "claude-code",
+        scope,
+        dryRun: parsed.values["dry-run"],
+        force: parsed.values.force
+      });
+      console.log(
+        `${result.dryRun ? "Dry run: would install" : "Installed"} ${result.manifest.profile} into ${result.targetRoot} (${scope} scope)`
+      );
+      console.log(
+        `files: ${result.manifest.files.length} managed file(s) + ${result.manifest.block.path} block`
+      );
+      for (const warning of result.warnings) {
+        console.log(`warning: ${warning}`);
+      }
+    } else if (command === "update") {
+      const result = update({
+        sourceRoot: packageRoot,
+        targetRoot: parsed.values.target,
+        dryRun: parsed.values["dry-run"],
+        force: parsed.values.force
+      });
+      console.log(
+        `${result.dryRun ? "Dry run: would update" : "Updated"} ${result.manifest.profile} (${result.manifest.adapter}) in ${result.targetRoot}`
+      );
+      console.log(
+        `files: ${result.manifest.files.length} managed file(s) + ${result.manifest.block.path} block`
+      );
+      for (const warning of result.warnings) {
+        console.log(`warning: ${warning}`);
+      }
+    } else if (command === "uninstall") {
+      uninstall({
+        targetRoot: parsed.values.target,
+        dryRun: parsed.values["dry-run"],
+        force: parsed.values.force
+      });
+      console.log(
+        `${parsed.values["dry-run"] ? "Dry run: would uninstall" : "Uninstalled"} from ${parsed.values.target}`
+      );
+    } else if (command === "doctor") {
+      const report = doctor({ targetRoot: parsed.values.target });
+      for (const warning of report.warnings) {
+        console.log(`warning: ${warning}`);
+      }
+      if (!report.ok) {
+        for (const error of report.errors) {
+          console.error(`error: ${error}`);
+        }
+        process.exitCode = 1;
+      } else {
+        console.log(`doctor: ok (${parsed.values.target})`);
+      }
+    } else if (command === "fixtures") {
+      const action = parsed.positionals[1] ?? "check";
+      if (action === "check") {
+        const checks = checkAll(process.cwd(), parsed.values.dir ?? "fixtures");
+        for (const check of checks) {
+          const label = check.ok ? "ok  " : "FAIL";
+          const holdout = check.hidden ? " (hidden)" : "";
+          console.log(`${label} ${check.id}${holdout}: ${check.detail}`);
+        }
+        const failed = checks.filter((check) => !check.ok);
+        const hidden = checks.filter((check) => check.hidden).length;
+        console.log(
+          `fixtures: ${checks.length - failed.length}/${checks.length} valid, ${hidden} marked hidden holdout`
+        );
+        if (failed.length > 0) {
+          process.exitCode = 1;
+        }
+      } else if (action === "run") {
+        const all = loadFixtures(process.cwd(), parsed.values.dir ?? "fixtures");
+        let fixtures = all;
+        if (parsed.values.id.length > 0) {
+          const known = new Set(all.map((fixture) => fixture.id));
+          const unknown = parsed.values.id.filter((id) => !known.has(id));
+          if (unknown.length > 0) {
+            throw new Error(`Unknown fixture id(s): ${unknown.join(", ")}`);
+          }
+          fixtures = all.filter((fixture) => parsed.values.id.includes(fixture.id));
+        }
+        const limit = parsed.values.limit ? positiveInt(parsed.values.limit, "--limit", fixtures.length) : void 0;
+        const repeats = positiveInt(parsed.values.repeats, "--repeats", 1);
+        const budget = positiveNumber(parsed.values["budget-usd"], "--budget-usd");
+        const arm = parsed.values.arm ?? "both";
+        if (arm !== "both" && arm !== "baseline" && arm !== "treatment") {
+          throw new Error("--arm must be both, baseline, or treatment");
+        }
+        const armCount = arm === "both" ? 2 : 1;
+        const ceiling = parsed.values["max-total-usd"] ? positiveNumber(parsed.values["max-total-usd"], "--max-total-usd") : 0;
+        const count = limit === void 0 ? fixtures.length : Math.min(limit, fixtures.length);
+        const harness = harnessOf(parsed.values.harness);
+        const projected = projectedCostUsd(count, repeats, budget, armCount);
+        const hidden = fixtures.slice(0, count).filter((fixture) => fixture.hidden).length;
+        console.log(
+          `plan: running ${count} of ${fixtures.length} selected fixture(s) (${hidden} marked hidden holdout), ${repeats} repeat(s), ${armCount} arm(s) [${arm}], $${budget.toFixed(2)} per run, harness ${harness}`
+        );
+        console.log(
+          `projected cost of the caps: $${projected.toFixed(2)} \u2014 not a ceiling: the harness checks its budget between turns, so a capped run overshoots (measured 1.17x and 1.46x of --budget-usd on 2026-11-04)`
+        );
+        if (!parsed.values.live) {
+          console.log(
+            "dry run: no model was called and nothing was spent. Add --live with --max-total-usd to run it."
+          );
+        } else {
+          if (ceiling === 0) {
+            throw new Error(
+              `--live needs --max-total-usd: this campaign projects $${projected.toFixed(2)}, state the approved ceiling`
+            );
+          }
+          if (projected > ceiling) {
+            throw new Error(
+              `projected $${projected.toFixed(2)} exceeds the approved ceiling of $${ceiling.toFixed(2)}: lower --limit, --repeats, or --budget-usd`
+            );
+          }
+          if (armCount === 1) {
+            console.log(
+              'single arm: this run cannot compare baseline against treatment, it only answers "did the harness behave"'
+            );
+          }
+          const report = runFixtureStudy({
+            sourceRoot: process.cwd(),
+            profileId: parsed.values.profile,
+            fixtures,
+            limit,
+            repeats,
+            budgetUsd: budget,
+            arm,
+            model: parsed.values.model,
+            settingSources: parsed.values["setting-sources"],
+            adapterId: HARNESS_ADAPTERS[harness],
+            runner: (cwd, prompt, runBudget) => harness === "opencode" ? runOpencode(cwd, prompt, runBudget, { model: parsed.values.model }) : runClaude(cwd, prompt, runBudget, {
+              model: parsed.values.model,
+              settingSources: parsed.values["setting-sources"],
+              // Edits are the one thing the agent must be able to do; shell and network
+              // stay denied, so the grade comes from the tests this tool runs afterwards.
+              agentArgs: ["--permission-mode", "acceptEdits", "--permission-prompts", "none"]
+            }),
+            outDir: parsed.values.out ?? join8(process.cwd(), ".hahahah", "coding")
+          });
+          printStudy(report);
+        }
+      } else if (action === "diagnose") {
+        const ids = parsed.values.id;
+        if (ids.length !== 1) {
+          throw new Error("fixtures diagnose needs exactly one --id <fixture>");
+        }
+        const arm = parsed.values.arm ?? "treatment";
+        if (arm !== "baseline" && arm !== "treatment") {
+          throw new Error("--arm must be baseline or treatment for a single-arm diagnostic");
+        }
+        const fixture = loadFixtures(process.cwd(), parsed.values.dir ?? "fixtures").find(
+          (candidate) => candidate.id === ids[0]
+        );
+        if (!fixture) {
+          throw new Error(`Unknown fixture id(s): ${ids[0]}`);
+        }
+        const budget = positiveNumber(parsed.values["budget-usd"], "--budget-usd");
+        const projected = projectedCostUsd(1, 1, budget, 1);
+        const ceiling = parsed.values["max-total-usd"] ? positiveNumber(parsed.values["max-total-usd"], "--max-total-usd") : 0;
+        console.log(
+          `diagnostic: ${fixture.id}, one arm [${arm}], $${budget.toFixed(2)} per run, projected $${projected.toFixed(2)} (caps are soft, see docs/phase-3-live-suite-results.md)`
+        );
+        if (!parsed.values.live) {
+          console.log("dry run: no model was called. Add --live with --max-total-usd to run it.");
+        } else {
+          if (ceiling === 0) {
+            throw new Error(
+              `--live needs --max-total-usd: this diagnostic projects $${projected.toFixed(2)}`
+            );
+          }
+          if (projected > ceiling) {
+            throw new Error(
+              `projected $${projected.toFixed(2)} exceeds the approved ceiling of $${ceiling.toFixed(2)}`
+            );
+          }
+          const result = diagnoseFixture({
+            sourceRoot: process.cwd(),
+            profileId: parsed.values.profile,
+            fixture,
+            arm,
+            budgetUsd: budget,
+            model: parsed.values.model,
+            settingSources: parsed.values["setting-sources"],
+            outDir: parsed.values.out ?? join8(process.cwd(), ".hahahah", "diagnostic")
+          });
+          const { summary, graded } = result;
+          const tools = Object.entries(summary.tools).map(([name, count]) => `${name} x${count}`).join(", ");
+          console.log(
+            `stream: subtype=${summary.subtype ?? "?"} turns=${summary.numTurns ?? "?"} cost=$${(summary.totalCostUsd ?? 0).toFixed(4)} events=${summary.lines}`
+          );
+          console.log(`tools attempted: ${tools || "none"}`);
+          for (const denial of summary.denials) {
+            console.log(`DENIED: ${denial}`);
+          }
+          for (const error of summary.toolErrors) {
+            console.log(`tool error: ${error}`);
+          }
+          console.log(
+            `workspace: changed=[${graded.changedFiles.join(", ")}] new=[${graded.otherNewFiles.join(", ")}] missing=[${graded.missingFiles.join(", ")}]`
+          );
+          console.log(`grade=${graded.grade} tests pass=${graded.pass} fail=${graded.fail}`);
+          console.log(`raw stream kept: ${result.rawPath}`);
+          console.log(`workspace kept for inspection: ${result.workspace} (delete when done)`);
+          if (graded.run.error) {
+            process.exitCode = 1;
+          }
+        }
+      } else {
+        printUsage();
+        process.exitCode = 1;
+      }
+    } else if (command === "eval") {
+      const suite = loadSuite(process.cwd(), parsed.values.suite);
+      const limit = parsed.values.limit ? Number.parseInt(parsed.values.limit, 10) : void 0;
+      const repeats = parsed.values.repeats ? Number.parseInt(parsed.values.repeats, 10) : 1;
+      const budget = Number.parseFloat(parsed.values["budget-usd"]);
+      if (limit !== void 0 && (!Number.isInteger(limit) || limit <= 0)) {
+        throw new Error("--limit must be a positive integer");
+      }
+      if (!Number.isInteger(repeats) || repeats < 1) {
+        throw new Error("--repeats must be a positive integer");
+      }
+      if (!Number.isFinite(budget) || budget <= 0) {
+        throw new Error("--budget-usd must be a positive number");
+      }
+      let tasks = suite.tasks;
+      if (parsed.values.task.length > 0) {
+        const known = new Set(suite.tasks.map((task) => task.id));
+        const unknown = parsed.values.task.filter((id) => !known.has(id));
+        if (unknown.length > 0) {
+          throw new Error(`Unknown task id(s): ${unknown.join(", ")} in suite ${suite.suite}`);
+        }
+        tasks = suite.tasks.filter((task) => parsed.values.task.includes(task.id));
+      }
+      const harness = harnessOf(parsed.values.harness);
+      const report = runEval({
+        sourceRoot: process.cwd(),
+        profileId: parsed.values.profile,
+        tasks,
+        suite: suite.suite,
+        limit,
+        repeats,
+        budgetUsd: budget,
+        model: parsed.values.model,
+        settingSources: parsed.values["setting-sources"],
+        adapterId: HARNESS_ADAPTERS[harness],
+        harness,
+        runner: runnerFor(harness, {
+          model: parsed.values.model,
+          settingSources: parsed.values["setting-sources"]
+        }),
+        // The runner is injected here so the harness can be chosen, which would otherwise disable
+        // the auto-probe. A real campaign always talks to a real gateway, so it must always probe.
+        probe: true,
+        outDir: parsed.values.out ?? join8(process.cwd(), ".hahahah", "eval")
+      });
+      const runs = report.results.reduce(
+        (total, result) => total + result.baseline.runs.length + result.treatment.runs.length,
+        0
+      );
+      console.log(
+        `eval: ${report.results.length} task(s) x ${report.repeats} repeat(s) = ${runs} runs, cost $${report.total_cost_usd.toFixed(4)}`
+      );
+      if (report.aborted) {
+        const cause = report.aborted.kind === "quota" ? "the provider refused further requests" : "consecutive runs were answered with nothing at all - the harness or route is not answering";
+        console.log(
+          `ABORTED after ${report.aborted.afterRuns} run(s): ${cause} (${report.aborted.reason.slice(0, 120)}). Not measured: ${report.aborted.remainingTasks.join(", ") || `${report.aborted.partialTask} (partial)`}. Nothing further was spent.`
+        );
+      }
+      for (const result of report.results) {
+        const state = (arm) => {
+          if (arm.consensus === "error") return `ERROR: ${arm.runs[0]?.error ?? "no runs"}`;
+          const passed = arm.runStatuses.filter((status) => status === "pass").length;
+          const findings = [...new Set(arm.screens.findings)];
+          const detail = findings.length > 0 ? ` (${findings.join("; ")})` : "";
+          return `${arm.consensus} ${passed}/${arm.runs.length} med $${arm.median.costUsd.toFixed(4)}${detail}`;
+        };
+        console.log(
+          `- ${result.task.id}: baseline=${state(result.baseline)}, treatment=${state(result.treatment)}`
+        );
+      }
+      const { baseline, treatment } = report.summary;
+      if (report.summary.tasks_with_checks > 0) {
+        console.log(
+          `screens: baseline ${baseline.pass} pass / ${baseline.fail} fail / ${baseline.unknown} unknown; treatment ${treatment.pass} pass / ${treatment.fail} fail / ${treatment.unknown} unknown`
+        );
+      }
+      const failedRun = report.results.flatMap((result) => [...result.baseline.runs, ...result.treatment.runs]).find((run) => run.error);
+      if (failedRun) {
+        process.exitCode = 1;
+      } else if (parsed.values.strict && treatment.fail > 0) {
+        console.error(`strict: ${treatment.fail} treatment screen(s) failed across repeats`);
+        process.exitCode = 1;
+      }
+    } else {
+      printUsage();
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    if (error instanceof BuildError || error instanceof InstallError) {
+      console.error(`Command failed: ${error.message}`);
+    } else {
+      console.error(error);
+    }
+    process.exitCode = 1;
+  } finally {
+    try {
+      const latest = await updateCheck;
+      if (latest) {
+        console.error(formatUpdateNotice(version, latest));
+      }
+    } catch {
+    }
+  }
+}
+export {
+  runnerFor
+};