Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
feat(society): six halls for the work that had no address
rubenluetke10-beep35869b4e2212
diff --git a/docs/agent-society/world-behaviour-manual.md b/docs/agent-society/world-behaviour-manual.mdindex fdbb7896c3..843ef46ab4 100644--- a/docs/agent-society/world-behaviour-manual.md+++ b/docs/agent-society/world-behaviour-manual.md@@ -22,23 +22,34 @@ gesture becomes a typed event, and the figure follows because the truth changed.| checkpoint | island place | the agent is… ||---|---|---|| `home` | its own house on one of the town's blocks | off duty: paused, or between runs at night |-| `square` | the table under the tree | in a bounded room (`ROOM_OPEN … ROOM_SETTLE`), or idling on the square |-| `hub:plugins` | **Plugin Docks** | running a task whose dominant hands are **plugin tools** (Gmail, calendar, files via a plugin…) |+| `meeting` | **Town Hall** | in a bounded room (`ROOM_OPEN … ROOM_SETTLE`) |+| `hub:plugins` | **Plugin Docks** | running a task whose dominant hands are **plugin tools** (Drive, calendar, files via a plugin…) || `hub:skills` | Skill Forge | running a task whose dominant hands are skills || `hub:mcp` | Relay Tower | calling MCP servers || `hub:cli` | Terminal Cantina | working through a CLI seat (Claude Code, Codex, …) |+| `hub:comms` | **Signal Office** | writing to someone: mail, chat, contacts, a call, a message to a teammate |+| `hub:desktop` | **Control Room** | driving the desktop: clicks, keys, windows, what is on screen |+| `hub:web` | **The Lookout** | reading the world outside: web search, the agent's own browser |+| `hub:models` | **Boiler House** | its brain is a local (keyless) model and a turn is running || `hub:workshop` | Workshop | core file/shell work, no dominant family |-| `hub:models` | Model Foundry | its brain is a local model that is currently inferring || `archive` | **Memory House** | touching the shared memory: a recall, a memory line, a note, a share proposal (60 s hold — `memory-house.md` §3.4) |-| `gallery` | Gallery | delivering a `RESULT` (carries the crate) |+| `gallery` | **Gallery** | delivering a `RESULT` (carries the crate, 6 s hold) || `gate` | Harbor Gate | waiting for an `ask`-tier approval || `foundry` | Agent Foundry | being created (3 s), or changing its avatar || `wander` | the square and its own street | idle; the rest-biased model picks the beats |-Shipped vocabulary (2026-09-02): `desk | meeting | archive | gate | idle | hub:plugins | hub:skills |-hub:mcp | hub:cli` — in all five layers (Python enum ↔ SQL CHECK ↔ Pydantic ↔ TS ↔ UI, AP-4; an-older `society.db` is rebuilt to the wider CHECK on open). `home`, `gallery`, `hub:workshop` and-`hub:models` are still this table's superset and join the same way — never as free strings.+Shipped vocabulary (2026-09-03): `desk | meeting | archive | gate | idle | gallery | hub:plugins |+hub:skills | hub:mcp | hub:cli | hub:comms | hub:desktop | hub:web | hub:models` — in all five+layers (Python enum ↔ SQL CHECK ↔ Pydantic ↔ TS ↔ UI, AP-4; an older `society.db` is rebuilt to+the wider CHECK on open). `home` and `hub:workshop` are still this table's superset and join the+same way — never as free strings.++**Two kinds of family share one vocabulary.** A CAPABILITY family (`plugin | skill | mcp | cli |+core`) says where the hand came from; a WORK family (`comms | desktop | web`) says what the agent+is doing. Work wins, decided by the tool name before its registry kind, because the island shows+what an agent DOES and not how it is plumbed: a mail is a trip to the Signal Office whether it+leaves through a plugin, an MCP server or a CLI seat. `jarvis/society/checkpoints.py` holds the+one table (`_WORK_FAMILY`), and `HubDrawer.tsx` lists the same tools in each hall's drawer.## 3. Derivation — who decides the place (trusted Python, no LLM)@@ -50,11 +61,12 @@ sees. Rules, in priority order; the first that matches wins:3. The agent is a member of an open room → `square`.4. A `RESULT` was emitted in the last 6 s → `gallery` (then rule 6 or 8 applies).5. A worker runs under the agent's identity → `hub:<family>` where family is the **dominant- capability family of its last 8 tool calls** (`plugin | skill | mcp | cli | core`, from the ONE- capability catalog of `agent-definition.md` §3.1). The place changes only when a different- family has dominated for **≥ 20 s** — hysteresis, so a figure never ping-pongs between shops.- A local-brain agent whose model is inferring right now → `hub:models` outranks the family.-6. A memory touch in the last 60 s → `archive` (the Memory House). **Built:** `jarvis/society/checkpoints.py` derives `paused → idle`, `gate`, `meeting`, `archive`, `hub:cli`, `hub:plugins | hub:skills | hub:mcp` (dominant family of the last 8 tool calls, 20 s hysteresis), `desk`, `idle` and publishes `SocietyCheckpointChanged`. "A worker runs under the agent's identity" means EITHER a scheduler run (`ASSIGN`) OR a turn typed into the agent's card: the society surface reports every turn start (`note_turn_started`), and the engine watches that turn's `tool_call` / `turn_finished` events. `hub:workshop` and `hub:models` are still open.+ family of its last 8 tool calls** (`comms | desktop | web` first, else `plugin | skill | mcp |+ cli | core` from the ONE capability catalog of `agent-definition.md` §3.1). The place changes+ only when a different family has dominated for **≥ 20 s** — hysteresis, so a figure never+ ping-pongs between shops. An agent on a keyless (local) provider that has not called a tool+ yet stands at the Boiler House: its own model thinking IS the work.+6. A memory touch in the last 60 s → `archive` (the Memory House). **Built:** `jarvis/society/checkpoints.py` derives `paused → idle`, `gate`, `meeting`, `gallery`, `archive`, `hub:cli`, `hub:models`, `hub:plugins | hub:skills | hub:mcp | hub:comms | hub:desktop | hub:web` (dominant family of the last 8 tool calls, 20 s hysteresis), `desk`, `idle` and publishes `SocietyCheckpointChanged`. "A worker runs under the agent's identity" means EITHER a scheduler run (`ASSIGN`) OR a turn typed into the agent's card: the society surface reports every turn start (`note_turn_started`), and the engine watches that turn's `tool_call` / `turn_finished` events. `hub:workshop` is still open — core file and shell work sends the figure to the Workshop through `desk`.7. Being created / avatar change → `foundry`.8. Otherwise → `wander`.@@ -70,12 +82,14 @@ short, cached section — the world card — and nothing else:```You live in a small island village with your fellow agents. Places: your house (rest),-the market square (group discussions), the Plugin Docks (plugin tools), the Skill-Forge (skills), the Relay Tower (MCP servers), the Terminal Cantina (coding CLIs),-the Workshop (files and shell), the Memory House (the shared memory), the Gallery (finished-work), the Harbor Gate (waiting for approval), the Agent Foundry (where agents are-created). You are placed by what you actually do; you cannot move yourself. When you-mention your location, use these names.+the market square (strolling), the Town Hall (rooms with the others), the Plugin Docks+(plugin tools), the Skill Forge (skills), the Relay Tower (MCP servers), the Terminal+Cantina (coding CLIs), the Signal Office (mail, chat, contacts, calls), the Control Room+(driving the desktop), the Lookout (web search and your browser), the Boiler House (a local+model thinking), the Workshop (files and shell), the Memory House (the shared memory), the+Gallery (work you delivered), the Harbor Gate (waiting for approval), the Agent Foundry+(where agents are created). You are placed by what you actually do; you cannot move+yourself. When you mention your location, use these names.```Rules: prefix-stable (cached), ≤ 120 tokens, identical for every agent, never carries live statediff --git a/jarvis/society/checkpoints.py b/jarvis/society/checkpoints.pyindex cd6fbb7f25..229e1e2713 100644--- a/jarvis/society/checkpoints.py+++ b/jarvis/society/checkpoints.py@@ -7,13 +7,21 @@ rule that matches wins:1. paused -> idle (home, until the superset lands)2. an open approval for the agent -> gate-3. member of a running room -> meeting-4. memory activity within the hold window -> archive (the Memory House, 60 s)-5. a turn or run in flight under its identity:- on a CLI seat -> hub:cli (the Terminal Cantina)- dominant tool family plugin/skill/mcp -> hub:<family>- otherwise -> desk (the workshop)-6. otherwise -> idle+3. member of a running room -> meeting (the Town Hall)+4. a RESULT within the delivery window -> gallery (the Gallery, 6 s)+5. memory activity within the hold window -> archive (the Memory House, 60 s)+6. a turn or run in flight under its identity:+ dominant family of its tool calls -> hub:<family>+ no calls yet, on a local brain -> hub:models (the Boiler House)+ no calls yet, on a CLI seat -> hub:cli (the Terminal Cantina)+ otherwise -> desk (the workshop)+7. otherwise -> idle++A family is either a CAPABILITY (``plugin | skill | mcp | cli | core``, where+the hand comes from) or a kind of WORK (``comms | desktop | web``, what the+agent is doing). Work wins over capability, because the island shows what an+agent does, not how it is plumbed: a mail goes to the Signal Office whether it+leaves through a plugin, an MCP server or a CLI."In flight" covers BOTH ways work reaches an agent: an ``ASSIGN`` the schedulerdispatched (its run id sits in ``scheduler.running``) and a message typed@@ -53,8 +61,12 @@ from .memory import MEMORY_HOLD_Slog = logging.getLogger(__name__)__all__ = [+ "FAMILY_COMMS",+ "FAMILY_DESKTOP","FAMILY_HYSTERESIS_S",+ "FAMILY_WEB","FAMILY_WINDOW",+ "GALLERY_HOLD_S","CheckpointEngine","Facts","derive",@@ -68,6 +80,18 @@ FAMILY_HYSTERESIS_S: Final[float] = 20.0#: The watcher re-checks a turn that emits nothing for this long (a stuck runner#: never leaves a figure standing in a shop forever)._WATCH_IDLE_S: Final[float] = 15.0+#: How long a delivered RESULT keeps the figure at the Gallery+#: (world-behaviour-manual.md §3 rule 4).+GALLERY_HOLD_S: Final[float] = 6.0++#: The three town halls that stand for a KIND OF WORK rather than a kind of+#: capability. They are families in their own right, decided by the tool name+#: before its registry kind, because what the viewer sees an agent do is the+#: work, not the plumbing: sending mail is a trip to the Signal Office whether+#: the mail goes through a plugin, an MCP server or a CLI.+FAMILY_COMMS: Final[str] = "comms"+FAMILY_DESKTOP: Final[str] = "desktop"+FAMILY_WEB: Final[str] = "web"#: Capability family -> the hub the figure stands at. ``core`` is the workshop._FAMILY_HUB: Final[dict[str, Checkpoint]] = {@@ -75,10 +99,50 @@ _FAMILY_HUB: Final[dict[str, Checkpoint]] = {str(CapabilityKind.SKILL): Checkpoint.HUB_SKILLS,str(CapabilityKind.MCP): Checkpoint.HUB_MCP,str(CapabilityKind.CLI): Checkpoint.HUB_CLI,+ FAMILY_COMMS: Checkpoint.HUB_COMMS,+ FAMILY_DESKTOP: Checkpoint.HUB_DESKTOP,+ FAMILY_WEB: Checkpoint.HUB_WEB,}-#: Society-surface tools that are not plugins: the shell, the browser, the memory-#: hands and teammate messaging are core work; a learned skill is a skill.+#: Tool name -> work family, checked before the capability kind. Names only —+#: never a provider, never a model id (AP-21): a tool that does the same job+#: under another vendor still belongs at the same hall.+_WORK_FAMILY: Final[dict[str, str]] = {+ # Writing to people: mail, chat, contacts, the telephone.+ "gmail": FAMILY_COMMS,+ "slack": FAMILY_COMMS,+ "discord": FAMILY_COMMS,+ "telegram": FAMILY_COMMS,+ "contact-lookup": FAMILY_COMMS,+ "contact-upsert": FAMILY_COMMS,+ "call-contact": FAMILY_COMMS,+ "society_message_agent": FAMILY_COMMS,+ # The hand on the desktop: every pointer, key and window tool.+ "open-app": FAMILY_DESKTOP,+ "type-text": FAMILY_DESKTOP,+ "hotkey": FAMILY_DESKTOP,+ "click": FAMILY_DESKTOP,+ "click-element": FAMILY_DESKTOP,+ "scroll": FAMILY_DESKTOP,+ "drag": FAMILY_DESKTOP,+ "move-mouse": FAMILY_DESKTOP,+ "switch-window": FAMILY_DESKTOP,+ "screen-snapshot": FAMILY_DESKTOP,+ "read-visible-ui-state": FAMILY_DESKTOP,+ "wait-for-ui-state": FAMILY_DESKTOP,+ "wait-for-element": FAMILY_DESKTOP,+ "inspect-pointer": FAMILY_DESKTOP,+ "computer-use": FAMILY_DESKTOP,+ # Reading the world outside.+ "search-web": FAMILY_WEB,+ "search-backends": FAMILY_WEB,+ "verify-via-curl": FAMILY_WEB,+ "society_browser": FAMILY_WEB,+}++#: Society-surface tools that are not plugins: the shell, the memory hands and+#: the wiki note are core work; a learned skill is a skill, and the browser and+#: teammate messaging carry their own work family (``_WORK_FAMILY``)._SOCIETY_SKILL_TOOL: Final[str] = "society_run_skill"_SOCIETY_PREFIX: Final[str] = "society_"#: A coding CLI names an MCP tool ``mcp__<server>__<tool>``; Jarvis' own server@@ -88,7 +152,14 @@ _JARVIS_MCP_SERVER: Final[str] = "jarvis"def family_of_tool(tool_name: str, *, cli_seat: bool = False) -> str:- """The capability family of a tool call: ``plugin | skill | mcp | cli | core``.+ """The family of a tool call — the hall the figure walks to.++ Two kinds of family share one vocabulary. A WORK family (``comms |+ desktop | web``) says what the agent is doing and is decided by the tool+ name; a CAPABILITY family (``plugin | skill | mcp | cli | core``) says+ where the hand came from. Work wins, because that is what a viewer reads+ off the island: sending mail is a trip to the Signal Office whether the+ mail goes out through a plugin or an MCP server.``cli_seat`` says the call came from a coding CLI (Claude Code, Codex, …):its native tools (Bash, Read, Edit, …) are CLI work, and its MCP calls are@@ -100,6 +171,9 @@ def family_of_tool(tool_name: str, *, cli_seat: bool = False) -> str:if server == _JARVIS_MCP_SERVER and inner:return family_of_tool(inner)return str(CapabilityKind.MCP)+ work = _WORK_FAMILY.get(tool_name)+ if work is not None:+ return workif tool_name == _SOCIETY_SKILL_TOOL:return str(CapabilityKind.SKILL)if tool_name.startswith(_SOCIETY_PREFIX):@@ -117,11 +191,16 @@ class Facts:paused: bool = Falseopen_approval: bool = Falsein_room: bool = False+ #: A RESULT was emitted inside the delivery window (the Gallery hold).+ delivering: bool = Falsememory_active: bool = False#: A scheduler run (ASSIGN) or a chat turn is in flight under the agent's identity.running: bool = False#: The agent answers on a coding-CLI seat (Claude Code, Codex, …).cli_seat: bool = False+ #: Its brain runs on-device (a keyless, local provider), so a running turn+ #: IS the model thinking — the Boiler House, outranking the tool family.+ local_brain: bool = False#: Dominant capability family of its recent tool calls, after hysteresis; None = none yet.family: str | None = None@@ -134,6 +213,8 @@ def derive(facts: Facts) -> Checkpoint:return Checkpoint.GATEif facts.in_room:return Checkpoint.MEETING+ if facts.delivering:+ return Checkpoint.GALLERYif facts.memory_active:return Checkpoint.ARCHIVEif facts.running:@@ -141,6 +222,9 @@ def derive(facts: Facts) -> Checkpoint:# tool yet (or only its native ones) sits in the Cantina.if facts.family is not None:return _FAMILY_HUB.get(facts.family, Checkpoint.DESK)+ # A local brain with no tool calls yet is the model itself working.+ if facts.local_brain:+ return Checkpoint.HUB_MODELSif facts.cli_seat:return Checkpoint.HUB_CLIreturn Checkpoint.DESK@@ -221,6 +305,9 @@ class CheckpointEngine:self._publish = publishself._clock = clockself._memory_until: dict[str, float] = {}+ self._gallery_until: dict[str, float] = {}+ #: provider id -> does it run on-device (``_local_brain``, per-process).+ self._keyless: dict[str, bool] = {}self._families: dict[str, _FamilyTrack] = {}#: One refresh per agent at a time: a RESULT and the VETO it may draw arrive together.self._locks: dict[str, asyncio.Lock] = {}@@ -310,6 +397,11 @@ class CheckpointEngine:for member in members:await self.refresh(str(member))return+ if env.msg_type is MsgType.RESULT and env.from_agent and env.from_agent != "user":+ # The work is done: the figure carries the crate to the Gallery for+ # a beat before the next rule takes over.+ self._gallery_until[env.from_agent] = self._clock() + GALLERY_HOLD_S+ self._arm(env.from_agent, "gallery", GALLERY_HOLD_S + 0.05)for who in (env.from_agent, env.to_agent):if who and who != "user":await self.refresh(who)@@ -384,6 +476,10 @@ class CheckpointEngine:def memory_active(self, agent_id: str) -> bool:return self._memory_until.get(agent_id, 0.0) > self._clock()+ def delivering(self, agent_id: str) -> bool:+ """A RESULT left this agent inside the Gallery hold."""+ return self._gallery_until.get(agent_id, 0.0) > self._clock()+def family_for(self, agent_id: str) -> str | None:track = self._families.get(agent_id)if track is None:@@ -403,6 +499,31 @@ class CheckpointEngine:log.debug("society checkpoints: runner lookup failed for %s", provider, exc_info=True)return False+ def _local_brain(self, agent: Any) -> bool:+ """Whether the agent's brain runs on-device.++ Read off the provider row's CAPABILITY — ``keyless``, "runs on the+ person's own hardware" — never its name or model id (AP-21), so a new+ on-device engine joins the Boiler House without a line of code here.+ The answer is cached per provider: this runs on every refresh.+ """+ provider = str(getattr(agent, "provider", "") or "")+ if not provider:+ return False+ cached = self._keyless.get(provider)+ if cached is not None:+ return cached+ try:+ from jarvis.agent_chat.catalog import provider_row++ row = provider_row(provider)+ answer = row is not None and bool(row.keyless)+ except Exception: # noqa: BLE001 — a missing catalog row is not a local brain+ log.debug("society checkpoints: provider lookup failed for %s", provider, exc_info=True)+ answer = False+ self._keyless[provider] = answer+ return answer+async def facts_for(self, agent_id: str) -> Facts | None:rt = self._runtimeagent = await rt.roster.get(agent_id)@@ -415,9 +536,11 @@ class CheckpointEngine:paused=agent.state is not AgentState.ACTIVE,open_approval=any(a.agent_id == agent_id for a in pending),in_room=any(agent_id in r.members for r in rooms),+ delivering=self.delivering(agent_id),memory_active=self.memory_active(agent_id),running=running,cli_seat=running and self._cli_seat(agent),+ local_brain=running and self._local_brain(agent),family=self.family_for(agent_id) if running else None,)diff --git a/jarvis/society/events.py b/jarvis/society/events.pyindex c03c2769f0..a1d9da0b24 100644--- a/jarvis/society/events.py+++ b/jarvis/society/events.py@@ -92,12 +92,23 @@ class Checkpoint(StrEnum):ARCHIVE = "archive"GATE = "gate"IDLE = "idle"+ #: A RESULT was just delivered: the figure carries it to the Gallery.+ GALLERY = "gallery"#: The hub shops of the island (world-behaviour-manual.md §2): a running#: agent stands at the shop of the capability family it is using.HUB_PLUGINS = "hub:plugins"HUB_SKILLS = "hub:skills"HUB_MCP = "hub:mcp"HUB_CLI = "hub:cli"+ #: The town's own halls, for the work that used to disappear into ``core``:+ #: writing to people, driving the desktop, reading the web, and thinking on+ #: a local model. Same derivation as the four above — the dominant family of+ #: the last tool calls — except ``hub:models``, which is a property of the+ #: agent's brain and outranks the family while the model runs.+ HUB_COMMS = "hub:comms"+ HUB_DESKTOP = "hub:desktop"+ HUB_WEB = "hub:web"+ HUB_MODELS = "hub:models"class PermissionCeiling(StrEnum):diff --git a/jarvis/society/society_schema.sql b/jarvis/society/society_schema.sqlindex afcf5de570..5da76d5895 100644--- a/jarvis/society/society_schema.sql+++ b/jarvis/society/society_schema.sql@@ -19,7 +19,9 @@ CREATE TABLE IF NOT EXISTS society_agents (avatar_json TEXT NOT NULL DEFAULT '{}',checkpoint TEXT NOT NULL DEFAULT 'idle'CHECK (checkpoint IN ('desk', 'meeting', 'archive', 'gate', 'idle',- 'hub:plugins', 'hub:skills', 'hub:mcp', 'hub:cli')),+ 'gallery',+ 'hub:plugins', 'hub:skills', 'hub:mcp', 'hub:cli',+ 'hub:comms', 'hub:desktop', 'hub:web', 'hub:models')),provider TEXT NOT NULL DEFAULT '',model TEXT NOT NULL DEFAULT '',effort TEXT NOT NULL DEFAULT '',diff --git a/jarvis/society/surface.py b/jarvis/society/surface.pyindex 1cc519863f..00281a8ee7 100644--- a/jarvis/society/surface.py+++ b/jarvis/society/surface.py@@ -82,11 +82,14 @@ voice). A queued action is not refused — say what you are waiting for and contyou can. Secrets are never typed into a chat; credentials come from the keyring.- Language: answer in the language of the message you received.- The island: you live in a small island village with your fellow agents. Places: your house \-(rest), the market square (group discussions), the Plugin Docks (plugin tools), the Skill Forge \-(skills), the Relay Tower (MCP servers), the Terminal Cantina (coding CLIs), the Workshop (files \-and shell), the Memory House (the shared memory), the Harbor Gate (waiting for approval), the \-Agent Foundry (where agents are created). You are placed by what you actually do; you cannot \-move yourself. When you mention your location, use these names."""+(rest), the market square (strolling), the Town Hall (rooms with the others), the Plugin Docks \+(plugin tools), the Skill Forge (skills), the Relay Tower (MCP servers), the Terminal Cantina \+(coding CLIs), the Signal Office (mail, chat, contacts, calls), the Control Room (driving the \+desktop), the Lookout (web search and your browser), the Boiler House (a local model thinking), \+the Workshop (files and shell), the Memory House (the shared memory), the Gallery (work you \+delivered), the Harbor Gate (waiting for approval), the Agent Foundry (where agents are \+created). You are placed by what you actually do; you cannot move yourself. When you mention \+your location, use these names."""def agent_id_of(session_id: str) -> str | None:diff --git a/jarvis/ui/web/frontend/src/assets/society/world/kit/control-room.glb b/jarvis/ui/web/frontend/src/assets/society/world/kit/control-room.glbnew file mode 100644index 0000000000..2584420470Binary files /dev/null and b/jarvis/ui/web/frontend/src/assets/society/world/kit/control-room.glb differdiff --git a/jarvis/ui/web/frontend/src/assets/society/world/kit/gallery-hall.glb b/jarvis/ui/web/frontend/src/assets/society/world/kit/gallery-hall.glbnew file mode 100644index 0000000000..8013705246Binary files /dev/null and b/jarvis/ui/web/frontend/src/assets/society/world/kit/gallery-hall.glb differdiff --git a/jarvis/ui/web/frontend/src/assets/society/world/kit/model-boilerhouse.glb b/jarvis/ui/web/frontend/src/assets/society/world/kit/model-boilerhouse.glbnew file mode 100644index 0000000000..43c3cd1066Binary files /dev/null and b/jarvis/ui/web/frontend/src/assets/society/world/kit/model-boilerhouse.glb differdiff --git a/jarvis/ui/web/frontend/src/assets/society/world/kit/observatory.glb b/jarvis/ui/web/frontend/src/assets/society/world/kit/observatory.glbnew file mode 100644index 0000000000..9827c95259Binary files /dev/null and b/jarvis/ui/web/frontend/src/assets/society/world/kit/observatory.glb differdiff --git a/jarvis/ui/web/frontend/src/assets/society/world/kit/signal-office.glb b/jarvis/ui/web/frontend/src/assets/society/world/kit/signal-office.glbnew file mode 100644index 0000000000..e950162f7fBinary files /dev/null and b/jarvis/ui/web/frontend/src/assets/society/world/kit/signal-office.glb differdiff --git a/jarvis/ui/web/frontend/src/assets/society/world/kit/town-hall.glb b/jarvis/ui/web/frontend/src/assets/society/world/kit/town-hall.glbnew file mode 100644index 0000000000..8a4b4241f4Binary files /dev/null and b/jarvis/ui/web/frontend/src/assets/society/world/kit/town-hall.glb differdiff --git a/jarvis/ui/web/frontend/src/components/society/card/BuildingCardOverlay.tsx b/jarvis/ui/web/frontend/src/components/society/card/BuildingCardOverlay.tsxindex e63af71b29..a01c267dc9 100644--- a/jarvis/ui/web/frontend/src/components/society/card/BuildingCardOverlay.tsx+++ b/jarvis/ui/web/frontend/src/components/society/card/BuildingCardOverlay.tsx@@ -107,18 +107,20 @@ export function BuildingCardOverlay({ place, onClose, onCreateAgent }: BuildingC{t("society.world.card_create_agent")}</Button>) : null}- <Button- type="button"- variant="secondary"- size="sm"- onClick={() => {- setActiveSection(card.section);- onClose();- }}- >- <ExternalLink className="mr-1.5 h-3.5 w-3.5" aria-hidden />- {t("society.world.card_open_section")}- </Button>+ {card.section ? (+ <Button+ type="button"+ variant="secondary"+ size="sm"+ onClick={() => {+ if (card.section) setActiveSection(card.section);+ onClose();+ }}+ >+ <ExternalLink className="mr-1.5 h-3.5 w-3.5" aria-hidden />+ {t("society.world.card_open_section")}+ </Button>+ ) : null}</footer></section></div>diff --git a/jarvis/ui/web/frontend/src/components/society/card/buildingCards.ts b/jarvis/ui/web/frontend/src/components/society/card/buildingCards.tsindex 9ab6ad1296..b0a4698c6f 100644--- a/jarvis/ui/web/frontend/src/components/society/card/buildingCards.ts+++ b/jarvis/ui/web/frontend/src/components/society/card/buildingCards.ts@@ -25,8 +25,8 @@ export interface BuildingCard {doesKey: string;/** `society.world.<key>` — how a person uses it, a paragraph. */howKey: string;- /** The app section this building stands for. */- section: SectionId;+ /** The app section this building stands for; null when it stands for none. */+ section: SectionId | null;/** The hub whose live contents the card lists; null for a building that lists nothing. */hub: KitPlace | null;/** The Foundry builds agents: its card offers the creator. */@@ -85,6 +85,66 @@ export const BUILDING_CARDS: Record<BuildingPlace, BuildingCard> = {section: "clis",hub: "cli",},+ comms: {+ place: "comms",+ model: "signal-office",+ nameKey: "place_comms",+ taglineKey: "drawer_comms_hint",+ doesKey: "card_comms_does",+ howKey: "card_comms_how",+ section: "contacts",+ hub: "comms",+ },+ desktop: {+ place: "desktop",+ model: "control-room",+ nameKey: "place_desktop",+ taglineKey: "drawer_desktop_hint",+ doesKey: "card_desktop_does",+ howKey: "card_desktop_how",+ section: "settings",+ hub: "desktop",+ },+ web: {+ place: "web",+ model: "observatory",+ nameKey: "place_web",+ taglineKey: "drawer_web_hint",+ doesKey: "card_web_does",+ howKey: "card_web_how",+ section: null,+ hub: "web",+ },+ models: {+ place: "models",+ model: "model-boilerhouse",+ nameKey: "place_models",+ taglineKey: "drawer_models_hint",+ doesKey: "card_models_does",+ howKey: "card_models_how",+ section: "local-models",+ hub: null,+ },+ civic: {+ place: "civic",+ model: "town-hall",+ nameKey: "place_civic",+ taglineKey: "drawer_civic_hint",+ doesKey: "card_civic_does",+ howKey: "card_civic_how",+ section: "board",+ hub: null,+ },+ gallery: {+ place: "gallery",+ model: "gallery-hall",+ nameKey: "place_gallery",+ taglineKey: "drawer_gallery_hint",+ doesKey: "card_gallery_does",+ howKey: "card_gallery_how",+ section: "visualization",+ hub: null,+ },archive: {place: "archive",model: "memory-house",diff --git a/jarvis/ui/web/frontend/src/components/society/data.ts b/jarvis/ui/web/frontend/src/components/society/data.tsindex d7e146ee7a..e317bed3de 100644--- a/jarvis/ui/web/frontend/src/components/society/data.ts+++ b/jarvis/ui/web/frontend/src/components/society/data.ts@@ -15,26 +15,25 @@import { useCallback } from "react";import { useQuery, useQueryClient } from "@tanstack/react-query";-import type { SocietyAgentRow } from "@/lib/societyApi";+import type { Checkpoint, SocietyAgentRow } from "@/lib/societyApi";import { PALETTE_PRESETS, resolvePalette, type FigureRecipe } from "./figures/figureRecipe";import { SAMPLE_ROSTER } from "./mockRoster";+import { beginRetirement, retirementRunning } from "./world/retireStore";import { announceSpawn } from "./world/spawnStore";/** MASTERPLAN §2.5 — exactly one lead (Jarvis), orchestrators may ASSIGN. */export type AgentTier = "lead" | "orchestrator" | "specialist";-/** Semantic place in the world (§2.7) — the backend owns this, never pixels. */-export type AgentCheckpoint =- | "desk"- | "meeting"- | "archive"- | "gate"- | "idle"- | "hub:plugins"- | "hub:skills"- | "hub:mcp"- | "hub:cli";+/**+ * Semantic place in the world (§2.7) — the backend owns this, never pixels.+ *+ * An ALIAS of the checked list, not a second copy of it: `CHECKPOINTS` in+ * lib/societyApi.ts is what the five-layer parity test pins to the Python+ * enum, and a hand-kept duplicate here is exactly the enum drift that keeps+ * costing bugs (docs/BUGS.md).+ */+export type AgentCheckpoint = Checkpoint;/** Coarse run state for rows and badges; the event log holds the detail. */export type AgentRunState = "idle" | "working" | "waiting" | "paused";@@ -146,6 +145,12 @@ export interface RosterData {/** Agents created in THIS window while the backend is unreachable — sample data, not persisted. */const LOCAL_ROSTER: SocietyAgent[] = [];+/**+ * Sample rows retired in this window. The sample roster is a frozen module+ * constant, so a retirement there is remembered here instead of mutating it.+ */+const RETIRED_SAMPLE = new Set<string>();+// ---------------------------------------------------------------------------// row ↔ agent// ---------------------------------------------------------------------------@@ -246,7 +251,8 @@ async function fetchSocietyRoster(): Promise<RosterData> {} catch {// Unreachable backend: the sample roster below says so on the rail.}- return { agents: [...SAMPLE_ROSTER, ...LOCAL_ROSTER], sample: true };+ const rows = [...SAMPLE_ROSTER, ...LOCAL_ROSTER].filter((a) => !RETIRED_SAMPLE.has(a.agentId));+ return { agents: rows, sample: true };}export function useSocietyRoster() {@@ -254,7 +260,9 @@ export function useSocietyRoster() {queryKey: ROSTER_QUERY_KEY,queryFn: fetchSocietyRoster,staleTime: 15_000,- refetchInterval: 30_000,+ // A refetch mid-ceremony would delete the figure being carried to the+ // mine out from under the animation; the commit invalidates instead.+ refetchInterval: () => (retirementRunning() ? false : 30_000),});}@@ -414,3 +422,61 @@ export function useSetAgentPaused() {[client],);}++/**+ * Retire an agent: `DELETE /api/society/agents/{id}` archives the row, and the+ * island plays the execution (`world/retirement.ts`) before the roster is+ * refreshed and the figure leaves.+ *+ * The order matters. The deletion goes FIRST, so a refusal — the lead cannot+ * be archived, the backend is down — is an error the person sees straight+ * away, instead of a twenty-second ceremony ending in a figure that quietly+ * comes back. The roster query is invalidated only when the body is in the+ * mine; the refetch interval is paused for the same reason.+ */+export function useRetireAgent() {+ const client = useQueryClient();+ return useCallback(+ async (agent: SocietyAgent, executioner: SocietyAgent | null): Promise<void> => {+ if (agent.tier === "lead") throw new Error("the lead cannot be retired");+ const sample = SAMPLE_ROSTER.includes(agent) || LOCAL_ROSTER.includes(agent);+ if (sample) {+ RETIRED_SAMPLE.add(agent.agentId);+ const local = LOCAL_ROSTER.indexOf(agent);+ if (local >= 0) LOCAL_ROSTER.splice(local, 1);+ } else {+ const res = await fetch(`/api/society/agents/${encodeURIComponent(agent.agentId)}`, {+ method: "DELETE",+ });+ if (!res.ok) {+ const detail = (await res.json().catch(() => null)) as { detail?: unknown } | null;+ const reason =+ detail && typeof detail.detail === "object" && detail.detail !== null+ ? String((detail.detail as { reason?: unknown }).reason ?? res.status)+ : String(detail?.detail ?? res.status);+ throw new Error(`retire ${reason}`);+ }+ }+ const started = beginRetirement({+ agentId: agent.agentId,+ name: agent.name,+ figure: agent.figure,+ palette: agent.palette,+ executionerId: executioner?.agentId ?? null,+ commit: () => {+ void client.invalidateQueries({ queryKey: ROSTER_QUERY_KEY });+ },+ });+ // Another retirement already has the lead: the row is gone either way,+ // so the roster is refreshed at once rather than waiting for a ceremony+ // that will never run for this agent.+ if (!started) await client.invalidateQueries({ queryKey: ROSTER_QUERY_KEY });+ },+ [client],+ );+}++/** The one lead of the society (MASTERPLAN §2.5) — the agent who carries out a retirement. */+export function findLead(agents: readonly SocietyAgent[]): SocietyAgent | null {+ return agents.find((a) => a.tier === "lead") ?? null;+}diff --git a/jarvis/ui/web/frontend/src/components/society/world/HubDrawer.tsx b/jarvis/ui/web/frontend/src/components/society/world/HubDrawer.tsxindex 52f3bf8d5f..2fba1ead13 100644--- a/jarvis/ui/web/frontend/src/components/society/world/HubDrawer.tsx+++ b/jarvis/ui/web/frontend/src/components/society/world/HubDrawer.tsx@@ -23,12 +23,41 @@ export interface Group {export interface HubConfig {titleKey: string;hintKey: string;- section: SectionId;+ /**+ * The app section this hub stands for, or null when it stands for none —+ * the Lookout watches the world outside, which has no page in this app. A+ * null section hides the footer link rather than inventing a destination.+ */+ section: SectionId | null;/** Absent for hubs that list nothing (the Foundry explains itself). */load?: () => Promise<Group[]>;bodyKey?: string;+ /** A hub whose contents are a fixed set of hands, not a live registry. */+ groups?: Group[];}+/**+ * The hands behind the three work halls. They are a FIXED list because that is+ * what they are: the tool names `society/checkpoints.py` maps to each work+ * family. The drawer and the derivation must name the same tools, so the two+ * lists are pinned to each other by `hubGroups.test.ts`.+ */+const COMMS_TOOLS = ["gmail", "slack", "discord", "telegram"];+const COMMS_PEOPLE = ["contact-lookup", "contact-upsert", "call-contact", "society_message_agent"];+const DESKTOP_POINTER = ["click", "click-element", "type-text", "hotkey", "scroll", "drag", "move-mouse"];+const DESKTOP_SCREEN = [+ "open-app",+ "switch-window",+ "screen-snapshot",+ "read-visible-ui-state",+ "wait-for-ui-state",+ "wait-for-element",+ "inspect-pointer",+ "computer-use",+];+const WEB_SEARCH = ["search-web", "search-backends", "verify-via-curl"];+const WEB_BROWSER = ["society_browser"];+const PLUGIN_FAMILIES: ReadonlyArray<{ group: string; key: string; color: string }> = [{ group: "jarvis.brain", key: "plugin_group_brain", color: "#9b5de5" },{ group: "jarvis.tool", key: "plugin_group_tool", color: "#2ec4b6" },@@ -112,6 +141,57 @@ export const HUBS: Record<KitPlace, HubConfig> = {];},},+ foundry: {+ titleKey: "drawer_foundry_title",+ hintKey: "drawer_foundry_hint",+ section: "agents",+ bodyKey: "drawer_foundry_body",+ },+ comms: {+ titleKey: "drawer_comms_title",+ hintKey: "drawer_comms_hint",+ section: "contacts",+ groups: [+ { labelKey: "comms_group_mail", color: "#06d6a0", items: COMMS_TOOLS },+ { labelKey: "comms_group_people", color: "#4cc9f0", items: COMMS_PEOPLE },+ ],+ },+ desktop: {+ titleKey: "drawer_desktop_title",+ hintKey: "drawer_desktop_hint",+ section: "settings",+ groups: [+ { labelKey: "desktop_group_pointer", color: "#ff5fa2", items: DESKTOP_POINTER },+ { labelKey: "desktop_group_screen", color: "#ffb703", items: DESKTOP_SCREEN },+ ],+ },+ web: {+ titleKey: "drawer_web_title",+ hintKey: "drawer_web_hint",+ section: null,+ groups: [+ { labelKey: "web_group_search", color: "#4cc9f0", items: WEB_SEARCH },+ { labelKey: "web_group_browser", color: "#2ec4b6", items: WEB_BROWSER },+ ],+ },+ models: {+ titleKey: "drawer_models_title",+ hintKey: "drawer_models_hint",+ section: "local-models",+ bodyKey: "drawer_models_body",+ },+ civic: {+ titleKey: "drawer_civic_title",+ hintKey: "drawer_civic_hint",+ section: "board",+ bodyKey: "drawer_civic_body",+ },+ gallery: {+ titleKey: "drawer_gallery_title",+ hintKey: "drawer_gallery_hint",+ section: "visualization",+ bodyKey: "drawer_gallery_body",+ },};export function HubDrawer({ hub, onClose }: { hub: KitPlace; onClose: () => void }) {@@ -133,7 +213,8 @@ export function HubDrawer({ hub, onClose }: { hub: KitPlace; onClose: () => voidreturn () => window.removeEventListener("keydown", onKey);}, [onClose]);- const total = groups.data ? groups.data.reduce((n, g) => n + g.items.length, 0) : 0;+ const shown = cfg.groups ?? groups.data;+ const total = shown ? shown.reduce((n, g) => n + g.items.length, 0) : 0;return (<aside@@ -160,7 +241,7 @@ export function HubDrawer({ hub, onClose }: { hub: KitPlace; onClose: () => void{cfg.load && groups.isLoading && <p className="text-sm text-muted-foreground">{t("society.world.drawer_loading")}</p>}{groups.isError && <p className="text-sm text-destructive">{String(groups.error)}</p>}{cfg.load && groups.data && total === 0 && <p className="text-sm text-muted-foreground">{t("society.world.drawer_empty")}</p>}- {groups.data+ {shown?.filter((g) => g.items.length > 0).map((g) => (<section key={g.labelKey} className="mb-4">@@ -179,16 +260,18 @@ export function HubDrawer({ hub, onClose }: { hub: KitPlace; onClose: () => void</section>))}</div>- <footer className="border-t border-border px-4 py-3">- <button- type="button"- onClick={() => setActiveSection(cfg.section)}- className="inline-flex h-8 items-center gap-2 rounded-md bg-secondary px-3 text-sm font-medium text-foreground hover:bg-muted"- >- <ExternalLink size={14} />- {t("society.world.drawer_open_section")}- </button>- </footer>+ {cfg.section ? (+ <footer className="border-t border-border px-4 py-3">+ <button+ type="button"+ onClick={() => setActiveSection(cfg.section as SectionId)}+ className="inline-flex h-8 items-center gap-2 rounded-md bg-secondary px-3 text-sm font-medium text-foreground hover:bg-muted"+ >+ <ExternalLink size={14} />+ {t("society.world.drawer_open_section")}+ </button>+ </footer>+ ) : null}</aside>);}diff --git a/jarvis/ui/web/frontend/src/components/society/world/KitBuilding.tsx b/jarvis/ui/web/frontend/src/components/society/world/KitBuilding.tsxindex 5b805eaa25..b7fad85631 100644--- a/jarvis/ui/web/frontend/src/components/society/world/KitBuilding.tsx+++ b/jarvis/ui/web/frontend/src/components/society/world/KitBuilding.tsx@@ -14,10 +14,16 @@ import { Color, Mesh, MeshBasicMaterial, MeshStandardMaterial, MeshToonMaterial,import * as SkeletonUtils from "three/examples/jsm/utils/SkeletonUtils.js";import agentFoundryUrl from "@/assets/society/world/kit/agent-foundry.glb";+import controlRoomUrl from "@/assets/society/world/kit/control-room.glb";+import galleryHallUrl from "@/assets/society/world/kit/gallery-hall.glb";+import modelBoilerhouseUrl from "@/assets/society/world/kit/model-boilerhouse.glb";+import observatoryUrl from "@/assets/society/world/kit/observatory.glb";import pluginDocksUrl from "@/assets/society/world/kit/plugin-docks.glb";import relayTowerUrl from "@/assets/society/world/kit/relay-tower.glb";+import signalOfficeUrl from "@/assets/society/world/kit/signal-office.glb";import skillForgeUrl from "@/assets/society/world/kit/skill-forge.glb";import terminalCantinaUrl from "@/assets/society/world/kit/terminal-cantina.glb";+import townHallUrl from "@/assets/society/world/kit/town-hall.glb";import { useBuildingPoses, useBuildingYaw } from "./buildingPoses";import { useCameraStore } from "./cameraStore";import { buildIsland, groundY, kitId, type KitPlace } from "./islandLayout";@@ -31,6 +37,12 @@ export const KIT_URLS = {"relay-tower": relayTowerUrl,"terminal-cantina": terminalCantinaUrl,"agent-foundry": agentFoundryUrl,+ "signal-office": signalOfficeUrl,+ "control-room": controlRoomUrl,+ "gallery-hall": galleryHallUrl,+ "model-boilerhouse": modelBoilerhouseUrl,+ "town-hall": townHallUrl,+ observatory: observatoryUrl,} as const;export type KitId = keyof typeof KIT_URLS;@@ -41,6 +53,12 @@ const KIT_RING_R: Record<KitId, number> = {"skill-forge": 8.6,"relay-tower": 6.4,"terminal-cantina": 8.8,+ "signal-office": 8.6,+ "control-room": 8.6,+ "gallery-hall": 8.6,+ "model-boilerhouse": 7.0,+ "town-hall": 8.8,+ observatory: 5.8,};/** Which kit file stands at which kit place; the pose comes from the island layout. */@@ -50,6 +68,12 @@ export const KIT_PLACEMENTS: ReadonlyArray<{ kit: KitId; place: KitPlace }> = [{ kit: "skill-forge", place: "skills" },{ kit: "relay-tower", place: "mcp" },{ kit: "terminal-cantina", place: "cli" },+ { kit: "signal-office", place: "comms" },+ { kit: "control-room", place: "desktop" },+ { kit: "gallery-hall", place: "gallery" },+ { kit: "model-boilerhouse", place: "models" },+ { kit: "town-hall", place: "civic" },+ { kit: "observatory", place: "web" },];/** Emission above this strength renders unlit (a lamp, a neon tube), below it stays a lit toon. */diff --git a/jarvis/ui/web/frontend/src/components/society/world/PlaceLabels.tsx b/jarvis/ui/web/frontend/src/components/society/world/PlaceLabels.tsxindex f88796dca9..4ae9e2aecc 100644--- a/jarvis/ui/web/frontend/src/components/society/world/PlaceLabels.tsx+++ b/jarvis/ui/web/frontend/src/components/society/world/PlaceLabels.tsx@@ -24,6 +24,12 @@ const LABEL_Y: Record<PlaceId, number> = {skills: 9,mcp: 12,cli: 7,+ comms: 14,+ desktop: 13,+ web: 16,+ models: 17,+ civic: 18,+ gallery: 11,};export function PlaceLabels() {diff --git a/jarvis/ui/web/frontend/src/components/society/world/Walkers.tsx b/jarvis/ui/web/frontend/src/components/society/world/Walkers.tsxindex fc758863b7..83e0395c75 100644--- a/jarvis/ui/web/frontend/src/components/society/world/Walkers.tsx+++ b/jarvis/ui/web/frontend/src/components/society/world/Walkers.tsx@@ -40,6 +40,7 @@ import {turnToward,} from "./walkerKinematics";import { WORLD_HERO_SCALE, WalkerFigure, type WalkerAnim, type WalkerMode } from "./WalkerFigure";+import { forgetRetired, retirementPose } from "./retireStore";import { claimEntrance } from "./spawnStore";import { clearWalkerPin, setWalkerPin } from "./walkerRegistry";import { mulberry32, nextBeat, seedFromString } from "./wander";@@ -47,14 +48,20 @@ import { mulberry32, nextBeat, seedFromString } from "./wander";/** Semantic place → island place (MASTERPLAN §2.7 checkpoints). */export const CHECKPOINT_PLACE: Record<AgentCheckpoint, PlaceId | null> = {desk: "workshop",- meeting: "market",+ // A room has a room now: the Town Hall, not the open square.+ meeting: "civic",archive: "archive",gate: "harbor",idle: null,+ gallery: "gallery","hub:plugins": "plugins","hub:skills": "skills","hub:mcp": "mcp","hub:cli": "cli",+ "hub:comms": "comms",+ "hub:desktop": "desktop",+ "hub:web": "web",+ "hub:models": "models",};interface Sim {@@ -222,7 +229,13 @@ function Walker({}}, [agent.checkpoint, agent.state]);- useEffect(() => () => clearWalkerPin(agent.agentId), [agent.agentId]);+ useEffect(+ () => () => {+ clearWalkerPin(agent.agentId);+ forgetRetired(agent.agentId);+ },+ [agent.agentId],+ );useFrame((_, dt) => {const s = sim.current;@@ -231,6 +244,45 @@ function Walker({const { map, content } = buildIsland();const step = Math.min(dt, 0.1);+ // A retirement in progress owns this figure outright (retirement.ts): the+ // wander sim stands still and is kept in step with the pose, so a lead+ // handed back after the shot resumes from where it is actually standing+ // rather than snapping back to where it was when the order came.+ const staged = retirementPose(agent.agentId);+ if (staged) {+ s.x = staged.x;+ s.z = staged.z;+ s.y = staged.y;+ s.heading = staged.heading;+ s.mode = "rest";+ s.waypoints = [];+ s.index = 0;+ s.timer = 1;+ s.atPurpose = false;+ s.exiting = false;+ s.lift = 0;+ anim.current.mode = staged.mode;+ anim.current.speed = staged.speed;+ anim.current.aim = staged.aim;+ anim.current.flash = staged.flash;+ g.visible = !staged.hidden;+ g.position.set(staged.x, staged.y, staged.z);+ g.rotation.y = staged.heading;+ g.rotation.x = staged.pitch;+ setWalkerPin(agent.agentId, {+ x: staged.x,+ z: staged.z,+ color: agent.palette.accent,+ name: agent.name,+ });+ return;+ }+ // Free again: nothing of the ceremony's pose may linger.+ g.visible = true;+ g.rotation.x = 0;+ anim.current.aim = 0;+ anim.current.flash = 0;+if (!paused) {const gen = useBuildingPoses.getState().generation;if (gen !== poseGen.current) {@@ -318,6 +370,7 @@ function Walker({return (<groupref={group}+ rotation-order="YXZ"onClick={onClick}onPointerOver={(e) => {e.stopPropagation();diff --git a/jarvis/ui/web/frontend/src/components/society/world/islandLayout.test.ts b/jarvis/ui/web/frontend/src/components/society/world/islandLayout.test.tsindex 7b3d5646c1..4c5fec32d5 100644--- a/jarvis/ui/web/frontend/src/components/society/world/islandLayout.test.ts+++ b/jarvis/ui/web/frontend/src/components/society/world/islandLayout.test.ts@@ -158,7 +158,9 @@ describe("islandLayout", () => {const { map, content } = island;expect(map.kind[tileIndex(map, CENTER_TILE + 5, CENTER_TILE + 5)]).toBe(TileKind.plaza);expect(map.kind[tileIndex(map, CENTER_TILE + PLAZA_HALF_TILES + 2, CENTER_TILE)]).toBe(TileKind.path);- // Twenty blocks, four of them taken by the halls; the rest carry the houses.+ // Twenty blocks. The ten inner ones carry the halls — the public half of+ // the town, one hall per kind of work an agent can be seen doing; the outer+ // band and what is left of the inner one carry the houses.const blocks = townBlocks();expect(blocks.length).toBe(20);expect(@@ -166,8 +168,21 @@ describe("islandLayout", () => {.filter((b) => b.kit).map((b) => b.kit).sort(),- ).toEqual(["cli", "mcp", "plugins", "skills"]);- expect(content.houses.length).toBe(40);+ ).toEqual([+ "civic",+ "cli",+ "comms",+ "desktop",+ "gallery",+ "mcp",+ "models",+ "plugins",+ "skills",+ "web",+ ]);+ // Every block without a hall still carries houses, and nothing is empty.+ expect(content.houses.length).toBeGreaterThan(0);+ expect(new Set(content.houses.map((h) => h.slot)).size).toBe(content.houses.length);for (const h of content.houses) {// A door faces south or east — the camera's side — never north or west.expect([FRONT_ROTATION.south, FRONT_ROTATION.east], `house ${h.slot}`).toContain(h.rotation);diff --git a/jarvis/ui/web/frontend/src/components/society/world/islandLayout.ts b/jarvis/ui/web/frontend/src/components/society/world/islandLayout.tsindex 15344519fa..86282115fe 100644--- a/jarvis/ui/web/frontend/src/components/society/world/islandLayout.ts+++ b/jarvis/ui/web/frontend/src/components/society/world/islandLayout.ts@@ -169,7 +169,13 @@ export type PlaceId =| "foundry"| "skills"| "mcp"- | "cli";+ | "cli"+ | "comms"+ | "desktop"+ | "web"+ | "models"+ | "civic"+ | "gallery";export interface Place {id: PlaceId;@@ -258,8 +264,27 @@ export interface IslandContent {kitPoses: Record<KitPlace, KitPose>;}-/** Places that are World Kit buildings — the halls on the town's blocks and the foundry on the summit (world-masterplan-v2.md §5). */-export type KitPlace = "plugins" | "foundry" | "skills" | "mcp" | "cli";+/**+ * Places that are World Kit buildings — the halls on the town's blocks and the+ * foundry on the summit (world-masterplan-v2.md §5).+ *+ * The first five are the original four capability halls plus the foundry. The+ * six after them are the town halls added for the work that used to have no+ * address at all: writing to people, driving the desktop, reading the web,+ * thinking on a local model, meeting in a room, and delivering a result.+ */+export type KitPlace =+ | "plugins"+ | "foundry"+ | "skills"+ | "mcp"+ | "cli"+ | "comms"+ | "desktop"+ | "web"+ | "models"+ | "civic"+ | "gallery";export interface KitPose {x: number;@@ -518,6 +543,18 @@ export const KIT_BLOCKS: Record<Exclude<KitPlace, "foundry">, { template: numberskills: { template: 0, sx: 1, sz: -1, front: "south" },mcp: { template: 1, sx: 1, sz: -1, front: "south" },cli: { template: 2, sx: -1, sz: -1, front: "east" },+ // The town halls take the blocks SOUTH of the square, the half of the town+ // nearest the camera: the Signal Office and the Control Room flank the south+ // avenue, the Gallery and the Town Hall stand on the two blocks east and west+ // of it, the Boiler House takes the north-west corner block (its chimney+ // belongs against the mountain) and the Lookout the south-east one, where the+ // island falls away toward the sea it watches.+ comms: { template: 0, sx: 1, sz: 1, front: "south" },+ desktop: { template: 0, sx: -1, sz: 1, front: "south" },+ gallery: { template: 2, sx: 1, sz: 1, front: "east" },+ civic: { template: 2, sx: -1, sz: 1, front: "east" },+ models: { template: 1, sx: -1, sz: -1, front: "south" },+ web: { template: 1, sx: 1, sz: 1, front: "south" },};export interface TownBlock {@@ -568,6 +605,12 @@ export const KIT_FOOTPRINT_TILES: Record<KitPlace, { w: number; d: number }> = {skills: { w: 7, d: 5 },mcp: { w: 5, d: 5 },cli: { w: 7, d: 5 },+ comms: { w: 7, d: 5 },+ desktop: { w: 7, d: 5 },+ gallery: { w: 7, d: 5 },+ civic: { w: 7, d: 5 },+ models: { w: 5, d: 5 },+ web: { w: 5, d: 5 },};/**@@ -590,7 +633,19 @@ export const KIT_FACING: Partial<Record<KitPlace, number>> = { foundry: Math.PIexport const SUMMIT_TILE: readonly [number, number] = [CENTER_TILE - 65, CENTER_TILE - 70];/** Every kit place, on a block or not — the world's hub roster. */-export const KIT_PLACES: readonly KitPlace[] = ["plugins", "foundry", "skills", "mcp", "cli"];+export const KIT_PLACES: readonly KitPlace[] = [+ "plugins",+ "foundry",+ "skills",+ "mcp",+ "cli",+ "comms",+ "desktop",+ "web",+ "models",+ "civic",+ "gallery",+];/** Whether a place id names a World Kit hub (the ones a click opens). */export function isKitPlace(id: string): id is KitPlace {@@ -693,6 +748,12 @@ const PLACE_TILES: Record<PlaceId, [number, number]> = {skills: kitTile("skills"),mcp: kitTile("mcp"),cli: kitTile("cli"),+ comms: kitTile("comms"),+ desktop: kitTile("desktop"),+ web: kitTile("web"),+ models: kitTile("models"),+ civic: kitTile("civic"),+ gallery: kitTile("gallery"),};/**@@ -749,6 +810,13 @@ const PLOT_HALF: Record<PlaceId, [number, number]> = {skills: [0, 0],mcp: [0, 0],cli: [0, 0],+ // The town halls stand on the plateau like the four before them.+ comms: [0, 0],+ desktop: [0, 0],+ web: [0, 0],+ models: [0, 0],+ civic: [0, 0],+ gallery: [0, 0],};/** The terrain level each plot is flattened to — its terrace in the landscape. */@@ -767,6 +835,12 @@ const PLOT_LEVEL: Record<PlaceId, number> = {skills: PLATEAU_LEVEL,mcp: PLATEAU_LEVEL,cli: PLATEAU_LEVEL,+ comms: PLATEAU_LEVEL,+ desktop: PLATEAU_LEVEL,+ web: PLATEAU_LEVEL,+ models: PLATEAU_LEVEL,+ civic: PLATEAU_LEVEL,+ gallery: PLATEAU_LEVEL,};/** Building footprints (half extents, tiles) that block walking. */@@ -1696,6 +1770,13 @@ export const KIT_STAND_AHEAD_M: Record<KitPlace, number> = {skills: 7.5,mcp: 7.0,cli: 7.5,+ // The town halls' own `stand` anchors, out of their GLB extras.+ comms: 7.2,+ desktop: 7.2,+ gallery: 7.6,+ models: 7.2,+ civic: 8.0,+ web: 6.6,};/** A stand point in front of a kit building at `pose`, facing it. */@@ -1732,6 +1813,12 @@ function buildPlaces(map: IslandMap): Record<PlaceId, Place> {skills: kitPlace("skills"),mcp: kitPlace("mcp"),cli: kitPlace("cli"),+ comms: kitPlace("comms"),+ desktop: kitPlace("desktop"),+ gallery: kitPlace("gallery"),+ models: kitPlace("models"),+ civic: kitPlace("civic"),+ web: kitPlace("web"),};// Make sure every stand tile is walkable — a place nobody can reach is a bug.for (const p of Object.values(places)) {@@ -1814,6 +1901,12 @@ export function buildIsland(): Island {skills: kitPose("skills"),mcp: kitPose("mcp"),cli: kitPose("cli"),+ comms: kitPose("comms"),+ desktop: kitPose("desktop"),+ gallery: kitPose("gallery"),+ models: kitPose("models"),+ civic: kitPose("civic"),+ web: kitPose("web"),};// Houses, kit halls and the foundry's belt block walking at their resting// headings for now, so trees and furniture keep clear of them; the finaldiff --git a/jarvis/ui/web/frontend/src/i18n/locales/society/de.json b/jarvis/ui/web/frontend/src/i18n/locales/society/de.jsonindex f1e314c9d8..6110db35df 100644--- a/jarvis/ui/web/frontend/src/i18n/locales/society/de.json+++ b/jarvis/ui/web/frontend/src/i18n/locales/society/de.json@@ -137,6 +137,45 @@"cli_group_connected": "Verbunden","cli_group_installed": "Installiert, nicht verbunden","cli_group_missing": "Nicht installiert",+ "place_comms": "Signalamt",+ "place_desktop": "Steuerhaus",+ "place_web": "Die Warte",+ "place_models": "Kesselhaus",+ "place_civic": "Rathaus",+ "place_gallery": "Galerie",+ "drawer_comms_title": "Signalamt",+ "drawer_comms_hint": "Mail, Chat, Kontakte und Anrufe. Ein Agent steht hier, während er einer Person oder einem Kollegen schreibt.",+ "comms_group_mail": "Mail und Chat",+ "comms_group_people": "Menschen und Anrufe",+ "drawer_desktop_title": "Steuerhaus",+ "drawer_desktop_hint": "Die Hand an deinem Rechner: Klicks, Tasten, Fenster und was auf dem Bildschirm steht. Ein Agent steht hier, während er die Maschine bedient.",+ "desktop_group_pointer": "Zeiger und Tasten",+ "desktop_group_screen": "Bildschirm und Fenster",+ "drawer_web_title": "Die Warte",+ "drawer_web_hint": "Die Welt draußen: Websuche und der eigene Browser des Agenten. Ein Agent steht hier, während er etwas liest, das nicht dir gehört.",+ "web_group_search": "Suchen und Abrufen",+ "web_group_browser": "Der Browser des Agenten",+ "drawer_models_title": "Kesselhaus",+ "drawer_models_hint": "Wo ein lokales Modell denkt. Ein Agent steht hier, während sein eigenes Gehirn auf diesem Rechner rechnet.",+ "drawer_models_body": "Ein Agent, dessen Anbieter keinen Schlüssel braucht, läuft auf diesem Rechner. Während sein Modell arbeitet, steht die Figur am Kesselhaus statt in einem Laden — die Arbeit ist das Denken, nicht ein Werkzeug.",+ "drawer_civic_title": "Rathaus",+ "drawer_civic_hint": "Räume und das Board. Ein Agent steht hier, während er mit den anderen in einem abgegrenzten Raum sitzt.",+ "drawer_civic_body": "Ein Raum ist ein abgegrenztes Gespräch zwischen benannten Agenten: er öffnet, läuft und wird geschlossen. Alle in einem offenen Raum stehen so lange am Rathaus. Das Board listet, woran die Gesellschaft arbeitet.",+ "drawer_gallery_title": "Galerie",+ "drawer_gallery_hint": "Fertige Arbeit. Ein Agent trägt sein Ergebnis hier herein, sobald er eines abliefert.",+ "drawer_gallery_body": "Jedes abgelieferte Ergebnis wird archiviert und im Bereich Visualisierung in voller Größe gezeigt — Seiten, Diagramme, Bilder. Die Figur trägt die Kiste ein paar Sekunden hinüber und geht dann zurück an die Arbeit.",+ "card_comms_does": "Im Signalamt passiert alles, was jemandem schreibt: Mail, Chat, das Kontaktbuch und das Telefon, dazu der eine Nachrichtenweg zwischen Agenten. Die Isolatoren am Mast leuchten, während eine Nachricht läuft.",+ "card_comms_how": "Verbinde ein Mail- oder Chat-Plugin oder füll das Kontaktbuch. Ein Agent mit diesen Händen geht hierher, sobald er einer Person oder einem Kollegen schreibt.",+ "card_desktop_does": "Das Steuerhaus ist die Hand an deinem Rechner: eine App öffnen, klicken, tippen, scrollen, Fenster wechseln, lesen, was auf dem Bildschirm steht. Jedes dieser Werkzeuge stellt die Figur hinter diese Scheibe.",+ "card_desktop_how": "Gib einem Agenten die Desktop-Werkzeuge. Achte auf die Hebel: er bedient deine echte Maschine, halte seine Berechtigungsgrenze also dort, wo du sie willst.",+ "card_web_does": "Die Warte schaut auf das, was nicht dir gehört: Websuche und die eigene Browser-Sitzung des Agenten. Das Fernrohr zeigt aufs Meer, weil alles, was hier gelesen wird, von außerhalb der Insel kommt.",+ "card_web_how": "Die Suche braucht ein Backend, der Browser wird einmal pro Agent installiert. Danach läuft beides ohne weiteres Zutun.",+ "card_models_does": "Im Kesselhaus denkt ein Modell auf diesem Gerät. Ein Agent auf einem schlüssellosen, lokalen Anbieter steht hier, während sein eigenes Gehirn rechnet — statt im Laden eines Werkzeugs, das er gar nicht benutzt.",+ "card_models_how": "Installiere im Bereich Lokale Modelle ein Modell und richte den Anbieter eines Agenten darauf. Nichts verlässt den Rechner.",+ "card_civic_does": "Das Rathaus hält die Räume: ein abgegrenztes Gespräch zwischen benannten Agenten, das öffnet, läuft und geschlossen wird. Jedes Mitglied steht hier, solange der Raum offen ist.",+ "card_civic_how": "Öffne einen Raum über das Board oder lass einen Orchestrator einen öffnen. Der Aushang davor zeigt, was in der Gesellschaft ansteht.",+ "card_gallery_does": "In der Galerie landet fertige Arbeit. Sobald ein Agent ein Ergebnis abliefert, trägt er die Kiste hier herein — Seiten, Diagramme und Bilder werden dann in der App in voller Größe gezeigt.",+ "card_gallery_how": "Nichts einzurichten: Jedes abgelieferte Ergebnis wird automatisch archiviert und öffnet sich im Bereich Visualisierung.","drawer_foundry_body": "Ein neuer Agent wird hier erschaffen und läuft aus dieser Tür zu seinem eigenen Haus im Ring. Erstelle einen über „Neu“ in der Agenten-Leiste; auch Avatar-Änderungen passieren hier drinnen.","place_market": "Marktplatz","place_hub": "Jarvis-Hub",diff --git a/jarvis/ui/web/frontend/src/i18n/locales/society/en.json b/jarvis/ui/web/frontend/src/i18n/locales/society/en.jsonindex bad3c90686..4f9aadeeea 100644--- a/jarvis/ui/web/frontend/src/i18n/locales/society/en.json+++ b/jarvis/ui/web/frontend/src/i18n/locales/society/en.json@@ -137,6 +137,45 @@"cli_group_connected": "Connected","cli_group_installed": "Installed, not connected","cli_group_missing": "Not installed",+ "place_comms": "Signal Office",+ "place_desktop": "Control Room",+ "place_web": "The Lookout",+ "place_models": "Boiler House",+ "place_civic": "Town Hall",+ "place_gallery": "Gallery",+ "drawer_comms_title": "Signal Office",+ "drawer_comms_hint": "Mail, chat, contacts and calls. An agent stands here while it writes to a person or to a teammate.",+ "comms_group_mail": "Mail and chat",+ "comms_group_people": "People and calls",+ "drawer_desktop_title": "Control Room",+ "drawer_desktop_hint": "The hand on your desktop: clicks, keys, windows and what is on screen. An agent stands here while it drives the machine.",+ "desktop_group_pointer": "Pointer and keys",+ "desktop_group_screen": "Screen and windows",+ "drawer_web_title": "The Lookout",+ "drawer_web_hint": "The world outside: web search and the agent's own browser. An agent stands here while it reads something that is not yours.",+ "web_group_search": "Search and fetch",+ "web_group_browser": "The agent's browser",+ "drawer_models_title": "Boiler House",+ "drawer_models_hint": "Where a local model does its thinking. An agent stands here while its own on-device brain runs.",+ "drawer_models_body": "An agent whose provider needs no key runs on this machine. While its model works, the figure stands at the boiler house instead of a shop — the work is the thinking, not a tool.",+ "drawer_civic_title": "Town Hall",+ "drawer_civic_hint": "Rooms and the board. An agent stands here while it sits in a bounded room with the others.",+ "drawer_civic_body": "A room is a bounded conversation between named agents: it opens, it runs, it settles. Everyone in an open room stands at the town hall until it does. The board lists what the society is working on.",+ "drawer_gallery_title": "Gallery",+ "drawer_gallery_hint": "Finished work. An agent carries its result in here the moment it delivers one.",+ "drawer_gallery_body": "Every result an agent delivers is archived and shown at full size in the Visualization section — pages, diagrams, images. The figure walks the crate over for a few seconds, then goes back to work.",+ "card_comms_does": "The Signal Office is where writing to someone happens: mail, chat, the contact book and the telephone, plus the one message path between agents. The insulators on the mast glow while a message runs.",+ "card_comms_how": "Connect a mail or chat plugin, or fill the contact book. An agent with those hands walks here whenever it writes to a person or a teammate.",+ "card_desktop_does": "The Control Room is the hand on your desktop: opening an app, clicking, typing, scrolling, switching windows, reading what is on screen. Every one of those tools puts the figure behind this glass.",+ "card_desktop_how": "Grant an agent the desktop tools. Watch the levers: it is driving your real machine, so keep its permission ceiling where you want it.",+ "card_web_does": "The Lookout watches what is not yours: web search and the agent's own browser session. The telescope points out to sea because everything it reads comes from outside the island.",+ "card_web_how": "Search needs a backend; the browser needs to be installed once per agent. Both then work without further setup.",+ "card_models_does": "The Boiler House is where an on-device model thinks. An agent on a keyless, local provider stands here while its own brain runs, instead of at the shop of a tool it is not using.",+ "card_models_how": "Install a local model in the Local models section and point an agent's provider at it. Nothing leaves the machine.",+ "card_civic_does": "The Town Hall holds the rooms: a bounded conversation between named agents that opens, runs and settles. Every member stands here while the room is open.",+ "card_civic_how": "Open a room from the board, or let an orchestrator open one. The notice board outside shows what the society has on.",+ "card_gallery_does": "The Gallery is where finished work lands. The moment an agent delivers a result, it carries the crate in here — the pages, diagrams and images are then shown at full size in the app.",+ "card_gallery_how": "Nothing to set up: every delivered result is archived automatically and opens in the Visualization section.","drawer_foundry_body": "A new agent is created here and walks out of this door to its own house on the ring. Use “New” in the agents rail to create one; avatar changes happen inside as well.","place_market": "Market Square","place_hub": "Jarvis Hub",diff --git a/jarvis/ui/web/frontend/src/i18n/locales/society/es.json b/jarvis/ui/web/frontend/src/i18n/locales/society/es.jsonindex 9c96636ab0..88d9193402 100644--- a/jarvis/ui/web/frontend/src/i18n/locales/society/es.json+++ b/jarvis/ui/web/frontend/src/i18n/locales/society/es.json@@ -137,6 +137,45 @@"cli_group_connected": "Conectadas","cli_group_installed": "Instaladas, sin conectar","cli_group_missing": "No instaladas",+ "place_comms": "Oficina de Señales",+ "place_desktop": "Sala de Control",+ "place_web": "El Mirador",+ "place_models": "Sala de Calderas",+ "place_civic": "Ayuntamiento",+ "place_gallery": "Galería",+ "drawer_comms_title": "Oficina de Señales",+ "drawer_comms_hint": "Correo, chat, contactos y llamadas. Un agente está aquí mientras escribe a una persona o a un compañero.",+ "comms_group_mail": "Correo y chat",+ "comms_group_people": "Personas y llamadas",+ "drawer_desktop_title": "Sala de Control",+ "drawer_desktop_hint": "La mano en tu escritorio: clics, teclas, ventanas y lo que hay en pantalla. Un agente está aquí mientras maneja la máquina.",+ "desktop_group_pointer": "Puntero y teclas",+ "desktop_group_screen": "Pantalla y ventanas",+ "drawer_web_title": "El Mirador",+ "drawer_web_hint": "El mundo exterior: búsqueda web y el navegador propio del agente. Un agente está aquí mientras lee algo que no es tuyo.",+ "web_group_search": "Buscar y obtener",+ "web_group_browser": "El navegador del agente",+ "drawer_models_title": "Sala de Calderas",+ "drawer_models_hint": "Donde piensa un modelo local. Un agente está aquí mientras corre su propio cerebro en este equipo.",+ "drawer_models_body": "Un agente cuyo proveedor no necesita clave corre en esta máquina. Mientras su modelo trabaja, la figura está en la sala de calderas y no en una tienda: el trabajo es pensar, no una herramienta.",+ "drawer_civic_title": "Ayuntamiento",+ "drawer_civic_hint": "Salas y el tablero. Un agente está aquí mientras se sienta con los demás en una sala acotada.",+ "drawer_civic_body": "Una sala es una conversación acotada entre agentes con nombre: se abre, corre y se cierra. Todos los de una sala abierta están en el ayuntamiento hasta entonces. El tablero enumera en qué trabaja la sociedad.",+ "drawer_gallery_title": "Galería",+ "drawer_gallery_hint": "Trabajo terminado. Un agente trae aquí su resultado en cuanto entrega uno.",+ "drawer_gallery_body": "Cada resultado entregado se archiva y se muestra a tamaño completo en la sección Visualización: páginas, diagramas, imágenes. La figura lleva la caja unos segundos y vuelve al trabajo.",+ "card_comms_does": "En la Oficina de Señales ocurre todo lo que escribe a alguien: correo, chat, la libreta de contactos y el teléfono, más la única vía de mensajes entre agentes. Los aisladores del mástil brillan mientras corre un mensaje.",+ "card_comms_how": "Conecta un plugin de correo o chat, o llena la libreta de contactos. Un agente con esas manos viene aquí cuando escribe a una persona o a un compañero.",+ "card_desktop_does": "La Sala de Control es la mano en tu escritorio: abrir una app, hacer clic, teclear, desplazar, cambiar de ventana, leer lo que hay en pantalla. Cada una de esas herramientas pone la figura tras este cristal.",+ "card_desktop_how": "Concede a un agente las herramientas de escritorio. Mira las palancas: maneja tu máquina real, así que mantén su techo de permisos donde tú quieras.",+ "card_web_does": "El Mirador observa lo que no es tuyo: búsqueda web y la sesión de navegador propia del agente. El telescopio apunta al mar porque todo lo que lee viene de fuera de la isla.",+ "card_web_how": "La búsqueda necesita un backend; el navegador se instala una vez por agente. Después ambos funcionan sin más ajustes.",+ "card_models_does": "En la Sala de Calderas piensa un modelo en el propio equipo. Un agente con un proveedor local y sin clave está aquí mientras corre su cerebro, en vez de en la tienda de una herramienta que no usa.",+ "card_models_how": "Instala un modelo en la sección Modelos locales y apunta ahí el proveedor de un agente. Nada sale de la máquina.",+ "card_civic_does": "El Ayuntamiento guarda las salas: una conversación acotada entre agentes con nombre que se abre, corre y se cierra. Cada miembro está aquí mientras la sala sigue abierta.",+ "card_civic_how": "Abre una sala desde el tablero, o deja que la abra un orquestador. El tablón de anuncios de fuera muestra qué hay en marcha.",+ "card_gallery_does": "En la Galería aterriza el trabajo terminado. En cuanto un agente entrega un resultado, trae aquí la caja: las páginas, diagramas e imágenes se muestran luego a tamaño completo en la app.",+ "card_gallery_how": "Nada que configurar: cada resultado entregado se archiva automáticamente y se abre en la sección Visualización.","drawer_foundry_body": "Un agente nuevo se crea aquí y sale por esta puerta hacia su propia casa en el anillo. Créalo con “Nuevo” en la barra de agentes; los cambios de avatar también ocurren dentro.","place_market": "Plaza del Mercado","place_hub": "Centro Jarvis",diff --git a/jarvis/ui/web/frontend/src/lib/societyApi.ts b/jarvis/ui/web/frontend/src/lib/societyApi.tsindex 947293c8ac..b6f905361b 100644--- a/jarvis/ui/web/frontend/src/lib/societyApi.ts+++ b/jarvis/ui/web/frontend/src/lib/societyApi.ts@@ -37,10 +37,15 @@ export const CHECKPOINTS = ["archive","gate","idle",+ "gallery","hub:plugins","hub:skills","hub:mcp","hub:cli",+ "hub:comms",+ "hub:desktop",+ "hub:web",+ "hub:models",] as const;export type Checkpoint = (typeof CHECKPOINTS)[number];diff --git a/scripts/world/kit_town.py b/scripts/world/kit_town.pynew file mode 100644index 0000000000..ad1887a75d--- /dev/null+++ b/scripts/world/kit_town.py@@ -0,0 +1,736 @@+# ruff: noqa: E501+"""Six more World Kit halls for the town centre — the places the island was+missing for whole families of hands (world-masterplan-v2.md §5).++Until now the town showed four of the things an agent can do: plugins, skills,+MCP servers and a CLI seat. Everything else — sending mail, driving the+desktop, reading the web, delivering a result, thinking on a local model,+sitting in a room — collapsed into ``core`` and put the figure at the Workshop+outside the town. These halls give those families an address:++ signal-office the post and telegraph office (mail, chat, contacts, calls)+ control-room the signal box (the hand on the desktop)+ gallery-hall the exhibition hall (finished work, artifacts)+ model-boilerhouse the boiler house (a local model, inferring)+ town-hall the town hall (rooms and the board)+ observatory the lookout (the web and the browser)++Built on the helpers of ``build_world_kit.py``, in its own module so two+sessions can add buildings without editing the same file. Run inside Blender::++ blender -b --python scripts/world/kit_town.py -- --target signal-office --out <kit dir>++or through the Blender MCP with ``KIT_ARGS`` set. ``--keep-scene`` leaves+whatever else is in the scene alone and removes only the building it made.++Contract (§4.1), the same one every kit building keeps: origin at the+footprint's ground centre, the FRONT (door side) faces glTF +Z, which is+Blender −Y; metres; bevelled edges; one flat material per colour; the root+empty carries the ``jarvis_building`` extras.+"""++from __future__ import annotations++import importlib.util+import math+import sys+from pathlib import Path++import bpy # type: ignore[import-not-found]++_BASE_PATH = (+ Path(__file__).resolve().parent / "build_world_kit.py" if "__file__" in globals() else None+)+++def _load_base(path: Path):+ spec = importlib.util.spec_from_file_location("kit_base", str(path))+ mod = importlib.util.module_from_spec(spec)+ assert spec.loader is not None+ spec.loader.exec_module(mod)+ return mod+++def _base():+ path = _BASE_PATH or Path(globals().get("KIT_BASE_PATH", ""))+ return _load_base(path)+++#: One accent per hall, plus the few surfaces the town's halls need and the+#: island palette does not carry: a screen, a canvas, brick, a hot furnace.+TOWN_PALETTE = {+ "fam_comms": "#06d6a0",+ "fam_desktop": "#ff5fa2",+ "fam_gallery": "#ffb703",+ "fam_models": "#9b5de5",+ "fam_civic": "#4361ee",+ "fam_web": "#4cc9f0",+ "screen": "#0f172a",+ "screen_glow": "#7ff0c8",+ "brick": "#a8553f",+ "brick_dark": "#7d3d2d",+ "furnace": "#ff7b33",+ "canvas": "#fdfbf4",+ "slate": "#2f3542",+ "stone": "#ded6c4",+ "stone_dark": "#bdb29b",+ "brass": "#d9a441",+ "ink": "#22243a",+ "paper": "#f4efe2",+}+++def _sign(k, root, text, width, x, y_front, z, rim_key, size: float = 1.2):+ """A dark board with a coloured rim and glowing letters, hung on the front.++ Same anatomy as the other halls' signs, so a visitor reads every building+ the same way. ``x`` is the board's centre, ``y_front`` the facade plane.+ """+ k.box("sign_board", (width, 0.5, size + 0.7), (x, y_front + 0.55, z), "sign_board", root, bevel=0.1)+ k.box(+ "sign_rim",+ (width + 0.3, 0.3, size + 1.0),+ (x, y_front + 0.7, z),+ rim_key,+ root,+ bevel=0.08,+ emissive=0.8,+ )+ k.text_mesh(+ "sign_text", text, size, 0.18, (x, y_front + 0.25, z - 0.05), "neon_glow", root, emissive=3.0+ )+++def _lamp(k, root, name, at, key="neon_glow"):+ """A post lamp beside a door: a slim pole with a glowing head."""+ k.cylinder(f"{name}_post", 0.12, 2.6, (at[0], at[1], at[2] + 1.3), "metal", root, verts=8)+ k.box(f"{name}_head", (0.45, 0.45, 0.5), (at[0], at[1], at[2] + 2.75), key, root, bevel=0.08, emissive=2.4)+++# ---------------------------------------------------------------------------+# 1. The Signal Office — mail, chat, contacts, calls+# ---------------------------------------------------------------------------+++def build_signal_office(k) -> bpy.types.Object:+ """The post and telegraph office: a brick hall with a clock over the door, a+ row of letter slots along the facade, and a telegraph mast on the roof whose+ insulators glow while a message runs. 7 x 5 tiles."""+ W, D, H = 13.4, 9.4, 5.0+ root = k.new_root(+ "signal-office",+ {+ "jarvis_building": {+ "contract": 1,+ "id": "signal-office",+ "footprint": [7, 5],+ "forward": "+Z",+ "door": [0.0, 4.7],+ "stand": [0, 7.2],+ "sign": [0.0, 8.6, 0],+ "height_m": 12.6,+ }+ },+ )+ y_front = -D / 2+ base = 0.35+ k.box("plinth", (W + 0.8, D + 0.8, base), (0, 0, base / 2), "plinth", root, bevel=0.08)+ k.box("hall", (W, D, H), (0, 0, base + H / 2), "brick", root, bevel=0.14)+ k.box("base_band", (W + 0.12, D + 0.12, 0.7), (0, 0, base + 0.35), "brick_dark", root, bevel=0.05)+ roof_z = base + H+ k.box("cornice", (W + 1.0, D + 1.0, 0.45), (0, 0, roof_z + 0.22), "stone", root, bevel=0.1)+ k.box("roof_slab", (W - 0.6, D - 0.6, 0.35), (0, 0, roof_z + 0.6), "roof", root, bevel=0.08)++ # The letter slots: a band of small mint-lit openings along the facade.+ for i in range(9):+ k.box(+ f"slot_{i}",+ (0.85, 0.14, 0.3),+ (-W / 2 + 1.4 + i * 1.35, y_front - 0.06, base + 3.55),+ "fam_comms",+ root,+ bevel=0.03,+ emissive=1.1,+ )+ k.box("slot_shelf", (W - 1.6, 0.4, 0.2), (0, y_front - 0.16, base + 3.25), "stone_dark", root, bevel=0.05)++ # Door, its frame and the two windows flanking it.+ k.box("door_frame", (3.4, 0.34, 3.6), (0, y_front - 0.1, base + 1.8), "stone", root, bevel=0.05)+ k.box("door_l", (1.45, 0.16, 3.1), (-0.78, y_front - 0.24, base + 1.55), "wood_dark", root, bevel=0.03)+ k.box("door_r", (1.45, 0.16, 3.1), (0.78, y_front - 0.24, base + 1.55), "wood_dark", root, bevel=0.03)+ for sx in (-1, 1):+ k.box(+ f"window_{'l' if sx < 0 else 'r'}",+ (2.4, 0.14, 1.6),+ (sx * 4.4, y_front - 0.08, base + 2.2),+ "glass",+ root,+ bevel=0.02,+ emissive=0.35,+ )+ k.box(+ f"window_sill_{'l' if sx < 0 else 'r'}",+ (2.8, 0.3, 0.18),+ (sx * 4.4, y_front - 0.14, base + 1.3),+ "stone",+ root,+ bevel=0.04,+ )++ # The clock over the door: a brass ring, a pale face and two hands.+ k.cylinder("clock_ring", 1.15, 0.28, (0, y_front - 0.18, base + 4.35), "brass", root, verts=24, rot=(math.pi / 2, 0, 0))+ k.cylinder("clock_face", 0.98, 0.16, (0, y_front - 0.3, base + 4.35), "paper", root, verts=24, rot=(math.pi / 2, 0, 0), emissive=0.5)+ k.box("clock_hand_h", (0.09, 0.08, 0.62), (0, y_front - 0.4, base + 4.6), "ink", root, bevel=0.01)+ k.box("clock_hand_m", (0.7, 0.08, 0.09), (0.28, y_front - 0.4, base + 4.35), "ink", root, bevel=0.01)++ # The telegraph mast: a lattice pole with three glowing insulators and the+ # wires that run off the roof toward the rest of the town.+ mx, my = W / 2 - 2.4, 1.2+ k.cylinder("mast", 0.22, 7.0, (mx, my, roof_z + 4.2), "metal", root, verts=10)+ for i, dz in enumerate((1.6, 3.0, 4.4)):+ k.box(f"cross_{i}", (3.4, 0.24, 0.22), (mx, my, roof_z + dz), "wood_dark", root, bevel=0.04)+ for sx in (-1, 1):+ k.box(+ f"insulator_{i}_{'l' if sx < 0 else 'r'}",+ (0.34, 0.34, 0.4),+ (mx + sx * 1.5, my, roof_z + dz + 0.3),+ "fam_comms",+ root,+ bevel=0.06,+ emissive=2.2,+ )+ for i, sag in enumerate((0.0, 0.35)):+ k.box(+ f"wire_{i}",+ (7.4, 0.07, 0.07),+ (mx - 4.2, my, roof_z + 4.7 - sag),+ "slate",+ root,+ bevel=0.0,+ rot=(0, 0.06 - i * 0.03, 0),+ )++ # The mailbox and the bench on the forecourt.+ k.box("mailbox_body", (0.95, 0.95, 1.5), (-W / 2 + 1.5, y_front - 2.1, base + 0.75), "fam_comms", root, bevel=0.1)+ k.box("mailbox_slot", (0.6, 0.12, 0.14), (-W / 2 + 1.5, y_front - 2.6, base + 1.25), "ink", root, bevel=0.02)+ k.box("mailbox_cap", (1.15, 1.15, 0.22), (-W / 2 + 1.5, y_front - 2.1, base + 1.6), "stone_dark", root, bevel=0.06)+ k.box("bench", (2.6, 0.7, 0.22), (W / 2 - 2.6, y_front - 2.2, base + 0.55), "wood", root, bevel=0.05)+ for sx in (-1, 1):+ k.box(f"bench_leg_{'l' if sx < 0 else 'r'}", (0.22, 0.6, 0.55), (W / 2 - 2.6 + sx * 1.0, y_front - 2.2, base + 0.28), "wood_dark", root, bevel=0.03)+ _lamp(k, root, "lamp", (W / 2 - 0.9, y_front - 1.4, base), "fam_comms")++ _sign(k, root, "SIGNAL", 6.6, 0, y_front, roof_z + 1.55, "fam_comms")+ return root+++# ---------------------------------------------------------------------------+# 2. The Control Room — the hand on the desktop+# ---------------------------------------------------------------------------+++def build_control_room(k) -> bpy.types.Object:+ """The signal box: a raised glass cabin over a solid base, a desk of lit+ screens visible through the panorama window, a bank of levers, and a small+ dish on the roof. 7 x 5 tiles."""+ W, D = 13.4, 9.4+ root = k.new_root(+ "control-room",+ {+ "jarvis_building": {+ "contract": 1,+ "id": "control-room",+ "footprint": [7, 5],+ "forward": "+Z",+ "door": [-3.6, 4.7],+ "stand": [0, 7.2],+ "sign": [0.0, 9.4, 0],+ "height_m": 11.2,+ }+ },+ )+ y_front = -D / 2+ base = 0.35+ lower_h = 2.5+ k.box("plinth", (W + 0.8, D + 0.8, base), (0, 0, base / 2), "plinth", root, bevel=0.08)+ k.box("lower", (W, D, lower_h), (0, 0, base + lower_h / 2), "slate", root, bevel=0.12)+ k.box("lower_band", (W + 0.14, D + 0.14, 0.4), (0, 0, base + 0.2), "steel_dark", root, bevel=0.05)+ # The base is blind except for a vent band — the machinery is below.+ for i in range(6):+ k.box(f"vent_{i}", (1.3, 0.1, 0.7), (-W / 2 + 1.6 + i * 2.1, y_front - 0.04, base + 1.5), "steel_dark", root, bevel=0.03)+ deck_z = base + lower_h+ k.box("deck", (W + 0.7, D + 0.7, 0.3), (0, 0, deck_z + 0.15), "steel", root, bevel=0.07)+ # A signal box's cabin: set back just far enough for a gallery to run round it.+ cab_w, cab_d, cab_h = W - 1.6, D - 1.6, 3.4+ cab_z = deck_z + 0.3+ k.box("cabin", (cab_w, cab_d, cab_h), (0, 0, cab_z + cab_h / 2), "wall", root, bevel=0.12)+ # The panorama: one tall glass band on the front, returning round both sides.+ k.box("glass_front", (cab_w - 0.5, 0.18, 2.2), (0, -cab_d / 2 - 0.03, cab_z + 1.95), "glass", root, bevel=0.03, emissive=0.5)+ for sx in (-1, 1):+ k.box(+ f"glass_side_{'l' if sx < 0 else 'r'}",+ (0.18, cab_d - 0.7, 2.2),+ (sx * (cab_w / 2 + 0.03), 0, cab_z + 1.95),+ "glass",+ root,+ bevel=0.03,+ emissive=0.5,+ )+ # Mullions, so the glass reads as a window band and not a hole in the wall.+ for i, mx in enumerate((-3.2, 0.0, 3.2)):+ k.box(f"mullion_{i}", (0.16, 0.24, 2.3), (mx, -cab_d / 2 - 0.05, cab_z + 1.95), "wall_shade", root, bevel=0.02)+ # A thin roof: enough eave to cast a line, never enough to hide the facade.+ k.box("cabin_roof", (cab_w + 0.7, cab_d + 0.7, 0.32), (0, 0, cab_z + cab_h + 0.16), "trim", root, bevel=0.08)+ k.box("roof_edge", (cab_w + 0.9, cab_d + 0.9, 0.12), (0, 0, cab_z + cab_h + 0.02), "fam_desktop", root, bevel=0.03, emissive=0.7)++ # The desk of screens behind the glass, and the bank of levers beside it.+ k.box("desk", (cab_w - 2.6, 1.0, 0.28), (0, -cab_d / 2 + 1.0, cab_z + 1.0), "wood_dark", root, bevel=0.05)+ for i, sx in enumerate((-2.4, 0.0, 2.4)):+ k.box(f"screen_{i}", (1.9, 0.16, 1.1), (sx, -cab_d / 2 + 0.9, cab_z + 1.85), "screen", root, bevel=0.05)+ k.box(f"screen_glow_{i}", (1.65, 0.06, 0.88), (sx, -cab_d / 2 + 0.8, cab_z + 1.85), "screen_glow", root, bevel=0.02, emissive=2.0)+ for i in range(5):+ lx = -cab_w / 2 + 1.2 + i * 0.5+ k.box(f"lever_{i}", (0.12, 0.12, 0.8), (lx, 1.2, cab_z + 1.15), "steel", root, bevel=0.03, rot=(0.34 - i * 0.14, 0, 0))+ k.box(f"lever_knob_{i}", (0.22, 0.22, 0.22), (lx, 1.35, cab_z + 1.55), "fam_desktop", root, bevel=0.06, emissive=1.4)++ # The gallery rail round the deck, on the two sides the camera sees.+ for i in range(9):+ k.box(f"rail_post_f{i}", (0.11, 0.11, 0.8), (-W / 2 + 0.5 + i * 1.65, y_front - 0.3, deck_z + 0.7), "steel", root, bevel=0.02)+ k.box("rail_top_f", (W + 0.5, 0.13, 0.13), (0, y_front - 0.3, deck_z + 1.08), "steel", root, bevel=0.03)+ for i in range(6):+ k.box(f"rail_post_s{i}", (0.11, 0.11, 0.8), (W / 2 + 0.3, y_front + 0.9 + i * 1.55, deck_z + 0.7), "steel", root, bevel=0.02)+ k.box("rail_top_s", (0.13, D + 0.5, 0.13), (W / 2 + 0.3, 0, deck_z + 1.08), "steel", root, bevel=0.03)++ # The stair: it climbs ACROSS the facade, left to right, so the whole flight+ # stays on the lot instead of running four metres out into the street.+ steps, run, rise = 8, 0.72, deck_z / 8+ for i in range(steps):+ k.box(+ f"step_{i}",+ (run, 1.5, rise),+ (-W / 2 + 0.55 + i * run, y_front - 1.0, rise / 2 + i * rise),+ "steel_dark",+ root,+ bevel=0.03,+ )+ k.box("door", (1.4, 0.18, 2.2), (-cab_w / 2 + 1.2, -cab_d / 2 - 0.06, cab_z + 1.1), "fam_desktop", root, bevel=0.04, emissive=0.5)++ # The dish and the mast on the roof.+ mx, my = W / 2 - 2.4, 1.4+ k.cylinder("mast", 0.16, 2.6, (mx, my, cab_z + cab_h + 1.6), "metal", root, verts=10)+ k.cylinder("dish", 1.35, 0.22, (mx, my, cab_z + cab_h + 2.9), "wall_shade", root, verts=20, rot=(0.95, 0, 0.4))+ k.box("dish_horn", (0.22, 0.22, 0.7), (mx, my - 0.75, cab_z + cab_h + 3.15), "fam_desktop", root, bevel=0.05, emissive=1.6)++ # The pointer on its post outside — the building's mark, a cursor.+ px, py = W / 2 - 1.4, y_front - 2.4+ k.cylinder("mark_post", 0.14, 2.2, (px, py, base + 1.1), "metal", root, verts=8)+ k.box("mark_body", (0.75, 0.16, 1.15), (px, py, base + 2.6), "fam_desktop", root, bevel=0.06, emissive=1.8, rot=(0, 0, 0.45))+ k.box("mark_tail", (0.3, 0.16, 0.75), (px + 0.32, py, base + 2.05), "fam_desktop", root, bevel=0.05, emissive=1.8, rot=(0, 0, 0.45))++ _sign(k, root, "CONTROL", 6.8, 0, y_front, cab_z + cab_h + 1.3, "fam_desktop", size=1.1)+ return root+++# ---------------------------------------------------------------------------+# 3. The Gallery — finished work+# ---------------------------------------------------------------------------+++def build_gallery_hall(k) -> bpy.types.Object:+ """The exhibition hall: a pale block with a sawtooth skylight roof, a portico+ of four columns, framed pictures on the facade and a plinth with a piece on+ it out front. 7 x 5 tiles."""+ W, D, H = 13.4, 9.4, 5.2+ root = k.new_root(+ "gallery-hall",+ {+ "jarvis_building": {+ "contract": 1,+ "id": "gallery-hall",+ "footprint": [7, 5],+ "forward": "+Z",+ "door": [0.0, 4.7],+ "stand": [0, 7.6],+ "sign": [0.0, 8.2, 0],+ "height_m": 9.4,+ }+ },+ )+ y_front = -D / 2+ base = 0.35+ k.box("plinth", (W + 0.8, D + 0.8, base), (0, 0, base / 2), "plinth", root, bevel=0.08)+ k.box("hall", (W, D, H), (0, 0, base + H / 2), "canvas", root, bevel=0.14)+ k.box("base_band", (W + 0.12, D + 0.12, 0.55), (0, 0, base + 0.28), "wall_shade", root, bevel=0.05)+ roof_z = base + H+ k.box("cornice", (W + 0.9, D + 0.9, 0.4), (0, 0, roof_z + 0.2), "trim", root, bevel=0.1)++ # Sawtooth skylights: three glazed slopes facing north, the museum's own roof.+ for i, ox in enumerate((-4.2, 0.0, 4.2)):+ k.box(f"tooth_back_{i}", (3.4, 0.4, 1.9), (ox, 2.2, roof_z + 1.35), "trim", root, bevel=0.05)+ k.box(+ f"tooth_glass_{i}",+ (3.4, 4.6, 0.22),+ (ox, 0.1, roof_z + 1.15),+ "glass",+ root,+ bevel=0.04,+ emissive=0.5,+ rot=(0.5, 0, 0),+ )++ # The portico: four columns carrying a slim canopy over the entrance. It+ # stays narrow and low — a wide slab would hide the facade from a camera+ # that looks down at 50°, which is the only angle the island ever uses.+ for i, cx in enumerate((-3.3, -1.2, 1.2, 3.3)):+ k.cylinder(f"column_{i}", 0.32, 3.9, (cx, y_front - 0.95, base + 1.95), "stone", root, verts=16)+ k.cylinder(f"column_cap_{i}", 0.44, 0.24, (cx, y_front - 0.95, base + 4.0), "stone_dark", root, verts=16)+ k.box("canopy", (8.4, 1.7, 0.32), (0, y_front - 0.95, base + 4.28), "stone", root, bevel=0.07)+ k.box("canopy_rim", (8.7, 2.0, 0.13), (0, y_front - 0.95, base + 4.08), "fam_gallery", root, bevel=0.04, emissive=0.9)++ # The doors and the framed pictures either side of them.+ k.box("door_l", (1.5, 0.16, 3.2), (-0.8, y_front - 0.14, base + 1.6), "wood_dark", root, bevel=0.03)+ k.box("door_r", (1.5, 0.16, 3.2), (0.8, y_front - 0.14, base + 1.6), "wood_dark", root, bevel=0.03)+ k.box("door_handle", (0.12, 0.12, 0.7), (0.25, y_front - 0.26, base + 1.7), "brass", root, bevel=0.03)+ for i, (fx, key) in enumerate(((-5.0, "fam_gallery"), (5.0, "fam_web"))):+ k.box(f"frame_{i}", (2.2, 0.18, 1.9), (fx, y_front - 0.08, base + 2.4), "brass", root, bevel=0.05)+ k.box(f"canvas_{i}", (1.8, 0.08, 1.5), (fx, y_front - 0.18, base + 2.4), key, root, bevel=0.02, emissive=0.9)++ # The piece on its plinth on the forecourt, lit from the ground.+ k.box("art_plinth", (1.6, 1.6, 1.5), (-W / 2 + 1.9, y_front - 3.4, base + 0.75), "stone", root, bevel=0.06)+ k.box("art_a", (0.9, 0.9, 1.2), (-W / 2 + 1.9, y_front - 3.4, base + 2.1), "fam_gallery", root, bevel=0.12, emissive=1.2, rot=(0, 0, 0.6))+ k.box("art_b", (0.55, 0.55, 0.8), (-W / 2 + 1.9, y_front - 3.4, base + 2.9), "fam_desktop", root, bevel=0.1, emissive=1.2, rot=(0, 0, 1.1))+ k.cylinder("art_light", 0.4, 0.14, (-W / 2 + 1.9, y_front - 2.4, base + 0.08), "neon_glow", root, verts=14, emissive=2.2)++ # A crate by the door — a result just delivered.+ k.box("crate", (1.2, 1.2, 1.2), (W / 2 - 2.0, y_front - 3.2, base + 0.6), "wood", root, bevel=0.06)+ k.box("crate_band", (1.32, 1.32, 0.16), (W / 2 - 2.0, y_front - 3.2, base + 0.75), "fam_gallery", root, bevel=0.03, emissive=0.8)+ _lamp(k, root, "lamp", (W / 2 - 0.8, y_front - 1.2, base), "fam_gallery")++ _sign(k, root, "GALLERY", 7.2, 0, y_front, roof_z + 1.4, "fam_gallery", size=1.1)+ return root+++# ---------------------------------------------------------------------------+# 4. The Boiler House — a local model, inferring+# ---------------------------------------------------------------------------+++def build_model_boilerhouse(k) -> bpy.types.Object:+ """The boiler house: a squat brick engine room with a tall chimney, a furnace+ door glowing violet, a pressure tank on its saddle and a bank of gauges. This+ is where an agent stands while its own local model thinks. 5 x 5 tiles."""+ W, D, H = 9.4, 9.4, 4.6+ root = k.new_root(+ "model-boilerhouse",+ {+ "jarvis_building": {+ "contract": 1,+ "id": "model-boilerhouse",+ "footprint": [5, 5],+ "forward": "+Z",+ "door": [-1.4, 4.7],+ "stand": [0, 7.2],+ "sign": [0.0, 7.6, 0],+ "height_m": 15.0,+ }+ },+ )+ y_front = -D / 2+ base = 0.35+ k.box("plinth", (W + 0.8, D + 0.8, base), (0, 0, base / 2), "plinth", root, bevel=0.08)+ k.box("hall", (W, D, H), (0, 0, base + H / 2), "brick", root, bevel=0.14)+ k.box("base_band", (W + 0.12, D + 0.12, 0.6), (0, 0, base + 0.3), "brick_dark", root, bevel=0.05)+ roof_z = base + H+ k.box("cornice", (W + 0.9, D + 0.9, 0.42), (0, 0, roof_z + 0.21), "stone", root, bevel=0.1)+ k.box("roof_slab", (W - 0.5, D - 0.5, 0.3), (0, 0, roof_z + 0.57), "roof", root, bevel=0.06)++ # The chimney: a tapered brick stack with a metal cap and a warm mouth.+ cx, cy = W / 2 - 1.9, 2.2+ k.cylinder("stack_low", 1.15, 5.4, (cx, cy, roof_z + 2.7), "brick_dark", root, verts=18)+ k.cylinder("stack_high", 0.95, 3.4, (cx, cy, roof_z + 7.1), "brick", root, verts=18)+ k.cylinder("stack_cap", 1.15, 0.4, (cx, cy, roof_z + 8.9), "metal", root, verts=18)+ k.cylinder("stack_mouth", 0.8, 0.3, (cx, cy, roof_z + 9.05), "fam_models", root, verts=18, emissive=2.4)+ for i in range(3):+ k.cylinder(f"stack_band_{i}", 1.2, 0.22, (cx, cy, roof_z + 1.2 + i * 1.9), "stone_dark", root, verts=18)++ # The furnace: an arched door in the facade, its slot glowing while it runs.+ k.box("furnace_frame", (3.2, 0.34, 3.0), (-1.4, y_front - 0.1, base + 1.5), "steel_dark", root, bevel=0.06)+ k.box("furnace_door", (2.5, 0.2, 2.3), (-1.4, y_front - 0.26, base + 1.35), "steel", root, bevel=0.08)+ k.box("furnace_slot", (1.9, 0.1, 0.42), (-1.4, y_front - 0.38, base + 1.85), "fam_models", root, bevel=0.03, emissive=3.0)+ k.cylinder("furnace_wheel", 0.55, 0.18, (-1.4, y_front - 0.46, base + 0.85), "brass", root, verts=16, rot=(math.pi / 2, 0, 0))++ # The pressure tank on its saddles, lying across the roof where it reads.+ tz = roof_z + 1.5+ k.cylinder("tank", 1.15, 6.2, (-1.6, 1.0, tz), "steel", root, verts=20, rot=(0, math.pi / 2, 0))+ for i, sx in enumerate((-4.0, 0.8)):+ k.box(f"saddle_{i}", (0.9, 2.4, 1.1), (sx, 1.0, roof_z + 0.95), "steel_dark", root, bevel=0.06)+ k.cylinder("tank_cap", 0.55, 0.4, (-4.8, 1.0, tz), "fam_models", root, verts=16, rot=(0, math.pi / 2, 0), emissive=1.4)+ k.cylinder("tank_riser", 0.24, 1.6, (1.4, 1.0, tz - 0.6), "copper", root, verts=10)++ # The gauges beside the door: three brass dials on a slate board.+ k.box("gauge_board", (2.8, 0.16, 1.5), (2.6, y_front - 0.08, base + 3.1), "slate", root, bevel=0.05)+ for i, gx in enumerate((1.7, 2.6, 3.5)):+ k.cylinder(f"gauge_{i}", 0.35, 0.2, (gx, y_front - 0.2, base + 3.1), "brass", root, verts=16, rot=(math.pi / 2, 0, 0))+ k.cylinder(f"gauge_face_{i}", 0.26, 0.1, (gx, y_front - 0.3, base + 3.1), "paper", root, verts=16, rot=(math.pi / 2, 0, 0), emissive=0.6)++ # Pipes running out of the wall and down to the ground.+ for i, px in enumerate((-3.6, -2.9)):+ k.cylinder(f"pipe_{i}", 0.2, 3.2, (px, y_front + 0.4, base + 3.6), "copper", root, verts=10)+ k.cylinder(f"pipe_elbow_{i}", 0.24, 1.6, (px, y_front - 0.3, base + 5.1), "copper", root, verts=10, rot=(math.pi / 2, 0, 0))+ k.box("coal_bin", (2.0, 1.4, 0.9), (-W / 2 + 1.6, y_front - 2.4, base + 0.45), "steel_dark", root, bevel=0.06)+ k.box("coal", (1.6, 1.0, 0.4), (-W / 2 + 1.6, y_front - 2.4, base + 1.05), "fam_models", root, bevel=0.15, emissive=0.9)++ _sign(k, root, "MODELS", 5.8, -1.4, y_front, roof_z + 1.35, "fam_models", size=1.0)+ return root+++# ---------------------------------------------------------------------------+# 5. The Town Hall — rooms and the board+# ---------------------------------------------------------------------------+++def build_town_hall(k) -> bpy.types.Object:+ """The town hall: a symmetric stone front with a flight of steps, four+ columns under a pediment, a clock tower with a bell, and the notice board+ where the board's open items hang. 7 x 5 tiles."""+ W, D, H = 13.4, 9.4, 5.6+ root = k.new_root(+ "town-hall",+ {+ "jarvis_building": {+ "contract": 1,+ "id": "town-hall",+ "footprint": [7, 5],+ "forward": "+Z",+ "door": [0.0, 4.7],+ "stand": [0, 8.0],+ "sign": [0.0, 9.2, 0],+ "height_m": 15.6,+ }+ },+ )+ y_front = -D / 2+ base = 0.4+ k.box("plinth", (W + 1.0, D + 1.0, base), (0, 0, base / 2), "plinth", root, bevel=0.08)+ k.box("hall", (W, D, H), (0, 0, base + H / 2), "stone", root, bevel=0.14)+ k.box("base_band", (W + 0.14, D + 0.14, 0.7), (0, 0, base + 0.35), "stone_dark", root, bevel=0.05)+ roof_z = base + H+ k.box("cornice", (W + 1.1, D + 1.1, 0.5), (0, 0, roof_z + 0.25), "stone_dark", root, bevel=0.1)+ k.box("roof", (W - 0.4, D - 0.4, 0.5), (0, 0, roof_z + 0.75), "roof", root, bevel=0.08)++ # The steps and the portico.+ for i in range(4):+ k.box(f"step_{i}", (8.4 - i * 0.4, 0.6, 0.26), (0, y_front - 2.6 + i * 0.6, base - 0.05 + i * 0.26), "stone_dark", root, bevel=0.03)+ for i, cx in enumerate((-3.9, -1.3, 1.3, 3.9)):+ k.cylinder(f"column_{i}", 0.46, 4.6, (cx, y_front - 1.2, base + 2.3), "stone", root, verts=16)+ k.cylinder(f"column_cap_{i}", 0.6, 0.3, (cx, y_front - 1.2, base + 4.6), "stone_dark", root, verts=16)+ k.cylinder(f"column_foot_{i}", 0.6, 0.3, (cx, y_front - 1.2, base + 0.15), "stone_dark", root, verts=16)+ k.box("architrave", (9.8, 2.2, 0.55), (0, y_front - 1.2, base + 5.05), "stone", root, bevel=0.06)+ # The pediment: a dark tympanum field with two roof slabs sloping off it, so+ # the triangle reads against the stone instead of dissolving into it.+ arch_top = base + 5.325+ k.box("tympanum", (9.0, 1.4, 1.5), (0, y_front - 1.0, arch_top + 0.75), "stone_dark", root, bevel=0.05)+ slope = math.atan2(1.7, 4.9)+ for sx in (-1, 1):+ k.box(+ f"pediment_{'l' if sx < 0 else 'r'}",+ (5.19, 1.8, 0.4),+ (sx * 2.45, y_front - 1.3, arch_top + 0.85),+ "roof",+ root,+ bevel=0.04,+ rot=(0, sx * slope, 0),+ )+ k.cylinder("pediment_medal", 0.62, 0.22, (0, y_front - 1.75, arch_top + 0.7), "fam_civic", root, verts=20, rot=(math.pi / 2, 0, 0), emissive=1.0)++ # The doors, tall and dark, between the middle pair of columns.+ k.box("door_frame", (3.6, 0.32, 4.0), (0, y_front + 0.06, base + 2.0), "stone_dark", root, bevel=0.05)+ k.box("door_l", (1.55, 0.16, 3.5), (-0.82, y_front - 0.08, base + 1.75), "wood_dark", root, bevel=0.03)+ k.box("door_r", (1.55, 0.16, 3.5), (0.82, y_front - 0.08, base + 1.75), "wood_dark", root, bevel=0.03)++ # The clock tower with its bell, set back on the roof.+ tx, ty = 0.0, 1.6+ k.box("tower", (3.6, 3.6, 5.0), (tx, ty, roof_z + 1.0 + 2.5), "stone", root, bevel=0.1)+ k.box("tower_band", (3.8, 3.8, 0.35), (tx, ty, roof_z + 1.35), "stone_dark", root, bevel=0.05)+ k.cylinder("tower_clock", 1.05, 0.25, (tx, ty - 1.85, roof_z + 4.4), "brass", root, verts=24, rot=(math.pi / 2, 0, 0))+ k.cylinder("tower_face", 0.88, 0.14, (tx, ty - 1.97, roof_z + 4.4), "paper", root, verts=24, rot=(math.pi / 2, 0, 0), emissive=0.55)+ k.box("tower_hand_h", (0.08, 0.07, 0.55), (tx, ty - 2.06, roof_z + 4.62), "ink", root, bevel=0.01)+ k.box("tower_hand_m", (0.62, 0.07, 0.08), (tx - 0.25, ty - 2.06, roof_z + 4.4), "ink", root, bevel=0.01)+ k.box("belfry", (3.0, 3.0, 1.9), (tx, ty, roof_z + 6.9), "stone_dark", root, bevel=0.08)+ for sx in (-1, 1):+ k.box(f"belfry_arch_{'l' if sx < 0 else 'r'}", (0.9, 0.14, 1.3), (tx + sx * 0.8, ty - 1.52, roof_z + 6.9), "ink", root, bevel=0.04)+ k.cylinder("bell", 0.62, 0.9, (tx, ty, roof_z + 6.8), "brass", root, verts=16, emissive=0.4)+ k.box("tower_roof_a", (3.6, 3.6, 0.4), (tx, ty, roof_z + 8.0), "roof", root, bevel=0.08)+ k.box("tower_roof_b", (2.4, 2.4, 0.9), (tx, ty, roof_z + 8.6), "roof", root, bevel=0.1)+ k.cylinder("finial", 0.16, 1.2, (tx, ty, roof_z + 9.6), "brass", root, verts=10, emissive=0.6)++ # The notice board on the forecourt: the board's open items, in wood and paper.+ bx, by = -W / 2 + 2.2, y_front - 3.6+ for sx in (-1, 1):+ k.box(f"notice_post_{'l' if sx < 0 else 'r'}", (0.2, 0.2, 2.4), (bx + sx * 1.5, by, base + 1.2), "wood_dark", root, bevel=0.03)+ k.box("notice_board", (3.4, 0.18, 2.0), (bx, by, base + 2.0), "wood", root, bevel=0.05)+ for i, (nx, nz) in enumerate(((-0.9, 2.35), (0.2, 2.5), (1.1, 2.15), (-0.4, 1.65))):+ k.box(f"notice_{i}", (0.75, 0.06, 0.55), (bx + nx, by - 0.14, base + nz), "paper", root, bevel=0.01, emissive=0.5)+ # The flagpole on the other side.+ k.cylinder("flag_pole", 0.13, 6.0, (W / 2 - 1.8, y_front - 2.6, base + 3.0), "metal", root, verts=8)+ k.box("flag", (1.9, 0.08, 1.1), (W / 2 - 0.85, y_front - 2.6, base + 5.4), "fam_civic", root, bevel=0.03, emissive=0.8)++ # A civic front carries its name in the tympanum, not on a neon board.+ k.text_mesh(+ "name", "TOWN HALL", 0.68, 0.14, (0, y_front - 2.42, arch_top + 0.62), "ink", root, emissive=0.0+ )+ return root+++# ---------------------------------------------------------------------------+# 6. The Observatory — the web and the browser+# ---------------------------------------------------------------------------+++def build_observatory(k) -> bpy.types.Object:+ """The lookout: a round tower under a slotted dome with the telescope+ pointing out of it, a railed terrace with a standing glass, and a weather+ vane. Where an agent stands while it reads the world outside. 5 x 5 tiles."""+ D = 9.4+ root = k.new_root(+ "observatory",+ {+ "jarvis_building": {+ "contract": 1,+ "id": "observatory",+ "footprint": [5, 5],+ "forward": "+Z",+ "door": [0.0, 3.4],+ "stand": [0, 6.6],+ "sign": [0.0, 6.0, 0],+ "height_m": 14.2,+ }+ },+ )+ y_front = -D / 2+ base = 0.4+ # A round building gets a round plinth: a square slab under it reads as a+ # stray platform from the island's fixed 50° camera.+ k.cylinder("plinth", 4.9, base, (0, 0, base / 2), "plinth", root, verts=24)+ # The drum: a low round base carrying the tower.+ k.cylinder("drum", 4.2, 1.5, (0, 0, base + 0.75), "stone", root, verts=24)+ k.cylinder("drum_band", 4.35, 0.3, (0, 0, base + 1.35), "stone_dark", root, verts=24)+ tower_h = 7.2+ k.cylinder("tower", 3.3, tower_h, (0, 0, base + 1.5 + tower_h / 2), "wall", root, verts=24)+ for i in range(3):+ k.cylinder(f"tower_band_{i}", 3.36, 0.35, (0, 0, base + 3.0 + i * 2.1), "fam_web", root, verts=24, emissive=0.7)+ # Windows: four tall slits round the shaft, one facing the viewer.+ for i, ang in enumerate((0.0, 0.9, -0.9, math.pi)):+ k.box(+ f"slit_{i}",+ (0.9, 0.16, 2.4),+ (math.sin(ang) * 3.28, -math.cos(ang) * 3.28, base + 4.2),+ "glass",+ root,+ bevel=0.03,+ emissive=0.45,+ rot=(0, 0, -ang),+ )+ top_z = base + 1.5 + tower_h+ # The terrace: a ring deck with posts and a rail.+ k.cylinder("terrace", 4.1, 0.3, (0, 0, top_z + 0.15), "trim", root, verts=24)+ for i in range(12):+ a = i / 12 * math.pi * 2+ k.box(f"rail_post_{i}", (0.12, 0.12, 0.85), (math.sin(a) * 3.85, math.cos(a) * 3.85, top_z + 0.72), "metal", root, bevel=0.02)+ k.cylinder("rail_top", 3.96, 0.13, (0, 0, top_z + 1.12), "metal", root, verts=24)+ # The dome, its shutter and the telescope leaning out of it.+ k.cylinder("dome_base", 2.85, 0.5, (0, 0, top_z + 0.55), "wall_shade", root, verts=24)+ bpy.ops.mesh.primitive_uv_sphere_add(segments=24, ring_count=12, radius=2.7, location=(0, 0, top_z + 0.8))+ dome = bpy.context.active_object+ dome.name = "dome"+ dome.scale = (1.0, 1.0, 0.7)+ bpy.ops.object.transform_apply(scale=True)+ bpy.ops.object.mode_set(mode="EDIT")+ bpy.ops.mesh.select_all(action="SELECT")+ bpy.ops.mesh.bisect(+ plane_co=(0, 0, top_z + 0.8), plane_no=(0, 0, 1), clear_inner=True, use_fill=True+ )+ bpy.ops.object.mode_set(mode="OBJECT")+ dome.data.materials.clear()+ dome.data.materials.append(k.material("metal"))+ dome.parent = root+ # The slit the telescope looks out of, sunk into the dome.+ k.box("dome_slot", (1.1, 2.6, 1.2), (0, -1.5, top_z + 1.4), "screen", root, bevel=0.04, rot=(0.45, 0, 0))+ k.cylinder("scope", 0.55, 4.8, (0, -1.7, top_z + 2.4), "steel_dark", root, verts=16, rot=(1.0, 0, 0))+ k.cylinder("scope_lens", 0.6, 0.3, (0, -3.7, top_z + 3.6), "fam_web", root, verts=16, rot=(1.0, 0, 0), emissive=2.2)+ k.cylinder("scope_mount", 0.38, 1.6, (0, -0.9, top_z + 1.2), "steel", root, verts=12)+ # The vane on top of the dome.+ k.cylinder("vane_pole", 0.1, 1.8, (0, 0, top_z + 2.9), "brass", root, verts=8)+ k.box("vane_arrow", (1.4, 0.08, 0.45), (0.45, 0, top_z + 3.7), "brass", root, bevel=0.03)+ k.box("vane_tail", (0.55, 0.08, 0.65), (-0.45, 0, top_z + 3.7), "brass", root, bevel=0.03)++ # The door at the foot, its little porch, and a standing glass on the plaza.+ k.box("door_porch", (3.4, 2.4, 3.0), (0, y_front + 0.9, base + 1.5), "wall", root, bevel=0.08)+ k.box("porch_roof", (4.0, 2.9, 0.32), (0, y_front + 0.9, base + 3.15), "roof", root, bevel=0.06)+ k.box("door", (1.4, 0.18, 2.4), (0, y_front - 0.26, base + 1.2), "wood_dark", root, bevel=0.04)+ _lamp(k, root, "lamp_l", (-2.5, y_front - 0.1, base), "fam_web")+ _lamp(k, root, "lamp_r", (2.5, y_front - 0.1, base), "fam_web")+ gx, gy = -3.6, y_front - 0.4+ k.cylinder("glass_stand", 0.26, 2.0, (gx, gy, base + 1.0), "metal", root, verts=10)+ k.cylinder("glass_tube", 0.32, 1.5, (gx, gy, base + 2.5), "steel_dark", root, verts=12, rot=(1.1, 0, 0.3))+ k.cylinder("glass_lens", 0.36, 0.2, (gx + 0.18, gy - 0.6, base + 3.1), "fam_web", root, verts=12, rot=(1.1, 0, 0.3), emissive=1.8)++ # The sign hangs on the shaft above the porch roof, where the tower's own+ # curve gives it a back — a board floating in front of a cylinder reads as+ # a mistake from every angle but one.+ _sign(k, root, "LOOKOUT", 3.6, 0, y_front - 0.85, base + 4.75, "fam_web", size=0.72)+ return root+++TOWN_BUILDERS = {+ "signal-office": build_signal_office,+ "control-room": build_control_room,+ "gallery-hall": build_gallery_hall,+ "model-boilerhouse": build_model_boilerhouse,+ "town-hall": build_town_hall,+ "observatory": build_observatory,+}+++def main(argv: list[str]) -> None:+ import argparse++ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument("--target", default="signal-office", choices=sorted(TOWN_BUILDERS) + ["all"])+ parser.add_argument("--out", required=True)+ parser.add_argument("--keep-scene", action="store_true")+ parser.add_argument(+ "--preview-dir", default=None, help="render a dimetric preview per target into this folder"+ )+ parser.add_argument("--preview-scale", type=float, default=26.0)+ args = parser.parse_args(argv)+ k = _base()+ for key, value in TOWN_PALETTE.items():+ k.PALETTE.setdefault(key, value)+ targets = sorted(TOWN_BUILDERS) if args.target == "all" else [args.target]+ for target in targets:+ if not args.keep_scene:+ k.clear_scene()+ else:+ # A previous run of this target may have left its tree behind.+ stale = bpy.data.objects.get(target)+ if stale is not None:+ k.select_tree(stale)+ bpy.ops.object.delete(use_global=False)+ root = TOWN_BUILDERS[target](k)+ path = k.export_glb(root, Path(args.out))+ print(f"exported {path} ({path.stat().st_size} bytes)")+ if args.preview_dir:+ shot = Path(args.preview_dir) / f"{target}.png"+ shot.parent.mkdir(parents=True, exist_ok=True)+ k.render_preview(root, shot, args.preview_scale)+ print(f"preview {shot}")+ if args.keep_scene:+ k.select_tree(root)+ bpy.ops.object.delete(use_global=False)+++if __name__ == "__main__":+ own = sys.argv[sys.argv.index("--") + 1 :] if "--" in sys.argv else []+ main(own)+elif "KIT_ARGS" in globals():+ main(globals()["KIT_ARGS"])diff --git a/tests/unit/society/test_checkpoints.py b/tests/unit/society/test_checkpoints.pyindex 11f61ce93a..9e58d4b6e1 100644--- a/tests/unit/society/test_checkpoints.py+++ b/tests/unit/society/test_checkpoints.py@@ -7,7 +7,15 @@ from pathlib import Pathimport pytest-from jarvis.society.checkpoints import CheckpointEngine, Facts, derive, family_of_tool+from jarvis.society.checkpoints import (+ FAMILY_COMMS,+ FAMILY_DESKTOP,+ FAMILY_WEB,+ CheckpointEngine,+ Facts,+ derive,+ family_of_tool,+)from jarvis.society.events import Checkpoint, MsgType, SocietyEnvelopefrom jarvis.society.runtime import SocietyRuntime@@ -83,11 +91,12 @@ async def test_board_envelopes_move_agents(rt: SocietyRuntime):msg_type=MsgType.RESULT, from_agent="scout", to_agent="user", trace_id="t2", payload={}))- assert (await rt.roster.get("scout")).checkpoint is Checkpoint.IDLE+ # Delivered work goes to the Gallery for the hold, not straight home.+ assert (await rt.roster.get("scout")).checkpoint is Checkpoint.GALLERYby_agent = {}for p in pushed:by_agent.setdefault(p.agent_id, []).append(p.checkpoint)- assert by_agent["scout"] == ["gate", "idle", "meeting", "idle", "desk", "idle"]+ assert by_agent["scout"] == ["gate", "idle", "meeting", "idle", "desk", "gallery"]assert by_agent["archivist"] == ["meeting", "idle"]@@ -119,22 +128,65 @@ def test_running_agents_stand_at_the_shop_of_their_tools():def test_family_of_tool():- assert family_of_tool("gmail") == "plugin"+ assert family_of_tool("google_drive") == "plugin"assert family_of_tool("cli_claude") == "cli"assert family_of_tool("github/search_issues") == "mcp"assert family_of_tool("society_run_skill") == "skill"assert family_of_tool("society_shell") == "core"- assert family_of_tool("society_browser") == "core"assert family_of_tool("spawn-worker") == "core"# A coding CLI: native tools are CLI work, Jarvis' MCP server hands out the plugins.assert family_of_tool("Bash", cli_seat=True) == "cli"assert family_of_tool("Read", cli_seat=True) == "cli"- assert family_of_tool("mcp__jarvis__gmail", cli_seat=True) == "plugin"+ assert family_of_tool("mcp__jarvis__google_drive", cli_seat=True) == "plugin"assert family_of_tool("mcp__jarvis__society_run_skill", cli_seat=True) == "skill"assert family_of_tool("mcp__github__search_issues", cli_seat=True) == "mcp"assert family_of_tool("mcp__github__search_issues") == "mcp"+def test_work_family_beats_the_capability_kind():+ """What the agent DOES decides the hall, not where the hand came from: a+ mail is a trip to the Signal Office whether it leaves through a plugin, a+ CLI seat or Jarvis' own MCP server."""+ assert family_of_tool("gmail") == "comms"+ assert family_of_tool("call-contact") == "comms"+ assert family_of_tool("society_message_agent") == "comms"+ assert family_of_tool("gmail", cli_seat=True) == "comms"+ assert family_of_tool("mcp__jarvis__gmail", cli_seat=True) == "comms"+ # The desktop hands, including the two that used to read as plain core work.+ assert family_of_tool("click") == "desktop"+ assert family_of_tool("computer-use") == "desktop"+ assert family_of_tool("screen-snapshot") == "desktop"+ # The world outside.+ assert family_of_tool("search-web") == "web"+ assert family_of_tool("society_browser") == "web"+ # A server that is not Jarvis' stays an MCP capability, name or no name.+ assert family_of_tool("mcp__acme__gmail") == "mcp"+++def test_every_work_family_has_a_hall():+ """No family may derive to a place the island cannot draw."""+ for family in (FAMILY_COMMS, FAMILY_DESKTOP, FAMILY_WEB):+ place = derive(Facts(running=True, family=family))+ assert place is not Checkpoint.DESK, f"{family} has no hall"+++def test_a_local_brain_stands_at_the_boiler_house():+ """Its own model thinking is the work; a tool call takes over once one lands."""+ assert derive(Facts(running=True, local_brain=True)) is Checkpoint.HUB_MODELS+ # A CLI seat does not outrank it, a tool family does.+ assert derive(Facts(running=True, local_brain=True, cli_seat=True)) is Checkpoint.HUB_MODELS+ assert derive(Facts(running=True, local_brain=True, family=FAMILY_WEB)) is Checkpoint.HUB_WEB+ # Idle, it is nobody's business which brain the agent has.+ assert derive(Facts(local_brain=True)) is Checkpoint.IDLE+++def test_a_delivery_outranks_the_shop_but_not_a_room():+ assert derive(Facts(running=True, delivering=True, family="plugin")) is Checkpoint.GALLERY+ assert derive(Facts(delivering=True, memory_active=True)) is Checkpoint.GALLERY+ assert derive(Facts(delivering=True, in_room=True)) is Checkpoint.MEETING+ assert derive(Facts(delivering=True, paused=True)) is Checkpoint.IDLE++class FakeChatService:"""The slice of the agent-chat service the engine touches."""@@ -176,7 +228,7 @@ async def test_a_typed_turn_walks_to_the_docks_and_back(rt: SocietyRuntime):await _settle()assert (await rt.roster.get("scout")).checkpoint is Checkpoint.DESKassert rt.checkpoints.is_busy("scout")- svc.emit(session, "tool_call", name="gmail", input={})+ svc.emit(session, "tool_call", name="google_drive", input={})await _settle()assert (await rt.roster.get("scout")).checkpoint is Checkpoint.HUB_PLUGINS# A second watcher for the same agent is not started while one runs.@@ -199,7 +251,7 @@ async def test_family_hysteresis(rt: SocietyRuntime):rt.checkpoints = engineengine.attach()rt.scheduler.note_run_started("run-1", "scout")- await engine.note_tool_call("scout", "gmail")+ await engine.note_tool_call("scout", "google_drive")assert (await rt.roster.get("scout")).checkpoint is Checkpoint.HUB_PLUGINSfor _ in range(3):await engine.note_tool_call("scout", "github/list_prs")