@diottodev/runic 1.0.0 → 1.1.0

package/engineering/universal-scraping-architect/scripts/validate_extraction.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""
+validate_extraction.py
+Intelligent stdlib-only validation for JSON structures.
+"""
+import argparse
+import json
+import sys
+import os
+
+
+def validate_json(file_path):
+    if not os.path.exists(file_path):
+        return {"status": "error", "message": f"File {file_path} not found."}
+
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            # Basic validation: ensure it's not empty and is a list/dict
+            if not data:
+                return {"status": "warning", "message": "JSON file is empty."}
+            return {"status": "ok", "message": "JSON is valid and well-formed."}
+    except json.JSONDecodeError as e:
+        return {"status": "error", "message": f"Invalid JSON: {str(e)}"}
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Standard Library JSON Validator")
+    parser.add_argument("file", help="Path to JSON file to validate")
+    parser.add_argument("--json", action="store_true", help="Output results in JSON format")
+
+    args = parser.parse_args()
+    result = validate_json(args.file)
+
+    if args.json:
+        print(json.dumps(result, indent=2))
+    else:
+        print(f"[{result['status'].upper()}] {result['message']}")
+
+    sys.exit(0 if result['status'] == "ok" else 1)
+
+
+if __name__ == "__main__":
+    main()

package/engineering/workflow-builder/.claude-plugin/plugin.json

@@ -0,0 +1,18 @@
+{
+  "name": "workflow-builder",
+  "description": "Workflow-builder skill: design and write deterministic multi-agent workflow scripts (.js files in .claude/workflows/) for Claude Code's Workflow tool (CLAUDE_CODE_WORKFLOWS=1, /workflows). Every session opens with an intake question set; when the user is vague, a stdlib recommendation engine infers and proposes a topology with rationale instead of stalling. Ships 3 stdlib Python tools (intake recommendation engine, .js validator enforcing the pure-literal-meta / no-non-determinism / guarded-loop / parallel-thunk rules, topology scaffolder), 3 references citing 7-8 authoritative sources each (full API surface, orchestration patterns, decision + intake guide), templates + a runnable example, cs-workflow-architect persona agent + /cs:workflow-build slash command. Use when building, scaffolding, or running a custom Claude Code workflow or orchestrating sub-agents (fan-out, pipeline, loop, judge-panel).",
+  "version": "1.0.0",
+  "author": {
+    "name": "Alireza Rezvani",
+    "url": "https://alirezarezvani.com"
+  },
+  "homepage": "https://github.com/alirezarezvani/claude-skills/tree/main/engineering/workflow-builder",
+  "repository": "https://github.com/alirezarezvani/claude-skills",
+  "license": "MIT",
+  "skills": ["./skills/workflow-builder"],
+  "attribution": {
+    "inspired_by": "https://github.com/ray-amjad/claude-code-workflow-creator",
+    "original_author": "Ray Amjad",
+    "derivation_note": "Original content written for this repo from Claude Code's publicly-documented Workflow tool API. Ray Amjad's claude-code-workflow-creator (no LICENSE file at time of authoring) is credited as the conceptual inspiration for the workflow-authoring skill pattern; no text was copied verbatim."
+  }
+}

package/engineering/workflow-builder/README.md

@@ -0,0 +1,55 @@
+# workflow-builder
+
+Design and write deterministic multi-agent **workflow** scripts for Claude Code's Workflow tool — `.js` files in `.claude/workflows/` that fan work out to fresh-context sub-agents under plain JavaScript control flow. Only leaf `agent()` calls spend tokens, so the main session stays clean and the run is resumable.
+
+Targets the Workflow tool introduced in Claude Code v2.1.147 (gated behind `CLAUDE_CODE_WORKFLOWS=1`, browsable via `/workflows`).
+
+## The intake-first rule
+
+Every workflow-creation session opens with an intake question set (what task, what unit of work, known list vs. loop, barrier vs. pipeline, structured output, depth). **When the user is vague, the skill does not stall or interrogate in a loop** — it runs a deterministic recommendation engine that infers a topology and presents it *with the reasoning* ("here's what I'd build and why"), then confirms before writing any file.
+
+## What's in the box
+
+| Component | Where | What it does |
+|---|---|---|
+| **Intake recommendation engine** | `skills/workflow-builder/scripts/workflow_intake.py` | Classifies a (vague) task → recommended topology + runner-up + per-stage model plan + budget guard + a one-line rationale per choice. |
+| **Workflow validator** | `skills/workflow-builder/scripts/validate_workflow.py` | Stdlib linter for `.js` workflows: pure-literal `meta`, no `Date.now()`/`Math.random()`/argless `new Date()`, no FS/Node APIs in the orchestrator, `parallel()` thunks, guarded loops, `filter(Boolean)`, size cap. PASS / WARN / FAIL with line numbers. |
+| **Scaffolder** | `skills/workflow-builder/scripts/scaffold_workflow.py` | Emits a runnable starter for any of 5 topologies (fan-out, pipeline, barrier, loop, judge-panel). |
+| **3 references** | `skills/workflow-builder/references/` | API reference · orchestration patterns · decision + intake guide (7-8 sources each). |
+| **Templates + example** | `skills/workflow-builder/assets/` | Fan-out / pipeline / loop starters + a complete PR-triage workflow. |
+| **Persona agent** | `agents/cs-workflow-architect.md` | Design-first interrogator that refuses to write before the topology is confirmed. |
+| **Slash command** | `commands/cs-workflow-build.md` | `/cs:workflow-build <task>` — runs the full intake → scaffold → validate flow. |
+
+## Quick start
+
+```bash
+cd skills/workflow-builder
+
+# 1. Turn a vague request into a concrete proposal
+python scripts/workflow_intake.py --task "review my open PRs for bugs"
+
+# 2. Scaffold the confirmed topology
+python scripts/scaffold_workflow.py --topology pipeline --name pr-triage \
+  --description "Triage open PRs" > /tmp/pr-triage.js
+
+# 3. Validate before running
+python scripts/validate_workflow.py /tmp/pr-triage.js
+```
+
+All three tools run with `--sample` (no args) and `--help`.
+
+## Running the workflows it writes
+
+```bash
+export CLAUDE_CODE_WORKFLOWS=1          # the feature is off by default
+# save the .js under .claude/workflows/ , then launch + watch via /workflows
+# P = pause/resume , X = skip a sub-agent ; failed agents retry automatically
+```
+
+## Attribution
+
+Conceptually inspired by [Ray Amjad's claude-code-workflow-creator](https://github.com/ray-amjad/claude-code-workflow-creator). All content here was written for this repo against Claude Code's publicly-documented Workflow tool API; no text was copied verbatim.
+
+## License
+
+MIT.

package/engineering/workflow-builder/agents/cs-workflow-architect.md

@@ -0,0 +1,96 @@
+---
+name: cs-workflow-architect
+description: Workflow-architect persona. Opens every workflow-creation session with the intake question set, infers-and-proposes when the user is vague (never interrogates in a loop), and refuses to write a workflow file before the topology is confirmed. Enforces the hard rules (pure-literal meta, no non-determinism, guarded loops, parallel thunks) via the validator before any run.
+skills: engineering/workflow-builder/skills/workflow-builder
+domain: engineering
+model: opus
+tools: [Read, Write, Bash, Grep, Glob]
+---
+
+# Workflow Architect Agent
+
+## Voice
+
+**Opening:** "Before any code — what repeatable, multi-step task do you want to automate, and what's the one unit of work a single sub-agent does once?"
+**When the user is vague:** "You were light on detail, so here's the topology I'd build and why — tell me what to change." (Never re-ask questions they already half-answered.)
+**Closing:** "Confirmed the shape? I'll scaffold it, validate it, and hand you the file for `.claude/workflows/`."
+
+Direct, decisive, design-first. Treats topology as a pre-code decision. Trusts the validator over judgement for the mechanical rules. Refuses to write a workflow when a single agent or a skill would do.
+
+## Purpose
+
+Orchestrates the `workflow-builder` skill across the three workflow-authoring decisions:
+
+1. **Intake** — ask what kind of workflow; map answers to a topology (fan-out / pipeline / barrier / loop / judge-panel).
+2. **Recommend** — when input is vague, run the intake engine to produce concrete proposals *with rationale*, then confirm the shape.
+3. **Build → validate → run** — scaffold the starter, lint it, and hand it off for `/workflows`.
+
+Differentiates clearly:
+
+- **vs `write-a-skill`** — that authors reusable *skills*; this authors deterministic *workflow* `.js` files.
+- **vs the plain Agent tool** — a single task needs an agent, not a workflow. Say so when intake reveals one unit, one task.
+- **vs a Skill** — a procedure where Claude picks steps dynamically should be a skill, not a fixed-topology workflow.
+
+**Hard rule:** never write a workflow file before the topology is confirmed, and never call a workflow "ready" until `validate_workflow.py` returns PASS or a documented WARN.
+
+## Skill Integration
+
+**Skill Location:** `../skills/workflow-builder/`
+
+### Python Tools (Stdlib)
+
+1. **Workflow Intake Engine** — `../skills/workflow-builder/scripts/workflow_intake.py`
+   - `python workflow_intake.py --task "..." [--units --stages --needs-all --structured]`
+   - Returns recommended topology + runner-up + per-stage model plan + budget guard + rationale.
+2. **Workflow Validator** — `../skills/workflow-builder/scripts/validate_workflow.py`
+   - `python validate_workflow.py path/to/workflow.js`
+   - PASS / WARN / FAIL with line numbers; enforces meta/non-determinism/Node-API/thunk/loop rules.
+3. **Workflow Scaffolder** — `../skills/workflow-builder/scripts/scaffold_workflow.py`
+   - `python scaffold_workflow.py --topology pipeline --name X --description "..."`
+   - Emits a runnable starter for the chosen topology.
+
+### Knowledge Bases
+
+- `../skills/workflow-builder/references/decision_and_intake_guide.md` — the question framework + vague-input playbook + worked examples.
+- `../skills/workflow-builder/references/api_reference.md` — full API surface (globals, options, caps, sandbox rules).
+- `../skills/workflow-builder/references/orchestration_patterns.md` — copy-paste topology shapes.
+
+## Workflow
+
+```bash
+# 1. Intake (always first). If the user is vague, infer and propose:
+python ../skills/workflow-builder/scripts/workflow_intake.py --task "their request"
+
+# 2. Confirm the topology + phases with the user. (Only approval gate.)
+
+# 3. Scaffold the confirmed topology:
+python ../skills/workflow-builder/scripts/scaffold_workflow.py \
+  --topology <fan-out|pipeline|barrier|loop|judge-panel> --name <name> --description "..." \
+  > .claude/workflows/<name>.js
+
+# 4. Edit agent prompts, then validate before running:
+python ../skills/workflow-builder/scripts/validate_workflow.py .claude/workflows/<name>.js
+
+# 5. Enable + run: export CLAUDE_CODE_WORKFLOWS=1 ; launch via /workflows (P=pause, X=skip).
+```
+
+## Output Standards
+
+```
+**Bottom Line:** [one sentence — recommended topology + whether a workflow is even the right tool]
+**The Decision:** [intake | recommend | scaffold | validate | run]
+**The Evidence:** [intake-engine rationale + validator verdict with line numbers]
+**How to Act:** [3 concrete next steps]
+**Your Decision:** [the call only the user can make — confirm topology, set budget, name the workflow]
+```
+
+## Related
+
+- Skill: [`workflow-builder`](../skills/workflow-builder/SKILL.md)
+- Command: [`/cs:workflow-build`](../commands/cs-workflow-build.md)
+- Adjacent: `../../write-a-skill/` (authoring skills, not workflows), `../../grill-me/` (forcing-question discipline)
+
+---
+
+**Version:** 1.0.0
+**Status:** Production Ready

package/engineering/workflow-builder/commands/cs-workflow-build.md

@@ -0,0 +1,95 @@
+---
+name: "cs-workflow-build"
+description: "/cs:workflow-build <task-description> — Design and write a deterministic Claude Code workflow (.js). Opens with intake questions, infers-and-proposes a topology when the request is vague, then scaffolds + validates the file. Use when building or running a custom Claude Code workflow."
+---
+
+# /cs:workflow-build — Workflow Architect Intake
+
+**Command:** `/cs:workflow-build <task-description>`
+
+Designs a deterministic multi-agent workflow for Claude Code's Workflow tool. Always opens with intake; never writes a file before the topology is confirmed.
+
+## When to Run
+
+- Building a new `.claude/workflows/*.js` file
+- Automating a repeatable, multi-step task across fresh-context sub-agents
+- Deciding whether a task even warrants a workflow (vs. a single agent or a skill)
+
+## Step 1 — Intake (always first)
+
+Ask the opening question set. Lead with #1.
+
+1. What repeatable, multi-step task do you want to automate?
+2. What is the one unit of work a single sub-agent does once?
+3. How many units — a known list, or discovered by looping?
+4. Do later steps need *all* prior results at once, or can each item flow on its own?
+5. Does any step need structured data back (a verdict, a list, scores)?
+6. Roughly how deep / how many tokens?
+
+## Step 2 — If the user is vague, infer and propose (don't loop on questions)
+
+```bash
+python ../skills/workflow-builder/scripts/workflow_intake.py --task "<their request>" \
+  --units unknown --stages unknown --needs-all unknown --structured unknown
+```
+
+Present the result as "here's what I'd build and why": recommended topology (+ runner-up), per-stage model picks, a budget guard, and the rationale for each choice. Then ask only "what should I change?"
+
+## Step 3 — Confirm the shape, then scaffold
+
+```bash
+python ../skills/workflow-builder/scripts/scaffold_workflow.py \
+  --topology <fan-out|pipeline|barrier|loop|judge-panel> --name <name> --description "..." \
+  > .claude/workflows/<name>.js
+```
+
+## Step 4 — Validate before running
+
+```bash
+python ../skills/workflow-builder/scripts/validate_workflow.py .claude/workflows/<name>.js
+```
+
+Fix every FAIL. WARNs need a one-line justification.
+
+## Step 5 — Run
+
+```bash
+export CLAUDE_CODE_WORKFLOWS=1   # the feature is off by default
+# Save under .claude/workflows/, then launch + monitor via /workflows.
+# P = pause/resume, X = skip a sub-agent. Failed agents retry automatically.
+```
+
+## The Hard Rules (validator enforces)
+
+1. `meta` is a pure literal and the first statement — no variables, spreads, template strings, or calls.
+2. No `Date.now()`, `Math.random()`, or argless `new Date()` — they break resume.
+3. No filesystem / Node APIs in the orchestrator — that work goes inside `agent()`.
+4. `parallel()` takes thunks (`() => agent(...)`); default to `pipeline()` unless a stage needs the whole prior set.
+5. Guard every open-ended loop with a counter or `budget.remaining()`.
+6. `results.filter(Boolean)` before using parallel/pipeline output.
+
+## Output Format
+
+```markdown
+# Workflow Build: <name>
+## The Decision
+[intake | recommend | scaffold | validate | run]
+## Recommended Topology
+[fan-out | pipeline | barrier | loop | judge-panel] — why
+## Model Plan
+[per-stage model + reason]
+## Validator Verdict
+🟢 PASS | 🟡 WARN (justified) | 🔴 FAIL (with line numbers)
+## Next Steps
+[3 concrete actions]
+```
+
+## Related
+
+- Agent: [`cs-workflow-architect`](../agents/cs-workflow-architect.md)
+- Skill: [`workflow-builder`](../skills/workflow-builder/SKILL.md)
+- Adjacent: `/cs:write-a-skill` (authoring skills, not workflows)
+
+---
+
+**Version:** 1.0.0

package/engineering/workflow-builder/skills/workflow-builder/README.md

@@ -0,0 +1,33 @@
+# workflow-builder (skill)
+
+Intake-first authoring of deterministic multi-agent **workflow `.js` files** for Claude Code's Workflow tool (`CLAUDE_CODE_WORKFLOWS=1`, `/workflows`). See the plugin root [README](../../README.md) for the full overview and attribution.
+
+## Tools (`scripts/`)
+
+| Tool | Purpose |
+|---|---|
+| `workflow_intake.py` | Classify a (vague) task → recommended topology + runner-up + per-stage model plan + budget guard + rationale. |
+| `validate_workflow.py` | Lint a workflow `.js`: pure-literal `meta`, no non-determinism, no Node/FS APIs, `parallel()` thunks, guarded loops, `filter(Boolean)`, size cap. PASS / WARN / FAIL with line numbers. |
+| `scaffold_workflow.py` | Emit a runnable starter for any of 5 topologies (fan-out, pipeline, barrier, loop, judge-panel). |
+
+All three run with `--sample` (no args) and `--help`.
+
+## Quick start
+
+```bash
+python scripts/workflow_intake.py --task "review my open PRs for bugs"
+python scripts/scaffold_workflow.py --topology pipeline --name pr-triage \
+  --description "Triage open PRs" > /tmp/pr-triage.js
+python scripts/validate_workflow.py /tmp/pr-triage.js
+```
+
+## Layout
+
+- `references/` — API surface, orchestration patterns, decision + intake guide.
+- `assets/templates/` — fan-out / pipeline / loop-until-budget starters.
+- `assets/examples/` — a complete PR-triage workflow.
+- `expected_outputs/` — captured deterministic tool outputs used as regression fixtures.
+
+## License
+
+MIT.

package/engineering/workflow-builder/skills/workflow-builder/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: workflow-builder
+description: Design and write deterministic multi-agent workflow scripts (.js files in .claude/workflows/) for Claude Code's Workflow tool. Use when a user wants to build, create, author, scaffold, or run a custom Claude Code workflow, orchestrate sub-agents (fan-out, pipeline, loop, judge-panel), or automate a repeatable multi-step task across fresh-context agents.
+license: MIT
+metadata:
+  inspired_by: "https://github.com/ray-amjad/claude-code-workflow-creator (Ray Amjad)"
+  targets: "Claude Code Workflow tool (CLAUDE_CODE_WORKFLOWS=1, /workflows)"
+  version: 1.0.0
+---
+
+# Workflow Builder
+
+Author runnable workflow scripts for Claude Code's Workflow tool: deterministic multi-agent orchestration files (`.js`) that fan work out to fresh-context sub-agents under plain JavaScript control flow. Only leaf `agent()` calls spend tokens, so the main session stays clean and the whole run is resumable.
+
+## ALWAYS start every session with intake (non-negotiable)
+
+Before proposing or writing any workflow, run the intake. Do not skip to code.
+
+1. **Ask what kind of workflow they want.** Use this opening question set:
+   - What repeatable, multi-step task do you want to automate?
+   - What is the one unit of work a single sub-agent does once?
+   - How many units — a known list, or discovered by looping?
+   - Do later steps need *all* prior results at once, or can each item flow on its own?
+   - Does any step need structured data back (a verdict, a list, scores)?
+   - Roughly how many tokens / how deep should it go?
+
+2. **If the user is vague, do NOT stall.** Run the recommendation engine to turn whatever you have into 1-2 concrete proposals, then present them *with the reasoning*:
+   ```bash
+   python scripts/workflow_intake.py --task "their description" \
+     --units unknown --stages unknown --needs-all unknown --structured unknown
+   ```
+   The engine returns a recommended topology (fan-out / pipeline / loop / barrier / judge-panel), model picks, a budget guard, and a one-line rationale per choice. Present those as "Here's what I'd build and why" — never ask the user to re-answer questions they already half-answered.
+
+3. **Confirm the shape with the user** (topology + phases + parallel-vs-pipeline) before writing the file. This is the only approval gate.
+
+See [references/decision_and_intake_guide.md](references/decision_and_intake_guide.md) for the full question framework, the vague-input playbook, and worked recommendation examples.
+
+## Decide if a workflow is even the right tool
+
+| Scenario | Use |
+|----------|-----|
+| Single sub-agent, one task | plain Agent tool |
+| Reusable procedure, Claude picks steps dynamically | a Skill |
+| Many sub-agents in a fixed topology, deterministic + resumable | **Workflow** ✓ |
+
+Workflows earn their cost when work is parallel or multi-stage, must be reproducible, long enough to fail halfway (so resume matters), or benefits from isolating each step in its own context window. For one-off tasks, just use Claude directly.
+
+## Build → validate → run loop
+
+1. **Scaffold** a starter from the confirmed topology:
+   ```bash
+   python scripts/scaffold_workflow.py --topology pipeline --name pr-triage \
+     --description "Triage open PRs" > .claude/workflows/pr-triage.js
+   ```
+2. **Edit** the file: `meta` block first (pure literal, first statement), then the async body using the injected globals — `agent()`, `pipeline()`, `parallel()`, `phase()`, `log()`, `budget`, `args`, `workflow()`. Full surface in [references/api_reference.md](references/api_reference.md); copy-paste shapes in [references/orchestration_patterns.md](references/orchestration_patterns.md).
+3. **Validate** before running — catches the parser-fatal mistakes:
+   ```bash
+   python scripts/validate_workflow.py .claude/workflows/pr-triage.js
+   ```
+4. **Run** it: enable the feature with `export CLAUDE_CODE_WORKFLOWS=1`, save the file under `.claude/workflows/`, then use `/workflows` to launch and watch it live. Press **P** to pause/resume, **X** to skip a sub-agent. Failed agents retry automatically.
+
+## Hard rules (validator enforces these)
+
+- `meta` is a **pure literal** and the **first statement** — no variables, spreads, template strings, or function calls inside it.
+- **No non-determinism:** `Date.now()`, `Math.random()`, argless `new Date()` break resume — pass timestamps via `args`.
+- **No filesystem / Node APIs** (`require`, `fs`, `process`, network) in the orchestrator — that work belongs *inside* `agent()` prompts.
+- `parallel()` takes **thunks** (`() => agent(...)`), not bare promises. Default to `pipeline()` unless a stage needs the whole prior result set.
+- **Guard every open-ended loop** with a counter or `budget.remaining()` check — unguarded loops hit the 1000-agent cap.
+- Filter skipped/failed agents: `results.filter(Boolean)`.
+
+## Tooling
+
+- `scripts/workflow_intake.py` — intake recommendation engine (topology + model + budget + rationale from vague input).
+- `scripts/validate_workflow.py` — stdlib linter for the rules above; PASS / WARN / FAIL with line numbers.
+- `scripts/scaffold_workflow.py` — generate a starter `.js` for any topology.
+- `assets/templates/` — fan-out, pipeline, loop-until-budget starters. `assets/examples/` — a complete runnable workflow.
+
+All scripts run with `--sample` (no args) and `--help`.

package/engineering/workflow-builder/skills/workflow-builder/assets/examples/pr-triage.js

@@ -0,0 +1,98 @@
+// Example workflow: triage open PRs for bugs before merge.
+//
+// Shape: fan-out (one reviewer per PR) -> skeptic-vote (verify each high-severity
+// finding so a false positive doesn't waste review time) -> synthesize one report.
+//
+// Run: enable CLAUDE_CODE_WORKFLOWS=1, save under .claude/workflows/, launch via /workflows.
+// Pass PR identifiers in via args, e.g. Workflow({ scriptPath, args: { prs: ['#12', '#15'] } }).
+
+export const meta = {
+  name: 'pr-triage',
+  description: 'Triage open PRs for bugs before merge, with adversarial verification of high-severity findings',
+  whenToUse: 'Run before a merge window to surface and confirm likely bugs across open PRs',
+  phases: [
+    { title: 'Review', detail: 'One reviewer agent per PR', model: 'haiku' },
+    { title: 'Verify', detail: 'Skeptic vote on high-severity findings', model: 'sonnet' },
+    { title: 'Report', detail: 'Synthesize a single triage report', model: 'opus' }
+  ]
+}
+
+const FINDINGS_SCHEMA = {
+  type: 'object',
+  properties: {
+    pr: { type: 'string' },
+    findings: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          severity: { type: 'string', enum: ['low', 'medium', 'high'] },
+          file: { type: 'string' }
+        },
+        required: ['title', 'severity']
+      }
+    }
+  },
+  required: ['pr', 'findings']
+}
+
+const VERDICT_SCHEMA = {
+  type: 'object',
+  properties: { refuted: { type: 'boolean' }, reason: { type: 'string' } },
+  required: ['refuted']
+}
+
+// args.prs is the list of PR identifiers to triage; gathering their diffs happens
+// inside each reviewer agent (the orchestrator has no filesystem/network access).
+const PRS = args?.prs ?? ['#101', '#102', '#103']
+
+// Phase 1 — fan out one reviewer per PR. Cheap model, structured output.
+phase('Review')
+const reviews = await parallel(
+  PRS.map((pr, i) => () =>
+    agent(
+      `Review PR ${pr} for likely bugs. Inspect the diff and report concrete findings.`,
+      { label: `review:${pr}`, phase: 'Review', model: 'haiku', schema: FINDINGS_SCHEMA }
+    )
+  )
+)
+
+// Collect every high-severity finding across all PRs.
+const highSeverity = reviews
+  .filter(Boolean)
+  .flatMap(r => (r.findings ?? []).map(f => ({ ...f, pr: r.pr })))
+  .filter(f => f.severity === 'high')
+
+log(`Reviewed ${reviews.filter(Boolean).length} PRs; ${highSeverity.length} high-severity findings to verify.`)
+
+// Phase 2 — skeptic vote: three independent agents try to refute each high finding.
+// A finding survives only if it is NOT refuted by a majority.
+phase('Verify')
+const confirmed = []
+for (let i = 0; i < highSeverity.length; i++) {
+  const f = highSeverity[i]
+  const votes = await parallel(
+    Array.from({ length: 3 }, (_, k) => () =>
+      agent(
+        `Try hard to REFUTE this bug claim about PR ${f.pr}: "${f.title}" in ${f.file ?? 'unknown file'}. ` +
+        `Return { refuted: boolean, reason }.`,
+        { label: `skeptic:${i + 1}.${k + 1}`, phase: 'Verify', model: 'sonnet', schema: VERDICT_SCHEMA }
+      )
+    )
+  )
+  const survives = votes.filter(v => v && !v.refuted).length >= 2
+  if (survives) confirmed.push(f)
+}
+
+log(`Verified findings: ${confirmed.length} of ${highSeverity.length} survived the skeptic vote.`)
+
+// Phase 3 — synthesize one report from the confirmed findings.
+phase('Report')
+const report = await agent(
+  `Write a concise PR-triage report. Group by PR. Only include these confirmed high-severity findings:\n` +
+  JSON.stringify(confirmed, null, 2),
+  { model: 'opus' }
+)
+
+return { report, confirmed, reviewed: reviews.filter(Boolean).length }

package/engineering/workflow-builder/skills/workflow-builder/assets/templates/fan-out.js

@@ -0,0 +1,48 @@
+export const meta = {
+  name: 'fan-out-research',
+  description: 'Fan out independent units, then synthesize',
+  phases: [
+    { title: 'Fan out' },
+    { title: 'Synthesize' }
+  ]
+}
+
+
+const FINDINGS_SCHEMA = {
+  type: 'object',
+  properties: {
+    findings: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          severity: { type: 'string', enum: ['low', 'medium', 'high'] }
+        },
+        required: ['title']
+      }
+    }
+  },
+  required: ['findings']
+}
+
+
+// Fan-out: independent units in parallel, then one synthesis.
+const ITEMS = args?.items ?? ['item one', 'item two', 'item three']
+
+phase('Fan out')
+const results = await parallel(
+  ITEMS.map((item, i) => () =>
+    agent(`Do the unit of work for:\n${item}`,
+          { label: `unit:${i + 1}`, model: 'haiku', schema: FINDINGS_SCHEMA }))
+)
+
+phase('Synthesize')
+const clean = results.filter(Boolean)
+const report = await agent(
+  `Synthesize these results into one report:\n${JSON.stringify(clean)}`,
+  { model: 'opus' }
+)
+log(`Done: synthesized ${clean.length} results.`)
+return report
+

package/engineering/workflow-builder/skills/workflow-builder/assets/templates/loop-until-budget.js

@@ -0,0 +1,52 @@
+export const meta = {
+  name: 'loop-until-budget',
+  description: 'Discover items under a budget guard',
+  phases: [
+    { title: 'Discover' }
+  ]
+}
+
+
+const FINDINGS_SCHEMA = {
+  type: 'object',
+  properties: {
+    findings: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          severity: { type: 'string', enum: ['low', 'medium', 'high'] }
+        },
+        required: ['title']
+      }
+    }
+  },
+  required: ['findings']
+}
+
+
+// Loop: discover an unknown number of items. GUARDED against the agent cap.
+const found = []
+const seen = new Set()
+let dryRounds = 0
+const HARD_CAP = 100
+
+phase('Discover')
+while (
+  dryRounds < 2 &&
+  found.length < HARD_CAP &&
+  (!budget.total || budget.remaining() > 50_000)
+) {
+  const r = await agent(
+    `Find items NOT already found:\n${JSON.stringify([...seen])}`,
+    { model: 'sonnet', schema: FINDINGS_SCHEMA }
+  )
+  const fresh = (r?.findings ?? []).filter(f => !seen.has(f.title))
+  fresh.forEach(f => seen.add(f.title))
+  found.push(...fresh)
+  dryRounds = fresh.length === 0 ? dryRounds + 1 : 0
+  log(`Round complete: ${fresh.length} new, ${found.length} total.`)
+}
+return found
+