codex-workflow-v2 2.0.0-alpha.4 → 2.0.0-alpha.6

package/dist/src/alpha6/adoption.js

@@ -0,0 +1,920 @@
+import { PROTOCOL_VERSION, STATE_SCHEMA_VERSION } from '../contracts.js';
+import { WorkflowError } from '../errors.js';
+import { createUlid } from '../ulid.js';
+import { assertHash64, canonicalJsonStringify, computeSidecarEventHash, sha256Hex, } from './store-sidecars.js';
+const ADOPTION_POSTURE_SIDECAR = 'adoption-posture.jsonl';
+const ACTIVE_TASK_BASELINE_STATUSES = new Set([
+    'planning',
+    'awaiting_execution_authorization',
+    'ready',
+    'in_progress',
+    'validating',
+    'needs_fix',
+    'awaiting_final_acceptance',
+    'ready_to_merge',
+    'merging',
+    'blocked',
+]);
+const EVENT_TYPES = new Set(['project-registration', 'adoption-apply']);
+export function readCurrentAdoptionPosture(store, projectId) {
+    const sidecarPath = store.projectSidecarPath(projectId, ADOPTION_POSTURE_SIDECAR);
+    const events = store.readSidecarEvents(store.projectRoot(projectId), ADOPTION_POSTURE_SIDECAR, {
+        validateEvent: (event, context) => validateAdoptionPostureEvent(event, projectId, context.file, context.line),
+    });
+    validateAdoptionPostureHistory(events, projectId, sidecarPath);
+    return events.at(-1) ?? null;
+}
+export function status(input, currentPosture) {
+    const prepared = buildAdoptionPreparation(input, currentPosture);
+    return {
+        status: prepared.status,
+        safe: prepared.safe,
+        blockers: prepared.blockers,
+        currentPosture: prepared.currentPosture,
+        baselineDigestHash: prepared.baselineDigestHash,
+        sidecarBaselineHash: prepared.sidecarBaselineHash,
+    };
+}
+export function buildAdoptionPreparation(input, currentPosture) {
+    const normalized = normalizePreparationInput(input);
+    const posture = currentPosture ?? null;
+    const sidecarBaselineHash = computeSidecarBaselineHash(normalized.sidecarInventory);
+    const terminalMilestones = normalized.milestones
+        .filter((milestone) => milestone.status === 'accepted' || milestone.status === 'cancelled')
+        .map((milestone) => ({
+        milestoneId: milestone.id,
+        revision: milestone.revision,
+        status: milestone.status,
+    }))
+        .sort(compareById('milestoneId'));
+    const terminalTasks = normalized.tasks
+        .filter((task) => task.status === 'merged' || task.status === 'cancelled')
+        .map((task) => ({
+        taskId: task.id,
+        revision: task.revision,
+        status: task.status,
+    }))
+        .sort(compareById('taskId'));
+    const activeTasks = normalized.tasks
+        .filter((task) => ACTIVE_TASK_BASELINE_STATUSES.has(task.status))
+        .map((task) => buildActiveTaskBaseline(task))
+        .sort(compareById('taskId'));
+    const tasksSummary = normalized.tasks
+        .map((task) => ({ taskId: task.id, revision: task.revision, status: task.status }))
+        .sort(compareById('taskId'));
+    const milestonesSummary = normalized.milestones
+        .map((milestone) => ({ milestoneId: milestone.id, revision: milestone.revision, status: milestone.status }))
+        .sort(compareById('milestoneId'));
+    const adoptionBoundaryAt = normalized.now.toISOString();
+    const baselineDigestHash = sha256Hex(canonicalJsonStringify({
+        version: 'alpha6-adoption-baseline-v1',
+        projectId: normalized.projectId,
+        repositoryIdentity: normalized.repositoryIdentity,
+        packageVersion: normalized.packageVersion,
+        protocolVersion: normalized.protocolVersion,
+        stateSchemaVersion: normalized.stateSchemaVersion,
+        sidecarBaselineHash,
+        terminalMilestones,
+        terminalTasks,
+        activeTasks,
+        tasksSummary,
+        milestonesSummary,
+    }));
+    if (posture) {
+        assertAdoptionBaselinePreserved(posture, normalized.tasks, normalized.milestones);
+        return {
+            status: 'applied',
+            safe: normalized.blockers.length === 0,
+            blockers: normalized.blockers,
+            currentPosture: posture,
+            baselineDigestHash,
+            sidecarBaselineHash,
+            confirmationCodeBindingHash: null,
+            confirmationCode: null,
+            candidateEvent: null,
+        };
+    }
+    const candidateEvent = createAdoptionPostureEvent({
+        eventType: 'adoption-apply',
+        actor: null,
+        packageVersion: normalized.packageVersion,
+        projectId: normalized.projectId,
+        protocolVersion: normalized.protocolVersion,
+        stateSchemaVersion: normalized.stateSchemaVersion,
+        adoptionBoundaryAt,
+        baselineDigestHash,
+        sidecarBaselineHash,
+        repositoryIdentity: normalized.repositoryIdentity,
+        terminalMilestones,
+        terminalTasks,
+        activeTasks,
+        previousEventHash: null,
+        now: normalized.now,
+        confirmationCodeBindingHash: null,
+    });
+    const bindingHash = computeAdoptionConfirmationBindingHash(candidateEvent);
+    candidateEvent.confirmationCodeBindingHash = bindingHash;
+    candidateEvent.eventHash = computeSidecarEventHash(candidateEvent);
+    return {
+        status: normalized.blockers.length === 0 ? 'ready' : 'missing',
+        safe: normalized.blockers.length === 0,
+        blockers: normalized.blockers,
+        currentPosture: null,
+        baselineDigestHash,
+        sidecarBaselineHash,
+        confirmationCodeBindingHash: bindingHash,
+        confirmationCode: adoptionConfirmationCode(bindingHash),
+        candidateEvent,
+    };
+}
+export function initializeProjectRegistrationAdoption(store, input) {
+    const normalized = normalizeProjectRegistrationInput(input);
+    const current = readCurrentAdoptionPosture(store, normalized.projectId);
+    if (current)
+        return current;
+    const event = buildProjectRegistrationAdoptionEvent({
+        projectId: normalized.projectId,
+        repositoryIdentity: normalized.repositoryIdentity,
+        packageVersion: normalized.packageVersion,
+        protocolVersion: normalized.protocolVersion,
+        stateSchemaVersion: normalized.stateSchemaVersion,
+        tasks: [],
+        milestones: [],
+        sidecarInventory: [],
+        blockers: [],
+        now: normalized.now,
+    });
+    return store.appendSidecarEvent(store.projectRoot(normalized.projectId), ADOPTION_POSTURE_SIDECAR, event, {
+        validateEvent: (candidate, context) => validateAdoptionPostureEvent(candidate, normalized.projectId, context.file, context.line),
+    });
+}
+export function applyAdoptionPosture(store, input, actor, confirmationCode) {
+    const normalizedActor = normalizeHumanActor(actor, 'Adoption apply actor');
+    const currentPosture = readCurrentAdoptionPosture(store, input.projectId);
+    if (currentPosture) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `Project ${input.projectId} already has an adoption posture.`, {
+            projectId: input.projectId,
+            eventType: currentPosture.eventType,
+            eventId: currentPosture.eventId,
+        });
+    }
+    const prepared = buildAdoptionPreparation(input, currentPosture);
+    if (prepared.status === 'applied' || !prepared.candidateEvent || !prepared.confirmationCodeBindingHash || !prepared.confirmationCode) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `Project ${input.projectId} does not have a pending adoption candidate.`, {
+            projectId: input.projectId,
+            status: prepared.status,
+        });
+    }
+    if (prepared.blockers.length > 0) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Alpha.6 adoption apply requires a safe boundary.', {
+            projectId: input.projectId,
+            blockers: prepared.blockers,
+        });
+    }
+    if (confirmationCode.trim() !== prepared.confirmationCode) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Adoption confirmation does not match the current project baseline.', {
+            projectId: input.projectId,
+            expectedConfirmationCode: prepared.confirmationCode,
+            actualConfirmationCode: confirmationCode.trim(),
+            confirmationCodeBindingHash: prepared.confirmationCodeBindingHash,
+        });
+    }
+    const event = {
+        ...prepared.candidateEvent,
+        adoptionBoundaryAt: input.now.toISOString(),
+        recordedAt: input.now.toISOString(),
+        actor: normalizedActor,
+        confirmationCodeBindingHash: prepared.confirmationCodeBindingHash,
+    };
+    event.eventHash = computeSidecarEventHash(event);
+    const projectRoot = store.projectRoot(input.projectId);
+    return store.appendSidecarEvent(projectRoot, ADOPTION_POSTURE_SIDECAR, event, {
+        validateEvent: (candidate, context) => validateAdoptionPostureEvent(candidate, input.projectId, context.file, context.line),
+    });
+}
+export function buildProjectRegistrationAdoptionEvent(input) {
+    const normalized = normalizePreparationInput(input);
+    const currentPosture = null;
+    const prepared = buildAdoptionPreparation(normalized, currentPosture);
+    if (prepared.currentPosture) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `Project ${normalized.projectId} already has an adoption posture sidecar.`, {
+            projectId: normalized.projectId,
+        });
+    }
+    return createAdoptionPostureEvent({
+        eventType: 'project-registration',
+        actor: null,
+        packageVersion: normalized.packageVersion,
+        projectId: normalized.projectId,
+        protocolVersion: normalized.protocolVersion,
+        stateSchemaVersion: normalized.stateSchemaVersion,
+        adoptionBoundaryAt: normalized.now.toISOString(),
+        baselineDigestHash: prepared.baselineDigestHash,
+        sidecarBaselineHash: prepared.sidecarBaselineHash,
+        repositoryIdentity: normalized.repositoryIdentity,
+        terminalMilestones: [],
+        terminalTasks: [],
+        activeTasks: [],
+        previousEventHash: null,
+        now: normalized.now,
+        confirmationCodeBindingHash: null,
+    });
+}
+export function assertAdoptionBaselinePreserved(posture, tasks, milestones) {
+    const tasksById = new Map(tasks.map((task) => [task.id, task]));
+    const milestonesById = new Map(milestones.map((milestone) => [milestone.id, milestone]));
+    for (const terminalMilestone of posture.terminalMilestones) {
+        const current = milestonesById.get(terminalMilestone.milestoneId);
+        if (!current || current.revision !== terminalMilestone.revision || current.status !== terminalMilestone.status) {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption posture terminal Milestone baseline no longer matches canonical state.', {
+                milestoneId: terminalMilestone.milestoneId,
+                expectedRevision: terminalMilestone.revision,
+                actualRevision: current?.revision ?? null,
+                expectedStatus: terminalMilestone.status,
+                actualStatus: current?.status ?? null,
+            });
+        }
+    }
+    for (const terminalTask of posture.terminalTasks) {
+        const current = tasksById.get(terminalTask.taskId);
+        if (!current || current.revision !== terminalTask.revision || current.status !== terminalTask.status) {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption posture terminal Task baseline no longer matches canonical state.', {
+                taskId: terminalTask.taskId,
+                expectedRevision: terminalTask.revision,
+                actualRevision: current?.revision ?? null,
+                expectedStatus: terminalTask.status,
+                actualStatus: current?.status ?? null,
+            });
+        }
+    }
+    for (const baseline of posture.activeTasks) {
+        const current = tasksById.get(baseline.taskId);
+        if (!current) {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption posture active Task baseline no longer matches canonical state.', {
+                taskId: baseline.taskId,
+            });
+        }
+        for (const completed of baseline.completedSteps) {
+            const step = current.steps.find((candidate) => candidate.id === completed.stepId);
+            if (!step) {
+                throw new WorkflowError('STATE_CORRUPT', 'Adoption posture completed Step baseline is missing from the current Task.', {
+                    taskId: baseline.taskId,
+                    stepId: completed.stepId,
+                });
+            }
+            if (step.status !== completed.status) {
+                throw new WorkflowError('STATE_CORRUPT', 'Adoption posture completed Step baseline status no longer matches the current Task.', {
+                    taskId: baseline.taskId,
+                    stepId: completed.stepId,
+                    expectedStatus: completed.status,
+                    actualStatus: step.status,
+                });
+            }
+            const actualEvidenceHash = step.evidence ? sha256Hex(canonicalJsonStringify(step.evidence)) : null;
+            if (actualEvidenceHash !== completed.evidenceHash) {
+                throw new WorkflowError('STATE_CORRUPT', 'Adoption posture completed Step evidence hash no longer matches the current Task.', {
+                    taskId: baseline.taskId,
+                    stepId: completed.stepId,
+                    expectedEvidenceHash: completed.evidenceHash,
+                    actualEvidenceHash,
+                });
+            }
+        }
+    }
+}
+function validateAdoptionPostureEvent(event, expectedProjectId, file, line) {
+    assertPlainObject(event, 'Adoption posture event', file, line);
+    assertExactKeys(event, [
+        'eventId',
+        'projectId',
+        'eventType',
+        'actor',
+        'packageVersion',
+        'protocolVersion',
+        'stateSchemaVersion',
+        'adoptionBoundaryAt',
+        'baselineDigestHash',
+        'sidecarBaselineHash',
+        'confirmationCodeBindingHash',
+        'repositoryIdentity',
+        'terminalMilestones',
+        'terminalTasks',
+        'activeTasks',
+        'previousEventHash',
+        'recordedAt',
+        'eventHash',
+    ], 'Adoption posture event contains unexpected fields.', file, line);
+    requireNonEmptyString(event.eventId, 'Adoption posture eventId', { file, line });
+    if (event.projectId !== expectedProjectId) {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption posture event project binding does not match its project root.', {
+            file,
+            line,
+            expectedProjectId,
+            actualProjectId: event.projectId,
+            eventId: event.eventId,
+        });
+    }
+    if (!EVENT_TYPES.has(event.eventType)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption posture eventType is invalid.', {
+            file,
+            line,
+            eventId: event.eventId,
+            eventType: event.eventType,
+        });
+    }
+    requireNonEmptyString(event.packageVersion, 'Adoption posture packageVersion', { file, line, eventId: event.eventId });
+    if (event.protocolVersion !== PROTOCOL_VERSION) {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption posture protocolVersion is invalid.', {
+            file,
+            line,
+            eventId: event.eventId,
+            protocolVersion: event.protocolVersion,
+        });
+    }
+    if (event.stateSchemaVersion !== STATE_SCHEMA_VERSION) {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption posture stateSchemaVersion is invalid.', {
+            file,
+            line,
+            eventId: event.eventId,
+            stateSchemaVersion: event.stateSchemaVersion,
+        });
+    }
+    requireIsoTimestamp(event.adoptionBoundaryAt, 'Adoption posture adoptionBoundaryAt', { file, line, eventId: event.eventId });
+    requireIsoTimestamp(event.recordedAt, 'Adoption posture recordedAt', { file, line, eventId: event.eventId });
+    if (typeof event.baselineDigestHash !== 'string') {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption posture baselineDigestHash must be sha256.', {
+            file,
+            line,
+            eventId: event.eventId,
+        });
+    }
+    if (typeof event.sidecarBaselineHash !== 'string') {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption posture sidecarBaselineHash must be sha256.', {
+            file,
+            line,
+            eventId: event.eventId,
+        });
+    }
+    assertHash64(event.baselineDigestHash, 'Adoption posture baselineDigestHash');
+    assertHash64(event.sidecarBaselineHash, 'Adoption posture sidecarBaselineHash');
+    if (event.confirmationCodeBindingHash !== null) {
+        if (typeof event.confirmationCodeBindingHash !== 'string') {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption posture confirmationCodeBindingHash must be null or sha256.', {
+                file,
+                line,
+                eventId: event.eventId,
+            });
+        }
+        assertHash64(event.confirmationCodeBindingHash, 'Adoption posture confirmationCodeBindingHash');
+    }
+    if (event.previousEventHash !== null) {
+        if (typeof event.previousEventHash !== 'string') {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption posture previousEventHash must be null or sha256.', {
+                file,
+                line,
+                eventId: event.eventId,
+            });
+        }
+        assertHash64(event.previousEventHash, 'Adoption posture previousEventHash');
+    }
+    if (typeof event.eventHash !== 'string') {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption posture eventHash must be sha256.', {
+            file,
+            line,
+            eventId: event.eventId,
+        });
+    }
+    assertHash64(event.eventHash, 'Adoption posture eventHash');
+    validateRepositoryIdentity(event.repositoryIdentity, file, line, event.eventId);
+    validateTerminalMilestones(event, file, line);
+    validateTerminalTasks(event, file, line);
+    validateActiveTasks(event, file, line);
+    if (event.eventType === 'project-registration') {
+        if (event.actor !== null || event.confirmationCodeBindingHash !== null) {
+            throw new WorkflowError('STATE_CORRUPT', 'Project registration adoption posture must not record actor or confirmation binding.', {
+                file,
+                line,
+                eventId: event.eventId,
+            });
+        }
+    }
+    else if (event.actor === null) {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption apply posture must record the human actor.', {
+            file,
+            line,
+            eventId: event.eventId,
+        });
+    }
+    else {
+        validateStoredHumanActor(event.actor, 'Adoption apply actor', {
+            file,
+            line,
+            eventId: event.eventId,
+        });
+        if (event.confirmationCodeBindingHash === null) {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption apply posture must record confirmationCodeBindingHash.', {
+                file,
+                line,
+                eventId: event.eventId,
+            });
+        }
+    }
+}
+function validateAdoptionPostureHistory(events, projectId, file) {
+    let seenApply = false;
+    for (const [index, event] of events.entries()) {
+        const previous = index > 0 ? events[index - 1] : null;
+        if (!previous) {
+            if (event.previousEventHash !== null) {
+                throw new WorkflowError('STATE_CORRUPT', `Adoption posture first event must not have previousEventHash: ${file}`, {
+                    line: index + 1,
+                    eventId: event.eventId,
+                });
+            }
+        }
+        else {
+            if (event.previousEventHash !== previous.eventHash) {
+                throw new WorkflowError('STATE_CORRUPT', `Adoption posture chain is broken: ${file}`, {
+                    line: index + 1,
+                    eventId: event.eventId,
+                    previousEventId: previous.eventId,
+                });
+            }
+            if (event.projectId !== previous.projectId) {
+                throw new WorkflowError('STATE_CORRUPT', `Adoption posture project changed across history: ${file}`, {
+                    line: index + 1,
+                    projectId,
+                    eventId: event.eventId,
+                });
+            }
+            if (previous.eventType === 'adoption-apply') {
+                throw new WorkflowError('STATE_CORRUPT', `Adoption posture cannot append events after adoption-apply: ${file}`, {
+                    line: index + 1,
+                    eventId: event.eventId,
+                    previousEventId: previous.eventId,
+                });
+            }
+            if (event.eventType === 'project-registration') {
+                throw new WorkflowError('STATE_CORRUPT', `Adoption posture cannot append a later project-registration event: ${file}`, {
+                    line: index + 1,
+                    eventId: event.eventId,
+                });
+            }
+        }
+        if (event.eventType === 'adoption-apply')
+            seenApply = true;
+        if (seenApply && index !== events.length - 1) {
+            throw new WorkflowError('STATE_CORRUPT', `Adoption posture cannot contain events after adoption-apply: ${file}`, {
+                line: index + 1,
+                eventId: event.eventId,
+            });
+        }
+        if (event.eventType === 'adoption-apply') {
+            const expectedBinding = computeAdoptionConfirmationBindingHash(event);
+            if (event.confirmationCodeBindingHash !== expectedBinding) {
+                throw new WorkflowError('STATE_CORRUPT', 'Adoption posture confirmationCodeBindingHash is inconsistent.', {
+                    line: index + 1,
+                    eventId: event.eventId,
+                    expectedBindingHash: expectedBinding,
+                    actualBindingHash: event.confirmationCodeBindingHash,
+                });
+            }
+        }
+    }
+}
+function createAdoptionPostureEvent(options) {
+    const event = {
+        eventId: `ADO-${createUlid(options.now.getTime())}`,
+        projectId: options.projectId,
+        eventType: options.eventType,
+        actor: options.actor,
+        packageVersion: options.packageVersion,
+        protocolVersion: options.protocolVersion,
+        stateSchemaVersion: options.stateSchemaVersion,
+        adoptionBoundaryAt: options.adoptionBoundaryAt,
+        baselineDigestHash: options.baselineDigestHash,
+        sidecarBaselineHash: options.sidecarBaselineHash,
+        confirmationCodeBindingHash: options.confirmationCodeBindingHash,
+        repositoryIdentity: options.repositoryIdentity,
+        terminalMilestones: options.terminalMilestones,
+        terminalTasks: options.terminalTasks,
+        activeTasks: options.activeTasks,
+        previousEventHash: options.previousEventHash,
+        recordedAt: options.now.toISOString(),
+        eventHash: '',
+    };
+    event.eventHash = computeSidecarEventHash(event);
+    return event;
+}
+function computeAdoptionConfirmationBindingHash(event) {
+    return sha256Hex(canonicalJsonStringify(adoptionConfirmationProjection(event)));
+}
+function adoptionConfirmationCode(bindingHash) {
+    return `ADA-${bindingHash.slice(0, 24).toUpperCase()}`;
+}
+function buildActiveTaskBaseline(task) {
+    const stepIds = task.steps.map((step) => step.id);
+    assertUniqueStrings(stepIds, 'Task Step ids must be unique for adoption baseline.', {
+        taskId: task.id,
+        stepIds,
+    });
+    const completedSteps = task.steps
+        .filter((step) => step.status === 'completed' || step.status === 'skipped')
+        .map((step) => ({
+        stepId: step.id,
+        status: step.status,
+        evidenceHash: step.evidence ? sha256Hex(canonicalJsonStringify(step.evidence)) : null,
+    }))
+        .sort(compareById('stepId'));
+    const completedStepIds = completedSteps.map((step) => step.stepId);
+    const remainingStepIds = task.steps
+        .filter((step) => step.status !== 'completed' && step.status !== 'skipped')
+        .map((step) => step.id)
+        .sort();
+    assertUniqueStrings(completedStepIds, 'Adoption completed Step ids must be unique.', {
+        taskId: task.id,
+        completedStepIds,
+    });
+    assertUniqueStrings(remainingStepIds, 'Adoption remaining Step ids must be unique.', {
+        taskId: task.id,
+        remainingStepIds,
+    });
+    const overlap = remainingStepIds.filter((stepId) => completedStepIds.includes(stepId));
+    if (overlap.length > 0) {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption task baseline cannot overlap completed and remaining Steps.', {
+            taskId: task.id,
+            overlappingStepIds: overlap,
+        });
+    }
+    return {
+        taskId: task.id,
+        taskRevision: task.revision,
+        status: task.status,
+        completedSteps,
+        remainingStepIds,
+    };
+}
+function computeSidecarBaselineHash(entries) {
+    const normalized = entries
+        .filter((entry) => entry.sidecarName !== ADOPTION_POSTURE_SIDECAR)
+        .map((entry) => normalizeSidecarInventoryEntry(entry))
+        .sort(compareInventoryEntries);
+    return sha256Hex(canonicalJsonStringify(normalized));
+}
+function normalizePreparationInput(input) {
+    requireNonEmptyString(input.projectId, 'Adoption projectId', { projectId: input.projectId });
+    requireNonEmptyString(input.packageVersion, 'Adoption packageVersion', { packageVersion: input.packageVersion });
+    if (input.protocolVersion !== PROTOCOL_VERSION) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Alpha.6 adoption helper requires protocol version 1.', {
+            protocolVersion: input.protocolVersion,
+            expectedProtocolVersion: PROTOCOL_VERSION,
+        });
+    }
+    if (input.stateSchemaVersion !== STATE_SCHEMA_VERSION) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Alpha.6 adoption helper requires canonical state schema version 2.', {
+            stateSchemaVersion: input.stateSchemaVersion,
+            expectedStateSchemaVersion: STATE_SCHEMA_VERSION,
+        });
+    }
+    if (!(input.now instanceof Date) || Number.isNaN(input.now.getTime())) {
+        throw new WorkflowError('INVALID_ARGUMENT', 'Adoption now must be a valid Date.');
+    }
+    return {
+        ...input,
+        repositoryIdentity: normalizeRepositoryIdentity(input.repositoryIdentity),
+        blockers: normalizeBlockers(input.blockers),
+        sidecarInventory: normalizeSidecarInventory(input.sidecarInventory),
+    };
+}
+function normalizeProjectRegistrationInput(input) {
+    requireInvalidArgumentNonEmptyString(input.projectId, 'Adoption projectId', { projectId: input.projectId });
+    requireInvalidArgumentNonEmptyString(input.packageVersion, 'Adoption packageVersion', { packageVersion: input.packageVersion });
+    if (input.protocolVersion !== PROTOCOL_VERSION) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Alpha.6 adoption helper requires protocol version 1.', {
+            protocolVersion: input.protocolVersion,
+            expectedProtocolVersion: PROTOCOL_VERSION,
+        });
+    }
+    if (input.stateSchemaVersion !== STATE_SCHEMA_VERSION) {
+        throw new WorkflowError('TRANSITION_BLOCKED', 'Alpha.6 adoption helper requires canonical state schema version 2.', {
+            stateSchemaVersion: input.stateSchemaVersion,
+            expectedStateSchemaVersion: STATE_SCHEMA_VERSION,
+        });
+    }
+    if (!(input.now instanceof Date) || Number.isNaN(input.now.getTime())) {
+        throw new WorkflowError('INVALID_ARGUMENT', 'Adoption now must be a valid Date.');
+    }
+    return {
+        ...input,
+        repositoryIdentity: normalizeRepositoryIdentity(input.repositoryIdentity),
+    };
+}
+function normalizeRepositoryIdentity(identity) {
+    return {
+        repositoryRoot: requireNonEmptyString(identity.repositoryRoot, 'Adoption repositoryRoot', { repositoryRoot: identity.repositoryRoot }),
+        gitCommonDir: requireNonEmptyString(identity.gitCommonDir, 'Adoption gitCommonDir', { gitCommonDir: identity.gitCommonDir }),
+    };
+}
+function normalizeSidecarInventoryEntry(entry) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        throw new WorkflowError('INVALID_ARGUMENT', 'Adoption sidecar inventory entry must be an object.');
+    }
+    if (entry.scope !== 'project' && entry.scope !== 'task' && entry.scope !== 'milestone') {
+        throw new WorkflowError('INVALID_ARGUMENT', 'Adoption sidecar inventory scope is invalid.', {
+            scope: entry.scope,
+        });
+    }
+    const ownerId = requireNonEmptyString(entry.ownerId, 'Adoption sidecar inventory ownerId', {
+        ownerId: entry.ownerId,
+        scope: entry.scope,
+    });
+    const sidecarName = requireNonEmptyString(entry.sidecarName, 'Adoption sidecar inventory sidecarName', {
+        ownerId,
+        scope: entry.scope,
+    });
+    assertHash64(entry.contentHash, 'Adoption sidecar inventory contentHash');
+    return { scope: entry.scope, ownerId, sidecarName, contentHash: entry.contentHash };
+}
+function normalizeSidecarInventory(entries) {
+    if (!Array.isArray(entries)) {
+        throw new WorkflowError('INVALID_ARGUMENT', 'Adoption sidecar inventory must be an array.');
+    }
+    const normalized = entries.map((entry) => normalizeSidecarInventoryEntry(entry));
+    const identityKeys = normalized.map((entry) => `${entry.scope}\u0000${entry.ownerId}\u0000${entry.sidecarName}`);
+    if (new Set(identityKeys).size !== identityKeys.length) {
+        throw new WorkflowError('INVALID_ARGUMENT', 'Adoption sidecar inventory contains duplicate sidecar identities.', {
+            duplicates: identityKeys,
+        });
+    }
+    return normalized;
+}
+function normalizeBlockers(blockers) {
+    if (!Array.isArray(blockers)) {
+        throw new WorkflowError('INVALID_ARGUMENT', 'Adoption blockers must be an array.');
+    }
+    return [...new Set(blockers.map((blocker) => requireNonEmptyString(blocker, 'Adoption blocker', { blocker })))].sort();
+}
+function validateRepositoryIdentity(repositoryIdentity, file, line, eventId) {
+    assertPlainObject(repositoryIdentity, 'Adoption posture repositoryIdentity', file, line);
+    assertExactKeys(repositoryIdentity, ['repositoryRoot', 'gitCommonDir'], 'Adoption posture repositoryIdentity contains unexpected fields.', file, line);
+    requireNonEmptyString(repositoryIdentity.repositoryRoot, 'Adoption posture repositoryRoot', { file, line, eventId });
+    requireNonEmptyString(repositoryIdentity.gitCommonDir, 'Adoption posture gitCommonDir', { file, line, eventId });
+}
+function validateTerminalMilestones(event, file, line) {
+    if (!Array.isArray(event.terminalMilestones)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption posture terminalMilestones must be an array.', {
+            file,
+            line,
+            eventId: event.eventId,
+        });
+    }
+    const milestoneIds = [];
+    for (const record of event.terminalMilestones) {
+        assertPlainObject(record, 'Adoption terminal Milestone record', file, line);
+        assertExactKeys(record, ['milestoneId', 'revision', 'status'], 'Adoption terminal Milestone record contains unexpected fields.', file, line);
+        milestoneIds.push(requireNonEmptyString(record.milestoneId, 'Adoption terminal Milestone milestoneId', { file, line, eventId: event.eventId }));
+        requirePositiveInteger(record.revision, 'Adoption terminal Milestone revision', { file, line, eventId: event.eventId });
+        if (record.status !== 'accepted' && record.status !== 'cancelled') {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption terminal Milestone status is invalid.', {
+                file,
+                line,
+                eventId: event.eventId,
+                status: record.status,
+            });
+        }
+    }
+    assertUniqueStrings(milestoneIds, 'Adoption terminal Milestone ids must be unique.', {
+        file,
+        line,
+        eventId: event.eventId,
+        milestoneIds,
+    });
+}
+function validateTerminalTasks(event, file, line) {
+    if (!Array.isArray(event.terminalTasks)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption posture terminalTasks must be an array.', {
+            file,
+            line,
+            eventId: event.eventId,
+        });
+    }
+    const taskIds = [];
+    for (const record of event.terminalTasks) {
+        assertPlainObject(record, 'Adoption terminal Task record', file, line);
+        assertExactKeys(record, ['taskId', 'revision', 'status'], 'Adoption terminal Task record contains unexpected fields.', file, line);
+        taskIds.push(requireNonEmptyString(record.taskId, 'Adoption terminal Task taskId', { file, line, eventId: event.eventId }));
+        requirePositiveInteger(record.revision, 'Adoption terminal Task revision', { file, line, eventId: event.eventId });
+        if (record.status !== 'merged' && record.status !== 'cancelled') {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption terminal Task status is invalid.', {
+                file,
+                line,
+                eventId: event.eventId,
+                status: record.status,
+            });
+        }
+    }
+    assertUniqueStrings(taskIds, 'Adoption terminal Task ids must be unique.', {
+        file,
+        line,
+        eventId: event.eventId,
+        taskIds,
+    });
+}
+function validateActiveTasks(event, file, line) {
+    if (!Array.isArray(event.activeTasks)) {
+        throw new WorkflowError('STATE_CORRUPT', 'Adoption posture activeTasks must be an array.', {
+            file,
+            line,
+            eventId: event.eventId,
+        });
+    }
+    const terminalTaskIds = new Set(event.terminalTasks.map((record) => record.taskId));
+    const activeTaskIds = [];
+    for (const baseline of event.activeTasks) {
+        assertPlainObject(baseline, 'Adoption active Task baseline', file, line);
+        assertExactKeys(baseline, ['taskId', 'taskRevision', 'status', 'completedSteps', 'remainingStepIds'], 'Adoption active Task baseline contains unexpected fields.', file, line);
+        const taskId = requireNonEmptyString(baseline.taskId, 'Adoption active Task baseline taskId', { file, line, eventId: event.eventId });
+        activeTaskIds.push(taskId);
+        if (terminalTaskIds.has(taskId)) {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption posture cannot classify the same Task as both terminal and active.', {
+                file,
+                line,
+                eventId: event.eventId,
+                taskId,
+            });
+        }
+        requirePositiveInteger(baseline.taskRevision, 'Adoption active Task baseline taskRevision', { file, line, eventId: event.eventId, taskId });
+        if (!ACTIVE_TASK_BASELINE_STATUSES.has(baseline.status)) {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption active Task baseline status is invalid.', {
+                file,
+                line,
+                eventId: event.eventId,
+                taskId,
+                status: baseline.status,
+            });
+        }
+        if (!Array.isArray(baseline.completedSteps)) {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption active Task baseline completedSteps must be an array.', {
+                file,
+                line,
+                eventId: event.eventId,
+                taskId,
+            });
+        }
+        if (!Array.isArray(baseline.remainingStepIds)) {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption active Task baseline remainingStepIds must be an array.', {
+                file,
+                line,
+                eventId: event.eventId,
+                taskId,
+            });
+        }
+        const completedStepIds = [];
+        for (const completed of baseline.completedSteps) {
+            assertPlainObject(completed, 'Adoption completed Step baseline', file, line);
+            assertExactKeys(completed, ['stepId', 'status', 'evidenceHash'], 'Adoption completed Step baseline contains unexpected fields.', file, line);
+            const stepId = requireNonEmptyString(completed.stepId, 'Adoption completed Step stepId', { file, line, eventId: event.eventId, taskId });
+            completedStepIds.push(stepId);
+            if (completed.status !== 'completed' && completed.status !== 'skipped') {
+                throw new WorkflowError('STATE_CORRUPT', 'Adoption completed Step status is invalid.', {
+                    file,
+                    line,
+                    eventId: event.eventId,
+                    taskId,
+                    stepId,
+                    status: completed.status,
+                });
+            }
+            if (completed.evidenceHash !== null) {
+                if (typeof completed.evidenceHash !== 'string') {
+                    throw new WorkflowError('STATE_CORRUPT', 'Adoption completed Step evidenceHash must be null or sha256.', {
+                        file,
+                        line,
+                        eventId: event.eventId,
+                        taskId,
+                        stepId,
+                    });
+                }
+                assertHash64(completed.evidenceHash, 'Adoption completed Step evidenceHash');
+            }
+        }
+        assertUniqueStrings(completedStepIds, 'Adoption completed Step ids must be unique.', {
+            file,
+            line,
+            eventId: event.eventId,
+            taskId,
+            completedStepIds,
+        });
+        const remainingStepIds = baseline.remainingStepIds.map((stepId) => requireNonEmptyString(stepId, 'Adoption remaining Step id', { file, line, eventId: event.eventId, taskId }));
+        assertUniqueStrings(remainingStepIds, 'Adoption remaining Step ids must be unique.', {
+            file,
+            line,
+            eventId: event.eventId,
+            taskId,
+            remainingStepIds,
+        });
+        const overlap = remainingStepIds.filter((stepId) => completedStepIds.includes(stepId));
+        if (overlap.length > 0) {
+            throw new WorkflowError('STATE_CORRUPT', 'Adoption active Task baseline cannot overlap completed and remaining Steps.', {
+                file,
+                line,
+                eventId: event.eventId,
+                taskId,
+                overlappingStepIds: overlap,
+            });
+        }
+    }
+    assertUniqueStrings(activeTaskIds, 'Adoption active Task ids must be unique.', {
+        file,
+        line,
+        eventId: event.eventId,
+        activeTaskIds,
+    });
+}
+function normalizeHumanActor(value, label) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new WorkflowError('INVALID_ARGUMENT', `${label} must be a non-empty string.`, { actor: value });
+    }
+    const actor = value.trim();
+    if (actor.startsWith('agent:')) {
+        throw new WorkflowError('TRANSITION_BLOCKED', `${label} must be a human actor.`, {
+            actor,
+        });
+    }
+    return actor;
+}
+function validateStoredHumanActor(value, label, context) {
+    const actor = requireNonEmptyString(value, label, context);
+    if (actor.startsWith('agent:')) {
+        throw new WorkflowError('STATE_CORRUPT', `${label} must be a human actor.`, {
+            ...context,
+            actor,
+        });
+    }
+    return actor;
+}
+function requireNonEmptyString(value, label, context) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new WorkflowError('STATE_CORRUPT', `${label} must be a non-empty string.`, context);
+    }
+    return value.trim();
+}
+function requireInvalidArgumentNonEmptyString(value, label, context) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new WorkflowError('INVALID_ARGUMENT', `${label} must be a non-empty string.`, context);
+    }
+    return value.trim();
+}
+function requireIsoTimestamp(value, label, context) {
+    const timestamp = requireNonEmptyString(value, label, context);
+    if (Number.isNaN(Date.parse(timestamp))) {
+        throw new WorkflowError('STATE_CORRUPT', `${label} must be an ISO timestamp.`, context);
+    }
+    return timestamp;
+}
+function requirePositiveInteger(value, label, context) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new WorkflowError('STATE_CORRUPT', `${label} must be a positive integer.`, context);
+    }
+    return value;
+}
+function assertPlainObject(value, label, file, line) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new WorkflowError('STATE_CORRUPT', `${label} must be an object.`, { file, line });
+    }
+}
+function assertExactKeys(record, allowedKeys, message, file, line) {
+    const allowed = new Set(allowedKeys);
+    const extraKeys = Object.keys(record).filter((key) => !allowed.has(key));
+    if (extraKeys.length > 0) {
+        throw new WorkflowError('STATE_CORRUPT', message, { file, line, extraKeys });
+    }
+}
+function assertUniqueStrings(values, message, context) {
+    if (new Set(values).size !== values.length) {
+        throw new WorkflowError('STATE_CORRUPT', message, context);
+    }
+}
+function compareInventoryEntries(left, right) {
+    return `${left.scope}\u0000${left.ownerId}\u0000${left.sidecarName}\u0000${left.contentHash}`
+        .localeCompare(`${right.scope}\u0000${right.ownerId}\u0000${right.sidecarName}\u0000${right.contentHash}`);
+}
+function compareById(key) {
+    return (left, right) => left[key].localeCompare(right[key]);
+}
+function adoptionConfirmationProjection(event) {
+    return {
+        version: 'alpha6-adoption-confirmation-v1',
+        projectId: event.projectId,
+        repositoryIdentity: event.repositoryIdentity,
+        packageVersion: event.packageVersion,
+        protocolVersion: event.protocolVersion,
+        stateSchemaVersion: event.stateSchemaVersion,
+        baselineDigestHash: event.baselineDigestHash,
+        sidecarBaselineHash: event.sidecarBaselineHash,
+        terminalMilestones: event.terminalMilestones,
+        terminalTasks: event.terminalTasks,
+        activeTasks: event.activeTasks,
+    };
+}
+//# sourceMappingURL=adoption.js.map