interlatch 0.28.2__tar.gz → 0.28.4__tar.gz

{interlatch-0.28.2 → interlatch-0.28.4}/CHANGELOG.md

@@ -3,6 +3,31 @@
 <!-- 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.28.3 (2026-10-20)
+
+- **Settings › Hubs.** Each hub this computer sends to has its own card: whether sending works, the last share,
+  **Share now**, its dashboard (signed in as that hub's link), joining and leaving it. The Projects sidebar names the
+  hub each group goes to and lists folders waiting for a hub first, and the status bar names every hub
+  ([Several hubs on one computer](docs/profiles.md)).
+
+## 0.28.2 (2026-10-20)
+
+- **Several hubs: connect your groups.** `interlatch profile` became `interlatch hubs` and `interlatch group`: add a
+  hub (`interlatch hubs add Acme <address> --code <code>`), then connect a group of projects to it
+  (`interlatch group connect "Acme work" Acme`). What the group holds goes to that hub, and changing the group on the
+  dashboard's Projects page moves its sessions with it. A project taken out of a connected group waits for you
+  instead of going back to Personal. `--profile` is now `--hub`; the old name still works
+  ([Several hubs on one computer](docs/profiles.md)).
+- **Several hubs on the dashboard.** Settings › Devices › Hubs lists this computer's hubs and their groups, adds and
+  joins one, and settles folders that wait for you; a group's page has **Goes to**, which connects the group to a hub
+  ([Several hubs on one computer](docs/profiles.md)).
+- **Moving a folder takes its sessions back from the hub that had them.** When a group, a project or a waiting folder
+  moves to another hub (or a group is disconnected), the hub it left takes back the sessions this computer sent it,
+  before anything goes to the new one. One that can't be reached takes them back at the next send. Home now shows
+  folders that wait for you to choose a hub under **Needs you**
+  ([Moving takes sessions back](docs/profiles.md#moving-takes-sessions-back)). Update your hubs too: an older hub
+  can't take sessions back.
+
 ## 0.28.1 (2026-10-19)
 
 - **Profiles, first stage:** `interlatch profile create Acme --owns ~/work/acme` makes a named profile that owns a

{interlatch-0.28.2 → interlatch-0.28.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: interlatch
-Version: 0.28.2
+Version: 0.28.4
 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.28.4/changelog.d/hub-pages.md

@@ -0,0 +1,4 @@
+- **Every hub has the same page.** Settings › Hubs lists each hub, Personal's too, and each one opens a page of its own
+  with how sending goes, **Projects on the hub** (join a project with a folder here, add or remove a folder, leave or
+  rejoin) and what this computer shares with it. Settings › Devices is about this computer and your phone again
+  ([Several hubs on one computer](docs/profiles.md)).

{interlatch-0.28.2 → interlatch-0.28.4}/docs/devices.md

@@ -69,7 +69,7 @@ then on:
 - **Analysis runs only on the hub.** If the computer already analyzed sessions with its own Interlatch, it hands
   those analyses over when it joins, so the hub does not pay to analyze them again.
 - **That computer's own dashboard and MCP tools stop updating.** They keep what they had; open the hub's dashboard
-  instead (**Settings › Devices** has a link).
+  instead (**Settings › Hubs** has a link).
 
 ### Same project, different folders
 
@@ -93,7 +93,7 @@ matching project of its own:
    already on the hub: they move with their knowledge, and both projects' knowledge bases are rebuilt. The more
    specific match wins, so a repository inside the folder whose git remote the hub knows still follows its remote. A
    folder inside a repository the hub files under another project is refused, because a repository belongs to one
-   project. `interlatch hub folders` shows what goes where. **Settings › Devices › Projects on the hub** does the same
+   project. `interlatch hub folders` shows what goes where. **Settings › Hubs › (the hub) › Projects on the hub** does the same
    from the dashboard: **Join a project** picks one of the hub's projects and a folder here. To take back a folder
    added by mistake, see [Leaving](#leaving). The hub's **Team › Computers** lists the folders each computer added.
    On this computer's **Projects** page and sidebar, the hub's projects that folders here go to come first, under
@@ -126,7 +126,7 @@ projects there from its next push, as if you had added each of their folders to
   above. A project recorded on another computer (such as `server:/root/app`) can't go from here.
 
 The project must already be on the hub (a member's computer can't make one), and the choice is made on this computer
-itself, not from another device. **Settings › Devices › Projects on the hub** shows the group under that project, and
+itself, not from another device. **Settings › Hubs › (the hub) › Projects on the hub** shows the group under that project, and
 the Projects page and sidebar list the group's projects under that project as well as in the group.
 
 ### What is sent
@@ -153,7 +153,7 @@ A computer can keep its transcripts and still add to the hub's knowledge. Join w
 interlatch hub join https://pc.tail1234.ts.net --token … --share knowledge
 ```
 
-(or, on a computer that already joined, `interlatch config set hub.share knowledge`, or **Settings › Devices › What this
+(or, on a computer that already joined, `interlatch config set hub.share knowledge`, or **Settings › Hubs › (the hub) › What this
 computer sends** in its dashboard). That computer then works like a
 standalone Interlatch: it records its own sessions, analyzes them itself (with its own Claude Code or Codex login,
 Bob API key or model provider), and keeps its dashboard and MCP tools up to date. After each analysis it sends the hub only:
@@ -169,7 +169,7 @@ It does that only for sessions the hub files under one of its projects: those in
 computer, and its push counts them as "kept here". A hub that has never run a session in a repository itself doesn't
 know its remote, as with a hub in Docker or on a server, so add your folder for each project there. To share
 sessions from every folder, join with `--all-folders`, run `interlatch config set hub.all_folders true`, or choose
-**Every folder** under **Settings › Devices › What this computer sends**.
+**Every folder** under **Settings › Hubs › (the hub) › What this computer sends**.
 
 Prompts, shell commands, file paths, transcripts and lessons about you (global ones and preferences) never leave
 the computer. Sessions from GitHub Copilot, IBM Bob, Google Antigravity and OpenCode are shared too; imported chats are not.
@@ -238,13 +238,13 @@ unless the connection works, the password is never shown again, and only an admi
 - **Teammates' lessons come back.** Each time it shares, a computer that shares knowledge gets its teammates' lessons
   for the repositories it has clones of, the projects it shared sessions in, and those it added folders to. It shares
   after each analysis (when a session ends, and every 15 minutes with the background agent from `interlatch install`),
-  and at once with `interlatch push` or **Share now** in **Settings › Devices**. They are
+  and at once with `interlatch push` or **Share now** in **Settings › Hubs**. They are
   kept read-only in its own database, under its own folder for that repository, where its MCP tools answer with them
   (marked as teammates') and the start-of-session notes list them under **From teammates' sessions**. Its dashboard
   shows them on project pages and in **All knowledge**, marked **from** the computers whose sessions stated them;
-  the source **From teammates** there lists only them, and **Read them** in **Settings › Devices** opens that list.
+  the source **From teammates** there lists only them, and **Read them** in **Settings › Hubs** opens that list.
   Lessons it stated itself are not sent back. One it dismisses stays dismissed; one the team no longer has disappears.
-  `interlatch hub status` and its **Settings › Devices** show how many it holds; **Share now** there
+  `interlatch hub status` and its **Settings › Hubs** show how many it holds; **Share now** there
   pushes at once.
 - **Only the hub connects to the database.** Computers never get its address or password, so it can sit on a
   network only the hub reaches. Its tables live in the schema `team`, with an audit log of every push and pull
@@ -269,7 +269,7 @@ Devices › Projects on the hub**, each project has these buttons:
   command line: `interlatch hub remove-folder <folder>`. A computer that sends transcripts keeps them on the hub: the
   hub files them by their git remote or their own folder again.
 
-`interlatch hub leave`, or **Leave the hub…** in **Settings › Devices**, makes the computer record and analyze its own
+`interlatch hub leave`, or **Leave the hub…** in **Settings › Hubs**, makes the computer record and analyze its own
 sessions again; the hub keeps what it was sent. It also removes the teammates' lessons that came from the hub, and
 puts aside what the computer had for that hub (its folders, the projects it left, and its groups shared there) in
 `~/.interlatch/hub-left/`, so a different hub joined later never gets any of it. Whether it shares knowledge only
@@ -361,7 +361,7 @@ or the id the refused join printed. That code joins that computer only.
 
 ### Opening the hub's dashboard
 
-- **From your own Interlatch.** On a computer that joined, **Settings › Devices › Open the hub's dashboard** asks the
+- **From your own Interlatch.** On a computer that joined, **Settings › Hubs › (the hub) › Open the hub's dashboard** asks the
   hub for a sign-in link, valid for 5 minutes, and opens it in your browser. There is no password.
 - **With the invite link.** Opening `…/signin?code=…` shows who the code signs in as; **Sign in** signs that browser
   in. You can also paste the code on the hub's sign-in screen. Use this for a phone, or for someone with no computer

{interlatch-0.28.2 → interlatch-0.28.4}/docs/docker.md

@@ -199,7 +199,7 @@ docker compose exec hub interlatch hub invite "Yuma" --email yuma@example.com --
 
 Send them the `interlatch hub join …` line, not the link, with [Joining your team's hub](join-a-hub.md), which
 walks them through the rest. The code works once, so don't send both. Once their computer has joined, they open the
-dashboard from their own Interlatch: **Settings › Devices › Open the hub's dashboard**, or `interlatch hub signin`. For
+dashboard from their own Interlatch: **Settings › Hubs › (the hub) › Open the hub's dashboard**, or `interlatch hub signin`. For
 a phone, or someone who only views the dashboard, make a new code with
 `docker compose exec hub interlatch hub invite yuma@example.com` (or **New invite** on their row in **Team › People**)
 and send its **link**.

{interlatch-0.28.2 → interlatch-0.28.4}/docs/ja/devices.md

@@ -68,7 +68,7 @@ interlatch hub join https://pc.tail1234.ts.net --token …
 - **分析はハブだけで行います。** そのコンピューターが自分の Interlatch ですでに分析していたセッションは、参加するときにその結果を
   ハブに引き渡すので、ハブがもう一度費用をかけて分析することはありません。
 - **そのコンピューター自身のダッシュボードと MCP ツールは更新されなくなります。** それまでの内容は残ります。代わりにハブの
-  ダッシュボードを開いてください（**Settings › Devices** にリンクがあります）。
+  ダッシュボードを開いてください（**Settings › Hubs** にリンクがあります）。
 
 ### 同じプロジェクト、別のフォルダー
 
@@ -90,7 +90,7 @@ interlatch hub join https://pc.tail1234.ts.net --token …
    両方のプロジェクトのナレッジベースが作り直されます。より具体的な指定が優先されるので、フォルダーの中にあってもハブが
    git リモートを知っているリポジトリはそのリモートに従います。ハブが別のプロジェクトに入れているリポジトリの中のフォルダーは追加できません
    （1 つのリポジトリは 1 つのプロジェクトに属します）。`interlatch hub folders` でどこに入るかを確認できます。
-   ダッシュボードの **Settings › Devices › Projects on the hub** でも同じことができ、**Join a project** でハブの
+   ダッシュボードの **Settings › Hubs › (the hub) › Projects on the hub** でも同じことができ、**Join a project** でハブの
    プロジェクトとこのコンピューターのフォルダーを選びます。間違えて追加したフォルダーを外すには[やめるとき](#やめるとき)を
    見てください。ハブの **Team › Computers** に、各コンピューターが追加したフォルダーが表示されます。
    このコンピューターの **Projects** ページとサイドバーでは、ここのフォルダーの送り先になっているハブのプロジェクトが
@@ -123,7 +123,7 @@ interlatch hub join https://pc.tail1234.ts.net --token …
   別のコンピューターで記録されたプロジェクト（`server:/root/app` など）は、ここからは送れません。
 
 プロジェクトはハブにすでにある必要があり（メンバーのコンピューターでは作れません）、選ぶのはこのコンピューター自身で、ほかの
-デバイスからはできません。**Settings › Devices › Projects on the hub** ではそのプロジェクトの下にグループが表示され、グループの
+デバイスからはできません。**Settings › Hubs › (the hub) › Projects on the hub** ではそのプロジェクトの下にグループが表示され、グループの
 プロジェクトは Projects ページとサイドバーで、グループの中に加えてそのプロジェクトの下にも並びます。
 
 ### 送られるもの
@@ -147,7 +147,7 @@ interlatch hub join https://pc.tail1234.ts.net --token …
 interlatch hub join https://pc.tail1234.ts.net --token … --share knowledge
 ```
 
-（参加済みのコンピューターでは `interlatch config set hub.share knowledge`、またはそのダッシュボードの **Settings › Devices ›
+（参加済みのコンピューターでは `interlatch config set hub.share knowledge`、またはそのダッシュボードの **Settings › Hubs › (the hub) ›
 What this computer sends**）。そのコンピューターは単独の Interlatch と同じように
 動きます。自分のセッションを記録し、自分で分析し（自分の Claude Code か Codex のログイン、Bob API キー、または
 モデルプロバイダーで）、ダッシュボードと MCP ツールも更新され続けます。分析のたびにハブへ送るのは次のものだけです。
@@ -162,7 +162,7 @@ What this computer sends**）。そのコンピューターは単独の Interlat
 それ以外のフォルダーのセッションはコンピューターに残り、送信の結果には「kept here」として数えられます。Docker やサーバー上の
 ハブのように、ハブ自身がそのリポジトリでセッションを実行したことがなければ、ハブはその git リモートを知りません。その場合は
 プロジェクトごとに自分のフォルダーを追加してください。すべてのフォルダーのセッションを共有するには、`--all-folders` を付けて
-参加するか、`interlatch config set hub.all_folders true` を実行するか、**Settings › Devices › What this computer sends** で
+参加するか、`interlatch config set hub.all_folders true` を実行するか、**Settings › Hubs › (the hub) › What this computer sends** で
 **すべてのフォルダー** を選びます。
 
 プロンプト、シェルのコマンド、ファイルのパス、トランスクリプト、あなた自身についてのナレッジ（全体のものと好み）は
@@ -219,12 +219,12 @@ interlatch hub store                          # 接続し、テーブルを用
 - **チームメイトのナレッジが戻ってきます。** ナレッジを共有しているコンピューターは、共有するたびに、クローンを持っている
   リポジトリ、セッションを共有したプロジェクト、フォルダーを追加したプロジェクトについて、チームメイトのナレッジを受け取り
   ます。共有するのは分析のたび（セッションが終わったとき、`interlatch install` のバックグラウンドエージェントがあれば
-  15 分ごと）と、`interlatch push` または **Settings › Devices** の **Share now** を使ったときです。自分のデータベースに読み取り専用で、そのリポジトリの自分のフォルダーの下に保存されます。MCP ツールはそれも
+  15 分ごと）と、`interlatch push` または **Settings › Hubs** の **Share now** を使ったときです。自分のデータベースに読み取り専用で、そのリポジトリの自分のフォルダーの下に保存されます。MCP ツールはそれも
   （チームメイトのものと示して）答えに使い、セッション開始時のメモは **From teammates' sessions** の下に並べます。
   ダッシュボードでも、プロジェクトのページと **All knowledge** に、それを述べたセッションのコンピューター名を **from** で
-  示して表示します。そこで取得元に **From teammates** を選ぶとそれだけが並び、**Settings › Devices** の **Read them** で
+  示して表示します。そこで取得元に **From teammates** を選ぶとそれだけが並び、**Settings › Hubs** の **Read them** で
   その一覧が開きます。自分が述べたナレッジは返ってきません。却下したものは却下されたまま残り、チームから消えたものは消えます。持っている数は
-  `interlatch hub status` とそのコンピューターの **Settings › Devices** で分かり、そこの **Share now** ですぐに
+  `interlatch hub status` とそのコンピューターの **Settings › Hubs** で分かり、そこの **Share now** ですぐに
   プッシュできます。
 - **データベースにつなぐのはハブだけです。** 各コンピューターはそのアドレスもパスワードも知らないので、ハブだけが届く
   ネットワークに置けます。テーブルはスキーマ `team` にあり、プッシュとプルごとの監査ログ（件数のみ）も残ります。更新の
@@ -236,7 +236,7 @@ interlatch hub store                          # 接続し、テーブルを用
 
 ### やめるとき
 
-ナレッジを共有するコンピューターは、ハブのプロジェクトのうち一つから抜けて、ほかには残れます。**Settings › Devices ›
+ナレッジを共有するコンピューターは、ハブのプロジェクトのうち一つから抜けて、ほかには残れます。**Settings › Hubs › (the hub) ›
 Projects on the hub** で、プロジェクトごとに次のボタンがあります。
 
 - **Leave**：このコンピューターはそこへのセッションの共有と、そのプロジェクトのチームメイトのナレッジの受け取りを
@@ -249,7 +249,7 @@ Projects on the hub** で、プロジェクトごとに次のボタンがあり
   `interlatch hub remove-folder <folder>` です。トランスクリプトを送るコンピューターでは、ハブにトランスクリプトが残り、
   ハブは git リモートか元のフォルダーで振り分け直します。
 
-`interlatch hub leave`、または **Settings › Devices** の **Leave the hub…** で、そのコンピューターは再び自分でセッションを
+`interlatch hub leave`、または **Settings › Hubs** の **Leave the hub…** で、そのコンピューターは再び自分でセッションを
 記録・分析します。ハブは受け取ったものを残します。そのハブから来たチームメイトのナレッジも削除し、そのハブのための設定
 （フォルダー、抜けたプロジェクト、そこに共有したグループ）は `~/.interlatch/hub-left/` に保存するので、
 あとで参加するほかのハブには渡りません。ナレッジだけを共有するかどうか（`[hub] share`）はそのままです。再び参加するには新しい招待が必要です。同じハブにもう一度参加すると、それらを
@@ -339,7 +339,7 @@ interlatch hub join https://interlatch.example.internal --code K7PQ-M2XD-9HNA --
 
 ### ハブのダッシュボードを開く
 
-- **自分の Interlatch から。** 参加したコンピューターで **Settings › Devices › Open the hub's dashboard** を押すと、ハブから
+- **自分の Interlatch から。** 参加したコンピューターで **Settings › Hubs › (the hub) › Open the hub's dashboard** を押すと、ハブから
   5 分間有効なサインインリンクを受け取り、ブラウザーで開きます。パスワードはありません。
 - **招待リンクで。** `…/signin?code=…` を開くと、そのコードでだれとしてサインインするかが表示され、**サインイン** を押すと
   そのブラウザーがサインインします。ハブのサインイン画面にコードを貼り付けても同じです。スマートフォンや、ハブに参加した

{interlatch-0.28.2 → interlatch-0.28.4}/docs/ja/docker.md

@@ -198,7 +198,7 @@ docker compose exec hub interlatch hub invite "Yuma" --email yuma@example.com --
 
 リンクではなく `interlatch hub join …` の行を、[チームのハブに参加する](join-a-hub.md)と一緒に送ってください。
 残りの手順はそのページが案内します。コードは一度しか使えないので、両方は送らないでください。コンピューターが参加したあとは、
-本人の Interlatch からダッシュボードを開けます：**Settings › Devices › Open the hub's dashboard**、または
+本人の Interlatch からダッシュボードを開けます：**Settings › Hubs › (the hub) › Open the hub's dashboard**、または
 `interlatch hub signin`。スマートフォン用や、ダッシュボードを見るだけの人には、
 `docker compose exec hub interlatch hub invite yuma@example.com`（または **Team › People** のその人の行の **New invite**）で
 新しいコードを作り、その**リンク**を送ります。

{interlatch-0.28.2 → interlatch-0.28.4}/docs/ja/join-a-hub.md

@@ -69,7 +69,7 @@ interlatch hub add-folder ~/code/website --project Website
 これで、そこで分析済みのものが送られます。ハブがすでに知っている git リポジトリのクローンは、この手順がなくても
 そのプロジェクトに入りますが、実行しても問題ありません。
 
-ダッシュボードでも同じことができます：**Settings › Devices › Projects on the hub › Join a project** で、
+ダッシュボードでも同じことができます：**Settings › Hubs › (the hub) › Projects on the hub › Join a project** で、
 プロジェクトとあなたのフォルダーを選びます。
 
 ハブにそのプロジェクトがないと言われたり、**Join a project** が「一致するものはありません。」となったりしたら、
@@ -83,21 +83,21 @@ interlatch hub status
 ```
 
 ハブのアドレス、最後に送った時刻、受け取ったチームメイトのナレッジの数が表示されます。ダッシュボードの
-**Settings › Devices** にも同じものが表示されます。そこの **Open the hub's dashboard** で、あなたのプロジェクトが
+**Settings › Hubs** にも同じものが表示されます。そこの **Open the hub's dashboard** で、あなたのプロジェクトが
 見えるハブのダッシュボードにサインインできます。
 
 ## その後
 
 - **分析のたびに、** あなたのコンピューターはプロジェクトの新しい要約とナレッジを送ります。今すぐ送るには
-  `interlatch push`、または **Settings › Devices** の **Share now** を使います。
+  `interlatch push`、または **Settings › Hubs** の **Share now** を使います。
 - **送るたびに、** チームメイトがそのプロジェクトで学んだことが返ってきます。エージェントは Interlatch の MCP
   ツールを通じて、チームメイトのものと分かる形でそのナレッジを使えます。セッション開始時のメモを有効にしている場合
   （`interlatch install --inject-context`）、新しいセッションの "From teammates' sessions" にも並びます。
 - **あなたのダッシュボード**には、これまでどおりあなた自身のセッションが表示されます。チームメイトのナレッジは、
-  プロジェクトのページと **All knowledge** に、どのコンピューターから来たかを示して並びます。**Settings › Devices** の
+  プロジェクトのページと **All knowledge** に、どのコンピューターから来たかを示して並びます。**Settings › Hubs** の
   **Read them** でそれだけの一覧が開きます。
 
-一つのプロジェクトへの共有をやめるには、**Settings › Devices** でその横の **Leave** を選びます（または
+一つのプロジェクトへの共有をやめるには、**Settings › Hubs** でその横の **Leave** を選びます（または
 `interlatch hub leave --project <name>`）。そこで共有したものはハブに残ります。間違ったフォルダーを追加したときは、
 その横の **Remove** でフォルダーを外すと、あなたのコンピューターがそこから共有したものをハブが削除します。送るのを
 すべてやめるには **Leave the hub…** を選びます（または `interlatch hub leave`）。すでに送ったものはハブに残ります。

{interlatch-0.28.2 → interlatch-0.28.4}/docs/ja/profiles.md

@@ -29,7 +29,7 @@
 
 グループのフォルダーですでに記録されたセッションは Acme に移り、それ以降は Acme のハブに送られます。Personal のハブがすでに持っているものは、先にそのハブが取り下げます（[移すとハブから取り下げる](#moving-takes-sessions-back)）。`--dry-run` を付けると、何も変えずに、移るものと、そのうちハブが持っている数を表示します。
 
-**ダッシュボードでは：** **設定 › デバイス › ハブ**でハブを追加し（名前、アドレス、招待コード）、グループのページの**送り先**で、そのグループのセッションを送るハブを選びます。
+**ダッシュボードでは：** **設定 › ハブ**に Personal のものを含むすべてのハブが並び、ハブの追加（名前、アドレス、招待コード）もここで行います。ハブごとに同じ構成のページがあります。送信がうまくいっているか、**今すぐ共有**、ハブのダッシュボード、**ハブのプロジェクト**（ここのフォルダーでハブのプロジェクトに参加する、抜ける）、そのハブと何を共有するか、です。グループのページの**送り先**で、そのグループのセッションを送るハブを選びます。**プロジェクト**のサイドバーでは、ハブにつないだグループにそのハブの名前が表示され、選択を待つフォルダーが先頭に並びます。
 
 ほかのコンピューターと同じく、ハブに送られるのは、そのハブのプロジェクトに追加したフォルダーのものだけです（`interlatch --hub Acme hub add-folder ~/work/acme/app --project App`）。`--all-folders` を付けて参加した場合は別です。
 
@@ -67,7 +67,7 @@ interlatch group choose ~/work/acme/notes Acme       # または personal
 interlatch group where ~/work/acme/app               # フォルダーがどのハブに行くか、その理由
 ```
 
-**設定 › デバイス › ハブ**にも一覧があり、それぞれに**選ぶ**ボタンがあります。**ホーム**の**あなたの対応待ち**にも表示されます。あるフォルダーが選択待ちにしているプロジェクト（つないだグループの中にある、どのハブにもつないでいないグループ）は、そのフォルダーの下にまとめて表示します。
+**設定 › ハブ**にも一覧があり、それぞれに**選ぶ**ボタンがあります。**ホーム**の**あなたの対応待ち**にも表示されます。あるフォルダーが選択待ちにしているプロジェクト（つないだグループの中にある、どのハブにもつないでいないグループ）は、そのフォルダーの下にまとめて表示します。
 
 ## エージェントに見えるもの
 

{interlatch-0.28.2 → interlatch-0.28.4}/docs/ja/troubleshooting.md

@@ -87,7 +87,7 @@ Codex にはセッション終了フックがないため、Codex のセッシ
 ID でそのコンピューター専用の招待を作り（`interlatch hub invite <名前> --computer <ID>`）、そのコードで参加してください
 （[コンピューターを参加させる](devices.md#コンピューターを参加させる)）。
 
-**ステータスバーに「ハブに送信できていません」と表示される。** クリックすると **設定 › デバイス** に理由が出ます。
+**ステータスバーに「ハブに送信できていません」と表示される。** クリックすると **設定 › ハブ** に理由が出ます。
 「ハブがこのコンピューターを受け付けていません」と出る場合は、ハブがこのコンピューターのトークンを受け付けなくなったため、ここで学んだことが
 ハブに届いていません。多くの場合、管理者が **チーム › 利用者** でそのコンピューターを取り消したか置き換えています。管理者にこのコンピューター
 用の新しい招待を頼み、そのコードをハブのカードの **参加し直す** に貼り付けてください（`interlatch hub join <ハブのアドレス> --code <コード>`

{interlatch-0.28.2 → interlatch-0.28.4}/docs/join-a-hub.md

@@ -67,7 +67,7 @@ Use your folder for the project and the project's name from step 2. This sends w
 analyzed there. A clone of a git repository the hub already knows is filed under its project without this step,
 but running it does no harm.
 
-Your dashboard can do the same: **Settings › Devices › Projects on the hub › Join a project**, then pick the project
+Your dashboard can do the same: **Settings › Hubs › (the hub) › Projects on the hub › Join a project**, then pick the project
 and your folder.
 
 If the hub says it has no such project, or **Join a project** answers "Nothing matches.", you don't see that
@@ -81,21 +81,21 @@ interlatch hub status
 ```
 
 It shows the hub's address, when your computer last sent, and how many of your teammates' lessons it holds. Your
-dashboard's **Settings › Devices** shows the same. **Open the hub's dashboard** there signs you in to the hub's
+dashboard's **Settings › Hubs** shows the same. **Open the hub's dashboard** there signs you in to the hub's
 dashboard, where you see your projects.
 
 ## From then on
 
 - **After each analysis,** your computer sends the project's new summaries and lessons. `interlatch push`, or
-  **Share now** in **Settings › Devices**, sends right away.
+  **Share now** in **Settings › Hubs**, sends right away.
 - **Each time it sends,** it gets back what your teammates learned in the project. Your agents find those lessons
   through Interlatch's MCP tools, marked as teammates'. With start-of-session notes on (`interlatch install
   --inject-context`), new sessions also list them under "From teammates' sessions".
 - **Your own dashboard** keeps showing your own sessions, as before. Your teammates' lessons appear on its project
-  pages and in **All knowledge**, marked with the computers they came from; **Read them** in **Settings › Devices**
+  pages and in **All knowledge**, marked with the computers they came from; **Read them** in **Settings › Hubs**
   lists only those.
 
-To stop sharing to one project, choose **Leave** next to it in **Settings › Devices** (or run `interlatch hub leave
+To stop sharing to one project, choose **Leave** next to it in **Settings › Hubs** (or run `interlatch hub leave
 --project <name>`). What you shared there stays on the hub. Added the wrong folder? **Remove** next to it takes the
 folder back, and the hub deletes what your computer shared from it. To stop sending altogether, choose **Leave the
 hub…** (or run `interlatch hub leave`). What you already sent stays on the hub. Your teammates' lessons from it are

{interlatch-0.28.2 → interlatch-0.28.4}/docs/profiles.md

@@ -37,8 +37,11 @@ The sessions already recorded in the group's folders move to Acme, and go to Acm
 Personal's hub already has, it takes back first (see [Moving takes sessions back](#moving-takes-sessions-back)).
 `--dry-run` shows what would move, and how many of them a hub has, without changing anything.
 
-**On the dashboard:** **Settings › Devices › Hubs** adds a hub (its name, address and invite code), and a group's page
-has **Goes to**, where you pick the hub its sessions go to.
+**On the dashboard:** **Settings › Hubs** lists every hub, Personal's too, and adds one (its name, address and
+invite code). Each hub has a page of its own, the same for every hub: whether sending to it works, **Share now**, its
+dashboard, **Projects on the hub** (join one of its projects with a folder here, or leave one) and what this computer
+shares with it. A group's page has **Goes to**, where you pick the hub its sessions go to. In the **Projects** sidebar,
+a group connected to a hub shows that hub's name, and folders waiting for you are listed first.
 
 As on any computer, a hub gets only the folders added to one of its projects
 (`interlatch --hub Acme hub add-folder ~/work/acme/app --project App`), unless you joined with `--all-folders`.
@@ -84,7 +87,7 @@ interlatch group choose ~/work/acme/notes Acme       # or: personal
 interlatch group where ~/work/acme/app               # who gets a folder, and why
 ```
 
-**Settings › Devices › Hubs** lists them too, with a **Choose** for each, and **Home** shows them under **Needs you**. Projects a folder holds waiting (a group
+**Settings › Hubs** lists them too, with a **Choose** for each, and **Home** shows them under **Needs you**. Projects a folder holds waiting (a group
 connected to no hub inside a connected one) are listed once, under that folder.
 
 ## What agents see

{interlatch-0.28.2 → interlatch-0.28.4}/docs/troubleshooting.md

@@ -92,7 +92,7 @@ computer sent to the hub before, and the hub has no key on record from it, or an
 for that computer, with the id the message shows: `interlatch hub invite <name> --computer <id>`; join with that code
 ([Joining a computer](devices.md#joining-a-computer)).
 
-**The status bar says "Not sending to the hub".** Click it: **Settings › Devices** says why. "The hub no longer
+**The status bar says "Not sending to the hub".** Click it: **Settings › Hubs** says why. "The hub no longer
 accepts this computer" means the hub turned this computer's token away, so nothing it learns reaches the hub. Usually
 an admin revoked or replaced that computer in **Team › People**. Ask an admin for a new invite for this computer, then
 paste the code into **Join again** in the Hub card, or run `interlatch hub join <hub address> --code <code>`. The

{interlatch-0.28.2 → interlatch-0.28.4}/src/interlatch/core/i18n/ja.py

@@ -482,4 +482,7 @@ JA: dict[str, str] = {
     "Pick a project to move.": "移動するプロジェクトを選んでください。",
     "This computer doesn't send to a hub.": "このコンピューターはハブに送っていません。",
     "Chronicle is now Interlatch. Updating moves this install from the agents-chronicle package to interlatch; the chronicle command keeps working.": "Chronicle は Interlatch になりました。更新すると、このインストールは agents-chronicle パッケージから interlatch に移ります。chronicle コマンドはそのまま使えます。",
+    "{hub} hasn't joined a hub yet.": "{hub} はまだハブに参加していません。",
+    "Change this on the computer itself, not from another device.": "別のデバイスからではなく、このコンピューターで変更してください。",
+    "With several hubs, every hub but Personal's gets summaries and lessons only.": "複数のハブがあるときは、Personal 以外のハブには要約とナレッジだけを送ります。",
 }

{interlatch-0.28.2 → interlatch-0.28.4}/src/interlatch/interfaces/cli/commands/sharing.py

@@ -199,7 +199,10 @@ def cmd_hub(args) -> int:
             console.print(f"Joined the hub at {url}, sharing knowledge only. This computer keeps recording and "
                           "analyzing its own sessions; the hub gets each analyzed session's summary and project "
                           "lessons. Transcripts and lessons about you stay here.", highlight=False)
-            if cfg.hub_all_folders:
+            if cfg.hub_all_folders and cfg.owner != "personal":  # another hub: it gets what its groups hold
+                console.print("It shares sessions from every folder its groups hold (--all-folders): nothing until you "
+                              "connect a group to it (`interlatch group connect <group> <hub>`).", highlight=False)
+            elif cfg.hub_all_folders:
                 console.print("It shares sessions from every folder on this computer (--all-folders).", highlight=False)
             elif not args.code or got.get("projects") is None:  # a limited person heard which projects above
                 console.print("Only sessions in the hub's projects are shared: add your folder for each one with "

{interlatch-0.28.2 → interlatch-0.28.4}/src/interlatch/interfaces/web/api/devices.py

@@ -220,6 +220,8 @@ def action_share_mode(ctx: Context, share: str) -> dict:
         return {"error": tr("this computer has not joined a hub")}
     if share not in SHARE_MODES:
         return {"error": tr("unknown share mode {share!r}", share=share)}
+    if share != "knowledge" and ctx.cfg.owner != "personal":  # its transcripts would carry every hub's sessions
+        return {"error": tr("With several hubs, every hub but Personal's gets summaries and lessons only.")}
     set_config_value(ctx.cfg, "hub", "share", json.dumps(share))
     ctx.cfg = load_config(ctx.cfg.home)
     return {"ok": True, "share": ctx.cfg.hub_share}

{interlatch-0.28.2 → interlatch-0.28.4}/src/interlatch/interfaces/web/api/hubs.py

@@ -1,8 +1,9 @@
-"""Several hubs on one computer (docs/profiles.md), on the dashboard: Settings › Devices › Hubs lists them and what
-waits for you; a group's page connects the group to one. application.profiles does the work."""
+"""Several hubs on one computer (docs/profiles.md), on the dashboard: Settings › Hubs lists them, how each one's sending
+goes and what waits for you; a group's page connects the group to one. application.profiles does the work."""
 
 from __future__ import annotations
 
+from ....core.i18n import tr
 from ..context import Context
 
 
@@ -22,6 +23,7 @@ def hubs(ctx: Context) -> dict:
         return {"error": str(exc), "hubs": [], "groups": [], "waiting": []}
     hubs = [r for r in rows if r["id"] != "waiting"]
     for r in hubs:
+        r.update(_sending(_hub_cfg(ctx, r["id"], reg)))
         r.pop("home", None)  # this computer's folders: not needed to show them
     gs = []
     for g in groups(ctx.conn):
@@ -30,6 +32,71 @@ def hubs(ctx: Context) -> dict:
     return {"hubs": hubs, "groups": gs, "waiting": _waiting(waiting(ctx.conn), reg)}
 
 
+class HubView:
+    """The dashboard as one of this computer's hubs sees it: that hub's config (Personal's, or another's own folder,
+    which reads Personal's archive), the same archive, jobs and state. What a device action writes back to its config
+    stays with that hub; only Personal's replaces the dashboard's."""
+
+    def __init__(self, ctx: Context, cfg):
+        self._ctx = ctx
+        self._cfg = cfg
+
+    @property
+    def cfg(self):
+        return self._cfg
+
+    @cfg.setter
+    def cfg(self, cfg) -> None:
+        self._cfg = cfg
+        if cfg.owner == "personal":
+            self._ctx.cfg = cfg
+
+    def __getattr__(self, name):
+        return getattr(self._ctx, name)
+
+
+def for_hub(ctx: Context, key) -> tuple[object, str | None]:
+    """(the dashboard as hub `key` sees it, None), or (None, why not). No key, or "personal": Personal's, as before."""
+    from ....application.profiles import ProfileError, find_profile
+    from ....core.config import load_config
+
+    key = str(key or "").strip()
+    if not key or key.casefold() == "personal":
+        return ctx, None
+    try:
+        p = find_profile(ctx.cfg.home, key)
+    except ProfileError as exc:
+        return None, str(exc)
+    if not (p.home / "config.toml").exists():
+        return None, tr("{hub} hasn't joined a hub yet.", hub=p.label)
+    return HubView(ctx, load_config(p.home, create=False)), None
+
+
+def _hub_cfg(ctx: Context, hub_id: str, reg):
+    """The config that sends to hub `hub_id`: Personal's, or that hub's own folder's (None: no such hub)."""
+    from ....core.config import load_config
+
+    if hub_id == "personal":
+        return ctx.cfg
+    p = reg.profiles.get(hub_id) if reg else None
+    return load_config(p.home, create=False) if p and (p.home / "config.toml").exists() else None
+
+
+def _sending(cfg) -> dict:
+    """How sending to the hub goes, as Settings › Devices shows it for Personal's: the hub's name as it last said, the
+    last share, a problem worth a warning, and the teammates' lessons it sent back."""
+    from ....sharing.projects import last_folders
+    from ....sharing.pull import last_team
+    from ....sharing.push import last_push, send_problem
+
+    if cfg is None or not cfg.is_spoke:
+        return {"joined": False}
+    pushed = last_push(cfg)
+    return {"joined": True, "hub_name": (last_folders(cfg) or {}).get("hub"), "share": cfg.hub_share,
+            "all_folders": cfg.hub_all_folders, "last_push": pushed, "push_problem": send_problem(pushed),
+            "team_lessons": (last_team(cfg) or {}).get("lessons")}
+
+
 def _waiting(rows: list[dict], reg=None) -> list[dict]:
     """What waits, one entry per choice to make: the projects a folder holds waiting (a group connected to no hub
     inside a connected one, a project picked out of one) together under that folder, with how many projects and
@@ -51,7 +118,8 @@ def _waiting(rows: list[dict], reg=None) -> list[dict]:
 
 def action_hubs(ctx: Context, verb: str, body: dict) -> tuple[dict, int]:
     """add (name, and optionally address and code to join it), remove, connect (group, hub; personal disconnects),
-    choose (folder, hub or personal). A change the hubs can't make says why, 409, and changes nothing."""
+    choose (folder, hub or personal), push (hub: share with it now), leave (hub: stop sending to it). A change the hubs
+    can't make says why, 409, and changes nothing."""
     from ....application import profiles as ops
     from ....core.profiles import RegistryError
     from ....projects.groups import GroupError
@@ -87,6 +155,24 @@ def action_hubs(ctx: Context, verb: str, body: dict) -> tuple[dict, int]:
                 moved = ops.connect(ctx.cfg, body.get("group"), hub, leave_on_hub=leave)
             return {"ok": True, "moved": sum(moved.sessions.values()), "taken": sum(moved.taken.values()),
                     "to": {moved.labels.get(k, k): v for k, v in moved.to.items()}}, 200
+        if verb in ("push", "leave"):
+            key = str(body.get("hub") or "")
+            reg = ctx.cfg.profiles
+            hub_id = "personal" if key.strip().casefold() == "personal" else ops.find_profile(ctx.cfg.home, key).id
+            hcfg = _hub_cfg(ctx, hub_id, reg)
+            if hcfg is None or not hcfg.is_spoke:
+                return {"error": tr("{hub} hasn't joined a hub yet.", hub=key)}, 409
+            if verb == "push":
+                from ....sharing.push import push
+
+                return {"ok": True, "started": ctx.jobs.start("push", lambda progress: push(hcfg, progress=progress)
+                                                                 .summary())}, 200
+            from ....sharing.client import leave_hub
+
+            left = leave_hub(hcfg)
+            if hub_id == "personal":
+                ctx.cfg = left
+            return {"ok": True, "hub": hcfg.hub_url}, 200
         if verb == "choose":
             moved = ops.choose(ctx.cfg, str(body.get("folder") or ""), str(body.get("hub") or ""), leave_on_hub=leave)
             return {"ok": True, "moved": sum(moved.sessions.values()), "taken": sum(moved.taken.values())}, 200

{interlatch-0.28.2 → interlatch-0.28.4}/src/interlatch/interfaces/web/api/status.py

@@ -156,12 +156,13 @@ def status_small(ctx: Context, limited: bool = False) -> dict:
     if limited:  # the hub's own queue, jobs and updates are not theirs to see
         return {"pending": {"ready": 0, "queued": 0}, "analysis": {"auto": False, "max_per_run": 0, "label": ""}, "paused_until": None,
                 "last_sync": None, "jobs": {}, "version": __version__, "update": None, "ui_build": UI_BUILD,
-                "hub_url": None, "hub_problem": None, "limited": True}
+                "hub_url": None, "hub_urls": [], "hub_problem": None, "limited": True}
 
     recall(ctx.conn)  # a check made by another dashboard process, or before a restart
     _maybe_check_daily(ctx)
 
     pending = count_pending(ctx.conn, ctx.cfg)
+    sending = _sending_to(ctx)
     return {
         "pending": pending,
         "analysis": {"auto": ctx.cfg.analysis.auto, "max_per_run": ctx.cfg.analysis.max_per_run,
@@ -175,14 +176,35 @@ def status_small(ctx: Context, limited: bool = False) -> dict:
         "update": available(),
         "ui_build": UI_BUILD,
         "hub_url": ctx.cfg.hub_url or None,  # set on a computer that sends its sessions to a hub
-        "hub_problem": _hub_problem(ctx),  # its pushes don't get through: the status bar warns
+        "hub_urls": [c.hub_url for c in sending],  # and the other hubs it sends to (docs/profiles.md)
+        "hub_problem": _hub_problem(sending),  # its pushes don't get through: the status bar warns
     }
 
 
-def _hub_problem(ctx: Context) -> dict | None:
+def _sending_to(ctx: Context) -> list:
+    """The configs that send to a hub: Personal's (when it joined one), then each other hub this computer joined."""
+    from ....application.profiles import joined
+
+    return ([ctx.cfg] if ctx.cfg.is_spoke else []) + joined(ctx.cfg)
+
+
+def _hub_problem(sending: list) -> dict | None:
+    """The first hub whose sends don't get through, with its name when it isn't Personal's (`profile`)."""
+    from ....core.profiles import PERSONAL
     from ....sharing.push import last_push, send_problem
 
-    return send_problem(last_push(ctx.cfg)) if ctx.cfg.is_spoke else None
+    for cfg in sending:
+        if problem := send_problem(last_push(cfg)):
+            if cfg.owner != PERSONAL:
+                from ....core.profiles import RegistryError
+
+                try:
+                    reg = cfg.profiles
+                except RegistryError:
+                    reg = None
+                problem["profile"] = reg.label(cfg.owner) if reg else cfg.owner
+            return problem
+    return None
 
 
 def status(ctx: Context) -> dict: