pushary 1.9.101 → 1.9.103

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.9.103
+
+- The Hermes plugin Pushary installs is now 1.0.1. When it hands a Hermes session to Pushary's history helper, the helper now gets only what it reads: the home folder, the search path, the temporary folder and locale, the Pushary settings it uses, and the Pushary key Hermes holds. Hermes' other provider keys no longer reach it. Checking whether history is allowed sends the key on standard input only.
+
+## 1.9.102
+
+- The Hermes plugin Pushary installs is now 1.0.0. In Hermes Desktop, a Pushary chip in the status bar shows the approvals waiting on your phone, and you can answer them there too. Only one answer counts: a Hermes Desktop answer is used only when Pushary confirms that answer is what withdrew the question, and otherwise the panel says the approval had already closed. The chip also lists how recent approvals ended and where they were answered. Enable Pushary under Capabilities, Plugins in Hermes Desktop to see it.
+- On a Team workspace, a Hermes approval that an approval route sends to someone else, with "Only they can answer" on, is no longer handed to Hermes' own prompt. The plugin waits for the route's approvers until Hermes' timeout and denies if none of them answers.
+- When Hermes has already given up on an approval, because it timed out or the turn was interrupted, the plugin withdraws the question from your phone at its next check instead of leaving it open.
+
 ## 1.9.101
 
 - When npm cannot write to its global folder (an `EACCES` from a system Node install on Linux, for example), setup now reports that same reason for every agent it connects, and tells each one to fix the npm prefix. Before, only the first agent got that reason. The others said an earlier installation "did not finish safely" and to retry, which could not work.

package/dist/bin/pushary-clean.js

@@ -53,7 +53,7 @@ import {
   defaultHermesHome,
   hermesReceiptPaths,
   removeHermesWiring
-} from "../chunk-VSE4OIBT.js";
+} from "../chunk-COBOR3ST.js";
 import "../chunk-QCGNGEGE.js";
 import {
   planClineRemoval,

package/dist/bin/pushary-codex-hook.js

@@ -814,7 +814,7 @@ var decidePreToolUse = async (input) => {
 };
 var repairCodexHoldsQuietly = async () => {
   try {
-    const { repairCodexHolds } = await import("../reapply-GTEJJ6HZ.js");
+    const { repairCodexHolds } = await import("../reapply-LDCMRN6Q.js");
     repairCodexHolds();
   } catch {
     return;

package/dist/bin/pushary-daemon.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   inspectConfiguredManagedProviders
-} from "../chunk-IUBDGISO.js";
+} from "../chunk-RMFL62HR.js";
 import {
   HEARTBEAT_INTERVAL_MS,
   sendHeartbeat
@@ -14,7 +14,7 @@ import {
   HERMES_INSTALL_MARKER_FILE,
   defaultHermesHome,
   parseHermesInstallMarker
-} from "../chunk-VSE4OIBT.js";
+} from "../chunk-COBOR3ST.js";
 import {
   writeHuman
 } from "../chunk-QCGNGEGE.js";

package/dist/bin/pushary-doctor.js

@@ -75,7 +75,7 @@ import {
   routesHermesQuestions,
   runsAnOlderPlugin,
   shippedHermesPlugin
-} from "../chunk-VSE4OIBT.js";
+} from "../chunk-COBOR3ST.js";
 import "../chunk-QCGNGEGE.js";
 import {
   FX_PROFILE_REFUSALS,

package/dist/bin/pushary-session-start-hook.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   reapplyClaudeForVersion
-} from "../chunk-IUBDGISO.js";
+} from "../chunk-RMFL62HR.js";
 import "../chunk-RVSRPDRF.js";
-import "../chunk-VSE4OIBT.js";
+import "../chunk-COBOR3ST.js";
 import "../chunk-SXAZPWL7.js";
 import "../chunk-JECH4NJL.js";
 import "../chunk-AZSOH2SF.js";

package/dist/bin/pushary-setup.js

@@ -136,7 +136,7 @@ import {
   routesHermesQuestions,
   runsAnOlderPlugin,
   shippedHermesPlugin
-} from "../chunk-VSE4OIBT.js";
+} from "../chunk-COBOR3ST.js";
 import {
   setHumanStream
 } from "../chunk-QCGNGEGE.js";

package/dist/bin/pushary-upgrade.js

