interlatch 0.26.0__tar.gz → 0.27.0__tar.gz

{interlatch-0.26.0 → interlatch-0.27.0}/CHANGELOG.md

@@ -3,6 +3,32 @@
 <!-- Don't add lines here: a pull request puts its line in a new file in changelog.d/ (see changelog.d/README.md),
      and each release moves the files it took into a dated section below. -->
 
+## 0.26.0 (2026-10-16)
+
+- **Adventure:** a new page in Innerlatch puts every lesson that counts on a pixel world map, one region per attribute
+  and one territory per roadmap module, fogged where no lesson reached yet. Click a monster for a turn-based battle
+  (Attack, Skill, Defend, Run) led by the agent that taught it; a win marks it cleared, and battles never change
+  levels. The Party page keeps the characters and quests, and a lesson link anywhere in Innerlatch now opens the lesson
+  in a window over the page instead of leaving for the dashboard ([Party](docs/party.md#adventure)).
+- **Choose what analyzes sessions at install:** `interlatch install` now lists every choice (Claude Code, Codex,
+  IBM Bob and the model providers' APIs, Ollama included) with whether each is ready, and sets up the one you pick:
+  its endpoint, API key and model, then one test call. `--backend <name>` chooses without asking
+  ([Install](docs/install.md#command-line)).
+- **Joining a hub works again:** `interlatch hub join` no longer stops with "module 'http' has no attribute 'client'"
+  on a fresh install.
+- **A group's page:** **Analyze** on a project group's heading on the Projects page (or **The whole group** in the
+  sidebar) reads the group's projects as one big project. It shows each project's share of the group's time, cost and
+  knowledge, what waits on you across all of them, where their last sessions left off, each folder in git, their
+  roadmaps and their work week by week, with every item named by its project. A **Map** draws the projects and the
+  services and platforms they use, hand-drawn, with the ones they share easy to spot and an Excalidraw download; Usage
+  charts each project's time week by week. Each project's knowledge base and architecture sketch sit beside the
+  others, and the glossary terms the projects share come first ([Project groups](docs/dashboard.md#project-groups)).
+- **Towns and gear:** each Adventure region has a town whose shop sells gear for its roadmap modules (a weapon, armor
+  and charm per module, in three tiers that open as your agents reach Lv 1, 3 and 5 in that skill) and battle supplies.
+  A lesson's first win pays gold and may drop loot of its kind; battles gain an **Item** command, and each agent
+  wears three slots, changed on its page or in the new **Bag**. Gear only changes battle numbers, never levels
+  ([Party](docs/party.md#towns-and-gear)).
+
 ## 0.25.0 (2026-10-15)
 
 - **Innerlatch:** the Party, the Leaderboard, the Arena and their Google sign-in moved out of the dashboard into

{interlatch-0.26.0 → interlatch-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: interlatch
-Version: 0.26.0
+Version: 0.27.0
 Summary: Shared memory for your coding agents: records every session (Claude Code, Codex, Copilot, Bob, Antigravity, OpenCode) locally and keeps what they learned, each lesson linked to the session it came from.
 Project-URL: Homepage, https://interlatch.com
 Project-URL: Documentation, https://interlatch.com/docs/

interlatch-0.27.0/changelog.d/party-formations.md

@@ -0,0 +1,4 @@
+- **Formations:** the Party page builds decks, teams of one to three agents in the order they fight, up to five
+  of them. The Arena fields the deck you pick, as a relay: lead against lead, and whoever wins a bout stays on with
+  the HP it has left. A deck of one is the old champion duel. Sheets now carry the lineup (format 3), so arena players
+  on older versions don't meet newer ones until they update ([Party](docs/party.md#formations)).

{interlatch-0.26.0 → interlatch-0.27.0}/docs/ja/party.md

@@ -85,18 +85,28 @@ Lv 1 に達すると I 段階、Lv 3 で II 段階、Lv 5 で III 段階が店
 身につけます。エージェントのページか**バッグ**で付け替え、バッグでは要らないものを売れます。装備で変わるのは戦闘の数値だけで、
 レベルや経験値は教訓からだけ得られます。
 
+## 編成
+
+パーティー画面の**編成**で**デッキ**を作れます。デッキは 1〜3 人のエージェントを戦う順番（先鋒・中堅・大将）に並べたチームで、
+名前をつけて 5 つまで持てます。枠の下の**控え**からエージェントを入れ、矢印かドラッグで順番を入れ替えます。控えのエージェントを
+枠にドラッグすると入れ替わります。何も変えないうちは、レベルの高い 3 人のデッキが 1 つあります（デッキができる前にチャンピオンを
+選んでいた場合は、そのエージェントとレベルの高い 2 人）。アリーナに出すデッキは、ここかアリーナのページの
+**アリーナに出場させる**で選びます。デッキで変わるのは誰がどの順番で戦うかだけで、レベルは変わりません。
+
 ## アリーナ
 
 リーダーボードに参加している人は、パーティーを**アリーナ**に出すこともできます。アリーナは Innerlatch の独立したページです。
 Innerlatch のレールで**アリーナ**を開き、**アリーナに入る**を選びます（先にボードに参加します）。それからは同期のたびに、パーティーのキャラクター
-シートを公開します。コーディングエージェントそれぞれのレベル、ランク、クラス、6 つの能力値のレベルと、どのエージェントが
-チャンピオンか、ボードに表示する名前と画像、コンピューターを見分けるコード（名前ではなくハッシュ）です。教訓、プロジェクト、
+シートを公開します。コーディングエージェントそれぞれのレベル、ランク、クラス、6 つの能力値のレベルと、出場させるチーム
+（どのエージェントをどの順番で出すか）、ボードに表示する名前と画像、コンピューターを見分けるコード（名前ではなくハッシュ）です。教訓、プロジェクト、
 セッション、タイトル、プロンプトは送りません。
 
-アリーナはチャンピオン同士の一騎打ちです。チャンピオンは、アリーナのカードのタイルでほかを選ぶまでは、いちばんレベルの高い
-エージェントです。毎週、ほかのすべてのプレイヤーのチャンピオンと 1 回ずつ戦い、アリーナのページは勝利数と、各プレイヤーの
-チャンピオンとそのレベルを並べます。ライバルをクリックすると一騎打ちを見られます。左があなたのチャンピオン、右が相手で、
-ラウンドごとに進み、同じ戦いが下に記録として書かれ、その下に両方のパーティーが並びます。対戦は公開された 2 つのシートとその週から、あなた自身の
+アリーナはチーム同士の勝ち抜き戦です。あなたのチームは、出場させているデッキです（[編成](#編成)）。毎週、ほかのすべての
+プレイヤーのチームと 1 回ずつ戦います。先鋒どうしがラウンドごとに 1 対 1 で戦い、勝ったほうは残りの HP のまま相手の次の
+エージェントと戦います。40 ラウンドたっても決着しないときは、HP の残りが少ないほうが敗退します。先にエージェントがいなくなった
+チームの負けです。1 人のデッキ同士なら、ふつうの一騎打ちです。アリーナのページは勝利数と、各プレイヤーのチームを並べます。
+ライバルをクリックすると対戦を見られます。左があなたのチーム、右が相手で、同じ戦いが下に記録として書かれ、その下に両方の
+パーティーが並びます。対戦は公開された 2 つのシートとその週から、あなた自身の
 コンピューターで計算されるので、2 人とも同じ結果を見ます。数字は自己申告で、記録ではなくゲームです。**アリーナを出る**と
 シートは削除され、ボードには残ります。ボードから抜けるとアリーナからも出ます。
 

{interlatch-0.26.0 → interlatch-0.27.0}/docs/ja/privacy.md

@@ -18,7 +18,7 @@ Interlatch の Firebase プロジェクトから、公開されている求人
 このリクエストに含まれるのはプロジェクトの公開ウェブキーだけで、サインインを含め、あなたに関する情報は何も送りません。
 さらにアリーナのページで**アリーナに入る**と、同期のたびにパーティーのキャラクターシートを同じ Firebase プロジェクトに
 公開し、誰でも読めるようになります。コーディングエージェントそれぞれのレベル、ランク、クラス、6 つの能力値のレベルと、
-どのエージェントがチャンピオンか、ボードの名前と画像、コンピューターを見分けるハッシュです。教訓、プロジェクト、セッション、タイトル、プロンプトは送りません。
+出場させるチーム（どのエージェントをどの順番で出すか）、ボードの名前と画像、コンピューターを見分けるハッシュです。教訓、プロジェクト、セッション、タイトル、プロンプトは送りません。
 対戦は公開されたシートからあなたのコンピューターで計算されます。**アリーナを出る**（またはボードから抜ける）とシートは削除されます
 （[アリーナ](party.md#アリーナ)）。
 claude.ai や ChatGPT のエクスポートを取り込むときはチャットだけを読み、アカウントのファイル（`users.json`、`user.json`）は開きません。

{interlatch-0.26.0 → interlatch-0.27.0}/docs/party.md

@@ -95,18 +95,29 @@ ADR Scroll from a decision. Use supplies and loot from the **Item** command in a
 (weapon, armor, charm): change them on the agent's page or in the **Bag**, where you can also sell what you don't need.
 Gear only changes battle numbers: levels and XP still come from lessons alone.
 
+## Formations
+
+On the Party page, **Formation** builds **decks**: teams of one to three of your agents, in the order they fight
+(lead, middle, anchor). Keep up to five, each with a name of your choice. Add an agent from the **Bench** below the
+slots, reorder with the arrows or by dragging, and drag a bench agent onto a slot to swap it in. Until you change
+anything, your party has one deck: your three highest-level agents (or, if you picked a champion before decks
+existed, that agent and then the two highest). One deck is the one the Arena fields: pick it with **Field in the
+Arena**, here or on the Arena page. A deck changes who fights and in what order, never a level.
+
 ## The arena
 
 People on the leaderboard can also put their parties in the **Arena**, a page of its own in Innerlatch. Open
 **Arena** in Innerlatch's rail and choose **Enter the arena** (you join the board first). From then on each sync publishes your party's
-character sheet: for each of your coding agents its level, tier, class and six attribute levels, and which agent
-is your champion, with the name and picture you show on the board and the code that tells your computers apart (a
+character sheet: for each of your coding agents its level, tier, class and six attribute levels, and the team you
+field (which agents, in what order), with the name and picture you show on the board and the code that tells your computers apart (a
 hash, not a name). No lessons, projects, sessions, titles or prompts go.
 
-The arena is champion against champion. Your champion is your highest-level agent until you pick another from the
-tiles on your arena card. Every week it duels every other player's champion once, and the Arena page ranks you by
-wins, with each player's champion and level. Click a rival to watch the duel: your champion on the left, theirs on
-the right, round by round, with the same fight written out as a log underneath and both full parties below. Each battle is worked out on your own
+The arena is team against team, in a relay. Your team is the deck you field ([Formations](#formations)). Every
+week it fights every other player's team once: the two leads fight one on one, round by round; whoever wins the bout
+stays on, with the HP it has left, against the other side's next agent; a bout still going after 40 rounds puts out
+the one with less of its HP left. The team that runs out of agents loses. A deck of one against a deck of one is a
+plain duel. The Arena page ranks you by wins, with each player's team. Click a rival to watch the battle: your team on
+the left, theirs on the right, with the same fight written out as a log underneath and both full parties below. Each battle is worked out on your own
 computer from the two published sheets and the week, so both players see the same result. The numbers are
 self-reported: it's a game, not a record. **Leave the arena** deletes your sheet; you stay on the board. Leaving the
 board leaves the arena too.

{interlatch-0.26.0 → interlatch-0.27.0}/docs/privacy.md

@@ -20,7 +20,7 @@ public job-market numbers (open roles per roadmap track) from Interlatch's Fireb
 That request carries the project's public web key and nothing about you, not even your sign-in.
 If you also **Enter the arena** on the Arena page, each sync publishes your party's character sheet to the same
 Firebase project, readable by anyone: for each of your coding agents its level, tier, class and six attribute
-levels, and which agent is your champion, with your board name and picture and a hash that tells your computers apart. No lessons, projects, sessions,
+levels, and the team you field (which agents, in what order), with your board name and picture and a hash that tells your computers apart. No lessons, projects, sessions,
 titles or prompts. Battles are worked out on your computer from the published sheets; **Leave the arena** (or leaving
 the board) deletes your sheet ([The arena](party.md#the-arena)).
 Importing a claude.ai or ChatGPT export reads only the chats, never the account files (`users.json`, `user.json`).

{interlatch-0.26.0 → interlatch-0.27.0}/leaderboard/firestore.rules

@@ -111,12 +111,14 @@ service cloud.firestore {
         && data.at == request.time;
     }
 
-    // The arena: a party's sheet (src/interlatch/sharing/arena.py writes it). Fields (all required, no others):
-    //   name, photo, machine: as for players; v: int, the sheet format (2);
+    // The arena: a party's sheet (src/interlatch/sharing/arena.py writes it). Fields (all required but lineup, no others):
+    //   name, photo, machine: as for players; v: int, the sheet format (2, or 3 with a lineup);
     //   agents: a map of the coding agents, each {level: int 1-200, tier: novice|adept|expert|master,
     //           cls: null or a track id (<= 64), attrs: {craft, data, ops, guard, arcana, lore: int}}: always the first
     //           five, and opencode from Interlatch versions that know it (sheets from older ones have no opencode);
-    //   champion: which of them fights for the party;
+    //   champion: which of them fights first for the party;
+    //   lineup (v 3 only, and required there): the deck it fields, 1-3 of its agents in order, each once, the champion
+    //           first (v 2 sheets, from versions before decks, field the champion alone);
     //   at: timestamp, the server time of the upload (request.time). No lessons, projects or titles.
     // Cheap on purpose: a request may evaluate at most 1000 expressions, and the full bounds on every attribute (as
     // before) went over it with five agents, so no sheet could be written. The values' bounds are left to the readers,
@@ -132,17 +134,23 @@ service cloud.firestore {
         && a.attrs.guard is int && a.attrs.arcana is int && a.attrs.lore is int;
     }
 
+    function isValidArenaLineup(data) {
+      return data.lineup is list && data.lineup.size() >= 1 && data.lineup.size() <= 3
+        && data.lineup.toSet().size() == data.lineup.size() && data.lineup.hasOnly(data.agents.keys())
+        && data.lineup[0] == data.champion;
+    }
+
     function isValidArena(data) {
       let fields = ['name', 'photo', 'machine', 'v', 'agents', 'champion', 'at'];
       let agents = ['claude', 'codex', 'copilot', 'bob', 'antigravity', 'opencode'];
       let required = ['claude', 'codex', 'copilot', 'bob', 'antigravity'];
-      return hasOnlyAllowedFields(fields) && hasRequiredFields(fields)
+      return hasOnlyAllowedFields(fields.concat(['lineup'])) && hasRequiredFields(fields)
         && data.name is string && data.name.size() >= 1 && data.name.size() <= 64
         && data.photo is string && data.photo.size() <= 500
         && (data.photo == ''
             || data.photo.matches('^https://(lh3[.]googleusercontent[.]com|avatars[.]githubusercontent[.]com)/[^\\s]+$'))
         && data.machine is string && data.machine.matches('^[A-Za-z0-9-]{8,64}$')
-        && data.v == 2
+        && ((data.v == 2 && !('lineup' in data)) || (data.v == 3 && isValidArenaLineup(data)))
         && data.champion in agents
         && data.agents is map && data.agents.keys().hasOnly(agents) && data.agents.keys().hasAll(required)
         && isValidArenaAgent(data.agents.claude) && isValidArenaAgent(data.agents.codex)

{interlatch-0.26.0 → interlatch-0.27.0}/src/interlatch/core/i18n/ja.py

@@ -373,6 +373,11 @@ JA: dict[str, str] = {
     "that doesn't go in this slot": "それはこの装備欄には付けられません",
     "only consumables and loot can be used": "使えるのは消耗品と戦利品だけです",
     "none left": "もう残っていません",
+    # ---- formations (formation.py)
+    "no such deck": "そのデッキはありません",
+    "a party holds at most 5 decks": "デッキは 5 つまでです",
+    "a party keeps at least one deck": "デッキは最低 1 つ必要です",
+    "a deck holds one to three of your agents, each once": "デッキには 1〜3 人のエージェントを、重複なしで入れてください",
     "{tier} {noun} of {module}": "{tier}の{noun}（{module}）",
     "+{atk} attack, and +{skill} to the {module} skill, in battle only": "攻撃 +{atk}、{module} のスキル +{skill}（戦闘中のみ）",
     "+{hp} HP, and {cut}% less damage taken, in battle only": "HP +{hp}、受けるダメージ {cut}% 減（戦闘中のみ）",

{interlatch-0.26.0 → interlatch-0.27.0}/src/interlatch/interfaces/web/api/leaderboard.py

@@ -23,8 +23,8 @@ def leaderboard(ctx: Context, q: dict) -> dict:
         try:
             out["rows"] = arena.board(me.get("uid") if me.get("arena") else None)
             out["week"] = arena.week()
-            if me.get("signed_in"):  # who this computer fields (picked, or the highest level)
-                out["me"] = {**me, "champion": arena.champion(ctx.cfg, ctx.conn, lb.read_state(ctx.cfg))}
+            if me.get("signed_in"):  # the team this computer fields, and the decks it can pick from
+                out["me"] = {**me, **_fielding(ctx)}
         except lb.LeaderboardError as e:
             out["error"] = str(e)
         return out
@@ -101,13 +101,20 @@ def action_arena(ctx: Context, which: str) -> dict:
     return lb.status(ctx.cfg)
 
 
-def action_arena_champion(ctx: Context, body: dict) -> dict:
-    """Field another champion: one of the five coding agents; sent now when in the arena."""
+def _fielding(ctx: Context) -> dict:
     from ....sharing import arena
     from ....sharing import leaderboard as lb
 
-    arena.pick(ctx.cfg, ctx.conn, body.get("agent"))
-    return {**lb.status(ctx.cfg), "champion": arena.champion(ctx.cfg, ctx.conn, lb.read_state(ctx.cfg))}
+    return arena.fielding(ctx.cfg, ctx.conn, lb.read_state(ctx.cfg))
+
+
+def action_arena_deck(ctx: Context, body: dict) -> dict:
+    """Field another of this computer's decks; sent now when in the arena."""
+    from ....sharing import arena
+    from ....sharing import leaderboard as lb
+
+    arena.pick(ctx.cfg, ctx.conn, body.get("deck"))
+    return {**lb.status(ctx.cfg), **_fielding(ctx)}
 
 
 def action_leaderboard_join(ctx: Context) -> dict:

{interlatch-0.26.0 → interlatch-0.27.0}/src/interlatch/interfaces/web/api/party.py

@@ -47,7 +47,25 @@ def party(ctx: Context, viewer: dict | None, *, here: bool) -> dict:
         return {"signed_in": False, **gate, **({"preview": pt.preview(ctx.conn, _here_id(ctx))} if here else {})}
     data = pt.compute(ctx.conn, _here_id(ctx), viewer)
     # who's hiring for the classes it shows: read from Firebase only now, signed in (the numbers are public)
-    return {"signed_in": True, **gate, "who": me, **data, "market": pt.market_block(pt.payload_tracks(data))}
+    return {"signed_in": True, **gate, "who": me, **data, "market": pt.market_block(pt.payload_tracks(data)),
+            "formations": _formations(ctx, viewer, data)}
+
+
+def _levels(data: dict) -> dict[str, int]:
+    return {a["agent"]: a["level"] for a in data.get("agents") or []}
+
+
+def _lead(ctx: Context, viewer: dict | None):
+    """The champion picked on this computer before decks existed: the first of the deck made for its party."""
+    from ....sharing import leaderboard as lb
+
+    return (lb.read_state(ctx.cfg) or {}).get("champion") if viewer is None else None
+
+
+def _formations(ctx: Context, viewer: dict | None, data: dict) -> dict:
+    from ....knowledge import formation
+
+    return formation.formations(ctx.conn, viewer, _levels(data), _lead(ctx, viewer))
 
 
 def _refused() -> tuple[dict, int]:
@@ -160,6 +178,44 @@ def action_party_bag(ctx: Context, viewer: dict | None, what: str, body: dict, *
     return {"bag": got}, 200
 
 
+def action_party_deck(ctx: Context, viewer: dict | None, body: dict, *, here: bool) -> tuple[dict, int]:
+    """POST /api/party/deck: add a deck (no "id"), rename it or change its members in order ("name", "members"),
+    delete it ("delete": true), or field it in the Arena ("arena": true, this computer's own party only). Answers the
+    decks; when the team this computer fields changed and it is in the arena, the sheet is sent now."""
+    from ....knowledge import formation
+    from ....knowledge import party as pt
+
+    if who(ctx, viewer) is None:
+        return _refused()
+    deck = body.get("id")
+    levels = _levels(pt.compute(ctx.conn, _here_id(ctx), viewer))
+    lead = _lead(ctx, viewer)
+    before = formation.formations(ctx.conn, viewer, levels, lead)
+    try:
+        if deck is not None and not isinstance(deck, str):
+            raise pt.PartyError(formation.NO_DECK)
+        if body.get("delete"):
+            got = formation.delete(ctx.conn, viewer, levels, deck, lead=lead)
+        elif body.get("arena"):
+            if viewer is not None:  # a hub person's party never enters the arena
+                raise pt.PartyError(formation.NO_DECK)
+            got = formation.field(ctx.conn, viewer, levels, deck, lead=lead)
+        else:
+            got = formation.save(ctx.conn, viewer, levels, deck, name=body.get("name"), members=body.get("members"),
+                                 lead=lead)
+    except pt.PartyError as exc:
+        return {"error": tr(str(exc))}, 400
+    if viewer is None and _fielded(before) != _fielded(got):
+        from ....sharing import arena
+
+        arena.resend(ctx.cfg, ctx.conn)
+    return {"formations": got}, 200
+
+
+def _fielded(f: dict) -> list[str]:
+    return next((d["members"] for d in f["decks"] if d["id"] == f["arena"]), [])
+
+
 def action_party_quest(ctx: Context, viewer: dict | None, body: dict, *, here: bool) -> tuple[dict, int]:
     """Mark a quest done or not, in the viewer's own log; answers the party as it is now."""
     from ....knowledge import party as pt

{interlatch-0.26.0 → interlatch-0.27.0}/src/interlatch/interfaces/web/handler.py

@@ -28,10 +28,10 @@ LEGACY_SESSION_COOKIE = "chronicle_session"  # the same, signed in before the re
 PROXY_HEADERS = ("X-Forwarded-For", "Tailscale-User-Login", "X-Forwarded-Proto", "X-Real-IP", "Forwarded")
 HUB_PUSH = ("/api/hub/file", "/api/hub/sessions", "/api/hub/analyses", "/api/hub/done", "/api/hub/hello",
             "/api/hub/withdraw")
-# POSTs any person signed in to a hub may make, not only admins: their own Party quest log, goal, cleared encounters
-# and bag (routes.PARTY decides)
+# POSTs any person signed in to a hub may make, not only admins: their own Party quest log, goal, cleared encounters,
+# bag and decks (routes.PARTY decides)
 PARTY_OWN = ("/api/party/quest", "/api/party/goal", "/api/party/cleared", "/api/party/buy", "/api/party/sell",
-             "/api/party/equip", "/api/party/use")
+             "/api/party/equip", "/api/party/use", "/api/party/deck")
 
 log = logging.getLogger("interlatch.server")
 SIGNIN_HELP = ("Ask an admin of this hub for a new invite, or open the hub's dashboard again from your own Interlatch "

{interlatch-0.26.0 → interlatch-0.27.0}/src/interlatch/interfaces/web/routes.py

@@ -293,8 +293,8 @@ def _arena(h, ctx, m, body):  # what this computer publishes about its party: on
     from ...sharing.leaderboard import LeaderboardError
 
     try:
-        if m.group(1) == "champion":
-            return h._json(api.leaderboard.action_arena_champion(ctx, _body(body)))
+        if m.group(1) == "deck":
+            return h._json(api.leaderboard.action_arena_deck(ctx, _body(body)))
         return h._json(api.leaderboard.action_arena(ctx, m.group(1)))
     except LeaderboardError as e:
         return h._json({"error": str(e)}, 502)
@@ -311,7 +311,9 @@ def _party_sign(h, ctx, m, body):  # the Party's Google sign-in: the leaderboard
         return h._json({"error": str(e)}, 502)
 
 
-def _party_own(h, ctx, m, body):  # the viewer's own quest log, goal, cleared encounters and bag
+def _party_own(h, ctx, m, body):  # the viewer's own quest log, goal, cleared encounters, bag and decks
+    if m.group(1) == "deck":
+        return h._json(*api.party.action_party_deck(ctx, h.viewer, _body(body), here=h._from_here()))
     if m.group(1) in ("buy", "sell", "equip", "use"):
         return h._json(*api.party.action_party_bag(ctx, h.viewer, m.group(1), _body(body), here=h._from_here()))
     act = {"quest": api.party.action_party_quest, "goal": api.party.action_party_goal,
@@ -369,11 +371,11 @@ def _suggestions_refresh(h, ctx, m, body):
 POST: list[Route] = [
     Route("/api/sync", ANYONE, lambda h, ctx, m, b: h._json({"started": api.status.action_sync(ctx)})),
     Route(r"/api/leaderboard/(signin|finish|cancel|join|send|name|leave)", LEADERBOARD, _leaderboard),
-    Route(r"/api/leaderboard/arena/(join|leave|champion)", LEADERBOARD, _arena),
+    Route(r"/api/leaderboard/arena/(join|leave|deck)", LEADERBOARD, _arena),
     # a Google sign-in kept on this computer: only from here
     Route(r"/api/party/(signin|signout)", HERE, _party_sign),
     # the viewer's own quest log: from here, or any person signed in to a hub, not only admins (handler.PARTY_OWN)
-    Route(r"/api/party/(quest|goal|cleared|buy|sell|equip|use)", PARTY, _party_own),
+    Route(r"/api/party/(quest|goal|cleared|buy|sell|equip|use|deck)", PARTY, _party_own),
     Route(r"/api/artifacts/(\d+)/reveal", LOCAL_FILES, _reveal),
     # a password: at the hub itself, or an admin of a hub with people
     Route("/api/team-store/test", OWNER, lambda h, ctx, m, b: h._json(api.hub_admin.action_team_store_test(ctx, b))),

{interlatch-0.26.0 → interlatch-0.27.0}/src/interlatch/knowledge/arena.py

@@ -1,10 +1,13 @@
-"""The Arena: champion against champion. Two published party sheets each name one of their five agents as champion,
-and the two champions fight a deterministic duel, so everyone computes the same result for the same pair and week
-(sharing/arena.py publishes and reads the sheets). Pure functions: no clock, no global random.
+"""The Arena: team against team. Two published party sheets each field a lineup, one to TEAM_MAX of their agents in
+order (a deck from the Party page, knowledge/formation.py), and the two lineups fight a deterministic relay, so everyone
+computes the same result for the same pair and week (sharing/arena.py publishes and reads the sheets). Pure functions:
+no clock, no global random.
 
 A sheet holds, per coding agent, its level (1..200), tier, class (a track id or None) and six attribute levels (0..100),
-and which agent is the champion: nothing about any lesson. Stats come from those (stats()); a duel is rounds of turns
-by speed until one champion falls or MAX_ROUNDS pass (then the one with more of its HP left wins).
+its lineup, and its champion (the lineup's first): nothing about any lesson. Stats come from those (stats()). Each side's
+first agent fights the other's in a bout: rounds of turns by speed until one falls or MAX_ROUNDS pass (then the one with
+less of its HP left is out). The one left standing stays on, with the HP it has, against the next agent of the side
+that lost one; the side that runs out of agents loses. A lineup of one against a lineup of one is a plain duel.
 """
 
 from __future__ import annotations
@@ -16,13 +19,14 @@ from datetime import date
 
 from ..core.agents import CODING_AGENTS
 
-SHEET_V = 2  # 2: a champion
+SHEET_V = 3  # 2: a champion; 3: a lineup (its first is the champion)
 ATTRS = ("craft", "data", "ops", "guard", "arcana", "lore")
 TIERS = ("novice", "adept", "expert", "master")
 LEVEL_MAX, ATTR_MAX = 200, 100
-MAX_ROUNDS = 40
+TEAM_MAX = 3  # agents in a lineup
+MAX_ROUNDS = 40  # a bout's
 LOG_MAX = 400
-HEAL_EVERY = 3  # a champion with lore >= HEAL_LORE heals itself on every 3rd turn of its own
+HEAL_EVERY = 3  # a fighter with lore >= HEAL_LORE heals itself on every 3rd turn of its own
 HEAL_LORE = 10
 SPECIALS = {"adept": "Second wind", "expert": "Focus", "master": "Overdrive"}
 OVERDRIVE = 2.5  # the master's special: one hit this much harder
@@ -65,6 +69,14 @@ def champion_of(agents: dict, picked) -> str:
     return picked if picked in CODING_AGENTS else default_champion(agents)
 
 
+def lineup_of(agents: dict, lineup, champion=None) -> list[str]:
+    """`lineup` as the rules take it: distinct coding agents in its order, at most TEAM_MAX; none of them, the champion
+    alone (a sheet without a lineup)."""
+    got = list(dict.fromkeys(a for a in lineup if isinstance(a, str) and a in CODING_AGENTS))[:TEAM_MAX] \
+        if isinstance(lineup, list) else []
+    return got or [champion_of(agents, champion)]
+
+
 def power(agents: dict) -> int:
     """A party's power, as the board shows it: the sum of its agents' levels."""
     return sum(clean_agent(agents.get(n)).get("level", 1) for n in CODING_AGENTS)
@@ -82,15 +94,15 @@ def seed_for(week: str, uid_a: str, uid_b: str) -> str:
 
 
 def match(uid_1: str, sheet_1: dict, uid_2: str, sheet_2: dict, week: str) -> dict:
-    """This week's duel between two players (sheets: {"agents", "champion"}): sides a and b are the two uids sorted,
-    so whichever of them asks, it is the same duel. Adds "a" and "b" (their uids) and "winner_uid"."""
+    """This week's battle between two players (sheets: {"agents", "lineup", "champion"}): sides a and b are the two
+    uids sorted, so whichever of them asks, it is the same battle. Adds "a" and "b" (their uids) and "winner_uid"."""
     (ua, sa), (ub, sb) = sorted(((uid_1, sheet_1), (uid_2, sheet_2)), key=lambda p: p[0])
     out = battle(sa, sb, seed_for(week, ua, ub))
     return {**out, "a": ua, "b": ub, "winner_uid": ua if out["winner"] == "a" else ub}
 
 
 def standings(sheets: dict[str, dict], week: str) -> dict[str, dict]:
-    """{uid: {"wins", "losses"}}: every champion against every other this week (sheets: {uid: sheet})."""
+    """{uid: {"wins", "losses"}}: every lineup against every other this week (sheets: {uid: sheet})."""
     out = {u: {"wins": 0, "losses": 0} for u in sheets}
     uids = sorted(sheets)
     for i, ua in enumerate(uids):
@@ -101,9 +113,9 @@ def standings(sheets: dict[str, dict], week: str) -> dict[str, dict]:
     return out
 
 
-# ------------------------------------------------------------------ the duel
+# ------------------------------------------------------------------ the battle
 def stats(agent: dict) -> dict:
-    """A champion's stats from its level and attribute levels."""
+    """A fighter's stats from its level and attribute levels."""
     a = clean_agent(agent)
     lv, at = a["level"], a["attrs"]
     return {"hp": 20 + 4 * lv + 2 * at["guard"], "atk": 5 + at["craft"] + at["arcana"] // 2,
@@ -112,16 +124,18 @@ def stats(agent: dict) -> dict:
 
 
 def battle(a_sheet: dict, b_sheet: dict, seed: str) -> dict:
-    """`{"winner": "a"|"b", "rounds", "log", "units"}`: side a's champion against side b's, from `seed` (hex)."""
+    """`{"winner": "a"|"b", "rounds", "log", "champions", "lineups", "units"}`: side a's lineup against side b's, bout
+    after bout, from `seed` (hex). Round numbers run on across bouts; a newcomer's entry is an "in" event, and a fighter
+    out of time an "out" one."""
     rng = random.Random(int(seed, 16))
-    units = {}
+    teams: dict[str, list[dict]] = {}
     for side, sheet in (("a", a_sheet), ("b", b_sheet)):
         agents = (sheet or {}).get("agents") or {}
-        name = champion_of(agents, (sheet or {}).get("champion"))
-        s = stats(agents.get(name))
-        uid = f"{side}:{name}"
-        units[side] = {**s, "id": uid, "agent": name, "max": s["hp"], "turns": 0, "special": False, "focus": False,
-                       "key": rng.random()}
+        teams[side] = []
+        for i, name in enumerate(lineup_of(agents, (sheet or {}).get("lineup"), (sheet or {}).get("champion"))):
+            s = stats(agents.get(name))
+            teams[side].append({**s, "id": f"{side}:{name}", "agent": name, "order": i, "max": s["hp"], "turns": 0,
+                                "special": False, "focus": False, "out": False, "key": rng.random()})
     log: list[dict] = []
 
     def emit(r, t, src, dst, n, hp, name=None):
@@ -139,7 +153,7 @@ def battle(a_sheet: dict, b_sheet: dict, seed: str) -> dict:
         elif not dst["special"] and dst["hp"] * 2 < dst["max"] and dst["tier"] in SPECIALS:
             special(r, dst, src)
 
-    def special(r, u, foe):  # once per duel, when the champion first drops below half its HP
+    def special(r, u, foe):  # once per battle, when the fighter first drops below half its HP
         u["special"] = True
         name = SPECIALS[u["tier"]]
         if u["tier"] == "adept":
@@ -152,31 +166,44 @@ def battle(a_sheet: dict, b_sheet: dict, seed: str) -> dict:
         else:  # one hit, OVERDRIVE times harder
             hurt(r, u, foe, max(1, int(roll(u, foe) * OVERDRIVE * rng.uniform(0.85, 1.15))), "special", name)
 
-    winner, rounds = None, 0
-    for r in range(1, MAX_ROUNDS + 1):
-        rounds = r
-        for u in sorted(units.values(), key=lambda x: (-x["spd"], x["key"])):
-            foe = units["b" if u["id"].startswith("a:") else "a"]
-            if u["hp"] <= 0 or foe["hp"] <= 0:
-                continue
-            u["turns"] += 1
-            if u["heal"] and u["turns"] % HEAL_EVERY == 0 and u["hp"] < u["max"]:
-                gain = min(u["max"] - u["hp"], u["heal"])
-                u["hp"] += gain
-                emit(r, "heal", u["id"], u["id"], gain, u["hp"])
-            crit = rng.random() * 100 < u["crit"]
-            dmg = max(1, int(roll(u, foe) * (2 if crit else 1) * (2 if u["focus"] else 1) * rng.uniform(0.85, 1.15)))
-            u["focus"] = False
-            hurt(r, u, foe, dmg, "crit" if crit else "hit")
-        if units["a"]["hp"] <= 0 or units["b"]["hp"] <= 0:
-            winner = "a" if units["a"]["hp"] > 0 else "b"
-            break
-    if winner is None:  # time: the one with more of its HP left; level with it, the seed decides
-        left = {s: units[s]["hp"] / units[s]["max"] for s in "ab"}
-        winner = "a" if left["a"] > left["b"] else "b" if left["b"] > left["a"] else rng.choice("ab")
+    down = lambda u: u["hp"] <= 0 or u["out"]  # noqa: E731
+    ia = ib = rounds = 0
+    while ia < len(teams["a"]) and ib < len(teams["b"]):
+        pair = (teams["a"][ia], teams["b"][ib])
+        if rounds:  # a later bout: who stepped in
+            for u in pair:
+                if not u["turns"]:
+                    emit(rounds, "in", u["id"], None, 0, u["hp"])
+        for _ in range(MAX_ROUNDS):
+            rounds += 1
+            for u in sorted(pair, key=lambda x: (-x["spd"], x["key"])):
+                foe = pair[1] if u is pair[0] else pair[0]
+                if u["hp"] <= 0 or foe["hp"] <= 0:
+                    continue
+                u["turns"] += 1
+                if u["heal"] and u["turns"] % HEAL_EVERY == 0 and u["hp"] < u["max"]:
+                    gain = min(u["max"] - u["hp"], u["heal"])
+                    u["hp"] += gain
+                    emit(rounds, "heal", u["id"], u["id"], gain, u["hp"])
+                crit = rng.random() * 100 < u["crit"]
+                dmg = max(1, int(roll(u, foe) * (2 if crit else 1) * (2 if u["focus"] else 1) * rng.uniform(0.85, 1.15)))
+                u["focus"] = False
+                hurt(rounds, u, foe, dmg, "crit" if crit else "hit")
+            if pair[0]["hp"] <= 0 or pair[1]["hp"] <= 0:
+                break
+        else:  # time: the one with less of its HP left is out; level with it, the seed decides
+            left = [u["hp"] / u["max"] for u in pair]
+            gone = pair[0] if left[0] < left[1] else pair[1] if left[1] < left[0] else rng.choice(pair)
+            gone["out"] = True
+            emit(rounds, "out", (pair[1] if gone is pair[0] else pair[0])["id"], gone["id"], 0, gone["hp"])
+        ia += down(pair[0])
+        ib += down(pair[1])
+    winner = "a" if ia < len(teams["a"]) else "b"
     log.append({"r": rounds, "t": "end", "src": None, "dst": None, "n": 0, "hp": 0, "name": winner})
     return {"winner": winner, "rounds": rounds, "log": log,
-            "champions": {s: units[s]["agent"] for s in "ab"},
-            # end_hp: where each champion ended, also when the log was cut short (LOG_MAX)
-            "units": {u["id"]: {"hp": u["max"], "end_hp": u["hp"], "tier": u["tier"], "level": u["level"]}
-                      for u in units.values()}}
+            "champions": {s: teams[s][0]["agent"] for s in "ab"},
+            "lineups": {s: [u["agent"] for u in teams[s]] for s in "ab"},
+            # end_hp: where each fighter ended, also when the log was cut short (LOG_MAX); out: beaten on time
+            "units": {u["id"]: {"hp": u["max"], "end_hp": u["hp"], "tier": u["tier"], "level": u["level"],
+                                "order": u["order"], "out": u["out"]}
+                      for s in "ab" for u in teams[s]}}