@tea-agent/loop-agent 0.16.0 → 0.16.1-beta.1

package/dist/application/evaluation/outer-loop.js

@@ -1,132 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { createCampaign, validateCampaign, } from "./campaign.js";
-import { buildScorecardFromMatrixEvidence, formatMatrixRunMarkdown, runCampaignMatrix, } from "./campaign-matrix.js";
-import { formatProposerRunMarkdown, proposeFromCurate } from "./proposer.js";
-import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
-import { campaignManifestInputSchema } from "./types.js";
-/**
- * M7 outer-loop orchestration:
- * optional bounded propose → ensure/create campaign → matrix → optional scorecard.
- * Never calls promote/alias APIs.
- */
-export async function runOuterLoop(input) {
-    let proposerRun;
-    if (input.proposeFromCurate) {
-        proposerRun = await proposeFromCurate({
-            repoRoot: input.repoRoot,
-            maxCandidates: input.maxProposals ?? 1,
-            dryRun: false,
-            now: input.now,
-        });
-        if (proposerRun.proposals.length === 0) {
-            throw new Error(`outer-loop propose produced no candidates: ${proposerRun.skippedReasons.join("; ")}`);
-        }
-    }
-    let campaignId = input.campaignId;
-    if (input.campaignManifestPath) {
-        const absolute = path.resolve(input.repoRoot, input.campaignManifestPath);
-        const raw = JSON.parse(await readFile(absolute, "utf-8"));
-        if (proposerRun && proposerRun.proposals.length > 0) {
-            raw.challengerCandidateIds = proposerRun.proposals.map((row) => row.candidateId);
-        }
-        const parsed = campaignManifestInputSchema.parse(raw);
-        if (campaignId && parsed.campaignId !== campaignId) {
-            throw new Error(`campaignId mismatch: --campaign-id=${campaignId}, manifest=${parsed.campaignId}`);
-        }
-        campaignId = parsed.campaignId;
-        const staging = path.join(input.repoRoot, ".harness/evaluation/outer-loop", `${parsed.campaignId}.manifest.json`);
-        await writeJsonAtomic(staging, parsed, { repoRoot: input.repoRoot });
-        await validateCampaign({
-            repoRoot: input.repoRoot,
-            manifestPath: staging,
-        });
-        await createCampaign({
-            repoRoot: input.repoRoot,
-            manifestPath: staging,
-        });
-    }
-    if (!campaignId) {
-        throw new Error("outer-loop requires --campaign-id or --campaign-manifest");
-    }
-    if (proposerRun && !input.campaignManifestPath) {
-        // Campaign must already list proposed challengers.
-        const { showCampaign } = await import("./campaign.js");
-        const existing = await showCampaign({
-            repoRoot: input.repoRoot,
-            campaignId,
-        });
-        for (const proposal of proposerRun.proposals) {
-            if (!existing.manifest.challengerCandidateIds.includes(proposal.candidateId)) {
-                throw new Error(`proposed candidate ${proposal.candidateId} is not in campaign ${campaignId} challengers; recreate campaign with --campaign-manifest or add challenger ids`);
-            }
-        }
-    }
-    const matrixResult = await runCampaignMatrix({
-        repoRoot: input.repoRoot,
-        campaignId,
-        mode: input.matrixMode,
-        fixturePath: input.fixturePath,
-        maxPublicCells: input.maxPublicCells,
-        includePrivateChecks: true,
-        writeEvidenceDraft: true,
-        piExecutor: input.piExecutor,
-        now: input.now,
-    });
-    let scorecardBuilt = false;
-    let promotionEligible;
-    if (input.buildScorecard && matrixResult.evidence) {
-        // Scorecard from matrix draft alone is usually insufficient for held_out;
-        // still persist for inspection when requested.
-        try {
-            await buildScorecardFromMatrixEvidence({
-                repoRoot: input.repoRoot,
-                campaignId,
-                evidence: matrixResult.evidence,
-            });
-            scorecardBuilt = true;
-            const { readCampaignScorecard } = await import("../../infrastructure/evaluation/campaign-store.js");
-            const scorecard = await readCampaignScorecard(input.repoRoot, campaignId);
-            promotionEligible = scorecard?.policy.promotionEligible;
-        }
-        catch {
-            scorecardBuilt = false;
-        }
-    }
-    const result = {
-        schemaVersion: 1,
-        proposerRun,
-        campaignId,
-        matrix: matrixResult.matrix,
-        scorecardBuilt,
-        promotionEligible,
-        autoPromote: false,
-        next: [
-            `loop-agent eval campaign show --campaign-id ${campaignId} --json`,
-            `loop-agent eval campaign scorecard --campaign-id ${campaignId} --evidence .harness/evaluation/campaigns/${campaignId}/evidence-draft.json --json`,
-            `loop-agent eval promote --alias <name> --to-candidate <id> --campaign-id ${campaignId} --reason <text> --dry-run`,
-            "NEVER auto-promote: human --apply required after policy pass",
-        ],
-    };
-    return result;
-}
-export function formatOuterLoopMarkdown(result) {
-    const lines = [
-        `# Outer Loop: ${result.campaignId}`,
-        "",
-        `- autoPromote: \`${result.autoPromote}\``,
-        `- scorecardBuilt: ${result.scorecardBuilt}`,
-        `- promotionEligible: ${result.promotionEligible ?? "(n/a)"}`,
-        "",
-    ];
-    if (result.proposerRun) {
-        lines.push(formatProposerRunMarkdown(result.proposerRun));
-    }
-    lines.push(formatMatrixRunMarkdown(result.matrix));
-    lines.push("## Next", "");
-    for (const step of result.next) {
-        lines.push(`- ${step}`);
-    }
-    lines.push("");
-    return `${lines.join("\n")}\n`;
-}

