@ornexus/neocortex 4.60.73 → 4.60.75

package/packages/shared/dist/invocation/explicit-intent-recovery.d.ts

@@ -0,0 +1,83 @@
+export declare const EXPLICIT_INTENT_RECOVERY_VERSION: 1;
+export type ExplicitIntentRecoveryReasonV1 = 'exact-admission-accepted' | 'recovery-positional-overflow-eligible' | 'recovery-not-positional-overflow' | 'recovery-command-not-exact-first' | 'recovery-command-schema-ineligible' | 'recovery-unsafe-token' | 'recovery-multiple-explicit-commands' | 'recovery-target-not-unique' | 'recovery-canonical-admission-conflict';
+export interface ExplicitIntentRecoveryBindingV1 {
+    readonly schemaVersion: typeof EXPLICIT_INTENT_RECOVERY_VERSION;
+    readonly originalSha256: string;
+    readonly originalByteLength: number;
+    readonly canonicalSha256: string;
+    readonly canonicalByteLength: number;
+    readonly commandId: string;
+    readonly targetKind: 'story-ref' | 'epic-ref' | 'target-ref';
+    readonly discardedTokenCount: number;
+    readonly receiptSha256: string;
+    readonly reasonCode: 'recovery-positional-overflow-eligible';
+    readonly publicSafe: true;
+}
+export type ExplicitIntentRecoveryResultV1 = {
+    readonly schemaVersion: typeof EXPLICIT_INTENT_RECOVERY_VERSION;
+    readonly kind: 'exact';
+    readonly reasonCode: 'exact-admission-accepted';
+    readonly publicSafe: true;
+} | {
+    readonly schemaVersion: typeof EXPLICIT_INTENT_RECOVERY_VERSION;
+    readonly kind: 'canonicalized';
+    readonly canonicalArgs: string;
+    readonly binding: ExplicitIntentRecoveryBindingV1;
+    readonly publicSafe: true;
+} | {
+    readonly schemaVersion: typeof EXPLICIT_INTENT_RECOVERY_VERSION;
+    readonly kind: 'confirmation-required' | 'rejected';
+    readonly reasonCode: Exclude<ExplicitIntentRecoveryReasonV1, 'exact-admission-accepted' | 'recovery-positional-overflow-eligible'>;
+    readonly candidateCount: number;
+    readonly publicSafe: true;
+};
+interface RecoveryAdmissionProjection {
+    readonly outcome: string;
+    readonly reason: string;
+    readonly selection?: {
+        readonly commandId: string;
+        readonly positionals: readonly string[];
+        readonly options: Readonly<Record<string, unknown>>;
+    };
+}
+interface RecoveryTokenProjection {
+    readonly value: string;
+    readonly whollyUnquoted: boolean;
+}
+interface RecoveryCommandProjection {
+    readonly id: string;
+    readonly aliases: readonly string[];
+    readonly number: number;
+}
+interface RecoverySchemaProjection {
+    readonly commandId: string;
+    readonly operation: {
+        readonly operations: readonly unknown[];
+    };
+    readonly options: readonly {
+        readonly required: boolean;
+    }[];
+    readonly positionals: readonly {
+        readonly kind: string;
+        readonly cardinality: string;
+        readonly required: boolean;
+    }[];
+}
+export interface ExplicitIntentRecoveryAuthority {
+    readonly input: string;
+    readonly exactAdmission: RecoveryAdmissionProjection;
+    readonly tokens: readonly RecoveryTokenProjection[] | null;
+    readonly commands: readonly RecoveryCommandProjection[];
+    readonly schemas: readonly RecoverySchemaProjection[];
+    readonly admitCanonical: (candidate: string) => RecoveryAdmissionProjection;
+}
+/**
+ * P224.02 exact-first recovery kernel.
+ *
+ * The caller supplies the exact parser, schema and lexer projections so this
+ * module stays pure and cannot become a second registry or parser. The result
+ * never contains discarded prose or the original input bytes.
+ */
+export declare function recoverExplicitIntentWithAuthority(authority: ExplicitIntentRecoveryAuthority): ExplicitIntentRecoveryResultV1;
+export declare function assertExplicitIntentRecoveryBindingV1(value: unknown, canonicalArgs?: string): asserts value is ExplicitIntentRecoveryBindingV1;
+export {};

