superwait 0.2.0__py3-none-any.whl

superwait/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: superwait
+description: Wait for agents and external conditions together, with any/all/quorum, early wake conditions, long deadlines, and useful partial results.
+---
+
+# Superwait
+
+Express when you want to wake. You choose the workflow; native tools remain
+available for spawning, steering, or collecting additional results.
+
+## One request
+
+Call wait_for with a request. For example, wait for two reviewers, wake early
+on a blocker, and stop after two hours:
+
+~~~json
+{
+  "agents": ["/root/reviewer_a", "/root/reviewer_b", "/root/reviewer_c"],
+  "session": "parent-session-from-startup-context",
+  "mode": "quorum",
+  "quorum": 2,
+  "wake_on": [{"kind": "signal", "key": "review-42/blocker", "state": "blocked", "label": "Review blocked"}],
+  "timeout": "2h"
+}
+~~~
+
+agents accepts native IDs and Codex task paths directly. The installed host
+is the default provider; set provider for a different host. Hooks must be
+installed before spawning. Codex paths become resolvable when its stop hook
+supplies the worker metadata. Codex task paths require the parent session from
+the SessionStart context supplied by setup; this prevents matching an old
+conversation with the same names. The Codex CLI fallback fills it from the
+calling thread's environment. Native UUIDs need no extra scope.
+list_agents is available for discovery or troubleshooting, not a prerequisite.
+
+mode is all by default, or any, or quorum with a count. Add targets
+for other conditions; they and agents count toward the same threshold.
+wake_on returns early independently of that threshold. Add label to any
+condition to make its meaning explicit in the result.
+
+~~~json
+{"kind":"file","path":"/workspace/ci-failed.json","label":"CI failed"}
+{"kind":"http","url":"http://localhost:8080/health","status":200}
+{"kind":"signal","key":"build-42","state":"ready"}
+{"kind":"file","path":"/workspace/server.log","event":"contains","text":"Ready"}
+{"kind":"command","argv":["python3","/workspace/check_ci.py"],"exit_code":0}
+~~~
+
+Files support exists (default), missing, changed, and literal contains.
+HTTP matches the status code. Command probes run repeatedly without a shell;
+use an observational check, not the build/deploy itself. Prefer absolute paths.
+interval controls polling, default 1 second; increase it for remote services.
+
+## Use the result
+
+- status: matched, interrupted, timed_out, or error.
+- reason and triggered: why the wait ended and which early condition fired.
+- ready: observed results and event cursors; pending: remaining work/errors.
+- continue_wait: a ready-to-use request for the remaining work, or null.
+
+After handling an interruption, pass continue_wait back as the next request
+if you want to continue. It retains the absolute deadline and file-change
+baselines, carries the remaining quorum, and consumes delivered event signals.
+Persistent conditions such as an existing blocker file must clear or be removed
+from wake_on before proceeding. After reaching a quorum, continuation waits
+for all remaining work. It does not repeat reports you already received.
+
+timeout accepts 30s, 10m, 2h, or 1d. A timezone-qualified deadline
+overrides it. A timed-out continuation remains expired; choose a new deadline
+explicitly if you want more time. For a resumed worker, use an agent target
+with after set to its last returned cursor to await a new response:
+
+~~~json
+{"session":"parent-session","targets":[{"kind":"agent","provider":"codex","id":"/root/reviewer_a","after":42}],"timeout":"2h"}
+~~~
+
+A stopped response is not proof the assignment passed; read its result. Another
+stop hook can continue a worker. Unknown workers stay pending. Cursor stop
+hooks sometimes lack enough identity: use an explicit unique outcome signal
+for indistinguishable concurrent assignments. Signal keys should identify the
+particular task; existing matching signals count unless after excludes them.
+Use signal(key, state, data) for explicit checkpoints and outcomes.
+
+## Long waits and cancellation
+
+Setup configures Codex/Claude's MCP timeout for 24 hours by default. For waits
+beyond the configured host limit, or long Cursor waits, use the same request
+with superwait wait --request wait.json --output result.json in the host's
+background terminal. The CLI emits one final result; normal host notifications
+or native collection retrieve it. It does not wake a closed conversation.
+
+Cancel the MCP call or send Ctrl-C to the CLI to stop waiting. The observed
+workers continue; only the wait's own probes are cleaned up. The process and
+machine must stay alive. CLI exits: 0 matched/interrupted, 124 timeout,
+130 cancelled, 2 error. details: true adds raw observations for diagnosis.

superwait/__init__.py

@@ -0,0 +1 @@
+"""Conditional waits with no model calls between observations."""

superwait/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

superwait/cli.py

