agentwire-dev 1.80.0__tar.gz → 1.80.1__tar.gz

{agentwire_dev-1.80.0 → agentwire_dev-1.80.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentwire-dev
-Version: 1.80.0
+Version: 1.80.1
 Summary: Multi-session voice web interface for AI coding agents
 Project-URL: Homepage, https://agentwire.dev
 Project-URL: Repository, https://github.com/dotdevdotdev/agentwire-dev

{agentwire_dev-1.80.0 → agentwire_dev-1.80.1}/agentwire/__init__.py

@@ -1,3 +1,3 @@
 """AgentWire - Multi-session voice web interface for AI coding agents."""
 
-__version__ = "1.80.0"
+__version__ = "1.80.1"

{agentwire_dev-1.80.0 → agentwire_dev-1.80.1}/agentwire/core.py

@@ -1563,6 +1563,23 @@ def record_session_launch(
     return metadata
 
 
+def session_owns_cwd(metadata: dict, cwd: str) -> bool:
+    """Whether *cwd* is where the recorded session runs (#1289).
+
+    Compared as Claude keys history: the physical path through
+    ``history.encode_project_path``, against ``cwd_at_launch`` and
+    ``worktree_path``. A nested ``claude -p`` started from a pane in a scratch
+    directory fails this, which keeps its conversation out of the chain.
+    """
+    from .history import encode_project_path
+
+    def key(path: str) -> str:
+        return encode_project_path(os.path.realpath(path))
+
+    owned = {key(p) for p in (metadata.get("cwd_at_launch"), metadata.get("worktree_path")) if p}
+    return key(cwd) in owned
+
+
 def record_conversation_change(session_name: str, conversation_id: str) -> bool:
     """Make *conversation_id* the session's CURRENT conversation (#1271).
 

{agentwire_dev-1.80.0 → agentwire_dev-1.80.1}/agentwire/doctor_cli.py

@@ -1011,6 +1011,10 @@ def _render_orphaned_history_section() -> int:
                   + ("   [moved since launch]" if f["moved"] else ""))
             print(f"         history:  {f['found_at']}")
             print(f"         expected: {f['expected_dir']}/")
+        print("       Ids whose history sits under scratch directories are nested "
+              "`claude -p` runs a worker made from its pane: before #1289 the "
+              "session-start hook recorded them into the chain. The session's own "
+              "conversation is the one keyed to its launch cwd.")
         print("       Recover with `agentwire history migrate` — the transcripts are "
               "intact, just keyed to the old path. Until then `agentwire restart` on a "
               "'current conversation' one starts FRESH (role intact) rather than "

{agentwire_dev-1.80.0 → agentwire_dev-1.80.1}/agentwire/hooks_cli.py

@@ -757,7 +757,7 @@ def record_session_start(payload: dict) -> str:
     :func:`cmd_hooks_session_start` is the one place that turns that into exit 0.
     """
     from . import pane_manager
-    from .core import record_conversation_change
+    from .core import load_session_metadata, record_conversation_change, session_owns_cwd
 
     conversation_id = payload.get("session_id")
     if not isinstance(conversation_id, str) or not conversation_id:
@@ -771,6 +771,16 @@ def record_session_start(payload: dict) -> str:
         return f"skipped: worker pane {session}.{pane_index}"
 
     source = payload.get("source", "?")
+    # A headless `claude -p` started from this pane inherits $TMUX_PANE and fires
+    # this same hook with source=startup, indistinguishable from a real start
+    # except by its cwd (#1289).
+    payload_cwd = payload.get("cwd")
+    if not isinstance(payload_cwd, str) or not payload_cwd:
+        return f"ignored: payload has no cwd, cannot tell {session}'s conversation from a nested run"
+    metadata = load_session_metadata(session)
+    if metadata.get("cwd_at_launch") and not session_owns_cwd(metadata, payload_cwd):
+        return (f"ignored: {conversation_id} ran in {payload_cwd}, not {session}'s "
+                f"{metadata['cwd_at_launch']} (nested run, source={source})")
     if record_conversation_change(session, conversation_id):
         return f"recorded {conversation_id} for {session} (source={source})"
     return f"unchanged: {session} already at {conversation_id} or has no launch record"

{agentwire_dev-1.80.0 → agentwire_dev-1.80.1}/docs/wiki/sessions/conversation-identity.md

@@ -291,6 +291,19 @@ carrying the new `session_id`) reports each change:
   because the tail is what restart reads as "current"). Already-last is a no-op,
   so it is idempotent and the launch's own id costs nothing. A session with no
   launch record is left alone: the hook never conjures a partial record.
