interlatch 0.29.2__tar.gz → 0.29.3__tar.gz

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

@@ -3,6 +3,19 @@
 <!-- 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.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.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: interlatch
-Version: 0.29.2
+Version: 0.29.3
 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.3/changelog.d/analysis-usage-footer.md

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

{interlatch-0.29.2 → interlatch-0.29.3}/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.3}/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.3}/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.3}/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.2 → interlatch-0.29.3}/src/interlatch/core/config.py

@@ -62,6 +62,9 @@ idle_minutes = 20
 min_prompts = 1
 # Max session analyses per worker run (the background job runs every 15 minutes).
 max_per_run = 6
+# Pause automatic analysis while your Claude plan's 5-hour or 7-day limit is at or above this percent (backend
+# "claude", needs `interlatch install --statusline`). 0 = never pause for it.
+plan_limit_pct = 0
 # Parallel analysis processes.
 concurrency = 2
 # Also analyze sessions recorded before Interlatch was installed (newest first, within max_per_run).
@@ -275,6 +278,7 @@ class AnalysisConfig:
     idle_minutes: int = 20
     min_prompts: int = 1
     max_per_run: int = 6
+    plan_limit_pct: int = 0  # pause automatic runs at this % of a Claude plan limit; 0 = off
     concurrency: int = 2
     backfill: bool = True
     chunk_chars: int = 150_000

{interlatch-0.29.2 → interlatch-0.29.3}/src/interlatch/core/i18n/ja.py

@@ -156,6 +156,9 @@ JA: dict[str, str] = {
         "準備完了：バックグラウンドの処理が次の実行（15 分ごと）で分析します",
     "ready to re-analyze: the session continued after it was analyzed": "再分析の準備完了：分析のあとにセッションが続きました",
     "analysis is paused until {when} (usage limit); it resumes by itself": "使用量の上限のため、分析は {when} まで一時停止しています。自動で再開します",
+    "your Claude plan's {window} limit is at {pct}%, at or above the {cap}% you set; it resumes after {when}":
+        "Claude プランの{window}の上限が {pct}% で、設定した {cap}% 以上です。{when} 以降に再開します",
+    "session (5hr)": "セッション（5 時間）", "weekly (7 day)": "週間（7 日）", "spend": "利用額",
     "automatic analysis is off (analysis.auto); analyze it from its page or with `interlatch analyze`":
         "自動分析がオフです（analysis.auto）。セッションのページか `interlatch analyze` で分析してください",
     "analysis is off (record only): pick an analyzer in Status › Analysis to analyze sessions":

{interlatch-0.29.2 → interlatch-0.29.3}/src/interlatch/interfaces/web/api/status.py

@@ -178,9 +178,59 @@ def status_small(ctx: Context, limited: bool = False) -> dict:
         "hub_url": ctx.cfg.hub_url or None,  # set on a computer that sends its sessions to a hub
         "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
+        "usage": analysis_usage(ctx),  # the status bar's usage chip and the limits it sets
     }
 
 
+def analysis_usage(ctx: Context) -> dict:
+    """What analysis has used (API-equivalent USD today, this month, all time; the Claude plan's windows from the status
+    line) and the limits set for it (analysis.max_per_run, max_budget_usd, plan_limit_pct)."""
+    from ....analysis.queue import plan_over_limit, queue_block
+    from ....runtime.install import statusline_installed
+    from ....runtime.statusline import plan_usage
+
+    a = ctx.cfg.analysis
+    day = datetime.now().astimezone().replace(hour=0, minute=0, second=0, microsecond=0)
+    today, month = to_iso(day), to_iso(day.replace(day=1))
+    row = ctx.conn.execute(
+        "SELECT COALESCE(SUM(CASE WHEN started_at >= ? THEN cost_usd END), 0), "
+        "COALESCE(SUM(CASE WHEN started_at >= ? THEN cost_usd END), 0), COALESCE(SUM(cost_usd), 0), "
+        "SUM(CASE WHEN started_at >= ? THEN 1 ELSE 0 END) FROM analyses", (today, month, today)).fetchone()
+    over = plan_over_limit(ctx.conn, ctx.cfg)
+    return {"spent": {"today": row[0], "month": row[1], "total": row[2]}, "calls_today": row[3] or 0,
+            "plan": plan_usage(ctx.conn), "plan_applies": a.backend == "claude", "over": over,
+            "collector": statusline_installed(ctx.cfg),  # without it no plan readings ever arrive
+            "block": queue_block(ctx.conn, ctx.cfg) if over else None,  # why the queue stopped, in the queue's words
+            "limits": {"max_per_run": a.max_per_run, "max_budget_usd": a.max_budget_usd, "plan_limit_pct": a.plan_limit_pct}}
+
+
+# what the status bar's usage panel may set, with the bounds a value must be in
+LIMITS = {"max_per_run": (int, 1, 100), "max_budget_usd": (float, 0.1, 100.0), "plan_limit_pct": (int, 0, 100)}
+
+
+def action_limits(ctx: Context, body: dict) -> dict:
+    """Save the analysis limits (LIMITS) the status bar's usage panel sets; returns the usage with them."""
+    from ....core.config import load_config, set_config_value
+
+    refused = []
+    for key, (kind, lo, hi) in LIMITS.items():
+        if key not in body:
+            continue
+        try:
+            v = kind(body[key])
+        except (TypeError, ValueError):
+            v = None
+        if v is None or isinstance(body[key], bool) or not lo <= v <= hi:
+            refused.append(key)
+            continue
+        set_config_value(ctx.cfg, "analysis", key, f"{v:.2f}" if kind is float else str(v))
+    ctx.cfg = load_config(ctx.cfg.home)
+    out = analysis_usage(ctx)
+    if refused:
+        out["error"] = tr("not saved: {keys}", keys=", ".join(refused))
+    return out
+
+
 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

{interlatch-0.29.2 → interlatch-0.29.3}/src/interlatch/interfaces/web/routes.py

@@ -478,6 +478,7 @@ POST: list[Route] = [
     Route("/api/analysis/backend", ANYONE,
           lambda h, ctx, m, b: h._json(api.settings.action_backend(ctx, str(b.get("backend") or "")))),
     Route("/api/analysis/agent", ANYONE, lambda h, ctx, m, b: h._json(api.settings.action_agent(ctx, _body(b)))),
+    Route("/api/analysis/limits", ANYONE, lambda h, ctx, m, b: h._json(api.status.action_limits(ctx, _body(b)))),
     # an API key, and where transcripts are sent
     Route("/api/analysis/provider", OWNER, lambda h, ctx, m, b: h._json(api.settings.action_provider(ctx, _body(b)))),
     Route("/api/analysis/provider/test", OWNER, lambda h, ctx, m, b: h._json(

{interlatch-0.29.2 → interlatch-0.29.3}/src/interlatch/web/app.css

@@ -1727,6 +1727,34 @@ table.data tr.picked:hover td { background: color-mix(in srgb, var(--accent) 11%
 #activity .act-mark.no { color: var(--critical-ink); }
 #activity .act-foot { display: flex; justify-content: space-between; align-items: center; gap: 8px; padding-top: 10px; border-top: 1px solid var(--grid); font-size: 12px; }
 :root[data-motion="off"] #activity, :root[data-motion="off"] #activity .act-bar i { animation: none; transition: none; } :root[data-motion="off"] #activity .act-bar.indeterminate i { left: 0; width: 100%; opacity: 0.4; }
+/* Analysis usage: what the status bar's usage chip opens: the plan's windows, analysis spend, and the limits */
+#usage-panel { position: fixed; left: 12px; bottom: 38px; z-index: 62; width: min(380px, calc(100vw - 24px)); max-height: min(75vh, 600px); overflow-y: auto;
+  padding: 12px 14px; border-radius: 6px; background: var(--glass-strong); color: var(--ink); font-size: 13px;
+  box-shadow: var(--glass-shadow), 0 10px 32px rgba(0, 0, 0, 0.16), inset 0 0 0 0.5px var(--glass-rim); animation: upd-in 0.18s ease-out; }
+#usage-panel .act-head { display: flex; align-items: center; justify-content: space-between; margin-bottom: 4px; font-size: 14px; }
+#usage-panel .un-close { border: 0; background: transparent; color: var(--muted); font-size: 17px; line-height: 1; padding: 2px 5px; border-radius: 6px; cursor: pointer; }
+#usage-panel .un-close:hover { background: var(--hover); color: var(--ink); }
+#usage-panel .subhead { margin: 12px 0 6px; }
+#usage-panel .warn-line { margin: 6px 0 0; font-size: 12.5px; }
+#usage-panel .us-wins { display: grid; gap: 10px; }
+#usage-panel .us-top { display: flex; justify-content: space-between; gap: 10px; font-variant-numeric: tabular-nums; }
+#usage-panel .us-bar { position: relative; height: 6px; margin-top: 6px; border-radius: 3px; background: var(--surface-3); }
+#usage-panel .us-bar i { position: absolute; inset: 0 auto 0 0; border-radius: 3px; background: var(--accent); }
+#usage-panel .us-bar.over i { background: var(--warning); }
+#usage-panel .us-bar u { position: absolute; top: -3px; bottom: -3px; width: 2px; margin-left: -1px; border-radius: 1px; background: var(--ink-2); }
+#usage-panel .us-note { font-size: 12px; }
+#usage-panel .us-win .us-note { margin-top: 4px; }
+#usage-panel .us-facts { display: grid; grid-template-columns: repeat(3, 1fr); gap: 8px; }
+#usage-panel .us-facts .fact { display: grid; gap: 1px; }
+#usage-panel .us-facts b { font-size: 15px; font-variant-numeric: tabular-nums; }
+#usage-panel .us-facts span { font-size: 11.5px; color: var(--muted); }
+#usage-panel .us-form { display: grid; grid-template-columns: 1fr 1fr; gap: 10px 12px; align-items: start; }
+#usage-panel .us-form label { display: grid; gap: 3px; font-size: 12px; color: var(--ink-2); }
+#usage-panel .us-form label:nth-child(3) { grid-column: 1 / -1; }
+#usage-panel .us-form small { font-size: 11px; }
+#usage-panel .us-form .input { width: 100%; }
+#usage-panel .us-save { grid-column: 1 / -1; display: flex; justify-content: flex-end; }
+:root[data-motion="off"] #usage-panel { animation: none; }
 
 /* Export: a small menu of formats under (or, in the selection bar, above) its button */
 details.menu { position: relative; }

{interlatch-0.29.2 → interlatch-0.29.3}/src/interlatch/web/app.js

@@ -9117,6 +9117,7 @@ async function pollStatus() {
       : st.last_sync ? t("Synced {ago}", { ago: ago(st.last_sync) }) : t("Not synced yet");
     $("#status-version").textContent = st.version ? `Interlatch ${st.version}` : "";
     showHubProblem(st.hub_problem);
+    showUsage(st);
     showUpdate(st.update, st.version);
     pollUnseen();
     pollNews();
@@ -9185,6 +9186,7 @@ function toggleActivity(force) {
   const open = force ?? box.hidden;
   box.hidden = !open;
   $("#status-pill").setAttribute("aria-expanded", String(open));
+  if (open && !$("#usage-panel").hidden) toggleUsage(false);
   if (open) { if (lastStatus) drawActivity(lastStatus); pollStatus(); }
 }
 function drawActivity(st) {
@@ -9241,6 +9243,86 @@ function showHubProblem(pb) {
   chip.dataset.page = `#/hub?name=${encodeURIComponent(pb.profile || "personal")}`;
   chip.title = `${hubProblemTitle(pb)} · ${t("since {time}", { time: fmtDT(pb.since) })}`;
 }
+// Analysis usage on every page: a chip in the status bar (the Claude plan's windows, what analysis spent today) that
+// opens a panel with the detail and the limits analysis runs under (analysis_usage, action_limits)
+// named as Claude Code's own Account & usage panel names them
+const PLAN_SHORT = { five_hour: t("Session"), seven_day: t("Weekly"), spend_limit: t("spend") };
+const PLAN_NAME = { five_hour: t("Session (5hr)"), seven_day: t("Weekly (7 day)"), spend_limit: t("Spend limit") };
+const PLAN_CAPS = [0, 50, 60, 70, 80, 90, 95];
+function showUsage(st) {
+  const chip = $("#status-usage"), u = st.usage;
+  chip.hidden = !u || st.limited;
+  if (chip.hidden) return;
+  const cap = u.plan_applies ? u.limits.plan_limit_pct : 0;
+  const wins = Object.entries(u.plan?.limits || {}).map(([k, v]) => `${PLAN_SHORT[k] || k} ${Math.round(v.used_pct)}%`);
+  chip.className = u.over ? "warn" : "";
+  if (!wins.length) wins.push(u.collector ? t("plan usage: waiting for Claude Code") : t("plan usage: not set up"));
+  chip.replaceChildren(h("span", { class: "dot" }), [...wins, cap && u.plan?.limits && Object.keys(u.plan.limits).length ? t("pauses at {pct}%", { pct: cap }) : null,
+    t("{cost} today", { cost: fmtCost(u.spent.today) })].filter(Boolean).join(" · "));
+  chip.title = u.block || t("Analysis usage and limits: click to see and change them");
+}
+function toggleUsage(force) {
+  const box = $("#usage-panel");
+  const open = force ?? box.hidden;
+  box.hidden = !open;
+  $("#status-usage").setAttribute("aria-expanded", String(open));
+  if (open) { toggleActivity(false); if (lastStatus?.usage) drawUsage(lastStatus.usage); }
+}
+// drawn when it opens and after a save, not on every poll, so a value being typed stays
+function drawUsage(u) {
+  const box = $("#usage-panel"), admin = canAdmin(), lim = u.limits;
+  const cap = u.plan_applies ? lim.plan_limit_pct : 0;
+  const win = ([k, v]) => h("div", { class: "us-win" },
+    h("div", { class: "us-top" }, h("b", null, PLAN_NAME[k] || k), h("span", null, `${Math.round(v.used_pct)}%`)),
+    h("div", { class: `us-bar${cap && v.used_pct >= cap ? " over" : ""}`, role: "meter", "aria-label": PLAN_NAME[k] || k,
+      "aria-valuemin": "0", "aria-valuemax": "100", "aria-valuenow": String(Math.round(v.used_pct)) },
+      h("i", { style: { width: `${Math.min(100, Math.max(1, v.used_pct))}%` } }),
+      cap ? h("u", { style: { left: `${cap}%` }, title: t("Analysis pauses at {pct}%", { pct: cap }) }) : null),
+    h("div", { class: "muted us-note", title: fmtDT(v.resets_at) }, t("{pct}% left · resets {when}",
+      { pct: Math.max(0, 100 - Math.round(v.used_pct)), when: untilText(v.resets_at) })));
+  const wins = Object.entries(u.plan?.limits || {});
+  const plan = wins.length ? [...wins.map(win), h("div", { class: "muted us-note" }, [t("as of {ago}", { ago: ago(u.plan.as_of) }),
+      !u.plan_applies ? t("Analysis isn't using Claude Code now, so these don't limit it") : null].filter(Boolean).join(" · "))]
+    : h("div", { class: "muted us-note" }, u.collector
+      ? t("Recorded from Claude Code's status line: the numbers come with your next Claude Code session in a terminal and the sync after it (Pro and Max plans).")
+      : tx("Not set up: run {command} so Claude Code's status line records them (Pro and Max plans). Until then the pause at plan limit can't act.",
+        { command: h("code", null, "interlatch install --statusline") }));
+  const fact = (v, label) => h("div", { class: "fact" }, h("b", null, fmtCost(v)), h("span", null, label));
+  const num = (name, label, attrs, hint) => h("label", null, h("span", null, label),
+    h("input", { class: "input", type: "number", name, value: lim[name], disabled: !admin, required: true, ...attrs }), hint ? h("small", { class: "muted" }, hint) : null);
+  const caps = PLAN_CAPS.includes(lim.plan_limit_pct) ? PLAN_CAPS : [...PLAN_CAPS, lim.plan_limit_pct].sort((a, b) => a - b);
+  const form = h("form", { class: "us-form", onsubmit: async (e) => {
+    e.preventDefault();
+    const f = e.currentTarget, btn = f.querySelector("button[type=submit]");
+    btn.disabled = true;
+    const r = await post("/api/analysis/limits", { max_per_run: +f.max_per_run.value, max_budget_usd: +f.max_budget_usd.value,
+      plan_limit_pct: +f.plan_limit_pct.value }).catch((err) => ({ error: err.message }));
+    btn.disabled = false;
+    if (r.error) { toast(r.error, 6000); return; }
+    toast(t("Analysis limits saved."));
+    lastStatus = { ...lastStatus, usage: r };
+    drawUsage(r);
+    pollStatus(); // the chip and the queue's reason follow the new limits
+  } },
+    num("max_per_run", t("Sessions per run"), { min: 1, max: 100, step: 1 }, t("every 15 minutes")),
+    num("max_budget_usd", t("Budget per call (USD)"), { min: 0.1, max: 100, step: 0.1 }, t("API-equivalent; Claude Code and Bob")),
+    h("label", null, h("span", null, t("Pause at plan limit")),
+      h("select", { class: "input", name: "plan_limit_pct", disabled: !admin },
+        caps.map((c) => h("option", { value: c, selected: c === lim.plan_limit_pct }, c ? `${c}%` : t("Never")))),
+      h("small", { class: "muted" }, t("Session or weekly, while Claude Code analyzes"))),
+    h("div", { class: "us-save" }, h("button", { class: "btn small primary", type: "submit", disabled: !admin }, t("Save"))));
+  box.replaceChildren(...[
+    h("div", { class: "act-head" }, h("b", null, t("Analysis usage")),
+      h("button", { class: "un-close", type: "button", "aria-label": t("Close"), onclick: () => toggleUsage(false) }, "×")),
+    u.block ? h("div", { class: "warn-line" }, icon("pause"), " ", LANG === "en" ? `${u.block[0].toUpperCase()}${u.block.slice(1)}.` : `${u.block}。`) : null,
+    h("div", { class: "subhead" }, t("Claude plan")), h("div", { class: "us-wins" }, plan),
+    h("div", { class: "subhead" }, t("Spent on analysis")),
+    h("div", { class: "us-facts", title: t("API-equivalent: what the tokens would cost at list prices") },
+      fact(u.spent.today, t("today")), fact(u.spent.month, t("this month")), fact(u.spent.total, t("all time"))),
+    h("div", { class: "subhead" }, t("Limits")), form,
+    admin ? null : h("div", { class: "muted us-note" }, t("Only an admin can change these.")),
+  ].filter(Boolean));
+}
 // an update on offer: a chip in the status bar, a dot on Settings, and once per update a notification card
 function showUpdate(u, version) {
   const upd = $("#status-update");
@@ -9419,6 +9501,12 @@ document.addEventListener("mousedown", (e) => { if (!$("#activity").hidden && !e
 document.addEventListener("keydown", (e) => { if (e.key === "Escape" && !$("#activity").hidden) toggleActivity(false); });
 $("#status-update").addEventListener("click", () => go("#/status?focus=updates"));
 $("#status-hub-problem").addEventListener("click", (e) => go(e.currentTarget.dataset.page || "#/devices"));
+$("#status-usage").addEventListener("click", () => toggleUsage());
+$("#status-usage").setAttribute("aria-haspopup", "dialog");
+$("#status-usage").setAttribute("aria-expanded", "false");
+$("#usage-panel").setAttribute("aria-label", t("Analysis usage"));
+document.addEventListener("mousedown", (e) => { if (!$("#usage-panel").hidden && !e.target.closest("#usage-panel, #status-usage")) toggleUsage(false); });
+document.addEventListener("keydown", (e) => { if (e.key === "Escape" && !$("#usage-panel").hidden) toggleUsage(false); });
 $("#status-queue").addEventListener("click", openQueueDialog);
 $("#status-queue").setAttribute("aria-haspopup", "dialog");
 $("#status-queue").setAttribute("aria-expanded", "false");

{interlatch-0.29.2 → interlatch-0.29.3}/src/interlatch/web/index.html

@@ -68,6 +68,7 @@
         <span id="status-hub" hidden></span>
         <button type="button" id="status-pill" title="Background work"></button>
         <button type="button" id="status-queue" hidden></button>
+        <button type="button" id="status-usage" hidden></button>
       </div>
       <div class="st-right">
         <span id="status-sync"></span>
@@ -85,6 +86,7 @@
   <div id="toast" role="status" aria-live="polite" hidden></div>
   <div id="update-note" role="status" aria-live="polite" hidden></div>
   <div id="activity" role="dialog" aria-label="Activity" hidden></div>
+  <div id="usage-panel" role="dialog" aria-label="Analysis usage" hidden></div>
   <script src="rough.js"></script>
   <script src="ja.js"></script>
   <script src="i18n.js"></script>

{interlatch-0.29.2 → interlatch-0.29.3}/src/interlatch/web/ja.js

@@ -73,6 +73,36 @@ window.INTERLATCH_JA = {
   "{limit} limit {pct}% (resets {when})": "{limit}の上限 {pct}%（{when} にリセット）",
   "as of {ago}": "取得：{ago}",
   "{limit} limit used": "{limit}の上限の使用量",
+  // Analysis usage: the status bar's chip and panel
+  "Weekly": "週間",
+  "Session (5hr)": "セッション（5 時間）",
+  "Weekly (7 day)": "週間（7 日）",
+  "Spend limit": "利用額の上限",
+  "{pct}% left · resets {when}": "残り {pct}% · {when}にリセット",
+  "{cost} today": "今日 {cost}",
+  "pauses at {pct}%": "{pct}% で停止",
+  "Analysis usage and limits: click to see and change them": "分析の使用量と上限：クリックで確認・変更",
+  "Analysis pauses at {pct}%": "{pct}% で分析を一時停止",
+  "Analysis isn't using Claude Code now, so these don't limit it": "いまの分析は Claude Code を使っていないため、これらの上限はかかりません",
+  "plan usage: waiting for Claude Code": "プランの使用量：Claude Code を待っています",
+  "plan usage: not set up": "プランの使用量：未設定",
+  "Recorded from Claude Code's status line: the numbers come with your next Claude Code session in a terminal and the sync after it (Pro and Max plans).": "Claude Code のステータスラインから記録します。次にターミナルで Claude Code を使い、そのあと同期すると表示されます（Pro と Max プラン）。",
+  "Not set up: run {command} so Claude Code's status line records them (Pro and Max plans). Until then the pause at plan limit can't act.": "未設定です。{command} を実行すると、Claude Code のステータスラインが記録します（Pro と Max プラン）。それまでは「プランの上限で一時停止」は働きません。",
+  "Analysis limits saved.": "分析の上限を保存しました。",
+  "Sessions per run": "1 回の実行のセッション数",
+  "every 15 minutes": "15 分ごと",
+  "Budget per call (USD)": "1 回の呼び出しの予算（USD）",
+  "API-equivalent; Claude Code and Bob": "API 換算。Claude Code と Bob",
+  "Pause at plan limit": "プランの上限で一時停止",
+  "Never": "しない",
+  "Session or weekly, while Claude Code analyzes": "セッションまたは週間。Claude Code で分析しているとき",
+  "Analysis usage": "分析の使用量",
+  "Claude plan": "Claude プラン",
+  "Spent on analysis": "分析に使った額",
+  "today": "今日",
+  "this month": "今月",
+  "Limits": "上限",
+  "Only an admin can change these.": "変更できるのは管理者だけです。",
   "How far your plan limits moved while this session ran (includes anything else using the same account then)": "このセッションの実行中にプランの上限がどれだけ進んだか（同じ時間に同じアカウントを使ったものも含みます）",
   "ready now": "すぐに分析",
   "still active": "まだ作業中",

{interlatch-0.29.2 → interlatch-0.29.3}/tests/test_queue.py

@@ -187,3 +187,63 @@ def test_a_spoke_that_shares_knowledge_analyzes_here(synced):
         assert st["hub_url"] and st["analysis"]["on_hub"] is on_hub
         assert api.status.analysis_queue(app.context())["on_hub"] is on_hub
     assert api.status.status_small(App(cfg).context())["analysis"]["on_hub"] is False
+
+
+def _plan(conn, five_hour, seven_day=10.0):
+    import json
+
+    later = to_iso(utcnow() + timedelta(hours=2))
+    kv_set(conn, "plan_usage_latest", json.dumps({"as_of": to_iso(utcnow()), "limits": {
+        "five_hour": {"used_pct": five_hour, "resets_at": later},
+        "seven_day": {"used_pct": seven_day, "resets_at": to_iso(utcnow() + timedelta(days=3))}}}))
+    conn.commit()
+
+
+def test_the_plan_limit_the_user_set_stops_automatic_runs(synced):
+    """analysis.plan_limit_pct: at or above it, the queue says why and a background run analyzes nothing; a session
+    asked for still runs, and the cap means nothing while another analyzer runs or when it is 0."""
+    from interlatch.analysis.queue import plan_over_limit
+    from interlatch.application.workflows import run_worker
+
+    conn, cfg = synced["conn"], synced["cfg"]
+    conn.execute("UPDATE sessions SET analysis_status = 'pending', analysis_attempts = 0, ended_flag = 1")
+    _plan(conn, five_hour=85.0)
+    capped = replace(cfg, analysis=replace(cfg.analysis, plan_limit_pct=80))
+    assert plan_over_limit(conn, capped)["window"] == "five_hour"
+    assert "session (5hr) limit is at 85%, at or above the 80% you set" in count_pending(conn, capped)["block"]
+    assert count_pending(conn, replace(capped, analysis=replace(capped.analysis, plan_limit_pct=90)))["block"] is None
+    assert count_pending(conn, cfg)["block"] is None  # 0: off
+    assert plan_over_limit(conn, replace(capped, analysis=replace(capped.analysis, backend="codex"))) is None
+
+    report = run_worker(capped, synthesize=False)
+    assert not report.analyzed and "plan_limit_pct = 80" in report.note
+    assert conn.execute("SELECT analysis_status FROM sessions WHERE id = ?", (SID,)).fetchone()[0] == "pending"
+    report = run_worker(capped, session_ids=[SID], synthesize=False)
+    assert report.analyzed
+    assert conn.execute("SELECT analysis_status FROM sessions WHERE id = ?", (SID,)).fetchone()[0] == "done"
+
+
+def test_the_status_bar_shows_usage_and_saves_the_limits(synced):
+    from interlatch.core.config import load_config
+    from interlatch.interfaces.web.app import App
+
+    conn, cfg = synced["conn"], synced["cfg"]
+    _plan(conn, five_hour=42.0)
+    conn.execute("INSERT INTO analyses(kind, target, started_at, cost_usd) VALUES ('session', 'x', ?, 0.5), "
+                 "('session', 'y', '2020-01-01T00:00:00Z', 2.0)", (to_iso(utcnow()),))
+    conn.commit()
+    ctx = App(cfg).context()
+    u = api.status.status_small(ctx)["usage"]
+    assert u["spent"]["today"] == 0.5 and u["spent"]["total"] >= 2.5 and u["calls_today"] >= 1
+    assert u["plan"]["limits"]["five_hour"]["used_pct"] == 42.0 and u["over"] is None and u["collector"] is False
+    assert "usage" not in api.status.status_small(ctx, limited=True)  # someone the hub limits to projects
+
+    r = api.status.action_limits(ctx, {"max_per_run": 3, "max_budget_usd": 1.5, "plan_limit_pct": 40})
+    assert r["limits"] == {"max_per_run": 3, "max_budget_usd": 1.5, "plan_limit_pct": 40} and "error" not in r
+    assert r["over"]["window"] == "five_hour" and "at or above the 40% you set" in r["block"]
+    saved = load_config(cfg.home).analysis
+    assert (saved.max_per_run, saved.max_budget_usd, saved.plan_limit_pct) == (3, 1.5, 40)
+
+    r = api.status.action_limits(ctx, {"max_per_run": 0, "max_budget_usd": "lots", "plan_limit_pct": True})
+    assert r["error"] == "not saved: max_per_run, max_budget_usd, plan_limit_pct"
+    assert r["limits"] == {"max_per_run": 3, "max_budget_usd": 1.5, "plan_limit_pct": 40}

{interlatch-0.29.2 → interlatch-0.29.3}/tests/test_route_matrix.py

@@ -216,6 +216,7 @@ ROUTES: dict[tuple[str, str], Access] = {
     ("POST", "/api/update"): POST_ADMIN,
     ("POST", "/api/analysis/backend"): POST_ADMIN,
     ("POST", "/api/analysis/agent"): POST_ADMIN,
+    ("POST", "/api/analysis/limits"): POST_ADMIN,
     ("POST", "/api/analysis/provider"): POST_ADMIN,
     ("POST", "/api/analysis/provider/test"): POST_ADMIN,
     ("POST", "/api/analysis/provider/models"): POST_ADMIN,

interlatch-0.29.2/changelog.d/hub-glossary-members.md

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

interlatch-0.29.2/changelog.d/hub-project-page.md

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