@x12i/graphenix-executable-format 1.0.0

package/dist/test/executable-format.test.js

@@ -0,0 +1,844 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = require("node:test");
+const graphenix_core_1 = require("@x12i/graphenix-core");
+const api_js_1 = require("../api.js");
+const minimal_executable_graph_js_1 = require("../fixtures/minimal-executable-graph.js");
+const graphenix_core_2 = require("@x12i/graphenix-core");
+const constants_js_1 = require("../constants.js");
+function setGraphModelConfig(doc, modelConfig) {
+    const next = structuredClone(doc);
+    const ext = next.graph.metadata.extensions[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+    ext.modelConfig = modelConfig;
+    return next;
+}
+(0, node_test_1.describe)("graphenix base validation", () => {
+    (0, node_test_1.it)("valid executable graph passes Graphenix validateGraph()", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const result = (0, graphenix_core_1.validateGraph)(doc);
+        strict_1.default.equal(result.valid, true);
+    });
+});
+(0, node_test_1.describe)("executable profile validation", () => {
+    (0, node_test_1.it)("valid executable graph passes assertExecutableGraph()", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        strict_1.default.doesNotThrow(() => (0, api_js_1.assertExecutableGraph)(doc));
+    });
+    (0, node_test_1.it)("plain Graphenix graph without executable profile fails", () => {
+        const doc = (0, minimal_executable_graph_js_1.createPlainGraphenixGraph)();
+        const result = (0, api_js_1.validateExecutableGraph)(doc);
+        strict_1.default.equal(result.valid, false);
+        strict_1.default.ok(result.errors.some((e) => e.code === "EXECUTABLE_PROFILE_MISSING"));
+    });
+    (0, node_test_1.it)("graph-level modelConfig is required", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const ext = doc.graph.metadata.extensions[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+        delete ext.modelConfig;
+        const result = (0, api_js_1.validateExecutableGraph)(doc);
+        strict_1.default.equal(result.valid, false);
+        strict_1.default.ok(result.errors.some((e) => e.code === "GRAPH_MODEL_CONFIG_MISSING"));
+    });
+});
+(0, node_test_1.describe)("model inheritance", () => {
+    (0, node_test_1.it)("node with no modelConfig inherits all slots", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const plan = (0, api_js_1.resolveNodeAiPlan)(doc, "node:professional-answer");
+        strict_1.default.equal(plan.slots.preActionModel.inherited, true);
+        strict_1.default.equal(plan.slots.skillModel.inherited, true);
+        strict_1.default.equal(plan.slots.postActionModel.inherited, true);
+        strict_1.default.match((0, api_js_1.explainNodeInheritance)(plan), /graph case default/);
+    });
+    (0, node_test_1.it)("node may override only skillModel", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const taskNode = doc.graph.nodes.find((n) => n.id === "node:professional-answer");
+        const params = taskNode.parameters;
+        strict_1.default.ok(params && params.nodeType === "task");
+        taskNode.parameters = {
+            ...params,
+            taskConfiguration: {
+                modelConfig: {
+                    modelConfig: {
+                        skillModel: { kind: "profileChoice", key: "vol/pro" }
+                    }
+                }
+            }
+        };
+        const plan = (0, api_js_1.resolveNodeAiPlan)(doc, "node:professional-answer");
+        strict_1.default.equal(plan.slots.skillModel.inherited, false);
+        strict_1.default.equal(plan.slots.preActionModel.inherited, true);
+    });
+});
+(0, node_test_1.describe)("model fallback", () => {
+    (0, node_test_1.it)("fallback uses graph same-slot only", () => {
+        const resolved = (0, api_js_1.resolveNodeModelSlot)({
+            slot: "skillModel",
+            graphSelection: { kind: "profileChoice", key: "vol/default" },
+            nodeSelection: {
+                kind: "model",
+                provider: "openrouter",
+                modelId: "missing"
+            },
+            fallbackPolicy: {
+                enabled: true,
+                allowedTriggers: ["nodeModelUnavailable"],
+                maxAttemptsPerSlot: 1
+            },
+            availabilityResult: {
+                available: false,
+                trigger: "nodeModelUnavailable",
+                reason: "model not found"
+            },
+            graphCaseId: "default",
+            nodeId: "node:test"
+        });
+        strict_1.default.equal(resolved.source, "fallbackToGraphDefault");
+        strict_1.default.equal(resolved.selected.kind === "profileChoice" ? resolved.selected.key : "", "vol/default");
+    });
+    (0, node_test_1.it)("fallback does not use runtime or request model defaults", () => {
+        const runtime = (0, api_js_1.validateRuntimeObject)({
+            jobId: "job-1",
+            job: { id: "job-1", jobId: "job-1" },
+            graphDefaultModel: { kind: "profileChoice", key: "cheap/default" }
+        });
+        strict_1.default.equal(runtime.valid, false);
+    });
+});
+(0, node_test_1.describe)("studio adapter", () => {
+    (0, node_test_1.it)("studio request with graphDefaultModel fails", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const result = (0, api_js_1.validateStudioExecuteRequest)({
+            mode: "graph",
+            jobId: "job-1",
+            graph: doc,
+            graphDefaultModel: {}
+        });
+        strict_1.default.equal(result.valid, false);
+        strict_1.default.ok(result.errors.some((e) => e.code === "STUDIO_GRAPH_DEFAULT_MODEL_FORBIDDEN"));
+    });
+    (0, node_test_1.it)("studio adapter outputs compiled { plan, runtime }", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const ext = doc.graph.metadata.extensions[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+        ext.modelConfig = {
+            version: "graph-model-config/v1",
+            default: {
+                preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                skillModel: { kind: "profileChoice", key: "vol/default" },
+                postActionModel: { kind: "profileChoice", key: "cheap/default" }
+            }
+        };
+        const request = {
+            mode: "graph",
+            jobId: "job-123",
+            graph: doc,
+            runtime: {
+                input: { target_subnet_cidr: "10.0.0.0/24" }
+            },
+            openrouterApiKey: "secret-should-not-copy"
+        };
+        const execution = (0, api_js_1.buildGraphExecutionRequestFromStudioExecute)(request, {
+            agentId: "agent-1"
+        });
+        strict_1.default.equal(execution.runtime.jobId, "job-123");
+        strict_1.default.equal(execution.plan.source.graphId, doc.id);
+        strict_1.default.equal(execution.plan.format, "x12i.graphenix.executable-plan/v1");
+        strict_1.default.equal("openrouterApiKey" in execution.runtime, false);
+        strict_1.default.equal("openrouterApiKey" in execution.plan, false);
+        const profile = execution.plan.graph.graph.metadata?.extensions?.[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+        strict_1.default.equal(profile?.modelConfig?.cases?.[0]?.id, "default");
+        strict_1.default.equal((0, api_js_1.validateExecutablePlan)(execution.plan).valid, true);
+    });
+});
+(0, node_test_1.describe)("runtime validation", () => {
+    (0, node_test_1.it)("credentials are never copied into runtime", () => {
+        const result = (0, api_js_1.validateRuntimeObject)({
+            jobId: "job-1",
+            job: { id: "job-1", jobId: "job-1" },
+            credentials: { token: "x" }
+        });
+        strict_1.default.equal(result.valid, false);
+    });
+    (0, node_test_1.it)("runtime modelConfig is rejected", () => {
+        const result = (0, api_js_1.validateRuntimeObject)({
+            jobId: "job-1",
+            job: { id: "job-1", jobId: "job-1" },
+            modelConfig: {}
+        });
+        strict_1.default.equal(result.valid, false);
+    });
+});
+(0, node_test_1.describe)("migration", () => {
+    (0, node_test_1.it)("legacy graph migrates into valid Graphenix executable document", () => {
+        const migrated = (0, api_js_1.migrateLegacyGraphModelObjectToGraphenixExecutable)({
+            id: "graph:legacy",
+            version: "0.1.0",
+            nodes: [
+                {
+                    id: "node:a",
+                    kind: "task",
+                    skillKey: "demo"
+                }
+            ],
+            edges: [],
+            modelConfig: {
+                version: "graph-model-config/v1",
+                cases: [
+                    {
+                        id: "default",
+                        modelConfig: {
+                            preActionModel: { kind: "profile", profile: "economy" },
+                            skillModel: { kind: "profile", profile: "balanced" },
+                            postActionModel: { kind: "profile", profile: "economy" }
+                        }
+                    }
+                ]
+            }
+        });
+        strict_1.default.equal(migrated.formatVersion, graphenix_core_2.GRAPHENIX_FORMAT_VERSION);
+        strict_1.default.doesNotThrow(() => (0, api_js_1.assertExecutableGraph)(migrated));
+    });
+});
+(0, node_test_1.describe)("node kinds", () => {
+    (0, node_test_1.it)("task nodes must use kind x12i:task", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        doc.graph.nodes[0].kind = "task:wrong";
+        const result = (0, api_js_1.validateExecutableGraph)(doc);
+        strict_1.default.ok(result.errors.some((e) => e.code === "TASK_NODE_INVALID"));
+    });
+});
+(0, node_test_1.describe)("deterministic cases", () => {
+    (0, node_test_1.it)("AC-001: runtime.mode eq simulate is accepted", () => {
+        const errors = (0, api_js_1.validateCaseCondition)({
+            path: "runtime.mode",
+            op: "eq",
+            value: "simulate"
+        });
+        strict_1.default.equal(errors.length, 0);
+    });
+    (0, node_test_1.it)("AC-007/008: first matching case is selected, else default", () => {
+        const doc = setGraphModelConfig((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            version: "graph-model-config/v1",
+            cases: [
+                {
+                    id: "default",
+                    modelConfig: {
+                        preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                        skillModel: { kind: "profileChoice", key: "vol/default" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                },
+                {
+                    id: "simulate",
+                    when: { path: "runtime.mode", op: "eq", value: "simulate" },
+                    modelConfig: {
+                        preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                        skillModel: { kind: "profileChoice", key: "sum/default" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                }
+            ]
+        });
+        const context = (0, api_js_1.buildDeterministicCaseContext)(doc, { mode: "simulate" });
+        const plan = (0, api_js_1.resolveNodeAiPlan)(doc, "node:professional-answer", context);
+        strict_1.default.equal(plan.graphCaseId, "simulate");
+    });
+    (0, node_test_1.it)("AC-009/010: default case requirements", () => {
+        const noDefault = (0, api_js_1.validateExecutableGraph)(setGraphModelConfig((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            version: "graph-model-config/v1",
+            cases: [
+                {
+                    id: "simulate",
+                    when: { path: "runtime.mode", op: "eq", value: "simulate" },
+                    modelConfig: {
+                        preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                        skillModel: { kind: "profileChoice", key: "sum/default" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                }
+            ]
+        }));
+        strict_1.default.ok(noDefault.errors.some((e) => e.code === "CASE_SELECTION_DEFAULT_MISSING"));
+    });
+});
+(0, node_test_1.describe)("forbidden AI selectors", () => {
+    (0, node_test_1.it)("AC-020: ai.prompt is rejected", () => {
+        const errors = (0, api_js_1.validateCaseCondition)({ ai: { prompt: "complex?" } });
+        strict_1.default.ok(errors.some((e) => e.code === "CASE_CONDITION_FORBIDDEN_AI_SELECTOR"));
+    });
+    (0, node_test_1.it)("AC-024: ai.classification path is rejected", () => {
+        const errors = (0, api_js_1.validateCaseCondition)({
+            path: "ai.classification.risk",
+            op: "eq",
+            value: "high"
+        });
+        strict_1.default.ok(errors.some((e) => e.code === "CASE_CONDITION_FORBIDDEN_PATH"));
+    });
+    (0, node_test_1.it)("AC-025: node.output path is rejected", () => {
+        const errors = (0, api_js_1.validateCaseCondition)({
+            path: "node.output.riskClassifier.risk",
+            op: "eq",
+            value: "high"
+        });
+        strict_1.default.ok(errors.some((e) => e.code === "CASE_CONDITION_FORBIDDEN_PATH"));
+    });
+});
+(0, node_test_1.describe)("profile-choice validation", () => {
+    (0, node_test_1.it)("AC-030/031/032: valid profileChoice keys accepted", () => {
+        strict_1.default.equal((0, api_js_1.isProfileChoiceKeyFormat)("cheap/default"), true);
+        strict_1.default.equal((0, api_js_1.isProfileChoiceKeyFormat)("vol/default"), true);
+        strict_1.default.equal((0, api_js_1.isProfileChoiceKeyFormat)("deep/openai_deep"), true);
+        strict_1.default.equal((0, api_js_1.isKnownProfileChoice)("vol/pro"), true);
+    });
+    (0, node_test_1.it)("AC-033/034/035/036: bare aliases rejected", () => {
+        for (const key of ["cheap", "balanced", "cheapest", "default"]) {
+            strict_1.default.equal((0, api_js_1.isProfileChoiceKeyFormat)(key), false);
+        }
+    });
+    (0, node_test_1.it)("AC-037/038: vendor slugs and legacy aliases rejected", () => {
+        // Syntactically valid profile/choice shape, but not a bundled registry key.
+        strict_1.default.equal((0, api_js_1.isProfileChoiceKeyFormat)("openai/gpt-4o-mini"), true);
+        strict_1.default.equal((0, api_js_1.isKnownProfileChoice)("openai/gpt-4o-mini"), false);
+        strict_1.default.equal((0, api_js_1.isProfileChoiceKeyFormat)("cheap@anthropic_cheap"), false);
+    });
+    (0, node_test_1.it)("AC-039: unknown choice rejected in graph validation", () => {
+        const result = (0, api_js_1.validateExecutableGraph)(setGraphModelConfig((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            version: "graph-model-config/v1",
+            cases: [
+                {
+                    id: "default",
+                    modelConfig: {
+                        preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                        skillModel: { kind: "profileChoice", key: "cheap/missing_choice" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                }
+            ]
+        }));
+        strict_1.default.ok(result.errors.some((e) => e.code === "PROFILE_CHOICE_KEY_UNKNOWN"));
+    });
+    (0, node_test_1.it)("deprecated kind profile is rejected", () => {
+        const result = (0, api_js_1.validateExecutableGraph)(setGraphModelConfig((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            version: "graph-model-config/v1",
+            cases: [
+                {
+                    id: "default",
+                    modelConfig: {
+                        preActionModel: { kind: "profile", profile: "economy" },
+                        skillModel: { kind: "profileChoice", key: "vol/default" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                }
+            ]
+        }));
+        strict_1.default.ok(result.errors.some((e) => e.code === "PROFILE_SELECTION_KIND_DEPRECATED"));
+    });
+});
+(0, node_test_1.describe)("normalization", () => {
+    (0, node_test_1.it)("AC-060: graph default shorthand normalizes to cases[0].id = default", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const ext = doc.graph.metadata.extensions[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+        ext.modelConfig = {
+            version: "graph-model-config/v1",
+            default: {
+                preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                skillModel: { kind: "profileChoice", key: "vol/default" },
+                postActionModel: { kind: "profileChoice", key: "cheap/default" }
+            }
+        };
+        const normalized = (0, api_js_1.normalizeExecutableGraph)(doc);
+        const profile = normalized.graph.metadata?.extensions?.[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+        strict_1.default.equal(profile?.modelConfig?.cases?.[0]?.id, "default");
+        strict_1.default.equal(profile?.modelConfig?.cases?.[0]?.when, undefined);
+    });
+    (0, node_test_1.it)("AC-066: normalization does not mutate source graph", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const before = structuredClone(doc);
+        (0, api_js_1.normalizeExecutableGraph)(doc);
+        strict_1.default.deepEqual(doc, before);
+    });
+});
+(0, node_test_1.describe)("full resolution example", () => {
+    (0, node_test_1.it)("matches CR/FR section 12 resolution", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const taskNode = doc.graph.nodes.find((n) => n.id === "node:professional-answer");
+        const params = taskNode.parameters;
+        strict_1.default.ok(params && params.nodeType === "task");
+        const ext = doc.graph.metadata.extensions[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+        ext.modelConfig = {
+            version: "graph-model-config/v1",
+            cases: [
+                {
+                    id: "default",
+                    modelConfig: {
+                        preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                        skillModel: { kind: "profileChoice", key: "vol/default" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                },
+                {
+                    id: "simulate",
+                    when: { path: "runtime.mode", op: "eq", value: "simulate" },
+                    modelConfig: {
+                        preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                        skillModel: { kind: "profileChoice", key: "sum/default" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                },
+                {
+                    id: "deep-live",
+                    when: {
+                        all: [
+                            { path: "runtime.mode", op: "eq", value: "live" },
+                            { path: "runtime.input.analysisDepth", op: "eq", value: "deep" }
+                        ]
+                    },
+                    modelConfig: {
+                        preActionModel: { kind: "profileChoice", key: "vol/default" },
+                        skillModel: { kind: "profileChoice", key: "deep/openai_deep" },
+                        postActionModel: { kind: "profileChoice", key: "sum/default" }
+                    }
+                }
+            ]
+        };
+        taskNode.parameters = {
+            ...params,
+            taskConfiguration: {
+                modelConfig: {
+                    inherit: true,
+                    cases: [
+                        {
+                            id: "default",
+                            modelConfig: {
+                                skillModel: { kind: "profileChoice", key: "vol/pro" }
+                            }
+                        },
+                        {
+                            id: "simulate",
+                            when: { path: "runtime.mode", op: "eq", value: "simulate" },
+                            modelConfig: {
+                                skillModel: { kind: "profileChoice", key: "sum/default" }
+                            }
+                        },
+                        {
+                            id: "high-risk-input",
+                            when: {
+                                path: "runtime.input.riskLevel",
+                                op: "eq",
+                                value: "high"
+                            },
+                            modelConfig: {
+                                preActionModel: { kind: "profileChoice", key: "vol/default" },
+                                skillModel: { kind: "profileChoice", key: "deep/openai_deep" },
+                                postActionModel: { kind: "profileChoice", key: "sum/default" }
+                            }
+                        }
+                    ]
+                }
+            }
+        };
+        const context = (0, api_js_1.buildDeterministicCaseContext)(doc, {
+            mode: "live",
+            input: { analysisDepth: "deep", riskLevel: "high" }
+        });
+        const plan = (0, api_js_1.resolveNodeAiPlan)(doc, "node:professional-answer", context);
+        strict_1.default.equal(plan.graphCaseId, "deep-live");
+        strict_1.default.equal(plan.nodeCaseId, "high-risk-input");
+        strict_1.default.equal(plan.slots.preActionModel.selected.kind, "profileChoice");
+        if (plan.slots.preActionModel.selected.kind === "profileChoice") {
+            strict_1.default.equal(plan.slots.preActionModel.selected.key, "vol/default");
+        }
+        if (plan.slots.skillModel.selected.kind === "profileChoice") {
+            strict_1.default.equal(plan.slots.skillModel.selected.key, "deep/openai_deep");
+        }
+        strict_1.default.ok(plan.caseSelection.graph.matchedConditions.some((c) => c.includes("runtime.mode eq live")));
+        strict_1.default.ok(plan.caseSelection.node?.matchedConditions.some((c) => c.includes("runtime.input.riskLevel eq high")));
+    });
+});
+(0, node_test_1.describe)("evaluateCaseCondition", () => {
+    (0, node_test_1.it)("AC-004/005/006: all, any, not supported", () => {
+        const context = (0, api_js_1.buildDeterministicCaseContext)((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            mode: "live",
+            input: { riskLevel: "high", tier: "gold" }
+        });
+        strict_1.default.equal((0, api_js_1.evaluateCaseCondition)({
+            all: [
+                { path: "runtime.mode", op: "eq", value: "live" },
+                { path: "runtime.input.riskLevel", op: "eq", value: "high" }
+            ]
+        }, context), true);
+        strict_1.default.equal((0, api_js_1.evaluateCaseCondition)({
+            any: [
+                { path: "runtime.input.tier", op: "eq", value: "silver" },
+                { path: "runtime.input.tier", op: "eq", value: "gold" }
+            ]
+        }, context), true);
+        strict_1.default.equal((0, api_js_1.evaluateCaseCondition)({
+            not: { path: "runtime.mode", op: "eq", value: "simulate" }
+        }, context), true);
+    });
+});
+(0, node_test_1.describe)("lifecycle artifacts", () => {
+    (0, node_test_1.it)("AC-A001/A005: authoring graph with modelConfig.default passes", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const ext = doc.graph.metadata.extensions[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+        ext.modelConfig = {
+            version: "graph-model-config/v1",
+            default: {
+                preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                skillModel: { kind: "profileChoice", key: "vol/default" },
+                postActionModel: { kind: "profileChoice", key: "cheap/default" }
+            }
+        };
+        strict_1.default.equal((0, api_js_1.validateAuthoringGraph)(doc).valid, true);
+    });
+    (0, node_test_1.it)("AC-A003/A004: bare profile and kind profile fail authoring validation", () => {
+        const bareProfile = (0, api_js_1.validateAuthoringGraph)(setGraphModelConfig((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            version: "graph-model-config/v1",
+            cases: [
+                {
+                    id: "default",
+                    modelConfig: {
+                        preActionModel: { kind: "profileChoice", key: "cheap" },
+                        skillModel: { kind: "profileChoice", key: "vol/default" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                }
+            ]
+        }));
+        strict_1.default.ok(bareProfile.errors.some((e) => e.code === "PROFILE_CHOICE_KEY_FORMAT_INVALID"));
+        const kindProfile = (0, api_js_1.validateAuthoringGraph)(setGraphModelConfig((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            version: "graph-model-config/v1",
+            cases: [
+                {
+                    id: "default",
+                    modelConfig: {
+                        preActionModel: { kind: "profile", profile: "cheap" },
+                        skillModel: { kind: "profileChoice", key: "vol/default" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                }
+            ]
+        }));
+        strict_1.default.ok(kindProfile.errors.some((e) => e.code === "PROFILE_SELECTION_KIND_DEPRECATED"));
+    });
+    (0, node_test_1.it)("AC-P001/P003/P008/P009/P010: compile produces run-bound executable plan", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const ext = doc.graph.metadata.extensions[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+        ext.modelConfig = {
+            version: "graph-model-config/v1",
+            cases: [
+                {
+                    id: "default",
+                    modelConfig: {
+                        preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                        skillModel: { kind: "profileChoice", key: "vol/default" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                },
+                {
+                    id: "simulate",
+                    when: { path: "runtime.mode", op: "eq", value: "simulate" },
+                    modelConfig: {
+                        preActionModel: { kind: "profileChoice", key: "cheap/default" },
+                        skillModel: { kind: "profileChoice", key: "sum/default" },
+                        postActionModel: { kind: "profileChoice", key: "cheap/default" }
+                    }
+                }
+            ]
+        };
+        const runtime = (0, api_js_1.buildRuntimeObject)({
+            jobId: "job-compile-1",
+            mode: "simulate",
+            input: { target_subnet_cidr: "10.0.0.0/24" }
+        });
+        const before = structuredClone(doc);
+        const plan = (0, api_js_1.compileExecutablePlan)(doc, runtime, {
+            profileRegistry: { version: "3.0.0", registryHash: "sha256:profiles456" },
+            environment: "prod"
+        });
+        strict_1.default.deepEqual(doc, before);
+        strict_1.default.equal(plan.format, "x12i.graphenix.executable-plan/v1");
+        strict_1.default.equal(plan.source.graphId, doc.id);
+        strict_1.default.equal(plan.runtimeBinding.jobId, "job-compile-1");
+        strict_1.default.equal(plan.caseSelection.graph.caseId, "simulate");
+        strict_1.default.equal(plan.profileRegistry.version, "3.0.0");
+        const profileExt = plan.graph.graph.metadata?.extensions?.[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+        strict_1.default.equal("default" in (profileExt?.modelConfig ?? {}), false);
+        const professionalPlan = plan.nodePlans["node:professional-answer"];
+        strict_1.default.equal(professionalPlan?.modelSlots?.skillModel?.selection.kind, "profileChoice");
+        strict_1.default.equal((0, api_js_1.validateExecutablePlan)(plan).valid, true);
+    });
+    (0, node_test_1.it)("AC-E003/E006/E008: executable plan is normalized with resolved node slots", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const runtime = (0, api_js_1.buildRuntimeObject)({ jobId: "job-plan-1" });
+        const plan = (0, api_js_1.compileExecutablePlan)(doc, runtime);
+        strict_1.default.equal((0, api_js_1.validateExecutablePlan)(plan).valid, true);
+        strict_1.default.ok(plan.nodePlans["node:professional-answer"]?.modelSlots?.preActionModel);
+        strict_1.default.equal("credentials" in plan, false);
+    });
+    (0, node_test_1.it)("AC-T001/T002/T011: execution trace references plan and keeps append-only events", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const runtime = (0, api_js_1.buildRuntimeObject)({ jobId: "job-trace-1", mode: "live" });
+        const plan = (0, api_js_1.compileExecutablePlan)(doc, runtime);
+        const trace = (0, api_js_1.createExecutionTrace)(plan, runtime);
+        strict_1.default.equal(trace.source.graphId, plan.source.graphId);
+        strict_1.default.equal(trace.plan.planId, plan.planId);
+        strict_1.default.equal(trace.status, "queued");
+        const startedAt = "2026-06-06T12:00:01.000Z";
+        const updated = (0, api_js_1.appendExecutionEvent)(trace, {
+            id: "evt:1",
+            ts: startedAt,
+            level: "info",
+            type: "graph.started",
+            message: "Graph execution started."
+        });
+        strict_1.default.equal(updated.events.length, 1);
+        strict_1.default.notEqual(updated, trace);
+        strict_1.default.equal((0, api_js_1.validateExecutionTrace)(updated, plan.nodePlans).valid, true);
+        const nodeTrace = updated.nodeExecutions["node:professional-answer"];
+        strict_1.default.ok(nodeTrace?.units["unit:node:professional-answer:skill"]);
+    });
+});
+function getTaskNode(doc, nodeId = "node:professional-answer") {
+    return doc.graph.nodes.find((node) => node.id === nodeId);
+}
+function setTaskConfiguration(doc, config) {
+    const node = getTaskNode(doc);
+    const params = node.parameters;
+    strict_1.default.ok(params && params.nodeType === "task");
+    node.parameters = {
+        ...params,
+        taskConfiguration: config
+    };
+    return doc;
+}
+function setGraphPolicies(doc, policies) {
+    const ext = doc.graph.metadata.extensions[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+    ext.policies = policies;
+    return doc;
+}
+(0, node_test_1.describe)("execution units", () => {
+    (0, node_test_1.it)("AC-001: task node with no preActions/postActions compiles into one skill unit", () => {
+        const doc = (0, minimal_executable_graph_js_1.createMinimalExecutableGraph)();
+        const runtime = (0, api_js_1.buildRuntimeObject)({ jobId: "job-units-1" });
+        const plan = (0, api_js_1.compileExecutablePlan)(doc, runtime);
+        const units = plan.nodePlans["node:professional-answer"].executionUnits;
+        strict_1.default.equal(units.length, 1);
+        strict_1.default.equal(units[0].unitKind, "skill");
+        strict_1.default.equal(units[0].unitId, "unit:node:professional-answer:skill");
+    });
+    (0, node_test_1.it)("AC-002/003/004: preActions before skill and postActions after with stable order", () => {
+        const doc = setTaskConfiguration((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            preActions: [
+                { id: "pre:a", actionKey: "prepare-input" },
+                { id: "pre:b", actionKey: "normalize-input" }
+            ],
+            postActions: [
+                { id: "post:a", actionKey: "validate-output" },
+                { id: "post:b", actionKey: "shape-response" }
+            ]
+        });
+        const plan = (0, api_js_1.compileExecutablePlan)(doc, (0, api_js_1.buildRuntimeObject)({ jobId: "job-units-2" }));
+        const units = plan.nodePlans["node:professional-answer"].executionUnits;
+        strict_1.default.equal(units.length, 5);
+        strict_1.default.deepEqual(units.map((unit) => [unit.order, unit.unitKind, unit.actionKey ?? unit.skillKey]), [
+            [0, "preAction", "prepare-input"],
+            [1, "preAction", "normalize-input"],
+            [2, "skill", "professional-answer"],
+            [3, "postAction", "validate-output"],
+            [4, "postAction", "shape-response"]
+        ]);
+    });
+    (0, node_test_1.it)("AC-005/006/007: units use resolved node model slots", () => {
+        const doc = setTaskConfiguration((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            preActions: [{ id: "pre:a", actionKey: "prepare-input" }],
+            postActions: [{ id: "post:a", actionKey: "validate-output" }]
+        });
+        const plan = (0, api_js_1.compileExecutablePlan)(doc, (0, api_js_1.buildRuntimeObject)({ jobId: "job-units-3" }));
+        const nodePlan = plan.nodePlans["node:professional-answer"];
+        const pre = nodePlan.executionUnits.find((unit) => unit.unitKind === "preAction");
+        const skill = nodePlan.executionUnits.find((unit) => unit.unitKind === "skill");
+        const post = nodePlan.executionUnits.find((unit) => unit.unitKind === "postAction");
+        strict_1.default.equal(pre.modelSlot, "preActionModel");
+        if (pre.modelSelection?.kind === "profileChoice") {
+            strict_1.default.equal(pre.modelSelection.key, "cheap/default");
+        }
+        strict_1.default.equal(skill.modelSlot, "skillModel");
+        if (skill.modelSelection?.kind === "profileChoice") {
+            strict_1.default.equal(skill.modelSelection.key, "vol/default");
+        }
+        strict_1.default.equal(post.modelSlot, "postActionModel");
+        if (post.modelSelection?.kind === "profileChoice") {
+            strict_1.default.equal(post.modelSelection.key, "cheap/default");
+        }
+    });
+    (0, node_test_1.it)("AC-008/009: node skillModel override does not affect pre/post units", () => {
+        const doc = setTaskConfiguration((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            modelConfig: {
+                inherit: true,
+                modelConfig: {
+                    skillModel: { kind: "profileChoice", key: "deep/openai_deep" }
+                }
+            },
+            preActions: [{ id: "pre:a", actionKey: "prepare-input" }],
+            postActions: [{ id: "post:a", actionKey: "validate-output" }]
+        });
+        const plan = (0, api_js_1.compileExecutablePlan)(doc, (0, api_js_1.buildRuntimeObject)({ jobId: "job-units-4" }));
+        const units = plan.nodePlans["node:professional-answer"].executionUnits;
+        const pre = units.find((unit) => unit.unitKind === "preAction");
+        const skill = units.find((unit) => unit.unitKind === "skill");
+        const post = units.find((unit) => unit.unitKind === "postAction");
+        if (pre.modelSelection?.kind === "profileChoice") {
+            strict_1.default.equal(pre.modelSelection.key, "cheap/default");
+        }
+        if (skill.modelSelection?.kind === "profileChoice") {
+            strict_1.default.equal(skill.modelSelection.key, "deep/openai_deep");
+        }
+        if (post.modelSelection?.kind === "profileChoice") {
+            strict_1.default.equal(post.modelSelection.key, "cheap/default");
+        }
+    });
+    (0, node_test_1.it)("AC-010: action-level model override fails when policy disabled", () => {
+        const doc = setTaskConfiguration((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            preActions: [
+                {
+                    id: "pre:a",
+                    actionKey: "prepare-input",
+                    modelSelection: { kind: "profileChoice", key: "vol/pro" }
+                }
+            ]
+        });
+        const result = (0, api_js_1.validateAuthoringGraph)(doc);
+        strict_1.default.ok(result.errors.some((e) => e.code === "TASK_ACTION_MODEL_OVERRIDE_FORBIDDEN"));
+    });
+    (0, node_test_1.it)("AC-011/012: action-level model override passes when policy enabled", () => {
+        const doc = setGraphPolicies(setTaskConfiguration((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            preActions: [
+                {
+                    id: "pre:a",
+                    actionKey: "prepare-input",
+                    modelSelection: { kind: "profileChoice", key: "vol/pro" }
+                }
+            ]
+        }), { allowActionLevelModelOverride: true });
+        strict_1.default.equal((0, api_js_1.validateAuthoringGraph)(doc).valid, true);
+        const plan = (0, api_js_1.compileExecutablePlan)(doc, (0, api_js_1.buildRuntimeObject)({ jobId: "job-units-5" }));
+        const pre = plan.nodePlans["node:professional-answer"].executionUnits[0];
+        strict_1.default.equal(pre.modelSource, "actionOverride");
+        if (pre.modelSelection?.kind === "profileChoice") {
+            strict_1.default.equal(pre.modelSelection.key, "vol/pro");
+        }
+    });
+    (0, node_test_1.it)("AC-013: bare profile key in action-level override fails", () => {
+        const doc = setGraphPolicies(setTaskConfiguration((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            preActions: [
+                {
+                    id: "pre:a",
+                    actionKey: "prepare-input",
+                    modelSelection: { kind: "profileChoice", key: "cheap" }
+                }
+            ]
+        }), { allowActionLevelModelOverride: true });
+        const result = (0, api_js_1.validateAuthoringGraph)(doc);
+        strict_1.default.ok(result.errors.some((e) => e.code === "PROFILE_CHOICE_KEY_FORMAT_INVALID"));
+    });
+    (0, node_test_1.it)("AC-014/015/016: unit fallback stays on same slot only", () => {
+        const resolvedPre = (0, api_js_1.resolveNodeModelSlot)({
+            slot: "preActionModel",
+            graphSelection: { kind: "profileChoice", key: "cheap/default" },
+            nodeSelection: { kind: "profileChoice", key: "vol/pro" },
+            fallbackPolicy: {
+                enabled: true,
+                allowedTriggers: ["nodeModelUnavailable"],
+                maxAttemptsPerSlot: 1
+            },
+            availabilityResult: {
+                available: false,
+                trigger: "nodeModelUnavailable"
+            },
+            graphCaseId: "default",
+            nodeId: "node:professional-answer"
+        });
+        strict_1.default.equal(resolvedPre.source, "fallbackToGraphDefault");
+        if (resolvedPre.selected.kind === "profileChoice") {
+            strict_1.default.equal(resolvedPre.selected.key, "cheap/default");
+        }
+        const plan = (0, api_js_1.compileExecutablePlan)(setTaskConfiguration((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            preActions: [{ id: "pre:a", actionKey: "prepare-input" }],
+            postActions: [{ id: "post:a", actionKey: "validate-output" }]
+        }), (0, api_js_1.buildRuntimeObject)({ jobId: "job-units-fallback" }));
+        const units = plan.nodePlans["node:professional-answer"].executionUnits;
+        strict_1.default.ok(units.every((unit) => unit.modelSlot !== "skillModel" || unit.unitKind === "skill"));
+        strict_1.default.ok(units.every((unit) => unit.modelSlot !== "postActionModel" || unit.unitKind === "postAction"));
+        strict_1.default.ok(units.every((unit) => unit.modelSlot !== "preActionModel" || unit.unitKind === "preAction"));
+    });
+    (0, node_test_1.it)("AC-017/018/019: execution trace records planned units and unit fallback", () => {
+        const doc = setTaskConfiguration((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            preActions: [{ id: "pre:a", actionKey: "prepare-input" }],
+            postActions: [{ id: "post:a", actionKey: "validate-output" }]
+        });
+        const runtime = (0, api_js_1.buildRuntimeObject)({ jobId: "job-units-6" });
+        const plan = (0, api_js_1.compileExecutablePlan)(doc, runtime);
+        const trace = (0, api_js_1.createExecutionTrace)(plan, runtime);
+        const nodeTrace = trace.nodeExecutions["node:professional-answer"];
+        strict_1.default.equal(Object.keys(nodeTrace.units).length, 3);
+        const skillUnitId = "unit:node:professional-answer:skill";
+        nodeTrace.units[skillUnitId] = {
+            ...nodeTrace.units[skillUnitId],
+            status: "completed",
+            resolvedInvocation: {
+                provider: "openai",
+                modelId: "gpt-4o",
+                profileChoiceKey: "vol/default"
+            },
+            fallback: {
+                applied: true,
+                trigger: "nodeModelUnavailable",
+                from: { kind: "profileChoice", key: "vol/pro" },
+                to: { kind: "profileChoice", key: "vol/default" }
+            }
+        };
+        const invalidFallback = structuredClone(trace);
+        invalidFallback.nodeExecutions["node:professional-answer"].units[skillUnitId].fallback = {
+            applied: true,
+            trigger: "nodeModelTransientFailure"
+        };
+        const invalidPolicyPlan = structuredClone(plan);
+        invalidPolicyPlan.nodePlans["node:professional-answer"].fallbackPolicy = {
+            enabled: true,
+            allowedTriggers: ["nodeModelUnavailable"]
+        };
+        strict_1.default.equal((0, api_js_1.validateExecutionTrace)(invalidFallback, invalidPolicyPlan.nodePlans).valid, false);
+        const withEvent = (0, api_js_1.appendExecutionEvent)(trace, {
+            id: "evt:unit:1",
+            ts: "2026-06-06T12:00:02.100Z",
+            level: "info",
+            type: "executionUnit.model.resolved",
+            nodeId: "node:professional-answer",
+            unitId: skillUnitId,
+            evidence: {
+                unitKind: "skill",
+                modelSlot: "skillModel",
+                profileChoiceKey: "vol/default",
+                source: "graphDefault"
+            }
+        });
+        strict_1.default.equal(withEvent.events[0].type, "executionUnit.model.resolved");
+    });
+    (0, node_test_1.it)("AC-020: graph, plan, and trace remain implementation-agnostic", () => {
+        const doc = setTaskConfiguration((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+            preActions: [{ id: "pre:a", actionKey: "prepare-input" }]
+        });
+        const runtime = (0, api_js_1.buildRuntimeObject)({ jobId: "job-units-7" });
+        const plan = (0, api_js_1.compileExecutablePlan)(doc, runtime);
+        const trace = (0, api_js_1.createExecutionTrace)(plan, runtime);
+        const serialized = JSON.stringify({ doc, plan, trace });
+        for (const forbidden of ["openrouter", "anthropic-sdk", "langchain"]) {
+            strict_1.default.equal(serialized.includes(forbidden), false);
+        }
+    });
+});
+//# sourceMappingURL=executable-format.test.js.map