package/packages/shared/dist/invocation/explicit-intent-recovery.js

@@ -0,0 +1,187 @@
+import { createHash } from 'node:crypto';
+export const EXPLICIT_INTENT_RECOVERY_VERSION = 1;
+function sha256(value) {
+    return createHash('sha256').update(value, 'utf8').digest('hex');
+}
+function rejected(kind, reasonCode, candidateCount = 0) {
+    return Object.freeze({
+        schemaVersion: EXPLICIT_INTENT_RECOVERY_VERSION,
+        kind,
+        reasonCode,
+        candidateCount: Math.max(0, Math.min(candidateCount, 16)),
+        publicSafe: true,
+    });
+}
+function commandForFirstToken(token, commands) {
+    if (!token.whollyUnquoted)
+        return undefined;
+    const normalized = token.value.replace(/^\*/, '').toLowerCase();
+    if (!token.value.startsWith('*') || !/^[a-z][a-z0-9?-]*$/.test(normalized))
+        return undefined;
+    return commands.find((command) => command.id === normalized || command.aliases.includes(normalized));
+}
+function isExplicitCommandToken(token, commands) {
+    if (!token.whollyUnquoted || !token.value.startsWith('*'))
+        return false;
+    const normalized = token.value.slice(1).toLowerCase();
+    return commands.some((command) => command.id === normalized || command.aliases.includes(normalized));
+}
+function recoverableTypedTarget(kind, value) {
+    const candidate = value.startsWith('@') ? value.slice(1) : value;
+    if (kind === 'story-ref') {
+        return /^(?:docs\/stories\/[A-Za-z0-9._/-]+\.story\.md|P\d+\.\d+|story-P\d+\.\d+)$/.test(candidate);
+    }
+    if (kind === 'epic-ref') {
+        return /^(?:docs\/epics\/epic-[A-Za-z0-9][A-Za-z0-9_-]*\.md|P\d+|epic-[A-Za-z0-9][A-Za-z0-9_-]*(?:\.md)?)$/i.test(candidate);
+    }
+    return /^(?:P\d+|EPIC-\d+)$/i.test(candidate)
+        || /^docs\/epics\/?$/.test(candidate)
+        || /^docs\/epics\/epic-[A-Za-z0-9][A-Za-z0-9_-]*\.md$/i.test(candidate);
+}
+/**
+ * P224.02 exact-first recovery kernel.
+ *
+ * The caller supplies the exact parser, schema and lexer projections so this
+ * module stays pure and cannot become a second registry or parser. The result
+ * never contains discarded prose or the original input bytes.
+ */
+export function recoverExplicitIntentWithAuthority(authority) {
+    if (authority.exactAdmission.outcome === 'resolved') {
+        return Object.freeze({
+            schemaVersion: EXPLICIT_INTENT_RECOVERY_VERSION,
+            kind: 'exact',
+            reasonCode: 'exact-admission-accepted',
+            publicSafe: true,
+        });
+    }
+    if (authority.exactAdmission.outcome !== 'invalid_arguments'
+        || authority.exactAdmission.reason !== 'positional_overflow') {
+        return rejected('rejected', 'recovery-not-positional-overflow');
+    }
+    const tokens = authority.tokens;
+    if (!tokens || tokens.length < 3) {
+        return rejected('rejected', 'recovery-command-not-exact-first');
+    }
+    const command = commandForFirstToken(tokens[0], authority.commands);
+    if (!command)
+        return rejected('rejected', 'recovery-command-not-exact-first');
+    const schema = authority.schemas.find((item) => item.commandId === command.id);
+    const positional = schema?.positionals[0];
+    if (!schema
+        || schema.operation.operations.length > 0
+        || schema.options.some((option) => option.required)
+        || schema.positionals.length !== 1
+        || positional?.cardinality !== 'one'
+        || !['story-ref', 'epic-ref', 'target-ref'].includes(positional.kind)) {
+        return rejected('rejected', 'recovery-command-schema-ineligible');
+    }
+    if (tokens.slice(1).some((token) => isExplicitCommandToken(token, authority.commands))) {
+        return rejected('confirmation-required', 'recovery-multiple-explicit-commands');
+    }
+    // Recovery never discards quoted material or option-shaped tokens. Exact
+    // admission remains responsible for accepted options and quoted arguments.
+    if (tokens.slice(1).some((token) => !token.whollyUnquoted || token.value.startsWith('--')
+        || token.value.startsWith('*'))) {
+        return rejected('confirmation-required', 'recovery-unsafe-token');
+    }
+    const candidates = tokens.slice(1).flatMap((token) => {
+        if (!recoverableTypedTarget(positional.kind, token.value)) {
+            return [];
+        }
+        const canonicalArgs = `*${command.id} ${token.value}`;
+        const admission = authority.admitCanonical(canonicalArgs);
+        if (admission.outcome !== 'resolved'
+            || admission.selection?.commandId !== command.id
+            || admission.selection.positionals.length !== 1
+            || Object.keys(admission.selection.options).length !== 0)
+            return [];
+        return [{ canonicalArgs, target: admission.selection.positionals[0] }];
+    });
+    const unique = [...new Map(candidates.map((candidate) => [candidate.canonicalArgs, candidate])).values()];
+    if (unique.length !== 1) {
+        return rejected('confirmation-required', 'recovery-target-not-unique', unique.length);
+    }
+    const selected = unique[0];
+    const finalAdmission = authority.admitCanonical(selected.canonicalArgs);
+    if (finalAdmission.outcome !== 'resolved'
+        || finalAdmission.selection?.commandId !== command.id
+        || finalAdmission.selection.positionals[0] !== selected.target) {
+        return rejected('rejected', 'recovery-canonical-admission-conflict', 1);
+    }
+    const originalSha256 = sha256(authority.input);
+    const canonicalSha256 = sha256(selected.canonicalArgs);
+    const base = {
+        schemaVersion: EXPLICIT_INTENT_RECOVERY_VERSION,
+        originalSha256,
+        originalByteLength: Buffer.byteLength(authority.input, 'utf8'),
+        canonicalSha256,
+        canonicalByteLength: Buffer.byteLength(selected.canonicalArgs, 'utf8'),
+        commandId: command.id,
+        targetKind: positional.kind,
+        discardedTokenCount: tokens.length - 2,
+        reasonCode: 'recovery-positional-overflow-eligible',
+        publicSafe: true,
+    };
+    const receiptSha256 = sha256(`p224-explicit-intent-recovery-v1\0${JSON.stringify(base)}`);
+    return Object.freeze({
+        schemaVersion: EXPLICIT_INTENT_RECOVERY_VERSION,
+        kind: 'canonicalized',
+        canonicalArgs: selected.canonicalArgs,
+        binding: Object.freeze({ ...base, receiptSha256 }),
+        publicSafe: true,
+    });
+}
+export function assertExplicitIntentRecoveryBindingV1(value, canonicalArgs) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('EXPLICIT_INTENT_RECOVERY_BINDING_INVALID');
+    }
+    const candidate = value;
+    const expectedKeys = [
+        'canonicalByteLength', 'canonicalSha256', 'commandId', 'discardedTokenCount',
+        'originalByteLength', 'originalSha256', 'publicSafe', 'reasonCode',
+        'receiptSha256', 'schemaVersion', 'targetKind',
+    ];
+    if (Object.keys(candidate).sort().join('\0') !== expectedKeys.sort().join('\0')
+        || candidate.schemaVersion !== EXPLICIT_INTENT_RECOVERY_VERSION
+        || !['story-ref', 'epic-ref', 'target-ref'].includes(String(candidate.targetKind))
+        || typeof candidate.commandId !== 'string'
+        || !/^[a-z][a-z0-9?-]{0,63}$/.test(candidate.commandId)
+        || typeof candidate.originalSha256 !== 'string'
+        || !/^[a-f0-9]{64}$/.test(candidate.originalSha256)
+        || typeof candidate.canonicalSha256 !== 'string'
+        || !/^[a-f0-9]{64}$/.test(candidate.canonicalSha256)
+        || typeof candidate.receiptSha256 !== 'string'
+        || !/^[a-f0-9]{64}$/.test(candidate.receiptSha256)
+        || !Number.isSafeInteger(candidate.originalByteLength)
+        || candidate.originalByteLength < 1
+        || !Number.isSafeInteger(candidate.canonicalByteLength)
+        || candidate.canonicalByteLength < 1
+        || !Number.isSafeInteger(candidate.discardedTokenCount)
+        || candidate.discardedTokenCount < 1
+        || candidate.discardedTokenCount > 512
+        || candidate.reasonCode !== 'recovery-positional-overflow-eligible'
+        || candidate.publicSafe !== true) {
+        throw new Error('EXPLICIT_INTENT_RECOVERY_BINDING_INVALID');
+    }
+    if (canonicalArgs !== undefined
+        && (candidate.canonicalByteLength !== Buffer.byteLength(canonicalArgs, 'utf8')
+            || candidate.canonicalSha256 !== sha256(canonicalArgs))) {
+        throw new Error('EXPLICIT_INTENT_RECOVERY_BINDING_CONFLICT');
+    }
+    const receiptBase = {
+        schemaVersion: candidate.schemaVersion,
+        originalSha256: candidate.originalSha256,
+        originalByteLength: candidate.originalByteLength,
+        canonicalSha256: candidate.canonicalSha256,
+        canonicalByteLength: candidate.canonicalByteLength,
+        commandId: candidate.commandId,
+        targetKind: candidate.targetKind,
+        discardedTokenCount: candidate.discardedTokenCount,
+        reasonCode: candidate.reasonCode,
+        publicSafe: candidate.publicSafe,
+    };
+    if (candidate.receiptSha256
+        !== sha256(`p224-explicit-intent-recovery-v1\0${JSON.stringify(receiptBase)}`)) {
+        throw new Error('EXPLICIT_INTENT_RECOVERY_BINDING_CONFLICT');
+    }
+}

package/packages/shared/dist/invocation/index.d.ts

@@ -1,3 +1,4 @@
+import { type ExplicitIntentRecoveryResultV1 } from './explicit-intent-recovery.js';
 export * from './input-envelope.js';
 export * from './project-identity-migration.js';
 export * from './state-projection.js';
@@ -5,6 +6,7 @@ export * from './strict-effect-receipt.js';
 export * from './public-diagnostics.js';
 export * from './recovery-route-compiler.js';
 export * from './executable-policy-recovery.js';
+export * from './explicit-intent-recovery.js';
 export declare const EXACT_INVOCATION_POLICY: "p205-exact-invocation-v1";
 export declare const INVOCATION_SCHEMA_VERSION: "p205-invocation-schema-v1";
 export declare const INVOCATION_LIMITS: Readonly<{
@@ -147,6 +149,11 @@ type LexResult = {
 };
 export declare function lexInvocationEnvelope(input: string): LexResult;
 export declare function admitInvocation(input: string, options?: InvocationAdmissionOptions): InvocationAdmissionResultV1;
+/**
+ * P224.02 public exact-first recovery facade. It reuses this module's single
+ * registry, schema, lexer and admission authority instead of duplicating policy.
+ */
+export declare function recoverExplicitInvocation(input: string, options?: InvocationAdmissionOptions): ExplicitIntentRecoveryResultV1;
 export interface InvocationAdmissionReceiptV1 {
     readonly schemaVersion: 1;
     readonly policy: typeof EXACT_INVOCATION_POLICY;

package/packages/shared/dist/invocation/index.js

@@ -10,6 +10,7 @@ import { COMMAND_REGISTRY_CHECKSUM, COMMAND_REGISTRY_VERSION, GENERATED_SHARED_C
 import { GENERATED_INVOCATION_SCHEMA_MANIFEST, GENERATED_INVOCATION_SCHEMAS, } from '../generated/invocation-schema.generated.js';
 import { canonicalizeCommandRegistryJcs } from '../command-registry-contract.js';
 import { CONTINUITY_GOAL_OPERATION_IDS } from '../continuity/goal-operation-authority.js';
+import { recoverExplicitIntentWithAuthority, } from './explicit-intent-recovery.js';
 export * from './input-envelope.js';
 export * from './project-identity-migration.js';
 export * from './state-projection.js';
@@ -17,6 +18,7 @@ export * from './strict-effect-receipt.js';
 export * from './public-diagnostics.js';
 export * from './recovery-route-compiler.js';
 export * from './executable-policy-recovery.js';
+export * from './explicit-intent-recovery.js';
 export const EXACT_INVOCATION_POLICY = 'p205-exact-invocation-v1';
 export const INVOCATION_SCHEMA_VERSION = 'p205-invocation-schema-v1';
 export const INVOCATION_LIMITS = Object.freeze({
@@ -598,6 +600,26 @@ export function admitInvocation(input, options = {}) {
         return reject('invalid_arguments', uiUxReview, lexed.tokens.length, bytes);
     return resolved(command, operation.operationId, parsed, uiUxReview, lexed.tokens.length, bytes);
 }
+/**
+ * P224.02 public exact-first recovery facade. It reuses this module's single
+ * registry, schema, lexer and admission authority instead of duplicating policy.
+ */
+export function recoverExplicitInvocation(input, options = {}) {
+    const exactAdmission = admitInvocation(input, options);
+    const lexed = lexInvocationEnvelope(input);
+    return recoverExplicitIntentWithAuthority({
+        input,
+        exactAdmission,
+        tokens: lexed.ok ? lexed.tokens : null,
+        commands: commands.map((command) => ({
+            id: command.id,
+            aliases: command.aliases,
+            number: command.number,
+        })),
+        schemas: invocationSchemas,
+        admitCanonical: (candidate) => admitInvocation(candidate, options),
+    });
+}
 function resolved(command, operationId, parsed, uiUxReview, tokenCount, bytes) {
     const selection = freeze({
         commandId: command.id,

package/packages/shared/dist/yolo/change-evidence.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { posix } from 'node:path';
 const SHA = /^[a-f0-9]{40}(?:[a-f0-9]{24})?$/;
-const PATH = /^[A-Za-z0-9_.-][A-Za-z0-9_./ -]{0,239}$/;
+const PATH = /^[A-Za-z0-9_.\[\]-][A-Za-z0-9_./ \[\]-]{0,239}$/;
 const UNSAFE = /(^|\/)(?:\.env(?:\.|$)|secrets?|credentials?|private-prompts?|customer-data)(?:\/|$)|(?:token|password|license[_-]?key|secret)[=:]/i;
 function digest(paths) {
     return createHash('sha256').update(JSON.stringify(paths)).digest('hex');

package/packages/shared/dist/yoloop/epic-terminal-git.js

@@ -1,4 +1,17 @@
 /** Public contracts and pure safety decisions for epic-owned terminal Git. */
+import { createHash } from 'node:crypto';
+/**
+ * P205 complete-gate budgets are declared in config/release-gates.v2.json and
+ * mirrored here so installed clients keep the same closed runtime bounds.
+ * release-gates.test.mjs prevents either side from drifting independently.
+ */
+export const P205_RELEASE_GATE_BUDGETS = Object.freeze({
+    completeGateWorstCaseMs: 45 * 60 * 1000,
+    cancellationGraceMs: 5 * 60 * 1000,
+    aggregateValidityMs: 2 * 60 * 60 * 1000,
+    terminalWorkflowMaxDurationMs: 2 * 60 * 60 * 1000,
+});
+export const P205_ROOT_INVOKE_TIMEOUT_MS = P205_RELEASE_GATE_BUDGETS.completeGateWorstCaseMs + P205_RELEASE_GATE_BUDGETS.cancellationGraceMs;
 export const EPIC_TERMINAL_GIT_REASON_CODES = Object.freeze({
     READY: 'epic-terminal-git-ready',
     ALREADY_COMPLETE: 'epic-terminal-git-already-complete',
@@ -38,6 +51,96 @@ export const EPIC_TERMINAL_GIT_REASON_CODES = Object.freeze({
     PR_BASE_GUARD_UNVERIFIABLE: 'epic-terminal-pr-base-guard-unverifiable',
     PR_MERGE_QUEUE_LOCAL_GATE_REQUIRED: 'epic-terminal-pr-merge-queue-local-gate-required',
 });
+export function epicHeadReconciliationRangeDigest(lastAcceptedCheckpointHeadSha, executionHeadSha, reconciliationCommitShas) {
+    return createHash('sha256').update([
+        'epic-head-reconciliation-range-v1',
+        lastAcceptedCheckpointHeadSha,
+        executionHeadSha,
+        ...reconciliationCommitShas,
+    ].join('\0')).digest('hex');
+}
+export function epicHeadReconciliationPathsDigest(paths) {
+    return createHash('sha256').update(paths.join('\0')).digest('hex');
+}
+export function epicHeadReconciliationInputDigest(value) {
+    return createHash('sha256').update(JSON.stringify({
+        schemaVersion: value.schemaVersion,
+        kind: value.kind,
+        producer: value.producer,
+        epicId: value.epicId,
+        executionBranch: value.executionBranch,
+        originBranch: value.originBranch,
+        graphRevision: value.graphRevision,
+        originHeadSha: value.originHeadSha,
+        lastAcceptedCheckpointHeadSha: value.lastAcceptedCheckpointHeadSha,
+        executionHeadSha: value.executionHeadSha,
+        acceptedCheckpointIds: value.acceptedCheckpointIds,
+        acceptedCheckpointHeads: value.acceptedCheckpointHeads,
+        reconciliationCommitShas: value.reconciliationCommitShas,
+        commitRangeDigest: value.commitRangeDigest,
+        changedPaths: value.changedPaths,
+        changedPathsDigest: value.changedPathsDigest,
+        allowedWriteSet: value.allowedWriteSet,
+        allowedWriteSetDigest: value.allowedWriteSetDigest,
+        aggregateReceiptRef: value.aggregateReceiptRef,
+        aggregateManifestDigest: value.aggregateManifestDigest,
+        aggregateResultDigest: value.aggregateResultDigest,
+        producedAt: value.producedAt,
+        revalidatedAt: value.revalidatedAt,
+        publicSafe: value.publicSafe,
+    })).digest('hex');
+}
+export function validateEpicHeadReconciliationReceipt(value, expected) {
+    if (!value || value.schemaVersion !== 1 || value.kind !== 'epic_head_reconciliation'
+        || value.producer !== 'client-p205-head-reconciliation-v1' || value.publicSafe !== true
+        || !nonEmpty(value.epicId) || !nonEmpty(value.executionBranch) || !nonEmpty(value.originBranch)
+        || !Array.isArray(value.acceptedCheckpointIds) || !Array.isArray(value.acceptedCheckpointHeads)
+        || !Array.isArray(value.reconciliationCommitShas) || !Array.isArray(value.changedPaths)
+        || !Array.isArray(value.allowedWriteSet)
+        || value.epicId !== expected.epicId || value.executionBranch !== expected.executionBranch
+        || value.originBranch !== expected.originBranch || value.graphRevision !== expected.graphRevision
+        || value.originHeadSha !== expected.originHeadSha || value.executionHeadSha !== expected.executionHeadSha
+        || value.lastAcceptedCheckpointHeadSha !== expected.acceptedCheckpointHeads.at(-1)
+        || !sameOrdered(value.acceptedCheckpointIds, expected.acceptedCheckpointIds)
+        || !sameOrdered(value.acceptedCheckpointHeads, expected.acceptedCheckpointHeads)
+        || value.aggregateReceiptRef !== expected.aggregateQaReceipt.receiptRef
+        || value.aggregateManifestDigest !== expected.aggregateQaReceipt.manifestDigest
+        || value.aggregateResultDigest !== expected.aggregateQaReceipt.resultDigest
+        || !nonEmpty(value.aggregateReceiptRef) || !isHash(value.aggregateManifestDigest)
+        || !isHash(value.aggregateResultDigest) || !nonEmpty(value.producedAt) || !nonEmpty(value.revalidatedAt)
+        || value.acceptedCheckpointIds.length === 0 || value.acceptedCheckpointIds.length > 2_048
+        || value.acceptedCheckpointIds.some((id) => !nonEmpty(id) || id.length > 240)
+        || value.reconciliationCommitShas.length > 2_048
+        || value.changedPaths.length > 2_048
+        || value.allowedWriteSet.length === 0 || value.allowedWriteSet.length > 2_048
+        || (value.lastAcceptedCheckpointHeadSha !== value.executionHeadSha
+            && (value.reconciliationCommitShas.length === 0 || value.changedPaths.length === 0))
+        || (value.lastAcceptedCheckpointHeadSha === value.executionHeadSha
+            && (value.reconciliationCommitShas.length !== 0 || value.changedPaths.length !== 0))
+        || !isFullSha(value.originHeadSha) || !isFullSha(value.lastAcceptedCheckpointHeadSha)
+        || !isFullSha(value.executionHeadSha) || !isHash(value.graphRevision)
+        || value.acceptedCheckpointHeads.some((sha) => !isFullSha(sha))
+        || value.reconciliationCommitShas.some((sha) => !isFullSha(sha))
+        || !sameOrdered(value.changedPaths, [...new Set(value.changedPaths)].sort())
+        || !sameOrdered(value.allowedWriteSet, [...new Set(value.allowedWriteSet)].sort())
+        || value.changedPaths.some((path) => !safeRepositoryPath(path))
+        || value.allowedWriteSet.some((path) => !safeWriteScope(path))
+        || value.changedPaths.some((path) => !value.allowedWriteSet.some((scope) => writeScopeCovers(scope, path)))
+        || value.commitRangeDigest !== epicHeadReconciliationRangeDigest(value.lastAcceptedCheckpointHeadSha, value.executionHeadSha, value.reconciliationCommitShas)
+        || value.changedPathsDigest !== epicHeadReconciliationPathsDigest(value.changedPaths)
+        || value.allowedWriteSetDigest !== epicHeadReconciliationPathsDigest(value.allowedWriteSet)
+        || value.inputDigest !== epicHeadReconciliationInputDigest(value)
+        || !isHash(value.commitRangeDigest) || !isHash(value.changedPathsDigest)
+        || !isHash(value.allowedWriteSetDigest) || !isHash(value.inputDigest))
+        return false;
+    const producedAt = Date.parse(value.producedAt);
+    const revalidatedAt = Date.parse(value.revalidatedAt);
+    const now = Date.parse(expected.nowIso);
+    return Number.isFinite(producedAt) && Number.isFinite(revalidatedAt) && Number.isFinite(now)
+        && revalidatedAt >= producedAt
+        && now - revalidatedAt <= P205_RELEASE_GATE_BUDGETS.aggregateValidityMs
+        && revalidatedAt - now <= P205_RELEASE_GATE_BUDGETS.cancellationGraceMs;
+}
 export function validateEpicTerminalGitDirective(directive, actual) {
     const reasons = [];
     if (!nonEmpty(directive.originBranch))
@@ -76,8 +179,8 @@ export function validateEpicTerminalGitDirective(directive, actual) {
         || !directive.localGates.receiptRefs.includes(aggregate.receiptRef)) {
         reasons.push(EPIC_TERMINAL_GIT_REASON_CODES.AGGREGATE_QA_REQUIRED);
     }
-    else if (!Number.isFinite(Date.parse(aggregate.checkedAt)) || actual.nowIso && (Date.parse(actual.nowIso) - Date.parse(aggregate.checkedAt) > 30 * 60 * 1000
-        || Date.parse(aggregate.checkedAt) - Date.parse(actual.nowIso) > 5 * 60 * 1000)) {
+    else if (!Number.isFinite(Date.parse(aggregate.checkedAt)) || actual.nowIso && (Date.parse(actual.nowIso) - Date.parse(aggregate.checkedAt) > P205_RELEASE_GATE_BUDGETS.aggregateValidityMs
+        || Date.parse(aggregate.checkedAt) - Date.parse(actual.nowIso) > P205_RELEASE_GATE_BUDGETS.cancellationGraceMs)) {
         reasons.push(EPIC_TERMINAL_GIT_REASON_CODES.AGGREGATE_QA_STALE);
     }
     const originBinding = actual.originBinding;
@@ -90,6 +193,24 @@ export function validateEpicTerminalGitDirective(directive, actual) {
         || !Number.isFinite(Date.parse(originBinding.capturedAt))) {
         reasons.push(EPIC_TERMINAL_GIT_REASON_CODES.ORIGIN_BINDING_REQUIRED);
     }
+    const directedReconciliation = directive.localGates?.headReconciliationReceipt;
+    const actualReconciliation = actual.headReconciliationReceipt;
+    if (directedReconciliation && (!actualReconciliation || !originBinding || !aggregate
+        || directedReconciliation.inputDigest !== actualReconciliation.inputDigest
+        || !validateEpicHeadReconciliationReceipt(actualReconciliation, {
+            epicId: directive.epicId,
+            executionBranch: directive.executionBranch,
+            originBranch: directive.originBranch,
+            graphRevision: directive.graphRevision,
+            originHeadSha: originBinding.originHeadSha,
+            executionHeadSha: actual.executionHeadSha,
+            acceptedCheckpointIds: actual.acceptedCheckpointIds,
+            acceptedCheckpointHeads: actualReconciliation.acceptedCheckpointHeads,
+            aggregateQaReceipt: aggregate,
+            nowIso: actual.nowIso ?? new Date(0).toISOString(),
+        }))) {
+        reasons.push(EPIC_TERMINAL_GIT_REASON_CODES.AGGREGATE_QA_REQUIRED);
+    }
     if (actual.writerLeaseActive)
         reasons.push(EPIC_TERMINAL_GIT_REASON_CODES.LEASE_ACTIVE);
     if (!sameSet(directive.storyCheckpointIds, actual.acceptedCheckpointIds)) {
@@ -220,6 +341,9 @@ function nonEmpty(value) {
 function isSha(value) {
     return /^[a-f0-9]{7,64}$/i.test(value);
 }
+function isFullSha(value) {
+    return /^[a-f0-9]{40,64}$/i.test(value);
+}
 function isHash(value) {
     return typeof value === 'string' && /^[a-f0-9]{64}$/i.test(value);
 }
@@ -229,3 +353,21 @@ function unique(values) {
 function sameSet(left, right) {
     return left.length === right.length && [...left].sort().every((item, index) => item === [...right].sort()[index]);
 }
+function sameOrdered(left, right) {
+    return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+function safeRepositoryPath(value) {
+    return safeWriteScope(value) && !value.endsWith('/');
+}
+function safeWriteScope(value) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 512
+        || value.startsWith('/') || value.startsWith('-') || value.includes('\\')
+        || value.includes('\0') || value.includes('//'))
+        return false;
+    const parts = value.replace(/\/$/, '').split('/');
+    return parts.length > 0 && parts.every((part) => part.length > 0 && part !== '.' && part !== '..')
+        && parts[0] !== '.git';
+}
+function writeScopeCovers(scope, path) {
+    return scope === path || scope.endsWith('/') && path.startsWith(scope);
+}

package/targets-stubs/antigravity/gemini.md

@@ -1,4 +1,4 @@
-# 🧠 Neocortex v4.60.73 | OrNexus Team
+# 🧠 Neocortex v4.60.75 | 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.73 | OrNexus Team"
+description: "🧠 Neocortex v4.60.75 | OrNexus Team"
 ---
 
 <!--

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.73'
+    version: '4.60.75'
     architecture: 'thin-client'
     module: stand-alone
     hasSidecar: false

package/targets-stubs/claude-code/neocortex-root.md

@@ -1,6 +1,6 @@
 ---
 name: neocortex-root
-description: "🧠 Neocortex Root Agent v4.60.73 | OrNexus Team"
+description: "🧠 Neocortex Root Agent v4.60.75 | OrNexus Team"
 model: opus
 color: blue
 tools:
@@ -108,7 +108,7 @@ SEMPRE que este agente for invocado, imprima o banner abaixo como PRIMEIRO outpu
 ┌────────────────────────────────────────────────────────────┐
 │                                                            │
 │       #######           N E O C O R T E X                  │
-│      ###  ########      v4.60.73                           │
+│      ###  ########      v4.60.75                           │
 │ #########      #####                                       │
 │ ##    ##############    Development Orchestrator           │
 │ ##   ###  ######  ##    OrNexus Team                       │

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

@@ -4,7 +4,7 @@ agent:
     name: 'Neocortex'
     title: 'Development Orchestrator'
     icon: '>'
-    version: '4.60.73'
+    version: '4.60.75'
     architecture: 'thin-client'
     module: stand-alone
     hasSidecar: false

package/targets-stubs/claude-code/neocortex.md

@@ -1,6 +1,6 @@
 ---
 name: neocortex
-description: "🧠 Neocortex v4.60.73 | OrNexus Team"
+description: "🧠 Neocortex v4.60.75 | OrNexus Team"
 model: opus
 color: blue
 permissionMode: bypassPermissions
@@ -104,7 +104,7 @@ SEMPRE que este agente for invocado, imprima o banner abaixo como PRIMEIRO outpu
 ┌────────────────────────────────────────────────────────────┐
 │                                                            │
 │       #######           N E O C O R T E X                  │
-│      ###  ########      v4.60.73                           │
+│      ###  ########      v4.60.75                           │
 │ #########      #####                                       │
 │ ##    ##############    Development Orchestrator           │
 │ ##   ###  ######  ##    OrNexus Team                       │