sidegraph 0.3.0__tar.gz → 0.3.1__tar.gz

{sidegraph-0.3.0 → sidegraph-0.3.1}/CHANGELOG.md

@@ -7,6 +7,26 @@ interfaces, exactly, and what each one promises: [`docs/reference/stability.md`]
 
 ## [Unreleased]
 
+## [0.3.1] — 2026-09-19
+
+### Fixed
+
+- **A session is now identified by its transcript, not by the host's `session_id`.** That
+  field does not mean the same thing on every host: Claude Code mints one per session (and
+  names the transcript after it), while Codex reports the *workspace* session — one id that
+  outlives a single session, survives `resume`, and is shared by every thread beneath it. On
+  Codex that put a whole store's history in one bucket (measured: 1928 of 1929 recorded events
+  in one live store, spanning 27 hours) and, worse, made every per-session guard fire once per
+  workspace instead of once per session: the second thread opened within a minute had its
+  context map dropped as a duplicate injection, and the first thread to finish spent the
+  capture nudge for all of them. All four hook sites now take the session from
+  `transcript_path`'s file name, falling back to `session_id` when no transcript is given.
+  On Claude Code this is the same string it already recorded — verified against a live store,
+  where all 74 recorded session ids are exactly transcript names — so nothing moves there.
+  The workspace session is kept beside it in the new `telemetry:session_group` meta key, as
+  the only link between sibling threads. See
+  [`docs/reference/hooks.md`](docs/reference/hooks.md#which-session-a-hook-is-in).
+
 ## [0.3.0] — 2026-09-19
 
 ### Added

{sidegraph-0.3.0 → sidegraph-0.3.1}/CLAUDE.md

@@ -13,7 +13,7 @@ task-aware retrieval + decision memory riding on the engine's entity graph.
 continuing participant in the project. A core feature must preserve, organize, or deliver
 accumulated project understanding. Document search by itself is not the product.
 
-Sidegraph is pre-1.0 (v0.3.0) — the full loop (capture, ratification, mistakes-first
+Sidegraph is pre-1.0 (v0.3.1) — the full loop (capture, ratification, mistakes-first
 retrieval, refactor-surviving re-anchoring, semantic docs layer, mind-model domains, and the
 facts evidence layer) ships and is exercised end-to-end, but interfaces may still move before
 a stable release. See

{sidegraph-0.3.0 → sidegraph-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sidegraph
-Version: 0.3.0
+Version: 0.3.1
 Summary: Own the memory, rent the graph — a durable decision/lessons layer as a sidecar over a code-graph engine.
 Project-URL: Homepage, https://github.com/SantyagoSeaman/sidegraph
 Project-URL: Repository, https://github.com/SantyagoSeaman/sidegraph

{sidegraph-0.3.0 → sidegraph-0.3.1}/docs/reference/hooks.md

@@ -7,6 +7,24 @@ a JSON payload from stdin and write a JSON response to stdout, per the Claude Co
 contract. For wiring them into `.claude/settings.json`, see
 [`getting-started/claude-code-setup.md`](../getting-started/claude-code-setup.md).
 
+## Which session a hook is in
+
+Every per-session guard below — the capture ledger, the nudge markers, the recorded events —
+needs to know which session it is in, and the payload field named `session_id` does not mean
+the same thing on every host:
+
+- **Claude Code** gives a fresh `session_id` per session, and names the transcript after it.
+- **Codex** gives the *workspace* session: one id that outlives a single session, survives
+  `resume`, and is shared by every thread under that workspace.
+
+So the session is taken from **`transcript_path` — its file name without the extension** —
+falling back to `session_id` when the payload carries no transcript (the field is nullable in
+Codex's own hook schema). On Claude Code the two are the same string, so nothing changed
+there; on Codex each thread is now its own session instead of a day of work sharing one.
+
+The workspace session, when it differs, is kept separately in the `telemetry:session_group`
+meta key: it is the only thing linking sibling threads.
+
 ## `sidegraph-session-start`
 
 Reads: `$SIDEGRAPH_DIR` (or the deprecated `$SIDEGRAPH_DB`; default `.sidegraph`, resolved via
@@ -19,8 +37,9 @@ single proposal-surfacing policy — `$SIDEGRAPH_UNRATIFIED` and
 [`configuration.md`](configuration.md#environment-variables)): proposed records outside
 the surfacing window, or any proposed record in regulated mode, no longer render as
 content in the TOC's unratified block, while the pending-ratification counter below
-always keeps counting them. The stdin payload is read but its
-contents are currently unused.
+always keeps counting them. From the stdin payload it reads only the session — see
+[Which session a hook is in](#which-session-a-hook-is-in) — used for the duplicate-injection
+guard and published to the store as the telemetry session key.
 
 Behavior:
 
@@ -120,7 +139,8 @@ Reads: `$SIDEGRAPH_DIR` (or the deprecated `$SIDEGRAPH_DB`; default `.sidegraph`
 `$SIDEGRAPH_CAPTURE_NUDGE` (unset by default; set to `off` to disable this hook entirely).
 Reads the stdin JSON payload for three keys: `session_id`, `stop_hook_active`, and
 `transcript_path` (the Claude Code Stop-hook contract — `transcript_path` points at the
-session's transcript JSONL file). Does not read `$SIDEGRAPH_GRAPH` — this hook never touches
+session's transcript JSONL file, and also identifies the session: see
+[Which session a hook is in](#which-session-a-hook-is-in)). Does not read `$SIDEGRAPH_GRAPH` — this hook never touches
 the graph.
 
 Behavior, in order:
@@ -128,8 +148,8 @@ Behavior, in order:
 1. `$SIDEGRAPH_CAPTURE_NUDGE == "off"` → print `{}` (allow), without marking the ledger.
 2. `stop_hook_active` truthy (this Stop is the continuation of our own earlier block) →
    print `{}` (allow). Prevents an infinite block loop.
-3. No `session_id` in the payload → print `{}` (allow) — can't dedup the nudge without an id,
-   so it never risks looping.
+3. No session identity in the payload (neither `transcript_path` nor `session_id`) → print
+   `{}` (allow) — can't dedup the nudge without an id, so it never risks looping.
 4. **Substance gate:** count the transcript's *real* user prompts — JSONL lines with
    `type: "user"` whose `message.content` is a string, or a list containing at least one
    block that is NOT `type: "tool_result"`. Claude Code transcripts use `type: "user"` for
@@ -187,7 +207,7 @@ The banner appears **at most once per session**, and only in sessions that have
 triggers it.
 
 **Once-per-session behavior:** the `capture_sessions` table in the store (`was_captured` /
-`mark_captured`) is the ledger — one row per `session_id`. Combined with the
+`mark_captured`) is the ledger — one row per session. Combined with the
 `stop_hook_active` check and the substance gate, this guarantees the block-and-nudge fires
 **at most once per session**, and only once the session looks substantial, even though Claude
 Code calls `Stop` every time the agent finishes responding. Ordering matters:
@@ -205,7 +225,8 @@ Reads: `$SIDEGRAPH_DIR` (or the deprecated `$SIDEGRAPH_DB`; default `.sidegraph`
 `$SIDEGRAPH_GREP_NUDGE` (unset by default; set to `off` to disable this hook entirely). Does
 not read `$SIDEGRAPH_GRAPH` — this hook, like
 `stop`, never touches the graph. Reads the stdin JSON payload for three keys: `tool_name`,
-`tool_input`, `session_id`.
+`tool_input`, and the session (`transcript_path`, else `session_id` — see
+[Which session a hook is in](#which-session-a-hook-is-in)).
 
 Behavior, in order — any `{}` below means the tool call proceeds through Claude Code's normal
 permission flow, untouched:
@@ -216,8 +237,8 @@ permission flow, untouched:
 3. `tool_input` has no string `file_path`/`path`/`pattern` argument (and no other non-empty
    string argument at all) → print `{}`. Deliberately permissive otherwise — any string arg is
    treated as "looks like a file/pattern target," not just a particular path shape.
-4. No `session_id` in the payload → print `{}`.
-5. A per-session marker (`pretool_nudge:<session_id>` in `store.meta` — deliberately **not**
+4. No session identity in the payload → print `{}`.
+5. A per-session marker (`pretool_nudge:<session>` in `store.meta` — deliberately **not**
    the `Stop` hook's `capture_sessions` ledger, so the two one-shot guards can't consume each
    other) already set → print `{}`.
 6. The store has zero accepted domains **and** zero currently-valid (non-superseded,

{sidegraph-0.3.0 → sidegraph-0.3.1}/docs/reference/releasing.md

@@ -45,6 +45,15 @@ package version.
 
 Run from a clean `main`, in this order.
 
+0. `uv run python tools/preflight_release.py`. Seconds, no network. It checks what the rest
+   of this checklist cannot: that every restatement of the version agrees with
+   `pyproject.toml`, that the changelog carries a dated heading with a fresh `[Unreleased]`
+   above it, that both checkouts are clean and on `main`, that the tag does not already
+   exist — and, above all, **which repository the tag belongs to**, derived from the
+   checkout rather than assumed. Add `--online` for the two remote lookups. It reports every
+   finding in one run rather than stopping at the first, so a release is prepared in one
+   sitting instead of five.
+
 1. `uv run pytest -q`. Full suite green.
 2. `uv run pre-commit run --all-files`. Lint, format, and types clean; this is exactly what
    CI runs, and now also gitleaks, zizmor, actionlint, and the shipped-surface/public-twin/
@@ -80,6 +89,13 @@ one. Cut the release with:
 git tag vX.Y.Z && git push origin vX.Y.Z
 ```
 
+**Run that in the public checkout, not the internal one.** PyPI's trusted publisher is
+configured against `SantyagoSeaman/sidegraph`, so a tag pushed to the internal repository
+produces a valid OIDC token with the wrong `repository` claim and the publish job dies on
+`invalid-publisher` — after the whole test matrix has run. The public snapshot is therefore
+cut and pushed *first*, and the tag goes on the commit that snapshot created. Pushing the
+internal `main` is a separate step that triggers no publish at all.
+
 That push triggers [`.github/workflows/publish.yml`](../../.github/workflows/publish.yml),
 three jobs in sequence.
 

{sidegraph-0.3.0 → sidegraph-0.3.1}/plugin/sidegraph/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "sidegraph",
   "displayName": "Sidegraph",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Durable decision/lessons memory over your code graph — ADRs, gotchas, and constraints that survive refactors, retrieved mistakes-first.",
   "author": { "name": "SantyagoSeaman", "url": "https://github.com/SantyagoSeaman" },
   "homepage": "https://github.com/SantyagoSeaman/sidegraph",

{sidegraph-0.3.0 → sidegraph-0.3.1}/plugin/sidegraph/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "sidegraph",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Durable decision/lessons memory over your code graph — ADRs, gotchas, and constraints that survive refactors, retrieved mistakes-first.",
   "license": "Apache-2.0",
   "skills": "./skills/",

{sidegraph-0.3.0 → sidegraph-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sidegraph"
-version = "0.3.0"
+version = "0.3.1"
 description = "Own the memory, rent the graph — a durable decision/lessons layer as a sidecar over a code-graph engine."
 readme = "README.md"
 requires-python = ">=3.13"

{sidegraph-0.3.0 → sidegraph-0.3.1}/src/sidegraph/__init__.py

@@ -19,7 +19,7 @@ from .schema import (
 )
 from .store import Store
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 
 __all__ = [
     "SCHEMA_VERSION",

{sidegraph-0.3.0 → sidegraph-0.3.1}/src/sidegraph/config.py

@@ -87,6 +87,14 @@ def _warn_deprecated_sidegraph_db(value: str) -> None:
 # without importing the host seam — host/hooks.py re-exports it for its own callers/tests.
 TELEMETRY_SESSION_KEY = "telemetry:session"
 
+# The workspace session a recorded session sits beneath, when the host has one (Codex: its
+# `session_id` is an umbrella that spans days, survives resume and covers every thread under
+# it — see host/hooks._session_identity). Written only when it differs from the recorded key,
+# so a Claude Code store never carries it: there, the two are the same string. Kept because it
+# is the only link between sibling threads, which is what separates "how many tasks" from
+# "how many agents under one task" on that host.
+TELEMETRY_SESSION_GROUP_KEY = "telemetry:session_group"
+
 
 def telemetry_enabled() -> bool:
     """True unless ``SIDEGRAPH_TELEMETRY=off``. Opt-out, read at point of use and never

{sidegraph-0.3.0 → sidegraph-0.3.1}/src/sidegraph/host/hooks.py

@@ -23,13 +23,14 @@ import json
 import os
 import sys
 from datetime import UTC, datetime
+from pathlib import PurePosixPath
 from typing import NamedTuple
 
 # Defined in config.py, not here: server.py (core) needs this constant too (Task 4), and
 # core importing from host/ would invert this project's seam rule (host may depend on the
 # core, never the reverse). Re-exported so `hooks.TELEMETRY_SESSION_KEY` still resolves for
 # callers and tests that reach it through this module.
-from ..config import TELEMETRY_SESSION_KEY
+from ..config import TELEMETRY_SESSION_GROUP_KEY, TELEMETRY_SESSION_KEY
 
 CAPTURE_NUDGE = (
     "Sidegraph: if this session produced a durable decision, lesson, or gotcha — or a "
@@ -68,6 +69,41 @@ _SESSION_START_KEY = "session_start"
 _SESSION_START_DEDUPE_SECONDS = 60
 
 
+def _session_identity(payload: dict) -> tuple[str | None, str | None]:
+    """The session this payload belongs to, and the workspace session above it.
+
+    ``payload["session_id"]`` does not mean the same thing on both hosts, and reading it
+    directly attributed a Codex store's whole history to one session. Measured 2026-09-19:
+
+    - Claude Code: per session, and the transcript is named after it — all 74 session ids in
+      this repository's own store are exactly transcript stems.
+    - Codex: the *umbrella* workspace session. It spans days, survives ``resume``, and covers
+      every thread beneath it — 1928 of 1929 events in a second live store landed in one
+      bucket across 27 hours. The thread's own identity is its rollout file; Codex's
+      ``session-start.command.input`` schema carries no thread id and no ``agent_type``.
+
+    So the transcript path is the one field that identifies a session on both hosts, and its
+    stem is the id on the host where the two agree. Returns ``(key, group)``: ``group`` is the
+    host's own ``session_id`` when it differs from ``key``, else ``None`` — nothing extra to
+    record on a host whose session id already IS the key.
+
+    Beyond attribution, this is what unblocks the 60s double-injection dedupe
+    (:func:`_session_start_duplicate`): two Codex threads opened within a minute reported the
+    same id, so the second one's context map was suppressed as a duplicate. Observed in the
+    live rollouts, which start in pairs seconds apart.
+    """
+    raw_id = payload.get("session_id")
+    session_id = raw_id if isinstance(raw_id, str) and raw_id else None
+    raw_path = payload.get("transcript_path")
+    stem = None
+    if isinstance(raw_path, str) and raw_path:
+        # PurePosixPath, not Path: the stem of a host-written path, never touched on disk.
+        stem = PurePosixPath(raw_path).stem or None
+    key = stem or session_id
+    group = session_id if session_id and session_id != key else None
+    return key, group
+
+
 def _session_start_duplicate(store, session_id: str, now: datetime) -> bool:
     """True iff ``session_start()`` already ran for ``session_id`` within the last
     :data:`_SESSION_START_DEDUPE_SECONDS` (design D7.2). Same session id AND a fresh
@@ -245,24 +281,22 @@ def session_start() -> None:
 
         payload = _read_payload()
         store = Store(resolve_store_path(root=os.environ.get("CLAUDE_PROJECT_DIR")))
-        session_id = payload.get("session_id")
+        # Not payload["session_id"] directly: that field is the umbrella workspace session
+        # on Codex, not this session — see _session_identity.
+        session_id, session_group = _session_identity(payload)
 
         # D7.2: double-injection dedupe, checked BEFORE any other work (sync/TOC/nudges) —
         # a duplicate SessionStart call for the same session within the window exits
         # silently, same "print {} and return" shape the Stop hook's own one-shot ledger
         # uses. Gated on a real session id (see _session_start_duplicate's docstring).
-        if (
-            isinstance(session_id, str)
-            and session_id
-            and _session_start_duplicate(store, session_id, datetime.now(UTC))
-        ):
+        if session_id and _session_start_duplicate(store, session_id, datetime.now(UTC)):
             print(json.dumps({}))
             return
 
         # Own try/except, like the ratification nudge below: telemetry must never cost the
         # map, which is this hook's only real deliverable.
         try:
-            if isinstance(session_id, str) and session_id:
+            if session_id:
                 # D7.3 (staleness-machinery wave, E8: author=None session=None on
                 # Stop-channel captures): this write is now UNCONDITIONAL — no longer
                 # gated on telemetry_enabled() — because capture._propose_one falls back
@@ -272,6 +306,8 @@ def session_start() -> None:
                     TELEMETRY_SESSION_KEY,
                     f"{session_id}|{datetime.now(UTC).isoformat()}",
                 )
+                if session_group:
+                    store.set_meta(TELEMETRY_SESSION_GROUP_KEY, session_group)
             # Pruning is deliberately NOT gated on telemetry_enabled() (practitioner
             # re-review round 2): it used to be, which meant opting out froze the 30-day
             # retention of whatever journal already existed — an opt-out that makes the
@@ -416,7 +452,7 @@ def stop() -> None:
         if payload.get("stop_hook_active"):
             print(json.dumps({}))
             return
-        session_id = payload.get("session_id")
+        session_id, _ = _session_identity(payload)
         if not session_id:
             print(json.dumps({}))
             return
@@ -540,8 +576,8 @@ def _record_touch_event(payload: dict) -> None:
         tool = payload.get("tool_name")
         if tool not in _TOUCH_TOOLS:
             return
-        session_id = payload.get("session_id")
-        if not isinstance(session_id, str) or not session_id:
+        session_id, _ = _session_identity(payload)
+        if not session_id:
             return
         root = os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
         path = _touch_path(payload.get("tool_input"), root)
@@ -684,7 +720,7 @@ def pre_tool_use() -> None:
         if not _looks_like_source_target(payload.get("tool_input")):
             print(json.dumps({}))
             return
-        session_id = payload.get("session_id")
+        session_id, _ = _session_identity(payload)
         if not session_id:
             print(json.dumps({}))
             return

{sidegraph-0.3.0 → sidegraph-0.3.1}/tests/test_host_drift_nudge.py

@@ -41,8 +41,11 @@ def _assistant(text="ok"):
     }
 
 
-def _transcript(tmp_path, real_prompts=2):
-    path = tmp_path / "transcript.jsonl"
+def _transcript(tmp_path, real_prompts=2, name="s1"):
+    # Named after the session, as both hosts do (Claude Code: `<session_id>.jsonl`; Codex:
+    # the per-thread rollout file) — hooks._session_identity takes the session from this
+    # path, so two sessions sharing one file name would share their per-session ledgers.
+    path = tmp_path / f"{name}.jsonl"
     with open(path, "w") as fh:
         for _ in range(real_prompts):
             fh.write(json.dumps(_user_prompt()) + "\n")
@@ -123,7 +126,7 @@ def test_session_start_survives_refresh_raising(tmp_path, monkeypatch, capsys):
 
 
 def _stop_payload(tmp_path, session="s1"):
-    return {"session_id": session, "transcript_path": _transcript(tmp_path)}
+    return {"session_id": session, "transcript_path": _transcript(tmp_path, name=session)}
 
 
 @pytest.mark.parametrize("n", [5, 10**6])
@@ -175,12 +178,12 @@ def test_stop_refresh_runs_after_substance_gate_only(tmp_path, monkeypatch, caps
     refresh calls — no git work on trivial sessions — and a substantial one makes ≥1.
     The ≥1 half is the honest red half against unfixed code."""
     calls = _fake_refresh(monkeypatch, 1)
-    gated = {"session_id": "s-gated", "transcript_path": _transcript(tmp_path, real_prompts=1)}
+    gated = {"session_id": "s-gated", "transcript_path": _transcript(tmp_path, 1, "s-gated")}
     out = _run_stop(monkeypatch, capsys, gated, tmp_path / ".sidegraph")
     assert out == {}
     assert len(calls) == 0
 
-    substantial = {"session_id": "s-full", "transcript_path": _transcript(tmp_path)}
+    substantial = {"session_id": "s-full", "transcript_path": _transcript(tmp_path, name="s-full")}
     out = _run_stop(monkeypatch, capsys, substantial, tmp_path / ".sidegraph")
     assert out["decision"] == "block"
     assert len(calls) == 1

{sidegraph-0.3.0 → sidegraph-0.3.1}/tests/test_host_pretool.py

@@ -344,3 +344,36 @@ def test_title_is_clipped_and_sanitised(tmp_path, monkeypatch, capsys):
     assert "\n" not in text
     assert text.count('"') == 2  # exactly the pair this nudge adds
     assert "…" in text
+
+
+# -- Codex: one umbrella session id, several threads ----------------------------------------
+#
+# Codex's payload `session_id` is the workspace session, not this session: it spans days and
+# covers every thread under it (see hooks._session_identity). The one-shot ledger is keyed on
+# the session, so reading that field directly spent the nudge for a whole workspace on the
+# first thread that read a file.
+
+_CODEX_ROLLOUTS = (
+    "/w/.codex/sessions/2026/09/19/rollout-2026-09-19T12-00-31-01a0b953-2d7c.jsonl",
+    "/w/.codex/sessions/2026/09/19/rollout-2026-09-19T12-16-06-01a0b961-7463.jsonl",
+)
+
+
+def test_each_codex_thread_gets_its_own_nudge(tmp_path, monkeypatch, capsys):
+    """Red against a ledger keyed on payload['session_id']: the second thread — a different
+    session reporting the same umbrella id — was silently treated as already nudged."""
+    db = tmp_path / "s.db"
+    _seed_one_decision(db)
+    umbrella = "01a0b3e2-39d2-7180-86a5-408a6f9ce058"
+
+    outs = [
+        _run(
+            monkeypatch,
+            capsys,
+            dict(READ_PAYLOAD, session_id=umbrella, transcript_path=rollout),
+            db,
+        )
+        for rollout in _CODEX_ROLLOUTS
+    ]
+
+    assert all("hookSpecificOutput" in out for out in outs), outs

{sidegraph-0.3.0 → sidegraph-0.3.1}/tests/test_host_session_key.py

@@ -144,3 +144,96 @@ def test_a_prune_failure_does_not_cost_the_session_map(tmp_path, monkeypatch, ca
     out = json.loads(capsys.readouterr().out)
 
     assert "hookSpecificOutput" in out, "the map must survive a telemetry failure"
+
+
+# -- Codex: session identity comes from the transcript, not the host's session_id ----------
+#
+# Measured 2026-09-19 on two live stores. Claude Code's `session_id` is per session and its
+# transcript is named after it: all 74 session ids in this repo's own store are exactly
+# transcript stems. Codex's `session_id` is the umbrella workspace session — it spans days,
+# survives resume, and covers every thread beneath it: 1928 of 1929 events in a second live
+# store landed in ONE bucket across 27 hours, while each thread had its own rollout file.
+# Codex's SessionStart payload carries no thread id and no agent_type (schema
+# `session-start.command.input`), so `transcript_path` is the only field that identifies a
+# session on both hosts.
+
+
+def _codex_payload(rollout: str, umbrella: str = "01a0b3e2-39d2-7180-86a5-408a6f9ce058"):
+    """A Codex SessionStart payload: one umbrella id, one per-thread rollout file."""
+    return {
+        "session_id": umbrella,
+        "source": "startup",
+        "transcript_path": f"/w/.codex/sessions/2026/09/19/{rollout}.jsonl",
+        "cwd": "/w/project",
+    }
+
+
+def test_two_codex_threads_sharing_one_umbrella_id_are_two_sessions(tmp_path, monkeypatch, capsys):
+    """The defect, red against reading payload['session_id']: two Codex threads report the
+    same umbrella `session_id`, so every event from both was attributed to one session and
+    the second thread's SessionStart was swallowed by the 60s double-injection dedupe."""
+    db = tmp_path / "db"
+    keys = []
+    for rollout in (
+        "rollout-2026-09-19T12-00-31-01a0b953-2d7c-76e3-9dac-7d375dad7954",
+        "rollout-2026-09-19T12-16-06-01a0b961-7463-7b21-bd3b-bab64d9d5d8b",
+    ):
+        _run_session_start(monkeypatch, capsys, _codex_payload(rollout), db)
+        store = Store(db)
+        raw = store.get_meta(hooks.TELEMETRY_SESSION_KEY)
+        store.close()
+        assert raw is not None
+        keys.append(raw.partition("|")[0])
+
+    assert keys[0] != keys[1], "two threads under one umbrella id must be two sessions"
+    assert keys[1].endswith("01a0b961-7463-7b21-bd3b-bab64d9d5d8b")
+
+
+def test_the_umbrella_id_is_kept_so_codex_threads_can_be_grouped(tmp_path, monkeypatch, capsys):
+    """The workspace session is the only link between a Codex thread and its siblings, so it
+    is recorded beside the key rather than discarded."""
+    db = tmp_path / "db"
+    _run_session_start(
+        monkeypatch, capsys, _codex_payload("rollout-2026-09-19T12-16-06-01a0b961-7463"), db
+    )
+
+    store = Store(db)
+    group = store.get_meta(hooks.TELEMETRY_SESSION_GROUP_KEY)
+    store.close()
+
+    assert group == "01a0b3e2-39d2-7180-86a5-408a6f9ce058"
+
+
+def test_claude_code_keeps_the_session_id_it_already_recorded(tmp_path, monkeypatch, capsys):
+    """No-regression control, and the reason this change is safe to ship: under Claude Code
+    the transcript stem IS the session id, so the recorded key does not move and no group
+    key is written (there is no umbrella above a Claude Code session)."""
+    db = tmp_path / "db"
+    sid = "134960fe-2641-48d5-aaf7-223d9129df38"
+    _run_session_start(
+        monkeypatch,
+        capsys,
+        {"session_id": sid, "transcript_path": f"/w/.claude/projects/repo/{sid}.jsonl"},
+        db,
+    )
+
+    store = Store(db)
+    raw = store.get_meta(hooks.TELEMETRY_SESSION_KEY)
+    group = store.get_meta(hooks.TELEMETRY_SESSION_GROUP_KEY)
+    store.close()
+
+    assert raw is not None and raw.partition("|")[0] == sid
+    assert group is None
+
+
+def test_a_null_transcript_path_falls_back_to_the_session_id(tmp_path, monkeypatch, capsys):
+    """`transcript_path` is nullable in Codex's own schema, so its absence must leave the
+    previous behaviour exactly as it was rather than record nothing."""
+    db = tmp_path / "db"
+    _run_session_start(monkeypatch, capsys, {"session_id": "abc-123", "transcript_path": None}, db)
+
+    store = Store(db)
+    raw = store.get_meta(hooks.TELEMETRY_SESSION_KEY)
+    store.close()
+
+    assert raw is not None and raw.partition("|")[0] == "abc-123"

{sidegraph-0.3.0 → sidegraph-0.3.1}/tests/test_host_stop.py

@@ -73,7 +73,8 @@ def _substantial(tmp_path, name="transcript.jsonl"):
 
 def test_first_stop_blocks_with_nudge_and_marks_ledger(tmp_path, monkeypatch, capsys):
     db = tmp_path / "s.db"
-    transcript = _substantial(tmp_path)
+    # Named after the session, as both hosts do — the ledger key comes from this path.
+    transcript = _substantial(tmp_path, name="s1.jsonl")
     out = _run(
         monkeypatch,
         capsys,
@@ -273,7 +274,7 @@ def test_one_shot_session_with_tool_work_arms_the_gate(tmp_path, monkeypatch, ca
         [_user_prompt()] + [_assistant_tool_use() for _ in range(hooks._MIN_TOOL_USES)],
         "sdk-cli",
     )
-    transcript = _write_transcript(tmp_path / "transcript.jsonl", entries)
+    transcript = _write_transcript(tmp_path / "os1.jsonl", entries)
     out = _run(
         monkeypatch,
         capsys,
@@ -707,3 +708,31 @@ def test_stop_hook_honors_legacy_sidegraph_db_with_deprecation_notice(
 
     assert "SIDEGRAPH_DB is deprecated" in captured.err
     assert "SIDEGRAPH_DIR" in captured.err
+
+
+def test_each_codex_thread_earns_its_own_capture_nudge(tmp_path, monkeypatch, capsys):
+    """The capture ledger is per session, and Codex reports one umbrella `session_id` for
+    every thread under a workspace (hooks._session_identity). Red against reading that field
+    directly: the first thread to finish spent the nudge for all of them — a day of Codex
+    threads got one capture prompt between them."""
+    db = tmp_path / "s.db"
+    umbrella = "01a0b3e2-39d2-7180-86a5-408a6f9ce058"
+    outs = []
+    for thread in (
+        "rollout-2026-09-19T12-00-31-01a0b953-2d7c",
+        "rollout-2026-09-19T12-16-06-01a0b961-7463",
+    ):
+        outs.append(
+            _run(
+                monkeypatch,
+                capsys,
+                {
+                    "session_id": umbrella,
+                    "stop_hook_active": False,
+                    "transcript_path": _substantial(tmp_path, name=f"{thread}.jsonl"),
+                },
+                db,
+            )
+        )
+
+    assert [out.get("decision") for out in outs] == ["block", "block"], outs

{sidegraph-0.3.0 → sidegraph-0.3.1}/tests/test_host_touch_events.py

@@ -251,3 +251,28 @@ def test_a_store_failure_does_not_break_the_hook(tmp_path, monkeypatch, capsys):
         root,
     )
     assert isinstance(out, dict)  # valid JSON, hook did not crash
+
+
+def test_a_codex_touch_is_recorded_against_its_thread_not_the_workspace(
+    tmp_path, monkeypatch, capsys
+):
+    """Codex's payload `session_id` is the umbrella workspace session — stable across days and
+    every thread beneath it (hooks._session_identity). Recording against it put a whole
+    store's history in one bucket: 1928 of 1929 events in a live store, across 27 hours.
+    Red against reading that field directly."""
+    db = tmp_path / "db"
+    root = tmp_path
+    (root / "a.py").write_text("x = 1\n")
+    umbrella = "01a0b3e2-39d2-7180-86a5-408a6f9ce058"
+    thread = "rollout-2026-09-19T12-16-06-01a0b961-7463"
+    payload = {
+        "session_id": umbrella,
+        "tool_name": "Read",
+        "tool_input": {"file_path": str(root / "a.py")},
+        "transcript_path": f"/w/.codex/sessions/2026/09/19/{thread}.jsonl",
+    }
+
+    _run(monkeypatch, capsys, payload, db, root)
+
+    assert _events(db, umbrella) == []
+    assert len(_events(db, thread)) == 1

{sidegraph-0.3.0 → sidegraph-0.3.1}/uv.lock

@@ -1293,7 +1293,7 @@ wheels = [
 
 [[package]]
 name = "sidegraph"
-version = "0.3.0"
+version = "0.3.1"
 source = { editable = "." }
 dependencies = [
     { name = "fastmcp" },