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

package/dist/application/evaluation/types.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { campaignBudgetSchema } from "./budget.js";
 export const evalSplitSchema = z.enum(["public", "private", "held_out"]);
 export const replayEvidenceRefSchema = z
     .object({
@@ -129,524 +128,3 @@ export const lifecycleEventSchema = z
     eventHash: z.string().regex(/^[a-f0-9]{64}$/),
 })
     .strict();
-// --- Incumbent Alias + Promotion Decision (M2 W2.4) ---
-export const aliasNameSchema = z
-    .string()
-    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "alias must be one safe path segment");
-export const incumbentAliasSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    alias: aliasNameSchema,
-    candidateId: candidateIdSchema,
-    bundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    updatedAt: z.string().min(1),
-    updatedByDecisionId: z.string().min(1),
-    previousCandidateId: candidateIdSchema.nullable(),
-})
-    .strict();
-export const aliasHistoryEventSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    seq: z.number().int().positive(),
-    decisionId: z.string().min(1),
-    action: z.enum(["promote", "rollback"]),
-    fromCandidateId: candidateIdSchema.nullable(),
-    toCandidateId: candidateIdSchema,
-    toBundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    at: z.string().min(1),
-})
-    .strict();
-export const promotionDecisionSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    decisionId: z.string().min(1),
-    alias: aliasNameSchema,
-    action: z.enum(["promote", "rollback"]),
-    fromCandidateId: candidateIdSchema.nullable(),
-    toCandidateId: candidateIdSchema,
-    toBundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    reason: z.string().min(1),
-    actor: z.literal("human"),
-    humanRequired: z.literal(true),
-    applied: z.boolean(),
-    createdAt: z.string().min(1),
-    campaignId: z.string().min(1).nullable().optional(),
-})
-    .strict();
-// --- Corpus Manifest (W1.5) ---
-export const corpusIdSchema = z
-    .string()
-    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "corpusId must be one safe path segment");
-export const corpusTaskClassSchema = z.enum([
-    "docs",
-    "bugfix",
-    "implement",
-    "frontend",
-    "backend-test",
-    "fullstack",
-    "bootstrap",
-    "refactor",
-]);
-export const corpusTaskSchema = z
-    .object({
-    taskRef: z
-        .string()
-        .min(1)
-        .regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/, "taskRef must be a safe relative id (letters, numbers, . _ - /)")
-        .refine((value) => !value.includes(".."), "taskRef must not contain .."),
-    class: corpusTaskClassSchema,
-    split: evalSplitSchema,
-    seeds: z
-        .array(z.number().int().nonnegative())
-        .min(2)
-        .max(3)
-        .superRefine((seeds, ctx) => {
-        const seen = new Set();
-        for (let i = 0; i < seeds.length; i += 1) {
-            const seed = seeds[i];
-            if (seen.has(seed)) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: `duplicate seed ${seed}`,
-                    path: [i],
-                });
-            }
-            seen.add(seed);
-        }
-    }),
-    description: z.string().optional(),
-    featureId: z.string().min(1).optional(),
-})
-    .strict();
-function refineCorpusTasks(manifest, ctx) {
-    const refs = new Set();
-    const classes = new Set();
-    const splits = new Set();
-    for (let i = 0; i < manifest.tasks.length; i += 1) {
-        const task = manifest.tasks[i];
-        if (refs.has(task.taskRef)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `duplicate taskRef: ${task.taskRef}`,
-                path: ["tasks", i, "taskRef"],
-            });
-        }
-        refs.add(task.taskRef);
-        classes.add(task.class);
-        splits.add(task.split);
-    }
-    if (classes.size < 3) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "corpus requires at least 3 distinct task classes",
-            path: ["tasks"],
-        });
-    }
-    for (const required of ["public", "private", "held_out"]) {
-        if (!splits.has(required)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `corpus requires at least one ${required} task`,
-                path: ["tasks"],
-            });
-        }
-    }
-}
-const corpusManifestObjectSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    corpusId: corpusIdSchema,
-    createdAt: z.string().min(1),
-    description: z.string().optional(),
-    tasks: z.array(corpusTaskSchema).min(12).max(20),
-    corpusHash: z
-        .string()
-        .regex(/^(sha256:)?[a-f0-9]{64}$/i)
-        .optional(),
-})
-    .strict();
-export const corpusManifestInputSchema = corpusManifestObjectSchema.superRefine(refineCorpusTasks);
-export const corpusManifestSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    corpusId: corpusIdSchema,
-    createdAt: z.string().min(1),
-    description: z.string().optional(),
-    tasks: z.array(corpusTaskSchema).min(12).max(20),
-    corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-})
-    .strict()
-    .superRefine(refineCorpusTasks);
-// --- Private Verifier + Campaign (M4) ---
-export const privateVerifierIdSchema = z
-    .string()
-    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "privateVerifierId must be one safe path segment");
-export const privateVerifierCheckSchema = z
-    .object({
-    checkId: z
-        .string()
-        .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "checkId must be a safe id"),
-    kind: z.literal("shell"),
-    command: z.array(z.string().min(1)).min(1),
-    cwd: z.string().min(1).default("."),
-    timeoutMs: z.number().int().positive().max(3_600_000).default(60_000),
-    expectedExitCode: z.number().int().default(0),
-})
-    .strict();
-export const privateVerifierManifestInputSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    privateVerifierId: privateVerifierIdSchema,
-    createdAt: z.string().min(1),
-    description: z.string().optional(),
-    checks: z.array(privateVerifierCheckSchema).min(1),
-    manifestHash: z
-        .string()
-        .regex(/^(sha256:)?[a-f0-9]{64}$/i)
-        .optional(),
-})
-    .strict();
-export const privateVerifierManifestSchema = privateVerifierManifestInputSchema
-    .extend({
-    manifestHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-})
-    .strict();
-export const campaignIdSchema = z
-    .string()
-    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "campaignId must be one safe path segment");
-export const campaignStatusSchema = z.enum([
-    "prepared",
-    "running",
-    "completed",
-    "invalid",
-    "aborted",
-]);
-export const campaignEvaluatorIntegritySchema = z
-    .object({
-    corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    privateVerifierManifestHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    budgetHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    scoringRulesHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-})
-    .strict();
-function refineCampaignCandidates(manifest, ctx) {
-    if (manifest.budget.mode !== "hard") {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "campaign budget.mode must be hard (record-only campaigns cannot enter promotion path)",
-            path: ["budget", "mode"],
-        });
-    }
-    if (manifest.challengerCandidateIds.includes(manifest.incumbentCandidateId)) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "challengerCandidateIds must not include incumbentCandidateId",
-            path: ["challengerCandidateIds"],
-        });
-    }
-    const seen = new Set();
-    for (let i = 0; i < manifest.challengerCandidateIds.length; i += 1) {
-        const id = manifest.challengerCandidateIds[i];
-        if (seen.has(id)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `duplicate challengerCandidateId: ${id}`,
-                path: ["challengerCandidateIds", i],
-            });
-        }
-        seen.add(id);
-    }
-}
-const campaignManifestObjectSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    campaignId: campaignIdSchema,
-    createdAt: z.string().min(1),
-    status: campaignStatusSchema.default("prepared"),
-    controllerFingerprint: z.string().min(1).optional(),
-    policyVersion: z.string().min(1).default("promotion-policy-v1"),
-    incumbentCandidateId: candidateIdSchema,
-    challengerCandidateIds: z.array(candidateIdSchema).min(1),
-    corpusId: corpusIdSchema,
-    corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    privateVerifierId: privateVerifierIdSchema,
-    privateVerifierManifestHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    budget: campaignBudgetSchema,
-    seeds: z.array(z.number().int().nonnegative()).min(1).optional(),
-    notes: z.string().optional(),
-    evaluatorIntegrity: campaignEvaluatorIntegritySchema.optional(),
-})
-    .strict();
-export const campaignManifestInputSchema = campaignManifestObjectSchema.superRefine(refineCampaignCandidates);
-export const campaignManifestSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    campaignId: campaignIdSchema,
-    createdAt: z.string().min(1),
-    status: campaignStatusSchema,
-    controllerFingerprint: z.string().min(1).optional(),
-    policyVersion: z.string().min(1),
-    incumbentCandidateId: candidateIdSchema,
-    challengerCandidateIds: z.array(candidateIdSchema).min(1),
-    corpusId: corpusIdSchema,
-    corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    privateVerifierId: privateVerifierIdSchema,
-    privateVerifierManifestHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    budget: campaignBudgetSchema,
-    seeds: z.array(z.number().int().nonnegative()).min(1).optional(),
-    notes: z.string().optional(),
-    evaluatorIntegrity: campaignEvaluatorIntegritySchema,
-})
-    .strict()
-    .superRefine(refineCampaignCandidates);
-export const campaignCellExecutionRoleSchema = z.enum([
-    "candidate_run",
-    "private_verify",
-    "promotion_gate_only",
-]);
-export const campaignPlanCellSchema = z
-    .object({
-    cellId: z.string().min(1),
-    candidateId: candidateIdSchema,
-    bundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    taskRef: z.string().min(1),
-    seed: z.number().int().nonnegative(),
-    split: evalSplitSchema,
-    executionRole: campaignCellExecutionRoleSchema,
-    /** Controller-only flag; never serialized into candidate DAG prompts. */
-    privateVerifierAttached: z.boolean(),
-})
-    .strict();
-export const campaignPlanSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    campaignId: campaignIdSchema,
-    planHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    createdAt: z.string().min(1),
-    cells: z.array(campaignPlanCellSchema).min(1),
-})
-    .strict();
-// --- Campaign Evidence + Promotion Policy (M5) ---
-export const campaignEvidenceCellSchema = z
-    .object({
-    cellId: z.string().min(1).optional(),
-    candidateId: candidateIdSchema,
-    taskRef: z.string().min(1),
-    seed: z.number().int().nonnegative(),
-    split: evalSplitSchema,
-    verifyPassed: z.boolean(),
-    runId: z.string().min(1).optional(),
-    score: z.number().optional(),
-})
-    .strict();
-export const campaignEvidenceDiffSchema = z
-    .object({
-    path: z.string().min(1),
-    unifiedDiff: z.string(),
-})
-    .strict();
-export const campaignEvidenceSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    campaignId: campaignIdSchema,
-    challengerCandidateId: candidateIdSchema,
-    cells: z.array(campaignEvidenceCellSchema).min(1),
-    diffs: z.array(campaignEvidenceDiffSchema).default([]),
-    verifyCommands: z
-        .object({
-        incumbent: z.array(z.string().min(1)).default([]),
-        challenger: z.array(z.string().min(1)).default([]),
-    })
-        .strict()
-        .default({ incumbent: [], challenger: [] }),
-    budgetStatus: z
-        .object({
-        incumbent: z.enum(["ok", "breached", "missing"]),
-        challenger: z.enum(["ok", "breached", "missing"]),
-    })
-        .strict()
-        .default({ incumbent: "missing", challenger: "missing" }),
-})
-    .strict();
-// --- Learned Guidance Experiment (M6) ---
-export const experimentIdSchema = z
-    .string()
-    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "experimentId must be one safe path segment");
-export const experimentPatternEvidenceSchema = z
-    .object({
-    key: z.string().min(1),
-    failureClass: z.string().min(1),
-    fixScopeShape: z.string().min(1),
-    invariant: z.string().min(1),
-    count: z.number().int().positive(),
-    sourceRunIds: z.array(z.string().min(1)).default([]),
-    whenToApply: z.string().min(1),
-    whenNotToApply: z.string().min(1),
-})
-    .strict();
-export const experimentDispositionSchema = z
-    .object({
-    status: z.enum(["accepted", "rejected"]),
-    at: z.string().min(1),
-    reason: z.string().min(1),
-    campaignId: campaignIdSchema.optional(),
-    scorecardPlanHash: z.string().min(1).optional(),
-    heldOutNonRegression: z
-        .enum(["pass", "fail", "insufficient", "review"])
-        .optional(),
-})
-    .strict();
-export const experimentRecordSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    experimentId: experimentIdSchema,
-    candidateId: candidateIdSchema,
-    source: z.literal("knowledge-curate"),
-    createdAt: z.string().min(1),
-    proposalPath: z.string().min(1),
-    proposalSha256: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    patterns: z.array(experimentPatternEvidenceSchema).default([]),
-    status: z.enum(["experimenting", "accepted", "rejected"]),
-    disposition: experimentDispositionSchema.optional(),
-})
-    .strict();
-// --- Outer-loop Proposer + Candidate Matrix (M7) ---
-export const proposerRunIdSchema = z
-    .string()
-    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "proposerRunId must be one safe path segment");
-export const proposerProposalSchema = z
-    .object({
-    candidateId: candidateIdSchema,
-    experimentId: experimentIdSchema,
-    proposalPath: z.string().min(1),
-    bundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
-    status: z.literal("proposed_experimenting"),
-})
-    .strict();
-export const proposerRunSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    proposerRunId: proposerRunIdSchema,
-    source: z.literal("knowledge-curate"),
-    createdAt: z.string().min(1),
-    maxCandidates: z.number().int().positive(),
-    proposals: z.array(proposerProposalSchema),
-    skippedReasons: z.array(z.string().min(1)).default([]),
-    /** Always false: proposer must never promote aliases. */
-    autoPromote: z.literal(false),
-})
-    .strict();
-export const matrixModeSchema = z.enum([
-    "dry-run",
-    "stub",
-    "pi-plan",
-    "pi",
-]);
-export const matrixCellResultSchema = z
-    .object({
-    cellId: z.string().min(1),
-    candidateId: candidateIdSchema,
-    taskRef: z.string().min(1),
-    seed: z.number().int().nonnegative(),
-    split: evalSplitSchema,
-    executionRole: z.enum([
-        "candidate_run",
-        "private_verify",
-        "promotion_gate_only",
-    ]),
-    mode: matrixModeSchema,
-    verifyPassed: z.boolean().optional(),
-    runId: z.string().min(1).optional(),
-    jobPath: z.string().min(1).optional(),
-    detail: z.string().optional(),
-    skipped: z.boolean().default(false),
-})
-    .strict();
-export const matrixRunSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    campaignId: campaignIdSchema,
-    planHash: z.string().min(1),
-    mode: matrixModeSchema,
-    createdAt: z.string().min(1),
-    cells: z.array(matrixCellResultSchema),
-    privateCheckCount: z.number().int().nonnegative(),
-    privateCheckFailed: z.number().int().nonnegative(),
-    evidencePath: z.string().min(1).optional(),
-    /** Always false: matrix must never promote aliases. */
-    autoPromote: z.literal(false),
-})
-    .strict();
-export const matrixFixtureSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    defaultVerifyPassed: z.boolean().default(false),
-    results: z
-        .array(z
-        .object({
-        cellId: z.string().min(1).optional(),
-        candidateId: candidateIdSchema.optional(),
-        taskRef: z.string().min(1).optional(),
-        seed: z.number().int().nonnegative().optional(),
-        split: evalSplitSchema.optional(),
-        verifyPassed: z.boolean(),
-        runId: z.string().min(1).optional(),
-    })
-        .strict())
-        .default([]),
-})
-    .strict();
-// --- Ignition research gate (M8) ---
-export const ignitionIdSchema = z
-    .string()
-    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "ignitionId must be one safe path segment");
-export const ignitionGenerationSchema = z
-    .object({
-    generation: z.number().int().nonnegative(),
-    parentCandidateId: candidateIdSchema.nullable(),
-    proposerRunId: proposerRunIdSchema,
-    proposedCandidateIds: z.array(candidateIdSchema).default([]),
-    proposalCount: z.number().int().nonnegative(),
-    campaignId: campaignIdSchema.optional(),
-    promotionEligible: z.boolean().optional(),
-    heldOutNonRegression: z
-        .enum(["pass", "fail", "insufficient", "review"])
-        .optional(),
-    privateImprovement: z
-        .enum(["pass", "fail", "insufficient", "review"])
-        .optional(),
-    recordedAt: z.string().min(1),
-})
-    .strict();
-export const ignitionVerdictSchema = z.enum([
-    "insufficient_evidence",
-    "trend_positive",
-    "trend_flat",
-    "trend_negative",
-    "inconclusive",
-]);
-export const ignitionReportSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    ignitionId: ignitionIdSchema,
-    createdAt: z.string().min(1),
-    updatedAt: z.string().min(1),
-    generations: z.array(ignitionGenerationSchema).default([]),
-    metrics: z
-        .object({
-        generationCount: z.number().int().nonnegative(),
-        meanProposalsPerGeneration: z.number().nonnegative(),
-        proposalYieldDelta: z.number().nullable(),
-        scorecardObservedRate: z.number().nullable(),
-        minGenerationsForSignal: z.number().int().positive(),
-        sampleSufficient: z.boolean(),
-    })
-        .strict(),
-    verdict: ignitionVerdictSchema,
-    reasons: z.array(z.string().min(1)).default([]),
-    /** Research gate only — never authorizes product RSI Level 1 claims. */
-    rsiLevel1ClaimAllowed: z.literal(false),
-    /** Always false — ignition never promotes. */
-    autoPromote: z.literal(false),
-})
-    .strict();

