@exellix/graph-composer 2.0.0

package/dist/aiTaskProfile.js

@@ -0,0 +1,179 @@
+/** Built-in worox-graph local skills — no aiTaskProfile required. */
+export const DEFAULT_LOCAL_SKILL_KEYS = [
+    "scoped-data-reader",
+    "deterministic-rule",
+    "scoped-answer-assembler",
+    "scoped-answer-writer",
+];
+const VALID_SYNTHESIS_DESTINATIONS = new Set([
+    "job",
+    "task",
+    "execution",
+]);
+function nonEmptyString(v) {
+    return typeof v === "string" && v.trim().length > 0;
+}
+function readRecord(v) {
+    if (v === null || v === undefined || typeof v !== "object" || Array.isArray(v)) {
+        return undefined;
+    }
+    return v;
+}
+function readAiTaskProfileFromRecord(container) {
+    if (container === undefined)
+        return {};
+    const raw = container.aiTaskProfile;
+    const p = readRecord(raw);
+    if (p === undefined)
+        return {};
+    const webRaw = readRecord(p.webScoping);
+    let web;
+    if (webRaw !== undefined) {
+        const enabled = webRaw.enabled === true;
+        const qraw = webRaw.questions;
+        const questions = Array.isArray(qraw)
+            ? qraw.filter((x) => nonEmptyString(x)).map((s) => s.trim())
+            : undefined;
+        web = { enabled, ...(questions !== undefined && questions.length > 0 ? { questions } : {}) };
+    }
+    const synRaw = readRecord(p.inputSynthesis);
+    let synthesis;
+    if (synRaw !== undefined) {
+        const enabled = synRaw.enabled === true;
+        const catalogId = nonEmptyString(synRaw.catalogId)
+            ? synRaw.catalogId.trim()
+            : undefined;
+        const strategyKey = nonEmptyString(synRaw.strategyKey)
+            ? synRaw.strategyKey.trim()
+            : undefined;
+        const outputKey = nonEmptyString(synRaw.outputKey)
+            ? synRaw.outputKey.trim()
+            : undefined;
+        const mode = nonEmptyString(synRaw.mode) ? synRaw.mode.trim() : undefined;
+        const dest = synRaw.destination;
+        const destination = typeof dest === "string" &&
+            VALID_SYNTHESIS_DESTINATIONS.has(dest)
+            ? dest
+            : undefined;
+        const sourcesRaw = synRaw.sources;
+        const sources = Array.isArray(sourcesRaw)
+            ? sourcesRaw.filter((x) => nonEmptyString(x)).map((s) => s.trim())
+            : undefined;
+        synthesis = {
+            enabled,
+            ...(catalogId !== undefined ? { catalogId } : {}),
+            ...(strategyKey !== undefined ? { strategyKey } : {}),
+            ...(outputKey !== undefined ? { outputKey } : {}),
+            ...(destination !== undefined ? { destination } : {}),
+            ...(sources !== undefined && sources.length > 0 ? { sources } : {}),
+            ...(mode !== undefined ? { mode } : {}),
+        };
+    }
+    return {
+        pre: nonEmptyString(p.preStrategyKey) ? p.preStrategyKey.trim() : undefined,
+        post: nonEmptyString(p.postStrategyKey) ? p.postStrategyKey.trim() : undefined,
+        ...(web !== undefined ? { web } : {}),
+        ...(synthesis !== undefined ? { synthesis } : {}),
+    };
+}
+function hasSynthesisPipelineConflict(node) {
+    const tc = readRecord(node.taskConfiguration);
+    const profile = readRecord(tc?.aiTaskProfile);
+    const syn = readRecord(profile?.inputSynthesis);
+    if (syn?.enabled !== true)
+        return false;
+    const pipeline = node.executionPipeline ?? readRecord(tc)?.executionPipeline;
+    if (!Array.isArray(pipeline))
+        return false;
+    for (const step of pipeline) {
+        const s = readRecord(step);
+        if (s?.phase === "pre" && s?.type === "synthesized-context")
+            return true;
+    }
+    return false;
+}
+function localSkillKeySet(utilitySkills, extraLocal) {
+    const s = new Set(DEFAULT_LOCAL_SKILL_KEYS);
+    for (const u of utilitySkills ?? []) {
+        if (typeof u.skillKey === "string" && u.skillKey.trim() !== "") {
+            s.add(u.skillKey.trim());
+        }
+    }
+    if (extraLocal !== undefined) {
+        for (const k of extraLocal) {
+            if (typeof k === "string" && k.trim() !== "")
+                s.add(k.trim());
+        }
+    }
+    return s;
+}
+/**
+ * Lists **AI task** nodes that violate the **task node execution protocol**
+ * (pre/post strategies, web scoping questions, input synthesis strategy).
+ */
+export function reportTaskNodeProtocolGaps(graph, options) {
+    const localKeys = localSkillKeySet(options?.utilitySkills, options?.extraLocalSkillKeys);
+    const g = graph;
+    const nodes = g.nodes;
+    if (!Array.isArray(nodes))
+        return [];
+    const out = [];
+    for (const n of nodes) {
+        if (n === null || typeof n !== "object" || Array.isArray(n))
+            continue;
+        const node = n;
+        if (node.type !== undefined && node.type !== "task")
+            continue;
+        const id = typeof node.id === "string" ? node.id : "";
+        const skillKey = typeof node.skillKey === "string" ? node.skillKey.trim() : "";
+        if (id === "" || skillKey === "")
+            continue;
+        if (localKeys.has(skillKey))
+            continue;
+        const taskConfiguration = readRecord(node.taskConfiguration);
+        const meta = readRecord(node.metadata);
+        const fromTaskConfig = readAiTaskProfileFromRecord(taskConfiguration);
+        const fromMeta = readAiTaskProfileFromRecord(meta);
+        const pre = fromTaskConfig.pre ?? fromMeta.pre;
+        const post = fromTaskConfig.post ?? fromMeta.post;
+        const web = fromTaskConfig.web ?? fromMeta.web;
+        const synthesis = fromTaskConfig.synthesis ?? fromMeta.synthesis;
+        const issues = [];
+        if (pre === undefined)
+            issues.push("missing_preStrategyKey");
+        if (post === undefined)
+            issues.push("missing_postStrategyKey");
+        const wsEnabled = web?.enabled === true;
+        const questions = web?.questions ?? [];
+        if (wsEnabled && questions.length === 0) {
+            issues.push("web_scoping_enabled_without_questions");
+        }
+        if (!wsEnabled && questions.length > 0) {
+            issues.push("web_scoping_questions_without_enabled");
+        }
+        if (synthesis?.enabled === true) {
+            if (!nonEmptyString(synthesis.catalogId)) {
+                issues.push("synthesis_enabled_without_catalogId");
+            }
+            if (!nonEmptyString(synthesis.strategyKey)) {
+                issues.push("synthesis_enabled_without_strategyKey");
+            }
+            if (!nonEmptyString(synthesis.outputKey)) {
+                issues.push("synthesis_enabled_without_outputKey");
+            }
+            if (!synthesis.sources || synthesis.sources.length === 0) {
+                issues.push("synthesis_enabled_without_sources");
+            }
+            if (synthesis.destination === undefined) {
+                issues.push("synthesis_enabled_without_destination");
+            }
+        }
+        if (hasSynthesisPipelineConflict(node)) {
+            issues.push("synthesis_pipeline_conflict");
+        }
+        if (issues.length > 0) {
+            out.push({ nodeId: id, skillKey, issues });
+        }
+    }
+    return out;
+}

package/dist/canonicalGraphDocument.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Graph document shell canonicalization (nodes array, response, top-level keys).
+ */
+/** Convert record-keyed `nodes` to an array; returns whether conversion happened. */
+export declare function normalizeNodesToArray(graph: Record<string, unknown>): boolean;
+export declare function canonicalizeGraphDocumentShell(graph: Record<string, unknown>): boolean;
+export declare function canonicalizeTaskNodePlacement(node: Record<string, unknown>): boolean;
+//# sourceMappingURL=canonicalGraphDocument.d.ts.map

package/dist/canonicalGraphDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalGraphDocument.d.ts","sourceRoot":"","sources":["../src/canonicalGraphDocument.ts"],"names":[],"mappings":"AAAA;;GAEG;AAmTH,qFAAqF;AACrF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAc7E;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CA8BtF;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAQpF"}

package/dist/canonicalGraphDocument.js

@@ -0,0 +1,344 @@
+/**
+ * Graph document shell canonicalization (nodes array, response, top-level keys).
+ */
+const CANONICAL_TOP_LEVEL_KEYS = new Set([
+    "id",
+    "version",
+    "modelConfig",
+    "jobKnowledge",
+    "nodes",
+    "edges",
+    "variables",
+    "response",
+    "metadata",
+]);
+const FORBIDDEN_ROOT_RUNTIME_KEYS = new Set([
+    "input",
+    "inputs",
+    "jobMemory",
+    "taskMemory",
+    "executionMemory",
+    "outputsMemory",
+    "aliasConfig",
+    "outputConstraints",
+    "taskKnowledge",
+]);
+const FORBIDDEN_GRAPH_RESPONSE_KEYS = [
+    "version",
+    "target",
+    "primaryResponsePaths",
+    "debugResponsePaths",
+    "notableExecutionPaths",
+    "mappingPreset",
+];
+const FORBIDDEN_NARRIX_WEB_KEYS = [
+    "webScopeQuestions",
+    "webScoping",
+    "webScopeTemplates",
+    "forceWebScope",
+    "webScopeEntityIdPath",
+];
+/** Metadata execution keys → taskConfiguration target (value transform optional). */
+const METADATA_EXECUTION_LIFT = {
+    aiTaskProfile: { target: "aiTaskProfile" },
+    narrix: { target: "narrix" },
+    narrixMode: { target: "narrixMode" },
+    narrixInput: { target: "narrixInput" },
+    synthesizedContext: {
+        target: "aiTaskProfile",
+        transform: (v) => {
+            const syn = readRecord(v);
+            if (syn !== undefined)
+                return { inputSynthesis: syn };
+            if (v === true)
+                return { inputSynthesis: { enabled: true } };
+            return { inputSynthesis: v };
+        },
+    },
+    executionStrategyKey: {
+        target: "executionStrategies",
+        transform: (v) => (typeof v === "string" && v.trim() !== "" ? [{ strategyKey: v.trim() }] : v),
+    },
+    executionStrategies: { target: "executionStrategies" },
+    outputConstraints: {
+        target: "aiTasksOutputValidation",
+        transform: (v) => {
+            const o = readRecord(v);
+            if (o !== undefined && "schema" in o)
+                return o;
+            return { schema: v };
+        },
+    },
+    aiTasksOutputValidation: { target: "aiTasksOutputValidation" },
+    modelConfig: { target: "modelConfig" },
+    llmCall: { target: "llmCall" },
+    inputStrategyKey: { target: "inputStrategyKey" },
+    synthesizedInput: { target: "synthesizedInput" },
+    stepRetryPolicy: { target: "stepRetryPolicy" },
+    concurrency: { target: "concurrency" },
+    taskKind: { target: "taskKind" },
+    autoValidateDecisionOutput: { target: "autoValidateDecisionOutput" },
+    identity: { target: "runTaskIdentity" },
+    runTaskIdentity: { target: "runTaskIdentity" },
+    memoryKey: { target: "memoryKey" },
+    taskTypeId: { target: "taskTypeId" },
+    scopingMapId: { target: "scopingMapId" },
+    entityIdPath: { target: "entityIdPath" },
+    rules: { target: "rules" },
+};
+const NODE_ROOT_TO_TASK_CONFIGURATION = [
+    "smartInput",
+    "executionPipeline",
+    "conditions",
+    "outputValidation",
+];
+function readRecord(v) {
+    if (v === null || v === undefined || typeof v !== "object" || Array.isArray(v)) {
+        return undefined;
+    }
+    return v;
+}
+function nonEmptyString(v) {
+    return typeof v === "string" && v.trim().length > 0;
+}
+function extractWebQuestionsFromNarrix(narrix) {
+    const raw = narrix.webScopeQuestions;
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const item of raw) {
+        if (typeof item === "string" && item.trim() !== "") {
+            out.push(item.trim());
+            continue;
+        }
+        const o = readRecord(item);
+        const q = o?.question;
+        if (typeof q === "string" && q.trim() !== "")
+            out.push(q.trim());
+    }
+    return out;
+}
+function mergeWebScopingFromNarrix(taskConfiguration, narrix) {
+    let changed = false;
+    const questions = extractWebQuestionsFromNarrix(narrix);
+    const enabled = narrix.enableWebScope === true ||
+        narrix.forceWebScope === true ||
+        questions.length > 0;
+    const profile = {
+        ...readRecord(taskConfiguration.aiTaskProfile),
+    };
+    const existingWeb = readRecord(profile.webScoping);
+    const existingQuestions = Array.isArray(existingWeb?.questions)
+        ? existingWeb.questions.filter((x) => nonEmptyString(x))
+        : [];
+    if (questions.length > 0 || enabled) {
+        const mergedQuestions = [...new Set([...existingQuestions, ...questions])];
+        profile.webScoping = {
+            enabled: existingWeb?.enabled === true || enabled || mergedQuestions.length > 0,
+            ...(mergedQuestions.length > 0 ? { questions: mergedQuestions } : {}),
+        };
+        taskConfiguration.aiTaskProfile = profile;
+        changed = true;
+    }
+    for (const k of FORBIDDEN_NARRIX_WEB_KEYS) {
+        if (k in narrix) {
+            delete narrix[k];
+            changed = true;
+        }
+    }
+    return changed;
+}
+function stripForbiddenNarrixWebKeys(narrix) {
+    let changed = false;
+    for (const k of FORBIDDEN_NARRIX_WEB_KEYS) {
+        if (k in narrix) {
+            delete narrix[k];
+            changed = true;
+        }
+    }
+    return changed;
+}
+function liftSkillKeyAndVariables(node) {
+    let changed = false;
+    const data = readRecord(node.data);
+    const meta = readRecord(node.metadata);
+    if (data?.skillKey !== undefined && node.skillKey === undefined) {
+        node.skillKey = data.skillKey;
+        delete data.skillKey;
+        changed = true;
+    }
+    if (meta?.skillKey !== undefined && node.skillKey === undefined) {
+        node.skillKey = meta.skillKey;
+        delete meta.skillKey;
+        changed = true;
+    }
+    if (data?.variables !== undefined && node.variables === undefined) {
+        node.variables = data.variables;
+        delete data.variables;
+        changed = true;
+    }
+    if (meta?.variables !== undefined && node.variables === undefined) {
+        node.variables = meta.variables;
+        delete meta.variables;
+        changed = true;
+    }
+    if (data !== undefined && Object.keys(data).length === 0) {
+        delete node.data;
+        changed = true;
+    }
+    if (meta !== undefined && Object.keys(meta).length === 0 && node.metadata !== undefined) {
+        // keep metadata if other keys remain
+    }
+    return changed;
+}
+function liftMetadataExecutionToTaskConfiguration(node) {
+    const meta = readRecord(node.metadata);
+    if (meta === undefined)
+        return false;
+    let changed = false;
+    const taskConfiguration = {
+        ...readRecord(node.taskConfiguration),
+    };
+    for (const [key, spec] of Object.entries(METADATA_EXECUTION_LIFT)) {
+        if (!(key in meta) || meta[key] === undefined)
+            continue;
+        const raw = meta[key];
+        delete meta[key];
+        if (spec.target === "aiTaskProfile") {
+            const patch = (spec.transform ? spec.transform(raw) : raw);
+            const profile = {
+                ...readRecord(taskConfiguration.aiTaskProfile),
+                ...patch,
+            };
+            if (readRecord(taskConfiguration.aiTaskProfile)?.inputSynthesis !== undefined && patch.inputSynthesis !== undefined) {
+                profile.inputSynthesis = {
+                    ...readRecord(readRecord(taskConfiguration.aiTaskProfile)?.inputSynthesis),
+                    ...readRecord(patch.inputSynthesis),
+                };
+            }
+            taskConfiguration.aiTaskProfile = profile;
+            changed = true;
+            continue;
+        }
+        if (taskConfiguration[spec.target] === undefined) {
+            taskConfiguration[spec.target] = spec.transform ? spec.transform(raw) : raw;
+            changed = true;
+        }
+    }
+    if (!changed)
+        return false;
+    node.taskConfiguration = taskConfiguration;
+    if (Object.keys(meta).length === 0) {
+        delete node.metadata;
+    }
+    else {
+        node.metadata = meta;
+    }
+    return true;
+}
+function liftNodeRootToTaskConfiguration(node) {
+    let changed = false;
+    const taskConfiguration = {
+        ...readRecord(node.taskConfiguration),
+    };
+    for (const key of NODE_ROOT_TO_TASK_CONFIGURATION) {
+        if (node[key] !== undefined && taskConfiguration[key] === undefined) {
+            taskConfiguration[key] = node[key];
+            delete node[key];
+            changed = true;
+        }
+    }
+    if (!changed)
+        return false;
+    node.taskConfiguration = taskConfiguration;
+    return true;
+}
+function removeLegacySynthesisFlags(node) {
+    const tc = readRecord(node.taskConfiguration);
+    const profile = readRecord(tc?.aiTaskProfile);
+    const syn = readRecord(profile?.inputSynthesis);
+    if (syn === undefined || !("alsoWriteLegacySynthesizedContext" in syn))
+        return false;
+    const next = { ...syn };
+    delete next.alsoWriteLegacySynthesizedContext;
+    const nextProfile = { ...profile, inputSynthesis: next };
+    node.taskConfiguration = { ...tc, aiTaskProfile: nextProfile };
+    return true;
+}
+function canonicalizeNarrixWebOnNode(node) {
+    const tc = readRecord(node.taskConfiguration);
+    if (tc === undefined)
+        return false;
+    let changed = false;
+    const narrix = readRecord(tc.narrix);
+    if (narrix !== undefined && mergeWebScopingFromNarrix(tc, narrix)) {
+        changed = true;
+    }
+    if (narrix !== undefined && stripForbiddenNarrixWebKeys(narrix)) {
+        changed = true;
+    }
+    if (changed)
+        node.taskConfiguration = tc;
+    return changed;
+}
+/** Convert record-keyed `nodes` to an array; returns whether conversion happened. */
+export function normalizeNodesToArray(graph) {
+    const nodes = graph.nodes;
+    if (Array.isArray(nodes))
+        return false;
+    if (nodes === null || typeof nodes !== "object")
+        return false;
+    const next = [];
+    for (const [key, value] of Object.entries(nodes)) {
+        const node = readRecord(value);
+        if (node === undefined)
+            continue;
+        if (node.id === undefined)
+            node.id = key;
+        next.push(node);
+    }
+    graph.nodes = next;
+    return true;
+}
+export function canonicalizeGraphDocumentShell(graph) {
+    let changed = false;
+    if (normalizeNodesToArray(graph))
+        changed = true;
+    for (const key of Object.keys(graph)) {
+        if (!CANONICAL_TOP_LEVEL_KEYS.has(key)) {
+            if (FORBIDDEN_ROOT_RUNTIME_KEYS.has(key)) {
+                delete graph[key];
+                changed = true;
+            }
+        }
+    }
+    const response = readRecord(graph.response);
+    if (response !== undefined) {
+        let responseChanged = false;
+        for (const k of FORBIDDEN_GRAPH_RESPONSE_KEYS) {
+            if (k in response) {
+                delete response[k];
+                responseChanged = true;
+            }
+        }
+        if (responseChanged) {
+            graph.response = response;
+            changed = true;
+        }
+    }
+    return changed;
+}
+export function canonicalizeTaskNodePlacement(node) {
+    let changed = false;
+    if (liftSkillKeyAndVariables(node))
+        changed = true;
+    if (liftMetadataExecutionToTaskConfiguration(node))
+        changed = true;
+    if (liftNodeRootToTaskConfiguration(node))
+        changed = true;
+    if (canonicalizeNarrixWebOnNode(node))
+        changed = true;
+    if (removeLegacySynthesisFlags(node))
+        changed = true;
+    return changed;
+}