package/dist/application/evaluation/pi-cell-executor.js

@@ -1,39 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { runDagUseCase } from "../dag/run-dag.js";
-import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
-/**
- * M7 live-Pi wiring (bounded): materialize a per-cell DagSpec with evaluation
- * binding and run `runDagUseCase` in dry-run mode only.
- *
- * Never auto-promotes. Full live Pi execute remains opt-in via custom PiCellExecutor.
- */
-export function createDagDryRunPiCellExecutor(input) {
-    return async (ctx) => {
-        const absoluteTemplate = path.resolve(ctx.repoRoot, input.dagTemplatePath);
-        const raw = JSON.parse(await readFile(absoluteTemplate, "utf-8"));
-        raw.version = 3;
-        raw.evaluation = ctx.evaluation;
-        raw.title =
-            typeof raw.title === "string"
-                ? `${raw.title} :: ${ctx.cell.cellId}`
-                : `eval-matrix-${ctx.cell.cellId}`;
-        const cellDagPath = path.join(ctx.repoRoot, path.dirname(ctx.jobPath), `${ctx.cell.cellId}.dag.json`);
-        await writeJsonAtomic(cellDagPath, raw, { repoRoot: ctx.repoRoot });
-        const result = await runDagUseCase({
-            repoRoot: ctx.repoRoot,
-            dagPath: cellDagPath,
-            cwd: ctx.repoRoot,
-            initOnly: false,
-            dryRun: true,
-        });
-        if (!("mode" in result) || result.mode !== "dry-run") {
-            throw new Error("createDagDryRunPiCellExecutor expected dry-run result; refuse non-dry execution");
-        }
-        return {
-            verifyPassed: false,
-            runId: result.runId,
-            detail: `pi dry-run prepared runDir=${result.runDir}; verifyPassed left false until live shell evidence`,
-        };
-    };
-}

package/dist/application/evaluation/private-verifier.js

