The sequence, and the loops around it

How it actually flows

The stages below are the machinery, and they do run in order. What they are not is the shape of the thing: an opportunity is framed by the front end, argued over by seven chairs who each know something the others do not, and changed in shape when a statement it rested on turns out to be false. These are the arrows a stage table cannot draw — the front-end loop that wraps all of it, and every place the contracts send a candidate backward before a human ever sees it.

The route map

Every path a candidate can take, forwards and backwards. Read the solid lines first for the sequence; the dashed amber lines are where it doubles back, and they are the interesting half — four of them fire before a human ever sees the candidate, and every one is defined in a department contract rather than invented for this page.

steernoyesyesno — stage: verifyingunder 6/9 →queued-researchdrafted claims go backto Verifya kill floor firessurvivesrevive condition fires —Stage 0 watches for itrejectedapprovedthe flywheel — what towatch for, and what totry nextStage 0 · Scoutsignals, recalls, codes,policyStage 0.5 · Seed Scoutmacro-trend seedsStage 1 · Generatorcandidate file, all claimsunverifiedStage 2 · Scorerdraft score, triage onlyGate A — worth aVerifier pass?Parkeda named skip, not a silentoneStage 3 · Verifierfresh context, typedconnectorsStage 4 · Scorerverified composite6 of 9 factors verified?Stage 5 · Gate checkkill floors, verified dataonly45 · Researchdossier, drafted claimsKilledlogged with a reviveconditionStage 5.5 · Wrapeight wrap criteriaStage 6 · HumanshortlistTier 3 — a person, never anagentStage 7 · Diligencebench evidence, FTO memo,draftsStage 8 · Outcome loggedcalibration log
Drag the diagram sideways to pan →
Solid lines run forward. Dashed amber lines are the loops — the four places a candidate goes backwards, all of them defined in a department contract rather than added here.
Mermaid source for this diagram
flowchart TD
    scan["Stage 0 · Scout<br><small>signals, recalls, codes, policy</small>"]
    seed["Stage 0.5 · Seed Scout<br><small>macro-trend seeds</small>"]
    gen["Stage 1 · Generator<br><small>candidate file, all claims unverified</small>"]
    score["Stage 2 · Scorer<br><small>draft score, triage only</small>"]
    gatea{"Gate A — worth a Verifier pass?"}
    parked(["Parked<br><small>a named skip, not a silent one</small>"])
    verify["Stage 3 · Verifier<br><small>fresh context, typed connectors</small>"]
    rescore["Stage 4 · Scorer<br><small>verified composite</small>"]
    cover{"6 of 9 factors verified?"}
    gate["Stage 5 · Gate check<br><small>kill floors, verified data only</small>"]
    research["45 · Research<br><small>dossier, drafted claims</small>"]
    killed(["Killed<br><small>logged with a revive condition</small>"])
    wrap["Stage 5.5 · Wrap<br><small>eight wrap criteria</small>"]
    human["Stage 6 · Human shortlist<br><small>Tier 3 — a person, never an agent</small>"]
    dilig["Stage 7 · Diligence<br><small>bench evidence, FTO memo, drafts</small>"]
    outcome["Stage 8 · Outcome logged<br><small>calibration log</small>"]
    scan --> gen
    seed -->|steer| gen
    gen --> score
    score --> gatea
    gatea -->|no| parked
    gatea -->|yes| verify
    verify --> rescore
    rescore --> cover
    cover -->|yes| gate
    cover -.->|no — stage: verifying| verify
    gate -.->|under 6/9 → queued-research| research
    research -.->|drafted claims go back to Verify| verify
    gate -->|a kill floor fires| killed
    gate -->|survives| wrap
    killed -.->|revive condition fires — Stage 0 watches for it| gen
    wrap --> human
    human -.->|rejected| killed
    human -->|approved| dilig
    dilig --> outcome
    outcome -.->|the flywheel — what to watch for, and what to try next| scan
    class verify t2;
    class killed red;
    class human t3;
    class outcome green;

