@boboddy/sdk 0.1.5-alpha → 0.1.7-alpha

package/dist/definitions/advancement-policies/define-advancement-policy.d.ts

@@ -1,3 +1,50 @@
+/** Aggregation types supported by the runtime for computed signals. */
+export type PipelineStepComputedSignalType = "average" | "weighted_average" | "sum" | "min" | "max" | "count" | "boolean_any" | "boolean_all";
+type Join<T extends readonly string[], D extends string> = T extends readonly [
+    infer Head extends string,
+    ...infer Rest extends readonly string[]
+] ? Rest extends readonly [] ? Head : `${Head}${D}${Join<Rest, D>}` : "";
+/**
+ * An inline computed-signal token returned by `Computed.X(...)`. Carries the
+ * derived `key` (e.g. `"sum_success"`), the aggregation `type`, and the input
+ * signal keys it aggregates over. At serialization time, every inline token
+ * embedded in a rule's signal position is extracted into the step's
+ * `computedSignalDefinitions` and replaced by its bare key string.
+ *
+ * - `TKey`             — the auto-derived key (literal template).
+ * - `TInputSignalKeys` — the union of input signal keys; constrained to the
+ *                        step's signals via `Rule.signal` / `Rule.when` typing.
+ */
+export type InlineComputedSignal<TKey extends string = string, TInputSignalKeys extends string = string> = {
+    readonly _tag: "computed_signal";
+    readonly key: TKey;
+    readonly type: PipelineStepComputedSignalType;
+    readonly inputSignalKeys: ReadonlyArray<TInputSignalKeys>;
+    readonly configJson: Record<string, unknown> | null;
+    readonly availableWhenResultStatusIn: readonly string[] | null;
+};
+type ComputedOptions = {
+    configJson?: Record<string, unknown> | null;
+    availableWhenResultStatusIn?: readonly string[] | null;
+};
+/**
+ * Factories for inline computed signals. Each call returns a token whose `key`
+ * is auto-derived as `${type}_${inputSignalKeys.join("_")}`.
+ *
+ * @example
+ * Rule.when(Computed.sum(["success"]), "greaterThan", 1, "continue")
+ * Rule.signal(Computed.average(["score"]), "greaterThanInclusive", 80)
+ */
+export declare const Computed: {
+    readonly average: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`average_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly weightedAverage: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`weighted_average_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly sum: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`sum_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly min: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`min_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly max: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`max_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly count: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`count_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly booleanAny: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`boolean_any_${Join<TInputs, "_">}`, TInputs[number]>;
+    readonly booleanAll: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`boolean_all_${Join<TInputs, "_">}`, TInputs[number]>;
+};
 /**
  * Comparison operators supported by json-rules-engine.
  * These map directly to the operator names the runtime evaluates against signal values.
@@ -26,11 +73,14 @@ export type AdvancementOutcome = AdvancementEventType | {
  * by `Rule.when()`.
  *
  * `TSignalKeys` is constrained to the declaring step's signal keys, so the
- * `signal` field is validated at compile time.
+ * `signal` field is validated at compile time. `signal` may be either a step
+ * signal key (string) or an inline `Computed.X(...)` token — at serialization
+ * time, inline tokens are hoisted into `computedSignalDefinitions` and replaced
+ * by their bare key string.
  */
 export type SignalCondition<TSignalKeys extends string = string> = {
     readonly _tag: "signal";
-    signal: TSignalKeys;
+    signal: TSignalKeys | InlineComputedSignal<string, TSignalKeys>;
     operator: ConditionOperator;
     value: unknown;
 };
@@ -80,7 +130,7 @@ export type Rule<TSignalKeys extends string = string> = {
  *   Rule.signal("flagged", "equal", false),
  * ], "continue")
  */
-declare function signal<TSignalKeys extends string>(signal: TSignalKeys, operator: ConditionOperator, value: unknown): SignalCondition<TSignalKeys>;
+declare function signal<TSignalKeys extends string>(signal: TSignalKeys | InlineComputedSignal<string, TSignalKeys>, operator: ConditionOperator, value: unknown): SignalCondition<TSignalKeys>;
 /**
  * When called with only `conditions`: returns a nested `AllCondition` group
  * for use inside another `Rule.all()` or `Rule.any()`.
@@ -136,7 +186,7 @@ declare function any<TSignalKeys extends string>(conditions: RuleCondition<TSign
  * Rule.when("passed", "equal", true, "continue")
  * Rule.when("score", "greaterThanInclusive", 80, { outcome: "continue", outcomeJson: { via: "score" } })
  */
-declare function when<TSignalKeys extends string>(signal: TSignalKeys, operator: ConditionOperator, value: unknown, outcome: AdvancementOutcome): Rule<TSignalKeys>;
+declare function when<TSignalKeys extends string>(signal: TSignalKeys | InlineComputedSignal<string, TSignalKeys>, operator: ConditionOperator, value: unknown, outcome: AdvancementOutcome): Rule<TSignalKeys>;
 /**
  * All factories for building advancement rules.
  *
@@ -215,4 +265,19 @@ export type SerializedAdvancementPolicy = {
     allowedEventTypes: AdvancementEventType[];
 };
 export declare function serializeAdvancementPolicy(policy: AdvancementPolicy | undefined): SerializedAdvancementPolicy;
+/** Wire-format computed signal definition emitted on the pipeline step. */
+export type SerializedComputedSignalDefinition = {
+    key: string;
+    type: PipelineStepComputedSignalType;
+    inputSignalKeys: string[];
+    configJson: Record<string, unknown> | null;
+    availableWhenResultStatusIn: string[] | null;
+};
+/**
+ * Walks the rules tree, extracts every inline `Computed.X(...)` token embedded
+ * in a `SignalCondition.signal` position, dedupes by key, and returns the
+ * resulting computed-signal definitions. Two tokens with the same key but
+ * differing definitions are a programming error and throw.
+ */
+export declare function extractInlineComputedSignals(policy: AdvancementPolicy | undefined): SerializedComputedSignalDefinition[];
 export {};

package/dist/definitions/advancement-policies/index.js

@@ -14,6 +14,27 @@ var __export = (target, all) => {
 };
 
 // src/definitions/advancement-policies/define-advancement-policy.ts
+function makeComputed(type, inputSignalKeys, options) {
+  const key = [type, ...inputSignalKeys].join("_");
+  return {
+    _tag: "computed_signal",
+    key,
+    type,
+    inputSignalKeys,
+    configJson: options?.configJson ?? null,
+    availableWhenResultStatusIn: options?.availableWhenResultStatusIn ?? null
+  };
+}
+var Computed = {
+  average: (inputSignalKeys, options) => makeComputed("average", inputSignalKeys, options),
+  weightedAverage: (inputSignalKeys, options) => makeComputed("weighted_average", inputSignalKeys, options),
+  sum: (inputSignalKeys, options) => makeComputed("sum", inputSignalKeys, options),
+  min: (inputSignalKeys, options) => makeComputed("min", inputSignalKeys, options),
+  max: (inputSignalKeys, options) => makeComputed("max", inputSignalKeys, options),
+  count: (inputSignalKeys, options) => makeComputed("count", inputSignalKeys, options),
+  booleanAny: (inputSignalKeys, options) => makeComputed("boolean_any", inputSignalKeys, options),
+  booleanAll: (inputSignalKeys, options) => makeComputed("boolean_all", inputSignalKeys, options)
+};
 function signal(signal2, operator, value) {
   return { _tag: "signal", signal: signal2, operator, value };
 }