+- **Only the session's own conversations count (#1289).** A headless
+  `claude -p` run from a pane (a worker's comparison or spike in a scratch dir)
+  inherits `$TMUX_PANE` and fires the same hook. Verified payload shape:
+  `{session_id, transcript_path, cwd, hook_event_name, source}` — `cwd` is the
+  physical path, and a headless run reports `source: "startup"`, identical to a
+  real start, so **`source` is no signal**; `cwd` is. The hook records an id
+  only when `core.session_owns_cwd` says the payload `cwd` (through
+  `history.encode_project_path` of the realpath) equals the recorded
+  `cwd_at_launch` or `worktree_path`. A mismatch, or a payload with no `cwd`,
+  is ignored and the reason goes to the debug log. Chains polluted before this
+  fix keep their stray ids (`restart` skips ids with no transcript under the
+  launch cwd, so they are inert there); `doctor`'s orphaned-history output
+  names nested runs as the likely cause.
 - Errors are logged to `/tmp/claude-hook-debug.log`, never raised.
 
 `restart`'s newest-first walk is unchanged: a `/clear`ed conversation that

{agentwire_dev-1.80.0 → agentwire_dev-1.80.1}/tests/unit/test_conversation_change.py

@@ -24,6 +24,7 @@ def store(tmp_path, monkeypatch):
     cwd = tmp_path / "worktree"
     cwd.mkdir()
     (tmp_path / "projects").mkdir()
+    _STORE_CWD[0] = cwd
     return types.SimpleNamespace(root=tmp_path, cwd=cwd, projects=tmp_path / "projects")
 
 
@@ -51,8 +52,14 @@ def launch(store, session="sess"):
     return agent.conversation_id
 
 
-def session_start(cid, source="clear"):
-    return hooks_cli.record_session_start({"session_id": cid, "source": source})
+def session_start(cid, source="clear", cwd=None):
+    """The real SessionStart payload: session_id, transcript_path, cwd, source."""
+    return hooks_cli.record_session_start(
+        {"session_id": cid, "source": source, "cwd": str(cwd or _STORE_CWD[0])}
+    )
+
+
+_STORE_CWD: list = [None]
 
 
 def chain(session="sess"):
@@ -107,6 +114,28 @@ def test_the_hook_is_idempotent_and_resume_moves_an_old_id_to_the_tail(store, pa
     assert chain() == ["b", launched]
 
 
+def test_a_nested_headless_run_from_another_cwd_never_joins_the_chain(store, pane):
+    """#1289: `claude -p` in a scratch dir inherits $TMUX_PANE and fires the hook
+    with source=startup, same as a real start. Only its cwd differs."""
+    launched = launch(store)
+    scratch = store.root / "scratchpad-neutral"
+    scratch.mkdir()
+    link = store.root / "link-to-worktree"
+    link.symlink_to(store.cwd)
+
+    outcomes = [
+        session_start("nested", source="startup", cwd=scratch),
+        hooks_cli.record_session_start({"session_id": "no-cwd", "source": "startup"}),
+    ]
+    assert all(o.startswith("ignored") for o in outcomes), outcomes
+    assert "scratchpad-neutral" in outcomes[0]  # the reason is logged
+    assert chain() == [launched]
+
+    # The session's own /clear still lands, even reported through a symlink.
+    assert session_start("real-clear", cwd=link).startswith("recorded")
+    assert chain() == [launched, "real-clear"]
+
+
 def test_the_hook_never_writes_outside_its_own_session_record(store, pane):
     launch(store)
     before = chain()
@@ -135,7 +164,7 @@ def test_the_hook_command_exits_zero_on_every_bad_input(store, pane, monkeypatch
         raise OSError("read-only store")
 
     monkeypatch.setattr("agentwire.core.store_session_metadata", boom)
-    monkeypatch.setattr("sys.stdin", io.StringIO(json.dumps({"session_id": "new"})))
+    monkeypatch.setattr("sys.stdin", io.StringIO(json.dumps({"session_id": "new", "cwd": str(store.cwd)})))
     codes.append(hooks_cli.cmd_hooks_session_start(types.SimpleNamespace()))
 
     assert codes == [0] * len(codes)