tabc 0.2.0__tar.gz → 0.2.1__tar.gz

{tabc-0.2.0 → tabc-0.2.1}/CHANGELOG.md

@@ -1,6 +1,54 @@
 # Changelog
 
-## 0.2.0 — Unreleased
+## 0.2.1 — 2026-10-15
+
+### Added
+
+- A Codex queue notification route. Under the native Codex managed-daemon
+  app-server, the notifier submits notification metadata to the registered
+  Codex thread with `codex queue` instead of typing into a terminal.
+- `register --codex-queue` requires that route with no terminal fallback. It
+  needs `--kind codex` and `--auto-enter on`.
+- A local receipt database, `codex_queue_receipts.db`, that limits submission
+  to one attempt per thread UUID and notification ID. An uncertain result is
+  recorded as `UNKNOWN` and is not submitted again automatically.
+
+### Changed
+
+- `register` requires `--kind`. The previous default, `generic`, is removed.
+- `register --kind codex --auto-enter on` selects the Codex queue route when
+  the current Codex thread verifies, then a terminal route verified by the same
+  command. With neither, registration is refused and existing routes are kept.
+- When registration selects the Codex queue route, `--take-route` is refused.
+
+### Upgrade notes
+
+- The ledger schema is unchanged. Nodes, signing keys, messages, delivery
+  states, TACs, and routes are kept. No conversion is needed.
+- Stop `tabus.doorbell`, install 0.2.1, restart `tabd`, then start one
+  `tabus.doorbell` from the same installation:
+
+```bash
+python -m pip install --upgrade "tabc==0.2.1"
+# Or, for desktop MCP support:
+python -m pip install --upgrade "tabc[mcp]==0.2.1"
+```
+
+- Confirm the running notifier is 0.2.1 before registering Codex queue routes.
+  Run one notifier. An older notifier records `UNSUPPORTED` for these routes.
+- Scripts that call `register` without `--kind` must add it.
+- To use the Codex queue route, register again from each intended Codex
+  conversation after the notifier is replaced.
+- The notifier creates `codex_queue_receipts.db` in the tabc home directory on
+  its first Codex queue submission. It is separate from message read state.
+- The Codex queue route is a notifier path. It is not part of the MCP adapter,
+  which still does not wake an agent.
+- If a desktop client runs `tabc-mcp`, restart that MCP process from the client
+  after the upgrade so it loads the new installation.
+- Checked with codex-cli 0.162.1 on macOS only.
+- After restart, `tabc --version` and `tabd --version` report 0.2.1.
+
+## 0.2.0 — 2026-09-23
 
 ### Added
 

{tabc-0.2.0 → tabc-0.2.1}/GUIDE.md

@@ -78,6 +78,33 @@ Read the two together:
 A row existing is not the same as a row pointing at you. Check the string, not
 the count.
 
+### Codex queue routes
+
+This applies to 0.2.1 and later, which add the Codex queue adapter. For a
+Codex queue route, `adapter` is `codex-queue` and `target` is a Codex thread
+UUID, not a terminal. Compare it with the conversation you are in:
+
+```bash
+echo "$CODEX_THREAD_ID"
+sqlite3 "file:$HOME/.tabc/tabus.db?mode=ro" \
+  "SELECT adapter, target, auto_enter FROM tab_routes
+    WHERE node_id='<your-node>' AND revoked_at IS NULL"
+```
+
+| Outcome | What it means |
+|---|---|
+| `QUEUED` | Codex accepted the notification input for that thread. It is not `READ`, and the text can appear after the current reply ends |
+| `UNKNOWN` | The submission result is uncertain. The same notification is not submitted again automatically. Check the inbox with `dm`. If every notification ends here, check that the notifier's own `PATH` has a native `codex` and that its Codex environment reaches the same local daemon |
+| `DISABLED` | Automatic submission is off for the route, so nothing was submitted. Register again with `--auto-enter on` |
+| `UNSUPPORTED` | The running notifier predates the queue adapter. Replace it with the matching release, then register again |
+
+If the target is another conversation's UUID, register again from your own
+conversation. Do not copy a UUID into the route.
+
+After replacing the notifier and registering, confirm one real round trip: a
+message arrives in the conversation and a reply comes back. A `QUEUED` record
+does not show that.
+
 ---
 
 ## What a success record does not prove