@@ -1,46 +0,0 @@
-import { listPrivateVerifierIds, loadPrivateVerifierManifestFromPath, materializePrivateVerifierManifest, readPrivateVerifierManifest, registerPrivateVerifierManifest, } from "../../infrastructure/evaluation/private-verifier-store.js";
-export async function validatePrivateVerifier(input) {
-    const raw = await loadPrivateVerifierManifestFromPath(input.repoRoot, input.manifestPath);
-    const manifest = await materializePrivateVerifierManifest(raw);
-    return { manifest };
-}
-export async function registerPrivateVerifier(input) {
-    const validated = await validatePrivateVerifier(input);
-    return registerPrivateVerifierManifest({
-        repoRoot: input.repoRoot,
-        manifest: validated.manifest,
-    });
-}
-export async function showPrivateVerifier(input) {
-    const manifest = await readPrivateVerifierManifest(input.repoRoot, input.privateVerifierId);
-    return { manifest };
-}
-export async function listPrivateVerifiers(input) {
-    const ids = await listPrivateVerifierIds(input.repoRoot);
-    const rows = [];
-    for (const privateVerifierId of ids) {
-        const manifest = await readPrivateVerifierManifest(input.repoRoot, privateVerifierId);
-        rows.push({
-            privateVerifierId,
-            manifestHash: manifest.manifestHash,
-            checkCount: manifest.checks.length,
-        });
-    }
-    return rows;
-}
-export function formatPrivateVerifierMarkdown(manifest) {
-    return [
-        `# Private Verifier: ${manifest.privateVerifierId}`,
-        "",
-        `- manifestHash: \`${manifest.manifestHash}\``,
-        `- checks: ${manifest.checks.length}`,
-        `- createdAt: \`${manifest.createdAt}\``,
-        "",
-        "> Controller-only. Must never enter candidate prompt, skill snapshot, or contentRefs.",
-        "",
-        "## Checks",
-        "",
-        ...manifest.checks.map((check) => `- \`${check.checkId}\` (${check.kind}): command arity=${check.command.length}, timeoutMs=${check.timeoutMs}`),
-        "",
-    ].join("\n");
-}

package/dist/application/evaluation/promotion-policy.js

