Lodash-style value transforms (fp::get/pick/take/…) and fp::pipe — worker-side pipelines that move big values function→function without routing them through the model.
iiiverifiedexact versions are immutable; binary and bundle artifacts are digest-pinned.
Remove null elements from an array (lodash _.compact, null-only: 0, false and "" are KEPT). Pairs with fp::map, whose sporadic misses become null.
Input value (a pipe lands the previous step's value here).
Trigger-binding guard: compare a JSON pointer inside the fired event and answer { decision: "allow" | "skip", reason }; config is { path?, op, to?, negate? } with the fp::when ops. A pointer that resolves to nothing SKIPS rather than erroring.
Invert the verdict — the only way to fire when the path is ABSENT (a path that never resolves then fires on every event).
Comparison to run.
JSON pointer into the event; defaults to the whole event.
Right-hand side for the comparison ops; rejected for exists/not_empty.
Count array elements per plucked key (lodash _.countBy) into { "<key>": <count> }; path "" counts by the element itself. Same key rules as fp::groupBy.
JSON pointer plucked from each element as the bucket key (`""` = the element itself).
Input value (a pipe lands the previous step's value here).
Skip the first n elements of an array or the first n characters of a string (lodash _.drop).
How many array elements / string characters to skip.
Input value (a pipe lands the previous step's value here).
Keep array elements whose properties equal a partial object (lodash _.filter with a matches iteratee). `matches` is a partial OBJECT, never a bare string/number; only object elements can match.
Partial object an element's top-level properties must equal.
Input value (a pipe lands the previous step's value here).
Flatten an array one level (lodash _.flatten).
Input value (a pipe lands the previous step's value here).
Extract the single value at a JSON pointer (lodash _.get). A miss names the keys that were available.
JSON pointer selecting the value to return (e.g. `/content`).
Input value (a pipe lands the previous step's value here).
Extract the value at a JSON pointer, or `default` when the path misses (lodash fp.getOr). A stored null is a hit, not a miss.
Returned when the path matches nothing (a stored null is a hit).
JSON pointer selecting the value to return (e.g. `/content`).
Input value (a pipe lands the previous step's value here).
Bucket array elements by a plucked key (lodash _.groupBy) into { "<key>": [element, ...] }; path "" groups by the element itself. Keys must be a string, number, or boolean; null or container keys error.
JSON pointer plucked from each element as the bucket key (`""` = the element itself).
Input value (a pipe lands the previous step's value here).
Internal pre_generate hook: appends fp::pipe usage guidance to the agent system prompt. Bound to harness::hook::pre-generate at worker startup; not called directly.
The system prompt assembled so far (base + any prior hook's mutation).
The harness applies `system_prompt` only when the key is present (`HookRunner::run_pre_generate` — `if m.system_prompt.is_some()`), so `None` serializes to an empty object: the safe no-op that preserves the harness's assembled prompt.
Full replacement system prompt (base + appended guidance). The harness overwrites, it does not merge.
Join array elements into one string (lodash _.join); separator defaults to ",".
Separator between elements (default `","`).
Input value (a pipe lands the previous step's value here).
Pluck the value at a JSON pointer from each array element (lodash _.map with a property iteratee). Sporadic misses become null (fp::compact drops them); a path matching NO element errors.
JSON pointer plucked from each element (e.g. `/id`); sporadic misses become null, a path matching no element errors.
Input value (a pipe lands the previous step's value here).
Find the largest number in an array (lodash _.max/_.maxBy); `path` plucks from each element first. Returns the NUMBER, not the element. An empty array errors.
JSON pointer plucked from each element before reducing (the lodash `…By` form).
Input value (a pipe lands the previous step's value here).
Average an array of numbers (lodash _.mean/_.meanBy); `path` plucks from each element first. Deviates from lodash: an EMPTY array errors instead of yielding NaN.
JSON pointer plucked from each element before reducing (the lodash `…By` form).
Input value (a pipe lands the previous step's value here).
Find the smallest number in an array (lodash _.min/_.minBy); `path` plucks from each element first. Returns the NUMBER, not the element. An empty array errors.
JSON pointer plucked from each element before reducing (the lodash `…By` form).
Input value (a pipe lands the previous step's value here).
Return array element n (negative counts from the end, lodash _.nth). Out of bounds errors naming the length.
Index to pluck; negative counts from the end (`-1` = last element).
Input value (a pipe lands the previous step's value here).
Drop top-level keys from an object (lodash _.omit).
Top-level keys to drop; missing keys are ignored.
Input value (a pipe lands the previous step's value here).
Internal: reload fp settings from the authoritative configuration on change.
Configuration id that changed.
Subset an object by top-level keys (lodash _.pick); missing keys are omitted.
Top-level keys to keep; missing keys are silently omitted.
Input value (a pipe lands the previous step's value here).
Run a worker-side pipeline: each step triggers a function and its result lands in the next step's payload at `into` (default "/value"); fp::* steps thread the bare value and a failing fp::when stops the pipe. The FIRST step gets no threaded value. Returns per-step sizes and a preview, not the value.
Preview length of the final threaded value in the receipt (capped at 8000).
Steps run in order; step N+1 receives step N's threaded value.
Function id to trigger.
JSON pointer in this step's payload where the previous value lands (default `/value`); object keys only, no array indexing.
Base payload for the call.
True when a `fp::when` guard failed and stopped the pipe: the receipts end at the guard and NO later step ran. Absent (false) on a full run.
Size of the value threaded OUT of this step (chars of its string or serialized form).
Set when the threaded value REPLACED a non-null literal already in this step's payload at the `into` pointer — almost always an omitted `into` on a write step clobbering the value it meant to write.
Reverse an array (lodash _.reverse, immutable like lodash/fp).
Input value (a pipe lands the previous step's value here).
Count a collection (lodash _.size): array length, string chars, or object key count. Non-collections error instead of returning 0.
Input value (a pipe lands the previous step's value here).
Sort array elements ascending by the value at a JSON pointer (lodash _.sortBy, stable); path "" sorts the elements themselves. Keys must all be numbers, strings, or booleans. Pair with fp::reverse for descending.
JSON pointer plucked from each element as the sort key (e.g. `/score`).
Input value (a pipe lands the previous step's value here).
Split a string into an array of strings (lodash _.split).
Non-empty separator to split on (e.g. `"\n"`).
Input value (a pipe lands the previous step's value here).
Total an array of numbers (lodash _.sum/_.sumBy); `path` plucks the addend from each element first. An empty array totals 0; a non-numeric element errors rather than being skipped.
JSON pointer plucked from each element before reducing (the lodash `…By` form).
Input value (a pipe lands the previous step's value here).
Keep the first n elements of an array or the first n characters of a string (lodash _.take).
How many array elements / string characters to keep.
Input value (a pipe lands the previous step's value here).
Deduplicate an array, keeping first occurrences (lodash _.uniq).
Input value (a pipe lands the previous step's value here).
Guard: test the value at a JSON pointer (`path` defaults to the whole value; a pointer miss FAILS, never errors) and return { passed, value }. As a fp::pipe step a passing guard threads the ORIGINAL value onward and a failing one STOPS the pipe (`short_circuited: true`).
Comparison to run.
JSON pointer selecting what to test (default: the whole value).
Right-hand side for the comparison ops; rejected for exists / not_empty.
Input value (a pipe lands the previous step's value here).
The ORIGINAL input value, untouched — guards test, they never reshape.
