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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentwire-dev
-Version: 1.77.5
+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
@@ -228,7 +228,7 @@ Requires-Dist: aiohttp-jinja2>=1.6
 Requires-Dist: aiohttp>=3.13.4
 Requires-Dist: av>=12.0.0
 Requires-Dist: certifi>=2026.10.23
-Requires-Dist: damage-control-dev<0.2,>=0.1.6
+Requires-Dist: damage-control-dev<0.3,>=0.2.0
 Requires-Dist: fastapi>=0.104.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: kokoro-onnx>=0.4.9; python_version < '3.14'

{agentwire_dev-1.77.5 → agentwire_dev-1.79.0}/RELEASING.md

@@ -6,7 +6,7 @@ Every release does **both** a PyPI publish and a GitHub release. The **GitHub re
 
 ## The engine is a separate project (single source)
 
-The damage-control engine has exactly one source: the `damage-control-dev` repo (<https://github.com/dotdevdotdev/damage-control-dev>), published on PyPI. `agentwire-dev` only *consumes* it through the range in `pyproject.toml` (currently `damage-control-dev>=0.1.6,<0.2`); a checkout and a PyPI install both resolve it from PyPI. There is no copy of the engine in this repo and nothing to release from here. `tests/unit/test_damage_control_pin.py` checks that the declared floor/ceiling parse and that the installed engine satisfies them.
+The damage-control engine has exactly one source: the `damage-control-dev` repo (<https://github.com/dotdevdotdev/damage-control-dev>), published on PyPI. `agentwire-dev` only *consumes* it through the range in `pyproject.toml` (currently `damage-control-dev>=0.2.0,<0.3`); a checkout and a PyPI install both resolve it from PyPI. There is no copy of the engine in this repo and nothing to release from here. `tests/unit/test_damage_control_pin.py` checks that the declared floor/ceiling parse and that the installed engine satisfies them.
 
 To ship an engine change:
 

{agentwire_dev-1.77.5 → agentwire_dev-1.79.0}/agentwire/__init__.py

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

{agentwire_dev-1.77.5 → 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.77.5 → 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.77.5 → 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.77.5 → agentwire_dev-1.79.0}/agentwire/safety/rule_baselines.json

@@ -17,6 +17,7 @@
       "2c49ab654ff58675a3917d852093bc5f5ecc7d16cab10cd5046d11e8cede9621",
       "3cf2127d5f470f1fc9b24c3507c091b999110ed2fbb300f19765ac905d457e16",
       "5ba2be093a035021f04be9f3adcc8a234cf8f04dd63955f8693d72472d7c3a21",
+      "7675af135ecb0381130ab5988a54e9860ef975d568fd9025d003481c4a841144",
       "a30f698ca4156bc9a0715c5df4583c41d026a566d0bd8d534d263bec8b951e74",
       "a977b051e9ff66490816bbbd562e9106015c4e0950b547422f92debfd7d361f6",
       "c471a54cf5045348dc1df644852dc5933aa8bfd0e1aee0cddc1a20862128adde"

{agentwire_dev-1.77.5 → agentwire_dev-1.79.0}/agentwire/safety/rules/agentwire.yaml

@@ -42,6 +42,6 @@ bashToolPatterns:
 
   # Note: `agentwire tasks promote` (#720/#721) is blocked via
   # safety/_core.py's PROTECTED_COMMAND_PATTERNS instead of an ordinary
-  # bashToolPatterns entry here — it needs escape-hatch/kill-switch immunity,
+  # bashToolPatterns entry here — it needs `# ask:`/kill-switch immunity,
   # which only the code-level protected-command check provides (a rule in
-  # this file would still be overridable by `# allow:`).
+  # this file would still be softened by `# ask:`).

{agentwire_dev-1.77.5 → 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.77.5 → 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.77.5 → 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.77.5 → agentwire_dev-1.79.0}/agentwire/tasks_cli.py

@@ -24,8 +24,8 @@ closed):
   shelled out to `tasks promote` would hand the agent an instant, unguarded
   bypass of the whole scheme. CLI-only keeps this on the human's own terminal.
 - `agentwire tasks promote` is ALSO hard-blocked as a `PROTECTED_COMMAND_PATTERNS`
-  entry in `damage_control/engine.py` — escape-hatch- and kill-switch-EXEMPT (same tier
-  as the protected-control-plane file check), so `# allow:` and
+  entry in `damage_control/engine.py` — `# ask:`- and kill-switch-EXEMPT (same tier
+  as the protected-control-plane file check), so `# ask:` and
   `enabled: false` can't open it either.
 - `cmd_tasks_promote` ITSELF refuses to run outside a genuine host context
   (see `_host_context_ok` below), regardless of how it's reached. This is the

{agentwire_dev-1.77.5 → agentwire_dev-1.79.0}/corpus/cases/bypass.yaml

@@ -1352,3 +1352,26 @@
   - secrets
   - home
   source: tests/unit/test_damage_control_bypass.py::test_secrets_stay_blocked_wherever_home_is
+- id: ask-comment-001
+  tool: Bash
+  input: 'git reset --hard origin/main  # ask: sync to remote'
+  context:
+    ruleset: full
+  expect:
+    decision: ask
+  class: ask-comment
+  tags:
+  - ask-comment
+  source: tests/unit/test_damage_control_bypass.py::test_ask_comment_turns_a_block_into_an_undemotable_human_confirmation
+- id: ask-comment-002
+  tool: Bash
+  input: 'git reset --hard origin/main  # allow: sync to remote'
+  context:
+    ruleset: full
+  expect:
+    decision: block
+  class: ask-comment
+  tags:
+  - ask-comment
+  - removed-escape
+  source: tests/unit/test_damage_control_bypass.py::test_the_old_allow_comment_has_no_effect