@@ -0,0 +1,109 @@
+"""A shell interface and stdio MCP server sharing one wait engine."""
+
+import argparse
+import asyncio
+import json
+import os
+import sqlite3
+import sys
+from pathlib import Path
+
+from .store import Store
+
+
+def parser():
+    root = argparse.ArgumentParser(description="Wait for conditions without repeated model calls.")
+    root.add_argument("--db", type=Path, help="Local event database (or SUPERWAIT_DB).")
+    root.add_argument("--provider", dest="default_provider", choices=["codex", "claude", "cursor"],
+                      help="Default host for the agents shorthand.")
+    commands = root.add_subparsers(dest="command", required=True)
+    wait = commands.add_parser("wait", help="Wait once; print one final JSON result.")
+    wait.add_argument("--request", default="-", help="JSON request file, or - for stdin.")
+    wait.add_argument("--timeout", help="Override request duration: 30s, 10m, 2h, 1d.")
+    wait.add_argument("--output", type=Path, help="Also atomically save the final result here.")
+    signal = commands.add_parser("signal", help="Publish a local checkpoint or outcome.")
+    signal.add_argument("key")
+    signal.add_argument("--state", default="ready")
+    signal.add_argument("--data", default="{}", help="Small JSON object.")
+    agents = commands.add_parser("agents", help="List recent hook-observed subagents.")
+    agents.add_argument("provider", choices=["codex", "claude", "cursor"])
+    agents.add_argument("--session")
+    hook = commands.add_parser("hook", help="Host lifecycle adapter; reads JSON on stdin.")
+    hook.add_argument("provider", choices=["codex", "claude", "cursor"])
+    commands.add_parser("serve", help="Serve the MCP API over stdio.")
+    setup = commands.add_parser("setup", help="Configure hooks, MCP, and the skill in a project.")
+    setup.add_argument("provider", choices=["codex", "claude", "cursor"])
+    setup.add_argument("--project", required=True, type=Path)
+    setup.add_argument("--max-wait", default="24h", help="Host tool timeout, where supported.")
+    prune = commands.add_parser("prune", help="Delete old local observations.")
+    prune.add_argument("--days", type=float, default=30)
+    return root
+
+
+def main():
+    args = parser().parse_args()
+    code = 0
+    try:
+        if args.command == "setup":
+            from .setup import configure
+            result = configure(args.provider, args.project, args.db, args.max_wait)
+        else:
+            store = Store(args.db)
+            if args.command == "wait":
+                from .engine import wait_for
+                from .models import Agent, WaitRequest
+                raw = json.loads(sys.stdin.read() if args.request == "-" else Path(args.request).read_text())
+                if not isinstance(raw, dict):
+                    raise ValueError("wait request must be a JSON object")
+                if args.default_provider and raw.get("provider") is None:
+                    raw["provider"] = args.default_provider
+                if args.timeout:
+                    raw["timeout"] = args.timeout
+                    raw.pop("deadline", None)
+                request = WaitRequest.model_validate(raw)
+                if (request.provider or "codex") == "codex" and request.session is None and os.environ.get("CODEX_THREAD_ID"):
+                    if any(isinstance(t, Agent) and t.provider == "codex" and t.id.startswith("/")
+                           and t.session is None for t in [*request.conditions, *request.wake_conditions]):
+                        request = request.model_copy(update={"session": os.environ["CODEX_THREAD_ID"]})
+                result = asyncio.run(wait_for(request, store))
+                code = {"timed_out": 124, "error": 2}.get(result["status"], 0)
+            elif args.command == "signal":
+                data = json.loads(args.data)
+                if not isinstance(data, dict) or not args.key or not args.state:
+                    raise ValueError("signal requires nonempty key/state and object data")
+                result = {"seq": store.emit("signal", args.key, args.state, data=data)}
+            elif args.command == "agents":
+                result = {"agents": store.agents(args.provider, args.session), "limit": 50}
+            elif args.command == "hook":
+                from .hooks import record_hook
+                result = record_hook(args.provider, json.load(sys.stdin), store)
+            elif args.command == "serve":
+                from .server import serve
+                serve(store, args.default_provider or "codex")
+                return
+            elif args.command == "prune":
+                if args.days <= 0:
+                    raise ValueError("days must be positive")
+                result = {"deleted": store.prune(args.days)}
+    except KeyboardInterrupt:
+        result, code = {"status": "cancelled"}, 130
+    except (ValueError, OSError, sqlite3.Error) as exc:
+        if args.command == "hook":
+            # A recorder never asks the host to retry, continue, or block an agent.
+            print(f"superwait hook: {exc}", file=sys.stderr)
+            result = {"permission": "allow"} if args.provider == "cursor" else {}
+        else:
+            result, code = {"status": "error", "error": str(exc)}, 2
+    rendered = json.dumps(result, ensure_ascii=False)
+    if args.command == "wait" and args.output:
+        import tempfile
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        fd, temporary = tempfile.mkstemp(prefix=".superwait-", dir=args.output.parent)
+        try:
+            with os.fdopen(fd, "w") as f:
+                f.write(rendered + "\n")
+            os.replace(temporary, args.output)
+        finally:
+            Path(temporary).unlink(missing_ok=True)
+    print(rendered)
+    raise SystemExit(code)

superwait/engine.py

