@sleepy_panda_srl/portulan 0.3.0 → 0.4.0

package/evals/ab/personas/protocol/first-probe.mjs.txt

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+// Acquire the frozen persona comparisons through native children; never run by a recipe.
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { spawnSync, execFileSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { cloneTree, childEnv, transcriptOf } from "./warm.mjs";
+import { readTranscript } from "./ledger.mjs";
+import { CORPUS, grade } from "../evals/ab/personas/grader.mjs";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const ROLES = ["implementer", "reviewer", "librarian"];
+const FROZEN = ["evals/ab/personas/corpus.json", "evals/ab/personas/grader.mjs", "cli/persona-routing.test.mjs"];
+const digest = bytes => createHash("sha256").update(bytes).digest("hex");
+const sha = file => digest(fs.readFileSync(file));
+const json = file => JSON.parse(fs.readFileSync(file, "utf8"));
+const save = (file, value) => fs.writeFileSync(file, JSON.stringify(value, null, 2) + "\n");
+const git = (...args) => execFileSync("git", args, { cwd: ROOT, encoding: "utf8" }).trim();
+const records = file => fs.readFileSync(file, "utf8").split("\n").filter(Boolean).map(line => JSON.parse(line));
+
+export function parentPrompt(role, taskFile, effort) {
+    const input = {
+        subagent_type: `portulan:${role}`, description: "Frozen persona artifact probe",
+        prompt: `Read ${taskFile} and follow its task exactly. This is an artifact proposal, not a completed repository change.`,
+        run_in_background: false,
+        ...(effort === null ? {} : { effort }),
+    };
+    return "This is a frozen evaluation. Invoke the Agent tool exactly once with these input values: " + JSON.stringify(input) +
+        ". Do not supply a child model or change the effort. Wait for that foreground child to finish. Do not answer its task yourself or invoke another child. After completion reply only DONE.";
+}
+
+function response(file) {
+    const raw = fs.readFileSync(file, "utf8").trim();
+    let value;
+    try { value = JSON.parse(raw); } catch { throw Error("the CLI returned no single JSON result"); }
+    if (value.type !== "result" || value.is_error || value.subtype !== "success" || typeof value.session_id !== "string") throw Error("the CLI did not complete successfully");
+    return value;
+}
+
+function answerOf(rows) {
+    const messages = rows.filter(r => r.type === "assistant" && r.message?.model !== "<synthetic>" && Array.isArray(r.message?.content));
+    const last = messages.at(-1)?.message.id;
+    if (!last) throw Error("child has no final assistant message");
+    const blocks = messages.filter(r => r.message.id === last).flatMap(r => r.message.content).filter(b => b.type === "text");
+    return [...new Set(blocks.map(b => b.text))].join("\n").trim();
+}
+
+export function nativeInvocation(rows, role, effort) {
+    const calls = rows.filter(r => r.type === "assistant").flatMap(r => r.message?.content ?? []).filter(b => b.type === "tool_use" && ["Agent", "Task"].includes(b.name));
+    const unique = [...new Map(calls.map(call => [call.id, call])).values()];
+    if (unique.length !== 1) throw Error("a parent must invoke exactly one native child");
+    const input = unique[0].input;
+    if (input?.subagent_type !== `portulan:${role}` || Object.hasOwn(input, "model") || (input.effort ?? null) !== effort) throw Error("the parent did not select the frozen role/inherited model/effort");
+    if (input.run_in_background === true) throw Error("a background child is not a completed foreground comparison");
+    return { type: input.subagent_type, effort: input.effort ?? null, prompt: input.prompt };
+}
+
+function collectCall(entry, dir, tree, env) {
+    if (entry.exit !== 0 || entry.timedOut) throw Error("a parent invocation failed or timed out");
+    const result = response(path.join(dir, entry.stdout));
+    const transcript = transcriptOf(result.session_id, tree, env);
+    if (transcript === null) throw Error("the completed parent transcript is unavailable");
+    const rows = records(transcript);
+    const invocation = nativeInvocation(rows, entry.role, entry.effort);
+    if (invocation.prompt !== entry.childPrompt) throw Error("the child did not receive the frozen prompt verbatim");
+    const agentDir = path.join(path.dirname(transcript), result.session_id, "subagents");
+    const children = fs.readdirSync(agentDir).filter(name => /^agent-.*\.jsonl$/.test(name));
+    if (children.length !== 1) throw Error("the parent has other than one child transcript");
+    const child = path.join(agentDir, children[0]);
+    const childRows = records(child);
+    const parentUsage = readTranscript(transcript), childUsage = readTranscript(child);
+    if (parentUsage.malformed || childUsage.malformed) throw Error("a transcript has malformed records");
+    const parent = parentUsage.requests.filter(r => !r.synthetic && !r.sidechain);
+    const requests = childUsage.requests.filter(r => !r.synthetic);
+    if (!parent.length || !requests.length) throw Error("parent or child usage is missing");
+    const models = [...new Set([...parent, ...requests].map(r => r.model))];
+    if (models.length !== 1 || !models[0]) throw Error("inherited parent/child concrete models disagree or are unknown");
+    const efforts = [...new Set(requests.map(r => r.effort))];
+    if (entry.effort !== null && (efforts.length !== 1 || efforts[0] !== entry.effort)) throw Error("host usage does not establish the requested child effort");
+    const target = path.join(dir, "originals", entry.key);
+    fs.mkdirSync(target, { recursive: true });
+    fs.copyFileSync(transcript, path.join(target, "parent.jsonl"));
+    fs.copyFileSync(child, path.join(target, "child.jsonl"));
+    return {
+        invocation: { type: invocation.type, effort: invocation.effort, promptSha256: digest(invocation.prompt) },
+        model: models[0], efforts, parentEfforts: [...new Set(parent.map(r => r.effort))],
+        answer: answerOf(childRows), usage: { parent, child: requests },
+        raw: { result: sha(path.join(dir, entry.stdout)), parent: sha(path.join(target, "parent.jsonl")), child: sha(path.join(target, "child.jsonl")) },
+        transcriptDuplicates: { parent: parentUsage.duplicates, child: childUsage.duplicates },
+    };
+}
+
+function initialize(dir) {
+    if (fs.existsSync(dir)) throw Error("acquisition directory already exists; no automatic retry or resampling");
+    fs.mkdirSync(dir, { recursive: true });
+    const frozen = Object.fromEntries(FROZEN.map(rel => [rel, sha(path.join(ROOT, rel))]));
+    const tree = cloneTree(ROOT, path.join(dir, "tree"));
+    const version = execFileSync("claude", ["--version"], { encoding: "utf8" }).trim();
+    const journal = { version: 1, phase: "frozen", started: new Date().toISOString(), source: git("rev-parse", "HEAD"), host: version, frozen, calls: [] };
+    fs.mkdirSync(path.join(dir, "frozen"));
+    for (const rel of FROZEN) fs.copyFileSync(path.join(ROOT, rel), path.join(dir, "frozen", path.basename(rel)));
+    fs.mkdirSync(path.join(dir, "tasks"));
+    for (const task of CORPUS.cases) save(path.join(dir, "tasks", task.id + ".json"), { role: task.role, task: task.task });
+    save(path.join(dir, "journal.json"), journal);
+    return { journal, tree };
+}
+
+function call(journal, dir, tree, { key, role, effort, task, model = null }) {
+    const taskFile = path.join(dir, "tasks", task + ".json");
+    const env = childEnv(process.env, { cache_lifetime: "5m" }, { local: true });
+    const childPrompt = `Read ${taskFile} and follow its task exactly. This is an artifact proposal, not a completed repository change.`;
+    const args = ["-p", parentPrompt(role, taskFile, effort), "--output-format", "json", "--effort", "high", "--plugin-dir", tree,
+        "--tools", "Agent,Read", "--allowedTools", `Agent(portulan:${role}),Read`, "--add-dir", path.join(dir, "tasks"), "--max-budget-usd", "1", ...(model ? ["--model", model] : [])];
+    const entry = { key, role, effort, task, childPrompt, model, started: new Date().toISOString(), state: "started", stdout: key + ".stdout.json", stderr: key + ".stderr.txt" };
+    journal.calls.push(entry);
+    save(path.join(dir, "journal.json"), journal);
+    const started = Date.now();
+    const run = spawnSync("claude", args, { cwd: tree, env, encoding: "utf8", timeout: 180000, maxBuffer: 4 * 1024 * 1024 });
+    fs.writeFileSync(path.join(dir, entry.stdout), run.stdout ?? "");
+    fs.writeFileSync(path.join(dir, entry.stderr), run.stderr ?? "");
+    Object.assign(entry, { exit: run.status, timedOut: run.error?.code === "ETIMEDOUT", durationMs: Date.now() - started, ended: new Date().toISOString() });
+    try {
+        entry.collected = collectCall(entry, dir, tree, env);
+        entry.state = "complete";
+        if (task !== "mechanism") entry.grade = grade(CORPUS.cases.find(c => c.id === task), entry.collected.answer);
+    } catch (error) {
+        entry.state = "invalid";
+        entry.fault = error.message;
+        journal.phase = "aborted";
+    }
+    save(path.join(dir, "journal.json"), journal);
+    process.stdout.write(`${key}: ${entry.state}${entry.grade ? `, semantic ${entry.grade.ok ? "PASS" : "FAIL"}` : ""}\n`);
+    if (entry.state !== "complete") throw Error(entry.fault);
+    return entry;
+}
+
+export function run(argv = process.argv.slice(2)) {
+    const [mode, named] = argv;
+    if (!["probe", "run"].includes(mode) || !named || argv.length !== 2) throw Error("usage: node cli/acquire-personas.mjs probe|run <private-directory>");
+    const dir = path.resolve(named);
+    if (mode === "probe") {
+        const { journal, tree } = initialize(dir);
+        save(path.join(dir, "tasks", "mechanism.json"), { role: "implementer", task: "Read your role charter, then reply exactly MECHANISM_OK. This tests native effort selection only; do not edit files or call other tools." });
+        const entry = call(journal, dir, tree, { key: "mechanism-medium", role: "implementer", effort: "medium", task: "mechanism" });
+        if (entry.collected.answer !== "MECHANISM_OK") throw Error("mechanism child did not finish its fixed task");
+        journal.model = entry.collected.model;
+        journal.phase = "mechanism-demonstrated";
+        save(path.join(dir, "journal.json"), journal);
+        return 0;
+    }
+    const journal = json(path.join(dir, "journal.json"));
+    if (journal.phase !== "mechanism-demonstrated" || journal.calls.length !== 1) throw Error("no valid untouched mechanism probe; refusing retry or resampling");
+    for (const rel of FROZEN) if (sha(path.join(ROOT, rel)) !== journal.frozen[rel]) throw Error("frozen semantic source changed");
+    journal.instrument = sha(fileURLToPath(import.meta.url));
+    journal.phase = "acquiring";
+    save(path.join(dir, "journal.json"), journal);
+    const tree = path.join(dir, "tree");
+    for (const [i, task] of CORPUS.cases.entries()) {
+        for (const arm of i % 2 === 0 ? ["a", "b"] : ["b", "a"]) {
+            const entry = call(journal, dir, tree, { key: `${task.id}-${arm}`, role: task.role, effort: arm === "a" ? null : "medium", task: task.id, model: journal.model });
+            if (entry.collected.model !== journal.model) throw Error("the frozen concrete model changed");
+            if (arm === "a" && !entry.grade.ok) { journal.phase = "aborted"; save(path.join(dir, "journal.json"), journal); throw Error("a control failed: no routing is earned and no resampling is allowed"); }
+        }
+    }
+    journal.phase = "complete";
+    save(path.join(dir, "journal.json"), journal);
+    return 0;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    try { process.exitCode = run(); } catch (error) { process.stderr.write(`persona acquisition: ${error.message}\n`); process.exitCode = 2; }
+}

package/evals/ab/personas/protocol/publisher.mjs.txt

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+// Publish whitelisted numeric metadata and generic answers from the completed private persona acquisition.
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { pathToFileURL } from "node:url";
+import { parentPrompt } from "./acquire-personas.mjs";
+import { CORPUS } from "../evals/ab/personas/grader.mjs";
+import { ROLES, ROUTING, summarize, register, verifyData } from "./persona-routing.mjs";
+
+const sha = bytes => createHash("sha256").update(bytes).digest("hex");
+const read = file => JSON.parse(fs.readFileSync(file, "utf8"));
+const digest = file => sha(fs.readFileSync(file));
+const save = (file, value) => fs.writeFileSync(file, JSON.stringify(value, null, 2) + "\n");
+const counters = ["uncached", "written5m", "written1h", "writtenUnknown", "read", "output"];
+const usage = requests => requests.map(request => Object.fromEntries([
+    ["id", "request-" + sha(request.id)], ...["model", "effort", "at", ...counters].map(key => [key, request[key]]),
+]));
+
+function normalizedArgs(args, directory, sessionId) {
+    return args.map(value => value.replaceAll(path.join(directory, "tree"), "<plugin>").replaceAll(directory, "<acquisition>")
+        .replaceAll(sessionId ?? "NO_SESSION_ID_WAS_RECORDED", "<parent-context>"));
+}
+
+function normalize(call, directory, firstProbe = false) {
+    const partial = firstProbe ? call.partial : null;
+    const child = firstProbe ? partial.children.flatMap(child => child.usage) : call.collected.usage.child;
+    const parent = firstProbe ? partial.parent : call.collected.usage.parent;
+    const raw = firstProbe ? { parent: partial.parentSha256, child: partial.children[0].sha256, result: digest(path.join(directory, call.stdout)) } : call.collected.raw;
+    const args = firstProbe ? ["-p", parentPrompt(call.role, path.join(directory, "tasks/mechanism.json"), call.effort), "--output-format", "json", "--effort", "high", "--plugin-dir", path.join(directory, "tree"),
+        "--tools", "Agent,Read", "--allowedTools", `Agent(portulan:${call.role}),Read`, "--add-dir", path.join(directory, "tasks"), "--max-budget-usd", "1"] : call.argv;
+    const result = {
+        key: call.key, task: call.task, role: call.role, effort: call.effort, requestedModel: call.model,
+        model: firstProbe ? parent[0].model : call.collected.model, parentEffort: "high", fresh: true,
+        context: "context-" + sha(call.sessionId ?? raw.parent), childContext: "child-" + sha(raw.child),
+        state: call.state, exit: call.exit, timedOut: call.timedOut, started: call.started, ended: call.ended,
+        argv: normalizedArgs(args, directory, call.sessionId), argvProvenance: firstProbe ? "reconstructed-after-execution" : "recorded-before-execution",
+        instrumentSha256: firstProbe ? partial.postProbeSourceSha256 : call.instrumentSha256,
+        usage: { parent: usage(parent), child: usage(child) }, raw,
+        hostEstimateUsd: read(path.join(directory, call.stdout)).total_cost_usd,
+    };
+    if (firstProbe) Object.assign(result, { reason: "error_max_budget_usd", markerSeen: partial.children[0].markerSeen === true,
+        sourceSnapshotTiming: "after-execution", freshContextEvidence: "one parent transcript and one child transcript; no resume option" });
+    else {
+        const answer = normalizedArgs([call.collected.answer], directory)[0];
+        Object.assign(result, { invocation: { ...call.collected.invocation, model: null, background: false }, answer,
+            answerRawSha256: sha(call.collected.answer), answerPresentationSha256: sha(answer), answerNormalized: answer !== call.collected.answer,
+            transcriptDuplicates: call.collected.transcriptDuplicates });
+    }
+    if (call.grade) result.grade = call.grade;
+    if (call.regraded) result.regraded = call.regraded;
+    if (call.task === "mechanism" && !firstProbe) result.markerSeen = call.collected.answer === "MECHANISM_OK";
+    else if (call.task !== "mechanism") result.arm = call.key.endsWith("-a") ? "a" : "b";
+    return result;
+}
+
+export function publish(root, firstDirectory, directory) {
+    root = path.resolve(root); firstDirectory = path.resolve(firstDirectory); directory = path.resolve(directory);
+    const first = read(path.join(firstDirectory, "journal.json")), journal = read(path.join(directory, "journal.json"));
+    if (journal.phase !== "complete" || journal.calls.length !== 19 || first.calls.length !== 1) throw Error("only the complete, unrepeated acquisition may be published");
+    const target = path.join(root, "evals/ab/personas");
+    const sourceHashes = Object.fromEntries(["evals/ab/personas/corpus.json", "evals/ab/personas/grader.mjs"].map(file => [file, journal.qualityFrozen.semantic[file]]));
+    for (const role of ROLES) {
+        const file = `core/personas/${role}.md`, expected = journal.qualityFrozen.roles[role].persona;
+        if (digest(path.join(directory, "tree", file)) !== expected) throw Error("the acquired charter differs from its frozen hash");
+        sourceHashes[file] = expected;
+    }
+    for (const [file, expected] of Object.entries(sourceHashes)) if (digest(path.join(root, file)) !== expected) throw Error("current source differs from its acquired frozen hash: " + file);
+    const records = {}, turns = journal.calls.slice(1).map(call => normalize(call, directory));
+    for (const role of ROLES) {
+        const record = { version: 1, role, host: journal.host, model: journal.model, turns: turns.filter(turn => turn.role === role) };
+        record.summary = summarize(record); records[role] = record;
+    }
+    const old = fs.readFileSync(path.join(directory, "frozen-quality/grader.mjs"), "utf8");
+    const current = fs.readFileSync(path.join(root, "evals/ab/personas/grader.mjs"), "utf8");
+    const approval = read(path.join(directory, "decode-repair-approval.json"));
+    const preflights = [normalize(first.calls[0], firstDirectory, true), normalize(journal.calls[0], directory)];
+    const capture = {
+        version: 1, phase: journal.phase, sourceCommit: journal.source, host: journal.host, model: journal.model,
+        seed: CORPUS.seed, prices: CORPUS.prices, routing: ROUTING,
+        publication: { answerTransformation: "replace only known plugin-root and acquisition-root prefixes with <plugin> and <acquisition>",
+            normalizedAnswers: turns.filter(turn => turn.answerNormalized).map(turn => turn.key),
+            note: "Original wording otherwise retained; original answers stay private with raw-answer digests. This presentation normalization changes no semantic artifact or score." },
+        qualityFrozenAt: journal.priorQualityFrozen.at, continuationFrozenAt: journal.qualityFrozen.at,
+        order: journal.qualityFrozen.order, taskSha256: journal.qualityFrozen.tasks,
+        preflights, decodeRepair: { ...journal.decodeRepair, approval: approval.verdict, reruns: 0,
+            semanticSuffixSha256: sha(current.slice(current.indexOf("function codeCases"))),
+            explanation: "After one outcome, the original decoder rejected one JSON fence followed by prose. The same retained answer passes the revised decoder; all semantic predicates, cases and price code are byte-identical. The original false score remains. Independent approval covered exact decoder and continuation instrument hashes before the remaining seventeen calls." },
+        accounting: { calls: 20, parentContexts: 20, qualityChildren: 18,
+            requests: [...preflights, ...turns].flatMap(call => [...call.usage.parent, ...call.usage.child]).length,
+            note: "Both probes, every parent and every child are included. Host USD values are lifecycle estimates, not subscription bills, and are not added to the declared-vector indexes." },
+        sources: sourceHashes,
+        bindings: Object.fromEntries(ROLES.map(role => [role, journal.qualityFrozen.roles[role].binding])),
+        instruments: { firstProbe: { sha256: first.calls[0].partial.postProbeSourceSha256, timing: "snapshotted-after-execution" },
+            secondProbe: { sha256: journal.instrumentSha256, timing: "frozen-before-execution" },
+            firstOutcome: { sha256: journal.priorQualityFrozen.instrument, timing: "frozen-before-execution" },
+            continuation: { sha256: journal.qualityFrozen.instrument, timing: "approved-and-frozen-before-seventeen-untouched-cells" },
+            publisher: { sha256: digest(new URL(import.meta.url)), timing: "after-acquisition; whitelisted normalization only" } }, files: {},
+    };
+    verifyData(capture, records);
+    fs.mkdirSync(path.join(target, "bindings"), { recursive: true });
+    fs.mkdirSync(path.join(target, "protocol"), { recursive: true });
+    for (const role of ROLES) {
+        save(path.join(target, `${role}.json`), records[role]);
+        fs.writeFileSync(path.join(target, `${role}.md`), register(records[role]));
+        fs.copyFileSync(path.join(directory, "tree/agents", `${role}.md`), path.join(target, "bindings", `${role}.txt`));
+        capture.files[`${role}.json`] = digest(path.join(target, `${role}.json`));
+    }
+    const snapshots = [
+        [path.join(firstDirectory, "frozen/acquire-v1-after-probe.mjs"), "first-probe.mjs.txt"],
+        [path.join(directory, "frozen/acquire.mjs"), "second-probe.mjs.txt"],
+        [path.join(directory, "frozen-quality/acquire.mjs"), "first-outcome.mjs.txt"],
+        [path.join(directory, "frozen-quality-repair/acquire.mjs"), "continuation.mjs.txt"],
+        [new URL(import.meta.url), "publisher.mjs.txt"],
+    ];
+    for (const [source, name] of snapshots) fs.copyFileSync(source, path.join(target, "protocol", name));
+    fs.writeFileSync(path.join(target, "repairs/grader-before-decode-repair.mjs.txt"), old);
+    save(path.join(target, "acquisition.json"), capture);
+    return digest(path.join(target, "acquisition.json"));
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(fs.realpathSync(process.argv[1])).href) {
+    try {
+        if (process.argv.length !== 5) throw Error("usage: node cli/normalize-personas.mjs <repo-root> <failed-probe-directory> <completed-directory>");
+        console.log(publish(...process.argv.slice(2)));
+    } catch (error) { console.error(error.message); process.exitCode = 2; }
+}

package/evals/ab/personas/protocol/second-probe.mjs.txt

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+// Acquire the frozen persona comparisons through native children; never run by a recipe.
+import fs from "node:fs";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { spawnSync, execFileSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { cloneTree, childEnv, transcriptOf } from "./warm.mjs";
+import { readTranscript } from "./ledger.mjs";
+import { CORPUS, grade } from "../evals/ab/personas/grader.mjs";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const PARENT_MODEL = "claude-sonnet-5-5";
+const ROLES = ["implementer", "reviewer", "librarian"];
+const FROZEN = ["evals/ab/personas/corpus.json", "evals/ab/personas/grader.mjs", "cli/persona-routing.test.mjs"];
+const digest = bytes => createHash("sha256").update(bytes).digest("hex");
+const sha = file => digest(fs.readFileSync(file));
+const json = file => JSON.parse(fs.readFileSync(file, "utf8"));
+const save = (file, value) => fs.writeFileSync(file, JSON.stringify(value, null, 2) + "\n");
+const git = (...args) => execFileSync("git", args, { cwd: ROOT, encoding: "utf8" }).trim();
+const records = file => fs.readFileSync(file, "utf8").split("\n").filter(Boolean).map(line => JSON.parse(line));
+
+export function parentPrompt(role, taskFile, effort) {
+    const input = {
+        subagent_type: `portulan:${role}`, description: "Frozen persona artifact probe",
+        prompt: `Read ${taskFile} and follow its task exactly. This is an artifact proposal, not a completed repository change.`,
+        run_in_background: false,
+        ...(effort === null ? {} : { effort }),
+    };
+    return "This is a frozen evaluation. Invoke the Agent tool exactly once with these input values: " + JSON.stringify(input) +
+        ". Do not supply a child model or change the effort. Wait for that foreground child to finish. Do not answer its task yourself or invoke another child. After completion reply only DONE.";
+}
+
+function response(file) {
+    const raw = fs.readFileSync(file, "utf8").trim();
+    let value;
+    try { value = JSON.parse(raw); } catch { throw Error("the CLI returned no single JSON result"); }
+    if (value.type !== "result" || value.is_error || value.subtype !== "success" || typeof value.session_id !== "string") throw Error("the CLI did not complete successfully");
+    return value;
+}
+
+function answerOf(rows) {
+    const messages = rows.filter(r => r.type === "assistant" && r.message?.model !== "<synthetic>" && Array.isArray(r.message?.content));
+    const last = messages.at(-1)?.message.id;
+    if (!last) throw Error("child has no final assistant message");
+    const blocks = messages.filter(r => r.message.id === last).flatMap(r => r.message.content).filter(b => b.type === "text");
+    return [...new Set(blocks.map(b => b.text))].join("\n").trim();
+}
+
+export function nativeInvocation(rows, role, effort) {
+    const calls = rows.filter(r => r.type === "assistant").flatMap(r => r.message?.content ?? []).filter(b => b.type === "tool_use" && ["Agent", "Task"].includes(b.name));
+    const unique = [...new Map(calls.map(call => [call.id, call])).values()];
+    if (unique.length !== 1) throw Error("a parent must invoke exactly one native child");
+    const input = unique[0].input;
+    if (input?.subagent_type !== `portulan:${role}` || Object.hasOwn(input, "model") || (input.effort ?? null) !== effort) throw Error("the parent did not select the frozen role/inherited model/effort");
+    if (input.run_in_background === true) throw Error("a background child is not a completed foreground comparison");
+    return { type: input.subagent_type, effort: input.effort ?? null, prompt: input.prompt };
+}
+
+function collectCall(entry, dir, tree, env) {
+    if (entry.exit !== 0 || entry.timedOut) throw Error("a parent invocation failed or timed out");
+    const result = response(path.join(dir, entry.stdout));
+    if (result.session_id !== entry.sessionId) throw Error("the result belongs to a different parent session");
+    const transcript = transcriptOf(result.session_id, tree, env);
+    if (transcript === null) throw Error("the completed parent transcript is unavailable");
+    const rows = records(transcript);
+    const invocation = nativeInvocation(rows, entry.role, entry.effort);
+    if (invocation.prompt !== entry.childPrompt) throw Error("the child did not receive the frozen prompt verbatim");
+    const agentDir = path.join(path.dirname(transcript), result.session_id, "subagents");
+    const children = fs.readdirSync(agentDir).filter(name => /^agent-.*\.jsonl$/.test(name));
+    if (children.length !== 1) throw Error("the parent has other than one child transcript");
+    const child = path.join(agentDir, children[0]);
+    const childRows = records(child);
+    const parentUsage = readTranscript(transcript), childUsage = readTranscript(child);
+    if (parentUsage.malformed || childUsage.malformed) throw Error("a transcript has malformed records");
+    const parent = parentUsage.requests.filter(r => !r.synthetic && !r.sidechain);
+    const requests = childUsage.requests.filter(r => !r.synthetic);
+    if (!parent.length || !requests.length) throw Error("parent or child usage is missing");
+    const models = [...new Set([...parent, ...requests].map(r => r.model))];
+    if (models.length !== 1 || !models[0]) throw Error("inherited parent/child concrete models disagree or are unknown");
+    const efforts = [...new Set(requests.map(r => r.effort))];
+    if (entry.effort !== null && (efforts.length !== 1 || efforts[0] !== entry.effort)) throw Error("host usage does not establish the requested child effort");
+    const target = path.join(dir, "originals", entry.key);
+    fs.mkdirSync(target, { recursive: true });
+    fs.copyFileSync(transcript, path.join(target, "parent.jsonl"));
+    fs.copyFileSync(child, path.join(target, "child.jsonl"));
+    return {
+        invocation: { type: invocation.type, effort: invocation.effort, promptSha256: digest(invocation.prompt) },
+        model: models[0], efforts, parentEfforts: [...new Set(parent.map(r => r.effort))],
+        answer: answerOf(childRows), usage: { parent, child: requests },
+        raw: { result: sha(path.join(dir, entry.stdout)), parent: sha(path.join(target, "parent.jsonl")), child: sha(path.join(target, "child.jsonl")) },
+        transcriptDuplicates: { parent: parentUsage.duplicates, child: childUsage.duplicates },
+    };
+}
+
+function partialUsage(entry, dir, tree, env) {
+    const transcript = transcriptOf(entry.sessionId, tree, env);
+    if (transcript === null) return { parent: [], children: [], unavailable: true };
+    const target = path.join(dir, "originals", entry.key);
+    fs.mkdirSync(target, { recursive: true });
+    fs.copyFileSync(transcript, path.join(target, "parent.jsonl"));
+    const agentDir = path.join(path.dirname(transcript), entry.sessionId, "subagents");
+    const children = fs.existsSync(agentDir) ? fs.readdirSync(agentDir).filter(name => /^agent-.*\.jsonl$/.test(name)).map(name => {
+        const file = path.join(agentDir, name);
+        fs.copyFileSync(file, path.join(target, name));
+        return { usage: readTranscript(file).requests, sha256: sha(file) };
+    }) : [];
+    return { parent: readTranscript(transcript).requests, parentSha256: sha(transcript), children, unavailable: false };
+}
+
+function initialize(dir) {
+    if (fs.existsSync(dir)) throw Error("acquisition directory already exists; no automatic retry or resampling");
+    fs.mkdirSync(dir, { recursive: true });
+    const frozen = Object.fromEntries(FROZEN.map(rel => [rel, sha(path.join(ROOT, rel))]));
+    const tree = cloneTree(ROOT, path.join(dir, "tree"));
+    const version = execFileSync("claude", ["--version"], { encoding: "utf8" }).trim();
+    const journal = { version: 1, phase: "frozen", started: new Date().toISOString(), source: git("rev-parse", "HEAD"), host: version, frozen,
+        parentPolicy: { model: PARENT_MODEL, effort: "high", configuredEstimateCeilingUsd: 1, tools: "Agent,Read" }, instrumentSha256: sha(fileURLToPath(import.meta.url)), calls: [] };
+    fs.mkdirSync(path.join(dir, "frozen"));
+    for (const rel of FROZEN) fs.copyFileSync(path.join(ROOT, rel), path.join(dir, "frozen", path.basename(rel)));
+    fs.copyFileSync(fileURLToPath(import.meta.url), path.join(dir, "frozen", "acquire.mjs"));
+    fs.mkdirSync(path.join(dir, "tasks"));
+    for (const task of CORPUS.cases) save(path.join(dir, "tasks", task.id + ".json"), { role: task.role, task: task.task });
+    save(path.join(dir, "journal.json"), journal);
+    return { journal, tree };
+}
+
+function call(journal, dir, tree, { key, role, effort, task, model = PARENT_MODEL }) {
+    const taskFile = path.join(dir, "tasks", task + ".json");
+    const env = childEnv(process.env, { cache_lifetime: "5m" }, { local: true });
+    const childPrompt = `Read ${taskFile} and follow its task exactly. This is an artifact proposal, not a completed repository change.`;
+    const sessionId = randomUUID();
+    const args = ["-p", parentPrompt(role, taskFile, effort), "--output-format", "json", "--session-id", sessionId, "--effort", "high", "--plugin-dir", tree,
+        "--tools", "Agent,Read", "--allowedTools", `Agent(portulan:${role}),Read`, "--add-dir", path.join(dir, "tasks"), "--max-budget-usd", "1", ...(model ? ["--model", model] : [])];
+    const entry = { key, role, effort, task, childPrompt, model, sessionId, argv: args, instrumentSha256: sha(fileURLToPath(import.meta.url)), started: new Date().toISOString(), state: "started", stdout: key + ".stdout.json", stderr: key + ".stderr.txt" };
+    journal.calls.push(entry);
+    save(path.join(dir, "journal.json"), journal);
+    const started = Date.now();
+    const run = spawnSync("claude", args, { cwd: tree, env, encoding: "utf8", timeout: 180000, maxBuffer: 4 * 1024 * 1024 });
+    fs.writeFileSync(path.join(dir, entry.stdout), run.stdout ?? "");
+    fs.writeFileSync(path.join(dir, entry.stderr), run.stderr ?? "");
+    Object.assign(entry, { exit: run.status, timedOut: run.error?.code === "ETIMEDOUT", durationMs: Date.now() - started, ended: new Date().toISOString() });
+    try {
+        entry.collected = collectCall(entry, dir, tree, env);
+        entry.state = "complete";
+        if (task !== "mechanism") entry.grade = grade(CORPUS.cases.find(c => c.id === task), entry.collected.answer);
+    } catch (error) {
+        entry.state = "invalid";
+        entry.fault = error.message;
+        try { entry.partial = partialUsage(entry, dir, tree, env); } catch { entry.partial = { unavailable: true }; }
+        journal.phase = "aborted";
+    }
+    save(path.join(dir, "journal.json"), journal);
+    process.stdout.write(`${key}: ${entry.state}${entry.grade ? `, semantic ${entry.grade.ok ? "PASS" : "FAIL"}` : ""}\n`);
+    if (entry.state !== "complete") throw Error(entry.fault);
+    return entry;
+}
+
+export function run(argv = process.argv.slice(2)) {
+    const [mode, named] = argv;
+    if (!["probe", "run"].includes(mode) || !named || argv.length !== 2) throw Error("usage: node cli/acquire-personas.mjs probe|run <private-directory>");
+    const dir = path.resolve(named);
+    if (mode === "probe") {
+        const { journal, tree } = initialize(dir);
+        save(path.join(dir, "tasks", "mechanism.json"), { role: "implementer", task: "Read your role charter, then reply exactly MECHANISM_OK. This tests native effort selection only; do not edit files or call other tools." });
+        const entry = call(journal, dir, tree, { key: "mechanism-medium", role: "implementer", effort: "medium", task: "mechanism" });
+        if (entry.collected.answer !== "MECHANISM_OK") throw Error("mechanism child did not finish its fixed task");
+        journal.model = entry.collected.model;
+        journal.phase = "mechanism-demonstrated";
+        save(path.join(dir, "journal.json"), journal);
+        return 0;
+    }
+    const journal = json(path.join(dir, "journal.json"));
+    if (journal.phase !== "mechanism-demonstrated" || journal.calls.length !== 1) throw Error("no valid untouched mechanism probe; refusing retry or resampling");
+    for (const rel of FROZEN) if (sha(path.join(ROOT, rel)) !== journal.frozen[rel]) throw Error("frozen semantic source changed");
+    journal.instrument = sha(fileURLToPath(import.meta.url));
+    journal.phase = "acquiring";
+    save(path.join(dir, "journal.json"), journal);
+    const tree = path.join(dir, "tree");
+    for (const [i, task] of CORPUS.cases.entries()) {
+        for (const arm of i % 2 === 0 ? ["a", "b"] : ["b", "a"]) {
+            const entry = call(journal, dir, tree, { key: `${task.id}-${arm}`, role: task.role, effort: arm === "a" ? null : "medium", task: task.id });
+            if (entry.collected.model !== journal.model) throw Error("the frozen concrete model changed");
+            if (arm === "a" && !entry.grade.ok) { journal.phase = "aborted"; save(path.join(dir, "journal.json"), journal); throw Error("a control failed: no routing is earned and no resampling is allowed"); }
+        }
+    }
+    journal.phase = "complete";
+    save(path.join(dir, "journal.json"), journal);
+    return 0;
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    try { process.exitCode = run(); } catch (error) { process.stderr.write(`persona acquisition: ${error.message}\n`); process.exitCode = 2; }
+}

package/evals/ab/personas/repairs/first-control-answer.txt

@@ -0,0 +1,23 @@
+```json
+{
+  "code": "function lowerBound(sorted, value) {\n  let lo = 0;\n  let hi = sorted.length;\n  while (lo < hi) {\n    const mid = lo + Math.floor((hi - lo) / 2);\n    if (sorted[mid] < value) {\n      lo = mid + 1;\n    } else {\n      hi = mid;\n    }\n  }\n  return lo;\n}"
+}
+```
+
+This is an artifact proposal only. I changed no repository files and ran nothing, since the task said no tools beyond reading the charter were needed.
+
+The search range is the half-open interval `[lo, hi)`, with `hi` starting at `sorted.length`. This replaces the old `sorted.length - 1` start, which could never return `sorted.length` and so gave the wrong answer when every entry is below `value`.
+
+- **Empty array:** `lo` and `hi` are both 0, so the loop never runs and it returns 0, which equals `sorted.length`.
+- **Duplicates:** when `sorted[mid] >= value`, `hi` moves to `mid`, so the search keeps narrowing toward the leftmost qualifying index.
+- **Value below the first entry:** every probe takes the `hi = mid` branch, so it returns 0.
+- **Value above the last entry:** every probe takes the `lo = mid + 1` branch, so it returns `sorted.length`.
+- **No mutation:** it only reads `sorted` and `value`.
+
+Hand-traced on `[1,2,2,3]`:
+
+| `value` | Result |
+|---|---|
+| 2 | 1 |
+| 0 | 0 |
+| 4 | 4 |