@x12i/graphenix-executable-format 1.0.0 → 2.0.1

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

@@ -1,62 +1,55 @@
-"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");
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { validateGraph } from "@x12i/graphenix-core";
+import { assertExecutableGraph, validateExecutableGraph, validateStudioExecuteRequest, validateRuntimeObject, buildGraphExecutionRequestFromStudioExecute, resolveNodeAiPlan, explainNodeInheritance, resolveNodeModelSlot, normalizeExecutableGraph, validateCaseCondition, evaluateCaseCondition, isProfileChoiceKeyFormat, isKnownProfileChoice, buildDeterministicCaseContext, compileExecutablePlan, validateExecutablePlan, validateAuthoringGraph, createExecutionTrace, appendExecutionEvent, validateExecutionTrace, buildRuntimeObject, createMinimalExecutableGraph, createPlainGraphenixGraph, migrateLegacyGraphModelObjectToGraphenixExecutable, validateAuthoringExecutableGraph } from "../api.js";
+import { EXECUTABLE_PROFILE_NAMESPACE } from "@x12i/graphenix-executable-contracts";
 function setGraphModelConfig(doc, modelConfig) {
     const next = structuredClone(doc);
-    const ext = next.graph.metadata.extensions[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+    const ext = next.graph.metadata.extensions[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);
+describe("graphenix base validation", () => {
+    it("valid executable graph passes Graphenix validateGraph()", () => {
+        const doc = createMinimalExecutableGraph();
+        const result = validateGraph(doc);
+        assert.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];
+describe("executable profile validation", () => {
+    it("valid executable graph passes assertExecutableGraph()", () => {
+        const doc = createMinimalExecutableGraph();
+        assert.doesNotThrow(() => assertExecutableGraph(doc));
+    });
+    it("plain Graphenix graph without executable profile fails", () => {
+        const doc = createPlainGraphenixGraph();
+        const result = validateExecutableGraph(doc);
+        assert.equal(result.valid, false);
+        assert.ok(result.errors.some((e) => e.code === "EXECUTABLE_PROFILE_MISSING"));
+    });
+    it("graph-level modelConfig is required", () => {
+        const doc = createMinimalExecutableGraph();
+        const ext = doc.graph.metadata.extensions[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"));
+        const result = validateExecutableGraph(doc);
+        assert.equal(result.valid, false);
+        assert.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)();
+describe("model inheritance", () => {
+    it("node with no modelConfig inherits all slots", () => {
+        const doc = createMinimalExecutableGraph();
+        const plan = resolveNodeAiPlan(doc, "node:professional-answer");
+        assert.equal(plan.slots.preActionModel.inherited, true);
+        assert.equal(plan.slots.skillModel.inherited, true);
+        assert.equal(plan.slots.postActionModel.inherited, true);
+        assert.match(explainNodeInheritance(plan), /graph case default/);
+    });
+    it("node may override only skillModel", () => {
+        const doc = 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");
+        assert.ok(params && params.nodeType === "task");
         taskNode.parameters = {
             ...params,
             taskConfiguration: {
@@ -67,14 +60,14 @@ function setGraphModelConfig(doc, modelConfig) {
                 }
             }
         };
-        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);
+        const plan = resolveNodeAiPlan(doc, "node:professional-answer");
+        assert.equal(plan.slots.skillModel.inherited, false);
+        assert.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)({
+describe("model fallback", () => {
+    it("fallback uses graph same-slot only", () => {
+        const resolved = resolveNodeModelSlot({
             slot: "skillModel",
             graphSelection: { kind: "profileChoice", key: "vol/default" },
             nodeSelection: {
@@ -95,33 +88,33 @@ function setGraphModelConfig(doc, modelConfig) {
             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");
+        assert.equal(resolved.source, "fallbackToGraphDefault");
+        assert.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)({
+    it("fallback does not use runtime or request model defaults", () => {
+        const runtime = validateRuntimeObject({
             jobId: "job-1",
             job: { id: "job-1", jobId: "job-1" },
             graphDefaultModel: { kind: "profileChoice", key: "cheap/default" }
         });
-        strict_1.default.equal(runtime.valid, false);
+        assert.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)({
+describe("studio adapter", () => {
+    it("studio request with graphDefaultModel fails", () => {
+        const doc = createMinimalExecutableGraph();
+        const result = 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"));
+        assert.equal(result.valid, false);
+        assert.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];
+    it("studio adapter outputs compiled { plan, runtime }", () => {
+        const doc = createMinimalExecutableGraph();
+        const ext = doc.graph.metadata.extensions[EXECUTABLE_PROFILE_NAMESPACE];
         ext.modelConfig = {
             version: "graph-model-config/v1",
             default: {
@@ -139,87 +132,121 @@ function setGraphModelConfig(doc, modelConfig) {
             },
             openrouterApiKey: "secret-should-not-copy"
         };
-        const execution = (0, api_js_1.buildGraphExecutionRequestFromStudioExecute)(request, {
+        const execution = 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);
+        assert.equal(execution.runtime.jobId, "job-123");
+        assert.equal(execution.plan.source.graphId, doc.id);
+        assert.equal(execution.plan.format, "graphenix.executable-plan/v1");
+        assert.equal("openrouterApiKey" in execution.runtime, false);
+        assert.equal("openrouterApiKey" in execution.plan, false);
+        const profile = execution.plan.graph.graph.metadata?.extensions?.[EXECUTABLE_PROFILE_NAMESPACE];
+        assert.equal(profile?.modelConfig?.cases?.[0]?.id, "default");
+        assert.equal(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)({
+describe("runtime validation", () => {
+    it("credentials are never copied into runtime", () => {
+        const result = validateRuntimeObject({
             jobId: "job-1",
             job: { id: "job-1", jobId: "job-1" },
             credentials: { token: "x" }
         });
-        strict_1.default.equal(result.valid, false);
+        assert.equal(result.valid, false);
     });
-    (0, node_test_1.it)("runtime modelConfig is rejected", () => {
-        const result = (0, api_js_1.validateRuntimeObject)({
+    it("runtime modelConfig is rejected", () => {
+        const result = validateRuntimeObject({
             jobId: "job-1",
             job: { id: "job-1", jobId: "job-1" },
             modelConfig: {}
         });
-        strict_1.default.equal(result.valid, false);
+        assert.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)({
+describe("legacy migration CRS-001", () => {
+    it("flat exellix graph migrates into valid authoring document", () => {
+        const migrated = migrateLegacyGraphModelObjectToGraphenixExecutable({
             id: "graph:legacy",
             version: "0.1.0",
             nodes: [
                 {
                     id: "node:a",
-                    kind: "task",
-                    skillKey: "demo"
+                    type: "task",
+                    skillKey: "professional-answer",
+                    conditions: {
+                        jsonConditions: { path: "runtime.input.ready", op: "eq", value: true }
+                    },
+                    smartInput: { paths: ["runtime.input.question"] },
+                    taskKnowledge: ["kb:faq"]
+                },
+                {
+                    id: "node:finalizer",
+                    type: "finalizer",
+                    finalizerType: "single-output",
+                    config: { from: "node:a" }
                 }
             ],
-            edges: [],
+            edges: [{ from: "node:a", to: "node:finalizer" }],
             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" }
+                            preActionModel: "cheap",
+                            skillModel: "balanced",
+                            postActionModel: "deep"
                         }
                     }
                 ]
-            }
+            },
+            metadata: {
+                graphEntry: {
+                    dataFilters: {
+                        version: "exellix.structured-data-filters/v1",
+                        when: { path: "runtime.input.tenant", op: "exists" }
+                    }
+                }
+            },
+            jobKnowledge: ["kb:job"]
         });
-        strict_1.default.equal(migrated.formatVersion, graphenix_core_2.GRAPHENIX_FORMAT_VERSION);
-        strict_1.default.doesNotThrow(() => (0, api_js_1.assertExecutableGraph)(migrated));
+        assert.equal(migrated.id, "graph:legacy");
+        assert.equal(migrated.graph.nodes.length, 2);
+        assert.equal(migrated.graph.nodes[0]?.kind, "task");
+        assert.equal((migrated.graph.nodes[0]?.parameters).skillKey, "professional-answer");
+        const conditions = (migrated.graph.nodes[0]?.parameters)
+            .conditions;
+        assert.ok(Array.isArray(conditions.runWhen));
+        const smartInput = (migrated.graph.nodes[0]?.parameters)
+            .smartInput;
+        assert.deepEqual(smartInput?.paths, [{ path: "runtime.input.question" }]);
+        const profile = migrated.graph.metadata?.extensions?.["graphenix.executable/v1"];
+        const triplet = profile?.modelConfig?.cases?.[0]?.modelConfig;
+        assert.equal(triplet?.preActionModel?.kind, "profileChoice");
+        assert.equal(triplet?.preActionModel?.key, "cheap/default");
+        assert.equal(triplet?.skillModel?.key, "vol/default");
+        assert.equal(triplet?.postActionModel?.key, "deep/openai_deep");
+        assert.equal(validateAuthoringExecutableGraph(migrated).valid, true);
     });
 });
-(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)();
+describe("node kinds", () => {
+    it("task nodes must use kind task", () => {
+        const doc = 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"));
+        const result = validateExecutableGraph(doc);
+        assert.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)({
+describe("deterministic cases", () => {
+    it("AC-001: runtime.mode eq simulate is accepted", () => {
+        const errors = validateCaseCondition({
             path: "runtime.mode",
             op: "eq",
             value: "simulate"
         });
-        strict_1.default.equal(errors.length, 0);
+        assert.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)(), {
+    it("AC-007/008: first matching case is selected, else default", () => {
+        const doc = setGraphModelConfig(createMinimalExecutableGraph(), {
             version: "graph-model-config/v1",
             cases: [
                 {
@@ -241,12 +268,12 @@ function setGraphModelConfig(doc, modelConfig) {
                 }
             ]
         });
-        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");
+        const context = buildDeterministicCaseContext(doc, { mode: "simulate" });
+        const plan = resolveNodeAiPlan(doc, "node:professional-answer", context);
+        assert.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)(), {
+    it("AC-009/010: default case requirements", () => {
+        const noDefault = validateExecutableGraph(setGraphModelConfig(createMinimalExecutableGraph(), {
             version: "graph-model-config/v1",
             cases: [
                 {
@@ -260,51 +287,51 @@ function setGraphModelConfig(doc, modelConfig) {
                 }
             ]
         }));
-        strict_1.default.ok(noDefault.errors.some((e) => e.code === "CASE_SELECTION_DEFAULT_MISSING"));
+        assert.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"));
+describe("forbidden AI selectors", () => {
+    it("AC-020: ai.prompt is rejected", () => {
+        const errors = validateCaseCondition({ ai: { prompt: "complex?" } });
+        assert.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)({
+    it("AC-024: ai.classification path is rejected", () => {
+        const errors = validateCaseCondition({
             path: "ai.classification.risk",
             op: "eq",
             value: "high"
         });
-        strict_1.default.ok(errors.some((e) => e.code === "CASE_CONDITION_FORBIDDEN_PATH"));
+        assert.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)({
+    it("AC-025: node.output path is rejected", () => {
+        const errors = validateCaseCondition({
             path: "node.output.riskClassifier.risk",
             op: "eq",
             value: "high"
         });
-        strict_1.default.ok(errors.some((e) => e.code === "CASE_CONDITION_FORBIDDEN_PATH"));
+        assert.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", () => {
+describe("profile-choice validation", () => {
+    it("AC-030/031/032: valid profileChoice keys accepted", () => {
+        assert.equal(isProfileChoiceKeyFormat("cheap/default"), true);
+        assert.equal(isProfileChoiceKeyFormat("vol/default"), true);
+        assert.equal(isProfileChoiceKeyFormat("deep/openai_deep"), true);
+        assert.equal(isKnownProfileChoice("vol/pro"), true);
+    });
+    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);
+            assert.equal(isProfileChoiceKeyFormat(key), false);
         }
     });
-    (0, node_test_1.it)("AC-037/038: vendor slugs and legacy aliases rejected", () => {
+    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);
+        assert.equal(isProfileChoiceKeyFormat("openai/gpt-4o-mini"), true);
+        assert.equal(isKnownProfileChoice("openai/gpt-4o-mini"), false);
+        assert.equal(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)(), {
+    it("AC-039: unknown choice rejected in graph validation", () => {
+        const result = validateExecutableGraph(setGraphModelConfig(createMinimalExecutableGraph(), {
             version: "graph-model-config/v1",
             cases: [
                 {
@@ -317,10 +344,10 @@ function setGraphModelConfig(doc, modelConfig) {
                 }
             ]
         }));
-        strict_1.default.ok(result.errors.some((e) => e.code === "PROFILE_CHOICE_KEY_UNKNOWN"));
+        assert.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)(), {
+    it("deprecated kind profile is rejected", () => {
+        const result = validateExecutableGraph(setGraphModelConfig(createMinimalExecutableGraph(), {
             version: "graph-model-config/v1",
             cases: [
                 {
@@ -333,13 +360,13 @@ function setGraphModelConfig(doc, modelConfig) {
                 }
             ]
         }));
-        strict_1.default.ok(result.errors.some((e) => e.code === "PROFILE_SELECTION_KIND_DEPRECATED"));
+        assert.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];
+describe("normalization", () => {
+    it("AC-060: graph default shorthand normalizes to cases[0].id = default", () => {
+        const doc = createMinimalExecutableGraph();
+        const ext = doc.graph.metadata.extensions[EXECUTABLE_PROFILE_NAMESPACE];
         ext.modelConfig = {
             version: "graph-model-config/v1",
             default: {
@@ -348,25 +375,25 @@ function setGraphModelConfig(doc, modelConfig) {
                 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);
+        const normalized = normalizeExecutableGraph(doc);
+        const profile = normalized.graph.metadata?.extensions?.[EXECUTABLE_PROFILE_NAMESPACE];
+        assert.equal(profile?.modelConfig?.cases?.[0]?.id, "default");
+        assert.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)();
+    it("AC-066: normalization does not mutate source graph", () => {
+        const doc = createMinimalExecutableGraph();
         const before = structuredClone(doc);
-        (0, api_js_1.normalizeExecutableGraph)(doc);
-        strict_1.default.deepEqual(doc, before);
+        normalizeExecutableGraph(doc);
+        assert.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)();
+describe("full resolution example", () => {
+    it("matches CR/FR section 12 resolution", () => {
+        const doc = 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];
+        assert.ok(params && params.nodeType === "task");
+        const ext = doc.graph.metadata.extensions[EXECUTABLE_PROFILE_NAMESPACE];
         ext.modelConfig = {
             version: "graph-model-config/v1",
             cases: [
@@ -439,51 +466,51 @@ function setGraphModelConfig(doc, modelConfig) {
                 }
             }
         };
-        const context = (0, api_js_1.buildDeterministicCaseContext)(doc, {
+        const context = 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");
+        const plan = resolveNodeAiPlan(doc, "node:professional-answer", context);
+        assert.equal(plan.graphCaseId, "deep-live");
+        assert.equal(plan.nodeCaseId, "high-risk-input");
+        assert.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");
+            assert.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");
+            assert.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")));
+        assert.ok(plan.caseSelection.graph.matchedConditions.some((c) => c.includes("runtime.mode eq live")));
+        assert.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)(), {
+describe("evaluateCaseCondition", () => {
+    it("AC-004/005/006: all, any, not supported", () => {
+        const context = buildDeterministicCaseContext(createMinimalExecutableGraph(), {
             mode: "live",
             input: { riskLevel: "high", tier: "gold" }
         });
-        strict_1.default.equal((0, api_js_1.evaluateCaseCondition)({
+        assert.equal(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)({
+        assert.equal(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)({
+        assert.equal(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];
+describe("lifecycle artifacts", () => {
+    it("AC-A001/A005: authoring graph with modelConfig.default passes", () => {
+        const doc = createMinimalExecutableGraph();
+        const ext = doc.graph.metadata.extensions[EXECUTABLE_PROFILE_NAMESPACE];
         ext.modelConfig = {
             version: "graph-model-config/v1",
             default: {
@@ -492,10 +519,10 @@ function setGraphModelConfig(doc, modelConfig) {
                 postActionModel: { kind: "profileChoice", key: "cheap/default" }
             }
         };
-        strict_1.default.equal((0, api_js_1.validateAuthoringGraph)(doc).valid, true);
+        assert.equal(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)(), {
+    it("AC-A003/A004: bare profile and kind profile fail authoring validation", () => {
+        const bareProfile = validateAuthoringGraph(setGraphModelConfig(createMinimalExecutableGraph(), {
             version: "graph-model-config/v1",
             cases: [
                 {
@@ -508,8 +535,8 @@ function setGraphModelConfig(doc, modelConfig) {
                 }
             ]
         }));
-        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)(), {
+        assert.ok(bareProfile.errors.some((e) => e.code === "PROFILE_CHOICE_KEY_FORMAT_INVALID"));
+        const kindProfile = validateAuthoringGraph(setGraphModelConfig(createMinimalExecutableGraph(), {
             version: "graph-model-config/v1",
             cases: [
                 {
@@ -522,11 +549,11 @@ function setGraphModelConfig(doc, modelConfig) {
                 }
             ]
         }));
-        strict_1.default.ok(kindProfile.errors.some((e) => e.code === "PROFILE_SELECTION_KIND_DEPRECATED"));
+        assert.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];
+    it("AC-P001/P003/P008/P009/P010: compile produces run-bound executable plan", () => {
+        const doc = createMinimalExecutableGraph();
+        const ext = doc.graph.metadata.extensions[EXECUTABLE_PROFILE_NAMESPACE];
         ext.modelConfig = {
             version: "graph-model-config/v1",
             cases: [
@@ -549,57 +576,57 @@ function setGraphModelConfig(doc, modelConfig) {
                 }
             ]
         };
-        const runtime = (0, api_js_1.buildRuntimeObject)({
+        const runtime = 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, {
+        const plan = 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);
+        assert.deepEqual(doc, before);
+        assert.equal(plan.format, "graphenix.executable-plan/v1");
+        assert.equal(plan.source.graphId, doc.id);
+        assert.equal(plan.runtimeBinding.jobId, "job-compile-1");
+        assert.equal(plan.caseSelection.graph.caseId, "simulate");
+        assert.equal(plan.profileRegistry.version, "3.0.0");
+        const profileExt = plan.graph.graph.metadata?.extensions?.[EXECUTABLE_PROFILE_NAMESPACE];
+        assert.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");
+        assert.equal(professionalPlan?.modelSlots?.skillModel?.selection.kind, "profileChoice");
+        assert.equal(validateExecutablePlan(plan).valid, true);
+    });
+    it("AC-E003/E006/E008: executable plan is normalized with resolved node slots", () => {
+        const doc = createMinimalExecutableGraph();
+        const runtime = buildRuntimeObject({ jobId: "job-plan-1" });
+        const plan = compileExecutablePlan(doc, runtime);
+        assert.equal(validateExecutablePlan(plan).valid, true);
+        assert.ok(plan.nodePlans["node:professional-answer"]?.modelSlots?.preActionModel);
+        assert.equal("credentials" in plan, false);
+    });
+    it("AC-T001/T002/T011: execution trace references plan and keeps append-only events", () => {
+        const doc = createMinimalExecutableGraph();
+        const runtime = buildRuntimeObject({ jobId: "job-trace-1", mode: "live" });
+        const plan = compileExecutablePlan(doc, runtime);
+        const trace = createExecutionTrace(plan, runtime);
+        assert.equal(trace.source.graphId, plan.source.graphId);
+        assert.equal(trace.plan.planId, plan.planId);
+        assert.equal(trace.status, "queued");
         const startedAt = "2026-06-06T12:00:01.000Z";
-        const updated = (0, api_js_1.appendExecutionEvent)(trace, {
+        const updated = 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);
+        assert.equal(updated.events.length, 1);
+        assert.notEqual(updated, trace);
+        assert.equal(validateExecutionTrace(updated, plan.nodePlans).valid, true);
         const nodeTrace = updated.nodeExecutions["node:professional-answer"];
-        strict_1.default.ok(nodeTrace?.units["unit:node:professional-answer:skill"]);
+        assert.ok(nodeTrace?.units["unit:node:professional-answer:skill"]);
     });
 });
 function getTaskNode(doc, nodeId = "node:professional-answer") {
@@ -608,7 +635,7 @@ function getTaskNode(doc, nodeId = "node:professional-answer") {
 function setTaskConfiguration(doc, config) {
     const node = getTaskNode(doc);
     const params = node.parameters;
-    strict_1.default.ok(params && params.nodeType === "task");
+    assert.ok(params && params.nodeType === "task");
     node.parameters = {
         ...params,
         taskConfiguration: config
@@ -616,22 +643,22 @@ function setTaskConfiguration(doc, config) {
     return doc;
 }
 function setGraphPolicies(doc, policies) {
-    const ext = doc.graph.metadata.extensions[constants_js_1.EXECUTABLE_PROFILE_NAMESPACE];
+    const ext = doc.graph.metadata.extensions[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);
+describe("execution units", () => {
+    it("AC-001: task node with no preActions/postActions compiles into one skill unit", () => {
+        const doc = createMinimalExecutableGraph();
+        const runtime = buildRuntimeObject({ jobId: "job-units-1" });
+        const plan = 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");
+        assert.equal(units.length, 1);
+        assert.equal(units[0].unitKind, "skill");
+        assert.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)(), {
+    it("AC-002/003/004: preActions before skill and postActions after with stable order", () => {
+        const doc = setTaskConfiguration(createMinimalExecutableGraph(), {
             preActions: [
                 { id: "pre:a", actionKey: "prepare-input" },
                 { id: "pre:b", actionKey: "normalize-input" }
@@ -641,10 +668,10 @@ function setGraphPolicies(doc, policies) {
                 { id: "post:b", actionKey: "shape-response" }
             ]
         });
-        const plan = (0, api_js_1.compileExecutablePlan)(doc, (0, api_js_1.buildRuntimeObject)({ jobId: "job-units-2" }));
+        const plan = compileExecutablePlan(doc, 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]), [
+        assert.equal(units.length, 5);
+        assert.deepEqual(units.map((unit) => [unit.order, unit.unitKind, unit.actionKey ?? unit.skillKey]), [
             [0, "preAction", "prepare-input"],
             [1, "preAction", "normalize-input"],
             [2, "skill", "professional-answer"],
@@ -652,31 +679,31 @@ function setGraphPolicies(doc, policies) {
             [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)(), {
+    it("AC-005/006/007: units use resolved node model slots", () => {
+        const doc = setTaskConfiguration(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 plan = compileExecutablePlan(doc, 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");
+        assert.equal(pre.modelSlot, "preActionModel");
         if (pre.modelSelection?.kind === "profileChoice") {
-            strict_1.default.equal(pre.modelSelection.key, "cheap/default");
+            assert.equal(pre.modelSelection.key, "cheap/default");
         }
-        strict_1.default.equal(skill.modelSlot, "skillModel");
+        assert.equal(skill.modelSlot, "skillModel");
         if (skill.modelSelection?.kind === "profileChoice") {
-            strict_1.default.equal(skill.modelSelection.key, "vol/default");
+            assert.equal(skill.modelSelection.key, "vol/default");
         }
-        strict_1.default.equal(post.modelSlot, "postActionModel");
+        assert.equal(post.modelSlot, "postActionModel");
         if (post.modelSelection?.kind === "profileChoice") {
-            strict_1.default.equal(post.modelSelection.key, "cheap/default");
+            assert.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)(), {
+    it("AC-008/009: node skillModel override does not affect pre/post units", () => {
+        const doc = setTaskConfiguration(createMinimalExecutableGraph(), {
             modelConfig: {
                 inherit: true,
                 modelConfig: {
@@ -686,23 +713,23 @@ function setGraphPolicies(doc, policies) {
             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 plan = compileExecutablePlan(doc, 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");
+            assert.equal(pre.modelSelection.key, "cheap/default");
         }
         if (skill.modelSelection?.kind === "profileChoice") {
-            strict_1.default.equal(skill.modelSelection.key, "deep/openai_deep");
+            assert.equal(skill.modelSelection.key, "deep/openai_deep");
         }
         if (post.modelSelection?.kind === "profileChoice") {
-            strict_1.default.equal(post.modelSelection.key, "cheap/default");
+            assert.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)(), {
+    it("AC-010: action-level model override fails when policy disabled", () => {
+        const doc = setTaskConfiguration(createMinimalExecutableGraph(), {
             preActions: [
                 {
                     id: "pre:a",
@@ -711,11 +738,11 @@ function setGraphPolicies(doc, policies) {
                 }
             ]
         });
-        const result = (0, api_js_1.validateAuthoringGraph)(doc);
-        strict_1.default.ok(result.errors.some((e) => e.code === "TASK_ACTION_MODEL_OVERRIDE_FORBIDDEN"));
+        const result = validateAuthoringGraph(doc);
+        assert.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)(), {
+    it("AC-011/012: action-level model override passes when policy enabled", () => {
+        const doc = setGraphPolicies(setTaskConfiguration(createMinimalExecutableGraph(), {
             preActions: [
                 {
                     id: "pre:a",
@@ -724,16 +751,16 @@ function setGraphPolicies(doc, policies) {
                 }
             ]
         }), { 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" }));
+        assert.equal(validateAuthoringGraph(doc).valid, true);
+        const plan = compileExecutablePlan(doc, buildRuntimeObject({ jobId: "job-units-5" }));
         const pre = plan.nodePlans["node:professional-answer"].executionUnits[0];
-        strict_1.default.equal(pre.modelSource, "actionOverride");
+        assert.equal(pre.modelSource, "actionOverride");
         if (pre.modelSelection?.kind === "profileChoice") {
-            strict_1.default.equal(pre.modelSelection.key, "vol/pro");
+            assert.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)(), {
+    it("AC-013: bare profile key in action-level override fails", () => {
+        const doc = setGraphPolicies(setTaskConfiguration(createMinimalExecutableGraph(), {
             preActions: [
                 {
                     id: "pre:a",
@@ -742,11 +769,11 @@ function setGraphPolicies(doc, policies) {
                 }
             ]
         }), { 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"));
+        const result = validateAuthoringGraph(doc);
+        assert.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)({
+    it("AC-014/015/016: unit fallback stays on same slot only", () => {
+        const resolvedPre = resolveNodeModelSlot({
             slot: "preActionModel",
             graphSelection: { kind: "profileChoice", key: "cheap/default" },
             nodeSelection: { kind: "profileChoice", key: "vol/pro" },
@@ -762,29 +789,29 @@ function setGraphPolicies(doc, policies) {
             graphCaseId: "default",
             nodeId: "node:professional-answer"
         });
-        strict_1.default.equal(resolvedPre.source, "fallbackToGraphDefault");
+        assert.equal(resolvedPre.source, "fallbackToGraphDefault");
         if (resolvedPre.selected.kind === "profileChoice") {
-            strict_1.default.equal(resolvedPre.selected.key, "cheap/default");
+            assert.equal(resolvedPre.selected.key, "cheap/default");
         }
-        const plan = (0, api_js_1.compileExecutablePlan)(setTaskConfiguration((0, minimal_executable_graph_js_1.createMinimalExecutableGraph)(), {
+        const plan = compileExecutablePlan(setTaskConfiguration(createMinimalExecutableGraph(), {
             preActions: [{ id: "pre:a", actionKey: "prepare-input" }],
             postActions: [{ id: "post:a", actionKey: "validate-output" }]
-        }), (0, api_js_1.buildRuntimeObject)({ jobId: "job-units-fallback" }));
+        }), 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"));
+        assert.ok(units.every((unit) => unit.modelSlot !== "skillModel" || unit.unitKind === "skill"));
+        assert.ok(units.every((unit) => unit.modelSlot !== "postActionModel" || unit.unitKind === "postAction"));
+        assert.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)(), {
+    it("AC-017/018/019: execution trace records planned units and unit fallback", () => {
+        const doc = setTaskConfiguration(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 runtime = buildRuntimeObject({ jobId: "job-units-6" });
+        const plan = compileExecutablePlan(doc, runtime);
+        const trace = createExecutionTrace(plan, runtime);
         const nodeTrace = trace.nodeExecutions["node:professional-answer"];
-        strict_1.default.equal(Object.keys(nodeTrace.units).length, 3);
+        assert.equal(Object.keys(nodeTrace.units).length, 3);
         const skillUnitId = "unit:node:professional-answer:skill";
         nodeTrace.units[skillUnitId] = {
             ...nodeTrace.units[skillUnitId],
@@ -811,8 +838,8 @@ function setGraphPolicies(doc, policies) {
             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, {
+        assert.equal(validateExecutionTrace(invalidFallback, invalidPolicyPlan.nodePlans).valid, false);
+        const withEvent = appendExecutionEvent(trace, {
             id: "evt:unit:1",
             ts: "2026-06-06T12:00:02.100Z",
             level: "info",
@@ -826,18 +853,18 @@ function setGraphPolicies(doc, policies) {
                 source: "graphDefault"
             }
         });
-        strict_1.default.equal(withEvent.events[0].type, "executionUnit.model.resolved");
+        assert.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)(), {
+    it("AC-020: graph, plan, and trace remain implementation-agnostic", () => {
+        const doc = setTaskConfiguration(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 runtime = buildRuntimeObject({ jobId: "job-units-7" });
+        const plan = compileExecutablePlan(doc, runtime);
+        const trace = 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);
+            assert.equal(serialized.includes(forbidden), false);
         }
     });
 });