@@ -0,0 +1,244 @@
+"""Concurrent observations, monotonic deadlines, and cancellation."""
+
+import asyncio
+import os
+import signal
+import sqlite3
+import stat
+import time
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import httpx2 as httpx
+
+from .models import Agent, Command, File, HTTP, Signal, WaitRequest
+from .store import AmbiguousAgent, Store
+
+
+def file_stamp(path):
+    try:
+        stat = path.stat()
+        return [stat.st_dev, stat.st_ino, stat.st_size, stat.st_mtime_ns, stat.st_ctime_ns]
+    except FileNotFoundError:
+        return None
+
+
+def baseline_for(target):
+    if not isinstance(target, File) or target.event != "changed":
+        return None
+    if target.since is not None:
+        return None if target.since == "missing" else target.since
+    return file_stamp(Path(target.path).expanduser())
+
+
+async def command_result(target):
+    spawning = asyncio.create_task(asyncio.create_subprocess_exec(
+        *target.argv, cwd=target.cwd, stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE, start_new_session=(os.name == "posix"),
+    ))
+    cancelled = False
+    try:
+        process = await asyncio.shield(spawning)
+    except asyncio.CancelledError:
+        # Obtain the handle even if another condition wins during process creation.
+        process = await spawning
+        cancelled = True
+
+    async def tail(stream):
+        value = b""
+        while chunk := await stream.read(8192):
+            value = (value + chunk)[-4096:]
+        return value.decode(errors="replace")
+
+    readers = [asyncio.create_task(tail(process.stdout)), asyncio.create_task(tail(process.stderr))]
+    finished = False
+    try:
+        if cancelled:
+            raise asyncio.CancelledError
+        async with asyncio.timeout(target.probe_timeout):
+            code = await process.wait()
+            stdout, stderr = await asyncio.gather(*readers)
+        finished = True
+        return {"matched": code == target.exit_code, "exit_code": code, "stdout": stdout, "stderr": stderr}
+    finally:
+        # Only terminate probes we launched; never the agents or jobs being observed.
+        if not finished:
+            try:
+                if os.name == "posix":
+                    os.killpg(process.pid, signal.SIGKILL)
+                elif process.returncode is None:
+                    process.kill()
+            except ProcessLookupError:
+                pass
+        await process.wait()
+        for reader in readers:
+            if not reader.done():
+                reader.cancel()
+        await asyncio.gather(*readers, return_exceptions=True)
+
+
+async def observe(target, store, client, baseline=None):
+    try:
+        if isinstance(target, (Agent, Signal)):
+            if isinstance(target, Agent):
+                event = store.agent(target.id, target.provider, target.session)
+                matched = event and event["state"] in target.states and event["seq"] > target.after
+            else:
+                event = store.signal(target.key, target.state, target.after)
+                matched = bool(event)
+            return {"matched": bool(matched), "state": event["state"] if event else "unknown", "event": event}
+        if isinstance(target, File):
+            path = Path(target.path).expanduser().absolute()
+            stamp = file_stamp(path)
+            if target.event == "contains":
+                if stamp is None:
+                    return {"matched": False, "state": "missing"}
+                needle = target.text.encode()
+                fd = os.open(path, os.O_RDONLY | getattr(os, "O_NONBLOCK", 0))
+                with os.fdopen(fd, "rb") as f:
+                    if not stat.S_ISREG(os.fstat(f.fileno()).st_mode):
+                        return {"matched": False, "error": "contains requires a regular file"}
+                    overlap = b""
+                    matched = False
+                    while block := f.read(65536):
+                        data = overlap + block
+                        if needle in data:
+                            matched = True
+                            break
+                        overlap = data[-(len(needle) - 1):] if len(needle) > 1 else b""
+                        await asyncio.sleep(0)  # Large logs remain interruptible.
+            else:
+                matched = {"exists": stamp is not None, "missing": stamp is None, "changed": stamp != baseline}[target.event]
+            return {"matched": matched, "path": str(path), "stamp": stamp}
+        if isinstance(target, HTTP):
+            async with client.stream("GET", target.url) as response:
+                return {"matched": response.status_code == target.status, "status_code": response.status_code}
+        if isinstance(target, Command):
+            return await command_result(target)
+    except AmbiguousAgent as exc:
+        return {"matched": False, "state": "ambiguous", "error": str(exc)}
+    except (OSError, ValueError, sqlite3.Error, httpx.HTTPError, TimeoutError) as exc:
+        # Connection failures and nonzero probes are observations, not successful conditions.
+        return {"matched": False, "error": str(exc)[:500] or type(exc).__name__}
+    raise TypeError("unsupported target")
+
+
+async def wait_for(request: WaitRequest, store: Store, progress=None):
+    started = time.monotonic()
+    duration = request.duration()
+    end = started + duration
+    deadline = request.deadline.isoformat() if request.deadline else (datetime.now(timezone.utc) + timedelta(seconds=duration)).isoformat()
+    primary = request.conditions
+    wake_conditions = request.wake_conditions
+    targets = [*primary, *wake_conditions]
+    baselines = [baseline_for(t) for t in targets]
+    results = [{"matched": False, "state": "pending"} for _ in targets]
+    needed = len(primary) if request.mode == "all" else (request.quorum if request.mode == "quorum" else 1)
+    checks = 0
+    async with httpx.AsyncClient(timeout=10, follow_redirects=False) as client:
+        changed = asyncio.Event()
+
+        async def probe(i):
+            nonlocal checks
+            while True:
+                checks += 1
+                results[i] = await observe(targets[i], store, client, baselines[i])
+                changed.set()
+                await asyncio.sleep(request.interval)
+
+        async def keepalive():
+            while True:
+                await asyncio.sleep(15)
+                await progress(time.monotonic() - started, duration)
+
+        def card(t, r):
+            identity = {Agent: "id", Signal: "key", File: "path", HTTP: "url", Command: "argv"}[type(t)]
+            value = getattr(t, identity)
+            c = {"label": t.label or value, "kind": t.kind, identity: value,
+                 "state": r.get("state", "matched" if r["matched"] else "pending")}
+            if isinstance(t, Agent):
+                c["provider"] = t.provider
+            if e := r.get("event"):
+                c["cursor"] = e["seq"]
+                if isinstance(t, Agent):
+                    c.update(id=e["key"], handle=t.id, session=e["session"])
+                if r["matched"]:
+                    data = e["data"]
+                    field = "report" if data.get("report") else "summary"
+                    c["result"] = data.get(field, "") if isinstance(t, Agent) else data
+                    if isinstance(t, Agent) and data.get(field + "_truncated"):
+                        c["result_truncated"] = True
+                        if data.get("transcript_path"):
+                            c["transcript_path"] = data["transcript_path"]
+                elif isinstance(t, (Agent, Signal)) and e["seq"] <= t.after:
+                    c["state"] = "awaiting_new_event"
+            for key in ("error", "status_code", "exit_code", "stdout", "stderr"):
+                if key in r and r[key] != "":
+                    c[key] = r[key]
+            return c
+
+        def continuing(t, r, baseline, wake=False):
+            data = t.model_dump(exclude_none=True, exclude_defaults=True)
+            if isinstance(t, File) and t.event == "changed":
+                data["since"] = (r.get("stamp") if wake and r["matched"] else baseline) or "missing"
+            if isinstance(t, (Agent, Signal)) and wake and r["matched"]:
+                data["after"] = r["event"]["seq"]
+            return data
+
+        def outcome(status, error=None):
+            main = list(zip(primary, results, baselines))
+            wake = list(zip(wake_conditions, results[len(primary):], baselines[len(primary):]))
+            ready = [card(t, r) for t, r, _ in main if r["matched"]]
+            pending = [card(t, r) for t, r, _ in main if not r["matched"]]
+            triggered = [card(t, r) for t, r, _ in wake if r["matched"]]
+            reason = {
+                "matched": f"{len(ready)} of {len(primary)} targets ready; {needed} required.",
+                "interrupted": "Wake condition matched: " + ", ".join(str(c["label"]) for c in triggered),
+                "timed_out": f"Deadline reached with {len(pending)} targets still pending.",
+                "error": error or "Resolve the reported target error before waiting again.",
+            }[status]
+            continuation = None
+            if pending and status != "error":
+                remaining = needed - len(ready)
+                continuation = {"targets": [continuing(t, r, b) for t, r, b in main if not r["matched"]],
+                    "mode": "all", "deadline": deadline, "interval": request.interval,
+                    "wake_on": [continuing(t, r, b, True) for t, r, b in wake]}
+                if 0 < remaining < len(pending):
+                    continuation.update(mode="quorum", quorum=remaining)
+            result = {"status": status, "reason": reason, "ready": ready, "pending": pending,
+                "triggered": triggered, "progress": {"ready": len(ready), "required": needed, "total": len(primary)},
+                "deadline": deadline, "elapsed_seconds": round(time.monotonic() - started, 3),
+                "continue_wait": continuation}
+            if request.details:
+                result.update(checks=checks,
+                    targets=[{"target": t.model_dump(exclude_none=True), **r} for t, r, _ in main],
+                    wake_on=[{"target": t.model_dump(exclude_none=True), **r} for t, r, _ in wake])
+            return result
+
+        try:
+            async with asyncio.timeout_at(end):
+                async with asyncio.TaskGroup() as group:
+                    workers = [group.create_task(probe(i)) for i in range(len(targets))]
+                    if progress:
+                        workers.append(group.create_task(keepalive()))
+                    try:
+                        while True:
+                            await changed.wait()
+                            changed.clear()
+                            # Each condition polls independently: a slow probe must
+                            # not delay checking a fast-changing wake condition.
+                            if any(r.get("state") == "ambiguous" for r in results):
+                                return outcome("error")
+                            identities = [(r["event"]["provider"], r["event"]["session"], r["event"]["key"])
+                                          for t, r in zip(primary, results) if isinstance(t, Agent) and r.get("event")]
+                            if len(identities) != len(set(identities)):
+                                return outcome("error", "Two targets resolve to the same agent; remove the duplicate handle.")
+                            if any(r["matched"] for r in results[len(primary):]):
+                                return outcome("interrupted")
+                            if sum(r["matched"] for r in results[:len(primary)]) >= needed:
+                                return outcome("matched")
+                    finally:
+                        for worker in workers:
+                            worker.cancel()
+        except TimeoutError:
+            return outcome("timed_out")

superwait/hooks.py

@@ -0,0 +1,102 @@
+"""Translate documented host lifecycle payloads into local observations."""
+
+import hashlib
+import json
+from pathlib import Path
+
+from .store import Store
+
+
+def task_key(payload):
+    value = [payload.get("task"), payload.get("subagent_type")]
+    return hashlib.sha256(json.dumps(value, ensure_ascii=False).encode()).hexdigest()
+
+
+def codex_aliases(payload):
+    """Read only the metadata header of the exact transcript supplied by Codex.
+
+    Codex 0.153 exposes task paths in session metadata but not lifecycle hooks.
+    UUID and parent checks prevent correlating a different worker's transcript.
+    No history scan, body parsing, model call, or host-state mutation is needed.
+    """
+    path = payload.get("agent_transcript_path")
+    if not path:
+        return []
+    try:
+        with Path(path).open("rb") as f:
+            line = f.readline()
+        record = json.loads(line)
+        meta = record.get("payload", {})
+        source = meta.get("source", {})
+        spawn = source.get("subagent", {}).get("thread_spawn", {}) if isinstance(source, dict) else {}
+        if (record.get("type") != "session_meta" or meta.get("id") != payload.get("agent_id")
+                or spawn.get("parent_thread_id") != payload.get("session_id")):
+            return []
+        path = spawn.get("agent_path")
+        return [path] if isinstance(path, str) and path else []
+    except (OSError, ValueError, AttributeError):
+        return []
+
+
+def record_hook(provider: str, payload: dict, store: Store):
+    if not isinstance(payload, dict):
+        raise ValueError("hook payload must be a JSON object")
+    event = payload.get("hook_event_name", "")
+    name = event.lower()
+    session = payload.get("session_id") or ""
+    if provider == "codex" and name == "sessionstart" and session:
+        return {"hookSpecificOutput": {"hookEventName": "SessionStart", "additionalContext":
+            f"Superwait parent session: {session}. When waiting on Codex task paths such as /root/reviewer, "
+            "set request.session to this value. Native UUIDs do not require it."}}
+    agent = payload.get("agent_id")
+    data = {"agent_type": payload.get("agent_type", ""), "source": event}
+    state = None
+    if provider == "cursor":
+        session = payload.get("parent_conversation_id") or payload.get("conversation_id") or session
+        agent = payload.get("subagent_id")
+        data["agent_type"] = payload.get("subagent_type", "")
+        data["task_key"] = task_key(payload)
+        if name == "subagentstop" and not agent:
+            # Cursor's documented stop payload omits the start ID. Never guess
+            # between concurrent identical tasks, even when one finished first.
+            candidates = [a for a in store.agents("cursor", session, None)
+                          if a["state"] == "running" and a["data"].get("task_key") == data["task_key"]]
+            if payload.get("task") and len(candidates) == 1:
+                agent = candidates[0]["key"]
+            else:
+                store.emit("diagnostic", "cursor-unmatched-stop", "unmatched", provider="cursor", session=session,
+                           data={"reason": "stop event has no unambiguous subagent ID; use an explicit signal", "candidates": len(candidates)})
+                return {}
+        summary = str(payload.get("summary") or "")
+        data["summary"] = summary[:4096]
+        data["summary_truncated"] = len(summary) > 4096
+        if path := payload.get("agent_transcript_path"):
+            data["transcript_path"] = path
+        state = {"completed": "stopped", "error": "error", "aborted": "aborted"}.get(payload.get("status"))
+    else:
+        summary = str(payload.get("last_assistant_message") or "")
+        data["summary"] = summary[:4096]
+        data["summary_truncated"] = len(summary) > 4096
+        if path := payload.get("agent_transcript_path"):
+            data["transcript_path"] = path
+    if name == "subagentstart":
+        state = "running"
+    elif name == "subagentstop":
+        state = state or "stopped"
+    elif name == "posttooluse" and payload.get("tool_name") == "SubagentHandback" and agent:
+        # A delivered report is not itself a completion event.
+        prior = store.latest("agent", agent, provider=provider, session=session)
+        state = prior["state"] if prior else "running"
+        report = str(payload.get("tool_input", {}).get("message") or "")
+        data = {**(prior["data"] if prior else {}), "report": report[:8192], "report_truncated": len(report) > 8192}
+    else:
+        return {}
+    if not session or not agent:
+        raise ValueError("lifecycle event is missing its session or agent ID")
+    prior = store.latest("agent", agent, provider=provider, session=session)
+    if provider == "codex":
+        data["aliases"] = codex_aliases(payload) or (prior["data"].get("aliases", []) if prior else [])
+    if name != "subagentstart" and prior:
+        data = {**prior["data"], **data}
+    store.emit("agent", agent, state, provider=provider, session=session, data=data)
+    return {"permission": "allow"} if provider == "cursor" and name == "subagentstart" else {}

superwait/models.py