package/dist/cli/command-definitions.js

@@ -77,23 +77,7 @@ const INIT_SUBCOMMANDS = [
     "update",
 ];
 const EXAMPLES_SUBCOMMANDS = ["list", "show", "copy"];
-const EVAL_SUBCOMMANDS = [
-    "replay",
-    "report",
-    "candidate",
-    "alias",
-    "promote",
-    "rollback",
-    "corpus",
-    "context-policy",
-    "budget",
-    "private-verifier",
-    "campaign",
-    "experiment",
-    "propose",
-    "outer-loop",
-    "ignition",
-];
+const EVAL_SUBCOMMANDS = ["replay", "report", "candidate"];
 const CLOSEOUT_SUBCOMMANDS = ["task"];
 const PLAN_SUBCOMMANDS = ["list", "create", "complete", "check"];
 const SPINE_SUBCOMMANDS = ["audit"];
@@ -216,8 +200,8 @@ export const COMMAND_DEFINITIONS = [
         name: "eval",
         adapter: "required",
         tier: "operator",
-        intent: "Replay completed DAG evidence, manage Candidate Registry and corpus contracts, and human-gate incumbent alias promote/rollback without live campaigns.",
-        usage: "eval <…|propose|outer-loop|ignition> ...; propose from-curate; outer-loop run; campaign matrix; ignition <record|evaluate|show|list>; promote remains human-gated (no auto-promote; ignition never claims RSI Level 1)",
+        intent: "Replay completed DAG evidence and manage immutable Candidate Registry lifecycle without live model execution or promotion.",
+        usage: "eval <replay|report|candidate> ...; candidate <register|show|list|transition> [--json|--markdown]",
         subcommands: [...EVAL_SUBCOMMANDS],
         handler: async ({ repoRoot, subcommand, rest }) => {
             await runEval(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));