@@ -47,7 +68,7 @@ function resolveOutcome(outcome) {
 function serializeCondition(condition) {
   if (condition._tag === "signal") {
     return {
-      fact: condition.signal,
+      fact: typeof condition.signal === "string" ? condition.signal : condition.signal.key,
       operator: condition.operator,
       value: condition.value
     };
@@ -89,7 +110,49 @@ function serializeAdvancementPolicy(policy) {
     allowedEventTypes: [...outcomeSet]
   };
 }
+function visitSignalConditions(conditions, visit) {
+  for (const c of conditions) {
+    if (c._tag === "signal") {
+      visit(c);
+    } else {
+      visitSignalConditions(c.conditions, visit);
+    }
+  }
+}
+function isSameComputedDefinition(a, b) {
+  return a.type === b.type && a.inputSignalKeys.length === b.inputSignalKeys.length && a.inputSignalKeys.every((k, i) => k === b.inputSignalKeys[i]) && JSON.stringify(a.configJson) === JSON.stringify(b.configJson) && JSON.stringify(a.availableWhenResultStatusIn) === JSON.stringify(b.availableWhenResultStatusIn);
+}
+function extractInlineComputedSignals(policy) {
+  if (!policy?.rules)
+    return [];
+  const byKey = new Map;
+  for (const rule of policy.rules) {
+    visitSignalConditions(rule.conditions, (cond) => {
+      if (typeof cond.signal === "string")
+        return;
+      const inline = cond.signal;
+      const def = {
+        key: inline.key,
+        type: inline.type,
+        inputSignalKeys: [...inline.inputSignalKeys],
+        configJson: inline.configJson,
+        availableWhenResultStatusIn: inline.availableWhenResultStatusIn ? [...inline.availableWhenResultStatusIn] : null
+      };
+      const existing = byKey.get(def.key);
+      if (existing) {
+        if (!isSameComputedDefinition(existing, def)) {
+          throw new Error(`Conflicting inline computed signal definitions for key "${def.key}"`);
+        }
+        return;
+      }
+      byKey.set(def.key, def);
+    });
+  }
+  return [...byKey.values()];
+}
 export {
   serializeAdvancementPolicy,
-  Rule
+  extractInlineComputedSignals,
+  Rule,
+  Computed
 };

package/dist/definitions/pipelines/define-pipeline.d.ts

@@ -1,8 +1,8 @@
 import type { ZodType } from "zod";
 import type { DotPaths, TypedStepDefinitionSpec } from "../steps/define-step";
-import { type AdvancementPolicy, type SerializedAdvancementPolicy } from "../advancement-policies/define-advancement-policy";
-export type { AdvancementPolicy } from "../advancement-policies/define-advancement-policy";
-export { Rule } from "../advancement-policies/define-advancement-policy";
+import { type AdvancementPolicy, type SerializedAdvancementPolicy, type SerializedComputedSignalDefinition } from "../advancement-policies/define-advancement-policy";
+export type { AdvancementPolicy, PipelineStepComputedSignalType, } from "../advancement-policies/define-advancement-policy";
+export { Computed, Rule, } from "../advancement-policies/define-advancement-policy";
 type AnyTypedStep = TypedStepDefinitionSpec<any, any, any>;
 export type PipelineInputBinding = {
     source: "pipeline_input";
@@ -43,7 +43,10 @@ export type PipelineStepConfig<TStep extends AnyTypedStep = AnyTypedStep> = {
     timeout?: number | null;
     /**
      * Controls when and how this step advances in the pipeline.
-     * Signal keys in `whenSignal()` rules are type-checked against this step's declared signals.
+     * Signal keys in `Rule.signal()` / `Rule.when()` calls are type-checked
+     * against the step's declared signals. Inline `Computed.X(...)` tokens can
+     * also appear in the signal position; they're hoisted into the step's
+     * `computedSignalDefinitions` at serialization time.
      * Defaults to `{ defaultOutcome: "continue" }` when omitted.
      */
     advancement?: AdvancementPolicy<TStep["__signalKeys"]>;
@@ -73,6 +76,7 @@ export type PipelineDefinitionSpec = {
         inputBindingsJson: Record<string, SerializedBinding>;
         timeoutSeconds: number | null;
         advancementPolicyDefinition: SerializedAdvancementPolicy;
+        computedSignalDefinitions: SerializedComputedSignalDefinition[];
     }>;
 };
 /**
@@ -92,7 +96,10 @@ export type DefinePipelineInput = {
  * Defines a pipeline from an ordered list of step configs.
  *
  * Each step's `advancement` policy is typed against that step's declared signal
- * keys — passing an unknown signal key to `whenSignal()` is a compile-time error.
+ * keys — passing an unknown signal key to `Rule.signal()` / `Rule.when()` is a
+ * compile-time error. Inline `Computed.X(...)` tokens can also be used in the
+ * signal position; they're walked out of the rules tree at serialization time
+ * and emitted as the step's `computedSignalDefinitions`.
  *
  * TypeScript achieves per-element signal key checking by constraining `TSteps`
  * to a tuple of step instances (`AnyTypedStep[]`), not step configs. Each element

package/dist/definitions/pipelines/index.js

@@ -14,6 +14,27 @@ var __export = (target, all) => {
 };
 
 // src/definitions/advancement-policies/define-advancement-policy.ts
+function makeComputed(type, inputSignalKeys, options) {
+  const key = [type, ...inputSignalKeys].join("_");
+  return {
+    _tag: "computed_signal",
+    key,
+    type,
+    inputSignalKeys,
+    configJson: options?.configJson ?? null,
+    availableWhenResultStatusIn: options?.availableWhenResultStatusIn ?? null
+  };
+}
+var Computed = {
+  average: (inputSignalKeys, options) => makeComputed("average", inputSignalKeys, options),
+  weightedAverage: (inputSignalKeys, options) => makeComputed("weighted_average", inputSignalKeys, options),
+  sum: (inputSignalKeys, options) => makeComputed("sum", inputSignalKeys, options),
+  min: (inputSignalKeys, options) => makeComputed("min", inputSignalKeys, options),
+  max: (inputSignalKeys, options) => makeComputed("max", inputSignalKeys, options),
+  count: (inputSignalKeys, options) => makeComputed("count", inputSignalKeys, options),
+  booleanAny: (inputSignalKeys, options) => makeComputed("boolean_any", inputSignalKeys, options),
+  booleanAll: (inputSignalKeys, options) => makeComputed("boolean_all", inputSignalKeys, options)
+};
 function signal(signal2, operator, value) {
   return { _tag: "signal", signal: signal2, operator, value };
 }
@@ -47,7 +68,7 @@ function resolveOutcome(outcome) {
 function serializeCondition(condition) {
   if (condition._tag === "signal") {
     return {
-      fact: condition.signal,
+      fact: typeof condition.signal === "string" ? condition.signal : condition.signal.key,
       operator: condition.operator,
       value: condition.value
     };
@@ -89,6 +110,46 @@ function serializeAdvancementPolicy(policy) {
     allowedEventTypes: [...outcomeSet]
   };
 }
+function visitSignalConditions(conditions, visit) {
+  for (const c of conditions) {
+    if (c._tag === "signal") {
+      visit(c);
+    } else {
+      visitSignalConditions(c.conditions, visit);
+    }
+  }
+}
+function isSameComputedDefinition(a, b) {
+  return a.type === b.type && a.inputSignalKeys.length === b.inputSignalKeys.length && a.inputSignalKeys.every((k, i) => k === b.inputSignalKeys[i]) && JSON.stringify(a.configJson) === JSON.stringify(b.configJson) && JSON.stringify(a.availableWhenResultStatusIn) === JSON.stringify(b.availableWhenResultStatusIn);
+}
+function extractInlineComputedSignals(policy) {
+  if (!policy?.rules)
+    return [];
+  const byKey = new Map;
+  for (const rule of policy.rules) {
+    visitSignalConditions(rule.conditions, (cond) => {
+      if (typeof cond.signal === "string")
+        return;
+      const inline = cond.signal;
+      const def = {
+        key: inline.key,
+        type: inline.type,
+        inputSignalKeys: [...inline.inputSignalKeys],
+        configJson: inline.configJson,
+        availableWhenResultStatusIn: inline.availableWhenResultStatusIn ? [...inline.availableWhenResultStatusIn] : null
+      };
+      const existing = byKey.get(def.key);
+      if (existing) {
+        if (!isSameComputedDefinition(existing, def)) {
+          throw new Error(`Conflicting inline computed signal definitions for key "${def.key}"`);
+        }
+        return;
+      }
+      byKey.set(def.key, def);
+    });
+  }
+  return [...byKey.values()];
+}
 
 // src/definitions/pipelines/define-pipeline.ts
 function fromPipelineInput(_schema, path) {
@@ -128,7 +189,8 @@ function definePipeline(config) {
       position: index + 1,
       inputBindingsJson: Object.fromEntries(Object.entries(stepConfig.input ?? {}).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)])),
       timeoutSeconds: stepConfig.timeout ?? null,
-      advancementPolicyDefinition: serializeAdvancementPolicy(stepConfig.advancement)
+      advancementPolicyDefinition: serializeAdvancementPolicy(stepConfig.advancement),
+      computedSignalDefinitions: extractInlineComputedSignals(stepConfig.advancement)
     }))
   };
 }
@@ -179,5 +241,6 @@ export {
   fromPipelineInput,
   definePipeline,
   createPipelineDefinitionsClient,
-  Rule
+  Rule,
+  Computed
 };

package/dist/definitions/steps/define-step.d.ts

@@ -43,13 +43,6 @@ export type StepSignalSpec = {
     required?: boolean;
     availableWhenResultStatusIn?: string[] | null;
 };
-export type StepComputedSignalSpec = {
-    key: string;
-    type: "average" | "weighted_average" | "sum" | "min" | "max" | "custom";
-    inputSignalKeys: string[];
-    configJson?: Record<string, unknown> | null;
-    availableWhenResultStatusIn?: string[] | null;
-};
 export type DefineStepInput<TInput extends ZodType = ZodType, TResult extends ZodType = ZodType> = {
     key: string;
     name: string;
@@ -59,7 +52,6 @@ export type DefineStepInput<TInput extends ZodType = ZodType, TResult extends Zo
     input?: TInput;
     result?: TResult;
     signals?: SignalSpecInput<TResult["_output"]>[];
-    computedSignals?: StepComputedSignalSpec[];
     features?: AnyStepFeature[];
     mcpServers?: OpenCodeMcpServers | null;
     status?: "draft" | "active";
@@ -81,13 +73,6 @@ export type StepDefinitionSpec = {
         required: boolean;
         availableWhenResultStatusIn: string[] | null;
     }>;
-    computedSignalDefinitions: Array<{
-        key: string;
-        type: "average" | "weighted_average" | "sum" | "min" | "max" | "custom";
-        inputSignalKeys: string[];
-        configJson: Record<string, unknown> | null;
-        availableWhenResultStatusIn: string[] | null;
-    }>;
     opencodeMcpJson: OpenCodeMcpServers | null;
 };
 export type TypedStepDefinitionSpec<TInput = unknown, TResult = unknown, TSignalKeys extends string = string> = StepDefinitionSpec & {

package/dist/definitions/steps/index.js

@@ -12026,13 +12026,6 @@ ${feature._promptAddition}` : feature._promptAddition;
         availableWhenResultStatusIn: s.availableWhenResultStatusIn ?? null
       }))
     ],
-    computedSignalDefinitions: (config2.computedSignals ?? []).map((cs) => ({
-      key: cs.key,
-      type: cs.type,
-      inputSignalKeys: cs.inputSignalKeys,
-      configJson: cs.configJson ?? null,
-      availableWhenResultStatusIn: cs.availableWhenResultStatusIn ?? null
-    })),
     opencodeMcpJson: config2.mcpServers ?? null
   };
   return spec;

package/dist/definitions/steps/step-definitions-client.d.ts

@@ -56,16 +56,6 @@ declare const buildStepDefinitionsClient: (stepDefinitions: StepDefinitions) =>
             createdAt: string;
             updatedAt: string;
         }>;
-        computedSignalDefinitions: Array<{
-            id: string;
-            key: string;
-            type: "average" | "weighted_average" | "sum" | "min" | "max" | "custom";
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-            createdAt: string;
-            updatedAt: string;
-        }>;
         createdAt: string;
         updatedAt: string;
     }[]>;
@@ -118,16 +108,6 @@ declare const buildStepDefinitionsClient: (stepDefinitions: StepDefinitions) =>
             createdAt: string;
             updatedAt: string;
         }>;
-        computedSignalDefinitions: Array<{
-            id: string;
-            key: string;
-            type: "average" | "weighted_average" | "sum" | "min" | "max" | "custom";
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-            createdAt: string;
-            updatedAt: string;
-        }>;
         createdAt: string;
         updatedAt: string;
     }>;
@@ -180,16 +160,6 @@ declare const buildStepDefinitionsClient: (stepDefinitions: StepDefinitions) =>
             createdAt: string;
             updatedAt: string;
         }>;
-        computedSignalDefinitions: Array<{
-            id: string;
-            key: string;
-            type: "average" | "weighted_average" | "sum" | "min" | "max" | "custom";
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-            createdAt: string;
-            updatedAt: string;
-        }>;
         createdAt: string;
         updatedAt: string;
     }>;

package/dist/generated/types.gen.d.ts

@@ -690,16 +690,6 @@ export type GetApiStepDefinitionsResponses = {
             createdAt: string;
             updatedAt: string;
         }>;
-        computedSignalDefinitions: Array<{
-            id: string;
-            key: string;
-            type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'custom';
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-            createdAt: string;
-            updatedAt: string;
-        }>;
         createdAt: string;
         updatedAt: string;
     }>;
@@ -751,13 +741,6 @@ export type PostApiStepDefinitionsData = {
             required: boolean;
             availableWhenResultStatusIn: Array<string> | unknown;
         }>;
-        computedSignalDefinitions: Array<{
-            key: string;
-            type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'custom';
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-        }>;
     };
     path?: never;
     query?: never;
@@ -931,16 +914,6 @@ export type PostApiStepDefinitionsResponses = {
             createdAt: string;
             updatedAt: string;
         }>;
-        computedSignalDefinitions: Array<{
-            id: string;
-            key: string;
-            type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'custom';
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-            createdAt: string;
-            updatedAt: string;
-        }>;
         createdAt: string;
         updatedAt: string;
     };
@@ -1090,16 +1063,6 @@ export type GetApiStepDefinitionsByStepDefinitionIdResponses = {
             createdAt: string;
             updatedAt: string;
         }>;
-        computedSignalDefinitions: Array<{
-            id: string;
-            key: string;
-            type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'custom';
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-            createdAt: string;
-            updatedAt: string;
-        }>;
         createdAt: string;
         updatedAt: string;
     };
@@ -1151,13 +1114,6 @@ export type PutApiStepDefinitionsByStepDefinitionIdData = {
             required: boolean;
             availableWhenResultStatusIn: Array<string> | unknown;
         }>;
-        computedSignalDefinitions: Array<{
-            key: string;
-            type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'custom';
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-        }>;
     };
     path: {
         stepDefinitionId: string;
@@ -1301,16 +1257,6 @@ export type PutApiStepDefinitionsByStepDefinitionIdResponses = {
             createdAt: string;
             updatedAt: string;
         }>;
-        computedSignalDefinitions: Array<{
-            id: string;
-            key: string;
-            type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'custom';
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-            createdAt: string;
-            updatedAt: string;
-        }>;
         createdAt: string;
         updatedAt: string;
     };
@@ -1460,16 +1406,6 @@ export type PutApiStepDefinitionsByStepDefinitionIdArchiveResponses = {
             createdAt: string;
             updatedAt: string;
         }>;
-        computedSignalDefinitions: Array<{
-            id: string;
-            key: string;
-            type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'custom';
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-            createdAt: string;
-            updatedAt: string;
-        }>;
         createdAt: string;
         updatedAt: string;
     };
@@ -3097,6 +3033,18 @@ export type GetApiLinearPipelineDefinitionsResponses = {
                 createdAt: string;
                 updatedAt: string;
             };
+            computedSignalDefinitions: Array<{
+                id: string;
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+                createdAt: string;
+                updatedAt: string;
+            }>;
             createdAt: string;
             updatedAt: string;
         }>;
@@ -3192,6 +3140,15 @@ export type PostApiLinearPipelineDefinitionsData = {
                 } | unknown;
                 allowedEventTypes: Array<'continue' | 'block' | 'needs_review' | 'complete'>;
             };
+            computedSignalDefinitions: Array<{
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+            }>;
         }>;
     };
     path?: never;
@@ -3410,6 +3367,18 @@ export type PostApiLinearPipelineDefinitionsResponses = {
                 createdAt: string;
                 updatedAt: string;
             };
+            computedSignalDefinitions: Array<{
+                id: string;
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+                createdAt: string;
+                updatedAt: string;
+            }>;
             createdAt: string;
             updatedAt: string;
         }>;
@@ -3505,6 +3474,15 @@ export type PutApiLinearPipelineDefinitionsData = {
                 } | unknown;
                 allowedEventTypes: Array<'continue' | 'block' | 'needs_review' | 'complete'>;
             };
+            computedSignalDefinitions: Array<{
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+            }>;
         }>;
     };
     path?: never;
@@ -3675,6 +3653,18 @@ export type PutApiLinearPipelineDefinitionsResponses = {
                 createdAt: string;
                 updatedAt: string;
             };
+            computedSignalDefinitions: Array<{
+                id: string;
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+                createdAt: string;
+                updatedAt: string;
+            }>;
             createdAt: string;
             updatedAt: string;
         }>;
@@ -3887,6 +3877,18 @@ export type GetApiLinearPipelineDefinitionsByLinearPipelineDefinitionIdResponses
                 createdAt: string;
                 updatedAt: string;
             };
+            computedSignalDefinitions: Array<{
+                id: string;
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+                createdAt: string;
+                updatedAt: string;
+            }>;
             createdAt: string;
             updatedAt: string;
         }>;
@@ -4083,6 +4085,18 @@ export type PutApiLinearPipelineDefinitionsByLinearPipelineDefinitionIdArchiveRe
                 createdAt: string;
                 updatedAt: string;
             };
+            computedSignalDefinitions: Array<{
+                id: string;
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+                createdAt: string;
+                updatedAt: string;
+            }>;
             createdAt: string;
             updatedAt: string;
         }>;
@@ -4171,6 +4185,15 @@ export type PostApiLinearPipelineDefinitionsByLinearPipelineDefinitionIdStepsDat
             } | unknown;
             allowedEventTypes: Array<'continue' | 'block' | 'needs_review' | 'complete'>;
         };
+        computedSignalDefinitions: Array<{
+            key: string;
+            type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+            inputSignalKeys: Array<string>;
+            configJson: {
+                [key: string]: unknown;
+            } | unknown;
+            availableWhenResultStatusIn: Array<string> | unknown;
+        }>;
     };
     path: {
         linearPipelineDefinitionId: string;
@@ -4358,6 +4381,18 @@ export type PostApiLinearPipelineDefinitionsByLinearPipelineDefinitionIdStepsRes
                 createdAt: string;
                 updatedAt: string;
             };
+            computedSignalDefinitions: Array<{
+                id: string;
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+                createdAt: string;
+                updatedAt: string;
+            }>;
             createdAt: string;
             updatedAt: string;
         }>;
@@ -4555,6 +4590,18 @@ export type DeleteApiLinearPipelineDefinitionsByLinearPipelineDefinitionIdStepsB
                 createdAt: string;
                 updatedAt: string;
             };
+            computedSignalDefinitions: Array<{
+                id: string;
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+                createdAt: string;
+                updatedAt: string;
+            }>;
             createdAt: string;
             updatedAt: string;
         }>;
@@ -4643,6 +4690,15 @@ export type PutApiLinearPipelineDefinitionsByLinearPipelineDefinitionIdStepsByLi
             } | unknown;
             allowedEventTypes: Array<'continue' | 'block' | 'needs_review' | 'complete'>;
         };
+        computedSignalDefinitions: Array<{
+            key: string;
+            type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+            inputSignalKeys: Array<string>;
+            configJson: {
+                [key: string]: unknown;
+            } | unknown;
+            availableWhenResultStatusIn: Array<string> | unknown;
+        }>;
     };
     path: {
         linearPipelineDefinitionId: string;
@@ -4831,6 +4887,18 @@ export type PutApiLinearPipelineDefinitionsByLinearPipelineDefinitionIdStepsByLi
                 createdAt: string;
                 updatedAt: string;
             };
+            computedSignalDefinitions: Array<{
+                id: string;
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+                createdAt: string;
+                updatedAt: string;
+            }>;
             createdAt: string;
             updatedAt: string;
         }>;
@@ -5076,6 +5144,18 @@ export type PutApiLinearPipelineDefinitionsByLinearPipelineDefinitionIdStepsByLi
                 createdAt: string;
                 updatedAt: string;
             };
+            computedSignalDefinitions: Array<{
+                id: string;
+                key: string;
+                type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'count' | 'boolean_any' | 'boolean_all';
+                inputSignalKeys: Array<string>;
+                configJson: {
+                    [key: string]: unknown;
+                } | unknown;
+                availableWhenResultStatusIn: Array<string> | unknown;
+                createdAt: string;
+                updatedAt: string;
+            }>;
             createdAt: string;
             updatedAt: string;
         }>;
@@ -9125,16 +9205,6 @@ export type PostApiStepDefinitionTemplatesByStepDefinitionTemplateIdInstantiateR
             createdAt: string;
             updatedAt: string;
         }>;
-        computedSignalDefinitions: Array<{
-            id: string;
-            key: string;
-            type: 'average' | 'weighted_average' | 'sum' | 'min' | 'max' | 'custom';
-            inputSignalKeys: Array<string>;
-            configJson: unknown;
-            availableWhenResultStatusIn: Array<string> | unknown;
-            createdAt: string;
-            updatedAt: string;
-        }>;
         createdAt: string;
         updatedAt: string;
     };

package/dist/index.js

@@ -13369,13 +13369,6 @@ ${feature._promptAddition}` : feature._promptAddition;
         availableWhenResultStatusIn: s.availableWhenResultStatusIn ?? null
       }))
     ],
-    computedSignalDefinitions: (config2.computedSignals ?? []).map((cs) => ({
-      key: cs.key,
-      type: cs.type,
-      inputSignalKeys: cs.inputSignalKeys,
-      configJson: cs.configJson ?? null,
-      availableWhenResultStatusIn: cs.availableWhenResultStatusIn ?? null
-    })),
     opencodeMcpJson: config2.mcpServers ?? null
   };
   return spec;
@@ -15804,6 +15797,27 @@ var Features = {
   })
 };
 // src/definitions/advancement-policies/define-advancement-policy.ts
+function makeComputed(type, inputSignalKeys, options) {
+  const key = [type, ...inputSignalKeys].join("_");
+  return {
+    _tag: "computed_signal",
+    key,
+    type,
+    inputSignalKeys,
+    configJson: options?.configJson ?? null,
+    availableWhenResultStatusIn: options?.availableWhenResultStatusIn ?? null
+  };
+}
+var Computed = {
+  average: (inputSignalKeys, options) => makeComputed("average", inputSignalKeys, options),
+  weightedAverage: (inputSignalKeys, options) => makeComputed("weighted_average", inputSignalKeys, options),
+  sum: (inputSignalKeys, options) => makeComputed("sum", inputSignalKeys, options),
+  min: (inputSignalKeys, options) => makeComputed("min", inputSignalKeys, options),
+  max: (inputSignalKeys, options) => makeComputed("max", inputSignalKeys, options),
+  count: (inputSignalKeys, options) => makeComputed("count", inputSignalKeys, options),
+  booleanAny: (inputSignalKeys, options) => makeComputed("boolean_any", inputSignalKeys, options),
+  booleanAll: (inputSignalKeys, options) => makeComputed("boolean_all", inputSignalKeys, options)
+};
 function signal(signal2, operator, value) {
   return { _tag: "signal", signal: signal2, operator, value };
 }
@@ -15837,7 +15851,7 @@ function resolveOutcome(outcome) {
 function serializeCondition(condition) {
   if (condition._tag === "signal") {
     return {
-      fact: condition.signal,
+      fact: typeof condition.signal === "string" ? condition.signal : condition.signal.key,
       operator: condition.operator,
       value: condition.value
     };
@@ -15879,6 +15893,46 @@ function serializeAdvancementPolicy(policy) {
     allowedEventTypes: [...outcomeSet]
   };
 }
+function visitSignalConditions(conditions, visit) {
+  for (const c of conditions) {
+    if (c._tag === "signal") {
+      visit(c);
+    } else {
+      visitSignalConditions(c.conditions, visit);
+    }
+  }
+}
+function isSameComputedDefinition(a, b) {
+  return a.type === b.type && a.inputSignalKeys.length === b.inputSignalKeys.length && a.inputSignalKeys.every((k, i) => k === b.inputSignalKeys[i]) && JSON.stringify(a.configJson) === JSON.stringify(b.configJson) && JSON.stringify(a.availableWhenResultStatusIn) === JSON.stringify(b.availableWhenResultStatusIn);
+}
+function extractInlineComputedSignals(policy) {
+  if (!policy?.rules)
+    return [];
+  const byKey = new Map;
+  for (const rule of policy.rules) {
+    visitSignalConditions(rule.conditions, (cond) => {
+      if (typeof cond.signal === "string")
+        return;
+      const inline = cond.signal;
+      const def = {
+        key: inline.key,
+        type: inline.type,
+        inputSignalKeys: [...inline.inputSignalKeys],
+        configJson: inline.configJson,
+        availableWhenResultStatusIn: inline.availableWhenResultStatusIn ? [...inline.availableWhenResultStatusIn] : null
+      };
+      const existing = byKey.get(def.key);
+      if (existing) {
+        if (!isSameComputedDefinition(existing, def)) {
+          throw new Error(`Conflicting inline computed signal definitions for key "${def.key}"`);
+        }
+        return;
+      }
+      byKey.set(def.key, def);
+    });
+  }
+  return [...byKey.values()];
+}
 
 // src/definitions/pipelines/define-pipeline.ts
 function fromPipelineInput(_schema, path) {
@@ -15918,7 +15972,8 @@ function definePipeline(config2) {
       position: index + 1,
       inputBindingsJson: Object.fromEntries(Object.entries(stepConfig.input ?? {}).filter((entry) => entry[1] !== undefined).map(([key, binding]) => [key, serializeBinding(binding)])),
       timeoutSeconds: stepConfig.timeout ?? null,
-      advancementPolicyDefinition: serializeAdvancementPolicy(stepConfig.advancement)
+      advancementPolicyDefinition: serializeAdvancementPolicy(stepConfig.advancement),
+      computedSignalDefinitions: extractInlineComputedSignals(stepConfig.advancement)
     }))
   };
 }
@@ -16633,6 +16688,7 @@ export {
   PipelineDefinitions,
   FeedbackRequests,
   Features,
+  Computed,
   BoboddyClient,
   BOBODDY_CONFIG_RELATIVE_PATH,
   Api

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@boboddy/sdk",
-  "version": "0.1.5-alpha",
+  "version": "0.1.7-alpha",
   "type": "module",
   "exports": {
     ".": {