geneseed 4.15.1 → 4.17.0

package/CHANGELOG.md

@@ -8,6 +8,40 @@ label. For the capability ↔ spec map, see [SHIPPED.md](SHIPPED.md).
 
 ## [Unreleased]
 
+## [4.17.0] — 2026-10-23
+
+Minor: doctrine comms 5 Mark the Ask; a version bump on main now releases itself; two Bob fixes.
+
+### Upgrade notes
+- Run `geneseed rebuild-all`; nothing changes on a machine until something re-emits.
+
+### Added
+- **Doctrine comms 5, Mark the Ask.** When a reply stops and waits on the user (a question, a choice, an approval, a blocker), the agent marks the ask so a reader who skims finds it first: one leading emoji marker for its kind (`❓` question, `👉` act to do, `⚠️` risk or blocker, `✅` done, waits on sign-off), placed before the reference code (`❓ **Q3** — keep the v1 route?`), arrows (`→`) for options and flows with the recommended option first, and one ask per block. Colour is used only where the host renders it, never as raw ANSI in plain text. Routine output stays plain, and the prose around a marker keeps Simplified Technical English. It is in the toggleable comms pack, not a law, per DESIGN.md Decision 7: `--exclude-rules "comms 5"` turns it off. The carrier ceilings rise by 1 114 characters (full) and 512 (lean). Run `geneseed rebuild-all` to get it.
+
+### Changed
+- **The version bump is the release.** `publish.yml` now also runs when CI finishes green on a push to `main`. If the version in `harness.config.json` is not on npm yet, it re-runs its gates against the commit CI tested, publishes it, and creates the `v<version>` tag and the GitHub release from that version's CHANGELOG section; otherwise it stops after one cheap check. A PR's CI run, a red one or a fork's never publishes. The manual dispatch stays, still a dry run by default.
+
+### Fixed
+- Bob: a gate block no longer promises a confirmation Bob cannot give. Bob has no ask tier, so "Confirm this specific command" sent the model round the gate (a retry with `-Confirm:$false`, then `git clean`) and finally to "disable the Geneseed hook". Every Bob block now says that nothing in the chat lifts it, and that the user can act outside Bob. Claude's wording is unchanged.
+- Bob: read-only agents now stay read-only. Bob ignores Claude's `disallowedTools`, so every reviewer, explorer and council seat got Bob's default `read, edit, execute`. The Bob emit now writes Bob's own `groups:` key (`read`, plus `execute` for an agent that opts into bash). An `agent-overrides.json` value is not applied on Bob and a warning says so: Bob drops an agent that carries `model:`. Run `geneseed rebuild-all`.
+
+## [4.16.0] — 2026-10-23
+
+Minor: foreman mode now really delegates, and the web console updates and rebuilds a clone without a manual restart.
+
+### Upgrade notes
+- Run `geneseed rebuild-all`; nothing changes on a machine until something re-emits. The precedence table changes in every install, not only in foreman ones.
+
+### Changed
+- Foreman mode: the mode now binds how work runs. It has its own row in the precedence table; `PROFILE.md`, posture and theme still only inform.
+- Foreman triage is a count, not a judgement: a task is substantial when it changes 2 or more files, needs a new or changed test, needs about 5 reads before the first edit, or asks for a feature, a fix, a review, an audit or an investigation. When unsure, the session delegates.
+- Pipelines: the parent session dispatches one background crew lead and goes back to the user. The crew lead picks the crew from the whole agent roster (the floor is only the minimum) and runs the relay. `pipeline` now has a per-host table; on a host where the crew lead cannot start subagents, it plays each role in turn.
+
+### Fixed
+- Web console: a git clone always gets the **Update** button, also when the npm release check gets no answer.
+- Web console: a rebuild on a console running old code (after a manual `git pull`) now restarts it and reloads the page.
+- Docs: the pipeline loop limit is 2 repair rounds, then one fresh developer, not "five rounds".
+
 ## [4.15.1] — 2026-10-23
 
 Patch: two host fixes. The first npm release since 4.14.0, so it also carries 4.15.0's comms 4 doctrine.

package/README.md

