@exaudeus/workrail 1.0.0 → 1.2.0

package/dist/v2/durable-core/domain/recommendation-warnings.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRecommendationExceedance = checkRecommendationExceedance;
+const AUTONOMY_ORDER = {
+    guided: 0,
+    full_auto_stop_on_user_deps: 1,
+    full_auto_never_stop: 2,
+};
+const RISK_POLICY_ORDER = {
+    conservative: 0,
+    balanced: 1,
+    aggressive: 2,
+};
+function checkRecommendationExceedance(effective, recommended) {
+    const warnings = [];
+    if (recommended.recommendedAutonomy !== undefined &&
+        AUTONOMY_ORDER[effective.autonomy] > AUTONOMY_ORDER[recommended.recommendedAutonomy]) {
+        warnings.push({
+            kind: 'autonomy_exceeds_recommendation',
+            effective: effective.autonomy,
+            recommended: recommended.recommendedAutonomy,
+            summary: `Effective autonomy '${effective.autonomy}' exceeds workflow recommendation '${recommended.recommendedAutonomy}'.`,
+        });
+    }
+    if (recommended.recommendedRiskPolicy !== undefined &&
+        RISK_POLICY_ORDER[effective.riskPolicy] > RISK_POLICY_ORDER[recommended.recommendedRiskPolicy]) {
+        warnings.push({
+            kind: 'risk_policy_exceeds_recommendation',
+            effective: effective.riskPolicy,
+            recommended: recommended.recommendedRiskPolicy,
+            summary: `Effective riskPolicy '${effective.riskPolicy}' exceeds workflow recommendation '${recommended.recommendedRiskPolicy}'.`,
+        });
+    }
+    return warnings;
+}

package/dist/v2/durable-core/domain/risk-policy-guardrails.d.ts

@@ -0,0 +1,15 @@
+import type { RiskPolicyV2 } from '../schemas/session/preferences.js';
+import type { ReasonV1 } from './reason-model.js';
+export type GuardrailOutcome = {
+    readonly disposition: 'block';
+    readonly reason: ReasonV1;
+} | {
+    readonly disposition: 'downgrade_to_warning';
+    readonly reason: ReasonV1;
+    readonly rationale: string;
+};
+export declare function applyGuardrail(policy: RiskPolicyV2, reason: ReasonV1): GuardrailOutcome;
+export declare function applyGuardrails(policy: RiskPolicyV2, reasons: readonly ReasonV1[]): {
+    readonly blocking: readonly ReasonV1[];
+    readonly downgraded: readonly GuardrailOutcome[];
+};

package/dist/v2/durable-core/domain/risk-policy-guardrails.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyGuardrail = applyGuardrail;
+exports.applyGuardrails = applyGuardrails;
+function isNeverDowngradable(reason) {
+    switch (reason.kind) {
+        case 'missing_required_output':
+        case 'invalid_required_output':
+            return true;
+        case 'user_only_dependency':
+            return true;
+        case 'invariant_violation':
+        case 'storage_corruption_detected':
+        case 'evaluation_error':
+            return true;
+        case 'missing_context_key':
+        case 'context_budget_exceeded':
+            return true;
+        case 'required_capability_unknown':
+        case 'required_capability_unavailable':
+            return false;
+        default: {
+            const _exhaustive = reason;
+            return _exhaustive;
+        }
+    }
+}
+function applyGuardrail(policy, reason) {
+    if (isNeverDowngradable(reason)) {
+        return { disposition: 'block', reason };
+    }
+    switch (policy) {
+        case 'conservative':
+            return { disposition: 'block', reason };
+        case 'balanced':
+            if (reason.kind === 'required_capability_unknown') {
+                return {
+                    disposition: 'downgrade_to_warning',
+                    reason,
+                    rationale: `riskPolicy=balanced: capability '${reason.capability}' status unknown — proceeding with warning`,
+                };
+            }
+            return { disposition: 'block', reason };
+        case 'aggressive':
+            if (reason.kind === 'required_capability_unknown' || reason.kind === 'required_capability_unavailable') {
+                return {
+                    disposition: 'downgrade_to_warning',
+                    reason,
+                    rationale: `riskPolicy=aggressive: capability '${reason.capability}' issue downgraded to warning`,
+                };
+            }
+            return { disposition: 'block', reason };
+        default: {
+            const _exhaustive = policy;
+            return _exhaustive;
+        }
+    }
+}
+function applyGuardrails(policy, reasons) {
+    const blocking = [];
+    const downgraded = [];
+    for (const reason of reasons) {
+        const outcome = applyGuardrail(policy, reason);
+        switch (outcome.disposition) {
+            case 'block':
+                blocking.push(outcome.reason);
+                break;
+            case 'downgrade_to_warning':
+                downgraded.push(outcome);
+                break;
+            default: {
+                const _exhaustive = outcome;
+                return _exhaustive;
+            }
+        }
+    }
+    return { blocking, downgraded };
+}

