interlatch 0.29.2__tar.gz → 0.29.4__tar.gz

{interlatch-0.29.2 → interlatch-0.29.4}/.pre-commit-config.yaml

@@ -42,7 +42,7 @@ repos:
   - repo: local
     hooks:
       - id: node-check
-        name: node --check (dashboard and VS Code extension JavaScript parses)
+        name: node --check (dashboard, VS Code and browser extension JavaScript parses)
         language: system
         entry: node --check
-        files: ^(src/interlatch/web|vscode-extension)/.*\.js$
+        files: ^(src/interlatch/web|src/interlatch/browser_extension|vscode-extension)/.*\.js$

{interlatch-0.29.2 → interlatch-0.29.4}/CHANGELOG.md

@@ -3,6 +3,26 @@
 <!-- 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.29.3 (2026-10-29)
+
+- **Analysis usage on every page:** the status bar shows your Claude plan's session (5hr) and weekly (7 day) usage, as
+  Claude Code names them, and what analysis spent today. Click it to see what's left and when each resets, this month's
+  and all-time spend, and to set the analysis limits: sessions per run, the budget per call, and a new cap that pauses
+  automatic analysis at a percent of your plan limit ([Configuration](docs/configuration.md)).
+
+## 0.29.2 (2026-10-29)
+
+- **A project's page on a team hub:** the team's knowledge leads. Each knowledge base entry and lesson names whose
+  sessions taught it, lessons two people found separately sit side by side, **Since your last visit** lists new and
+  replaced lessons, **Start here** greets someone new to the project, **People** shows who has worked on what (never
+  a count per person), and **Who's working on it** draws each person's sessions over eight weeks. Tokens and cost
+  move to an admin-only Usage tab, and the Systems map is no longer offered where it would be empty or refused
+  ([On a team hub](docs/dashboard.md#on-a-team-hub)).
+- **A project's glossary and mindmap on a team hub:** a project's page there has a **Glossary & map** tab: its terms
+  as a list or a mindmap. Teammates limited to some projects now see it too, with the terms their projects use and
+  what their projects say of them, never what another project wrote
+  ([On a team hub](docs/dashboard.md#on-a-team-hub)).
+
 ## 0.29.1 (2026-10-25)
 
 - **The interview, your job goal's final boss:** three questions a day, written from the job description and from

{interlatch-0.29.2 → interlatch-0.29.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: interlatch
-Version: 0.29.2
+Version: 0.29.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.29.4/changelog.d/browser-extension.md

@@ -0,0 +1,4 @@
+- **claude.ai and ChatGPT chats, saved as you use the sites:** a browser extension for Chrome, Edge and Brave sends
+  your chats to the dashboard while a claude.ai or chatgpt.com tab is open, so new chats need no new export. Chats in
+  ChatGPT projects keep their project's name. **Settings › Browser extension** walks you through installing it
+  ([Saving chats as you use the sites](docs/sources.md#saving-chats-as-you-use-the-sites)).

{interlatch-0.29.2 → interlatch-0.29.4}/docs/configuration.md

@@ -35,6 +35,7 @@ the file. Changes apply on the next sync or worker run. `INTERLATCH_HOME` reloca
 | `idle_minutes` | `20` | a session must have ended or been idle this long before it is analyzed |
 | `min_prompts` | `1` | sessions with fewer human prompts are skipped |
 | `max_per_run` / `concurrency` | `6` / `2` | analyses per 15-minute run, and parallel analysis processes |
+| `plan_limit_pct` | `0` | pause automatic analysis while your Claude plan's session (5hr) or weekly (7 day) limit is at or above this percent (Claude Code as the analyzer, with the status-line collector); `0` never pauses. Set it, and the limits above, from the usage chip in the dashboard's status bar |
 | `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 |

{interlatch-0.29.2 → interlatch-0.29.4}/docs/ja/configuration.md

@@ -35,6 +35,7 @@
 | `idle_minutes` | `20` | 分析されるには、セッションが終了しているか、この時間アイドルである必要があります |
 | `min_prompts` | `1` | 人間のプロンプトがこれより少ないセッションはスキップされます |
 | `max_per_run` / `concurrency` | `6` / `2` | 15 分ごとの実行 1 回あたりの分析数と、並列に動かす分析プロセスの数 |
+| `plan_limit_pct` | `0` | Claude プランのセッション（5 時間）または週間（7 日）の上限がこの割合以上のあいだ、自動分析を止めます（分析エンジンが Claude Code で、ステータスラインの収集があるとき）。`0` は止めません。これと上の上限は、ダッシュボードのステータスバーの使用量から設定できます |
 | `backfill` | `true` | インストール前に記録されたセッションも分析する（新しい順） |
 | `chunk_chars` | `150000` | 1 回の呼び出しに渡す、まとめたトランスクリプトの文字数。これより長いセッションは map-reduce で処理します |
 | `timeout_seconds` | `900` | 呼び出し 1 回あたりの実時間の上限 |

{interlatch-0.29.2 → interlatch-0.29.4}/docs/ja/privacy.md

@@ -22,6 +22,8 @@ Interlatch の Firebase プロジェクトから、公開されている求人
 対戦は公開されたシートからあなたのコンピューターで計算されます。**アリーナを出る**（またはボードから抜ける）とシートは削除されます
 （[アリーナ](party.md#アリーナ)）。
 claude.ai や ChatGPT のエクスポートを取り込むときはチャットだけを読み、アカウントのファイル（`users.json`、`user.json`）は開きません。
+ブラウザ拡張を読み込んだ場合、拡張は claude.ai と chatgpt.com のチャットだけをあなたのサインインで読み、このコンピューターの
+ダッシュボードにだけ送ります（[ソース](sources.md#ブラウザ拡張でチャットを保存する)）。
 提案した行が公開リポジトリに入る前に警告するため、GitHub のリモートがあるプロジェクトでは、あなた自身の `gh` のログインで
 `gh repo view` を実行します。GitHub に送るのはリポジトリの名前だけで、結果は 1 週間覚えておきます。`gh` が
 なければ何も送りません（[提案](suggestions.md#プライバシー)）。

{interlatch-0.29.2 → interlatch-0.29.4}/docs/ja/sources.md

@@ -75,13 +75,14 @@ IDE はそれ以外の会話ファイルをローカルに保存しません。
 接続すると `~/.config/opencode/opencode.json` に MCP サーバーが登録されます（OpenCode はこれを `opencode.jsonc` と
 合わせて読みます。`opencode.jsonc` は書き換えません）。
 
-**claude.ai と ChatGPT のチャット**は Mac に保存されないため、データのエクスポートから取り込みます。claude.ai は
+**claude.ai と ChatGPT のチャット**は Mac に保存されません。ブラウザ拡張がサイトを使うたびに保存し
+（[下記](#ブラウザ拡張でチャットを保存する)）、それより前のチャットはデータのエクスポートから取り込みます。claude.ai は
 **設定 › プライバシー › データをエクスポート**、ChatGPT は **設定 › データコントロール › データをエクスポート** を開くと、届いたメールのリンクから
-`.zip` をダウンロードできます。Sources ページの **Import export…**（カード *Chat exports*）、または `interlatch import <zip>` で取り込みます
+`.zip` をダウンロードできます。Sources ページの **Import export…**（カード *Web chats*）、または `interlatch import <zip>` で取り込みます
 （展開したフォルダーや `conversations.json` も使えます）。どちらのサービスのものかは中身から判別します。各チャットはセッション（エージェント
 `claude-ai` または `chatgpt`、`source = claude-ai-export` または `chatgpt-export`）になり、プロンプト、応答、思考、ツール呼び出し
 （claude.ai のアーティファクト、ChatGPT の Python・ブラウズ・画像生成とその出力）、添付ファイルや画像の注記が入ります。claude.ai のプロジェクト内の
-チャットは `claude.ai/<プロジェクト>`、それ以外は `claude.ai`、ChatGPT のチャットは `chatgpt.com` にまとまります。ChatGPT のチャットは画面に表示される
+チャットは `claude.ai/<プロジェクト>`、それ以外は `claude.ai`、ChatGPT のチャットは `chatgpt.com`（ブラウザ拡張で保存したプロジェクト内のチャットは `chatgpt.com/<プロジェクト>`）にまとまります。ChatGPT のチャットは画面に表示される
 分岐に沿って読むため、編集前のプロンプトや再生成で切り替えた回答は含まれません。新しいエクスポートはいつでも取り込めます。新しいチャットと
 変更されたチャットだけが追加されます。読み込んでアーカイブするのはチャット（`conversations.json` と、プロジェクト名のための claude.ai の
 `projects.json`）だけで、アカウントのファイル（`users.json`、`user.json`）と ChatGPT の `chat.html` は開きません。
@@ -90,11 +91,39 @@ IDE はそれ以外の会話ファイルをローカルに保存しません。
 エクスポートにはトークン数がないため、費用は表示されません。Claude Code on the web のセッションは claude.ai のエクスポートに含まれません。
 `claude --teleport <id>` で Mac に通常の Claude Code のトランスクリプトとして取り込めます。
 
+### ブラウザ拡張でチャットを保存する
+
+ブラウザ拡張は、claude.ai と ChatGPT を使うたびにチャットを保存します。新しいチャットのために改めてエクスポートする必要はありません。
+Chrome、Edge、Brave などの Chromium 系ブラウザで動きます。Chrome ウェブストアにはないため、ダッシュボードが用意するフォルダーから読み込みます。
+
+ダッシュボードの **設定 › ブラウザ拡張** に、Chrome、Edge、Brave それぞれのインストール手順と、拡張がこれまでに送ったものが表示されます。要点は次のとおりです。
+
+1. `chrome://extensions`（Edge は `edge://extensions`）を開き、**デベロッパー モード**をオンにします。
+2. **パッケージ化されていない拡張機能を読み込む**で `~/.interlatch/browser-extension` を選びます（パスはそのページからコピーできます）。
+3. claude.ai か chatgpt.com を開きます。
+
+どちらかのサイトのタブが開いている間、拡張は前回から変わったチャットをサイトに問い合わせます（タブを開いたとき、5 分ごと、そしてチャットを離れて数秒後。別のチャットやタブ、アプリに移ったときで、1 分に 1 回まで）。
+変わったチャットをサイト自身のページと同じ方法で、あなたのサインインで読み、このコンピューターのダッシュボードに送ります。最初の同期は
+直近 30 日分です（拡張のポップアップで変えられます）。それより前のチャットはエクスポートから取り込みます。1 回の同期で読むのは 40 件までで、
+次の同期は 2 分後に続くため、数百件ある最初の同期には時間がかかります。サイトから速度を落とすよう求められたときは 10 分待ちます。
+一時チャットは含めません。ChatGPT のプロジェクト内のチャットは `chatgpt.com/<プロジェクト>` にまとまります。
+
+保存したチャットはエクスポートが更新するのと同じセッションで、同じように保存・アーカイブされます（最新のコピーは
+`archive/<claude-ai|chatgpt>/captured/<id>/`）。取り込んだチャットと同じく**自動では分析しません**。選別して（下記）価値のあるものを
+分析待ちに入れるか、チャットを開いて **Analyze now** を選びます。
+
+拡張のツールバーボタンには、ダッシュボードにつながっているか、サイトごとの最後の同期とエラーが表示され、**Sync now**、**Paused**、
+ダッシュボードのポート（`[server] port` を変えていなければ 11524）、最初の同期でさかのぼる日数を設定できます。読むのは claude.ai と
+chatgpt.com だけで、送り先は `http://127.0.0.1` だけです。ダッシュボードは、Web ページが送れないヘッダーを付けた、このコンピューターからの
+チャットだけを受け付けます。拡張は公開 API ではなくサイトの内部エンドポイントを使うため、サイトが変更すると、Interlatch の更新で対応するまで
+ツールバーボタンにエラーが表示されます。Interlatch を更新するとダッシュボードがフォルダーを更新し、Chrome は再起動時（または
+`chrome://extensions` の再読み込みボタン）に新しいバージョンを読み込みます。
+
 ### 取り込んだチャットの選別
 
 チャット履歴の大半は、調べもの、文章の書き直し、日常の質問で、分析しても何も残りません。選別はチャットを
 **分析する価値あり**（worth analyzing）、**たぶん**（maybe）、**価値なし**（not worth it）に分け、それぞれにトピックと
-一行の理由を付けます。これで分析を役に立つチャットに回せます。エクスポートのカード（Sources › Chat exports）で
+一行の理由を付けます。これで分析を役に立つチャットに回せます。エクスポートのカード（Sources › Web chats）で
 **Screen N chats** を選ぶか、`interlatch screen` を実行します（`--sample 200` でまず無作為の 200 件で試す、
 `--dry-run` は件数を数えるだけ）。
 

{interlatch-0.29.2 → interlatch-0.29.4}/docs/privacy.md

@@ -24,6 +24,8 @@ levels, and the team you field (which agents, in what order), with your board na
 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`).
+The browser extension, if you load it, reads chats only on claude.ai and chatgpt.com, with your own sign-in, and sends
+them only to the dashboard on this computer ([Sources](sources.md#saving-chats-as-you-use-the-sites)).
 To warn before a suggested line lands in a public repository, Interlatch runs `gh repo view` with your own `gh` login
 for projects with a GitHub remote; that sends GitHub the repository's name and nothing else, and the answer is
 remembered for a week. Without `gh` nothing is sent ([Suggestions](suggestions.md#privacy)).

{interlatch-0.29.2 → interlatch-0.29.4}/docs/sources.md

@@ -80,15 +80,16 @@ into the database, which it does on its first start. OpenCode has no session-end
 by the 15-minute sync. Connecting registers the MCP server in `~/.config/opencode/opencode.json` (OpenCode merges it
 with `opencode.jsonc`, which is never rewritten).
 
-**Chats on claude.ai and ChatGPT** are not stored on your Mac, so they come in from a data export: on claude.ai,
+**Chats on claude.ai and ChatGPT** are not stored on your Mac. The browser extension saves them as you use the sites
+([below](#saving-chats-as-you-use-the-sites)); older chats come in from a data export: on claude.ai,
 **Settings › Privacy › Export data**; on ChatGPT, **Settings › Data controls › Export data**. The email's link
-downloads a `.zip`. Import it with **Import export…** on the Sources page (card *Chat exports*), or
+downloads a `.zip`. Import it with **Import export…** on the Sources page (card *Web chats*), or
 `interlatch import <zip>` (the unpacked folder or `conversations.json` work too); which service it came from is
 recognized from its contents. Each chat becomes a session (agent `claude-ai` or `chatgpt`, `source =
 claude-ai-export` or `chatgpt-export`) with its prompts, replies, thinking, tool calls (claude.ai artifacts,
 ChatGPT's Python, browsing and image steps, with their output) and notes of attached files and images. claude.ai
 chats in a project are grouped under `claude.ai/<project>`, the rest under `claude.ai`; ChatGPT chats under
-`chatgpt.com`. A ChatGPT chat is read along the branch ChatGPT shows, so edited prompts and regenerated answers you
+`chatgpt.com` (or `chatgpt.com/<project>`, when the browser extension saved it). A ChatGPT chat is read along the branch ChatGPT shows, so edited prompts and regenerated answers you
 moved away from are left out. Import a newer export any time: new and changed chats are added, unchanged ones
 skipped. Only the chats are read and archived (`conversations.json`, and claude.ai's `projects.json` for project
 names); the account files (`users.json`, `user.json`) and ChatGPT's `chat.html` are never opened, and a zip uploaded
@@ -99,11 +100,44 @@ choose **Analyze now**, or import with `--analyze` to queue them all. The export
 no cost. Claude Code on the web sessions are not in the claude.ai export; `claude --teleport <id>` brings one onto your
 Mac as an ordinary Claude Code transcript. Codex Cloud tasks are a separate source (above).
 
+### Saving chats as you use the sites
+
+The browser extension saves claude.ai and ChatGPT chats as you use the sites, so new chats need no new export. It
+works in Chrome, Edge, Brave and other Chromium browsers. It isn't in the Chrome Web Store: you load it from a folder
+the dashboard keeps for it.
+
+**Settings › Browser extension** in the dashboard walks you through it, for Chrome, Edge or Brave, and shows what the
+extension has sent so far. In short:
+
+1. Open `chrome://extensions` (Edge: `edge://extensions`) and turn on **Developer mode**.
+2. Choose **Load unpacked** and pick `~/.interlatch/browser-extension` (the page has the path to copy).
+3. Open claude.ai or chatgpt.com.
+
+While a tab of either site is open, the extension asks the site which chats changed since it last looked: when the
+tab loads, every 5 minutes, and a few seconds after you leave a chat (for another chat, tab or app; at most once a
+minute). It reads each changed chat the way the site's own page does, with your sign-in, and
+sends it to the dashboard on this computer. The first sync goes back 30 days (change it in the extension's popup);
+older chats come in from an export. A sync reads at most 40 chats and the next follows two minutes later, so a first
+sync of a few hundred chats takes a while; when a site asks it to slow down, it waits ten minutes. Temporary chats
+are left out. Chats in a ChatGPT project are grouped under `chatgpt.com/<project>`.
+
+A saved chat is the same session an export updates, stored and archived the same way (its latest copy in
+`archive/<claude-ai|chatgpt>/captured/<id>/`). Like imported chats, saved chats are **not analyzed automatically**:
+screen them (below) and queue the ones worth it, or choose **Analyze now** on one.
+
+The extension's toolbar button shows whether it reaches the dashboard, each site's last sync and any error, with
+**Sync now**, **Paused**, the dashboard's port (11524 unless you changed `[server] port`) and how far back the first
+sync goes. It reads only claude.ai and chatgpt.com and sends only to `http://127.0.0.1`. The dashboard takes chats
+only from this computer, with a header no web page can send. The extension uses the sites' internal endpoints, not a
+published API: when a site changes them, the toolbar button shows the error until an Interlatch update catches up.
+After an Interlatch update the dashboard refreshes the folder, and Chrome loads the new version when it restarts (or
+with the reload button on `chrome://extensions`).
+
 ### Screening imported chats
 
 Most of a chat history is lookups, rewrites and everyday questions that analysis would turn into nothing. Screening
 sorts the chats into **worth analyzing**, **maybe** and **not worth it**, with a topic and a one-line reason each,
-so the analysis goes where it pays. Choose **Screen N chats** on the export's card (Sources › Chat exports), or run
+so the analysis goes where it pays. Choose **Screen N chats** on the export's card (Sources › Web chats), or run
 `interlatch screen` (`--sample 200` tries it on a random 200 first, `--dry-run` only counts).
 
 - It reads only each chat's opening: title, date, the first and last prompt and the start of the first reply,

{interlatch-0.29.2 → interlatch-0.29.4}/packaging/macos/Interlatch.spec

@@ -21,6 +21,7 @@ a = Analysis(
     # the package metadata carries the version (interlatch.__version__ reads it); the Party reads its roadmap catalog,
     # and the job-market numbers it shows until Firebase answers
     datas=[(str(ROOT / "src" / "interlatch" / "web"), "interlatch/web"),
+           (str(ROOT / "src" / "interlatch" / "browser_extension"), "interlatch/browser_extension"),
            (str(ROOT / "src" / "interlatch" / "knowledge" / "roadmap.json"), "interlatch/knowledge"),
            (str(ROOT / "src" / "interlatch" / "knowledge" / "market.json"), "interlatch/knowledge")]
           + copy_metadata("interlatch"),

{interlatch-0.29.2 → interlatch-0.29.4}/src/interlatch/analysis/queue.py

@@ -95,12 +95,36 @@ def queue_block(conn, cfg: Config, runner: Runner | None = None) -> str | None:
         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`")
+    over = plan_over_limit(conn, cfg)
+    if over:
+        return tr("your Claude plan's {window} limit is at {pct}%, at or above the {cap}% you set; it resumes after {when}",
+                  window=tr(WINDOW_LABEL.get(over["window"], over["window"])), pct=round(over["used_pct"]),
+                  cap=cfg.analysis.plan_limit_pct, when=local_str(over["resets_at"], "%m-%d %H:%M"))
     runner = runner or make_runner(cfg)
     if not runner.available():
         return tr("{reason}, so nothing can be analyzed", reason=runner.unavailable_reason())
     return None
 
 
+WINDOW_LABEL = {"five_hour": "session (5hr)", "seven_day": "weekly (7 day)", "spend_limit": "spend"}  # Claude Code's names
+
+
+def plan_over_limit(conn, cfg: Config) -> dict | None:
+    """The Claude plan window (statusline.py) at or above analysis.plan_limit_pct, while Claude Code analyzes: its
+    name, used_pct and resets_at. None when the cap is off, another analyzer runs, or no window is that full."""
+    cap = cfg.analysis.plan_limit_pct
+    if not cap or cap <= 0 or cfg.analysis.backend != "claude":
+        return None
+    from ..runtime.statusline import plan_usage
+
+    windows = (plan_usage(conn) or {}).get("limits") or {}
+    over = [(name, w) for name, w in windows.items() if name in WINDOW_LABEL and (w.get("used_pct") or 0) >= cap]
+    if not over:
+        return None
+    name, w = max(over, key=lambda x: x[1]["resets_at"])  # the one that frees up last
+    return {"window": name, "used_pct": w["used_pct"], "resets_at": w["resets_at"]}
+
+
 def count_pending(conn, cfg: Config) -> dict:
     """The analysis queue: `ready` now, `queued` (everything that will be analyzed by itself, ready included),
     `held` (needs a change first), each with a count per reason, and `block` when the whole queue is stopped."""

{interlatch-0.29.2 → interlatch-0.29.4}/src/interlatch/application/workflows.py

@@ -9,7 +9,7 @@ import sqlite3
 from collections.abc import Callable
 from datetime import timedelta
 
-from ..analysis.queue import PAUSE_KEY, pending_sessions
+from ..analysis.queue import PAUSE_KEY, pending_sessions, plan_over_limit
 from ..analysis.runners.base import LLMError, Runner, UsageLimitError
 from ..analysis.runners.factory import make_runner
 from ..analysis.worker import WorkReport, analyze_many
@@ -92,7 +92,12 @@ def _run_locked(cfg: Config, conn, report: WorkReport, *, session_ids, max_analy
     conn.commit()
     runner = make_runner(cfg)
     paused = kv_get(conn, PAUSE_KEY)
-    if analyze and (cfg.analysis.auto or session_ids or force):
+    # at the plan limit the user set (analysis.plan_limit_pct): runs on their own wait; sessions asked for still run
+    capped = None if session_ids or force else plan_over_limit(conn, cfg)
+    if capped:
+        report.note = (f"Claude plan's {capped['window']} limit at {capped['used_pct']:.0f}% "
+                       f"(analysis.plan_limit_pct = {cfg.analysis.plan_limit_pct}); analysis skipped")
+    if analyze and not capped and (cfg.analysis.auto or session_ids or force):
         if paused and paused > to_iso(utcnow()) and not session_ids:
             report.paused_until = paused
         elif not runner.available():
@@ -102,9 +107,9 @@ def _run_locked(cfg: Config, conn, report: WorkReport, *, session_ids, max_analy
             analyze_many(cfg, ids, runner, report, model=model, progress=progress)
     auto = cfg.synthesis.auto or force
     # the projects and groups whose weekly re-analysis is due: someone turned each on, so they run without [synthesis] auto
-    due = (_weekly_due(cfg, conn) if synthesize and not session_ids and runner.available() and not report.paused_until
-           and not (paused and paused > to_iso(utcnow())) else [])
-    if synthesize and (auto or due) and runner.available() and not report.paused_until:
+    due = (_weekly_due(cfg, conn) if synthesize and not session_ids and not capped and runner.available()
+           and not report.paused_until and not (paused and paused > to_iso(utcnow())) else [])
+    if synthesize and not capped and (auto or due) and runner.available() and not report.paused_until:
         _synthesize(cfg, conn, runner, report, force=force, auto=auto, also=_weekly_projects(cfg, conn, due),
                     progress=progress)
         _glossaries(cfg, conn, runner, report, progress=progress)

interlatch-0.29.4/src/interlatch/browser_extension/background.js

@@ -0,0 +1,58 @@
+/* Interlatch: save web chats. The service worker: the one part that talks to the dashboard on this computer.
+
+capture.js runs in claude.ai and chatgpt.com tabs and reads the chats there; a page on https can't call
+http://127.0.0.1, so it hands each chat here and this sends it to POST /api/capture (the dashboard's
+chat_import.capture). The dashboard takes it only from this computer, with the X-Interlatch header no web page can
+send it. */
+"use strict";
+
+const DEFAULT_PORT = 11524;
+
+async function dashboard() {
+  const { port } = await chrome.storage.local.get("port");
+  return `http://127.0.0.1:${Number(port) || DEFAULT_PORT}`;
+}
+
+async function send(format, conversation) {
+  const base = await dashboard();
+  let res;
+  try {
+    res = await fetch(`${base}/api/capture`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Interlatch": "1" },
+      body: JSON.stringify({ format, conversation }),
+    });
+  } catch {
+    return { ok: false, retry: true, error: `the Interlatch dashboard is not running at ${base}` };
+  }
+  const body = await res.json().catch(() => ({}));
+  if (res.ok) return { ok: true, ...body };
+  // only 400 is about the chat itself (not one the dashboard can read), so it isn't sent again until it changes; the
+  // rest is the dashboard's: 409 a sync holds the archive, 404 a version without /api/capture, 403 not this computer's
+  if (res.status === 404) return { ok: false, retry: true, error: "update Interlatch: this dashboard can't take chats yet" };
+  return { ok: false, retry: res.status !== 400, error: body.error || `the dashboard answered ${res.status}` };
+}
+
+async function status() {
+  const base = await dashboard();
+  try {
+    const res = await fetch(`${base}/api/me`, { headers: { "X-Interlatch": "1" } });
+    const me = await res.json();
+    if (!res.ok) return { base, ok: false, error: me.error || `answered ${res.status}` };
+    return { base, ok: me.viewer?.here !== false, error: me.viewer?.here === false ? "not this computer's dashboard" : null };
+  } catch {
+    return { base, ok: false, error: "not running" };
+  }
+}
+
+chrome.runtime.onMessage.addListener((msg, sender, reply) => {
+  if (msg?.type === "capture" && sender.tab) {
+    send(msg.format, msg.conversation).then(reply);
+    return true;
+  }
+  if (msg?.type === "status" && !sender.tab) {
+    status().then(reply);
+    return true;
+  }
+  return false;
+});

interlatch-0.29.4/src/interlatch/browser_extension/capture.js

@@ -0,0 +1,202 @@
+/* Interlatch: save web chats. Runs in claude.ai and chatgpt.com tabs.
+
+While a tab of the site is open (on load, then every few minutes), it asks the site's own conversation list which
+chats changed since the last sync, reads each one the way the site's page does (same origin, your own sign-in), and
+hands it to background.js for the dashboard. A chat is read in the JSON a data export holds, so the dashboard stores
+it as an import would, as the same session. The first sync goes back `days` (30 by default); older chats come in from a
+data export. Temporary chats are left out. A sync reads at most MAX chats and the next one follows a few minutes
+later, so a first sync with many chats doesn't run into the site's rate limit; when the site asks to slow down anyway
+(429), the sync waits longer.
+
+These are the sites' internal endpoints, not a published API: if a site changes them, the popup shows the error. */
+"use strict";
+
+(() => {
+  const SITE = { "claude.ai": "claude-ai", "chatgpt.com": "chatgpt" }[location.hostname];
+  if (!SITE) return;
+  const KEY = `sync:${SITE}`;
+  const LOCK = `lock:${SITE}`; // one tab syncs a site at a time
+  const EVERY = 5 * 60e3;
+  const PAUSE = 700; // between two chats read: the pace of someone clicking through them
+  const MAX = 40; // chats read in one sync: ChatGPT answered 429 after about 200 in a row
+  const AGAIN = 2 * 60e3; // the next sync, when this one stopped at MAX
+  const SLOWED = 10 * 60e3; // the next sync, after a 429
+  const SOON_DELAY = 5e3; // after you leave a chat: the site has saved its last reply by then
+  const SOON_GAP = 60e3;
+  const MARGIN = 10 * 60e3; // the next sync looks this far before the last one began
+  const STALE_LOCK = 15 * 60e3;
+  const DEFAULT_DAYS = 30;
+  const DAY = 86400e3;
+
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  const time = (v) => { // an ISO date, or seconds (ChatGPT) or milliseconds since 1970
+    const n = typeof v === "number" ? v : v !== "" && v != null && !isNaN(Number(v)) ? Number(v) : NaN;
+    return isNaN(n) ? Date.parse(v) || 0 : n < 1e12 ? n * 1000 : n;
+  };
+
+  async function getJSON(path, headers) {
+    const res = await fetch(path, { credentials: "include", headers });
+    if (!res.ok) {
+      throw Object.assign(new Error(`${location.hostname}${path.split("?")[0]} answered ${res.status}`), { status: res.status });
+    }
+    return res.json();
+  }
+
+  // Each site: the chats changed since `since` (ms), newest first, and one chat as its data export holds it.
+  const claude = {
+    async *changed(since) {
+      const orgs = await getJSON("/api/organizations");
+      for (const org of Array.isArray(orgs) ? orgs : []) {
+        if (Array.isArray(org.capabilities) && !org.capabilities.includes("chat")) continue; // an API-only organization
+        for (let offset = 0; ; offset += 50) {
+          const page = await getJSON(`/api/organizations/${org.uuid}/chat_conversations?limit=50&offset=${offset}`);
+          if (!Array.isArray(page) || !page.length) break;
+          let older = false;
+          for (const c of page) {
+            if (time(c.updated_at) < since) { older = true; continue; }
+            if (!c.is_temporary) yield { id: c.uuid, updated: c.updated_at, org: org.uuid, item: c };
+          }
+          if (older || page.length < 50) break;
+        }
+      }
+    },
+    async read(it) {
+      const conv = await getJSON(
+        `/api/organizations/${it.org}/chat_conversations/${it.id}?tree=True&rendering_mode=messages&render_all_tools=true`);
+      // the chat itself doesn't name its project; the list does
+      if (it.item.project && !conv.project) conv.project = it.item.project;
+      if (it.item.project_uuid && !conv.project_uuid) conv.project_uuid = it.item.project_uuid;
+      return conv;
+    },
+  };
+
+  const chatgpt = {
+    token: null,
+    async headers() {
+      if (!this.token) {
+        const session = await getJSON("/api/auth/session");
+        if (!session.accessToken) throw new Error("not signed in to ChatGPT");
+        this.token = session.accessToken;
+      }
+      const device = document.cookie.match(/(?:^|; )oai-did=([^;]+)/)?.[1];
+      return { Authorization: `Bearer ${this.token}`, ...(device ? { "oai-device-id": decodeURIComponent(device) } : {}) };
+    },
+    async *listed(path, since, project) {
+      const h = await this.headers();
+      for (let offset = 0; ; offset += 28) {
+        const page = await getJSON(`${path}offset=${offset}&limit=28&order=updated`, h);
+        const items = page.items || [];
+        let older = false;
+        for (const c of items) {
+          if (time(c.update_time) < since) { older = true; continue; }
+          if (!c.is_temporary_chat) yield { id: c.id, updated: String(c.update_time), project };
+        }
+        if (older || items.length < 28) break;
+      }
+    },
+    async *changed(since) {
+      this.token = null; // a fresh one each sync: it expires
+      yield* this.listed("/backend-api/conversations?", since, null);
+      // chats in a ChatGPT project are not in that list: each project lists its own, newest first
+      const h = await this.headers();
+      let cursor = null;
+      do {
+        const side = await getJSON(`/backend-api/gizmos/snorlax/sidebar?conversations_per_gizmo=0${
+          cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`, h);
+        const items = side.items || [];
+        for (const g of items) {
+          const giz = g.gizmo?.gizmo || g.gizmo || {};
+          if (!giz.id) continue;
+          const project = { id: giz.id, name: giz.display?.name || "" };
+          for (let c = "0"; c != null;) {
+            const page = await getJSON(`/backend-api/gizmos/${giz.id}/conversations?cursor=${encodeURIComponent(c)}`, h);
+            let older = false;
+            for (const conv of page.items || []) {
+              if (time(conv.update_time) < since) { older = true; continue; }
+              yield { id: conv.id, updated: String(conv.update_time), project };
+            }
+            c = older || !(page.items || []).length ? null : page.cursor ?? null;
+          }
+        }
+        cursor = items.length ? side.cursor : null;
+      } while (cursor);
+    },
+    async read(it) {
+      const conv = await getJSON(`/backend-api/conversation/${it.id}`, await this.headers());
+      if (it.project) conv.project = it.project;
+      return conv;
+    },
+  };
+
+  const site = SITE === "claude-ai" ? claude : chatgpt;
+  let running = false;
+
+  async function sync() {
+    if (running) return;
+    running = true;
+    try {
+      const { [KEY]: saved, [LOCK]: lock, days, paused } = await chrome.storage.local.get([KEY, LOCK, "days", "paused"]);
+      const started = Date.now();
+      if (paused || (lock && started - lock < STALE_LOCK)) return;
+      await chrome.storage.local.set({ [LOCK]: started });
+      const state = { seen: {}, captured: 0, ...saved, running: started, progress: 0 }; // the popup shows the progress
+      await chrome.storage.local.set({ [KEY]: state });
+      const since = state.since ? state.since - MARGIN : started - (Number(days) || DEFAULT_DAYS) * DAY;
+      let sent = 0, read = 0, error = null, more = false, slowed = false;
+      const done = new Set();
+      try {
+        for await (const it of site.changed(since)) {
+          if (done.has(it.id)) continue;
+          done.add(it.id);
+          if (state.seen[it.id] === it.updated) continue; // sent already, and not changed since
+          if (read++ >= MAX) { more = true; break; }
+          const conv = await site.read(it);
+          let r;
+          try {
+            r = await chrome.runtime.sendMessage({ type: "capture", format: SITE, conversation: conv });
+          } catch {
+            r = { retry: true, error: "the extension was reloaded: reload this tab" };
+          }
+          if (!r?.ok && r?.retry !== false) { error = r?.error || "could not reach the dashboard"; break; }
+          state.seen[it.id] = it.updated; // sent, or refused for good (not sent again until it changes)
+          if (r.ok && (r.result === "new" || r.result === "updated")) state.progress = ++sent;
+          if (!r.ok) state.refused = { at: Date.now(), error: r.error };
+          await chrome.storage.local.set({ [KEY]: state });
+          await sleep(PAUSE);
+        }
+      } catch (e) {
+        if (e?.status === 429) more = slowed = true;
+        else error = String(e?.message || e);
+      }
+      if (!error && !more) { // a later sync looks only from here; chats seen before that can't come up again unchanged
+        state.since = started;
+        for (const [id, updated] of Object.entries(state.seen)) if (time(updated) < started - MARGIN) delete state.seen[id];
+      }
+      Object.assign(state, { lastRun: Date.now(), error, more, slowed, running: null, captured: (state.captured || 0) + sent });
+      if (sent) state.lastSent = Date.now();
+      await chrome.storage.local.set({ [KEY]: state });
+      await chrome.storage.local.remove(LOCK);
+      if (more) setTimeout(sync, slowed ? SLOWED : AGAIN); // the rest, a little later
+    } finally {
+      running = false;
+    }
+  }
+
+  const here = () => chrome.storage.local.set({ [`alive:${SITE}`]: Date.now() }); // the popup knows a tab answers
+  here();
+  setTimeout(sync, 3000);
+  setInterval(sync, EVERY);
+  // the chat you were in, without waiting for the next 5 minutes: when you leave it for another chat (the sites
+  // change the address without loading a page) or for another tab or app; at most once a minute
+  let lastSoon = 0, path = location.pathname;
+  const soon = () => {
+    if (Date.now() - lastSoon < SOON_GAP) return;
+    lastSoon = Date.now();
+    setTimeout(sync, SOON_DELAY);
+  };
+  setInterval(() => { if (location.pathname !== path) { path = location.pathname; soon(); } }, 2000);
+  document.addEventListener("visibilitychange", () => { if (document.visibilityState === "hidden") soon(); });
+  chrome.storage.onChanged.addListener((changes) => { // Sync now, from the popup
+    if (changes.syncNow?.newValue) { here(); sync(); }
+  });
+})();

interlatch-0.29.4/src/interlatch/browser_extension/manifest.json

@@ -0,0 +1,18 @@
+{
+  "manifest_version": 3,
+  "name": "Interlatch: save web chats",
+  "version": "1.0.0",
+  "description": "Sends your claude.ai and ChatGPT chats to the Interlatch dashboard on this computer as you use the sites.",
+  "icons": { "16": "icon-16.png", "32": "icon-32.png", "48": "icon-48.png", "128": "icon-128.png" },
+  "action": {
+    "default_title": "Interlatch",
+    "default_popup": "popup.html",
+    "default_icon": { "16": "icon-16.png", "32": "icon-32.png" }
+  },
+  "background": { "service_worker": "background.js" },
+  "permissions": ["storage"],
+  "host_permissions": ["http://127.0.0.1/*"],
+  "content_scripts": [
+    { "matches": ["https://claude.ai/*", "https://chatgpt.com/*"], "js": ["capture.js"], "run_at": "document_idle" }
+  ]
+}