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

package/dist/application/evaluation/alias.js

@@ -0,0 +1,184 @@
+import { readFile } from "node:fs/promises";
+import { aliasHistoryPath, commitAliasMove, listAliasNames, listIncumbentCandidateIds, makeDecisionId, readIncumbentAlias, readPromotionDecision, } from "../../infrastructure/evaluation/alias-store.js";
+import { readCandidateRecord } from "../../infrastructure/evaluation/candidate-store.js";
+async function requireAcceptedCandidate(input) {
+    const record = await readCandidateRecord(input.repoRoot, input.candidateId);
+    if (record.status !== "accepted") {
+        throw new Error(`alias move requires candidate lifecycle accepted; ${input.candidateId} is ${record.status}`);
+    }
+    return {
+        candidateId: record.manifest.candidateId,
+        bundleHash: record.manifest.bundleHash,
+    };
+}
+function buildDecision(input) {
+    const decisionId = makeDecisionId({
+        alias: input.alias,
+        action: input.action,
+        toCandidateId: input.toCandidateId,
+        createdAt: input.createdAt,
+    });
+    return {
+        schemaVersion: 1,
+        decisionId,
+        alias: input.alias,
+        action: input.action,
+        fromCandidateId: input.fromCandidateId,
+        toCandidateId: input.toCandidateId,
+        toBundleHash: input.toBundleHash,
+        reason: input.reason,
+        actor: "human",
+        humanRequired: true,
+        applied: input.applied,
+        createdAt: input.createdAt,
+        campaignId: input.campaignId ?? null,
+    };
+}
+async function planAliasMove(input) {
+    const reason = input.reason.trim();
+    if (!reason) {
+        throw new Error("alias move requires non-empty --reason");
+    }
+    const createdAt = input.now ?? new Date().toISOString();
+    const previous = await readIncumbentAlias(input.repoRoot, input.alias);
+    if (input.action === "rollback" && !previous) {
+        throw new Error(`cannot rollback alias ${input.alias}: alias does not exist yet`);
+    }
+    const target = await requireAcceptedCandidate({
+        repoRoot: input.repoRoot,
+        candidateId: input.toCandidateId,
+    });
+    if (previous && previous.candidateId === target.candidateId) {
+        throw new Error(`alias ${input.alias} already points at candidate ${target.candidateId}`);
+    }
+    const decision = buildDecision({
+        alias: input.alias,
+        action: input.action,
+        fromCandidateId: previous?.candidateId ?? null,
+        toCandidateId: target.candidateId,
+        toBundleHash: target.bundleHash,
+        reason,
+        applied: !input.dryRun,
+        createdAt,
+        campaignId: input.campaignId,
+    });
+    const nextAlias = {
+        schemaVersion: 1,
+        alias: input.alias,
+        candidateId: target.candidateId,
+        bundleHash: target.bundleHash,
+        updatedAt: createdAt,
+        updatedByDecisionId: decision.decisionId,
+        previousCandidateId: previous?.candidateId ?? null,
+    };
+    if (input.dryRun) {
+        return {
+            dryRun: true,
+            decision: { ...decision, applied: false },
+            alias: nextAlias,
+            previous,
+        };
+    }
+    const historySeq = previous ? await nextHistorySeq(input.repoRoot, input.alias) : 1;
+    const historyEvent = {
+        schemaVersion: 1,
+        seq: historySeq,
+        decisionId: decision.decisionId,
+        action: input.action,
+        fromCandidateId: previous?.candidateId ?? null,
+        toCandidateId: target.candidateId,
+        toBundleHash: target.bundleHash,
+        at: createdAt,
+    };
+    await commitAliasMove({
+        repoRoot: input.repoRoot,
+        decision,
+        nextAlias,
+        historyEvent,
+    });
+    // W2.4 does not auto-retire the previous incumbent: lifecycle `accepted` ≠
+    // alias pointer, and rollback drills must be able to point back without
+    // inventing a new candidate id. Operators may `eval candidate transition
+    // --to retired` separately.
+    return {
+        dryRun: false,
+        decision,
+        alias: (await readIncumbentAlias(input.repoRoot, input.alias)),
+        previous,
+    };
+}
+async function nextHistorySeq(repoRoot, alias) {
+    const text = await readFile(aliasHistoryPath(repoRoot, alias), "utf-8").catch(() => "");
+    const lines = text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    return lines.length + 1;
+}
+export async function promoteAlias(input) {
+    return planAliasMove({
+        ...input,
+        action: "promote",
+        dryRun: input.dryRun !== false,
+    });
+}
+export async function rollbackAlias(input) {
+    return planAliasMove({
+        ...input,
+        action: "rollback",
+        dryRun: input.dryRun !== false,
+    });
+}
+export async function showAlias(input) {
+    const current = await readIncumbentAlias(input.repoRoot, input.alias);
+    if (!current) {
+        throw new Error(`alias not found: ${input.alias}`);
+    }
+    return current;
+}
+export async function listAliases(input) {
+    const names = await listAliasNames(input.repoRoot);
+    const rows = [];
+    for (const name of names) {
+        const current = await readIncumbentAlias(input.repoRoot, name);
+        if (current)
+            rows.push(current);
+    }
+    return rows;
+}
+export async function isCandidatePromotionApplied(input) {
+    const incumbents = await listIncumbentCandidateIds(input.repoRoot);
+    return incumbents.has(input.candidateId);
+}
+export function formatAliasMarkdown(alias) {
+    return [
+        `# Alias: ${alias.alias}`,
+        "",
+        `- candidateId: \`${alias.candidateId}\``,
+        `- bundleHash: \`${alias.bundleHash}\``,
+        `- previousCandidateId: \`${alias.previousCandidateId ?? "null"}\``,
+        `- updatedByDecisionId: \`${alias.updatedByDecisionId}\``,
+        `- updatedAt: \`${alias.updatedAt}\``,
+        "",
+    ].join("\n");
+}
+export function formatAliasMoveMarkdown(result) {
+    const mode = result.dryRun ? "dry-run" : "applied";
+    return [
+        `# Alias ${result.decision.action} (${mode})`,
+        "",
+        `- alias: \`${result.decision.alias}\``,
+        `- from: \`${result.decision.fromCandidateId ?? "null"}\``,
+        `- to: \`${result.decision.toCandidateId}\``,
+        `- bundleHash: \`${result.decision.toBundleHash}\``,
+        `- decisionId: \`${result.decision.decisionId}\``,
+        `- applied: \`${result.decision.applied}\``,
+        `- reason: ${result.decision.reason}`,
+        "",
+        result.dryRun
+            ? "_No alias files were written (dry-run). Pass `--apply` to commit._"
+            : "_Alias pointer updated; candidate bundles and completed DAG facts were not rewritten._",
+        "",
+    ].join("\n");
+}
+export { readPromotionDecision };

package/dist/application/evaluation/budget.js

@@ -0,0 +1,192 @@
+import { z } from "zod";
+/**
+ * Campaign / DAG hard-budget contract (Eval Lab W3.4–W3.5 / M3).
+ *
+ * Token incompleteness: missing `tokensUsed` must never be treated as 0.
+ * When `maxTokens` is set, only known token samples accumulate; breach fires
+ * only when the known sum exceeds the limit. Calls + wall time + repair passes
+ * are the primary hard dimensions for v1.
+ */
+export const campaignBudgetModeSchema = z.enum(["hard", "record-only"]);
+export const campaignBudgetLimitsSchema = z
+    .object({
+    maxTokens: z.number().int().positive().optional(),
+    maxWallTimeMs: z.number().int().positive().optional(),
+    maxExecutorCalls: z.number().int().positive().optional(),
+    maxRepairPasses: z.number().int().nonnegative().optional(),
+    maxConcurrency: z.number().int().positive().optional(),
+    maxContextChars: z.number().int().positive().optional(),
+})
+    .strict()
+    .superRefine((limits, ctx) => {
+    const hasHardDim = limits.maxTokens !== undefined ||
+        limits.maxWallTimeMs !== undefined ||
+        limits.maxExecutorCalls !== undefined ||
+        limits.maxRepairPasses !== undefined ||
+        limits.maxContextChars !== undefined;
+    if (!hasHardDim) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "budget.limits requires at least one of maxTokens, maxWallTimeMs, maxExecutorCalls, maxRepairPasses, maxContextChars",
+        });
+    }
+});
+export const campaignBudgetSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    mode: campaignBudgetModeSchema.default("hard"),
+    limits: campaignBudgetLimitsSchema,
+})
+    .strict();
+export function createBudgetLedger(budget) {
+    return {
+        schemaVersion: 1,
+        mode: budget.mode,
+        limits: { ...budget.limits },
+        consumed: {
+            tokens: null,
+            wallTimeMs: 0,
+            executorCalls: 0,
+            repairPasses: 0,
+            peakContextChars: 0,
+            missingTokenNodeIds: [],
+        },
+        breaches: [],
+        status: budget.mode === "record-only" ? "record-only" : "ok",
+    };
+}
+export function resolveEffectiveMaxConcurrent(requested, budget) {
+    const limit = budget?.limits.maxConcurrency;
+    if (limit === undefined) {
+        return { maxConcurrent: Math.max(1, requested), clamped: false };
+    }
+    const maxConcurrent = Math.max(1, Math.min(requested, limit));
+    return { maxConcurrent, clamped: maxConcurrent < requested };
+}
+function pushBreach(ledger, breach) {
+    const full = {
+        ...breach,
+        at: breach.at ?? new Date().toISOString(),
+    };
+    const duplicate = ledger.breaches.some((existing) => existing.dimension === full.dimension &&
+        existing.nodeId === full.nodeId &&
+        existing.limit === full.limit);
+    if (!duplicate) {
+        ledger.breaches.push(full);
+    }
+    if (ledger.mode === "hard") {
+        ledger.status = "breached";
+    }
+}
+function checkLimit(ledger, dimension, consumed, limit, opts) {
+    if (limit === undefined)
+        return undefined;
+    const exceeded = opts?.inclusive ? consumed >= limit : consumed > limit;
+    if (!exceeded)
+        return undefined;
+    const breach = {
+        dimension,
+        limit,
+        consumed,
+        at: new Date().toISOString(),
+        ...(opts?.nodeId ? { nodeId: opts.nodeId } : {}),
+    };
+    pushBreach(ledger, breach);
+    return breach;
+}
+/**
+ * Pre-node check (no call increment yet).
+ * Discrete call budget uses inclusive compare so maxExecutorCalls=1 allows the
+ * first node then blocks starting a second.
+ */
+export function checkBudgetPreNode(ledger, sample) {
+    ledger.consumed.wallTimeMs = sample.wallTimeMs;
+    ledger.consumed.repairPasses = sample.repairPasses;
+    return (checkLimit(ledger, "executorCalls", ledger.consumed.executorCalls, ledger.limits.maxExecutorCalls, { inclusive: true }) ??
+        checkLimit(ledger, "wallTimeMs", sample.wallTimeMs, ledger.limits.maxWallTimeMs) ??
+        checkLimit(ledger, "repairPasses", sample.repairPasses, ledger.limits.maxRepairPasses));
+}
+/**
+ * Record one finished node execution attempt and evaluate hard limits.
+ * Increments executorCalls by 1. Does not invent tokens when missing.
+ */
+export function recordNodeBudgetSample(ledger, sample) {
+    ledger.consumed.executorCalls += 1;
+    ledger.consumed.wallTimeMs = sample.wallTimeMs;
+    ledger.consumed.repairPasses = sample.repairPasses;
+    if (sample.tokensUsed === undefined) {
+        if (!ledger.consumed.missingTokenNodeIds.includes(sample.nodeId)) {
+            ledger.consumed.missingTokenNodeIds.push(sample.nodeId);
+        }
+    }
+    else {
+        ledger.consumed.tokens = (ledger.consumed.tokens ?? 0) + sample.tokensUsed;
+    }
+    if (sample.contextChars !== undefined) {
+        ledger.consumed.peakContextChars = Math.max(ledger.consumed.peakContextChars, sample.contextChars);
+    }
+    return (checkLimit(ledger, "executorCalls", ledger.consumed.executorCalls, ledger.limits.maxExecutorCalls, { nodeId: sample.nodeId, inclusive: true }) ??
+        checkLimit(ledger, "wallTimeMs", ledger.consumed.wallTimeMs, ledger.limits.maxWallTimeMs, { nodeId: sample.nodeId }) ??
+        checkLimit(ledger, "repairPasses", ledger.consumed.repairPasses, ledger.limits.maxRepairPasses, { nodeId: sample.nodeId }) ??
+        (ledger.consumed.tokens !== null
+            ? checkLimit(ledger, "tokens", ledger.consumed.tokens, ledger.limits.maxTokens, { nodeId: sample.nodeId })
+            : undefined) ??
+        checkLimit(ledger, "contextChars", ledger.consumed.peakContextChars, ledger.limits.maxContextChars, { nodeId: sample.nodeId }));
+}
+export function isHardBudgetBreached(ledger) {
+    return Boolean(ledger && ledger.mode === "hard" && ledger.status === "breached");
+}
+/** Mark all PENDING nodes as SKIPPED due to budget breach (fail closed). */
+export function skipPendingNodesForBudgetBreach(nodes, breach) {
+    const skipped = [];
+    const reason = `budget_breach:${breach.dimension}`;
+    for (const [id, node] of Object.entries(nodes)) {
+        if (node.status !== "PENDING")
+            continue;
+        node.status = "SKIPPED";
+        node.skippedReason = reason;
+        skipped.push(id);
+    }
+    return skipped;
+}
+export function formatBudgetReportMarkdown(ledger) {
+    const limits = ledger.limits;
+    const c = ledger.consumed;
+    const lines = [
+        `# Budget Ledger`,
+        ``,
+        `- **mode**: ${ledger.mode}`,
+        `- **status**: ${ledger.status}`,
+        ``,
+        `## Limits`,
+        ``,
+        `| dimension | limit |`,
+        `|---|---|`,
+        `| maxTokens | ${limits.maxTokens ?? "n/a"} |`,
+        `| maxWallTimeMs | ${limits.maxWallTimeMs ?? "n/a"} |`,
+        `| maxExecutorCalls | ${limits.maxExecutorCalls ?? "n/a"} |`,
+        `| maxRepairPasses | ${limits.maxRepairPasses ?? "n/a"} |`,
+        `| maxConcurrency | ${limits.maxConcurrency ?? "n/a"} |`,
+        `| maxContextChars | ${limits.maxContextChars ?? "n/a"} |`,
+        ``,
+        `## Consumed`,
+        ``,
+        `| dimension | value |`,
+        `|---|---|`,
+        `| tokens | ${c.tokens ?? "n/a (missing)"} |`,
+        `| wallTimeMs | ${c.wallTimeMs} |`,
+        `| executorCalls | ${c.executorCalls} |`,
+        `| repairPasses | ${c.repairPasses} |`,
+        `| peakContextChars | ${c.peakContextChars} |`,
+        `| missingTokenNodes | ${c.missingTokenNodeIds.join(", ") || "none"} |`,
+    ];
+    if (ledger.breaches.length > 0) {
+        lines.push(``, `## Breaches`, ``);
+        for (const breach of ledger.breaches) {
+            lines.push(`- **${breach.dimension}**: consumed ${breach.consumed} > limit ${breach.limit}` +
+                (breach.nodeId ? ` (node ${breach.nodeId})` : "") +
+                ` at ${breach.at}`);
+        }
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/application/evaluation/campaign-hash.js

@@ -0,0 +1,47 @@
+import { formatContentSha, sha256Hex, } from "./candidate-hash.js";
+/** Frozen placeholder for M4; M5 may replace with real scoring rules bytes. */
+export const SCORING_RULES_V1 = "promotion-policy-v1";
+export function computeScoringRulesHash(policyVersion = SCORING_RULES_V1) {
+    return formatContentSha(sha256Hex(policyVersion));
+}
+export function computeBudgetHash(budget) {
+    const canonical = {
+        schemaVersion: budget.schemaVersion,
+        mode: budget.mode,
+        limits: Object.fromEntries(Object.entries(budget.limits).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)),
+    };
+    return formatContentSha(sha256Hex(JSON.stringify(canonical)));
+}
+export function computePrivateVerifierManifestHash(manifest) {
+    const checks = [...manifest.checks]
+        .map((check) => ({
+        checkId: check.checkId,
+        kind: check.kind,
+        command: [...check.command],
+        cwd: check.cwd ?? ".",
+        timeoutMs: check.timeoutMs ?? 60_000,
+        expectedExitCode: check.expectedExitCode ?? 0,
+    }))
+        .sort((a, b) => a.checkId < b.checkId ? -1 : a.checkId > b.checkId ? 1 : 0);
+    const canonical = {
+        schemaVersion: 1,
+        privateVerifierId: manifest.privateVerifierId,
+        checks,
+    };
+    return formatContentSha(sha256Hex(JSON.stringify(canonical)));
+}
+export function computeCampaignPlanHash(campaignId, cells) {
+    const sorted = [...cells].sort((a, b) => a.cellId < b.cellId ? -1 : a.cellId > b.cellId ? 1 : 0);
+    const canonical = {
+        schemaVersion: 1,
+        campaignId,
+        cells: sorted,
+    };
+    return formatContentSha(sha256Hex(JSON.stringify(canonical)));
+}
+export function assertPrivateVerifierHash(manifest) {
+    const recomputed = computePrivateVerifierManifestHash(manifest);
+    if (recomputed !== manifest.manifestHash) {
+        throw new Error(`privateVerifier manifestHash mismatch for ${manifest.privateVerifierId}: expected ${recomputed}, got ${manifest.manifestHash}`);
+    }
+}