Numbering is sequence, not importance. 00 through 50 (plus 60) are the stages a candidate actually moves through in order; 80, 90 and 95 sit outside that sequence on purpose — they reason over or render what a candidate already has, and advance no stage:, no status:, and no score. See Departments for what each one contracts to do.

The loop the stages sit inside

The front end owns the opportunity and owns none of the expertise. It writes down what the opportunity rests on — the assumption register, a subset of the claims, each with who depends on it and what breaks if it is false — then convenes the chairs. Each returns a position: a verdict, the conditions that would change it, and the requests it raises. Conditions become unverified claims, and go to the Verifier like everything else.

conveneevery condition is anunverified claima chair's binding adds aregister rownoyesthe answer becomes aclaim, verified like anyotherevery position againstthe old shape goes stalerow closedAn opportunityframed by 10_front-endAssumption registerthe load-bearing subset, whodepends on eachRound tableseven chairs, each answeringcoldSeven positionsverdict · conditions ·requests raisedConditions become claimsa bound condition is aregister rowStage 3 · Verifiertags it, coldTag comes back refutedor unconfirmed?The register row holdsImpact reviewwho depended on it · what itcostsAbsorbnothing load-bearing fellPivotthe shape changes, with alessonCommissionraise the work that settlesitRequest ledgeranswer must name an artifact
Drag the diagram sideways to pan →
There are exactly three outcomes from an impact review, and check_loop.py refuses a loop record that invents a fourth. "Note it and carry on" is what the register exists to make impossible.
Mermaid source for this diagram
flowchart TD
    opp(["An opportunity<br><small>framed by 10_front-end</small>"])
    reg["Assumption register<br><small>the load-bearing subset, who depends on each</small>"]
    table["Round table<br><small>seven chairs, each answering cold</small>"]
    pos["Seven positions<br><small>verdict · conditions · requests raised</small>"]
    cond["Conditions become claims<br><small>a bound condition is a register row</small>"]
    ver["Stage 3 · Verifier<br><small>tags it, cold</small>"]
    fail{"Tag comes back refuted or unconfirmed?"}
    holds(["The register row holds"])
    ir["Impact review<br><small>who depended on it · what it costs</small>"]
    absorb["Absorb<br><small>nothing load-bearing fell</small>"]
    pivot["Pivot<br><small>the shape changes, with a lesson</small>"]
    commission["Commission<br><small>raise the work that settles it</small>"]
    req["Request ledger<br><small>answer must name an artifact</small>"]
    opp --> reg
    reg -->|convene| table
    table --> pos
    pos --> cond
    pos -->|every condition is
an unverified claim| ver
    cond -.->|a chair's binding adds a register row| reg
    ver --> fail
    fail -->|no| holds
    fail -->|yes| ir
    ir --> absorb
    ir --> pivot
    ir --> commission
    commission --> req
    req -.->|the answer becomes a claim, verified like any other| ver
    pivot -.->|every position against the old shape goes stale| table
    absorb -.->|row closed| reg
    class ver,ir t2;
    class pivot t1;
Loop — a statement fails: when a registered claim comes back refuted or unconfirmed, an impact review fires — who depended on it, what it costs, and one of exactly three outcomes: absorb (nothing load-bearing depended on it), pivot (the opportunity changes shape, with lineage and a lesson), or commission (the work that would settle it gets raised). There is deliberately no fourth outcome; "note it and carry on" is what the register exists to make impossible, and check_loop.py refuses a loop record that tries it.
Loop — a pivot re-opens the round table: a pivot bumps pivot: in the loop record, and every position written against the old shape shows as stale until that chair answers again. Chairs disagreeing in writing is the output, not a problem to resolve — and no chair holds a veto: blocks opens an impact review, and killing stays Stage 5 arithmetic over verified claims.

See this running on a real opportunity →

