godmode

Files (8)

• SKILL.md
• programme-dashboard.html · assets/
• charter-template.md · references/
• lessons.md · references/
• stage-workflows.md · references/
• state-and-beads.md · references/
• verify-lanes.md · references/
• beads_remote.sh · scripts/

SKILL.md (first lines)

# godmode — the autonomous product factory

A runtime orchestrator that OWNS the loop. It composes existing machinery —
`/loop` (driver), `Workflow` (staged ultracode), beads (state), `/here-now`
(dashboard hosting), `tmux-verify`/browser-harness/Playwright (verify lanes) —
into one self-driving programme. You are the driver each tick; these files are
your constitution and playbooks.

## Entry modes

| Invocation | Action |
|---|---|
| `/godmode <north-star> --mode finite\|perpetual [--approval none\|roadmap] [--no-court] [--budget <tokens>] [--deadline <ISO>]` (alias: `/godmode init <north-star> ...`) | INIT: generate charter + state + dashboard + beads, then begin finite delivery or perpetual evolution |
| `/godmode run [--take-over]` | Resume/continue the loop from state (any session, incl. post-crash). Claims the driver lease first: refuses while another session's lease is fresh, auto-claims a stale one, `--take-over` forces after an AskUserQuestion confirm. On a fresh machine: `sync.sh discover`, pick the slug, claim, then `sync.sh adopt <slug>` reconstructs local state |
| `/godmode status` | Standup: read state + beads + dashboard + lease, report, change nothing. NEVER adopts (observer-safe: no scratch state means hooks stay inert). Preflight prints "status publishing DISABLED: missing <X>" when here-now/credentials are absent |
| `/godmode pause` | Stop re-arming the loop; state stays resumable; release the lease (`lease.sh release`) |

## Provider parity

| Capability | Claude | Codex | Copilot |
|---|---|---|---|
| init / run (drive the loop) | native scheduler | native Codex automation required | external scheduler adapter required |
| status / discover | yes | yes | yes |
| dashboard publish + sidecar sync + lease guard | all hooks | hooks.json (shared format) | sessionStart pull + staleness nudge |

Never claim a provider is driving when its scheduler or peer-model adapter is
missing. Record the capability result in state and defer that lane visibly.

## The three-layer machine

```
LAYER 1  CHARTER   .agents/goals/<slug>-charter.md   — constitution, re-read EVERY tick
LAYER 2  DRIVER    /loop dynamic mode                — ScheduleWakeup ~600s, same prompt re-entered
LAYER 3  WORKFLOWS one ultracode Workflow per stage  — resumable via resumeFromRunId
STATE    beads (epic/feature nodes) + .agents/scratch/<slug>-state.json (working
         copy) + hook-maintained sidecar mirror {state,charter,lease} on the
         dedicated ref refs/godmode/<slug> (cross-machine; GODMODE_SYNC=local opts out)
```

## Pipeline (stage names are the primary vocabulary; W-numbers are aliases)

```
SIGNAL                   TTL    ONE model gathers CITED external evidence: comparable
        │                       products, user-reported gaps, constraining standards.
        │                       Reads the append-only ledger first and returns only what is
        │                       NEW; parked rows keep their reason and are never re-proposed.
        │                       /research if available, else WebSearch+WebFetch. Charter-gated;
        │                       unavailable degrades to repo-only discovery, never a failure.
        ▼
DISCOVER                 once   BRAIN brainstorms the nirvana landscape from the
        │                       north-star + a repo scan + the SIGNAL rows + any existing
        │                       backlog → writes the feature REGISTRY
        │                       (.agents/plans/<slug>-registry.md), provenance per row
        │                       (repo | signal | user). User lists appended, not replaced.
        ▼
FEASIBILITY COURT (W0)   once   every REGISTRY idea → verdict: feasible | downgrade | park+blocker
        │                       skipped only by explicit --no-court (registry taken verbatim)
        ▼
ROADMAP (W1)             once   cluster survivors → ordered epics + parallel-pair candidates,
        │                       seed beads (one per epic + per feature)
        ▼
[OPTIONAL ROADMAP GATE]         only when approval_policy is roadmap
        ▼
per epic, serial on stacked branches:
   PLAN (W2)      planner → adversarial review → revise → VERIFY THE REVISE EDITED THE
        │         PLAN FILES (mtime/content) — see references/lessons.md
        ▼
   EXECUTE (W3)   build (model pair per workstream) → pair review → adversarial epic
        │         review (+fix) → VERIFY (surface lane, references/verify-lanes.md)
        ▼         → bounded fix loop (≤2) → build gate (unpiped!)
   SHIP           stacked PR (labelled for review) → close epic+feature beads with
        │         evidence notes → dashboard update
        ▼
PERPETUAL         after every ship: full regression + refresh SIGNAL if stale +
                  next discovery/plan. Backlog-dry refreshes SIGNAL first and
                  becomes adaptive evidence research, never DONE
TERMINATION       finite backlog-dry | --budget exhausted | --deadline reached |
                  security, production-safety, authority, or lease loss
```

Perpetual progression: after each epic ships, start cumulative regression in
an isolated lane. At the same time, the completeness critic re-enters Discover
and creates evidence-backed candidates for the next generation, refreshing the
external Signal first when it is stale, so a dry backlog is replenished from
new outside evidence rather than from re-reading the same repo. The refresh
appends to the signal ledger and dedupes against every row ever recorded,
parked ones included, so the programme does not pay to rediscover a dead end it
already rejected. A confirmed
defect preempts the single mutation lane. Discovery and planning continue in
parallel. An empty Court result enters adaptive-backoff research, never DONE.

## Creative quorum

Every creative decision has two independent model perspectives: Discover,
Feasibility Court, Roadmap, completeness critic, incident root-cause analysis,
and strategic reprioritisation. Signal is not one of them: gathering cited
external evidence is retrieval, so it runs on one model and is judged by its
citations, not by quorum. Resolve the route before launching work with:

```bash
${CLAUDE_PLUGIN_ROOT}/scripts/programme_policy.py creative-route <availability.json>
```

- Claude primary pairs a Claude creative model with `codex:codex-rescue`.
- Codex primary pairs a Codex model with Claude Fable.
- Copilot primary uses two distinct Copilot models, then enriches with Claude
  or Codex when available.
- Fallback uses any two distinct available models. One model means creative
  work is deferred, while regression and grounded work continue.
- Persist both proposals, model identifiers, evidence, disagreement, and the
  synthesis. A third model synthesises when available; otherwise use the
  evidence rubric and preserve dissent.

Parallel epics: allowed ONLY if blessed AND file-sets provably disjoint AND
worktrees available; otherwise serialise (single worktree = single checkout).

## INIT procedure

1. Parse the north-star + flags. Derive `<slug>`.

From stevengonsalvez/ainb-toolkit, MIT.

More from stevengonsalvez/ainb-toolkit