@@ -28,7 +28,7 @@ import {
 import {
   ensureCodexTrustAfterReapply,
   reapplyAllAgents
-} from "../chunk-IUBDGISO.js";
+} from "../chunk-RMFL62HR.js";
 import {
   HERMES_RESTART_COMMAND,
   describeCodexTrustConfirmation
@@ -42,7 +42,7 @@ import {
   readMacAppAgentKey
 } from "../chunk-JKOAAIJD.js";
 import "../chunk-WYJ6QM7K.js";
-import "../chunk-VSE4OIBT.js";
+import "../chunk-COBOR3ST.js";
 import {
   FX_RELOAD_AFTER_BRIDGE,
   fxHttpEntryKeptNote,

package/dist/{chunk-VSE4OIBT.js → chunk-COBOR3ST.js}

@@ -107,6 +107,7 @@ def register(ctx):
         "on_session_start": _on_session_start,
         "on_session_end": _on_session_end,
         "on_session_finalize": _on_session_finalize,
+        "post_approval_response": _on_post_approval_response,
     }
     for hook_name, callback in hooks.items():
         ctx.register_hook(hook_name, callback)
@@ -314,6 +315,15 @@ def _on_pre_tool_call(tool_name=None, args=None, session_id=None, **kwargs):
         return _block_unapproved(tool_name)
 
 
+PUSHARY_TRANSPORT_SURFACE = f"transport:{host.TRANSPORT_NAME}"
+
+
+def _on_post_approval_response(choice=None, surface=None, request_id=None, **kwargs):
+    if surface == PUSHARY_TRANSPORT_SURFACE and request_id:
+        approval.record_host_outcome(str(request_id), choice)
+    return None
+
+
 def _tool_failed(result, status):
     if status is not None:
         return status == "error"
@@ -937,7 +947,618 @@ def get_end_user_decision(decision_id, wait_seconds=45):
     seg = urllib.parse.quote(str(decision_id), safe="")
     return _rest_call("GET", f"/decisions/{seg}", params={"wait": wait_seconds})
 ` },
-  { path: "approval.py", contents: 'import time\n\nfrom . import api, identity\n\nHERMES_SHELL_TOOL = "terminal"\nDECISION_LINE_MAX = 500\nACTION_BODY_MAX = 4000\n\nPOLL_CEILING_SECONDS = 50.0\n\nCHOICE_LABELS = (\n    ("once", "Allow once"),\n    ("session", "Allow for this session"),\n    ("always", "Always allow"),\n    ("deny", "Deny"),\n)\n\n\nclass TransportUnavailable(Exception):\n    pass\n\n\nQUESTION_COMMAND_MAX = 160\n\nPLUGIN_RULE_MARKER = "(plugin approval rule)"\n\n\ndef _offered(allowed):\n    return [pair for pair in CHOICE_LABELS if pair[0] in set(allowed or ())]\n\n\ndef _command_head(command):\n    return " ".join(str(command or "").split()[:2])[:80]\n\n\ndef _command_summary(command):\n    collapsed = " ".join(str(command or "").split())\n    if len(collapsed) <= QUESTION_COMMAND_MAX:\n        return collapsed\n    return collapsed[:QUESTION_COMMAND_MAX - 1] + "\u2026"\n\n\ndef _choice_from_answer(value, offered, uses_select):\n    answer = str(value or "").strip()\n    if uses_select:\n        for choice, label in offered:\n            if answer.lower() == label.lower():\n                return choice\n        return "deny"\n    return "once" if api.is_affirmative(answer) else "deny"\n\n\ndef _subject(request):\n    """What to put in the question.\n\n    A dangerous-command approval carries the real command. A plugin rule\n    escalated from pre_tool_call carries a synthetic display label instead, and\n    the plugin\'s own message is the part worth reading, so use that.\n    """\n    command = str(request.command or "")\n    if PLUGIN_RULE_MARKER in command:\n        lines = str(request.description or "").strip().splitlines()\n        if lines and lines[0].strip():\n            return _command_summary(lines[0])\n    return _command_summary(command)\n\n\ndef _open_question(request, offered, uses_select):\n    command = str(request.command or "")\n    return api.ask_user(\n        question=f"Allow Hermes to run `{_subject(request)}`?",\n        question_type="select" if uses_select else "confirm",\n        options=[label for _, label in offered] if uses_select else None,\n        context=str(request.description or "")[:500] or None,\n        agent_name=identity.agent_name(),\n        session_id=identity.session_id(),\n        machine_id=identity.machine_id(),\n        tool_name=HERMES_SHELL_TOOL,\n        tool_target=_command_head(command),\n        action=command[:DECISION_LINE_MAX] or None,\n        action_body=command[:ACTION_BODY_MAX] or None,\n        blocker=(\n            f"Hermes flagged this command as {request.pattern_key}"[:DECISION_LINE_MAX]\n            if request.pattern_key\n            else None\n        ),\n        wait=False,\n    )\n\n\ndef _stopped(result):\n    return result.get("handoffAction") == "stop" or result.get("status") in ("cancelled", "unavailable", "stopped")\n\n\ndef _withdraw(correlation_id):\n    try:\n        cancelled = api.cancel_question(correlation_id)\n        if _stopped(cancelled) or cancelled.get("error"):\n            return {"handoffAction": "stop"}\n        if cancelled.get("cancelled") is True:\n            return {}\n        answer = api.wait_for_answer(correlation_id, 1000)\n        if answer.get("answered") or answer.get("status") in ("expired", "missing"):\n            return answer\n    except Exception:\n        pass\n    return {"handoffAction": "stop"}\n\n\ndef present(request):\n    offered = _offered(request.allowed_choices)\n    if not offered:\n        return request.respond("deny")\n    uses_select = [choice for choice, _ in offered] != ["once", "deny"]\n    # Reserve time for withdrawal before the host discards a late decision.\n    started_at = time.monotonic()\n    deadline = started_at + max(float(request.timeout_seconds or 0) - 10, 0.0)\n    created = _open_question(request, offered, uses_select)\n    if created.get("answered"):\n        return request.respond(_choice_from_answer(created.get("value"), offered, uses_select))\n    if _stopped(created):\n        return request.respond("deny")\n    correlation_id = created.get("correlationId")\n    if not correlation_id:\n        raise TransportUnavailable("Pushary did not create an approval")\n\n    policy_deadline = None\n    window_ms = created.get("policyTimeoutMs")\n    if created.get("deliveryMode") == "push_first" and isinstance(window_ms, (int, float)) and window_ms >= 0:\n        policy_deadline = started_at + window_ms / 1000\n        deadline = min(deadline, policy_deadline)\n    handoff = created.get("noDevices") or created.get("suppressed") or created.get("status") in ("terminal", "notified")\n    answer = created\n    try:\n        while not handoff and time.monotonic() < deadline:\n            remaining = deadline - time.monotonic()\n            answer = api.wait_for_answer(correlation_id, int(min(POLL_CEILING_SECONDS, max(1.0, remaining)) * 1000))\n            if answer.get("answered"):\n                return request.respond(_choice_from_answer(answer.get("value"), offered, uses_select))\n            if _stopped(answer) or answer.get("error") or answer.get("status") in ("expired", "missing"):\n                break\n            # Some hosts/proxies return pending immediately instead of long-polling.\n            time.sleep(min(0.1, max(0, deadline - time.monotonic())))\n    except Exception:\n        answer = {"handoffAction": "stop"}\n\n    late = _withdraw(correlation_id)\n    if _stopped(answer) or _stopped(late):\n        return request.respond("deny")\n    if late.get("answered"):\n        return request.respond(_choice_from_answer(late.get("value"), offered, uses_select))\n    if handoff or (policy_deadline is not None and time.monotonic() >= policy_deadline):\n        # Only a fenced question may reach Hermes\'s configured builtin fallback.\n        raise TransportUnavailable("Approval handed back to Hermes")\n    return request.respond("deny")\n' },
+  { path: "approval_ledger.py", contents: 'from __future__ import annotations\n\nimport json\nimport os\nimport re\nimport secrets\nfrom dataclasses import dataclass\nfrom pathlib import Path\nfrom typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Literal, Mapping, Optional, Set, Tuple, Union\n\nif TYPE_CHECKING:\n    from typing_extensions import TypeGuard\n\nApprovalChoice = Literal["once", "session", "always", "deny"]\nRecordState = Literal["waiting", "settled"]\nClaimState = Literal["claiming", "won", "lost"]\nHandedBack = Literal["handed_to_hermes"]\nEnded = Literal["ended"]\nSettledOutcome = Union[ApprovalChoice, HandedBack]\nRecentOutcome = Union[SettledOutcome, Ended]\nDecider = Literal["hermes_desktop", "pushary_transport"]\nRefusedClaim = Literal["not_found", "not_waiting", "not_answerable_here", "not_offered", "already_claimed"]\nClaimResult = Union[Literal["claimed"], RefusedClaim]\nProcessIsRunning = Callable[[int], bool]\n\nAPPROVAL_CHOICES: Tuple[ApprovalChoice, ...] = ("once", "session", "always", "deny")\nWAITING: RecordState = "waiting"\nSETTLED: RecordState = "settled"\nCLAIMING: ClaimState = "claiming"\nWON: ClaimState = "won"\nLOST: ClaimState = "lost"\nCLAIM_STATES: Tuple[ClaimState, ...] = (CLAIMING, WON, LOST)\nHANDED_TO_HERMES: HandedBack = "handed_to_hermes"\nENDED: Ended = "ended"\nSETTLED_OUTCOMES: Tuple[SettledOutcome, ...] = (*APPROVAL_CHOICES, HANDED_TO_HERMES)\nRECENT_OUTCOMES: Tuple[RecentOutcome, ...] = (*SETTLED_OUTCOMES, ENDED)\nDECIDED_BY_DESKTOP: Decider = "hermes_desktop"\nDECIDED_BY_TRANSPORT: Decider = "pushary_transport"\n\nCLAIMED: Literal["claimed"] = "claimed"\nNOT_FOUND: RefusedClaim = "not_found"\nNOT_WAITING: RefusedClaim = "not_waiting"\nNOT_ANSWERABLE_HERE: RefusedClaim = "not_answerable_here"\nNOT_OFFERED: RefusedClaim = "not_offered"\nALREADY_CLAIMED: RefusedClaim = "already_claimed"\nREFUSED_CLAIMS: Tuple[RefusedClaim, ...] = (NOT_FOUND, NOT_WAITING, NOT_ANSWERABLE_HERE, NOT_OFFERED, ALREADY_CLAIMED)\n\nDESKTOP_ANSWER_SOURCE = "hermes_desktop"\nUNNAMED_ANSWER_SOURCE = "pushary"\n\nLEDGER_PATH = ("plugin-data", "pushary", "approvals")\nRECORD_SUFFIX = ".json"\nHOST_OUTCOME_PREFIX = "host-"\nTEMPORARY_PREFIX = "."\n\nCORRELATION_ID_PATTERN = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$")\nREQUEST_ID_PATTERN = re.compile(r"^[A-Za-z0-9_-]{1,64}$")\nTOKEN_PATTERN = re.compile(r"^[a-z][a-z0-9_]{0,63}$")\n\nRETENTION_SECONDS = 24 * 60 * 60\nRECENT_LIMIT = 6\nSUBJECT_MAX = 200\nLABEL_MAX = 80\n\n\n@dataclass(frozen=True)\nclass OfferedChoice:\n    choice: ApprovalChoice\n    label: str\n\n\n@dataclass(frozen=True)\nclass OpenedApproval:\n    correlation_id: str\n    request_id: Optional[str]\n    subject: str\n    choices: Tuple[OfferedChoice, ...]\n    pid: int\n    opened_at_ms: int\n    deadline_at_ms: int\n\n\n@dataclass(frozen=True)\nclass WaitingRecord:\n    opened: OpenedApproval\n\n\n@dataclass(frozen=True)\nclass SettledRecord:\n    opened: OpenedApproval\n    outcome: SettledOutcome\n    answer_source: Optional[str]\n    settled_at_ms: int\n\n\nApprovalRecord = Union[WaitingRecord, SettledRecord]\n\n\n@dataclass(frozen=True)\nclass HostOutcome:\n    request_id: str\n    choice: str\n    at_ms: int\n\n\n@dataclass(frozen=True)\nclass WaitingApproval:\n    correlation_id: str\n    subject: str\n    choices: Tuple[OfferedChoice, ...]\n    opened_at_ms: int\n    deadline_at_ms: int\n    answerable_here: bool\n    routed_to: Optional[str]\n    claim: Optional[ClaimState]\n\n\n@dataclass(frozen=True)\nclass RecentApproval:\n    correlation_id: str\n    subject: str\n    opened_at_ms: int\n    settled_at_ms: int\n    outcome: RecentOutcome\n    answer_source: Optional[str]\n    host_outcome: Optional[str]\n\n\n@dataclass(frozen=True)\nclass ApprovalsView:\n    waiting: Tuple[WaitingApproval, ...]\n    recent: Tuple[RecentApproval, ...]\n\n\ndef is_correlation_id(value: object) -> TypeGuard[str]:\n    return isinstance(value, str) and CORRELATION_ID_PATTERN.fullmatch(value) is not None\n\n\ndef is_request_id(value: object) -> TypeGuard[str]:\n    return isinstance(value, str) and REQUEST_ID_PATTERN.fullmatch(value) is not None\n\n\ndef is_token(value: object) -> TypeGuard[str]:\n    return isinstance(value, str) and TOKEN_PATTERN.fullmatch(value) is not None\n\n\ndef approval_choice(value: object) -> Optional[ApprovalChoice]:\n    for choice in APPROVAL_CHOICES:\n        if value == choice:\n            return choice\n    return None\n\n\ndef _record_state(value: object) -> Optional[RecordState]:\n    for state in (WAITING, SETTLED):\n        if value == state:\n            return state\n    return None\n\n\ndef _settled_outcome(value: object) -> Optional[SettledOutcome]:\n    for outcome in SETTLED_OUTCOMES:\n        if value == outcome:\n            return outcome\n    return None\n\n\ndef _instant(value: object) -> Optional[int]:\n    return value if isinstance(value, int) and not isinstance(value, bool) and value >= 0 else None\n\n\ndef _bounded_text(value: object, limit: int) -> Optional[str]:\n    return value if isinstance(value, str) and len(value) <= limit else None\n\n\ndef _fields(value: object) -> Optional[Mapping[object, object]]:\n    return value if isinstance(value, dict) else None\n\n\ndef offered_choices(pairs: Iterable[Tuple[str, str]]) -> Tuple[OfferedChoice, ...]:\n    offered = []\n    for raw_choice, raw_label in pairs:\n        choice = approval_choice(raw_choice)\n        if choice is not None:\n            offered.append(OfferedChoice(choice, str(raw_label)[:LABEL_MAX]))\n    return tuple(offered)\n\n\ndef _parse_offered(value: object) -> Optional[OfferedChoice]:\n    fields = _fields(value)\n    if fields is None:\n        return None\n    choice = approval_choice(fields.get("choice"))\n    label = _bounded_text(fields.get("label"), LABEL_MAX)\n    return OfferedChoice(choice, label) if choice is not None and label is not None else None\n\n\ndef _parse_choices(value: object) -> Optional[Tuple[OfferedChoice, ...]]:\n    if not isinstance(value, list):\n        return None\n    parsed: List[OfferedChoice] = []\n    for item in value:\n        offered = _parse_offered(item)\n        if offered is None:\n            return None\n        parsed.append(offered)\n    return tuple(parsed)\n\n\ndef _parse_opened(fields: Mapping[object, object]) -> Optional[OpenedApproval]:\n    correlation_id = fields.get("correlationId")\n    request_id = fields.get("requestId")\n    subject = _bounded_text(fields.get("subject"), SUBJECT_MAX)\n    choices = _parse_choices(fields.get("choices"))\n    pid = fields.get("pid")\n    opened_at_ms = _instant(fields.get("openedAtMs"))\n    deadline_at_ms = _instant(fields.get("deadlineAtMs"))\n    if not is_correlation_id(correlation_id):\n        return None\n    if request_id is not None and not is_request_id(request_id):\n        return None\n    if (\n        subject is None\n        or not choices\n        or not isinstance(pid, int) or isinstance(pid, bool) or pid <= 0\n        or opened_at_ms is None\n        or deadline_at_ms is None\n    ):\n        return None\n    return OpenedApproval(\n        correlation_id=correlation_id,\n        request_id=request_id,\n        subject=subject,\n        choices=choices,\n        pid=pid,\n        opened_at_ms=opened_at_ms,\n        deadline_at_ms=deadline_at_ms,\n    )\n\n\ndef parse_record(value: object) -> Optional[ApprovalRecord]:\n    fields = _fields(value)\n    if fields is None:\n        return None\n    opened = _parse_opened(fields)\n    state = _record_state(fields.get("state"))\n    if opened is None or state is None:\n        return None\n    if state == WAITING:\n        return WaitingRecord(opened)\n    outcome = _settled_outcome(fields.get("outcome"))\n    settled_at_ms = _instant(fields.get("settledAtMs"))\n    answer_source = fields.get("answerSource")\n    if outcome is None or settled_at_ms is None:\n        return None\n    if answer_source is not None and not is_token(answer_source):\n        return None\n    return SettledRecord(opened, outcome, answer_source, settled_at_ms)\n\n\ndef parse_host_outcome(value: object) -> Optional[HostOutcome]:\n    fields = _fields(value)\n    if fields is None:\n        return None\n    request_id = fields.get("requestId")\n    choice = fields.get("choice")\n    at_ms = _instant(fields.get("atMs"))\n    if not is_request_id(request_id) or not is_token(choice) or at_ms is None:\n        return None\n    return HostOutcome(request_id, choice, at_ms)\n\n\ndef _offered_json(choice: OfferedChoice) -> Dict[str, object]:\n    return {"choice": choice.choice, "label": choice.label}\n\n\ndef _opened_json(opened: OpenedApproval) -> Dict[str, object]:\n    return {\n        "correlationId": opened.correlation_id,\n        "requestId": opened.request_id,\n        "subject": opened.subject,\n        "choices": [_offered_json(choice) for choice in opened.choices],\n        "pid": opened.pid,\n        "openedAtMs": opened.opened_at_ms,\n        "deadlineAtMs": opened.deadline_at_ms,\n    }\n\n\ndef _record_json(record: ApprovalRecord) -> Dict[str, object]:\n    stored = _opened_json(record.opened)\n    if isinstance(record, WaitingRecord):\n        stored["state"] = WAITING\n        return stored\n    stored.update(state=SETTLED, outcome=record.outcome, answerSource=record.answer_source,\n                  settledAtMs=record.settled_at_ms)\n    return stored\n\n\ndef _host_outcome_json(outcome: HostOutcome) -> Dict[str, object]:\n    return {"requestId": outcome.request_id, "choice": outcome.choice, "atMs": outcome.at_ms}\n\n\ndef ledger_directory(home: Path) -> Path:\n    return Path(home).joinpath(*LEDGER_PATH)\n\n\ndef _record_path(home: Path, correlation_id: str) -> Path:\n    return ledger_directory(home) / f"{correlation_id}{RECORD_SUFFIX}"\n\n\ndef _host_outcome_path(home: Path, request_id: str) -> Path:\n    return ledger_directory(home) / f"{HOST_OUTCOME_PREFIX}{request_id}{RECORD_SUFFIX}"\n\n\ndef _ensure_parent(path: Path) -> None:\n    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)\n\n\ndef _staged_json(path: Path, value: Dict[str, object]) -> Path:\n    _ensure_parent(path)\n    staged = path.with_name(f"{TEMPORARY_PREFIX}{path.name}.{secrets.token_hex(8)}.tmp")\n    try:\n        with open(os.open(staged, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600), "w", encoding="utf-8") as handle:\n            json.dump(value, handle)\n    except BaseException:\n        staged.unlink(missing_ok=True)\n        raise\n    return staged\n\n\ndef _replace_json(path: Path, value: Dict[str, object]) -> None:\n    staged = _staged_json(path, value)\n    try:\n        os.replace(staged, path)\n    finally:\n        staged.unlink(missing_ok=True)\n\n\ndef _read_json(path: Path) -> object:\n    try:\n        return json.loads(path.read_text(encoding="utf-8"))\n    except (OSError, ValueError):\n        return None\n\n\ndef read_record(home: Path, correlation_id: str) -> Optional[ApprovalRecord]:\n    if not is_correlation_id(correlation_id):\n        return None\n    record = parse_record(_read_json(_record_path(home, correlation_id)))\n    return record if record is not None and record.opened.correlation_id == correlation_id else None\n\n\ndef read_host_outcome(home: Path, request_id: Optional[str]) -> Optional[HostOutcome]:\n    if not is_request_id(request_id):\n        return None\n    outcome = parse_host_outcome(_read_json(_host_outcome_path(home, request_id)))\n    return outcome if outcome is not None and outcome.request_id == request_id else None\n\n\ndef open_approval(\n    home: Path,\n    *,\n    correlation_id: str,\n    request_id: Optional[str],\n    subject: str,\n    choices: Tuple[OfferedChoice, ...],\n    pid: int,\n    opened_at_ms: int,\n    deadline_at_ms: int,\n) -> bool:\n    if not is_correlation_id(correlation_id) or pid <= 0 or not choices:\n        return False\n    opened = OpenedApproval(\n        correlation_id=correlation_id,\n        request_id=request_id if is_request_id(request_id) else None,\n        subject=subject[:SUBJECT_MAX],\n        choices=choices,\n        pid=pid,\n        opened_at_ms=opened_at_ms,\n        deadline_at_ms=deadline_at_ms,\n    )\n    _replace_json(_record_path(home, correlation_id), _record_json(WaitingRecord(opened)))\n    return True\n\n\ndef settle_approval(\n    home: Path,\n    correlation_id: str,\n    *,\n    outcome: SettledOutcome,\n    answer_source: Optional[str],\n    settled_at_ms: int,\n) -> bool:\n    record = read_record(home, correlation_id)\n    if not isinstance(record, WaitingRecord):\n        return False\n    source = answer_source if is_token(answer_source) else None\n    _replace_json(_record_path(home, correlation_id), _record_json(SettledRecord(record.opened, outcome, source,\n                                                                                 settled_at_ms)))\n    return True\n\n\ndef record_host_outcome(home: Path, request_id: str, choice: str, at_ms: int) -> bool:\n    if not is_request_id(request_id) or not is_token(choice):\n        return False\n    _replace_json(_host_outcome_path(home, request_id), _host_outcome_json(HostOutcome(request_id, choice, at_ms)))\n    return True\n\n\ndef host_has_finished(home: Path, request_id: Optional[str]) -> bool:\n    return read_host_outcome(home, request_id) is not None\n\n\ndef _owner_is_running(opened: OpenedApproval, process_is_running: ProcessIsRunning) -> bool:\n    return opened.pid > 0 and process_is_running(opened.pid)\n\n\ndef _is_live(record: ApprovalRecord, host_outcome: Optional[HostOutcome], now_ms: int,\n             process_is_running: ProcessIsRunning) -> bool:\n    return (\n        isinstance(record, WaitingRecord)\n        and host_outcome is None\n        and now_ms < record.opened.deadline_at_ms\n        and _owner_is_running(record.opened, process_is_running)\n    )\n\n\ndef _waiting_elsewhere(record: WaitingRecord) -> WaitingApproval:\n    opened = record.opened\n    return WaitingApproval(\n        correlation_id=opened.correlation_id,\n        subject=opened.subject,\n        choices=opened.choices,\n        opened_at_ms=opened.opened_at_ms,\n        deadline_at_ms=opened.deadline_at_ms,\n        answerable_here=False,\n        routed_to=None,\n        claim=None,\n    )\n\n\ndef _recent(record: ApprovalRecord, host_outcome: Optional[HostOutcome]) -> RecentApproval:\n    opened = record.opened\n    if isinstance(record, SettledRecord):\n        outcome: RecentOutcome = record.outcome\n        settled_at_ms = record.settled_at_ms\n        answer_source = record.answer_source\n    else:\n        outcome = ENDED\n        settled_at_ms = host_outcome.at_ms if host_outcome else opened.deadline_at_ms\n        answer_source = None\n    return RecentApproval(\n        correlation_id=opened.correlation_id,\n        subject=opened.subject,\n        opened_at_ms=opened.opened_at_ms,\n        settled_at_ms=settled_at_ms,\n        outcome=outcome,\n        answer_source=answer_source,\n        host_outcome=host_outcome.choice if host_outcome else None,\n    )\n\n\ndef approvals_view(\n    records: Iterable[ApprovalRecord],\n    host_outcomes: Mapping[str, HostOutcome],\n    now_ms: int,\n    process_is_running: ProcessIsRunning,\n) -> ApprovalsView:\n    waiting = []\n    recent = []\n    for record in records:\n        request_id = record.opened.request_id\n        host_outcome = host_outcomes.get(request_id) if request_id else None\n        if isinstance(record, WaitingRecord) and _is_live(record, host_outcome, now_ms, process_is_running):\n            waiting.append(_waiting_elsewhere(record))\n        else:\n            recent.append(_recent(record, host_outcome))\n    waiting.sort(key=lambda item: item.opened_at_ms)\n    recent.sort(key=lambda item: item.settled_at_ms, reverse=True)\n    return ApprovalsView(waiting=tuple(waiting), recent=tuple(recent[:RECENT_LIMIT]))\n\n\ndef _ledger_files(home: Path) -> List[Path]:\n    try:\n        return [path for path in ledger_directory(home).iterdir() if path.is_file()]\n    except OSError:\n        return []\n\n\ndef _correlation_id_of(name: str) -> Optional[str]:\n    candidate = name[: -len(RECORD_SUFFIX)] if name.endswith(RECORD_SUFFIX) else None\n    return candidate if is_correlation_id(candidate) else None\n\n\ndef _ledger_entries(home: Path) -> List[Tuple[Path, object]]:\n    return [(path, _read_json(path)) for path in _ledger_files(home) if not path.name.startswith(TEMPORARY_PREFIX)]\n\n\ndef read_approvals(home: Path, now_ms: int, process_is_running: ProcessIsRunning) -> ApprovalsView:\n    records: List[ApprovalRecord] = []\n    host_outcomes: Dict[str, HostOutcome] = {}\n    for path, value in _ledger_entries(home):\n        name = path.name\n        if name.startswith(HOST_OUTCOME_PREFIX):\n            host_outcome = parse_host_outcome(value)\n            if host_outcome is not None:\n                host_outcomes[host_outcome.request_id] = host_outcome\n        else:\n            record = parse_record(value)\n            if record is not None and name == f"{record.opened.correlation_id}{RECORD_SUFFIX}":\n                records.append(record)\n    return approvals_view(records, host_outcomes, now_ms, process_is_running)\n\n\ndef _unexpired_waiting(home: Path, now_ms: int) -> Set[str]:\n    kept: Set[str] = set()\n    for path, value in _ledger_entries(home):\n        if path.name.startswith(HOST_OUTCOME_PREFIX) or not path.name.endswith(RECORD_SUFFIX):\n            continue\n        record = parse_record(value)\n        if isinstance(record, WaitingRecord) and record.opened.deadline_at_ms > now_ms:\n            kept.add(record.opened.correlation_id)\n    return kept\n\n\ndef prune(home: Path, now_seconds: float) -> None:\n    kept = _unexpired_waiting(home, int(now_seconds * 1000))\n    for path in _ledger_files(home):\n        if _correlation_id_of(path.name) in kept:\n            continue\n        try:\n            if now_seconds - path.stat().st_mtime > RETENTION_SECONDS:\n                path.unlink(missing_ok=True)\n        except OSError:\n            continue\n' },
+  { path: "approval.py", contents: `import logging
+import os
+import sys
+import time
+from typing import Literal, Optional, Tuple
+
+from . import api, approval_ledger, cancellation, desktop_answers, desktop_contract, identity, installation
+
+logger = logging.getLogger(__name__)
+
+HERMES_SHELL_TOOL = "terminal"
+DECISION_LINE_MAX = 500
+ACTION_BODY_MAX = 4000
+
+POLL_CEILING_SECONDS = 50.0
+WITHDRAW_RESERVE_SECONDS = 10.0
+HOST_RETURN_MARGIN_SECONDS = 1.0
+LATE_ANSWER_POLL_MS = 1000
+
+TUI_GATEWAY_MODULE = "tui_gateway.server"
+
+RouteAnswerability = Literal["requester", "routed_elsewhere", "unknown"]
+ANSWERABLE_BY_REQUESTER: RouteAnswerability = "requester"
+ROUTED_ELSEWHERE: RouteAnswerability = "routed_elsewhere"
+ANSWERABILITY_UNKNOWN: RouteAnswerability = "unknown"
+
+Withdrawal = Literal["withdrawn", "answered_late", "ended", "stopped"]
+WITHDRAWN: Withdrawal = "withdrawn"
+ANSWERED_LATE: Withdrawal = "answered_late"
+ENDED_UNANSWERED: Withdrawal = "ended"
+STOPPED: Withdrawal = "stopped"
+
+
+CHOICE_LABELS = (
+    ("once", "Allow once"),
+    ("session", "Allow for this session"),
+    ("always", "Always allow"),
+    ("deny", "Deny"),
+)
+
+
+class TransportUnavailable(Exception):
+    pass
+
+
+QUESTION_COMMAND_MAX = 160
+
+PLUGIN_RULE_MARKER = "(plugin approval rule)"
+
+
+def _offered(allowed):
+    return [pair for pair in CHOICE_LABELS if pair[0] in set(allowed or ())]
+
+
+def _command_head(command):
+    return " ".join(str(command or "").split()[:2])[:80]
+
+
+def _command_summary(command):
+    collapsed = " ".join(str(command or "").split())
+    if len(collapsed) <= QUESTION_COMMAND_MAX:
+        return collapsed
+    return collapsed[:QUESTION_COMMAND_MAX - 1] + "\u2026"
+
+
+def _choice_from_answer(value, offered, uses_select):
+    answer = str(value or "").strip()
+    if uses_select:
+        for choice, label in offered:
+            if answer.lower() == label.lower():
+                return choice
+        return "deny"
+    return "once" if api.is_affirmative(answer) else "deny"
+
+
+def _subject(request):
+    """What to put in the question.
+
+    A dangerous-command approval carries the real command. A plugin rule
+    escalated from pre_tool_call carries a synthetic display label instead, and
+    the plugin's own message is the part worth reading, so use that.
+    """
+    command = str(request.command or "")
+    if PLUGIN_RULE_MARKER in command:
+        lines = str(request.description or "").strip().splitlines()
+        if lines and lines[0].strip():
+            return _command_summary(lines[0])
+    return _command_summary(command)
+
+
+def _open_question(request, offered, uses_select):
+    command = str(request.command or "")
+    return api.ask_user(
+        question=f"Allow Hermes to run \`{_subject(request)}\`?",
+        question_type="select" if uses_select else "confirm",
+        options=[label for _, label in offered] if uses_select else None,
+        context=str(request.description or "")[:500] or None,
+        agent_name=identity.agent_name(),
+        session_id=identity.session_id(),
+        machine_id=identity.machine_id(),
+        tool_name=HERMES_SHELL_TOOL,
+        tool_target=_command_head(command),
+        action=command[:DECISION_LINE_MAX] or None,
+        action_body=command[:ACTION_BODY_MAX] or None,
+        blocker=(
+            f"Hermes flagged this command as {request.pattern_key}"[:DECISION_LINE_MAX]
+            if request.pattern_key
+            else None
+        ),
+        wait=False,
+    )
+
+
+def _stopped(result):
+    return result.get("handoffAction") == cancellation.STOP_HANDOFF or result.get("status") in (
+        "cancelled", cancellation.UNAVAILABLE_STATUS, "stopped")
+
+
+def _route_answerability(created) -> RouteAnswerability:
+    requester_may_answer = created.get("requesterMayAnswer")
+    if requester_may_answer is True:
+        return ANSWERABLE_BY_REQUESTER
+    if requester_may_answer is False:
+        return ROUTED_ELSEWHERE
+    return ANSWERABILITY_UNKNOWN
+
+
+def _routed_to(created) -> Optional[str]:
+    routed_to = created.get("routedTo")
+    return routed_to if isinstance(routed_to, str) and routed_to.strip() else None
+
+
+def _withdraw(correlation_id) -> Tuple[Withdrawal, dict]:
+    try:
+        result = cancellation.classify_cancellation(api.cancel_question(correlation_id))
+        if result in (cancellation.WITHDRAWN_BY_THIS_CALL, cancellation.CANCELLED_UNPROVEN):
+            return WITHDRAWN, {}
+        if result == cancellation.NOT_PENDING:
+            answer = api.wait_for_answer(correlation_id, LATE_ANSWER_POLL_MS)
+            if answer.get("answered"):
+                return ANSWERED_LATE, answer
+            if answer.get("status") in ("expired", "missing"):
+                return ENDED_UNANSWERED, answer
+    except Exception:
+        pass
+    return STOPPED, {}
+
+
+def _wall_clock_ms():
+    return int(time.time() * 1000)
+
+
+def announce_approvals_changed() -> None:
+    if TUI_GATEWAY_MODULE not in sys.modules:
+        return
+    try:
+        from hermes_cli.plugin_events import broadcast_plugin_event
+    except Exception:
+        return
+    try:
+        broadcast_plugin_event(desktop_contract.PLUGIN_ID, desktop_contract.APPROVALS_CHANGED_EVENT, {})
+    except Exception:
+        logger.debug("[pushary] could not tell Hermes Desktop about an approval", exc_info=True)
+
+
+def _open_answer_slot(request, correlation_id: str, offered, answerability: RouteAnswerability,
+                      routed_to: Optional[str], opened_at_ms: int, deadline_at_ms: int) -> None:
+    try:
+        desktop_answers.shared_answers().open_slot(
+            correlation_id,
+            request_id=getattr(request, "request_id", None),
+            subject=_subject(request),
+            choices=approval_ledger.offered_choices(offered),
+            opened_at_ms=opened_at_ms,
+            deadline_at_ms=deadline_at_ms,
+            answerable_here=answerability == ANSWERABLE_BY_REQUESTER,
+            routed_to=routed_to,
+        )
+    except Exception:
+        logger.debug("[pushary] could not offer an approval to Hermes Desktop", exc_info=True)
+
+
+def _close_answer_slot(correlation_id: str) -> None:
+    try:
+        desktop_answers.shared_answers().close_slot(correlation_id)
+    except Exception:
+        logger.debug("[pushary] could not withdraw an approval from Hermes Desktop", exc_info=True)
+
+
+def _record_opened(request, correlation_id: str, offered, answerability: RouteAnswerability,
+                   routed_to: Optional[str]) -> None:
+    opened_at_ms = _wall_clock_ms()
+    deadline_at_ms = opened_at_ms + int(float(request.timeout_seconds or 0) * 1000)
+    _open_answer_slot(request, correlation_id, offered, answerability, routed_to, opened_at_ms, deadline_at_ms)
+    try:
+        home = installation.hermes_home()
+        approval_ledger.prune(home, time.time())
+        opened = approval_ledger.open_approval(
+            home,
+            correlation_id=correlation_id,
+            request_id=getattr(request, "request_id", None),
+            subject=_subject(request),
+            choices=approval_ledger.offered_choices(offered),
+            pid=os.getpid(),
+            opened_at_ms=opened_at_ms,
+            deadline_at_ms=deadline_at_ms,
+        )
+    except Exception:
+        logger.debug("[pushary] could not record an open approval", exc_info=True)
+        opened = False
+    if opened:
+        announce_approvals_changed()
+
+
+def _record_settled(correlation_id: str, outcome, answer_source: Optional[str]) -> None:
+    try:
+        settled = approval_ledger.settle_approval(
+            installation.hermes_home(),
+            correlation_id,
+            outcome=outcome,
+            answer_source=answer_source,
+            settled_at_ms=_wall_clock_ms(),
+        )
+    except Exception:
+        logger.debug("[pushary] could not record a settled approval", exc_info=True)
+        return
+    if settled:
+        announce_approvals_changed()
+
+
+def record_host_outcome(request_id, choice) -> None:
+    try:
+        desktop_answers.shared_answers().end_for_request(request_id)
+    except Exception:
+        logger.debug("[pushary] could not end an approval in Hermes Desktop", exc_info=True)
+    try:
+        recorded = approval_ledger.record_host_outcome(installation.hermes_home(), request_id, choice, _wall_clock_ms())
+    except Exception:
+        logger.debug("[pushary] could not record Hermes's approval outcome", exc_info=True)
+        return
+    if recorded:
+        announce_approvals_changed()
+
+
+def _decided(request, correlation_id, choice, answer_source):
+    _record_settled(correlation_id, choice, answer_source)
+    return request.respond(choice)
+
+
+def _answer_source(answer) -> str:
+    source = answer.get("answerSource")
+    return source if approval_ledger.is_token(source) else approval_ledger.UNNAMED_ANSWER_SOURCE
+
+
+def _answered(request, correlation_id, answer, offered, uses_select):
+    choice = _choice_from_answer(answer.get("value"), offered, uses_select)
+    return _decided(request, correlation_id, choice, _answer_source(answer))
+
+
+def _offered_choices(offered) -> Tuple[str, ...]:
+    return tuple(choice for choice, _ in offered)
+
+
+def _host_has_finished(request, correlation_id: str) -> bool:
+    try:
+        if desktop_answers.shared_answers().has_ended(correlation_id):
+            return True
+        return approval_ledger.host_has_finished(installation.hermes_home(), getattr(request, "request_id", None))
+    except Exception:
+        return False
+
+
+def _desktop_decision(correlation_id: str, offered) -> Optional[str]:
+    try:
+        return desktop_answers.shared_answers().desktop_decision(correlation_id, _offered_choices(offered))
+    except Exception:
+        logger.debug("[pushary] could not read a Hermes Desktop answer", exc_info=True)
+        return None
+
+
+def _final_say(correlation_id: str, offered, host_deadline: float, claim_may_still_win: bool) -> Optional[str]:
+    wait = min(desktop_answers.CLAIM_RESOLVE_SECONDS, host_deadline - time.monotonic()) if claim_may_still_win else 0.0
+    try:
+        return desktop_answers.shared_answers().take_final_say(correlation_id, _offered_choices(offered),
+                                                               claim_wait_seconds=wait)
+    except Exception:
+        logger.debug("[pushary] could not settle who answers this approval", exc_info=True)
+        return None
+
+
+def present(request):
+    offered = _offered(request.allowed_choices)
+    if not offered:
+        return request.respond("deny")
+    uses_select = [choice for choice, _ in offered] != ["once", "deny"]
+    # Reserve time for withdrawal before the host discards a late decision.
+    started_at = time.monotonic()
+    timeout_seconds = float(request.timeout_seconds or 0)
+    deadline = started_at + max(timeout_seconds - WITHDRAW_RESERVE_SECONDS, 0.0)
+    host_deadline = started_at + max(timeout_seconds - HOST_RETURN_MARGIN_SECONDS, 0.0)
+    created = _open_question(request, offered, uses_select)
+    if created.get("answered"):
+        return request.respond(_choice_from_answer(created.get("value"), offered, uses_select))
+    if _stopped(created):
+        return request.respond("deny")
+    correlation_id = created.get("correlationId")
+    if not correlation_id:
+        raise TransportUnavailable("Pushary did not create an approval")
+    answerability = _route_answerability(created)
+    _record_opened(request, correlation_id, offered, answerability, _routed_to(created))
+    try:
+        return _await_decision(request, created, correlation_id, offered, uses_select, answerability,
+                               started_at, deadline, host_deadline)
+    finally:
+        _close_answer_slot(correlation_id)
+
+
+def _await_decision(request, created, correlation_id: str, offered, uses_select: bool,
+                    answerability: RouteAnswerability, started_at: float, deadline: float, host_deadline: float):
+    may_hand_back = answerability != ROUTED_ELSEWHERE
+    nothing_was_delivered = bool(created.get("noDevices") or created.get("status") in ("terminal", "notified"))
+    policy_deadline = None
+    window_ms = created.get("policyTimeoutMs")
+    if may_hand_back and created.get("deliveryMode") == "push_first" and isinstance(window_ms, (int, float)) and window_ms >= 0:
+        policy_deadline = started_at + window_ms / 1000
+        deadline = min(deadline, policy_deadline)
+    handoff = may_hand_back and (nothing_was_delivered or bool(created.get("suppressed")))
+    nobody_can_answer = not may_hand_back and nothing_was_delivered
+    answer = created
+    try:
+        while not handoff and not nobody_can_answer and time.monotonic() < deadline:
+            if _host_has_finished(request, correlation_id):
+                answer = {"handoffAction": "stop"}
+                break
+            remaining = deadline - time.monotonic()
+            answer = api.wait_for_answer(correlation_id, int(min(POLL_CEILING_SECONDS, max(1.0, remaining)) * 1000))
+            if answer.get("answered"):
+                return _answered(request, correlation_id, answer, offered, uses_select)
+            if _stopped(answer) or answer.get("error") or answer.get("status") in ("expired", "missing"):
+                break
+            # Some hosts/proxies return pending immediately instead of long-polling.
+            time.sleep(min(0.1, max(0, deadline - time.monotonic())))
+    except Exception:
+        answer = {"handoffAction": "stop"}
+
+    desktop = _desktop_decision(correlation_id, offered)
+    if desktop:
+        return _decided(request, correlation_id, desktop, approval_ledger.DESKTOP_ANSWER_SOURCE)
+    withdrawal, late = _withdraw(correlation_id)
+    if withdrawal == ANSWERED_LATE:
+        return _answered(request, correlation_id, late, offered, uses_select)
+    desktop = _final_say(correlation_id, offered, host_deadline, claim_may_still_win=withdrawal == STOPPED)
+    if desktop:
+        return _decided(request, correlation_id, desktop, approval_ledger.DESKTOP_ANSWER_SOURCE)
+    if _stopped(answer) or withdrawal == STOPPED:
+        return _decided(request, correlation_id, "deny", None)
+    if handoff or (policy_deadline is not None and time.monotonic() >= policy_deadline):
+        # Only a fenced question may reach Hermes's configured builtin fallback.
+        _record_settled(correlation_id, approval_ledger.HANDED_TO_HERMES, None)
+        raise TransportUnavailable("Approval handed back to Hermes")
+    return _decided(request, correlation_id, "deny", None)
+` },
+  { path: "cancellation.py", contents: 'from __future__ import annotations\n\nfrom typing import Literal, Mapping, Tuple\n\nCancellation = Literal[\n    "withdrawn_by_this_call",\n    "cancelled_unproven",\n    "already_cancelled",\n    "not_pending",\n    "unreachable",\n]\n\nWITHDRAWN_BY_THIS_CALL: Cancellation = "withdrawn_by_this_call"\nCANCELLED_UNPROVEN: Cancellation = "cancelled_unproven"\nALREADY_CANCELLED: Cancellation = "already_cancelled"\nNOT_PENDING: Cancellation = "not_pending"\nUNREACHABLE: Cancellation = "unreachable"\nCANCELLATIONS: Tuple[Cancellation, ...] = (\n    WITHDRAWN_BY_THIS_CALL,\n    CANCELLED_UNPROVEN,\n    ALREADY_CANCELLED,\n    NOT_PENDING,\n    UNREACHABLE,\n)\n\nUNAVAILABLE_STATUS = "unavailable"\nSTOP_HANDOFF = "stop"\n\n\ndef classify_cancellation(response: object) -> Cancellation:\n    if not isinstance(response, Mapping):\n        return UNREACHABLE\n    fields: Mapping[object, object] = response\n    cancelled = fields.get("cancelled")\n    by_this_call = fields.get("cancelledByThisCall")\n    if (\n        not isinstance(cancelled, bool)\n        or fields.get("status") == UNAVAILABLE_STATUS\n        or fields.get("handoffAction") == STOP_HANDOFF\n        or (by_this_call is not None and not isinstance(by_this_call, bool))\n        or (by_this_call is True and not cancelled)\n    ):\n        return UNREACHABLE\n    if not cancelled:\n        return NOT_PENDING\n    if by_this_call is None:\n        return CANCELLED_UNPROVEN\n    return WITHDRAWN_BY_THIS_CALL if by_this_call else ALREADY_CANCELLED\n' },
+  { path: "dashboard/manifest.json", contents: '{\n  "name": "pushary",\n  "label": "Pushary",\n  "description": "Approvals Pushary is carrying to your phone, answerable from Hermes Desktop",\n  "version": "1.0.1",\n  "tab": { "hidden": true },\n  "entry": "web.js",\n  "api": "plugin_api.py"\n}\n' },
+  { path: "dashboard/plugin_api.py", contents: `import importlib
+import sys
+import time
+import types
+from pathlib import Path
+from typing import Any
+
+from fastapi import APIRouter, Body, HTTPException
+
+PLUGIN_DIRECTORY = Path(__file__).resolve().parent.parent
+BACKEND_PACKAGE = "pushary_plugin_desktop_backend"
+INVALID_ANSWER = 'Send {"choice": one of the choices Hermes offered}'
+
+
+def _register_plugin_package() -> None:
+    package = types.ModuleType(BACKEND_PACKAGE)
+    package.__path__ = [str(PLUGIN_DIRECTORY)]
+    sys.modules[BACKEND_PACKAGE] = package
+
+
+_register_plugin_package()
+api = importlib.import_module(f"{BACKEND_PACKAGE}.api")
+approval = importlib.import_module(f"{BACKEND_PACKAGE}.approval")
+approval_ledger = importlib.import_module(f"{BACKEND_PACKAGE}.approval_ledger")
+desktop_answers = importlib.import_module(f"{BACKEND_PACKAGE}.desktop_answers")
+contract = importlib.import_module(f"{BACKEND_PACKAGE}.desktop_contract")
+host = importlib.import_module(f"{BACKEND_PACKAGE}.host")
+installation = importlib.import_module(f"{BACKEND_PACKAGE}.installation")
+
+router = APIRouter()
+
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+@router.get(contract.APPROVALS_PATH)
+def approvals():
+    now_ms = _now_ms()
+    recorded = approval_ledger.read_approvals(installation.hermes_home(), now_ms, installation.process_is_running)
+    view = contract.view_with_answers_here(recorded, desktop_answers.shared_answers().waiting_here(now_ms))
+    setup = contract.setup_wire(
+        api_key_saved=api.is_configured(),
+        transport_selected=host.pushary_is_selected_transport(),
+        plugin_version=installation.LOADED_PLUGIN_VERSION,
+    )
+    return contract.approvals_response(view, setup)
+
+
+@router.post(f"{contract.APPROVALS_PATH}/{{correlation_id}}{contract.ANSWER_PATH_SUFFIX}")
+def answer(correlation_id: str, body: Any = Body(default=None)):
+    choice = contract.parse_answer_request(body)
+    if choice is None or not approval_ledger.is_correlation_id(correlation_id):
+        raise HTTPException(status_code=400, detail=INVALID_ANSWER)
+    response = contract.answer_from_desktop(
+        desktop_answers.shared_answers(),
+        correlation_id,
+        choice,
+        cancel_question=api.cancel_question,
+        now_ms=_now_ms(),
+    )
+    approval.announce_approvals_changed()
+    return response
+` },
+  { path: "dashboard/web.js", contents: "(function registerPusharyDashboardPlugin() {\n  var sdk = window.__HERMES_PLUGIN_SDK__\n  var plugins = window.__HERMES_PLUGINS__\n  if (!sdk || !plugins) return\n  var h = sdk.React.createElement\n\n  function PusharyDashboardNote() {\n    return h('p', { style: { padding: '16px', color: 'var(--color-muted-foreground)' } },\n      'Pushary approvals show in the Hermes Desktop status bar and on your phone.')\n  }\n\n  plugins.register('pushary', PusharyDashboardNote)\n})()\n" },
+  { path: "desktop_answers.py", contents: `from __future__ import annotations
+
+import sys
+import threading
+import types
+from typing import Dict, Iterable, List, Optional, Tuple, TypedDict
+
+from . import approval_ledger as ledger
+
+SHARED_STATE_MODULE = "pushary_plugin_desktop_answers"
+CLAIM_RESOLVE_SECONDS = 3.0
+
+
+class AnswerSlot(TypedDict):
+    request_id: Optional[str]
+    subject: str
+    choices: List[Tuple[ledger.ApprovalChoice, str]]
+    opened_at_ms: int
+    deadline_at_ms: int
+    answerable_here: bool
+    routed_to: Optional[str]
+    claim: Optional[ledger.ClaimState]
+    decided_by: Optional[ledger.Decider]
+    desktop_choice: Optional[ledger.ApprovalChoice]
+
+
+class DesktopAnswers:
+    def __init__(self, condition: threading.Condition, slots: Dict[str, AnswerSlot]) -> None:
+        self._condition = condition
+        self._slots = slots
+
+    def open_slot(
+        self,
+        correlation_id: str,
+        *,
+        request_id: Optional[str],
+        subject: str,
+        choices: Tuple[ledger.OfferedChoice, ...],
+        opened_at_ms: int,
+        deadline_at_ms: int,
+        answerable_here: bool,
+        routed_to: Optional[str],
+    ) -> None:
+        slot: AnswerSlot = {
+            "request_id": request_id,
+            "subject": subject,
+            "choices": [(offered.choice, offered.label) for offered in choices],
+            "opened_at_ms": opened_at_ms,
+            "deadline_at_ms": deadline_at_ms,
+            "answerable_here": answerable_here,
+            "routed_to": routed_to,
+            "claim": None,
+            "decided_by": None,
+            "desktop_choice": None,
+        }
+        with self._condition:
+            self._slots[correlation_id] = slot
+            self._condition.notify_all()
+
+    def close_slot(self, correlation_id: str) -> None:
+        with self._condition:
+            self._slots.pop(correlation_id, None)
+            self._condition.notify_all()
+
+    def end_for_request(self, request_id: str) -> None:
+        with self._condition:
+            for slot in self._slots.values():
+                if slot["request_id"] == request_id and slot["decided_by"] is None:
+                    slot["decided_by"] = ledger.DECIDED_BY_TRANSPORT
+            self._condition.notify_all()
+
+    def has_ended(self, correlation_id: str) -> bool:
+        with self._condition:
+            slot = self._slots.get(correlation_id)
+            return slot is not None and slot["decided_by"] is not None
+
+    def claim(self, correlation_id: str, choice: ledger.ApprovalChoice, *, now_ms: int) -> ledger.ClaimResult:
+        with self._condition:
+            slot = self._slots.get(correlation_id)
+            if slot is None:
+                return ledger.NOT_FOUND
+            if slot["decided_by"] is not None or now_ms >= slot["deadline_at_ms"]:
+                return ledger.NOT_WAITING
+            if not slot["answerable_here"]:
+                return ledger.NOT_ANSWERABLE_HERE
+            if all(offered != choice for offered, _ in slot["choices"]):
+                return ledger.NOT_OFFERED
+            if slot["claim"] is not None:
+                return ledger.ALREADY_CLAIMED
+            slot["claim"] = ledger.CLAIMING
+            return ledger.CLAIMED
+
+    def decide_from_desktop(self, correlation_id: str, choice: ledger.ApprovalChoice) -> bool:
+        with self._condition:
+            slot = self._slots.get(correlation_id)
+            won = slot is not None and slot["decided_by"] is None and slot["claim"] == ledger.CLAIMING
+            if slot is not None and won:
+                slot["decided_by"] = ledger.DECIDED_BY_DESKTOP
+                slot["desktop_choice"] = choice
+                slot["claim"] = ledger.WON
+            elif slot is not None and slot["claim"] == ledger.CLAIMING:
+                slot["claim"] = ledger.LOST
+            self._condition.notify_all()
+            return won
+
+    def lose_claim(self, correlation_id: str) -> None:
+        with self._condition:
+            slot = self._slots.get(correlation_id)
+            if slot is not None and slot["claim"] == ledger.CLAIMING:
+                slot["claim"] = ledger.LOST
+            self._condition.notify_all()
+
+    def desktop_decision(self, correlation_id: str, offered: Iterable[ledger.ApprovalChoice]) -> Optional[ledger.ApprovalChoice]:
+        with self._condition:
+            return self._desktop_choice_locked(correlation_id, tuple(offered))
+
+    def take_final_say(
+        self,
+        correlation_id: str,
+        offered: Iterable[ledger.ApprovalChoice],
+        *,
+        claim_wait_seconds: float,
+    ) -> Optional[ledger.ApprovalChoice]:
+        allowed = tuple(offered)
+        with self._condition:
+            self._condition.wait_for(lambda: not self._claim_is_being_fenced(correlation_id),
+                                     timeout=max(0.0, claim_wait_seconds))
+            slot = self._slots.get(correlation_id)
+            if slot is not None and slot["decided_by"] is None:
+                slot["decided_by"] = ledger.DECIDED_BY_TRANSPORT
+                self._condition.notify_all()
+                return None
+            return self._desktop_choice_locked(correlation_id, allowed)
+
+    def waiting_here(self, now_ms: int) -> Tuple[ledger.WaitingApproval, ...]:
+        with self._condition:
+            live = [(correlation_id, slot.copy()) for correlation_id, slot in self._slots.items()
+                    if slot["decided_by"] != ledger.DECIDED_BY_TRANSPORT and now_ms < slot["deadline_at_ms"]]
+        return tuple(_waiting(correlation_id, slot) for correlation_id, slot in live)
+
+    def _claim_is_being_fenced(self, correlation_id: str) -> bool:
+        slot = self._slots.get(correlation_id)
+        return slot is not None and slot["decided_by"] is None and slot["claim"] == ledger.CLAIMING
+
+    def _desktop_choice_locked(
+        self, correlation_id: str, allowed: Tuple[ledger.ApprovalChoice, ...]
+    ) -> Optional[ledger.ApprovalChoice]:
+        slot = self._slots.get(correlation_id)
+        if slot is None or slot["decided_by"] != ledger.DECIDED_BY_DESKTOP or not slot["answerable_here"]:
+            return None
+        choice = slot["desktop_choice"]
+        return choice if choice in allowed else None
+
+
+def _waiting(correlation_id: str, slot: AnswerSlot) -> ledger.WaitingApproval:
+    return ledger.WaitingApproval(
+        correlation_id=correlation_id,
+        subject=slot["subject"],
+        choices=tuple(ledger.OfferedChoice(choice, label) for choice, label in slot["choices"]),
+        opened_at_ms=slot["opened_at_ms"],
+        deadline_at_ms=slot["deadline_at_ms"],
+        answerable_here=slot["answerable_here"],
+        routed_to=slot["routed_to"],
+        claim=slot["claim"],
+    )
+
+
+def shared_answers() -> DesktopAnswers:
+    holder = sys.modules.get(SHARED_STATE_MODULE)
+    if holder is None:
+        created = types.ModuleType(SHARED_STATE_MODULE)
+        setattr(created, "condition", threading.Condition())
+        setattr(created, "slots", {})
+        holder = sys.modules.setdefault(SHARED_STATE_MODULE, created)
+    condition = getattr(holder, "condition")
+    slots = getattr(holder, "slots")
+    if not isinstance(condition, threading.Condition) or not isinstance(slots, dict):
+        raise RuntimeError(f"{SHARED_STATE_MODULE} in sys.modules is not Pushary's Desktop answer state")
+    return DesktopAnswers(condition, slots)
+` },
+  { path: "desktop_contract.py", contents: 'from __future__ import annotations\n\nfrom typing import Callable, List, Literal, Mapping, Optional, Tuple, TypedDict, Union\n\nfrom . import approval_ledger as ledger\nfrom . import cancellation\nfrom .desktop_answers import DesktopAnswers\n\nCONTRACT_VERSION = 1\nPLUGIN_ID = "pushary"\nAPPROVALS_CHANGED_EVENT = "approvals.changed"\nAPPROVALS_CHANGED_WIRE_EVENT = f"plugin.{PLUGIN_ID}.{APPROVALS_CHANGED_EVENT}"\nAPPROVALS_PATH = "/approvals"\nANSWER_PATH_SUFFIX = "/answer"\n\nFenceOutcome = Literal["answered_here", "already_closed", "unreachable"]\nAnswerOutcome = Union[FenceOutcome, ledger.RefusedClaim]\n\nANSWERED_HERE: FenceOutcome = "answered_here"\nALREADY_CLOSED: FenceOutcome = "already_closed"\nUNREACHABLE: FenceOutcome = "unreachable"\nFENCE_OUTCOMES: Tuple[FenceOutcome, ...] = (ANSWERED_HERE, ALREADY_CLOSED, UNREACHABLE)\nANSWER_OUTCOMES: Tuple[AnswerOutcome, ...] = (*FENCE_OUTCOMES, *ledger.REFUSED_CLAIMS)\n\nHOST_FAILURE_OUTCOMES: Tuple[str, ...] = (\n    "transport_busy",\n    "transport_error",\n    "transport_interrupted",\n    "transport_invalid",\n    "transport_stale",\n    "transport_timeout",\n)\n\nCancelQuestion = Callable[[str], object]\n\n\nclass OfferedChoiceWire(TypedDict):\n    choice: ledger.ApprovalChoice\n    label: str\n\n\nclass WaitingApprovalWire(TypedDict):\n    correlationId: str\n    subject: str\n    choices: List[OfferedChoiceWire]\n    openedAtMs: int\n    deadlineAtMs: int\n    answerableHere: bool\n    routedTo: Optional[str]\n    claim: Optional[ledger.ClaimState]\n\n\nclass RecentApprovalWire(TypedDict):\n    correlationId: str\n    subject: str\n    openedAtMs: int\n    settledAtMs: int\n    outcome: ledger.RecentOutcome\n    answerSource: Optional[str]\n    hostOutcome: Optional[str]\n\n\nclass SetupWire(TypedDict):\n    apiKey: bool\n    transport: bool\n    pluginVersion: Optional[str]\n\n\nclass ApprovalsResponse(TypedDict):\n    version: int\n    waiting: List[WaitingApprovalWire]\n    recent: List[RecentApprovalWire]\n    setup: SetupWire\n\n\nclass AnswerResponse(TypedDict):\n    version: int\n    outcome: AnswerOutcome\n\n\nclass ContractFacts(TypedDict):\n    version: int\n    approvalsChangedWireEvent: str\n    approvalsPath: str\n    answerPathSuffix: str\n    correlationIdPattern: str\n    tokenPattern: str\n    approvalChoices: List[str]\n    claimStates: List[str]\n    recentOutcomes: List[str]\n    answerOutcomes: List[str]\n    hostFailureOutcomes: List[str]\n\n\ndef _offered_wire(offered: ledger.OfferedChoice) -> OfferedChoiceWire:\n    return {"choice": offered.choice, "label": offered.label}\n\n\ndef _waiting_wire(item: ledger.WaitingApproval) -> WaitingApprovalWire:\n    return {\n        "correlationId": item.correlation_id,\n        "subject": item.subject,\n        "choices": [_offered_wire(offered) for offered in item.choices],\n        "openedAtMs": item.opened_at_ms,\n        "deadlineAtMs": item.deadline_at_ms,\n        "answerableHere": item.answerable_here,\n        "routedTo": item.routed_to,\n        "claim": item.claim,\n    }\n\n\ndef _recent_wire(item: ledger.RecentApproval) -> RecentApprovalWire:\n    return {\n        "correlationId": item.correlation_id,\n        "subject": item.subject,\n        "openedAtMs": item.opened_at_ms,\n        "settledAtMs": item.settled_at_ms,\n        "outcome": item.outcome,\n        "answerSource": item.answer_source,\n        "hostOutcome": item.host_outcome,\n    }\n\n\ndef setup_wire(*, api_key_saved: bool, transport_selected: bool, plugin_version: Optional[str]) -> SetupWire:\n    return {"apiKey": api_key_saved, "transport": transport_selected, "pluginVersion": plugin_version}\n\n\ndef view_with_answers_here(view: ledger.ApprovalsView, here: Tuple[ledger.WaitingApproval, ...]) -> ledger.ApprovalsView:\n    answered_here = {item.correlation_id for item in here}\n    elsewhere = tuple(item for item in view.waiting if item.correlation_id not in answered_here)\n    waiting = tuple(sorted((*here, *elsewhere), key=lambda item: item.opened_at_ms))\n    return ledger.ApprovalsView(waiting=waiting, recent=view.recent)\n\n\ndef approvals_response(view: ledger.ApprovalsView, setup: SetupWire) -> ApprovalsResponse:\n    return {\n        "version": CONTRACT_VERSION,\n        "waiting": [_waiting_wire(item) for item in view.waiting],\n        "recent": [_recent_wire(item) for item in view.recent],\n        "setup": setup,\n    }\n\n\ndef answer_response(outcome: AnswerOutcome) -> AnswerResponse:\n    return {"version": CONTRACT_VERSION, "outcome": outcome}\n\n\ndef parse_answer_request(body: object) -> Optional[ledger.ApprovalChoice]:\n    if not isinstance(body, Mapping):\n        return None\n    fields: Mapping[object, object] = body\n    if set(fields) != {"choice"}:\n        return None\n    return ledger.approval_choice(fields.get("choice"))\n\n\ndef _refused(result: ledger.ClaimResult) -> Optional[ledger.RefusedClaim]:\n    for refused in ledger.REFUSED_CLAIMS:\n        if result == refused:\n            return refused\n    return None\n\n\ndef _cancel_from_desktop(cancel_question: CancelQuestion, correlation_id: str) -> cancellation.Cancellation:\n    try:\n        return cancellation.classify_cancellation(cancel_question(correlation_id))\n    except Exception:\n        return cancellation.UNREACHABLE\n\n\ndef answer_from_desktop(\n    answers: DesktopAnswers,\n    correlation_id: str,\n    choice: ledger.ApprovalChoice,\n    *,\n    cancel_question: CancelQuestion,\n    now_ms: int,\n) -> AnswerResponse:\n    refused = _refused(answers.claim(correlation_id, choice, now_ms=now_ms))\n    if refused is not None:\n        return answer_response(refused)\n    withdrawal = _cancel_from_desktop(cancel_question, correlation_id)\n    if withdrawal == cancellation.WITHDRAWN_BY_THIS_CALL and answers.decide_from_desktop(correlation_id, choice):\n        return answer_response(ANSWERED_HERE)\n    answers.lose_claim(correlation_id)\n    return answer_response(UNREACHABLE if withdrawal == cancellation.UNREACHABLE else ALREADY_CLOSED)\n\n\ndef contract_facts() -> ContractFacts:\n    return {\n        "version": CONTRACT_VERSION,\n        "approvalsChangedWireEvent": APPROVALS_CHANGED_WIRE_EVENT,\n        "approvalsPath": APPROVALS_PATH,\n        "answerPathSuffix": ANSWER_PATH_SUFFIX,\n        "correlationIdPattern": ledger.CORRELATION_ID_PATTERN.pattern,\n        "tokenPattern": ledger.TOKEN_PATTERN.pattern,\n        "approvalChoices": list(ledger.APPROVAL_CHOICES),\n        "claimStates": list(ledger.CLAIM_STATES),\n        "recentOutcomes": list(ledger.RECENT_OUTCOMES),\n        "answerOutcomes": list(ANSWER_OUTCOMES),\n        "hostFailureOutcomes": list(HOST_FAILURE_OUTCOMES),\n    }\n' },
+  { path: "desktop/plugin.js", contents: "// Generated from desktop-src/plugin.ts by scripts/build-desktop.mjs. Edit the source, then run it.\nimport { atom, Button, CopyButton, host, Popover, PopoverContent, PopoverTrigger, STATUSBAR_AREAS, StatusDot, useValue } from '@hermes/plugin-sdk';\nimport { createElement as h, useEffect, useState } from 'react';\nexport const PLUGIN_ID = 'pushary';\nexport const CONTRACT_VERSION = 1;\nexport const APPROVALS_CHANGED_WIRE_EVENT = 'plugin.pushary.approvals.changed';\nexport const APPROVALS_PATH = '/approvals';\nexport const ANSWER_PATH_SUFFIX = '/answer';\nexport const CORRELATION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;\nexport const TOKEN_PATTERN = /^[a-z][a-z0-9_]{0,63}$/;\nexport const APPROVAL_CHOICES = ['once', 'session', 'always', 'deny'];\nexport const CLAIM_STATES = ['claiming', 'won', 'lost'];\nexport const RECENT_OUTCOMES = ['once', 'session', 'always', 'deny', 'handed_to_hermes', 'ended'];\nexport const ANSWER_OUTCOMES = [\n    'answered_here', 'already_closed', 'unreachable',\n    'not_found', 'not_waiting', 'not_answerable_here', 'not_offered', 'already_claimed'\n];\nexport const HOST_FAILURE_OUTCOMES = [\n    'transport_busy', 'transport_error', 'transport_interrupted', 'transport_invalid', 'transport_stale', 'transport_timeout'\n];\nconst isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);\nconst isOneOf = (values) => (value) => typeof value === 'string' && values.includes(value);\nconst isApprovalChoice = isOneOf(APPROVAL_CHOICES);\nconst isClaimState = isOneOf(CLAIM_STATES);\nconst isRecentOutcome = isOneOf(RECENT_OUTCOMES);\nconst isAnswerOutcome = isOneOf(ANSWER_OUTCOMES);\nconst isHostFailureOutcome = isOneOf(HOST_FAILURE_OUTCOMES);\nconst isInstant = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;\nconst isCorrelationId = (value) => typeof value === 'string' && CORRELATION_ID_PATTERN.test(value);\nconst isTokenOrNull = (value) => value === null || (typeof value === 'string' && TOKEN_PATTERN.test(value));\nconst isContractVersion = (value) => value === CONTRACT_VERSION;\nconst parseList = (value, parse) => {\n    if (!Array.isArray(value))\n        return null;\n    const parsed = [];\n    for (const item of value) {\n        const result = parse(item);\n        if (result === null)\n            return null;\n        parsed.push(result);\n    }\n    return parsed;\n};\nconst parseOfferedChoice = (value) => {\n    if (!isRecord(value) || !isApprovalChoice(value.choice) || typeof value.label !== 'string')\n        return null;\n    return { choice: value.choice, label: value.label };\n};\nconst parseWaitingApproval = (value) => {\n    if (!isRecord(value))\n        return null;\n    const choices = parseList(value.choices, parseOfferedChoice);\n    const claim = value.claim === null || isClaimState(value.claim) ? value.claim : undefined;\n    const routedTo = value.routedTo === null || typeof value.routedTo === 'string' ? value.routedTo : undefined;\n    if (!isCorrelationId(value.correlationId) || typeof value.subject !== 'string' || choices === null\n        || !isInstant(value.openedAtMs) || !isInstant(value.deadlineAtMs) || claim === undefined\n        || typeof value.answerableHere !== 'boolean' || routedTo === undefined)\n        return null;\n    return {\n        correlationId: value.correlationId,\n        subject: value.subject,\n        choices,\n        openedAtMs: value.openedAtMs,\n        deadlineAtMs: value.deadlineAtMs,\n        answerableHere: value.answerableHere,\n        routedTo,\n        claim\n    };\n};\nconst parseRecentApproval = (value) => {\n    if (!isRecord(value) || !isCorrelationId(value.correlationId) || typeof value.subject !== 'string'\n        || !isInstant(value.openedAtMs) || !isInstant(value.settledAtMs) || !isRecentOutcome(value.outcome)\n        || !isTokenOrNull(value.answerSource) || !isTokenOrNull(value.hostOutcome))\n        return null;\n    return {\n        correlationId: value.correlationId,\n        subject: value.subject,\n        openedAtMs: value.openedAtMs,\n        settledAtMs: value.settledAtMs,\n        outcome: value.outcome,\n        answerSource: value.answerSource,\n        hostOutcome: value.hostOutcome\n    };\n};\nconst parseSetup = (value) => {\n    if (!isRecord(value) || typeof value.apiKey !== 'boolean' || typeof value.transport !== 'boolean')\n        return null;\n    const pluginVersion = value.pluginVersion;\n    if (pluginVersion !== null && typeof pluginVersion !== 'string')\n        return null;\n    return { apiKey: value.apiKey, transport: value.transport, pluginVersion };\n};\nexport const parseApprovalsResponse = (value) => {\n    if (!isRecord(value) || !isContractVersion(value.version))\n        return null;\n    const waiting = parseList(value.waiting, parseWaitingApproval);\n    const recent = parseList(value.recent, parseRecentApproval);\n    const setup = parseSetup(value.setup);\n    if (waiting === null || recent === null || setup === null)\n        return null;\n    return { version: value.version, waiting, recent, setup };\n};\nexport const parseAnswerResponse = (value) => {\n    if (!isRecord(value) || !isContractVersion(value.version) || !isAnswerOutcome(value.outcome))\n        return null;\n    return { version: value.version, outcome: value.outcome };\n};\nexport const answerPath = (correlationId) => isCorrelationId(correlationId) ? `${APPROVALS_PATH}/${correlationId}${ANSWER_PATH_SUFFIX}` : null;\nconst LIVE_REFRESH_MS = 2000;\nconst IDLE_REFRESH_MS = 15000;\nconst CLOCK_TICK_MS = 1000;\nconst GATEWAY_OPEN = 'open';\nconst SETTINGS_CHANGED_EVENT = `plugin.${PLUGIN_ID}.settings.changed`;\nconst TRANSPORT_COMMAND = 'hermes config set security.approval.transport pushary';\nconst SIGN_UP_URL = 'https://pushary.com/sign-up?from=hermes';\nconst UNKNOWN_SURFACE = 'Pushary';\nconst NOT_ANSWERED = 'Not answered';\nconst UNNAMED_SUBJECT = 'A command Hermes flagged';\nconst SENDING_ANSWER = 'Sending your answer\u2026';\nconst ANSWER_SURFACES = {\n    mobile_app: 'phone',\n    mobile_background: 'phone',\n    mac_app: 'Mac',\n    slack: 'Slack',\n    dashboard: 'web',\n    decide_page: 'web',\n    live_page: 'web',\n    answer_link: 'web',\n    inbox: 'web',\n    sandbox: 'sandbox',\n    hermes_desktop: 'Hermes Desktop'\n};\nconst HOST_FAILURE_TEXT = {\n    transport_busy: 'Hermes was busy',\n    transport_error: 'Failed in Hermes',\n    transport_interrupted: 'Turn interrupted',\n    transport_invalid: 'Refused by Hermes',\n    transport_stale: 'Refused by Hermes',\n    transport_timeout: 'Timed out in Hermes'\n};\nconst CHOICE_RESULTS = {\n    once: 'Allowed once',\n    session: 'Allowed for this session',\n    always: 'Always allowed',\n    deny: 'Denied'\n};\nconst CHOICE_BUTTON_VARIANTS = {\n    once: 'default',\n    session: 'secondary',\n    always: 'secondary',\n    deny: 'outline'\n};\nconst ANSWER_NOTICES = {\n    answered_here: { kind: 'success', message: 'Answered from Hermes Desktop.' },\n    already_closed: { kind: 'info', message: 'This approval had already closed, so your answer was not used.' },\n    unreachable: { kind: 'error', message: 'Pushary did not confirm your answer, so it was not used.' },\n    not_found: { kind: 'info', message: 'This approval has already ended.' },\n    not_waiting: { kind: 'info', message: 'This approval has already ended.' },\n    not_answerable_here: { kind: 'info', message: 'A Team route sends this approval to someone else to answer.' },\n    not_offered: { kind: 'error', message: 'Hermes did not offer that choice.' },\n    already_claimed: { kind: 'info', message: 'This approval is already being answered.' }\n};\nconst ANSWER_FAILED = {\n    kind: 'error',\n    message: 'Hermes Desktop could not send that answer. Answer on your phone.'\n};\nexport const waitedFor = (ms) => {\n    const seconds = Math.max(0, Math.floor(ms / 1000));\n    return `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, '0')}`;\n};\nexport const ago = (ms) => {\n    const minutes = Math.floor(Math.max(0, ms) / 60000);\n    if (minutes < 1)\n        return 'just now';\n    if (minutes < 60)\n        return `${minutes} min ago`;\n    const hours = Math.floor(minutes / 60);\n    if (hours < 24)\n        return `${hours} h ago`;\n    return `${Math.floor(hours / 24)} d ago`;\n};\nconst surfaceOf = (answerSource) => ANSWER_SURFACES[answerSource] ?? UNKNOWN_SURFACE;\nconst choiceOutcomeText = (choice, answerSource) => {\n    if (answerSource === null)\n        return choice === 'deny' ? NOT_ANSWERED : CHOICE_RESULTS[choice];\n    return `${CHOICE_RESULTS[choice]} \xB7 ${surfaceOf(answerSource)}`;\n};\nexport const outcomeText = (item) => {\n    if (item.outcome === 'handed_to_hermes')\n        return 'Handed to Hermes';\n    if (isHostFailureOutcome(item.hostOutcome))\n        return HOST_FAILURE_TEXT[item.hostOutcome];\n    if (item.outcome === 'ended')\n        return 'Ended';\n    return choiceOutcomeText(item.outcome, item.answerSource);\n};\nexport const waitingLabel = (count) => count === 1 ? '1 approval waiting' : `${count} approvals waiting`;\nexport const waitingLine = (item, now) => {\n    const waited = waitedFor(now - item.openedAtMs);\n    if (!item.answerableHere) {\n        return item.routedTo === null ? `Answer it on your phone \xB7 ${waited}` : `Routed to ${item.routedTo} \xB7 ${waited}`;\n    }\n    switch (item.claim) {\n        case 'claiming':\n            return SENDING_ANSWER;\n        case 'won':\n            return 'Answered here. Handing it to Hermes\u2026';\n        case 'lost':\n            return `Answer it on your phone \xB7 ${waited}`;\n        case null:\n            return `Waiting on your phone \xB7 ${waited}`;\n    }\n};\nexport const approvalStatusLine = (item, now, answering) => answering === item.correlationId ? SENDING_ANSWER : waitingLine(item, now);\nconst subjectOf = (subject) => subject || UNNAMED_SUBJECT;\nconst readyChipSummary = (response) => {\n    if (response.waiting.length > 0) {\n        const waiting = waitingLabel(response.waiting.length);\n        return { tone: 'warn', text: `Pushary \xB7 ${waiting}`, label: `Pushary: ${waiting}` };\n    }\n    if (!response.setup.apiKey)\n        return { tone: 'warn', text: 'Pushary \xB7 set up', label: 'Pushary needs your API key' };\n    if (!response.setup.transport) {\n        return { tone: 'warn', text: 'Pushary \xB7 not routing', label: 'Approvals are not routed to Pushary' };\n    }\n    return { tone: 'good', text: 'Pushary', label: 'Pushary carries approvals to your phone' };\n};\nexport const chipSummary = (state) => {\n    switch (state.kind) {\n        case 'loading':\n            return { tone: 'muted', text: 'Pushary', label: 'Pushary is loading' };\n        case 'offline':\n            return { tone: 'muted', text: 'Pushary', label: 'The Pushary backend is not running' };\n        case 'incompatible':\n            return { tone: 'bad', text: 'Pushary \xB7 update', label: 'This Pushary Desktop half does not match its backend' };\n        case 'ready':\n            return readyChipSummary(state.response);\n    }\n};\nexport const answerNotice = (value) => {\n    const response = parseAnswerResponse(value);\n    return response === null ? ANSWER_FAILED : ANSWER_NOTICES[response.outcome];\n};\nexport const panelStateFrom = (value) => {\n    const response = parseApprovalsResponse(value);\n    return response === null ? { kind: 'incompatible' } : { kind: 'ready', response };\n};\nconst waitingCount = (state) => (state.kind === 'ready' ? state.response.waiting.length : 0);\nexport const createApprovalsStore = (ctx) => {\n    const state = atom({ kind: 'loading' });\n    const open = atom(false);\n    const answering = atom(null);\n    let inFlight = null;\n    let refreshAgain = false;\n    let loadedAt = Number.NEGATIVE_INFINITY;\n    const load = async () => {\n        try {\n            state.set(panelStateFrom(await ctx.rest(APPROVALS_PATH)));\n        }\n        catch {\n            state.set({ kind: 'offline' });\n        }\n        finally {\n            loadedAt = Date.now();\n        }\n    };\n    const refresh = () => {\n        if (inFlight !== null) {\n            refreshAgain = true;\n            return inFlight;\n        }\n        inFlight = load().finally(() => {\n            inFlight = null;\n            if (refreshAgain) {\n                refreshAgain = false;\n                void refresh();\n            }\n        });\n        return inFlight;\n    };\n    const answer = async (item, choice) => {\n        const path = answerPath(item.correlationId);\n        if (answering.get() !== null || path === null)\n            return;\n        answering.set(item.correlationId);\n        try {\n            host.notify(answerNotice(await ctx.rest(path, { method: 'POST', body: { choice } })));\n        }\n        catch {\n            host.notify(ANSWER_FAILED);\n        }\n        finally {\n            answering.set(null);\n            void refresh();\n        }\n    };\n    const refreshIsDue = (now) => open.get() || waitingCount(state.get()) > 0 || now - loadedAt >= IDLE_REFRESH_MS;\n    return { state, open, answering, refresh, answer, refreshIsDue };\n};\nconst STYLES = {\n    chip: { display: 'inline-flex', alignItems: 'center', gap: '6px' },\n    popover: { width: 'min(340px, calc(100vw - 24px))', padding: 0 },\n    panel: {\n        padding: '12px', display: 'flex', flexDirection: 'column', gap: '12px', overflowY: 'auto', overscrollBehavior: 'contain',\n        maxHeight: 'min(560px, calc(var(--radix-popover-content-available-height, 100vh) - 16px))'\n    },\n    heading: { fontSize: '12px', fontWeight: 600, color: 'var(--ui-text-primary)' },\n    muted: { fontSize: '11px', lineHeight: '16px', color: 'var(--ui-text-tertiary)' },\n    section: { display: 'flex', flexDirection: 'column', gap: '8px' },\n    card: {\n        display: 'flex', flexDirection: 'column', gap: '8px', padding: '8px',\n        borderRadius: '4px', boxShadow: 'inset 0 0 0 1px var(--ui-stroke-secondary)'\n    },\n    subject: {\n        fontFamily: 'var(--font-mono, monospace)', fontSize: '11px', lineHeight: '16px',\n        color: 'var(--ui-text-primary)', wordBreak: 'break-word', maxHeight: '160px', overflowY: 'auto'\n    },\n    choices: { display: 'flex', flexWrap: 'wrap', gap: '6px' },\n    command: {\n        fontFamily: 'var(--font-mono, monospace)', fontSize: '11px', padding: '6px 8px', borderRadius: '4px',\n        background: 'var(--ui-bg-quaternary)', color: 'var(--ui-text-secondary)', userSelect: 'text', wordBreak: 'break-all'\n    },\n    row: { display: 'flex', justifyContent: 'space-between', gap: '8px', fontSize: '11px', lineHeight: '16px' },\n    rowSubject: {\n        overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap',\n        fontFamily: 'var(--font-mono, monospace)', color: 'var(--ui-text-secondary)'\n    },\n    rowOutcome: { flexShrink: 0, color: 'var(--ui-text-tertiary)' }\n};\nconst useNow = (ticking) => {\n    const [now, setNow] = useState(Date.now());\n    useEffect(() => {\n        if (!ticking)\n            return undefined;\n        const timer = setInterval(() => setNow(Date.now()), CLOCK_TICK_MS);\n        return () => clearInterval(timer);\n    }, [ticking]);\n    return now;\n};\nconst Muted = ({ text }) => h('div', { style: STYLES.muted }, text);\nconst SetupNotice = ({ setup, ctx }) => {\n    if (!setup.apiKey) {\n        return h('div', { style: STYLES.section }, h(Muted, { text: 'Add your Pushary API key under Settings, Plugins, Pushary.' }), h('div', null, h(Button, {\n            variant: 'secondary', size: 'xs', onClick: () => void ctx.os.openExternal(SIGN_UP_URL), children: 'Get a key'\n        })));\n    }\n    if (!setup.transport) {\n        return h('div', { style: STYLES.section }, h(Muted, { text: 'Hermes is not sending approvals to Pushary yet. Run this once:' }), h('div', { style: STYLES.command }, TRANSPORT_COMMAND), h('div', null, h(CopyButton, { text: TRANSPORT_COMMAND, label: 'Copy', showLabel: true, buttonSize: 'xs' })));\n    }\n    return null;\n};\nconst ChoiceButtons = ({ item, store }) => {\n    const answering = useValue(store.answering);\n    const disabled = answering !== null || item.claim !== null;\n    return h('div', { style: STYLES.choices }, ...item.choices.map(offered => h(Button, {\n        key: offered.choice,\n        variant: CHOICE_BUTTON_VARIANTS[offered.choice],\n        size: 'xs',\n        disabled,\n        onClick: () => void store.answer(item, offered.choice),\n        children: offered.label\n    })));\n};\nconst ApprovalCard = ({ item, store, now }) => {\n    const answering = useValue(store.answering);\n    return h('div', { style: STYLES.card }, h('div', { style: STYLES.subject }, subjectOf(item.subject)), h(Muted, { text: approvalStatusLine(item, now, answering) }), item.answerableHere ? h(ChoiceButtons, { item, store }) : null);\n};\nconst RecentRow = ({ item, now }) => h('div', { style: STYLES.row }, h('span', { style: STYLES.rowSubject, title: subjectOf(item.subject) }, subjectOf(item.subject)), h('span', { style: STYLES.rowOutcome }, `${outcomeText(item)} \xB7 ${ago(now - item.settledAtMs)}`));\nconst WaitingList = ({ response, store, now }) => {\n    if (response.waiting.length === 0) {\n        return h(Muted, { text: 'No approvals waiting. Answer them here or on your phone, whichever is closer.' });\n    }\n    return h('div', { style: STYLES.section }, ...response.waiting.map(item => h(ApprovalCard, { key: item.correlationId, item, store, now })));\n};\nconst RecentList = ({ recent, now }) => {\n    if (recent.length === 0)\n        return null;\n    return h('div', { style: STYLES.section }, h(Muted, { text: 'Recent' }), ...recent.map(item => h(RecentRow, { key: item.correlationId, item, now })));\n};\nconst ReadyPanel = ({ response, store, ctx }) => {\n    const now = useNow(response.waiting.length > 0);\n    const heading = response.waiting.length ? waitingLabel(response.waiting.length) : 'Pushary';\n    return h('div', { style: STYLES.panel }, h('div', { style: STYLES.heading }, heading), h(SetupNotice, { setup: response.setup, ctx }), h(WaitingList, { response, store, now }), h(RecentList, { recent: response.recent, now }));\n};\nconst PANEL_MESSAGES = {\n    loading: 'Loading\u2026',\n    offline: 'The Pushary backend is not running. Enable Pushary under Capabilities, Plugins, then restart Hermes.',\n    incompatible: 'This copy of the Pushary Desktop half does not match its backend. Rescan plugins under Capabilities.'\n};\nexport const PusharyPanel = ({ store, ctx }) => {\n    const state = useValue(store.state);\n    if (state.kind !== 'ready')\n        return h('div', { style: STYLES.panel }, h(Muted, { text: PANEL_MESSAGES[state.kind] }));\n    return h(ReadyPanel, { response: state.response, store, ctx });\n};\nexport const PusharyChip = ({ store, ctx }) => {\n    const summary = chipSummary(useValue(store.state));\n    const open = useValue(store.open);\n    const onOpenChange = (value) => {\n        store.open.set(value);\n        if (value)\n            void store.refresh();\n    };\n    return h(Popover, {\n        open,\n        onOpenChange,\n        children: [\n            h(PopoverTrigger, { key: 'trigger', asChild: true, children: h(Button, {\n                    variant: 'ghost', size: 'micro', 'aria-label': summary.label, title: summary.label,\n                    children: h('span', { style: STYLES.chip }, h(StatusDot, { tone: summary.tone }), h('span', null, summary.text))\n                }) }),\n            h(PopoverContent, { key: 'content', side: 'top', align: 'end', 'aria-label': 'Pushary approvals',\n                style: STYLES.popover, children: h(PusharyPanel, { store, ctx }) })\n        ]\n    });\n};\nconst registerPushary = (ctx) => {\n    const store = createApprovalsStore(ctx);\n    ctx.register({ id: 'approvals', area: STATUSBAR_AREAS.right, order: 120, render: () => h(PusharyChip, { store, ctx }) });\n    ctx.onEvent(APPROVALS_CHANGED_WIRE_EVENT, () => void store.refresh());\n    ctx.onEvent(SETTINGS_CHANGED_EVENT, () => void store.refresh());\n    ctx.onDispose(host.state.gateway.listen(value => {\n        if (value === GATEWAY_OPEN)\n            void store.refresh();\n    }));\n    ctx.setInterval(() => {\n        if (store.refreshIsDue(Date.now()))\n            void store.refresh();\n    }, LIVE_REFRESH_MS);\n    void store.refresh();\n};\nconst plugin = {\n    id: PLUGIN_ID,\n    name: 'Pushary',\n    description: 'Approvals Pushary is carrying to your phone, answerable here too.',\n    register: registerPushary\n};\nexport default plugin;\n" },
   { path: "history.py", contents: `from __future__ import annotations
 
 import hashlib
@@ -969,6 +1590,11 @@ SNAPSHOT_PRUNE_INTERVAL_SECONDS = 60 * 60
 SOURCE_UNAVAILABLE = "source_unavailable"
 HISTORY_NOT_ALLOWED_WARNING = ("[pushary] Hermes session history is not saved on this computer; it needs "
                                "\`npx pushary@latest setup\` with the key Hermes uses, or Session history turned on in the Pushary Mac app")
+HELPER_ENVIRONMENT_NAMES = frozenset({
+    "HOME", "PATH", "TMPDIR", "LANG", "LC_ALL", "LC_CTYPE",
+    "SYSTEMROOT", "PATHEXT", "COMSPEC", "USERPROFILE", "APPDATA", "LOCALAPPDATA", "TEMP", "TMP",
+    "PUSHARY_BASE_URL", "PUSHARY_API_URL", "PUSHARY_CONFIG_FILE", "PUSHARY_TRANSCRIPTS", "PUSHARY_TRANSCRIPT_REGISTRY_DIR",
+})
 
 
 class _Authorization(NamedTuple):
@@ -1096,6 +1722,14 @@ def write_snapshot(path: Path, session_id: str, messages: list[dict[str, object]
         Path(temporary).unlink(missing_ok=True)
 
 
+def _helper_environment() -> dict[str, str]:
+    return {name: value for name, value in os.environ.items() if name in HELPER_ENVIRONMENT_NAMES}
+
+
+def _registration_environment(key: str) -> dict[str, str]:
+    return {**_helper_environment(), "PUSHARY_API_KEY": key, "PUSHARY_BASE_URL": api.BASE_URL}
+
+
 def _registration_command(key: str) -> list[str] | None:
     root = Path.home() / ".pushary"
     try:
@@ -1110,7 +1744,7 @@ def _registration_command(key: str) -> list[str] | None:
             command = [helper, "hermes"]
         result = subprocess.run([helper, "authorize-export"],
                                 input=json.dumps({"apiKey": key, "baseUrl": api.BASE_URL}), text=True,
-                                stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, timeout=5, check=False)
+                                env=_helper_environment(), stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, timeout=5, check=False)
         if result.returncode != 0:
             return None
         authorization = json.loads(result.stdout)
@@ -1264,8 +1898,7 @@ def _export_loop(database_path: Path, session_id: str, key: str, command: list[s
             if ending or time.monotonic() >= next_registration:
                 payload = {"session_id": session_id, "cwd": str(database_path.parent), "transcript_path": str(path),
                            "hook_event_name": "SessionEnd" if ending else "SessionStart"}
-                environment = {**os.environ, "PUSHARY_API_KEY": key, "PUSHARY_BASE_URL": api.BASE_URL}
-                result = subprocess.run(command, input=json.dumps(payload), text=True, env=environment,
+                result = subprocess.run(command, input=json.dumps(payload), text=True, env=_registration_environment(key),
                                         stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5, check=False)
                 if result.returncode != 0:
                     logger.warning("[pushary] Hermes history reader could not register")
@@ -1415,7 +2048,7 @@ def load_record(approval_transport_registered, pid, loaded_at):
     }
 
 
-def _process_is_running(pid):
+def process_is_running(pid):
     if os.name == "nt":
         return True
     try:
@@ -1428,7 +2061,7 @@ def _process_is_running(pid):
 
 
 def _record_belongs_to_running_process(record):
-    return record.stem.isdigit() and _process_is_running(int(record.stem))
+    return record.stem.isdigit() and process_is_running(int(record.stem))
 
 
 def _prune_expired_load_records(directory, keep, now):
@@ -1463,7 +2096,7 @@ def record_plugin_load(approval_transport_registered, home=None, pid=None, now=N
         logger.debug("[pushary] could not record the plugin load: %s", exc)
         return None
 ` },
-  { path: "plugin.yaml", contents: "name: pushary\nversion: 0.9.2\ndescription: Push notifications and human-in-the-loop for Hermes Agent via Pushary\nauthor: RalphNex OU\nrequires_env:\n  - name: PUSHARY_API_KEY\n    description: Your Pushary API key\n    url: https://pushary.com/sign-up?from=hermes\n    secret: true\nprovides_tools:\n  - pushary_remind\n  - pushary_notify\n  - pushary_ask\n  - pushary_wait\n  - pushary_cancel\n  - pushary_propose_scope\n  - pushary_enroll\n  - pushary_ask_end_user\nprovides_hooks:\n  - pre_llm_call\n  - pre_tool_call\n  - post_tool_call\n  - on_session_start\n  - on_session_end\n  - on_session_finalize\nprovides_approval_transports:\n  - pushary\n" },
+  { path: "plugin.yaml", contents: 'name: pushary\nversion: 1.0.1\ndescription: Push notifications and human-in-the-loop for Hermes Agent via Pushary\nauthor: RalphNex OU\nrequires_env:\n  - name: PUSHARY_API_KEY\n    description: Your Pushary API key\n    url: https://pushary.com/sign-up?from=hermes\n    secret: true\nconfig_schema:\n  api_key:\n    type: secret\n    env: PUSHARY_API_KEY\n    label: Pushary API key\n    description: "Get one at pushary.com/sign-up?from=hermes"\n    required: true\nprovides_tools:\n  - pushary_remind\n  - pushary_notify\n  - pushary_ask\n  - pushary_wait\n  - pushary_cancel\n  - pushary_propose_scope\n  - pushary_enroll\n  - pushary_ask_end_user\nprovides_hooks:\n  - pre_llm_call\n  - pre_tool_call\n  - post_tool_call\n  - on_session_start\n  - on_session_end\n  - on_session_finalize\n  - post_approval_response\nprovides_approval_transports:\n  - pushary\n' },
   { path: "schemas.py", contents: `PUSHARY_REMIND = {
     "name": "pushary_remind",
     "description": "Schedule a one-time personal reminder on Pushary, even after Hermes exits. Use body plus in_minutes or at (ISO timestamp with explicit UTC offset, within 30 days). Never guess the user's timezone. Confirm the returned time. No arguments lists pending reminders; cancel_reminder_id cancels a scheduled one. Use Hermes cron for agent work; use this for reminding the operator.",

package/dist/{chunk-IUBDGISO.js → chunk-RMFL62HR.js}

@@ -7,7 +7,7 @@ import {
   installHermesPlugin,
   refreshHermesPluginFiles,
   shippedHermesPlugin
-} from "./chunk-VSE4OIBT.js";
+} from "./chunk-COBOR3ST.js";
 import {
   fxIgnoresInstructionsFile,
   fxInstructionsBody,

package/dist/{reapply-GTEJJ6HZ.js → reapply-LDCMRN6Q.js}

@@ -12,9 +12,9 @@ import {
   reapplyOpenCodePlugin,
   reapplyVsCodePlugin,
   repairCodexHolds
-} from "./chunk-IUBDGISO.js";
+} from "./chunk-RMFL62HR.js";
 import "./chunk-RVSRPDRF.js";
-import "./chunk-VSE4OIBT.js";
+import "./chunk-COBOR3ST.js";
 import "./chunk-SXAZPWL7.js";
 import "./chunk-JECH4NJL.js";
 import "./chunk-AZSOH2SF.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pushary",
-  "version": "1.9.101",
+  "version": "1.9.103",
   "description": "Human-in-the-loop (HITL) for AI agents: ask a person for approvals or answers by push notification. One command connects Claude Code, Codex, Cursor, Gemini CLI and more.",
   "keywords": [
     "pushary",