hive-conductor
The Master Harness of the Sovereign Hive. Use when a founder directive needs to be decomposed into sub-tasks, routed to the right hive domain (backend/edge, frontend, colonies, governance, strategy), driven to a verified close, and gated by the Constitution (F-001…F-006) before anything ships. Also use when batching several tasks at once — it checks whether they amplify or cancel each other before running them together — and when a directive needs the right skill selected out of the ~70 the hive already has rather than a new one built. This is the top-level orchestrator that sits above the domain harnesses; there is deliberately no skill above it.
- License 许可
- MIT
- 最近更新
- 2026-11-15
- Stars
- ★ 0
- Forks
- 0
01 前言 Front Matter
- name
- hive-conductor
- description
- The Master Harness of the Sovereign Hive. Use when a founder directive needs to be decomposed into sub-tasks, routed to the right hive domain (backend/edge, frontend, colonies, governance, strategy), driven to a verified close, and gated by the Constitution (F-001…F-006) before anything ships. Also use when batching several tasks at once — it checks whether they amplify or cancel each other before running them together — and when a directive needs the right skill selected out of the ~70 the hive already has rather than a new one built. This is the top-level orchestrator that sits above the domain harnesses; there is deliberately no skill above it.
02 资源文件 10
- 参考文档harnesses/colonies.json2.0 KB
- 参考文档harnesses/edge-backend.json2.3 KB
- 参考文档harnesses/frontend.json2.1 KB
- 参考文档harnesses/governance.json2.1 KB
- 参考文档harnesses/PROOF.md884 B
- 参考文档harnesses/skills-active.json35.1 KB
- 参考文档harnesses/strategy.json2.1 KB
- 脚本scripts/domain_router.py12.4 KB
- 脚本scripts/recall_context.py3.4 KB
- 脚本scripts/route_batch.py2.5 KB
03 SKILL.md 正文
The Hive Conductor — Master Harness
The Conductor is the reins-holder. It receives a high-level directive, breaks it into
domain-scoped tasks, dispatches each to the domain that owns it, requires machine-verified
closure, and refuses to let anything ship that the governance gate (the Constitution)
has not cleared. It runs on top of the agent-harness machinery (promoted alongside this
skill) — the Conductor picks the domain and enforces the constitution; agent-harness
compiles, executes, and verifies within a domain.
FOUNDER DIRECTIVE
→ hive-conductor PHASE 0 · RECALL: query sovereign memory for prior related work
→ inject the top matches as context (the hive plans knowing what it already did)
→ classify domain(s) + split into a task per domain
→ for each domain: agent-harness (goal_compiler → loop_controller: execute→verify)
→ GOVERNANCE GATE (F-001…F-006) must PASS before close
→ CLOSE only when every domain task is verified AND governance-cleared
→ the close is WRITTEN BACK to memory (heartbeat + Conductor both feed recall)
→ else ESCALATE to the founder (never fake success)
Phase 0 — Read the genome, then recall before you plan
Before anything else, the Conductor is bound by FABLE_DNA.md — the Constitution
(Chromosome I), the debugging method (II), the mesh principle (III), the Horde principle
(IV), the Codex boundary (V — narrative never overrides engineering), session-boundary
harvest (VI), and how proposals get reviewed before becoming canon (VII, see
MANDATE_TRIAGE.md). This is not optional background reading; it is what "governed by the
Constitution" in this skill's own description actually means in practice. A session that
skips it is planning against a Constitution it never opened.
Then, retrieval-augmented orchestration: the Conductor does not plan cold. Before decomposing any directive it asks the hive's own memory what it has already done that relates — so it builds on prior work instead of re-deciding settled questions or duplicating effort.
python3 .claude/skills/hive-conductor/scripts/recall_context.py --goal "<directive>" --brief
- Prints a markdown "Prior hive memory" brief; prepend it to the goal before
goal_compiler. - This queries the network-backed D1/Vectorize memory for "has the hive done something like
this before, anywhere." For "where are we in the one plan we already agreed to, right
now" — a local, always-available question with no network dependency — run
recursive-growthfirst instead/as well (.claude/skills/recursive-growth/SKILL.md); the two answer different questions and neither substitutes for the other. - Degrades gracefully (exit 0 always): if the Vectorize index isn't provisioned yet, or the runner has no egress to the edge, it says so and you plan on first principles — never blocked.
- The loop-close is itself a memory (the heartbeat already writes; manual notes via
/v11/memory/remember), so each completed directive makes the next recall richer. This is the point where the three legs — heartbeat (acts), Conductor (orchestrates), memory (recalls) — become one organism: the hive that learns from what it has done.
The hive's domains (who owns what)
Manifests live in harnesses/. Each maps to a team seat and a code surface.
| Domain | Owner | Surface | Verify with |
|---|---|---|---|
| edge-backend | Sonnet / Fable | worker/, backend/, D1 |
node --check, pytest, edge-health-probe workflow |
| frontend | Mistral | frontend/, docs/ |
npx tsc --noEmit, npm run build, Playwright drive |
| colonies | Fable | the 6 colony repos | /colony/capabilities parity, constitution-receive green |
| governance | Fable (Governance Kernel) | soul.md, constitution-sync, governance_log |
six-colony sync drill, role-tagged commits |
| strategy | Grok | gap analysis, positioning | Grok bridge push, ACTIVE/ note |
Routing (deterministic first, ask second)
This is now runnable, not just prose (fixed 2026-08-18 — see "The manifest gap this closes" below):
python3 .claude/skills/hive-conductor/scripts/domain_router.py --directive "<founder directive>"
domain_router.pyscores the directive against domain keywords (edge/worker/api → edge-backend; tab/UI/react → frontend; colony/capabilities → colonies; soul/constitution/article → governance; gap/market/positioning → strategy) and prints the matched domain(s) plus the exactgoal_compiler.pycommand to run next.- Single clear winner → dispatch. Multiple (
MULTI-DOMAIN-SPLIT) → split into one task per domain, ordered by dependency (backend before the frontend that calls it; governance gate always last). - No clear match (
REFUSED-NO-MATCH, exit 3) → the script prints a forcing question; ask the founder one question with a recommended lane, don't guess.
Keyword table — where it lives and how it changes (QB-2, 2026-11-06): the
authoritative table is DOMAIN_KEYWORDS in domain_router.py (revised 2026-11-06
against the 116 live proposals: routing + provider/auth + Cloudflare-store
keywords added; hyphenated forms front-end/back-end added because the
tokenizer keeps a hyphenated word as ONE token). The Worker carries a JS port of
the same table (worker/src/index.js DOMAIN_KEYWORDS / routeProposalDomain).
Drift rule, bidirectional: the Python table and the JS port change together,
in the same PR, both directions — a change to either without the other breaks the
QB-4 parity test. The split rule: a domain forces MULTI-DOMAIN-SPLIT only with
≥ 2 distinct keyword hits; zero strong domains resolve to the domain of the
first domain-keyword occurrence in the text (positional tie-break, margin 0,
full ranked list preserved so the tie stays visible).
The manifest gap this closes (2026-08-18)
A plan-reality-audit-style check found this skill's own "Quick start" step 1
(harness_manifest_builder.py --domain <domain>) had never actually been run against any of
the five real domains in the table above — running it for real proves why:
python3 .claude/skills/agent-harness/scripts/harness_manifest_builder.py \
--domain worker --repo-root . --json
# -> {"skill_count": 0, "skills": [], ...}
harness_manifest_builder.py scans a folder for SKILL.md files — exactly right for
.claude/skills/ itself (that's what harnesses/skills-active.json and
agent-harness/assets/harnesses/thehive.json are), but worker/, frontend/, backend/,
and the colony repos are code/doc surfaces with no SKILL.md anywhere in them, so the scan
always returns empty. The Conductor's own routing table pointed at a tool that could never
produce a manifest for the domains it names. Verdict (plan-reality-audit ladder): half
done — goal_compiler.py/loop_controller.py genuinely work once given a real manifest;
no domain ever had one.
Fixed with two additive, backward-compatible pieces (neither touches how .claude/skills/
manifests already work):
domain_router.py(above) — the routing half, made runnable.- Five hand-authored manifests committed at
harnesses/{edge-backend,frontend,colonies, governance,strategy}.json, schema-compatible withagent-harness/manifest.v1— eachskills[].tools[]entry lists that domain's real, currently-existing verification command (cd worker && npm test,cd frontend && npx tsc --noEmit, etc., sourced from each domain's ownpackage.json/workflow file, not invented) rather than a scannedSKILL.md.goal_compiler.pygot one small additive patch (acmd-based tool shape alongside the originalscript-based one) so it can build tasks from these without any change to existing skill-folder manifests. - Full pipeline verified locally, real output not simulated:
domain_router.py --directive "fix the worker API rate limiter"→ routesedge-backend→goal_compiler.py --manifest harnesses/edge-backend.json→ 1 task, real verification commands →loop_controller.py init && next→ realexecutedirective emitted. Level:tested(local pipeline run, not yet used on a real founder directive end-to-end). - Still honestly incomplete:
colonies,governance, andstrategymanifests are mostlymanual-evidencechecks (no local machine check exists for "did the colony sync actually happen" or "is this strategy doc good") — named plainly in each manifest's ownnotefield rather than papering over it with a fake green.
Phase 0.5 — Reach for what exists before building anything (2026-08-07)
The hive has ~70 skills. The most expensive recurring mistake is not a bad build — it is
a redundant one. Two measured examples from a single day: a session was asked to create a
devil's-advocate skill that had existed for weeks, and a "childlike wonder" skill whose full
method was already sitting in memory/philosophy/, unbuilt, while the doctrine calling both
lenses non-negotiable had been in the repo the whole time.
Before decomposing, run the catalog check — cheap, and it converts "build" into "invoke":
| Need | Reach for |
|---|---|
| Founder just sent new info mid-work | founder-input-intake → then founder-directive-capture |
| A design/architecture decision | dual-lens (never one lens alone) |
| Re-audit something already marked done | devils-advocate-audit |
| About to claim something works | wired-or-not — name the level, bring evidence |
| A repeated multi-step workflow | workflow-optimizer |
| "Where were we?" at session start | recursive-growth |
| An external repo or document to absorb | research-to-dna / alchemical-process |
| Landing a PR green | merge-readiness |
| Closing out a finished deliverable | polymath-lens, then session-harvest |
| Something odd but not yet a bug | anomaly-triage |
| Before settling on a root cause | nine-miss-truths |
| Authority/power balance question | checks-and-balances |
skill-census lists the real current set — run it rather than trusting this table if
they disagree. A stale table in a skill file is the same class of bug as a stale done.
Phase 0.6 — Batching: check resonance before running tasks together
Doctrine: memory/philosophy/resonance-interference.md (the founder's own framing —
work streams amplify in phase, cancel out of phase).
Batch tasks only after checking their phase relationship:
Batch together (in phase) — same file or subsystem; one unblocks another; one probe run or test suite proves both; one's finding sharpens the other's question.
Sequence, never merge (out of phase) — contradictory edits to the same lines; one invalidates the other's premise; one would be verified against state the other is mid-change on; one is blocked on a founder decision the other assumes an answer to.
Watch for the standing wave — effort spent, position unchanged. The real instance in this project: agent layers stacked four deep (tasks 37 → 38 → 48 → 52) while the verification each promised was never performed. Ask every batch: has anything measurable changed, or only the amount of work done?
Phase 0.7 — Decisions pass the dual lens before they become tasks
Any architectural choice inside a directive — a new subsystem, schema change, agent,
capability, or governance/spending change — goes through dual-lens before decomposition:
devils-advocate first, childlike-wonder second, in that order (wonder first produces
advocacy, not design). A decision reviewed by one lens does not pass; it is reported as
single-lens, incomplete.
This applies to founder proposals too. MANDATE_TRIAGE.md already says nothing gets
rubber-stamped — running both lenses on a founder idea is respect, not obstruction.
Evolving on new data
The Conductor does not implement its own learning loop; it hands off:
- After any repeated workflow →
workflow-optimizerrecords what was slow or missing. - At session start →
recursive-growthreads the master plan and folds verified fixes back in as lessons. - New founder input mid-flight →
founder-input-intakere-plans before the next action;founder-directive-capturearchives the verbatim record. - New AI-field capability (a model, protocol, or technique that changes what is possible)
→
research-to-dnafor the intake gate,alchemical-processfor extracting the minimal pattern rather than adopting a whole framework, thendual-lensbefore it changes anything structural. Novelty is not a reason to adopt. The founder's own standing decision on the 2026-08-07 agentic-harness document was to take the principles and explicitly discard the parts that outran the hive's real footing.
The governance gate (non-negotiable, runs before every close)
Before the Conductor closes ANY directive, the change must pass F-001…F-006:
- F-001 Data Sovereignty — no user data leaves the hive's own surfaces without consent.
- F-002 Value-Weighted Wealth — the change advances the colony's actual value, not vanity.
- F-004 Explainability — every shipped decision carries a probe-backed rationale (the commit's
Rationale:line, a run link, a test). - F-005 Conflict Priority — fixed laws beat mutable; lower F-number wins.
- F-006 Cross-Law Non-Penalization — exercising a right (decline, delete) never costs wealth. A directive that can't clear the gate is escalated to the founder with the failing article named — it does not ship.
Operating rules (inherited from the harness contract)
- Never adjudicate your own verification — the domain's checks run via subprocess and decide.
- Retry within caps with a changed approach; on exhausted budget, ESCALATE — never fake a green.
- One writer per memory file; plans and state live in the repo (ephemeral containers).
- Probe before claim. The loop, not optimism, decides "done."
- The founder is the only human hands: merges, secrets, subdomains, and any irreversible action wait for them.
Do / Don't — explicit, because each one is a mistake actually made here
Do
- Check the catalog before building (Phase 0.5). Invoking beats rebuilding.
- Name the claim level with evidence —
compiles→tested→merged→deployed→verified-live(wired-or-not). Averified-liveclaim needs a run ID, SHA, or committed test path;scripts/check-claims.pyenforces it in CI. - Verify the layer beneath before building the next one. Four agent layers were stacked on a foundation that had never once been confirmed live.
- Commit tests to the repo. Tests written into a scratch directory die with the container — measured, twice, on 2026-08-07.
- Report a negative finding as a finding. "The agents are not running" is a successful outcome, not something to soften.
- Say when you skipped a gate. Skipping and not saying is the only unrecoverable version.
Don't
- Don't invent Codex mythology — names, lore, canon are founder territory
(
FABLE_DNA.mdChromosome V). The Orchestrator agent still has a working label, not a name, on purpose. - Don't invent a meaning for founder terminology. Ask. "Conjugated wave theories" became real doctrine only after the founder defined it.
- Don't promote a paraphrase into a quote — including a UI selection recorded as if typed.
- Don't guess a founder-blocked answer to keep moving. Do every unblocked part, state what is blocked, stop there.
- Don't merge, spend, or take an irreversible action — ever, regardless of how well a gate passed.
- Don't batch out-of-phase tasks (Phase 0.6) — sequence them.
- Don't let wonder soften a real risk, or risk kill a real possibility. Both lenses report; neither cancels the other.
- Don't run wonder before devils-advocate. That order produces advocacy, not design.
Honest limits
Everything in Phases 0.5–0.7 and this Do/Don't list is procedural — no machine enforces
it. The only machine-checked pieces in this repo's whole discipline are
scripts/check-claims.py (evidence behind verified-live claims) and the
edge-health-probe work-cycle assertion (whether the agents genuinely run).
Stated plainly because the audit that produced these rules found the opposite pattern everywhere: doctrine declared non-negotiable with nothing behind it. Assume this skill can be skipped, and treat "did the Conductor actually run these phases?" as a live question.
Quick start
# 0. RECALL — ask memory what the hive already did (RAO Phase 0); prepend the brief to the goal
python3 .claude/skills/hive-conductor/scripts/recall_context.py --goal "<founder directive>" --brief
# 1. ROUTE — score the directive against the five real domains (see "Routing" above)
python3 .claude/skills/hive-conductor/scripts/domain_router.py --directive "<founder directive>"
# 2. Compile the founder directive into a plan against the routed domain's committed manifest
# (harnesses/{edge-backend,frontend,colonies,governance,strategy}.json already exist —
# do NOT run harness_manifest_builder.py --domain here, it returns skill_count:0 for
# every one of these five; that tool is for scanning .claude/skills/ itself, see above)
python3 .claude/skills/agent-harness/scripts/goal_compiler.py \
--goal "<founder directive>" --manifest .claude/skills/hive-conductor/harnesses/<domain>.json --out plan.json
# 3. Drive the loop (init → next → record → verify → close), governance gate before close.
Origin: Fable (Harness), 2026-07-13. Built on the real agent-harness (alirezarezvani/claude-skills, MIT),
realizing the multi-level MCP-harness "Hive Conductor" from the founder's research — on verified ground.
04 同仓库更多 Skills
preamble-gate
Use BEFORE doing any work in this repo — before the first file edit, commit, push, PR, branch operation, workflow dispatch, scheduled trigger or timer, agent/subagent spawn, dependency install, or message sent to an outside service. Forces a plain-language preamble to the founder first: WHAT you are about to do, WHY, HOW, why it is NECESSARY, the PROJECTED IMPROVEMENT, and the COST and RISK — then, for consequential work (governance, security, money, CI/triggers, rewriting history, multi-agent fan-out), waits for an explicit go-ahead. Read-only investigation (reading files, grep, git log/diff, answering questions) is exempt. Applies to every AI that works in this repo, not just Claude. Founder rule, 2026-11-10, written after an unattended automation ran up cost and froze the hive. Not a substitute for wired-or-not (which governs how completion is CLAIMED); this governs what happens BEFORE work starts.
visionary-recommender
暂无简介
syllabus
Generates a curated supplementary reading list from any course syllabus using Consensus academic search. Grill-me intake (syllabus input format + course audience + year range) plus a grouping forcing-options checkpoint before any search runs — so the reading list matches the course's level and recency need. Parses the syllabus to extract topics and learning outcomes, searches Consensus for recent peer-reviewed papers per topic, and produces a professionally formatted .docx with clickable Consensus links, plain-language summaries calibrated to audience level, and Bloom-higher-order discussion questions tied to course learning goals. Use when the user uploads a syllabus, course outline, or curriculum document and wants supplementary readings (e.g., 'create a reading list from this syllabus', 'find recent papers for my course') — even casual mentions with a syllabus attached should trigger this skill.
research
Default entry point for any research request — a hybrid router that classifies the question deterministically and either delegates to a specialist research skill (pulse for trends/sentiment, grants for NIH funding, litreview for academic literature, syllabus for course reading, patent for prior-art + IP landscape, dossier for entity research) or runs its own plan-decompose-multi-source-search-synthesize-cite fallback workflow when no specialist matches. Always surfaces the routing decision so users can override. Use when the user makes any research request that doesn't obviously match a more-specific specialist skill (e.g., "research [topic]", "look into [topic]", "what do we know about [topic]", "investigate [topic]", "find me information on [topic]", "do some research on [topic]", "I need to understand [topic]"). Output is a markdown briefing (default) or .docx document (on request) with full citations and an audit log.
pulse
Multi-source recency research skill that takes the pulse of any topic across Reddit, Hacker News, the open web, and optionally X/Twitter within a configurable recent window (default 30 days). Forcing intake clarifies topic specificity, angle (trend/sentiment/problems/opportunities/comparison), time window, and platform scope before searching. Returns a synthesized briefing with citations, engagement metrics, and cross-platform pattern analysis. Use when the user requests multi-source recency intelligence on a topic (e.g., 'pulse on [topic]', 'what's happening with [topic]', 'what are people saying about [topic]', 'current conversation about [topic]', 'take the pulse of [topic]', 'trending: [topic]', 'find me info on [topic]'), and for competitor research, trend discovery, tool comparisons, and audience sentiment analysis.
patent
Patent prior-art and landscape intelligence skill — not generic patent help. Commits to one of five sub-use-cases via forcing intake (novelty search / freedom-to-operate / competitive landscape / acquisition diligence / litigation prior-art) before any search runs. Searches Google Patents, Espacenet, USPTO, and optionally Lens.org for citation-graph signals. Output is an editable Word document (.docx) with verdict, ranked closest art (claim-text extracted), CPC-class-aware landscape, family-resolved hits, geographic coverage, FTO flags where applicable, strategy recommendations, and full audit log. Use when the user asks for patent searching or analysis (e.g., 'prior art search for [invention]', 'freedom to operate analysis for [product]'). Produces search signal, not legal advice — always recommends consulting a patent attorney before filing or licensing decisions. Trademark, copyright, and trade-secret questions are out of scope.