Build me a workflow that loops over each project in my GitHub and
saves a summary of its open issues. After the loop is done, the
workflow runs self-improve on itself.

git clone https://github.com/DanMcInerney/orchflows
cd orchflows
./install.sh          # install.cmd on Windows

> fix the flaky login test
# orch-fix: reproduce it, prove the cause, guard the repair

> why did memory double last release?
# orch-investigate: one read-only lane, answer cited from primary evidence

> ship dark mode
# orch-spec → orch-deliver: frozen spec, tickets, parallel subagents
# on a rolling frontier, one review gate, final verification

> build me a custom workflow that reads all the documentation, then
  researches similar projects, then builds a spec doc to copy their
  best features and implements them
# orch-build: the chain is admitted as a project-local skill,
# callable by name from then on

> orch-loop orch-deliver until `pytest -q` exits 0
> orch-panel these three cache designs — blind judges, pick one
> orch-critique src/auth under the security lens

> build me a workflow that does spec > deliver, then always updates
  the documentation afterwards (favoring edits and deletions over
  additions), and automatically PRs and merges it

> my release workflow: orch-investigate what merged since the last
  tag → orch-deliver the release notes under the content pack →
  orch-self-improve

flowchart TD
    spec["orch-spec — freeze exactly what should be made"] --> pack{"pack: code | content | research | design"}
    pack --> ws["orch-workspace — clean, isolated working area"]
    ws --> dec["orch-decompose — cut the spec into ordered tickets"]
    dec --> frontier["orch-frontier — dispatch every ready ticket"]
    frontier --> task["orch-task"]
    task --> del["orch-delegate — hand the ticket to the right agent"]
    del --> exec["executor: orch-tdd | orch-draft / orch-edit | orch-investigate / orch-synthesize | orch-render"]
    exec -.-> chk["orch-check — fresh agent double-checks (when needed)"]
    exec --> integ["orch-integrate — accept or reject the returned work"]
    chk --> integ
    integ -.->|rejected| frontier
    integ --> ver1["orch-verify — run any remaining checks"]
    ver1 --> frontier
    frontier --> gate["orch-review-fix — critique, repair confirmed defects, re-verify"]
    gate --> final["orch-verify — final result matches the original request"]

