@boboddy/sdk 0.5.1 → 0.5.2

package/dist/push/index.js

@@ -12082,6 +12082,12 @@ ${feature._promptAddition}` : feature._promptAddition;
 }
 // src/definitions/steps/define-code-step.ts
 function codeStep(config2) {
+  const features = config2.features ?? [];
+  let effectiveResult = config2.resultSchema;
+  for (const feature of features) {
+    effectiveResult = effectiveResult ? effectiveResult.extend(feature._resultExtension.shape) : feature._resultExtension;
+  }
+  const featureSignals = features.flatMap((f) => f._signals);
   const spec = {
     key: config2.key,
     name: config2.name,
@@ -12091,14 +12097,23 @@ function codeStep(config2) {
     status: config2.status ?? "active",
     prompt: null,
     inputSchemaJson: config2.inputSchema ? toJSONSchema(config2.inputSchema) : null,
-    resultSchemaJson: config2.resultSchema ? toJSONSchema(config2.resultSchema) : null,
-    signalExtractorDefinitions: (config2.signals ?? []).map((signal) => ({
-      key: signal.key ?? signal.sourcePath,
-      sourcePath: signal.sourcePath,
-      type: signal.type,
-      required: signal.required ?? true,
-      availableWhenResultStatusIn: signal.availableWhenResultStatusIn ?? null
-    })),
+    resultSchemaJson: effectiveResult ? toJSONSchema(effectiveResult) : null,
+    signalExtractorDefinitions: [
+      ...(config2.signals ?? []).map((signal) => ({
+        key: signal.key ?? signal.sourcePath,
+        sourcePath: signal.sourcePath,
+        type: signal.type,
+        required: signal.required ?? true,
+        availableWhenResultStatusIn: signal.availableWhenResultStatusIn ?? null
+      })),
+      ...featureSignals.map((signal) => ({
+        key: signal.key,
+        sourcePath: signal.sourcePath,
+        type: signal.type,
+        required: signal.required ?? true,
+        availableWhenResultStatusIn: signal.availableWhenResultStatusIn ?? null
+      }))
+    ],
     opencodeMcpJson: null,
     opencodePluginJson: null,
     healthChecksJson: null,
@@ -16084,20 +16099,29 @@ function date4(params) {
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 config(en_default());
 // src/definitions/steps/step-features.ts
+var notificationKindSchema = exports_external.enum([
+  "feedback_request",
+  "status_update",
+  "blocked",
+  "result_ready",
+  "warning"
+]);
+var notificationPrioritySchema = exports_external.enum(["low", "normal", "high", "urgent"]);
+var notificationChannelSchema = exports_external.enum([
+  "in_app",
+  "work_item_platform_comment",
+  "email",
+  "slack"
+]);
 var NOTIFICATION_SIGNAL_KEY = "$boboddy_notifications_v1";
 var NOTIFICATION_RESULT_KEY = "$boboddy_notifications_v1";
+var DEFAULT_NOTIFICATION_KIND = "status_update";
 var notificationItemSchema = exports_external.object({
-  kind: exports_external.enum([
-    "feedback_request",
-    "status_update",
-    "blocked",
-    "result_ready",
-    "warning"
-  ]).describe("The kind of user notification."),
+  kind: notificationKindSchema.describe("The kind of user notification."),
   title: exports_external.string().describe("Short, human-readable notification title."),
   body: exports_external.string().describe("The notification body / details."),
-  priority: exports_external.enum(["low", "normal", "high", "urgent"]).describe("How important this notification is for the user."),
-  suggestedChannels: exports_external.array(exports_external.enum(["in_app", "work_item_platform_comment", "email", "slack"])).optional().describe("Channels the agent thinks are worth using. The platform policy decides the final channels."),
+  priority: notificationPrioritySchema.describe("How important this notification is for the user."),
+  suggestedChannels: exports_external.array(notificationChannelSchema).optional().describe("Channels the agent thinks are worth using. The platform policy decides the final channels."),
   payload: exports_external.record(exports_external.string(), exports_external.unknown()).optional().describe('Kind-specific structured data. For "feedback_request": { category, urgency, suggestedKey? }.')
 }).describe("A single user notification emitted by the agent.");
 var notificationsFeature = {
@@ -16127,23 +16151,62 @@ var notificationsFeature = {
     }
   ]
 };
+var feedbackRequestsFeature = {
+  _resultExtension: exports_external.object({
+    [NOTIFICATION_RESULT_KEY]: exports_external.array(notificationItemSchema.extend({ kind: exports_external.literal("feedback_request") })).optional()
+  }),
+  _promptAddition: [
+    "## Feedback Requests",
+    "",
+    `If you need to ask a human a clarifying question, populate the \`${NOTIFICATION_RESULT_KEY}\` array with items of kind \`"feedback_request"\`.`,
+    "Each item must include:",
+    "- **title**: A short, human-readable summary of the question.",
+    "- **body**: The full question.",
+    "- **priority**: One of `low`, `normal`, `high`, `urgent`.",
+    '- **payload**: `{ "category": string, "urgency": "blocking"|"clarification"|"assumption"|"informational", "suggestedKey"?: string }`.'
+  ].join(`
+`),
+  _signals: notificationsFeature._signals
+};
 var Features = {
-  notifications: Object.assign(() => notificationsFeature, {
-    signal: {
-      key: NOTIFICATION_SIGNAL_KEY,
-      find(signals) {
-        const match = signals.find((s) => s.key === NOTIFICATION_SIGNAL_KEY);
-        if (!match)
-          return;
-        const parsed = exports_external.array(notificationItemSchema).safeParse(match.valueJson);
-        return parsed.success ? parsed.data : undefined;
-      }
-    }
+  notifications: () => notificationsFeature,
+  feedbackRequests: () => feedbackRequestsFeature
+};
+var NotificationSignal = {
+  key: NOTIFICATION_SIGNAL_KEY,
+  find(signals) {
+    const match = signals.find((s) => s.key === NOTIFICATION_SIGNAL_KEY);
+    if (!match)
+      return;
+    const parsed = exports_external.array(notificationItemSchema).safeParse(match.valueJson);
+    return parsed.success ? parsed.data : undefined;
+  }
+};
+var Notify = {
+  create: (item) => ({
+    [NOTIFICATION_RESULT_KEY]: [item]
   }),
-  feedbackRequests: Object.assign(() => notificationsFeature, {
-    signal: {
-      key: NOTIFICATION_SIGNAL_KEY
+  inApp: (title, body, priority, options) => Notify.create({
+    kind: options?.kind ?? DEFAULT_NOTIFICATION_KIND,
+    title,
+    body,
+    priority,
+    suggestedChannels: ["in_app"],
+    ...options?.payload ? { payload: options.payload } : {}
+  }),
+  feedbackRequest: (question, category, urgency, suggestedKey) => Notify.create({
+    kind: "feedback_request",
+    title: question,
+    body: question,
+    priority: "normal",
+    payload: {
+      category,
+      urgency,
+      ...suggestedKey ? { suggestedKey } : {}
     }
+  }),
+  merge: (...fragments) => ({
+    [NOTIFICATION_RESULT_KEY]: fragments.flatMap((fragment) => fragment[NOTIFICATION_RESULT_KEY])
   })
 };
 // src/definitions/advancement-policies/define-advancement-policy.ts
@@ -16840,25 +16903,6 @@ function compileLoopState(stateKey, state, ctx) {
 function compileTerminalState(stateKey, kind) {
   return { nodeDefinitions: [{ nodeKey: stateKey, kind }], edges: [] };
 }
-function assertNoIllegalConvergentEdges(pipelineKey, nodeKindByKey, edges) {
-  const incoming = new Map;
-  for (const edge of edges) {
-    const list = incoming.get(edge.toNodeKey) ?? [];
-    list.push(edge);
-    incoming.set(edge.toNodeKey, list);
-  }
-  for (const [targetKey, incomingEdges] of incoming) {
-    if (incomingEdges.length <= 1)
-      continue;
-    const hasInvalidSource = incomingEdges.some((edge) => {
-      const kind = nodeKindByKey.get(edge.fromNodeKey);
-      return kind !== "choice" && kind !== "loop";
-    });
-    if (hasInvalidSource) {
-      throw new Error(`Pipeline "${pipelineKey}": state "${targetKey}" has more than one incoming edge, but not every source is a 'choice'/'loop' state (unconditional convergent edges are not allowed \u2014 see docs/research/flat-pipeline-sdk-and-visual-designer.md \xA76).`);
-    }
-  }
-}
 
 // src/definitions/pipelines/define-pipeline.ts
 function isWorkingNodeDefinition(node) {
@@ -16895,8 +16939,6 @@ function definePipeline(config2) {
     nodeDefinitions.push(...compiled.nodeDefinitions);
     dependencyEdges.push(...compiled.edges);
   }
-  const nodeKindByKey = new Map(nodeDefinitions.map((node) => [node.nodeKey, node.kind]));
-  assertNoIllegalConvergentEdges(config2.key, nodeKindByKey, dependencyEdges);
   let inputSchemaJson = null;
   if (config2.input) {
     try {
@@ -16912,6 +16954,7 @@ function definePipeline(config2) {
     version: config2.version ?? 1,
     status: config2.status ?? "active",
     inputSchemaJson,
+    entryNodeKey: config2.startAt,
     _stepDefinitions: [...stepDefMap.values()],
     nodeDefinitions,
     dependencyEdges
@@ -17024,6 +17067,7 @@ var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
         description: spec.description,
         status: spec.status,
         inputSchemaJson: spec.inputSchemaJson,
+        entryNodeKey: spec.entryNodeKey,
         nodeDefinitions,
         dependencyEdges
       };
@@ -17375,22 +17419,22 @@ function enumeratePaths(node, root, maxDepth = 3, limit = 40) {
   visit(node, "", 1);
   return [...new Set(out)].sort();
 }
-function resolveSourcePath(schema, sourcePath) {
+function resolvePathToNode(schema, sourcePath) {
   const segments = parseSourcePath(sourcePath);
   if (segments.length === 0)
-    return { kind: "resolved" };
+    return { kind: "resolved", node: schema };
   let candidates = [schema];
   let resolvedPrefix = "";
   for (const segment of segments) {
-    const expanded = candidates.flatMap((node) => flatten(node, schema) ?? []);
+    const expanded = candidates.flatMap((node2) => flatten(node2, schema) ?? []);
     if (expanded.length === 0)
       return { kind: "indeterminate" };
-    const outcome = combine(expanded.map((node) => stepInto(node, segment)));
+    const outcome = combine(expanded.map((node2) => stepInto(node2, segment)));
     if (outcome.kind === "indeterminate")
       return { kind: "indeterminate" };
     if (outcome.kind === "invalid") {
       const availablePaths = [
-        ...new Set(expanded.flatMap((node) => enumeratePaths(node, schema)))
+        ...new Set(expanded.flatMap((node2) => enumeratePaths(node2, schema)))
       ].sort();
       return {
         kind: "invalid",
@@ -17403,7 +17447,60 @@ function resolveSourcePath(schema, sourcePath) {
     candidates = [outcome.node];
     resolvedPrefix = resolvedPrefix ? `${resolvedPrefix}.${segment}` : segment;
   }
-  return { kind: "resolved" };
+  const [node] = candidates;
+  return node ? { kind: "resolved", node } : { kind: "indeterminate" };
+}
+function resolveSourcePath(schema, sourcePath) {
+  const result = resolvePathToNode(schema, sourcePath);
+  if (result.kind === "resolved")
+    return { kind: "resolved" };
+  if (result.kind === "indeterminate")
+    return { kind: "indeterminate" };
+  return {
+    kind: "invalid",
+    resolvedPrefix: result.resolvedPrefix,
+    segment: result.segment,
+    reason: result.reason,
+    availablePaths: result.availablePaths
+  };
+}
+var KNOWN_TYPES = new Set([
+  "string",
+  "number",
+  "boolean",
+  "object",
+  "array",
+  "null"
+]);
+function normalizeTypeName(name) {
+  return name === "integer" ? "number" : name;
+}
+function resolveSchemaType(node, root = node) {
+  const branches = flatten(node, root);
+  if (!branches || branches.length === 0)
+    return "unknown";
+  const types = new Set;
+  for (const branch of branches) {
+    const record2 = asRecord(branch);
+    if (!record2)
+      return "unknown";
+    const names = [...typeNames(record2)].map(normalizeTypeName);
+    if (names.length !== 1)
+      return "unknown";
+    const [name] = names;
+    if (!name || !KNOWN_TYPES.has(name))
+      return "unknown";
+    types.add(name);
+  }
+  if (types.size !== 1)
+    return "unknown";
+  return [...types][0];
+}
+function resolvePathType(schema, sourcePath) {
+  const result = resolvePathToNode(schema, sourcePath);
+  if (result.kind !== "resolved")
+    return "unknown";
+  return resolveSchemaType(result.node, schema);
 }
 // src/definitions/pipelines/chain-graph.ts
 function tryComputeTopoRanks(nodeDefinitions, dependencyEdges) {
@@ -17456,8 +17553,77 @@ function tryOrderNodeDefinitionsByTopoRank(nodeDefinitions, dependencyEdges) {
     return rankDiff !== 0 ? rankDiff : left.declarationIndex - right.declarationIndex;
   }).map(({ node }) => node);
 }
+function tryComputeDominators(nodeDefinitions, dependencyEdges, entryNodeKey) {
+  const nodeKeys = new Set(nodeDefinitions.map((node) => node.nodeKey));
+  if (!nodeKeys.has(entryNodeKey))
+    return null;
+  if (tryComputeTopoRanks(nodeDefinitions, dependencyEdges) === null) {
+    return null;
+  }
+  const outgoing = new Map;
+  const incoming = new Map;
+  for (const key of nodeKeys) {
+    outgoing.set(key, []);
+    incoming.set(key, []);
+  }
+  for (const edge of dependencyEdges) {
+    outgoing.get(edge.fromNodeKey)?.push(edge.toNodeKey);
+    incoming.get(edge.toNodeKey)?.push(edge.fromNodeKey);
+  }
+  const reachable = new Set([entryNodeKey]);
+  const queue = [entryNodeKey];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === undefined)
+      break;
+    for (const next of outgoing.get(current) ?? []) {
+      if (reachable.has(next))
+        continue;
+      reachable.add(next);
+      queue.push(next);
+    }
+  }
+  const dom = new Map;
+  dom.set(entryNodeKey, new Set([entryNodeKey]));
+  for (const key of reachable) {
+    if (key !== entryNodeKey)
+      dom.set(key, new Set(reachable));
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const key of reachable) {
+      if (key === entryNodeKey)
+        continue;
+      let intersection2 = null;
+      for (const predecessor of incoming.get(key) ?? []) {
+        if (!reachable.has(predecessor))
+          continue;
+        const predecessorDom = dom.get(predecessor);
+        if (!predecessorDom)
+          continue;
+        if (intersection2 === null) {
+          intersection2 = new Set(predecessorDom);
+          continue;
+        }
+        for (const candidate of intersection2) {
+          if (!predecessorDom.has(candidate))
+            intersection2.delete(candidate);
+        }
+      }
+      const nextDom = intersection2 ?? new Set;
+      nextDom.add(key);
+      const currentDom = dom.get(key);
+      if (!currentDom || currentDom.size !== nextDom.size || [...currentDom].some((item) => !nextDom.has(item))) {
+        dom.set(key, nextDom);
+        changed = true;
+      }
+    }
+  }
+  return dom;
+}
 
-// src/definitions/validation/validate-definition-specs.ts
+// src/definitions/validation/validation-issue.ts
 function listPaths(paths, limit = 24) {
   if (paths.length === 0)
     return "";
@@ -17465,6 +17631,250 @@ function listPaths(paths, limit = 24) {
     return paths.join(", ");
   return `${paths.slice(0, limit).join(", ")}, \u2026 (${String(paths.length - limit)} more)`;
 }
+
+// src/definitions/validation/validate-input-bindings.ts
+var WORK_ITEM_TOP_LEVEL_FIELD_SET = new Set(WORK_ITEM_TOP_LEVEL_FIELDS);
+function isAutoBoundWorkItemField(field) {
+  return field === "workItemTitle" || field === "workItemDescription";
+}
+function bindingContexts(pipeline) {
+  const contexts = [];
+  for (const node of pipeline.nodeDefinitions) {
+    if (isWorkingNodeDefinition(node)) {
+      contexts.push({
+        nodeKey: node.nodeKey,
+        branchKey: null,
+        stepKey: node.stepKey,
+        inputBindingsJson: node.inputBindingsJson ?? {}
+      });
+      continue;
+    }
+    if (node.kind === "parallel" && node.branches) {
+      for (const [branchKey, branch] of Object.entries(node.branches)) {
+        contexts.push({
+          nodeKey: node.nodeKey,
+          branchKey,
+          stepKey: branch.stepKey,
+          inputBindingsJson: branch.inputBindingsJson ?? {}
+        });
+      }
+    }
+  }
+  return contexts;
+}
+function bindingContextLabel(pipelineKey, ctx) {
+  return ctx.branchKey ? `Pipeline "${pipelineKey}" node "${ctx.nodeKey}" branch "${ctx.branchKey}"` : `Pipeline "${pipelineKey}" node "${ctx.nodeKey}"`;
+}
+function knownInputFields(specs) {
+  const fields = new Set;
+  for (const spec of specs) {
+    const schema = spec.inputSchemaJson;
+    if (!schema)
+      continue;
+    const properties = schema["properties"];
+    if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
+      continue;
+    }
+    for (const key of Object.keys(properties))
+      fields.add(key);
+  }
+  return fields;
+}
+function requiredInputFields(specs) {
+  const fields = new Set;
+  for (const spec of specs) {
+    const schema = spec.inputSchemaJson;
+    if (!schema)
+      continue;
+    const required2 = schema["required"];
+    if (!Array.isArray(required2))
+      continue;
+    for (const entry of required2) {
+      if (typeof entry === "string")
+        fields.add(entry);
+    }
+  }
+  return fields;
+}
+function isJsonSchemaNode(value) {
+  return typeof value === "boolean" || typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function findPropertyNode(specs, field) {
+  for (const spec of specs) {
+    const schema = spec.inputSchemaJson;
+    if (!schema)
+      continue;
+    const properties = schema["properties"];
+    if (!properties || typeof properties !== "object" || Array.isArray(properties)) {
+      continue;
+    }
+    const node = properties[field];
+    if (isJsonSchemaNode(node))
+      return { node, root: schema };
+  }
+  return null;
+}
+function checkUnboundRequiredInputs(pipelines, stepsByKey) {
+  const issues = [];
+  for (const pipeline of pipelines) {
+    for (const ctx of bindingContexts(pipeline)) {
+      const specs = stepsByKey.get(ctx.stepKey);
+      if (!specs)
+        continue;
+      const required2 = requiredInputFields(specs);
+      if (required2.size === 0)
+        continue;
+      const bound = new Set(Object.keys(ctx.inputBindingsJson));
+      const missing = [...required2].filter((field) => !bound.has(field) && !isAutoBoundWorkItemField(field)).sort();
+      if (missing.length === 0)
+        continue;
+      const where = bindingContextLabel(pipeline.key, ctx);
+      const boundList = [
+        ...bound,
+        "workItemTitle",
+        "workItemDescription"
+      ].sort();
+      for (const field of missing) {
+        issues.push({
+          check: "unbound-required-input",
+          severity: "error",
+          pipelineKey: pipeline.key,
+          nodeKey: ctx.nodeKey,
+          branchKey: ctx.branchKey ?? undefined,
+          message: `${where} runs step "${ctx.stepKey}", which requires input "${field}", ` + `but no binding provides it. Bound inputs: ${listPaths(boundList)}.`
+        });
+      }
+    }
+  }
+  return issues;
+}
+function checkBindingTargetFields(pipelines, stepsByKey) {
+  const issues = [];
+  for (const pipeline of pipelines) {
+    for (const ctx of bindingContexts(pipeline)) {
+      const specs = stepsByKey.get(ctx.stepKey);
+      const knownFields = specs ? knownInputFields(specs) : null;
+      const where = bindingContextLabel(pipeline.key, ctx);
+      for (const [field, binding] of Object.entries(ctx.inputBindingsJson)) {
+        if (knownFields && !isAutoBoundWorkItemField(field) && !knownFields.has(field)) {
+          issues.push({
+            check: "binding-target-field",
+            severity: "info",
+            pipelineKey: pipeline.key,
+            nodeKey: ctx.nodeKey,
+            branchKey: ctx.branchKey ?? undefined,
+            message: `${where} is passing information ("${field}") to step "${ctx.stepKey}" ` + `that it isn't explicitly asking for \u2014 the step declares no such ` + `additionalInput field, so the value is dropped. Declared fields: ` + `${knownFields.size > 0 ? listPaths([...knownFields].sort()) : "(none)"}.`
+          });
+        }
+        if (binding.source === "work_item" && !binding.field.startsWith(WORK_ITEM_FIELDS_PATH_PREFIX) && !WORK_ITEM_TOP_LEVEL_FIELD_SET.has(binding.field)) {
+          issues.push({
+            check: "binding-target-field",
+            severity: "error",
+            pipelineKey: pipeline.key,
+            nodeKey: ctx.nodeKey,
+            branchKey: ctx.branchKey ?? undefined,
+            message: `${where} binds input "${field}" to work_item field "${binding.field}", ` + `which is not a known top-level work-item field and does not start ` + `with "${WORK_ITEM_FIELDS_PATH_PREFIX}". Known top-level fields: ` + `${listPaths(WORK_ITEM_TOP_LEVEL_FIELDS)}.`
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function describeBindingSource(binding) {
+  switch (binding.source) {
+    case "step_signal":
+      return `signal "${binding.signalKey}" of node "${binding.stepKey}"`;
+    case "step_output":
+      return `the output of node "${binding.stepKey}"`;
+    case "signals_list":
+      return `the signals list of fan-out node "${binding.stepKey}"`;
+    case "pipeline_input":
+      return `pipeline input "${binding.path}"`;
+    case "work_item":
+      return `work_item field "${binding.field}"`;
+    case "literal":
+      return "a literal value";
+    case "fan_out_item":
+      return "the fan-out item";
+  }
+}
+function bindingSourceType(binding, pipeline, nodeByKey, stepsByKey) {
+  if (binding.source === "step_signal") {
+    const producerNode = nodeByKey.get(binding.stepKey);
+    if (!producerNode || !isWorkingNodeDefinition(producerNode))
+      return "unknown";
+    const specs = stepsByKey.get(producerNode.stepKey) ?? [];
+    for (const spec of specs) {
+      const signal2 = spec.signalExtractorDefinitions.find((candidate) => candidate.key === binding.signalKey);
+      if (signal2)
+        return signal2.type;
+    }
+    return "unknown";
+  }
+  if (binding.source === "step_output") {
+    const producerNode = nodeByKey.get(binding.stepKey);
+    if (!producerNode || !isWorkingNodeDefinition(producerNode))
+      return "unknown";
+    const specs = stepsByKey.get(producerNode.stepKey) ?? [];
+    for (const spec of specs) {
+      if (spec.resultSchemaJson)
+        return resolveSchemaType(spec.resultSchemaJson);
+    }
+    return "unknown";
+  }
+  if (binding.source === "signals_list")
+    return "array";
+  if (binding.source === "pipeline_input") {
+    return pipeline.inputSchemaJson ? resolvePathType(pipeline.inputSchemaJson, binding.path) : "unknown";
+  }
+  if (binding.source === "work_item") {
+    if (binding.field.startsWith(WORK_ITEM_FIELDS_PATH_PREFIX))
+      return "unknown";
+    return WORK_ITEM_TOP_LEVEL_FIELD_SET.has(binding.field) ? "string" : "unknown";
+  }
+  return "unknown";
+}
+function checkBindingTypeCompatibility(pipelines, stepsByKey) {
+  const issues = [];
+  for (const pipeline of pipelines) {
+    const nodeByKey = new Map(pipeline.nodeDefinitions.map((node) => [node.nodeKey, node]));
+    for (const ctx of bindingContexts(pipeline)) {
+      const specs = stepsByKey.get(ctx.stepKey);
+      const where = bindingContextLabel(pipeline.key, ctx);
+      for (const [field, binding] of Object.entries(ctx.inputBindingsJson)) {
+        if (binding.source === "fan_out_item")
+          continue;
+        if (isAutoBoundWorkItemField(field))
+          continue;
+        if (!specs)
+          continue;
+        const target = findPropertyNode(specs, field);
+        if (!target)
+          continue;
+        const targetType = resolveSchemaType(target.node, target.root);
+        if (targetType === "unknown")
+          continue;
+        const sourceType = bindingSourceType(binding, pipeline, nodeByKey, stepsByKey);
+        if (sourceType === "unknown")
+          continue;
+        if (sourceType === targetType)
+          continue;
+        issues.push({
+          check: "binding-type-mismatch",
+          severity: "warning",
+          pipelineKey: pipeline.key,
+          nodeKey: ctx.nodeKey,
+          branchKey: ctx.branchKey ?? undefined,
+          message: `${where} binds input "${field}" (declared type "${targetType}") to ` + `${describeBindingSource(binding)}, which resolves to type ` + `"${sourceType}" \u2014 the types disagree.`
+        });
+      }
+    }
+  }
+  return issues;
+}
+
+// src/definitions/validation/validate-definition-specs.ts
 function quotedOrRoot(prefix) {
   return prefix ? `"${prefix}"` : "the result root";
 }
@@ -17483,6 +17893,7 @@ function checkSignalSourcePaths(steps) {
       const suffix = availablePaths.length > 0 ? ` Valid sourcePaths ${resolvedPrefix ? `under "${resolvedPrefix}"` : "for this step"}: ${listPaths(availablePaths)}.` : "";
       issues.push({
         check: "signal-source-path",
+        severity: "error",
         message: `Step "${step.key}" declares signal "${signal2.key}" with sourcePath ` + `"${signal2.sourcePath}", which can never resolve against the step's ` + `result schema: ${cause}.${suffix}`
       });
     }
@@ -17505,6 +17916,7 @@ function checkHealthChecks(steps) {
       if (!mcpServerKeySet.has(check2.mcp)) {
         issues.push({
           check: "health-check-mcp-server",
+          severity: "error",
           message: `${where} names MCP server "${check2.mcp}", but the step declares no ` + `such server in mcpServers. Declared servers: ${mcpServerKeys.length > 0 ? listPaths([...mcpServerKeys].sort()) : "(none)"}.`
         });
       }
@@ -17512,6 +17924,7 @@ function checkHealthChecks(steps) {
       if (check2.tool.startsWith(prefix)) {
         issues.push({
           check: "health-check-double-qualified",
+          severity: "error",
           message: `${where} sets mcp "${check2.mcp}" and tool "${check2.tool}", which already ` + `starts with "${prefix}". When "mcp" is set, "tool" should be the bare tool ` + `name \u2014 OpenCode resolves it to "${prefix}${check2.tool}". Did you mean ` + `tool: "${check2.tool.slice(prefix.length)}"?`
         });
       }
@@ -17548,6 +17961,7 @@ function checkRouteTargets(pipelines, knownPipelineKeys) {
           continue;
         issues.push({
           check: "route-target",
+          severity: "error",
           pipelineKey: pipeline.key,
           nodeKey: node.nodeKey,
           message: `Pipeline "${pipeline.key}" step "${stepLabel}" routes to pipeline ` + `"${target}", but no pipeline with that key was found on the server or ` + `in the current push batch. Push the target pipeline first.`
@@ -17603,6 +18017,7 @@ function checkSignalBindings(pipelines, stepsByKey) {
     const order = [...pipeline.nodeDefinitions.keys()].sort((left, right) => (ranks.get(left) ?? 0) - (ranks.get(right) ?? 0)).map((index) => pipeline.nodeDefinitions[index]?.nodeKey ?? "");
     const orderHint = `Nodes in "${pipeline.key}", in order: ${order.join(" \u2192 ")}.`;
     const nodeByKey = new Map(pipeline.nodeDefinitions.map((node) => [node.nodeKey, node]));
+    const dominatorSets = tryComputeDominators(pipeline.nodeDefinitions, pipeline.dependencyEdges, pipeline.entryNodeKey);
     pipeline.nodeDefinitions.forEach((node, index) => {
       const consumerRank = ranks.get(index) ?? index;
       const where = `Pipeline "${pipeline.key}" node "${node.nodeKey}"`;
@@ -17613,6 +18028,7 @@ function checkSignalBindings(pipelines, stepsByKey) {
           continue;
         const what = source.kind === "signal" ? `binds input "${field}" to signal "${source.signalKey ?? ""}" of node "${source.nodeKey}"` : source.kind === "signals_list" ? `binds input "${field}" to the signals list of fan-out node "${source.nodeKey}"` : `binds input "${field}" to the output of node "${source.nodeKey}"`;
         const issueBase = {
+          severity: "error",
           pipelineKey: pipeline.key,
           nodeKey: node.nodeKey,
           targetNodeKey: source.nodeKey
@@ -17627,11 +18043,12 @@ function checkSignalBindings(pipelines, stepsByKey) {
           });
           continue;
         }
-        if (producerRank >= consumerRank) {
+        const producesBeforeConsumer = dominatorSets !== null ? source.nodeKey !== node.nodeKey && (dominatorSets.get(node.nodeKey)?.has(source.nodeKey) ?? false) : producerRank < consumerRank;
+        if (!producesBeforeConsumer) {
           issues.push({
             check: "signal-binding",
             ...issueBase,
-            message: `${where} ${what}, but that node does not run before it, so the ` + `value will never exist. ${orderHint}`
+            message: `${where} ${what}, but that node does not run on every path ` + `leading to this node, so the value may not exist. ${orderHint}`
           });
           continue;
         }
@@ -17663,11 +18080,14 @@ function validateDefinitionSpecs(specs, options = {}) {
     ...checkSignalSourcePaths(specs.steps),
     ...checkHealthChecks(specs.steps),
     ...checkRouteTargets(specs.pipelines, options.knownPipelineKeys ?? []),
-    ...checkSignalBindings(specs.pipelines, stepsByKey)
+    ...checkSignalBindings(specs.pipelines, stepsByKey),
+    ...checkUnboundRequiredInputs(specs.pipelines, stepsByKey),
+    ...checkBindingTargetFields(specs.pipelines, stepsByKey),
+    ...checkBindingTypeCompatibility(specs.pipelines, stepsByKey)
   ];
 }
 function assertValidDefinitionSpecs(specs, options = {}) {
-  const issues = validateDefinitionSpecs(specs, options);
+  const issues = validateDefinitionSpecs(specs, options).filter((issue2) => issue2.severity === "error");
   if (issues.length === 0)
     return;
   const header = issues.length === 1 ? "Definition validation failed:" : `Definition validation failed with ${String(issues.length)} problems:`;