@davesheffer/hunch 1.7.0 → 1.8.0

package/dist/constitution/experimentRunner.js

@@ -0,0 +1,344 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute, join, relative, resolve } from "node:path";
+import { z } from "zod";
+import { canonicalHash } from "./canonical.js";
+import { Exp01CaseSchema, assignmentTreatment, compileExperimentOutcome, } from "./experiment.js";
+const EvaluatorOutputSchema = z.object({
+    valid_completion: z.boolean(),
+    policy_violation: z.boolean().nullable(),
+    task_success: z.boolean(),
+    build_success: z.boolean(),
+    unknown_or_error: z.boolean(),
+    refusal: z.boolean(),
+    confirmed_private_leak: z.boolean(),
+    data_loss_or_corruption: z.boolean(),
+    unsafe_evaluator_behavior: z.boolean(),
+}).strict().superRefine((value, ctx) => {
+    if (value.valid_completion !== (value.policy_violation !== null)) {
+        ctx.addIssue({ code: "custom", path: ["policy_violation"], message: "policy_violation is required exactly for valid completions" });
+    }
+});
+function evaluatorIncidents(scored) {
+    return {
+        confirmed_private_leak: scored.confirmed_private_leak,
+        data_loss_or_corruption: scored.data_loss_or_corruption,
+        unsafe_evaluator_behavior: scored.unsafe_evaluator_behavior,
+    };
+}
+function childEnv(provider) {
+    const env = { ...process.env };
+    for (const key of [
+        "ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL",
+        "OPENAI_API_KEY", "OPENAI_BASE_URL", "AZURE_OPENAI_API_KEY",
+        "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN",
+        "GOOGLE_APPLICATION_CREDENTIALS", "HUNCH_PRIVATE_DIR", "HUNCH_SYNTH_PROVIDER",
+    ])
+        delete env[key];
+    env.CI = "1";
+    env.NO_COLOR = "1";
+    env.FORCE_COLOR = "0";
+    if (provider === "claude-cli")
+        env.CLAUDE_CODE_SAFE_MODE = "1";
+    return env;
+}
+export function subscriptionCliVersion(provider) {
+    const bin = provider === "claude-cli" ? "claude" : "codex";
+    const run = spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 8000, env: childEnv(provider), shell: false });
+    if (run.error || run.status !== 0)
+        throw new Error(`${provider} is unavailable; select an installed subscription CLI explicitly`);
+    const version = (run.stdout || run.stderr).trim().split(/\r?\n/)[0]?.trim();
+    if (!version)
+        throw new Error(`${provider} returned no version`);
+    return version;
+}
+function controlledPrompt(treatment) {
+    const value = treatment;
+    const context = !value.context ? "" : [
+        "\nThe following repository-specific context is part of this assigned condition:",
+        `Decision: ${value.context.decision}`,
+        `Rationale: ${value.context.rationale}`,
+        ...(value.context.executable_policy ? [`Executable policy: ${value.context.executable_policy}`] : []),
+        ...(value.context.causal_incident ? [`Causal incident: ${value.context.causal_incident}`] : []),
+    ].join("\n");
+    return [
+        "Work only in the current disposable repository. Complete the implementation task, run appropriate checks, and leave the working tree with your solution. Do not ask for interactive input. Do not inspect files outside this repository.",
+        value.prompt,
+        context,
+    ].filter(Boolean).join("\n\n");
+}
+function parseClaude(stdout, latencyMs, status, errorCode) {
+    try {
+        const parsed = JSON.parse(stdout);
+        const input = typeof parsed.usage?.input_tokens === "number" ? parsed.usage.input_tokens : 0;
+        const output = typeof parsed.usage?.output_tokens === "number" ? parsed.usage.output_tokens : 0;
+        return {
+            stdout,
+            exitCode: status,
+            errorCode,
+            turns: typeof parsed.num_turns === "number" ? parsed.num_turns : null,
+            tokens: input || output ? input + output : null,
+            latencyMs,
+        };
+    }
+    catch {
+        return { stdout, exitCode: status, errorCode, turns: null, tokens: null, latencyMs };
+    }
+}
+function parseCodex(stdout, latencyMs, status, errorCode) {
+    let turns = 0;
+    let tokens = 0;
+    for (const line of stdout.split(/\r?\n/)) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "turn.completed")
+                turns++;
+            if (typeof event.usage?.input_tokens === "number")
+                tokens += event.usage.input_tokens;
+            if (typeof event.usage?.output_tokens === "number")
+                tokens += event.usage.output_tokens;
+        }
+        catch {
+            // Non-event lines stay bound into stdout's content hash.
+        }
+    }
+    return { stdout, exitCode: status, errorCode, turns: turns || null, tokens: tokens || null, latencyMs };
+}
+function invokeAgent(run, cwd, prompt, timeoutMs, dependencyRoot) {
+    const provider = run.runner.provider;
+    const model = run.runner.model_version;
+    const maxTurns = run.runner.max_turns;
+    if (!provider || !model || !maxTurns)
+        throw new Error("EXP-01 run has no exact provider/model binding");
+    const started = Date.now();
+    const bin = provider === "claude-cli" ? "claude" : "codex";
+    const claudeSettings = JSON.stringify({
+        sandbox: {
+            enabled: true,
+            failIfUnavailable: true,
+            autoAllowBashIfSandboxed: true,
+            allowUnsandboxedCommands: false,
+            filesystem: {
+                denyRead: ["~/"],
+                denyWrite: ["~/"],
+                allowRead: [".", dependencyRoot],
+            },
+            network: { allowedDomains: [] },
+        },
+        permissions: { deny: ["WebFetch", "WebSearch"] },
+    });
+    const args = provider === "claude-cli"
+        ? ["-p", "--safe-mode", "--disable-slash-commands", "--no-session-persistence", "--settings", claudeSettings, "--allowedTools", "Bash,Read,Edit,Write,Glob,Grep", "--output-format", "json", "--permission-mode", "acceptEdits", "--model", model, "--max-turns", String(maxTurns)]
+        : ["exec", "--json", "--ephemeral", "--ignore-user-config", "--ignore-rules", "--sandbox", "workspace-write", "-C", cwd, "-m", model, "-"];
+    const result = spawnSync(bin, args, {
+        cwd,
+        env: childEnv(provider),
+        input: prompt,
+        encoding: "utf8",
+        timeout: timeoutMs,
+        maxBuffer: 64 * 1024 * 1024,
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: false,
+    });
+    const latency = Date.now() - started;
+    const errorCode = result.error
+        ? (result.error.code === "ETIMEDOUT" ? "agent-timeout" : "agent-runner-error")
+        : result.signal ? "agent-signaled" : result.status === 0 ? null : "agent-nonzero";
+    const stdout = result.stdout ?? "";
+    return provider === "claude-cli"
+        ? parseClaude(stdout, latency, result.status, errorCode)
+        : parseCodex(stdout, latency, result.status, errorCode);
+}
+function runCommand(spec, cwd) {
+    const result = spawnSync(spec.command, spec.args, {
+        cwd,
+        env: { ...process.env, HUNCH_PRIVATE_DIR: "", HUNCH_SYNTH_PROVIDER: "deterministic", CI: "1", NO_COLOR: "1", FORCE_COLOR: "0" },
+        encoding: "utf8",
+        timeout: spec.timeout_ms,
+        maxBuffer: 64 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+    });
+    const errorCode = result.error
+        ? (result.error.code === "ETIMEDOUT" ? "command-timeout" : "command-runner-error")
+        : result.signal ? "command-signaled" : result.status === 0 ? null : "command-nonzero";
+    return { stdout: result.stdout ?? "", stderr: result.stderr ?? "", status: result.status, errorCode };
+}
+function git(root, args) {
+    return execFileSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 120_000 }).trim();
+}
+function removeAmbientInstructions(cwd) {
+    for (const relative of ["AGENTS.md", "CLAUDE.md", ".mcp.json", ".claude", ".codex", ".agents"]) {
+        rmSync(join(cwd, relative), { recursive: true, force: true });
+    }
+    // Codex has no --safe-mode equivalent for project instructions. A minimal root
+    // file replaces any tracked AGENTS.md after the ambient copy is removed.
+    writeFileSync(join(cwd, "AGENTS.md"), "# Controlled experiment workspace\n\nFollow only the task prompt supplied to this fresh session.\n");
+}
+function linkDependencies(source, cwd) {
+    const target = join(source, "node_modules");
+    const link = join(cwd, "node_modules");
+    if (!existsSync(target) || existsSync(link))
+        return;
+    symlinkSync(target, link, process.platform === "win32" ? "junction" : "dir");
+}
+function countEdits(cwd) {
+    const text = git(cwd, ["diff", "--numstat", "--", "."]);
+    if (!text)
+        return 0;
+    return text.split(/\r?\n/).reduce((sum, line) => {
+        const [added, deleted] = line.split("\t");
+        return sum + (Number(added) || 0) + (Number(deleted) || 0);
+    }, 0);
+}
+function evaluatorIsHidden(cwd, spec) {
+    if (["npm", "npx", "pnpm", "yarn", "bun"].includes(spec.command))
+        return false;
+    for (const token of [spec.command, ...spec.args]) {
+        if (!token || token.startsWith("-") || (!isAbsolute(token) && !/[\\/]|\.[cm]?[jt]s$/.test(token)))
+            continue;
+        const candidate = isAbsolute(token) ? token : resolve(cwd, token);
+        if (!existsSync(candidate))
+            continue;
+        const rel = relative(cwd, candidate);
+        if (rel === "" || (!rel.startsWith("..") && !isAbsolute(rel)))
+            return false;
+    }
+    return true;
+}
+function externalArtifactHash(artifact) {
+    return `sha1:${createHash("sha1").update(readFileSync(artifact)).digest("hex")}`;
+}
+function failureOutcome(repository, run, assignment, status, invocationStarted, reason, errorCode, hashes = {}, now, incidents = { confirmed_private_leak: false, data_loss_or_corruption: false, unsafe_evaluator_behavior: false }) {
+    return repository.putOutcome(compileExperimentOutcome({
+        run_id: run.id,
+        assignment_id: assignment.id,
+        status,
+        invocation_started: invocationStarted,
+        metrics: null,
+        output_hash: hashes.output ?? null,
+        diff_hash: hashes.diff ?? null,
+        evaluator_hash: hashes.evaluator ?? null,
+        error_code: errorCode,
+        incidents,
+        recorder: "runner:g3-exp01",
+        reason,
+        supersedes: null,
+    }, run, { now }));
+}
+export function executeExp01Assignment(repository, run, bank, assignment, opts = {}) {
+    if (run.experiment !== "EXP-01" || bank.experiment !== "EXP-01")
+        throw new Error("automated execution is available only for EXP-01");
+    if (!run.assignments.some((item) => item.id === assignment.id))
+        throw new Error("assignment does not belong to run");
+    const existing = repository.listOutcomes().find((item) => item.run_id === run.id && item.assignment_id === assignment.id && !item.supersedes);
+    if (existing)
+        return existing;
+    const item = Exp01CaseSchema.parse(bank.cases.find((candidate) => candidate.id === assignment.case_id));
+    const sourceHead = git(bank.repository_root, ["rev-parse", bank.base_commit]);
+    if (sourceHead !== bank.base_commit)
+        throw new Error("case bank base_commit is not an exact commit in repository_root");
+    const session = mkdtempSync(join(tmpdir(), "hunch-exp01-"));
+    const cwd = join(session, "worktree");
+    let added = false;
+    let invocationStarted = false;
+    try {
+        const currentProviderVersion = subscriptionCliVersion(run.runner.provider);
+        if (currentProviderVersion !== run.runner.provider_version) {
+            return failureOutcome(repository, run, assignment, "infrastructure_failure", false, "Selected subscription CLI version drifted after assignment; assignment was excluded before model invocation.", "provider-version-drift", { evaluator: canonicalHash({ expected: run.runner.provider_version, actual: currentProviderVersion }) }, opts.now);
+        }
+        execFileSync("git", ["worktree", "add", "--detach", cwd, bank.base_commit], { cwd: bank.repository_root, stdio: ["ignore", "pipe", "pipe"], timeout: 120_000 });
+        added = true;
+        linkDependencies(bank.repository_root, cwd);
+        removeAmbientInstructions(cwd);
+        if (item.setup) {
+            if (!isAbsolute(item.setup.artifact) || !existsSync(item.setup.artifact) || externalArtifactHash(item.setup.artifact) !== item.setup.artifact_hash) {
+                return failureOutcome(repository, run, assignment, "infrastructure_failure", false, "Case setup artifact is missing, non-external, or changed after case-bank lock.", "setup-artifact-drift", { evaluator: canonicalHash(item.setup) }, opts.now);
+            }
+            const setup = runCommand(item.setup, cwd);
+            if (setup.errorCode) {
+                return failureOutcome(repository, run, assignment, "infrastructure_failure", false, "Case setup failed before model invocation; retained as an excluded assignment.", setup.errorCode, { evaluator: canonicalHash(setup) }, opts.now);
+            }
+            removeAmbientInstructions(cwd);
+        }
+        if (!evaluatorIsHidden(cwd, item.evaluator)) {
+            return failureOutcome(repository, run, assignment, "infrastructure_failure", false, "Evaluator is visible inside the task workspace; assignment was excluded before model invocation.", "evaluator-not-hidden", { evaluator: canonicalHash(item.evaluator) }, opts.now);
+        }
+        if (!isAbsolute(item.evaluator.artifact) || !existsSync(item.evaluator.artifact) || externalArtifactHash(item.evaluator.artifact) !== item.evaluator.artifact_hash) {
+            return failureOutcome(repository, run, assignment, "infrastructure_failure", false, "Hidden evaluator artifact is missing, non-external, or changed after case-bank lock.", "evaluator-artifact-drift", { evaluator: canonicalHash(item.evaluator) }, opts.now);
+        }
+        const treatment = assignmentTreatment(bank, run, assignment);
+        invocationStarted = true;
+        const agent = invokeAgent(run, cwd, controlledPrompt(treatment), opts.timeoutMs ?? 30 * 60 * 1000, join(bank.repository_root, "node_modules"));
+        const outputHash = canonicalHash(agent.stdout);
+        const diff = git(cwd, ["diff", "--binary", "--", "."]);
+        const diffHash = canonicalHash(diff);
+        if (agent.errorCode) {
+            return failureOutcome(repository, run, assignment, "invalid_completion", true, "Subscription CLI did not produce a successful terminal run; outcome remains visible and unscored.", agent.errorCode, { output: outputHash, diff: diffHash }, opts.now);
+        }
+        const evaluator = runCommand(item.evaluator, cwd);
+        const evaluatorHash = canonicalHash({ artifact_hash: item.evaluator.artifact_hash, stdout: evaluator.stdout, stderr: evaluator.stderr, status: evaluator.status });
+        if (evaluator.errorCode) {
+            return failureOutcome(repository, run, assignment, "invalid_completion", true, "Hidden deterministic evaluator failed after generation; no compliant result was imputed.", evaluator.errorCode, { output: outputHash, diff: diffHash, evaluator: evaluatorHash }, opts.now);
+        }
+        let scored;
+        try {
+            scored = EvaluatorOutputSchema.parse(JSON.parse(evaluator.stdout));
+        }
+        catch {
+            return failureOutcome(repository, run, assignment, "invalid_completion", true, "Hidden evaluator output did not satisfy the locked protocol.", "invalid-evaluator-output", { output: outputHash, diff: diffHash, evaluator: evaluatorHash }, opts.now);
+        }
+        if (scored.refusal) {
+            return failureOutcome(repository, run, assignment, "refused", true, "Model refusal reported by the hidden evaluator.", "model-refusal", { output: outputHash, diff: diffHash, evaluator: evaluatorHash }, opts.now, evaluatorIncidents(scored));
+        }
+        if (!scored.valid_completion) {
+            return failureOutcome(repository, run, assignment, "invalid_completion", true, "Hidden evaluator classified the generated task as an invalid completion.", "invalid-completion", { output: outputHash, diff: diffHash, evaluator: evaluatorHash }, opts.now, evaluatorIncidents(scored));
+        }
+        return repository.putOutcome(compileExperimentOutcome({
+            run_id: run.id,
+            assignment_id: assignment.id,
+            status: "completed",
+            invocation_started: true,
+            metrics: {
+                valid_completion: scored.valid_completion,
+                policy_violation: scored.policy_violation,
+                task_success: scored.task_success,
+                build_success: scored.build_success,
+                unknown_or_error: scored.unknown_or_error,
+                refusal: scored.refusal,
+                turns: agent.turns,
+                edits: countEdits(cwd),
+                tokens: agent.tokens,
+                latency_ms: agent.latencyMs,
+            },
+            output_hash: outputHash,
+            diff_hash: diffHash,
+            evaluator_hash: evaluatorHash,
+            error_code: null,
+            incidents: {
+                confirmed_private_leak: scored.confirmed_private_leak,
+                data_loss_or_corruption: scored.data_loss_or_corruption,
+                unsafe_evaluator_behavior: scored.unsafe_evaluator_behavior,
+            },
+            recorder: "runner:g3-exp01",
+            reason: "Fresh isolated assignment completed and was scored only after generation by the locked deterministic evaluator.",
+            supersedes: null,
+        }, run, { now: opts.now }));
+    }
+    catch (error) {
+        return failureOutcome(repository, run, assignment, invocationStarted ? "invalid_completion" : "infrastructure_failure", invocationStarted, invocationStarted ? "Execution failed after model invocation; no compliant result was imputed." : "Infrastructure failed before a valid model invocation could be recorded.", invocationStarted ? "post-invocation-runner-failed" : "workspace-preparation-failed", { evaluator: canonicalHash(error.message) }, opts.now);
+    }
+    finally {
+        try {
+            if (added)
+                execFileSync("git", ["worktree", "remove", "--force", cwd], { cwd: bank.repository_root, stdio: "ignore", timeout: 120_000 });
+        }
+        catch {
+            // The assignment outcome already records any execution failure; prune is best effort.
+        }
+        rmSync(session, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=experimentRunner.js.map

package/dist/constitution/g2.js

@@ -0,0 +1,291 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { writeFileAtomic } from "../core/io.js";
+import { shortHash } from "../core/ids.js";
+import { canonicalHash } from "./canonical.js";
+const HASH = /^sha1:[a-f0-9]{40}$/;
+const HUMAN_ACTOR = /^(human|github|git):[^\s]+$/i;
+const encode = (value) => `${JSON.stringify(value, null, 2)}\n`;
+export const G2_RUNBOOK_CATEGORIES = [
+    "evaluator_error",
+    "false_positive",
+    "private_leak",
+    "stale_policy",
+    "provider_outage",
+    "corrupt_graph",
+    "adapter_break",
+];
+const G2RunbookSelectionSchema = z.object(Object.fromEntries(G2_RUNBOOK_CATEGORIES.map((category) => [category, z.string().regex(/^rb_[A-Za-z0-9_-]+$/)]))).strict();
+export const G2PlanSchema = z.object({
+    id: z.string().regex(/^g2plan_[a-f0-9]{10}$/),
+    content_hash: z.string().regex(HASH),
+    gate: z.literal("G2"),
+    policy_ids: z.array(z.string().regex(/^pol_[a-f0-9]{10}$/)).min(10, "G2 requires at least 10 selected policies"),
+    runbooks: G2RunbookSelectionSchema,
+    min_shadow_applicable: z.number().int().min(1).max(10000),
+    actor: z.string().regex(HUMAN_ACTOR, "G2 plan requires an explicit human actor (human:, github:, or git:)"),
+    reason: z.string().trim().min(1).max(2000),
+    supersedes: z.string().regex(/^g2plan_[a-f0-9]{10}$/).nullable(),
+    data_class: z.literal("private"),
+    authority: z.literal("none"),
+    created_at: z.string().datetime({ offset: true }),
+}).strict().superRefine((plan, ctx) => {
+    if (new Set(plan.policy_ids).size !== plan.policy_ids.length) {
+        ctx.addIssue({ code: "custom", path: ["policy_ids"], message: "G2 policy ids must be unique" });
+    }
+    const runbookIds = Object.values(plan.runbooks);
+    if (new Set(runbookIds).size !== runbookIds.length) {
+        ctx.addIssue({ code: "custom", path: ["runbooks"], message: "G2 requires a unique runbook for every operational category" });
+    }
+});
+export function g2PlanContentHash(plan) {
+    const { id: _id, content_hash: _contentHash, ...body } = plan;
+    return canonicalHash(body);
+}
+export function compileG2Plan(input, opts = {}) {
+    const body = {
+        gate: "G2",
+        policy_ids: [...input.policy_ids].sort(),
+        runbooks: Object.fromEntries(G2_RUNBOOK_CATEGORIES.map((category) => [category, input.runbooks[category]])),
+        min_shadow_applicable: input.min_shadow_applicable ?? 20,
+        actor: input.actor,
+        reason: input.reason.trim(),
+        supersedes: input.supersedes ?? null,
+        data_class: "private",
+        authority: "none",
+        created_at: opts.now ?? new Date().toISOString(),
+    };
+    const contentHash = canonicalHash(body);
+    return G2PlanSchema.parse({ id: `g2plan_${shortHash(contentHash)}`, content_hash: contentHash, ...body });
+}
+export const RunbookRehearsalSchema = z.object({
+    id: z.string().regex(/^rehearsal_[a-f0-9]{10}$/),
+    content_hash: z.string().regex(HASH),
+    runbook_id: z.string().regex(/^rb_[A-Za-z0-9_-]+$/),
+    runbook_hash: z.string().regex(HASH),
+    result: z.enum(["passed", "failed"]),
+    actor: z.string().regex(HUMAN_ACTOR, "runbook rehearsal requires an explicit human actor (human:, github:, or git:)"),
+    evidence_hashes: z.array(z.string().regex(HASH)).min(1),
+    notes: z.string().trim().min(1).max(4000),
+    supersedes: z.string().regex(/^rehearsal_[a-f0-9]{10}$/).nullable(),
+    data_class: z.literal("private"),
+    authority: z.literal("none"),
+    created_at: z.string().datetime({ offset: true }),
+}).strict().superRefine((receipt, ctx) => {
+    if (new Set(receipt.evidence_hashes).size !== receipt.evidence_hashes.length) {
+        ctx.addIssue({ code: "custom", path: ["evidence_hashes"], message: "rehearsal evidence hashes must be unique" });
+    }
+});
+export function runbookRehearsalContentHash(receipt) {
+    const { id: _id, content_hash: _contentHash, ...body } = receipt;
+    return canonicalHash(body);
+}
+export function compileRunbookRehearsal(input, opts = {}) {
+    const body = {
+        runbook_id: input.runbook_id,
+        runbook_hash: input.runbook_hash,
+        result: input.result,
+        actor: input.actor,
+        evidence_hashes: [...new Set(input.evidence_hashes)].sort(),
+        notes: input.notes.trim(),
+        supersedes: input.supersedes ?? null,
+        data_class: "private",
+        authority: "none",
+        created_at: opts.now ?? new Date().toISOString(),
+    };
+    const contentHash = canonicalHash(body);
+    return RunbookRehearsalSchema.parse({ id: `rehearsal_${shortHash(contentHash)}`, content_hash: contentHash, ...body });
+}
+export function currentAppendOnly(records, label, identity, singleCurrent = false) {
+    const byId = new Map(records.map((record) => [record.id, record]));
+    if (byId.size !== records.length)
+        throw new Error(`duplicate ${label} id`);
+    const childCount = new Map();
+    for (const record of records) {
+        if (!record.supersedes)
+            continue;
+        const parent = byId.get(record.supersedes);
+        if (!parent)
+            throw new Error(`${label} ${record.id} supersedes missing ${record.supersedes}`);
+        if (identity(parent) !== identity(record))
+            throw new Error(`${label} ${record.id} supersedes a different evidence target`);
+        childCount.set(parent.id, (childCount.get(parent.id) ?? 0) + 1);
+        if (childCount.get(parent.id) > 1)
+            throw new Error(`${label} ${parent.id} has a branched supersession chain`);
+    }
+    for (const record of records) {
+        const visited = new Set();
+        let cursor = record;
+        while (cursor?.supersedes) {
+            if (visited.has(cursor.id))
+                throw new Error(`${label} chain contains a cycle at ${cursor.id}`);
+            visited.add(cursor.id);
+            cursor = byId.get(cursor.supersedes);
+        }
+    }
+    const current = records.filter((record) => !childCount.has(record.id)).sort((a, b) => a.id.localeCompare(b.id));
+    const identities = new Set();
+    for (const record of current) {
+        const key = identity(record);
+        if (identities.has(key))
+            throw new Error(`${label} target ${key} has multiple current records`);
+        identities.add(key);
+    }
+    if (singleCurrent && current.length > 1)
+        throw new Error(`${label} has multiple current records`);
+    return current;
+}
+export function currentG2Plans(records) {
+    const parsed = records.map((record) => G2PlanSchema.parse(record));
+    return currentAppendOnly(parsed, "G2 plan", () => "G2", true);
+}
+export function currentRunbookRehearsals(records) {
+    const parsed = records.map((record) => RunbookRehearsalSchema.parse(record));
+    return currentAppendOnly(parsed, "runbook rehearsal", (record) => `${record.runbook_id}:${record.runbook_hash}`);
+}
+export function scoreG2Readiness(input) {
+    const blockers = [];
+    if (!input.manifest) {
+        blockers.push("No current private G2 evidence plan exists; a human must select the exact dogfood policies and operational runbooks.");
+        if (input.inventory) {
+            if (input.inventory.private_policies < 10)
+                blockers.push(`Private dogfood policy inventory is ${input.inventory.private_policies}/10 minimum.`);
+            if (input.inventory.private_proofs < 10)
+                blockers.push(`Private proof inventory is ${input.inventory.private_proofs}/10 minimum; every selected policy needs an exact current P3+ proof.`);
+            if (input.inventory.private_corpora < 10)
+                blockers.push(`Private imported-corpus inventory is ${input.inventory.private_corpora}/10 minimum; every selected policy needs known-bad and known-good fixtures.`);
+            if (input.inventory.private_shadow_evaluations < 200)
+                blockers.push(`Private shadow inventory is ${input.inventory.private_shadow_evaluations}/200 baseline observations (default 20 across 10 policies); the human plan may set a stricter bound.`);
+            if (input.inventory.private_runbooks < G2_RUNBOOK_CATEGORIES.length)
+                blockers.push(`Private operational runbook inventory is ${input.inventory.private_runbooks}/${G2_RUNBOOK_CATEGORIES.length} minimum unique category mappings.`);
+            if (input.inventory.private_rehearsals < G2_RUNBOOK_CATEGORIES.length)
+                blockers.push(`Private runbook rehearsal inventory is ${input.inventory.private_rehearsals}/${G2_RUNBOOK_CATEGORIES.length} minimum exact-content receipts.`);
+        }
+    }
+    if (input.manifest && input.policy_evidence.length !== input.manifest.policy_ids.length) {
+        blockers.push(`Selected policy evidence is incomplete (${input.policy_evidence.length}/${input.manifest.policy_ids.length}).`);
+    }
+    for (const evidence of input.policy_evidence) {
+        for (const reason of evidence.reasons)
+            blockers.push(`${evidence.policy_id}: ${reason}`);
+    }
+    if (input.manifest && input.runbook_evidence.length !== G2_RUNBOOK_CATEGORIES.length) {
+        blockers.push(`Operational runbook evidence is incomplete (${input.runbook_evidence.length}/${G2_RUNBOOK_CATEGORIES.length}).`);
+    }
+    for (const evidence of input.runbook_evidence) {
+        for (const reason of evidence.reasons)
+            blockers.push(`${evidence.category}/${evidence.runbook_id}: ${reason}`);
+    }
+    const activeBlocking = [...new Set(input.active_blocking_policy_ids)].sort();
+    if (activeBlocking.length)
+        blockers.push(`Blocking behavior must remain disabled for G2; active blocking policies: ${activeBlocking.join(", ")}.`);
+    const uniqueBlockers = [...new Set(blockers)];
+    const body = {
+        gate: "G2",
+        manifest: input.manifest,
+        policy_evidence: [...input.policy_evidence].sort((a, b) => a.policy_id.localeCompare(b.policy_id)),
+        runbook_evidence: [...input.runbook_evidence].sort((a, b) => a.category.localeCompare(b.category)),
+        active_blocking_policy_ids: activeBlocking,
+        blockers: uniqueBlockers,
+        ...(input.inventory ? { inventory: input.inventory } : {}),
+        recommendation: uniqueBlockers.length ? "not_ready" : "eligible_for_human_g2_signoff",
+        authority: "none",
+        g2_passed: false,
+    };
+    const contentHash = canonicalHash(body);
+    return { id: `g2readiness_${shortHash(contentHash)}`, content_hash: contentHash, ...body };
+}
+export function loadPrivateRecords(dir, prefix, parse, label) {
+    if (!dir || !existsSync(dir))
+        return [];
+    const records = [];
+    for (const name of readdirSync(dir).filter((entry) => entry.startsWith(prefix) && entry.endsWith(".json")).sort()) {
+        try {
+            records.push(parse(JSON.parse(readFileSync(join(dir, name), "utf8"))));
+        }
+        catch (error) {
+            throw new Error(`invalid ${label}/${name}: ${error.message}`);
+        }
+    }
+    return records;
+}
+/** Private-only append-only storage for the human-selected G2 packet and runbook drills. */
+export class G2EvidenceRepository {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    listPlans() {
+        const records = loadPrivateRecords(this.store.privateDir ? join(this.store.privateDir, "gates") : undefined, "g2plan_", (raw) => {
+            const parsed = G2PlanSchema.parse(raw);
+            if (parsed.content_hash !== g2PlanContentHash(parsed) || parsed.id !== `g2plan_${shortHash(parsed.content_hash)}`) {
+                throw new Error(`G2 plan ${parsed.id} content hash mismatch`);
+            }
+            return parsed;
+        }, "gates");
+        currentG2Plans(records);
+        return records.sort((a, b) => a.id.localeCompare(b.id));
+    }
+    currentPlan() {
+        return currentG2Plans(this.listPlans())[0] ?? null;
+    }
+    putPlan(plan) {
+        if (!this.store.privateDir)
+            throw new Error("No private Hunch overlay is configured; refusing to write G2 evidence.");
+        const parsed = G2PlanSchema.parse(plan);
+        if (parsed.content_hash !== g2PlanContentHash(parsed) || parsed.id !== `g2plan_${shortHash(parsed.content_hash)}`)
+            throw new Error(`G2 plan ${parsed.id} content hash mismatch`);
+        const records = this.listPlans();
+        const existing = records.find((record) => record.id === parsed.id);
+        if (existing)
+            return existing;
+        const current = currentG2Plans(records)[0];
+        if (current && parsed.supersedes !== current.id)
+            throw new Error(`G2 plan ${current.id} is current; pass supersedes:${current.id} to append a correction`);
+        if (!current && parsed.supersedes)
+            throw new Error(`G2 plan ${parsed.id} supersedes no current plan`);
+        currentG2Plans([...records, parsed]);
+        const dir = join(this.store.privateDir, "gates");
+        mkdirSync(dir, { recursive: true });
+        writeFileAtomic(join(dir, `${parsed.id}.json`), encode(parsed));
+        return parsed;
+    }
+    listRehearsals() {
+        const records = loadPrivateRecords(this.store.privateDir ? join(this.store.privateDir, "rehearsals") : undefined, "rehearsal_", (raw) => {
+            const parsed = RunbookRehearsalSchema.parse(raw);
+            if (parsed.content_hash !== runbookRehearsalContentHash(parsed) || parsed.id !== `rehearsal_${shortHash(parsed.content_hash)}`) {
+                throw new Error(`runbook rehearsal ${parsed.id} content hash mismatch`);
+            }
+            return parsed;
+        }, "rehearsals");
+        currentRunbookRehearsals(records);
+        return records.sort((a, b) => a.id.localeCompare(b.id));
+    }
+    putRehearsal(receipt) {
+        if (!this.store.privateDir)
+            throw new Error("No private Hunch overlay is configured; refusing to write runbook rehearsal evidence.");
+        const parsed = RunbookRehearsalSchema.parse(receipt);
+        if (parsed.content_hash !== runbookRehearsalContentHash(parsed) || parsed.id !== `rehearsal_${shortHash(parsed.content_hash)}`)
+            throw new Error(`runbook rehearsal ${parsed.id} content hash mismatch`);
+        const records = this.listRehearsals();
+        const existing = records.find((record) => record.id === parsed.id);
+        if (existing)
+            return existing;
+        const sameTarget = currentRunbookRehearsals(records).find((record) => record.runbook_id === parsed.runbook_id && record.runbook_hash === parsed.runbook_hash);
+        if (sameTarget && parsed.supersedes !== sameTarget.id) {
+            throw new Error(`runbook ${parsed.runbook_id} rehearsal ${sameTarget.id} is current for this exact content; pass supersedes:${sameTarget.id} to append a correction`);
+        }
+        if (!sameTarget && parsed.supersedes)
+            throw new Error(`runbook rehearsal ${parsed.id} supersedes no current exact-content rehearsal`);
+        currentRunbookRehearsals([...records, parsed]);
+        const dir = join(this.store.privateDir, "rehearsals");
+        mkdirSync(dir, { recursive: true });
+        writeFileAtomic(join(dir, `${parsed.id}.json`), encode(parsed));
+        return parsed;
+    }
+}
+export function runbookContentHash(runbook) {
+    return canonicalHash(runbook);
+}
+//# sourceMappingURL=g2.js.map