orchflows
│
├── Layer 0 · contracts/ — Shared forms that keep every part of the system speaking the same language
│   ├── delegation     — Says what another agent should do, use, avoid, and return
│   ├── pack-signature — Lists what every project-type setup must provide
│   ├── spec           — Records exactly what the user wants made
│   ├── verdict        — Records whether a check passed and what proves it
│   ├── work-item      — Describes and tracks one piece of work
│   └── worklog        — Records the progress and current state of a larger job
│
├── Layer 1 · skills/ — Things the agents know how to do
│   │
│   ├── kernel/ — Basic building blocks used by the rest of the system
│   │   ├── orch-check          — Has a fresh agent double-check the work and correct problems
│   │   ├── orch-critique       — Reviews something and lists the most important problems
│   │   ├── orch-decompose      — Breaks a large job into smaller pieces in the right order
│   │   ├── orch-delegate       — Hands one clearly defined task to another agent
│   │   ├── orch-elicit         — Asks the user when a decision cannot safely be made for them
│   │   ├── orch-integrate      — Decides whether returned work is acceptable and can be used
│   │   ├── orch-investigate    — Researches one focused question using reliable evidence
│   │   ├── orch-judge          — Rates one option using standards agreed on beforehand
│   │   ├── orch-mechanize      — Turns a repeatedly performed step into a reusable script
│   │   ├── orch-synthesize     — Combines findings from several sources into one answer
│   │   ├── orch-verify         — Runs the agreed checks to see whether the work passes
│   │   ├── orch-worklog        — Updates the job's progress record
│   │   └── orch-workspace      — Prepares a clean and safe place in which to work
│   │
│   ├── engines/ — Reusable ways of organizing work
│   │   ├── orch-task      — Takes one ready piece of work from start to acceptance
│   │   ├── orch-frontier  — Starts each piece of work as soon as the work it needs is finished
│   │   ├── orch-loop      — Repeats work until an agreed check says it is done
│   │   └── orch-panel     — Uses several independent reviewers to compare choices fairly
│   │
│   ├── workflows/ — Complete processes made from the smaller building blocks
│   │   ├── orch-spec          — Turns a request into a clear, agreed plan
│   │   ├── orch-deliver       — Runs a project from the agreed plan to a checked final result
│   │   ├── orch-goal          — Runs the delivery process again to improve the result further
│   │   ├── orch-bench         — Sets the rules and tests before different options are compared
│   │   ├── orch-evolve        — Creates and compares improved versions over several rounds
│   │   ├── orch-diagnose      — Reproduces a problem and finds what is actually causing it
│   │   ├── orch-fix           — Finds the cause of a problem, repairs it, and proves it stays fixed
│   │   ├── orch-repair        — Applies the smallest change that fixes a known problem
│   │   ├── orch-review-fix    — Reviews the result once, fixes valid problems, and checks it again
│   │   ├── orch-build         — Creates or changes a reusable part of the orchflows library
│   │   ├── orch-fixture       — Saves a finished task as an example that can be run again later
│   │   ├── orch-self-improve  — Studies past difficulties and proposes improvements to the system
│   │   └── orch-triage        — Sorts a list of work into what is ready, blocked, or needs a person
│   │
│   ├── instances/ — Skills that perform a particular kind of hands-on work
│   │   ├── orch-tdd               — Writes software in small steps and checks each step with tests
│   │   ├── orch-resolve-conflicts — Decides how to combine two sets of changes that clash
│   │   ├── orch-draft             — Writes one section using only the supplied information
│   │   ├── orch-edit              — Combines separate sections into one consistent document
│   │   └── orch-render            — Builds a screen and checks how it actually looks and behaves
│   │
│   └── utilities/ — Small optional helpers
│       ├── orch-visualize — Turns supplied information into a diagram
│       └── orch-off       — Stops orchflows from automatically choosing skills
│
├── Layer 2 · packs/ — Setups for different kinds of projects
│   ├── orch-code-pack     — Tells the system how to organize, save, and check software work
│   ├── orch-content-pack  — Tells the system how to organize and review written documents
│   ├── orch-research-pack — Tells the system how to answer questions using trustworthy sources
│   └── orch-design-pack   — Tells the system how to build and visually check interfaces
│
└── Layer 3 · compositions/ — Example playbooks showing how the parts can be combined
    ├── delivery-loop        — Repeats delivery until a chosen measurement says to stop
    ├── drift-canary         — Reruns known examples to detect changes in agent behavior
    ├── evidence-to-document — Researches a subject first, then turns the findings into a document
    ├── evolve               — Produces several versions and selects the strongest one
    ├── feature-plus-docs    — Builds a software feature and then documents what was built
    ├── improvement-delivery — Turns an approved process improvement into a tested change
    ├── renovate             — Reviews an existing project and completes selected improvements
    └── skill-tournament     — Tests competing versions of a skill to see which works best

UNITS OF WORK — the orchflows ladder
│
├── (floor) Tested script
│     no model, no ticket — a unit of certainty, not of work
│     orch-mechanize keeps pushing repetition down here
│
├── U0 — Direct answer
│     question answered from context already in hand
│     no deliverable change → no record, no ticket
│
├── U1 — Verified ad-hoc ticket
│     one ticket + one execution + one external verdict
│     U1×N: a small ticket graph with edges, run on the frontier
│
├── U2 — The run (spec → delivery)
│     a frozen spec governs a ticket graph → rolling frontier →
│     one review gate → final verification
│
└── U3 — Composition
      control flow OVER units: chained runs, goal loops

packs/
├── orch-code-pack     — delivers code        · deterministic oracles · executor orch-tdd
│                        workspace: git, one worktree per work item
├── orch-content-pack  — delivers documents   · judged oracles        · executor orch-draft, assembly orch-edit
│                        workspace: document tree with outline slots
├── orch-design-pack   — delivers rendered UI · capture oracles       · executor orch-render
│                        workspace: git plus render (view × breakpoint × state)
└── orch-research-pack — delivers answers     · evidence oracles      · executor orch-investigate, assembly orch-synthesize
                         workspace: evidence store of lane packets