omc-core 0.4.35 → 0.4.37

package/dist/ticket09-test-field-mutation.js

@@ -1,1026 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { canonicalCloudPivotBaselineFingerprint, canonicalCloudPivotEnvironmentFingerprint } from "./cloudpivot-fingerprints.js";
-import { canonicalFormalDiscoveryFingerprint } from "./formal-capability-discovery.js";
-import { CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE } from "./cloudpivot-low-code.js";
-import { compileNativeOperations, runNativeConfigurationPackage } from "./cloudpivot-native-configuration.js";
-import { buildKnowledgePack } from "./knowledge-pack-builder.js";
-import { KnowledgePackRuntime } from "./knowledge-pack-runtime.js";
-import { createDeliveryPlanApproval, deliveryPlanApprovalHash, proposeDeliveryPlan } from "./two-stage-change-package.js";
-import { validateConfigurationIntent } from "./configuration-intent.js";
-import { SENSITIVE_SECRET_VALUE } from "./delivery-graph.js";
-import { appendApprovalHumanBlock } from "./approval-frame-readability.js";
-import { activeFieldFamily, fieldFamilyMemberCountWord, fieldFamilyMemberFullProse, fieldFamilyMemberNamesProse, fieldFamilyMembers } from "./families/registry.js";
-import { isTicket08TargetSchema, TICKET08_TEST_MUTATION_ROUTE } from "./ticket08-test-model-mutation.js";
-/**
- * Ticket 09 (usable-model ladder, rung 1) — AMENDED IN PLACE (Ticket 19
- * numeric-logical → Ticket 21, field-type ladder rung 03, scaffolding
- * precedent): the governed test field-create capability now covers the
-  * active family. One chain run creates every typed draft field on the run's
-  * own fixture LIST model — each with its registered create-DTO shape,
-  * selector cardinality/identity contract, two-state readback
- * delta, and per-type behavior checks. The fixture model is created in-run
- * through the existing executable Ticket 08 model-create capability; the
- * field package consumes the authoritative model readback handoff and is
- * itself an independently immutable, independently dual-approved package.
- * Evidence from this capability is never inferred to any other field type
- * or capability; field publish, form draft/publish, app publish, production,
- * staging, tenant administration, Redis, restart, deployment, and release
- * stay rejected.
- *
- * Authoritative 8.6.26 contract (decompiled engine + live probe ledger +
- * type survey matrix §2.3/§5):
- * - create DTO is `BizPropertyModel`: the shared baseline
- *   name/name_i18n/code/schemaCode/propertyType/propertyEmpty/defaultValue
-  *   plus serialized `options` from each registered family member with NO
-  *   propertyLength where the type matrix has no enum default length
-  *   (BizPropertyModel.java:21-40, BizPropertyController.java:849-914,
-  *   write-mapping.js:136-178);
- * - `propertyType` serializes as the BizPropertyType @JsonValue index;
- * - field readback is two-state: bizproperty/list?isPublish=false (draft) and
- *   isPublish=true (published); a newly created field appears only in the
- *   draft state (probe ledger: field create succeeded, draft-only readback);
- * - readback options come back FILTERED (bizFormFacade.filterOptions) — the
-  *   per-type readback delta (filtered options round-trip, scalar selector
-  *   identity defaultValue wire shape) is recorded verbatim by the rung's
-  *   behavior probe so the live run pins
- *   the matrix's open slots (BizPropertyController.java:457-486);
- * - draft field deletion is the synchronous force_delete with query params
- *   bizSchemaCode/bizPropertyCode (BizPropertyController.java:1532-1560);
- *   unpublished fields delete directly (controller:1484-1530);
- * - field and schema codes share the server encoding contract: letter first,
- *   letters/digits/underscore only, pinned here to the conservative 26
- *   character limit (live errcode 10005 evidence).
- */
-export const TICKET09_FIELD_MUTATION_ROUTE = "ticket09-test-field-mutation";
-export const TICKET09_FIELD_CLEANUP_ROUTE = "ticket09-test-field-cleanup";
-export const TICKET09_FIELD_CREATE_CAPABILITY_ID = "cloudpivot.test.field-create-8.6.26";
-export const TICKET09_FIELD_CLEANUP_CAPABILITY_ID = "cloudpivot.test.field-cleanup-8.6.26";
-export const TICKET09_FIELD_MUTATION_KNOWLEDGE_PACK_ID = "cloudpivot-8.6-ticket09-test-field-mutation";
-export const TICKET09_TEST_ENVIRONMENT_NAME = "test";
-export const TICKET09_TEST_APPLICATION_CODE = "test";
-export const TICKET09_REFERENCE_EVIDENCE_VERSION = "8.6.26";
-export const TICKET09_FIELD_CREATE_ENDPOINT = "/api/api/app/bizproperty/create";
-export const TICKET09_FIELD_READBACK_ENDPOINT = "/api/api/app/bizproperty/list";
-export const TICKET09_FIELD_CLEANUP_ENDPOINT = "/api/api/app/bizproperty/force_delete";
-/**
- * Deep-frozen family descriptor pinned to the capability's familyMembers.
- * Ticket 03b (family registry refactor): single source is the ACTIVE
- * registration of `src/families/registry.ts` (the self-contained family
- * module `src/families/<family>.ts`) — this export is the ticket-09
- * projection of it, byte-identical to the previously inline table. Ticket
- * 25: N-capable — the projection carries every active family member in
- * governed order.
- */
-export const TICKET09_FIELD_FAMILY = Object.freeze(fieldFamilyMembers().map((member) => Object.freeze({
-    familyPosition: member.familyPosition,
-    propertyTypeName: member.propertyTypeName,
-    propertyType: member.propertyType,
-    controlType: member.controlType,
-    propertyLength: member.propertyLength,
-    fieldOptions: member.fieldOptions,
-    resolveFieldOptions: member.resolveFieldOptions,
-})));
-export function ticket09FamilyMember(propertyTypeName) {
-    const member = TICKET09_FIELD_FAMILY.find((candidate) => candidate.propertyTypeName === propertyTypeName);
-    if (!member)
-        throw new Error(`Ticket 09 family has no member ${propertyTypeName}.`);
-    return member;
-}
-export const TICKET09_PROHIBITED_MUTATION_TERMS = Object.freeze([
-    "publish", "deploy", "restart", "release", "redis", "tenant-admin", "runtime-crud",
-    "model:", "form", "view-create", "folder-create", "folder-delete",
-]);
-const TICKET09_UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const SHA256 = /^[a-f0-9]{64}$/i;
-/** The named `test` environment and its dedicated test application are hard preconditions. */
-export function assertTicket09TestFieldMutationEnvironment(settings) {
-    if (settings.environmentName !== "test")
-        throw new Error("Ticket 09 field mutation is restricted to the named test environment; production and staging are rejected.");
-    if (!settings.baseUrl.trim() || !/^https?:\/\/\S+$/i.test(settings.baseUrl.trim()))
-        throw new Error("Ticket 09 field mutation requires an absolute configured test environment endpoint.");
-    if (settings.testApplicationCode !== "test")
-        throw new Error("Ticket 09 field mutation requires the dedicated test application to be test.");
-}
-/**
- * The field code obeys the same server encoding contract as the model schema
- * code: letter first, letters/digits/underscore only, at most 26 characters.
- * The host-owned fixture field code is `omc_t09_` + 16 lowercase hex digits
- * (24 characters, unique per run; exact-absence preflight still guards
- * collisions).
- */
-export const TICKET09_TARGET_FIELD_PATTERN = /^omc_t09_[0-9a-f]{16}$/;
-const TICKET09_FIELD_CODE_PREFIX = "omc_t09_";
-export function ticket09TargetFieldCode() {
-    return `${TICKET09_FIELD_CODE_PREFIX}${randomUUID().replaceAll("-", "").slice(0, 16)}`;
-}
-export function isTicket09TargetField(fieldCode) {
-    return TICKET09_TARGET_FIELD_PATTERN.test(fieldCode);
-}
-export function assertTicket09TargetField(fieldCode) {
-    if (!isTicket09TargetField(fieldCode))
-        throw new Error("Ticket 09 targetFieldCode must be a host-scoped omc_t09_<16-hex> field code within the CloudPivot 8.6.26 26-character code contract.");
-    return fieldCode;
-}
-export function ticket09DeliveryId(testRunId) { return `ticket09-field-${testRunId}`; }
-export function ticket09FieldCleanupDeliveryId(testRunId) { return `ticket09-field-cleanup-${testRunId}`; }
-export function ticket09FieldScope(targetSchemaCode, targetFieldCode) { return `cloudpivot:field:${targetSchemaCode}/${targetFieldCode}`; }
-/** The family-scoped scope key binding every family field code (the ACTIVE family's member set). */
-export function ticket09FamilyScope(targetSchemaCode, targetFieldCodes) { return `cloudpivot:field:${targetSchemaCode}/${targetFieldCodes.join("+")}`; }
-export function ticket09FieldName(targetFieldCode) { return assertTicket09TargetField(targetFieldCode); }
-/**
- * Per-type default values (Ticket 03b: the derivation lives in the family
- * module — `src/families/<family>.ts` — through the registry; the member
- * identity is the ACTIVE family's registered data).
- */
-function ticket09RegisteredMember(propertyTypeName) {
-    const member = fieldFamilyMembers().find((candidate) => candidate.propertyTypeName === propertyTypeName);
-    if (!member)
-        throw new Error(`The active family has no ${propertyTypeName} member.`);
-    return member;
-}
-export function ticket09FieldDefaultValue(member, testRunId) {
-    return ticket09RegisteredMember(member.propertyTypeName).defaultValue(testRunId);
-}
-/** Design-time designer direct URL; unpublished fixtures stay inspectable here without any publish. */
-export function ticket09DesignerDirectUrl(targetSchemaCode) { return `/admin/#/apps/model/${TICKET09_TEST_APPLICATION_CODE}/${targetSchemaCode}/`; }
-export function decodeTicket09FieldListEvidence(input) {
-    const url = `${TICKET09_FIELD_READBACK_ENDPOINT}?schemaCode=${encodeURIComponent(input.schemaCode)}&isPublish=${input.isPublish}`;
-    const query = { schemaCode: input.schemaCode, propertyCode: input.propertyCode, isPublish: input.isPublish };
-    const envelope = input.body;
-    if (!envelope || typeof envelope !== "object" || envelope.errcode !== 0 || !Array.isArray(envelope.data))
-        throw new Error("Ticket 09 field list readback did not decode the authoritative envelope.");
-    // The row must bind both the field code and the queried model schema; a
-    // same-coded field from another model never satisfies this evidence.
-    const row = envelope.data.find((candidate) => typeof candidate === "object" && candidate !== null && candidate.code === input.propertyCode && candidate.schemaCode === input.schemaCode);
-    if (!row)
-        return Object.freeze({ classification: "absent", reason: "exact-absence", query, url });
-    const expectedMember = fieldFamilyMembers().find((member) => member.propertyType === input.expectedPropertyType);
-    if (row.propertyType !== input.expectedPropertyType && row.propertyType !== String(input.expectedPropertyType))
-        throw new Error(`Ticket 09 field list readback returned a field outside the expected ${expectedMember?.propertyTypeName ?? String(input.expectedPropertyType)} contract.`);
-    const decodedPropertyType = Number(row.propertyType);
-    const decodedMember = fieldFamilyMembers().find((member) => member.propertyType === decodedPropertyType);
-    const field = Object.freeze({
-        ...(typeof row.id === "string" && row.id ? { id: row.id } : {}),
-        code: input.propertyCode,
-        schemaCode: row.schemaCode,
-        propertyType: decodedPropertyType,
-        ...(decodedMember ? { propertyTypeName: decodedMember.propertyTypeName } : {}),
-        propertyEmpty: typeof row.propertyEmpty === "boolean" ? row.propertyEmpty : true,
-        defaultValue: typeof row.defaultValue === "string" ? row.defaultValue : null,
-        rawDefaultValue: row.defaultValue === undefined ? null : row.defaultValue,
-        propertyLength: typeof row.propertyLength === "number" ? row.propertyLength : null,
-        published: row.published === true,
-        options: typeof row.options === "string" ? row.options : null,
-        topLevelFormat: typeof row.format === "string" ? row.format : null,
-        selectionJson: row.selectionJson === undefined ? null : row.selectionJson,
-    });
-    return Object.freeze({ classification: "present", reason: "exact-presence", query, url, field });
-}
-export function buildTicket09FieldCleanupContract(testRunId, targetSchemaCode, targetFieldCodes) {
-    if (!TICKET09_UUID_V4.test(testRunId) || !isTicket08TargetSchema(targetSchemaCode) || targetFieldCodes.length !== TICKET09_FIELD_FAMILY.length || targetFieldCodes.some((code) => !isTicket09TargetField(code)) || new Set(targetFieldCodes).size !== TICKET09_FIELD_FAMILY.length)
-        throw new Error("Ticket 09 field cleanup contract requires the exact host-owned testRunId, fixture schema, and the distinct server-legal family field codes (one per active family member).");
-    return Object.freeze({
-        capabilityId: TICKET09_FIELD_CLEANUP_CAPABILITY_ID,
-        testRunId,
-        targetSchemaCode,
-        targetFieldCodes,
-        operation: { method: "POST", endpoint: TICKET09_FIELD_CLEANUP_ENDPOINT, payload: "query:bizSchemaCode+bizPropertyCode-per-family-field" },
-        postDeleteAbsenceReadback: { method: "GET", endpoint: TICKET09_FIELD_READBACK_ENDPOINT, expected: "draft-exact-absence-per-family-field" },
-        ownership: "field-codes-schema-and-draft-state-bound-to-testRunId",
-        modelCascade: "ticket08-owned-model-physical-delete-cascades-draft-fields",
-        replayPolicy: "absent-is-no-op",
-        uncertainPolicy: "stop-retain-report-no-retry",
-    });
-}
-/** Deterministic, run-independent contract identities pinned by the Knowledge Pack promotion. */
-export function ticket09FieldCreateContractHash() { return digest(ticket09FieldCreateContract()); }
-export function ticket09FieldCleanupContractHash() { return digest(ticket09FieldCleanupContractTemplate()); }
-function ticket09FieldCreateContract() {
-    // Ticket 03b: the family fragment of the contract is synthesized over
-    // the ACTIVE registry registration (src/families/<family>.ts) — adding
-    // or amending a family recomputes this contract hash deterministically.
-    const family = activeFieldFamily();
-    const members = fieldFamilyMembers();
-    return {
-        capabilityId: TICKET09_FIELD_CREATE_CAPABILITY_ID,
-        operationKind: "field-create-family",
-        method: "POST",
-        endpoint: CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE.endpoint,
-        readbackEndpoint: CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE.readbackEndpoint,
-        preflight: CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE.preflight,
-        dto: `BizPropertyModel-family:baseline(name,name_i18n,code,schemaCode,propertyType,propertyEmpty,defaultValue)+per-type(${members.map((member) => `${member.propertyTypeName}:${member.dtoIncrement}`).join(";")};${family.propertyLengthContractWording})`,
-        family: members.map((member) => ({ propertyTypeName: member.propertyTypeName, propertyType: member.propertyType, propertyLength: member.propertyLength, options: member.fieldOptions })),
-        propertyEmpty: false,
-        readbackStates: ["isPublish=false:present", "isPublish=true:absent"],
-        readbackDeltas: Object.fromEntries(members.map((member) => [member.propertyTypeName, member.readbackDelta])),
-        transportMode: "serialized-server-field-create-8.6.26",
-        fieldCodeContract: { pattern: "^[A-Za-z][A-Za-z0-9_]*$", maxLength: 26, evidence: "live-authoritative-errcode-10005" },
-        capability: CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE,
-        evidence: [...CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE.evidence],
-        requiredPermissions: ["configuration-write"],
-        prohibited: [...TICKET09_PROHIBITED_MUTATION_TERMS],
-    };
-}
-function ticket09FieldCleanupContractTemplate() {
-    return {
-        capabilityId: TICKET09_FIELD_CLEANUP_CAPABILITY_ID,
-        operationKind: "owned-draft-family-field-force-delete",
-        method: "POST",
-        endpoint: TICKET09_FIELD_CLEANUP_ENDPOINT,
-        payload: "query:bizSchemaCode+bizPropertyCode-per-family-field",
-        postDeleteAbsenceReadback: `${TICKET09_FIELD_READBACK_ENDPOINT}?isPublish=false:draft-exact-absence-per-family-field`,
-        ownership: "field-codes-schema-and-draft-state-bound-to-testRunId",
-        modelCascade: "ticket08-owned-model-physical-delete-cascades-draft-fields",
-        replayPolicy: "absent-is-no-op",
-        uncertainPolicy: "stop-retain-report-no-retry",
-    };
-}
-/** Package operations are exactly one bounded field operation per active family member, in registry order. */
-export function assertTicket09OperationsBounded(input) {
-    const expectedCount = TICKET09_FIELD_FAMILY.length;
-    if (input.operations.length !== expectedCount)
-        throw new Error(`Ticket 09 ${input.route} packages must contain exactly the ${expectedCount} bounded family operations.`);
-    const expectedPrefix = input.route === TICKET09_FIELD_MUTATION_ROUTE ? "field:" : "cleanup:field:";
-    input.operations.forEach((operation, index) => {
-        const identity = `${operation.id} ${operation.target} ${operation.path}`.toLowerCase();
-        if (TICKET09_PROHIBITED_MUTATION_TERMS.some((term) => identity.includes(term)) || !operation.id.startsWith(expectedPrefix))
-            throw new Error(`Ticket 09 operation ${operation.id} is outside the bounded operation set; prohibited families (publish, deploy, restart, release, redis, tenant administration, runtime CRUD, model/form/view/folder writes) remain rejected.`);
-        const expectedFieldCode = input.targetFieldCodes[index];
-        const target = `field:${input.targetSchemaCode}/${expectedFieldCode}`;
-        const expected = input.route === TICKET09_FIELD_MUTATION_ROUTE
-            ? { id: target, path: TICKET09_FIELD_CREATE_ENDPOINT, transportMode: "serialized-server-field-create-8.6.26" }
-            : { id: `cleanup:${target}`, path: TICKET09_FIELD_CLEANUP_ENDPOINT, transportMode: "cloudpivot-field-force-delete-8.6.26" };
-        if (operation.id !== expected.id || operation.path !== expected.path || operation.transportMode !== expected.transportMode || operation.target !== target)
-            throw new Error(`Ticket 09 operation ${operation.id} does not match the exact family target binding for ${target}.`);
-    });
-}
-/** Builds the signed, version-bound pack promoting exactly the single test field-create capability. */
-export function buildTicket09FieldMutationKnowledgePack(input) {
-    const compiler = { id: "src/ticket09-test-field-mutation.ts:createTicket09FieldCreatePlanApproval", sha256: digest("omc-ticket09-compiler-v1") };
-    const decoder = { id: "src/dsh-host-plugin.ts:createCloudPivotWriteTransport", sha256: digest("omc-ticket09-decoder-v1") };
-    return buildKnowledgePack({
-        packId: TICKET09_FIELD_MUTATION_KNOWLEDGE_PACK_ID,
-        packVersion: "1.0.0",
-        sourceVersion: TICKET09_REFERENCE_EVIDENCE_VERSION,
-        sourceArtifacts: [{ id: "cloudpivot-8.6.26-serialized-field-create-capability", sha256: digest(CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE) }],
-        references: [
-            { id: "yunshu-probe-ledger-field-create-draft-only-readback", sha256: digest("yunshu-probe-ledger-field-create") },
-            { id: TICKET09_FIELD_CREATE_ENDPOINT, sha256: digest(TICKET09_FIELD_CREATE_ENDPOINT) },
-            { id: TICKET09_FIELD_READBACK_ENDPOINT, sha256: digest(TICKET09_FIELD_READBACK_ENDPOINT) },
-            { id: TICKET09_FIELD_CLEANUP_ENDPOINT, sha256: digest(TICKET09_FIELD_CLEANUP_ENDPOINT) },
-        ],
-        compilers: [compiler],
-        decoders: [decoder],
-        capabilities: [{
-                id: TICKET09_FIELD_CREATE_CAPABILITY_ID,
-                status: "runtime-verified",
-                promote: true,
-                compilerRef: compiler.id,
-                decoderRef: decoder.id,
-                sourceEvidence: [...CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE.evidence, TICKET09_FIELD_CREATE_ENDPOINT, TICKET09_FIELD_READBACK_ENDPOINT, "BizPropertyController.java:161-207", "BizPropertyController.java:1484-1560"],
-                runtimeEvidence: ["yunshu-probe-ledger-field-create-draft-only-readback", "cloudpivot.field-create.serialized-server-8.6.26"],
-                operationPromotions: [{
-                        id: "field-create",
-                        status: "promoted",
-                        operationContractHash: ticket09FieldCreateContractHash(),
-                        sourceRefs: [...CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE.evidence, TICKET09_FIELD_CREATE_ENDPOINT, TICKET09_FIELD_READBACK_ENDPOINT, TICKET09_FIELD_CLEANUP_ENDPOINT],
-                        versionFamily: "8.6",
-                        referenceVersion: TICKET09_REFERENCE_EVIDENCE_VERSION,
-                        requiredEvidence: ["cleanup", "discovery", "permission", "readback", "test", "write"],
-                        evidence: ["cleanup", "discovery", "permission", "readback", "test", "write"],
-                        blockedReasons: [],
-                    }],
-            }],
-        signerKeyId: input.signerKeyId,
-        signingKey: input.signingKey,
-        createdAt: input.createdAt,
-    });
-}
-/** Loads the pack against CloudPivot 8.6.26 and pins the single executable capability and contract hash. */
-export function loadTicket09KnowledgePack(artifact, trustedKeys) {
-    const runtime = new KnowledgePackRuntime(trustedKeys);
-    const load = runtime.load(artifact, TICKET09_REFERENCE_EVIDENCE_VERSION);
-    if (!load.accepted)
-        throw new Error(`Ticket 09 Knowledge Pack is not authoritative: ${load.blockingReasons.join(", ")}.`);
-    const active = runtime.active();
-    const capabilities = active.capabilities;
-    if (capabilities.length !== 1 || capabilities[0].id !== TICKET09_FIELD_CREATE_CAPABILITY_ID)
-        throw new Error("Ticket 09 Knowledge Pack must promote exactly the single test field-create capability; evidence inference to other field types or capabilities is rejected.");
-    const hashes = capabilities[0].operationContractHashes;
-    if (hashes.length !== 1 || hashes[0] !== ticket09FieldCreateContractHash())
-        throw new Error("Ticket 09 Knowledge Pack operation contract hash does not match the canonical field-create contract.");
-    return { runtime, packId: active.manifest.packId, contentDigest: active.manifest.contentSha256, executableCapabilities: capabilities.map(({ id }) => id) };
-}
-/** The family field codes in contract order (one per active family member). */
-export function ticket09TargetFieldCodes(evidence) {
-    return evidence.targetFields.map((field) => field.targetFieldCode);
-}
-/** Host-owned composite-chain evidence capture: consumes the completed model handoff and proves model presence plus exact draft absence for BOTH family fields. */
-export function captureTicket09FieldCreateEvidence(input) {
-    assertTicket09TestFieldMutationEnvironment(input.settings);
-    if (!TICKET09_UUID_V4.test(input.testRunId))
-        throw new Error("Ticket 09 evidence capture requires the run's host-owned UUID v4 testRunId.");
-    const handoff = input.handoff;
-    const report = handoff.modelExecutionReport;
-    if (!handoff.modelPackageId || !SHA256.test(handoff.modelPackageHash) || report.route !== TICKET08_TEST_MUTATION_ROUTE || report.status !== "completed" || report.mutationExecuted !== true)
-        throw new Error("Ticket 09 field create requires the completed authoritative model-create handoff; serial writes never assume state.");
-    const modelEvidence = handoff.modelEvidence;
-    if (report.testRunId !== input.testRunId || modelEvidence.testRunId !== input.testRunId || handoff.ownership.testRunId !== input.testRunId)
-        throw new Error("Ticket 09 composite chain requires the single run testRunId across the model and field packages.");
-    const targetSchemaCode = modelEvidence.targetSchemaCode;
-    if (!isTicket08TargetSchema(targetSchemaCode) || report.targetSchemaCode !== targetSchemaCode)
-        throw new Error("Ticket 09 fixture model identity diverges from the completed model-create handoff.");
-    if (input.targetFieldCodes.length !== TICKET09_FIELD_FAMILY.length || input.targetFieldCodes.some((code) => !isTicket09TargetField(code)) || new Set(input.targetFieldCodes).size !== TICKET09_FIELD_FAMILY.length)
-        throw new Error("Ticket 09 evidence capture requires one distinct host-owned family field code per active family member.");
-    const modelPresence = input.modelPresence;
-    if (modelPresence.classification !== "present" || modelPresence.query.schemaCode !== targetSchemaCode)
-        throw new Error("Ticket 09 field create requires the fixture model to be present in fresh authoritative readback.");
-    const entry = input.designTime.directory.models.find((candidate) => candidate.schemaCode === targetSchemaCode);
-    if (!entry || entry.appCode !== TICKET09_TEST_APPLICATION_CODE || entry.modelType !== "LIST" || entry.parentId !== modelEvidence.folder.id || entry.parentId !== handoff.ownership.folderId || typeof entry.id !== "string" || !entry.id)
-        throw new Error("Ticket 09 field create requires the fixture model design-time directory binding (id, LIST, dedicated application, evidence folder).");
-    const targetFields = input.targetFieldCodes.map((targetFieldCode, index) => {
-        const member = TICKET09_FIELD_FAMILY[index];
-        const fieldEvidence = input.fieldEvidence[index];
-        if (fieldEvidence.classification !== "absent" || fieldEvidence.reason !== "exact-absence" || fieldEvidence.query.schemaCode !== targetSchemaCode || fieldEvidence.query.propertyCode !== targetFieldCode || fieldEvidence.query.isPublish !== "false")
-            throw new Error(`Ticket 09 evidence capture requires exact authenticated draft absence evidence for the host-derived ${member.propertyTypeName} family field.`);
-        const plan = Object.freeze({
-            familyPosition: member.familyPosition,
-            propertyTypeName: member.propertyTypeName,
-            propertyType: member.propertyType,
-            controlType: member.controlType,
-            targetFieldCode,
-            fieldName: ticket09FieldName(targetFieldCode),
-            fieldDefaultValue: ticket09FieldDefaultValue(member, input.testRunId),
-            propertyLength: member.propertyLength,
-            fieldOptions: member.resolveFieldOptions
-                ? member.resolveFieldOptions({ schemaCode: targetSchemaCode, memberFieldCodes: input.targetFieldCodes, testRunId: input.testRunId })
-                : member.fieldOptions,
-            fieldEvidence,
-        });
-        return plan;
-    });
-    const authoritativeOrigin = input.discovery.authoritativeOrigin;
-    const enterpriseId = input.discovery.enterpriseId;
-    if (!authoritativeOrigin || !enterpriseId)
-        throw new Error("Ticket 09 evidence capture requires authenticated environment fingerprint evidence.");
-    const environmentFingerprint = canonicalCloudPivotEnvironmentFingerprint({ environment: TICKET09_TEST_ENVIRONMENT_NAME, authoritativeOrigin, applicationCode: TICKET09_TEST_APPLICATION_CODE, enterpriseId });
-    if (environmentFingerprint !== modelEvidence.environmentFingerprint)
-        throw new Error("Ticket 09 field create is outside the model handoff environment fingerprint.");
-    const evidence = Object.freeze({
-        route: TICKET09_FIELD_MUTATION_ROUTE,
-        capabilityId: TICKET09_FIELD_CREATE_CAPABILITY_ID,
-        environmentName: TICKET09_TEST_ENVIRONMENT_NAME,
-        applicationCode: TICKET09_TEST_APPLICATION_CODE,
-        folder: modelEvidence.folder,
-        targetSchemaCode,
-        targetFields,
-        testRunId: input.testRunId,
-        environmentFingerprint,
-        baselineFingerprint: canonicalCloudPivotBaselineFingerprint({ environmentFingerprint, applicationCode: TICKET09_TEST_APPLICATION_CODE, discovery: input.discovery }),
-        discoveryFingerprint: canonicalFormalDiscoveryFingerprint(input.discovery),
-        handoff,
-        modelPresence,
-        cleanupContract: buildTicket09FieldCleanupContract(input.testRunId, targetSchemaCode, targetFields.map((field) => field.targetFieldCode)),
-        designerDirectUrl: ticket09DesignerDirectUrl(targetSchemaCode),
-        capturedAt: new Date((input.now ?? Date.now)()).toISOString(),
-    });
-    if ([evidence.environmentFingerprint, evidence.baselineFingerprint, evidence.discoveryFingerprint].some((value) => !SHA256.test(value)))
-        throw new Error("Ticket 09 evidence fingerprints are not canonical.");
-    if (SENSITIVE_SECRET_VALUE.test(stable(evidence)))
-        throw new Error("Ticket 09 evidence contains prohibited sensitive data.");
-    return evidence;
-}
-export const TICKET09_EVIDENCE_DEFAULT_TTL_MS = 25 * 60_000;
-export const TICKET09_EVIDENCE_MAX_TTL_MS = 30 * 60_000;
-/** Single-use, TTL-bounded evidence store; consumed exactly once by plan creation. */
-export class Ticket09EvidenceStore {
-    records = new Map();
-    now;
-    ttlMs;
-    lastNow;
-    constructor(options = {}) {
-        this.now = options.now ?? Date.now;
-        this.ttlMs = options.ttlMs ?? TICKET09_EVIDENCE_DEFAULT_TTL_MS;
-        if (!Number.isFinite(this.ttlMs) || this.ttlMs < 1 || this.ttlMs > TICKET09_EVIDENCE_MAX_TTL_MS)
-            throw new Error("Ticket 09 evidence TTL must be between 1ms and its safety maximum.");
-    }
-    capture(evidence) {
-        validateTicket09Evidence(evidence);
-        const evidenceId = `ticket09-evidence-${randomUUID()}`;
-        const expiresAt = this.readClock() + this.ttlMs;
-        const stored = Object.freeze({ ...evidence, evidenceArtifactId: evidenceId });
-        this.records.set(evidenceId, { evidence: stored, expiresAt, consumed: false });
-        return { evidenceId, expiresAt, evidence: stored };
-    }
-    consume(evidenceId) {
-        const record = this.records.get(evidenceId);
-        if (!record)
-            throw new Error("Ticket 09 evidence artifact is missing or divergent.");
-        if (record.consumed)
-            throw new Error("Ticket 09 evidence has already been consumed.");
-        if (record.expiresAt <= this.readClock())
-            throw new Error("Ticket 09 evidence is stale or expired.");
-        record.consumed = true;
-        return record.evidence;
-    }
-    resolve(evidenceId) {
-        const record = this.records.get(evidenceId);
-        if (!record || !record.consumed)
-            throw new Error("Ticket 09 evidence artifact is missing or has not been consumed by planning.");
-        if (record.expiresAt <= this.readClock())
-            throw new Error("Ticket 09 evidence artifact is stale or expired.");
-        return record.evidence;
-    }
-    readClock() {
-        const currentTime = this.now();
-        if (!Number.isFinite(currentTime))
-            throw new Error("Ticket 09 evidence clock is invalid; fail closed.");
-        if (this.lastNow !== undefined && currentTime < this.lastNow)
-            throw new Error("Ticket 09 evidence clock moved backwards; fail closed.");
-        this.lastNow = currentTime;
-        return currentTime;
-    }
-}
-/** The exact evidenced per-type BizPropertyModel create DTOs: shared baseline + per-type propertyLength/options (matrix §2.3), required (propertyEmpty false) plus per-type default value. */
-export function buildTicket09FieldCreatePayloads(evidence) {
-    validateTicket09Evidence(evidence);
-    return evidence.targetFields.map((field) => ({
-        name: field.fieldName,
-        name_i18n: JSON.stringify({ "zh-CN": field.fieldName }),
-        code: field.targetFieldCode,
-        schemaCode: evidence.targetSchemaCode,
-        propertyType: field.propertyType,
-        ...(field.propertyLength === null ? {} : { propertyLength: field.propertyLength }),
-        propertyEmpty: false,
-        defaultValue: field.fieldDefaultValue,
-        ...(field.propertyType === 9 || field.propertyType === 11 ? relationPayloadFields(field.fieldOptions) : {}),
-        options: field.fieldOptions,
-    }));
-}
-function relationPayloadFields(optionsJson) {
-    const options = JSON.parse(optionsJson);
-    if (typeof options.schemaCode !== "string" || typeof options.displayField !== "string" || typeof options.relativePropertyMatchCode !== "string")
-        throw new Error("Relevance relation options must carry the concrete schema, display, and match fields.");
-    return { relativeCode: options.schemaCode, relativePropertyCode: options.displayField, relativePropertyMatchCode: options.relativePropertyMatchCode };
-}
-export function buildTicket09ConfigurationIntent(evidence) {
-    validateTicket09Evidence(evidence);
-    const target = `${evidence.targetSchemaCode}/${ticket09TargetFieldCodes(evidence).join("+")}`;
-    return {
-        intentVersion: 1,
-        targetFamily: "8.6",
-        environmentBinding: { application: evidence.applicationCode, model: evidence.targetSchemaCode, baselineFingerprint: evidence.baselineFingerprint },
-        sourceRequirement: `Ticket 09 maintainer test (${activeFieldFamily().familyId} family rung): create ${fieldFamilyMemberCountWord()} unique draft typed fields — ${fieldFamilyMemberFullProse()} — on the run's fixture LIST model, with authoritative two-state readback, per-type behavior validation and wire-shape probe evidence, and staged owned cleanup.`,
-        resources: evidence.targetFields.map((field) => ({ id: `${evidence.targetSchemaCode}/${field.targetFieldCode}`, kind: "field", state: "create", properties: { propertyType: field.propertyTypeName, propertyEmpty: false, defaultValue: field.fieldDefaultValue, ...(field.propertyLength === null ? {} : { propertyLength: field.propertyLength }), options: JSON.parse(field.fieldOptions), schemaCode: evidence.targetSchemaCode, name: field.fieldName } })),
-        relationships: [],
-        lifecycle: evidence.targetFields.map((field, index) => ({ resourceId: `${evidence.targetSchemaCode}/${field.targetFieldCode}`, transitions: ["create"], order: index + 1, idempotent: false, dependencyChecks: ["completed-model-handoff", "draft-exact-absence-preflight"], recoveryBoundary: `field:${evidence.targetSchemaCode}/${field.targetFieldCode}` })),
-        behavior: [{ id: "created-family-field-structure", kind: "structure", requiredCapabilityIds: [TICKET09_FIELD_CREATE_CAPABILITY_ID], resourceIds: evidence.targetFields.map((field) => `${evidence.targetSchemaCode}/${field.targetFieldCode}`), obligations: ["authoritative draft (isPublish=false) readback carries EVERY active family field", "published (isPublish=true) readback carries neither field", "required and per-type default-value configuration decode from authoritative readback", "per-type options round-trip decodes with the readback wire shapes recorded verbatim (each member's registered readback delta, scalar-empty defaultValue identity shape for selector fields, top-level format synthesis where the member carries it)", "designer direct URL stays inspectable without publish"] }],
-        acceptance: [{ id: "ticket09-create-readback", scenario: "family-field-create-readback-behavior", actor: "omc-maintainer-opencode", assertions: ["every family field is present in the draft readback only", "propertyEmpty false and each type's defaultValue decode from authoritative readback", "each type's options round-trip and scalar identity wire shape decode with the readback wire shapes recorded verbatim", "fixture remains inspectable at the designer direct URL"], readbackInvariants: [`${TICKET09_FIELD_READBACK_ENDPOINT}?schemaCode=<model>&isPublish=false lists every exact family field`, `${TICKET09_FIELD_READBACK_ENDPOINT}?schemaCode=<model>&isPublish=true lists neither field`], outcome: "validated" }],
-        cleanup: [{ id: "ticket09-owned-family-field-cleanup", boundary: `ticket09:${evidence.testRunId}:family-field-force-delete`, dependencyChecks: ["draft family field ownership readback", "draft exact absence readback per family field"], resources: evidence.targetFields.map((field) => `field:${evidence.targetSchemaCode}/${field.targetFieldCode}`) }],
-        implementationConstraints: { nativePreferred: true, backendRequired: false, prohibitedPaths: ["form.online-js", "business-rule", "integration", "backend.extension"], approvalExceptions: [] },
-        evidenceRefs: [TICKET09_FIELD_CREATE_CAPABILITY_ID, TICKET09_FIELD_CREATE_ENDPOINT, TICKET09_FIELD_READBACK_ENDPOINT, TICKET09_FIELD_CLEANUP_ENDPOINT, ...CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE.evidence],
-        unresolved: [],
-    };
-}
-function ticket09FieldCreateOperations(evidence) {
-    const payloads = buildTicket09FieldCreatePayloads(evidence);
-    return evidence.targetFields.map((field, index) => {
-        const target = `field:${evidence.targetSchemaCode}/${field.targetFieldCode}`;
-        return {
-            id: target,
-            method: "POST",
-            path: TICKET09_FIELD_CREATE_ENDPOINT,
-            target,
-            payload: payloads[index],
-            expectedReadback: `${target}:draft`,
-            evidence: [TICKET09_FIELD_CREATE_CAPABILITY_ID, ...CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE.evidence, TICKET09_FIELD_READBACK_ENDPOINT],
-            transportMode: "serialized-server-field-create-8.6.26",
-            capability: CLOUDPIVOT_8_6_26_SERIALIZED_FIELD_CREATE,
-        };
-    });
-}
-function ticket09FieldCleanupOperations(evidence) {
-    return evidence.targetFields.map((field) => {
-        const target = `field:${evidence.targetSchemaCode}/${field.targetFieldCode}`;
-        return {
-            id: `cleanup:${target}`,
-            method: "POST",
-            path: TICKET09_FIELD_CLEANUP_ENDPOINT,
-            target,
-            payload: { bizSchemaCode: evidence.targetSchemaCode, bizPropertyCode: field.targetFieldCode },
-            expectedReadback: `${target}:deleted`,
-            evidence: [TICKET09_FIELD_CLEANUP_CAPABILITY_ID, "BizPropertyController.java:1484-1560", TICKET09_FIELD_READBACK_ENDPOINT],
-            transportMode: "cloudpivot-field-force-delete-8.6.26",
-        };
-    });
-}
-/** Creates and proposes the immutable Ticket 09 Delivery Plan Approval for the two-step family field-create package. */
-export function createTicket09FieldCreatePlanApproval(input) {
-    const evidence = validateTicket09Evidence(input.evidence);
-    assertDigest(input.knowledgePackDigest, "knowledge pack digest");
-    const operations = ticket09FieldCreateOperations(evidence);
-    const targetFieldCodes = ticket09TargetFieldCodes(evidence);
-    assertTicket09OperationsBounded({ route: TICKET09_FIELD_MUTATION_ROUTE, operations, targetSchemaCode: evidence.targetSchemaCode, targetFieldCodes });
-    const intent = buildTicket09ConfigurationIntent(evidence);
-    if (validateConfigurationIntent(intent).length)
-        throw new Error("Ticket 09 Configuration Intent is invalid; planning is blocked.");
-    const binding = {
-        deliveryId: ticket09DeliveryId(evidence.testRunId),
-        environment: TICKET09_TEST_ENVIRONMENT_NAME,
-        baselineFingerprint: evidence.baselineFingerprint,
-        environmentFingerprint: evidence.environmentFingerprint,
-        discoveryFingerprint: evidence.discoveryFingerprint,
-        ...(evidence.evidenceArtifactId ? { evidenceArtifactId: evidence.evidenceArtifactId } : {}),
-    };
-    const planHash = digest({ route: TICKET09_FIELD_MUTATION_ROUTE, capabilityId: TICKET09_FIELD_CREATE_CAPABILITY_ID, target: `${evidence.targetSchemaCode}/${targetFieldCodes.join("+")}`, testRunId: evidence.testRunId, operations: operations.map((operation) => ({ id: operation.id, readback: operation.expectedReadback })), modelHandoff: { packageId: evidence.handoff.modelPackageId, packageHash: evidence.handoff.modelPackageHash }, folder: evidence.folder, fingerprints: { baseline: evidence.baselineFingerprint, environment: evidence.environmentFingerprint, discovery: evidence.discoveryFingerprint }, cleanupContractHash: ticket09FieldCleanupContractHash(), knowledgePackDigest: input.knowledgePackDigest, prohibited: [...TICKET09_PROHIBITED_MUTATION_TERMS] });
-    const base = createDeliveryPlanApproval({
-        binding,
-        requirementHash: digest({ target: `${evidence.targetSchemaCode}/${targetFieldCodes.join("+")}` }),
-        clarificationHash: digest("ticket09-test-field-mutation-family-date-time"),
-        intentHash: digest(intent),
-        decisionHash: digest(TICKET09_FIELD_MUTATION_ROUTE),
-        graphHash: digest(operations.map((operation) => operation.id)),
-        riskHash: digest(TICKET09_RISKS),
-        validationPlanHash: digest("authoritative-two-state-family-field-readback-and-per-type-required-default-behavior"),
-        cleanupPlanHash: ticket09FieldCleanupContractHash(),
-        allowedOperationScope: targetFieldCodes.map((fieldCode) => ticket09FieldScope(evidence.targetSchemaCode, fieldCode)),
-        planHash,
-        applicationCode: TICKET09_TEST_APPLICATION_CODE,
-        folderId: evidence.folder.id,
-        folderName: evidence.folder.name,
-        targets: [`${evidence.targetSchemaCode}/${targetFieldCodes.join("+")}`],
-    });
-    const approval = {
-        ...base,
-        route: TICKET09_FIELD_MUTATION_ROUTE,
-        testRunId: evidence.testRunId,
-        targetSchemaCode: evidence.targetSchemaCode,
-        targetFieldCodes,
-        capabilityId: TICKET09_FIELD_CREATE_CAPABILITY_ID,
-        knowledgePackDigest: input.knowledgePackDigest,
-        cleanupContractHash: ticket09FieldCleanupContractHash(),
-        environmentName: TICKET09_TEST_ENVIRONMENT_NAME,
-    };
-    const proposal = { ...approval, approvalHash: deliveryPlanApprovalHash(approval) };
-    proposeDeliveryPlan(input.ledger, proposal);
-    return { approval: proposal, operations, cleanupContract: evidence.cleanupContract, intent, binding };
-}
-const TICKET09_RISKS = [
-    `Exactly ${fieldFamilyMemberCountWord()} unique draft typed field creates (${fieldFamilyMemberNamesProse()}) on the run's own fixture LIST model are in scope; field publish, form draft/publish, app publish, model, view, runtime, folder, deployment, restart, release, Redis, and tenant administration remain rejected.`,
-    "Owned family field cleanup is separately approved and bounded to the fields created by this testRunId with draft exact absence readback per field; the model fixture is physically deleted afterwards through the existing owned model cleanup.",
-];
-/** Proves the fixture family fields were created by this run: exact codes, draft state, typed semantics, dedicated application model, present readback. */
-export function validateTicket09FieldCleanupOwnership(input) {
-    const evidence = validateTicket09Evidence(input.evidence);
-    const fieldIds = [];
-    input.fieldEvidence.forEach((fieldEvidence, index) => {
-        const expected = evidence.targetFields[index];
-        if (fieldEvidence.classification !== "present" || fieldEvidence.reason !== "exact-presence" || fieldEvidence.query.schemaCode !== evidence.targetSchemaCode || fieldEvidence.query.propertyCode !== expected.targetFieldCode || fieldEvidence.query.isPublish !== "false")
-            throw new Error(`Ticket 09 field cleanup requires the created ${expected.propertyTypeName} field to be present in the authoritative draft readback.`);
-        const field = fieldEvidence.field;
-        if (!field || field.code !== expected.targetFieldCode || field.schemaCode !== evidence.targetSchemaCode)
-            throw new Error(`Ticket 09 field cleanup ownership readback returned the wrong ${expected.propertyTypeName} field.`);
-        if (field.published === true)
-            throw new Error("Ticket 09 field cleanup only owns unpublished draft fields; published-field semantics are a separate rung.");
-        if (field.propertyType !== expected.propertyType)
-            throw new Error(`Ticket 09 field cleanup ownership requires the created ${expected.propertyTypeName} field semantics.`);
-        if (field.id)
-            fieldIds.push(field.id);
-    });
-    return {
-        ...(fieldIds.length ? { fieldIds } : {}),
-        testRunId: evidence.testRunId,
-        postCreateBaselineFingerprint: canonicalCloudPivotBaselineFingerprint({ environmentFingerprint: evidence.environmentFingerprint, applicationCode: evidence.applicationCode, discovery: input.discovery }),
-    };
-}
-/** Creates and proposes the separately gated field cleanup Delivery Plan Approval bound to the owned fixture field. */
-export function createTicket09FieldCleanupPlanApproval(input) {
-    const evidence = validateTicket09Evidence(input.evidence);
-    assertDigest(input.knowledgePackDigest, "knowledge pack digest");
-    if (input.ownership.testRunId !== evidence.testRunId || !SHA256.test(input.ownership.postCreateBaselineFingerprint))
-        throw new Error("Ticket 09 field cleanup approval requires the exact validated ownership binding.");
-    const operations = ticket09FieldCleanupOperations(evidence);
-    const targetFieldCodes = ticket09TargetFieldCodes(evidence);
-    assertTicket09OperationsBounded({ route: TICKET09_FIELD_CLEANUP_ROUTE, operations, targetSchemaCode: evidence.targetSchemaCode, targetFieldCodes });
-    const binding = {
-        deliveryId: ticket09FieldCleanupDeliveryId(evidence.testRunId),
-        environment: TICKET09_TEST_ENVIRONMENT_NAME,
-        baselineFingerprint: input.ownership.postCreateBaselineFingerprint,
-        environmentFingerprint: evidence.environmentFingerprint,
-        ...(evidence.evidenceArtifactId ? { evidenceArtifactId: evidence.evidenceArtifactId } : {}),
-    };
-    const planHash = digest({ route: TICKET09_FIELD_CLEANUP_ROUTE, capabilityId: TICKET09_FIELD_CLEANUP_CAPABILITY_ID, target: `${evidence.targetSchemaCode}/${targetFieldCodes.join("+")}`, testRunId: evidence.testRunId, fieldIds: input.ownership.fieldIds ?? [], operations: operations.map((operation) => ({ id: operation.id, readback: operation.expectedReadback })), cleanupContractHash: ticket09FieldCleanupContractHash(), knowledgePackDigest: input.knowledgePackDigest, prohibited: [...TICKET09_PROHIBITED_MUTATION_TERMS] });
-    const base = createDeliveryPlanApproval({
-        binding,
-        requirementHash: digest({ target: `${evidence.targetSchemaCode}/${targetFieldCodes.join("+")}`, cleanup: true }),
-        clarificationHash: digest("ticket09-owned-family-field-cleanup"),
-        intentHash: digest({ cleanup: true, target: `${evidence.targetSchemaCode}/${targetFieldCodes.join("+")}` }),
-        decisionHash: digest(TICKET09_FIELD_CLEANUP_ROUTE),
-        graphHash: digest(operations.map((operation) => operation.id)),
-        riskHash: digest(TICKET09_CLEANUP_RISKS),
-        validationPlanHash: digest("draft-family-field-force-delete-and-exact-absence"),
-        cleanupPlanHash: ticket09FieldCleanupContractHash(),
-        allowedOperationScope: targetFieldCodes.map((fieldCode) => ticket09FieldScope(evidence.targetSchemaCode, fieldCode)),
-        planHash,
-        applicationCode: TICKET09_TEST_APPLICATION_CODE,
-        folderId: evidence.folder.id,
-        folderName: evidence.folder.name,
-        targets: [`${evidence.targetSchemaCode}/${targetFieldCodes.join("+")}`],
-    });
-    const approval = {
-        ...base,
-        route: TICKET09_FIELD_CLEANUP_ROUTE,
-        testRunId: evidence.testRunId,
-        targetSchemaCode: evidence.targetSchemaCode,
-        targetFieldCodes,
-        capabilityId: TICKET09_FIELD_CLEANUP_CAPABILITY_ID,
-        knowledgePackDigest: input.knowledgePackDigest,
-        cleanupContractHash: ticket09FieldCleanupContractHash(),
-        environmentName: TICKET09_TEST_ENVIRONMENT_NAME,
-    };
-    const proposal = { ...approval, approvalHash: deliveryPlanApprovalHash(approval) };
-    proposeDeliveryPlan(input.ledger, proposal);
-    return { approval: proposal, operations, cleanupContract: evidence.cleanupContract, intent: buildTicket09ConfigurationIntent(evidence), binding };
-}
-const TICKET09_CLEANUP_RISKS = [
-    `Field cleanup force-deletes exactly the ${fieldFamilyMemberCountWord()} draft family fields (${fieldFamilyMemberNamesProse()}) created by this testRunId after per-field ownership readback.`,
-    "Uncertain delete outcomes stop, retain, and report the fixture; replay and unbounded deletion are rejected.",
-];
-/** Compiles the immutable two-step family field-create package bound to the approved plan, pack digest, and pinned contract hash. */
-export function prepareTicket09FieldCreatePackage(input) {
-    const evidence = validateTicket09Evidence(input.evidence);
-    const approval = requireTicket09Approval(input.approval, TICKET09_FIELD_MUTATION_ROUTE, TICKET09_FIELD_CREATE_CAPABILITY_ID);
-    const persisted = requirePersistedApprovedPlan(input.ledger, approval);
-    assertTicket09BindingMatchesEvidence(persisted.binding, evidence);
-    const targetFieldCodes = ticket09TargetFieldCodes(evidence);
-    for (const fieldCode of targetFieldCodes) {
-        const scope = ticket09FieldScope(evidence.targetSchemaCode, fieldCode);
-        if (!persisted.allowedOperationScope.includes(scope))
-            throw new Error(`Ticket 09 package step is outside the approved operation scope: ${scope}.`);
-    }
-    if (input.pinnedFieldCreateContractHash !== ticket09FieldCreateContractHash())
-        throw new Error("Ticket 09 pinned field-create contract hash does not match the canonical 8.6.26 capability contract.");
-    assertDigest(input.knowledgePackDigest, "knowledge pack digest");
-    if (input.knowledgePackDigest !== approval.knowledgePackDigest)
-        throw new Error("Ticket 09 knowledge pack digest diverges from the approved plan binding.");
-    const operations = ticket09FieldCreateOperations(evidence);
-    assertTicket09OperationsBounded({ route: TICKET09_FIELD_MUTATION_ROUTE, operations, targetSchemaCode: evidence.targetSchemaCode, targetFieldCodes });
-    const pkg = compileTicket09Package({ ledger: input.ledger, planApproval: persisted, operations, knowledgePackDigest: input.knowledgePackDigest, packageId: `ticket09-field-${digest(persisted.approvalId).slice(0, 32)}`, recoveryPolicyHash: digest("ticket09-family-field-create-steps-only"), capabilityEvidence: [TICKET09_FIELD_CREATE_CAPABILITY_ID, "cloudpivot.field-create.serialized-server-8.6.26", TICKET09_FIELD_READBACK_ENDPOINT, ...targetFieldCodes.map((fieldCode) => `familyField:${fieldCode}`), `modelHandoff:${evidence.handoff.modelPackageId}`, `folder:${evidence.folder.id}`, `testRunId:${evidence.testRunId}`, `baselineFingerprint:${persisted.binding.baselineFingerprint}`] });
-    return { package: pkg, operations, planApproval: persisted, dryRun: ticket09DryRun(evidence, operations), evidence };
-}
-/** Compiles the immutable two-step owned family field-cleanup package bound to the separately approved cleanup plan. */
-export function prepareTicket09FieldCleanupPackage(input) {
-    const evidence = validateTicket09Evidence(input.evidence);
-    const approval = requireTicket09Approval(input.approval, TICKET09_FIELD_CLEANUP_ROUTE, TICKET09_FIELD_CLEANUP_CAPABILITY_ID);
-    const persisted = requirePersistedApprovedPlan(input.ledger, approval);
-    if (persisted.binding.environmentFingerprint !== evidence.environmentFingerprint)
-        throw new Error("Ticket 09 field cleanup approval is outside the evidence environment binding.");
-    const targetFieldCodes = ticket09TargetFieldCodes(evidence);
-    for (const fieldCode of targetFieldCodes) {
-        const scope = ticket09FieldScope(evidence.targetSchemaCode, fieldCode);
-        if (!persisted.allowedOperationScope.includes(scope))
-            throw new Error(`Ticket 09 field cleanup step is outside the approved operation scope: ${scope}.`);
-    }
-    if (input.pinnedCleanupContractHash !== ticket09FieldCleanupContractHash())
-        throw new Error("Ticket 09 pinned field cleanup contract hash does not match the canonical owned-cleanup contract.");
-    assertDigest(input.knowledgePackDigest, "knowledge pack digest");
-    if (input.knowledgePackDigest !== approval.knowledgePackDigest)
-        throw new Error("Ticket 09 knowledge pack digest diverges from the approved field cleanup plan binding.");
-    if (input.ownership.testRunId !== evidence.testRunId)
-        throw new Error("Ticket 09 field cleanup package requires the exact validated ownership binding.");
-    const operations = ticket09FieldCleanupOperations(evidence);
-    assertTicket09OperationsBounded({ route: TICKET09_FIELD_CLEANUP_ROUTE, operations, targetSchemaCode: evidence.targetSchemaCode, targetFieldCodes });
-    const pkg = compileTicket09Package({ ledger: input.ledger, planApproval: persisted, operations, knowledgePackDigest: input.knowledgePackDigest, packageId: `ticket09-field-cleanup-${digest(persisted.approvalId).slice(0, 32)}`, recoveryPolicyHash: digest("ticket09-family-field-cleanup-steps-only"), capabilityEvidence: [TICKET09_FIELD_CLEANUP_CAPABILITY_ID, TICKET09_FIELD_CLEANUP_ENDPOINT, TICKET09_FIELD_READBACK_ENDPOINT, ...(input.ownership.fieldIds ?? []).map((fieldId) => `fieldId:${fieldId}`), `testRunId:${evidence.testRunId}`] });
-    return { package: pkg, operations, planApproval: persisted, dryRun: ticket09DryRun(evidence, operations), evidence };
-}
-function compileTicket09Package(input) {
-    const snapshots = input.operations.map((operation) => {
-        const snapshotBase = { id: `snapshot:${operation.id}`, target: operation.target, identity: operation.target, recoveryBoundary: operation.target, state: "absent", baselineFingerprint: input.planApproval.binding.baselineFingerprint };
-        return { ...snapshotBase, snapshotHash: digest(snapshotBase) };
-    });
-    const pkg = compileNativeOperations({
-        operations: [...input.operations],
-        binding: input.planApproval.binding,
-        planApproval: input.planApproval,
-        snapshotManifest: snapshots,
-        releasePlanHash: digest("ticket09-no-release"),
-        recoveryPolicyHash: input.recoveryPolicyHash,
-        knowledgePack: { id: TICKET09_FIELD_MUTATION_KNOWLEDGE_PACK_ID, digest: input.knowledgePackDigest },
-        capabilityEvidence: input.capabilityEvidence,
-        requiredPermissions: ["configuration-write"],
-        packageId: input.packageId,
-        ledger: input.ledger,
-    });
-    input.ledger.createPackage(pkg);
-    return pkg;
-}
-/** Read-only dry-run projection; never a CloudPivot write and never a publish operation. */
-function ticket09DryRun(evidence, operations) {
-    const readbackOperations = [
-        { id: `readback:fields:${evidence.targetSchemaCode}:draft`, method: "GET", path: TICKET09_FIELD_READBACK_ENDPOINT, target: `fields:${evidence.targetSchemaCode}:draft`, payload: { schemaCode: evidence.targetSchemaCode, isPublish: "false" }, expectedReadback: `fields:${evidence.targetSchemaCode}:draft:read`, evidence: ["BizPropertyController.java:161-207"] },
-        { id: `readback:fields:${evidence.targetSchemaCode}:published`, method: "GET", path: TICKET09_FIELD_READBACK_ENDPOINT, target: `fields:${evidence.targetSchemaCode}:published`, payload: { schemaCode: evidence.targetSchemaCode, isPublish: "true" }, expectedReadback: `fields:${evidence.targetSchemaCode}:published:read`, evidence: ["BizPropertyController.java:161-207"] },
-    ];
-    const body = JSON.stringify({ execution: "read-only-dry-run", operations, readbackOperations, blocked: [], prohibitedActions: ["cloudpivot-write"] }, null, 2) + "\n";
-    return { execution: "read-only-dry-run", operations, readbackOperations, blocked: [], prohibitedActions: ["cloudpivot-write"], artifact: { name: "cloudpivot-ticket09-field-dry-run.json", body, sha256: digest(body), mimeType: "application/json" } };
-}
-export function formatTicket09DeliveryPlanApprovalFrame(approval) {
-    const value = requireTicket09Approval(approval, TICKET09_FIELD_MUTATION_ROUTE, TICKET09_FIELD_CREATE_CAPABILITY_ID);
-    return appendApprovalHumanBlock(`Approve Ticket 09 Delivery Plan Approval ${value.approvalId} hash ${value.approvalHash}; plan hash ${value.planHash}; capability ${value.capabilityId}; environment test; application test; environment fingerprint ${value.binding.environmentFingerprint}; baseline fingerprint ${value.binding.baselineFingerprint}; folder ${value.folderId} (${value.folderName}); fixture model ${value.targetSchemaCode}; family fields ${value.targetFieldCodes.join(" + ")} (${fieldFamilyMemberNamesProse()}); testRunId ${value.testRunId}; exact scopes ${value.allowedOperationScope.join("; ")}; ${fieldFamilyMemberCountWord()} serialized draft typed field-create steps (${fieldFamilyMemberFullProse()}) with required configuration, authoritative two-state readback, per-type behavior validation, and separately approved staged owned cleanup.`, { capability: "ticket09-field-create", kind: "delivery-plan", identities: [value.targetSchemaCode, ...value.targetFieldCodes], scope: [...value.allowedOperationScope] });
-}
-export function formatTicket09EnvironmentChangeApprovalFrame(input) {
-    const value = requireTicket09Approval(input.approval, TICKET09_FIELD_MUTATION_ROUTE, TICKET09_FIELD_CREATE_CAPABILITY_ID);
-    return appendApprovalHumanBlock(`Approve Ticket 09 Environment Change Approval for package ${input.packageId} hash ${input.packageHash}; plan approval ${value.approvalId} hash ${value.approvalHash}; environment test; folder ${value.folderId} (${value.folderName}); fixture model ${value.targetSchemaCode}; family fields ${value.targetFieldCodes.join(" + ")}; testRunId ${value.testRunId}; exact scopes ${value.allowedOperationScope.join("; ")}; ${fieldFamilyMemberCountWord()} serialized draft typed field-create steps executed by the single Forge configuration writer lease with authoritative readback.`, { capability: "ticket09-field-create", kind: "environment-change", identities: [value.targetSchemaCode, ...value.targetFieldCodes], scope: [...value.allowedOperationScope] });
-}
-export function formatTicket09FieldCleanupDeliveryPlanApprovalFrame(approval) {
-    const value = requireTicket09Approval(approval, TICKET09_FIELD_CLEANUP_ROUTE, TICKET09_FIELD_CLEANUP_CAPABILITY_ID);
-    return appendApprovalHumanBlock(`Approve Ticket 09 field cleanup Delivery Plan Approval ${value.approvalId} hash ${value.approvalHash}; plan hash ${value.planHash}; capability ${value.capabilityId}; environment test; application test; environment fingerprint ${value.binding.environmentFingerprint}; post-create baseline fingerprint ${value.binding.baselineFingerprint}; folder ${value.folderId} (${value.folderName}); fixture model ${value.targetSchemaCode}; family fields ${value.targetFieldCodes.join(" + ")}; testRunId ${value.testRunId}; exact scopes ${value.allowedOperationScope.join("; ")}; force-delete only the owned draft family fields after per-field ownership readback.`, { capability: "ticket09-field-cleanup", kind: "delivery-plan", identities: [value.targetSchemaCode, ...value.targetFieldCodes], scope: [...value.allowedOperationScope] });
-}
-export function formatTicket09FieldCleanupEnvironmentChangeApprovalFrame(input) {
-    const value = requireTicket09Approval(input.approval, TICKET09_FIELD_CLEANUP_ROUTE, TICKET09_FIELD_CLEANUP_CAPABILITY_ID);
-    return appendApprovalHumanBlock(`Approve Ticket 09 field cleanup Environment Change Approval for package ${input.packageId} hash ${input.packageHash}; plan approval ${value.approvalId} hash ${value.approvalHash}; environment test; fixture model ${value.targetSchemaCode}; family fields ${value.targetFieldCodes.join(" + ")}; testRunId ${value.testRunId}; exactly ${fieldFamilyMemberCountWord()} owned draft field force-deletes with draft exact absence readback per field; uncertain outcomes stop, retain, and report.`, { capability: "ticket09-field-cleanup", kind: "environment-change", identities: [value.targetSchemaCode, ...value.targetFieldCodes], scope: [...value.allowedOperationScope] });
-}
-/** Decodes the readback options member defensively: the engine returns a JSON string (filtered). */
-function decodeReadbackOptions(options) {
-    if (options === null || options === "")
-        return null;
-    try {
-        return JSON.parse(options);
-    }
-    catch {
-        return options;
-    }
-}
-/** Validates real family field configuration behavior beyond HTTP 2xx: per-field draft-only presence, typed decode, required/default configuration, and per-type options contract — recording the wire shapes verbatim as the probe evidence. */
-export function validateTicket09FieldBehavior(input) {
-    const evidence = validateTicket09Evidence(input.evidence);
-    const checks = [];
-    const observations = [];
-    const add = (id, ok, detail) => checks.push({ id, status: ok ? "validated" : "blocked", detail });
-    // Ticket 03b: the per-type behavior-check definitions (expected options
-    // format, the top-level format synthesis delta, the probe record) are
-    // the ACTIVE family's registered member descriptors.
-    const members = fieldFamilyMembers();
-    input.evidence.targetFields.forEach((expected, index) => {
-        const member = members[index];
-        const draft = input.draft[index];
-        const published = input.published[index];
-        const suffix = expected.propertyTypeName.toLowerCase();
-        const expectedFormat = member.readbackOptionsFormat;
-        const draftPresent = draft.classification === "present" && draft.query.schemaCode === evidence.targetSchemaCode && draft.query.propertyCode === expected.targetFieldCode && draft.query.isPublish === "false" && draft.field?.code === expected.targetFieldCode && draft.field?.schemaCode === evidence.targetSchemaCode;
-        add(`draft-field-present-${suffix}`, draftPresent, draftPresent ? `the draft (isPublish=false) readback lists the created ${expected.propertyTypeName} field.` : `the draft readback did not list the created ${expected.propertyTypeName} field.`);
-        const publishedAbsent = published.classification === "absent" && published.query.schemaCode === evidence.targetSchemaCode && published.query.propertyCode === expected.targetFieldCode && published.query.isPublish === "true";
-        add(`published-field-absent-${suffix}`, publishedAbsent, publishedAbsent ? `the published (isPublish=true) readback does not list the draft ${expected.propertyTypeName} field.` : `the draft ${expected.propertyTypeName} field appeared in the published readback state.`);
-        const field = draft.field;
-        add(`property-type-${suffix}`, field?.propertyType === expected.propertyType, `propertyType decodes as ${field?.propertyType ?? "<missing>"}; expected ${expected.propertyType} (${expected.propertyTypeName}).`);
-        add(`required-configuration-${suffix}`, field?.propertyEmpty === false, `propertyEmpty decodes as ${String(field?.propertyEmpty)}; required configuration was not preserved on the ${expected.propertyTypeName} field.`);
-        // The defaultValue gate requires the exact pinned string shape on the
-        // wire and records the exact wire type for the matrix's open slots.
-        // OQ-5 (type-matrix §12): for selector fields the authoritative FIELD
-        // readback defaultValue is a SCALAR (the org empty-string default); an
-        // object/{id,name}/[{id,name}] payload would decode as a blocked
-        // non-scalar wire shape here and on the create-DTO transport seam.
-        const wire = field?.rawDefaultValue;
-        const defaultValueOk = wire === expected.fieldDefaultValue;
-        add(`default-value-configuration-${suffix}`, defaultValueOk, `defaultValue decodes on the wire as ${JSON.stringify(wire ?? null)}; expected the ${expected.propertyTypeName} scalar shape ${JSON.stringify(expected.fieldDefaultValue)}.`);
-        add(`identity-wire-shape-${suffix}`, wire === null || typeof wire === "string", `the ${expected.propertyTypeName} field defaultValue wire shape decodes as ${wire === null ? "null" : typeof wire} (a scalar string); an object/array identity payload is rejected by the governed create-DTO and readback decode contracts.`);
-        const decodedOptions = decodeReadbackOptions(field?.options ?? null);
-        // The per-member readback options contract is the ACTIVE family module's
-        // registered delta: when the member carries a format key it must survive
-        // the filtered readback (the top-level format synthesis depends on
-        // options.format surviving, BizPropertyController.java:473-486); when the
-        // member's delta is format-free the readback options may legitimately be
-        // absent/null or carry no format key (matrix §2.4/§3.3) — the verbatim
-        // round-trip is what the observation records either way.
-        const optionsObject = decodedOptions && typeof decodedOptions === "object" && !Array.isArray(decodedOptions) ? decodedOptions : null;
-        const formatOk = expectedFormat !== null
-            ? optionsObject !== null && optionsObject.format === expectedFormat
-            : optionsObject === null || !("format" in optionsObject);
-        add(`options-configuration-${suffix}`, formatOk, formatOk ? `the ${expected.propertyTypeName} options round-trip decodes as ${JSON.stringify(decodedOptions)}${expectedFormat === null ? "" : `; the format key survives the filtered readback as "${expectedFormat}"`}.` : `the ${expected.propertyTypeName} options round-trip decodes as ${JSON.stringify(decodedOptions)}${expectedFormat === null ? " (the member's readback delta carries no format key, so the decoded options must not carry one)" : `; the format key must survive the filtered readback as "${expectedFormat}"`}.`);
-        if (member.fieldOptions.includes('"optionsSet"')) {
-            const selectionJsonOk = (field?.selectionJson ?? null) === null;
-            add(`selection-json-null-${suffix}`, selectionJsonOk, selectionJsonOk ? `the ${expected.propertyTypeName} readback keeps selectionJson explicitly null; custom choices remain under options.optionsSet.` : `the ${expected.propertyTypeName} readback did not carry an explicit null selectionJson; OQ-2 requires null.`);
-        }
-        if (member.topLevelFormatSynthesis && member.topLevelFormatSynthesisDetail) {
-            // DATE's readback delta: the controller synthesizes the row's
-            // TOP-LEVEL `format` from options.format (473-486) — pinned statically
-            // and gated; the observation records the verbatim member.
-            const topLevelFormatOk = field?.topLevelFormat === expectedFormat;
-            // A synthesis member always pins its options format (family module contract).
-            add(`top-level-format-synthesis-${suffix}`, topLevelFormatOk, member.topLevelFormatSynthesisDetail(field?.topLevelFormat ?? null, member.readbackOptionsFormat));
-        }
-        observations.push({
-            propertyTypeName: expected.propertyTypeName,
-            propertyType: expected.propertyType,
-            fieldCode: expected.targetFieldCode,
-            defaultValueWireType: wire === null ? "null" : typeof wire === "string" ? "string" : typeof wire === "number" ? "number" : typeof wire === "boolean" ? "boolean" : "other",
-            defaultValueWireValue: wire ?? null,
-            optionsRoundTrip: decodedOptions,
-            topLevelFormat: field?.topLevelFormat ?? null,
-        });
-    });
-    add("designer-direct-url", evidence.designerDirectUrl.startsWith(`/admin/#/apps/model/${TICKET09_TEST_APPLICATION_CODE}/${evidence.targetSchemaCode}/`), `designer direct URL ${evidence.designerDirectUrl} stays inspectable without publish.`);
-    const blocked = checks.find((check) => check.status === "blocked");
-    return blocked
-        ? { status: "blocked", reason: `Ticket 09 behavior validation failed: ${blocked.detail}`, checks, typeMatrixObservations: observations }
-        : { status: "validated", checks, typeMatrixObservations: observations };
-}
-/** Execution boundary: named test environment, route-bound package steps, active approvals, no replay of terminal or uncertain packages. */
-export function assertTicket09ExecutionBoundary(input) {
-    if (input.environmentName !== "test")
-        throw new Error("Ticket 09 execution is restricted to the named test environment; production and staging are rejected.");
-    const { projection } = input;
-    const routeStepPrefix = input.route === TICKET09_FIELD_MUTATION_ROUTE ? "field:" : "cleanup:field:";
-    if (input.steps.length !== TICKET09_FIELD_FAMILY.length || input.steps.some((step) => !step.id.startsWith(routeStepPrefix)))
-        throw new Error(`Ticket 09 execution boundary rejected package ${input.packageId}: its steps are not the ${TICKET09_FIELD_FAMILY.length} ${routeStepPrefix} family operations bound to the ${input.route} route.`);
-    if (projection.status === "approved" && projection.approvals.plan === "approved" && projection.approvals.environment === "approved")
-        return;
-    if (projection.status === "completed")
-        throw new Error(`Ticket 09 package ${input.packageId} is already terminal completed; replay is rejected.`);
-    if (projection.status === "uncertain")
-        throw new Error(`Ticket 09 package ${input.packageId} is uncertain; reconcile by authoritative readback before any replay.`);
-    if (projection.status === "in_progress")
-        throw new Error(`Ticket 09 package ${input.packageId} is already running; concurrent execution is rejected.`);
-    const pending = [...projection.blockers];
-    if (projection.approvals.plan !== "approved")
-        pending.push("Delivery Plan Approval is required before package execution.");
-    if (projection.approvals.environment !== "approved")
-        pending.push("Environment Change Approval is required before mutation.");
-    throw new Error(`Ticket 09 execution boundary rejected package ${input.packageId}: status is ${projection.status} (blocked); ${[...new Set(pending)].join("; ")}.`);
-}
-function ticket09ReportTargetFields(evidence) {
-    return evidence.targetFields.map((field) => ({ propertyTypeName: field.propertyTypeName, propertyType: field.propertyType, targetFieldCode: field.targetFieldCode, fieldDefaultValue: field.fieldDefaultValue, fieldOptions: field.fieldOptions }));
-}
-/** Executes the approved two-step family field-create package through the single OMC Host write transport, then validates per-type behavior and records the wire-shape probe. */
-export async function executeTicket09FieldCreatePackage(input) {
-    assertTicket09TestFieldMutationEnvironment(input.settings);
-    if (typeof input.transport.serializedServerFieldCreate !== "function")
-        throw new Error("Ticket 09 execution requires the OMC Host serialized field-create transport; bypass transports are rejected.");
-    const projection = input.ledger.project(input.prepared.package.packageId);
-    assertTicket09ExecutionBoundary({ projection, environmentName: input.settings.environmentName, packageId: input.prepared.package.packageId, route: TICKET09_FIELD_MUTATION_ROUTE, steps: input.prepared.package.steps });
-    if (input.environmentApproval.packageId !== input.prepared.package.packageId || input.environmentApproval.packageHash !== input.prepared.package.packageHash)
-        throw new Error("Ticket 09 Environment Change Approval does not match the prepared package.");
-    const evidence = input.prepared.evidence;
-    for (const field of evidence.targetFields) {
-        const probe = await input.readFieldEvidence(field.propertyTypeName, "false");
-        if (probe.classification !== "absent" || probe.reason !== "exact-absence")
-            throw new Error(`Ticket 09 execution requires exact draft target absence for the ${field.propertyTypeName} family field ${field.targetFieldCode}; it is already present or blocked.`);
-    }
-    const result = await runNativeConfigurationPackage({
-        package: input.prepared.package,
-        gate: {
-            mode: "approved",
-            planApproval: { status: "approved", approvalHash: input.prepared.planApproval.approvalHash },
-            environmentApproval: { status: "approved", packageHash: input.environmentApproval.packageHash },
-            lease: { owner: "configuration-agent", environment: TICKET09_TEST_ENVIRONMENT_NAME },
-            baselineFingerprint: input.prepared.package.binding.baselineFingerprint,
-            snapshots: input.prepared.package.snapshotManifest,
-            package: input.prepared.package,
-        },
-        operations: input.prepared.operations,
-        ledger: input.ledger,
-        planApproval: input.prepared.planApproval,
-        transport: input.transport,
-        credentials: input.credentials,
-        authoritativeOrigin: input.authoritativeOrigin,
-        testApplicationCode: TICKET09_TEST_APPLICATION_CODE,
-    }, input.signal);
-    const mutationExecuted = result.steps.some((step) => step.status === "committed" || step.status === "uncertain");
-    const blockers = [...result.blockers];
-    let status = ticket09ExecutionStatus(result.status);
-    let nextAction = result.nextAction;
-    let behavior;
-    let typeMatrixObservations;
-    if (result.status === "completed") {
-        const draft = await Promise.all(evidence.targetFields.map((field) => input.readFieldEvidence(field.propertyTypeName, "false")));
-        const published = await Promise.all(evidence.targetFields.map((field) => input.readFieldEvidence(field.propertyTypeName, "true")));
-        const validation = validateTicket09FieldBehavior({ evidence, draft, published });
-        behavior = validation;
-        typeMatrixObservations = validation.typeMatrixObservations;
-        if (validation.status !== "validated") {
-            status = "blocked";
-            blockers.push(validation.reason ?? "Ticket 09 behavior validation failed.");
-            nextAction = "reconcile-behavior-retain-and-report-resource";
-        }
-    }
-    return { reportType: "omc.ticket09.test-field-mutation-execution", schemaVersion: 1, packageId: result.packageId, packageHash: result.packageHash, route: TICKET09_FIELD_MUTATION_ROUTE, testRunId: evidence.testRunId, targetSchemaCode: evidence.targetSchemaCode, targetFields: ticket09ReportTargetFields(evidence), status, mutationExecuted, steps: result.steps, blockers, nextAction, ...(behavior ? { behavior } : {}), ...(typeMatrixObservations ? { typeMatrixObservations } : {}) };
-}
-/** Executes the separately approved owned family field cleanup with per-field draft exact absence readback; uncertainty stops and retains. */
-export async function executeTicket09FieldCleanupPackage(input) {
-    assertTicket09TestFieldMutationEnvironment(input.settings);
-    if (typeof input.transport.fieldForceDelete !== "function")
-        throw new Error("Ticket 09 field cleanup requires the OMC Host draft field force-delete transport; bypass transports are rejected.");
-    const projection = input.ledger.project(input.prepared.package.packageId);
-    assertTicket09ExecutionBoundary({ projection, environmentName: input.settings.environmentName, packageId: input.prepared.package.packageId, route: TICKET09_FIELD_CLEANUP_ROUTE, steps: input.prepared.package.steps });
-    if (input.environmentApproval.packageId !== input.prepared.package.packageId || input.environmentApproval.packageHash !== input.prepared.package.packageHash)
-        throw new Error("Ticket 09 field cleanup Environment Change Approval does not match the prepared package.");
-    const evidence = input.evidence;
-    const probes = await Promise.all(evidence.targetFields.map((field) => input.readFieldEvidence(field.propertyTypeName, "false")));
-    if (probes.every((probe) => probe.classification === "absent")) {
-        return { reportType: "omc.ticket09.test-field-mutation-execution", schemaVersion: 1, packageId: input.prepared.package.packageId, packageHash: input.prepared.package.packageHash, route: TICKET09_FIELD_CLEANUP_ROUTE, testRunId: evidence.testRunId, targetSchemaCode: evidence.targetSchemaCode, targetFields: ticket09ReportTargetFields(evidence), status: "blocked", mutationExecuted: false, steps: projection.steps, blockers: ["Ticket 09 field cleanup targets are already absent; nothing owned remains to delete and no unbounded deletion is attempted."], nextAction: "accept", absenceReadback: probes };
-    }
-    const result = await runNativeConfigurationPackage({
-        package: input.prepared.package,
-        gate: {
-            mode: "approved",
-            planApproval: { status: "approved", approvalHash: input.prepared.planApproval.approvalHash },
-            environmentApproval: { status: "approved", packageHash: input.environmentApproval.packageHash },
-            lease: { owner: "configuration-agent", environment: TICKET09_TEST_ENVIRONMENT_NAME },
-            baselineFingerprint: input.prepared.package.binding.baselineFingerprint,
-            snapshots: input.prepared.package.snapshotManifest,
-            package: input.prepared.package,
-        },
-        operations: input.prepared.operations,
-        ledger: input.ledger,
-        planApproval: input.prepared.planApproval,
-        transport: input.transport,
-        credentials: input.credentials,
-        authoritativeOrigin: input.authoritativeOrigin,
-        testApplicationCode: TICKET09_TEST_APPLICATION_CODE,
-    }, input.signal);
-    const mutationExecuted = result.steps.some((step) => step.status === "committed" || step.status === "uncertain");
-    const blockers = [...result.blockers];
-    let status = ticket09ExecutionStatus(result.status);
-    let nextAction = result.nextAction;
-    let absenceReadback;
-    if (result.status === "completed") {
-        absenceReadback = await Promise.all(evidence.targetFields.map((field) => input.readFieldEvidence(field.propertyTypeName, "false")));
-        if (absenceReadback.some((readback) => readback.classification !== "absent" || readback.reason !== "exact-absence")) {
-            status = "uncertain";
-            blockers.push("Ticket 09 post-cleanup draft exact absence readback did not confirm absence for every family field; the fixture fields are retained and reported.");
-            nextAction = "reconcile";
-        }
-    }
-    return { reportType: "omc.ticket09.test-field-mutation-execution", schemaVersion: 1, packageId: result.packageId, packageHash: result.packageHash, route: TICKET09_FIELD_CLEANUP_ROUTE, testRunId: evidence.testRunId, targetSchemaCode: evidence.targetSchemaCode, targetFields: ticket09ReportTargetFields(evidence), status, mutationExecuted, steps: result.steps, blockers, nextAction, ...(absenceReadback ? { absenceReadback } : {}) };
-}
-function ticket09ExecutionStatus(status) {
-    if (status === "completed" || status === "uncertain" || status === "partial")
-        return status;
-    return "blocked";
-}
-function requireTicket09Approval(approval, route, capabilityId) {
-    const value = approval;
-    if (value.route !== route || value.capabilityId !== capabilityId || value.environmentName !== "test" || value.applicationCode !== "test" || value.targets?.length !== 1 || !value.folderId || !value.folderName || !value.testRunId || !value.targetSchemaCode || !Array.isArray(value.targetFieldCodes) || value.targetFieldCodes.length !== TICKET09_FIELD_FAMILY.length || value.targetFieldCodes.some((code) => !isTicket09TargetField(code)) || new Set(value.targetFieldCodes).size !== TICKET09_FIELD_FAMILY.length)
-        throw new Error(`Ticket 09 approval frame is not bound to the exact ${route} route, family targets, folder, and testRunId.`);
-    return value;
-}
-function requirePersistedApprovedPlan(ledger, approval) {
-    if (approval.status !== "approved")
-        throw new Error("Ticket 09 package preparation requires the approved exact Ticket 09 Delivery Plan Approval.");
-    const persisted = ledger.findPlanApproval(approval.approvalId);
-    if (!persisted || persisted.status !== "approved" || persisted.approvalHash !== approval.approvalHash)
-        throw new Error("Ticket 09 package preparation requires the exact authoritative approved Delivery Plan Approval.");
-    return persisted;
-}
-function assertTicket09BindingMatchesEvidence(binding, evidence) {
-    const expected = {
-        deliveryId: ticket09DeliveryId(evidence.testRunId),
-        environment: TICKET09_TEST_ENVIRONMENT_NAME,
-        baselineFingerprint: evidence.baselineFingerprint,
-        environmentFingerprint: evidence.environmentFingerprint,
-        discoveryFingerprint: evidence.discoveryFingerprint,
-        ...(evidence.evidenceArtifactId ? { evidenceArtifactId: evidence.evidenceArtifactId } : {}),
-    };
-    if (stable(binding) !== stable(expected))
-        throw new Error("Ticket 09 plan approval binding is outside the evidence baseline, environment, discovery, or delivery binding.");
-}
-function validateTicket09Evidence(evidence) {
-    if (!evidence || evidence.route !== TICKET09_FIELD_MUTATION_ROUTE || evidence.capabilityId !== TICKET09_FIELD_CREATE_CAPABILITY_ID)
-        throw new Error("Ticket 09 evidence is not the host-owned field mutation route.");
-    if (evidence.environmentName !== "test" || evidence.applicationCode !== "test")
-        throw new Error("Ticket 09 evidence is outside the named test environment and dedicated test application.");
-    if (!isTicket08TargetSchema(evidence.targetSchemaCode))
-        throw new Error("Ticket 09 evidence fixture model is not the host-owned Ticket 08 schema.");
-    if (!Array.isArray(evidence.targetFields) || evidence.targetFields.length !== TICKET09_FIELD_FAMILY.length)
-        throw new Error("Ticket 09 evidence must carry the exact date-time family enumeration.");
-    evidence.targetFields.forEach((field, index) => {
-        const member = TICKET09_FIELD_FAMILY[index];
-        const expectedOptions = member.resolveFieldOptions
-            ? member.resolveFieldOptions({ schemaCode: evidence.targetSchemaCode, memberFieldCodes: evidence.targetFields.map((candidate) => candidate.targetFieldCode), testRunId: evidence.testRunId })
-            : member.fieldOptions;
-        if (field.propertyTypeName !== member.propertyTypeName || field.propertyType !== member.propertyType || field.controlType !== member.controlType || field.propertyLength !== member.propertyLength || field.fieldOptions !== expectedOptions || !isTicket09TargetField(field.targetFieldCode) || field.fieldName !== field.targetFieldCode)
-            throw new Error(`Ticket 09 evidence family member ${index + 1} diverges from the pinned ${member.propertyTypeName} contract.`);
-        if (field.fieldDefaultValue !== ticket09FieldDefaultValue(member, evidence.testRunId))
-            throw new Error(`Ticket 09 evidence family member ${index + 1} carries a divergent ${member.propertyTypeName} default value.`);
-        if (field.fieldEvidence.classification !== "absent" || field.fieldEvidence.reason !== "exact-absence" || field.fieldEvidence.query.schemaCode !== evidence.targetSchemaCode || field.fieldEvidence.query.propertyCode !== field.targetFieldCode)
-            throw new Error(`Ticket 09 evidence does not carry exact authenticated draft absence for the ${member.propertyTypeName} family field.`);
-    });
-    if (new Set(evidence.targetFields.map((field) => field.targetFieldCode)).size !== TICKET09_FIELD_FAMILY.length)
-        throw new Error("Ticket 09 evidence family field codes must be distinct.");
-    if ([evidence.environmentFingerprint, evidence.baselineFingerprint, evidence.discoveryFingerprint].some((value) => !SHA256.test(value)))
-        throw new Error("Ticket 09 evidence fingerprints are not canonical.");
-    if (evidence.modelPresence.classification !== "present" || evidence.modelPresence.query.schemaCode !== evidence.targetSchemaCode)
-        throw new Error("Ticket 09 evidence does not carry the authoritative fixture model presence handoff.");
-    if (!evidence.folder.id || !evidence.folder.name)
-        throw new Error("Ticket 09 evidence folder binding is missing.");
-    return evidence;
-}
-function assertDigest(value, label) {
-    if (typeof value !== "string" || !SHA256.test(value) || !/[1-9a-f]/i.test(value))
-        throw new Error(`Ticket 09 ${label} is invalid.`);
-}
-function digest(value) { return createHash("sha256").update(stable(value)).digest("hex"); }
-function stable(value) { return JSON.stringify(sort(value)); }
-function sort(value) { if (Array.isArray(value))
-    return value.map(sort); if (value && typeof value === "object")
-    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, sort(item)])); return value; }
-//# sourceMappingURL=ticket09-test-field-mutation.js.map