package/dist/v2/durable-core/domain/validation-criteria-validator.d.ts

@@ -0,0 +1,16 @@
+import type { ValidationCriteria, ValidationResult } from '../../../types/validation.js';
+import type { OutputContract } from '../../../types/workflow-definition.js';
+import type { OutputRequirementStatus } from './blocking-decision.js';
+export declare const VALIDATION_CRITERIA_CONTRACT_REF: "wr.validationCriteria";
+export declare function getOutputRequirementStatusV1(args: {
+    readonly validationCriteria: ValidationCriteria | undefined;
+    readonly notesMarkdown: string | undefined;
+    readonly validation: ValidationResult | undefined;
+}): OutputRequirementStatus;
+export declare function getOutputRequirementStatusWithArtifactsV1(args: {
+    readonly outputContract: OutputContract | undefined;
+    readonly artifacts: readonly unknown[];
+    readonly validationCriteria: ValidationCriteria | undefined;
+    readonly notesMarkdown: string | undefined;
+    readonly validation: ValidationResult | undefined;
+}): OutputRequirementStatus;

package/dist/v2/durable-core/domain/validation-criteria-validator.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALIDATION_CRITERIA_CONTRACT_REF = void 0;
+exports.getOutputRequirementStatusV1 = getOutputRequirementStatusV1;
+exports.getOutputRequirementStatusWithArtifactsV1 = getOutputRequirementStatusWithArtifactsV1;
+const artifact_contract_validator_js_1 = require("./artifact-contract-validator.js");
+exports.VALIDATION_CRITERIA_CONTRACT_REF = 'wr.validationCriteria';
+function getOutputRequirementStatusV1(args) {
+    if (!args.validationCriteria)
+        return { kind: 'not_required' };
+    if (!args.notesMarkdown) {
+        return { kind: 'missing', contractRef: exports.VALIDATION_CRITERIA_CONTRACT_REF };
+    }
+    if (args.validation && !args.validation.valid) {
+        return { kind: 'invalid', contractRef: exports.VALIDATION_CRITERIA_CONTRACT_REF, validation: args.validation };
+    }
+    return { kind: 'not_required' };
+}
+function getOutputRequirementStatusWithArtifactsV1(args) {
+    if (args.outputContract) {
+        const result = (0, artifact_contract_validator_js_1.validateArtifactContract)(args.artifacts, args.outputContract);
+        if (!result.valid) {
+            const error = result.error;
+            if (error.code === 'MISSING_REQUIRED_ARTIFACT') {
+                return { kind: 'missing', contractRef: error.contractRef };
+            }
+            if (error.code === 'INVALID_ARTIFACT_SCHEMA') {
+                const validationResult = {
+                    valid: false,
+                    issues: error.issues.map(issue => issue),
+                    suggestions: ['Provide a valid artifact matching the contract schema'],
+                };
+                return { kind: 'invalid', contractRef: error.contractRef, validation: validationResult };
+            }
+            if (error.code === 'UNKNOWN_CONTRACT_REF') {
+                return { kind: 'missing', contractRef: error.contractRef };
+            }
+        }
+        return { kind: 'not_required' };
+    }
+    return getOutputRequirementStatusV1({
+        validationCriteria: args.validationCriteria,
+        notesMarkdown: args.notesMarkdown,
+        validation: args.validation,
+    });
+}

package/dist/v2/durable-core/domain/validation-event-builder.d.ts