@@ -1,151 +0,0 @@
-import { runIntegrityAudits } from "./integrity-audit.js";
-export const PROMOTION_POLICY_VERSION = "promotion-policy-v1";
-function emptyTally() {
-    return { incumbentWins: 0, challengerWins: 0, ties: 0 };
-}
-function pairKey(cell) {
-    return `${cell.split}\u0000${cell.taskRef}\u0000${cell.seed}`;
-}
-function tallyPaired(input) {
-    const byKey = new Map();
-    for (const cell of input.cells) {
-        if (cell.split !== input.split)
-            continue;
-        const key = pairKey(cell);
-        const row = byKey.get(key) ?? {};
-        if (cell.candidateId === input.incumbentCandidateId) {
-            row.incumbent = cell.verifyPassed;
-        }
-        else if (cell.candidateId === input.challengerCandidateId) {
-            row.challenger = cell.verifyPassed;
-        }
-        byKey.set(key, row);
-    }
-    const tally = emptyTally();
-    for (const row of byKey.values()) {
-        if (row.incumbent === undefined || row.challenger === undefined)
-            continue;
-        if (row.challenger === row.incumbent) {
-            tally.ties += 1;
-        }
-        else if (row.challenger && !row.incumbent) {
-            tally.challengerWins += 1;
-        }
-        else {
-            tally.incumbentWins += 1;
-        }
-    }
-    return tally;
-}
-function privateImprovementStatus(tally) {
-    const compared = tally.incumbentWins + tally.challengerWins + tally.ties;
-    if (compared === 0)
-        return "insufficient";
-    if (tally.challengerWins > tally.incumbentWins)
-        return "pass";
-    return "fail";
-}
-function heldOutNonRegressionStatus(tally) {
-    const compared = tally.incumbentWins + tally.challengerWins + tally.ties;
-    if (compared === 0)
-        return "insufficient";
-    // Non-regression: challenger must not lose more pairs than incumbent.
-    if (tally.challengerWins + tally.ties >= tally.incumbentWins)
-        return "pass";
-    return "fail";
-}
-function budgetStatusGate(status) {
-    if (status === "ok")
-        return "pass";
-    if (status === "breached")
-        return "fail";
-    return "insufficient";
-}
-function safetyStatus(findings) {
-    if (findings.some((f) => f.severity === "fail"))
-        return "fail";
-    if (findings.some((f) => f.severity === "review"))
-        return "review";
-    return "pass";
-}
-/**
- * Evaluate Promotion Policy v1 (W5.1).
- * Never auto-promotes; human gate remains mandatory at apply time.
- */
-export function evaluatePromotionPolicy(input) {
-    if (input.evidence.campaignId !== input.campaignId) {
-        throw new Error(`evidence campaignId mismatch: expected ${input.campaignId}, got ${input.evidence.campaignId}`);
-    }
-    const findings = runIntegrityAudits({
-        evidence: input.evidence,
-        incumbentCandidateId: input.incumbentCandidateId,
-    });
-    const paired = {
-        private: tallyPaired({
-            incumbentCandidateId: input.incumbentCandidateId,
-            challengerCandidateId: input.evidence.challengerCandidateId,
-            cells: input.evidence.cells,
-            split: "private",
-        }),
-        held_out: tallyPaired({
-            incumbentCandidateId: input.incumbentCandidateId,
-            challengerCandidateId: input.evidence.challengerCandidateId,
-            cells: input.evidence.cells,
-            split: "held_out",
-        }),
-        public: tallyPaired({
-            incumbentCandidateId: input.incumbentCandidateId,
-            challengerCandidateId: input.evidence.challengerCandidateId,
-            cells: input.evidence.cells,
-            split: "public",
-        }),
-    };
-    const safetyOk = safetyStatus(findings);
-    const gates = {
-        privateImprovement: privateImprovementStatus(paired.private),
-        heldOutNonRegression: heldOutNonRegressionStatus(paired.held_out),
-        budgetOk: budgetStatusGate(input.evidence.budgetStatus.challenger),
-        safetyOk,
-        humanRequired: true,
-    };
-    const reasons = [];
-    if (gates.privateImprovement !== "pass") {
-        reasons.push(`privateImprovement=${gates.privateImprovement} (challengerWins=${paired.private.challengerWins}, incumbentWins=${paired.private.incumbentWins}, ties=${paired.private.ties})`);
-    }
-    if (gates.heldOutNonRegression !== "pass") {
-        reasons.push(`heldOutNonRegression=${gates.heldOutNonRegression} (challengerWins=${paired.held_out.challengerWins}, incumbentWins=${paired.held_out.incumbentWins}, ties=${paired.held_out.ties})`);
-    }
-    if (gates.budgetOk !== "pass") {
-        reasons.push(`budgetOk=${gates.budgetOk}`);
-    }
-    if (gates.safetyOk === "fail") {
-        reasons.push(`safetyOk=fail (${findings.filter((f) => f.severity === "fail").map((f) => f.code).join(", ")})`);
-    }
-    else if (gates.safetyOk === "review") {
-        if (input.acknowledgeReview) {
-            reasons.push(`safetyOk=review acknowledged via --acknowledge-review (${findings.filter((f) => f.severity === "review").map((f) => f.code).join(", ")})`);
-        }
-        else {
-            reasons.push(`safetyOk=review (${findings.filter((f) => f.severity === "review").map((f) => f.code).join(", ")}); re-run with --acknowledge-review after human review`);
-        }
-    }
-    reasons.push("humanRequired=true (apply still needs --reason)");
-    const safetyAllows = gates.safetyOk === "pass" ||
-        (gates.safetyOk === "review" && Boolean(input.acknowledgeReview));
-    const promotionEligible = gates.privateImprovement === "pass" &&
-        gates.heldOutNonRegression === "pass" &&
-        gates.budgetOk === "pass" &&
-        safetyAllows;
-    return {
-        schemaVersion: 1,
-        policyVersion: PROMOTION_POLICY_VERSION,
-        campaignId: input.campaignId,
-        incumbentCandidateId: input.incumbentCandidateId,
-        challengerCandidateId: input.evidence.challengerCandidateId,
-        promotionEligible,
-        gates,
-        findings,
-        reasons,
-        paired,
-    };
-}

package/dist/application/evaluation/proposer.js