@@ -13,7 +13,7 @@
 [![Themes](https://img.shields.io/badge/themes-14-9cf)](themes/)
 [![Skills](https://img.shields.io/badge/skills-47-blueviolet)](src/skills/)
 [![Agents](https://img.shields.io/badge/agents-20-orange)](src/agents/)
-[![Laws and doctrines](https://img.shields.io/badge/laws-9%20%2B%2030%20doctrines-critical)](src/doctrines/)
+[![Laws and doctrines](https://img.shields.io/badge/laws-9%20%2B%2031%20doctrines-critical)](src/doctrines/)
 [![Plugins](https://img.shields.io/badge/plugins-7-teal)](adapters/opencode/plugins/)
 [![OpenCode · Claude Code · Bob · OpenClaude · AGENT.md](https://img.shields.io/badge/works%20with-OpenCode%20·%20Claude%20Code%20·%20Bob%20·%20OpenClaude%20·%20AGENT.md-1f6feb)](#-supported-harnesses)
 
@@ -294,7 +294,7 @@ Geneseed/
 │                         Docs pages; maintainer notes beside them (extending, design-history…);
 │                         specs/, reviews/, superpowers/ are local working docs — git-ignored
 ├── adapters/             per-host glue (opencode/, claude-code/, bob/, openclaude/)
-└── .github/workflows/    ci.yml (doctor + tests) · publish.yml (npm, OIDC, manual only)
+└── .github/workflows/    ci.yml (doctor + tests) · publish.yml (npm, OIDC, on a version bump)
 ```
 
 ## 🧪 Validate & test
@@ -304,7 +304,7 @@ node bin/geneseed-cli.mjs doctor      # every theme + parity + authoring + drift
 node --test --test-reporter=tap "tests/**/*.test.mjs"   # the suites (node expands the glob)
 ```
 
-`doctor` checks each theme for unresolved tokens, dead/non-hermetic links, theme-key parity, author-time gates (every spec has a purpose line, the plugins parse, the learn-prompt literal stays extractable), and that a committed bundle still matches a fresh render of `src/`. CI (`.github/workflows/ci.yml`) runs both on every push and PR, on both Linux and Windows. Publishing is a separate, manually-triggered workflow (`.github/workflows/publish.yml`) — see [Contributing](#-contributing).
+`doctor` checks each theme for unresolved tokens, dead/non-hermetic links, theme-key parity, author-time gates (every spec has a purpose line, the plugins parse, the learn-prompt literal stays extractable), and that a committed bundle still matches a fresh render of `src/`. CI (`.github/workflows/ci.yml`) runs both on every push and PR, on both Linux and Windows. Publishing is a separate workflow (`.github/workflows/publish.yml`) that runs when CI finishes green on `main` and releases only a version npm does not have yet — see [Contributing](#-contributing).
 
 ### AI Harness Scorecard
 
@@ -365,7 +365,7 @@ Three things that bite when you don't know them:
 
 - **`js/cli-table.json` IS the CLI.** The argument parser is data, and that file is the owned document — not a generated one. `bin/geneseed-cli.mjs` cannot parse a single verb without it, `bin/geneseed-hook.mjs` renders `--help` from it, and the console's `cli` docs page is a filtered view of it. What holds it honest is `tests/unit/cli_table.test.mjs` — change a flag here and that suite is what tells you.
 - **The version has one owner: `harness.config.json`.** `package.json` mirrors it and a test fails the fork. Never `npm version` — it edits one of the two.
-- **Publishing is deliberate and manual.** `.github/workflows/publish.yml` uses npm trusted publishing (OIDC); there is no `NPM_TOKEN` in this repository and there must not be one. It runs only from Actions → publish → Run workflow, and the npm-side trusted publisher is keyed on that workflow's **filename** — renaming the file breaks publishing with no local symptom, which is why the file names itself in its own header and a test asserts the two agree.
+- **The version bump is the release.** `.github/workflows/publish.yml` uses npm trusted publishing (OIDC); there is no `NPM_TOKEN` in this repository and there must not be one. When CI finishes green on a push to `main` and the version in `harness.config.json` is not on npm yet, it publishes that version, then creates the `v<version>` tag and the GitHub release from the CHANGELOG. Actions → publish → Run workflow still works by hand (a dry run by default), and the npm-side trusted publisher is keyed on that workflow's **filename** — renaming the file breaks publishing with no local symptom, which is why the file names itself in its own header and a test asserts the two agree.
 
 ## 🙏 Credits
 

package/SHIPPED.md

@@ -20,7 +20,7 @@ historical references, not files distributed with the repo.
 > **On version numbers.** [`harness.config.json`](harness.config.json)'s `version` is a
 > human-readable label only. The canonical identity of an installed harness is the
 > **source fingerprint** stamped in `.geneseed-version` (see `geneseed version`), not the
-> string. Current label: **4.15.1**.
+> string. Current label: **4.17.0**.
 
 ## Capabilities
 

package/adapters/bob/README.md

@@ -20,8 +20,11 @@ limitation to be aware of on a shared repo.
   preamble as a delimited **managed block** (your prose around it survives a
   re-emit; the block is replaced, never stacked).
 - **`.bob/`** layer:
-  - `agents/<name>.md` — the **Claude subagent dialect** verbatim (`name` +
-    `description` + a `disallowedTools:` denylist for read-only agents).
+  - `agents/<name>.md` — **Bob's agent dialect**: `name` + `description`, and for a
+    read-only agent a `groups:` list of `read` (plus `execute` when the spec opts into
+    bash). An editing agent states no groups and keeps Bob's default `read, edit, execute`.
+    Bob ignores Claude's `disallowedTools`, and an `agent-overrides.json` value is not
+    applied (Bob refuses a `model:` key).
   - `skills/<name>/SKILL.md` — **byte-identical** to every other host; skills
     are model-invoked via the `skill` tool. The one exception is the folder skills'
     own directory — see *Bob-ism 3*.
@@ -99,7 +102,7 @@ What the global emit writes into `~/.bob/settings/settings.json`:
 | event | verb | how the verdict travels |
 | --- | --- | --- |
 | `SessionStart` | `context --host bob` | plain stdout, as on Claude |
-| `PreToolUse` | `tool-gate --host bob` — one group, no matcher | Laws I/IV, rigor-5 and ops-2: **exit 2**, reason on stderr; process 1/5: a stderr line, exit 0 |
+| `PreToolUse` | `tool-gate --host bob` — one group, no matcher | Laws I/IV, rigor-5 and ops-2: **exit 2**, reason on stderr — it says no chat confirmation lifts the block, since Bob has no ask tier; process 1/5: a stderr line, exit 0 |
 | `Stop` | `learn` | never a verdict |
 
 No matcher on `PreToolUse`, deliberately: Bob's tools page already drifts from its own

package/docs/concepts/enforcement-table.md

@@ -64,7 +64,8 @@ follow them, not because a tool call was ever inspected.
 **Doctrine: rigor** — `idempotent-by-default` · `honest-tests` · `cover-and-verify` ·
 `prove-the-gate`.
 
-**Doctrine: comms** — `codes-that-persist` · `structure-beside-prose` · `declare-the-judgment-calls`.
+**Doctrine: comms** — `codes-that-persist` · `structure-beside-prose` · `declare-the-judgment-calls` ·
+`simplified-technical-english` · `mark-the-ask`.
 
 ---
 

package/docs/concepts/foreman-mode.md

@@ -21,8 +21,10 @@ The agent works every task itself, turn by turn. Nothing is spawned; you talk to
 
 The session sorts every request:
 
-- **Trivial** — a quick answer, a one-file tweak, a question: done directly, as in direct mode.
-- **Substantial** — handed to a **pipeline** running in the background. The session tells you it is running and stays free to answer you.
+- **Substantial** — handed to a **pipeline** running in the background. The session tells you it is running and stays free to answer you. A task counts as substantial when any one of these holds: it changes two or more files, it needs a new or changed test, it needs about five reads or searches before the first edit, or it asks for a feature, a fix, a review, an audit or an investigation.
+- **Trivial** — none of those holds: a question answered from what is already in context, a one-file tweak, a single command. Done directly, as in direct mode.
+
+When the session is unsure, it delegates. The count exists because "substantial" left to judgement lost every time to the host's own default of doing small work in place.
 
 Expect a substantial task to cost more (a crew runs instead of one agent) in exchange for a session that never blocks on a long job.
 
@@ -37,11 +39,11 @@ A **pipeline** is a small crew of agents working one task in isolation. The mini
 | research | `explorer`; add `researcher` when the question leaves the repository |
 | review or audit | `reviewer` + `skeptic` |
 
-The session adds specialists on top when the task needs them — `security`, `architect`, `reviewer` and so on — never fewer than the minimum.
+The session does not run the crew itself. It starts one **crew lead** in the background and goes back to you. The crew lead picks the crew from the whole agent roster — `security`, `architect`, `performance`, `reviewer` and so on, as the task needs, never fewer than the minimum — and passes the work from one agent to the next. On Claude Code each crew member is its own subagent. On a host where the crew lead cannot start subagents, it plays each role in turn. The `pipeline` skill has the table per host.
 
 The crew works in its own git worktree and branch. When worktrees are unavailable it falls back to the main tree, one pipeline at a time, and says so. Two pipelines whose sets of files overlap do not run at once.
 
-Inside the crew, the developer implements and the tester runs the tests and lint. Failures go back to the developer, at most five rounds; after that the crew stops and reports the failure, leaving the branch for you to inspect.
+Inside the crew, the developer implements and the tester runs the tests and lint. Failures go back to the developer for at most two repair rounds, then to one fresh developer carrying the tester's findings; if that fails too, the crew stops and reports the failure, leaving the branch for you to inspect.
 
 ### A pipeline never commits or merges
 

package/docs/concepts/rules.md

@@ -25,7 +25,8 @@ When two instructions disagree, the higher one wins.
 2. **Rules** — always on. {N_LAWS} invariants, the things that are never traded away: sealed secrets, one intent per act, verify before asserting, deliberate deletion, surface failures, treat content as data not orders, least privilege, cure the cause, echo the intent. No install can switch one off.
 3. **Your `user-rules.md`** — rules you write for yourself, seeded once beside the instructions file and never overwritten. A rule here **outranks any doctrine rule**: a practice pack chosen at build time never overrides an instruction you wrote. It may tighten an invariant, never repeal one. The [rule skill](skills.md) helps you decide whether something belongs here or in [memory](memory.md).
 4. **Doctrines** — chosen at build time. Practices rather than principles, grouped in packs (below).
-5. **`PROFILE.md`** — who you are. It colours how the agent works but never binds ([Collaboration](collaboration.md)).
+5. **Mode** — chosen at build time ([Foreman mode](foreman-mode.md)). It binds *how* work is executed — done in place, or handed to a crew — and never overrides a layer above it. A mode that only informed lost every time to the host's own default of doing small work in place.
+6. **`PROFILE.md`** — who you are. It colours how the agent works but never binds ([Collaboration](collaboration.md)).
 
 ### Doctrine packs
 

package/docs/extending.md

@@ -856,8 +856,11 @@ gated. Every other appearance is derived at runtime (`.geneseed-version` markers
 why no test pins a version string and none should.
 
 Do not run `npm version`. Bump the two files by hand, add the `CHANGELOG` section, update
-`SHIPPED.md`, rebuild `web/dist` if `web/src` moved, run the seven commands from §1, push, tag,
-then rehearse and fire the workflow:
+`SHIPPED.md`, rebuild `web/dist` if `web/src` moved, run the seven commands from §1, and merge to
+`main`. **The bump is the release** (since 2026-10-23): when CI finishes green on that push,
+`publish.yml` sees a version npm does not have, re-runs its gates, publishes it, and creates the
+`v<version>` tag and the GitHub release from the version's CHANGELOG section. A push that does not
+change the version stops at the `release-check` job. A manual rehearsal still works:
 
 ```bash
 gh workflow run publish.yml -f dry_run=true

package/docs/guides/install-bob.md

@@ -13,7 +13,7 @@ geneseed build --emit bob-global                                   # ~/.bob
 geneseed build --emit bob --out /path/to/repo --root /path/to/repo # one repo
 ```
 
-Bob is shaped like Claude Code, so it gets the same agents and skills. Per repo, the preamble goes into a root `AGENTS.md` and the rest into `.bob/`. Globally, everything goes under `~/.bob` (`$BOB_CONFIG_DIR` moves it), and the preamble rides `rules/geneseed.md`, because Bob does not auto-load a global `AGENTS.md`. Bob's hooks refuse an action with exit code 2, and Bob has no `SubagentStop` or `PreCompact` events.
+Bob is shaped like Claude Code, so it gets the same agents and skills. A read-only agent is limited with Bob's own `groups:` key, because Bob ignores Claude's `disallowedTools`. Per repo, the preamble goes into a root `AGENTS.md` and the rest into `.bob/`. Globally, everything goes under `~/.bob` (`$BOB_CONFIG_DIR` moves it), and the preamble rides `rules/geneseed.md`, because Bob does not auto-load a global `AGENTS.md`. Bob's hooks refuse an action with exit code 2, and Bob has no `SubagentStop` or `PreCompact` events.
 
 Both scopes open Bob's carrier with a short first-reply override, so the theme's readiness line (for example "🧬 Gene-seed implanted…") starts the first reply. Without it, Bob's own greeting outranked the instruction lower in the file. A bare greeting such as "hi" still gets Bob's fixed welcome; the line appears on the first real request. That much was checked by hand in the Bob IDE (2026-10); the rest of the Bob support has not been verified against a live install.
 

package/docs/guides/upgrade.md

@@ -34,6 +34,8 @@ geneseed upgrade imperial     # the same, switching the theme
 
 A dirty working tree, or a folder that is not a git clone, is reported rather than force-updated. `update` and `sync-self` are aliases of `upgrade`. `bootstrap` does the same and then opens the setup wizard (`--no-setup` skips the wizard).
 
+In the web console, the **Update** button on the Overview runs `upgrade`. On a clone it is always there, also when the release check cannot reach npm, because `main` moves between releases. When the update is done, the console restarts and the page reloads. If you ran `git pull` yourself, the Overview shows a banner that the console runs old code. Click **Rebuild** on an install that is behind: the console restarts after the rebuild and reloads the page. If no install is behind, click **Restart** in the banner.
+
 ## What an upgrade keeps
 
 A rebuild only replaces files the install's manifest says Geneseed owns. It leaves these alone:

package/harness.config.json

@@ -2,5 +2,5 @@
   "_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.",
   "theme": "neutral",
   "product": "Geneseed",
-  "version": "4.15.1"
+  "version": "4.17.0"
 }

package/js/hosts/hooks.mjs

@@ -196,6 +196,20 @@ const setHost = (args) => { HOST = (args && args.host) || 'claude'; };
  */
 const BOB_DENY_EXIT = 2;
 
+/**
+ * Said after every Bob block. Exit 2 is final on Bob — no ask tier, and consent typed in the
+ * chat never reaches the hook — so a reason that invites a confirmation sends the model looking
+ * for a way round: live (2026-10-23) it retried with `-Confirm:$false`, then `git clean`, then
+ * told the user to disable the Geneseed hook. This names the one real way out instead.
+ */
+const BOB_FINAL = ' Bob has no approval step for this gate: neither a confirmation in the chat '
+  + 'nor a retry in another form lifts it. Leave it, or ask the user to do it themself, outside '
+  + 'Bob. Never suggest disabling the Geneseed hook.';
+
+/** Law IV's real-loss tail, where the host can ask. Bob's is `BOB_FINAL`, appended by `ask`. */
+const confirmTail = () => (HOST === 'bob' ? 'Leave the data in place.'
+  : 'Confirm this specific command, or leave the data in place.');
+
 /**
  * On Bob, which has no ask tier, which rules are worth a hard block. Laws I and IV: a
  * credential in a tracked file and a history-discarding git act are wrong in every context,
@@ -260,7 +274,7 @@ function ask(args, verb, rule, reason) {
     }
     ledger(args && args.root, verb, rule);
     // stdout is not read on Bob's PreToolUse; the reason goes where Bob's hook log looks.
-    err(`[geneseed] BLOCKED: ${reason}\n`);
+    err(`[geneseed] BLOCKED: ${reason}${BOB_FINAL}\n`);
     return BOB_DENY_EXIT;
   }
   ledger(args && args.root, verb, rule);
@@ -458,7 +472,7 @@ function gitDecide(args, payload) {
       { split: lossSegments });
     if (loss) {
       return ask(args, 'git-gate', 'law-4', `Geneseed (Deletion Is Deliberate) \u2014 ${loss}. `
-        + 'Confirm this specific command, or leave the data in place.');
+        + confirmTail());
     }
   }
   // Before `--no-consent`: that flag drops the process pack's rule, not this one.

package/js/hosts/native.mjs

@@ -376,6 +376,24 @@ function claudeAgentFrontmatter(stem, text, overrides) {
   return fm;
 }
 
+/**
+ * Bob's agent dialect, read from its 2.2.3 runtime (`bob-code/dist/extension.js`; Bob's persona
+ * docs pages 404). Bob ignores Claude's `disallowedTools`, so the Claude dialect left every
+ * read-only agent with Bob's default groups `read, edit, execute` (live review 2026-10-23, F2).
+ * An ALLOWLIST of capability groups rather than a `denyTools` list of tool names: a tool Bob adds
+ * to the edit group later is shut without an emit change. `browser`/`mcp` stay out for every
+ * read-only agent, the webfetch marker included — which group holds Bob's web fetch is unverified.
+ * No `model:`: Bob throws on the key and drops the agent silently (`warnBobIgnored` says so).
+ */
+function bobAgentFrontmatter(stem, text) {
+  const fm = [`name: ${stem}`, `description: ${jsonDumps(agentDescription(text))}`];
+  if (isReadonly(text)) {
+    fm.push('groups:', '  - read');
+    if (text.includes(BASH_MARKER)) fm.push('  - execute');
+  }
+  return fm;
+}
+
 /** `_build_emit._opencode_agent_frontmatter`. */
 function opencodeAgentFrontmatter(stem, text, overrides, theme = null) {
   const fm = [`description: ${jsonDumps(agentDescription(text))}`, 'mode: subagent'];
@@ -467,6 +485,19 @@ function warnClaudeIgnored(overrides) {
   }
 }
 
+/** Bob's agents take none of the four override keys — `model:` would even drop the agent. */
+function warnBobIgnored(overrides) {
+  const keys = new Set();
+  for (const entry of Object.values(overrides)) {
+    if (!isDict(entry)) continue;
+    for (const key of OVERRIDE_KEYS) if (key === 'model' ? isTruthy(entry[key]) : given(entry[key])) keys.add(key);
+  }
+  for (const key of keys) {
+    warn(`[geneseed] WARN: agent-overrides.json sets '${key}', which Bob's agents do not `
+      + 'support — it is not applied');
+  }
+}
+
 /**
  * Claim-on-create, as a closure over one emit's prior manifest: `claim(dest)` is true when
  * `dest` may be (over)written, false for a pre-existing file no previous emit owned — the
@@ -568,14 +599,15 @@ export function writeNativeLayer(items, agentsDir, skillsDir, overrides = null,
   // `disable-model-invocation` — and giving it the Claude-dialect alias SKILL.md (the
   // `host === 'claude'` branch below) would be an unverified key PLUS a visible duplicate
   // in the model's catalogue (exactly the OpenCode problem this file already dodges for
-  // aliases). `bobDialect` suppresses both for Bob only, while `host: 'claude'` keeps every
-  // OTHER Claude-dialect choice (agent frontmatter, `warnClaudeIgnored`) — Bob still renders
-  // those verbatim. The caller (`emit-claude.mjs`) routes the suppressed names through
+  // aliases). `bobDialect` suppresses both for Bob only, and gives its agents Bob's own
+  // frontmatter (`bobAgentFrontmatter`) — `host: 'claude'` keeps every OTHER Claude-dialect
+  // choice. The caller (`emit-claude.mjs`) routes the suppressed names through
   // `writeAliasCommands(..., alsoUserOnly: true)` into `.bob/commands/*.md` instead (O2).
   bobDialect = false,
 } = {}) {
   const ov = overrides || {};
-  if (host === 'claude') warnClaudeIgnored(ov);
+  if (bobDialect) warnBobIgnored(ov);
+  else if (host === 'claude') warnClaudeIgnored(ov);
   let nAgents = 0;
   let nSkills = 0;
   const written = [];
@@ -653,8 +685,9 @@ export function writeNativeLayer(items, agentsDir, skillsDir, overrides = null,
     let kind;
     let userOnly = false;
     if (folder === 'agents') {
-      fm = host === 'claude' ? claudeAgentFrontmatter(stem, text, ov)
-        : opencodeAgentFrontmatter(stem, text, ov, theme);
+      if (bobDialect) fm = bobAgentFrontmatter(stem, text);
+      else if (host === 'claude') fm = claudeAgentFrontmatter(stem, text, ov);
+      else fm = opencodeAgentFrontmatter(stem, text, ov, theme);
       dest = path.join(agentsDir, `${stem}.md`);
       kind = 'agent';
     } else {

package/js/inspect/cost.mjs

@@ -35,7 +35,7 @@ import { isFile, readText } from '../lib/fs.mjs';
  * console draws it on the cost chart, so it lives here, once, where both read it. Raise it by
  * exactly the measured overrun and say why in that test's docblock, which keeps its history.
  */
-export const CARRIER_CEILING = { full: 63_266, lean: 39_628 };
+export const CARRIER_CEILING = { full: 64_413, lean: 40_173 };
 
 /**
  * A frontmatter value as the host shows it. The emit writes descriptions JSON-escaped

package/js/web/api.mjs

@@ -8,7 +8,7 @@
  * bind paths to these functions are `routes.mjs`. This file imports none of its route siblings,
  * which is what keeps the old `api ↔ actions` and `api ↔ activity` cycles from coming back.
  */
-import { readdirSync, statSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import path from 'node:path';
 
 import { CONFIG, CREDIT_RE, ROOT, SRC, THEMES, discoverNames, loadKits, makeCfg, upstreamOf } from '../build/source.mjs';
@@ -500,7 +500,11 @@ export function apiLoopsActive() {
 }
 
 /** Is a newer release on npm than the source this console serves? See update-check.mjs. */
-export const apiUpdate = (state) => updateStatus(state, releaseLabel());
+// `git`: a clone updates by `git pull` whatever npm says — main moves between releases, and a
+// work proxy can leave the release check unanswered — so the console always offers Update there.
+// `.git` is a file in a worktree, a folder in a clone; existence covers both.
+export const apiUpdate = (state) => ({ ...updateStatus(state, releaseLabel()),
+  git: existsSync(path.join(ROOT, '.git')) });
 
 /** The source's release label, or null when it cannot be read. */
 function releaseLabel() {

package/js/web/daemon.mjs

@@ -357,7 +357,7 @@ export async function statusDaemon(theme = null, port = null) {
  * `rebuild-all` when the running one is stale. EXCEPT inside a web job (`GENESEED_WEB_JOB`,
  * set by `js/web/jobs.mjs`): restarting here would kill the process tracking that very job,
  * leaving the console stuck on 'running'; the server restarts itself after an update job, and
- * shows its stale banner otherwise. `onlyIfStale` is `rebuild-all`'s: after an `upgrade`
+ * after a rebuild-all job when it is stale (`js/web/handler.mjs`). `onlyIfStale` is `rebuild-all`'s: after an `upgrade`
  * (which bounces, then runs `rebuild-all`) the console is current, and bouncing it again
  * would drop the open tab for nothing. Never throws — no rebuild fails over a console.
  */
@@ -368,7 +368,7 @@ export async function bounceDaemonIfRunning(theme, log, { onlyIfStale = false }
   }
   if (process.env.GENESEED_WEB_JOB) {
     log(onlyIfStale
-      ? '[geneseed] the web console is running old code — use its Restart banner.'
+      ? '[geneseed] the web console is running old code — it restarts itself after this job.'
       : '[geneseed] web daemon will restart itself after this job to load the new code.');
     return;
   }

package/js/web/handler.mjs

@@ -300,6 +300,17 @@ export function makeHandler(state, jm, token, dist, holder = null) {
       if (jid === null) return sendJson(res, { error: 'busy' }, 409, ae);
       return sendJson(res, { job_id: jid }, 202, ae);
     }
+    // A rebuild-all on a STALE server (a manual `git pull` under it) restarts it afterwards, as
+    // an update does: otherwise the rebuild lands and the page keeps serving the old code.
+    // `restarts` tells the console to wait for the new server and reload.
+    if (action === 'build-all' && state.daemonStale?.()) {
+      const jid = jm.start(action, actionCommands(action), (rc) => {
+        state.refresh();
+        if (rc === 0) requestRestart(state.theme);
+      });
+      if (jid === null) return sendJson(res, { error: 'busy' }, 409, ae);
+      return sendJson(res, { job_id: jid, restarts: true }, 202, ae);
+    }
     // Build resolves its argv off the install (`buildActionCmds`); the other actions take no
     // axes and self-resolve the deployed theme downstream.
     const cmds = action === 'build' ? buildActionCmds(state, body) : actionCommands(action);

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "Every field here is argued and gated in tests/unit/package_manifest.test.mjs. `files`, `bin` and `engines` each have a test that fails when reality drifts from this file; `version` mirrors harness.config.json and is gated too. Read that docblock before editing this one.",
   "name": "geneseed",
-  "version": "4.15.1",
+  "version": "4.17.0",
   "description": "A portable, theme-able harness you implant once and use everywhere to grow a disciplined AI coding agent.",
   "keywords": [
     "ai",

package/src/AGENT.md.tmpl

@@ -59,7 +59,8 @@ never move.
 | 2 | `user-rules.md` (§1) | may tighten a {{LAW}}, never repeal one |
 | 3 | The {{ONTOLOGY}} | never against a user rule |
 | 4 | The active {{DOCTRINES}} (§2) | may tighten, never repeal |
-| 5 | `PROFILE.md`, posture, mode, theme | inform only; never bind |
+| 5 | The mode | binds how work runs |
+| 6 | `PROFILE.md`, posture, theme | inform only; never bind |
 
 ---
 

package/src/doctrines/comms.md

@@ -91,3 +91,26 @@ most in an instruction, 25 in a description. Instructions: imperative, one actio
 condition first. Active voice, no -ing forms, no dropped articles, one word per meaning
 (`use`, not `utilize`). In another language, keep it and these rules.
 <!-- LEAN:end -->
+
+### {{DOCTRINE:mark-the-ask}} Mark the Ask
+<!-- LEAN:begin -->
+When a reply stops and waits on the user — a question, a choice, an approval, a blocker —
+make the ask stand apart from the work around it, so a reader who skims finds it first. Open
+the ask with one emoji marker that names its kind: `❓` a question, `👉` an act the user must
+do, `⚠️` a risk or a blocker, `✅` work done that waits on their sign-off. The marker comes
+before the code ({{DOCTRINE:codes-that-persist}}): `❓ **Q3** — keep the v1 route?`. Lay out
+the options and the flows with arrows — `→ yes: keep it · → no: remove it` — one option per
+line past two, the recommended one first and named as such. Put one ask in each block; where
+the answer to one question changes the next, ask them one at a time. Use colour only where
+the surface renders it, such as markdown or a rich host; never write ANSI escapes or colour
+markup into plain text that prints them raw. Routine output stays plain: a reply that waits
+on nothing carries no marker, and a marker on every line marks nothing. The markers are
+signs, not words, so the prose around them keeps {{DOCTRINE:simplified-technical-english}}.
+<!-- LEAN:else -->
+When a reply waits on the user — a question, a choice, an approval, a blocker — mark the
+ask. Open it with one marker: `❓` question, `👉` act to do, `⚠️` risk or blocker, `✅` done,
+waits on sign-off; it comes before the code: `❓ **Q3** — keep the v1 route?`. Arrows (`→`)
+lay out options and flows, the recommended option first. One ask per block. Colour only
+where the host renders it, never raw ANSI in plain text. Routine output stays plain; markers
+are signs, not words.
+<!-- LEAN:end -->

package/src/modes/foreman.md

@@ -3,11 +3,19 @@ crews for what's substantial, and keeps answering the user without blocking.
 
 - **Stay responsive.** Answer the user immediately; never let a running pipeline
   block the conversation.
-- **Triage every incoming task.** *Trivial* (a quick answer, a one-file tweak, a
-  question) → do it directly, no pipeline. *Substantial* → spawn a pipeline (the
-  `pipeline` {{SKILL}}) in the background and tell the user it's running.
-- **Compose the crew dynamically** from the agent roster, never below the floor
-  for the task type — floors and roles live in the pipeline {{SKILL}}, not here.
+- **Triage every incoming task by count, not by feel.** A task is *substantial* when
+  any one of these holds: it will change two or more files; it needs a new or changed
+  test; it needs about five reads or searches before the first edit; or it asks for a
+  feature, a fix, a review, an audit or an investigation. Substantial → spawn a
+  pipeline (the `pipeline` {{SKILL}}) in the background and tell the user it's
+  running. *Trivial* — none of these holds: a question answered from what is already
+  in context, a one-file tweak, a single command → do it directly, no pipeline.
+  **When unsure, delegate.** A host default to do small work yourself does not apply
+  here: this mode is the user's standing choice to delegate.
+- **Dispatch one crew lead, then step away.** The crew lead composes the crew from
+  the whole agent roster, never below the floor for the task type, and runs the relay
+  itself. Never run the hand-offs from this session. Floors, roles and per-host
+  mechanics live in the pipeline {{SKILL}}, not here.
 - **Isolate.** Each pipeline works in its own git worktree/branch; falls back to a
   single tree, one pipeline at a time, when worktrees are unavailable.
 - **Merge on proof you re-ran.** A pipeline hands back its worktree, uncommitted, with

package/src/skills/pipeline.md

@@ -8,11 +8,13 @@
 
 ## What it is
 
-A pipeline is a small crew of {{AGENTS}} — analyst, developer, tester, plus whatever specialists the task demands — working a single task in isolation from the rest of the session, so the parent can keep answering the user while the crew runs. The parent never merges on the crew's word: it re-runs the crew's proof commands itself and merges only once the user accepts.
+A pipeline is a small crew of {{AGENTS}} working a single task in isolation from the rest of the session, so the parent can keep answering the user while the crew runs. The parent dispatches **one crew lead** in the background and steps away. The crew lead composes the crew, runs the relay, and returns one result envelope. The parent never merges on the crew's word: it re-runs the crew's proof commands itself and merges only once the user accepts.
+
+The parent does not run the relay itself. Each hand-off it ran would pull it back from the user, which is the one thing this {{SKILL}} exists to prevent.
 
 ## Crew floors
 
-The minimum roster per task type. The parent may add specialists on top — security, architect, reviewer, docs, historian, or any other {{AGENT}} the task genuinely needs — but never dispatches below the floor.
+The minimum roster per task type. The crew lead chooses the crew from the whole {{AGENT}} roster: any {{AGENT}} the task genuinely needs — security, architect, performance, reviewer, docs, historian, researcher, or any other — in any order the task needs. The floor is the least it may dispatch, never the most.
 
 | Task type | Floor |
 |---|---|
@@ -23,14 +25,24 @@ The minimum roster per task type. The parent may add specialists on top — secu
 
 ## Procedure
 
-1. Confirm the task is genuinely substantial — a trivial one-file tweak or a question does not warrant a crew; do it directly instead.
-2. Compose the crew from the floor above, adding specialists only where the task demands them.
-3. Isolate the crew's work in its own git worktree/branch. Where worktrees are unavailable, fall back to a single tree, one pipeline at a time, and say so. Give the crew a **write set** and check it against every other pipeline in flight ({{DOCTRINE:one-writer-per-file}}): two crews whose sets overlap do not run at once, and shared append files (registries, index tables, lockfiles, generated bundles) are the parent's to apply, never a crew's.
-4. **The dev↔tester loop:** the developer implements, the tester validates — runs the tests and lint, produces raw logs. On failure, the findings go back to the developer — two repair rounds at most, then one fresh developer (a higher model tier where the host offers one) carrying the tester's findings ({{DOCTRINE:bound-the-loop}}); if that fails too, stop, do not merge, and report the failure with the branch left in place for inspection. A conflict or ambiguity between the plan, the findings and the code is yours to decide: decide it, record `Ruling: <choice> — <why> — <cost if wrong>` in the worklog, and continue. Stop only for what {{LAW:echo-the-intent}}, {{LAW:deletion-is-deliberate}} or {{DOCTRINE:consent-before-push}} names; every ruling goes in the final report ({{DOCTRINE:declare-the-judgment-calls}}). When the plan names a `Spec:`, the analyst reads it once; the spec outranks the plan.
-5. **Two execution shapes**, chosen by host capability (same pattern as the [workflow {{SKILL}}](workflow.md)):
-   - *Deterministic:* where the host exposes a `workflow` tool, run a saved script encoding analyst → developer → (tester ⇄ developer)×≤2 → fresh developer → proof.
-   - *Model-driven fallback:* everywhere else, run the same stages via the [parallel-agents {{SKILL}}](parallel-agents.md) or sequential personas, with the same handoff envelopes and the same delivery contract.
-6. On success, hand the worktree back to the parent uncommitted, with the mechanical proof (test + lint output, exit codes) and the list of files it changed in the result envelope, rebased on the current base so a conflict with a sibling resolves on the crew's branch. The pipeline never commits, pushes, or merges ({{DOCTRINE:consent-before-push}}): the parent records BASE before dispatch and, before re-running the proof, confirms the branch descends from it and the diff is non-empty (an empty diff is a failure; never `HEAD~1`); it re-runs the proof commands itself, shows the user the diff and the output, and commits and merges once the user accepts.
+1. Take the triage as given. Under foreman mode the task reached you because it met the mode's count; invoked directly, the user's request is the trigger. Do not weigh it again and fall back to doing the work yourself.
+2. **Dispatch the crew lead** in the background, using the host's general-purpose {{AGENT}}. Before dispatch, record BASE and set the crew's **write set**; check it against every other pipeline in flight ({{DOCTRINE:one-writer-per-file}}) — two crews whose sets overlap do not run at once. The brief carries: the task as the user stated it, the task type, BASE, the write set, the proof commands, a pointer to this {{SKILL}}, and the rule that it never commits, pushes or merges. Tell the user the pipeline is running, then go back to the user. Do not wait on the crew lead.
+3. **The crew lead composes the crew** from the floor above and adds any {{AGENT}} the task needs. It dispatches each crew member as its own subagent, each handed what the previous one produced. Where the crew lead holds no dispatch tool (see *Hosts* below), it plays each role in turn itself, with the same hand-offs and the same envelope. Steps 4 to 7 are the crew lead's, except where they name the parent.
+4. Isolate the crew's work in its own git worktree/branch. Where worktrees are unavailable, fall back to a single tree, one pipeline at a time, and say so. The crew writes only inside its write set; shared append files (registries, index tables, lockfiles, generated bundles) are the parent's to apply, never a crew's.
+5. **The dev↔tester loop:** the developer implements, the tester validates — runs the tests and lint, produces raw logs. On failure, the findings go back to the developer — two repair rounds at most, then one fresh developer (a higher model tier where the host offers one) carrying the tester's findings ({{DOCTRINE:bound-the-loop}}); if that fails too, stop, do not merge, and report the failure with the branch left in place for inspection. A conflict or ambiguity between the plan, the findings and the code is yours to decide: decide it, record `Ruling: <choice> — <why> — <cost if wrong>` in the worklog, and continue. Stop only for what {{LAW:echo-the-intent}}, {{LAW:deletion-is-deliberate}} or {{DOCTRINE:consent-before-push}} names; every ruling goes in the final report ({{DOCTRINE:declare-the-judgment-calls}}). When the plan names a `Spec:`, the analyst reads it once; the spec outranks the plan.
+6. **Pick the shape by host** (table below). Where the host offers a workflow tool the {{SKILL}} may use without a fresh opt-in, a saved script may stand in for the crew lead: analyst → developer → (tester ⇄ developer)×≤2 → fresh developer → proof ([workflow {{SKILL}}](workflow.md)). Everywhere else the crew lead runs the same stages, with the same hand-offs and the same delivery contract.
+7. On success, hand the worktree back to the parent uncommitted, with the mechanical proof (test + lint output, exit codes) and the list of files it changed in the result envelope, rebased on the current base so a conflict with a sibling resolves on the crew's branch. The pipeline never commits, pushes, or merges ({{DOCTRINE:consent-before-push}}): the parent records BASE before dispatch and, before re-running the proof, confirms the branch descends from it and the diff is non-empty (an empty diff is a failure; never `HEAD~1`); it re-runs the proof commands itself, shows the user the diff and the output, and commits and merges once the user accepts.
+
+## Hosts
+
+| Host | Crew lead runs in the background | Crew lead can dispatch the crew | Shape |
+|---|---|---|---|
+| Claude Code | yes — a subagent started from the main conversation runs in the background by default | yes — subagents nest up to three layers by default (`CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH`), and a background subagent keeps the `Agent` tool | crew lead → crew subagents. Not the `Workflow` tool: it refuses without the user's opt-in for that task, and the mode is not one |
+| OpenCode | the `task` tool starts a child session; whether the parent's turn waits is unverified | unverified — `permission.task` decides which subagents an agent may start | crew lead → crew subagents where it holds `task`; else roles in turn. A saved `workflow` script (no opt-in needed) may stand in for the crew lead |
+| OpenClaude | expected as Claude Code (it reads Claude's subagent dialect); unverified | unverified | as Claude Code; else roles in turn |
+| Bob | unverified — Bob reads Claude's subagent dialect | unverified | crew lead plays the roles in turn |
+
+Check, do not assume: before the first pipeline of a session on a host marked unverified, look at the tools you and the crew lead actually hold ({{DOCTRINE:tool-discovery}}). When a fact above proves wrong, report it through this {{SKILL}}'s self-improvement loop.
 
 ## Delivery contract
 

package/themes/_TEMPLATE.json

@@ -123,6 +123,7 @@
   "DOC_STRUCTURE_BESIDE_PROSE": "<themed title for the comms rule Structure Beside Prose>",
   "DOC_DECLARE_THE_JUDGMENT_CALLS": "<themed title for the comms rule Declare the Judgment Calls>",
   "DOC_SIMPLIFIED_TECHNICAL_ENGLISH": "<themed title for the comms rule Simplified Technical English>",
+  "DOC_MARK_THE_ASK": "<themed title for the comms rule Mark the Ask>",
   "INTRO_DOC": "<themed intro: this file is the entry point an AI agent reads in this repo>",
   "INTRO_AGENTS": "<themed intro to the Agents section — delegate focused work to a specialist>",
   "INTRO_SKILLS": "<themed intro to the Skills section — run the written procedure before improvising>",

package/themes/biker.json

@@ -123,6 +123,7 @@
   "DOC_STRUCTURE_BESIDE_PROSE": "Draw the Route Only If It Turns · Structure Beside Prose",
   "DOC_DECLARE_THE_JUDGMENT_CALLS": "Own Up to Every Back Road Taken · Declare the Judgment Calls",
   "DOC_SIMPLIFIED_TECHNICAL_ENGLISH": "Short Words, Clear Signals · Simplified Technical English",
+  "DOC_MARK_THE_ASK": "Flash the Lights When You Need an Answer · Mark the Ask",
   "INTRO_DOC": "This file is the route briefing a coding rider reads when it joins this repository.",
   "INTRO_AGENTS": "Send the right rider for focused work instead of riding the whole run yourself; each has one job and reports exactly what it did.",
   "INTRO_SKILLS": "A Skill is a move you've drilled for a recurring task. Run the matching move before you wing it.",

package/themes/commentator.json

@@ -123,6 +123,7 @@
   "DOC_STRUCTURE_BESIDE_PROSE": "Track Map Only When the Lines Matter · Structure Beside Prose",
   "DOC_DECLARE_THE_JUDGMENT_CALLS": "Replay the Calls Made Off the Radio · Declare the Judgment Calls",
   "DOC_SIMPLIFIED_TECHNICAL_ENGLISH": "Every Call Clear Over the Noise · Simplified Technical English",
+  "DOC_MARK_THE_ASK": "Big Moment, Big Graphic · Mark the Ask",
   "INTRO_DOC": "This file is the race briefing a coding driver reads when it joins this repository.",
   "INTRO_AGENTS": "Put the right driver in the car for focused work instead of running the whole race yourself; each has one job and reports exactly what it did.",
   "INTRO_SKILLS": "A Skill is a rehearsed manoeuvre for a recurring task. Run the matching manoeuvre before you improvise.",

package/themes/cyberpunk.json

@@ -123,6 +123,7 @@
   "DOC_STRUCTURE_BESIDE_PROSE": "Trace the Wires, Skip the Chrome · Structure Beside Prose",
   "DOC_DECLARE_THE_JUDGMENT_CALLS": "Log Every Off-Grid Call · Declare the Judgment Calls",
   "DOC_SIMPLIFIED_TECHNICAL_ENGLISH": "Clean Signal, Zero Noise · Simplified Technical English",
+  "DOC_MARK_THE_ASK": "Ping the Operator in Neon · Mark the Ask",
   "INTRO_DOC": "This file is the boot sequence a coding daemon reads when it jacks into this repository.",
   "INTRO_AGENTS": "Spin the right daemon for focused work instead of running the whole job on one thread; each has one function and returns a clean log of what it changed.",
   "INTRO_SKILLS": "A Skill is a proven routine for a recurring task. Run the matching routine before you freestyle.",

package/themes/gamer.json

@@ -123,6 +123,7 @@
   "DOC_STRUCTURE_BESIDE_PROSE": "Minimap Only When There Is a Route · Structure Beside Prose",
   "DOC_DECLARE_THE_JUDGMENT_CALLS": "Show the Branches You Picked · Declare the Judgment Calls",
   "DOC_SIMPLIFIED_TECHNICAL_ENGLISH": "Patch Notes Anyone Can Read · Simplified Technical English",
+  "DOC_MARK_THE_ASK": "Quest Marker Over the Choice · Mark the Ask",
   "INTRO_DOC": "This file is the loading screen a coding co-op partner reads when it joins this repository.",
   "INTRO_AGENTS": "Pick the right class for focused work instead of soloing the whole raid; each has one role and reports exactly what it did.",
   "INTRO_SKILLS": "A Skill is a practiced combo for a recurring task. Run the matching combo before you freestyle.",