@@ -0,0 +1,26 @@
+import { type Result } from 'neverthrow';
+import type { ValidationResult } from '../../../types/validation.js';
+import type { DomainEventV1 } from '../schemas/session/index.js';
+type EventToAppendV1 = Omit<DomainEventV1, 'eventIndex' | 'sessionId'>;
+export type ValidationEventError = {
+    readonly code: 'VALIDATION_EVENT_INVARIANT_VIOLATION';
+    readonly message: string;
+} | {
+    readonly code: 'VALIDATION_EVENT_TEXT_TOO_LARGE';
+    readonly message: string;
+};
+export declare function buildValidationPerformedEvent(args: {
+    readonly sessionId: string;
+    readonly validationId: string;
+    readonly attemptId: string;
+    readonly contractRef: string;
+    readonly result: ValidationResult;
+    readonly scope: {
+        readonly runId: string;
+        readonly nodeId: string;
+    };
+    readonly minted: {
+        readonly eventId: string;
+    };
+}): Result<EventToAppendV1, ValidationEventError>;
+export {};

package/dist/v2/durable-core/domain/validation-event-builder.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildValidationPerformedEvent = buildValidationPerformedEvent;
+const neverthrow_1 = require("neverthrow");
+const constants_js_1 = require("../constants.js");
+function utf8ByteLength(s) {
+    return new TextEncoder().encode(s).length;
+}
+function uniqueSorted(values) {
+    const sorted = [...values].filter((v) => v.length > 0).sort((a, b) => a.localeCompare(b, 'en-US'));
+    const out = [];
+    for (const v of sorted) {
+        if (out.length === 0 || out[out.length - 1] !== v)
+            out.push(v);
+    }
+    return out;
+}
+const VALIDATION_TRUNCATION_ITEM = '[TRUNCATED]';
+function truncateListToUtf8ByteBudget(args) {
+    if (args.maxBytes <= 0) {
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'maxBytes must be positive' });
+    }
+    const markerBytes = args.includeTruncationMarker ? utf8ByteLength(VALIDATION_TRUNCATION_ITEM) : 0;
+    if (args.includeTruncationMarker && markerBytes > args.maxBytes) {
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_TEXT_TOO_LARGE', message: 'validation truncation marker does not fit budget' });
+    }
+    const values = uniqueSorted(args.values);
+    const out = [];
+    let used = 0;
+    for (const v of values) {
+        const bytes = utf8ByteLength(v);
+        if (bytes > args.maxBytes) {
+            return (0, neverthrow_1.err)({
+                code: 'VALIDATION_EVENT_TEXT_TOO_LARGE',
+                message: 'validation item exceeds max bytes budget',
+            });
+        }
+        const remainingBudget = args.maxBytes - used;
+        const reserve = args.includeTruncationMarker ? markerBytes : 0;
+        const canFitWithReserve = bytes <= remainingBudget - reserve;
+        if (!canFitWithReserve) {
+            if (args.includeTruncationMarker) {
+                if (used + markerBytes <= args.maxBytes)
+                    out.push(VALIDATION_TRUNCATION_ITEM);
+            }
+            return (0, neverthrow_1.ok)(out);
+        }
+        out.push(v);
+        used += bytes;
+    }
+    return (0, neverthrow_1.ok)(out);
+}
+function buildValidationPerformedEvent(args) {
+    if (!args.sessionId)
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'sessionId is required' });
+    if (!args.validationId)
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'validationId is required' });
+    if (!args.attemptId)
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'attemptId is required' });
+    if (!args.contractRef)
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'contractRef is required' });
+    if (!args.scope.runId || !args.scope.nodeId) {
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'scope.runId and scope.nodeId are required' });
+    }
+    if (!args.minted.eventId)
+        return (0, neverthrow_1.err)({ code: 'VALIDATION_EVENT_INVARIANT_VIOLATION', message: 'minted.eventId is required' });
+    const issuesRes = truncateListToUtf8ByteBudget({
+        values: args.result.issues ?? [],
+        maxBytes: constants_js_1.MAX_VALIDATION_ISSUES_BYTES,
+        includeTruncationMarker: true,
+    });
+    if (issuesRes.isErr())
+        return (0, neverthrow_1.err)(issuesRes.error);
+    const suggestionsRes = truncateListToUtf8ByteBudget({
+        values: args.result.suggestions ?? [],
+        maxBytes: constants_js_1.MAX_VALIDATION_SUGGESTIONS_BYTES,
+        includeTruncationMarker: true,
+    });
+    if (suggestionsRes.isErr())
+        return (0, neverthrow_1.err)(suggestionsRes.error);
+    const dedupeKey = `validation_performed:${args.sessionId}:${args.attemptId}`;
+    const event = {
+        v: 1,
+        eventId: args.minted.eventId,
+        kind: 'validation_performed',
+        dedupeKey: dedupeKey,
+        scope: { runId: args.scope.runId, nodeId: args.scope.nodeId },
+        data: {
+            validationId: args.validationId,
+            attemptId: args.attemptId,
+            contractRef: args.contractRef,
+            result: {
+                valid: args.result.valid,
+                issues: issuesRes.value,
+                suggestions: suggestionsRes.value,
+            },
+        },
+    };
+    return (0, neverthrow_1.ok)(event);
+}

package/dist/v2/durable-core/domain/validation-loader.d.ts

@@ -0,0 +1,11 @@
+import { type Result } from 'neverthrow';
+import type { DomainEventV1 } from '../schemas/session/index.js';
+export type ValidationLoadError = {
+    readonly code: 'VALIDATION_LOAD_INVARIANT_VIOLATION';
+    readonly message: string;
+};
+export type LoadedValidationV1 = {
+    readonly issues: readonly string[];
+    readonly suggestions: readonly string[];
+};
+export declare function loadValidationResultV1(events: readonly DomainEventV1[], validationId: string): Result<LoadedValidationV1 | null, ValidationLoadError>;

package/dist/v2/durable-core/domain/validation-loader.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadValidationResultV1 = loadValidationResultV1;
+const neverthrow_1 = require("neverthrow");
+function loadValidationResultV1(events, validationId) {
+    if (!validationId) {
+        return (0, neverthrow_1.ok)(null);
+    }
+    let latest = null;
+    for (const e of events) {
+        if (e.kind !== 'validation_performed')
+            continue;
+        if (e.data.validationId !== validationId)
+            continue;
+        if (!latest || e.eventIndex > latest.eventIndex)
+            latest = e;
+    }
+    if (!latest)
+        return (0, neverthrow_1.ok)(null);
+    return (0, neverthrow_1.ok)({ issues: latest.data.result.issues, suggestions: latest.data.result.suggestions });
+}

package/dist/v2/durable-core/domain/validation-requirements-extractor.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationCriteria } from '../../../types/validation.js';
+export declare function extractValidationRequirements(criteria: ValidationCriteria | undefined): readonly string[];

package/dist/v2/durable-core/domain/validation-requirements-extractor.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractValidationRequirements = extractValidationRequirements;
+const validation_js_1 = require("../../../types/validation.js");
+function extractValidationRequirements(criteria) {
+    if (!criteria)
+        return [];
+    try {
+        const requirements = extractRequirementsRecursive(criteria);
+        return requirements.slice(0, 5);
+    }
+    catch {
+        return [];
+    }
+}
+function extractRequirementsRecursive(criteria) {
+    const requirements = [];
+    if ((0, validation_js_1.isValidationRule)(criteria)) {
+        const formatted = formatRule(criteria);
+        if (formatted)
+            requirements.push(formatted);
+        return requirements;
+    }
+    if ((0, validation_js_1.isValidationComposition)(criteria)) {
+        if (criteria.and) {
+            for (const sub of criteria.and) {
+                requirements.push(...extractRequirementsRecursive(sub));
+            }
+        }
+    }
+    return requirements;
+}
+function formatRule(rule) {
+    switch (rule.type) {
+        case 'contains':
+            if (!rule.value)
+                return null;
+            return `Must contain: "${rule.value}"`;
+        case 'regex':
+            if (!rule.pattern)
+                return null;
+            const flags = rule.flags ? ` (flags: ${rule.flags})` : '';
+            return `Must match pattern: ${rule.pattern}${flags}`;
+        case 'length':
+            const parts = [];
+            if (rule.min !== undefined)
+                parts.push(`≥${rule.min} chars`);
+            if (rule.max !== undefined)
+                parts.push(`≤${rule.max} chars`);
+            if (parts.length === 0)
+                return null;
+            return `Length: ${parts.join(', ')}`;
+        case 'schema':
+            return null;
+        default:
+            return null;
+    }
+}

package/dist/v2/durable-core/projections/snapshot-state.js

@@ -6,7 +6,7 @@ function deriveIsComplete(state) {
     return state.kind === 'complete';
 }
 function derivePendingStep(state) {
-    if (state.kind !== 'running')
+    if (state.kind !== 'running' && state.kind !== 'blocked')
         return null;
     if (state.pending.kind !== 'some')
         return null;

package/dist/v2/durable-core/schemas/artifacts/index.d.ts

@@ -0,0 +1,4 @@
+export { LOOP_CONTROL_CONTRACT_REF, LoopControlDecisionSchema, LoopControlMetadataV1Schema, LoopControlArtifactV1Schema, isLoopControlArtifact, parseLoopControlArtifact, findLoopControlArtifact, type LoopControlDecision, type LoopControlMetadataV1, type LoopControlArtifactV1, } from './loop-control.js';
+export declare const ARTIFACT_CONTRACT_REFS: readonly ["wr.contracts.loop_control"];
+export type ArtifactContractRef = (typeof ARTIFACT_CONTRACT_REFS)[number];
+export declare function isValidContractRef(ref: string): ref is ArtifactContractRef;

package/dist/v2/durable-core/schemas/artifacts/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARTIFACT_CONTRACT_REFS = exports.findLoopControlArtifact = exports.parseLoopControlArtifact = exports.isLoopControlArtifact = exports.LoopControlArtifactV1Schema = exports.LoopControlMetadataV1Schema = exports.LoopControlDecisionSchema = exports.LOOP_CONTROL_CONTRACT_REF = void 0;
+exports.isValidContractRef = isValidContractRef;
+var loop_control_js_1 = require("./loop-control.js");
+Object.defineProperty(exports, "LOOP_CONTROL_CONTRACT_REF", { enumerable: true, get: function () { return loop_control_js_1.LOOP_CONTROL_CONTRACT_REF; } });
+Object.defineProperty(exports, "LoopControlDecisionSchema", { enumerable: true, get: function () { return loop_control_js_1.LoopControlDecisionSchema; } });
+Object.defineProperty(exports, "LoopControlMetadataV1Schema", { enumerable: true, get: function () { return loop_control_js_1.LoopControlMetadataV1Schema; } });
+Object.defineProperty(exports, "LoopControlArtifactV1Schema", { enumerable: true, get: function () { return loop_control_js_1.LoopControlArtifactV1Schema; } });
+Object.defineProperty(exports, "isLoopControlArtifact", { enumerable: true, get: function () { return loop_control_js_1.isLoopControlArtifact; } });
+Object.defineProperty(exports, "parseLoopControlArtifact", { enumerable: true, get: function () { return loop_control_js_1.parseLoopControlArtifact; } });
+Object.defineProperty(exports, "findLoopControlArtifact", { enumerable: true, get: function () { return loop_control_js_1.findLoopControlArtifact; } });
+exports.ARTIFACT_CONTRACT_REFS = [
+    'wr.contracts.loop_control',
+];
+function isValidContractRef(ref) {
+    return exports.ARTIFACT_CONTRACT_REFS.includes(ref);
+}

package/dist/v2/durable-core/schemas/artifacts/loop-control.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+export declare const LOOP_CONTROL_CONTRACT_REF: "wr.contracts.loop_control";
+export declare const LoopControlDecisionSchema: z.ZodEnum<["continue", "stop"]>;
+export type LoopControlDecision = z.infer<typeof LoopControlDecisionSchema>;
+export declare const LoopControlMetadataV1Schema: z.ZodOptional<z.ZodObject<{
+    reason: z.ZodOptional<z.ZodString>;
+    issuesFound: z.ZodOptional<z.ZodNumber>;
+    iterationIndex: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    issuesFound?: number | undefined;
+    iterationIndex?: number | undefined;
+}, {
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    issuesFound?: number | undefined;
+    iterationIndex?: number | undefined;
+}>>;
+export type LoopControlMetadataV1 = z.infer<typeof LoopControlMetadataV1Schema>;
+export declare const LoopControlArtifactV1Schema: z.ZodObject<{
+    kind: z.ZodLiteral<"wr.loop_control">;
+    loopId: z.ZodString;
+    decision: z.ZodEnum<["continue", "stop"]>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodOptional<z.ZodString>;
+        issuesFound: z.ZodOptional<z.ZodNumber>;
+        iterationIndex: z.ZodOptional<z.ZodNumber>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        confidence?: number | undefined;
+        reason?: string | undefined;
+        issuesFound?: number | undefined;
+        iterationIndex?: number | undefined;
+    }, {
+        confidence?: number | undefined;
+        reason?: string | undefined;
+        issuesFound?: number | undefined;
+        iterationIndex?: number | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    kind: "wr.loop_control";
+    loopId: string;
+    decision: "continue" | "stop";
+    metadata?: {
+        confidence?: number | undefined;
+        reason?: string | undefined;
+        issuesFound?: number | undefined;
+        iterationIndex?: number | undefined;
+    } | undefined;
+}, {
+    kind: "wr.loop_control";
+    loopId: string;
+    decision: "continue" | "stop";
+    metadata?: {
+        confidence?: number | undefined;
+        reason?: string | undefined;
+        issuesFound?: number | undefined;
+        iterationIndex?: number | undefined;
+    } | undefined;
+}>;
+export type LoopControlArtifactV1 = z.infer<typeof LoopControlArtifactV1Schema>;
+export declare function isLoopControlArtifact(artifact: unknown): artifact is LoopControlArtifactV1;
+export declare function parseLoopControlArtifact(artifact: unknown): LoopControlArtifactV1 | null;
+export declare function findLoopControlArtifact(artifacts: readonly unknown[], loopId: string): LoopControlArtifactV1 | null;

package/dist/v2/durable-core/schemas/artifacts/loop-control.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoopControlArtifactV1Schema = exports.LoopControlMetadataV1Schema = exports.LoopControlDecisionSchema = exports.LOOP_CONTROL_CONTRACT_REF = void 0;
+exports.isLoopControlArtifact = isLoopControlArtifact;
+exports.parseLoopControlArtifact = parseLoopControlArtifact;
+exports.findLoopControlArtifact = findLoopControlArtifact;
+const zod_1 = require("zod");
+const constants_js_1 = require("../../constants.js");
+exports.LOOP_CONTROL_CONTRACT_REF = 'wr.contracts.loop_control';
+exports.LoopControlDecisionSchema = zod_1.z.enum(['continue', 'stop']);
+exports.LoopControlMetadataV1Schema = zod_1.z
+    .object({
+    reason: zod_1.z.string().max(1024).optional(),
+    issuesFound: zod_1.z.number().int().nonnegative().optional(),
+    iterationIndex: zod_1.z.number().int().nonnegative().optional(),
+    confidence: zod_1.z.number().int().min(0).max(100).optional(),
+})
+    .strict()
+    .optional();
+exports.LoopControlArtifactV1Schema = zod_1.z
+    .object({
+    kind: zod_1.z.literal('wr.loop_control'),
+    loopId: zod_1.z.string().min(1).max(64).regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'loopId must be delimiter-safe: [a-z0-9_-]+'),
+    decision: exports.LoopControlDecisionSchema,
+    metadata: exports.LoopControlMetadataV1Schema,
+})
+    .strict();
+function isLoopControlArtifact(artifact) {
+    if (typeof artifact !== 'object' || artifact === null)
+        return false;
+    return artifact.kind === 'wr.loop_control';
+}
+function parseLoopControlArtifact(artifact) {
+    const result = exports.LoopControlArtifactV1Schema.safeParse(artifact);
+    return result.success ? result.data : null;
+}
+function findLoopControlArtifact(artifacts, loopId) {
+    for (const artifact of artifacts) {
+        if (!isLoopControlArtifact(artifact))
+            continue;
+        const parsed = parseLoopControlArtifact(artifact);
+        if (parsed && parsed.loopId === loopId) {
+            return parsed;
+        }
+    }
+    return null;
+}