agentwire-dev 1.78.0__tar.gz → 1.79.0__tar.gz

{agentwire_dev-1.78.0 → agentwire_dev-1.79.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentwire-dev
-Version: 1.78.0
+Version: 1.79.0
 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.78.0 → agentwire_dev-1.79.0}/agentwire/__init__.py

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

{agentwire_dev-1.78.0 → agentwire_dev-1.79.0}/agentwire/core.py

@@ -1550,6 +1550,40 @@ def record_session_launch(
     return metadata
 
 
+def record_conversation_change(session_name: str, conversation_id: str) -> bool:
+    """Make *conversation_id* the session's CURRENT conversation (#1271).
+
+    :func:`record_session_launch` writes the chain once, at launch. Claude
+    mints a new id inside a running session on ``/clear`` and switches ids on
+    ``/resume``, and nothing at launch can know — so the SessionStart hook
+    reports each change here, and ``restart``'s newest-first chain walk works
+    unchanged.
+
+    The id ends up LAST in the chain: a fresh id is appended, and an id already
+    recorded (a ``/resume`` back to an earlier conversation) is moved to the
+    tail, because the walk reads the tail as "what the session is in now".
+    Already-last is a no-op that writes nothing, so the hook is idempotent and
+    the launch's own record (which fires the same id) costs nothing.
+
+    Returns whether the record changed. A session with no launch record is left
+    alone (False) — this must never conjure a partial record that
+    ``recorded_sessions`` and ``doctor`` would then take for a launched
+    session. Raises ``OSError`` if the write doesn't land (see
+    :func:`store_session_metadata`); the hook decides what to do about that.
+    """
+    metadata = load_session_metadata(session_name)
+    if not metadata.get("cwd_at_launch"):
+        return False
+
+    chain = list(metadata.get("conversation_ids") or [])
+    if chain and chain[-1] == conversation_id:
+        return False
+
+    metadata["conversation_ids"] = [c for c in chain if c != conversation_id] + [conversation_id]
+    store_session_metadata(session_name, metadata)
+    return True
+
+
 def notify_portal_session_created(session_name: str, parent: str | None, role: str | None) -> None:
     """Tell the portal a session was just created, with topology context (#747).
 

{agentwire_dev-1.78.0 → agentwire_dev-1.79.0}/agentwire/doctor_cli.py

@@ -497,6 +497,8 @@ def _render_damage_control_section(fix: bool = False) -> int:
             print(f"  [{mark}] {finding['message']}")
             if finding["level"] == "bad":
                 issues += 1
+            if finding["code"] == "stale-ruleset":
+                print("       Fix: agentwire safety install --refresh   (prints the diff and acknowledges it)")
         if not package_status["ok"]:
             print("       Fix: agentwire hooks install   (or: agentwire doctor --fix)")
             print("       Blocked outright? From a normal terminal (not through Claude Code):")
@@ -534,11 +536,9 @@ def _render_damage_control_section(fix: bool = False) -> int:
 
     # Rules and tooldefs ship inside the package; what lives on the machine is the host's
     # own overlay. A file there REPLACES the bundled one of the same name, so name each.
-    for section, groups in safety_migrate.classify().items():
-        named = groups["pristine"] + groups["edited"]
-        if named:
-            print(f"  [..] Your {section} overlay replaces bundled files: {', '.join(named)}")
-            print("       Fix: agentwire safety migrate   (removes pristine copies, keeps your edits)")
+    overlay_plan = safety_migrate.classify()
+    for line in safety_migrate.overlay_report_lines(overlay_plan):
+        print(line)
 
     # Rule groups and packs (#1141): informational only, never scored — a
     # disabled pack is a choice, not drift.
@@ -580,7 +580,7 @@ def _render_damage_control_section(fix: bool = False) -> int:
         print(f"  [!!] DUPLICATE rule ids in the loaded rule set: {', '.join(duplicates)}")
         print("       `disabled_rules` / `unattended_allow` naming one of these names")
         print("       BOTH rules. Usually a half-applied rule sync.")
-        print("       Fix: agentwire safety install --yes")
+        print(f"       Fix: {safety_migrate.duplicate_ids_fix(overlay_plan)}")
         issues += 1
     else:
         print("  [ok] Rule ids unique across the loaded rule set")
@@ -936,6 +936,56 @@ def scan_orphaned_history(sessions: list[str] | None = None) -> list[dict]:
     return findings
 
 
+def scan_unrecorded_transcripts(sessions: list[str] | None = None) -> list[dict]:
+    """Live sessions whose project dir holds transcripts newer than the recorded head (#1271).
+
+    The SessionStart hook keeps ``conversation_ids`` current across ``/clear``
+    and ``/resume``; a session that took one BEFORE the hook was installed has
+    a chain that stops at its launch id, and ``restart`` would resume that
+    stale conversation. The evidence is on disk: transcripts in the session's
+    history dir, absent from the chain, written after the head's own.
+
+    STATED, never scored, because it cannot be certain: the history dir is
+    keyed by cwd, so a second session sharing the directory writes transcripts
+    that look identical. The finding lists the candidates and says so. Live
+    sessions only — the ones you might actually restart.
+    """
+    from .core import load_session_metadata, recorded_sessions
+    from .history import claude_projects_dir, history_key_candidates
+
+    findings: list[dict] = []
+    for name in sessions if sessions is not None else recorded_sessions():
+        metadata = load_session_metadata(name)
+        ids = list(metadata.get("conversation_ids") or [])
+        cwd = metadata.get("cwd_at_launch")
+        if not ids or not cwd or not tmux_session_exists(name):
+            continue
+
+        for key in history_key_candidates(cwd):
+            project = claude_projects_dir() / key
+            try:
+                head = project / f"{ids[-1]}.jsonl"
+                baseline = head.stat().st_mtime if head.exists() else None
+                if baseline is None:
+                    continue  # no head transcript to be newer than
+                newer = sorted(
+                    (f for f in project.glob("*.jsonl")
+                     if f.stem not in ids and f.stat().st_mtime > baseline),
+                    key=lambda f: f.stat().st_mtime,
+                )
+            except OSError:
+                continue
+            if newer:
+                findings.append({
+                    "session": name,
+                    "head": ids[-1],
+                    "newer": [f.stem for f in newer],
+                    "project_dir": str(project),
+                })
+                break
+    return findings
+
+
 def _render_orphaned_history_section() -> int:
     """Doctor section: conversations a restart could not bring back (#871).
 
@@ -975,6 +1025,18 @@ def _render_orphaned_history_section() -> int:
         print("       Not a fault. Restarting these keeps the role and starts a fresh "
               "conversation.")
 
+    unrecorded = scan_unrecorded_transcripts()
+    if unrecorded:
+        print(f"  [..] {len(unrecorded)} live session(s) with transcripts newer than the "
+              "recorded conversation:")
+        for f in unrecorded:
+            print(f"       - {f['session']}: recorded head {f['head'][:8]}, newer "
+                  f"{', '.join(c[:8] for c in f['newer'])}")
+        print("       Likely a /clear or /resume taken before the session-start hook was "
+              "installed (`agentwire hooks install`): `agentwire restart` would resume the "
+              "recorded head, not the newer conversation. Not scored — another session in "
+              "the same directory writes transcripts that look the same.")
+
     return len(orphaned)
 
 

agentwire_dev-1.79.0/agentwire/hooks/session-start-handler.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# Claude Code SessionStart hook (source: startup|resume|clear|compact).
+#
+# Claude mints a new conversation id on /clear and switches ids on /resume;
+# nothing at launch can know. This reports the id to the owning agentwire
+# session's record so `agentwire restart` resumes the CURRENT conversation
+# (#1271). The logic lives in `agentwire hooks session-start` (CLI is SSOT);
+# this wrapper only hands over the payload.
+#
+# Never blocks the session start and never fails it: the work runs detached
+# and the script exits 0 unconditionally.
+
+DEBUG_LOG="/tmp/claude-hook-debug.log"
+AGENTWIRE="${AGENTWIRE_BIN:-$(which agentwire 2>/dev/null || echo "$HOME/.local/bin/agentwire")}"
+
+input=$(cat)
+[[ -n "$TMUX_PANE" ]] || exit 0
+
+(
+  printf '%s' "$input" | "$AGENTWIRE" hooks session-start 2>&1 \
+    | sed "s|^|[$(date -Iseconds)] session-start: |" >> "$DEBUG_LOG"
+) </dev/null >/dev/null 2>&1 &
+exit 0

{agentwire_dev-1.78.0 → agentwire_dev-1.79.0}/agentwire/hooks_cli.py

@@ -382,6 +382,13 @@ def _managed_hook_files() -> list[ManagedHook]:
             ("PostToolUse", "PostToolUseFailure", "PermissionDenied"),
             "Outcome logger", True, "required for damage-control audit outcomes",
         ),
+        # Reports Claude's in-session conversation changes (/clear, /resume,
+        # compact) into the launch record so `restart` resumes the CURRENT one.
+        ManagedHook(
+            "session-start-handler.sh", claude_hooks_dir(), ("SessionStart",),
+            "Session-start hook", True,
+            "required for `agentwire restart` to resume after /clear or /resume",
+        ),
         ManagedHook(
             "queue-processor.sh", Path.home() / ".agentwire", (),
             "Queue processor", True, "required for notification queuing",
@@ -740,6 +747,54 @@ def cmd_hooks_status(args) -> int:
     return 0
 
 
+def record_session_start(payload: dict) -> str:
+    """Apply one SessionStart payload to the owning session's record (#1271).
+
+    Returns a one-line outcome for the hook log. The owning session is resolved
+    from the PANE, and only pane 0 counts: a worker pane (index > 0) is not a
+    session and its conversation must never overwrite its owner's chain — the
+    same rule ``spawn`` and prompt routing apply. Raises on a failed write;
+    :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
+
+    conversation_id = payload.get("session_id")
+    if not isinstance(conversation_id, str) or not conversation_id:
+        return "skipped: payload has no session_id"
+
+    session = pane_manager.get_current_session()
+    pane_index = pane_manager.get_current_pane_index()
+    if not session or pane_index is None:
+        return "skipped: not in a tmux pane"
+    if pane_index > 0:
+        return f"skipped: worker pane {session}.{pane_index}"
+
+    source = payload.get("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"
+
+
+def cmd_hooks_session_start(args) -> int:
+    """Claude Code SessionStart hook body: payload on stdin, ALWAYS exits 0.
+
+    A hook that can fail a session start is worse than a stale chain, so every
+    error — unreadable payload, tmux gone, store unwritable — is logged to
+    stderr (the hook script routes that to the debug log) and swallowed.
+    """
+    import sys
+
+    try:
+        payload = json.loads(sys.stdin.read() or "{}")
+        if not isinstance(payload, dict):
+            raise ValueError("payload is not a JSON object")
+        print(record_session_start(payload), file=sys.stderr)
+    except Exception as e:
+        print(f"session-start hook error: {type(e).__name__}: {e}", file=sys.stderr)
+    return 0
+
+
 def register_hooks_parser(subparsers) -> None:
     hooks_parser = subparsers.add_parser(
         "hooks", help="Manage agentwire hook files (permission, idle handler, queue processor)"
@@ -775,3 +830,10 @@ def register_hooks_parser(subparsers) -> None:
         "status", help="Check hook installation status"
     )
     hooks_status.set_defaults(func=cmd_hooks_status)
+
+    # hooks session-start (invoked by the SessionStart hook, not by humans)
+    hooks_session_start = hooks_subparsers.add_parser(
+        "session-start",
+        help="SessionStart hook body: record the new conversation id (reads the payload on stdin; always exits 0)",
+    )
+    hooks_session_start.set_defaults(func=cmd_hooks_session_start)

{agentwire_dev-1.78.0 → agentwire_dev-1.79.0}/agentwire/safety_cli.py

@@ -54,6 +54,7 @@ def cmd_safety_install(args) -> int:
         assume_yes=getattr(args, "yes", False),
         force=getattr(args, "force", False),
         allow_foreign=getattr(args, "allow_foreign_source", False),
+        refresh=getattr(args, "refresh", False),
     )
 
 
@@ -163,6 +164,10 @@ def register_safety_parser(subparsers) -> None:
         "--force", action="store_true",
         help="Override the downgrade refusal (this package is older than the recorded install)",
     )
+    safety_install.add_argument(
+        "--refresh", action="store_true",
+        help="Print and acknowledge the ruleset diff since the last install (loosening is marked !!)",
+    )
     safety_install.add_argument(
         "--allow-foreign-source", action="store_true",
         help="Let a checkout that is NOT the installed tool write these "

{agentwire_dev-1.78.0 → agentwire_dev-1.79.0}/agentwire/safety_commands.py

@@ -606,16 +606,18 @@ def safety_install_cmd(
     assume_yes: bool = False,
     force: bool = False,
     allow_foreign: bool = False,
+    refresh: bool = False,
 ) -> int:
     """CLI command: ``agentwire safety install``: the package's ``init`` under AgentWire's profile.
 
-    Without ``--yes`` it asks once first. Returns non-zero on any refusal, so a script can never
-    read a refusal as success (the whole of #936's operator picture).
+    Without ``--yes`` it asks once first (``--refresh`` only prints and acknowledges the ruleset
+    diff, so it does not ask). Returns non-zero on any refusal, so a script can never read a
+    refusal as success (the whole of #936's operator picture).
     """
-    if not assume_yes:
+    if not assume_yes and not refresh:
         print("This registers the damage-control hooks (damage-control-dev) in Claude Code's user settings:")
         print(f"  {sys.executable} -I -m damage_control.hook <bash|edit|write|read|mcp>")
         if input("Proceed with installation? [y/N] ").strip().lower() != "y":
             print("Installation cancelled.")
             return 0
-    return safety_ext.install(force=force, allow_foreign=allow_foreign).code
+    return safety_ext.install(force=force, allow_foreign=allow_foreign, refresh=refresh).code

{agentwire_dev-1.78.0 → agentwire_dev-1.79.0}/agentwire/safety_migrate.py

@@ -6,7 +6,9 @@ REPLACES the bundled file of the same name (a stale copy is not protection, it i
 a script registration runs code that no longer ships. This command classifies what is on the
 machine with ``rule_baselines.json`` (the sha256 of every version we ever shipped):
 
-* an overlay file matching a shipped hash holds nothing the bundle lacks, so it is deleted;
+* an overlay file matching a shipped hash whose name the bundle still ships holds nothing the
+  bundle lacks, so it is deleted;
+* a shipped-hash file the bundle no longer ships (``gws.yaml``, #1143) stays: it may be the only copy;
 * any other overlay file is a human's edit, so it stays (and is named; it still overrides by name);
 * pack decisions that the old always-on files implied are recorded (``packs:`` in the policy);
 * registrations of the old scripts, and the scripts, are removed once the package hooks are
@@ -27,7 +29,12 @@ from typing import Any, Callable, Dict, List, Optional
 from damage_control import harness_config as hc
 from damage_control import install as dc_install
 from damage_control import packs
-from damage_control.engine import config_override_dir, policy_file_path
+from damage_control.engine import (
+    bundled_rule_sources,
+    bundled_tooldefs_dir,
+    config_override_dir,
+    policy_file_path,
+)
 
 from . import safety_ext
 
@@ -62,29 +69,74 @@ def _sha256(path: Path) -> Optional[str]:
 
 
 def _dirs() -> Dict[str, Path]:
+    safety_ext.activate()  # judge by AgentWire's profile: without it config_override_dir() is ~/.damage-control (#1268)
     base = config_override_dir()
     return {"rules": base / "damage-control", "tooldefs": base / "tooldefs"}
 
 
 def _legacy_dir() -> Path:
+    safety_ext.activate()
     return config_override_dir() / "hooks" / "damage-control"
 
 
+def bundled_names() -> Dict[str, set]:
+    """File names the CURRENT bundle provides: the engine's plus AgentWire's rules layer (#1269)."""
+    rule_sources = [*bundled_rule_sources(), safety_ext.RULES_DIR]
+    return {
+        "rules": {p.name for d in rule_sources for p in d.glob("*.yaml")},
+        "tooldefs": {p.name for p in bundled_tooldefs_dir().glob("*.yaml")},
+    }
+
+
 def classify() -> Dict[str, Dict[str, List[str]]]:
-    """``{section: {"pristine": [...], "edited": [...]}}`` for the shipped-named files on the machine."""
+    """``{section: {"pristine", "edited", "unbundled"}}`` for the shipped-named files on the machine.
+
+    ``pristine`` is redundant: it matches a version we shipped AND the bundle still provides that
+    name. ``unbundled`` matches a shipped version but the bundle no longer ships the name (baselines
+    keep retired history), so the copy may be the only protection there is and is never retired
+    (#1269). ``edited`` is a human's change.
+    """
     out: Dict[str, Dict[str, List[str]]] = {}
     baselines = load_baselines()
+    bundled = bundled_names()
     for section, live in _dirs().items():
-        pristine: List[str] = []
-        edited: List[str] = []
+        groups: Dict[str, List[str]] = {"pristine": [], "edited": [], "unbundled": []}
         for name, hashes in sorted(baselines[section].items()):
             target = live / name
-            if target.is_file():
-                (pristine if _sha256(target) in hashes else edited).append(name)
-        out[section] = {"pristine": pristine, "edited": edited}
+            if not target.is_file():
+                continue
+            if _sha256(target) not in hashes:
+                groups["edited"].append(name)
+            elif name in bundled[section]:
+                groups["pristine"].append(name)
+            else:
+                groups["unbundled"].append(name)
+        out[section] = groups
     return out
 
 
+def overlay_report_lines(plan: Dict[str, Dict[str, List[str]]]) -> List[str]:
+    """Doctor's overlay lines. Only a pristine copy has a Fix (migrate retires it); edited and
+    unbundled files are information, because migrate deliberately keeps them (#1270)."""
+    lines: List[str] = []
+    for section, groups in plan.items():
+        if groups["pristine"]:
+            lines.append(f"  [..] Redundant {section} copies of bundled files: {', '.join(groups['pristine'])}")
+            lines.append("       Fix: agentwire safety migrate   (removes the pristine copies)")
+        kept = groups["edited"] + groups["unbundled"]
+        if kept:
+            lines.append(f"  [..] Your {section} overlay replaces or adds to the bundle: {', '.join(kept)}")
+    return lines
+
+
+def duplicate_ids_fix(plan: Dict[str, Dict[str, List[str]]]) -> str:
+    """Legacy overlay copies shadow the bundle and are what duplicate rule ids come from on a
+    pre-package install; ``install`` does not touch them, ``migrate`` does (#1270)."""
+    if any(groups["pristine"] for groups in plan.values()):
+        return "agentwire safety migrate   (retires the old overlay copies that duplicate the bundle)"
+    return "agentwire safety install --yes"
+
+
 def legacy_files() -> List[Path]:
     return [p for name in LEGACY_HOOK_FILES if (p := _legacy_dir() / name).exists()]
 
@@ -170,6 +222,7 @@ def migrate(
     log: Callable[[str], None] = print,
 ) -> int:
     """Classify, install the package hooks, then retire what only the old install needed. Returns an exit code."""
+    safety_ext.activate()
     plan = classify()
     legacy = legacy_files()
     for section, groups in plan.items():
@@ -177,6 +230,8 @@ def migrate(
             log(f"{'would remove' if dry_run else 'remove'} {section[:-1]} copy {name} (the package ships it)")
         for name in groups["edited"]:
             log(f"keep {section[:-1]} {name}: edited, so it replaces the bundled file of that name")
+        for name in groups["unbundled"]:
+            log(f"keep {section[:-1]} {name}: the package no longer ships it, so this copy is the only one")
     for path in legacy:
         log(f"{'would remove' if dry_run else 'remove'} legacy hook script {path.name}")
     if dry_run:

{agentwire_dev-1.78.0 → agentwire_dev-1.79.0}/docs/wiki/sessions/conversation-identity.md

@@ -266,6 +266,43 @@ against the installed Claude Code, the same way #878 established tmux's
 mapping. Encoding only `/` (#892) produced a key no directory ever had for any
 path with a dot, underscore or space.
 
+## The chain follows the conversation, not just the launch (#1271)
+
+`record_session_launch` writes the chain **once**. Claude mints a new id inside
+a running session on `/clear` and switches ids on `/resume`, so a chain that
+only knew launches resumed a week-old conversation after six `/clear`s — the
+record named the id the session *started* with, not the one it was *in*. A
+single-launch test cannot see this; the bug only exists after a second step.
+
+A Claude Code `SessionStart` hook (`source`: `startup|resume|clear|compact`,
+carrying the new `session_id`) reports each change:
+
+- `hooks/session-start-handler.sh` is registered by `agentwire hooks install`
+  like the other managed hooks (drift checks in `hooks status` / `doctor`
+  included). It runs the work detached and exits 0 unconditionally — a hook
+  must never fail or slow a session start.
+- The body is `agentwire hooks session-start` (CLI is SSOT). It resolves the
+  owning session from `$TMUX_PANE` via `pane_manager`, **skips worker panes
+  (index > 0)** — a pane is not a session and must not write its owner's
+  chain, same rule as `spawn` — and calls `core.record_conversation_change`,
+  which uses the same atomic `store_session_metadata` write.
+- `record_conversation_change` puts the id **last** in the chain (an id already
+  present — `/resume` back to an earlier conversation — moves to the tail,
+  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.
+- Errors are logged to `/tmp/claude-hook-debug.log`, never raised.
+
+`restart`'s newest-first walk is unchanged: a `/clear`ed conversation that
+never took a turn has no transcript yet (written lazily), so the walk falls
+back to the previous id that does.
+
+**Sessions that took a `/clear` before the hook was installed** have a chain
+frozen at launch. `doctor` states (never scores) live sessions whose history
+dir holds transcripts newer than the recorded head and absent from the chain.
+It cannot be certain — another session in the same directory writes transcripts
+that look identical — hence a note, not a fault.
+
 ## Restarting in place
 
 `agentwire restart -s <session>` is the verb the record exists for: `/exit`,

agentwire_dev-1.79.0/tests/unit/test_conversation_change.py

@@ -0,0 +1,176 @@
+"""#1271: ``conversation_ids`` follows Claude's in-session id changes.
+
+A single-launch test cannot see this bug: the chain is written at launch, so a
+session that never ``/clear``s always restarts correctly. Every test here takes
+a SECOND step after the launch.
+"""
+
+import io
+import json
+import types
+
+import pytest
+
+from agentwire import doctor_cli, hooks_cli, restart_cli
+from agentwire.history import encode_project_path
+
+TURN = '{"type":"user","message":{"role":"user","content":"hi"}}\n'
+
+
+@pytest.fixture
+def store(tmp_path, monkeypatch):
+    monkeypatch.setattr("agentwire.core.CONFIG_DIR", tmp_path / "agentwire")
+    monkeypatch.setattr("agentwire.history.claude_projects_dir", lambda: tmp_path / "projects")
+    cwd = tmp_path / "worktree"
+    cwd.mkdir()
+    (tmp_path / "projects").mkdir()
+    return types.SimpleNamespace(root=tmp_path, cwd=cwd, projects=tmp_path / "projects")
+
+
+@pytest.fixture
+def pane(monkeypatch):
+    """Where the hook believes it runs: (session, pane_index)."""
+    where = types.SimpleNamespace(session="sess", index=0)
+    monkeypatch.setattr("agentwire.pane_manager.get_current_session", lambda: where.session)
+    monkeypatch.setattr("agentwire.pane_manager.get_current_pane_index", lambda: where.index)
+    return where
+
+
+def transcript(store, cid):
+    d = store.projects / encode_project_path(str(store.cwd))
+    d.mkdir(parents=True, exist_ok=True)
+    (d / f"{cid}.jsonl").write_text(TURN)
+    return d / f"{cid}.jsonl"
+
+
+def launch(store, session="sess"):
+    from agentwire.core import build_agent_command, record_session_launch
+
+    agent = build_agent_command("bypass")
+    record_session_launch(session, agent, store.cwd)
+    return agent.conversation_id
+
+
+def session_start(cid, source="clear"):
+    return hooks_cli.record_session_start({"session_id": cid, "source": source})
+
+
+def chain(session="sess"):
+    from agentwire.core import load_session_metadata
+
+    return load_session_metadata(session)["conversation_ids"]
+
+
+def test_restart_resumes_the_post_clear_conversation(store, pane, monkeypatch):
+    launched = launch(store)
+    transcript(store, launched)
+    session_start("after-clear-1")
+    transcript(store, "after-clear-1")
+    session_start("after-clear-2")
+    transcript(store, "after-clear-2")
+
+    assert chain() == [launched, "after-clear-1", "after-clear-2"]
+
+    captured = []
+    monkeypatch.setattr(restart_cli, "tmux_session_exists", lambda n: False)
+    monkeypatch.setattr(restart_cli, "_notify_portal_sessions_changed", lambda: None)
+    monkeypatch.setattr(restart_cli.pane_manager, "get_current_session", lambda: None)
+    monkeypatch.setattr(
+        restart_cli, "_launch_tmux_session",
+        lambda name, path, env, cmd: captured.append(cmd),
+    )
+    args = types.SimpleNamespace(session="sess", json=False, no_wait=True)
+    assert restart_cli.cmd_restart(args) == 0
+    assert '--resume "after-clear-2" --fork-session' in captured[0]
+
+
+def test_a_cleared_but_unprompted_conversation_falls_back_to_the_last_real_one(store, pane):
+    launched = launch(store)
+    transcript(store, launched)
+    session_start("cleared-never-prompted")  # no transcript: written lazily
+
+    resume_id, _ = restart_cli.resolve_resume_target(chain(), str(store.cwd))
+    assert resume_id == launched
+
+
+def test_the_hook_is_idempotent_and_resume_moves_an_old_id_to_the_tail(store, pane):
+    from agentwire.core import record_conversation_change
+
+    launched = launch(store)
+    assert record_conversation_change("sess", launched) is False  # the launch's own id
+    session_start("b")
+    assert session_start("b").startswith("unchanged")
+    assert chain() == [launched, "b"]
+
+    # /resume back to the launch conversation: it is now the CURRENT one.
+    session_start(launched, source="resume")
+    assert chain() == ["b", launched]
+
+
+def test_the_hook_never_writes_outside_its_own_session_record(store, pane):
+    launch(store)
+    before = chain()
+
+    pane.index = 1  # a worker pane is not a session
+    assert session_start("worker-conv").startswith("skipped: worker pane")
+
+    pane.index, pane.session = 0, "no-such-session"  # no launch record: nothing to extend
+    assert session_start("x").startswith("unchanged")
+    from agentwire.core import load_session_metadata, session_metadata_path
+
+    assert not session_metadata_path("no-such-session").exists()
+    assert load_session_metadata("no-such-session") == {}
+    assert chain() == before
+
+
+def test_the_hook_command_exits_zero_on_every_bad_input(store, pane, monkeypatch, capsys):
+    launch(store)
+    bad = ["", "{{{", "[1]", '{"no":"id"}', '{"session_id": 5}']
+    codes = []
+    for raw in bad:
+        monkeypatch.setattr("sys.stdin", io.StringIO(raw))
+        codes.append(hooks_cli.cmd_hooks_session_start(types.SimpleNamespace()))
+
+    def boom(*_):
+        raise OSError("read-only store")
+
+    monkeypatch.setattr("agentwire.core.store_session_metadata", boom)
+    monkeypatch.setattr("sys.stdin", io.StringIO(json.dumps({"session_id": "new"})))
+    codes.append(hooks_cli.cmd_hooks_session_start(types.SimpleNamespace()))
+
+    assert codes == [0] * len(codes)
+    assert "read-only store" in capsys.readouterr().err  # logged, not swallowed silently
+
+
+class TestDoctorUnrecordedTranscripts:
+    @pytest.fixture(autouse=True)
+    def live(self, monkeypatch):
+        monkeypatch.setattr(doctor_cli, "tmux_session_exists", lambda n: True)
+
+    def test_newer_unrecorded_transcript_is_stated(self, store):
+        import os
+
+        launched = launch(store)
+        head = transcript(store, launched)
+        cleared = transcript(store, "cleared")
+        os.utime(head, (1000, 1000))
+        os.utime(cleared, (2000, 2000))
+
+        [f] = doctor_cli.scan_unrecorded_transcripts(["sess"])
+        assert (f["head"], f["newer"]) == (launched, ["cleared"])
+
+    def test_a_recorded_or_older_transcript_is_silent(self, store, pane):
+        import os
+
+        launched = launch(store)
+        head = transcript(store, launched)
+        older = transcript(store, "older")
+        os.utime(older, (500, 500))
+        os.utime(head, (1000, 1000))
+        assert doctor_cli.scan_unrecorded_transcripts(["sess"]) == []
+
+        newer = transcript(store, "cleared")
+        os.utime(newer, (2000, 2000))
+        session_start("cleared")  # the hook caught it
+        os.utime(newer, (2000, 2000))
+        assert doctor_cli.scan_unrecorded_transcripts(["sess"]) == []

{agentwire_dev-1.78.0 → agentwire_dev-1.79.0}/tests/unit/test_hooks_install.py

@@ -109,6 +109,8 @@ class TestInstallHooks:
                    for e in events["PermissionRequest"] for h in e["hooks"])
         assert any(h["command"].endswith("idle-handler.sh")
                    for e in events["Notification"] for h in e["hooks"])
+        assert any(h["command"].endswith("session-start-handler.sh")
+                   for e in events["SessionStart"] for h in e["hooks"])
 
 
     def test_stale_installed_copy_refreshed(self, env):