Run any Skill in Manus with one click

run-factory

Stars0

Forks0

UpdatedJuly 13, 2026 at 08:11

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.

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Run Skill in Manus

Source

manutej

manutej/signal-forge

View GitHub Repository View Creator Repositories

Download

Run Skill in Manus

Related occupationsSOC

Based on SOC occupation classification

Market Research Analysts and Marketing SpecialistsBusiness and Financial Operations Occupations·SOC 13-1161

File Explorer

4 files

SKILL.md

readonly

More from this repository

same repository

account-copy

manutej/signal-forge

Emits reader-specific account copy — outreach sequences, follow-ups, one-pagers, case-study atoms, QBR narratives, renewal and expansion notes — by selecting a typed sequence blueprint and filling its slots only with facts the account already holds, so every piece reads like it was written for one named reader and never like mail-merge. Use when the user says "outreach for [prospect]", "follow-up email", "nurture sequence", "one-pager", "case study", "QBR narrative", "renewal note", "win-back", "expansion copy", or when a factory contract includes 07-copy. Runs one reader or batches a whole list with per-reader verification. Every claim cites SYNTHESIS or is cut; refuses unpersonalizable sends and "just checking in" revivals.

2026-07-130

bid-contract

manutej/signal-forge

Emits deal-specific bid paperwork from a typed clause system — proposal, contract skeleton, and internal pricing-floor math — by reading SYNTHESIS, computing a cost floor, selecting pricing shapes via a decision tree, and assembling plain-language clauses with bound slots. Use when the user says "write the bid", "proposal draft", "SOW", "contract for [prospect]", "pricing options", "redline their paper", or runs the 03-bid stage of a factory. Operates a level up from a document: a meta-prompt that generates paper, not a template. Never commits to volumes before proof; unknowns surface as flagged TBDs, never silent defaults; final terms always carry an attorney-review caveat.

2026-07-130

demo-forge

manutej/signal-forge

Builds the touchable sample that enacts the buyer's own workflow step — an interactive single-file prototype, a ceti-method animated explainer, or a live-channel (phone/chat) demo — so the buyer experiences the offer instead of reading about it, with buildable per-form artifact specs and a rehearsed 3-minute run-of-show. Use when the user says "demo for [prospect]", "build the sample", "prototype they can touch", "demo plan", "show don't tell", or as the 04-demo stage of a factory run. A demo the buyer can call or click beats any document; a generic vertical demo demonstrates nothing.

2026-07-130

design-dna

manutej/signal-forge

Extracts a prospect's real brand palette from their public materials, harmonizes it into a WCAG 2.2 AA-audited token set, and fuses it with CETI house rigor so every deliverable feels already theirs. Emits design/tokens.css (the versioned sf-tokens schema every artifact skill consumes) and design/palette.md (provenance + contrast matrix). Use when the user says "design DNA for [company]", "extract their colors", "brand the deliverables for this prospect", "tokens for this client", or automatically as the design stage of any factory run before artifacts are built. Refuses to ship invented colors or failing contrast pairs.

2026-07-130

forge

manutej/signal-forge

Forges a new reusable deliverable FACTORY — a versioned, example-agnostic meta-prompt that serves every future instance of a recurring sales, copywriting, or account-material category, one abstraction level above any single deal. Use when the user says "forge a factory", "/forge", "new factory for X", "we keep making X for clients", "turn this into a standing pipeline", or names a recurring deliverable category (QBR packs, launch copy, onboarding kits, audit reports, renewal decks, partnership pitches). Also use to EDIT an existing factory after feedback — version bumps, slot additions, rule changes — and to run the generalization check on any factory edit. This is the meta-meta skill: it does not produce client artifacts; it mints the machine that produces them.

2026-07-130

hunt

manutej/signal-forge

Hunts a prospect's provable weaknesses and buying tells from public sources and packages them as a typed, cited tells-dossier — the left half of the sign-here bijection (tells ↔ scope ↔ price) that makes the pitch feel painfully obvious. Use when the user says "hunt [company]", "find their tells", "weakness map", "recon this prospect", "why would they buy", "what are their gaps", "build the dossier", or before any bid, deck, demo, or outreach so positioning rests on demonstrated gaps instead of generic value props. Runs one prospect or fans out across many. Produces a cited dossier with severity/provability/monetizability scores, a live-demo wedge list, a quarantined-hypotheses section, and a NEEDS/UNKNOWNS handoff — never client-facing.

2026-07-130

name

run-factory

description

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/<slug>/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/<lane>.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:

Read prospects/<slug>/RUN.md — it names the current STAGE, open BLOCKERS, and per-lane status.
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.
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/<slug>/ 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.