Stories A told story · designed 2026-11-17 — nothing built; the rows are filed, none claimed

One routing

The answer in one paragraph. ONE already has every part Tony named, and they already touch in two places: a chat reply picks its model from its tags (routing/reply-model.ts), and the factory card flow runs pick, build, judge and close as one path that warns the model on a failed judge (factory/card-flow.ts). What is wrong is when the paths learn. world:route strengthens the path to the actor it chose, before any work comes back, and the reply it then runs never moves anything. So the actor paths learn from intent, and the model paths learn from nothing: of 21 shapes asked tonight, 20 had no row naming a model the router may answer. One shape (ts-lib) is warm, because the bake is the one writer that closes on an outcome. The design keeps both receivers. It adds the model, the team and the skills to the route's answer as optional fields, carries the shape, the parent and the cast in the signal's existing envelope, and moves every deposit to the outcome. No new entity, store or receiver.

What did not run

  • How many routes ended at the CEO: not measurable today. world:route writes its lane (learned · staked · explore · ceo) nowhere, and receiver_calls counts by outcome, not lane. The fifth deliverable fixes this.
  • How many messages carry tags in their envelope was not read. The gateway-call count below covers the model calls.

The first pass could not read production D1 from this session, and the dev TypeDB profile has no one database. ONE then read the D1 numbers from production. They are in § Measured, marked as ONE's read.

1 · What a routed signal carries

Field Where it lives today Status
Tags, bare words SignalMeta.tags (lib/signal-meta.ts), world:route tags, task tags, FN_TAGS (lib/in/spaces.ts:29) Live. The same word routes the signal, names the Space and tags the task
Who sent it SignalMeta.from, set from the attested ctx by stamp() and never from the body Live
Who it went to SignalMeta.to, SignalMeta.routedTo Live
Which group SignalMeta.group; group in the gateway's five words Live
Cost so far SignalMeta.hop[].cost (USD per hop); SignalMeta.price (a ceiling) Live for workflow runs (hopsFor); not appended by world:route
The trace id the ask door's signalId, sent to the model as signal (one-router § 14) Live
The parent signal conversation_id only as a channels-side field (channels/src/middleware.ts:820); a task thread is task:<tid> Missing from the envelope
The shape of the work a request field on world:pick-model; computed by messageShape(tags) for replies Missing from the envelope, so a hop cannot say which shape it ran
The cast nowhere; the task's @<slug> tag names one assignee Missing
The skills and tools used the agent's skills: frontmatter; tool calls inside channels Missing from the envelope
The rung that answered the response's routed Not recorded

The signal relation itself (schema/one.tql:262) holds payload, amount, success, latency and scope. It has no tag attribute, and it should not get one. Tags are routing words in the envelope, and the path keys (tag:<group>:<word>) are where they become weights.

The design: four optional fields and one rule for hops.

SignalMeta (additive; v stays 1)
  shape?   bare word — the kit or family it ran as
  parent?  the parent signal id, or task:<tid>
  cast?    actor slugs allowed to act on it
  hop[]    gains optional rung, model, skill

Each hop appends and never rewrites, as stamp() already guarantees. A hop may add tags, which is Tony's "always tagging". A hop may not add an actor to cast. A child signal's cast is a subset of its parent's. Widening it means going back to the lead, who is in the parent's cast and files a new row. Tags grow and the cast narrows, so the rule is "describe more, reach no further".

Three things must change together, or the fields die at the door:

  • readStamp and readSignalMeta copy by allow-list, so the new keys must be added there.
  • meta must be declared on each receiver's request in receivers.ts, because the HTTP edge returns zod's parsed body.
  • The gateway's five words stay five. shape rides in tags, never as a sixth key.

2 · One decision instead of three

Compose, don't merge. world:route answers who. world:pick-model answers which model. Both have callers that pin their response shapes:

Caller Reads
factory/card-flow.ts pick-model with kit, bare model id
routing/reply-model.ts pick-model model + reason
CLI one message (packages/cli/src/message.ts:39) route reply, with deliver:false
workflow-templates.ts:1922 route step route with deliver:false
workflow:price (the path builder's read) route decide:true plus one pick per step

So the merged answer is additive optional fields on world:route's response, filled by calling the existing pickModel() in-process:

deliver/reply  (unchanged) ok · routed · actor? · tags
                · reply?          (ceo omits actor)
decide:true    (unchanged) ok · receiver · rung
                · reason · tags
both gain      model? effort? pick?  pickModel()
               kit? seats?           teams.json
               skills?               actor's skills:
               trace?                keys decided on

The two shapes stay two shapes, and nothing is promised that a branch does not return today. decide:true stays a pure read: it calls pickModel() in-process, which reads the D1 mirror and writes nothing.

world:pick-model keeps its contract and stays the model door, so m.sh, the bake and card-flow are unchanged.

trace is the shipped nav:next pattern (lib/nav/next.ts): the answer names the exact (tag key → actor) and (shape → model) pairs it was decided on. The outcome signal marks or warns that trace through the ordinary verbs, so the decision and the learning use one set of keys, with one correction. Before the close, the model leg is rewritten to the model that ran (the invoiced usage.model), because a provider can substitute. The actor leg is the actor that answered.

Why not one key set "keyed by tags and shape"? The actor paths (tag:<group>:<word> → actor) and the model paths (shape:<shape> → model:<id>) answer different questions and already live in the one store (claw_paths, mirrored to the TypeDB path). Keying a (tags, shape) pair jointly would multiply rows by every tag combination and leave each one cold for longer. The join belongs in the answer (trace), not in the key.

3 · Teams as routing

A team already exists as data: each kit in routing/teams.json names a lead, build (makers), tests (test writers), a judge and a rungMax, generated from .claude/bake/families/<kit>/team.env. A route whose words name a kit returns that kit's seats, the same way messageShape(tags) already finds the kit for a reply. A route-team is not a group of group-type team. It is a cast for one piece of work, and it ends when the work settles. No entity is minted.

How the members talk, today and after:

Channel Today After
Task comments tasks:comment, the same D1 store as the room; an @mention adds a follows row unchanged; a comment carries the row's parent
The room thread:append to space:one unchanged
hc send Herdr only; logged to ~/.one/fleet/sends.jsonl, never a signal the sender mirrors a one-line thread:append to the row, so the substrate sees the hand-off
Delegation tasks:reassign swaps the @<slug> tag unchanged; the new assignee must already be in the parent's cast

Every member's signal inherits the parent's parent and cast. It may narrow the cast and add tags. The judge's verdict is the closing outcome for the whole team's trace.

The cast is enforced. It is not just asserted. The server reads the parent by id from its own store: the task row, or the stored stamp of the parent signal. It never trusts a cast or parent sent in the body. A child's effective cast is the body's cast intersected with the parent's stored cast, and an empty intersection is refused by name. tasks:reassign refuses an assignee outside the parent's cast. The parent must belong to the caller's group, or the lookup answers "not found", never "forbidden", so the refusal reveals nothing. Row 8 does not land without a written PASS from @security-auditor.

4 · The loop closes

The finding the rest depends on. At the end of the world:route handler (resolvers/subscriptions.ts, LANE 1 and 2 close), the order is: deliver, then mark, then run the reply.

  • With deliver:false, deliveredOk stays true and every tag:<group>:<word> → actor path is marked on selection. The comment says so ("the routing decision itself is the outcome"). That is a deposit on intent, and it is exactly what one message sends.
  • With reply:true, the mark is written before replyFor runs. The reply's success or failure moves no path, neither the actor path nor the model path.
  • With deliver:true, the mark waits for the delivery receipt. An inbox write that arrived is an outcome, but a small one.
  • The CEO lane is unchanged. A route nobody is staked on still triggers the standing workflow and lands on the owner's desk, deliver:false included, and it deposits nothing because no path was chosen.

Why world:pick-model stayed cold. It was not below the warm line of three. There was no answerable row: 20 of the 21 shapes asked returned weights: []. weights is read after answerable(), which drops any row naming a model outside KNOWN_MODELS. So an empty list means no row names a model the router may answer. ONE's read of production confirms both causes. The whole store holds 7 shape: rows. Six sit under do:simple and do:complex and name model:sonnet, model:opus, model:fable and model:model:opus. Those are Claude Code aliases, not ids the router may answer, so answerable() drops every one. The seventh is ts-lib. Only three writers move shape:<shape> → model:<id>:

  1. world:bake-outcome (pass marks, fail warns), which only the bake calls
  2. factory:attempt close with shape + model, which only the card flow and the factory executor call
  3. world:do-event's router lane

The shapes callers actually send have no writer:

  • message, the shape a reply falls back to when none of its tags names a kit
  • design, routing, plan and research
  • the five do:* shapes. world:seed-router would seed them at 0/0 with ids the router may answer, and those rows would then show in weights. None exist in production, so the seed never ran there

Only ts-lib has been baked enough to warm.

A second, separate bug. With no kit, pickModel returns COLD (Haiku) before the rung check runs, at two exits: no rows, and no row past the warm line. So {shape:"design", rung:"irreversible"} answers anthropic/claude-haiku-4.5, measured tonight. The kit path applies the rung first, so only no-kit callers are exposed. The fix checks the rung at every exit. The two fallback exits already answer the cheapest frontier model. The test pins every exit: no shape, no database, a failed read, a thrown read, no rows, below the warm line, all toxic, and warmed.

What warms it:

  • the reply closes its own (shape → model) path from replyFor's result (ok with text marks; an error warns; a timeout moves nothing). The key is the model that ran (usage.model, as factory card 11 already keys the bake), never the model that was picked, so a substitution cannot credit the wrong one
  • one deposit per (signal id, path key), so a retry cannot deposit twice. The delivery and the reply move different paths (actor and model), so neither uses up the other's close. A later, larger outcome on the same path (a task closed done after a reply) adds only the difference up to its own size, never a second full deposit. The ledger of what a signal has already deposited is the signal's own hop[], which is written once and only grows
  • every agent turn that carries a shape does the same through trace
  • bakes keep doing what they do

A tenant's reply must not steer the platform's model choice. That is the reason world:bake-outcome is platform-only. So tenant outcomes write shape:<group>:<shape>, and the pick reads the group key before the platform key. @security-auditor owns this seam.

Magnitude, against mark(edge, amount) (substrate.ts:590):

Outcome Deposit
a delivery arrived small, the floor
a reply came back with text the default 1
a task row closed done, or a judge passed larger
a promise kept (do-promise-settle.sh) largest, as today
each of the above failing a warn of the same size

Decay. fade takes one fade-rate per group (one.tql) and halves it for resistance. A delivery path and a proven model path decay at the same rate. A multiplier per path kind is enough: the source prefix, tag: · shape: · promise:, is already the kind. The group dial keeps its meaning.

Selection is not on the list. world:pick-model already draws by Thompson sampling. world:route already explores at 1 − sensitivity. A new selection rule waits until stagnation is observed on honest inputs.

Found on the way

These are two security findings in the same handler. Both are handed to @security-auditor as one row.

  • The marketplace receipt ignores delivery. recordMarketplaceReceipt runs after the mark whether deliveredOk is true or false. That receipt is what a later world:outcome cites before it may grade, so a route that never arrived can still earn a grade. Row 1 writes it only when deliver && deliveredOk; an attempted delivery is not enough.
  • A body field can overwrite the attested sender. The CEO lane calls triggerWorkflows with triggerPayload: { tags, sender, ...payload }, so a sender key in the request body replaces the attested one. Whether any workflow trusts triggerPayload.sender is unverified. Any workflow that does treats a body field as identity.

5 · Measured

asOf 2026-11-16T21:30Z. Every number below was read, not typed.

Read Result How
Model picks, 21 shapes (the 9 bake families, astro-page, the 5 do:* seeds, design, routing, plan, research, chat, message) 1 warm (ts-lib → deepseek/deepseek-v4-flash, net 7.52, cost-per-pass ranking); 20 cold with no answerable row one ask world:pick-model per shape
design at rung irreversible anthropic/claude-haiku-4.5, reason cold same door
Route verdicts, 10 department words, decide:true 8 ceo (finance security design routing sales content legal ops); engineering highway → factory-turn; marketing classified → factory-turn one ask world:route --data '{"tags":[w],"decide":true}'
Paths in the TypeDB brain 13,693 paths · 5,254 actors · 16,595 things one ask world:state
Top 20 highways 17 of 20 run between agent:researcher, agent:analyst, agent:designer, agent:builder and agent:marketer. The only code in the repo that names those actors is pay/tools/simulate-market.ts, a market simulation. Two more are self-loops (one→one, tony→tony) same read
Subscribers of routing, finance, security, design 0 each one ask world:subscribers

How to read these.

  • A verdict is not a delivery. decide:true reads only the tag:<group>:<word> rows in claw_paths. It skips the staked lane and explore, so 8 ceo verdicts say "nothing learned". They do not say "8 signals reached the CEO".
  • Two subscription stores. world:subscribers reads world:sub:<tag> rows in claw_paths (written by world:subscribe). The staked lane of world:route reads the D1 follows table (written by subscriptions:register, world:sync-subscriptions and the agent writer). So "0 subscribers of routing" sits beside a trailkeeper whose agent.md stakes routing. That is two answers to "who follows this word". It is named here as a decision for @architect and is not filed as a row: this design needs neither store to change.
  • The strongest learned paths are a simulation's trades. Any reader of highways today learns from a test, not from routed work.

ONE's read of production D1, about 2026-11-16T22:00Z (05:00 local), on the v3-prod primary, rows_written 0, using the queries below:

Read Result
Model calls through the gateway that carry tags 9,443 of 18,116 gateway_calls rows
claw_paths by source prefix announce 55,287, all weighted · one 9,283 (9,282 weighted) · inbox 1,712 · vespio 720 · tag 289 · tracking 279 · template 176 · moverchat 152 · close 105 · deploy 97 · a long tail, including raw hashes and task ids used as sources
shape: rows, the whole store 7: do:simple → model:sonnet 0.1, model:opus 2.36, model:model:opus 1.49 · do:complex → model:opus 2.40, model:fable 0.89, model:model:opus 1.33 · ts-lib → deepseek/deepseek-v4-flash 8.46 (resistance 0.94)

What ONE's read shows.

  • The routing keys are a rounding error. The tag:<group>:<word> rows, the ones world:route ranks on, number 289. The announce: rows number 55,287.
  • The announce rows are an unread store that only grows. Every arrival of a world:announce fan-out deposits on announce:<tags joined by +> → actor (resolvers/subscriptions.ts, the fan-out). The code's own comment says nothing ranks on that key (readActorReputation excludes it by design, and the route reads tag:), and no scheduled fade reaches the prefix. The key also changes with every tag combination, so the count grows with traffic and never falls. The deposit fires on a real arrival, so it is not a lie, but nothing reads it.
  • model:model:opus is a doubled prefix. world:do-event writes model:${data.model} without stripping a prefix the caller already sent. do-auto.sh sends model=$CONDUCTOR_MODEL, which it copies from world:pick-model's answer. Until 1820bb4bc that answer was the stored key (model:opus), so the key was prefixed twice. The read side answers bare ids now, but the writer still does not normalise. In the same handler, a do-event with a shape and a model but no success or composite marks: wonOrLost defaults to true. That is a deposit with no outcome behind it.

The queries, read-only:

-- signals carrying tags
SELECT COUNT(*) AS n,
  SUM(json_extract(content_json,'$.meta.tags') IS NOT NULL) AS tagged
FROM messages;
SELECT COUNT(*) AS n, SUM(tags IS NOT NULL AND tags <> '') AS tagged
FROM gateway_calls;
-- weighted paths, by kind
SELECT substr(source,1,instr(source||':',':')-1) AS kind,
  COUNT(*) AS n, SUM(strength>0 OR resistance>0) AS weighted,
  SUM(strength-resistance>=3) AS warm
FROM claw_paths GROUP BY kind ORDER BY n DESC;
-- every shape-to-model row, answerable or not
SELECT source, target, strength, resistance
FROM claw_paths WHERE source LIKE 'shape:%' ORDER BY source;

6 · The rows

Filed under one parent in group one with tasks:subtask, chained with blockedBy, and none claimed. They are ordered measurement, magnitude, decay. The parent is this file's root:. The child ids are on the board, so this file never goes stale on them.

Rank Row Blocked by
1 Route deposits on the outcome, never on selection; the marketplace receipt only after a delivery —
2 Irreversible rung checked at every exit of the pick —
3 Envelope: shape, parent and cast on SignalMeta, with the allow-lists and every receiver's meta declaration in the same change; hops append rung/model/skill —
4 Reply closes its shape-to-model path on the model that ran, once per signal, with the group key's writer and reader together 1
5 Route records the rung that answered 3
6 Deposit proportional to the outcome 1, 4
7 One answer: route returns model, kit, seats, skills and trace 2, 3
8 Teams as routing: kit seats, cast narrowing, hc hand-offs mirrored 7
9 Fade by path kind 6
10 Every surface moves together for the new fields (CLI, docs, llms.txt) 7, 8
11 Security: the attested sender cannot be overwritten in the CEO trigger payload —
12 world:do-event strips a prefixed model id before it writes, refuses to mark without an outcome, and the six legacy do:* rows are re-keyed or faded —
13 Announce paths: fade the announce: prefix on the schedule, and stop the key growing per tag combination —

Rows 10 to 13 sit outside the nine-item schedule above. Row 10 is the every-surface close, and rows 11 to 13 were found on the way. None of them changes the proof.

Every surface

Surface Changes
Schema (schema/one.tql) None. Path keys are strings; group.fade-rate keeps its meaning; no type, no attribute
SDK (packages/sdk/src/receivers.ts) additive optional response fields on world:route; meta declared where it is not yet; no new receiver, so signals-parity does not move
API (resolvers) resolvers/subscriptions.ts (deposit order, answer fields), resolvers/router.ts (rung first, group key), routing/reply-model.ts (close the path), signal-meta.ts (fields, allow-lists), substrate.ts (fade by kind)
CLI one message and one ask world:route print the model, team and rung; packages/cli README
MCP world:route is not on the derived MCP list today; if it joins, the new fields come from the registry with nothing written by hand
Chat the reply already runs pickReplyModel; it gains the close
Docs text/routing.md (§ The Universal Router, § Weight Mechanics), text/one-router.md (why cold), llms.txt route line, text/dictionary.md (cast)

Out of scope

  • A new selection rule (Ant System's probabilistic choice over a weighted sum). This waits for observed stagnation.
  • Merging the two subscription stores. It is named above and left for @architect.
  • Cleaning the simulated highways out of the brain. That is a data decision, not a design one.
  • Herdr itself. hc send stays a terminal tool, and only its hand-off is mirrored.