The loops inside the stages

None of these are new — they are stated in the department contracts already, and they are drawn on the route map above. What they mean:

Loop — under 6/9 verified factors: Stage 5 writes queued-research instead of a kill. 45_research builds more dossier, drafts more claims, and hands back to Verify → Rescore → Gate-check — the same three stages run again on the same candidate. departments/45_research/CONTEXT.md names this explicitly as "the loop that actually turns research into coverage."
Loop — a kill isn't the end either: when Stage 5 does fire a kill, the Librarian logs it with a named revive condition, and 00_scouting watches every future scan for exactly that condition. A fired one reopens the idea at Stage 1 — a second loop that never touches a human at all.
Loop — the flywheel itself: Stage 8's outcome feeds back into 00_scouting (what to watch for) and 10_front-end (what to try next). The root CONTEXT.md states this in one line: "Stage 8 feeds Stages 0 and 1." It is the loop the whole repo is named for, and it is the only one that spans the Tier 3 boundary.

The on-demand loop

80_commercial adds another: an unfillable market-model leg is filed as a research row, and once 45_research promotes a report against it, the model is rebuilt with a real leg instead of an assumption. It isn't tied to a stage number because /market-model itself isn't chained — running it is "a decision about where to spend effort," same as /research and /wrap (departments/CONTEXT.md).

not researchableresearchablethe model is rebuiltwith a real leg, not anassumption80 · Market modelstate the chain firstA leg with nothing underitDeclared assumptionnamed as such, never hiddenResearch rowsource_of_question:commercial-gap45 · Research reportsourced, carries no tagCopied into ## Claimsas unverifiedStage 3 · Verifier
Drag the diagram sideways to pan →
The request ledger generalises this to every pair of departments: any one may ask any other what it cannot answer itself, and the answer must name an artifact that exists.
Mermaid source for this diagram
flowchart TD
    model["80 · Market model<br><small>state the chain first</small>"]
    leg{"A leg with nothing under it"}
    assume[/"Declared assumption<br><small>named as such, never hidden</small>"/]
    row["Research row<br><small>source_of_question: commercial-gap</small>"]
    report["45 · Research report<br><small>sourced, carries no tag</small>"]
    claim["Copied into ## Claims<br><small>as unverified</small>"]
    ver2["Stage 3 · Verifier"]
    model --> leg
    leg -->|not researchable| assume
    leg -->|researchable| row
    row --> report
    report --> claim
    claim --> ver2
    ver2 -.->|the model is rebuilt with a real leg, not an assumption| model
    class ver2 t2;

What's still genuinely linear

The request ledger generalises that on-demand loop to every pair of departments: any one may ask any other a question it cannot answer itself, the answer must name an artifact that exists, and referred-out records an opportunity leaving the front end entirely for M&A, an R&D programme or a partner. What remains genuinely linear is narrower, and worth naming rather than smoothing over: Stage 3 has no automatic trigger back into 45_research when a candidate comes back mostly unconfirmed rather than failing the 6/9 floor outright. The path exists — a human or an agent can run /research on it at any time — but nothing makes that happen on its own between Stage 4 and Stage 5. That is a considered omission, not an oversight: the same contract that defines the queued-research loop also lists /research among the commands /flywheel-cycle deliberately does not chain, because which candidate deserves a research pass is a decision about where to spend effort, not a mechanical step every candidate should get automatically.

Inside each block

What one box on the route map compresses. Each list is drawn from that department's own ## Process section — see Departments for the full contract, inputs and outputs each one carries.

00_scouting · stage 0 · /scan

  1. /scan launches the Scout
  2. Sweep connectors for changed facts — clearances, recalls, patents, codes, policy, literature
  3. Log the diff: what changed and which candidates it touches — never a score, never a tag
  4. Librarian routes affected candidates back to Stage 2 for re-scoring

05_macro-trends · stage 0.5 · /seed-scan

  1. /seed-scan opens one of ten lanes, or re-checks a watchlist entry
  2. Anchors (dated sources), a direction, and a quarantined extrapolation — never merged
  3. A counter-anchor section and a runnable falsifier are required, not optional
  4. The seed becomes steer for Stage 1 — read whenever generation runs, never auto-chained

10_front-end · stage 1, and the loop · /generate, /front-end-loop, /round-table, /impact, /pivot

  1. /generate launches the Generator, primed with the rubric and the killed-idea log
  2. Copy the template; fill device class, target, mechanism, closest predicate
  3. Write every line of ## Claims as unverified — no scores, no verification yet
  4. Check the killed-idea log first — no re-proposing a dead shape without a fired revive condition

20_scoring · stage 2, 4 · /score, /rescore

  1. Stage 2: score unverified claims for triage only — no number here is final
  2. Gate A: worth the cost of a Verifier pass? A judgment call; a skip must be named
  3. Stage 4: recompute the composite from verified claims only, after Stage 3 runs
  4. Under 6/9 factors verified is a thin result → Stage 5 routes it, stage: stays

30_verification · stage 3 · /verify

  1. /verify launches the Verifier in a fresh, structurally separate context
  2. Route each claim by type to its typed connector — never a generic web search
  3. Set the tag in place — verified / unconfirmed / refuted — citing the connector's record
  4. A jurisdiction with no connector stays unconfirmed — never answered with the wrong regime's evidence

45_research · stage 4.5 · /research, /research-fleet

  1. /research or /research-fleet builds or refreshes a domain dossier
  2. Draft unverified claims from the sourced material — a dossier itself carries no tags
  3. Hand back to Verify → Rescore → Gate-check — the loop that turns research into coverage
  4. Also works rows 80_commercial commissions when a market-model leg has nothing under it

50_gate · stage 5, 5.5 · /gate-check, /wrap

  1. /gate-check: apply the kill floors to the Verified Composite, never Stage 2's draft
  2. Under 6/9 factors verified → queued-research, not a kill — looped back to 45_research
  3. A kill fires → the Librarian logs it with a revive condition Stage 0 watches for
  4. /wrap: complete the eight wrap criteria and write the ## Wrap section

60_human-review · stage 6, 7, 8 · /shortlist, /diligence, /log-outcome

  1. /shortlist compiles every wrapped candidate, led by evidence coverage — ranks nothing
  2. A human decides: approve, reject, or defer — recorded only by a person, never an agent
  3. Approved → /diligence: bench evidence, failure modes, a draft FTO (freedom to operate) memo — drafts, never sign-off
  4. A real outcome, once known, is logged via /log-outcome and feeds the calibration log

80_commercial · stage — · /market-model, /business-case

  1. /market-model: state the chain first, then run the checkable primitives under each leg
  2. Type every gap — draftable, researchable (filed to 45_research), or a declared assumption
  3. Report a band and a span with a coverage line; refuse a point estimate and a chosen scenario
  4. /business-case: who pays, from which budget, 2-4 routes to revenue, each with a kill condition

90_artifacts · stage — · /pitch-decks, /narrate

  1. /pitch-decks: three lenses, each slide a condition rather than a conclusion
  2. /narrate: synthesizes claims, dossier and decks into one story — no new facts introduced
  3. Renders review/ from the knowledge base — generated, never hand-edited
  4. Nothing here scores, gates, or touches stage: / status:

95_marketing · stage — · /messaging

  1. /messaging: reads the candidate cold, drafts investor / user / payer message sets
  2. Every line cites its claim and tag, or is marked [unsubstantiated]
  3. Anything beyond the stated intended use is named in its own section, not folded in
  4. Unsubstantiated lines get appended back to ## Claims as unverified
Words on this page1 abbreviation(s) and code(s), with what each stands for — copied from _shared/plain-language.md
FTO
freedom to operate — whether a product can be sold without infringing someone else's live patent