@soddong/agentic-domain-methodology 0.11.1

package/dist/seed-apply.js

@@ -0,0 +1,728 @@
+import { randomUUID } from "node:crypto";
+import { MethodologyService } from "./service.js";
+import { openMethodologyDatabase } from "./database.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function camelRow(row) {
+    if (row === undefined) {
+        return undefined;
+    }
+    return {
+        ...row,
+        methodologyId: row.methodology_id,
+        lifecycleId: row.lifecycle_id,
+        phaseId: row.phase_id,
+        processId: row.process_id,
+        stageId: row.stage_id,
+        activityId: row.activity_id,
+        sortOrder: row.sort_order
+    };
+}
+function asArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord);
+}
+function stringValue(value, key) {
+    const raw = value[key];
+    return typeof raw === "string" && raw.length > 0 ? raw : undefined;
+}
+function numberValue(value, key) {
+    const raw = value[key];
+    return typeof raw === "number" && Number.isFinite(raw) ? raw : undefined;
+}
+function boolValue(value, key, fallback) {
+    const raw = value[key];
+    return typeof raw === "boolean" ? raw : fallback;
+}
+function normalizeHandoffTypeCode(value) {
+    switch (value) {
+        case "artifact":
+        case "issue":
+        case "risk":
+        case "decision":
+        case "constraint":
+        case "approval":
+        case "context":
+            return value;
+        case "stage_gate":
+            return "context";
+        default:
+            return "context";
+    }
+}
+function sourceMetadata(input, payload) {
+    return {
+        seedSourcePackageName: input.sourcePackageName,
+        seedSourcePackageVersion: input.sourcePackageVersion,
+        seedBundleCode: input.bundleCode,
+        seedBundleVersion: input.bundleVersion,
+        seedSourceSection: input.sourceSection,
+        seedTargetOperation: input.targetOperation,
+        seedItemKey: input.itemKey,
+        seedPayload: payload
+    };
+}
+function methodologyVersion(input) {
+    return input.bundleVersion;
+}
+function findMethodology(db, methodologyCode, version) {
+    const row = db
+        .prepare(`SELECT *
+         FROM methodology_methodologies
+        WHERE methodology_code = ?
+          AND methodology_version = ?`)
+        .get(methodologyCode, version);
+    return camelRow(row);
+}
+function findLifecycle(db, methodologyId, lifecycleCode) {
+    const row = db
+        .prepare(`SELECT *
+         FROM methodology_lifecycles
+        WHERE methodology_id = ?
+          AND lifecycle_code = ?`)
+        .get(methodologyId, lifecycleCode);
+    return camelRow(row);
+}
+function findPhase(db, lifecycleId, phaseCode) {
+    const row = db
+        .prepare(`SELECT *
+         FROM methodology_phases
+        WHERE lifecycle_id = ?
+          AND phase_code = ?`)
+        .get(lifecycleId, phaseCode);
+    return camelRow(row);
+}
+function findPhaseByCode(db, methodologyId, phaseCode) {
+    const row = db
+        .prepare(`SELECT p.*
+         FROM methodology_phases p
+         JOIN methodology_lifecycles l ON l.lifecycle_id = p.lifecycle_id
+        WHERE l.methodology_id = ?
+          AND p.phase_code = ?
+        ORDER BY p.sort_order
+        LIMIT 1`)
+        .get(methodologyId, phaseCode);
+    return camelRow(row);
+}
+function findProcess(db, methodologyId, processCode) {
+    const row = db
+        .prepare(`SELECT *
+         FROM methodology_processes
+        WHERE methodology_id = ?
+          AND process_code = ?`)
+        .get(methodologyId, processCode);
+    return camelRow(row);
+}
+function findStage(db, processId, stageCode) {
+    const row = db
+        .prepare(`SELECT *
+         FROM methodology_stages
+        WHERE process_id = ?
+          AND stage_code = ?`)
+        .get(processId, stageCode);
+    return camelRow(row);
+}
+function findStageByCode(db, methodologyId, stageCode) {
+    const row = db
+        .prepare(`SELECT s.*
+         FROM methodology_stages s
+         JOIN methodology_processes p ON p.process_id = s.process_id
+        WHERE p.methodology_id = ?
+          AND s.stage_code = ?
+        ORDER BY s.sort_order
+        LIMIT 1`)
+        .get(methodologyId, stageCode);
+    return camelRow(row);
+}
+function findActivity(db, processId, activityCode) {
+    const row = db
+        .prepare(`SELECT *
+         FROM methodology_activities
+        WHERE process_id = ?
+          AND activity_code = ?`)
+        .get(processId, activityCode);
+    return camelRow(row);
+}
+function findActivityByCode(db, methodologyId, activityCode) {
+    const row = db
+        .prepare(`SELECT a.*
+         FROM methodology_activities a
+         JOIN methodology_processes p ON p.process_id = a.process_id
+        WHERE p.methodology_id = ?
+          AND a.activity_code = ?
+        ORDER BY a.sort_order
+        LIMIT 1`)
+        .get(methodologyId, activityCode);
+    return camelRow(row);
+}
+function createActivityCriteria(db, input) {
+    const activityCriteriaId = randomUUID();
+    db.prepare(`INSERT INTO methodology_activity_criteria
+       (activity_criteria_id, activity_id, criteria_type_code, criteria_name, criteria_text,
+        is_required, validation_required, severity_code, sort_order, metadata_json)
+     VALUES (?, ?, ?, ?, ?, 1, 1, ?, ?, ?)`).run(activityCriteriaId, input.activityId, input.criteriaTypeCode, input.criteriaName, input.criteriaText, input.severityCode ?? "error", input.sortOrder ?? 0, input.metadata === undefined ? null : JSON.stringify(input.metadata));
+    return activityCriteriaId;
+}
+function hasPhaseProcess(db, phaseId, processId) {
+    const row = db
+        .prepare(`SELECT phase_process_id
+         FROM methodology_phase_processes
+        WHERE phase_id = ?
+          AND process_id = ?`)
+        .get(phaseId, processId);
+    return row !== undefined;
+}
+function hasStageActivity(db, stageId, activityId) {
+    const row = db
+        .prepare(`SELECT stage_activity_id
+         FROM methodology_stage_activities
+        WHERE stage_id = ?
+          AND activity_id = ?`)
+        .get(stageId, activityId);
+    return row !== undefined;
+}
+function processGlobalActivitySortOrder(stage, payload) {
+    const localSortOrder = numberValue(payload, "sortOrder");
+    if (localSortOrder === undefined) {
+        return undefined;
+    }
+    return (stage.sortOrder * 1000) + localSortOrder;
+}
+function getCurrentMethodology(ctx) {
+    const methodologyCode = ctx.input.methodologyCode;
+    if (methodologyCode === undefined) {
+        return undefined;
+    }
+    return findMethodology(ctx.db, methodologyCode, methodologyVersion(ctx.input));
+}
+function blocked(message) {
+    return {
+        status: "blocked",
+        message
+    };
+}
+function applied(targetRefs, skippedCount) {
+    if (targetRefs.length === 0 && skippedCount > 0) {
+        return {
+            status: "skipped",
+            message: `All ${skippedCount} seed item(s) already exist.`
+        };
+    }
+    return {
+        status: "applied",
+        targetRefs,
+        message: skippedCount > 0 ? `${skippedCount} seed item(s) already existed.` : undefined
+    };
+}
+function applyMethodology(ctx) {
+    if (!isRecord(ctx.input.itemPayload)) {
+        return {
+            status: "failed",
+            message: "methodology payload must be an object."
+        };
+    }
+    const payload = ctx.input.itemPayload;
+    const methodologyCode = stringValue(payload, "methodologyCode");
+    const methodologyName = stringValue(payload, "methodologyName");
+    const methodologyVersionValue = methodologyVersion(ctx.input);
+    if (methodologyCode === undefined || methodologyName === undefined) {
+        return {
+            status: "failed",
+            message: "methodologyCode and methodologyName are required."
+        };
+    }
+    const existing = findMethodology(ctx.db, methodologyCode, methodologyVersionValue);
+    if (existing !== undefined) {
+        return applied([], 1);
+    }
+    const created = ctx.service.createMethodology({
+        methodologyCode,
+        methodologyName,
+        methodologyVersion: methodologyVersionValue,
+        methodologyStatusCode: stringValue(payload, "methodologyStatusCode"),
+        description: stringValue(payload, "description"),
+        metadata: sourceMetadata(ctx.input, payload)
+    });
+    return applied([`methodology:${created.methodologyCode}`], 0);
+}
+function applyLifecycle(ctx) {
+    if (!isRecord(ctx.input.itemPayload)) {
+        return {
+            status: "failed",
+            message: "lifecycle payload must be an object."
+        };
+    }
+    const methodology = getCurrentMethodology(ctx);
+    if (methodology === undefined) {
+        return blocked("Target methodology was not found for lifecycle seed.");
+    }
+    const payload = ctx.input.itemPayload;
+    const lifecycleCode = stringValue(payload, "lifecycleCode");
+    const lifecycleName = stringValue(payload, "lifecycleName");
+    if (lifecycleCode === undefined || lifecycleName === undefined) {
+        return {
+            status: "failed",
+            message: "lifecycleCode and lifecycleName are required."
+        };
+    }
+    if (findLifecycle(ctx.db, methodology.methodologyId, lifecycleCode) !== undefined) {
+        return applied([], 1);
+    }
+    const created = ctx.service.createLifecycle({
+        methodologyId: methodology.methodologyId,
+        lifecycleCode,
+        lifecycleName,
+        lifecycleTypeCode: stringValue(payload, "lifecycleTypeCode"),
+        description: stringValue(payload, "description"),
+        sortOrder: numberValue(payload, "lifecycleOrder"),
+        metadata: sourceMetadata(ctx.input, payload)
+    });
+    return applied([`lifecycle:${created.lifecycleCode}`], 0);
+}
+function applyPhases(ctx) {
+    const methodology = getCurrentMethodology(ctx);
+    if (methodology === undefined) {
+        return blocked("Target methodology was not found for phase seed.");
+    }
+    const targetRefs = [];
+    let skippedCount = 0;
+    for (const payload of asArray(ctx.input.itemPayload)) {
+        const lifecycleCode = stringValue(payload, "lifecycleCode");
+        const phaseCode = stringValue(payload, "phaseCode");
+        const phaseName = stringValue(payload, "phaseName");
+        if (lifecycleCode === undefined || phaseCode === undefined || phaseName === undefined) {
+            return {
+                status: "failed",
+                message: "phase seed requires lifecycleCode, phaseCode, and phaseName."
+            };
+        }
+        const lifecycle = findLifecycle(ctx.db, methodology.methodologyId, lifecycleCode);
+        if (lifecycle === undefined) {
+            return blocked(`Lifecycle was not found for phase seed: ${lifecycleCode}`);
+        }
+        if (findPhase(ctx.db, lifecycle.lifecycleId, phaseCode) !== undefined) {
+            skippedCount += 1;
+            continue;
+        }
+        const created = ctx.service.createPhase({
+            lifecycleId: lifecycle.lifecycleId,
+            phaseCode,
+            phaseName,
+            phasePurpose: stringValue(payload, "description"),
+            sortOrder: numberValue(payload, "phaseOrder"),
+            metadata: {
+                ...sourceMetadata(ctx.input, payload),
+                phaseTypeCode: stringValue(payload, "phaseTypeCode")
+            }
+        });
+        targetRefs.push(`phase:${created.phaseCode}`);
+    }
+    return applied(targetRefs, skippedCount);
+}
+function applyProcesses(ctx) {
+    const methodology = getCurrentMethodology(ctx);
+    if (methodology === undefined) {
+        return blocked("Target methodology was not found for process seed.");
+    }
+    const targetRefs = [];
+    let skippedCount = 0;
+    for (const payload of asArray(ctx.input.itemPayload)) {
+        const processCode = stringValue(payload, "processCode");
+        const processName = stringValue(payload, "processName");
+        const phaseCode = stringValue(payload, "phaseCode");
+        if (processCode === undefined || processName === undefined || phaseCode === undefined) {
+            return {
+                status: "failed",
+                message: "process seed requires processCode, processName, and phaseCode."
+            };
+        }
+        const phase = findPhaseByCode(ctx.db, methodology.methodologyId, phaseCode);
+        if (phase === undefined) {
+            return blocked(`Phase was not found for process seed: ${phaseCode}`);
+        }
+        const existing = findProcess(ctx.db, methodology.methodologyId, processCode);
+        const process = existing ?? ctx.service.createProcess({
+            methodologyId: methodology.methodologyId,
+            processCode,
+            processName,
+            processPurpose: stringValue(payload, "description"),
+            processTypeCode: stringValue(payload, "processTypeCode"),
+            metadata: sourceMetadata(ctx.input, payload)
+        });
+        if (!hasPhaseProcess(ctx.db, phase.phaseId, process.processId)) {
+            ctx.service.assignProcessToPhase({
+                phaseId: phase.phaseId,
+                processId: process.processId,
+                sortOrder: numberValue(payload, "processOrder"),
+                metadata: sourceMetadata(ctx.input, payload)
+            });
+        }
+        if (existing === undefined) {
+            targetRefs.push(`process:${process.processCode}`);
+        }
+        else {
+            skippedCount += 1;
+        }
+    }
+    return applied(targetRefs, skippedCount);
+}
+function applyStages(ctx) {
+    const methodology = getCurrentMethodology(ctx);
+    if (methodology === undefined) {
+        return blocked("Target methodology was not found for stage seed.");
+    }
+    const targetRefs = [];
+    let skippedCount = 0;
+    for (const payload of asArray(ctx.input.itemPayload)) {
+        const processCode = stringValue(payload, "processCode");
+        const stageCode = stringValue(payload, "stageCode");
+        const stageName = stringValue(payload, "stageName");
+        if (processCode === undefined || stageCode === undefined || stageName === undefined) {
+            return {
+                status: "failed",
+                message: "stage seed requires processCode, stageCode, and stageName."
+            };
+        }
+        const process = findProcess(ctx.db, methodology.methodologyId, processCode);
+        if (process === undefined) {
+            return blocked(`Process was not found for stage seed: ${processCode}`);
+        }
+        if (findStage(ctx.db, process.processId, stageCode) !== undefined) {
+            skippedCount += 1;
+            continue;
+        }
+        const created = ctx.service.createStage({
+            processId: process.processId,
+            stageCode,
+            stageName,
+            stageObjective: stringValue(payload, "description"),
+            stageTypeCode: stringValue(payload, "stageTypeCode"),
+            sortOrder: numberValue(payload, "stageOrder"),
+            metadata: sourceMetadata(ctx.input, payload)
+        });
+        targetRefs.push(`stage:${created.stageCode}`);
+    }
+    return applied(targetRefs, skippedCount);
+}
+function applyActivities(ctx) {
+    const methodology = getCurrentMethodology(ctx);
+    if (methodology === undefined) {
+        return blocked("Target methodology was not found for activity seed.");
+    }
+    const targetRefs = [];
+    let skippedCount = 0;
+    for (const payload of asArray(ctx.input.itemPayload)) {
+        const stageCode = stringValue(payload, "stageCode");
+        const activityCode = stringValue(payload, "activityCode");
+        const activityName = stringValue(payload, "activityName");
+        if (stageCode === undefined || activityCode === undefined || activityName === undefined) {
+            return {
+                status: "failed",
+                message: "activity seed requires stageCode, activityCode, and activityName."
+            };
+        }
+        const stage = findStageByCode(ctx.db, methodology.methodologyId, stageCode);
+        if (stage === undefined) {
+            return blocked(`Stage was not found for activity seed: ${stageCode}`);
+        }
+        const existing = findActivity(ctx.db, stage.processId, activityCode);
+        const activity = existing ?? ctx.service.createActivity({
+            processId: stage.processId,
+            activityCode,
+            activityName,
+            activityPurpose: stringValue(payload, "description"),
+            activityTypeCode: stringValue(payload, "activityTypeCode"),
+            sortOrder: processGlobalActivitySortOrder(stage, payload),
+            metadata: {
+                ...sourceMetadata(ctx.input, payload),
+                stageLocalSortOrder: numberValue(payload, "sortOrder")
+            }
+        });
+        if (!hasStageActivity(ctx.db, stage.stageId, activity.activityId)) {
+            ctx.service.assignActivityToStage({
+                stageId: stage.stageId,
+                activityId: activity.activityId,
+                sortOrder: numberValue(payload, "sortOrder"),
+                metadata: sourceMetadata(ctx.input, payload)
+            });
+        }
+        if (existing === undefined) {
+            targetRefs.push(`activity:${activity.activityCode}`);
+        }
+        else {
+            skippedCount += 1;
+        }
+    }
+    return applied(targetRefs, skippedCount);
+}
+function applyActivityArtifactRequirements(ctx) {
+    const methodology = getCurrentMethodology(ctx);
+    if (methodology === undefined) {
+        return blocked("Target methodology was not found for activity artifact requirement seed.");
+    }
+    const targetRefs = [];
+    let skippedCount = 0;
+    for (const payload of asArray(ctx.input.itemPayload)) {
+        const activityCode = stringValue(payload, "activityCode");
+        const artifactStandardCode = stringValue(payload, "artifactStandardCode");
+        const artifactStandardVersion = stringValue(payload, "artifactStandardVersion");
+        const requirementRoleCode = stringValue(payload, "requirementRoleCode");
+        if (activityCode === undefined ||
+            artifactStandardCode === undefined ||
+            artifactStandardVersion === undefined ||
+            requirementRoleCode === undefined) {
+            return {
+                status: "failed",
+                message: "activity artifact requirement seed requires activityCode, artifactStandardCode, artifactStandardVersion, and requirementRoleCode."
+            };
+        }
+        const activity = findActivityByCode(ctx.db, methodology.methodologyId, activityCode);
+        if (activity === undefined) {
+            return blocked(`Activity was not found for artifact requirement seed: ${activityCode}`);
+        }
+        const artifactComponentCode = stringValue(payload, "artifactComponentCode");
+        const existing = ctx.db
+            .prepare(`SELECT activity_artifact_requirement_id
+           FROM methodology_activity_artifact_requirements
+          WHERE activity_id = ?
+            AND artifact_standard_code = ?
+            AND artifact_standard_version = ?
+            AND requirement_role_code = ?
+            AND COALESCE(artifact_component_code, '') = ?`)
+            .get(activity.activityId, artifactStandardCode, artifactStandardVersion, requirementRoleCode, artifactComponentCode ?? "");
+        if (existing !== undefined) {
+            skippedCount += 1;
+            continue;
+        }
+        const created = ctx.service.addActivityArtifactRequirement({
+            activityId: activity.activityId,
+            artifactStandardCode,
+            artifactStandardVersion,
+            artifactComponentCode,
+            artifactComponentRoleCode: stringValue(payload, "artifactComponentRoleCode"),
+            requirementRoleCode: requirementRoleCode,
+            isPrimary: boolValue(payload, "isPrimary", false),
+            validationRequired: boolValue(payload, "validationRequired", false),
+            sortOrder: numberValue(payload, "sortOrder"),
+            metadata: {
+                ...sourceMetadata(ctx.input, payload),
+                requirementCode: stringValue(payload, "requirementCode"),
+                description: stringValue(payload, "description")
+            }
+        });
+        targetRefs.push(`activityArtifactRequirement:${created.activityArtifactRequirementId}`);
+    }
+    return applied(targetRefs, skippedCount);
+}
+function applyCriteria(ctx) {
+    const methodology = getCurrentMethodology(ctx);
+    if (methodology === undefined) {
+        return blocked("Target methodology was not found for criteria seed.");
+    }
+    const targetRefs = [];
+    let skippedCount = 0;
+    for (const payload of asArray(ctx.input.itemPayload)) {
+        const scopeTypeCode = stringValue(payload, "scopeTypeCode");
+        const scopeCode = stringValue(payload, "scopeCode");
+        const criteriaTypeCode = stringValue(payload, "criteriaTypeCode");
+        const criteriaName = stringValue(payload, "criteriaName");
+        if (scopeCode === undefined || criteriaTypeCode === undefined || criteriaName === undefined) {
+            return {
+                status: "failed",
+                message: "criteria seed requires scopeCode, criteriaTypeCode, and criteriaName."
+            };
+        }
+        if (scopeTypeCode === "activity") {
+            const activity = findActivityByCode(ctx.db, methodology.methodologyId, scopeCode);
+            if (activity === undefined) {
+                return blocked(`Activity was not found for criteria seed: ${scopeCode}`);
+            }
+            const sortOrder = numberValue(payload, "sortOrder") ?? 0;
+            const existing = ctx.db
+                .prepare(`SELECT activity_criteria_id
+             FROM methodology_activity_criteria
+            WHERE activity_id = ?
+              AND sort_order = ?`)
+                .get(activity.activityId, sortOrder);
+            if (existing !== undefined) {
+                skippedCount += 1;
+                continue;
+            }
+            const activityCriteriaId = createActivityCriteria(ctx.db, {
+                activityId: activity.activityId,
+                criteriaTypeCode,
+                criteriaName,
+                criteriaText: stringValue(payload, "description") ?? criteriaName,
+                severityCode: stringValue(payload, "severityCode"),
+                sortOrder,
+                metadata: {
+                    ...sourceMetadata(ctx.input, payload),
+                    criteriaCode: stringValue(payload, "criteriaCode"),
+                    scopeTypeCode
+                }
+            });
+            targetRefs.push(`activityCriteria:${activityCriteriaId}`);
+            continue;
+        }
+        if (scopeTypeCode !== undefined && scopeTypeCode !== "stage") {
+            return blocked(`Unsupported criteria scope type for seed apply: ${scopeTypeCode}`);
+        }
+        const stage = findStageByCode(ctx.db, methodology.methodologyId, scopeCode);
+        if (stage === undefined) {
+            return blocked(`Stage was not found for criteria seed: ${scopeCode}`);
+        }
+        const sortOrder = numberValue(payload, "sortOrder") ?? 0;
+        const existing = ctx.db
+            .prepare(`SELECT stage_criteria_id
+           FROM methodology_stage_criteria
+          WHERE stage_id = ?
+            AND criteria_type_code = ?
+            AND sort_order = ?`)
+            .get(stage.stageId, criteriaTypeCode, sortOrder);
+        if (existing !== undefined) {
+            skippedCount += 1;
+            continue;
+        }
+        const created = ctx.service.createStageCriteria({
+            stageId: stage.stageId,
+            criteriaTypeCode: criteriaTypeCode,
+            criteriaName,
+            criteriaText: stringValue(payload, "description") ?? criteriaName,
+            validationRequired: true,
+            severityCode: stringValue(payload, "severityCode"),
+            sortOrder,
+            metadata: {
+                ...sourceMetadata(ctx.input, payload),
+                criteriaCode: stringValue(payload, "criteriaCode"),
+                scopeTypeCode: stringValue(payload, "scopeTypeCode")
+            }
+        });
+        targetRefs.push(`criteria:${created.stageCriteriaId}`);
+    }
+    return applied(targetRefs, skippedCount);
+}
+function applyHandoffs(ctx) {
+    const methodology = getCurrentMethodology(ctx);
+    if (methodology === undefined) {
+        return blocked("Target methodology was not found for handoff seed.");
+    }
+    const targetRefs = [];
+    let skippedCount = 0;
+    for (const payload of asArray(ctx.input.itemPayload)) {
+        const sourceScopeCode = stringValue(payload, "sourceScopeCode");
+        const sourceCode = stringValue(payload, "sourceCode");
+        const targetScopeCode = stringValue(payload, "targetScopeCode");
+        const targetCode = stringValue(payload, "targetCode");
+        const handoffItemName = stringValue(payload, "handoffItemName");
+        if (sourceScopeCode === undefined ||
+            sourceCode === undefined ||
+            targetScopeCode === undefined ||
+            targetCode === undefined ||
+            handoffItemName === undefined) {
+            return {
+                status: "failed",
+                message: "handoff seed requires sourceScopeCode, sourceCode, targetScopeCode, targetCode, and handoffItemName."
+            };
+        }
+        if (sourceScopeCode !== "stage" || targetScopeCode !== "stage") {
+            return blocked(`Methodology seed apply currently supports stage-to-stage handoff only: ${sourceScopeCode} -> ${targetScopeCode}`);
+        }
+        const sourceStage = findStageByCode(ctx.db, methodology.methodologyId, sourceCode);
+        const targetStage = findStageByCode(ctx.db, methodology.methodologyId, targetCode);
+        if (sourceStage === undefined || targetStage === undefined) {
+            return blocked(`Stage was not found for handoff seed: ${sourceCode} -> ${targetCode}`);
+        }
+        const sortOrder = numberValue(payload, "sortOrder") ?? 0;
+        const existing = ctx.db
+            .prepare(`SELECT handoff_requirement_id
+           FROM methodology_handoff_requirements
+          WHERE source_scope_code = ?
+            AND source_ref_id = ?
+            AND target_scope_code = ?
+            AND target_ref_id = ?
+            AND sort_order = ?`)
+            .get(sourceScopeCode, sourceStage.stageId, targetScopeCode, targetStage.stageId, sortOrder);
+        if (existing !== undefined) {
+            skippedCount += 1;
+            continue;
+        }
+        const requiredArtifactStandardCodes = Array.isArray(payload.requiredArtifactStandardCodes)
+            ? payload.requiredArtifactStandardCodes.filter((item) => typeof item === "string")
+            : [];
+        const created = ctx.service.createHandoffRequirement({
+            sourceScopeCode: sourceScopeCode,
+            sourceRefId: sourceStage.stageId,
+            targetScopeCode: targetScopeCode,
+            targetRefId: targetStage.stageId,
+            handoffTypeCode: normalizeHandoffTypeCode(stringValue(payload, "handoffTypeCode")),
+            handoffItemName,
+            handoffDescription: stringValue(payload, "description"),
+            artifactStandardCode: requiredArtifactStandardCodes[0],
+            artifactStandardVersion: requiredArtifactStandardCodes.length > 0 ? "1.0.0" : undefined,
+            validationRequired: true,
+            sortOrder,
+            metadata: {
+                ...sourceMetadata(ctx.input, payload),
+                handoffCode: stringValue(payload, "handoffCode"),
+                requiredArtifactStandardCodes,
+                requiredResultRefs: Array.isArray(payload.requiredResultRefs) ? payload.requiredResultRefs : []
+            }
+        });
+        targetRefs.push(`handoff:${created.handoffRequirementId}`);
+    }
+    return applied(targetRefs, skippedCount);
+}
+export async function applyAgenticSeed(input) {
+    if (input.mode !== "apply") {
+        return {
+            status: "failed",
+            message: "agentic-domain-methodology only supports apply mode."
+        };
+    }
+    const db = openMethodologyDatabase();
+    try {
+        const service = new MethodologyService(db);
+        const ctx = { input, db, service };
+        const applyInTransaction = db.transaction(() => {
+            switch (input.sourceSection) {
+                case "methodology":
+                    return applyMethodology(ctx);
+                case "lifecycle":
+                    return applyLifecycle(ctx);
+                case "phases":
+                    return applyPhases(ctx);
+                case "processes":
+                    return applyProcesses(ctx);
+                case "stages":
+                    return applyStages(ctx);
+                case "activities":
+                    return applyActivities(ctx);
+                case "activityArtifactRequirements":
+                    return applyActivityArtifactRequirements(ctx);
+                case "criteria":
+                    return applyCriteria(ctx);
+                case "handoffs":
+                    return applyHandoffs(ctx);
+                default:
+                    return {
+                        status: "blocked",
+                        message: `Unsupported methodology seed section: ${input.sourceSection}`
+                    };
+            }
+        });
+        return applyInTransaction();
+    }
+    catch (error) {
+        return {
+            status: "failed",
+            message: error instanceof Error ? error.message : String(error)
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+//# sourceMappingURL=seed-apply.js.map