@@ -0,0 +1,128 @@
+"""The same validated request schema is used by MCP, Python, and the CLI."""
+
+import math
+import re
+from datetime import datetime, timezone
+from typing import Annotated, Literal
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+class Model(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+class Condition(Model):
+    label: str | None = Field(default=None, description="Optional name used in the result, e.g. CI failed.")
+
+
+class Agent(Condition):
+    kind: Literal["agent"]
+    provider: Literal["codex", "claude", "cursor"]
+    id: str = Field(min_length=1)
+    session: str | None = None
+    states: list[Literal["running", "stopped", "error", "aborted"]] = Field(
+        default_factory=lambda: ["stopped", "error", "aborted"], min_length=1
+    )
+    after: int = Field(default=0, ge=0, description="Only match an event newer than this cursor.")
+
+
+class Signal(Condition):
+    kind: Literal["signal"]
+    key: str = Field(min_length=1)
+    state: str | None = None
+    after: int = Field(default=0, ge=0)
+
+
+class File(Condition):
+    kind: Literal["file"]
+    path: str = Field(min_length=1)
+    event: Literal["exists", "missing", "changed", "contains"] = "exists"
+    text: str | None = None
+    since: list[int] | Literal["missing"] | None = Field(default=None,
+        description="Returned in continue_wait to preserve a changed-file baseline. Omit for a new wait.")
+
+    @model_validator(mode="after")
+    def check_text(self):
+        if self.event == "contains" and not self.text:
+            raise ValueError("file contains requires nonempty text")
+        return self
+
+
+class HTTP(Condition):
+    kind: Literal["http"]
+    url: str = Field(pattern=r"^https?://")
+    status: int = Field(default=200, ge=100, le=599)
+
+
+class Command(Condition):
+    kind: Literal["command"]
+    argv: list[str] = Field(min_length=1, description="An observational command, repeated without a shell.")
+    cwd: str | None = None
+    exit_code: int = 0
+    probe_timeout: float = Field(default=10, gt=0, allow_inf_nan=False)
+
+
+Target = Annotated[Agent | Signal | File | HTTP | Command, Field(discriminator="kind")]
+
+
+def seconds(value: str) -> float:
+    match = re.fullmatch(r"\s*(\d+(?:\.\d+)?)\s*(ms|s|m|h|d)?\s*", value)
+    if not match:
+        raise ValueError("duration must be a number with ms, s, m, h, or d (for example 2h)")
+    result = float(match[1]) * {None: 1, "ms": .001, "s": 1, "m": 60, "h": 3600, "d": 86400}[match[2]]
+    if not math.isfinite(result) or result <= 0:
+        raise ValueError("duration must be finite and positive")
+    return result
+
+
+class WaitRequest(Model):
+    agents: list[str] = Field(default_factory=list, description="Native IDs, or Codex task paths with the parent session. No UUID lookup needed.")
+    provider: Literal["codex", "claude", "cursor"] | None = Field(default=None,
+        description="Defaults to the host selected during setup; standalone Python defaults to Codex.")
+    session: str | None = Field(default=None, description="Parent session from SessionStart context; required for Codex task paths.")
+    targets: list[Target] = Field(default_factory=list)
+    timeout: str = "10m"
+    mode: Literal["any", "all", "quorum"] = "all"
+    quorum: int | None = Field(default=None, gt=0)
+    wake_on: list[Target] = Field(default_factory=list)
+    interval: float = Field(default=1, ge=.05, allow_inf_nan=False)
+    deadline: datetime | None = Field(default=None, description="Absolute deadline; survives a caller retry. Overrides timeout.")
+    details: bool = Field(default=False, description="Include raw probe observations for troubleshooting.")
+
+    @property
+    def conditions(self):
+        provider = self.provider or "codex"
+        return [*(Agent(kind="agent", provider=provider, id=id, session=self.session) for id in self.agents),
+                *self._scoped(self.targets)]
+
+    @property
+    def wake_conditions(self):
+        return self._scoped(self.wake_on)
+
+    def _scoped(self, targets):
+        return [t.model_copy(update={"session": self.session})
+                if isinstance(t, Agent) and t.provider == (self.provider or "codex") and t.session is None and self.session
+                else t for t in targets]
+
+    @model_validator(mode="after")
+    def validate_request(self):
+        seconds(self.timeout)
+        targets = self.conditions
+        if not targets:
+            raise ValueError("provide agents or targets to wait for")
+        if self.deadline and self.deadline.tzinfo is None:
+            raise ValueError("deadline must include a timezone")
+        if self.mode == "quorum":
+            if self.quorum is None or self.quorum > len(targets):
+                raise ValueError("quorum must be between 1 and the number of targets")
+        elif self.quorum is not None:
+            raise ValueError("quorum is only valid with mode=quorum")
+        if len({t.model_dump_json(exclude={"label"}) for t in targets}) != len(targets):
+            raise ValueError("duplicate targets would count the same outcome twice")
+        return self
+
+    def duration(self) -> float:
+        if self.deadline:
+            return max(0, (self.deadline - datetime.now(timezone.utc)).total_seconds())
+        return seconds(self.timeout)

superwait/server.py

@@ -0,0 +1,64 @@
+"""Thin MCP transport; the engine also runs directly as a CLI."""
+
+from typing import Any, Literal
+
+from mcp.server.mcpserver import Context, MCPServer
+
+from .engine import wait_for as run_wait
+from .models import WaitRequest
+from .store import Store
+
+
+def serve(store: Store, default_provider="codex"):
+    server = MCPServer("superwait", instructions=(
+        "Express a wait in one request: agents, any/all/quorum, early wake conditions, and deadline. "
+        f"The agents shorthand defaults to {default_provider}. Use native IDs or Codex /root/task paths directly. "
+        "Codex task paths require session from the SessionStart context to avoid matching another conversation. "
+        "Results give ready reports, pending work, triggered conditions, and a copyable continue_wait request. "
+        "list_agents is for discovery or troubleshooting; a stopped response is not proof its task passed. "
+        "Unknown agents remain pending. signal reports checkpoints or blockers explicitly. "
+        "For a wait longer than the host's MCP timeout, use the superwait CLI in its background terminal. "
+        "Cancelling a wait never stops the agents it observes."
+    ))
+
+    @server.tool()
+    async def wait_for(request: WaitRequest, ctx: Context) -> dict[str, Any]:
+        """Wait for any/all/quorum targets or wake_on conditions, until a deadline.
+
+        Use agents=[native_handle, ...] for workers; add targets for other conditions.
+        A target is agent, signal, file, http, or command. Command probes execute
+        repeatedly without a shell: use observational checks. File changed uses
+        the state at call entry. timeout accepts 30s, 10m, 2h, 1d. An absolute
+        deadline overrides timeout and preserves the deadline on retries.
+        Returns matched/interrupted/timed_out/error, ready reports, pending work,
+        and triggered conditions. Pass continue_wait back as request to continue
+        remaining work with the same deadline. details=true adds raw observations.
+        Protocol cancellation stops this wait and its own probes only.
+        """
+        async def progress(elapsed, duration):
+            await ctx.report_progress(elapsed, duration)
+        if request.provider is None:
+            request = request.model_copy(update={"provider": default_provider})
+        return await run_wait(request, store, progress)
+
+    @server.tool()
+    def list_agents(provider: Literal["codex", "claude", "cursor"], session: str | None = None) -> dict[str, Any]:
+        """List up to 50 recent hook-observed agents and their event cursors.
+
+        Specify session when known. Empty means no hooks have observed these
+        agents, not that they finished. after=seq waits for a later observation.
+        """
+        return {"agents": store.agents(provider, session), "limit": 50}
+
+    @server.tool()
+    def signal(key: str, state: str = "ready", data: dict | None = None) -> dict[str, Any]:
+        """Publish an explicit checkpoint or outcome to local waiting processes.
+
+        Use a task-specific unique key shared with the waiting agent. This does
+        not send a message, wake a closed conversation, or change an agent's work.
+        """
+        if not key or not state:
+            raise ValueError("key and state cannot be empty")
+        return {"seq": store.emit("signal", key, state, data=data)}
+
+    server.run(transport="stdio")

superwait/setup.py

@@ -0,0 +1,105 @@
+"""Project-local setup, preserving unrelated settings and saving originals."""
+
+import json
+import os
+import shlex
+import sys
+import tomllib
+from importlib.resources import files
+from pathlib import Path
+
+from .models import seconds
+from .store import default_db
+
+
+def write(path: Path, contents: str):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if path.exists():
+        if path.read_text() == contents:
+            return
+        backup = path.with_name(path.name + ".superwait-backup")
+        if not backup.exists():
+            fd = os.open(backup, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
+            with os.fdopen(fd, "wb") as f:
+                f.write(path.read_bytes())
+    path.write_text(contents)
+
+
+def configure(provider, project, db=None, max_wait="24h"):
+    project = project.expanduser().absolute()
+    db = (db or default_db()).expanduser().absolute()
+    prefix = [sys.executable, "-m", "superwait", "--db", str(db), "--provider", provider]
+    hook_command = shlex.join([*prefix, "hook", provider])
+    server = {"command": prefix[0], "args": [*prefix[1:], "serve"]}
+    host_timeout = int(seconds(max_wait)) + 30
+    hostdir = {"codex": ".codex", "claude": ".claude", "cursor": ".cursor"}[provider]
+    written = []
+
+    def put(path, content):
+        write(path, content)
+        written.append(str(path))
+
+    def read_json(path):
+        value = json.loads(path.read_text()) if path.exists() else {}
+        if not isinstance(value, dict):
+            raise ValueError(f"expected a JSON object in {path}")
+        return value
+
+    hookpath = project / hostdir / ("settings.json" if provider == "claude" else "hooks.json")
+    hook_config = read_json(hookpath)
+    if not isinstance(hook_config.get("hooks", {}), dict):
+        raise ValueError("existing hooks must be an object")
+
+    if provider == "codex":
+        path = project / hostdir / "config.toml"
+        text = path.read_text() if path.exists() else ""
+        parsed = tomllib.loads(text)
+        start, stop = "# BEGIN superwait", "# END superwait"
+        if start in text:
+            before, rest = text.split(start, 1)
+            _, after = rest.split(stop, 1)
+            text = before.rstrip() + after
+        elif "superwait" in parsed.get("mcp_servers", {}):
+            raise ValueError("existing superwait MCP entry is not managed by setup; edit it explicitly")
+        fragment = (f'{start}\n[mcp_servers.superwait]\ncommand = {json.dumps(server["command"])}\n'
+                    f'args = {json.dumps(server["args"])}\ntool_timeout_sec = {host_timeout}\n{stop}\n')
+        put(path, text.rstrip() + "\n\n" + fragment)
+    else:
+        path = project / (".mcp.json" if provider == "claude" else ".cursor/mcp.json")
+        config = read_json(path)
+        if provider == "claude":
+            server["timeout"] = host_timeout * 1000
+        config.setdefault("mcpServers", {})["superwait"] = server
+        put(path, json.dumps(config, indent=2) + "\n")
+
+    config = hook_config
+    hooks = config.setdefault("hooks", {})
+    if provider == "cursor":
+        config.setdefault("version", 1)
+    events = ["subagentStart", "subagentStop"] if provider == "cursor" else ["SubagentStart", "SubagentStop"]
+    if provider == "claude":
+        events.append("PostToolUse")
+    if provider == "codex":
+        events.append("SessionStart")
+    for event in events:
+        entries = hooks.setdefault(event, [])
+        # Remove only our recorder entries, identified by their exact invocation.
+        def ours(entry):
+            commands = [entry.get("command", "")] + [h.get("command", "") for h in entry.get("hooks", [])]
+            return any("-m superwait --db " in c and c.endswith(" hook " + provider) for c in commands)
+        entries[:] = [entry for entry in entries if not ours(entry)]
+        if provider == "cursor":
+            entries.append({"command": hook_command, "timeout": 5})
+        else:
+            entry = {"hooks": [{"type": "command", "command": hook_command, "timeout": 5}]}
+            if event == "PostToolUse":
+                entry["matcher"] = "SubagentHandback"
+            entries.append(entry)
+    put(hookpath, json.dumps(config, indent=2) + "\n")
+    skilldir = ".agents" if provider == "codex" else hostdir
+    skillpath = project / skilldir / "skills/superwait/SKILL.md"
+    put(skillpath, files("superwait").joinpath("SKILL.md").read_text()
+        + "\nCLI for this installation (includes the shared event database):\n\n```sh\n"
+        + shlex.join(prefix) + " wait --request wait.json\n```\n")
+    return {"written": written, "database": str(db), "max_wait": max_wait,
+            "next": "Restart the host and review its MCP/hooks trust prompts. Cursor: use the CLI for waits beyond its tool timeout."}

superwait/store.py

@@ -0,0 +1,113 @@
+"""Small local event store, shared by hooks and waiting processes."""
+
+import json
+import os
+import sqlite3
+import time
+from contextlib import contextmanager
+from pathlib import Path
+
+
+class AmbiguousAgent(ValueError):
+    pass
+
+
+def default_db() -> Path:
+    if value := os.environ.get("SUPERWAIT_DB"):
+        return Path(value).expanduser().absolute()
+    root = Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local/state"))
+    return root / "superwait/events.sqlite3"
+
+
+class Store:
+    def __init__(self, path: Path | str | None = None):
+        self.path = Path(path) if path is not None else default_db()
+        self.path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        fd = os.open(self.path, os.O_CREAT | os.O_RDWR, 0o600)
+        os.close(fd)
+        with self.connect() as db:
+            db.executescript("""
+                CREATE TABLE IF NOT EXISTS events (
+                    seq INTEGER PRIMARY KEY AUTOINCREMENT, kind TEXT NOT NULL,
+                    provider TEXT NOT NULL, session TEXT NOT NULL,
+                    key TEXT NOT NULL, state TEXT NOT NULL,
+                    at REAL NOT NULL, data TEXT NOT NULL
+                );
+                CREATE INDEX IF NOT EXISTS event_lookup
+                    ON events(kind, provider, session, key, seq);
+            """)
+
+    @contextmanager
+    def connect(self):
+        db = sqlite3.connect(self.path, timeout=2)
+        db.row_factory = sqlite3.Row
+        try:
+            with db:
+                yield db
+        finally:
+            db.close()
+
+    def emit(self, kind, key, state, *, provider="", session="", data=None):
+        payload = json.dumps(data or {}, ensure_ascii=False)
+        if len(payload.encode()) > 65536:
+            raise ValueError("event data must fit in 64 KiB")
+        with self.connect() as db:
+            cursor = db.execute(
+                "INSERT INTO events(kind,provider,session,key,state,at,data) VALUES(?,?,?,?,?,?,?)",
+                (kind, provider, session, key, state, time.time(), payload),
+            )
+            return cursor.lastrowid
+
+    @staticmethod
+    def decode(row):
+        return {**dict(row), "data": json.loads(row["data"])}
+
+    def latest(self, kind, key, *, provider="", session=None):
+        query = "SELECT * FROM events WHERE kind=? AND provider=? AND key=?"
+        args = [kind, provider, key]
+        if session is not None:
+            query += " AND session=?"
+            args.append(session)
+        query = "SELECT * FROM (" + query + " ORDER BY seq DESC) GROUP BY session HAVING seq=MAX(seq)"
+        with self.connect() as db:
+            rows = db.execute(query, args).fetchall()
+        if len(rows) > 1:
+            raise ValueError("agent ID exists in multiple sessions; specify session")
+        return self.decode(rows[0]) if rows else None
+
+    def signal(self, key, state=None, after=0):
+        query = "SELECT * FROM events WHERE kind='signal' AND key=? AND seq>?"
+        args = [key, after]
+        if state is not None:
+            query += " AND state=?"
+            args.append(state)
+        with self.connect() as db:
+            row = db.execute(query + " ORDER BY seq DESC LIMIT 1", args).fetchone()
+        return self.decode(row) if row else None
+
+    def agent(self, handle, provider, session=None):
+        if provider == "codex" and handle.startswith("/") and session is None:
+            raise AmbiguousAgent("Codex task paths are session-local; include session from the Superwait SessionStart context.")
+        matches = [a for a in self.agents(provider, session, None)
+                   if a["key"] == handle or handle in a["data"].get("aliases", [])]
+        if len(matches) > 1:
+            raise AmbiguousAgent(f"agent handle {handle!r} is ambiguous; specify its parent session")
+        return matches[0] if matches else None
+
+    def agents(self, provider=None, session=None, limit=50):
+        query = "SELECT * FROM events WHERE kind='agent'"
+        args = []
+        for name, value in (("provider", provider), ("session", session)):
+            if value is not None:
+                query += f" AND {name}=?"
+                args.append(value)
+        query += " AND seq IN (SELECT MAX(seq) FROM events WHERE kind='agent' GROUP BY provider,session,key) ORDER BY seq DESC"
+        if limit is not None:
+            query += " LIMIT ?"
+            args.append(limit)
+        with self.connect() as db:
+            return [self.decode(r) for r in db.execute(query, args)]
+
+    def prune(self, days=30):
+        with self.connect() as db:
+            return db.execute("DELETE FROM events WHERE at < ?", (time.time() - days * 86400,)).rowcount

superwait-0.2.0.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.5
+Name: superwait
+Version: 0.2.0
+Summary: Conditional waiting for coding agents
+Project-URL: Repository, https://github.com/ctxrs/superwait
+Project-URL: Issues, https://github.com/ctxrs/superwait/issues
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: httpx2<3,>=2.13
+Requires-Dist: mcp<3,>=2.2
+Requires-Dist: pydantic<3,>=2.12
+Description-Content-Type: text/markdown
+
+# Superwait
+
+Conditional waiting for coding agents. Wait for any, all, or a count of workers
+and other conditions, wake early on a blocker, and keep one deadline across
+interruptions.
+
+Superwait provides an MCP tool and CLI, with setup for Codex, Claude Code, and
+Cursor. The agent chooses the workflow; local code checks the conditions.
+There are no model calls inside the wait.
+
+## Install
+
+Requires Python 3.11+ and [uv](https://docs.astral.sh/uv/).
+
+```sh
+uv tool install superwait
+superwait setup codex --project /path/to/project
+# Other hosts:
+superwait setup claude --project /path/to/project
+superwait setup cursor --project /path/to/project
+```
+
+Setup installs project-local MCP settings, lifecycle hooks, and agent
+instructions. It preserves unrelated settings and backs up changed files as
+`.superwait-backup`. Restart the host and accept its normal trust prompts.
+Install hooks before spawning workers, and keep the Python tool environment
+installed. See [host integration](https://github.com/ctxrs/superwait/blob/main/docs/hosts.md) for details.
+
+To install the current source instead, use
+`uv tool install 'git+https://github.com/ctxrs/superwait'`.
+
+Linux is tested. Codex has live integration coverage; Claude Code and Cursor
+have adapter tests and still need full live workflow qualification. Other
+operating systems and multi-hour host waits remain unqualified.
+
+## Express the wait
+
+Call the MCP tool `wait_for` with a `request`. For example, wait for two of three
+reviewers, or return early when an explicit blocker signal arrives:
+
+```json
+{
+  "request": {
+    "agents": ["reviewer-a-id", "reviewer-b-id", "reviewer-c-id"],
+    "mode": "quorum",
+    "quorum": 2,
+    "wake_on": [{"kind": "signal", "key": "review-42/blocker", "state": "blocked"}],
+    "timeout": "2h"
+  }
+}
+```
+
+Use the native worker IDs from your host. The provider defaults to the host
+selected during setup. Codex task paths such as `/root/reviewer_a` also work
+when accompanied by the parent `session` supplied in its startup context.
+`list_agents` is available for discovery and troubleshooting.
+
+`mode` is `all` by default, or `any`, or `quorum` with a count. Add `targets` for
+other conditions; they count toward the same threshold as `agents`.
+
+| Condition | Matches when |
+| --- | --- |
+| `agent` | A lifecycle hook observes a requested worker state |
+| `signal` | A task-specific event is published |
+| `file` | A path exists, is missing, changes, or contains literal text |
+| `http` | A GET returns the requested status code |
+| `command` | An observational command returns the requested exit code |
+
+Checks run concurrently. Command probes take an argument array and run without
+a shell; use an observational check because it repeats. `interval` controls
+polling, with a default of one second. Use absolute paths when the MCP server's
+working directory may differ from yours.
+
+Publish an explicit checkpoint or blocker through the `signal` MCP tool or CLI:
+
+```sh
+superwait signal review-42/blocker --state blocked --data '{"reason":"missing fixture"}'
+```
+
+## Act on the result
+
+The result includes `status`, `reason`, completed reports in `ready`, remaining
+work in `pending`, and early wake conditions in `triggered`.
+
+Pass the returned `continue_wait` object back as the next request to continue.
+It preserves the deadline, remaining count, and file-change baselines, and
+advances past delivered event signals. Persistent conditions such as an existing
+blocker file must clear or be removed before continuing. After a quorum has
+already been reached, continuation waits for all remaining work.
+
+A stopped response does not prove an assignment succeeded. Read its report;
+another host hook may continue that worker. For a resumed worker, use an `agent`
+target with `after` set to its last returned `cursor`. Unknown workers stay
+pending. `details: true` adds raw observations for troubleshooting.
+
+## Long waits and the CLI
+
+Setup configures a per-server MCP timeout of 24 hours plus 30 seconds for Codex
+and Claude Code. `setup --max-wait 3d` changes that ceiling. Each request still
+has its own timeout or timezone-qualified `deadline`. An absolute deadline
+survives continuation; a timed-out continuation remains expired.
+
+For long Cursor waits, or waits beyond the host's configured MCP timeout, run
+the same engine through the host's background terminal:
+
+```sh
+superwait wait --request wait.json --output result.json
+```
+
+`wait.json` contains the request itself, without the MCP `request` wrapper.
+The CLI prints one final JSON result and atomically saves the optional output.
+It exits 0 for matched/early wake, 124 for timeout, 130 for Ctrl-C, and 2 for an
+invalid request or target ambiguity. Native completion notifications or terminal
+collection retrieve the result; the CLI does not background itself.
+
+Cancellation stops the wait and any probes it launched. It never cancels the
+workers being observed. The machine and process must remain alive.
+
+## Local state
+
+Hooks and waiters share a local SQLite database, defaulting to
+`$XDG_STATE_HOME/superwait/events.sqlite3` or
+`~/.local/state/superwait/events.sqlite3`. Set `SUPERWAIT_DB` or `--db` to use
+another store. Stored observations include worker IDs, report excerpts, and
+available transcript paths. `superwait prune --days 30` removes old observations.
+
+The Codex task-name adapter reads only the metadata header of the exact worker
+transcript supplied by its hook. It does not scan conversation history.
+Network requests occur only for requested HTTP or command checks.
+
+See [contributing](https://github.com/ctxrs/superwait/blob/main/CONTRIBUTING.md)
+for local development. Licensed under [MIT](https://github.com/ctxrs/superwait/blob/main/LICENSE).

superwait-0.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+superwait/SKILL.md,sha256=qIRiVg40JeGvW3FzDSP0yRCtnYldaoTKDxTySYTI918,4666
+superwait/__init__.py,sha256=Eb5iQDfMQ6BltLvKXgYz6itjD0baUJdySt-7acaRSM8,66
+superwait/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+superwait/cli.py,sha256=rrvrHfqiJVosNdRoif-NwwRb9r68zg_Z_q-WVp7uE1E,5760
+superwait/engine.py,sha256=OBUePlOKbTxZbKGL5F2-WM8hKUw1zInV_NsH0qUlIKo,11974
+superwait/hooks.py,sha256=R8MYib_QMuXIfv02nJJmKDWGAa4J6tg5e6jKTwbBMYw,5129
+superwait/models.py,sha256=mxk-oUARwa74POBX0ogitVrUDgEwOGQTqMcYH34yH38,5247
+superwait/server.py,sha256=diwhioIg9iiHcxnGJE7eu_AWY1Y3zJgkb_4KezMagXo,3396
+superwait/setup.py,sha256=YZo6bE2xZpktlXXU0tMYBdGTT_gx7AMS7aVjmJql5IQ,4766
+superwait/store.py,sha256=keR5rqEmzBsN1mkkPdHoUn1HGLQN1KQjyvxdNoYZoUI,4660
+superwait-0.2.0.dist-info/METADATA,sha256=W16JdwV-j0XL1hUPSYKmZRyGy3EJ4U5TaJ2jBoBzmIo,6147
+superwait-0.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+superwait-0.2.0.dist-info/entry_points.txt,sha256=2k_uHiST-TZ6HmFop70vtEcaHqFQwuC5F1oGFMTYdCE,49
+superwait-0.2.0.dist-info/licenses/LICENSE,sha256=Pda-CKlQ8mHwydWfTeX6d9eh6TgYUvymMFlDx0twgXE,1079
+superwait-0.2.0.dist-info/RECORD,,

superwait-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

superwait-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+superwait = superwait.cli:main

superwait-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Superwait contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.