package/dist/canonicalGraphWarnings.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Warn-first canonical inspection (does not throw). Use before enabling
+ * `assertCanonicalGraphDocument` hard-fail in a future minor.
+ */
+export declare function collectCanonicalGraphWarnings(graph: object): string[];
+//# sourceMappingURL=canonicalGraphWarnings.d.ts.map

package/dist/canonicalGraphWarnings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalGraphWarnings.d.ts","sourceRoot":"","sources":["../src/canonicalGraphWarnings.ts"],"names":[],"mappings":"AAwDA;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAsHrE"}

package/dist/canonicalGraphWarnings.js

@@ -0,0 +1,140 @@
+import { getCanonicalGraphDocumentViolations, collectAiTasksNodeExtensionIssues, } from "./graphEngineBridge.js";
+function readRecord(v) {
+    if (v === null || v === undefined || typeof v !== "object" || Array.isArray(v)) {
+        return undefined;
+    }
+    return v;
+}
+/** Execution keys that must not remain on task `metadata` after canonicalize. */
+const FORBIDDEN_TASK_METADATA_EXECUTION_KEYS = new Set([
+    "aiTaskProfile",
+    "narrix",
+    "narrixMode",
+    "narrixInput",
+    "synthesizedContext",
+    "executionStrategyKey",
+    "executionStrategies",
+    "outputConstraints",
+    "aiTasksOutputValidation",
+    "modelConfig",
+    "llmCall",
+    "inputStrategyKey",
+    "synthesizedInput",
+    "skillKey",
+    "variables",
+    "taskKnowledge",
+    "jobKnowledge",
+    "jobMemory",
+    "taskMemory",
+    "executionMemory",
+    "outputsMemory",
+    "aliasConfig",
+]);
+const FORBIDDEN_NARRIX_WEB_KEYS = [
+    "webScopeQuestions",
+    "webScoping",
+    "webScopeTemplates",
+    "forceWebScope",
+    "webScopeEntityIdPath",
+];
+const PURE_TASK_METADATA_KEYS = new Set([
+    "graphReadability",
+    "catalogBinding",
+    "catalogRequest",
+    "name",
+    "description",
+    "exellixContractTarget",
+    "__exellixVirtualBoundary",
+]);
+/**
+ * Warn-first canonical inspection (does not throw). Use before enabling
+ * `assertCanonicalGraphDocument` hard-fail in a future minor.
+ */
+export function collectCanonicalGraphWarnings(graph) {
+    const warnings = [];
+    const g = graph;
+    const topLevel = getCanonicalGraphDocumentViolations(graph);
+    if (topLevel.length > 0) {
+        warnings.push(`Canonical graph document: forbidden top-level key(s): ${topLevel.join(", ")}.`);
+    }
+    const nodes = g.nodes;
+    if (!Array.isArray(nodes)) {
+        if (nodes !== undefined) {
+            warnings.push("Canonical graph document: nodes must be an array (record-keyed nodes were removed in 5.x).");
+        }
+        return warnings;
+    }
+    for (let i = 0; i < nodes.length; i++) {
+        const node = readRecord(nodes[i]);
+        if (node === undefined)
+            continue;
+        const nodeId = typeof node.id === "string" ? node.id : `nodes[${i}]`;
+        const prefix = `node "${nodeId}"`;
+        const data = readRecord(node.data);
+        if (data !== undefined) {
+            if ("skillKey" in data) {
+                warnings.push(`${prefix}: skillKey must be on node.skillKey, not node.data.skillKey.`);
+            }
+            if ("variables" in data) {
+                warnings.push(`${prefix}: variables must be on node.variables, not node.data.variables.`);
+            }
+        }
+        const meta = readRecord(node.metadata);
+        if (meta !== undefined) {
+            for (const key of Object.keys(meta)) {
+                if (FORBIDDEN_TASK_METADATA_EXECUTION_KEYS.has(key)) {
+                    warnings.push(`${prefix}: forbidden metadata.${key} — move execution config to taskConfiguration.`);
+                }
+                else if (!PURE_TASK_METADATA_KEYS.has(key) && node.type !== "finalizer") {
+                    warnings.push(`${prefix}: metadata.${key} is not in the planning-only allowlist.`);
+                }
+            }
+        }
+        if (node.type !== "finalizer" && "outputMapping" in node) {
+            warnings.push(`${prefix}: outputMapping belongs on finalizers; use executionMapping for task nodes.`);
+        }
+        const tc = readRecord(node.taskConfiguration);
+        const narrix = readRecord(tc?.narrix);
+        if (narrix !== undefined) {
+            for (const k of FORBIDDEN_NARRIX_WEB_KEYS) {
+                if (k in narrix) {
+                    warnings.push(`${prefix}: taskConfiguration.narrix.${k} is forbidden — author web scope under taskConfiguration.aiTaskProfile.webScoping.`);
+                }
+            }
+        }
+        const profile = readRecord(tc?.aiTaskProfile);
+        const inputSynthesis = readRecord(profile?.inputSynthesis);
+        if (inputSynthesis !== undefined && "alsoWriteLegacySynthesizedContext" in inputSynthesis) {
+            warnings.push(`${prefix}: taskConfiguration.aiTaskProfile.inputSynthesis.alsoWriteLegacySynthesizedContext is removed in 5.x.`);
+        }
+        if (inputSynthesis?.enabled === true && Array.isArray(node.executionPipeline)) {
+            for (const step of node.executionPipeline) {
+                const s = readRecord(step);
+                if (s?.phase === "pre" && s?.type === "synthesized-context") {
+                    warnings.push(`${prefix}: inputSynthesis.enabled conflicts with manual PRE synthesized-context in executionPipeline.`);
+                    break;
+                }
+            }
+        }
+        const extIssues = collectAiTasksNodeExtensionIssues(node, `nodes[${i}]`);
+        for (const issue of extIssues) {
+            warnings.push(`${prefix}: ${issue.code} at ${issue.path}: ${issue.message}`);
+        }
+    }
+    const response = readRecord(g.response);
+    if (response !== undefined) {
+        const forbiddenResponse = [
+            "version",
+            "target",
+            "primaryResponsePaths",
+            "debugResponsePaths",
+            "notableExecutionPaths",
+            "mappingPreset",
+        ];
+        const bad = forbiddenResponse.filter((k) => k in response);
+        if (bad.length > 0) {
+            warnings.push(`graph.response: editor-only key(s) should be removed: ${bad.join(", ")}.`);
+        }
+    }
+    return warnings;
+}