# Run Factory > Execute a deliverable factory end-to-end on one prospect signal, or a batch of them — intake, digest, parallel cited research lanes, weakness hunt, synthesis, adversarial citation audit, then fan out the winning artifacts (dashboard, bid, deck, demo, copy). Use when the user pastes a prospect signal (text, email, call note), says "run the factory", "new prospect", "bid package for X", "full pipeline on this lead", "portfolio run" or "run these N leads", "resume the run", or names a registered factory to execute. This is the flagship orchestration harness of signal-forge. - Skill: `manutej/run-factory` (Agent Skill, multi-file: 4 files) - Install (CLI): `npx skillmds@latest add manutej/run-factory` - Raw SKILL.md: https://api.skillmd.com/api/skills/manutej/run-factory/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: DevOps & Infra - Author: manutej (https://skillmd.com/u/manutej) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/manutej/run-factory --- # Run-factory — the execution harness This skill is a **stage machine**, not a narrative. It runs one factory over one signal (or a queue of signals) as a sequence of stages, each with a typed input, a typed output on disk, and a **blocking predicate** that must evaluate true before the next stage starts. The orchestrator holds little in context; every dossier and artifact lives on disk. A fresh session can resume any run from its ledger. This is what lets the factory run at scale for many clients at once. Default factory: the bid-package seed at `../forge/references/factory-bid-package-v0.3.md`. If the use case has its own factory in `FACTORY/factories/`, execute that one. If neither fits, invoke the `forge` skill first, then return here. **Binding law (restated because it is load-bearing here):** evidence is sourced-or-flagged and audited before shipment (`../forge/references/evidence-rules.md`); flow is one-directional research→SYNTHESIS→artifact; refined input regenerates artifacts and never hand-patches them; client-facing language is plain; every offer is a tells↔scope↔price bijection (`../forge/references/meta-meta-map.md`). Design law for every artifact: `../forge/references/design-rigor.md`. A stage that would violate one of these does not run — it blocks and escalates. ## The loop every stage runs **Frame** (state the stage's inputs + blocking predicate) → **Do** (execute, orchestrator or spawned agent) → **Review** (check the output against this stage's acceptance checklist) → **Capture** (write the output to its path, tick the RUN.md ledger, mint atoms where the stage produced reusable knowledge into `FACTORY/atoms.md`). No stage is "done" on vibes; done means its predicate is checked and its ledger line is ticked. ## State: typed slots the harness carries Input slots (filled at Stage 0 from the signal; `UNKNOWN` is legal, never invented) and derived slots (pipeline products, in order) are defined by the factory — see `../forge/references/factory-schema.md` §2–3. The harness additionally tracks per-run **run-state**: `SLUG` (yyyy-mm-slug), `STAGE` (current), `BLOCKERS` (open predicate failures), `LANES` (spawned/returned/failed), `AUDIT_STATUS` (pending/passed with adjustments applied). Run-state lives in `prospects//RUN.md`, never only in context. ## The stage machine Each stage's inputs, outputs, executor, and blocking predicate are specified in full in `references/orchestration-protocol.md` (the executable spec). Summary: | # | Stage | Output (on disk) | Executor | Blocking predicate to advance | |---|---|---|---|---| | 0 | Intake | `00-intake-digest.md` (slots + `## atoms consulted`) | orchestrator | Signal quoted verbatim; every slot assigned or `UNKNOWN`; every AMBIGUITY listed with readings; **`FACTORY/INDEX.md` queried** by `VERTICAL` + use-case/stage tags and an `## atoms consulted` block written to the digest (the block MUST exist; it is empty only when INDEX is empty or has no matching atoms) | | 1 | Digest | `00-intake-digest.md` (+5 angles, questions) | orchestrator | 5 angles written; research questions derived from them | | 2 | Research + hunt | `01-research/.md`, `tells-dossier.md` | parallel subagents | Every lane returned a dossier + ≤600-word summary, cited+dated; hunt returned ≥2 live wedges or explicit none | | 3 | Synthesis | `01-research/SYNTHESIS.md`, `UNKNOWNS.md`, `NEEDS.md` | orchestrator | Thesis + numbers table (each entry source-tagged/dated) + gates + cost floor + 3 pricing shapes above floor; unknowns triaged | | 3b | Citation audit | `01-research/CITATIONS.md` | **fresh auditor** | Every load-bearing claim has a verdict; all ADJUSTED/UNVERIFIED corrections regenerated into SYNTHESIS | | 4 | Design DNA | `design/tokens.css`, `design/palette.md` | `design-dna` skill | Tokens emitted; every FG/BG pair passes WCAG AA (or CETI fallback logged) | | 5 | Artifact fan-out | `02-dashboard/` … `07-copy/` | parallel artifact skills | Each artifact passes its acceptance checklist (`references/orchestration-protocol.md`) + design-rigor QA ladder | | 6 | DONE + learning | updated `FACTORY/atoms.md` | orchestrator | Factory DONE predicate true; ≥1 atom minted; report delivered | **The one rule that makes it a machine:** every blocking predicate is **checked, not assumed**. Read the output file, evaluate the predicate against it, tick RUN.md. If it fails, the stage stays open — you retry, escalate, or block. You never advance on the belief that a stage "probably passed." ## Parallelism (what fans out, what is strictly sequential) Stages 0→1→3→3b→4 are **sequential** — each consumes the prior's output. Stage 2 **fans out** (one subagent per research lane + the hunt sweep, all in a single message). Stage 5 **fans out** (artifacts are independent projections of SYNTHESIS, so they build concurrently). The dependency and the reason for each edge are in `references/orchestration-protocol.md` §parallelism. Do not parallelize across a sequential edge; do not serialize a fan-out. ## Refusal conditions (the machine stops rather than shipping bad work) - **Refuse Stage-5 artifact fan-out until Stage-3b has passed** and all ADJUSTED/UNVERIFIED corrections are regenerated into SYNTHESIS. No artifact is built on unaudited numbers. - **Refuse to advance any stage whose blocking predicate is unchecked or failing.** Log the blocker in RUN.md. - **Refuse to hand-patch a shipped artifact** after a slot fills or an ambiguity resolves — regenerate from the updated SYNTHESIS instead. - **Refuse to let a subagent synthesize across lanes**, or to let a lane researcher also serve as the Stage-3b auditor (researcher and auditor are never the same agent). - **Refuse to invent any client-facing fact.** Unknowns go to the ledger and up the auto-triage ladder before they reach a human. ## Resume protocol (statelessness across sessions) Any session, with no prior context, can pick up a run: 1. Read `prospects//RUN.md` — it names the current `STAGE`, open `BLOCKERS`, and per-lane status. 2. **Re-verify the last-ticked stage's blocking predicate against its output file** — do not trust the tick; confirm the file satisfies the predicate (a crashed session may have ticked before writing). If it fails, reopen that stage. 3. Continue from the first unsatisfied predicate. Never restart completed stages; never skip an unchecked one. The RUN.md format is specified in `references/orchestration-protocol.md` §ledger. ## Portfolio mode (many signals at once) When the user pastes several signals or says "portfolio run / run these N leads": each signal gets its own isolated `prospects//` run and its own RUN.md; a top-level `PORTFOLIO.md` tracks every run's stage, blocking item, and next action. Client data is strictly per-run; only vertical priors, template caches, and house tokens are shared. Research-heavy stages stagger to respect concurrency ceilings; artifact fan-out saturates. Full batch protocol, queue format, concurrency ceilings, and cross-run learning flush: `references/scale-playbook.md`. ## Refinement after shipment When the user supplies new information (a slot fills, an ambiguity resolves): update Stage 0, regenerate downstream from the updated SYNTHESIS, re-run Stage-3b on any changed load-bearing claim — **never hand-patch**. Log the refinement in the changelog block inside `00-intake-digest.md` and route qualified feedback through `mint-atoms` (which traces each correction to the factory line that allowed it — the feedback-to-line hook). ## DONE predicate A run is DONE when the factory's DONE predicate holds (`factory-schema.md` §7): all contracted files exist · gates identified · citations independently audited and corrections applied · three pricing shapes priced above a computed floor with contractually defined billable units · sign-here bijection holds across bid/deck/dashboard · unknowns triaged and residual questions listed for the human · the `## atoms consulted` block written at Stage-0 intake is present · ≥1 atom minted. RUN.md's every stage line is ticked. Then report: what shipped, the live wedges, open questions for the human, atoms minted. ## References - `references/orchestration-protocol.md` — the stage machine as executable spec: full stage table (inputs · outputs · predicate · executor), parallelism map with rationale, context-budget rules, failure/retry policy, and the RUN.md ledger format. - `references/subagent-prompts.md` — verbatim, typed-slot prompt templates for the research-lane subagent, the Stage-3b adversarial auditor, and the artifact-builder handoff packets. - `references/scale-playbook.md` — portfolio mode: queue file, per-run isolation, shared-asset policy, concurrency ceilings, PORTFOLIO.md ledger, cross-run learning flush, and per-run cost accounting. - Shared law: `../forge/references/evidence-rules.md` · `meta-meta-map.md` · `design-rigor.md` · `factory-schema.md` · `factory-bid-package-v0.3.md`.