interlatch 0.28.0__tar.gz → 0.28.2__tar.gz

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

@@ -3,6 +3,58 @@
 <!-- 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.1 (2026-10-19)
+
+- **Profiles, first stage:** `interlatch profile create Acme --owns ~/work/acme` makes a named profile that owns a
+  folder (or repositories by git remote, `--remotes`). Its sessions stay off your Personal hub, a folder two profiles
+  could claim waits for you (`profile waiting`, `profile choose`), and `interlatch --profile Acme <command>` runs any
+  command for it. Sharing with each profile's own hub comes next ([Profiles](docs/profiles.md)).
+- **Profiles: agents see only their profile.** With named profiles, the MCP server and the notes at session start
+  show an agent only what its folder's profile owns, and nothing in a folder that waits for you to choose. Lines
+  proposed for your user-level CLAUDE.md and AGENTS.md come only from Personal's lessons
+  ([What agents see](docs/profiles.md#what-agents-see)).
+- **Profiles: one computer, several hubs.** A named profile joins a hub of its own
+  (`interlatch --profile Acme hub join …`) and sends it only the sessions it owns, read from your one archive, with its
+  own token and computer ID. Teammates' lessons from each hub reach only that profile's folders, and `interlatch push`
+  and the background job send for every hub ([Connect a profile to its hub](docs/profiles.md#connect-a-profile-to-its-hub)).
+- **OpenCode analyzes sessions:** pick OpenCode as the analyzer (`interlatch install`, `--backend opencode`, or
+  **Status › Analysis**) and it runs `opencode run` headless with no tools, through the providers you set up in
+  OpenCode, with the model you choose as `provider/model`. Install asks for the model and offers a test call. The CLI
+  inside the OpenCode desktop app is found too ([Analysis](docs/analysis.md)).
+- **Record only:** `interlatch install --no-analysis` (or **Record only** in install's list, or **Off** in
+  **Status › Analysis**) records sessions and never analyzes them: no model is called and nothing is sent anywhere for
+  analysis. Pick an analyzer later to analyze what was recorded ([Analysis](docs/analysis.md)).
+
+## 0.28.0 (2026-10-19)
+
+- **Sharing knowledge only sends only what is about the project:** a computer with `share = "knowledge"` used to send
+  the hub the analysis model's full reply with each session, which held lessons about you (your preferences, global
+  lessons) that were meant to stay on your computer, and titles with secrets the summary had redacted. It now sends
+  only each session's details, title, summary, goal, outcome, highlights, open threads, tags and project lessons, with
+  secrets redacted again on the way out; never the full reply, the session's mood or friction notes. A hub drops those
+  from computers that haven't updated yet, and an updated hub clears what it already received, in its team store too.
+  Titles and friction notes are now stored redacted on your own computer as well
+  ([What is shared](docs/join-a-hub.md#what-is-shared)).
+- **Leaving a hub leaves nothing behind for the next one:** `interlatch hub leave` (and **Leave the hub…** in
+  **Settings › Devices**) now also clears the folders, left projects and shared groups the computer had for that hub,
+  and its teammates' lessons, so a different hub joined later no longer gets the first one's folders and groups. They
+  are put aside, and joining the same hub again asks whether to bring them back (`--restore` / `--no-restore`).
+  `interlatch hub join` refuses a second hub while the computer is in one, before it sends anything there; joining the
+  same hub again still just renews the token. A hub that moved: `interlatch hub set-url <address>`
+  ([Joining your team's hub](docs/join-a-hub.md)).
+- **Each hub has its own sign-in cookie:** two hubs reached under one host name (on different ports, say) no longer
+  sign each other's people out: a hub's cookie is named for that hub, with `__Host-` in front over HTTPS. A browser
+  still sends one host name's cookies to all its ports, so give every hub a host name of its own, sslip.io names
+  included. A browser already signed in stays signed in and moves to the new name on its next visit
+  ([One name per hub](docs/devices.md#one-name-per-hub)).
+- **Less about your computer reaches a hub:** projects in `[sources] exclude_projects` no longer reach a hub in any
+  form: not their folders and git remotes, their prompts in `history.jsonl`, Codex's titles for them, or their
+  earlier analyses. A computer that shares knowledge of the hub's projects only now tells the hub just about the
+  repositories it can share from, and asks for teammates' lessons with just those. Invite codes and sign-in links are
+  now redacted like other credentials ([What the hub learns about this computer](docs/devices.md#what-the-hub-learns-about-this-computer)).
+- **Hand-edited hub folders:** `interlatch hub leave` and `interlatch hub add-folder` no longer stop with an error
+  when `config.toml` lists the hub's folders in a `[hub.folders]` section of its own.
+
 ## 0.27.8 (2026-10-19)
 
 - **Projects sidebar reads like a tree:** groups and the hub now have headers in the sidebar's own type, each with its

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

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

@@ -0,0 +1,6 @@
+- **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)).

interlatch-0.28.2/changelog.d/hub-take-back.md

@@ -0,0 +1,6 @@
+- **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.

interlatch-0.28.2/changelog.d/hubs-dashboard.md

@@ -0,0 +1,3 @@
+- **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)).

{interlatch-0.28.0 → interlatch-0.28.2}/docs/README.md

@@ -14,6 +14,7 @@
 | [VS Code extension](vscode.md) | The sessions behind the open file and every file agents worked on, in VS Code's Explorer |
 | [Phone and other computers](devices.md) | The dashboard on your phone through Tailscale, and one archive for several computers (a hub) |
 | [A hub in Docker](docker.md) | Setting up a team's hub on a server, step by step: Azure, the first admin, projects, inviting the team, troubleshooting |
+| [Several hubs on one computer](profiles.md) | Several teams with their own hubs on one computer: connect your groups of projects to the hub each belongs to, waiting folders, what agents see |
 | [Joining your team's hub](join-a-hub.md) | For teammates: join with the code your admin sent, add your project folder, get teammates' lessons back |
 | [A copy in Postgres](postgres.md) | Keep a copy of your archive in a Postgres database you choose (on this computer, in Docker, or in the cloud) for SQL and BI tools |
 | [What gets recorded and how analysis works](analysis.md) | Session data, knowledge kinds, the analysis pipeline and its cost |

{interlatch-0.28.0 → interlatch-0.28.2}/docs/analysis.md

@@ -60,6 +60,12 @@ instance, have no cache split (so no cost estimate), Bob tasks have no per-call
      background analysis and the dashboard don't see your shell's variables, so `interlatch install` offers to save it.
      Bob picks its own model. It keeps each analysis in its own task list;
      Interlatch doesn't import those as sessions.
+   - **OpenCode** (`backend = "opencode"`): `opencode run --standalone --format json` with an agent of Interlatch's
+     own that holds its instructions and denies every permission, so the model is offered no tool; a reply that
+     follows any tool call is thrown away. It runs through the providers you set up in OpenCode (`opencode auth
+     login`, or local models such as Ollama). OpenCode's free tier refuses headless runs. Interlatch finds `opencode`
+     on your PATH, or the CLI inside the OpenCode desktop app on a Mac. OpenCode saves each run as a session:
+     Interlatch reads its tokens and cost, then deletes it, and never imports runs from its work folder.
 
    - **A model provider's API** (`backend = "anthropic"`, `"bedrock"`, `"openai"`, `"azure"`, `"openrouter"`,
      `"ollama"` or `"openai-compatible"`): one plain HTTP request per call, with no tools in it, so the model can
@@ -68,10 +74,17 @@ instance, have no cache split (so no cost estimate), Bob tasks have no per-call
    Each agent's tab in **Status › Analysis** sets its model: for Claude Code, one for sessions (`analysis.model`), one
    for knowledge bases (`synthesis.model`) and one for screening imported chats (`analysis.screen_model`), each an
    alias (`sonnet`, `opus`, `haiku`, `fable`) or a full model id such as `claude-opus-5-5`; for Codex,
-   `analysis.codex_model` (empty: Codex's default). Both share `analysis.effort`.
+   `analysis.codex_model` (empty: Codex's default). Both share `analysis.effort`. For OpenCode,
+   `analysis.opencode_model` as `provider/model`, e.g. `anthropic/claude-sonnet-5-5` or `ollama/qwen3.8` (empty:
+   OpenCode's default model); `opencode models` lists them.
 
    `INTERLATCH_INTERNAL=1` makes Interlatch's own hooks inert for these runs. Switch in **Status › Analysis**, with
    `interlatch config set analysis.backend codex`, or for one run with `interlatch analyze --backend codex`.
+
+   **Record only.** `backend = "none"` (`interlatch install --no-analysis`, or **Off** in **Status › Analysis**)
+   records sessions and never analyzes them: no model is called and nothing leaves your computer for analysis, not
+   for sessions, knowledge bases, weekly re-analyses, screening or glossaries. Sessions wait in the queue; pick an
+   analyzer later to analyze them, or analyze a few once with `interlatch analyze --backend NAME`.
 4. The JSON reply is validated leniently (with one repair pass) and stored. When a project gains
    `min_new_items` new items, its knowledge base is re-synthesized (or once a week, on the day you pick, with fewer, where you turned on
    [weekly re-analysis](dashboard.md#project-groups) for it); items that are outdated, contradicted or
@@ -210,7 +223,8 @@ interlatch config set analysis.backend openai
 Cost: with a provider, the cost is what the API reports (OpenRouter) or an estimate from the token counts at
 Anthropic's, OpenAI's or Google's list prices (Anthropic, Bedrock, OpenAI, and Gemini models on an OpenAI-compatible
 server); Azure, Ollama and other models show tokens only. Otherwise,
-analysis runs through your own Claude Code or Codex login, or your Bob API key (Bob reports what each analysis cost).
+analysis runs through your own Claude Code, Codex or OpenCode login, or your Bob API key (Bob reports what each
+analysis cost; OpenCode reports its price for the model, nothing for a subscription or a local model).
 With Claude, the reported cost is the API
 list-price equivalent: sessions averaged about $0.38 each with Sonnet (digests average ~150k characters), and
 `max_budget_usd` caps each call. Codex reports tokens but no price, so Codex analyses show no cost. On a Claude or

{interlatch-0.28.0 → interlatch-0.28.2}/docs/cli.md

@@ -46,6 +46,9 @@
 | `interlatch hub people` / `hub role <email\|id> <role>` / `hub remove <email\|id>` / `hub shared-token on\|off` | On the hub: everyone with their role, the projects they see and their computers; change a role; remove someone; allow or refuse the shared token ([People and roles](devices.md#people-and-roles)) |
 | `interlatch hub add-folder <folder> --project <name>` / `hub remove-folder <folder>` / `hub folders [--list]` | On a computer that joined a hub: file a folder's sessions under a project on the hub, take a folder added by mistake back out, or show what goes where (`--list`: the hub's projects) ([Same project, different folders](devices.md#same-project-different-folders)). Sharing knowledge, `remove-folder` also has the hub delete what the computer shared from that folder ([Leaving](devices.md#leaving)) |
 | `interlatch hub leave --project <name>` / `hub rejoin --project <name>` | On a computer that shares knowledge: stop sharing to one of the hub's projects and getting its teammates' lessons, keeping what it already shared there; or start again ([Leaving](devices.md#leaving)) |
+| `interlatch hubs` / `hubs add <name> [<address> --code <code>] [--all-folders]` / `hubs remove <name> [--delete-data]` | The hubs this computer sends to besides Personal's, with the groups connected to each; add one (and join it), remove one ([Several hubs on one computer](profiles.md)) |
+| `interlatch group list` / `create <name> --folder <folder>…` / `add-folder` / `remove-folder <group> <folder>` / `connect <group> <hub>` / `disconnect <group>` / `where <folder>` / `waiting` / `choose <folder> <hub\|personal>` / `remove <group>` | Your groups of projects and the hub each goes to: connecting one moves its sessions so far to that hub; taking a project out of a connected group, or disconnecting it, makes it wait for you. `--dry-run` shows what would move; a hub that has sessions that move takes them back first; `--leave-on-hub` moves them even if it can't now |
+| `interlatch --hub <name> hub … \| push \| config …` | Run a hub command for another of this computer's hubs: join it, push its sessions, change its settings. Recording and analysis are Personal's. `interlatch push` sends to Personal's hub and then each other one |
 | `interlatch push` | On a computer that joined a hub: send its new sessions now (the hook and the background sync do this) |
 | `interlatch container` | What the hub's Docker image runs: set the hub up from `INTERLATCH_*` variables, then serve the dashboard and sync every 15 minutes ([A hub in Docker](docker.md)) |
 | `interlatch config [edit]` | Show or edit `~/.interlatch/config.toml` |

{interlatch-0.28.0 → interlatch-0.28.2}/docs/configuration.md

@@ -25,9 +25,10 @@ the file. Changes apply on the next sync or worker run. `INTERLATCH_HOME` reloca
 | Key | Default | |
 | --- | --- | --- |
 | `auto` | `true` | analyze sessions automatically once they go idle |
-| `backend` | `claude` | what analyzes sessions: `claude` (Claude Code) or `codex` (Codex) through your own login, `bob` (IBM Bob Shell, with a Bob API key: `interlatch config set-key bob`), or a model provider's API: `anthropic`, `bedrock`, `openai`, `azure`, `openrouter`, `ollama`, `openai-compatible` (see [`[providers.<name>]`](#providers)). Also in **Status › Analysis** |
+| `backend` | `claude` | what analyzes sessions: `claude` (Claude Code), `codex` (Codex) or `opencode` (OpenCode) through your own login, `bob` (IBM Bob Shell, with a Bob API key: `interlatch config set-key bob`), or a model provider's API: `anthropic`, `bedrock`, `openai`, `azure`, `openrouter`, `ollama`, `openai-compatible` (see [`[providers.<name>]`](#providers)). Or `none`: record sessions only, never analyze them (`interlatch install --no-analysis`). Also in **Status › Analysis** |
 | `model` / `effort` | `sonnet` / `medium` | Claude: any `claude --model` alias or full model id. `effort` also sets Codex's reasoning effort (`max` becomes `xhigh`). Both are in Claude Code's tab in **Status › Analysis** |
 | `codex_model` | `""` | Codex model, e.g. `gpt-5.5`; empty uses Codex's default |
+| `opencode_model` | `""` | OpenCode model as `provider/model`, e.g. `ollama/qwen3.8`; empty uses OpenCode's default |
 | `screen_model` | `haiku` | model that screens imported chats (`interlatch screen`); it reads only each chat's opening, 60 chats a call |
 | `language` | `en` | the language Interlatch writes in: summaries, knowledge, knowledge bases, the playbook, glossary definitions, weekly reviews, screening reasons and the lines it proposes for `CLAUDE.md` / `AGENTS.md`. `en` or `ja`; applies to what is analyzed from then on. Also in **Status › Analysis**. The dashboard's own language is chosen in the dashboard, per browser |
 | `max_budget_usd` | `3.0` | spend cap per `claude -p` call, API-equivalent USD (Codex reports tokens only) |
@@ -37,7 +38,7 @@ the file. Changes apply on the next sync or worker run. `INTERLATCH_HOME` reloca
 | `backfill` | `true` | also analyze sessions recorded before install (newest first) |
 | `chunk_chars` | `150000` | characters of condensed transcript per call; longer sessions are map-reduced |
 | `timeout_seconds` | `900` | wall-clock limit per call |
-| `claude_bin` / `codex_bin` / `bob_bin` | `""` | path to `claude` / `codex` / Bob Shell's `bob` (found automatically when empty) |
+| `claude_bin` / `codex_bin` / `bob_bin` / `opencode_bin` | `""` | path to `claude` / `codex` / Bob Shell's `bob` / `opencode` (found automatically when empty; for OpenCode, also the CLI inside its desktop app) |
 
 ## `[providers.*]`
 

{interlatch-0.28.0 → interlatch-0.28.2}/docs/ja/README.md

@@ -14,6 +14,7 @@
 | [VS Code 拡張機能](vscode.md) | 開いているファイルと、エージェントが作業したすべてのファイルの背後にあるセッションを、VS Code のエクスプローラーに表示 |
 | [スマートフォンとほかのコンピューター](devices.md) | Tailscale 経由でスマートフォンからダッシュボードを開く、複数のコンピューターで 1 つのアーカイブ（ハブ） |
 | [Docker でハブを動かす](docker.md) | サーバーでチームのハブを用意する手順：Azure、最初の管理者、プロジェクト、チームの招待、トラブルシューティング |
+| [1 台のコンピューターで複数のハブ](profiles.md) | それぞれにハブがある複数のチームを 1 台で：プロジェクトのグループをそれぞれのハブにつなぐ、選択を待つフォルダー、エージェントに見えるもの |
 | [チームのハブに参加する](join-a-hub.md) | チームメイト向け：管理者から届いたコードで参加し、プロジェクトのフォルダーを加え、チームメイトのナレッジを受け取る |
 | [Postgres へのコピー](postgres.md) | アーカイブのコピーを、選んだ Postgres データベース（このコンピューター、Docker、クラウド）に置いて SQL や BI ツールで使う |
 | [記録される内容と分析の仕組み](analysis.md) | セッションのデータ、ナレッジの種類、分析の流れとその費用 |

{interlatch-0.28.0 → interlatch-0.28.2}/docs/ja/analysis.md

@@ -54,6 +54,12 @@ Codex、Copilot、Bob、Antigravity、OpenCode のセッションも、ログに
      **Status › Analysis** の IBM Bob タブ。`BOB_API_KEY` も使えますが、それを持つターミナルからだけです。バックグラウンドの
      分析とダッシュボードはシェルの変数を見ないため、`interlatch install` が保存を提案します。モデルは Bob が選びます。Bob は各分析を自身のタスク一覧に残しますが、Interlatch はそれをセッションとして
      取り込みません。
+   - **OpenCode**（`backend = "opencode"`）：`opencode run --standalone --format json` を、Interlatch 専用のエージェントで
+     実行します。このエージェントは Interlatch の指示を持ち、すべての権限を拒否するので、モデルにはツールが提示されません。
+     ツール呼び出しのあとの応答は破棄されます。OpenCode に設定したプロバイダー（`opencode auth login`、または Ollama などの
+     ローカルモデル）を通じて動きます。OpenCode の無料枠はヘッドレス実行を受け付けません。Interlatch は PATH 上の `opencode`、
+     または Mac では OpenCode デスクトップアプリに同梱の CLI を見つけます。OpenCode は各実行をセッションとして保存しますが、
+     Interlatch はそのトークン数と費用を読んだあとに削除し、作業フォルダーでの実行は取り込みません。
 
    - **モデルプロバイダーの API**（`backend = "anthropic"`、`"bedrock"`、`"openai"`、`"azure"`、`"openrouter"`、
      `"ollama"`、`"openai-compatible"`）：呼び出しごとに素の HTTP リクエストを 1 回送ります。ツールは含まないので、モデルは
@@ -62,11 +68,18 @@ Codex、Copilot、Bob、Antigravity、OpenCode のセッションも、ログに
    **Status › Analysis** の各エージェントのタブでモデルを設定できます。Claude Code では、セッション用（`analysis.model`）、
    ナレッジベース用（`synthesis.model`）、取り込んだチャットの選別用（`analysis.screen_model`）を、エイリアス（`sonnet`、
    `opus`、`haiku`、`fable`）か `claude-opus-5-5` のような完全なモデル ID で指定します。Codex では `analysis.codex_model`
-   （空なら Codex の既定）。どちらも `analysis.effort` を共有します。
+   （空なら Codex の既定）。どちらも `analysis.effort` を共有します。OpenCode では `analysis.opencode_model` を
+   `provider/model` の形で指定します。例：`anthropic/claude-sonnet-5-5`、`ollama/qwen3.8`（空なら OpenCode の既定のモデル）。
+   一覧は `opencode models` で見られます。
 
    これらの実行中は `INTERLATCH_INTERNAL=1` によって Interlatch 自身のフックが無効になります。**Status › Analysis**、
    `interlatch config set analysis.backend codex`、または 1 回の実行だけなら `interlatch analyze --backend codex` で
    切り替えられます。
+
+   **記録のみ。** `backend = "none"`（`interlatch install --no-analysis`、または **Status › Analysis** の **オフ**）では、
+   セッションを記録するだけで分析はしません。モデルは呼ばれず、分析のために何もコンピューターの外へ出ません。セッション、
+   ナレッジベース、毎週の再分析、選別、用語集のどれも同じです。セッションはキューで待つので、あとで分析エンジンを選べば
+   分析されます。いくつかだけ 1 回分析するなら `interlatch analyze --backend NAME` を使います。
 4. JSON の応答は寛容に検証され（修復は 1 回まで）、保存されます。プロジェクトに `min_new_items` 件の新しい項目がたまると
    （[毎週の再分析](dashboard.md#プロジェクトのグループ)をオンにしたプロジェクトでは、それより少なくても週に 1 回、選んだ曜日に）、
    そのプロジェクトのナレッジベースが再統合され、古くなった項目、矛盾する項目、重複した項目は *superseded*（置き換え済み）になり、
@@ -187,7 +200,7 @@ interlatch config set analysis.backend openai
 
 プロバイダーを使う場合の費用は、API が報告する額（OpenRouter）か、トークン数から Anthropic や OpenAI の定価で見積もった額
 （Anthropic、Bedrock、OpenAI）です。Azure、Ollama、その他のサーバーはトークン数だけを表示します。それ以外では、
-分析はあなた自身の Claude Code または Codex のログイン、または Bob の API キー（Bob は分析ごとの費用を報告します）を通じて行われます。Claude の場合、表示される費用は API 定価に換算した
+分析はあなた自身の Claude Code、Codex、OpenCode のログイン、または Bob の API キー（Bob は分析ごとの費用を報告します。OpenCode はそのモデルの価格を報告し、サブスクリプションやローカルモデルでは 0 です）を通じて行われます。Claude の場合、表示される費用は API 定価に換算した
 金額です。Sonnet ではセッションあたり平均約 $0.38 でした（要約の平均は約 15 万文字）。`max_budget_usd` で 1 回の呼び出しの上限を
 設定できます。Codex はトークン数を報告しますが価格は報告しないため、Codex による分析には費用が表示されません。Claude や ChatGPT の
 サブスクリプションでは、請求ではなくプランの使用枠から消費されます。`interlatch analyze --pending --dry-run` で、使う前に未分析分の

{interlatch-0.28.0 → interlatch-0.28.2}/docs/ja/cli.md

@@ -46,6 +46,9 @@
 | `interlatch hub people` / `hub role <email\|id> <role>` / `hub remove <email\|id>` / `hub shared-token on\|off` | ハブで：全員のロール、見えるプロジェクト、コンピューターの一覧／ロールを変える／人を外す／共有トークンを許すか拒むか（[利用者とロール](devices.md#利用者とロール)） |
 | `interlatch hub add-folder <folder> --project <name>` / `hub remove-folder <folder>` / `hub folders [--list]` | ハブに参加したコンピューターで：フォルダーのセッションをハブのプロジェクトに入れる／間違えて追加したフォルダーを外す／どこに入るかを表示（`--list`：ハブのプロジェクト一覧）（[同じプロジェクト、別のフォルダー](devices.md#同じプロジェクト別のフォルダー)）。ナレッジを共有しているときは、`remove-folder` でそのフォルダーから共有したものもハブが削除します（[やめるとき](devices.md#やめるとき)） |
 | `interlatch hub leave --project <name>` / `hub rejoin --project <name>` | ナレッジを共有するコンピューターで：ハブのプロジェクトの一つへの共有とチームメイトのナレッジの受け取りをやめる（すでに共有したものは残る）、または再開する（[やめるとき](devices.md#やめるとき)） |
+| `interlatch hubs` / `hubs add <name> [<address> --code <code>] [--all-folders]` / `hubs remove <name> [--delete-data]` | Personal 以外にこのコンピューターが送るハブと、それぞれにつないだグループの一覧。追加する（参加もする）、削除する（[1 台のコンピューターで複数のハブ](profiles.md)） |
+| `interlatch group list` / `create <name> --folder <folder>…` / `add-folder` / `remove-folder <group> <folder>` / `connect <group> <hub>` / `disconnect <group>` / `where <folder>` / `waiting` / `choose <folder> <hub\|personal>` / `remove <group>` | プロジェクトのグループと、それぞれの送り先のハブ：つなぐと、これまでのセッションもそのハブに移る。つないだグループからプロジェクトを外す、または接続を外すと、あなたの選択を待つ。`--dry-run` は移るものの表示だけ、移るセッションを持つハブは先にそれを取り下げる。`--leave-on-hub` は今取り下げられなくても移す |
+| `interlatch --hub <name> hub … \| push \| config …` | このコンピューターのほかのハブでハブのコマンドを実行する：参加する、セッションを送る、設定を変える。記録と分析は Personal が行います。`interlatch push` は Personal のハブ、次にほかの各ハブへ送ります |
 | `interlatch push` | ハブに参加したコンピューターで：新しいセッションを今すぐ送る（フックとバックグラウンド同期も送ります） |
 | `interlatch container` | ハブの Docker イメージが実行するコマンド：`INTERLATCH_*` 変数からハブを設定し、ダッシュボードを提供して 15 分ごとに同期（[Docker でハブを動かす](docker.md)） |
 | `interlatch config [edit]` | `~/.interlatch/config.toml` を表示または編集 |

{interlatch-0.28.0 → interlatch-0.28.2}/docs/ja/configuration.md

@@ -25,9 +25,10 @@
 | キー | 既定値 | |
 | --- | --- | --- |
 | `auto` | `true` | アイドルになったセッションを自動で分析する |
-| `backend` | `claude` | セッションを分析するもの：あなた自身のログインで `claude`（Claude Code）または `codex`（Codex）、Bob の API キーで `bob`（IBM Bob Shell。`interlatch config set-key bob`）、またはモデルプロバイダーの API：`anthropic`、`bedrock`、`openai`、`azure`、`openrouter`、`ollama`、`openai-compatible`（[`[providers.<name>]`](#providers) を参照）。**Status › Analysis** でも変更できます |
+| `backend` | `claude` | セッションを分析するもの：あなた自身のログインで `claude`（Claude Code）、`codex`（Codex）、`opencode`（OpenCode）、Bob の API キーで `bob`（IBM Bob Shell。`interlatch config set-key bob`）、またはモデルプロバイダーの API：`anthropic`、`bedrock`、`openai`、`azure`、`openrouter`、`ollama`、`openai-compatible`（[`[providers.<name>]`](#providers) を参照）。または `none`：セッションを記録するだけで分析しません（`interlatch install --no-analysis`）。**Status › Analysis** でも変更できます |
 | `model` / `effort` | `sonnet` / `medium` | Claude：`claude --model` の任意のエイリアスか完全なモデル ID。`effort` は Codex の推論の強さにも使われます（`max` は `xhigh` になります）。どちらも **Status › Analysis** の Claude Code タブで変更できます |
 | `codex_model` | `""` | Codex のモデル。例：`gpt-5.5`。空の場合は Codex の既定のモデルを使います |
+| `opencode_model` | `""` | OpenCode のモデル（`provider/model`）。例：`ollama/qwen3.8`。空の場合は OpenCode の既定のモデルを使います |
 | `screen_model` | `haiku` | 取り込んだチャットを選別するモデル（`interlatch screen`）。各チャットの冒頭だけを、1 回の呼び出しで 60 件ずつ読みます |
 | `language` | `en` | Interlatch が書く言語：要約、ナレッジ、ナレッジベース、プレイブック、用語集の定義、週次の振り返り、選別の理由、`CLAUDE.md` / `AGENTS.md` に提案する行。`en` または `ja`。変更したあとに分析するものから反映されます。**Status › Analysis** でも変更できます。ダッシュボード自体の言語は、ダッシュボードでブラウザーごとに選びます |
 | `max_budget_usd` | `3.0` | `claude -p` の呼び出し 1 回あたりの費用上限（API 換算の USD。Codex はトークン数だけを報告します） |
@@ -37,7 +38,7 @@
 | `backfill` | `true` | インストール前に記録されたセッションも分析する（新しい順） |
 | `chunk_chars` | `150000` | 1 回の呼び出しに渡す、まとめたトランスクリプトの文字数。これより長いセッションは map-reduce で処理します |
 | `timeout_seconds` | `900` | 呼び出し 1 回あたりの実時間の上限 |
-| `claude_bin` / `codex_bin` / `bob_bin` | `""` | `claude` / `codex` / Bob Shell の `bob` のパス（空の場合は自動で検出） |
+| `claude_bin` / `codex_bin` / `bob_bin` / `opencode_bin` | `""` | `claude` / `codex` / Bob Shell の `bob` / `opencode` のパス（空の場合は自動で検出。OpenCode はデスクトップアプリに同梱の CLI も探します） |
 
 ## `[providers.*]`
 

interlatch-0.28.2/docs/ja/profiles.md

@@ -0,0 +1,112 @@
+# 1 台のコンピューターで複数のハブ
+
+[← Interlatch](../../README.ja.md) · [ドキュメント一覧](README.md)
+
+コンピューターが参加できるハブは一つです。自分のプロジェクトと取引先のプロジェクトのように、それぞれにハブがある複数のチームで働くときは、**プロジェクトのグループ**を、それぞれが属するハブにつなぎます。そうすると、各フォルダーのセッションは一つのハブにだけ届き、そこで作業するエージェントにはそのハブのものだけが見えます。
+
+- **Personal**（`~/.interlatch`）は、これまでどおり、すべてのエージェントのすべてのセッションを記録・分析します。このコンピューターにあるすべてのものの元のコピーで、自分のハブに送ることもできます。
+- **ほかのハブ**には、ここでの名前（たとえば Acme）を付けます。そのハブにつないだグループのセッションが届きます。読むのは Personal のアーカイブで、コピーは作らず、分析も二度しません。
+
+## ハブを追加してグループをつなぐ
+
+1. ハブの管理者から受け取った招待コードでハブを追加します（[チームのハブに参加する](join-a-hub.md)）。
+
+    ```bash
+    interlatch hubs add Acme https://hub.acme.example --code XXXX-XXXX-XXXX
+    ```
+
+2. そのハブに属するフォルダーのグループを作ります。ダッシュボードの「プロジェクト」ページにあるグループも使えます。
+
+    ```bash
+    interlatch group create "Acme work" --folder ~/work/acme --folder ~/clients/acme-site
+    ```
+
+3. グループをハブにつなぎます。
+
+    ```bash
+    interlatch group connect "Acme work" Acme
+    ```
+
+グループのフォルダーですでに記録されたセッションは Acme に移り、それ以降は Acme のハブに送られます。Personal のハブがすでに持っているものは、先にそのハブが取り下げます（[移すとハブから取り下げる](#moving-takes-sessions-back)）。`--dry-run` を付けると、何も変えずに、移るものと、そのうちハブが持っている数を表示します。
+
+**ダッシュボードでは：** **設定 › デバイス › ハブ**でハブを追加し（名前、アドレス、招待コード）、グループのページの**送り先**で、そのグループのセッションを送るハブを選びます。
+
+ほかのコンピューターと同じく、ハブに送られるのは、そのハブのプロジェクトに追加したフォルダーのものだけです（`interlatch --hub Acme hub add-folder ~/work/acme/app --project App`）。`--all-folders` を付けて参加した場合は別です。
+
+## グループで決まる
+
+つないだグループに入っているものが、そのハブに送られます。グループのフォルダーとその下のすべて、そして「プロジェクト」ページで手で入れたプロジェクトです。グループを変えると、これまでのセッションも含めてハブがそれに従います。
+
+| すること | そこにあるセッション |
+| --- | --- |
+| つないだグループにフォルダーを加える、プロジェクトを入れる | そのハブに移る |
+| つないだグループからプロジェクトを外す | あなたの選択を待つ（下記）。勝手に Personal には戻らない |
+| つないだグループのフォルダーの中に、どのハブにもつながないグループを作る | あなたの選択を待つ |
+| つないだグループのフォルダーの中のグループを、別のハブにつなぐ | そのハブに移る。狭いほうのグループが優先 |
+| グループの接続を外す（`interlatch group disconnect "Acme work"`） | あなたの選択を待つ |
+
+<a id="moving-takes-sessions-back"></a>
+
+### 移すとハブから取り下げる
+
+セッションが置かれるハブは一度に一つです。変更でセッションがあるハブから離れるとき（別のハブへ、またはあなたの選択待ちへ）、そのハブは、このコンピューターが送ったものを取り下げます。要約とナレッジが、そのハブとチームストアから消えます。これは新しいハブに何かを送る前に行います。あとでそのハブに戻すと、もう一度送られます。
+
+ハブに届かないとき、またはこのコンピューターがまだそのハブに送っている最中のときは、何も変えず、理由を表示します（ダッシュボードでも同じ）。あとでやり直すか、そのまま移してください（`--leave-on-hub`、またはダッシュボードの確認で **OK**）。その場合、次にこのコンピューターがそのハブに送るときに取り下げます。このバージョンより古いハブは取り下げができません。ハブを更新するか、そのまま移してください。そのハブのコピーは残ります。
+
+ハブの削除（`interlatch hubs remove`）では何も取り下げません。先にそのハブから抜けてください。
+
+一つのフォルダーが属せるハブは一つです。二つのハブのグループを同じフォルダーにつなぐことはできません。
+
+## 選択を待つフォルダー
+
+複数のハブのものになりうるフォルダーや、グループが手放したフォルダーは**選択を待ちます**。Personal は記録・分析を続けますが、あなたが選ぶまで、どのハブにも送られず、どのエージェントにも見えません。
+
+```bash
+interlatch group waiting
+interlatch group choose ~/work/acme/notes Acme       # または personal
+interlatch group where ~/work/acme/app               # フォルダーがどのハブに行くか、その理由
+```
+
+**設定 › デバイス › ハブ**にも一覧があり、それぞれに**選ぶ**ボタンがあります。**ホーム**の**あなたの対応待ち**にも表示されます。あるフォルダーが選択待ちにしているプロジェクト（つないだグループの中にある、どのハブにもつないでいないグループ）は、そのフォルダーの下にまとめて表示します。
+
+## エージェントに見えるもの
+
+Interlatch がエージェントに渡すもの（[MCP サーバー](mcp.md)のツールと、セッション開始時のメモ）は、エージェントが動くフォルダーで決まります。
+
+- **ハブにつないだグループのフォルダーでは：** そのハブのセッション、ナレッジ、ナレッジベース、チームメイトのナレッジだけ。
+- **それ以外の場所では：** Personal のものだけ。
+- **選択を待つフォルダーでは：** 何もありません。MCP のツールは、そのフォルダーがあなたの選択を待っていると伝えます。
+
+すべてのプロジェクトをまとめて作るもの（全体のプレイブック、ほかのハブのプロジェクトにも出てくる用語集の用語、テーマ、週次レビュー）は、ほかのハブがある間はエージェントに見せません。ダッシュボードには引き続きすべて表示されます。
+
+すべてのフォルダーでエージェントが読むユーザーレベルの指示ファイル（`~/.claude/CLAUDE.md`、`~/.codex/AGENTS.md`）に Interlatch が提案する行は、Personal のナレッジからだけ作ります。ほかのハブのセッションで得たナレッジは、そのプロジェクト自身のファイルに提案します（[提案](suggestions.md)）。
+
+## コマンド
+
+| 目的 | 実行するコマンド |
+| --- | --- |
+| ハブとそのグループの一覧 | `interlatch hubs` |
+| ハブを追加して参加する | `interlatch hubs add <name> [<address> --code <code>] [--all-folders]` |
+| ハブを削除する | `interlatch hubs remove <name> [--delete-data]`（先に抜けておく：`interlatch --hub <name> hub leave`） |
+| グループと送り先の一覧 | `interlatch group list` |
+| グループを作る、フォルダーを変える | `interlatch group create <name> --folder <folder>…`、`group add-folder` / `remove-folder <group> <folder>` |
+| グループをつなぐ、外す | `interlatch group connect <group> <hub>`、`group disconnect <group>` |
+| ほかのハブのハブコマンドを実行する | `interlatch --hub <name> hub …` / `push` / `config …` |
+
+`interlatch push` とバックグラウンドの処理は、Personal のハブ、次にほかの各ハブへ送ります。記録、分析、ダッシュボードは Personal が行います。`--hub` を付けて実行できるのは `hub`、`push`、`config` だけです。
+
+## 複数のハブとの共有
+
+- **ナレッジだけ。** どのハブにも、要約とプロジェクトのナレッジだけを送り、トランスクリプトは送りません。トランスクリプトを送るとすべてのハブのセッションが含まれてしまうため、ほかのハブがある間は Personal もトランスクリプトを送りません：`interlatch config set hub.share knowledge`。
+- **各ハブに一度だけ。** このコンピューターがすでに送っているハブへの参加は、何も送る前に断られます。
+- **自分の ID。** ハブごとにトークンとコンピューターの ID が別なので、二つのハブが ID でこのコンピューターを突き合わせることはできません。ただし、どのハブにもコンピューターの名前は表示されます。ハブに見せる名前は `~/.interlatch/profiles/<id>/machine.json` で変えられます。
+- **自分のチームメイト。** ハブから届いたチームメイトのナレッジはそのハブのものとして保存し、エージェントにはそのフォルダーでだけ見せます。一つのハブから抜けても（`interlatch --hub Acme hub leave`）、消えるのはそのハブのものだけです。
+- **Personal のハブ**には Personal のセッションだけが届きます。ハブへのあいさつで伝えるリポジトリやフォルダーにも、ほかのハブのものは含まれません。
+
+## 保存場所
+
+`~/.interlatch/profiles.toml` に、ほかのハブ、それぞれにつないだグループ、そこから決まるフォルダー、あなたの選択が入ります。読めるのはあなただけです。このファイルが読めないときは、直すまでどのハブにも何も共有しません。ハブごとに専用のフォルダー `~/.interlatch/profiles/<id>` があり、トークン、コンピューターの ID、共有の状態が入ります。
+
+最初にほかのハブを追加すると、Personal のアーカイブに各セッションの属するハブを記録する `session_owner` テーブルができます。ほかのハブのないアーカイブは変更されません。
+
+**0.28.1 から：** `interlatch profile` は `interlatch hubs` と `interlatch group` になり、`--profile` は `--hub` になりました（古い名前も使えます）。`--owns` でプロファイルに与えたフォルダーは、そのハブのものとして残ります。

interlatch-0.28.2/docs/profiles.md

@@ -0,0 +1,145 @@
+# Several hubs on one computer
+
+[← Interlatch](../README.md) · [Docs index](README.md)
+
+A computer joins one hub. If you work for more than one team, such as your own projects and a client's, each with
+its own hub, connect your **groups of projects** to the hub each one belongs to. Each folder's sessions then reach one
+hub only, and agents working there see only what belongs to it.
+
+- **Personal** (`~/.interlatch`) records and analyzes every session from every agent, as always. It's the master copy
+  of everything on this computer, and it may send to a hub of its own.
+- **Another hub** has a name here, such as Acme. It gets the sessions in the groups you connect to it, read from
+  Personal's archive: no second copy, and nothing analyzed twice.
+
+<a id="connect-a-profile-to-its-hub"></a>
+
+## Add a hub and connect a group
+
+1. Add the hub, with the invite code its admin sent ([Joining your team's hub](join-a-hub.md)):
+
+    ```bash
+    interlatch hubs add Acme https://hub.acme.example --code XXXX-XXXX-XXXX
+    ```
+
+2. Make a group of the folders that belong to it, or use one you already have on the dashboard's **Projects** page:
+
+    ```bash
+    interlatch group create "Acme work" --folder ~/work/acme --folder ~/clients/acme-site
+    ```
+
+3. Connect the group to the hub:
+
+    ```bash
+    interlatch group connect "Acme work" Acme
+    ```
+
+The sessions already recorded in the group's folders move to Acme, and go to Acme's hub from then on. Any that
+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.
+
+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`.
+
+## Groups decide
+
+What a connected group holds goes to its hub: its folders and everything below them, and projects you put in it by
+hand on the **Projects** page. Change the group and its hub follows, sessions so far included:
+
+| You | The sessions there |
+| --- | --- |
+| Add a folder to a connected group, or put a project in it | Move to its hub |
+| Take a project out of a connected group | Wait for you (below), never back to Personal on their own |
+| Make a group inside a connected group's folder, connected to no hub | Wait for you |
+| Connect a group to another hub inside a connected group's folder | Go to that hub: the narrower group wins |
+| Disconnect a group (`interlatch group disconnect "Acme work"`) | Wait for you |
+
+<a id="moving-takes-sessions-back"></a>
+
+### Moving takes sessions back
+
+A session is on one hub at a time. When a change moves sessions away from a hub (to another hub, or to wait for
+you), that hub takes back the ones this computer sent it: their summaries and lessons go, there and in its team
+store. This happens before anything goes to the new hub. A session chosen for that hub again is simply sent again.
+
+If the hub can't be reached, or this computer is still sending to it, nothing changes, on the dashboard too, and
+you're told why. Try again later, or move them anyway (`--leave-on-hub`, or **OK** on the dashboard's question): the
+hub takes them back the next time this computer sends to it. A hub older than this version can't take sessions back.
+Update it, or move them anyway and its copies stay there.
+
+Removing a hub (`interlatch hubs remove`) takes nothing back: leave it first.
+
+A folder can belong to one hub: connecting two hubs' groups to the same folder is refused.
+
+## Waiting folders
+
+A folder that could belong to more than one hub, or that a group let go, **waits**. Personal still records and
+analyzes its sessions, but no hub gets them and no agent sees them until you choose:
+
+```bash
+interlatch group waiting
+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
+connected to no hub inside a connected one) are listed once, under that folder.
+
+## What agents see
+
+What Interlatch gives an agent depends on the folder it runs in: the [MCP server](mcp.md)'s tools and the notes at
+the start of each session.
+
+- **In a folder of a group connected to a hub:** that hub's sessions, lessons, knowledge bases and teammates' lessons
+  only.
+- **Anywhere else:** Personal's only.
+- **In a waiting folder:** nothing. The MCP tools say the folder waits for you to choose.
+
+What is made from every project at once (the global playbook, glossary terms seen in another hub's projects, themes
+and weekly reviews) isn't shown to agents while you have another hub. The dashboard still shows everything.
+
+Lines Interlatch proposes for your user-level instruction files (`~/.claude/CLAUDE.md`, `~/.codex/AGENTS.md`), which
+agents read in every folder, come only from Personal's lessons. A lesson another hub's sessions taught is proposed for
+that project's own files instead ([Suggestions](suggestions.md)).
+
+## Commands
+
+| To | Run |
+| --- | --- |
+| List the hubs and their groups | `interlatch hubs` |
+| Add a hub, and join it | `interlatch hubs add <name> [<address> --code <code>] [--all-folders]` |
+| Remove a hub | `interlatch hubs remove <name> [--delete-data]` (leave it first: `interlatch --hub <name> hub leave`) |
+| List your groups and where each goes | `interlatch group list` |
+| Make a group, change its folders | `interlatch group create <name> --folder <folder>…`, `group add-folder` / `remove-folder <group> <folder>` |
+| Connect a group, or disconnect it | `interlatch group connect <group> <hub>`, `group disconnect <group>` |
+| Run a hub command for another hub | `interlatch --hub <name> hub …` / `push` / `config …` |
+
+`interlatch push` and the background job send to Personal's hub, then each other hub. Recording, analysis and the
+dashboard are Personal's: with `--hub`, only `hub`, `push` and `config` run.
+
+## Sharing with several hubs
+
+- **Knowledge only.** Every hub gets summaries and project lessons, never transcripts. A transcript upload would
+  carry every hub's sessions, so while you have another hub, Personal won't send transcripts:
+  `interlatch config set hub.share knowledge`.
+- **Each hub once.** Joining a hub that this computer already sends to is refused before anything is sent.
+- **Its own identity.** Each hub gets its own token and computer ID, so two hubs can't match this computer by its ID.
+  Each hub still shows the computer's name: change the name a hub sees in `~/.interlatch/profiles/<id>/machine.json`.
+- **Its own teammates.** Teammates' lessons a hub sends are kept for that hub, and agents see them only in its
+  folders. Leaving one hub (`interlatch --hub Acme hub leave`) removes only that hub's.
+- **Personal's hub** gets only Personal's sessions. The repositories and folders its hello names leave out what the
+  other hubs own.
+
+## Where it's kept
+
+`~/.interlatch/profiles.toml` lists the other hubs, the groups connected to each, the folders that follows from, and
+your choices. Only you can read it. If it can't be read, nothing is shared with any hub until it's fixed. Each hub
+also has a folder of its own, `~/.interlatch/profiles/<id>`, with its token, computer ID and sharing state.
+
+Personal's archive gets a `session_owner` table, the hub each session belongs to, once the first other hub is added.
+An archive without one is never changed.
+
+**From 0.28.1:** `interlatch profile` became `interlatch hubs` and `interlatch group`, and `--profile` is now `--hub`
+(the old name still works). Folders a profile was given with `--owns` stay that hub's.

{interlatch-0.28.0 → interlatch-0.28.2}/mkdocs.yml

@@ -75,6 +75,7 @@ nav:
       - Phone and other computers: devices.md
       - A hub in Docker: docker.md
       - Joining your team's hub: join-a-hub.md
+      - Several hubs on one computer: profiles.md
       - A copy in Postgres: postgres.md
   - Reference:
       - What gets recorded and how analysis works: analysis.md
@@ -97,6 +98,7 @@ nav:
       - スマートフォンとほかのコンピューター: ja/devices.md
       - Docker でハブを動かす: ja/docker.md
       - チームのハブに参加する: ja/join-a-hub.md
+      - 1 台のコンピューターで複数のハブ: ja/profiles.md
       - Postgres へのコピー: ja/postgres.md
       - 記録される内容と分析の仕組み: ja/analysis.md
       - 設定: ja/configuration.md

{interlatch-0.28.0 → interlatch-0.28.2}/src/interlatch/analysis/queue.py

@@ -10,7 +10,7 @@ from ..core.i18n import tr
 from ..core.util import local_str, one_line, parse_ts, to_iso, utcnow
 from ..storage.kv import kv_get
 from .runners.base import Runner
-from .runners.factory import make_runner
+from .runners.factory import OFF, make_runner
 
 PAUSE_KEY = "analysis_paused_until"
 
@@ -91,6 +91,8 @@ def queue_block(conn, cfg: Config, runner: Runner | None = None) -> str | None:
     paused = kv_get(conn, PAUSE_KEY)
     if paused and paused > to_iso(utcnow()):
         return tr("analysis is paused until {when} (usage limit); it resumes by itself", when=local_str(paused, "%m-%d %H:%M"))
+    if cfg.analysis.backend == OFF:
+        return tr("analysis is off (record only): pick an analyzer in Status › Analysis to analyze sessions")
     if not cfg.analysis.auto:
         return tr("automatic analysis is off (analysis.auto); analyze it from its page or with `interlatch analyze`")
     runner = runner or make_runner(cfg)

{interlatch-0.28.0 → interlatch-0.28.2}/src/interlatch/analysis/runners/base.py

@@ -1,5 +1,5 @@
-"""Run a headless coding agent with structured output: Claude Code (`claude -p`), Codex (`codex exec`) or IBM Bob;
-or, through api.py, a model provider's API.
+"""Run a headless coding agent with structured output: Claude Code (`claude -p`), Codex (`codex exec`), IBM Bob or
+OpenCode (`opencode run`); or, through api.py, a model provider's API. Or nothing: backend "none" only records.
 
 Agent runs use the developer's own install and login of the chosen agent (`analysis.backend`).
 Each call is isolated: no session is persisted (so analyses never show up as sessions), user hooks,
@@ -63,6 +63,10 @@ LIMIT_MARKERS = (
     "refresh token",
     "log in again",
 )
+# An agent whose tools are all off can still write a tool call into its reply (Bob, OpenCode): saying so up front makes
+# that rare.
+NO_TOOLS = ("You have no tools here: don't call or write one (no list_files, read_file or the like). Everything you "
+            "need is in the message; answer it directly.")
 
 
 class Runner: