interlatch 0.29.0__tar.gz → 0.29.2__tar.gz

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

@@ -3,6 +3,34 @@
 <!-- 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.1 (2026-10-25)
+
+- **The interview, your job goal's final boss:** three questions a day, written from the job description and from
+  your own past lessons, graded strong, fair or weak with what a strong answer covers and a better one from your own
+  work. It's practice until every must-have tower is lit; then two strong answers and none weak beat it and crown
+  the castle ([The interview](docs/party.md#the-interview)).
+- **A job goal brings its own monsters:** practice battles written for each of its requirements, more where your gap
+  is bigger, roam their zones marked ♜ and count toward each module's gate like your own lessons, so even a skill with
+  no past lessons has a way in. The world map flags each requirement, the field shows the next tower to work on, and
+  your hero now leads the party in battle ([Job monsters](docs/party.md#job-monsters)).
+
+## 0.29.0 (2026-10-24)
+
+- **You are the hero in Innerlatch:** the Party now starts with a character you make (a name and a pixel look) on a
+  career path you choose: a roadmap track, or the Generalist path of the modules most tracks share. Your hero levels
+  up only from the lessons you answer right in study battles (past answers count too), and shows your readiness in each
+  of your path's modules. Your coding agents become your companions, their levels unchanged
+  ([You, the hero](docs/party.md#you-the-hero)).
+- **Gate bosses in Innerlatch:** five lessons understood in a module open its gate, a stone arch on the field and a
+  link on your hero's card. Rank 1 asks for an explanation in your own words; ranks 2 to 4 for your own pull requests,
+  commits or documents and what they show. The analysis model judges it against the module's check: a pass raises your
+  rank there and your hero's XP, a "not yet" says what's missing and the gate opens again tomorrow. Your hero now leads
+  the party on the field ([Gates](docs/party.md#gates)).
+- **A job goal in Innerlatch:** paste a real job description and your analysis model maps it to the roadmap modules
+  and ranks it asks for, each with the line it came from; what the roadmap doesn't cover is listed apart. The job is a
+  castle whose towers light only with the ranks you show at gates, with the track that fits it best and the gates to
+  take next; its modules lead the field ([Job goal](docs/party.md#job-goal)).
+
 ## 0.28.8 (2026-10-22)
 
 - **A sign-in page that looks like Interlatch:** opening a hub's sign-in or invite link now shows the dashboard's own

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: interlatch
-Version: 0.29.0
+Version: 0.29.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.29.0 → interlatch-0.29.2}/ROADMAP.ja.md

@@ -56,10 +56,6 @@ Interlatch にこれから入るものを、おおよそ取り組む順に並べ
   作りません）。エージェントには今までどおりすべての教訓を渡します。効果は、尋ねるのではなく、思い出せたかと、同じ gotcha が
   あなたのセッションでまた起きるかで測り、一人ひとりの指標はすべてあなたのコンピューターに残します
   （[設計](docs/design/ja/learning.md)）。
-- **主人公はあなた、目指すは実際の仕事。** Innerlatch の冒険では、学びの戦闘で正解した教訓が、すでに
-  各ロードマップのモジュールの準備度として数えられ、主人公はそれでレベルが上がり、モジュールのゲートでは、分析モデルが判定する
-  あなた自身の言葉と仕事でそこのランクが上がり、貼りつけた求人の説明が、求めるモジュールとランクに対応づけられて目標に
-  なります。これから: その仕事とあなた自身の過去の仕事から書く面接の問いを、最後のボスにします（[設計](docs/design/ja/innerlatch.md#2-主人公)）。
 - **人の名前で、並べて見るチームメイトの教訓。** チームメイトの教訓は、プロジェクトのページと **All knowledge** に、
   どのコンピューターから来たかを示して表示されます。これから: コンピューター名ではなく人の名前で示すこと、週次レビューに
   チームメイトの教訓を入れること、2 人が述べた教訓を両方の事件として見せること（[設計](docs/design/ja/learning.md#4-チーム)）。

{interlatch-0.29.0 → interlatch-0.29.2}/ROADMAP.md

@@ -60,12 +60,6 @@ carefully.
   getting every lesson. Whether it works is measured by recall and by whether the same gotcha comes back in your
   sessions, not by asking, and every per-person measure stays on your computer
   ([design](docs/design/learning.md)).
-- **You as the hero, toward a real job.** In Innerlatch's Adventure, the lessons you answer right in study
-  battles count toward your readiness in each roadmap module, your hero levels up from them, and at a module's gate
-  your own words and work, judged by the analysis model, raise your rank there; a job description you paste is the
-  goal, mapped to the modules and ranks it asks for. Still to come: interview questions written from that job and
-  your own past work, as its final boss
-  ([design](docs/design/innerlatch.md#2-the-hero)).
 - **Teammates' lessons, by person and side by side.** They show on project pages and in **All knowledge**, marked
   with the computers they came from. Still to come: the person's name instead of the computer's, teammates' lessons
   in the weekly review, and a lesson two people stated shown as both their cases

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

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

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

{interlatch-0.29.0 → interlatch-0.29.2}/docs/dashboard.md

@@ -133,11 +133,41 @@ The other tabs hold the rest: **Working here** (the knowledge base, its [archite
 and the glossary), **Knowledge**, **Sessions**, **Artifacts** and **Usage** (the totals and the most edited files).
 The tab you pick stays in the address, so a link or a reload opens it again.
 
-The git rows and the roadmap file are read only in a browser on the computer the folder is on. On a hub with people,
-the cards are **Needs attention** and **Where the team left off**, and each session shows whose it is. Pull requests come
-from the transcripts computers send (`share = "everything"`), or from the links a session lists when a computer shares
-knowledge; commits only from transcripts. Someone limited to some projects sees the sessions, not their pull requests,
-as on a session's page.
+The git rows and the roadmap file are read only in a browser on the computer the folder is on.
+
+### On a team hub
+
+On a hub with people, a project's page is written for a teammate rather than for "you, coming back", and the team's
+knowledge leads. It is still read from what computers shared, with nothing written by a model:
+
+- **Overview:** the knowledge base's three headline points, with how many lessons arrived since it was last written
+  (or, when the hub has no analysis engine, why there is none). **Since your last visit:** the sessions, new lessons
+  and pull requests since you last opened the page, the lessons a newer one replaced (outdated or contradicted, and
+  whether it was yours) and the ones someone else found again. Pages you open within half an hour are one visit, so a
+  reload doesn't empty it. Beside it, **Needs attention** and **Only one person has worked on** (topics from one
+  person's sessions only: worth asking them, or pairing on it). Below, **Who's working on it**: each person's sessions
+  over the last eight weeks as dots, sized by active time and coloured by outcome, with a table view.
+- **Start here:** the gotchas and fixes, decisions and commands the team learned, the most trusted first, and who to
+  ask. Someone with no sessions in the project opens the page here.
+- **Knowledge base:** each entry names whose sessions taught it ("learned by"), with a badge when more than one person
+  found it. **Hit by more than one person** puts the sessions in which different people found the same lesson side by
+  side.
+- **Glossary & map:** the project's terms as a list or as a mindmap (category, then theme), for everyone who sees the
+  project. Someone limited to some projects gets the terms their projects use, each with what their projects say of
+  it: a term's definition shows when one of their projects wrote it, and otherwise their project's own note on it.
+  What a term gathers across projects (aliases, related terms, how often it was mentioned, the sessions it came up in
+  most, a theme's description) isn't shown to them.
+- **Lessons:** every lesson with who it was learned from, narrowed to a person or a kind, or the lessons a newer one
+  replaced.
+- **People:** who has worked on what, as topics from their sessions here.
+- **Activity:** **Where the team left off**, **Week by week** and the sessions. **Usage** (tokens, cost, most edited
+  files) is for admins only.
+
+People are credited, never counted: the page shows no lessons, sessions or time per person. Pull requests come from
+the transcripts computers send (`share = "everything"`), or from the links a session lists when a computer shares
+knowledge; commits only from transcripts. Someone limited to some projects sees their projects only, and the sessions,
+not their pull requests, as on a session's page. The Systems map isn't offered on a hub that takes knowledge only (it
+reads the commands sessions ran, which stay on members' computers), nor to someone limited to projects.
 
 ## Project groups
 

{interlatch-0.29.0 → interlatch-0.29.2}/docs/demo/make_demo.py

@@ -3,6 +3,9 @@
     uv run python docs/demo/make_demo.py /tmp/interlatch-demo
     INTERLATCH_HOME=/tmp/interlatch-demo/home uv run python -m interlatch ui --port 8898 --open
 
+With --hub, the demo computer is then a team hub with people: Ada at the hub, Yuma and Ueno sending from their own
+computers, each with some of the sessions, so a project's page shows the team's side (whose sessions taught what).
+
 It writes synthetic Claude Code transcripts for a fictional developer (five projects, about six weeks), then runs the
 real pipeline over them: sync, analysis, knowledge bases, glossary and weekly reviews. Then a project group with its
 Mindmap analyzed, and game mode on with a hero in Innerlatch: a path, lessons studied, gates passed and a job goal.
@@ -554,7 +557,8 @@ print(json.dumps({"type": "result", "subtype": "success", "is_error": False, "re
 
 
 def main() -> None:
-    out = Path(sys.argv[1] if len(sys.argv) > 1 else "/tmp/interlatch-demo").resolve()
+    paths = [a for a in sys.argv[1:] if not a.startswith("--")]
+    out = Path(paths[0] if paths else "/tmp/interlatch-demo").resolve()
     if out.exists():
         shutil.rmtree(out)
     claude_dir, home, bindir = out / "claude", out / "home", out / "bin"
@@ -609,6 +613,8 @@ def main() -> None:
         week = (now - timedelta(weeks=w)).strftime("%G-W%V")
         chronicle("review", week)
     subprocess.run([sys.executable, __file__, "--group-and-hero", str(home)], env=env, check=True)
+    if "--hub" in sys.argv:
+        subprocess.run([sys.executable, __file__, "--team-hub", str(home)], env=env, check=True)
     print(f"\nDemo ready. Open it with:\n  INTERLATCH_HOME={home} uv run python -m interlatch ui --port 8898 --open")
 
 
@@ -647,8 +653,72 @@ def group_and_hero(home: Path) -> None:
     jobs.add(conn, cfg, cat, None, title=JOB["title"], company=JOB["company"], text=JOB["text"])
 
 
+TEAM = (("Yuma", "yuma@example.com", ["billing-api", "storefront"]), ("Ueno", "ueno@example.com", None))
+SHARED = ("billing-api", "storefront", "infra")  # the projects whose sessions the team splits
+
+
+def team_hub(home: Path) -> None:
+    """The demo computer as a team hub with people (--hub): Ada, an admin, works at the hub; Yuma (limited to two
+    projects) and Ueno send from their own computers. The sessions of SHARED are split between the three, a lesson of
+    each project is stated again in a teammate's session, and one is replaced by a newer one, so a project's page has
+    whose-sessions-taught-what, side-by-side cases and "since your last visit" to show. Prints a sign-in link each."""
+    from interlatch.core.config import load_config, set_config_value
+    from interlatch.core.machine import local_machine_id
+    from interlatch.core.util import to_iso, utcnow
+    from interlatch.projects.team import VISIT_KV
+    from interlatch.sharing import people
+    from interlatch.sharing.identity import new_token
+    from interlatch.storage.kv import kv_set
+    from interlatch.storage.sqlite import connect
+
+    cfg = load_config(home)
+    new_token(cfg)
+    set_config_value(cfg, "hub", "name", '"Acme team"')
+    conn = connect(cfg.db_path)
+    here = local_machine_id(cfg)
+    ada = people.add(conn, "Ada Lovelace", "ada@example.com", "admin")
+    conn.execute("UPDATE machines SET person_id = ? WHERE id = ?", (ada["id"], here))
+    links, machines = {"Ada Lovelace": people.invite(conn, ada["id"])}, [here]
+    for i, (name, email, projects) in enumerate(TEAM):
+        person = people.add(conn, name, email, "member", by=ada, projects=[f"{ROOT}/{p}" for p in projects] if projects else None)
+        mid = str(uuid.UUID(int=0xD3E0 + i, version=4))
+        conn.execute("INSERT INTO machines(id, name, role, first_seen, last_seen) VALUES (?, ?, 'spoke', ?, ?)",
+                     (mid, f"{name.lower()}-laptop", to_iso(utcnow()), to_iso(utcnow())))
+        people.join_computer(conn, people.invite(conn, person["id"], machine=mid), mid, f"{name.lower()}-laptop")
+        links[name] = people.invite(conn, person["id"])
+        machines.append(mid)
+    rng = random.Random(11)
+    for project in SHARED:
+        sids = [r[0] for r in conn.execute("SELECT id FROM sessions WHERE project_path = ? ORDER BY started_at", (f"{ROOT}/{project}",))]
+        owner = {sid: machines[(i + rng.randrange(2)) % len(machines)] for i, sid in enumerate(sids)}
+        for sid, mid in owner.items():
+            conn.execute("UPDATE sessions SET machine_id = ? WHERE id = ?", (mid, sid))
+        lesson = conn.execute("SELECT id, session_id, confirmed_json FROM knowledge WHERE project_path = ? AND status = 'active' "
+                              "AND kind IN ('gotcha', 'fix') ORDER BY id LIMIT 1", (f"{ROOT}/{project}",)).fetchone()
+        other = next((sid for sid in sids if lesson and owner.get(sid) != owner.get(lesson["session_id"])), None)
+        if other:  # a teammate hit the same thing in a session of their own
+            confirmed = json.loads(lesson["confirmed_json"] or "[]") or [lesson["session_id"]]
+            conn.execute("UPDATE knowledge SET confirmed_json = ?, stage = 'established' WHERE id = ?",
+                         (json.dumps([*confirmed, other]), lesson["id"]))
+    newest, older = conn.execute("SELECT id FROM knowledge WHERE project_path = ? AND status = 'active' ORDER BY id DESC LIMIT 2",
+                                 (f"{ROOT}/billing-api",)).fetchall()
+    conn.execute("UPDATE knowledge SET status = 'superseded', superseded_by = ?, superseded_reason = 'outdated', superseded_at = ? "
+                 "WHERE id = ?", (newest[0], to_iso(utcnow() - timedelta(hours=20)), older[0]))
+    kid = conn.execute("SELECT MAX(id) FROM knowledge").fetchone()[0]
+    for (pid,) in conn.execute("SELECT id FROM people").fetchall():  # each last looked two days ago, before the newest lessons
+        for project in PROJECTS:
+            kv_set(conn, f"{VISIT_KV}p:{pid}:{ROOT}/{project}",
+                   json.dumps({"seen": to_iso(utcnow() - timedelta(days=2)), "kid": kid - 4, "prev": None, "prev_kid": None}))
+    conn.commit()
+    print("\nTeam hub ready. Sign in as (open on the hub's address):")
+    for name, code in links.items():
+        print(f"  {name}: /signin?code={code}")
+
+
 if __name__ == "__main__":
     if sys.argv[1:2] == ["--group-and-hero"]:
         group_and_hero(Path(sys.argv[2]))
+    elif sys.argv[1:2] == ["--team-hub"]:
+        team_hub(Path(sys.argv[2]))
     else:
         main()

{interlatch-0.29.0 → interlatch-0.29.2}/docs/design/innerlatch.md

@@ -3,7 +3,7 @@
 [← Roadmap](../../ROADMAP.md) · 日本語: [ja/innerlatch.md](ja/innerlatch.md) · Related: [lessons people learn from](learning.md)
 
 Status: study battles built in 0.27.3 (2026-10-18); the hero (section 2), gate bosses (section 7) and the job goal
-(section 8) built in October 2026. The interview boss (section 10) is still to come. The user guide is [Adventure](../party.md#adventure).
+(section 8) with its interview built in October 2026. The user guide is [Adventure](../party.md#adventure).
 
 Innerlatch is the game behind the door at the bottom of the dashboard's rail. **You are the hero:** a character you
 make, on a career path you choose, who beats the lessons of your own past work and levels up toward a real job. Your
@@ -267,11 +267,23 @@ The goal at the end of the path: a real job you want.
   card and the Party's sidebar: the world map's layout had no room for it), one tower per requirement. A tower lights
   when your rank reaches what it needs. The match is the must-haves lit out of all must-haves, with the ranks still to
   go; readiness shows apart from it, as gates you could take next.
+- **Job monsters.** A job brings its own enemies, so every requirement has some from the day it's added, one with
+  none of your own lessons included. Per requirement the model writes practice battles (study battles' shape) from the
+  posting's line, the module's study topics and your lessons there; how many follows the gap: 2, plus 2 a rank still
+  to go, plus 2 for a must-have, 2 fewer where you have 10 or more lessons of your own, between 3 and 10. They roam the
+  module's zone marked ♜, come back on the same spacing, and each one understood counts toward the module's gate as a
+  lesson does; ranks still need your own work there. A lit tower's monsters leave. On the world map each requirement is
+  a ♜ flag on its territory that takes you there. `src/interlatch/knowledge/jobprep.py`, `GET`/`POST /api/party/prep`.
 - **Steering the path.** The job suggests the track whose targets fit its requirements best; switching is your call.
   The job's modules lead the field (section 4).
 - **Several jobs.** Keep as many as you like; one is active at a time.
-- **Later: the final boss.** Interview questions written from the job description and grounded in your own past
-  work, answered like a gate.
+- **The final boss: the interview.** On the job's page. A sitting asks three questions, one per requirement
+  (must-haves first, unlit and weakest first, a different set each time), each written from the job description and
+  grounded in up to three of your own lessons in that module ("In <project>, you …: how would you …"). The model grades
+  each answer strong, fair or weak, says why, lists what a strong answer covers and sketches a better one from your own
+  work. Until every must-have tower is lit it is practice; then the boss is awake, and two strong answers with none
+  weak beat it and crown the castle. One sitting a day; it moves no rank and no XP. `knowledge/interview.py`,
+  `GET`/`POST /api/party/interview`.
 
 ## 9. Measuring it
 
@@ -287,7 +299,7 @@ One pull request each, judged before the next:
    card at the top of the Party page, companions under it.
 2. **Gate bosses** (section 7), which move the ranks.
 3. **The job goal** (section 8): paste, mapping, the castle, the match, the field led by its modules.
-4. **The final boss**, later.
+4. **The final boss**, the interview (section 8).
 
 ## Not doing
 

{interlatch-0.29.0 → interlatch-0.29.2}/docs/design/ja/innerlatch.md

@@ -3,7 +3,7 @@
 [← ロードマップ](../../../ROADMAP.ja.md) · English: [innerlatch.md](../innerlatch.md) · 関連: [人が学べる教訓](learning.md)
 
 状態: 学びの戦闘は 0.27.3（2026-10-18）で、主人公（2 節）、ゲートのボス（7 節）、仕事の目標（8 節）は 2026 年 10 月に
-できています。面接のボス（10 節）はこれからです。使い方は[冒険](../../ja/party.md#冒険)にあります。
+面接と一緒にできています。使い方は[冒険](../../ja/party.md#冒険)にあります。
 
 Innerlatch は、ダッシュボードのレールのいちばん下にある扉の奥のゲームです。**主人公はあなたです。** あなたが作った
 キャラクターが、自分で選んだキャリアの道を進み、自分の過去の仕事の教訓を倒してレベルを上げ、実際の仕事を目指します。
@@ -262,10 +262,21 @@ Innerlatch は、ダッシュボードのレールのいちばん下にある扉
   ワールドマップの配置には置く場所がありませんでした）の城になり、要件ごとに塔が 1 つあります。あなたのランクが必要なランクに
   届くと塔に灯がともります。合っている度合いは、必須の要件のうち灯がともったものの割合で、あといくつランクが要るかも
   出ます。準備度はそれとは別に、次に挑めるゲートとして出ます。
+- **仕事のモンスター。** 仕事は自分のモンスターを連れてくるので、加えた日からどの要件にも敵がいます。自分の教訓がない要件も
+  です。要件ごとにモデルが、求人の行、モジュールの学習テーマ、そこでのあなたの教訓から練習の戦闘（学びの戦闘の形）を書きます。
+  数は差しだいです：2 体、足りないランク 1 つにつき 2 体、必須ならさらに 2 体、自分の教訓が 10 以上あれば 2 体少なく、3〜10 体。
+  そのモジュールのゾーンを ♜ をつけて歩き、同じ間隔で戻ってきて、理解したものは教訓と同じくそのモジュールのゲートに数えられます。
+  ランクはそこで自分の仕事を示してはじめて上がります。塔に灯がともると、そのモンスターは去ります。ワールドマップでは要件ごとに、
+  その領地に ♜ の旗が立ち、そこへ連れていきます。`src/interlatch/knowledge/jobprep.py`、`GET`/`POST /api/party/prep`。
 - **道を寄せる。** 仕事は、目標が要件にいちばん合うトラックを勧めます。乗り換えるかはあなたが決めます。フィールドでは
   仕事のモジュールが先に出ます（4 節）。
 - **いくつもの仕事。** いくつでも残せます。有効なのは一度に 1 つです。
-- **あとで: 最後のボス。** 求人の説明から書き、あなた自身の過去の仕事にもとづく面接の問いで、ゲートと同じように答えます。
+- **最後のボス: 面接。** 仕事のページにあります。1 回の面接で、要件ごとに 1 つ、3 つの問いが出ます（必須が先、灯のない
+  もの・遠いものが先、毎回ちがう組み合わせ）。どれも求人の説明から書かれ、そのモジュールのあなた自身の教訓 3 つまでにもとづきます
+  （「<プロジェクト> で、あなたは…：どうしますか」）。モデルが答えを強い・まずまず・弱いで判定し、理由、強い答えが触れること、
+  あなた自身の仕事からのもっとよい答えを示します。必須の塔すべてに灯がともるまでは練習で、そのあとはボスが目覚め、強い答え 2 つ以上で
+  弱い答えがなければ突破となり、城に冠がつきます。面接は 1 日 1 回で、ランクも経験値も動きません。`knowledge/interview.py`、
+  `GET`/`POST /api/party/interview`。
 
 ## 9. 効果の測り方
 
@@ -280,7 +291,7 @@ Innerlatch は、ダッシュボードのレールのいちばん下にある扉
    いちばん上の主人公のカードと、その下の仲間。
 2. **ゲートのボス**（7 節）。ランクを動かします。
 3. **仕事の目標**（8 節）。貼りつけ、対応づけ、城、合っている度合い、仕事のモジュールが先に出るフィールド。
-4. **最後のボス**、あとで。
+4. **最後のボス**、面接（8 節）。
 
 ## やらないこと
 

{interlatch-0.29.0 → interlatch-0.29.2}/docs/development.md

@@ -215,6 +215,12 @@ uv run python docs/demo/make_demo.py /tmp/interlatch-demo
 INTERLATCH_HOME=/tmp/interlatch-demo/home uv run python -m interlatch ui --port 8898 --open
 ```
 
+With `--hub`, the demo computer then becomes a team hub with people: Ada, an admin, works at the hub, and Yuma (who
+sees only *billing-api* and *storefront*) and Ueno send from their own computers. Their sessions of three projects
+are split between them, so a project's page shows [the team's side](dashboard.md#on-a-team-hub). It prints a sign-in
+link for each person; open one from another device, or through a proxy, to see the hub as that person (a browser at
+the hub itself is always its admin).
+
 The README's GIF and tour video come from it too. With that dashboard running, `docs/demo/record_demo.py` drives
 headless Chromium through a scripted tour (it needs `ffmpeg` on PATH). It writes the whole tour to
 `docs/images/demo.mp4`, which git ignores, and a few seconds of it, under the 600 KB the large-file hook allows, to

{interlatch-0.29.0 → interlatch-0.29.2}/docs/ja/dashboard.md

@@ -82,10 +82,39 @@ macOS 以外では ⌘ の代わりに Ctrl を使います。macOS アプリで
 ほかのタブ：**作業の手引き**（ナレッジベース、[アーキテクチャ図](#アーキテクチャ図)、用語集）、**ナレッジ**、**セッション**、
 **成果物**、**使用量**（合計と編集の多いファイル）。選んだタブはアドレスに残るので、リンクや再読み込みでも同じタブが開きます。
 
-git の行とロードマップのファイルは、フォルダーがあるコンピューター上のブラウザーでだけ読み取ります。人のいるハブでは、カードは
-**要対応**と**チームが中断したところ**になり、各セッションに誰のものかが出ます。プルリクエストは、コンピューターが送る
+git の行とロードマップのファイルは、フォルダーがあるコンピューター上のブラウザーでだけ読み取ります。
+
+### チームのハブでは
+
+人のいるハブでは、プロジェクトのページは「戻ってきた自分」ではなくチームメイトのために書かれ、チームのナレッジが先頭に来ます。
+内容はコンピューターが共有したものから読み取り、モデルが書くものはありません。
+
+- **概要:** ナレッジベースの要点 3 つと、最後に作成した後に届いた教訓の数（ハブに分析エンジンがない場合は、ナレッジベースが
+  ない理由）。**前回の訪問以降:** 前回このページを開いてからのセッション、新しい教訓、プルリクエスト、新しい教訓に置き換えられた
+  教訓（古くなったか矛盾したか、あなたの教訓だったか）、ほかの人も見つけた教訓。30 分以内に開いたページは 1 回の訪問として
+  扱うので、再読み込みしても消えません。横に**要対応**と**一人だけが取り組んだテーマ**（一人のセッションにしか出てこない
+  テーマ。その人に聞くか、一緒に取り組む価値があります）。下に**誰が取り組んでいるか**: 直近 8 週間の各人のセッションを点で
+  表示し、大きさは作業時間、色は結果です。表でも見られます。
+- **はじめに:** チームが学んだ落とし穴と修正、決定、コマンドを信頼度の高い順に並べ、誰に聞くかも示します。このプロジェクトに
+  セッションがない人は、ここからページが開きます。
+- **ナレッジベース:** 各項目に、どの人のセッションから学んだか（「から学んだ教訓」）を示し、複数の人が見つけた項目には
+  バッジが付きます。**複数の人が遭遇した教訓**では、別々の人が同じ教訓を見つけたセッションを並べて表示します。
+- **用語集とマップ:** プロジェクトの用語を、一覧またはマインドマップ（カテゴリー、次にテーマ）で表示します。プロジェクトを
+  見られる人なら誰でも見られます。一部のプロジェクトだけを見られる人には、そのプロジェクトが使う用語を、そのプロジェクトでの
+  説明とともに表示します。用語の定義は、その人のプロジェクトが書いたものだけを表示し、それ以外はそのプロジェクトでの使われ方の
+  メモを代わりに表示します。複数のプロジェクトにまたがる情報（別名、関連する用語、言及の回数、よく出てきたセッション、テーマの
+  説明）は表示しません。
+- **教訓:** すべての教訓を、誰から学んだかとともに表示します。人や種類で絞り込んだり、新しい教訓に置き換えられた教訓を表示
+  したりできます。
+- **利用者:** 誰が何に取り組んだかを、このプロジェクトでのセッションのテーマで示します。
+- **アクティビティ:** **チームが中断したところ**、**週ごと**、セッション。**使用量**（トークン、コスト、編集の多いファイル）は
+  管理者だけに表示します。
+
+人の名前は出しますが、数えません。人ごとの教訓、セッション、時間の数は表示しません。プルリクエストは、コンピューターが送る
 トランスクリプト（`share = "everything"`）から、ナレッジを共有するコンピューターではセッションが記録しているリンクから表示します。
-コミットはトランスクリプトからだけです。一部のプロジェクトだけを見られる人には、セッションのページと同じく、プルリクエストは表示しません。
+コミットはトランスクリプトからだけです。一部のプロジェクトだけを見られる人には、そのプロジェクトだけを、セッションのページと同じく
+プルリクエストなしで表示します。システムマップは、ナレッジだけを受け取るハブ（セッションが実行したコマンドを読むため、
+メンバーのコンピューターに残ります）と、一部のプロジェクトだけを見られる人には表示しません。
 
 ## プロジェクトのグループ
 

{interlatch-0.29.0 → interlatch-0.29.2}/docs/ja/development.md

@@ -201,6 +201,12 @@ uv run python docs/demo/make_demo.py /tmp/interlatch-demo
 INTERLATCH_HOME=/tmp/interlatch-demo/home uv run python -m interlatch ui --port 8898 --open
 ```
 
+`--hub` を付けると、そのあとデモのコンピューターが人のいるチームのハブになります。管理者の Ada がハブで作業し、Yuma
+（*billing-api* と *storefront* だけを見られます）と Ueno が自分のコンピューターから送ります。3 つのプロジェクトのセッションを
+3 人で分けるので、プロジェクトのページに[チームの側](dashboard.md#チームのハブでは)が表示されます。各人のサインイン用のリンクを
+表示します。その人としてハブを見るには、別のデバイスかプロキシ経由で開いてください（ハブのコンピューター上のブラウザーは常に
+管理者です）。
+
 README の GIF とツアー動画もこのデータから作ります。そのダッシュボードを動かしたまま `docs/demo/record_demo.py` を実行すると、
 ヘッドレスの Chromium が決まった順にダッシュボードを巡ります（`ffmpeg` が PATH に必要です）。ツアー全体は git が無視する
 `docs/images/demo.mp4` に、その数秒は大きなファイルを止めるフックが許す 600 KB 以内で `docs/images/demo.gif` に書き出されます。

{interlatch-0.29.0 → interlatch-0.29.2}/docs/ja/party.md

@@ -81,6 +81,24 @@ Innerlatch の扉は、Google でサインインするまで開きません。
 仕事にいちばん合うトラックが出て、**このトラックを道にする**で道にできます。フィールドでは仕事のモジュールにモンスターが多く出て、
 ♜ の印がつきます。仕事は 20 件まで残せ、有効なのは一度に 1 つです。説明はこのコンピューターに残り、分析モデルにだけ送られます。
 
+### 仕事のモンスター
+
+仕事は自分のモンスターを連れてきます。仕事を加えると、モデルが要件ごとに、求人の行、モジュールの学習テーマ、そこでのあなた自身の教訓
+から練習の戦闘を書きます。差が大きいほど多く出ます（2 体、足りないランク 1 つにつき 2 体、必須ならさらに 2 体、自分の教訓が十分に
+あれば 2 体少なく。3〜10 体）。仕事の目標のページが、要件ごとに順に呼び出します。フィールドではそのゾーンを金色の ♜ をつけて歩き、
+学びの戦闘と同じように戦えて、正解するたびに、自分の教訓と同じくそのモジュールのゲートに近づきます。自分の教訓がない要件でも、
+ゲートへの道があります。塔に灯がともると、そのモンスターは去ります。ワールドマップでは要件ごとに、その領地に ♜ の旗が立ちます
+（必須は赤、灯がともると金）。押すとそこへ狩りに行けて、ゲートが開いていればゲートへ行きます。フィールドの帯には、仕事、次に取り組む
+塔、そのゲートまでの近さが出ます。どの戦闘でも主人公がパーティーの先頭に立ち、その教訓のエージェントが隣に並びます。
+
+### 面接
+
+仕事のページのいちばん下に、その**最後のボス、面接**が待っています。1 回の面接では、求人の説明から書かれ、あなた自身の過去の教訓に
+もとづく 3 つの問いが出ます（「あなたのプロジェクトで、あなたは…：どうしますか」）。それぞれ数文で答えると、モデルが強い・まずまず・
+弱いで判定し、理由、強い答えが触れること、あなた自身の仕事からのもっとよい答えを示します。必須の塔すべてに灯がともるまでは練習です。
+ともったあとは面接官が目覚め、強い答え 2 つ以上で弱い答えがなければ突破となり、城に冠（♛）がつきます。面接は 1 日 1 回で、毎回
+ちがう問いが出ます。ランクも経験値も動きません。
+
 エージェントはあなたの**仲間**で、主人公の下に並びます。仲間のレベルはその教訓がカバーしていることを示し、あなたのレベルを
 動かすことはなく、あなたのレベルが仲間のレベルを動かすこともありません。主人公、答え、道はこのコンピューターに残ります。
 ハブにサインインしているときは主人公はおらず、アリーナは仲間だけのままです。

{interlatch-0.29.0 → interlatch-0.29.2}/docs/party.md

@@ -86,9 +86,30 @@ the mapping fails, or you disagree with it, **Map again** or **Pick by hand**.
 The job is a **castle**, one tower per requirement (a must-have stands taller). A tower lights when your rank in its
 module, shown at its gate, reaches what the job asks: your hero's level never counts. The page shows the must-haves lit,
 the ranks still to go, the gates you could take next, and the track that fits the job best, with **Follow this track**
-to make it your path. The job's modules hold more monsters on the field, marked ♜. Keep up to 20 jobs, one active at a
+to make it your path. The job's zones hold more monsters on the field, marked ♜. Keep up to 20 jobs, one active at a
 time. The description stays on this computer and goes only to your analysis model.
 
+### Job monsters
+
+A job brings its own enemies. When it's added, the model writes practice battles for each requirement, from the
+posting's line, the module's study topics and your own lessons there: more where the gap is bigger (2, plus 2 for each
+rank still to go, plus 2 for a must-have, 2 fewer where you already have plenty of lessons; 3 to 10). The Job goal page
+summons them one requirement at a time. They roam their zones on the field with a gold ♜ over them and fight like study
+battles, and each one you get right counts toward that module's gate, like your own lessons: a requirement you have no
+lessons for still has a way to its gate. Once its tower is lit, its monsters leave. On the world map each requirement is
+a ♜ flag on its territory (red for a must-have, gold once lit); click it to go hunting there, or to its gate when it's
+open. On the field, a strip names the job, the next tower to work on and how close its gate is. Your hero leads the
+party in every battle, with the lesson's agent beside you.
+
+### The interview
+
+At the bottom of the job's page waits its **final boss: the interview**. Each sitting asks three questions written from
+the job description and grounded in your own past lessons ("In your project, you …: how would you …"). Answer each in
+a few sentences; the model grades it strong, fair or weak, says why, lists what a strong answer covers and sketches a
+better one from your own work. Until every must-have tower is lit, a sitting is practice. Once they are, the
+interviewer is awake: two strong answers and none weak beat it, and the castle gets its crown (♛). One sitting a day,
+with new questions each time. It changes no rank and no XP.
+
 Your agents are your **companions**, listed under the hero. Their levels show what their lessons cover; they never
 move yours, and yours never moves theirs. Your hero, your answers and your path are kept on this computer: signed in to
 a hub, there is no hero, and the Arena stays companions only.

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

@@ -217,6 +217,7 @@ JA: dict[str, str] = {
     "forbidden": "許可されていません",
     "not found": "見つかりません",
     "bad json": "JSON が正しくありません",
+    "that's more than it can take: make it shorter": "大きすぎて受け取れません。短くしてください",
     "empty upload": "アップロードが空です",
     "upload cut off": "アップロードが途中で切れました",
     "unknown connector": "そのソースはありません",
@@ -377,6 +378,14 @@ JA: dict[str, str] = {
     "your job goals are kept on your own computer": "仕事の目標はあなた自身のコンピューターに残ります",
     "no such job": "その仕事はありません",
     "unknown action": "その操作はありません",
+    "interviews are taken on your own computer": "面接を受けるのはあなた自身のコンピューターです",
+    "set a mapped job goal first": "先に、対応づけた仕事の目標を設定してください",
+    "you sat this interview today: it opens again tomorrow": "今日この面接を受けました。明日また受けられます",
+    "start the interview first": "先に面接を始めてください",
+    "job monsters are fought on your own computer": "仕事のモンスターと戦うのはあなた自身のコンピューターです",
+    "no such job monster": "その仕事のモンスターはいません",
+    "answer every question in a few sentences: at least {n} characters each": "どの問いにも数文で答えてください（それぞれ {n} 文字以上）",
+    "keep each answer under {n} characters": "答えはそれぞれ {n} 文字以内にしてください",
     "paste the whole job description: at least {n} characters": "求人の説明を全部貼りつけてください（{n} 文字以上）",
     "that's longer than a job description: keep it under {n} characters": "求人の説明としては長すぎます。{n} 文字以内にしてください",
     "you can keep {n} jobs: remove one first": "残せる仕事は {n} 件です。先に 1 件消してください",

{interlatch-0.29.0 → interlatch-0.29.2}/src/interlatch/interfaces/web/api/party.py

@@ -281,6 +281,94 @@ def action_party_job(ctx: Context, viewer: dict | None, body: dict, *, here: boo
     return jb.view(ctx.conn, cat, _here_id(ctx)), 200
 
 
+# ------------------------------------------------------------------ the interview (knowledge/interview.py): the final
+# boss, questions from the active job and the person's own past work; only at their own computer
+def interview(ctx: Context, viewer: dict | None) -> tuple[dict, int]:
+    """GET /api/party/interview: the active job's interview: awake or practice, today's questions, the last sitting."""
+    from ....knowledge import interview as iv
+    from ....knowledge import party as pt
+
+    if who(ctx, viewer) is None:
+        return _refused()
+    if viewer is not None:
+        return {"error": tr(iv.NOT_HERE)}, 403
+    return iv.view(ctx.conn, pt.load_catalog(), _here_id(ctx)), 200
+
+
+def action_party_interview(ctx: Context, viewer: dict | None, body: dict, *, here: bool) -> tuple[dict, int]:
+    """POST /api/party/interview {"action": "start"} writes today's questions; {"action": "answer", "answers": [...]}
+    grades them. Answers what it did and the interview as it is now."""
+    from ....knowledge import interview as iv
+    from ....knowledge import party as pt
+
+    if who(ctx, viewer) is None:
+        return _refused()
+    if viewer is not None:
+        return {"error": tr(iv.NOT_HERE)}, 403
+    cat, here_id, act = pt.load_catalog(), _here_id(ctx), body.get("action")
+    try:
+        if act == "start":
+            got = iv.start(ctx.conn, ctx.cfg, cat, here_id, here=True)
+        elif act == "answer":
+            got = iv.answer(ctx.conn, ctx.cfg, cat, here_id, body.get("answers"), here=True)
+        else:
+            return {"error": tr("unknown action")}, 400
+    except iv.InterviewError as exc:
+        return {"error": tr(exc.template, **exc.kw)}, 400
+    except Exception as exc:  # the model's call failed: nothing was kept
+        return {"error": tr(iv.NO_MODEL, reason=str(exc)[:200])}, 502
+    return {"result": got, "interview": iv.view(ctx.conn, cat, here_id)}, 200
+
+
+# ------------------------------------------------------------------ job monsters (knowledge/jobprep.py): the enemies the
+# active job brings to the field; only at the person's own computer
+def prep(ctx: Context, viewer: dict | None, q: dict) -> tuple[dict, int]:
+    """GET /api/party/prep?id=<p:…>: one job monster's encounter and its question (never which answer is right)."""
+    from ....knowledge import jobprep
+    from ....knowledge import party as pt
+
+    if who(ctx, viewer) is None:
+        return _refused()
+    if viewer is not None:
+        return {"error": tr(jobprep.NOT_HERE)}, 403
+    try:
+        return {"encounter": jobprep.encounter(ctx.conn, pt.load_catalog(), _here_id(ctx), q.get("id") or ""),
+                "ask": jobprep.ask(ctx.conn, q.get("id") or "")}, 200
+    except (jobprep.PrepError, KeyError):
+        return {"error": tr("not found")}, 404
+
+
+def action_party_prep(ctx: Context, viewer: dict | None, body: dict, *, here: bool) -> tuple[dict, int]:
+    """POST /api/party/prep {"action": "forge"} writes the next requirement's monsters (one requirement a call: the
+    page calls again while `left`); {"action": "pick", "id", "choice"} answers one."""
+    from ....knowledge import hero, jobprep, study
+    from ....knowledge import party as pt
+
+    if who(ctx, viewer) is None:
+        return _refused()
+    if viewer is not None:
+        return {"error": tr(jobprep.NOT_HERE)}, 403
+    act = body.get("action")
+    try:
+        if act == "forge":
+            got = jobprep.forge(ctx.conn, ctx.cfg, pt.load_catalog(), _here_id(ctx), here=True)
+            pt.clear_cache()
+            return got, 200
+        if act == "pick":
+            was = hero.total_xp(ctx.conn, study.studied_of(ctx.conn, "here"))
+            got = jobprep.pick(ctx.conn, body.get("id"), body.get("choice"), here=True)
+            out = {**got, "readiness": pt.adventure_map(ctx.conn, _here_id(ctx), viewer)["readiness"]}
+            if hero.load(ctx.conn) is not None:
+                now = hero.total_xp(ctx.conn, study.studied_of(ctx.conn, "here"))
+                out["hero"] = {"xp": now, "gained": now - was, "level": hero.level_of(now), "was_level": hero.level_of(was)}
+            return out, 200
+        return {"error": tr("unknown action")}, 400
+    except jobprep.PrepError as exc:
+        return {"error": tr(exc.template, **exc.kw)}, 400
+    except Exception as exc:  # the model's call failed: nothing was kept
+        return {"error": tr(jobprep.NO_MODEL, reason=str(exc)[:200])}, 502
+
+
 # ------------------------------------------------------------------ the Town & gear (knowledge/bag.py)
 def bag(ctx: Context, viewer: dict | None) -> tuple[dict, int]:
     """GET /api/party/bag: the viewer's gold, items, what each agent wears and the battle stats it adds."""