@@ -1,98 +0,0 @@
-import { createHash } from "node:crypto";
-import { writeProposerRun } from "../../infrastructure/evaluation/proposer-store.js";
-import { createExperimentFromCurate } from "./experiment.js";
-/**
- * Controlled outer-loop proposer (M7).
- * Only proposes bounded experimental candidates from knowledge-curate.
- * Never modifies evaluator/kernel/private verifier and never auto-promotes.
- */
-export async function proposeFromCurate(input) {
-    const maxCandidates = input.maxCandidates ?? 1;
-    if (maxCandidates < 1 || maxCandidates > 3) {
-        throw new Error("proposer maxCandidates must be between 1 and 3 (bounded)");
-    }
-    const dryRun = input.dryRun !== false;
-    const now = input.now ?? new Date().toISOString();
-    const proposerRunId = input.proposerRunId ??
-        `propose-${createHash("sha256").update(now).digest("hex").slice(0, 12)}`;
-    const proposals = [];
-    const skippedReasons = [];
-    if (dryRun) {
-        skippedReasons.push("dry-run: no candidate registered; re-run with --apply to materialize bounded proposals");
-        const run = {
-            schemaVersion: 1,
-            proposerRunId,
-            source: "knowledge-curate",
-            createdAt: now,
-            maxCandidates,
-            proposals,
-            skippedReasons,
-            autoPromote: false,
-        };
-        return run;
-    }
-    for (let i = 0; i < maxCandidates; i += 1) {
-        try {
-            const created = await createExperimentFromCurate({
-                repoRoot: input.repoRoot,
-                now,
-                candidateId: `proposed-${proposerRunId}-${i + 1}`,
-                experimentId: `exp-${proposerRunId}-${i + 1}`,
-            });
-            proposals.push({
-                candidateId: created.candidate.manifest.candidateId,
-                experimentId: created.record.experimentId,
-                proposalPath: created.record.proposalPath,
-                bundleHash: created.candidate.manifest.bundleHash,
-                status: "proposed_experimenting",
-            });
-        }
-        catch (error) {
-            skippedReasons.push(error instanceof Error ? error.message : String(error));
-            break;
-        }
-    }
-    const run = {
-        schemaVersion: 1,
-        proposerRunId,
-        source: "knowledge-curate",
-        createdAt: now,
-        maxCandidates,
-        proposals,
-        skippedReasons,
-        autoPromote: false,
-    };
-    await writeProposerRun({ repoRoot: input.repoRoot, run });
-    return run;
-}
-export function formatProposerRunMarkdown(run) {
-    const lines = [
-        `# Proposer Run: ${run.proposerRunId}`,
-        "",
-        `- source: \`${run.source}\``,
-        `- maxCandidates: ${run.maxCandidates}`,
-        `- proposals: ${run.proposals.length}`,
-        `- autoPromote: \`${run.autoPromote}\``,
-        "",
-        "## Proposals",
-        "",
-    ];
-    if (run.proposals.length === 0) {
-        lines.push("(none)", "");
-    }
-    else {
-        for (const proposal of run.proposals) {
-            lines.push(`- \`${proposal.candidateId}\` experiment=\`${proposal.experimentId}\` hash=\`${proposal.bundleHash}\``);
-        }
-        lines.push("");
-    }
-    if (run.skippedReasons.length > 0) {
-        lines.push("## Skipped / notes", "");
-        for (const reason of run.skippedReasons) {
-            lines.push(`- ${reason}`);
-        }
-        lines.push("");
-    }
-    lines.push("> M7: proposer only registers experimenting candidates; promotion remains human-gated.", "");
-    return `${lines.join("\n")}\n`;
-}

package/dist/infrastructure/evaluation/alias-store.js