@@ -189,9 +216,12 @@ ACCEPTED → CLAIMED → INJECTED → READ → PROCESSED
 A state cannot be skipped. `ACCEPTED` will not go straight to `READ`: pass
 through `INJECTED` with `open` or `pull` first, then `ack`.
 
-`--id` takes the **full** UUID. The id printed on a title line is truncated with
-an ellipsis, and copying that form gives `no such delivery`. Use
-`pull --mode full` and take the id from the detail block.
+CLI `open` and `ack` take the full UUID or a unique prefix, such as the
+shortened id that `dm` prints. A prefix that matches more than one message is
+refused as ambiguous. `sent --id` and every MCP `message_id` take the full UUID.
+
+A message that `pull` already claimed does not come back on a second `pull`.
+It stays listed in `dm`; open it from there.
 
 ---
 
@@ -275,11 +305,20 @@ The same visible text can therefore use different byte counts in NFC and NFD.
 - Agents sharing one operating-system account can read each other's key files.
   This is not a security boundary between them.
 - Message bodies are not encrypted at rest.
-- Automatic Enter types into an execution-capable input field. It is off for new
-  routes, and turning it on is a decision about that terminal, not a convenience.
-- Delivery is at-least-once, not exactly-once. A recipient absorbs duplicates.
+- On a terminal route, automatic Enter types into an execution-capable input
+  field. It is off for new routes, and turning it on is a decision about that
+  terminal, not a convenience. A Codex queue route does not type into a
+  terminal; it submits input to the conversation.
+- Message delivery is at-least-once, not exactly-once. A recipient absorbs
+  duplicates. Codex queue notifications are separate: the local receipt
+  database allows one submission attempt per thread UUID and notification ID,
+  and an `UNKNOWN` result is not submitted again automatically.
 - An alarm depends on a route. A node without one receives by `pull`, and no
   amount of sending will make it ring.
+- A Codex queue route submits notification input to a Codex thread. It was
+  checked with codex-cli 0.162.1 on macOS only. The notification text is a
+  command-line argument that local process tools can see. It carries sender
+  names, unread counts and TAC names or UUIDs, never a body.
 
 `SECURITY.md` states the five clauses and how far each is currently kept.
 

{tabc-0.2.0 → tabc-0.2.1}/MCP.md

@@ -30,6 +30,7 @@ normal node for each agent:
 Do not use `--program`: it creates a send-only node that cannot receive messages.
 Registration from iTerm2 or tmux can capture that terminal's notification route.
 Inspect the registration output; a terminal route does not notify the desktop app.
+The command above omits `--auto-enter`, so it does not select a Codex queue route.
 Do not share one node between independent agent conversations: they would share
 the inbox and delivery states.
 
@@ -121,6 +122,11 @@ There are no node deletion, daemon administration, shell execution or automatic
 polling tools. Arrival does not trigger an agent turn. The client must call tools
 on user request or through separately configured scheduling.
 
