@ornexus/neocortex 4.60.66 → 4.60.67

package/packages/shared/dist/yoloop/release-blocked.js

@@ -0,0 +1,653 @@
+import { yoloopDomainHash } from './canonical.js';
+import { validateReleaseLifecycle, } from '../compatibility/index.js';
+/** P223.03 -- first-class terminal non-success for one release attempt. */
+export const YOLOOP_RELEASE_BLOCKED_TOKEN = '[YOLOOP_RELEASE_BLOCKED]';
+export const YOLOOP_RELEASE_BLOCKED_REASON_CODE = 'YOLOOP_RELEASE_BLOCKED';
+export const MAX_RELEASE_BLOCKERS = 16;
+export const MAX_RELEASE_DOCTOR_FINDINGS = 32;
+export const MAX_RELEASE_EVIDENCE_REFS = 64;
+export const RELEASE_GATE_RECEIPT_SCHEMA = 'ReleaseGateReceipt/1.0';
+export const RELEASE_GATE_REQUEST_SCHEMA = 'ReleaseGateRequest/1.0';
+export const RELEASE_LIFECYCLE_DIMENSIONS = [
+    'implementationComplete',
+    'betaOperable',
+    'releaseReady',
+    'productionPromoted',
+];
+export const RELEASE_BLOCKED_REASON_CODES = [
+    'BETA_EVIDENCE_MISSING',
+    'BETA_NOT_OPERABLE',
+    'RELEASE_GATES_INCOMPLETE',
+    'PRODUCTION_PROMOTION_UNAUTHORIZED',
+    'COMPATIBILITY_REVALIDATION_REQUIRED',
+    'DOCTOR_FINDING_UNRESOLVED',
+    'CANDIDATE_IDENTITY_MISMATCH',
+    'LINEAGE_MISMATCH',
+    'EVIDENCE_STALE',
+    'EVIDENCE_UNKNOWN',
+    'OPERATOR_ACTION_REQUIRED',
+];
+export const RELEASE_BLOCKED_LIFECYCLE_REASON_CODES = [
+    'EVIDENCE_VERIFIED',
+    'EVIDENCE_NEGATIVE',
+    'EVIDENCE_NOT_EVALUATED',
+    ...RELEASE_BLOCKED_REASON_CODES,
+];
+export const RELEASE_RESUME_CONDITIONS = [
+    'REVALIDATE_COMPATIBILITY',
+    'REVALIDATE_CANDIDATE_IDENTITY',
+    'REVALIDATE_LINEAGE',
+    'REFRESH_EVIDENCE',
+    'RESOLVE_BLOCKING_CONDITION',
+];
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,159}$/;
+const SHA256 = /^[a-f0-9]{64}$/;
+const SAFE_REF = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,239}$/;
+const BLOCKED_REASON_SET = new Set(RELEASE_BLOCKED_REASON_CODES);
+const LIFECYCLE_REASON_SET = new Set(RELEASE_BLOCKED_LIFECYCLE_REASON_CODES);
+const DIMENSION_SET = new Set(RELEASE_LIFECYCLE_DIMENSIONS);
+const RESUME_CONDITION_SET = new Set(RELEASE_RESUME_CONDITIONS);
+const REQUIRED_REVALIDATIONS = Object.freeze([
+    'compatibility',
+    'candidate',
+    'lineage',
+    'freshness',
+    'blockers',
+]);
+export function createReleaseBlockedResult(input) {
+    assertSafeId(input.attemptId, 'attemptId');
+    assertIso(input.createdAt, 'createdAt');
+    const candidate = normalizeCandidate(input.candidate);
+    const authority = normalizeGateAuthority(input.authority);
+    const lineage = normalizeLineage(input.lineage);
+    const freshness = normalizeFreshness(input.freshness);
+    const lifecycle = normalizeLifecycle(input.lifecycle);
+    assertLifecycleOrdering(lifecycle);
+    const doctorFindings = normalizeDoctorFindings(input.doctorFindings);
+    const blockers = normalizeBlockers(input.blockers);
+    if (blockers.length === 0)
+        throw new Error('RELEASE_BLOCKED_BLOCKER_REQUIRED');
+    const preservedEvidenceRefs = normalizeRefs(input.preservedEvidenceRefs, MAX_RELEASE_EVIDENCE_REFS);
+    const conditionDigest = yoloopDomainHash('release-blocked-resume-condition-v1', {
+        authority,
+        candidate,
+        lineage,
+        blockers,
+        requiredRevalidations: REQUIRED_REVALIDATIONS,
+    });
+    const basis = {
+        schemaVersion: 'ReleaseBlockedResult/1.0',
+        kind: 'release-blocked',
+        outcome: 'release-blocked',
+        terminal: true,
+        successful: false,
+        terminationToken: YOLOOP_RELEASE_BLOCKED_TOKEN,
+        attemptId: input.attemptId,
+        createdAt: input.createdAt,
+        authority,
+        candidate,
+        lineage,
+        freshness,
+        lifecycle,
+        doctorFindings,
+        blockers,
+        preservedEvidenceRefs,
+        resume: {
+            mode: 'explicit-operator-action',
+            autoResume: false,
+            requiredRevalidations: REQUIRED_REVALIDATIONS,
+            conditionDigest,
+        },
+        completion: {
+            yoloopComplete: false,
+            yoloopAborted: false,
+            storyDone: false,
+            epicDone: false,
+        },
+        publicSafe: true,
+    };
+    return deepFreeze({
+        ...basis,
+        resultId: `release-blocked:${yoloopDomainHash('release-blocked-result-v1', basis)}`,
+    });
+}
+export function createReleaseGateReceipt(input) {
+    assertSafeId(input.gateId, 'gateId');
+    if (input.commandId !== 'yoloop' || !/^P[1-9][0-9]{0,11}$/.test(input.targetEpicId)) {
+        throw new Error('RELEASE_GATE_AUTHORITY_INVALID');
+    }
+    assertSafeId(input.attemptId, 'attemptId');
+    assertIso(input.createdAt, 'createdAt');
+    const candidate = normalizeCandidate(input.candidate);
+    const lineage = normalizeLineage(input.lineage);
+    const freshnessEvidence = normalizeFreshness(input.freshness);
+    if (freshnessEvidence.status !== 'fresh')
+        throw new Error('RELEASE_GATE_FRESHNESS_INVALID');
+    const lifecycleValidation = validateReleaseLifecycle(input.lifecycle);
+    if (!lifecycleValidation.accepted || !lifecycleValidation.projection) {
+        throw new Error('RELEASE_GATE_LIFECYCLE_INVALID');
+    }
+    const lifecycle = lifecycleValidation.projection;
+    const lifecycleInput = cloneReleaseLifecycleInput(input.lifecycle);
+    if (candidate.candidateId !== lifecycle.candidateId
+        || lineage.lineageDigest !== lifecycle.lineageSha256
+        || freshnessEvidence.checkedAt !== lifecycle.evaluatedAt
+        || lifecycle.implementationComplete.value !== true
+        || lifecycle.implementationComplete.freshness !== 'fresh'
+        || lifecycle.betaOperable.value === true
+        || lifecycle.releaseReady.value === true
+        || lifecycle.productionPromoted.value === true) {
+        throw new Error('RELEASE_GATE_LIFECYCLE_INVALID');
+    }
+    const doctorFindings = normalizeDoctorFindings(input.doctorFindings);
+    const blockers = normalizeBlockers(input.blockers);
+    if (blockers.length === 0)
+        throw new Error('RELEASE_BLOCKED_BLOCKER_REQUIRED');
+    for (const dimension of ['betaOperable', 'releaseReady', 'productionPromoted']) {
+        if (lifecycle[dimension].value !== true && !blockers.some((blocker) => blocker.dimension === dimension)) {
+            throw new Error('RELEASE_GATE_BLOCKER_COVERAGE_INVALID');
+        }
+    }
+    const preservedEvidenceRefs = normalizeRefs(input.preservedEvidenceRefs, MAX_RELEASE_EVIDENCE_REFS);
+    const basis = {
+        schemaVersion: RELEASE_GATE_RECEIPT_SCHEMA,
+        kind: 'authorized-release-gate-receipt',
+        gateId: input.gateId,
+        commandId: input.commandId,
+        targetEpicId: input.targetEpicId,
+        attemptId: input.attemptId,
+        createdAt: input.createdAt,
+        candidate,
+        lineage,
+        freshness: freshnessEvidence,
+        lifecycle: lifecycleInput,
+        doctorFindings,
+        blockers,
+        preservedEvidenceRefs,
+        publicSafe: true,
+    };
+    return deepFreeze({
+        ...basis,
+        receiptDigest: yoloopDomainHash('release-gate-receipt-v1', basis),
+    });
+}
+export function parseReleaseGateReceipt(value) {
+    if (!isRecord(value) || !hasExactKeys(value, [
+        'schemaVersion', 'kind', 'gateId', 'commandId', 'targetEpicId', 'attemptId', 'createdAt',
+        'candidate', 'lineage', 'freshness', 'lifecycle', 'doctorFindings', 'blockers',
+        'preservedEvidenceRefs', 'receiptDigest', 'publicSafe',
+    ]) || value.schemaVersion !== RELEASE_GATE_RECEIPT_SCHEMA
+        || value.kind !== 'authorized-release-gate-receipt' || value.publicSafe !== true)
+        return undefined;
+    try {
+        const rebuilt = createReleaseGateReceipt({
+            gateId: value.gateId,
+            commandId: value.commandId,
+            targetEpicId: value.targetEpicId,
+            attemptId: value.attemptId,
+            createdAt: value.createdAt,
+            candidate: value.candidate,
+            lineage: value.lineage,
+            freshness: value.freshness,
+            lifecycle: value.lifecycle,
+            doctorFindings: value.doctorFindings,
+            blockers: value.blockers,
+            preservedEvidenceRefs: value.preservedEvidenceRefs,
+        });
+        return value.receiptDigest === rebuilt.receiptDigest ? rebuilt : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Server admission gate. It never treats elapsed time, prose, queue exhaustion,
+ * or a missing field as release authority.
+ */
+export function decideReleaseGateAdmission(requestValue, authority) {
+    if (authority.commandId !== 'yoloop' || !authority.targetEpicId) {
+        return rejectedGate('RELEASE_GATE_AUTHORITY_INVALID');
+    }
+    if (!isRecord(requestValue) || requestValue.schemaVersion !== RELEASE_GATE_REQUEST_SCHEMA
+        || requestValue.publicSafe !== true)
+        return rejectedGate('RELEASE_GATE_REQUEST_INVALID');
+    if (requestValue.mode === 'evaluate') {
+        if (!hasExactKeys(requestValue, ['schemaVersion', 'mode', 'receipt', 'publicSafe'])) {
+            return rejectedGate('RELEASE_GATE_REQUEST_INVALID');
+        }
+        const receipt = parseReleaseGateReceipt(requestValue.receipt);
+        if (!receipt)
+            return rejectedGate('RELEASE_GATE_RECEIPT_INVALID');
+        if (receipt.commandId !== authority.commandId || receipt.targetEpicId !== authority.targetEpicId) {
+            return rejectedGate('RELEASE_GATE_TARGET_MISMATCH');
+        }
+        return deepFreeze({ kind: 'release-blocked', result: releaseBlockedResultFromGate(receipt), publicSafe: true });
+    }
+    if (requestValue.mode === 'resume') {
+        if (!hasOnlyOptionalKeys(requestValue, ['schemaVersion', 'mode', 'commandId', 'targetEpicId', 'previousResult', 'publicSafe'], ['action', 'revalidation']))
+            return rejectedGate('RELEASE_GATE_REQUEST_INVALID');
+        if (requestValue.commandId !== authority.commandId || requestValue.targetEpicId !== authority.targetEpicId) {
+            return rejectedGate('RELEASE_GATE_TARGET_MISMATCH');
+        }
+        const previousResult = parseReleaseBlockedResult(requestValue.previousResult);
+        if (!previousResult)
+            return rejectedGate('RELEASE_GATE_RECEIPT_INVALID');
+        if (previousResult.authority.commandId !== authority.commandId
+            || previousResult.authority.targetEpicId !== authority.targetEpicId) {
+            return rejectedGate('RELEASE_GATE_TARGET_MISMATCH');
+        }
+        const resumeDecision = decideReleaseBlockedResume({
+            result: previousResult,
+            action: requestValue.action,
+            revalidation: requestValue.revalidation,
+        });
+        return resumeDecision.kind === 'authorized'
+            ? deepFreeze({ kind: 'resume-authorized', resumeDecision, publicSafe: true })
+            : deepFreeze({ kind: 'release-blocked', result: previousResult, resumeDecision, publicSafe: true });
+    }
+    return rejectedGate('RELEASE_GATE_REQUEST_INVALID');
+}
+function releaseBlockedResultFromGate(receipt) {
+    const validation = validateReleaseLifecycle(receipt.lifecycle);
+    if (!validation.accepted || !validation.projection)
+        throw new Error('RELEASE_GATE_LIFECYCLE_INVALID');
+    return createReleaseBlockedResult({
+        attemptId: receipt.attemptId,
+        createdAt: receipt.createdAt,
+        authority: {
+            gateId: receipt.gateId,
+            commandId: receipt.commandId,
+            targetEpicId: receipt.targetEpicId,
+        },
+        candidate: receipt.candidate,
+        lineage: receipt.lineage,
+        freshness: receipt.freshness,
+        lifecycle: projectReleaseBlockedLifecycle(validation.projection, receipt.blockers),
+        doctorFindings: receipt.doctorFindings,
+        blockers: receipt.blockers,
+        preservedEvidenceRefs: receipt.preservedEvidenceRefs,
+    });
+}
+function projectReleaseBlockedLifecycle(lifecycle, blockers) {
+    const output = {};
+    for (const dimension of RELEASE_LIFECYCLE_DIMENSIONS) {
+        const evidence = lifecycle[dimension];
+        const blockerReasons = blockers
+            .filter((blocker) => blocker.dimension === dimension)
+            .map((blocker) => blocker.reasonCode);
+        output[dimension] = {
+            value: evidence.value,
+            reasonCodes: evidence.value === true
+                ? ['EVIDENCE_VERIFIED']
+                : blockerReasons.length > 0 ? blockerReasons : ['EVIDENCE_UNKNOWN'],
+            evidenceRefs: evidence.evidenceRefs,
+        };
+    }
+    return output;
+}
+function cloneReleaseLifecycleInput(value) {
+    const dimensions = {};
+    for (const dimension of RELEASE_LIFECYCLE_DIMENSIONS) {
+        const evidence = value[dimension];
+        dimensions[dimension] = Object.freeze({
+            value: evidence.value,
+            reasonCodes: Object.freeze([...evidence.reasonCodes]),
+            evidenceRefs: Object.freeze([...evidence.evidenceRefs]),
+            candidateId: evidence.candidateId,
+            lineageSha256: evidence.lineageSha256,
+            ...(evidence.observedAt ? { observedAt: evidence.observedAt } : {}),
+            ...(evidence.maxAgeSeconds !== undefined ? { maxAgeSeconds: evidence.maxAgeSeconds } : {}),
+        });
+    }
+    return Object.freeze({
+        schemaVersion: value.schemaVersion,
+        candidateId: value.candidateId,
+        lineageSha256: value.lineageSha256,
+        evaluatedAt: value.evaluatedAt,
+        implementationComplete: dimensions.implementationComplete,
+        betaOperable: dimensions.betaOperable,
+        releaseReady: dimensions.releaseReady,
+        productionPromoted: dimensions.productionPromoted,
+        publicSafe: true,
+    });
+}
+/** Strict wire parser. Unknown or malformed input is never interpreted as terminal success. */
+export function parseReleaseBlockedResult(value) {
+    if (!isRecord(value) || !hasExactKeys(value, [
+        'schemaVersion', 'kind', 'outcome', 'terminal', 'successful', 'terminationToken',
+        'attemptId', 'resultId', 'createdAt', 'authority', 'candidate', 'lineage', 'freshness',
+        'lifecycle', 'doctorFindings', 'blockers', 'preservedEvidenceRefs', 'resume',
+        'completion', 'publicSafe',
+    ]))
+        return undefined;
+    try {
+        if (value.schemaVersion !== 'ReleaseBlockedResult/1.0'
+            || value.kind !== 'release-blocked'
+            || value.outcome !== 'release-blocked'
+            || value.terminal !== true
+            || value.successful !== false
+            || value.terminationToken !== YOLOOP_RELEASE_BLOCKED_TOKEN
+            || value.publicSafe !== true
+            || !isRecord(value.completion)
+            || !hasExactKeys(value.completion, ['yoloopComplete', 'yoloopAborted', 'storyDone', 'epicDone'])
+            || value.completion.yoloopComplete !== false
+            || value.completion.yoloopAborted !== false
+            || value.completion.storyDone !== false
+            || value.completion.epicDone !== false)
+            return undefined;
+        const rebuilt = createReleaseBlockedResult({
+            attemptId: value.attemptId,
+            createdAt: value.createdAt,
+            authority: value.authority,
+            candidate: value.candidate,
+            lineage: value.lineage,
+            freshness: value.freshness,
+            lifecycle: value.lifecycle,
+            doctorFindings: value.doctorFindings,
+            blockers: value.blockers,
+            preservedEvidenceRefs: value.preservedEvidenceRefs,
+        });
+        if (value.resultId !== rebuilt.resultId || !isRecord(value.resume)
+            || !hasExactKeys(value.resume, ['mode', 'autoResume', 'requiredRevalidations', 'conditionDigest'])
+            || value.resume.conditionDigest !== rebuilt.resume.conditionDigest
+            || value.resume.mode !== 'explicit-operator-action'
+            || value.resume.autoResume !== false
+            || !Array.isArray(value.resume.requiredRevalidations)
+            || value.resume.requiredRevalidations.length !== REQUIRED_REVALIDATIONS.length
+            || value.resume.requiredRevalidations.some((item, index) => item !== REQUIRED_REVALIDATIONS[index]))
+            return undefined;
+        return rebuilt;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function replayReleaseBlockedResult(value) {
+    return parseReleaseBlockedResult(value);
+}
+/** Pure resume gate. Time passing alone can never authorize a successor. */
+export function decideReleaseBlockedResume(input) {
+    const result = parseReleaseBlockedResult(input.result);
+    if (!result || !isRecord(input.action)
+        || !hasExactKeys(input.action, ['kind', 'actionId', 'requestedAt', 'operatorConfirmed'])
+        || input.action.kind !== 'resume-release-attempt'
+        || input.action.operatorConfirmed !== true || !isSafeId(input.action.actionId)
+        || !isIso(input.action.requestedAt)) {
+        return rejectedResume('RELEASE_RESUME_EXPLICIT_ACTION_REQUIRED');
+    }
+    const check = input.revalidation;
+    if (!isRecord(check)
+        || !hasExactKeys(check, ['checkedAt', 'compatibility', 'candidate', 'lineage', 'freshness', 'resolvedBlockerIds'])
+        || check.compatibility !== 'compatible' || check.freshness !== 'fresh'
+        || !isIso(check.checkedAt) || !Array.isArray(check.resolvedBlockerIds)) {
+        return rejectedResume('RELEASE_RESUME_REVALIDATION_INVALID');
+    }
+    let candidate;
+    let lineage;
+    try {
+        candidate = normalizeCandidate(check.candidate);
+        lineage = normalizeLineage(check.lineage);
+    }
+    catch {
+        return rejectedResume('RELEASE_RESUME_REVALIDATION_INVALID');
+    }
+    if (candidate.candidateId !== result.candidate.candidateId
+        || candidate.candidateDigest !== result.candidate.candidateDigest) {
+        return rejectedResume('RELEASE_RESUME_CANDIDATE_MISMATCH');
+    }
+    if (lineage.lineageId !== result.lineage.lineageId
+        || lineage.lineageDigest !== result.lineage.lineageDigest
+        || lineage.parentDigest !== result.lineage.parentDigest) {
+        return rejectedResume('RELEASE_RESUME_LINEAGE_MISMATCH');
+    }
+    if (Date.parse(check.checkedAt) < Date.parse(result.createdAt)
+        || Date.parse(input.action.requestedAt) < Date.parse(result.createdAt)) {
+        return rejectedResume('RELEASE_RESUME_STALE_REVALIDATION');
+    }
+    const resolved = new Set(check.resolvedBlockerIds.filter(isSafeId));
+    if (resolved.size !== check.resolvedBlockerIds.length
+        || result.blockers.some((blocker) => !resolved.has(blocker.blockerId))) {
+        return rejectedResume('RELEASE_RESUME_BLOCKERS_UNRESOLVED');
+    }
+    const resumeBasis = {
+        previousResultId: result.resultId,
+        actionId: input.action.actionId,
+        requestedAt: input.action.requestedAt,
+        checkedAt: check.checkedAt,
+        conditionDigest: result.resume.conditionDigest,
+    };
+    const digest = yoloopDomainHash('release-blocked-resume-v1', resumeBasis);
+    return deepFreeze({
+        kind: 'authorized',
+        previousResultId: result.resultId,
+        resumeId: `release-resume:${digest}`,
+        nextAttemptId: `release-attempt:${digest}`,
+        publicSafe: true,
+    });
+}
+/** Existing clients already understand CLIENT_UPGRADE_REQUIRED as non-success. */
+export function buildLegacyReleaseBlockedFallback(resultValue) {
+    const result = parseReleaseBlockedResult(resultValue);
+    if (!result)
+        throw new Error('RELEASE_BLOCKED_RESULT_INVALID');
+    return deepFreeze({
+        success: false,
+        exitCode: 3,
+        errorCode: 'CLIENT_UPGRADE_REQUIRED',
+        instructions: [
+            '# Release Blocked -- Client Upgrade Required',
+            '',
+            'This release attempt ended without success. Upgrade the client, then explicitly resume after revalidation.',
+            'Run: npm install -g @ornexus/neocortex@latest',
+            '',
+            YOLOOP_RELEASE_BLOCKED_TOKEN,
+        ].join('\n'),
+        metadata: {
+            mode: 'error',
+            errorCode: 'CLIENT_UPGRADE_REQUIRED',
+            terminalClass: 'release-blocked',
+            yoloopComplete: false,
+            yoloopAborted: false,
+            upgradeRequired: true,
+            releaseBlockedResultId: result.resultId,
+            publicSafe: true,
+        },
+    });
+}
+function normalizeCandidate(value) {
+    if (!isRecord(value) || !hasExactKeys(value, ['candidateId', 'candidateDigest'])) {
+        throw new Error('RELEASE_BLOCKED_CANDIDATE_INVALID');
+    }
+    assertSafeId(value.candidateId, 'candidateId');
+    assertDigest(value.candidateDigest, 'candidateDigest');
+    return Object.freeze({ candidateId: value.candidateId, candidateDigest: value.candidateDigest });
+}
+function normalizeGateAuthority(value) {
+    if (!isRecord(value)
+        || !hasExactKeys(value, ['gateId', 'commandId', 'targetEpicId'])
+        || !isSafeId(value.gateId)
+        || value.commandId !== 'yoloop'
+        || typeof value.targetEpicId !== 'string'
+        || !/^P[1-9][0-9]{0,11}$/.test(value.targetEpicId)) {
+        throw new Error('RELEASE_GATE_AUTHORITY_INVALID');
+    }
+    return Object.freeze({
+        gateId: value.gateId,
+        commandId: value.commandId,
+        targetEpicId: value.targetEpicId,
+    });
+}
+function normalizeLineage(value) {
+    if (!isRecord(value)
+        || !hasOnlyOptionalKeys(value, ['lineageId', 'lineageDigest'], ['parentDigest'])) {
+        throw new Error('RELEASE_BLOCKED_LINEAGE_INVALID');
+    }
+    assertSafeId(value.lineageId, 'lineageId');
+    assertDigest(value.lineageDigest, 'lineageDigest');
+    if (value.parentDigest !== undefined)
+        assertDigest(value.parentDigest, 'parentDigest');
+    return Object.freeze({
+        lineageId: value.lineageId,
+        lineageDigest: value.lineageDigest,
+        ...(value.parentDigest ? { parentDigest: value.parentDigest } : {}),
+    });
+}
+function normalizeFreshness(value) {
+    if (!isRecord(value)
+        || !hasOnlyOptionalKeys(value, ['status', 'checkedAt'], ['validUntil'])
+        || !['fresh', 'stale', 'unknown'].includes(String(value.status))) {
+        throw new Error('RELEASE_BLOCKED_FRESHNESS_INVALID');
+    }
+    assertIso(value.checkedAt, 'checkedAt');
+    if (value.validUntil !== undefined) {
+        assertIso(value.validUntil, 'validUntil');
+        if (Date.parse(value.validUntil) < Date.parse(value.checkedAt))
+            throw new Error('RELEASE_BLOCKED_FRESHNESS_INVALID');
+    }
+    return Object.freeze({
+        status: value.status,
+        checkedAt: value.checkedAt,
+        ...(value.validUntil ? { validUntil: value.validUntil } : {}),
+    });
+}
+function normalizeLifecycle(value) {
+    if (!isRecord(value) || !hasExactKeys(value, RELEASE_LIFECYCLE_DIMENSIONS)) {
+        throw new Error('RELEASE_BLOCKED_LIFECYCLE_INVALID');
+    }
+    const output = {};
+    for (const dimension of RELEASE_LIFECYCLE_DIMENSIONS) {
+        const evidence = value[dimension];
+        if (!isRecord(evidence) || !hasExactKeys(evidence, ['value', 'reasonCodes', 'evidenceRefs'])
+            || ![true, false, 'unknown'].includes(evidence.value)
+            || !Array.isArray(evidence.reasonCodes) || evidence.reasonCodes.length < 1 || evidence.reasonCodes.length > 8
+            || evidence.reasonCodes.some((code) => typeof code !== 'string' || !LIFECYCLE_REASON_SET.has(code))) {
+            throw new Error('RELEASE_BLOCKED_LIFECYCLE_INVALID');
+        }
+        output[dimension] = Object.freeze({
+            value: evidence.value,
+            reasonCodes: Object.freeze([...new Set(evidence.reasonCodes)].sort()),
+            evidenceRefs: normalizeRefs(evidence.evidenceRefs, MAX_RELEASE_EVIDENCE_REFS),
+        });
+    }
+    return Object.freeze(output);
+}
+function assertLifecycleOrdering(value) {
+    if (value.productionPromoted.value === true && value.releaseReady.value !== true) {
+        throw new Error('RELEASE_BLOCKED_LIFECYCLE_ORDER_INVALID');
+    }
+    if (value.releaseReady.value === true
+        && (value.implementationComplete.value !== true || value.betaOperable.value !== true)) {
+        throw new Error('RELEASE_BLOCKED_LIFECYCLE_ORDER_INVALID');
+    }
+    if (value.productionPromoted.value === true)
+        throw new Error('RELEASE_BLOCKED_ALREADY_PROMOTED');
+}
+function normalizeDoctorFindings(values) {
+    if (!Array.isArray(values) || values.length > MAX_RELEASE_DOCTOR_FINDINGS) {
+        throw new Error('RELEASE_BLOCKED_DOCTOR_FINDINGS_INVALID');
+    }
+    const byId = new Map();
+    for (const value of values) {
+        if (!isRecord(value)
+            || !hasExactKeys(value, ['findingId', 'reasonCode', 'dimension', 'status', 'evidenceRefs'])
+            || !isSafeId(value.findingId) || !BLOCKED_REASON_SET.has(String(value.reasonCode))
+            || !DIMENSION_SET.has(String(value.dimension)) || !['open', 'resolved', 'unknown'].includes(String(value.status))) {
+            throw new Error('RELEASE_BLOCKED_DOCTOR_FINDINGS_INVALID');
+        }
+        if (byId.has(value.findingId))
+            throw new Error('RELEASE_BLOCKED_DOCTOR_FINDINGS_INVALID');
+        byId.set(value.findingId, Object.freeze({
+            findingId: value.findingId,
+            reasonCode: value.reasonCode,
+            dimension: value.dimension,
+            status: value.status,
+            evidenceRefs: normalizeRefs(value.evidenceRefs, MAX_RELEASE_EVIDENCE_REFS),
+        }));
+    }
+    return Object.freeze([...byId.values()].sort((a, b) => a.findingId.localeCompare(b.findingId)));
+}
+function normalizeBlockers(values) {
+    if (!Array.isArray(values) || values.length > MAX_RELEASE_BLOCKERS) {
+        throw new Error('RELEASE_BLOCKED_BLOCKERS_INVALID');
+    }
+    const byId = new Map();
+    for (const value of values) {
+        if (!isRecord(value)
+            || !hasExactKeys(value, ['blockerId', 'reasonCode', 'dimension', 'evidenceRefs', 'retryability', 'resumeCondition'])
+            || !isSafeId(value.blockerId) || !BLOCKED_REASON_SET.has(String(value.reasonCode))
+            || !DIMENSION_SET.has(String(value.dimension))
+            || !['operator-action', 'evidence-refresh', 'not-retryable'].includes(String(value.retryability))
+            || !RESUME_CONDITION_SET.has(String(value.resumeCondition))) {
+            throw new Error('RELEASE_BLOCKED_BLOCKERS_INVALID');
+        }
+        if (byId.has(value.blockerId))
+            throw new Error('RELEASE_BLOCKED_BLOCKERS_INVALID');
+        byId.set(value.blockerId, Object.freeze({
+            blockerId: value.blockerId,
+            reasonCode: value.reasonCode,
+            dimension: value.dimension,
+            evidenceRefs: normalizeRefs(value.evidenceRefs, MAX_RELEASE_EVIDENCE_REFS),
+            retryability: value.retryability,
+            resumeCondition: value.resumeCondition,
+        }));
+    }
+    return Object.freeze([...byId.values()].sort((a, b) => a.blockerId.localeCompare(b.blockerId)));
+}
+function normalizeRefs(value, max) {
+    if (!Array.isArray(value) || value.length > max)
+        throw new Error('RELEASE_BLOCKED_EVIDENCE_REFS_INVALID');
+    const refs = value.map((item) => {
+        if (typeof item !== 'string' || !SAFE_REF.test(item) || item.includes('..')
+            || item.startsWith('/') || item.includes('://') || item.includes('\\')) {
+            throw new Error('RELEASE_BLOCKED_EVIDENCE_REFS_INVALID');
+        }
+        return item;
+    });
+    return Object.freeze([...new Set(refs)].sort());
+}
+function rejectedResume(reasonCode) {
+    return Object.freeze({ kind: 'rejected', reasonCode, publicSafe: true });
+}
+function rejectedGate(reasonCode) {
+    return Object.freeze({ kind: 'rejected', reasonCode, publicSafe: true });
+}
+function hasExactKeys(value, expected) {
+    const keys = Object.keys(value).sort();
+    const sorted = [...expected].sort();
+    return keys.length === sorted.length && keys.every((key, index) => key === sorted[index]);
+}
+function hasOnlyOptionalKeys(value, required, optional) {
+    const allowed = new Set([...required, ...optional]);
+    return required.every((key) => Object.prototype.hasOwnProperty.call(value, key))
+        && Object.keys(value).every((key) => allowed.has(key));
+}
+function assertSafeId(value, field) {
+    if (typeof value !== 'string' || !isSafeId(value))
+        throw new Error(`RELEASE_BLOCKED_${field.toUpperCase()}_INVALID`);
+}
+function isSafeId(value) {
+    return typeof value === 'string' && SAFE_ID.test(value);
+}
+function assertDigest(value, field) {
+    if (typeof value !== 'string' || !SHA256.test(value))
+        throw new Error(`RELEASE_BLOCKED_${field.toUpperCase()}_INVALID`);
+}
+function assertIso(value, field) {
+    if (!isIso(value))
+        throw new Error(`RELEASE_BLOCKED_${field.toUpperCase()}_INVALID`);
+}
+function isIso(value) {
+    return typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value)
+        && Number.isFinite(Date.parse(value));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value))
+            deepFreeze(child);
+    }
+    return value;
+}

package/targets-stubs/antigravity/gemini.md

@@ -1,4 +1,4 @@
-# 🧠 Neocortex v4.60.66 | OrNexus Team
+# 🧠 Neocortex v4.60.67 | OrNexus Team
 
 This project uses Neocortex, a Development Orchestrator.
 

package/targets-stubs/antigravity/skill/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: neocortex
-description: "🧠 Neocortex v4.60.66 | OrNexus Team"
+description: "🧠 Neocortex v4.60.67 | OrNexus Team"
 ---
 
 <!--
@@ -160,7 +160,8 @@ while true; do
   echo "$RESPONSE"
   echo "$RESPONSE" | grep -q '\[YOLOOP_COMPLETE\]' && break
   echo "$RESPONSE" | grep -q '\[YOLOOP_ABORTED\]' && break
+  echo "$RESPONSE" | grep -q '\[YOLOOP_RELEASE_BLOCKED\]' && exit 1
 done
 ```
 
-Termination tokens: `[YOLOOP_COMPLETE]` (success) and `[YOLOOP_ABORTED]` (failure).
+Termination tokens: `[YOLOOP_COMPLETE]` (success), `[YOLOOP_ABORTED]` (failure), and `[YOLOOP_RELEASE_BLOCKED]` (terminal non-success).

package/targets-stubs/claude-code/neocortex-root.agent.yaml

@@ -4,7 +4,7 @@ agent:
     name: 'Neocortex Root Agent'
     title: 'Development Orchestrator (Root)'
     icon: '>'
-    version: '4.60.66'
+    version: '4.60.67'
     architecture: 'thin-client'
     module: stand-alone
     hasSidecar: false