@@ -1,199 +0,0 @@
-import { createHash } from "node:crypto";
-import { access, mkdir, readdir, readFile, rm, writeFile, } from "node:fs/promises";
-import path from "node:path";
-import { aliasHistoryEventSchema, aliasNameSchema, incumbentAliasSchema, promotionDecisionSchema, } from "../../application/evaluation/types.js";
-import { appendJsonlLineAtomic, writeJsonAtomic, writeTextAtomic, } from "../harness/atomic-write.js";
-import { EVALUATION_ROOT } from "./store.js";
-const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const ALIAS_LOCK_DIR = ".lock";
-const ALIAS_LOCK_RETRIES = 40;
-const ALIAS_LOCK_DELAY_MS = 25;
-const CURRENT_INTEGRITY_FILE = "current.sha256";
-export function assertAliasName(value) {
-    aliasNameSchema.parse(value);
-    if (!SAFE_ID.test(value)) {
-        throw new Error(`alias must contain only letters, numbers, dot, underscore, or hyphen: ${value}`);
-    }
-}
-export function aliasDir(repoRoot, alias) {
-    assertAliasName(alias);
-    return path.join(repoRoot, EVALUATION_ROOT, "aliases", alias);
-}
-export function aliasCurrentPath(repoRoot, alias) {
-    return path.join(aliasDir(repoRoot, alias), "current.json");
-}
-export function aliasHistoryPath(repoRoot, alias) {
-    return path.join(aliasDir(repoRoot, alias), "history.jsonl");
-}
-export function decisionDir(repoRoot) {
-    return path.join(repoRoot, EVALUATION_ROOT, "decisions");
-}
-export function decisionPath(repoRoot, decisionId) {
-    if (!SAFE_ID.test(decisionId)) {
-        throw new Error(`decision-id must contain only letters, numbers, dot, underscore, or hyphen: ${decisionId}`);
-    }
-    return path.join(decisionDir(repoRoot), `${decisionId}.json`);
-}
-function sha256Hex(content) {
-    return createHash("sha256").update(content, "utf8").digest("hex");
-}
-function serializeAlias(alias) {
-    return `${JSON.stringify(alias, null, 2)}\n`;
-}
-async function pathExists(filePath) {
-    try {
-        await access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function acquireAliasLock(repoRoot, alias) {
-    const lockPath = path.join(aliasDir(repoRoot, alias), ALIAS_LOCK_DIR);
-    await mkdir(aliasDir(repoRoot, alias), { recursive: true });
-    for (let attempt = 0; attempt < ALIAS_LOCK_RETRIES; attempt += 1) {
-        try {
-            await mkdir(lockPath);
-            return async () => {
-                await rm(lockPath, { recursive: true, force: true });
-            };
-        }
-        catch (error) {
-            if (error.code !== "EEXIST")
-                throw error;
-            await new Promise((resolve) => setTimeout(resolve, ALIAS_LOCK_DELAY_MS));
-        }
-    }
-    throw new Error(`timed out acquiring alias lock for ${alias}`);
-}
-async function assertCurrentIntegrity(repoRoot, alias, raw) {
-    const integrityPath = path.join(aliasDir(repoRoot, alias), CURRENT_INTEGRITY_FILE);
-    if (!(await pathExists(integrityPath))) {
-        throw new Error(`missing alias integrity file for ${alias}`);
-    }
-    const expected = (await readFile(integrityPath, "utf-8")).trim();
-    const actual = sha256Hex(raw);
-    if (expected !== actual) {
-        throw new Error(`alias integrity mismatch for ${alias}: expected ${expected}, got ${actual}`);
-    }
-}
-export async function readIncumbentAlias(repoRoot, alias) {
-    assertAliasName(alias);
-    const currentPath = aliasCurrentPath(repoRoot, alias);
-    if (!(await pathExists(currentPath)))
-        return null;
-    const raw = await readFile(currentPath, "utf-8");
-    await assertCurrentIntegrity(repoRoot, alias, raw);
-    const parsed = incumbentAliasSchema.parse(JSON.parse(raw));
-    if (parsed.alias !== alias) {
-        throw new Error(`alias identity mismatch: directory=${alias}, current=${parsed.alias}`);
-    }
-    return parsed;
-}
-export async function listAliasNames(repoRoot) {
-    const root = path.join(repoRoot, EVALUATION_ROOT, "aliases");
-    try {
-        const entries = await readdir(root, { withFileTypes: true });
-        return entries
-            .filter((entry) => entry.isDirectory() && SAFE_ID.test(entry.name))
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === "ENOENT")
-            return [];
-        throw error;
-    }
-}
-export async function listIncumbentCandidateIds(repoRoot) {
-    const names = await listAliasNames(repoRoot);
-    const ids = new Set();
-    for (const name of names) {
-        const current = await readIncumbentAlias(repoRoot, name);
-        if (current)
-            ids.add(current.candidateId);
-    }
-    return ids;
-}
-export async function readPromotionDecision(repoRoot, decisionId) {
-    const raw = await readFile(decisionPath(repoRoot, decisionId), "utf-8");
-    return promotionDecisionSchema.parse(JSON.parse(raw));
-}
-async function writeAliasCurrentAtomic(input) {
-    const dir = aliasDir(input.repoRoot, input.alias.alias);
-    await mkdir(dir, { recursive: true });
-    const serialized = serializeAlias(input.alias);
-    await writeTextAtomic(aliasCurrentPath(input.repoRoot, input.alias.alias), serialized, {
-        repoRoot: input.repoRoot,
-    });
-    await writeTextAtomic(path.join(dir, CURRENT_INTEGRITY_FILE), `${sha256Hex(serialized)}\n`, { repoRoot: input.repoRoot });
-}
-export async function commitAliasMove(input) {
-    const { repoRoot, decision, nextAlias, historyEvent } = input;
-    assertAliasName(decision.alias);
-    promotionDecisionSchema.parse(decision);
-    incumbentAliasSchema.parse(nextAlias);
-    aliasHistoryEventSchema.parse(historyEvent);
-    if (decision.decisionId !== nextAlias.updatedByDecisionId) {
-        throw new Error("decisionId must match alias.updatedByDecisionId");
-    }
-    if (decision.decisionId !== historyEvent.decisionId) {
-        throw new Error("decisionId must match history event");
-    }
-    const releaseLock = await acquireAliasLock(repoRoot, decision.alias);
-    const previousRaw = await readFile(aliasCurrentPath(repoRoot, decision.alias), "utf-8").catch(() => null);
-    const previousIntegrity = await readFile(path.join(aliasDir(repoRoot, decision.alias), CURRENT_INTEGRITY_FILE), "utf-8").catch(() => null);
-    const decisionFile = decisionPath(repoRoot, decision.decisionId);
-    let decisionWritten = false;
-    let historyWritten = false;
-    try {
-        if (await pathExists(decisionFile)) {
-            throw new Error(`decision already exists: ${decision.decisionId}`);
-        }
-        await mkdir(decisionDir(repoRoot), { recursive: true });
-        await writeJsonAtomic(decisionFile, decision, { repoRoot });
-        decisionWritten = true;
-        await writeAliasCurrentAtomic({ repoRoot, alias: nextAlias });
-        await appendJsonlLineAtomic(aliasHistoryPath(repoRoot, decision.alias), historyEvent, { repoRoot });
-        historyWritten = true;
-    }
-    catch (error) {
-        // Best-effort rollback of alias pointer + decision; history append is last.
-        if (previousRaw !== null) {
-            await writeTextAtomic(aliasCurrentPath(repoRoot, decision.alias), previousRaw, { repoRoot }).catch(() => undefined);
-            if (previousIntegrity !== null) {
-                await writeTextAtomic(path.join(aliasDir(repoRoot, decision.alias), CURRENT_INTEGRITY_FILE), previousIntegrity, { repoRoot }).catch(() => undefined);
-            }
-        }
-        else if (!historyWritten) {
-            await rm(aliasCurrentPath(repoRoot, decision.alias), {
-                force: true,
-            }).catch(() => undefined);
-            await rm(path.join(aliasDir(repoRoot, decision.alias), CURRENT_INTEGRITY_FILE), { force: true }).catch(() => undefined);
-        }
-        if (decisionWritten) {
-            await rm(decisionFile, { force: true }).catch(() => undefined);
-        }
-        throw error;
-    }
-    finally {
-        await releaseLock();
-    }
-}
-export function makeDecisionId(input) {
-    const stamp = input.createdAt.replace(/[^A-Za-z0-9._-]/g, "-");
-    const raw = `dec-${input.alias}-${input.action}-${input.toCandidateId}-${stamp}`;
-    return raw.slice(0, 180);
-}
-/** Test helper: force-corrupt integrity without going through commit. */
-export async function writeAliasCurrentForTest(input) {
-    await writeAliasCurrentAtomic({
-        repoRoot: input.repoRoot,
-        alias: input.alias,
-    });
-    if (input.corruptIntegrity) {
-        await writeFile(path.join(aliasDir(input.repoRoot, input.alias.alias), CURRENT_INTEGRITY_FILE), `${"0".repeat(64)}\n`, "utf-8");
-    }
-}