geneseed 5.0.4 → 5.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +56 -0
- package/SHIPPED.md +2 -2
- package/docs/concepts/exclusions.md +1 -1
- package/docs/concepts/factories.md +67 -15
- package/docs/concepts/loop-gates.md +5 -2
- package/docs/concepts/shared-tier.md +14 -0
- package/docs/extending.md +1 -1
- package/docs/guides/migrate.md +1 -1
- package/docs/guides/run-a-factory.md +41 -13
- package/docs/guides/upgrade-to-5.md +2 -2
- package/docs/reference/factory-actions.md +7 -7
- package/docs/web-ui.md +18 -6
- package/harness.config.json +1 -1
- package/js/README.md +3 -2
- package/js/build/args.mjs +34 -14
- package/js/build/emit-claude.mjs +3 -0
- package/js/build/emit-opencode.mjs +4 -0
- package/js/build/retired-skills.mjs +158 -0
- package/js/build/source.mjs +31 -11
- package/js/cli-table.json +32 -5
- package/js/factory/cli.mjs +49 -8
- package/js/factory/graph.mjs +72 -8
- package/js/factory/state.mjs +109 -27
- package/js/hosts/done-checks.mjs +3 -2
- package/js/hosts/memory-files.mjs +7 -2
- package/js/loop/catalog.mjs +16 -10
- package/js/loop/cli.mjs +16 -10
- package/js/maintain/memory.mjs +27 -2
- package/js/maintain/migrate.mjs +39 -25
- package/js/web/daemon.mjs +69 -14
- package/js/web/handler.mjs +22 -9
- package/package.json +1 -1
- package/src/agents/memory-curator.md +4 -4
- package/src/bricks/checks.md +62 -0
- package/src/bricks/intake.md +15 -6
- package/src/bricks/merge-gate.md +17 -8
- package/src/bricks/retro.md +8 -3
- package/src/bricks/review-panel.md +43 -0
- package/src/bricks/spec.md +20 -6
- package/src/factories/analysis-to-build.json +25 -7
- package/src/factories/bug-report-to-fix.json +25 -7
- package/src/factories/issue-to-pr.json +29 -11
- package/src/memory/README.md +1 -1
- package/src/skills/factory-forge.md +23 -5
- package/src/skills/factory.md +95 -25
- package/src/skills/geneseed.md +1 -1
- package/src/skills/loop.md +3 -2
- package/src/skills/rule/consolidate.md +1 -1
- package/src/skills/rule.md +1 -1
- package/themes/_TEMPLATE.json +1 -1
- package/web/dist/assets/{Activity-BaoxwVFH.js → Activity-CpkBwpu7.js} +1 -1
- package/web/dist/assets/{ActivityDetail-C_bFD0rW.js → ActivityDetail-DTPziZWM.js} +1 -1
- package/web/dist/assets/{Bonsai-B01lLf0m.js → Bonsai-hiG_gGNU.js} +1 -1
- package/web/dist/assets/{CopyButton-Bc66KPyA.js → CopyButton-DUIUfNp6.js} +1 -1
- package/web/dist/assets/{Dashboard-X7GZzGJp.js → Dashboard-Dnw6EyX7.js} +2 -2
- package/web/dist/assets/{Docs-LRYVnGLG.js → Docs-BEET_l16.js} +1 -1
- package/web/dist/assets/Factories-D6KXkfWw.js +1 -0
- package/web/dist/assets/{GreenhouseView-CfWR2-sX.js → GreenhouseView-BKxy5apE.js} +1 -1
- package/web/dist/assets/{Installs-nfFHnovH.js → Installs-CnFVlVD0.js} +1 -1
- package/web/dist/assets/{JournalView-lpOHcHKK.js → JournalView-ChFitHjo.js} +1 -1
- package/web/dist/assets/{Kits-Bw5EQl_i.js → Kits-CcR-OlwQ.js} +1 -1
- package/web/dist/assets/{Laws-CnZJ0wjZ.js → Laws-B1s5idOg.js} +1 -1
- package/web/dist/assets/LibRows-BZgdbI1l.js +1 -0
- package/web/dist/assets/Library-x6TkkEVF.js +3 -0
- package/web/dist/assets/{Loops-ZaHC5MVl.js → Loops-BH93KKxn.js} +1 -1
- package/web/dist/assets/{OperatorHudView-CggG0_sK.js → OperatorHudView-BO0aIKPL.js} +1 -1
- package/web/dist/assets/{Personal-BObvlb70.js → Personal-CE_0Vhh0.js} +1 -1
- package/web/dist/assets/{Settings-BFfPMPc9.js → Settings-CbpZvVN_.js} +1 -1
- package/web/dist/assets/{Tabs-B594Pad_.js → Tabs-C2oW7oEj.js} +1 -1
- package/web/dist/assets/{index-DsLmKHw0.js → index-BQwOmbor.js} +2 -2
- package/web/dist/assets/{index-DvPjphz0.css → index-CuIop_pO.css} +1 -1
- package/web/dist/index.html +2 -2
- package/adapters/claude-code/skills/geneseed/SKILL.md +0 -76
- package/web/dist/assets/Factories-ARenKBiP.js +0 -1
- package/web/dist/assets/LibRows-Hqvf1beK.js +0 -1
- package/web/dist/assets/Library-JaSsp6Yr.js +0 -3
package/CHANGELOG.md
CHANGED
|
@@ -8,6 +8,62 @@ label. For the capability ↔ spec map, see [SHIPPED.md](SHIPPED.md).
|
|
|
8
8
|
|
|
9
9
|
## [Unreleased]
|
|
10
10
|
|
|
11
|
+
## [5.1.1] — 2026-11-10
|
|
12
|
+
|
|
13
|
+
### Added
|
|
14
|
+
- **`geneseed memory consolidate`** rebuilds the memory index by hand: `MEMORY.md` and `topics/`, from the fact files on disk. It prints `+N indexed, -N pruned` and each pair of facts that share a description, and never merges them. It takes `--memory <dir>` like `list` and `rm`; a fact name, `--archived` or `--purge` is refused with exit 2.
|
|
15
|
+
|
|
16
|
+
### Fixed
|
|
17
|
+
- **The memory instructions name a command that runs.** The rule skill, the `memory-curator` agent and the memory README told the agent to run `geneseed learn --consolidate`, which the CLI refuses: `learn` is a hook verb. They now say `geneseed memory consolidate`. The `learn` hook still rebuilds the index after every fact it writes.
|
|
18
|
+
|
|
19
|
+
### Removed
|
|
20
|
+
- **`adapters/claude-code/skills/geneseed/SKILL.md`**, a stale hand-written copy of the `geneseed` skill that no install used. It told the agent to run `geneseed learn` and `geneseed context` by hand. The skill every install gets is rendered from `src/skills/geneseed.md`.
|
|
21
|
+
|
|
22
|
+
## [5.1.0] — 2026-11-09
|
|
23
|
+
|
|
24
|
+
### Added
|
|
25
|
+
- **Every shipped factory checks the work after the loop, and the `checks` and `review-panel` bricks.** `checks` (as `tester`) runs the repo's done list as the base branch holds it, never the branch's copy; a red command or a command that changes a tracked file fails it; a timeout, a missing tool, a failed fetch or no default branch is an `error` whose finding starts `environment:` and holds for you; the tree is restored afterwards, whatever the outcome. Once every command passes, a diff that touches a locked path holds for you. The locked paths are the done list, `.github/workflows/`, `.gitlab-ci.yml`, `.geneseed/factories/`, `loops/`, `bricks/`, and each path in the factory's new `protected` list, a rename's old path included. At that gate, `ok` lets it through, `no` stops. With no done list on the base, `checks` proposes one from the base's manifests and holds; on your yes it goes to the base by a PR of its own for you to merge, and `checks` runs again once. `review-panel` seats agents by the work item's size and areas from the factory's new `review.seats` table (default: `reviewer`, plus `tester` for medium, plus `steward` for large; `security`, `performance` or `user-advocate` by area), each blind to how the change was built, and merges their verdicts. The order is now loop → `checks` → `review-panel` → `holdout` → `pr-open` → `merge-gate` → `retro`; a failed check or review sends the work back to the loop, twice at most each (cycles `checks` and `review`). `geneseed factory check` refuses a seat that names no shipped agent (a project's own agents are not seats), a size with no list, and a malformed `protected`.
|
|
26
|
+
- **`intake` can ask.** It reports `needs-info` when a question only you can answer blocks the work, and holds: answer with `amend` (three times at most), go on with its stated assumptions with `ok`, or stop with `no`. `needs-info` names no lane, so `intake` is not a fork. It also rates the work item's `size` and `areas` for the review panel. Factories written before keep working, and so do runs in progress: the `needs-info` edge is optional, and without one, `ok` follows intake's `pass` edge. Add the edge only to route `needs-info` elsewhere.
|
|
27
|
+
- **The merge is proposed at the end.** After the close commit, when CI is green, the `factory` skill shows the PR, the CI state and the review verdicts, and asks you once whether to merge; on yes it squash-merges. A run still never merges without that yes, and never enables auto-merge.
|
|
28
|
+
|
|
29
|
+
### Changed
|
|
30
|
+
- **A reinstall or upgrade moves aside the skills an old build left behind.** Every global emit (so `rebuild-all`, `upgrade` and `migrate` too) moves each `skills/<name>` folder that an earlier build rendered under a name that no longer ships (an old alias or a retired skill), and that no manifest owns, to `<config dir>/archived-skills/<name>/<timestamp>/`, on Claude Code, Bob, OpenClaude and OpenCode, with one `pruned retired skill` line each. A folder moves only when it is a plain, readable directory with no links in it and its `SKILL.md` has the Geneseed render shape (`name:`, a JSON-quoted `description:`, and outside code fences a `# <theme skill label>: <name or the skill it aliases>` heading); a same-name skill of your own stays, and `migrate --dry-run` still lists it as an orphan.
|
|
31
|
+
- **`geneseed migrate --dry-run` prints `would prune`** for each folder the next emit moves, now for OpenCode too; `/api/migrate/preview` gains a `prunes` list, and `orphans` lists only what stays.
|
|
32
|
+
- **The Factories page draws every `loop:` stage as a compact box.** On the main path as in a fork's lanes, a loop stage names its loop over `whole loop` (or `not in catalogue`), and during a run `at <node>` names the child loop's step. The ring no longer sits inside the factory graph; the Loops page still draws it.
|
|
33
|
+
- **The factory transition ceiling is 60 per task** (was 30), and so at most 1200 over a run, for the two new stages and their laps.
|
|
34
|
+
|
|
35
|
+
### Fixed
|
|
36
|
+
- **The factory counts spec tasks as CommonMark reads the list.** A numbered line nests only from the text of the task above it, so tasks indented 1 or 2 spaces, or under a two-digit marker, are no longer lost; a backtick fence whose info string holds a backtick no longer hides the tasks under it; a heading indented 1–3 spaces, or a setext heading, now ends the list; and a task's own indented paragraph, `---` or `##` no longer ends it.
|
|
37
|
+
- **`geneseed factory record --spec` says what it checks:** a `spec.md` one folder under `specs/`.
|
|
38
|
+
- **A hand-edited `FACTORY.md` is refused for every stage it names** that the factory graph does not hold, and for an `awaiting` that does not match the status; `decide` on such a file gives the readable-state error, not a TypeError.
|
|
39
|
+
- **Every `geneseed factory` path argument is relative to the current directory.** `--spec` used to resolve against the git root.
|
|
40
|
+
- **`geneseed factory record --carry-file` and `decide --note-file`:** free text (your words, a stop reason) is written by the agent's file tool to a file, never put on the command line.
|
|
41
|
+
- **The factory skill pipes the porcelain into `geneseed factory record` in one command** (`git status --porcelain --untracked-files=all | geneseed factory record …`), in a POSIX shell and in PowerShell; `record` strips the CRLF and the leading BOM Windows PowerShell 5.1 can add. A record line whose spec path, carry path or outcome holds `commit` or `push` still makes the git gate ask: a false alarm, answer yes. `factory init` refuses a slug holding `git`, `commit` or `push`, which removes the commonest case.
|
|
42
|
+
- **A project factory that shadows a shipped one is named** in `geneseed factory check` (`overridden`), a factory parse problem names its level, and a project file that does not load makes `factory init` refuse instead of running the shipped graph of that name.
|
|
43
|
+
- **`geneseed factory check` refuses an environment outcome routed to a loop:** `checks` `error` and `merge-gate` `none` may not lead to a `loop:` stage or `$lane`.
|
|
44
|
+
- **An amended fork no longer keeps its old lane**, and **an amend at the spec gate may add tasks even after a loop that ran before the spec**: only the first task loop freezes the count.
|
|
45
|
+
- **A spec under a non-ASCII slug records:** the engine unquotes git's quoted porcelain paths.
|
|
46
|
+
- **`merge-gate` reads CI from the checks' states, never the exit code**; a red (1) or pending (8) exit is a verdict, not an environment failure.
|
|
47
|
+
- **The review panel no longer reviews `FACTORY.md` and `LOOP.md`**, and **the run report finds the notes of closed loops in git**.
|
|
48
|
+
- **The merge proposal states its guard truthfully:** `gh pr merge` runs only on your explicit yes in chat; no Geneseed gate asks before it.
|
|
49
|
+
- **The factory docs state the transition ceilings right** (60 per task, 1200 at most over a run, gated against the engine), the `factory-forge` example lists the stages of the factory it names, and a done-list branch that already exists on the remote is reported, not pushed over.
|
|
50
|
+
- **`geneseed web start` ends an unrecorded console of this install by challenge and response.** The console hands out a single-use nonce that lives 30 s, and the proof covers the port and that nonce, so a proof an impostor collects while the console is down can no longer shut the real console down later. A console from before this change gets no proof: it is named and left running, to be ended by hand once.
|
|
51
|
+
- **`geneseed web start` names a console of this install without the shutdown secret** (a foreground `geneseed web`, or a daemon that could not read its secret) and says how to stop it, instead of reading as an impostor.
|
|
52
|
+
- **An `--exclude-rules "comms 5"` exclusion (the retired *Mark the Ask*) says what it stopped doing:** the ask markers now bind inside comms 1, so the exclusion no longer removes them.
|
|
53
|
+
- **A rule exclusion whose address once belonged to a retired rule, and now belongs to a different live rule, warns loudly at build time**, naming both rules.
|
|
54
|
+
- **The Factories graph draws a fork only where the engine sees one**: a brick that declares a named outcome. A `loop:` stage, or a brick whose pass/fail edges reach two stages, is no longer drawn as lanes. Many routes back into one stage now land inside its box instead of overflowing it.
|
|
55
|
+
- **Factories › Active** says which install's catalogue drew a run's bricks and loops, shows "No runs yet" when the active-runs payload has no `factories` list instead of loading forever, and a catalogue payload without `factories` no longer crashes the page.
|
|
56
|
+
- **Stacked library list:** a click on the open row no longer keeps the list open for a later Ctrl-K jump from outside, and ArrowDown from the filter unfolds a folded list before it focuses the first row.
|
|
57
|
+
- **The pinned Primary agent row follows the text, category and Show filters**, so "No matches" and the picker count agree with the rows; its loadout is read once. "Show all rules" in the Loadout panel collapses again when you open another agent.
|
|
58
|
+
- **`docs/web-ui.md`** describes both ways to start a factory (the agent request and the by-hand worktree command), the fork definition, and the catalogue the Active tab borrows.
|
|
59
|
+
- **A loop's discard no longer stashes `FACTORY.md`.** The `loop` skill's discard kept only `LOOP.md` out of the stash, so a loop run as a factory stage stashed the factory's state with the attempt: an untracked `FACTORY.md` was lost, and a tracked one rolled its counters back. The discard now keeps both engine files, and the `checks` and `review-panel` bricks, which delete the untracked files their commands created, never touch either.
|
|
60
|
+
- **`geneseed factory record --spec` refuses a spec that is not at `specs/<slug>/spec.md`.** It took any path inside the worktree and stored it, and every later action then refused `FACTORY.md` as unreadable. The refusal now comes first, names the required shape, and leaves the state as it was. The `--spec` help names the shape too.
|
|
61
|
+
- **An amend at the spec gate may add tasks.** The factory froze the task count at the first `--spec` record, which comes before the spec's human gate, so a spec amended to list more tasks was refused. The count, and the run-wide ceiling with it, now follow each `--spec` record until the first loop launches; from then on they are frozen as before. The amend cap of 3, the per-task ceiling and the 20-task cap still bound every run.
|
|
62
|
+
- **A factory run with no loop closes cleanly.** The `factory` skill closed every run with `git rm -f FACTORY.md`, which fails in the `docs` lane of `issue-to-pr`: no loop runs there, so `FACTORY.md` is never tracked. The close step now deletes an untracked `FACTORY.md`, and commits and pushes only when there is a removal to commit; with no close commit, the final CI state is the one `merge-gate` read.
|
|
63
|
+
- **The `spec` brick states the task format the factory counts.** It now names the heading the engine looks for, the numbered-item forms, the indentation and where the list ends, and refers to the factory's task limit. In a factory it names the run's slug (it said the loop's title) and takes an amendment from the stage's carry (it said LOOP.md's notes); in a loop it keeps both as before. The count now matches it: a numbered sub-item (` 1.` under `1.`) is no longer counted as a task, and a fenced block in the list no longer ends it at a `# comment` line.
|
|
64
|
+
- **An environment failure no longer goes back to the loop.** `checks` reported a failed fetch, no default branch, a timeout or a missing tool as a `fail`, and `merge-gate` reported CI still pending after 30 minutes as a `fail`; every factory routes `fail` back to the loop, whose code cannot fix them, so each one burned laps and cycles. `checks` now reports them as `error` and `merge-gate` as `none`, each with a finding that starts `environment:`. Both outcomes already hold for you: `amend` runs the stage again once the environment is fixed, `no` stops. No factory graph changes. The `factory-forge` skill says never to route those outcomes to a loop.
|
|
65
|
+
- **A proposed done list reaches the base by PR, never by a push to it.** At `checks` `none`, the `factory` skill pushed the done list straight to the default branch, against the rule every factory gives every stage: push only your own branch. It now commits the file in a separate worktree on its own branch, `geneseed/done-list-<slug>`, pushes that branch and opens a PR for you to merge; `ok` still waits until the file is on the base.
|
|
66
|
+
|
|
11
67
|
## [5.0.4] — 2026-11-09
|
|
12
68
|
|
|
13
69
|
### Added
|
package/SHIPPED.md
CHANGED
|
@@ -20,7 +20,7 @@ historical references, not files distributed with the repo.
|
|
|
20
20
|
> **On version numbers.** [`harness.config.json`](harness.config.json)'s `version` is a
|
|
21
21
|
> human-readable label only. The canonical identity of an installed harness is the
|
|
22
22
|
> **source fingerprint** stamped in `.geneseed-version` (see `geneseed version`), not the
|
|
23
|
-
> string. Current label: **5.
|
|
23
|
+
> string. Current label: **5.1.1**.
|
|
24
24
|
|
|
25
25
|
## Capabilities
|
|
26
26
|
|
|
@@ -39,7 +39,7 @@ Every row below is present in the tree today; "Spec" names the design record.
|
|
|
39
39
|
| **OpenCode adapter** | Native agents/skills mapping + plugins (context, learn, guard, workflow, notify, ponytail, activity); global-emit link integrity; JSONC config target | `2026-06-07-opencode-adapter-features` · `2026-06-07-global-emit-link-integrity` · `2026-06-12-opencode-jsonc-target` · `2026-06-16-ponytail-minimal-code-mode` |
|
|
40
40
|
| **Host hooks, per dialect** | Every host gets the hook surface its runtime offers, spoken in that runtime's own verdict dialect via `--host`: Claude Code asks (`permissionDecision`), OpenClaude asks exactly as Claude does (a Claude Code fork, under `~/.openclaude` / `.openclaude/`), Bob refuses by exit code 2 (five Claude-named events, nested `~/.bob/settings/settings.json`, no subagent event), OpenCode's guard throws. Laws I/IV are the hard tier everywhere; the consent rules ask where a host can ask and warn where it cannot. `tool-gate` fuses the two gates for hosts that run one command per event; `PreCompact` runs `learn` before Claude compacts; every block or ask lands in `notebook/gates.jsonl` on every host | [bob](adapters/bob/README.md) · [claude-code](adapters/claude-code/README.md) · [candidate hosts](docs/candidate-hosts.md) |
|
|
41
41
|
| **Workflow primitive** | Saved, code-driven subagent orchestration (`workflow` tool + runtime); shipped scripts include `dispatch` — decompose a goal, route each subtask to its owning agent, converge | `2026-06-09-opencode-workflow-primitive` |
|
|
42
|
-
| **Per-agent memory** | Each capability agent keeps durable lessons in `memory/agents/<name>.md`: read at dispatch, written back mechanically by `learn` on session/subagent end (OpenCode plugin + Claude `SubagentStop`; Bob has no subagent event); `learn
|
|
42
|
+
| **Per-agent memory** | Each capability agent keeps durable lessons in `memory/agents/<name>.md`: read at dispatch, written back mechanically by `learn` on session/subagent end (OpenCode plugin + Claude `SubagentStop`; Bob has no subagent event); the `learn` hook rebuilds the index after every write, and `geneseed memory consolidate` rebuilds it by hand | `2026-07-04-orchestration-memory-upgrade` |
|
|
43
43
|
| **Wiki integration** | Machine-wide knowledge base (`geneseed-wiki.jsonc`): eager/lazy loading, conventions, protected folders enforced at the tool boundary | `2026-06-11-wiki-knowledge-base` |
|
|
44
44
|
| **Collaboration layer** | Negotiated postures (peer/mentor/expert/assistant/artisan, chosen at setup, inlined in AGENT.md), the bidirectional Pact, epistemically-typed memory (`force:` + Bridge rule), and a seed-once `PROFILE.md` identity with a web editor tab and a `profile` skill that interviews the user to draft it | `2026-07-12-collaboration-layer` |
|
|
45
45
|
| **Ownership** | The developer keeps ownership of production code: a Credo section (the code belongs to whoever answers for it), the `ownership` skill (setup from the code and a short interview, `feature`/`file`/`function` granularity, interfaces and sensitive zones always a checkpoint, announce-don't-ask), a `## Ownership` section in the committed root `AGENTS.md` (`mode: on\|off`), and a first-write gate on every host that stops the session's first write once in an application repo without one. learn-mode always comes first; `develop`, the `developer` agent and Foreman hold the checkpoints. Off per repo (`mode: off`), per install (`--no-ownership-gate`), per session ("proceed without") | `2026-10-26-ownership` |
|
|
@@ -56,7 +56,7 @@ The finer switch removes a single doctrine rule from an install while keeping th
|
|
|
56
56
|
geneseed build --emit claude-global --exclude-rules "process 7"
|
|
57
57
|
```
|
|
58
58
|
|
|
59
|
-
The install records it (`Excluded rules: process 7` beside its pack list) and every rebuild and upgrade keeps it. If a later version retires the rule
|
|
59
|
+
The install records it (`Excluded rules: process 7` beside its pack list) and every rebuild and upgrade keeps it. If a later version retires the rule, the rebuild prints a WARN, drops that address, and goes on. The WARN says what the exclusion no longer does: comms 5 (*Mark the Ask*) merged into comms 1 on 2026-11-08, so excluding `comms 5` no longer removes the ask markers, which now bind inside comms 1. If a new rule later takes a retired rule's address, an old exclusion of that address removes the new rule; the build then prints a loud WARN that names both rules, and the exclusion still applies until you remove it. The always-on Rules and the Ethos cannot be excluded.
|
|
60
60
|
|
|
61
61
|
**A hook goes with its rule.** Three doctrine rules are also enforced by a hook with no switch of its own, and excluding the rule, or building without its pack, drops that hook in the same rebuild. Including the rule again re-arms it at the next rebuild.
|
|
62
62
|
|
|
@@ -7,13 +7,15 @@ title: "Factories"
|
|
|
7
7
|
link: {"hash":"#/docs/factory-actions","label":"The geneseed factory actions →"}
|
|
8
8
|
description: "What a factory is: one work item carried through bricks and whole loops to an open PR, with routes back when CI fails."
|
|
9
9
|
---
|
|
10
|
-
To run one,
|
|
10
|
+
To run one, ask the agent in plain words ("Run the bug-report-to-fix factory on issue 412"). See
|
|
11
|
+
[Run a factory](../guides/run-a-factory.md#start-one-by-asking-the-agent).
|
|
11
12
|
|
|
12
13
|
A **factory** carries one work item (a request, a document or analysis, or a GitHub or GitLab
|
|
13
14
|
issue) through a graph of **stages** to an open pull request with green CI. A stage is a
|
|
14
15
|
[brick](loop-bricks.md) or a whole [loop](loops.md). `geneseed factory` is the state machine: it
|
|
15
16
|
decides every transition, cycle count and stop, and the `factory` [skill](skills.md) runs the stage
|
|
16
|
-
it is handed. **
|
|
17
|
+
it is handed. **No stage merges.** A run ends at "PR open, CI green"; then the agent asks you once
|
|
18
|
+
whether to merge, and merges only on your yes.
|
|
17
19
|
|
|
18
20
|
> **You already know this:** a ticket moving across a board — triaged, worked, reviewed, shipped
|
|
19
21
|
> for review. A failed check sends the card back a column, but only so many times before someone
|
|
@@ -30,8 +32,10 @@ loop that wrote it. Every such route sits inside a declared **cycle** with a `ma
|
|
|
30
32
|
Each lap back to the cycle's first stage spends one; past the `max`, the run stops. A route back
|
|
31
33
|
always starts a **fresh** loop: a new `LOOP.md`, whose first note is the reason the last lap
|
|
32
34
|
failed. When two cycles share that first stage, the lap spends the smallest one that holds the
|
|
33
|
-
stage it came from: a failed `holdout` spends `holdout`, a red `merge-gate` spends `ci`. The commits made before stay on the branch.
|
|
34
|
-
|
|
35
|
+
stage it came from: a failed `holdout` spends `holdout`, a red `merge-gate` spends `ci`. The commits made before stay on the branch. Whatever its cycles say, a run also stops after 60
|
|
36
|
+
stage transitions for one task (the count starts again for each spec task it reaches), and after
|
|
37
|
+
60 transitions per spec task over the whole run: a spec lists 20 tasks at most, so no run passes
|
|
38
|
+
1200.
|
|
35
39
|
|
|
36
40
|
`geneseed factory check` refuses a factory before any stage runs: an unknown brick or loop, an
|
|
37
41
|
outcome with no edge, a `$close` nothing reaches, a cycle with no `max`, a cycle entered anywhere
|
|
@@ -40,7 +44,7 @@ but its first stage, or a route back that spends no cycle.
|
|
|
40
44
|
## Forks and lanes
|
|
41
45
|
|
|
42
46
|
A **fork** is where the work takes one way or another. It is a brick that declares **named
|
|
43
|
-
outcomes**, any outcome other than `pass`, `fail`, `error` or `
|
|
47
|
+
outcomes**, any outcome other than `pass`, `fail`, `error`, `none` or `needs-info`. `triage` is one: `bug`,
|
|
44
48
|
`feature`, `deps`, `refactor`, `docs` and `fail`. Each named outcome has its own edge to its own
|
|
45
49
|
stage, its **lane**, and the outcome the brick reports picks the lane. `geneseed factory next`
|
|
46
50
|
hands the fork its `lanes`: each outcome with the stage it leads to.
|
|
@@ -48,7 +52,8 @@ hands the fork its `lanes`: each outcome with the stage it leads to.
|
|
|
48
52
|
Not every factory runs a loop, and not every lane is one. A loop is the lane for work that
|
|
49
53
|
changes code, because the loop carries the test → fix → verify proof. A brick is the lane where a
|
|
50
54
|
loop adds nothing: in `issue-to-pr`, `docs` goes to the `docs-update` brick, which commits its own
|
|
51
|
-
change. Every lane joins the same path after it: `
|
|
55
|
+
change. Every lane joins the same path after it: `checks`, `review-panel` and `holdout`, then
|
|
56
|
+
`pr-open` and `merge-gate`.
|
|
52
57
|
|
|
53
58
|
A route back after a fork targets **`$lane`**: the stage the run's most recent fork chose. The
|
|
54
59
|
engine records it in `FACTORY.md` when the fork's outcome is recorded, and an edge to `$lane` goes
|
|
@@ -75,20 +80,22 @@ names the run it belongs to.
|
|
|
75
80
|
|
|
76
81
|
| Factory | Stages |
|
|
77
82
|
| --- | --- |
|
|
78
|
-
| `analysis-to-build` | `intake` → `spec` → `holdout-write` → `loop:feature` → `holdout` → `pr-open` → `merge-gate` → `retro` → `$close`. `spec` writes `specs/<slug>/spec.md` with an ordered task list, and you approve it at its gate. `loop:feature` then runs once per task, in order, in the same worktree, and one PR opens at the end. A failed `
|
|
79
|
-
| `bug-report-to-fix` | `intake` → `holdout-write` → `loop:bugfix` → `holdout` → `pr-open` → `merge-gate` → `retro` → `$close`. A failed `
|
|
80
|
-
| `issue-to-pr` | `intake` → `holdout-write` → `triage`, a fork → one lane → `holdout` → `pr-open` → `merge-gate` → `retro` → `$close`. `triage` reports the lane: `bug` → `loop:bugfix`, `feature` → `loop:feature`, `deps` → `loop:deps-upgrade`, `refactor` → `loop:refactor`, `docs` → the `docs-update` brick. A failed `
|
|
83
|
+
| `analysis-to-build` | `intake` → `spec` → `holdout-write` → `loop:feature` → `checks` → `review-panel` → `holdout` → `pr-open` → `merge-gate` → `retro` → `$close`. `spec` writes `specs/<slug>/spec.md` with an ordered task list, and you approve it at its gate. `loop:feature` then runs once per task, in order, in the same worktree; `checks` and `review-panel` run once, after the last task, and one PR opens at the end. A failed `checks`, `review-panel` or `holdout`, or a red `merge-gate`, sends the work back to `loop:feature` as one extra task, twice at most each (cycles `checks`, `review`, `holdout` and `ci`) |
|
|
84
|
+
| `bug-report-to-fix` | `intake` → `holdout-write` → `loop:bugfix` → `checks` → `review-panel` → `holdout` → `pr-open` → `merge-gate` → `retro` → `$close`. A failed `checks`, `review-panel` or `holdout`, or a red `merge-gate`, sends the fix back to `loop:bugfix`, twice at most each (cycles `checks`, `review`, `holdout` and `ci`) |
|
|
85
|
+
| `issue-to-pr` | `intake` → `holdout-write` → `triage`, a fork → one lane → `checks` → `review-panel` → `holdout` → `pr-open` → `merge-gate` → `retro` → `$close`. `triage` reports the lane: `bug` → `loop:bugfix`, `feature` → `loop:feature`, `deps` → `loop:deps-upgrade`, `refactor` → `loop:refactor`, `docs` → the `docs-update` brick. A failed `checks`, `review-panel` or `holdout`, or a red `merge-gate`, sends the work back to `$lane`, that same lane, twice at most each (cycles `checks`, `review`, `holdout` and `ci`) |
|
|
81
86
|
|
|
82
87
|
The bricks they add:
|
|
83
88
|
|
|
84
89
|
| Brick | Does | Outcomes |
|
|
85
90
|
| --- | --- | --- |
|
|
86
|
-
| `intake` | Reads the request, the document or the issue (`gh issue view`, `glab issue view`) and writes one clear work item with testable criteria | `pass`, `fail` |
|
|
91
|
+
| `intake` | Reads the request, the document or the issue (`gh issue view`, `glab issue view`) and writes one clear work item with testable criteria, its `size` and its `areas`. `needs-info` holds for your answers to its questions (`gate: human`) | `pass`, `fail`, `needs-info` |
|
|
87
92
|
| `holdout-write` | Writes 3 to 8 prose scenarios (given / when / then) for the work item into the holdout folder, outside the worktree, and hands the work item on unchanged | `pass`, `fail` |
|
|
88
93
|
| `holdout` | Plays every scenario against the built change. `fail` carries one sentence per failed scenario, observed against expected; `error` when the diff touches the holdout folder or a scenario cannot be played | `pass`, `fail`, `error` |
|
|
94
|
+
| `checks` | Runs the done list as the base branch holds it, never the branch's copy. `error` holds when the diff touches a locked path, or on an environment failure (a failed fetch, a timeout, a missing tool); `none` holds with a proposed list when the base has none | `pass`, `fail`, `error`, `none` |
|
|
95
|
+
| `review-panel` | The `factory` skill seats a panel sized to the work item, each seat blind to how the change was built, and merges their verdicts | `pass`, `fail` |
|
|
89
96
|
| `triage` | A fork: reads the work item and reports the outcome that names its lane, with its reason. `fail` when no lane fits | `bug`, `feature`, `deps`, `refactor`, `docs`, `fail` |
|
|
90
97
|
| `pr-open` | Pushes the branch (the push asks you) and opens the PR, or updates the one already open | `pass`, `fail` |
|
|
91
|
-
| `merge-gate` | Waits for the PR's CI with a watch that returns by itself (each call under 10 minutes), 30 minutes at most. A repo with no CI reports `none`, and you decide | `pass`, `fail`, `none` |
|
|
98
|
+
| `merge-gate` | Waits for the PR's CI with a watch that returns by itself (each call under 10 minutes), 30 minutes at most. A repo with no CI reports `none`, and you decide; so does CI still pending at the bound, or a `gh`/`glab` that is missing or fails | `pass`, `fail`, `none` |
|
|
92
99
|
| `retro` | Writes the run report to `.geneseed/factory-runs/<slug>.md`, and keeps only a lasting lesson in memory | `pass` |
|
|
93
100
|
|
|
94
101
|
`analysis-to-build` also uses the loops' own `spec` brick (`gate: human`), the one the
|
|
@@ -99,6 +106,48 @@ The run report is git-ignored by the `.geneseed/.gitignore` Geneseed seeds. Wher
|
|
|
99
106
|
in the worktree, `retro` writes the report to the OS temp directory instead, so the tree stays
|
|
100
107
|
clean. The report lives in the worktree and goes when you remove it.
|
|
101
108
|
|
|
109
|
+
## Checks and the review panel
|
|
110
|
+
|
|
111
|
+
A loop proves its work with commands it can also edit. After the loop, two stages check it from
|
|
112
|
+
outside.
|
|
113
|
+
|
|
114
|
+
- **`checks` reads the done list from the base branch** (`.geneseed/done-checks.txt` there, read
|
|
115
|
+
with `git show`), never from the branch, and runs it against the branch. A red command is a
|
|
116
|
+
`fail`. A timeout, a missing tool, a failed fetch or no default branch is an **environment
|
|
117
|
+
failure**: the loop's code cannot fix it, so it never goes back to the loop. It is an `error`
|
|
118
|
+
whose finding starts `environment:`, and it holds for you: fix the environment and answer
|
|
119
|
+
`amend` to run `checks` again, or `no` to stop (`ok` goes on without the done list). The same
|
|
120
|
+
rule holds at `merge-gate`: CI still pending after 30 minutes, or `gh`/`glab` missing, is a
|
|
121
|
+
`none` that holds for you, and `amend` waits again. A command that changes a tracked file is a `fail` too
|
|
122
|
+
(a lint that fixes what it finds hides what it found). Whatever the outcome, `checks` then
|
|
123
|
+
restores every file its commands changed and deletes what they created, so the tree stays clean.
|
|
124
|
+
- **Locked paths.** Only when every command passes, `checks` lists the paths the branch changed,
|
|
125
|
+
a rename's old path included, and looks for a **locked path**: the done list,
|
|
126
|
+
`.github/workflows/`, `.gitlab-ci.yml`, `.geneseed/factories/`, `.geneseed/loops/`,
|
|
127
|
+
`.geneseed/bricks/`, plus each entry of the factory's `protected` list. A path is locked when it
|
|
128
|
+
equals an entry, or lies under an entry that ends in `/`. That `error` holds for you: `ok` lets
|
|
129
|
+
the change through and the run report names it, `no` stops. Tests are not locked; the review
|
|
130
|
+
judges a weakened test.
|
|
131
|
+
- **No done list on the base**, or one with no command. `checks` proposes one, inferred from the
|
|
132
|
+
base's manifests as the done gate infers checks, and holds; with no manifest it proposes nothing
|
|
133
|
+
and says so. On your yes, the agent commits the file in a temporary worktree on its own branch,
|
|
134
|
+
pushes that branch and opens a PR to the base branch: every factory stage pushes only its own
|
|
135
|
+
branch, never the base. You merge the PR; once the file is on the base, `ok` runs `checks`
|
|
136
|
+
again, once.
|
|
137
|
+
- **`review-panel` seats agents by the work item's size and areas.** `intake` rates the `size`
|
|
138
|
+
(`small`, `medium`, `large`) and the `areas` (`security`, `performance`, `ui`, `data`). The
|
|
139
|
+
factory's `review.seats` maps them to agents; the shipped default is `reviewer` for small, plus
|
|
140
|
+
`tester` for medium, plus `steward` for large, with `security` for security or data,
|
|
141
|
+
`performance` for performance and `user-advocate` for ui. Each seat gets only the work item,
|
|
142
|
+
the diff and the factory's rules, in its own context: never the loop's notes or the holdout
|
|
143
|
+
scenarios, and it edits nothing. A failing verdict from `reviewer`, `security` or `tester`
|
|
144
|
+
fails the stage; `performance`, `steward` and `user-advocate` advise. A seat may name only an
|
|
145
|
+
agent Geneseed ships: `geneseed factory check` refuses any other, a project's own agents
|
|
146
|
+
included.
|
|
147
|
+
|
|
148
|
+
A failed check or review sends the work back to the loop, twice at most each (cycles `checks` and
|
|
149
|
+
`review`).
|
|
150
|
+
|
|
102
151
|
## Holdout scenarios
|
|
103
152
|
|
|
104
153
|
A loop's tests are written by the same agent that writes the code, so they can share its
|
|
@@ -126,10 +175,13 @@ the `holdout` stage plays each scenario against the change as built and reports.
|
|
|
126
175
|
## In the console
|
|
127
176
|
|
|
128
177
|
The console's **Factories** page (in the Build group, after Loops) draws each factory as a
|
|
129
|
-
graph: its stages
|
|
130
|
-
route back as
|
|
131
|
-
|
|
132
|
-
|
|
178
|
+
graph: its stages top to bottom, a fork's lanes side by side, a `loop:` stage as a compact box
|
|
179
|
+
that names its loop over `whole loop`, each route back as a rail on the left with its cycle and
|
|
180
|
+
`max`, and `close` and `stop` as end caps.
|
|
181
|
+
Each factory shows how to start it: the request to give the agent, and the commands to start it
|
|
182
|
+
by hand, the worktree first and then `geneseed factory init`. Its **Active** tab lists every
|
|
183
|
+
registered run, with the current stage lit, the laps spent on each cycle and the child loop's
|
|
184
|
+
current step, written `at <node>` in the current stage's box. The page changes nothing in a run (its poll only drops finished runs older than 7 days from `factories.json`, as Loops does); you answer a run in the
|
|
133
185
|
agent's session.
|
|
134
186
|
|
|
135
187
|
## Your own factories
|
|
@@ -13,8 +13,11 @@ this way: the loop reports `{awaiting}` with `kind: "gate"` before the edge that
|
|
|
13
13
|
normally follow is taken at all — **the gate holds the whole transition**, so nothing is scored,
|
|
14
14
|
committed or counted against a ring budget while it waits.
|
|
15
15
|
|
|
16
|
-
A [factory](factories.md) stage holds the same way, answered with `geneseed factory decide
|
|
17
|
-
`
|
|
16
|
+
A [factory](factories.md) stage holds the same way, answered with `geneseed factory decide`.
|
|
17
|
+
Three shipped bricks do: `intake` (holds on `needs-info` — it has questions only you can
|
|
18
|
+
answer), `checks` (holds on `error` — the branch changed a locked path — and on `none` — the
|
|
19
|
+
base branch has no done list yet) and `merge-gate` (holds on `none` — the repo runs no CI on the
|
|
20
|
+
PR).
|
|
18
21
|
|
|
19
22
|
`geneseed loop decide --verdict ok|no|amend` answers it:
|
|
20
23
|
|
|
@@ -58,6 +58,20 @@ Each global emit, in the host's own config directory, moves that host's stores i
|
|
|
58
58
|
|
|
59
59
|
Nothing is deleted. After every copy is read back, the old `memory/` moves to `archived-memory/<stamp>/` beside it, and the notes and whole files move to the same kind of folder. The host store returns to its seed and keeps its `README.md`. Hand-written index text and `archive/` stay in that folder, and the report line names every other file that stayed there and did not fold. A store or file already linked to the tier, in either direction, is left alone. If a copy fails, the old store stays readable, the emit reports it on stderr and goes on, and the next emit retries. There is no automatic way back: to downgrade, restore the archived folder by hand.
|
|
60
60
|
|
|
61
|
+
### Retired skills
|
|
62
|
+
|
|
63
|
+
The same global emit also clears retired skills. A skill that Geneseed shipped and then removed or renamed can leave its folder in `skills/` with no manifest that owns it. Before the skill layer writes, the emit moves such a folder to `archived-skills/<name>/<timestamp>/` in the config directory and prints `[geneseed] <host>: pruned retired skill skills/<name> (moved to …)`. It moves the folder only when all of these hold:
|
|
64
|
+
|
|
65
|
+
- The name is an old alias or a retired skill id, and not a live skill.
|
|
66
|
+
- No manifest owns a path under it.
|
|
67
|
+
- The folder, the `skills/` folder, and everything inside it are real entries, not links or junctions, and the emit can read them.
|
|
68
|
+
- Its `SKILL.md` has the shape every Geneseed build wrote:
|
|
69
|
+
- `name: <folder>` on the second line;
|
|
70
|
+
- a `description:` on the third line, written as a JSON-quoted string;
|
|
71
|
+
- outside any code fence, a heading `# <label>: <id>`. The label is the `SKILL` word of a shipped theme, such as `Rite` or `Skill`. The id is the folder name, or the skill that the folder name is an alias of.
|
|
72
|
+
|
|
73
|
+
A folder that fails one check is yours. It stays, and `migrate --dry-run` lists it as an orphan. A folder the emit cannot read also stays, with a warning. A folder that passes all four checks is a `would prune` line there. A second emit finds nothing to move.
|
|
74
|
+
|
|
61
75
|
### The console
|
|
62
76
|
|
|
63
77
|
The console has one hub and no install switch. On the **Personal** page, Rules, Profile and Memory list the shared store once, tagged `shared`, and name no harness; a project install keeps its own entry. Each rule row shows its token cost, and the page shows the total. There is no rule limit. A **Pending** section shows what waits in the draft, with *Approve* and *Reject* on a rule, and the two files with three choices on a profile or wiki pointer. A decision that moves a file offers *Rebuild all*, which removes the host copy. An edit in another session makes the decision reload instead of applying, and no decision applies while a rebuild runs.
|
package/docs/extending.md
CHANGED
|
@@ -912,7 +912,7 @@ on N, and refuses (exit 1, nothing sent) when it names another port. A test inst
|
|
|
912
912
|
port is therefore stopped with `--port`, never with a bare `web stop` — that one stops whatever
|
|
913
913
|
the record names, usually the live console on 4747.
|
|
914
914
|
|
|
915
|
-
When the preferred port is taken, `clearPort` (`js/web/daemon.mjs`) asks `/api/ping` who holds it. The ping carries `rootId()`, a hash of the checkout root. A holder with our root is asked to shut down on `/api/shutdown` with `X-Geneseed-Secret`: a MAC of the port under the install secret in `.geneseed-web-secret` (32 random bytes,
|
|
915
|
+
When the preferred port is taken, `clearPort` (`js/web/daemon.mjs`) asks `/api/ping` who holds it. The ping carries `rootId()`, a hash of the checkout root. A holder with our root is asked for a nonce (`/api/ping?shutdown=1`), then asked to shut down on `/api/shutdown` with `X-Geneseed-Nonce` and `X-Geneseed-Secret`: a MAC of the port and the nonce under the install secret in `.geneseed-web-secret` (32 random bytes, created once next to the daemon record; mode 0600 on POSIX, the folder's inherited ACL on Windows). The console accepts each nonce it minted once, within 30 seconds, so a proof that an impostor collects is good nowhere later. The secret itself is never sent, and no pid is ever signalled, so a listener that only claims our root cannot cause harm. A holder of our root that answers `nonce: null` holds no secret (a foreground console, or a daemon that could not read its secret), and one that answers no `nonce` predates the handshake; both are named and left alone. Any other answer is left alone and named. A console older than the field has no root, so it is never assumed to be ours.
|
|
916
916
|
|
|
917
917
|
---
|
|
918
918
|
|
package/docs/guides/migrate.md
CHANGED
|
@@ -25,7 +25,7 @@ geneseed migrate # do it
|
|
|
25
25
|
|
|
26
26
|
**It runs only from the npm package.** From a git clone or a bundle, a real run has nothing to move: the rebuild would point the shim back at that same copy. So it refuses with exit 3 before it writes anything, and says to use `geneseed update`. An `npx` run refuses too: npm prunes that cache, and the shim would die with it. `--dry-run` works from anywhere. Outside the package it previews the fold, then says a real run would refuse.
|
|
27
27
|
|
|
28
|
-
`--dry-run` also previews [the fold](../concepts/shared-tier.md#the-fold) for each global install, even on a machine that has already migrated, because the fold runs in every global emit. Each host is read against the shared tier as it stands, so two hosts that hold the same new fact both count it.
|
|
28
|
+
`--dry-run` also previews [the fold](../concepts/shared-tier.md#the-fold) for each global install, even on a machine that has already migrated, because the fold runs in every global emit. Each host is read against the shared tier as it stands, so two hosts that hold the same new fact both count it. It also prints `would prune` for each retired skill folder that the next global emit moves aside, and `orphan` for each unowned file it leaves alone ([retired skills](../concepts/shared-tier.md#retired-skills)).
|
|
29
29
|
|
|
30
30
|
## All or nothing
|
|
31
31
|
|
|
@@ -6,7 +6,7 @@ kind: "concept"
|
|
|
6
6
|
section: "Factories"
|
|
7
7
|
description: "Carry a bug report, an issue or an analysis to an open PR with green CI: what you need, how to ask, and where it stops for you."
|
|
8
8
|
---
|
|
9
|
-
A **factory** carries one work item to an open pull request with green CI. Each stage is a brick or a whole loop, and a red CI run sends the work back to the loop, a bounded number of times. You ask in plain words. The agent drives `geneseed factory`, which decides every step.
|
|
9
|
+
A **factory** carries one work item to an open pull request with green CI. Each stage is a brick or a whole loop, and a red CI run sends the work back to the loop, a bounded number of times. You ask in plain words. The agent drives `geneseed factory`, which decides every step. No stage merges: at the end the agent asks you once whether to merge, and merges only on your yes.
|
|
10
10
|
|
|
11
11
|
This page is the how-to. For how the engine works (stages, cycles, state files), see [Factories](../concepts/factories.md).
|
|
12
12
|
|
|
@@ -27,22 +27,45 @@ geneseed factory list
|
|
|
27
27
|
geneseed factory check
|
|
28
28
|
```
|
|
29
29
|
|
|
30
|
-
## Start
|
|
30
|
+
## Start one by asking the agent
|
|
31
|
+
|
|
32
|
+
Name the factory and the work item in plain words, in a session in your repo:
|
|
31
33
|
|
|
32
34
|
```text
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
35
|
+
Run the bug-report-to-fix factory on https://github.com/acme/shop/issues/412
|
|
36
|
+
Take this bug report through bug-report-to-fix: totals round the wrong way on refunds
|
|
37
|
+
Run issue-to-pr on #42
|
|
38
|
+
Take issue 418 through the issue-to-pr factory
|
|
39
|
+
Take this analysis through analysis-to-build: docs/analysis/export-csv.md
|
|
40
|
+
Run the analysis-to-build factory on this request: add CSV export to the report page
|
|
36
41
|
```
|
|
37
42
|
|
|
43
|
+
On Claude Code, `/factory` with the same words is the explicit form: it loads the `factory`
|
|
44
|
+
skill directly. The console's **Factories** page shows the request for each factory, ready to copy.
|
|
45
|
+
|
|
38
46
|
The agent then:
|
|
39
47
|
|
|
40
|
-
1. Creates a worktree on a new branch, `git worktree add ../<repo>-factory-<slug> -b loop/factory-<slug>`, and works from there. Your own checkout is not touched.
|
|
48
|
+
1. Creates a worktree on a new branch, `git worktree add ../<repo>-factory-<slug> -b loop/factory-<slug>`, and works from there. Your own checkout is not touched. The slug never holds the word `git`, `commit` or `push`: `factory init` refuses it.
|
|
41
49
|
2. Runs `geneseed factory init --title … --requirement … --factory bug-report-to-fix --input <issue or text>`. This writes `FACTORY.md` at the worktree root and registers the run.
|
|
42
|
-
3. Steps the run: `intake` writes the work item, `holdout-write` writes the holdout scenarios outside the worktree, the `bugfix` loop fixes it commit by commit, `holdout` plays the scenarios against the fix, `pr-open` opens the PR, `merge-gate` waits for CI, and `retro` writes the run report. In `issue-to-pr`, a `triage` stage comes after `holdout-write` and picks the lane: the `bugfix`, `feature`, `deps-upgrade` or `refactor` loop, or the `docs-update` brick for a docs-only change. A failed scenario or red CI then sends the work back to that lane.
|
|
50
|
+
3. Steps the run: `intake` writes the work item, `holdout-write` writes the holdout scenarios outside the worktree, the `bugfix` loop fixes it commit by commit, `checks` runs the base branch's done list against the fix, `review-panel` has a panel of agents review it, `holdout` plays the scenarios against the fix, `pr-open` opens the PR, `merge-gate` waits for CI, and `retro` writes the run report. In `issue-to-pr`, a `triage` stage comes after `holdout-write` and picks the lane: the `bugfix`, `feature`, `deps-upgrade` or `refactor` loop, or the `docs-update` brick for a docs-only change. A failed check, review or scenario, or red CI, then sends the work back to that lane.
|
|
43
51
|
|
|
44
52
|
The holdout scenarios are checks the developer never sees: see [Holdout scenarios](../concepts/factories.md#holdout-scenarios). You can read them yourself in `~/.config/geneseed/holdout/<slug>/`; never paste them into the chat while the run is going, or the developer may see them.
|
|
45
53
|
|
|
54
|
+
## Start one by hand
|
|
55
|
+
|
|
56
|
+
Create the worktree first, then register the run in it. Never run `init` in your own checkout:
|
|
57
|
+
the run then works on your current branch. Keep the three commands as one `&&` chain and
|
|
58
|
+
replace every placeholder: if one command fails, the next ones do not run. Pick a slug without the
|
|
59
|
+
word `git`, `commit` or `push`: `factory init` refuses it.
|
|
60
|
+
|
|
61
|
+
```bash
|
|
62
|
+
git worktree add ../<repo>-factory-<slug> -b loop/factory-<slug> && cd ../<repo>-factory-<slug> && geneseed factory init --factory <name> --title "<title>" --requirement "<requirement>" --input "<issue URL, file path or pasted text>"
|
|
63
|
+
```
|
|
64
|
+
|
|
65
|
+
`init` alone runs nothing. It writes `FACTORY.md` and registers the run. An agent drives the run
|
|
66
|
+
from there with `geneseed factory next` and `geneseed factory record`: open a session in the
|
|
67
|
+
worktree and ask it to resume the run.
|
|
68
|
+
|
|
46
69
|
## Build from an analysis
|
|
47
70
|
|
|
48
71
|
`analysis-to-build` takes a larger piece of work: a design document, an analysis pasted into the
|
|
@@ -60,8 +83,8 @@ run the analysis-to-build factory on docs/analysis/export-csv.md
|
|
|
60
83
|
3. After your `ok`, the agent commits the spec (the commit asks you), `holdout-write` writes the
|
|
61
84
|
holdout scenarios from it, and the agent runs the `feature` loop once per task, in order.
|
|
62
85
|
`geneseed factory next` names each one as `task <i>/<n>`.
|
|
63
|
-
4. After the last task, `
|
|
64
|
-
and `merge-gate` waits for CI.
|
|
86
|
+
4. After the last task, `checks` and `review-panel` run once, `holdout` plays the scenarios,
|
|
87
|
+
`pr-open` opens one PR for all of them, and `merge-gate` waits for CI.
|
|
65
88
|
5. A failed scenario sends the work back to the `feature` loop as one extra task, with one
|
|
66
89
|
sentence per failure (observed against expected) as its first note. Red CI does the same, with
|
|
67
90
|
the failing checks as the note: "make CI green". Each is twice at most; a third failure stops
|
|
@@ -71,17 +94,22 @@ run the analysis-to-build factory on docs/analysis/export-csv.md
|
|
|
71
94
|
|
|
72
95
|
| Moment | What you decide |
|
|
73
96
|
| --- | --- |
|
|
97
|
+
| `intake` reports `needs-info` | The work item leaves a question only you can answer. The agent shows its numbered questions, each with the assumption it would make. Answer them (`amend`, three times at most), say `ok` to go on with the assumptions, or `no` to stop. |
|
|
98
|
+
| `checks` reports `error` | Every check passed, but the branch changed a locked path: the done list, CI config, or a factory, loop or brick. `ok` lets it through (the run report names it), `no` stops. Or the finding starts `environment:`: the fetch failed, no default branch was found, or a check timed out or its tool is missing. The loop cannot fix that: fix the environment and answer `amend` to run the checks again, or `no` to stop; `ok` goes on without them. |
|
|
99
|
+
| `checks` reports `none` | The base branch has no done list, or an empty one. The agent shows the one it proposes (or says no manifest gave one). On your yes it commits the file in a temporary worktree on its own branch, `geneseed/done-list-<slug>`, pushes that branch and opens a PR to the base branch (each step asks). You merge that PR. Once the file is on the base, `ok` runs the checks again. |
|
|
74
100
|
| The `spec` gate (`analysis-to-build`) | The task list: `ok` starts the first task, `amend` revises the spec, `no` stops the run. The spec commit after your `ok` asks too. |
|
|
75
101
|
| A push | Every push that is not a loop's own commit asks you, `pr-open`'s included. |
|
|
76
102
|
| A loop gate | Anything the `bugfix` loop asks you, as in [While a loop runs](loop-running.md). |
|
|
77
|
-
| `merge-gate` reports `none` | The repo runs no CI on the PR: `ok` goes on to `retro`, `no` stops the run. |
|
|
78
|
-
|
|
|
103
|
+
| `merge-gate` reports `none` | The repo runs no CI on the PR: `ok` goes on to `retro`, `no` stops the run. Or the finding starts `environment:`: CI was still pending after 30 minutes, or `gh`/`glab` is missing or failed. `amend` waits again (after you fix the tool), `ok` goes on to `retro` without a green verdict (the close step reads CI once more, and proposes the merge only when it is green), `no` stops. |
|
|
104
|
+
| A `geneseed factory record` line asks | The git gate asks on any command line that holds the word `git` and the word `commit` or `push`. A record line starts with `git status`, so a spec path, a finding's path or an outcome name with `commit` or `push` in it makes the gate ask. On a record line this is a false alarm: answer yes. |
|
|
105
|
+
| The close commit | The last commit removes `FACTORY.md`, and it asks. Its push runs CI again: the agent reads the checks once more and reports the final state. A run with no loop (the `docs` lane) never committed `FACTORY.md`: the agent deletes the file, there is no close commit, and the final state is the one `merge-gate` read. |
|
|
106
|
+
| The merge proposal | Only when that final CI state is green: the agent shows the PR, the CI state and each review seat's verdict, and asks once whether to merge. Only on your explicit yes in chat does it squash-merge (`gh pr merge --squash`); no Geneseed gate asks before that command, so your answer is the only guard. Otherwise the PR stays open. It never turns on auto-merge. |
|
|
79
107
|
|
|
80
|
-
Red CI does not stop for you: it sends the work back to the run's loop (`bugfix`, or the lane `triage` chose) with the failing checks as its first note, twice at most. A third red result stops the run. A failed holdout scenario works the same way, with its own count of two
|
|
108
|
+
Red CI does not stop for you: it sends the work back to the run's loop (`bugfix`, or the lane `triage` chose) with the failing checks as its first note, twice at most. A third red result stops the run. A failed holdout scenario works the same way, with its own count of two, and so do a failed `checks` and a failed `review-panel`. A holdout `error` stops the run: the diff touched the holdout folder, or a scenario could not be played.
|
|
81
109
|
|
|
82
110
|
## When it ends
|
|
83
111
|
|
|
84
|
-
On success the agent reports the PR, every stage with its outcome, each rework and why, and the run report at `.geneseed/factory-runs/<slug>.md`. On a stop it reports the reason and still writes the run report; the branch and `FACTORY.md` stay as they were, so you can see where it stopped. After a crash, ask the agent to resume: it runs `geneseed factory next` in the worktree.
|
|
112
|
+
On success the agent reports the PR (merged on your yes, or open), every stage with its outcome, each rework and why, and the run report at `.geneseed/factory-runs/<slug>.md`. On a stop it reports the reason and still writes the run report; the branch and `FACTORY.md` stay as they were, so you can see where it stopped. After a crash, ask the agent to resume: it runs `geneseed factory next` in the worktree.
|
|
85
113
|
|
|
86
114
|
---
|
|
87
115
|
|
|
@@ -43,9 +43,9 @@ It writes nothing. It prints one line for each global install, read against the
|
|
|
43
43
|
|
|
44
44
|
**Use only the `--dry-run` form here.** The `would re-emit` lines are the plan of `geneseed migrate` itself, which moves a clone install to [the npm shape](migrate.md). That is not a 5.0 step. From a clone those lines do not appear: the preview ends by saying a real run would refuse, and a real `migrate` there exits 3 and changes nothing.
|
|
45
45
|
|
|
46
|
-
It also lists
|
|
46
|
+
It also lists the folders of retired skills that no manifest owns. A `would prune` line names a folder that a Geneseed build rendered and that no longer ships. The next global emit moves it to `<config dir>/archived-skills/<name>/<timestamp>/`. An `orphan` line names a root `AGENT.md`, or a retired skill folder that is a link, holds a link, or does not look like a Geneseed render. Such a folder may be yours. Geneseed never moves it, so move it by hand if it is not.
|
|
47
47
|
|
|
48
|
-
**In the console.** With no terminal, there is no preview before the first fold: *Update* on a clone pulls and rebuilds in one job, so the fold runs in that click, and a 4.x console has no preview. Nothing is deleted, as step 3 shows. After that, *Preview next rebuild* on the Installs page, beside *Rebuild all*, shows the same fold lines and orphans for any later rebuild, without the `would re-emit` lines, and writes nothing.
|
|
48
|
+
**In the console.** With no terminal, there is no preview before the first fold: *Update* on a clone pulls and rebuilds in one job, so the fold runs in that click, and a 4.x console has no preview. Nothing is deleted, as step 3 shows. After that, *Preview next rebuild* on the Installs page, beside *Rebuild all*, shows the same fold lines and orphans for any later rebuild (not yet the `would prune` folders), without the `would re-emit` lines, and writes nothing.
|
|
49
49
|
|
|
50
50
|
## 3. Upgrade
|
|
51
51
|
|
|
@@ -6,17 +6,17 @@ kind: "concept"
|
|
|
6
6
|
section: "CLI & environment"
|
|
7
7
|
description: "The geneseed factory actions, one line each."
|
|
8
8
|
---
|
|
9
|
-
The actions of `geneseed factory`, the state machine that carries one work item through a graph of stages to an open PR. A stage is a brick or a whole loop (`loop:<template>`). A **fork** is a brick that declares a named outcome (one other than `pass`, `fail`, `error` or `
|
|
9
|
+
The actions of `geneseed factory`, the state machine that carries one work item through a graph of stages to an open PR. A stage is a brick or a whole loop (`loop:<template>`). A **fork** is a brick that declares a named outcome (one other than `pass`, `fail`, `error`, `none` or `needs-info`), each outcome with its own edge to its own lane. An edge target or a cycle node may be `$lane`: the stage the run's most recent fork chose. The run state lives in `FACTORY.md` at the worktree root, beside the child loop's `LOOP.md` ([Loop actions](loop-actions.md)). Each action prints one JSON object and exits 1 on a refusal.
|
|
10
10
|
|
|
11
11
|
| action | what it does |
|
|
12
12
|
|---|---|
|
|
13
|
-
| `check` | checks every factory in the catalogue, or one factory (`--factory <name or .json file>`): the factory has a name and no stage twice, every stage exists, every outcome has one edge, `$close` is reachable, every cycle is declared with a `max` from 1 to 5, each cycle is entered only at its first stage, and every route back targets the first stage of a cycle that holds its source. `$lane` needs a fork on every path to it, and a fork's own edge never targets it. In those checks, `$lane` stands for every lane of every fork. A factory that still uses the retired `loop:$triaged` stage or `loops` list gets a problem that names the replacement; nothing rewrites the file |
|
|
13
|
+
| `check` | checks every factory in the catalogue, or one factory (`--factory <name or .json file>`): the factory has a name and no stage twice, every stage exists, every outcome has one edge (`error` and `needs-info` may go without one: `error` then stops the run, and `needs-info` follows the stage's `pass` edge), `$close` is reachable, every cycle is declared with a `max` from 1 to 5, each cycle is entered only at its first stage, and every route back targets the first stage of a cycle that holds its source. `$lane` needs a fork on every path to it, and a fork's own edge never targets it. In those checks, `$lane` stands for every lane of every fork. A factory that still uses the retired `loop:$triaged` stage or `loops` list gets a problem that names the replacement; nothing rewrites the file. An optional `protected` must be a list of non-empty paths. An outcome on which a brick reports environment failures (`checks` `error`, `merge-gate` `none`) never routes to a `loop:` stage or `$lane`: no loop can fix a failed fetch, a missing tool or CI pending at the bound. An optional `review.seats` needs a non-empty list of agents for each of `small`, `medium` and `large`, and `areas`, when present, maps each area to such a list; every seat must name a shipped agent (`review.seats.medium: no agent named <name>`). A project factory overrides a global or shipped one of the same name, and a global one a shipped one: `check` lists each in `overridden`. A file that does not load is a problem that names its level (`factories/<name>.json (project): not JSON`), and it drops the factory of that name from lower levels, so `init` refuses with that problem instead of running another graph |
|
|
14
14
|
| `list` | lists the factories of the three origins (shipped, global, project), with description, category and origin |
|
|
15
|
-
| `init` | writes a fresh `FACTORY.md` from a factory, under a title, a requirement and an optional `--input` (an issue URL, a file path or pasted text). A factory that fails `check` is refused before any stage runs. Each `init` also registers the run in `factories.json`, beside the loop registry |
|
|
16
|
-
| `next` | returns the next thing to do: run a brick stage, run a loop (with `notes` to start it with, and the `task` when a spec set tasks: the spec's `path`, the task `count` and this task's `index`), answer an `awaiting` gate, or a terminal. A fork stage also gets `lanes`: each outcome it may report, with the stage it leads to. Refused while a `LOOP.md` exists that is not `done` or `stopped` (an unreadable one counts as running): the child loop finishes first. On a loop stage, refused while any `LOOP.md` is left: `git rm -f LOOP.md` and commit that removal before `geneseed loop init`. On a loop stage, `next` also records the launch in `FACTORY.md`: the loop template, the HEAD commit and the time. When a later stage routes back to the loop stage that ran the tasks, after its last task passed (
|
|
17
|
-
| `record` | records the current stage's outcome and follows its edge. A loop stage reports `pass` (its loop closed) or `fail` (it stopped), and only after `next` launched it. While its `LOOP.md` is still there, that file must name the stage's template, a `stopped` one admits only `fail`, and a `done` one only `pass`. With no `LOOP.md` left, `pass` and `fail` both need a HEAD that moved since `next`: the loop's close commit, or the commit that removes a stopped loop's `LOOP.md`. That is enough for `fail`. `pass` also needs the loop registry to show a `geneseed loop init` in this worktree after `next`. Without it, `pass` is refused: record it while the `done` `LOOP.md` is still at the root, or report `fail`. The registry does not keep a loop's final status, so a stopped loop whose `LOOP.md` was removed by hand can still pass. `--carry` hands a reason to the next stage; a re-entered loop starts with it as a note. On a fork, the outcome names the lane: the stage its edge reaches is stored as the run's `lane`, and an edge to `$lane` goes there. A route to `$lane` with no lane on record is refused. `--spec <path>` records
|
|
18
|
-
| `decide` | answers a held `gate: human` stage: `ok` follows the edge (an edge to `$lane` goes to the lane on record), `no` stops, `amend` re-runs the stage with the `--note` as its carry (three times at most) |
|
|
15
|
+
| `init` | writes a fresh `FACTORY.md` from a factory, under a title, a requirement and an optional `--input` (an issue URL, a file path or pasted text). A factory that fails `check` is refused before any stage runs, and so is a run branch `loop/factory-<slug>` whose slug holds the word `git`, `commit` or `push`: the slug lands on lines the git gate reads. Each `init` also registers the run in `factories.json`, beside the loop registry |
|
|
16
|
+
| `next` | returns the next thing to do: run a brick stage, run a loop (with `notes` to start it with, and the `task` when a spec set tasks: the spec's `path`, the task `count` and this task's `index`), answer an `awaiting` gate, or a terminal. A fork stage also gets `lanes`: each outcome it may report, with the stage it leads to. Every stage gets the factory's `rules`, and its `protected` paths when it declares any. Refused while a `LOOP.md` exists that is not `done` or `stopped` (an unreadable one counts as running): the child loop finishes first. On a loop stage, refused while any `LOOP.md` is left: `git rm -f LOOP.md` and commit that removal before `geneseed loop init`. On a loop stage, `next` also records the launch in `FACTORY.md`: the loop template, the HEAD commit and the time. When a later stage routes back to the loop stage that ran the tasks, after its last task passed (a failed `checks`, `review-panel` or `holdout`, or red CI at `merge-gate`), `next` hands out one extra task: the last `index` again, with `extra` set to the stage and outcome that sent it back (`"merge-gate reported fail"`). That lap spends the route's cycle and the transition ceilings like any other, and gives no fresh budget |
|
|
17
|
+
| `record` | records the current stage's outcome and follows its edge. A loop stage reports `pass` (its loop closed) or `fail` (it stopped), and only after `next` launched it. While its `LOOP.md` is still there, that file must name the stage's template, a `stopped` one admits only `fail`, and a `done` one only `pass`. With no `LOOP.md` left, `pass` and `fail` both need a HEAD that moved since `next`: the loop's close commit, or the commit that removes a stopped loop's `LOOP.md`. That is enough for `fail`. `pass` also needs the loop registry to show a `geneseed loop init` in this worktree after `next`. Without it, `pass` is refused: record it while the `done` `LOOP.md` is still at the root, or report `fail`. The registry does not keep a loop's final status, so a stopped loop whose `LOOP.md` was removed by hand can still pass. `--carry` hands a reason to the next stage; a re-entered loop starts with it as a note. `--carry-file <file>` reads it from a file instead (CRLF folded, trimmed), for free text, which never goes on the command line: the skill writes it with the host's file tool, never the shell, to a file it names uniquely. Every path argument (`--spec`, `--factory <file>`, `--carry-file`, `--note-file`) is relative to the current directory; only `FACTORY.md` is found at the git root. On a fork, the outcome names the lane: the stage its edge reaches is stored as the run's `lane`, and an edge to `$lane` goes there. A route to `$lane` with no lane on record is refused. `--spec <path>` records the run's spec, which must be at `specs/<slug>/spec.md` (any other path is refused before the state changes): the first loop stage recorded after it runs once per numbered item (`1.` or `1)`, indented 3 spaces at most) under its first heading that contains the word `task` or `tasks`, up to the next heading of the same or a higher level (`#`, indented 3 spaces at most, or a setext heading), 20 at most. As in CommonMark, a numbered item indented as far as the text of the task above it is a sub-item, and a fenced block (```` ``` ```` or `~~~`) is skipped whole. Until the first task loop launches (the first loop after a spec is on record; a loop that ran before any spec does not count), each `--spec` sets the count again, so a spec amended at its gate may list more tasks. From that launch the count is frozen: a later `--spec` may keep or lower it, never raise it. After a stage outside a loop, pipe it `git status --porcelain --untracked-files=all` in one command: `git status --porcelain --untracked-files=all | geneseed factory record …`. PowerShell pipes the same way; the CRLF that Windows PowerShell 5.1 adds, and the leading BOM it adds when `$OutputEncoding` is UTF-8, are stripped. The git gate asks on any line that holds the word `git` and the word `commit` or `push`, so a record line whose spec path, carry path or outcome holds `commit` or `push` asks: a false alarm the user can answer yes to. `init` refuses a slug with those words, which removes the commonest case. Plain `--porcelain` shows a new directory as one line (`?? specs/`), so a new spec is refused. The tree must be clean (a `mutate` brick such as a `docs-update` lane commits its change first), with two exceptions: engine files, and the run's spec at `specs/<slug>/spec.md` (the one recorded now, else the one on record). No stdin at all (a terminal) is refused. An empty pipe reads as a clean tree. Refused, as `next` is, while a child loop owns the worktree. Every state action also refuses a `FACTORY.md` that does not parse, or one that holds any of these: counters that are not non-negative integers, a run-wide ceiling above 1200, a gate amend count above 3, a `lane` that no fork of the factory leads to, a current stage, task-owning stage, launched loop or held gate that the factory does not hold, an `awaiting` that does not match the status, an unknown status, a `history` or `cycles` that is not a list, or a factory that no longer passes `check` |
|
|
18
|
+
| `decide` | answers a held `gate: human` stage: `ok` follows the edge (an edge to `$lane` goes to the lane on record), `no` stops, `amend` re-runs the stage with the `--note` as its carry (three times at most). `--note-file <file>` reads the note from a file instead, as `--carry-file` does |
|
|
19
19
|
|
|
20
|
-
A route back into a cycle spends the cycle whose first stage is the route's target; past its `max` the run stops. A run stops too after
|
|
20
|
+
A route back into a cycle spends the cycle whose first stage is the route's target; past its `max` the run stops. A run stops too after 60 stage transitions, counted again for each spec task the run reaches for the first time, and after 60 transitions per task of the spec (60 without a spec) over the whole run. That run-wide ceiling follows the spec's task count until the first task loop launches (the first spec sets it even after an earlier loop), and never changes after.
|
|
21
21
|
|
|
22
22
|
Run `geneseed factory --help` for the full flag list.
|
package/docs/web-ui.md
CHANGED
|
@@ -31,6 +31,11 @@ always get the command list.
|
|
|
31
31
|
- **Daemon.** `start` runs the server detached and returns your shell; it's a singleton
|
|
32
32
|
(already running ⇒ just reopens the browser). `stop` and the in-page **Stop** button
|
|
33
33
|
both POST a token-guarded `/api/shutdown`; `status` reports the running instance.
|
|
34
|
+
When the port is held by an unrecorded console of this install, `start` ends it by challenge
|
|
35
|
+
and response: the console hands out a single-use nonce that expires after 30 seconds, and
|
|
36
|
+
`start` answers with a MAC of the port and that nonce under the install secret. A foreground
|
|
37
|
+
`geneseed web` holds no secret, and a console from before this handshake checks no nonce; `start`
|
|
38
|
+
names either one and leaves it running.
|
|
34
39
|
- **Installable (PWA).** A manifest + service worker make it installable as a standalone
|
|
35
40
|
app; immutable assets are cached, while HTML and `/api/*` stay on the network so the
|
|
36
41
|
CSRF token never goes stale.
|
|
@@ -351,8 +356,11 @@ screen the run list stacks above the detail.
|
|
|
351
356
|
in the Loops page's three panes with two sections. **Templates** are grouped by origin; the
|
|
352
357
|
reader draws the selected factory as a vertical graph (`web/src/lib/factoryFlow.js`): each
|
|
353
358
|
stage on the row of its longest path from `start`, top to bottom, joined by lines; a brick a
|
|
354
|
-
grey block, a fork amber, a `loop:` stage
|
|
355
|
-
|
|
359
|
+
grey block, a fork amber, a `loop:` stage a teal box that names its loop (without `loop:`)
|
|
360
|
+
over `whole loop`, or `not in catalogue` when this install lacks it; the ring itself is on the
|
|
361
|
+
Loops page. A fork is what the engine calls one: a brick that declares a named outcome
|
|
362
|
+
(one outside `pass`, `fail`, `error`, `none` and `needs-info`), never a `loop:` stage, however
|
|
363
|
+
many stages its edges reach. The targets of a fork share a row, side by side, each lane labelled with its outcome,
|
|
356
364
|
and join again at the first stage every lane reaches. Each route back (an edge into a cycle's
|
|
357
365
|
first stage, the edge that spends a lap, `$lane` included) is a rail on the left labelled
|
|
358
366
|
`↺ <cycle> · max N`, the smallest cycle that holds it; every stop edge on the main path runs
|
|
@@ -362,15 +370,19 @@ screen the run list stacks above the detail.
|
|
|
362
370
|
first; when the rails do not fit, they become tags under the stage they leave, and the lanes
|
|
363
371
|
shrink to compact boxes (named without `loop:`). Only when even those do not fit (below about
|
|
364
372
|
524 px for five lanes) do the lanes stack as a list. Under it: a legend, the cycles in
|
|
365
|
-
words,
|
|
373
|
+
words, two ways to start a run, each with a Copy button — the request to paste to the agent
|
|
374
|
+
(`Run the <factory> factory on <issue URL, file or request>`), then the by-hand command, one
|
|
375
|
+
`&&` chain that adds a worktree, enters it and runs `geneseed factory init` there — and the
|
|
366
376
|
factory's rules. It reads `GET /api/factories/catalog` for the install the *Install:* picker
|
|
367
377
|
names. **Active** is every run `geneseed factory init` registered on this machine
|
|
368
378
|
(`GET /api/factories/active`, polled every 5 s, the graph read from each run's `FACTORY.md`),
|
|
369
379
|
grouped as Loops › Active is; the reader shows the run's stage, transitions, task number, its
|
|
370
380
|
child loop's step and iteration, what it awaits, and its graph with the current stage lit,
|
|
371
|
-
the lane its last fork took (the run's `lane`, else read from its `history`) lit, the child
|
|
372
|
-
the stage
|
|
373
|
-
|
|
381
|
+
the lane its last fork took (the run's `lane`, else read from its `history`) lit, the child
|
|
382
|
+
loop's node named under the current stage (`at <node>`) and each cycle's laps as `n / max`. A
|
|
383
|
+
run carries its graph but no bricks or loops: the graph borrows those from the catalogue of the
|
|
384
|
+
install the Templates tab's picker names, which the run's project may not share, and the reader
|
|
385
|
+
says which. No run reports tab: a run's report lives in its own worktree.
|
|
374
386
|
- **Profile** (`#/profile`) — `PROFILE.md`: who you are and how you like to work, one card
|
|
375
387
|
per file: the shared one every global install reads, tagged `shared`, and each project
|
|
376
388
|
install's own. Opens rendered; **Edit** is a whole-file editor. The save carries
|
package/harness.config.json
CHANGED
|
@@ -2,5 +2,5 @@
|
|
|
2
2
|
"_comment": "version is a human-readable release label only; the canonical identity of an installed harness is the source fingerprint stamped in .geneseed-version (see `harness version`), not this string.",
|
|
3
3
|
"theme": "neutral",
|
|
4
4
|
"product": "Geneseed",
|
|
5
|
-
"version": "5.
|
|
5
|
+
"version": "5.1.1"
|
|
6
6
|
}
|