+The Codex queue adapter, added in 0.2.1, is a separate notification
+path run by the notifier. It is not an MCP tool and does not change this
+section: the MCP adapter still does not wake an agent. See
+[Codex queue notifications](README.md#how-do-i-get-notifications-in-a-codex-thread).
+
 ## Errors and retries
 
 No request is automatically retried. A timeout, connection loss, server error or

{tabc-0.2.0/tabc.egg-info → tabc-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tabc
-Version: 0.2.0
+Version: 0.2.1
 Summary: A shared inbox for AI agents and programs on one machine
 License: MIT License
         
@@ -102,12 +102,30 @@ tabc sent --node alice
 ```
 
 The last line is what matters. It shows the message reached the other side,
-rather than showing that sending did not fail. `--id` takes the full UUID from
-the `pull --mode full` detail block, not the truncated one on a title line.
+rather than showing that sending did not fail. `ack --id` takes the full UUID
+from the `pull --mode full` detail block, or a unique prefix of it.
 
 Terminal notification is a separate process and does not start with the
 install; see the repository's guide before turning it on.
 
+## Updating from 0.2.0
+
+The ledger schema is unchanged. Nodes, signing keys, messages, delivery states,
+TACs, and routes are kept. Stop `tabus.doorbell`, install, restart `tabd`, then
+start one `tabus.doorbell` from the same installation:
+
+```bash
+python -m pip install --upgrade "tabc==0.2.1"
+# Or, when the local desktop MCP adapter is required:
+python -m pip install --upgrade "tabc[mcp]==0.2.1"
+```
+
+`register` now requires `--kind`. Update scripts that omit it. Codex agents
+register again from each conversation after the notifier is replaced. The
+notifier creates `codex_queue_receipts.db` in the tabc home directory on its
+first Codex queue submission. See the
+[changelog](https://github.com/jultabc/tabc/blob/main/CHANGELOG.md).
+
 ## Updating from 0.1.6
 
 The upgrade preserves nodes, messages, delivery states, TAC membership, names,
@@ -125,6 +143,7 @@ python -m pip install --upgrade "tabc[mcp]==0.2.0"
 Existing string TAC IDs are not converted during installation. Follow the
 repository README's 0.2.0 ledger conversion procedure when converting TAC IDs
 to UUIDs. Without conversion, restart `tabd` first, then `tabus.doorbell`.
+Then follow "Updating from 0.2.0".
 
 ## Commands
 
@@ -136,7 +155,7 @@ to UUIDs. Without conversion, restart `tabd` first, then `tabus.doorbell`.
 - `tabc tac search --node alice --query text`: search joined topics without changing read state.
 
 Register each recipient before sending. tac creators must also join their topic.
-In 0.2.0, the server mints a UUID for each new tac. Use that UUID for membership,
+Since 0.2.0, the server mints a UUID for each new tac. Use that UUID for membership,
 sending, reading, renaming and closing; use the unique name for display and search.
 Run `tabc --help` for available commands. The local server is `tabd`; management
 commands are provided separately by `tabm`.
@@ -163,6 +182,15 @@ Installation alone does not enable notifications. Automatic Enter defaults to of
 for new routes. Omitting the setting during registration preserves the same active
 route; `--auto-enter off` disables it explicitly.
 
+`register` requires `--kind`. A Codex agent running under the native Codex
+managed-daemon app-server can receive notifications in its conversation instead
+of a terminal. Replace the notifier with this release first, then run
+`tabc register --node <node> --kind codex --auto-enter on` from that
+conversation. `--codex-queue` requires that route with no terminal fallback.
+`QUEUED` means Codex accepted the notification input, not that it was read.
+This path was checked with codex-cli 0.162.1 on macOS only. See the repository
+README for conditions and limits.
+
 Do not connect notifications to an unreviewed command prompt.
 Automatic Enter does not guarantee a reply.
 

{tabc-0.2.0 → tabc-0.2.1}/PYPI.md

@@ -57,12 +57,30 @@ tabc sent --node alice
 ```
 
 The last line is what matters. It shows the message reached the other side,
-rather than showing that sending did not fail. `--id` takes the full UUID from
-the `pull --mode full` detail block, not the truncated one on a title line.
+rather than showing that sending did not fail. `ack --id` takes the full UUID
+from the `pull --mode full` detail block, or a unique prefix of it.
 
 Terminal notification is a separate process and does not start with the
 install; see the repository's guide before turning it on.
 
+## Updating from 0.2.0
+
+The ledger schema is unchanged. Nodes, signing keys, messages, delivery states,
+TACs, and routes are kept. Stop `tabus.doorbell`, install, restart `tabd`, then
+start one `tabus.doorbell` from the same installation:
+
+```bash
+python -m pip install --upgrade "tabc==0.2.1"
+# Or, when the local desktop MCP adapter is required:
+python -m pip install --upgrade "tabc[mcp]==0.2.1"
+```
+
+`register` now requires `--kind`. Update scripts that omit it. Codex agents
+register again from each conversation after the notifier is replaced. The
+notifier creates `codex_queue_receipts.db` in the tabc home directory on its
+first Codex queue submission. See the
+[changelog](https://github.com/jultabc/tabc/blob/main/CHANGELOG.md).
+
 ## Updating from 0.1.6
 
 The upgrade preserves nodes, messages, delivery states, TAC membership, names,
@@ -80,6 +98,7 @@ python -m pip install --upgrade "tabc[mcp]==0.2.0"
 Existing string TAC IDs are not converted during installation. Follow the
 repository README's 0.2.0 ledger conversion procedure when converting TAC IDs
 to UUIDs. Without conversion, restart `tabd` first, then `tabus.doorbell`.
+Then follow "Updating from 0.2.0".
 
 ## Commands
 
@@ -91,7 +110,7 @@ to UUIDs. Without conversion, restart `tabd` first, then `tabus.doorbell`.
 - `tabc tac search --node alice --query text`: search joined topics without changing read state.
 
 Register each recipient before sending. tac creators must also join their topic.
-In 0.2.0, the server mints a UUID for each new tac. Use that UUID for membership,
+Since 0.2.0, the server mints a UUID for each new tac. Use that UUID for membership,
 sending, reading, renaming and closing; use the unique name for display and search.
 Run `tabc --help` for available commands. The local server is `tabd`; management
 commands are provided separately by `tabm`.
@@ -118,6 +137,15 @@ Installation alone does not enable notifications. Automatic Enter defaults to of
 for new routes. Omitting the setting during registration preserves the same active
 route; `--auto-enter off` disables it explicitly.
 
+`register` requires `--kind`. A Codex agent running under the native Codex
+managed-daemon app-server can receive notifications in its conversation instead
+of a terminal. Replace the notifier with this release first, then run
+`tabc register --node <node> --kind codex --auto-enter on` from that
+conversation. `--codex-queue` requires that route with no terminal fallback.
+`QUEUED` means Codex accepted the notification input, not that it was read.
+This path was checked with codex-cli 0.162.1 on macOS only. See the repository
+README for conditions and limits.
+
 Do not connect notifications to an unreviewed command prompt.
 Automatic Enter does not guarantee a reply.
 

{tabc-0.2.0 → tabc-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tabc"
-version = "0.2.0"
+version = "0.2.1"
 description = "A shared inbox for AI agents and programs on one machine"
 readme = "PYPI.md"
 requires-python = ">=3.9"

{tabc-0.2.0 → tabc-0.2.1/tabc.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tabc
-Version: 0.2.0
+Version: 0.2.1
 Summary: A shared inbox for AI agents and programs on one machine
 License: MIT License
         
@@ -102,12 +102,30 @@ tabc sent --node alice
 ```
 
 The last line is what matters. It shows the message reached the other side,
-rather than showing that sending did not fail. `--id` takes the full UUID from
-the `pull --mode full` detail block, not the truncated one on a title line.
+rather than showing that sending did not fail. `ack --id` takes the full UUID
+from the `pull --mode full` detail block, or a unique prefix of it.
 
 Terminal notification is a separate process and does not start with the
 install; see the repository's guide before turning it on.
 
+## Updating from 0.2.0
+
+The ledger schema is unchanged. Nodes, signing keys, messages, delivery states,
+TACs, and routes are kept. Stop `tabus.doorbell`, install, restart `tabd`, then
+start one `tabus.doorbell` from the same installation:
+
+```bash
+python -m pip install --upgrade "tabc==0.2.1"
+# Or, when the local desktop MCP adapter is required:
+python -m pip install --upgrade "tabc[mcp]==0.2.1"
+```
+
+`register` now requires `--kind`. Update scripts that omit it. Codex agents
+register again from each conversation after the notifier is replaced. The
+notifier creates `codex_queue_receipts.db` in the tabc home directory on its
+first Codex queue submission. See the
+[changelog](https://github.com/jultabc/tabc/blob/main/CHANGELOG.md).
+
 ## Updating from 0.1.6
 
 The upgrade preserves nodes, messages, delivery states, TAC membership, names,
@@ -125,6 +143,7 @@ python -m pip install --upgrade "tabc[mcp]==0.2.0"
 Existing string TAC IDs are not converted during installation. Follow the
 repository README's 0.2.0 ledger conversion procedure when converting TAC IDs
 to UUIDs. Without conversion, restart `tabd` first, then `tabus.doorbell`.
+Then follow "Updating from 0.2.0".
 
 ## Commands
 
@@ -136,7 +155,7 @@ to UUIDs. Without conversion, restart `tabd` first, then `tabus.doorbell`.
 - `tabc tac search --node alice --query text`: search joined topics without changing read state.
 
 Register each recipient before sending. tac creators must also join their topic.
-In 0.2.0, the server mints a UUID for each new tac. Use that UUID for membership,
+Since 0.2.0, the server mints a UUID for each new tac. Use that UUID for membership,
 sending, reading, renaming and closing; use the unique name for display and search.
 Run `tabc --help` for available commands. The local server is `tabd`; management
 commands are provided separately by `tabm`.
@@ -163,6 +182,15 @@ Installation alone does not enable notifications. Automatic Enter defaults to of
 for new routes. Omitting the setting during registration preserves the same active
 route; `--auto-enter off` disables it explicitly.
 
+`register` requires `--kind`. A Codex agent running under the native Codex
+managed-daemon app-server can receive notifications in its conversation instead
+of a terminal. Replace the notifier with this release first, then run
+`tabc register --node <node> --kind codex --auto-enter on` from that
+conversation. `--codex-queue` requires that route with no terminal fallback.
+`QUEUED` means Codex accepted the notification input, not that it was read.
+This path was checked with codex-cli 0.162.1 on macOS only. See the repository
+README for conditions and limits.
+
 Do not connect notifications to an unreviewed command prompt.
 Automatic Enter does not guarantee a reply.
 

{tabc-0.2.0 → tabc-0.2.1}/tabc.egg-info/SOURCES.txt

@@ -15,6 +15,7 @@ tabus/__init__.py
 tabus/admin.py
 tabus/bus.py
 tabus/cli.py
+tabus/codex_queue.py
 tabus/compat_bcn.py
 tabus/compat_busd.py
 tabus/daemon.py

{tabc-0.2.0 → tabc-0.2.1}/tabus/bus.py

@@ -74,7 +74,7 @@ DB_PATH = os.environ.get(
 #    drifted once already — 0.1.0.post1 shipped while this said 0.1.0. Bump
 #    both together; tests/test_version_agreement.py fails the build otherwise.
 #    Do not copy the number into documentation.
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 PROTOCOL_VERSION = "tabus.v1"
 
 # TTLs. Past these, a derived status counts as old.

{tabc-0.2.0 → tabc-0.2.1}/tabus/cli.py

@@ -255,6 +255,12 @@ def fn_register(a):
     take_route = bool(getattr(a, "take_route", False))
     setting = getattr(a, "auto_enter", None)
     auto_enter = setting == "on"
+    if getattr(a, "codex_queue", False) and take_route:
+        print("--codex-queue does not support --take-route")
+        sys.exit(2)
+    if getattr(a, "codex_queue", False) and getattr(a, "program", None) is not None:
+        print("--codex-queue and --program cannot be used together")
+        sys.exit(2)
     if setting is not None:
         payload["auto_enter"] = auto_enter
     if getattr(a, "program", None) is not None and take_route:
@@ -290,6 +296,23 @@ def fn_register(a):
     else:
         captured = _capture_route()
         adapter, target = captured
+        # Codex shared-daemon commands have a thread identity, not a TTY owner.
+        # Automatic queue selection still requires explicit submission consent.
+        force_queue = getattr(a, "codex_queue", False)
+        if force_queue or (a.kind == "codex" and auto_enter):
+            if a.kind != "codex" or setting != "on":
+                print("--codex-queue requires --kind codex --auto-enter on")
+                sys.exit(2)
+            from .codex_queue import capture_current_thread
+            queue_target = capture_current_thread()
+            if queue_target is None and force_queue:
+                print("cannot verify the current Codex managed-daemon thread; registration not sent")
+                sys.exit(2)
+            if queue_target is not None:
+                if take_route:
+                    print("Codex queue delivery does not support --take-route; registration not sent")
+                    sys.exit(2)
+                adapter, target = "codex-queue", queue_target
         # A failed local capture cannot invalidate a previously stored route.
         # Do not send legacy auto-revocation fields, even to an older daemon.
         if not getattr(captured, "rejected", False) and take_route:
@@ -1061,7 +1084,9 @@ COMMANDS = {
         "register a node",
         [
             (("--node",), dict(required=True)),
-            (("--kind",), dict(default="generic")),
+            (("--kind",), dict(required=True)),
+            (("--codex-queue",), dict(action="store_true",
+                help="require Codex queue delivery without terminal fallback; requires kind codex and auto-enter on")),
             (
                 ("--take-route",),
                 dict(

tabc-0.2.1/tabus/codex_queue.py

@@ -0,0 +1,194 @@
+"""Deliver notifications to an explicit Codex thread, without terminal input.
+
+This module does not register routes or mark messages read. The receipt journal
+records delivery attempts, not messages. An uncertain attempt is never retried
+automatically: the queue command has no caller-supplied idempotency key.
+
+Notification text is passed in argv and can be visible to local process tools.
+Callers must pass notification metadata only, never message bodies or secrets.
+Receipt parsing requires exactly one success line on stdout. Additional stdout
+is treated as UNKNOWN even if submission may have succeeded.
+
+Rollout order: deploy and verify the updated doorbell daemon first, then
+register each intended Codex node with the documented options; an older daemon
+returns DELIVER_UNSUPPORTED.
+"""
+
+import os
+import re
+import sqlite3
+import subprocess
+import uuid
+
+
+def deliver_notification(target, notification_id, message, auto_enter):
+    """Doorbell boundary: use only a recognized local native Codex binary."""
+    import pwd
+    import shutil
+    from . import paths
+    from .terminal_frontend import executable_kind
+    executable = shutil.which("codex")
+    if not executable or not notification_id:
+        return "UNKNOWN", -1
+    executable = os.path.realpath(executable)
+    if executable_kind(executable, pwd.getpwuid(os.getuid()).pw_dir) != "codex":
+        return "UNKNOWN", -1
+    try:
+        queue = QueueDelivery(paths.state("codex_queue_receipts.db"), executable)
+        try:
+            state, _ = queue.deliver(target, notification_id, message, auto_enter=auto_enter)
+            return state, 1 if state == "QUEUED" else 0
+        finally:
+            queue.close()
+    except (OSError, sqlite3.Error, ValueError):
+        return "UNKNOWN", -1
+
+
+def capture_current_thread():
+    """Accept per-request thread identity only below a native managed daemon.
+
+    No terminal ownership is inferred. Shared daemon ancestry is used only to
+    identify the execution product. Same-OS-user environment forgery is outside
+    this local routing check, as for existing terminal route capture.
+    """
+    from .terminal_frontend import process_info, native_executable, executable_kind
+    import pwd
+    try:
+        target = current_thread()
+        uid = os.getuid()
+        home = pwd.getpwuid(uid).pw_dir
+        session = os.getsid(0)
+        pid = os.getpid()
+        seen = set()
+        for _ in range(64):
+            if pid <= 1 or pid in seen:
+                return None
+            seen.add(pid)
+            info = process_info(pid)
+            if info is None or info[0] != uid:
+                return None
+            if os.getsid(pid) != session:
+                executable = native_executable(pid)
+                if not executable or executable_kind(executable, home) != "codex":
+                    return None
+                if info[2] != pid or info[4] not in ("??", "?"):
+                    return None
+                args = info[5]
+                if os.path.basename(args[0]) != "codex" or args[1:] != [
+                    "app-server", "--listen", "unix://",
+                    "--analytics-default-enabled", "--managed-daemon",
+                ]:
+                    return None
+                if process_info(pid) != info or native_executable(pid) != executable:
+                    return None
+                return target
+            pid = info[1]
+    except (OSError, ValueError, TypeError, IndexError, subprocess.SubprocessError):
+        return None
+    return None
+
+
+def thread_id(value):
+    """Require a canonical UUID; session names are not routing identities."""
+    if not isinstance(value, str):
+        raise ValueError("Codex thread must be a canonical UUID")
+    try:
+        valid = str(uuid.UUID(value)) == value
+    except ValueError:
+        valid = False
+    if not valid:
+        raise ValueError("Codex thread must be a canonical UUID")
+    return value
+
+
+def current_thread(environ=None):
+    """Read the execution context, not the shared daemon's inherited tab ID.
+
+    This is a candidate identity only, not proof of terminal ownership.
+    Registration must separately validate the Codex execution context.
+    """
+    env = os.environ if environ is None else environ
+    return thread_id(env.get("CODEX_THREAD_ID"))
+
+
+class QueueDelivery:
+    """One attempted submission per (thread UUID, notification identity).
+
+    Use a dedicated local receipt database. The caller supplies an absolute,
+    trusted Codex executable path; no route may supply executable arguments.
+    The caller must reuse the same delivery_id after restart, timeout, or any
+    exception, including a receipt UPDATE/commit failure after queue acceptance.
+    Never allocate a new identity merely to retry an uncertain submission.
+    """
+
+    def __init__(self, receipt_db, executable, run=None):
+        if not os.path.isabs(executable):
+            raise ValueError("Codex executable must be an absolute path")
+        self.executable = executable
+        self.run = run or subprocess.run
+        self.db = sqlite3.connect(receipt_db, timeout=5)
+        self.db.execute("""CREATE TABLE IF NOT EXISTS codex_queue_receipts (
+            thread_id TEXT NOT NULL,
+            delivery_id TEXT NOT NULL,
+            state TEXT NOT NULL CHECK(state IN ('PENDING','QUEUED','UNKNOWN')),
+            submission_id TEXT,
+            PRIMARY KEY(thread_id, delivery_id)
+        )""")
+        self.db.commit()
+
+    def close(self):
+        self.db.close()
+
+    def deliver(self, target, delivery_id, message, *, auto_enter=False):
+        target = thread_id(target)
+        if not isinstance(delivery_id, str) or not delivery_id:
+            raise ValueError("stable delivery_id required")
+        if not isinstance(message, str) or not message or "\x00" in message:
+            raise ValueError("nonempty notification text required")
+        # Queue submits input; it has no equivalent to typing without Enter.
+        if auto_enter is not True:
+            return "DISABLED", None
+
+        self.db.execute("BEGIN IMMEDIATE")
+        try:
+            row = self.db.execute(
+                "SELECT state, submission_id FROM codex_queue_receipts "
+                "WHERE thread_id=? AND delivery_id=?", (target, delivery_id),
+            ).fetchone()
+            if row:
+                self.db.commit()
+                return ("UNKNOWN" if row[0] == "PENDING" else row[0]), row[1]
+            self.db.execute(
+                "INSERT INTO codex_queue_receipts VALUES (?, ?, 'PENDING', NULL)",
+                (target, delivery_id),
+            )
+            self.db.commit()
+        except BaseException:
+            self.db.rollback()
+            raise
+
+        state, submission = "UNKNOWN", None
+        try:
+            result = self.run(
+                [self.executable, "queue", "--remote=unix://",
+                 f"--thread={target}", f"--message={message}"],
+                stdin=subprocess.DEVNULL, capture_output=True, text=True,
+                timeout=15, check=False,
+            )
+            receipt = re.fullmatch(
+                r"Queued message ([0-9a-f-]{36}) for thread " + re.escape(target) + r"\.",
+                result.stdout.strip(),
+            )
+            if result.returncode == 0 and receipt:
+                submission = thread_id(receipt.group(1))
+                state = "QUEUED"
+        except (OSError, subprocess.SubprocessError, ValueError):
+            # Failure can follow acceptance. Do not translate it to safe retry.
+            pass
+        self.db.execute(
+            "UPDATE codex_queue_receipts SET state=?, submission_id=? "
+            "WHERE thread_id=? AND delivery_id=?",
+            (state, submission, target, delivery_id),
+        )
+        self.db.commit()
+        return state, submission

{tabc-0.2.0 → tabc-0.2.1}/tabus/doorbell.py

@@ -307,7 +307,7 @@ def format_doorbell_who(senders):
     return f"{senders[0]['sender']}"
 
 
-def deliver_doorbell(node_id, unread):
+def deliver_doorbell(node_id, unread, notification_id=None):
     """Attempt one delivery. Returns (outcome, adapter, match_count).
 
     🔴 It writes no ledger row; that belongs to the caller.
@@ -364,6 +364,10 @@ def deliver_doorbell(node_id, unread):
         return DELIVER_NOT_MINE, "-", 0
     adapter, target, *settings = route
     auto_enter = bool(settings[0]) if settings else False
+    if adapter == "codex-queue":
+        from .codex_queue import deliver_notification
+        result, matched = deliver_notification(target, notification_id, msg, auto_enter)
+        return result, adapter, matched
     # 🔴 The adapter dispatch stays an if-chain. It was briefly a name-to-function
     #   table and was reverted: the table freezes function references at import
     #   time, which stopped tests from substituting them — three of sixteen failed
@@ -470,7 +474,8 @@ def main():
                             flush=True,
                         )
                     continue
-                result, adapter, matched = deliver_doorbell(rcpt, d["unread"])
+                result, adapter, matched = deliver_doorbell(
+                    rcpt, d["unread"], notification_id=f"{rcpt}:{d['high_id']}")
                 # 🔴 An announcement overriding observation mode lands here too, and
                 #    the recorded mode stays as the mode it actually ran in — that is
                 #    the axis the watermark is measured on. Only the log tag differs.

{tabc-0.2.0 → tabc-0.2.1}/tabus/doorbell_poll.py

@@ -61,7 +61,7 @@ LEDGER_DB = os.environ.get(
 #   The legacy entry covers rings that went out through the old path. Those did
 #   ring, so they suppress. It has its own name so it can be counted; when it
 #   reaches zero, that path can be deleted.
-SUPPRESSING = ("SUCCESS", "SUCCESS_LEGACY", "SHADOW_ONLY", "TEXT_ONLY")
+SUPPRESSING = ("SUCCESS", "SUCCESS_LEGACY", "SHADOW_ONLY", "TEXT_ONLY", "QUEUED")
 UNKNOWN_RETRY_SECONDS = 30
 _unknown_attempts = {}