ai-foreman 1.7.28 → 2.0.0

package/dist/ticketPopulation.js

@@ -11,8 +11,6 @@ import { normalizeDeliveryConfig, validateDeliveryConfig } from "./tickets/deliv
 import { loadTicketsConfig, resolveTicketPaths } from "./tickets/config.js";
 import { StateDb } from "./tickets/stateDb.js";
 import { ticketDefinitionDigest } from "./tickets/riskWaivers.js";
-export const TICKET_POPULATION_PROPOSAL_START = "RAFI_TICKET_POPULATION_PROPOSAL_START";
-export const TICKET_POPULATION_PROPOSAL_END = "RAFI_TICKET_POPULATION_PROPOSAL_END";
 function additiveAbsenceRequirement(text) {
     return [
         /\bslice alone\b/i,
@@ -81,24 +79,6 @@ function stableJson(value) {
     }
     return JSON.stringify(value);
 }
-export function extractTicketPopulationProposal(output) {
-    const start = output.lastIndexOf(TICKET_POPULATION_PROPOSAL_START);
-    const end = output.lastIndexOf(TICKET_POPULATION_PROPOSAL_END);
-    if (start < 0 || end <= start)
-        throw new Error(`ticket-maker output is missing ${TICKET_POPULATION_PROPOSAL_START}/${TICKET_POPULATION_PROPOSAL_END}`);
-    const raw = output.slice(start + TICKET_POPULATION_PROPOSAL_START.length, end).trim().replace(/^```(?:json)?\s*/i, "").replace(/\s*```$/, "");
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`ticket-maker proposal is invalid JSON: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    const validated = ticketPopulationProposalV1Schema.safeParse(parsed);
-    if (!validated.success)
-        throw new Error(`ticket-maker proposal contract validation failed:\n${zodIssues(validated.error).map((issue) => `- ${issue}`).join("\n")}`);
-    return validated.data;
-}
 export function validateTicketPopulationProposal(proposal, plan, existing, options = {}) {
     const issues = [];
     const contract = ticketPopulationProposalV1Schema.safeParse(proposal);
@@ -156,7 +136,10 @@ export function materializeTicketPopulation(proposal, plan, existing, options =
             title: slice.title, area: slice.area, priority: slice.priority, size: slice.size, risk: slice.risk,
             depends_on: slice.depends_on.map((ref) => sliceToTicket.get(ref)), summary: slice.summary,
             acceptance: [...slice.acceptance], required_tests: [...slice.required_tests], likely_files: [...slice.likely_files],
-            documentation: structuredClone(slice.documentation ?? plan.slices.find(item => item.slice_ref === slice.slice_ref)?.documentation ?? { required: false, targets: [], criteria: [] }),
+            ...(plan.slices.find(item => item.slice_ref === slice.slice_ref)?.verification_version === 2
+                ? { verification_version: 2, verification_requirements: structuredClone(plan.slices.find(item => item.slice_ref === slice.slice_ref).verification_requirements) }
+                : {}),
+            documentation: structuredClone(plan.slices.find(item => item.slice_ref === slice.slice_ref)?.documentation ?? { required: false, targets: [], criteria: [] }),
             rollback: slice.rollback, notes: slice.notes, plan_ref: { plan_id: plan.plan_id, revision: plan.revision, slice_ref: slice.slice_ref },
             source_refs: (plan.slices.find((item) => item.slice_ref === slice.slice_ref)?.source_refs ?? slice.source_refs)?.map((ref) => ({
                 source: ref.source_id, item: ref.item ?? "document", source_id: ref.source_id, fingerprint: ref.fingerprint,

package/dist/ticketPopulationPageAuthority.d.ts

@@ -0,0 +1,13 @@
+import type { SelectedDispatchTupleV2 } from "rafi-spec";
+import type { WorkflowDb } from "./workflowDb.js";
+export interface TicketPopulationPageScope {
+    readonly projectDir: string;
+    readonly artifactId: string;
+    readonly runId: string;
+    readonly lineageId: string;
+    readonly leaseId: string;
+}
+export declare function withTicketPopulationPage<T>(scope: TicketPopulationPageScope, dispatch: () => Promise<T>): Promise<T>;
+/** Only the population owner with a persisted artifact intent may select a page. */
+export declare function sealTicketPopulationPage(db: WorkflowDb, root: string, tuple: SelectedDispatchTupleV2): void;
+export declare function assertTicketPopulationPageBinding(db: WorkflowDb, scope: TicketPopulationPageScope, tuple: SelectedDispatchTupleV2): void;

package/dist/ticketPopulationPageAuthority.js

@@ -0,0 +1,30 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const populationPage = new AsyncLocalStorage();
+export function withTicketPopulationPage(scope, dispatch) {
+    return populationPage.run(Object.freeze({ ...scope }), dispatch);
+}
+/** Only the population owner with a persisted artifact intent may select a page. */
+export function sealTicketPopulationPage(db, root, tuple) {
+    if (tuple.operation !== "ticket-population-page")
+        return;
+    const scope = populationPage.getStore();
+    const artifact = scope && db.operation(scope.artifactId);
+    if (!scope || scope.projectDir !== root || !artifact || artifact.kind !== "ticket-population-artifact" ||
+        artifact.runId !== scope.runId || artifact.status !== "in_progress" ||
+        artifact.intent.lineageId !== scope.lineageId ||
+        artifact.intent.leaseId !== scope.leaseId)
+        throw new Error("Ticket population pages require their active persisted artifact owner");
+    const prior = db.populationPageLedger(scope.artifactId);
+    if (prior && prior.state !== "open")
+        throw new Error("Ticket population artifact is already terminal");
+    db.beginPageLedger({ ...scope, tupleDigest: prior?.tupleDigest ?? tuple.digest });
+    db.planOperation({ runId: scope.runId, idempotencyKey: `${scope.artifactId}:page:${tuple.dispatchId}`,
+        kind: "ticket-population-page-binding", intent: { ...scope, tupleDigest: tuple.digest } });
+}
+export function assertTicketPopulationPageBinding(db, scope, tuple) {
+    const binding = db.operation(`${scope.artifactId}:page:${tuple.dispatchId}`);
+    const intent = binding?.intent;
+    if (!intent || binding?.kind !== "ticket-population-page-binding" || binding.runId !== scope.runId ||
+        intent.tupleDigest !== tuple.digest || intent.lineageId !== scope.lineageId || intent.leaseId !== scope.leaseId)
+        throw new Error("Ticket page receipt belongs to another artifact or lineage");
+}

package/dist/ticketPopulationPaging.d.ts

@@ -0,0 +1,27 @@
+import { type OutputContract, type TicketPopulationProposalV1Contract } from "rafi-spec";
+import type { TurnRequest, TurnResult } from "./adapters/types.js";
+import { type TicketPopulationPageScope } from "./ticketPopulationPageAuthority.js";
+type PageTurn = {
+    result: TurnResult;
+    status: {
+        kind: string;
+        reason?: string;
+        error?: string;
+        summary?: string;
+    };
+};
+/** Each provider page is sealed and durably appended before aggregate interpretation. */
+export declare function streamTicketPopulation(input: {
+    projectDir: string;
+    interviewId: string;
+    correction: number;
+    instruction: string;
+    checkpoint(scope: TicketPopulationPageScope): void;
+    dispatch(instruction: string, policy: TurnRequest & {
+        output: OutputContract;
+    }): Promise<PageTurn>;
+}): Promise<{
+    proposal: TicketPopulationProposalV1Contract;
+    turn: PageTurn;
+}>;
+export {};

package/dist/ticketPopulationPaging.js

@@ -0,0 +1,105 @@
+import { randomUUID } from "node:crypto";
+import { canonicalJson, structuredDigest, ticketPopulationPageOutput } from "rafi-spec";
+import { WorkflowDb } from "./workflowDb.js";
+import { operationPayload } from "./structuredOperation.js";
+import { assertTicketPopulationPageBinding, withTicketPopulationPage } from "./ticketPopulationPageAuthority.js";
+/** Each provider page is sealed and durably appended before aggregate interpretation. */
+export async function streamTicketPopulation(input) {
+    const runId = `ticket-population:${input.interviewId}`;
+    const artifactId = `${runId}:artifact:${input.correction}`;
+    const db = new WorkflowDb(input.projectDir);
+    try {
+        db.enableStructuredCommunication();
+        const prior = db.operation(artifactId);
+        if (prior) {
+            const retained = prior.intent;
+            const header = db.populationPageLedger(artifactId);
+            if (retained.instructionDigest !== structuredDigest(input.instruction) || retained.projectDir !== input.projectDir ||
+                retained.runId !== runId || !header || header.state !== "terminal")
+                throw new Error("Ticket population artifact already exists; reconcile retained pages before a fresh lineage");
+            const pages = db.populationPageRecords(artifactId);
+            const tickets = [], retirements = [];
+            let last;
+            let identity;
+            for (const [ordinal, content] of pages.entries()) {
+                const stored = JSON.parse(content);
+                last = db.retainedStructuredTurn(stored.dispatchId);
+                assertTicketPopulationPageBinding(db, retained, last.selectedDispatch);
+                const page = operationPayload(last, ticketPopulationPageOutput);
+                if (last.selectedDispatch?.digest !== stored.selectedDispatchDigest ||
+                    canonicalJson({ ...page, selectedDispatchDigest: stored.selectedDispatchDigest, dispatchId: stored.dispatchId }) !== content ||
+                    page.terminal !== (ordinal === pages.length - 1) || identity && (identity.plan_id !== page.plan_id || identity.revision !== page.revision))
+                    throw new Error("Retained ticket page failed native replay");
+                identity = { plan_id: page.plan_id, revision: page.revision };
+                tickets.push(...page.tickets);
+                retirements.push(...page.retirements);
+            }
+            if (!last || !identity)
+                throw new Error("Terminal ticket population has no native pages");
+            const proposal = { version: 1, ...identity, tickets, retirements };
+            if (Buffer.byteLength(canonicalJson(proposal)) > 6 * 1024 * 1024 || new Set(tickets.map(ticket => ticket.slice_ref)).size !== tickets.length)
+                throw new Error("Retained ticket population aggregate is invalid");
+            if (prior.status !== "confirmed")
+                db.updateOperation(artifactId, "confirmed", { result: { pageCount: pages.length, recovered: true } });
+            return { proposal, turn: { result: last, status: { kind: "done" } } };
+        }
+        const scope = { projectDir: input.projectDir, artifactId, runId,
+            lineageId: `${artifactId}:${randomUUID()}`, leaseId: randomUUID() };
+        db.ensureRun(runId);
+        db.planOperation({ runId, idempotencyKey: artifactId, kind: "ticket-population-artifact", intent: { ...scope, instructionDigest: structuredDigest(input.instruction) } });
+        db.updateOperation(artifactId, "in_progress");
+        input.checkpoint(scope); // Durable interview owner exists before provider contact.
+        const tickets = [], retirements = [];
+        let identity;
+        let predecessorDigest = null;
+        let last;
+        try {
+            for (let ordinal = 0; ordinal < 60; ordinal++) {
+                last = await withTicketPopulationPage(scope, () => input.dispatch(`${input.instruction}\n\n` +
+                    `Return page ${ordinal + 1} of at most 60 using the native ticket-population-page contract. ` +
+                    `At most 150 tickets and 750 KiB canonical bytes per page; all pages together must fit 6 MiB. ` +
+                    `Do not repeat prior tickets or retirements. terminal must be true only when the complete proposal has been supplied. ` +
+                    `Keep plan_id and revision identical across pages. Previous page digest: ${predecessorDigest ?? "none"}. ` +
+                    `Already retained ticket slice references: ${JSON.stringify(tickets.map(ticket => ticket.slice_ref))}.`, { output: ticketPopulationPageOutput, journalRunId: runId }));
+                if (last.result.isError || last.result.failure)
+                    throw new Error(last.status.reason ?? last.status.error ?? "Ticket population page was rejected");
+                const page = operationPayload(last.result, ticketPopulationPageOutput);
+                const tuple = last.result.selectedDispatch;
+                if (!tuple)
+                    throw new Error("Ticket page has no native tuple");
+                assertTicketPopulationPageBinding(db, scope, tuple);
+                db.replayStructuredDispatch(tuple.dispatchId, ticketPopulationPageOutput);
+                const header = db.populationPageLedger(artifactId);
+                if (!header)
+                    throw new Error("Ticket page was sent before its artifact was sealed");
+                const content = canonicalJson({ ...page, selectedDispatchDigest: tuple.digest, dispatchId: tuple.dispatchId });
+                const appended = db.appendPageLedger({ ...scope, tupleDigest: header.tupleDigest, ordinal,
+                    predecessorDigest, content, terminal: page.terminal });
+                // Domain interpretation begins only after the immutable page is durable.
+                if (identity && (identity.plan_id !== page.plan_id || identity.revision !== page.revision))
+                    throw new Error("Ticket page changed plan identity");
+                identity = { plan_id: page.plan_id, revision: page.revision };
+                tickets.push(...page.tickets);
+                retirements.push(...page.retirements);
+                predecessorDigest = appended.digest;
+                if (!page.terminal)
+                    continue;
+                const proposal = { version: 1, ...identity, tickets, retirements };
+                if (Buffer.byteLength(canonicalJson(proposal)) > 6 * 1024 * 1024)
+                    throw new Error("Ticket population aggregate exceeds 6 MiB");
+                if (new Set(tickets.map(ticket => ticket.slice_ref)).size !== tickets.length)
+                    throw new Error("Ticket pages contain duplicate slices");
+                db.updateOperation(artifactId, "confirmed", { result: { pageCount: ordinal + 1, terminalDigest: appended.digest } });
+                return { proposal, turn: last };
+            }
+            throw new Error("Ticket population did not terminate within 60 pages");
+        }
+        catch (error) {
+            db.updateOperation(artifactId, "uncertain", { error: String(error).slice(0, 4000) });
+            throw error;
+        }
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/tickets/renderMarkdown.d.ts

@@ -2,6 +2,20 @@ import type { TicketsConfig } from "./config.js";
 import type { TicketDef } from "./ticketSchema.js";
 import type { StateDb, TicketState } from "./stateDb.js";
 export declare function renderTrackerRules(progressDoc?: string): string;
+export type TrackerRulesMigration = {
+    disposition: "replaced-legacy" | "updated-managed-block";
+    content: string;
+} | {
+    disposition: "unchanged";
+    content: string;
+};
+/**
+ * Upgrade only Rafi text that can be identified exactly. Historical whole-file
+ * rules are replaced only when unmodified; otherwise just an exact historical
+ * native-result section can be upgraded. User additions and altered text stay
+ * byte-for-byte intact.
+ */
+export declare function migrateTrackerRules(content: string, progressDoc?: string): TrackerRulesMigration;
 export declare const DEFAULT_TRACKER_RULES: string;
 export interface RenderInput {
     config: TicketsConfig;

package/dist/tickets/renderMarkdown.js

@@ -18,7 +18,17 @@ function section(marker, content) {
     return `<!-- ${marker}_START -->\n${content}\n<!-- ${marker}_END -->`;
 }
 // ── Default tracker-rules content ─────────────────────────────────────────────
-export function renderTrackerRules(progressDoc = "docs/ticket-progress.md") {
+const RAFI_TRACKER_RULES_START = "<!-- rafi:tracker-rules:start -->";
+const RAFI_TRACKER_RULES_END = "<!-- rafi:tracker-rules:end -->";
+const LEGACY_NATIVE_RESULT_PROTOCOL = `## Native result protocol
+When Rafi is running this project, submit the host-selected structured JSON result.
+Use its declared summary, evidence, coverage, and continuity fields; do not append separate status markers.
+Rafi binds the assigned ticket identity and controls completion after independent QA.
+Use \`foreman tickets discover\` for newly discovered work during a build run.`;
+function managedNativeResultProtocol() {
+    return `${RAFI_TRACKER_RULES_START}\n${LEGACY_NATIVE_RESULT_PROTOCOL}\n${RAFI_TRACKER_RULES_END}`;
+}
+function renderLegacyTrackerRules(progressDoc) {
     return `# Tracker Rules
 
 ## Purpose
@@ -50,12 +60,36 @@ Use \`foreman tickets discover --summary "..." --rationale "..."\`.
 Do not manually edit generated sections of \`${progressDoc}\`.
 Use the \`foreman tickets\` commands instead.
 
-## STEP_STATUS protocol
-When Foreman is running this project, include the ticket ID in your done marker:
-  STEP_STATUS: done | ticket="T001" summary="implemented the feature"
-Use \`foreman tickets discover\` for newly discovered work during a build run.
+${LEGACY_NATIVE_RESULT_PROTOCOL}
 `;
 }
+export function renderTrackerRules(progressDoc = "docs/ticket-progress.md") {
+    return renderLegacyTrackerRules(progressDoc).replace(LEGACY_NATIVE_RESULT_PROTOCOL, managedNativeResultProtocol());
+}
+/**
+ * Upgrade only Rafi text that can be identified exactly. Historical whole-file
+ * rules are replaced only when unmodified; otherwise just an exact historical
+ * native-result section can be upgraded. User additions and altered text stay
+ * byte-for-byte intact.
+ */
+export function migrateTrackerRules(content, progressDoc = "docs/ticket-progress.md") {
+    const current = renderTrackerRules(progressDoc);
+    if (content.trim() === renderLegacyTrackerRules(progressDoc).trim()) {
+        return { disposition: "replaced-legacy", content: current };
+    }
+    const managed = new RegExp(`${escapeRegExp(RAFI_TRACKER_RULES_START)}[\\s\\S]*?${escapeRegExp(RAFI_TRACKER_RULES_END)}`);
+    if (managed.test(content)) {
+        const next = content.replace(managed, managedNativeResultProtocol());
+        return next === content ? { disposition: "unchanged", content } : { disposition: "updated-managed-block", content: next };
+    }
+    if (content.includes(LEGACY_NATIVE_RESULT_PROTOCOL)) {
+        return { disposition: "updated-managed-block", content: content.replace(LEGACY_NATIVE_RESULT_PROTOCOL, managedNativeResultProtocol()) };
+    }
+    return { disposition: "unchanged", content };
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 export const DEFAULT_TRACKER_RULES = renderTrackerRules();
 export function renderProgressDoc(input) {
     const { config, projectDir, ticketDefs, states, db } = input;

package/dist/tickets/ticketLoader.js

@@ -3,6 +3,7 @@ import { randomUUID } from "node:crypto";
 import { parse, stringify } from "yaml";
 import { Ajv } from "ajv";
 import { TICKET_JSON_SCHEMA } from "./ticketSchema.js";
+import { verificationRequirementV2Schema } from "rafi-spec";
 const ajv = new Ajv({ allErrors: true });
 const validateTicketSchema = ajv.compile(TICKET_JSON_SCHEMA);
 export function loadTickets(ticketsPath) {
@@ -38,6 +39,15 @@ export function validateTicketDefs(tickets) {
                 });
             }
         }
+        const hasV2 = ticket.verification_version !== undefined || ticket.verification_requirements !== undefined;
+        if (hasV2 && (ticket.verification_version !== 2 || !Array.isArray(ticket.verification_requirements) || ticket.verification_requirements.length === 0)) {
+            errors.push({ path: `tickets[${ticket.id ?? "?"}].verification_requirements`, message: "V2 verification requires version 2 and at least one typed requirement" });
+        }
+        for (const [index, requirement] of (ticket.verification_requirements ?? []).entries()) {
+            const parsed = verificationRequirementV2Schema.safeParse(requirement);
+            if (!parsed.success)
+                errors.push({ path: `tickets[${ticket.id ?? "?"}].verification_requirements[${index}]`, message: parsed.error.issues.map(issue => `${issue.path.join(".")}: ${issue.message}`).join("; ") });
+        }
     }
     const ids = new Set();
     for (const t of tickets) {

package/dist/tickets/ticketSchema.d.ts

@@ -1,4 +1,5 @@
 import { type DocumentationPolicyV1, type QaPreparationDepthDecisionV1 } from "rafi-spec";
+import { z } from "zod";
 export type TicketPriority = "P0" | "P1" | "P2" | "P3";
 export type TicketSize = "XS" | "S" | "M" | "L" | "XL";
 export type TicketRisk = "Low" | "Medium" | "High";
@@ -36,6 +37,8 @@ export interface TicketDef {
     summary: string;
     acceptance: string[];
     required_tests: string[];
+    verification_version?: 2;
+    verification_requirements?: import("rafi-spec").VerificationRequirementV2[];
     likely_files: string[];
     rollback?: string | null;
     notes?: string | null;
@@ -206,6 +209,58 @@ export declare const TICKET_JSON_SCHEMA: {
             };
             readonly minItems: 1;
         };
+        readonly verification_version: {
+            readonly const: 2;
+        };
+        readonly verification_requirements: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+                id: z.ZodString;
+                summary: z.ZodString;
+                timing: z.ZodEnum<{
+                    both: "both";
+                    preimplementation: "preimplementation";
+                    postimplementation: "postimplementation";
+                }>;
+                applicability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"always">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"host-executable-available">;
+                    executable: z.ZodEnum<{
+                        node: "node";
+                        pnpm: "pnpm";
+                        npm: "npm";
+                        yarn: "yarn";
+                        bun: "bun";
+                        python3: "python3";
+                        pytest: "pytest";
+                        cargo: "cargo";
+                        go: "go";
+                    }>;
+                    expected: z.ZodBoolean;
+                    phase: z.ZodEnum<{
+                        both: "both";
+                        preimplementation: "preimplementation";
+                        postimplementation: "postimplementation";
+                    }>;
+                }, z.core.$strict>], "kind">;
+                methods: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        command: "command";
+                        procedure: "procedure";
+                    }>;
+                    argv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    cwd: z.ZodString;
+                    runtime: z.ZodString;
+                    timeout_ms: z.ZodNumber;
+                    expected_outcome: z.ZodString;
+                }, z.core.$strict>>;
+                expected_evidence: z.ZodArray<z.ZodString>;
+                depends_on: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        };
         readonly likely_files: {
             readonly type: "array";
             readonly items: {
@@ -475,6 +530,58 @@ export declare const TICKETS_FILE_SCHEMA: {
                         };
                         readonly minItems: 1;
                     };
+                    readonly verification_version: {
+                        readonly const: 2;
+                    };
+                    readonly verification_requirements: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly items: z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+                            id: z.ZodString;
+                            summary: z.ZodString;
+                            timing: z.ZodEnum<{
+                                both: "both";
+                                preimplementation: "preimplementation";
+                                postimplementation: "postimplementation";
+                            }>;
+                            applicability: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                                kind: z.ZodLiteral<"always">;
+                            }, z.core.$strict>, z.ZodObject<{
+                                kind: z.ZodLiteral<"host-executable-available">;
+                                executable: z.ZodEnum<{
+                                    node: "node";
+                                    pnpm: "pnpm";
+                                    npm: "npm";
+                                    yarn: "yarn";
+                                    bun: "bun";
+                                    python3: "python3";
+                                    pytest: "pytest";
+                                    cargo: "cargo";
+                                    go: "go";
+                                }>;
+                                expected: z.ZodBoolean;
+                                phase: z.ZodEnum<{
+                                    both: "both";
+                                    preimplementation: "preimplementation";
+                                    postimplementation: "postimplementation";
+                                }>;
+                            }, z.core.$strict>], "kind">;
+                            methods: z.ZodArray<z.ZodObject<{
+                                kind: z.ZodEnum<{
+                                    command: "command";
+                                    procedure: "procedure";
+                                }>;
+                                argv: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                                cwd: z.ZodString;
+                                runtime: z.ZodString;
+                                timeout_ms: z.ZodNumber;
+                                expected_outcome: z.ZodString;
+                            }, z.core.$strict>>;
+                            expected_evidence: z.ZodArray<z.ZodString>;
+                            depends_on: z.ZodArray<z.ZodString>;
+                        }, z.core.$strict>>;
+                    };
                     readonly likely_files: {
                         readonly type: "array";
                         readonly items: {

package/dist/tickets/ticketSchema.js

@@ -1,4 +1,5 @@
-import { documentationPolicyV1Schema, qaPreparationDepthDecisionV1Schema } from "rafi-spec";
+import { documentationPolicyV1Schema, qaPreparationDepthDecisionV1Schema, verificationRequirementV2Schema } from "rafi-spec";
+import { z } from "zod";
 export const TICKET_JSON_SCHEMA = {
     type: "object",
     required: [
@@ -20,6 +21,8 @@ export const TICKET_JSON_SCHEMA = {
         summary: { type: "string", minLength: 1 },
         acceptance: { type: "array", items: { type: "string" }, minItems: 1 },
         required_tests: { type: "array", items: { type: "string" }, minItems: 1 },
+        verification_version: { const: 2 },
+        verification_requirements: { type: "array", minItems: 1, items: z.toJSONSchema(verificationRequirementV2Schema, { target: "draft-7", io: "input" }) },
         likely_files: { type: "array", items: { type: "string" } },
         rollback: { type: ["string", "null"] },
         notes: { type: ["string", "null"] },